fix(storage): 객체를 끝까지 돈 계정 삭제 purge는 늘 partition을 지운다

문제: 승인된 LOGOUT·ACCOUNT_DELETION purge는 객체 목록을 읽고, 하나씩
지우고, 마지막에 journal 행을 한 번 센 뒤 0이면 chunk sweep으로 끝나
`chunkSweep: "COMPLETED"`를 돌려준다. 목록과 세기는 각각 한 순간만 본다.
- 다른 탭이 새 객체를 put하는 중이면 purge의 remove가 그 put이 쥔
  origin lease를 기다린다. partition에 객체가 3개 이상이면 그 put은
  목록 뒤에 commit하고 세기 전에 complete까지 끝난다. 목록에도 행 수에도
  없어 sweep이 그 chunk를 건너뛰고, 계정 삭제 뒤에도 파일이 읽힌다
  (리뷰 실험 Y1b 메모리 20/20, Chromium 6/6). 저장소 테스트는 객체
  0~1개로만 돌아서 이 틈을 놓쳤다.
- FILES_READY에서 멈춘 put의 행이 `logicalKey`를 잃으면 세지 못한다.
  staging receipt가 chunk를 sweep에서 지켜 purge마다 COMPLETED인데
  receipt·chunk·manifest가 남는다(Y2).

