@effect-kit/storage 0.0.0-stage → 0.1.0

package/dist/sessions/download.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"download.js","names":[],"sources":["../../src/sessions/download.ts"],"sourcesContent":["import { Effect, Stream } from \"effect\";\n\nimport { StorageError } from \"../core/errors.js\";\nimport type { Checksum } from \"../core/object.js\";\nimport { pinnedRequest } from \"../transfers/download.js\";\nimport { sameChecksum } from \"../transfers/reader.js\";\nimport type { DownloadCheckpoint } from \"./checkpoint.js\";\nimport { sessionError } from \"./store.js\";\nimport type { UploadEnvironment } from \"./upload.js\";\n\nexport interface RestartableDownloadTarget<E = never, R = never> {\n  readonly id: string;\n  readonly identity?: string;\n  readonly discard?: () => Effect.Effect<void, E, R>;\n  readonly prefix: (length: number) => Stream.Stream<Uint8Array, E, R>;\n  /** Discard uncheckpointed tail bytes; never extend a short existing prefix. */\n  readonly truncate: (length: number) => Effect.Effect<void, E, R>;\n  readonly write: (offset: number, bytes: Uint8Array) => Effect.Effect<void, E, R>;\n  readonly sync: Effect.Effect<void, E, R>;\n  /** Must verify or idempotently recognize a prior publication of these exact bytes. */\n  readonly publish: (checksum: Checksum, length: number) => Effect.Effect<void, E, R>;\n}\n\nexport const runDownload = Effect.fnUntraced(function* <E, R>(\n  environment: UploadEnvironment,\n  original: DownloadCheckpoint,\n  target: RestartableDownloadTarget<E, R>,\n) {\n  const { runtime, store } = environment;\n  if (target.id !== original.targetId || target.id !== original.id)\n    return yield* sessionError(\"ForeignDownloadTarget\");\n  let checkpoint = original;\n  const operation = yield* runtime.begin(\"download\", checkpoint.length);\n  const workspace =\n    runtime.policy.maxSourceChunkBytes * 2 +\n    runtime.input.digest.workspaceBytes * 2 +\n    runtime.endpoint.transportOverheadBytes;\n  if (workspace > runtime.policy.memoryBudgetBytes)\n    return yield* sessionError(\"DownloadWorkspaceLimit\");\n  const save = Effect.fnUntraced(function* (next: DownloadCheckpoint) {\n    const saved = yield* store.write(next, checkpoint.revision);\n    if (saved.kind !== \"download\") return yield* sessionError(\"InvalidCheckpoint\");\n    checkpoint = saved;\n  });\n  const work = runtime.lease(\n    workspace,\n    Effect.scoped(\n      Effect.gen(function* () {\n        const identity = target.identity ?? target.id;\n        if (checkpoint.targetIdentity && checkpoint.targetIdentity !== identity)\n          return yield* sessionError(\"ChangedDownloadTarget\");\n        if (!checkpoint.targetIdentity) yield* save({ ...checkpoint, targetIdentity: identity });\n        if ([\"aborting\", \"aborted\"].includes(checkpoint.state))\n          return yield* sessionError(\"SessionAborting\");\n        if (checkpoint.state === \"completed\") return checkpoint.metadata;\n        if (checkpoint.state === \"verified\") {\n          if (!checkpoint.checksum) return yield* sessionError(\"MissingVerifiedDigest\");\n          operation.mutationStarted = true;\n          yield* target.publish(checkpoint.checksum, checkpoint.length);\n          operation.committed = true;\n          yield* save({ ...checkpoint, state: \"completed\" });\n          return checkpoint.metadata;\n        }\n        const pin = pinnedRequest(runtime.endpoint, checkpoint.metadata);\n        if (!pin) return yield* sessionError(\"PinnedDownloadRequired\");\n        // A crash/error after the last write may precede EOF/native checksum validation.\n        if (checkpoint.offset === checkpoint.length && checkpoint.offset > 0)\n          yield* save({ ...checkpoint, offset: 0, prefixChecksum: undefined });\n        yield* target.truncate(checkpoint.offset);\n        const hash = runtime.input.digest.create();\n        const prefixHash = runtime.input.digest.create();\n        const snapshot = hash.snapshot?.bind(hash);\n        if (!snapshot) return yield* sessionError(\"DigestSnapshotRequired\");\n        let prefixBytes = 0;\n        yield* Stream.runForEach(target.prefix(checkpoint.offset), (chunk) =>\n          Effect.gen(function* () {\n            if (\n              chunk.buffer.byteLength > runtime.policy.maxSourceChunkBytes ||\n              prefixBytes + chunk.length > checkpoint.offset\n            )\n              return yield* sessionError(\"InvalidDownloadPrefix\");\n            hash.update(chunk);\n            prefixHash.update(chunk);\n            prefixBytes += chunk.length;\n          }),\n        );\n        if (\n          prefixBytes !== checkpoint.offset ||\n          (checkpoint.offset > 0 &&\n            (!checkpoint.prefixChecksum ||\n              !sameChecksum(prefixHash.finish(), checkpoint.prefixChecksum)))\n        )\n          return yield* sessionError(\"ChangedDownloadPrefix\");\n        const start = checkpoint.offset;\n        yield* operation.request(\n          Effect.scoped(\n            Effect.gen(function* () {\n              const response = yield* runtime.endpoint.storage.get({\n                ...pin,\n                ...(start > 0 ? { range: { _tag: \"From\" as const, start } } : {}),\n              });\n              if (\n                response._tag !== \"Object\" ||\n                (checkpoint.metadata.etag && checkpoint.metadata.etag !== response.metadata.etag)\n              )\n                return yield* sessionError(\"ChangedDownloadSource\");\n              if (\n                start > 0 &&\n                (response.range?.start !== start || response.range.totalSize !== checkpoint.length)\n              )\n                return yield* sessionError(\"InvalidDownloadRange\");\n              yield* Stream.runForEach(response.body, (chunk) =>\n                Effect.gen(function* () {\n                  if (\n                    chunk.buffer.byteLength > runtime.policy.maxSourceChunkBytes ||\n                    checkpoint.offset + chunk.length > checkpoint.length\n                  )\n                    return yield* sessionError(\"DownloadLengthMismatch\");\n                  hash.update(chunk);\n                  yield* target.write(checkpoint.offset, chunk);\n                  yield* target.sync;\n                  yield* save({\n                    ...checkpoint,\n                    offset: checkpoint.offset + chunk.length,\n                    prefixChecksum: snapshot(),\n                  });\n                }),\n              );\n              if (\n                checkpoint.offset !== checkpoint.length ||\n                (response.contentLength !== undefined &&\n                  response.contentLength !== checkpoint.offset - start)\n              )\n                return yield* sessionError(\"DownloadLengthMismatch\");\n            }),\n          ),\n        );\n        const checksum = hash.finish();\n        const expected =\n          checkpoint.expectedChecksum ??\n          checkpoint.metadata.checksums?.find(\n            (candidate) =>\n              candidate.scope === \"full-object\" && candidate.algorithm === checksum.algorithm,\n          );\n        if (expected && !sameChecksum(checksum, expected))\n          return yield* sessionError(\"DownloadChecksumMismatch\");\n        yield* save({ ...checkpoint, state: \"verified\", checksum });\n        operation.mutationStarted = true;\n        yield* target.publish(checksum, checkpoint.length);\n        operation.committed = true;\n        yield* save({ ...checkpoint, state: \"completed\" });\n        return checkpoint.metadata;\n      }),\n    ),\n  );\n  return yield* runtime.deadline(operation, work).pipe(\n    Effect.mapError((error) =>\n      error instanceof StorageError &&\n      operation.mutationStarted &&\n      error.mutationOutcome !== \"rejected\"\n        ? new StorageError({\n            operation: error.operation,\n            provider: error.provider,\n            reason: error.reason,\n            requestId: error.requestId,\n            mutationOutcome: operation.committed ? \"succeeded\" : \"unknown\",\n          })\n        : error,\n    ),\n  );\n});\n"],"mappings":"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"}

