emdash 1.0.1 → 1.1.0

package/dist/stage-Csnh_yEd.mjs

@@ -0,0 +1,662 @@
+import { i as transferErrorDetailSchema, r as isTransferError, t as TransferError } from "./errors-CuHQRiBW.mjs";
+import { o as TRANSFER_LIMITS } from "./canonical-Y1dpjCnp.mjs";
+import { a as isSha256Digest, i as createSha256, r as createHashingStream } from "./digest-xIpR3o64.mjs";
+import { r as bumpRunningExportWriteEpochs } from "./fence-CGw57S4v.mjs";
+import { n as siteImportReceiptSchema } from "./receipt-Dpp1uaX9.mjs";
+import { a as timestampIsOlderThan, b as transferCursorSchema, c as EXECUTING_IMPORT_STATES, f as PRE_EXECUTION_IMPORT_STATES, h as TRANSFER_RUNTIME_GENERATION, i as timestampIsLive, m as TERMINAL_IMPORT_STATES, o as timestampNow, r as timestampIsDue, s as timestampOffset, v as isTransferOperationKind, x as transferProgressSchema, y as isTransferOperationState } from "./approvals-DycwI6lZ.mjs";
+import { n as stagingAuxKey, r as stagingKey } from "./keys-DxqxcAD4.mjs";
+import { sql } from "kysely";
+import { ulid } from "ulidx";
+
+//#region src/transfer/ops/operations.ts
+/**
+* Transfer operation rows: creation, lease claims, and lease-fenced state
+* writes.
+*
+* Every step of a running operation happens under a lease: `claim` is one
+* `UPDATE … WHERE lease is free … RETURNING` statement that installs a fresh
+* ULID lease token, and every later write is fenced on that token and on the
+* lease still being live. A caller that loses its lease (expiry, another
+* caller took over) gets `TRANSFER_LEASE_LOST` and must stop without writing.
+*/
+function toPublicOperation(operation) {
+	const { stagingSecret: _secret, leaseToken: _lease, ...rest } = operation;
+	return rest;
+}
+const MAX_IDEMPOTENCY_KEY_LENGTH = 255;
+function parseJson(value) {
+	if (value === null) return null;
+	return JSON.parse(value);
+}
+function toOperation(row) {
+	const { kind, state } = row;
+	if (!isTransferOperationKind(kind) || !isTransferOperationState(state)) throw new TransferError("TRANSFER_INVALID_STATE", "Unknown transfer operation kind or state");
+	const cursor = parseJson(row.cursor);
+	const progress = parseJson(row.progress);
+	const receipt = parseJson(row.receipt);
+	const errorDetail = parseJson(row.error_detail);
+	return {
+		id: row.id,
+		kind,
+		state,
+		stage: row.stage,
+		cursor: cursor === null ? null : transferCursorSchema.parse(cursor),
+		progress: progress === null ? null : transferProgressSchema.parse(progress),
+		options: parseJson(row.options),
+		idempotencyKey: row.idempotency_key,
+		packageDigest: isSha256Digest(row.package_digest) ? row.package_digest : null,
+		planDigest: isSha256Digest(row.plan_digest) ? row.plan_digest : null,
+		originSiteId: row.origin_site_id,
+		stagingSecret: row.staging_secret,
+		receipt: receipt === null ? null : siteImportReceiptSchema.parse(receipt),
+		errorCode: row.error_code,
+		errorDetail: errorDetail === null ? null : transferErrorDetailSchema.parse(errorDetail),
+		writeEpoch: Number(row.write_epoch),
+		attemptCount: Number(row.attempt_count),
+		leaseToken: row.lease_token,
+		leaseExpiresAt: row.lease_expires_at,
+		runtimeGeneration: Number(row.runtime_generation),
+		cancelRequestedAt: row.cancel_requested_at,
+		mutationStartedAt: row.mutation_started_at,
+		createdBy: row.created_by,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at,
+		completedAt: row.completed_at,
+		expiresAt: row.expires_at,
+		stagingCollectedAt: row.staging_collected_at
+	};
+}
+function createStagingSecret() {
+	const bytes = new Uint8Array(16);
+	crypto.getRandomValues(bytes);
+	return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+var TransferOperationRepository = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async get(id) {
+		const row = await this.db.selectFrom("_emdash_transfer_operations").selectAll().where("id", "=", id).executeTakeFirst();
+		return row ? toOperation(row) : null;
+	}
+	async require(id) {
+		const operation = await this.get(id);
+		if (!operation) throw new TransferError("TRANSFER_OPERATION_NOT_FOUND", "Transfer operation not found");
+		return operation;
+	}
+	/**
+	* Create an operation, or return the existing one for the same
+	* `(createdBy, kind, idempotencyKey)`. Throws
+	* `TRANSFER_IDEMPOTENCY_CONFLICT` when that key was used with a different
+	* package digest, and `TRANSFER_IMPORT_IN_PROGRESS` when another import
+	* already occupies the target.
+	*/
+	async create(input) {
+		if (input.idempotencyKey !== void 0 && (input.idempotencyKey.length === 0 || input.idempotencyKey.length > MAX_IDEMPOTENCY_KEY_LENGTH)) throw new TransferError("TRANSFER_IDEMPOTENCY_CONFLICT", "Invalid idempotency key");
+		if (input.idempotencyKey !== void 0) {
+			const existing = await this.findByIdempotencyKey(input);
+			if (existing) return {
+				operation: existing,
+				created: false
+			};
+		}
+		const id = ulid();
+		const inserted = await this.db.insertInto("_emdash_transfer_operations").values({
+			id,
+			kind: input.kind,
+			state: input.kind === "export" ? "pending" : "uploading",
+			idempotency_key: input.idempotencyKey ?? null,
+			package_digest: input.packageDigest ?? null,
+			origin_site_id: input.originSiteId ?? null,
+			options: input.options === void 0 ? null : JSON.stringify(input.options),
+			staging_secret: createStagingSecret(),
+			runtime_generation: TRANSFER_RUNTIME_GENERATION,
+			created_by: input.createdBy,
+			expires_at: timestampOffset(this.db, input.ttlSeconds ?? defaultTtl(input.kind)),
+			stage: null,
+			cursor: null,
+			progress: null,
+			plan_digest: null,
+			receipt: null,
+			error_code: null,
+			error_detail: null,
+			lease_token: null,
+			lease_expires_at: null,
+			cancel_requested_at: null,
+			mutation_started_at: null,
+			completed_at: null,
+			staging_collected_at: null
+		}).onConflict((conflict) => conflict.doNothing()).returningAll().executeTakeFirst();
+		if (inserted) return {
+			operation: toOperation(inserted),
+			created: true
+		};
+		if (input.idempotencyKey !== void 0) {
+			const existing = await this.findByIdempotencyKey(input);
+			if (existing) return {
+				operation: existing,
+				created: false
+			};
+		}
+		throw new TransferError("TRANSFER_IMPORT_IN_PROGRESS", "Another import is already in progress on this site");
+	}
+	async findByIdempotencyKey(input) {
+		const row = await this.db.selectFrom("_emdash_transfer_operations").selectAll().where("created_by", "=", input.createdBy).where("kind", "=", input.kind).where("idempotency_key", "=", input.idempotencyKey ?? "").executeTakeFirst();
+		if (!row) return null;
+		if (input.packageDigest !== void 0 && row.package_digest !== null && row.package_digest !== input.packageDigest) throw new TransferError("TRANSFER_IDEMPOTENCY_CONFLICT", "Idempotency key was already used for a different package");
+		return toOperation(row);
+	}
+	/** The import that currently occupies the target, if any. */
+	async findOccupyingImport() {
+		const row = await this.db.selectFrom("_emdash_transfer_operations").selectAll().where("kind", "=", "import").where((eb) => eb.or([eb("state", "in", [...PRE_EXECUTION_IMPORT_STATES, ...EXECUTING_IMPORT_STATES]), eb.and([eb("state", "in", ["failed", "cancelled"]), eb("mutation_started_at", "is not", null)])])).executeTakeFirst();
+		return row ? toOperation(row) : null;
+	}
+	/**
+	* Take the operation's lease if it is in one of `states` and no live lease
+	* exists. Throws `TRANSFER_OPERATION_NOT_FOUND`, or
+	* `TRANSFER_RUNTIME_MISMATCH` when the row was written by an incompatible
+	* runtime generation.
+	*/
+	async claim(id, states, options = {}) {
+		const leaseToken = ulid();
+		const now = timestampNow(this.db);
+		const row = await this.db.updateTable("_emdash_transfer_operations").set({
+			lease_token: leaseToken,
+			lease_expires_at: timestampOffset(this.db, options.leaseSeconds ?? TRANSFER_LIMITS.leaseSeconds),
+			attempt_count: sql`attempt_count + 1`,
+			updated_at: now
+		}).where("id", "=", id).where("state", "in", [...states]).where("runtime_generation", "=", TRANSFER_RUNTIME_GENERATION).where((eb) => eb.or([
+			eb("lease_token", "is", null),
+			eb("lease_expires_at", "is", null),
+			timestampIsDue(this.db, "lease_expires_at")
+		])).returningAll().executeTakeFirst();
+		if (row) return {
+			outcome: "claimed",
+			operation: toOperation(row),
+			leaseToken
+		};
+		const current = await this.require(id);
+		if (current.runtimeGeneration !== TRANSFER_RUNTIME_GENERATION) throw new TransferError("TRANSFER_RUNTIME_MISMATCH", "Transfer operation was created by an incompatible EmDash version");
+		if (!states.includes(current.state)) return {
+			outcome: "invalid_state",
+			operation: current
+		};
+		return {
+			outcome: "lease_active",
+			operation: current
+		};
+	}
+	/**
+	* Write state under the lease and extend it. Throws `TRANSFER_LEASE_LOST`
+	* when the lease is gone.
+	*/
+	async advance(id, leaseToken, patch) {
+		return this.fencedUpdate(id, leaseToken, {
+			...this.patchValues(patch),
+			lease_expires_at: timestampOffset(this.db, TRANSFER_LIMITS.leaseSeconds)
+		});
+	}
+	/** Write state and give up the lease so the next step can claim it. */
+	async release(id, leaseToken, patch = {}) {
+		return this.fencedUpdate(id, leaseToken, {
+			...this.patchValues(patch),
+			lease_token: null,
+			lease_expires_at: null
+		});
+	}
+	/**
+	* Write `patch`, move to `state`, and give up the lease; when a cancel was
+	* requested while the lease was held, move to `cancelled` instead. One
+	* statement decides, so a cancel racing the release is never lost.
+	*/
+	async releaseUnlessCancelled(id, leaseToken, state, patch = {}) {
+		const now = timestampNow(this.db);
+		return this.fencedUpdate(id, leaseToken, {
+			...this.patchValues(patch),
+			state: sql`CASE WHEN cancel_requested_at IS NULL THEN ${state} ELSE 'cancelled' END`,
+			completed_at: sql`CASE WHEN cancel_requested_at IS NULL THEN completed_at ELSE ${now} END`,
+			lease_token: null,
+			lease_expires_at: null
+		});
+	}
+	async complete(id, leaseToken, result = {}) {
+		return this.fencedUpdate(id, leaseToken, {
+			state: "complete",
+			receipt: result.receipt === void 0 ? void 0 : JSON.stringify(result.receipt),
+			progress: result.progress === void 0 ? void 0 : JSON.stringify(result.progress),
+			completed_at: timestampNow(this.db),
+			expires_at: result.ttlSeconds === void 0 ? void 0 : timestampOffset(this.db, result.ttlSeconds),
+			lease_token: null,
+			lease_expires_at: null
+		});
+	}
+	async fail(id, leaseToken, error) {
+		return this.fencedUpdate(id, leaseToken, {
+			state: "failed",
+			error_code: error.code,
+			error_detail: error.detail === void 0 ? null : JSON.stringify(error.detail),
+			completed_at: timestampNow(this.db),
+			lease_token: null,
+			lease_expires_at: null
+		});
+	}
+	/** Finish a cancellation the lease holder observed via `cancelRequestedAt`. */
+	async finishCancelled(id, leaseToken) {
+		return this.fencedUpdate(id, leaseToken, {
+			state: "cancelled",
+			completed_at: timestampNow(this.db),
+			lease_token: null,
+			lease_expires_at: null
+		});
+	}
+	/**
+	* Cancel an import. Without a live lease the operation becomes `cancelled`
+	* immediately; otherwise `cancel_requested_at` is set and the lease holder
+	* stops after its current batch. Returns the updated operation.
+	*/
+	async requestCancel(id) {
+		const cancellable = [...PRE_EXECUTION_IMPORT_STATES, ...EXECUTING_IMPORT_STATES];
+		const now = timestampNow(this.db);
+		const immediate = await this.db.updateTable("_emdash_transfer_operations").set({
+			state: "cancelled",
+			cancel_requested_at: now,
+			completed_at: now,
+			updated_at: now,
+			lease_token: null,
+			lease_expires_at: null
+		}).where("id", "=", id).where("kind", "=", "import").where("state", "in", cancellable).where((eb) => eb.or([
+			eb("lease_token", "is", null),
+			eb("lease_expires_at", "is", null),
+			timestampIsDue(this.db, "lease_expires_at")
+		])).returningAll().executeTakeFirst();
+		if (immediate) return toOperation(immediate);
+		const flagged = await this.db.updateTable("_emdash_transfer_operations").set({
+			cancel_requested_at: now,
+			updated_at: now
+		}).where("id", "=", id).where("kind", "=", "import").where("state", "in", cancellable).returningAll().executeTakeFirst();
+		if (flagged) return toOperation(flagged);
+		await this.require(id);
+		throw new TransferError("TRANSFER_INVALID_STATE", "Transfer operation cannot be cancelled");
+	}
+	/**
+	* Mark a failed or cancelled import abandoned. Lifts the write fence; never
+	* deletes imported data.
+	*/
+	async abandon(id) {
+		const now = timestampNow(this.db);
+		const row = await this.db.updateTable("_emdash_transfer_operations").set({
+			state: "abandoned",
+			updated_at: now
+		}).where("id", "=", id).where("kind", "=", "import").where("state", "in", ["failed", "cancelled"]).where((eb) => eb.or([
+			eb("lease_token", "is", null),
+			eb("lease_expires_at", "is", null),
+			timestampIsDue(this.db, "lease_expires_at")
+		])).returningAll().executeTakeFirst();
+		if (row) return toOperation(row);
+		await this.require(id);
+		throw new TransferError("TRANSFER_INVALID_STATE", "Only a failed or cancelled import can be abandoned");
+	}
+	/**
+	* Move operations past their `expires_at` to `expired` (pre-execution
+	* imports and every non-expired export) when no live lease holds them.
+	* Returns the expired operations so their staging can be collected.
+	*/
+	async expireDue(limit = 50) {
+		const candidates = await this.db.selectFrom("_emdash_transfer_operations").select("id").where("expires_at", "is not", null).where(timestampIsDue(this.db, "expires_at")).where((eb) => eb.or([eb.and([
+			eb("kind", "=", "import"),
+			eb("state", "in", [...PRE_EXECUTION_IMPORT_STATES]),
+			eb("mutation_started_at", "is", null)
+		]), eb.and([eb("kind", "=", "export"), eb("state", "in", [
+			"pending",
+			"running",
+			"complete",
+			"failed"
+		])])])).where((eb) => eb.or([
+			eb("lease_token", "is", null),
+			eb("lease_expires_at", "is", null),
+			timestampIsDue(this.db, "lease_expires_at")
+		])).orderBy("expires_at").limit(limit).execute();
+		if (candidates.length === 0) return [];
+		const now = timestampNow(this.db);
+		return (await this.db.updateTable("_emdash_transfer_operations").set({
+			state: "expired",
+			updated_at: now,
+			lease_token: null,
+			lease_expires_at: null
+		}).where("id", "in", candidates.map((candidate) => candidate.id)).where(timestampIsDue(this.db, "expires_at")).where((eb) => eb.or([eb.and([
+			eb("kind", "=", "import"),
+			eb("state", "in", [...PRE_EXECUTION_IMPORT_STATES]),
+			eb("mutation_started_at", "is", null)
+		]), eb.and([eb("kind", "=", "export"), eb("state", "in", [
+			"pending",
+			"running",
+			"complete",
+			"failed"
+		])])])).returning([
+			"id",
+			"kind",
+			"staging_secret"
+		]).execute()).flatMap((row) => isTransferOperationKind(row.kind) ? [{
+			id: row.id,
+			kind: row.kind,
+			stagingSecret: row.staging_secret
+		}] : []);
+	}
+	/**
+	* Operations whose staging area can be collected and has not been yet:
+	* imports in a terminal state, and exports that failed or expired
+	* (complete exports stay downloadable until they expire). Oldest first.
+	* A collector deletes staged objects with `TransferStage.deleteSome` until
+	* it returns 0, deletes child rows with {@link deleteChildRows} until it
+	* returns 0, then calls {@link markCollected}; a crash anywhere in between
+	* leaves the operation listed here, so collection resumes.
+	*
+	* `importRetentionSeconds` keeps a finished import's staging for that long
+	* after its last state change; expired imports are listed at once.
+	*/
+	async listUncollected(limit = 20, options = {}) {
+		const retention = options.importRetentionSeconds ?? 0;
+		const retainedStates = TERMINAL_IMPORT_STATES.filter((state) => state !== "expired");
+		return (await this.db.selectFrom("_emdash_transfer_operations").select([
+			"id",
+			"kind",
+			"state",
+			"staging_secret"
+		]).where("staging_collected_at", "is", null).where((eb) => eb.or([
+			eb.and([eb("kind", "=", "import"), eb("state", "=", "expired")]),
+			eb.and([
+				eb("kind", "=", "import"),
+				eb("state", "in", retainedStates),
+				timestampIsOlderThan(this.db, "updated_at", retention)
+			]),
+			eb.and([eb("kind", "=", "export"), eb("state", "in", ["failed", "expired"])])
+		])).where((eb) => eb.or([
+			eb("lease_token", "is", null),
+			eb("lease_expires_at", "is", null),
+			timestampIsDue(this.db, "lease_expires_at")
+		])).orderBy("updated_at").orderBy("id").limit(Math.min(Math.max(limit, 1), 100)).execute()).flatMap((row) => isTransferOperationKind(row.kind) && isTransferOperationState(row.state) ? [{
+			id: row.id,
+			kind: row.kind,
+			state: row.state,
+			stagingSecret: row.staging_secret
+		}] : []);
+	}
+	/** Record that an operation's staging area and child rows are gone. */
+	async markCollected(id) {
+		await this.db.updateTable("_emdash_transfer_operations").set({ staging_collected_at: timestampNow(this.db) }).where("id", "=", id).where("staging_collected_at", "is", null).execute();
+	}
+	/**
+	* Delete up to `limit` child rows of each child table of an operation
+	* (staged files, package index, media blobs), one bounded statement per
+	* table. Returns the number deleted; call until it returns 0. Always drain
+	* children this way before deleting an operation row: an `ON DELETE
+	* CASCADE` over millions of child rows in one statement exceeds D1's
+	* limits.
+	*/
+	async deleteChildRows(operationId, limit = 500) {
+		const bounded = Math.min(Math.max(Math.trunc(limit), 1), 5e3);
+		return [
+			await sql`
+			DELETE FROM _emdash_transfer_staged_files
+			WHERE operation_id = ${operationId}
+				AND path IN (
+					SELECT path FROM _emdash_transfer_staged_files
+					WHERE operation_id = ${operationId}
+					LIMIT ${bounded}
+				)
+		`.execute(this.db),
+			await sql`
+			DELETE FROM _emdash_transfer_package_index
+			WHERE operation_id = ${operationId}
+				AND (kind, id) IN (
+					SELECT kind, id FROM _emdash_transfer_package_index
+					WHERE operation_id = ${operationId}
+					LIMIT ${bounded}
+				)
+		`.execute(this.db),
+			await sql`
+			DELETE FROM _emdash_transfer_media_blobs
+			WHERE operation_id = ${operationId}
+				AND media_id IN (
+					SELECT media_id FROM _emdash_transfer_media_blobs
+					WHERE operation_id = ${operationId}
+					LIMIT ${bounded}
+				)
+		`.execute(this.db)
+		].reduce((sum, result) => sum + Number(result.numAffectedRows ?? 0n), 0);
+	}
+	/**
+	* Delete a collected operation row once it has no child rows left.
+	* Returns false, deleting nothing, otherwise. Identity-map rows are kept.
+	*/
+	async deleteIfChildless(id) {
+		const result = await this.db.deleteFrom("_emdash_transfer_operations").where("id", "=", id).where("staging_collected_at", "is not", null).where((eb) => eb.and([
+			eb.not(eb.exists(eb.selectFrom("_emdash_transfer_staged_files").select("path").where("_emdash_transfer_staged_files.operation_id", "=", id))),
+			eb.not(eb.exists(eb.selectFrom("_emdash_transfer_package_index").select("kind").where("_emdash_transfer_package_index.operation_id", "=", id))),
+			eb.not(eb.exists(eb.selectFrom("_emdash_transfer_media_blobs").select("media_id").where("_emdash_transfer_media_blobs.operation_id", "=", id)))
+		])).executeTakeFirst();
+		return Number(result.numDeletedRows ?? 0n) > 0;
+	}
+	/**
+	* Bump `write_epoch` on every running export. Fenced write paths call this
+	* so an export's consistency fence notices writes to tables that have no
+	* `updated_at`. Returns the number of exports touched.
+	*/
+	async recordWriteForRunningExports() {
+		return bumpRunningExportWriteEpochs(this.db);
+	}
+	/** Operations newest first, `{ items, nextCursor }` over `(created_at, id)`. */
+	async list(options = {}) {
+		const limit = Math.min(Math.max(options.limit ?? 50, 1), 100);
+		let query = this.db.selectFrom("_emdash_transfer_operations").selectAll();
+		if (options.kind) query = query.where("kind", "=", options.kind);
+		if (options.createdBy) query = query.where("created_by", "=", options.createdBy);
+		const cursor = options.cursor;
+		if (cursor) query = query.where((eb) => eb.or([eb("created_at", "<", cursor.createdAt), eb.and([eb("created_at", "=", cursor.createdAt), eb("id", "<", cursor.id)])]));
+		const rows = await query.orderBy("created_at", "desc").orderBy("id", "desc").limit(limit + 1).execute();
+		const items = rows.slice(0, limit).map((row) => toPublicOperation(toOperation(row)));
+		const last = items.at(-1);
+		return rows.length > limit && last ? {
+			items,
+			next: {
+				createdAt: last.createdAt,
+				id: last.id
+			}
+		} : { items };
+	}
+	patchValues(patch) {
+		const values = {};
+		if (patch.state !== void 0) values.state = patch.state;
+		if (patch.stage !== void 0) values.stage = patch.stage;
+		if (patch.cursor !== void 0) values.cursor = patch.cursor === null ? null : JSON.stringify(transferCursorSchema.parse(patch.cursor));
+		if (patch.progress !== void 0) values.progress = patch.progress === null ? null : JSON.stringify(transferProgressSchema.parse(patch.progress));
+		if (patch.packageDigest !== void 0) values.package_digest = patch.packageDigest;
+		if (patch.planDigest !== void 0) values.plan_digest = patch.planDigest;
+		if (patch.originSiteId !== void 0) values.origin_site_id = patch.originSiteId;
+		if (patch.markMutationStarted) values.mutation_started_at = sql`COALESCE(mutation_started_at, ${timestampNow(this.db)})`;
+		if (patch.ttlSeconds !== void 0) values.expires_at = timestampOffset(this.db, patch.ttlSeconds);
+		if (patch.retryError !== void 0) {
+			values.error_code = patch.retryError?.code ?? null;
+			values.error_detail = patch.retryError?.detail === void 0 ? null : JSON.stringify(patch.retryError.detail);
+		}
+		return values;
+	}
+	async fencedUpdate(id, leaseToken, values) {
+		const row = await this.db.updateTable("_emdash_transfer_operations").set({
+			...values,
+			updated_at: timestampNow(this.db)
+		}).where("id", "=", id).where("lease_token", "=", leaseToken).where("lease_expires_at", "is not", null).where(timestampIsLive(this.db, "lease_expires_at")).returningAll().executeTakeFirst();
+		if (!row) throw new TransferError("TRANSFER_LEASE_LOST", "Transfer operation lease was lost");
+		return toOperation(row);
+	}
+};
+function defaultTtl(kind) {
+	return kind === "export" ? TRANSFER_LIMITS.exportTtlSeconds : TRANSFER_LIMITS.pendingImportTtlSeconds;
+}
+
+//#endregion
+//#region src/transfer/staging/stage.ts
+const PACKAGE_CONTENT_TYPE = "application/octet-stream";
+function oversizeError() {
+	return new TransferError("TRANSFER_FILE_SIZE_MISMATCH", "File is larger than declared");
+}
+function toStream(body) {
+	if (body instanceof Uint8Array) return new ReadableStream({ start(controller) {
+		if (body.byteLength > 0) controller.enqueue(body);
+		controller.close();
+	} });
+	return body;
+}
+/**
+* Stream `body` into `key`, hashing and counting as it goes. The object is
+* kept only if exactly `expected.bytes` bytes with digest `expected.sha256`
+* were written; otherwise it is deleted and `TRANSFER_FILE_SIZE_MISMATCH` or
+* `TRANSFER_FILE_DIGEST_MISMATCH` is thrown. Where the runtime provides
+* `FixedLengthStream` (workerd), the upload is wrapped in one so R2 receives
+* a known length.
+*
+* Callers staging a package file must check its staged-files row first and
+* refuse the upload when it is already `verified` and its object still
+* matches, and must pass `keepExistingOnFailure` returning true once the row
+* is verified: a failed retry or concurrent upload of the same path must not
+* delete the object a successful upload stored. A failing upload that
+* already overwrote the object can still leave bad bytes behind a verified
+* row, so readers verify sizes and digests again when they read staged
+* files, and a later upload of that path replaces the bad object.
+*/
+async function putVerified(storage, key, body, expected, options = {}) {
+	const discard = async () => {
+		if (options.keepExistingOnFailure && await options.keepExistingOnFailure()) return;
+		await storage.delete(key).catch(() => void 0);
+	};
+	if (!Number.isSafeInteger(expected.bytes) || expected.bytes < 0) throw new TransferError("TRANSFER_FILE_SIZE_MISMATCH", "Invalid declared size");
+	const hasher = await createSha256();
+	const hashing = createHashingStream(hasher, {
+		maxBytes: expected.bytes,
+		onLimitExceeded: oversizeError
+	});
+	let stream = toStream(body).pipeThrough(hashing.stream);
+	if (typeof FixedLengthStream !== "undefined") stream = stream.pipeThrough(new FixedLengthStream(expected.bytes));
+	try {
+		await storage.upload({
+			key,
+			body: stream,
+			contentType: options.contentType ?? PACKAGE_CONTENT_TYPE
+		});
+	} catch (error) {
+		await discard();
+		if (isTransferError(error)) throw error;
+		const cause = findTransferError(error);
+		if (cause) throw cause;
+		if (hashing.bytes() !== expected.bytes) throw new TransferError("TRANSFER_FILE_SIZE_MISMATCH", "File size does not match", { cause: error });
+		throw new TransferError("TRANSFER_STORAGE_ERROR", "Failed to store file", { cause: error });
+	}
+	const digest = await hasher.digest();
+	if (hashing.bytes() !== expected.bytes) {
+		await discard();
+		throw new TransferError("TRANSFER_FILE_SIZE_MISMATCH", "File size does not match", { detail: {
+			expected: expected.bytes,
+			actual: hashing.bytes()
+		} });
+	}
+	if (digest !== expected.sha256) {
+		await discard();
+		throw new TransferError("TRANSFER_FILE_DIGEST_MISMATCH", "File digest does not match");
+	}
+}
+function findTransferError(error) {
+	let current = error;
+	for (let depth = 0; depth < 5 && current instanceof Error; depth++) {
+		if (current instanceof TransferError) return current;
+		current = current.cause;
+	}
+	return null;
+}
+/** Read a whole stream, failing once it exceeds `maxBytes`. */
+async function readStreamBytes(stream, maxBytes) {
+	const reader = stream.getReader();
+	const parts = [];
+	let total = 0;
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			total += value.byteLength;
+			if (total > maxBytes) throw new TransferError("TRANSFER_LIMIT_EXCEEDED", "File exceeds its size limit", { detail: { limit: maxBytes } });
+			parts.push(value);
+		}
+	} catch (error) {
+		await reader.cancel().catch(() => void 0);
+		throw error;
+	} finally {
+		reader.releaseLock();
+	}
+	const bytes = new Uint8Array(total);
+	let offset = 0;
+	for (const part of parts) {
+		bytes.set(part, offset);
+		offset += part.byteLength;
+	}
+	return bytes;
+}
+/** One operation's staging area in `storage` under `prefix` (see keys.ts). */
+var TransferStage = class {
+	constructor(storage, prefix) {
+		this.storage = storage;
+		this.prefix = prefix;
+	}
+	keyFor(path) {
+		return stagingKey(this.prefix, path);
+	}
+	async putVerified(path, body, bytes, sha256, options = {}) {
+		await putVerified(this.storage, this.keyFor(path), body, {
+			bytes,
+			sha256
+		}, options);
+	}
+	async exists(path) {
+		return this.storage.exists(this.keyFor(path));
+	}
+	async open(path) {
+		try {
+			return await this.storage.download(this.keyFor(path));
+		} catch (error) {
+			throw new TransferError("TRANSFER_FILE_MISSING", "Staged file is missing", {
+				detail: { path },
+				cause: error
+			});
+		}
+	}
+	async readBytes(path, maxBytes) {
+		return readStreamBytes((await this.open(path)).body, maxBytes);
+	}
+	async putAux(file, content) {
+		await this.storage.upload({
+			key: stagingAuxKey(this.prefix, file),
+			body: new TextEncoder().encode(content),
+			contentType: "application/json"
+		});
+	}
+	async readAux(file, maxBytes) {
+		const key = stagingAuxKey(this.prefix, file);
+		if (!await this.storage.exists(key)) return null;
+		const download = await this.storage.download(key);
+		return new TextDecoder().decode(await readStreamBytes(download.body, maxBytes));
+	}
+	/**
+	* Delete up to `limit` staged objects. Returns the number deleted; call
+	* again until it returns 0.
+	*/
+	async deleteSome(limit = 100) {
+		const listing = await this.storage.list({
+			prefix: this.prefix,
+			limit
+		});
+		for (const file of listing.files) await this.storage.delete(file.key);
+		return listing.files.length;
+	}
+};
+
+//#endregion
+export { toPublicOperation as a, TransferOperationRepository as i, putVerified as n, readStreamBytes as r, TransferStage as t };
+//# sourceMappingURL=stage-Csnh_yEd.mjs.map