고른 방법: 마지막 객체까지 돈 purge는 sweep 대신 늘 partition 삭제로
끝낸다(리뷰 2.1절 (d')). exclusive partition lock이 그때 진행 중인
put·delete를 모두 기다린 뒤 디렉터리 전체(staging 포함)와 그 partition
행을 지우므로 두 경우를 함께 막는다. 객체 순회는 `removedObjects`·
`releasedBytes` 보고와 예산 단위 진행을 위해 남긴다. 예산이나 다른 탭의
변경(CONFLICT) 때문에 끝까지 돌지 못한 호출은 지금처럼
`moreObjectsAvailable: true`를 돌려주고, 그때만 journal 행을 세서 끝나지
않은 행이 있으면 바로 partition을 지운다(2026-11-03 05-01 그대로).
purge 성공 report는 이제 `partitionDeleted`와 `moreObjectsAvailable`
중 정확히 하나를 가진다(walk 뒤 abort도 more로 보고).

버린 대안:
- (a) sweep 뒤에 다시 세고 committed 객체를 한 번 더 본다: ①만 막고
  ②가 남는다. 다시 볼 때 정책상 남겨야 할 객체를 가려내려면 목록을 끝까지
  다시 읽어야 한다.
- (b)+(a): 둘 다 막지만 판단 조건이 일곱 개가 된다.
- 세기를 아예 없애기: 예산에 걸린 호출의 crash 행 처리가 다음 호출로
  밀린다. 지금 동작을 바꿀 이유가 없어 남겼다.

위험·한계:
- 모든 승인 purge가 다른 탭의 진행 중 put을 기다린다(지금까지는 끝나지
  않은 행이 있을 때만). 기다림 상한은 `mutationLockWaitTimeoutMs`
  (1103/05-02)이고 abort로 멈출 수 있다.
- 같은 partition에 LOGOUT 때 남겨야 하는 객체가 섞이면 이 방법은 맞지
  않는다. 지금 정책 검사는 OPAQUE_PARTITION이면 LOGOUT·ACCOUNT_DELETION
  모두 purge만 허용해 그런 객체가 생기지 않는다.
- port의 `chunkSweep`은 아무도 채우지 않는다. 읽는 코드가 깨지지 않게
  타입은 남기고 `@deprecated`로 적었다.
- recipe fake의 purge도 늘 `partitionDeleted`다.
- `logicalKey`를 잃은 행 자체는 여전히 남는다(05-03 설계). 그 bytes는
  이제 남지 않는다.
- Firefox·WebKit에서 Y1은 돌리지 않았다. browser spec은 객체 0·3개
  두 경우로 늘렸다.

검증: desktop batch에서 확인
- node scripts/run-vitest.ts run tests/unit/opfs-worker-runtime.test.ts
  tests/unit/opfs-byte-store.test.ts tests/unit/indexeddb-opfs-journal.test.ts
- node scripts/run-vitest.ts run tests/recipes/browser-file-storage-contracts.test.ts
- corepack pnpm test:browser-capabilities tests/browser-capabilities/opfs-runtime.spec.ts --project=chromium

Refs: 1103/05-01
This commit is contained in:
DongHyeonka
2026-11-05 22:08:19 +09:00
parent e85c8361b6
commit 23662fb23a
7 changed files with 442 additions and 206 deletions
@@ -40,23 +40,24 @@ cleanup 결과를 확인하지 못하면 성공 값이 아니라 실패로 답
계속 돌고, 관측은 `OBJECT_RECONCILE` `DEGRADED` / `CORRUPT_DATA`로 남는다
([0929] 05-01). reconcile은 그 row를 지우지 않는다. 그 partition이 승인된
purge로 통째로 지워질 때 함께 지워지는 것은 partition 키(`logicalKey`)를
읽을 수 있는 row뿐이다(§7). 승인된 LOGOUT/ACCOUNT_DELETION purge는 그런
row를 보면 그 partition을 지운다(2026-11-03 05-01).
읽을 수 있는 row뿐이다(§7). 승인된 LOGOUT/ACCOUNT_DELETION purge는 객체를
끝까지 돌면 늘 그 partition을 지운다(1103/05-01 잔여).
- `unattributedCorruptTransactions`: 위 수 가운데 `logicalKey`까지 읽을 수
없는 row 수다. 어느 partition에도 속하지 않아 partition 삭제도 지우지
못한다. 그래서 따로 세고 `DEGRADED` 관측에서 뺀다(2026-11-03 05-03). 예전에는
이런 row 하나가 reconcile마다 `DEGRADED`를 남겨 경보가 늘 켜졌다. 같은 수로
남아 있으면 할 일이 없다. 수가 늘면 키 없는 row를 쓴 writer(다른 release,
외부 도구)를 찾는다. 이 row도 수동으로 지우지 않는다(3번). 그 row의
staging은 partition 디렉터리 안에 있어 그 partition이 지워지면 함께
지워지지만, 이 row는 purge의 partition 삭제 조건에 들지 않는다.
staging은 partition 디렉터리 안에 있어 승인된 purge가 그 partition을
지울 때 함께 지워진다. 예전에는 purge가 이 row를 세지 못해 chunk sweep으로
끝났고, staging receipt가 지킨 chunk·manifest가 `COMPLETED` 뒤에도
남았다(1103/05-01 잔여).
3. journal row를 수동으로 삭제하지 않는다. row가 사라지면 stale staging을 추적할
근거가 사라지고 quota만 누수된다.
4. OPFS root나 journal database를 통째로 삭제하거나 schema를 downgrade하지
않는다. rollback은 새 v2 write admission을 닫고 v1+v2 reader를 유지하는 것으로
수행한다. runtime이 스스로 지우는 것은 승인된 purge가 손상이나 끝나지 않은
transaction 때문에 끝나지 못할 때의 그 partition 디렉터리 하나와 그 partition의
journal row뿐이다(§7).
수행한다. runtime이 스스로 통째로 지우는 것은 승인된 LOGOUT/ACCOUNT_DELETION
purge의 그 partition 디렉터리 하나와 그 partition의 journal row뿐이다(§7).
## 1. 공통 원칙
@@ -450,27 +451,33 @@ VD-15 목표 runtime을 먼저 구현한다.
- `COMMITTED` + file missing/corrupt: reconstructable만 server rehydrate;
user-created private는 read-only/export/recovery
- stale staging/orphan chunk는 grace period와 bounded mark/sweep 후 제거
- `LOGOUT`/`ACCOUNT_DELETION` purge는 객체를 모두 지운 뒤 그 partition의 journal
row를 센다. 하나라도 있으면(다른 tab에서 진행 중인 put·delete, crash가 남긴
`PREPARING`·`FILES_READY`, 키는 읽히는 손상 row) sweep 대신 아래 partition
삭제로 간다(2026-11-03 05-01). 예전에는 이 row를 보지 않고 `COMPLETED`를
돌려줬다. 그래서 진행 중 put의 객체가 purge 뒤에도 읽혔고, `FILES_READY` row는
다음 reconcile이 commit해 객체로 되살렸다. row가 없으면 그 partition의 chunk를
grace 없이 sweep한다(05-04, `opfs-byte-store-adapter.ts` `enforcePolicies`).
staging receipt가 참조하는 chunk는 이때도 지우지 않는다. 이 두 reason에서는
report의 `chunkSweep`이 `COMPLETED`이거나 `partitionDeleted`가 있을 때 그
partition의 bytes가 지워진 것이다. `DEADLINE_REACHED`면 같은
purge를 다시 호출하고, `STAGING_STATE_UNREADABLE`이면 읽을 수 없는 staging부터
처리한다. 다른 탭이 바꾸고 있던 객체를 지우지 못하면 report는
`moreObjectsAvailable: true`이고 `chunkSweep`이 없다. 이때도 같은 purge를 다시
호출한다([0929] 05-02)
- 손상이나 끝나지 않은 transaction 때문에 끝나지 못하는 `LOGOUT`/
`ACCOUNT_DELETION` purge는 partition을 통째로 지운다([0929] 05-01,
2026-11-03 05-01, `opfs-byte-store-adapter.ts` `enforcePolicies`).
- `LOGOUT`/`ACCOUNT_DELETION` purge는 객체를 하나씩 지운 뒤, 마지막 객체까지
돌았으면 늘 아래 partition 삭제로 끝낸다(1103/05-01 잔여,
`opfs-byte-store-adapter.ts` `enforcePolicies`). chunk sweep으로 끝내지 않는다.
- 예전 동작: 객체를 다 돈 뒤 journal row를 한 번 세고, 0이면 chunk를 grace 없이
sweep해 `chunkSweep: "COMPLETED"`를 돌려줬다(05-04, 2026-11-03 05-01). 목록과
세기는 각각 한 순간만 본다. 그래서 두 경우에 bytes가 남은 채 `COMPLETED`였다.
① 다른 tab이 새 객체를 put하는 중이고 partition에 객체가 3개 이상이면, 그 put이
목록 뒤에 commit하고 세기 전에 끝났다. 목록에도 row 수에도 없어 sweep이 그
chunk를 건너뛰었고, 그 파일이 계정 삭제 뒤에도 읽혔다(메모리 20/20, Chromium
6/6). ② 멈춘 put의 journal row가 `logicalKey`를 잃으면 세지 못했고, 그
staging receipt·chunk·manifest가 purge마다 남았다.
- 이제 결과: 그 partition의 bytes가 지워진 것은 report에 `partitionDeleted`가
있을 때다. `chunkSweep`은 더 이상 채우지 않는다(port 타입에는 호환을 위해
남겼다).
- 예산(`budgetMs`·`maxObjects`)이나 다른 tab의 변경 때문에 객체를 끝까지 돌지
못하면 report는 `moreObjectsAvailable: true`이고 `partitionDeleted`가 없다.
같은 purge를 다시 호출한다([0929] 05-02). 다만 이때 그 partition의 journal
row(다른 tab에서 진행 중인 put·delete, crash가 남긴 `PREPARING`·`FILES_READY`,
키는 읽히는 손상 row)가 하나라도 있으면 그 호출이 바로 partition을 지운다
(2026-11-03 05-01).
- 승인된 `LOGOUT`/`ACCOUNT_DELETION` purge의 partition 삭제([0929] 05-01,
2026-11-03 05-01, 1103/05-01 잔여, `opfs-byte-store-adapter.ts`
`enforcePolicies`).
- 조건: 정책이 그 reason을 허용하고, authority가 이번 purge의 proof를 내주고
consumer가 소비했을 때(IndexedDB의 database 전체 삭제와 같은 승인). 그리고
다음 중 하나를 만났을 때: 목록에서 건너뛴 손상 object row, 손상 row 때문에
`CORRUPT_DATA`로 끝난 remove나 chunk sweep, `STAGING_STATE_UNREADABLE`, 그
다음 중 하나일 때: 마지막 객체까지 돌았다, 목록에서 건너뛴 손상 object row,
손상 row 때문에 `CORRUPT_DATA`로 끝난 remove, 끝까지 돌지 못한 호출에서 그
partition 키를 가진 journal row(`countPartitionTransactions`가 1 이상).
TTL·SESSION_END·UNTIL_SYNCED·PRESSURE는 손상 row를 건너뛰고 세기만 한다.
- 범위: worker가 origin mutation lease를 쥔 채
@@ -482,8 +489,9 @@ VD-15 목표 runtime을 먼저 구현한다.
row는 남긴다. 다른 partition은 건드리지 않는다.
- 결과: `partitionDeleted: true`, `moreObjectsAvailable: false`, 건너뛴 row 수
`corruptObjects`. 이 report면 그 partition의 bytes는 모두 지워진 것이다.
`chunkSweep`은 없다. 디렉터리는 지웠는데 journal 정리가 실패하면 실패를
반환한다. 같은 purge를 다시 호출하면 이어서 끝난다.
`removedObjects`·`releasedBytes`는 삭제 전에 하나씩 지운 객체만 센다.
디렉터리는 지웠는데 journal 정리가 실패하면 실패를 반환한다. 같은 purge를
다시 호출하면 이어서 끝난다.
- 다른 tab의 put·delete와의 순서: 모든 put·delete는 journal `begin`부터 끝날
때까지 partition lock(Web Lock
`<mutationLockName>:partition:<authorityToken>:<namespaceToken>:<partitionToken>`)을
@@ -504,9 +512,10 @@ VD-15 목표 runtime을 먼저 구현한다.
멈추고 `ABORTED`를 반환한다. 삭제 뒤에 줄 선 put·delete도 자기 `signal`로
기다림을 멈춘다. 어느 쪽이든 partition lock 기다림은
`mutationLockWaitTimeoutMs`(기본 10분)에서 `BLOCKED`(retryable)로 끝난다
(2026-11-03 05-02). purge가 journal row를 센 뒤에 시작한 put, 삭제가
lock을 요청한 뒤 온 put의 데이터는 남는다(point-in-time). purge 전에 그
partition의 쓰기를 멈추는 것이 composition의 몫이다.
(2026-11-03 05-02). 삭제가 lock을 요청한 뒤 온 put의 데이터는 남는다
(point-in-time). 그 전에 시작한 put은 삭제가 기다렸다가 함께 지운다.
모든 승인 purge가 이제 이 lock을 기다리므로, 다른 tab에서 오래 걸리는 put이
있으면 purge도 그만큼 늦게 끝난다.
- lock/worker 문제면 OPFS write off → approved capped fallback 또는 online-only
- scope binding mismatch면 affected scope를 read-only로 격리하고 registry/
composition을 forward fix; 다른 token path로 bytes를 이동하거나 추측 복구 금지
@@ -1652,8 +1652,9 @@ type MemoryDurableObjectStoreOptions = Readonly<{
* a journal row, and a LOGOUT or ACCOUNT_DELETION the policy allows leaves the
* partition empty. `reconcile` rolls a row that stopped while PREPARING back
* and commits one that stopped after FILES_READY, like the runtime's
* roll-forward; such a purge also drops every stopped row and reports
* `partitionDeleted` (2026-11-03 05-01, 05-04).
* roll-forward; such a purge also drops every stopped row. Every purge
* reports `partitionDeleted`, never a chunk sweep (2026-11-03 05-01, 05-04,
* 1103/05-01 rest).
*
* It does not model the worker, Web Locks, the composition authority, chunk
* dedup, orphan GC or the other maintenance reasons (`UNSUPPORTED`). Its
@@ -1926,8 +1927,9 @@ export class MemoryDurableObjectStore
const removedObjects = this.#objects.size;
this.#objects.clear();
// 2026-11-03 05-01. A stopped put goes with the partition, as the
// runtime's partition delete takes its row and its files.
const partitionDeleted = this.#pending.size > 0;
// runtime's partition delete takes its row and its files. 1103/05-01
// rest: the runtime ends every purge that walked all objects in that
// delete, so this one always reports it.
this.#pending.clear();
return dataSuccess(
Object.freeze({
@@ -1936,9 +1938,7 @@ export class MemoryDurableObjectStore
releasedBytes,
moreObjectsAvailable: false,
deadlineReached: false,
...(partitionDeleted
? { partitionDeleted: true as const }
: { chunkSweep: "COMPLETED" as const }),
partitionDeleted: true as const,
}),
);
}
@@ -805,8 +805,7 @@ export function createOpfsByteStoreAdapter(
const sweeping =
request.reason === "LOGOUT" || request.reason === "ACCOUNT_DELETION";
// [0929] 05-01. Rows the journal could not read and skipped, and damage
// met past the listing: a remove or the sweep failing on an unreadable
// row, or staging the sweep cannot read.
// met past the listing: a remove failing on an unreadable row.
let corruptObjects = 0;
let damaged = false;
@@ -888,14 +887,25 @@ export function createOpfsByteStoreAdapter(
}
afterObjectId = page.value.nextObjectId;
}
// 2026-11-03 05-01. A put or delete of this partition that has not
// finished holds bytes the object walk never sees and the sweep skips:
// one running in another tab, or a row a crash left (PREPARING, or
// FILES_READY, which the next reconcile would commit) or nothing can
// read. Any such row sends the purge to the partition delete below,
// which first waits for every live one.
// 1103/05-01 (rest). A walk that reached the last object no longer ends
// in a chunk sweep. The walk and a journal count each see one moment:
// another tab's put of a new object that committed after the listing
// and settled before the count was in neither, and a stopped put whose
// row lost its partition key is never counted. The sweep then skipped
// their chunks and staging and still reported COMPLETED, so the file
// stayed readable after the account deletion. Such a walk now always
// ends in the partition delete below, which waits for every put and
// delete of the partition and takes the whole directory, staging
// included, so nothing that began before it is left.
const walkFinished = !moreObjectsAvailable && !deadlineReached;
// 2026-11-03 05-01. A walk the budget or another tab's change stopped
// leaves the rest for the next call, unless a put or delete of this
// partition has not finished: one running in another tab, or a row a
// crash left (PREPARING, or FILES_READY, which the next reconcile would
// commit) or nothing can read. Any such row sends this call to the
// partition delete too.
let unfinished = 0;
if (sweeping && !request.signal?.aborted) {
if (sweeping && !walkFinished && !request.signal?.aborted) {
const counted = await dependencies.journal.countPartitionTransactions(
dependencies.scope,
);
@@ -904,40 +914,6 @@ export function createOpfsByteStoreAdapter(
}
unfinished = counted.value;
}
// 05-04. Removing an object leaves its chunks, and GC only takes a
// chunk 24 h after it was written, so a purged user's bytes stayed on
// the device. Once every object is gone the partition's chunks are swept
// without that grace. The sweep still skips any chunk the journal or a
// staged put references.
let chunkSweep: OpfsPolicyMaintenanceReport["chunkSweep"];
if (
sweeping &&
!unfinished &&
!corruptObjects &&
!damaged &&
!moreObjectsAvailable &&
!deadlineReached &&
!request.signal?.aborted
) {
const swept = await reconcileOrphanChunks(
deadline,
request.signal,
now(),
);
if (!swept.ok) {
if (swept.error.code !== "CORRUPT_DATA") {
return rebaseFailure(swept.error, "OBJECT_RECONCILE");
}
damaged = true;
} else {
chunkSweep = swept.value.status;
damaged = chunkSweep === "STAGING_STATE_UNREADABLE";
if (chunkSweep === "DEADLINE_REACHED") {
deadlineReached = true;
moreObjectsAvailable = true;
}
}
}
// [0929] 05-01. A row nothing can read never lets this purge finish, so
// the user's bytes would stay on the device for good. The authority
// approved this exact LOGOUT or ACCOUNT_DELETION (the same approval the
@@ -949,7 +925,7 @@ export function createOpfsByteStoreAdapter(
// wait for every put and delete of the partition in any tab.
const partitionDeleted =
sweeping &&
(corruptObjects > 0 || damaged || unfinished > 0) &&
(walkFinished || corruptObjects > 0 || damaged || unfinished > 0) &&
!request.signal?.aborted;
if (partitionDeleted) {
const removed = await withPartitionLock(
@@ -970,8 +946,12 @@ export function createOpfsByteStoreAdapter(
if (!removed.ok) {
return rebaseFailure(removed.error, "OBJECT_RECONCILE");
}
chunkSweep = undefined;
moreObjectsAvailable = false;
} else if (sweeping) {
// Only an abort between the walk and the delete gets here with the
// walk finished. Either way the partition still holds bytes, so a
// purge reports exactly one of `partitionDeleted` and more work.
moreObjectsAvailable = true;
}
const report: OpfsPolicyMaintenanceReport = Object.freeze({
inspectedObjects,
@@ -979,7 +959,6 @@ export function createOpfsByteStoreAdapter(
releasedBytes,
moreObjectsAvailable,
deadlineReached,
...(chunkSweep ? { chunkSweep } : {}),
...(corruptObjects ? { corruptObjects } : {}),
...(partitionDeleted ? { partitionDeleted } : {}),
});
@@ -1365,7 +1344,6 @@ export function createOpfsByteStoreAdapter(
async function reconcileOrphanChunks(
deadline: number,
signal: AbortSignal | undefined,
olderThanEpochMs = Math.max(0, now() - policy.orphanGracePeriodMs),
): Promise<
BrowserDataResult<
Readonly<{
@@ -1378,6 +1356,7 @@ export function createOpfsByteStoreAdapter(
}>
>
> {
const olderThanEpochMs = Math.max(0, now() - policy.orphanGracePeriodMs);
let inspected = 0;
let deleted = 0;
// R-5.1. Candidates include committed chunks, so a page can be all
@@ -152,12 +152,15 @@ export type OpfsPolicyMaintenanceReport = Readonly<{
moreObjectsAvailable: boolean;
deadlineReached: boolean;
/**
* 05-04. LOGOUT and ACCOUNT_DELETION only, once every object is removed and
* no put or delete of the partition is unfinished: how the sweep of the
* partition's now unreferenced chunks ended. For those two reasons the
* partition's bytes are gone exactly when this is `COMPLETED` or
* `partitionDeleted` is set; a put that begins after the purge reached its
* journal check is kept (2026-11-03 05-01).
* 05-04. How a LOGOUT or ACCOUNT_DELETION chunk sweep ended.
*
* @deprecated The reference runtime and the recipe fake no longer set it
* (1103/05-01 rest): a sweep after the object walk missed a new object
* another tab's put settled during the walk, and the staging of a stopped
* put whose journal row lost its partition key, and still said
* `COMPLETED`. Such a purge now ends in the partition delete, so
* `partitionDeleted` is the one completion signal. Kept so code that reads
* it still compiles; it is always absent.
*/
chunkSweep?: "COMPLETED" | "DEADLINE_REACHED" | "STAGING_STATE_UNREADABLE";
/**
@@ -166,12 +169,16 @@ export type OpfsPolicyMaintenanceReport = Readonly<{
*/
corruptObjects?: number;
/**
* [0929] 05-01. An approved LOGOUT or ACCOUNT_DELETION that damage kept
* from finishing, or that found an unfinished put or delete of the
* partition (2026-11-03 05-01), removed the whole partition directory and
* the partition's journal rows instead, after every put and delete of the
* partition then running in any tab had returned. Every byte of the
* partition is gone.
* [0929] 05-01. An approved LOGOUT or ACCOUNT_DELETION removed the whole
* partition directory and the partition's journal rows, after every put
* and delete of the partition then running in any tab had returned. Every
* byte of the partition is gone; a put that begins after that delete is
* kept. A purge that walked every object always ends this way (1103/05-01
* rest). One the budget or another tab's change stopped part-way ends this
* way only when damage or an unfinished put or delete of the partition
* (2026-11-03 05-01) was met; otherwise it reports `moreObjectsAvailable`
* and the caller runs it again. For these two reasons the partition's bytes
* are gone exactly when this is set.
*/
partitionDeleted?: true;
}>;
+118 -86
View File
@@ -329,97 +329,129 @@ async function removeOpfsAuthority(
// 2026-11-03 05-01 X1. The purge used to report a completed sweep while the
// other tab's put landed, and the object stayed readable after the account
// deletion. It now waits for that put and takes it with the partition.
test("05-01 an approved purge in another tab waits for a live put and takes it with the partition", async ({
page,
}) => {
const secondPage = await page.context().newPage();
const suffix = crypto.randomUUID().replaceAll("-", "");
const scope: OpfsTabScope = {
namespace: "durable-objects",
authorityToken: `authority_${suffix}`,
namespaceToken: `namespace_${suffix}`,
partitionToken: `partition_${suffix}`,
};
type Tab = import("../../src/adapters/storage/opfs/browser-opfs-runtime.ts").BrowserOpfsRuntime;
try {
await Promise.all([page.goto("/"), secondPage.goto("/")]);
if (!(await installOpfsTab(page, scope))) return;
expect(await installOpfsTab(secondPage, scope, true)).toBe(true);
// 1103/05-01 rest. That fix still reported a completed sweep, with the new
// object readable, once the purged partition held three or more objects:
// each remove waits for the origin lease the put holds, so the put settled
// before the purge counted the journal. A purge that walked every object now
// always ends in the partition delete.
for (const committedObjects of [0, 3]) {
test(`05-01 an approved purge in another tab waits for a live put and takes it with the partition (${committedObjects} committed objects)`, async ({
page,
}) => {
const secondPage = await page.context().newPage();
const suffix = crypto.randomUUID().replaceAll("-", "");
const scope: OpfsTabScope = {
namespace: "durable-objects",
authorityToken: `authority_${suffix}`,
namespaceToken: `namespace_${suffix}`,
partitionToken: `partition_${suffix}`,
};
type Tab = import("../../src/adapters/storage/opfs/browser-opfs-runtime.ts").BrowserOpfsRuntime;
try {
await Promise.all([page.goto("/"), secondPage.goto("/")]);
if (!(await installOpfsTab(page, scope))) return;
expect(await installOpfsTab(secondPage, scope, true)).toBe(true);
await page.evaluate(async () => {
const state = globalThis as unknown as {
__opfsTab: Tab;
__release?: () => void;
__put?: Promise<unknown>;
};
let streaming!: () => void;
const started = new Promise<void>((resolve) => {
streaming = resolve;
});
const gate = new Promise<void>((resolve) => {
state.__release = resolve;
});
state.__put = state.__opfsTab.objects.put({
objectId: "object_tab_12345678",
expectedGeneration: null,
mediaType: "application/octet-stream",
source: {
byteLength: 4,
async *stream() {
streaming();
await gate;
yield { ok: true as const, value: new Uint8Array([2, 7, 1, 8]) };
const seeded = await secondPage.evaluate(async (count) => {
const runtime = (globalThis as unknown as { __opfsTab: Tab }).__opfsTab;
const codes: string[] = [];
for (let index = 0; index < count; index += 1) {
const put = await runtime.objects.put({
objectId: `object_secret_${String(index).padStart(4, "0")}`,
expectedGeneration: null,
mediaType: "application/octet-stream",
source: {
byteLength: 1,
async *stream() {
yield { ok: true as const, value: new Uint8Array([index + 1]) };
},
},
});
codes.push(put.ok ? "OK" : put.error.code);
}
return codes;
}, committedObjects);
expect(seeded).toEqual(Array.from({ length: committedObjects }, () => "OK"));
await page.evaluate(async () => {
const state = globalThis as unknown as {
__opfsTab: Tab;
__release?: () => void;
__put?: Promise<unknown>;
};
let streaming!: () => void;
const started = new Promise<void>((resolve) => {
streaming = resolve;
});
const gate = new Promise<void>((resolve) => {
state.__release = resolve;
});
state.__put = state.__opfsTab.objects.put({
objectId: "object_tab_12345678",
expectedGeneration: null,
mediaType: "application/octet-stream",
source: {
byteLength: 4,
async *stream() {
streaming();
await gate;
yield { ok: true as const, value: new Uint8Array([2, 7, 1, 8]) };
},
},
});
await started;
});
await secondPage.evaluate(() => {
const state = globalThis as unknown as {
__opfsTab: Tab;
__purge?: Promise<unknown>;
};
state.__purge = state.__opfsTab.maintenance.enforcePolicies({
reason: "ACCOUNT_DELETION",
});
});
await page.waitForTimeout(250);
const put = await page.evaluate(async () => {
const state = globalThis as unknown as {
__release: () => void;
__put: Promise<unknown>;
};
state.__release();
return await state.__put;
});
const report = await secondPage.evaluate(
async () =>
await (globalThis as unknown as { __purge: Promise<unknown> }).__purge,
);
const opened = await secondPage.evaluate(async () => {
const runtime = (globalThis as unknown as { __opfsTab: Tab }).__opfsTab;
const result = await runtime.objects.open({
objectId: "object_tab_12345678",
});
return result.ok ? "OPENED" : result.error.code;
});
expect(put).toMatchObject({ ok: true, value: { generation: 1 } });
expect(report).toMatchObject({
ok: true,
value: {
removedObjects: committedObjects,
moreObjectsAvailable: false,
partitionDeleted: true,
},
});
await started;
});
await secondPage.evaluate(() => {
const state = globalThis as unknown as {
__opfsTab: Tab;
__purge?: Promise<unknown>;
};
state.__purge = state.__opfsTab.maintenance.enforcePolicies({
reason: "ACCOUNT_DELETION",
});
});
await page.waitForTimeout(250);
const put = await page.evaluate(async () => {
const state = globalThis as unknown as {
__release: () => void;
__put: Promise<unknown>;
};
state.__release();
return await state.__put;
});
const report = await secondPage.evaluate(
async () =>
await (globalThis as unknown as { __purge: Promise<unknown> }).__purge,
);
const opened = await secondPage.evaluate(async () => {
const runtime = (globalThis as unknown as { __opfsTab: Tab }).__opfsTab;
const result = await runtime.objects.open({
objectId: "object_tab_12345678",
});
return result.ok ? "OPENED" : result.error.code;
});
expect(put).toMatchObject({ ok: true, value: { generation: 1 } });
expect(report).toMatchObject({
ok: true,
value: { moreObjectsAvailable: false, partitionDeleted: true },
});
expect(opened).toBe("NOT_FOUND");
} finally {
for (const tab of [page, secondPage]) {
await tab.evaluate(() =>
(globalThis as unknown as { __opfsTab?: Tab }).__opfsTab?.close(),
);
expect(opened).toBe("NOT_FOUND");
} finally {
for (const tab of [page, secondPage]) {
await tab.evaluate(() =>
(globalThis as unknown as { __opfsTab?: Tab }).__opfsTab?.close(),
);
}
expect(await removeOpfsAuthority(page, scope)).toBe("DELETED");
await secondPage.close();
}
expect(await removeOpfsAuthority(page, scope)).toBe("DELETED");
await secondPage.close();
}
});
});
}
test("05-01 a reconcile in another tab skips a live put and the put stays readable", async ({
page,
@@ -672,12 +672,14 @@ describe("production browser file and storage recipe contracts", () => {
expectedGeneration: asObjectGeneration(2),
}),
).toMatchObject({ ok: false, error: { code: "CONFLICT" } });
expect(
await store.enforcePolicies({ reason: "ACCOUNT_DELETION" }),
).toMatchObject({
// 1103/05-01 rest. Like the runtime, a purge that walked every object
// ends in the partition delete, never in a chunk sweep.
const purged = await store.enforcePolicies({ reason: "ACCOUNT_DELETION" });
expect(purged).toMatchObject({
ok: true,
value: { removedObjects: 1, chunkSweep: "COMPLETED" },
value: { removedObjects: 1, partitionDeleted: true },
});
expect(purged.ok && purged.value.chunkSweep).toBeUndefined();
expect(await store.open({ objectId })).toMatchObject({
ok: false,
error: { code: "NOT_FOUND" },
+226 -19
View File
@@ -2254,15 +2254,17 @@ describe("05-04 a LOGOUT or ACCOUNT_DELETION purge leaves no partition bytes beh
expect(await putBytes(purged, "object_secret_2", [4, 5])).toMatchObject({ ok: true });
expect(await putBytes(kept, "object_kept_0001", [7, 7])).toMatchObject({ ok: true });
expect(await purged.maintenance.enforcePolicies({ reason })).toMatchObject({
const report = await purged.maintenance.enforcePolicies({ reason });
expect(report).toMatchObject({
ok: true,
value: {
removedObjects: 2,
moreObjectsAvailable: false,
deadlineReached: false,
chunkSweep: "COMPLETED",
partitionDeleted: true,
},
});
expect(report.ok && report.value.chunkSweep).toBeUndefined();
expect(filesUnder(root, scopeA)).toEqual([]);
expect(await openedBytes(kept, "object_kept_0001")).toEqual({
generation: 1,
@@ -2273,7 +2275,7 @@ describe("05-04 a LOGOUT or ACCOUNT_DELETION purge leaves no partition bytes beh
// 1101/13.6. A journal may hand back a page shorter than the limit (the port
// does not promise full pages). A purge that walked two such pages and
// removed everything is finished: it must say so and sweep the chunks.
// removed everything is finished: it must say so and take the partition.
it("finishes a purge that walked more than one journal page", async () => {
const { root, idb, tab } = sharedRootTabs();
const journal = createIndexedDbOpfsJournal({
@@ -2300,7 +2302,7 @@ describe("05-04 a LOGOUT or ACCOUNT_DELETION purge leaves no partition bytes beh
inspectedObjects: 2,
removedObjects: 2,
moreObjectsAvailable: false,
chunkSweep: "COMPLETED",
partitionDeleted: true,
},
});
expect(filesUnder(root, scopeA)).toEqual([]);
@@ -2310,25 +2312,89 @@ describe("05-04 a LOGOUT or ACCOUNT_DELETION purge leaves no partition bytes beh
// it, report a completed sweep and leave that object readable. A put or
// delete of the partition that has not finished now sends the purge to the
// partition delete, which waits for it and then takes it.
it("waits for a put that began before the purge and takes it with the partition", async () => {
const { root, tab } = sharedRootTabs();
const purger = tab("p", authority);
// 1103/05-01 rest (Y1b). That fix counted the journal once, after the walk.
// Each remove waits for the origin lease the other tab's put holds, so with
// three or more objects the put committed and settled before the count:
// neither the listing nor the count saw it, the sweep skipped its chunks
// and said COMPLETED, and the file stayed readable. One object hid this.
it.each([1, 3, 8])(
"waits for a put that began before the purge and takes it with the partition (%i committed objects)",
async (count) => {
const { root, tab } = sharedRootTabs();
const purger = tab("p", authority);
const writer = tab("w", authority);
for (let index = 1; index <= count; index += 1) {
expect(
await putBytes(purger, `object_secret_${index}`, [index]),
).toMatchObject({ ok: true });
}
const stalled = stalledSource();
const put = writer.objects.put({
objectId: "object_late_0001",
expectedGeneration: null,
mediaType: "application/octet-stream",
source: stalled.source,
});
await stalled.streaming;
const purge = purger.maintenance.enforcePolicies({ reason: "LOGOUT" });
await new Promise((resolve) => setTimeout(resolve, 20));
stalled.release();
expect(await put).toMatchObject({ ok: true });
const report = await purge;
expect(report).toMatchObject({
ok: true,
value: {
removedObjects: count,
moreObjectsAvailable: false,
partitionDeleted: true,
},
});
expect(report.ok && report.value.chunkSweep).toBeUndefined();
expect(filesUnder(root, scopeA)).toEqual([]);
expect(await openedBytes(writer, "object_late_0001")).toBe("NOT_FOUND");
},
);
// 1103/05-01 rest (Y1a). The same gap without timing: another tab's put of
// a new object commits and settles right after the purge lists the
// partition, so the listing misses it and no journal row is left to count.
it("takes a new object another tab's put settles between the purge's listing and its end", async () => {
const { root, idb, tab } = sharedRootTabs();
const journal = createIndexedDbOpfsJournal({
authorityToken: scopeA.authorityToken,
factory: idb.factory,
keyRange: idb.keyRange,
});
const stalled = stalledSource();
let late: ReturnType<typeof writer.objects.put> | undefined;
const purger = tab("p", {
...authority,
journal: {
...journal,
async listCommittedObjects(request) {
const page = await journal.listCommittedObjects(request);
stalled.release();
await late;
return page;
},
},
});
const writer = tab("w", authority);
expect(await putBytes(purger, "object_secret_1", [1, 2, 3])).toMatchObject({ ok: true });
const stalled = stalledSource();
const put = writer.objects.put({
late = writer.objects.put({
objectId: "object_late_0001",
expectedGeneration: null,
mediaType: "application/octet-stream",
source: stalled.source,
});
await stalled.streaming;
const purge = purger.maintenance.enforcePolicies({ reason: "LOGOUT" });
await new Promise((resolve) => setTimeout(resolve, 20));
stalled.release();
expect(await put).toMatchObject({ ok: true });
const report = await purge;
const report = await purger.maintenance.enforcePolicies({
reason: "ACCOUNT_DELETION",
});
expect(await late).toMatchObject({ ok: true, value: { generation: 1 } });
expect(report).toMatchObject({
ok: true,
value: {
@@ -2339,7 +2405,72 @@ describe("05-04 a LOGOUT or ACCOUNT_DELETION purge leaves no partition bytes beh
});
expect(report.ok && report.value.chunkSweep).toBeUndefined();
expect(filesUnder(root, scopeA)).toEqual([]);
expect(await openedBytes(writer, "object_late_0001")).toBe("NOT_FOUND");
expect(await openedBytes(purger, "object_late_0001")).toBe("NOT_FOUND");
});
// 2026-11-03 05-01. A walk the budget stops part-way is no finished purge.
// It leaves the rest for the next call, unless a put or delete of the
// partition is unfinished: then that call takes the partition at once.
it("continues a purge the object budget stopped, and takes the partition when a put is unfinished", async () => {
const { root, idb, tab } = sharedRootTabs();
const purger = tab("p", authority);
for (const objectId of ["object_secret_1", "object_secret_2", "object_secret_3"]) {
expect(await putBytes(purger, objectId, [1])).toMatchObject({ ok: true });
}
const first = await purger.maintenance.enforcePolicies({
reason: "ACCOUNT_DELETION",
maxObjects: 1,
});
expect(first).toEqual({
ok: true,
value: {
inspectedObjects: 1,
removedObjects: 1,
releasedBytes: 1,
moreObjectsAvailable: true,
deadlineReached: false,
},
});
expect(filesUnder(root, scopeA)).not.toEqual([]);
// A put that died before it wrote anything leaves a PREPARING row.
const journal = createIndexedDbOpfsJournal({
authorityToken: scopeA.authorityToken,
factory: idb.factory,
keyRange: idb.keyRange,
});
expect(
await journal.begin({
transactionId: "transaction_left_0001",
mutation: "PUT",
scope: scopeA,
objectId: "object_left_0001",
expectedGeneration: null,
targetGeneration: 1,
targetByteLength: 1,
targetStoragePolicy: storagePolicy,
startedAtEpochMs: 2,
}),
).toMatchObject({ ok: true });
expect(
await purger.maintenance.enforcePolicies({
reason: "ACCOUNT_DELETION",
maxObjects: 1,
}),
).toMatchObject({
ok: true,
value: {
inspectedObjects: 1,
removedObjects: 1,
moreObjectsAvailable: false,
partitionDeleted: true,
},
});
expect(filesUnder(root, scopeA)).toEqual([]);
expect(idb.readRaw("opfs-journal", "transaction_left_0001")).toBeUndefined();
expect(await openedBytes(purger, "object_secret_3")).toBe("NOT_FOUND");
});
// 2026-11-03 05-01 X2, X2b, X3. A put that stopped before it finished leaves
@@ -2420,11 +2551,87 @@ describe("05-04 a LOGOUT or ACCOUNT_DELETION purge leaves no partition bytes beh
},
);
// 1103/05-01 rest (Y2). The journal counts rows by their partition key, so a
// stopped put whose row lost that key was never counted. Its staging
// receipt kept its chunk out of the sweep, and every purge said COMPLETED
// with the receipt, the chunk and the manifest still on disk. The partition
// delete takes them; the keyless row itself stays, counted apart (05-03).
it("leaves no bytes of a stopped put whose journal row lost its partition key", async () => {
const { root, idb, tab } = sharedRootTabs();
const journal = createIndexedDbOpfsJournal({
authorityToken: scopeA.authorityToken,
factory: idb.factory,
keyRange: idb.keyRange,
});
const writerWorker = loopbackGateway(
createOpfsWorkerRuntime({
root: root as unknown as FileSystemDirectoryHandle,
crypto: globalThis.crypto,
policy: runtimePolicy,
leaseManager: exclusiveLeases(),
dedicatedWorker: true,
supportsSynchronousAccessHandles: false,
}),
);
const unavailable = async () =>
browserDataFailure("UNAVAILABLE", "INDEXEDDB_WRITE", {
retryable: true,
recovery: "RETRY",
});
// The tab crashes before commit: neither the commit nor its compensation
// lands, so the row stays FILES_READY with its staging on disk.
const writer = tab("w", {
journal: { ...journal, commitPut: unavailable } as OpfsJournalPort,
worker: {
...writerWorker,
abortPreparedPut: async () =>
browserDataFailure("UNAVAILABLE", "OBJECT_WRITE", {
retryable: true,
recovery: "RETRY",
}),
},
});
const purger = tab("p", authority);
expect(await putBytes(purger, "object_secret_1", [1, 2, 3])).toMatchObject({ ok: true });
expect(await putBytes(writer, "object_dead_0001", [9, 9, 9])).toMatchObject({
ok: false,
});
const { logicalKey: _dropped, ...keyless } = idb.readRaw(
"opfs-journal",
"transaction_w_1",
) as Record<string, unknown>;
idb.seed("opfs-journal", keyless);
expect(filesUnder(root, scopeA)).not.toEqual([]);
for (let run = 0; run < 2; run += 1) {
const report = await purger.maintenance.enforcePolicies({
reason: "ACCOUNT_DELETION",
});
expect(report).toMatchObject({
ok: true,
value: { moreObjectsAvailable: false, partitionDeleted: true },
});
expect(report.ok && report.value.chunkSweep).toBeUndefined();
expect(filesUnder(root, scopeA)).toEqual([]);
expect(await purger.maintenance.reconcile()).toMatchObject({
ok: true,
value: {
committedTransactions: 0,
corruptTransactions: 1,
unattributedCorruptTransactions: 1,
},
});
}
expect(await openedBytes(purger, "object_dead_0001")).toBe("NOT_FOUND");
expect(idb.readRaw("opfs-journal", "transaction_w_1")).toBeDefined();
});
// [0929] 05-02. Another tab overwrites the object the purge is removing, so
// the purge's remove ends in CONFLICT. That purge is not finished and must
// not claim a completed chunk sweep. The overwrite finishes between the
// purge's listing and its remove: one still running when the purge checks
// the journal sends it to the partition delete instead (2026-11-03 05-01).
// not claim to be. The overwrite finishes between the purge's listing and
// its remove: one still running when the purge checks the journal sends it
// to the partition delete instead (2026-11-03 05-01). The next call walks
// every object and takes the partition (1103/05-01 rest).
it("reports a purge that skipped a changing object as unfinished", async () => {
const { root, idb, tab } = sharedRootTabs();
const journal = createIndexedDbOpfsJournal({
@@ -2472,7 +2679,7 @@ describe("05-04 a LOGOUT or ACCOUNT_DELETION purge leaves no partition bytes beh
value: {
removedObjects: 1,
moreObjectsAvailable: false,
chunkSweep: "COMPLETED",
partitionDeleted: true,
},
});
expect(filesUnder(root, scopeA)).toEqual([]);