package/dist/sessions/native-upload.js

@@ -0,0 +1,168 @@
+import { StorageError } from "../core/errors.js";
+import { sameChecksum } from "../transfers/reader.js";
+import { download } from "../transfers/download.js";
+import { planUpload } from "../transfers/planner.js";
+import { NativeHandle, nativeUpload } from "../transfers/native-upload.js";
+import { operationMetadataKey } from "../transfers/upload.js";
+import { sessionError } from "./store.js";
+import { fingerprint } from "./upload.js";
+import { Effect, Redacted, Schema } from "effect";
+
+// src/sessions/native-upload.ts
+const codec = Schema.fromJsonString(Schema.toCodecJson(NativeHandle));
+const decodeNativeHandle = (value) => Schema.decodeUnknownEffect(codec)(Redacted.value(value)).pipe(Effect.mapError(() => sessionError("InvalidNativeHandle")));
+const runNativeUpload = Effect.fnUntraced(function* (environment, original, source) {
+	const { runtime, store } = environment;
+	if (original.state === "completed") {
+		if (!original.metadata) return yield* sessionError("MissingCompletionReceipt");
+		return original.metadata;
+	}
+	if ([
+		"aborting",
+		"cleanup-pending",
+		"aborted",
+		"initiating",
+		"completing",
+		"completion-unknown"
+	].includes(original.state)) return yield* sessionError("ReconciliationRequired", true);
+	if (!original.protocol || (original.protocol === "offset" ? !runtime.endpoint.offsets : !runtime.endpoint.blocks)) return yield* sessionError("ChangedProtocol");
+	let checkpoint = original;
+	const save = Effect.fnUntraced(function* (next) {
+		const result = yield* store.write(next, checkpoint.revision);
+		if (result.kind !== "upload") return yield* sessionError("InvalidCheckpoint");
+		checkpoint = result;
+	});
+	const base = yield* runtime.begin("upload", checkpoint.length);
+	base.progress.attempts = checkpoint.attempts;
+	const operation = {
+		...base,
+		id: checkpoint.operationId,
+		committed: checkpoint.state === "verifying",
+		request: (effect) => {
+			return Effect.gen(function* () {
+				if (checkpoint.attempts >= runtime.policy.maxAttempts) return yield* sessionError("SessionAttemptLimit");
+				yield* save({
+					...checkpoint,
+					attempts: checkpoint.attempts + 1
+				});
+				return yield* base.request(effect);
+			});
+		}
+	};
+	const plan = yield* planUpload(runtime.endpoint, runtime.policy, checkpoint.length, runtime.input.digest.workspaceBytes * 2 + (source.workspaceBytes ?? 0), checkpoint.protocol, false, checkpoint.condition);
+	if (checkpoint.partBytes !== plan.partBytes) return yield* sessionError("ChangedTransferPolicy");
+	return yield* runtime.deadline(operation, Effect.gen(function* () {
+		if (checkpoint.state !== "verifying") yield* runtime.lease(plan.workspaceBytes, Effect.scoped(Effect.gen(function* () {
+			if (source.length !== checkpoint.length || !sameChecksum(yield* fingerprint(environment, source, plan.partBytes), checkpoint.checksum)) return yield* sessionError("ChangedSource");
+			const handle = checkpoint.handle ? yield* decodeNativeHandle(checkpoint.handle) : void 0;
+			if (handle && (handle.ref.storeId !== runtime.endpoint.storage.storeId || handle.ref.key !== checkpoint.key)) return yield* sessionError("ForeignHandle");
+			yield* nativeUpload(runtime, {
+				key: checkpoint.key,
+				source,
+				expectedChecksum: checkpoint.checksum,
+				...checkpoint.condition ? { condition: checkpoint.condition } : {}
+			}, {
+				...checkpoint.headers,
+				customMetadata: {
+					...checkpoint.headers.customMetadata,
+					[operationMetadataKey]: checkpoint.operationId
+				}
+			}, operation, plan, {
+				handle,
+				blocks: checkpoint.blocks ?? [],
+				initiating: checkpoint.state === "created" && checkpoint.protocol === "offset" ? save({
+					...checkpoint,
+					state: "initiating"
+				}) : Effect.void,
+				initiated: (upload) => Schema.encodeEffect(codec)(upload).pipe(Effect.mapError(() => sessionError("InvalidNativeHandle")), Effect.flatMap((encoded) => save({
+					...checkpoint,
+					handle: Redacted.make(encoded),
+					state: "uploading"
+				}))),
+				acknowledged: (offset, block) => save({
+					...checkpoint,
+					state: "uploading",
+					offset,
+					...block ? { blocks: [...(checkpoint.blocks ?? []).filter((saved) => saved.blockId !== block.blockId), block] } : {}
+				}),
+				completing: Effect.suspend(() => save({
+					...checkpoint,
+					state: "completing"
+				})),
+				committed: (metadata) => save({
+					...checkpoint,
+					state: "verifying",
+					metadata
+				})
+			}).pipe(Effect.catch((error) => Effect.gen(function* () {
+				if (error instanceof StorageError && error.mutationOutcome === "rejected" && checkpoint.state === "completing") yield* save({
+					...checkpoint,
+					state: "uploading"
+				});
+				return yield* Effect.fail(error);
+			})));
+		})));
+		const metadata = checkpoint.metadata;
+		if (!metadata) return yield* sessionError("MissingCompletionReceipt");
+		operation.committed = true;
+		base.committed = true;
+		const verified = yield* download(runtime, {
+			ref: metadata.ref,
+			expectedChecksum: checkpoint.checksum,
+			target: { write: () => Effect.void }
+		}, operation, metadata);
+		yield* save({
+			...checkpoint,
+			state: "completed",
+			metadata: verified.metadata,
+			events: [{
+				id: `${checkpoint.operationId}:completed`,
+				kind: "completed",
+				delivered: false
+			}]
+		});
+		return verified.metadata;
+	})).pipe(Effect.mapError((error) => error instanceof StorageError && operation.committed ? new StorageError({
+		...error,
+		mutationOutcome: "succeeded"
+	}) : error));
+});
+const abortNativeUpload = Effect.fnUntraced(function* (environment, original) {
+	if (original.state === "aborted") return;
+	if ([
+		"completed",
+		"verifying",
+		"completing",
+		"completion-unknown",
+		"initiating"
+	].includes(original.state)) return yield* sessionError("ReconciliationRequired", true);
+	const { runtime, store } = environment;
+	const saved = yield* store.write({
+		...original,
+		state: "aborting"
+	}, original.revision);
+	if (saved.kind !== "upload") return yield* sessionError("InvalidCheckpoint");
+	if (saved.protocol === "offset" && saved.handle) {
+		const handle = yield* decodeNativeHandle(saved.handle);
+		if (handle.ref.storeId !== runtime.endpoint.storage.storeId || handle.ref.key !== saved.key || !runtime.endpoint.offsets) return yield* sessionError("ForeignHandle");
+		if ((yield* runtime.cleanupRequest(runtime.endpoint.offsets.cancel(handle)).pipe(Effect.timeout(runtime.policy.cleanupTimeoutMillis), Effect.result))._tag === "Failure") {
+			yield* store.write({
+				...saved,
+				state: "cleanup-pending"
+			}, saved.revision);
+			return yield* sessionError("CleanupPending", true);
+		}
+	}
+	yield* store.write({
+		...saved,
+		state: "aborted",
+		events: [{
+			id: `${saved.operationId}:aborted`,
+			kind: "aborted",
+			delivered: false
+		}]
+	}, saved.revision);
+});
+
+export { abortNativeUpload, decodeNativeHandle, runNativeUpload };
+//# sourceMappingURL=native-upload.js.map

package/dist/sessions/native-upload.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-upload.js","names":[],"sources":["../../src/sessions/native-upload.ts"],"sourcesContent":["import { Effect, Redacted, Schema } from \"effect\";\n\nimport type { ResumableHandle } from \"../core/contracts/resumable.js\";\nimport { StorageError } from \"../core/errors.js\";\nimport { download } from \"../transfers/download.js\";\nimport { NativeHandle, nativeUpload } from \"../transfers/native-upload.js\";\nimport { planUpload } from \"../transfers/planner.js\";\nimport { sameChecksum } from \"../transfers/reader.js\";\nimport type { Operation } from \"../transfers/runtime.js\";\nimport type { UploadSource } from \"../transfers/sources.js\";\nimport { operationMetadataKey } from \"../transfers/upload.js\";\nimport type { UploadCheckpoint } from \"./checkpoint.js\";\nimport { sessionError } from \"./store.js\";\nimport type { UploadEnvironment } from \"./upload.js\";\nimport { fingerprint } from \"./upload.js\";\n\nconst codec = Schema.fromJsonString(Schema.toCodecJson(NativeHandle));\nexport const decodeNativeHandle = (value: Redacted.Redacted<string>) =>\n  Schema.decodeUnknownEffect(codec)(Redacted.value(value)).pipe(\n    Effect.mapError(() => sessionError(\"InvalidNativeHandle\")),\n  );\n\nexport const runNativeUpload = Effect.fnUntraced(function* <E, R>(\n  environment: UploadEnvironment,\n  original: UploadCheckpoint,\n  source: UploadSource<E, R>,\n) {\n  const { runtime, store } = environment;\n  if (original.state === \"completed\") {\n    if (!original.metadata) return yield* sessionError(\"MissingCompletionReceipt\");\n    return original.metadata;\n  }\n  if (\n    [\n      \"aborting\",\n      \"cleanup-pending\",\n      \"aborted\",\n      \"initiating\",\n      \"completing\",\n      \"completion-unknown\",\n    ].includes(original.state)\n  )\n    return yield* sessionError(\"ReconciliationRequired\", true);\n  if (\n    !original.protocol ||\n    (original.protocol === \"offset\" ? !runtime.endpoint.offsets : !runtime.endpoint.blocks)\n  )\n    return yield* sessionError(\"ChangedProtocol\");\n  let checkpoint = original;\n  const save = Effect.fnUntraced(function* (next: UploadCheckpoint) {\n    const result = yield* store.write(next, checkpoint.revision);\n    if (result.kind !== \"upload\") return yield* sessionError(\"InvalidCheckpoint\");\n    checkpoint = result;\n  });\n  const base = yield* runtime.begin(\"upload\", checkpoint.length);\n  base.progress.attempts = checkpoint.attempts;\n  // Persist each attempt before execution, including retries and verification requests.\n  const operation: Operation = {\n    ...base,\n    id: checkpoint.operationId,\n    committed: checkpoint.state === \"verifying\",\n    request: (effect) => {\n      return Effect.gen(function* () {\n        if (checkpoint.attempts >= runtime.policy.maxAttempts)\n          return yield* sessionError(\"SessionAttemptLimit\");\n        yield* save({ ...checkpoint, attempts: checkpoint.attempts + 1 });\n        return yield* base.request(effect);\n      });\n    },\n  };\n  const plan = yield* planUpload(\n    runtime.endpoint,\n    runtime.policy,\n    checkpoint.length,\n    runtime.input.digest.workspaceBytes * 2 + (source.workspaceBytes ?? 0),\n    checkpoint.protocol,\n    false,\n    checkpoint.condition,\n  );\n  if (checkpoint.partBytes !== plan.partBytes) return yield* sessionError(\"ChangedTransferPolicy\");\n  return yield* runtime\n    .deadline(\n      operation,\n      Effect.gen(function* () {\n        if (checkpoint.state !== \"verifying\") {\n          yield* runtime.lease(\n            plan.workspaceBytes,\n            Effect.scoped(\n              Effect.gen(function* () {\n                if (\n                  source.length !== checkpoint.length ||\n                  !sameChecksum(\n                    yield* fingerprint(environment, source, plan.partBytes),\n                    checkpoint.checksum,\n                  )\n                )\n                  return yield* sessionError(\"ChangedSource\");\n                const handle = checkpoint.handle\n                  ? yield* decodeNativeHandle(checkpoint.handle)\n                  : undefined;\n                if (\n                  handle &&\n                  (handle.ref.storeId !== runtime.endpoint.storage.storeId ||\n                    handle.ref.key !== checkpoint.key)\n                )\n                  return yield* sessionError(\"ForeignHandle\");\n                yield* nativeUpload(\n                  runtime,\n                  {\n                    key: checkpoint.key,\n                    source,\n                    expectedChecksum: checkpoint.checksum,\n                    ...(checkpoint.condition ? { condition: checkpoint.condition } : {}),\n                  },\n                  {\n                    ...checkpoint.headers,\n                    customMetadata: {\n                      ...checkpoint.headers.customMetadata,\n                      [operationMetadataKey]: checkpoint.operationId,\n                    },\n                  },\n                  operation,\n                  plan,\n                  {\n                    handle,\n                    blocks: checkpoint.blocks ?? [],\n                    initiating:\n                      checkpoint.state === \"created\" && checkpoint.protocol === \"offset\"\n                        ? save({ ...checkpoint, state: \"initiating\" })\n                        : Effect.void,\n                    initiated: (upload: ResumableHandle) =>\n                      Schema.encodeEffect(codec)(upload).pipe(\n                        Effect.mapError(() => sessionError(\"InvalidNativeHandle\")),\n                        Effect.flatMap((encoded) =>\n                          save({\n                            ...checkpoint,\n                            handle: Redacted.make(encoded),\n                            state: \"uploading\",\n                          }),\n                        ),\n                      ),\n                    acknowledged: (offset, block) =>\n                      save({\n                        ...checkpoint,\n                        state: \"uploading\",\n                        offset,\n                        ...(block\n                          ? {\n                              blocks: [\n                                ...(checkpoint.blocks ?? []).filter(\n                                  (saved) => saved.blockId !== block.blockId,\n                                ),\n                                block,\n                              ],\n                            }\n                          : {}),\n                      }),\n                    completing: Effect.suspend(() => save({ ...checkpoint, state: \"completing\" })),\n                    committed: (metadata) => save({ ...checkpoint, state: \"verifying\", metadata }),\n                  },\n                ).pipe(\n                  Effect.catch((error) =>\n                    Effect.gen(function* () {\n                      if (\n                        error instanceof StorageError &&\n                        error.mutationOutcome === \"rejected\" &&\n                        checkpoint.state === \"completing\"\n                      )\n                        yield* save({ ...checkpoint, state: \"uploading\" });\n                      return yield* Effect.fail(error);\n                    }),\n                  ),\n                );\n              }),\n            ),\n          );\n        }\n        const metadata = checkpoint.metadata;\n        if (!metadata) return yield* sessionError(\"MissingCompletionReceipt\");\n        operation.committed = true;\n        base.committed = true;\n        const verified = yield* download(\n          runtime,\n          {\n            ref: metadata.ref,\n            expectedChecksum: checkpoint.checksum,\n            target: { write: () => Effect.void },\n          },\n          operation,\n          metadata,\n        );\n        yield* save({\n          ...checkpoint,\n          state: \"completed\",\n          metadata: verified.metadata,\n          events: [\n            { id: `${checkpoint.operationId}:completed`, kind: \"completed\", delivered: false },\n          ],\n        });\n        return verified.metadata;\n      }),\n    )\n    .pipe(\n      Effect.mapError((error) =>\n        error instanceof StorageError && operation.committed\n          ? new StorageError({ ...error, mutationOutcome: \"succeeded\" })\n          : error,\n      ),\n    );\n});\n\nexport const abortNativeUpload = Effect.fnUntraced(function* (\n  environment: UploadEnvironment,\n  original: UploadCheckpoint,\n) {\n  if (original.state === \"aborted\") return;\n  if (\n    [\"completed\", \"verifying\", \"completing\", \"completion-unknown\", \"initiating\"].includes(\n      original.state,\n    )\n  )\n    return yield* sessionError(\"ReconciliationRequired\", true);\n  const { runtime, store } = environment;\n  const saved = yield* store.write({ ...original, state: \"aborting\" }, original.revision);\n  if (saved.kind !== \"upload\") return yield* sessionError(\"InvalidCheckpoint\");\n  if (saved.protocol === \"offset\" && saved.handle) {\n    const handle = yield* decodeNativeHandle(saved.handle);\n    if (\n      handle.ref.storeId !== runtime.endpoint.storage.storeId ||\n      handle.ref.key !== saved.key ||\n      !runtime.endpoint.offsets\n    )\n      return yield* sessionError(\"ForeignHandle\");\n    const result = yield* runtime\n      .cleanupRequest(runtime.endpoint.offsets.cancel(handle))\n      .pipe(Effect.timeout(runtime.policy.cleanupTimeoutMillis), Effect.result);\n    if (result._tag === \"Failure\") {\n      yield* store.write({ ...saved, state: \"cleanup-pending\" }, saved.revision);\n      return yield* sessionError(\"CleanupPending\", true);\n    }\n  }\n  // Azure has no block-specific cancellation. Abandon only this session's IDs; native expiry owns cleanup.\n  yield* store.write(\n    {\n      ...saved,\n      state: \"aborted\",\n      events: [{ id: `${saved.operationId}:aborted`, kind: \"aborted\", delivered: false }],\n    },\n    saved.revision,\n  );\n});\n"],"mappings":"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"}

package/dist/sessions/store.d.ts

@@ -0,0 +1,40 @@
+import { StorageError } from "../core/errors.js";
+import { SessionCheckpoint } from "./checkpoint.js";
+import { Context, Effect, Layer, Redacted } from "effect";
+import { KeyValueStore } from "effect/persistence";
+export interface CheckpointProtection {
+  readonly seal: (plaintext: string, associatedData: string) => Effect.Effect<Redacted.Redacted<string>, StorageError>;
+  readonly open: (ciphertext: Redacted.Redacted<string>, associatedData: string) => Effect.Effect<string, StorageError>;
+}
+/** Implementations must exclude every competing owner for the entire supplied effect. */
+export interface SessionOwnership {
+  readonly withExclusive: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | StorageError, R>;
+}
+export interface SessionStoreOptions {
+  readonly namespace: string;
+  readonly protection: CheckpointProtection;
+  /** A promise by the application: no other process accesses this namespace concurrently. */
+  readonly ownership: "exclusive" | SessionOwnership;
+  readonly maximumCheckpointBytes?: number;
+}
+declare const UploadSessionStore_base: Context.ServiceClass<UploadSessionStore, "@effect-kit/storage/UploadSessionStore", {
+  readonly namespace: string;
+  readonly exclusive: SessionOwnership["withExclusive"];
+  readonly read: (id: string) => Effect.Effect<SessionCheckpoint | undefined, StorageError>;
+  readonly remove: (id: string, revision: number) => Effect.Effect<void, StorageError>;
+  /** Engine-internal: call only inside exclusive ownership. Revision is checked under that ownership. */
+  readonly write: (checkpoint: SessionCheckpoint, expectedRevision: number | undefined) => Effect.Effect<SessionCheckpoint, StorageError>;
+}>;
+export declare class UploadSessionStore extends UploadSessionStore_base {
+  static readonly make: (options: SessionStoreOptions) => Effect.Effect<{
+    readonly namespace: string;
+    readonly exclusive: SessionOwnership["withExclusive"];
+    readonly read: (id: string) => Effect.Effect<SessionCheckpoint | undefined, StorageError>;
+    readonly remove: (id: string, revision: number) => Effect.Effect<void, StorageError>;
+    /** Engine-internal: call only inside exclusive ownership. Revision is checked under that ownership. */
+    readonly write: (checkpoint: SessionCheckpoint, expectedRevision: number | undefined) => Effect.Effect<SessionCheckpoint, StorageError>;
+  }, StorageError, KeyValueStore.KeyValueStore>;
+  static layer(options: SessionStoreOptions): Layer.Layer<UploadSessionStore, StorageError, KeyValueStore.KeyValueStore>;
+}
+export {};
+//# sourceMappingURL=store.d.ts.map

package/dist/sessions/store.js

@@ -0,0 +1,77 @@
+import { storageError } from "../core/errors.js";
+import { SessionCheckpoint, SessionId } from "./checkpoint.js";
+import { Clock, Context, Effect, Layer, Redacted, Schema, Semaphore } from "effect";
+import { KeyValueStore } from "effect/persistence";
+
+// src/sessions/store.ts
+const sessionError = (code, unknown = false) => storageError("sessions", "session", {
+	_tag: "ProviderFailure",
+	code
+}, unknown ? "unknown" : "not-started");
+const locks = /* @__PURE__ */ new WeakMap();
+const ProtectedRecord = Schema.Struct({
+	version: Schema.Literal(1),
+	ciphertext: Schema.Redacted(Schema.String)
+});
+const json = Schema.toCodecJson(SessionCheckpoint);
+const envelope = Schema.toCodecJson(ProtectedRecord);
+var UploadSessionStore = class UploadSessionStore extends Context.Service()("@effect-kit/storage/UploadSessionStore") {
+	static make = Effect.fnUntraced(function* (options) {
+		const kvs = yield* KeyValueStore.KeyValueStore;
+		yield* Schema.decodeUnknownEffect(SessionId)(options.namespace).pipe(Effect.mapError(() => sessionError("InvalidNamespace")));
+		const maximum = options.maximumCheckpointBytes ?? 33554432;
+		if (!Number.isSafeInteger(maximum) || maximum < 1 || !options.ownership) return yield* sessionError("InvalidStorePolicy");
+		let lock = locks.get(kvs);
+		if (!lock) {
+			lock = Semaphore.makeUnsafe(1);
+			locks.set(kvs, lock);
+		}
+		const mutex = lock;
+		const envelopes = KeyValueStore.toSchemaStore(kvs, envelope);
+		const keyFor = (id) => `${options.namespace}:${id}`;
+		const read = Effect.fnUntraced(function* (id) {
+			yield* Schema.decodeUnknownEffect(SessionId)(id).pipe(Effect.mapError(() => sessionError("InvalidSessionId")));
+			const record = yield* envelopes.get(keyFor(id)).pipe(Effect.mapError(() => sessionError("CheckpointRead")));
+			if (record._tag === "None") return void 0;
+			if (Redacted.value(record.value.ciphertext).length > maximum * 2 + 4096) return yield* sessionError("CheckpointLimit");
+			const text = yield* options.protection.open(record.value.ciphertext, keyFor(id));
+			if (new TextEncoder().encode(text).length > maximum) return yield* sessionError("CheckpointLimit");
+			const checkpoint = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(json))(text).pipe(Effect.mapError(() => sessionError("InvalidCheckpoint")));
+			if (checkpoint.id !== id || checkpoint.namespace !== options.namespace) return yield* sessionError("ForeignCheckpoint");
+			return checkpoint;
+		});
+		return UploadSessionStore.of({
+			namespace: options.namespace,
+			exclusive: (effect) => mutex.withPermit(options.ownership === "exclusive" ? effect : options.ownership.withExclusive(effect)),
+			read,
+			remove: Effect.fnUntraced(function* (id, revision) {
+				const previous = yield* read(id);
+				if (!previous || previous.revision !== revision) return yield* sessionError("RevisionConflict");
+				yield* envelopes.remove(keyFor(id)).pipe(Effect.uninterruptible, Effect.mapError(() => sessionError("CheckpointDelete")));
+			}),
+			write: Effect.fnUntraced(function* (checkpoint, expectedRevision) {
+				if (checkpoint.namespace !== options.namespace) return yield* sessionError("ForeignCheckpoint");
+				if ((yield* read(checkpoint.id))?.revision !== expectedRevision) return yield* sessionError("RevisionConflict");
+				const updated = {
+					...checkpoint,
+					revision: (expectedRevision ?? -1) + 1,
+					updatedAt: yield* Clock.currentTimeMillis
+				};
+				const text = yield* Schema.encodeEffect(Schema.fromJsonString(json))(updated).pipe(Effect.mapError(() => sessionError("InvalidCheckpoint")));
+				if (new TextEncoder().encode(text).length > maximum) return yield* sessionError("CheckpointLimit");
+				const ciphertext = yield* options.protection.seal(text, keyFor(checkpoint.id));
+				yield* envelopes.set(keyFor(checkpoint.id), {
+					version: 1,
+					ciphertext
+				}).pipe(Effect.uninterruptible, Effect.mapError(() => sessionError("CheckpointWrite")));
+				return updated;
+			})
+		});
+	});
+	static layer(options) {
+		return Layer.effect(UploadSessionStore, UploadSessionStore.make(options));
+	}
+};
+
+export { UploadSessionStore, sessionError };
+//# sourceMappingURL=store.js.map

package/dist/sessions/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","names":[],"sources":["../../src/sessions/store.ts"],"sourcesContent":["import { Clock, Context, Effect, Layer, Redacted, Schema, Semaphore } from \"effect\";\nimport { KeyValueStore } from \"effect/persistence\";\n\nimport type { StorageError } from \"../core/errors.js\";\nimport { storageError } from \"../core/errors.js\";\nimport { SessionCheckpoint, SessionId } from \"./checkpoint.js\";\n\nexport const sessionError = (code: string, unknown = false) =>\n  storageError(\n    \"sessions\",\n    \"session\",\n    { _tag: \"ProviderFailure\", code },\n    unknown ? \"unknown\" : \"not-started\",\n  );\n\nexport interface CheckpointProtection {\n  readonly seal: (\n    plaintext: string,\n    associatedData: string,\n  ) => Effect.Effect<Redacted.Redacted<string>, StorageError>;\n  readonly open: (\n    ciphertext: Redacted.Redacted<string>,\n    associatedData: string,\n  ) => Effect.Effect<string, StorageError>;\n}\n/** Implementations must exclude every competing owner for the entire supplied effect. */\nexport interface SessionOwnership {\n  readonly withExclusive: <A, E, R>(\n    effect: Effect.Effect<A, E, R>,\n  ) => Effect.Effect<A, E | StorageError, R>;\n}\nexport interface SessionStoreOptions {\n  readonly namespace: string;\n  readonly protection: CheckpointProtection;\n  /** A promise by the application: no other process accesses this namespace concurrently. */\n  readonly ownership: \"exclusive\" | SessionOwnership;\n  readonly maximumCheckpointBytes?: number;\n}\nconst locks = new WeakMap<KeyValueStore.KeyValueStore, Semaphore.Semaphore>();\nconst ProtectedRecord = Schema.Struct({\n  version: Schema.Literal(1),\n  ciphertext: Schema.Redacted(Schema.String),\n});\nconst json = Schema.toCodecJson(SessionCheckpoint);\nconst envelope = Schema.toCodecJson(ProtectedRecord);\n\nexport class UploadSessionStore extends Context.Service<\n  UploadSessionStore,\n  {\n    readonly namespace: string;\n    readonly exclusive: SessionOwnership[\"withExclusive\"];\n    readonly read: (id: string) => Effect.Effect<SessionCheckpoint | undefined, StorageError>;\n    readonly remove: (id: string, revision: number) => Effect.Effect<void, StorageError>;\n    /** Engine-internal: call only inside exclusive ownership. Revision is checked under that ownership. */\n    readonly write: (\n      checkpoint: SessionCheckpoint,\n      expectedRevision: number | undefined,\n    ) => Effect.Effect<SessionCheckpoint, StorageError>;\n  }\n>()(\"@effect-kit/storage/UploadSessionStore\") {\n  static readonly make = Effect.fnUntraced(function* (options: SessionStoreOptions) {\n    const kvs = yield* KeyValueStore.KeyValueStore;\n    yield* Schema.decodeUnknownEffect(SessionId)(options.namespace).pipe(\n      Effect.mapError(() => sessionError(\"InvalidNamespace\")),\n    );\n    const maximum = options.maximumCheckpointBytes ?? 32 * 1024 * 1024;\n    if (!Number.isSafeInteger(maximum) || maximum < 1 || !options.ownership)\n      return yield* sessionError(\"InvalidStorePolicy\");\n    let lock = locks.get(kvs);\n    if (!lock) {\n      lock = Semaphore.makeUnsafe(1);\n      locks.set(kvs, lock);\n    }\n    const mutex = lock;\n    const envelopes = KeyValueStore.toSchemaStore(kvs, envelope);\n    const keyFor = (id: string) => `${options.namespace}:${id}`;\n    const read = Effect.fnUntraced(function* (id: string) {\n      yield* Schema.decodeUnknownEffect(SessionId)(id).pipe(\n        Effect.mapError(() => sessionError(\"InvalidSessionId\")),\n      );\n      const record = yield* envelopes\n        .get(keyFor(id))\n        .pipe(Effect.mapError(() => sessionError(\"CheckpointRead\")));\n      if (record._tag === \"None\") return undefined;\n      if (Redacted.value(record.value.ciphertext).length > maximum * 2 + 4096)\n        return yield* sessionError(\"CheckpointLimit\");\n      const text = yield* options.protection.open(record.value.ciphertext, keyFor(id));\n      if (new TextEncoder().encode(text).length > maximum)\n        return yield* sessionError(\"CheckpointLimit\");\n      const checkpoint = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(json))(text).pipe(\n        Effect.mapError(() => sessionError(\"InvalidCheckpoint\")),\n      );\n      if (checkpoint.id !== id || checkpoint.namespace !== options.namespace)\n        return yield* sessionError(\"ForeignCheckpoint\");\n      return checkpoint;\n    });\n    return UploadSessionStore.of({\n      namespace: options.namespace,\n      exclusive: (effect) =>\n        mutex.withPermit(\n          options.ownership === \"exclusive\" ? effect : options.ownership.withExclusive(effect),\n        ),\n      read,\n      remove: Effect.fnUntraced(function* (id, revision) {\n        const previous = yield* read(id);\n        if (!previous || previous.revision !== revision)\n          return yield* sessionError(\"RevisionConflict\");\n        yield* envelopes.remove(keyFor(id)).pipe(\n          Effect.uninterruptible,\n          Effect.mapError(() => sessionError(\"CheckpointDelete\")),\n        );\n      }),\n      write: Effect.fnUntraced(function* (checkpoint, expectedRevision) {\n        if (checkpoint.namespace !== options.namespace)\n          return yield* sessionError(\"ForeignCheckpoint\");\n        const previous = yield* read(checkpoint.id);\n        if (previous?.revision !== expectedRevision) return yield* sessionError(\"RevisionConflict\");\n        const updated = {\n          ...checkpoint,\n          revision: (expectedRevision ?? -1) + 1,\n          updatedAt: yield* Clock.currentTimeMillis,\n        };\n        const text = yield* Schema.encodeEffect(Schema.fromJsonString(json))(updated).pipe(\n          Effect.mapError(() => sessionError(\"InvalidCheckpoint\")),\n        );\n        if (new TextEncoder().encode(text).length > maximum)\n          return yield* sessionError(\"CheckpointLimit\");\n        const ciphertext = yield* options.protection.seal(text, keyFor(checkpoint.id));\n        yield* envelopes.set(keyFor(checkpoint.id), { version: 1, ciphertext }).pipe(\n          Effect.uninterruptible,\n          Effect.mapError(() => sessionError(\"CheckpointWrite\")),\n        );\n        return updated;\n      }),\n    });\n  });\n\n  static layer(options: SessionStoreOptions) {\n    return Layer.effect(UploadSessionStore, UploadSessionStore.make(options));\n  }\n}\n"],"mappings":"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"}

package/dist/sessions/upload.d.ts

@@ -0,0 +1,10 @@
+import "../core/errors.js";
+import "../transfers/sources.js";
+import "./store.js";
+import "../transfers/runtime.js";
+import { Effect } from "effect";
+export interface SessionOptions {
+  readonly configurationId: string;
+  readonly expiresInMillis?: number;
+}
+//# sourceMappingURL=upload.d.ts.map