@effect-kit/storage 0.0.0-stage → 0.0.0

package/dist/client/atoms/controller.js

@@ -0,0 +1,267 @@
+import { failUpload } from "../../uploads/schema.js";
+import { UploadClient } from "../../client.js";
+import { idleSnapshot } from "./state.js";
+import { Cause, Effect, Exit, Fiber, Semaphore } from "effect";
+
+// src/client/atoms/controller.ts
+/** One slot per registry. The owning scope joins work on disposal, independently of subscribers. */
+const makeController = Effect.fnUntraced(function* (options, publish) {
+	const client = yield* UploadClient;
+	const scope = yield* Effect.scope;
+	const lock = yield* Semaphore.make(1);
+	let snapshot = idleSnapshot;
+	let active;
+	let file;
+	let ticket;
+	let recoveryId;
+	let closed = false;
+	let generation = 0;
+	let progressTimer;
+	let pendingProgress;
+	const clearProgress = () => {
+		if (progressTimer !== void 0) clearTimeout(progressTimer);
+		progressTimer = void 0;
+		pendingProgress = void 0;
+	};
+	const update = (patch) => {
+		snapshot = Object.freeze({
+			...snapshot,
+			...patch
+		});
+		publish(snapshot);
+	};
+	const ensureOpen = () => closed ? Effect.fail(failUpload("Conflict")) : Effect.void;
+	const stop = Effect.suspend(() => {
+		generation++;
+		clearProgress();
+		const previous = active;
+		active = void 0;
+		return previous ? Fiber.interrupt(previous) : Effect.void;
+	});
+	let resumable = false;
+	const progress = (operation) => (value) => {
+		if (operation !== generation || closed) return;
+		pendingProgress = Object.freeze({ ...value });
+		if (progressTimer !== void 0) return;
+		progressTimer = setTimeout(() => {
+			const latest = pendingProgress;
+			clearProgress();
+			if (!latest || operation !== generation || closed || !snapshot.isRunning) return;
+			const phase = latest.phase === "completed" ? snapshot.phase : latest.phase;
+			update({
+				progress: latest,
+				phase,
+				canPause: phase === "uploading" && resumable
+			});
+		}, 16);
+	};
+	const finish = (status) => {
+		const latestProgress = pendingProgress;
+		clearProgress();
+		update({
+			...latestProgress ? { progress: latestProgress } : {},
+			phase: status.state === "published" ? "completed" : status.state === "publishing" ? "publishing" : status.state === "verifying" ? "verifying" : status.state === "aborted" ? "cancelled" : status.state === "rejected" ? "failed" : "uncertain",
+			status,
+			uploadId: status.id,
+			isRunning: false,
+			canPause: false,
+			canResume: ![
+				"published",
+				"aborted",
+				"rejected"
+			].includes(status.state)
+		});
+		if ([
+			"published",
+			"aborted",
+			"rejected"
+		].includes(status.state)) file = void 0;
+	};
+	const launch = Effect.fnUntraced(function* (selected, resume, suppliedId) {
+		yield* ensureOpen();
+		if (snapshot.isRunning) return yield* failUpload("Conflict");
+		if (resume && !suppliedId && !recoveryId) return yield* failUpload("NotFound");
+		if (!resume && ![
+			"idle",
+			"completed",
+			"cancelled"
+		].includes(snapshot.phase)) return yield* failUpload("Conflict");
+		const previousId = ticket?.id ?? snapshot.uploadId ?? (suppliedId && /^[a-f0-9]{64}$/u.test(suppliedId) ? suppliedId : void 0);
+		const operation = ++generation;
+		resumable = false;
+		file = selected;
+		if (!resume) {
+			ticket = void 0;
+			recoveryId = crypto.randomUUID();
+		} else if (suppliedId) recoveryId = suppliedId;
+		const checkpoint = recoveryId;
+		if (!checkpoint) return yield* failUpload("NotFound");
+		snapshot = Object.freeze({
+			...idleSnapshot,
+			operation,
+			phase: "hashing",
+			isRunning: true,
+			...recoveryId ? { resumeId: recoveryId } : {},
+			...resume && previousId ? { uploadId: previousId } : {}
+		});
+		publish(snapshot);
+		const onProgress = progress(operation);
+		const onProtocol = (protocol, uploadId) => {
+			if (operation !== generation || closed) return;
+			clearProgress();
+			resumable = protocol === "multipart" || protocol === "resumable";
+			recoveryId = uploadId;
+			update({
+				phase: "uploading",
+				uploadId,
+				resumeId: uploadId,
+				canPause: resumable
+			});
+		};
+		const work = Effect.gen(function* () {
+			let result;
+			if (resume) result = yield* client.resume({
+				uploadId: checkpoint,
+				file: selected,
+				onProgress,
+				onProtocol
+			});
+			else {
+				ticket = yield* client.create({
+					file: selected,
+					purpose: options.purpose,
+					context: options.context,
+					idempotencyKey: checkpoint,
+					onProgress,
+					...options.strategy ? { strategy: options.strategy } : {}
+				});
+				if (operation !== generation) return;
+				const id = ticket.id;
+				if (!id) return yield* failUpload("Unavailable");
+				recoveryId = id;
+				update({
+					phase: "uploading",
+					uploadId: id,
+					resumeId: id,
+					canPause: resumable
+				});
+				const sent = yield* client.transfer({
+					uploadId: id,
+					file: selected,
+					onProgress,
+					onProtocol
+				});
+				const transferred = pendingProgress;
+				clearProgress();
+				update({
+					phase: "verifying",
+					canPause: false,
+					...transferred ? { progress: transferred } : {}
+				});
+				result = yield* client.complete({
+					...sent,
+					onProgress
+				});
+			}
+			if (operation === generation) finish(result);
+		}).pipe(Effect.onExit((exit) => Effect.sync(() => {
+			if (operation !== generation || closed) return;
+			active = void 0;
+			if (Exit.isFailure(exit)) {
+				clearProgress();
+				update({
+					phase: Cause.hasInterrupts(exit.cause) ? "paused" : "uncertain",
+					failure: exit.cause,
+					isRunning: false,
+					canPause: false,
+					canResume: true,
+					...ticket?.id ? { uploadId: ticket.id } : {}
+				});
+			}
+		})));
+		active = yield* Effect.forkIn(work, scope);
+	});
+	const serialize = (effect) => lock.withPermit(effect);
+	const close = (notify) => serialize(Effect.gen(function* () {
+		if (closed) return;
+		closed = true;
+		yield* stop;
+		file = void 0;
+		if (notify) update({
+			phase: "disposed",
+			isRunning: false,
+			canPause: false,
+			canResume: false
+		});
+	}));
+	const dispose = close(true);
+	yield* Effect.addFinalizer(() => close(false));
+	return {
+		start: (selected) => serialize(launch(selected, false)),
+		resume: (input) => serialize(launch(input.file, true, input.uploadId)),
+		retry: serialize(Effect.suspend(() => file ? launch(file, true) : Effect.fail(failUpload("NotFound")))),
+		pause: serialize(Effect.gen(function* () {
+			yield* ensureOpen();
+			if (!snapshot.canPause) return yield* failUpload("Unsupported");
+			yield* stop;
+			update({
+				phase: "paused",
+				isRunning: false,
+				canPause: false,
+				canResume: true
+			});
+		})),
+		cancel: serialize(Effect.gen(function* () {
+			yield* ensureOpen();
+			if (snapshot.phase === "completed") return yield* failUpload("Conflict");
+			yield* stop;
+			update({
+				phase: "cancelling",
+				isRunning: true,
+				canPause: false
+			});
+			const uploadId = ticket?.id ?? snapshot.uploadId;
+			if (!uploadId) {
+				update({
+					phase: recoveryId ? "uncertain" : "cancelled",
+					isRunning: false,
+					canResume: Boolean(recoveryId)
+				});
+				return;
+			}
+			yield* client.abort({ uploadId }).pipe(Effect.tap((status) => Effect.sync(() => finish(status))), Effect.onExit((exit) => Effect.sync(() => {
+				if (Exit.isFailure(exit)) update({
+					phase: "uncertain",
+					failure: exit.cause,
+					isRunning: false,
+					canResume: true
+				});
+			})));
+		})),
+		reconcile: serialize(Effect.gen(function* () {
+			yield* ensureOpen();
+			if (snapshot.isRunning) return yield* failUpload("Conflict");
+			if (!snapshot.uploadId) return yield* failUpload("NotFound");
+			const status = yield* client.reconcile({ uploadId: snapshot.uploadId });
+			finish(status);
+			return status;
+		})),
+		reset: serialize(Effect.gen(function* () {
+			yield* ensureOpen();
+			if (snapshot.isRunning) return yield* failUpload("Conflict");
+			generation++;
+			file = void 0;
+			ticket = void 0;
+			recoveryId = void 0;
+			snapshot = Object.freeze({
+				...idleSnapshot,
+				operation: generation
+			});
+			publish(snapshot);
+		})),
+		dispose
+	};
+});
+
+export { makeController };
+//# sourceMappingURL=controller.js.map

package/dist/client/atoms/controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller.js","names":[],"sources":["../../../src/client/atoms/controller.ts"],"sourcesContent":["import { Cause, Effect, Exit, Fiber, Semaphore } from \"effect\";\n\nimport { failUpload } from \"../../uploads/schema.js\";\nimport type { UploadError, UploadInput, UploadStatus } from \"../../uploads/schema.js\";\nimport { UploadClient } from \"../index.js\";\nimport type { UploadProtocol } from \"../index.js\";\nimport type { UploadTicket } from \"../store.js\";\nimport type { UploadProgress } from \"../transport.js\";\nimport { idleSnapshot } from \"./state.js\";\nimport type { UploadSnapshot } from \"./state.js\";\n\nexport interface UploadSlotOptions {\n  readonly purpose: string;\n  readonly context: Readonly<Record<string, string>>;\n  readonly strategy?: UploadInput[\"strategy\"];\n}\n\n/** One slot per registry. The owning scope joins work on disposal, independently of subscribers. */\nexport const makeController = Effect.fnUntraced(function* (\n  options: UploadSlotOptions,\n  publish: (snapshot: UploadSnapshot) => void,\n) {\n  const client = yield* UploadClient;\n  const scope = yield* Effect.scope;\n  const lock = yield* Semaphore.make(1);\n  let snapshot = idleSnapshot;\n  let active: Fiber.Fiber<void, UploadError> | undefined;\n  let file: File | undefined;\n  let ticket: UploadTicket | undefined;\n  let recoveryId: string | undefined;\n  let closed = false;\n  let generation = 0;\n  let progressTimer: ReturnType<typeof setTimeout> | undefined;\n  let pendingProgress: UploadProgress | undefined;\n  const clearProgress = () => {\n    if (progressTimer !== undefined) clearTimeout(progressTimer);\n    progressTimer = undefined;\n    pendingProgress = undefined;\n  };\n\n  const update = (patch: Partial<UploadSnapshot>) => {\n    snapshot = Object.freeze({ ...snapshot, ...patch });\n    publish(snapshot);\n  };\n  const ensureOpen = () => (closed ? Effect.fail(failUpload(\"Conflict\")) : Effect.void);\n  const stop = Effect.suspend(() => {\n    generation++;\n    clearProgress();\n    const previous = active;\n    active = undefined;\n    return previous ? Fiber.interrupt(previous) : Effect.void;\n  });\n  let resumable = false;\n  const progress = (operation: number) => (value: UploadProgress) => {\n    if (operation !== generation || closed) return;\n    pendingProgress = Object.freeze({ ...value });\n    if (progressTimer !== undefined) return;\n    progressTimer = setTimeout(() => {\n      const latest = pendingProgress;\n      clearProgress();\n      if (!latest || operation !== generation || closed || !snapshot.isRunning) return;\n      // Fingerprinting also reports completed; only server publication completes an upload.\n      const phase = latest.phase === \"completed\" ? snapshot.phase : latest.phase;\n      update({ progress: latest, phase, canPause: phase === \"uploading\" && resumable });\n    }, 16);\n  };\n  const finish = (status: UploadStatus) => {\n    const latestProgress = pendingProgress;\n    clearProgress();\n    update({\n      ...(latestProgress ? { progress: latestProgress } : {}),\n      phase:\n        status.state === \"published\"\n          ? \"completed\"\n          : status.state === \"publishing\"\n            ? \"publishing\"\n            : status.state === \"verifying\"\n              ? \"verifying\"\n              : status.state === \"aborted\"\n                ? \"cancelled\"\n                : status.state === \"rejected\"\n                  ? \"failed\"\n                  : \"uncertain\",\n      status,\n      uploadId: status.id,\n      isRunning: false,\n      canPause: false,\n      canResume: ![\"published\", \"aborted\", \"rejected\"].includes(status.state),\n    });\n    if ([\"published\", \"aborted\", \"rejected\"].includes(status.state)) file = undefined;\n  };\n  const launch = Effect.fnUntraced(function* (\n    selected: File,\n    resume: boolean,\n    suppliedId?: string,\n  ) {\n    yield* ensureOpen();\n    if (snapshot.isRunning) return yield* failUpload(\"Conflict\");\n    if (resume && !suppliedId && !recoveryId) return yield* failUpload(\"NotFound\");\n    if (!resume && ![\"idle\", \"completed\", \"cancelled\"].includes(snapshot.phase))\n      return yield* failUpload(\"Conflict\");\n    const previousId =\n      ticket?.id ??\n      snapshot.uploadId ??\n      (suppliedId && /^[a-f0-9]{64}$/u.test(suppliedId) ? suppliedId : undefined);\n    const operation = ++generation;\n    resumable = false;\n    file = selected;\n    if (!resume) {\n      ticket = undefined;\n      recoveryId = crypto.randomUUID();\n    } else if (suppliedId) recoveryId = suppliedId;\n    const checkpoint = recoveryId;\n    if (!checkpoint) return yield* failUpload(\"NotFound\");\n    snapshot = Object.freeze({\n      ...idleSnapshot,\n      operation,\n      phase: \"hashing\",\n      isRunning: true,\n      ...(recoveryId ? { resumeId: recoveryId } : {}),\n      ...(resume && previousId ? { uploadId: previousId } : {}),\n    });\n    publish(snapshot);\n    const onProgress = progress(operation);\n    const onProtocol = (protocol: UploadProtocol, uploadId: string) => {\n      if (operation !== generation || closed) return;\n      clearProgress();\n      resumable = protocol === \"multipart\" || protocol === \"resumable\";\n      recoveryId = uploadId;\n      update({ phase: \"uploading\", uploadId, resumeId: uploadId, canPause: resumable });\n    };\n    const work = Effect.gen(function* () {\n      let result: UploadStatus;\n      if (resume) {\n        result = yield* client.resume({\n          uploadId: checkpoint,\n          file: selected,\n          onProgress,\n          onProtocol,\n        });\n      } else {\n        ticket = yield* client.create({\n          file: selected,\n          purpose: options.purpose,\n          context: options.context,\n          idempotencyKey: checkpoint,\n          onProgress,\n          ...(options.strategy ? { strategy: options.strategy } : {}),\n        });\n        if (operation !== generation) return;\n        const id = ticket.id;\n        if (!id) return yield* failUpload(\"Unavailable\");\n        recoveryId = id;\n        update({ phase: \"uploading\", uploadId: id, resumeId: id, canPause: resumable });\n        const sent = yield* client.transfer({\n          uploadId: id,\n          file: selected,\n          onProgress,\n          onProtocol,\n        });\n        const transferred = pendingProgress;\n        clearProgress();\n        update({\n          phase: \"verifying\",\n          canPause: false,\n          ...(transferred ? { progress: transferred } : {}),\n        });\n        result = yield* client.complete({ ...sent, onProgress });\n      }\n      if (operation === generation) finish(result);\n    }).pipe(\n      Effect.onExit((exit) =>\n        Effect.sync(() => {\n          if (operation !== generation || closed) return;\n          active = undefined;\n          if (Exit.isFailure(exit)) {\n            clearProgress();\n            update({\n              phase: Cause.hasInterrupts(exit.cause) ? \"paused\" : \"uncertain\",\n              failure: exit.cause,\n              isRunning: false,\n              canPause: false,\n              canResume: true,\n              ...(ticket?.id ? { uploadId: ticket.id } : {}),\n            });\n          }\n        }),\n      ),\n    );\n    active = yield* Effect.forkIn(work, scope);\n  });\n  const serialize = <A, E>(effect: Effect.Effect<A, E>) => lock.withPermit(effect);\n  const close = (notify: boolean) =>\n    serialize(\n      Effect.gen(function* () {\n        if (closed) return;\n        closed = true;\n        yield* stop;\n        file = undefined;\n        if (notify)\n          update({ phase: \"disposed\", isRunning: false, canPause: false, canResume: false });\n      }),\n    );\n  const dispose = close(true);\n  // Registry teardown has already invalidated its nodes; finalization must not republish.\n  yield* Effect.addFinalizer(() => close(false));\n\n  return {\n    start: (selected: File) => serialize(launch(selected, false)),\n    resume: (input: { readonly file: File; readonly uploadId?: string }) =>\n      serialize(launch(input.file, true, input.uploadId)),\n    retry: serialize(\n      Effect.suspend(() => (file ? launch(file, true) : Effect.fail(failUpload(\"NotFound\")))),\n    ),\n    pause: serialize(\n      Effect.gen(function* () {\n        yield* ensureOpen();\n        if (!snapshot.canPause) return yield* failUpload(\"Unsupported\");\n        yield* stop;\n        update({ phase: \"paused\", isRunning: false, canPause: false, canResume: true });\n      }),\n    ),\n    cancel: serialize(\n      Effect.gen(function* () {\n        yield* ensureOpen();\n        if (snapshot.phase === \"completed\") return yield* failUpload(\"Conflict\");\n        yield* stop;\n        update({ phase: \"cancelling\", isRunning: true, canPause: false });\n        const uploadId = ticket?.id ?? snapshot.uploadId;\n        if (!uploadId) {\n          update({\n            phase: recoveryId ? \"uncertain\" : \"cancelled\",\n            isRunning: false,\n            canResume: Boolean(recoveryId),\n          });\n          return;\n        }\n        yield* client.abort({ uploadId }).pipe(\n          Effect.tap((status) => Effect.sync(() => finish(status))),\n          Effect.onExit((exit) =>\n            Effect.sync(() => {\n              if (Exit.isFailure(exit))\n                update({\n                  phase: \"uncertain\",\n                  failure: exit.cause,\n                  isRunning: false,\n                  canResume: true,\n                });\n            }),\n          ),\n        );\n      }),\n    ),\n    reconcile: serialize(\n      Effect.gen(function* () {\n        yield* ensureOpen();\n        if (snapshot.isRunning) return yield* failUpload(\"Conflict\");\n        if (!snapshot.uploadId) return yield* failUpload(\"NotFound\");\n        const status = yield* client.reconcile({ uploadId: snapshot.uploadId });\n        finish(status);\n        return status;\n      }),\n    ),\n    reset: serialize(\n      Effect.gen(function* () {\n        yield* ensureOpen();\n        if (snapshot.isRunning) return yield* failUpload(\"Conflict\");\n        generation++;\n        file = undefined;\n        ticket = undefined;\n        recoveryId = undefined;\n        snapshot = Object.freeze({ ...idleSnapshot, operation: generation });\n        publish(snapshot);\n      }),\n    ),\n    dispose,\n  };\n});\n"],"mappings":"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"}

package/dist/client/atoms/state.d.ts

@@ -0,0 +1,17 @@
+import { UploadError, UploadStatus } from "../../uploads/schema.js";
+import { UploadProgress } from "../transport.js";
+import { Cause } from "effect";
+export type UploadPhase = "idle" | "hashing" | "authorizing" | "uploading" | "verifying" | "publishing" | "completed" | "paused" | "cancelling" | "cancelled" | "failed" | "uncertain" | "disposed";
+export interface UploadSnapshot {
+  readonly phase: UploadPhase;
+  readonly operation: number;
+  readonly uploadId?: string;
+  readonly resumeId?: string;
+  readonly progress?: UploadProgress;
+  readonly status?: UploadStatus;
+  readonly failure?: Cause.Cause<UploadError>;
+  readonly canPause: boolean;
+  readonly canResume: boolean;
+  readonly isRunning: boolean;
+}
+//# sourceMappingURL=state.d.ts.map

package/dist/client/atoms/state.js

@@ -0,0 +1,11 @@
+// src/client/atoms/state.ts
+const idleSnapshot = Object.freeze({
+	phase: "idle",
+	operation: 0,
+	canPause: false,
+	canResume: false,
+	isRunning: false
+});
+
+export { idleSnapshot };
+//# sourceMappingURL=state.js.map

package/dist/client/atoms/state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.js","names":[],"sources":["../../../src/client/atoms/state.ts"],"sourcesContent":["import type { Cause } from \"effect\";\n\nimport type { UploadError, UploadStatus } from \"../../uploads/schema.js\";\nimport type { UploadProgress } from \"../transport.js\";\n\nexport type UploadPhase =\n  | \"idle\"\n  | \"hashing\"\n  | \"authorizing\"\n  | \"uploading\"\n  | \"verifying\"\n  | \"publishing\"\n  | \"completed\"\n  | \"paused\"\n  | \"cancelling\"\n  | \"cancelled\"\n  | \"failed\"\n  | \"uncertain\"\n  | \"disposed\";\n\nexport interface UploadSnapshot {\n  readonly phase: UploadPhase;\n  readonly operation: number;\n  readonly uploadId?: string;\n  readonly resumeId?: string;\n  readonly progress?: UploadProgress;\n  readonly status?: UploadStatus;\n  readonly failure?: Cause.Cause<UploadError>;\n  readonly canPause: boolean;\n  readonly canResume: boolean;\n  readonly isRunning: boolean;\n}\n\nexport const idleSnapshot: UploadSnapshot = Object.freeze({\n  phase: \"idle\",\n  operation: 0,\n  canPause: false,\n  canResume: false,\n  isRunning: false,\n});\n"],"mappings":";AAiCA,MAAa,eAA+B,OAAO,OAAO;CACxD,OAAO;CACP,WAAW;CACX,UAAU;CACV,WAAW;CACX,WAAW;AACb,CAAC"}

package/dist/client/atoms.d.ts

@@ -0,0 +1,59 @@
+import { UploadError } from "../uploads/schema.js";
+import { UploadProgress } from "./transport.js";
+import { UploadClient } from "../client.js";
+import { UploadPhase, UploadSnapshot } from "./atoms/state.js";
+import { UploadSlotOptions } from "./atoms/controller.js";
+import { Effect, Layer } from "effect";
+import { AsyncResult, Atom } from "effect/reactivity";
+export interface UploadAtomsOptions<E = never> extends UploadSlotOptions {
+  readonly layer: Layer.Layer<UploadClient, E>;
+}
+/** Stable definitions; state and resources are isolated by the application's AtomRegistry. */
+declare const make: <E>(options: UploadAtomsOptions<E>) => {
+  state: Atom.Writable<UploadSnapshot, UploadSnapshot>;
+  progress: Atom.Writable<UploadProgress | undefined, UploadSnapshot>;
+  initialization: Atom.Atom<AsyncResult.AsyncResult<{
+    start: (selected: File) => Effect.Effect<undefined, UploadError, never>;
+    resume: (input: {
+      readonly file: File;
+      readonly uploadId?: string;
+    }) => Effect.Effect<undefined, UploadError, never>;
+    retry: Effect.Effect<undefined, UploadError, never>;
+    pause: Effect.Effect<undefined, UploadError, never>;
+    cancel: Effect.Effect<undefined, UploadError, never>;
+    reconcile: Effect.Effect<{
+      readonly version: 1;
+      readonly id: string;
+      readonly state: "aborted" | "initiating" | "published" | "publishing" | "ready" | "rejected" | "reserving" | "uploading" | "verifying";
+      readonly expiresAt: number;
+      readonly cleanupPending: boolean;
+      readonly result?: unknown;
+    }, UploadError, never>;
+    reset: Effect.Effect<undefined, UploadError, never>;
+    dispose: Effect.Effect<void, never, never>;
+  }, E>>;
+  start: Atom.AtomResultFn<File, undefined, E | UploadError>;
+  resume: Atom.AtomResultFn<{
+    readonly file: File;
+    readonly uploadId?: string;
+  }, undefined, E | UploadError>;
+  pause: Atom.AtomResultFn<void, undefined, E | UploadError>;
+  cancel: Atom.AtomResultFn<void, undefined, E | UploadError>;
+  retry: Atom.AtomResultFn<void, undefined, E | UploadError>;
+  reconcile: Atom.AtomResultFn<void, {
+    readonly version: 1;
+    readonly id: string;
+    readonly state: "aborted" | "initiating" | "published" | "publishing" | "ready" | "rejected" | "reserving" | "uploading" | "verifying";
+    readonly expiresAt: number;
+    readonly cleanupPending: boolean;
+    readonly result?: unknown;
+  }, E | UploadError>;
+  reset: Atom.AtomResultFn<void, undefined, E | UploadError>;
+  dispose: Atom.AtomResultFn<void, void, E>;
+};
+export declare const UploadAtoms: {
+  make: typeof make;
+};
+export type UploadAtomSet<E = never> = ReturnType<typeof make<E>>;
+export type { UploadPhase, UploadSlotOptions, UploadSnapshot };
+//# sourceMappingURL=atoms.d.ts.map

package/dist/client/atoms.js

@@ -0,0 +1,39 @@
+import { idleSnapshot } from "./atoms/state.js";
+import { makeController } from "./atoms/controller.js";
+import { Effect } from "effect";
+import { AsyncResult, Atom } from "effect/reactivity";
+
+// src/client/atoms/index.ts
+/** Stable definitions; state and resources are isolated by the application's AtomRegistry. */
+const make = (options) => {
+	const runtime = Atom.runtime(options.layer);
+	const initial = AsyncResult.initial();
+	const slot = {
+		purpose: options.purpose,
+		context: Object.freeze({ ...options.context }),
+		...options.strategy ? { strategy: options.strategy } : {}
+	};
+	const writable = Atom.make(idleSnapshot).pipe(Atom.keepAlive);
+	const state = Atom.map(writable, (snapshot) => snapshot).pipe(Atom.withServerValue(() => idleSnapshot));
+	const controller = runtime.atom((get) => makeController(slot, (snapshot) => {
+		get.registry.set(writable, snapshot);
+	})).pipe(Atom.keepAlive, Atom.withServerValue(() => initial));
+	const command = (run) => runtime.fn((input, get) => Effect.flatMap(get.result(controller), (service) => run(service, input)), { concurrent: true }).pipe(Atom.withServerValue(() => initial));
+	return {
+		state,
+		progress: Atom.map(state, (snapshot) => snapshot.progress),
+		initialization: controller,
+		start: command((service, file) => service.start(file)),
+		resume: command((service, input) => service.resume(input)),
+		pause: command((service, _input) => service.pause),
+		cancel: command((service, _input) => service.cancel),
+		retry: command((service, _input) => service.retry),
+		reconcile: command((service, _input) => service.reconcile),
+		reset: command((service, _input) => service.reset),
+		dispose: command((service, _input) => service.dispose)
+	};
+};
+const UploadAtoms = { make };
+
+export { UploadAtoms };
+//# sourceMappingURL=atoms.js.map

package/dist/client/atoms.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"atoms.js","names":[],"sources":["../../src/client/atoms/index.ts"],"sourcesContent":["import { Effect } from \"effect\";\nimport type { Layer } from \"effect\";\nimport { AsyncResult, Atom } from \"effect/reactivity\";\n\nimport type { UploadClient } from \"../index.js\";\nimport { makeController } from \"./controller.js\";\nimport type { UploadSlotOptions } from \"./controller.js\";\nimport { idleSnapshot } from \"./state.js\";\nimport type { UploadSnapshot } from \"./state.js\";\n\nexport type { UploadPhase, UploadSnapshot } from \"./state.js\";\nexport type { UploadSlotOptions } from \"./controller.js\";\n\nexport interface UploadAtomsOptions<E = never> extends UploadSlotOptions {\n  readonly layer: Layer.Layer<UploadClient, E>;\n}\n\n/** Stable definitions; state and resources are isolated by the application's AtomRegistry. */\nconst make = <E>(options: UploadAtomsOptions<E>) => {\n  const runtime = Atom.runtime(options.layer);\n  const initial = AsyncResult.initial();\n  const slot = {\n    purpose: options.purpose,\n    context: Object.freeze({ ...options.context }),\n    ...(options.strategy ? { strategy: options.strategy } : {}),\n  };\n  const writable = Atom.make<UploadSnapshot>(idleSnapshot).pipe(Atom.keepAlive);\n  const state = Atom.map(writable, (snapshot) => snapshot).pipe(\n    Atom.withServerValue(() => idleSnapshot),\n  );\n  const controller = runtime\n    .atom((get) =>\n      makeController(slot, (snapshot) => {\n        get.registry.set(writable, snapshot);\n      }),\n    )\n    .pipe(\n      Atom.keepAlive,\n      Atom.withServerValue(() => initial),\n    );\n\n  type Controller = Effect.Success<ReturnType<typeof makeController>>;\n  const command = <Input, A, Error>(\n    run: (service: Controller, input: Input) => Effect.Effect<A, Error>,\n  ) =>\n    runtime\n      .fn(\n        (input: Input, get) =>\n          Effect.flatMap(get.result(controller), (service) => run(service, input)),\n        { concurrent: true },\n      )\n      .pipe(Atom.withServerValue(() => initial));\n\n  return {\n    state,\n    progress: Atom.map(state, (snapshot) => snapshot.progress),\n    initialization: controller,\n    start: command((service, file: File) => service.start(file)),\n    resume: command((service, input: { readonly file: File; readonly uploadId?: string }) =>\n      service.resume(input),\n    ),\n    pause: command((service, _input: void) => service.pause),\n    cancel: command((service, _input: void) => service.cancel),\n    retry: command((service, _input: void) => service.retry),\n    reconcile: command((service, _input: void) => service.reconcile),\n    reset: command((service, _input: void) => service.reset),\n    dispose: command((service, _input: void) => service.dispose),\n  };\n};\n\nexport const UploadAtoms = { make };\nexport type UploadAtomSet<E = never> = ReturnType<typeof make<E>>;\n"],"mappings":";;;;;;;AAkBA,MAAM,QAAW,YAAmC;CAClD,MAAM,UAAU,KAAK,QAAQ,QAAQ,KAAK;CAC1C,MAAM,UAAU,YAAY,QAAQ;CACpC,MAAM,OAAO;EACX,SAAS,QAAQ;EACjB,SAAS,OAAO,OAAO,EAAE,GAAG,QAAQ,QAAQ,CAAC;EAC7C,GAAI,QAAQ,WAAW,EAAE,UAAU,QAAQ,SAAS,IAAI,CAAC;CAC3D;CACA,MAAM,WAAW,KAAK,KAAqB,YAAY,CAAC,CAAC,KAAK,KAAK,SAAS;CAC5E,MAAM,QAAQ,KAAK,IAAI,WAAW,aAAa,QAAQ,CAAC,CAAC,KACvD,KAAK,sBAAsB,YAAY,CACzC;CACA,MAAM,aAAa,QAChB,MAAM,QACL,eAAe,OAAO,aAAa;EACjC,IAAI,SAAS,IAAI,UAAU,QAAQ;CACrC,CAAC,CACH,CAAC,CACA,KACC,KAAK,WACL,KAAK,sBAAsB,OAAO,CACpC;CAGF,MAAM,WACJ,QAEA,QACG,IACE,OAAc,QACb,OAAO,QAAQ,IAAI,OAAO,UAAU,IAAI,YAAY,IAAI,SAAS,KAAK,CAAC,GACzE,EAAE,YAAY,KAAK,CACrB,CAAC,CACA,KAAK,KAAK,sBAAsB,OAAO,CAAC;CAE7C,OAAO;EACL;EACA,UAAU,KAAK,IAAI,QAAQ,aAAa,SAAS,QAAQ;EACzD,gBAAgB;EAChB,OAAO,SAAS,SAAS,SAAe,QAAQ,MAAM,IAAI,CAAC;EAC3D,QAAQ,SAAS,SAAS,UACxB,QAAQ,OAAO,KAAK,CACtB;EACA,OAAO,SAAS,SAAS,WAAiB,QAAQ,KAAK;EACvD,QAAQ,SAAS,SAAS,WAAiB,QAAQ,MAAM;EACzD,OAAO,SAAS,SAAS,WAAiB,QAAQ,KAAK;EACvD,WAAW,SAAS,SAAS,WAAiB,QAAQ,SAAS;EAC/D,OAAO,SAAS,SAAS,WAAiB,QAAQ,KAAK;EACvD,SAAS,SAAS,SAAS,WAAiB,QAAQ,OAAO;CAC7D;AACF;AAEA,MAAa,cAAc,EAAE,KAAK"}

package/dist/client/fingerprint.js

@@ -0,0 +1,28 @@
+import { failUpload } from "../uploads/schema.js";
+import { sha256 } from "../runtime/portable-hash.js";
+import { Effect } from "effect";
+
+// src/client/fingerprint.ts
+const hashFile = Effect.fnUntraced(function* (file, onProgress) {
+	const hash = sha256.create();
+	for (let offset = 0; offset < file.size; offset += 1024 ** 2) {
+		const bytes = yield* Effect.tryPromise({
+			try: () => file.slice(offset, offset + 1024 ** 2).arrayBuffer(),
+			catch: () => failUpload("Unavailable")
+		});
+		hash.update(new Uint8Array(bytes));
+		if (onProgress) yield* Effect.try({
+			try: () => onProgress({
+				phase: "hashing",
+				bytesAccepted: 0,
+				totalBytes: file.size,
+				measurement: "indeterminate"
+			}),
+			catch: () => failUpload("Unavailable")
+		});
+	}
+	return hash.finish().value;
+});
+
+export { hashFile };
+//# sourceMappingURL=fingerprint.js.map

package/dist/client/fingerprint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fingerprint.js","names":[],"sources":["../../src/client/fingerprint.ts"],"sourcesContent":["import { Effect } from \"effect\";\n\nimport { sha256 } from \"../runtime/portable-hash.js\";\nimport { failUpload } from \"../uploads/schema.js\";\nimport type { Progress } from \"./transport.js\";\nexport const hashFile = Effect.fnUntraced(function* (file: Blob, onProgress?: Progress) {\n  const hash = sha256.create();\n  for (let offset = 0; offset < file.size; offset += 1024 ** 2) {\n    const bytes = yield* Effect.tryPromise({\n      try: () => file.slice(offset, offset + 1024 ** 2).arrayBuffer(),\n      catch: () => failUpload(\"Unavailable\"),\n    });\n    hash.update(new Uint8Array(bytes));\n    if (onProgress)\n      yield* Effect.try({\n        try: () =>\n          onProgress({\n            phase: \"hashing\",\n            bytesAccepted: 0,\n            totalBytes: file.size,\n            measurement: \"indeterminate\",\n          }),\n        catch: () => failUpload(\"Unavailable\"),\n      });\n  }\n  return hash.finish().value;\n});\n"],"mappings":";;;;;AAKA,MAAa,WAAW,OAAO,WAAW,WAAW,MAAY,YAAuB;CACtF,MAAM,OAAO,OAAO,OAAO;CAC3B,KAAK,IAAI,SAAS,GAAG,SAAS,KAAK,MAAM,UAAU,QAAQ,GAAG;EAC5D,MAAM,QAAQ,OAAO,OAAO,WAAW;GACrC,WAAW,KAAK,MAAM,QAAQ,SAAS,QAAQ,CAAC,CAAC,CAAC,YAAY;GAC9D,aAAa,WAAW,aAAa;EACvC,CAAC;EACD,KAAK,OAAO,IAAI,WAAW,KAAK,CAAC;EACjC,IAAI,YACF,OAAO,OAAO,IAAI;GAChB,WACE,WAAW;IACT,OAAO;IACP,eAAe;IACf,YAAY,KAAK;IACjB,aAAa;GACf,CAAC;GACH,aAAa,WAAW,aAAa;EACvC,CAAC;CACL;CACA,OAAO,KAAK,OAAO,CAAC,CAAC;AACvB,CAAC"}

package/dist/client/store.d.ts

@@ -0,0 +1,31 @@
+import { failUpload } from "../uploads/schema.js";
+import { Effect, Schema } from "effect";
+import { KeyValueStore } from "effect/persistence";
+export declare const UploadTicket: Schema.Struct<{
+  readonly version: Schema.Literal<1>;
+  readonly id: Schema.optional<Schema.String>;
+  readonly idempotencyKey: Schema.NonEmptyString;
+  readonly input: Schema.Struct<{
+    readonly purpose: Schema.NonEmptyString;
+    readonly file: Schema.Struct<{
+      readonly name: Schema.String;
+      readonly size: Schema.Natural;
+      readonly contentType: Schema.String;
+      readonly sha256: Schema.String;
+    }>;
+    readonly context: Schema.$Record<Schema.String, Schema.String>;
+    readonly strategy: Schema.optional<Schema.Literals<readonly ["auto", "single", "post", "multipart", "resumable", "proxy"]>>;
+  }>;
+}>;
+export type UploadTicket = typeof UploadTicket.Type;
+export interface ClientUploadStore {
+  readonly read: (id: string) => Effect.Effect<UploadTicket | undefined, ReturnType<typeof failUpload>>;
+  readonly write: (id: string, ticket: UploadTicket) => Effect.Effect<void, ReturnType<typeof failUpload>>;
+  readonly remove: (id: string) => Effect.Effect<void, ReturnType<typeof failUpload>>;
+}
+export declare const UploadClientStore: {
+  memory(): ClientUploadStore;
+  webStorage(storage: globalThis.Storage, namespace: string): ClientUploadStore;
+  keyValueStore(kvs: KeyValueStore.KeyValueStore, namespace: string): ClientUploadStore;
+};
+//# sourceMappingURL=store.d.ts.map

package/dist/client/store.js

@@ -0,0 +1,56 @@
+import { UploadId, UploadInput, failUpload } from "../uploads/schema.js";
+import { Effect, Schema } from "effect";
+
+// src/client/store.ts
+const UploadTicket = Schema.Struct({
+	version: Schema.Literal(1),
+	id: Schema.optional(UploadId),
+	idempotencyKey: Schema.NonEmptyString,
+	input: UploadInput
+});
+const UploadClientStore = {
+	memory() {
+		const records = /* @__PURE__ */ new Map();
+		return {
+			read: (id) => Effect.sync(() => records.get(id)),
+			write: (id, ticket) => Effect.sync(() => {
+				records.set(id, structuredClone(ticket));
+			}),
+			remove: (id) => Effect.sync(() => {
+				records.delete(id);
+			})
+		};
+	},
+	webStorage(storage, namespace) {
+		const key = (id) => `${namespace}:browser-upload:${encodeURIComponent(id)}`;
+		return {
+			read: (id) => Effect.try({
+				try: () => storage.getItem(key(id)),
+				catch: () => failUpload("Unavailable")
+			}).pipe(Effect.flatMap((raw) => raw === null ? Effect.succeed(void 0) : raw.length > 65536 ? Effect.fail(failUpload("BadRequest")) : Schema.decodeUnknownEffect(Schema.fromJsonString(UploadTicket), { onExcessProperty: "error" })(raw).pipe(Effect.mapError(() => failUpload("BadRequest"))))),
+			write: (id, ticket) => Schema.decodeUnknownEffect(UploadTicket, { onExcessProperty: "error" })(ticket).pipe(Effect.mapError(() => failUpload("BadRequest")), Effect.flatMap((value) => Effect.try({
+				try: () => {
+					const encoded = JSON.stringify(value);
+					if (encoded.length > 65536) throw new Error("Ticket limit");
+					storage.setItem(key(id), encoded);
+				},
+				catch: () => failUpload("Unavailable")
+			}))),
+			remove: (id) => Effect.try({
+				try: () => storage.removeItem(key(id)),
+				catch: () => failUpload("Unavailable")
+			})
+		};
+	},
+	keyValueStore(kvs, namespace) {
+		const key = (id) => `${namespace}:browser-upload:${encodeURIComponent(id)}`;
+		return {
+			read: (id) => kvs.get(key(id)).pipe(Effect.mapError(() => failUpload("Unavailable")), Effect.flatMap((raw) => raw === void 0 ? Effect.succeed(void 0) : raw.length > 65536 ? Effect.fail(failUpload("BadRequest")) : Schema.decodeUnknownEffect(Schema.fromJsonString(UploadTicket))(raw).pipe(Effect.mapError(() => failUpload("BadRequest"))))),
+			write: (id, ticket) => Schema.decodeUnknownEffect(UploadTicket, { onExcessProperty: "error" })(ticket).pipe(Effect.mapError(() => failUpload("BadRequest")), Effect.flatMap((value) => kvs.set(key(id), JSON.stringify(value)).pipe(Effect.mapError(() => failUpload("Unavailable"))))),
+			remove: (id) => kvs.remove(key(id)).pipe(Effect.mapError(() => failUpload("Unavailable")))
+		};
+	}
+};
+
+export { UploadClientStore, UploadTicket };
+//# sourceMappingURL=store.js.map

package/dist/client/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","names":[],"sources":["../../src/client/store.ts"],"sourcesContent":["import { Effect, Schema } from \"effect\";\nimport type { KeyValueStore } from \"effect/persistence\";\n\nimport { UploadId, UploadInput, failUpload } from \"../uploads/schema.js\";\nexport const UploadTicket = Schema.Struct({\n  version: Schema.Literal(1),\n  id: Schema.optional(UploadId),\n  idempotencyKey: Schema.NonEmptyString,\n  input: UploadInput,\n});\nexport type UploadTicket = typeof UploadTicket.Type;\nexport interface ClientUploadStore {\n  readonly read: (\n    id: string,\n  ) => Effect.Effect<UploadTicket | undefined, ReturnType<typeof failUpload>>;\n  readonly write: (\n    id: string,\n    ticket: UploadTicket,\n  ) => Effect.Effect<void, ReturnType<typeof failUpload>>;\n  readonly remove: (id: string) => Effect.Effect<void, ReturnType<typeof failUpload>>;\n}\nexport const UploadClientStore = {\n  memory(): ClientUploadStore {\n    const records = new Map<string, UploadTicket>();\n    return {\n      read: (id) => Effect.sync(() => records.get(id)),\n      write: (id, ticket) =>\n        Effect.sync(() => {\n          records.set(id, structuredClone(ticket));\n        }),\n      remove: (id) =>\n        Effect.sync(() => {\n          records.delete(id);\n        }),\n    };\n  },\n  webStorage(storage: globalThis.Storage, namespace: string): ClientUploadStore {\n    const key = (id: string) => `${namespace}:browser-upload:${encodeURIComponent(id)}`;\n    return {\n      read: (id) =>\n        Effect.try({\n          try: () => storage.getItem(key(id)),\n          catch: () => failUpload(\"Unavailable\"),\n        }).pipe(\n          Effect.flatMap((raw) =>\n            raw === null\n              ? Effect.succeed(undefined)\n              : raw.length > 65536\n                ? Effect.fail(failUpload(\"BadRequest\"))\n                : Schema.decodeUnknownEffect(Schema.fromJsonString(UploadTicket), {\n                    onExcessProperty: \"error\",\n                  })(raw).pipe(Effect.mapError(() => failUpload(\"BadRequest\"))),\n          ),\n        ),\n      write: (id, ticket) =>\n        Schema.decodeUnknownEffect(UploadTicket, { onExcessProperty: \"error\" })(ticket).pipe(\n          Effect.mapError(() => failUpload(\"BadRequest\")),\n          Effect.flatMap((value) =>\n            Effect.try({\n              try: () => {\n                const encoded = JSON.stringify(value);\n                if (encoded.length > 65536) throw new Error(\"Ticket limit\");\n                storage.setItem(key(id), encoded);\n              },\n              catch: () => failUpload(\"Unavailable\"),\n            }),\n          ),\n        ),\n      remove: (id) =>\n        Effect.try({\n          try: () => storage.removeItem(key(id)),\n          catch: () => failUpload(\"Unavailable\"),\n        }),\n    };\n  },\n  keyValueStore(kvs: KeyValueStore.KeyValueStore, namespace: string): ClientUploadStore {\n    const key = (id: string) => `${namespace}:browser-upload:${encodeURIComponent(id)}`;\n    return {\n      read: (id) =>\n        kvs.get(key(id)).pipe(\n          Effect.mapError(() => failUpload(\"Unavailable\")),\n          Effect.flatMap((raw) =>\n            raw === undefined\n              ? Effect.succeed(undefined)\n              : raw.length > 65536\n                ? Effect.fail(failUpload(\"BadRequest\"))\n                : Schema.decodeUnknownEffect(Schema.fromJsonString(UploadTicket))(raw).pipe(\n                    Effect.mapError(() => failUpload(\"BadRequest\")),\n                  ),\n          ),\n        ),\n      write: (id, ticket) =>\n        Schema.decodeUnknownEffect(UploadTicket, { onExcessProperty: \"error\" })(ticket).pipe(\n          Effect.mapError(() => failUpload(\"BadRequest\")),\n          Effect.flatMap((value) =>\n            kvs\n              .set(key(id), JSON.stringify(value))\n              .pipe(Effect.mapError(() => failUpload(\"Unavailable\"))),\n          ),\n        ),\n      remove: (id) => kvs.remove(key(id)).pipe(Effect.mapError(() => failUpload(\"Unavailable\"))),\n    };\n  },\n};\n"],"mappings":";;;;AAIA,MAAa,eAAe,OAAO,OAAO;CACxC,SAAS,OAAO,QAAQ,CAAC;CACzB,IAAI,OAAO,SAAS,QAAQ;CAC5B,gBAAgB,OAAO;CACvB,OAAO;AACT,CAAC;AAYD,MAAa,oBAAoB;CAC/B,SAA4B;EAC1B,MAAM,0BAAU,IAAI,IAA0B;EAC9C,OAAO;GACL,OAAO,OAAO,OAAO,WAAW,QAAQ,IAAI,EAAE,CAAC;GAC/C,QAAQ,IAAI,WACV,OAAO,WAAW;IAChB,QAAQ,IAAI,IAAI,gBAAgB,MAAM,CAAC;GACzC,CAAC;GACH,SAAS,OACP,OAAO,WAAW;IAChB,QAAQ,OAAO,EAAE;GACnB,CAAC;EACL;CACF;CACA,WAAW,SAA6B,WAAsC;EAC5E,MAAM,OAAO,OAAe,GAAG,UAAU,kBAAkB,mBAAmB,EAAE;EAChF,OAAO;GACL,OAAO,OACL,OAAO,IAAI;IACT,WAAW,QAAQ,QAAQ,IAAI,EAAE,CAAC;IAClC,aAAa,WAAW,aAAa;GACvC,CAAC,CAAC,CAAC,KACD,OAAO,SAAS,QACd,QAAQ,OACJ,OAAO,QAAQ,MAAS,IACxB,IAAI,SAAS,QACX,OAAO,KAAK,WAAW,YAAY,CAAC,IACpC,OAAO,oBAAoB,OAAO,eAAe,YAAY,GAAG,EAC9D,kBAAkB,QACpB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,OAAO,eAAe,WAAW,YAAY,CAAC,CAAC,CACpE,CACF;GACF,QAAQ,IAAI,WACV,OAAO,oBAAoB,cAAc,EAAE,kBAAkB,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,KAC9E,OAAO,eAAe,WAAW,YAAY,CAAC,GAC9C,OAAO,SAAS,UACd,OAAO,IAAI;IACT,WAAW;KACT,MAAM,UAAU,KAAK,UAAU,KAAK;KACpC,IAAI,QAAQ,SAAS,OAAO,MAAM,IAAI,MAAM,cAAc;KAC1D,QAAQ,QAAQ,IAAI,EAAE,GAAG,OAAO;IAClC;IACA,aAAa,WAAW,aAAa;GACvC,CAAC,CACH,CACF;GACF,SAAS,OACP,OAAO,IAAI;IACT,WAAW,QAAQ,WAAW,IAAI,EAAE,CAAC;IACrC,aAAa,WAAW,aAAa;GACvC,CAAC;EACL;CACF;CACA,cAAc,KAAkC,WAAsC;EACpF,MAAM,OAAO,OAAe,GAAG,UAAU,kBAAkB,mBAAmB,EAAE;EAChF,OAAO;GACL,OAAO,OACL,IAAI,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,KACf,OAAO,eAAe,WAAW,aAAa,CAAC,GAC/C,OAAO,SAAS,QACd,QAAQ,SACJ,OAAO,QAAQ,MAAS,IACxB,IAAI,SAAS,QACX,OAAO,KAAK,WAAW,YAAY,CAAC,IACpC,OAAO,oBAAoB,OAAO,eAAe,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KACnE,OAAO,eAAe,WAAW,YAAY,CAAC,CAChD,CACR,CACF;GACF,QAAQ,IAAI,WACV,OAAO,oBAAoB,cAAc,EAAE,kBAAkB,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,KAC9E,OAAO,eAAe,WAAW,YAAY,CAAC,GAC9C,OAAO,SAAS,UACd,IACG,IAAI,IAAI,EAAE,GAAG,KAAK,UAAU,KAAK,CAAC,CAAC,CACnC,KAAK,OAAO,eAAe,WAAW,aAAa,CAAC,CAAC,CAC1D,CACF;GACF,SAAS,OAAO,IAAI,OAAO,IAAI,EAAE,CAAC,CAAC,CAAC,KAAK,OAAO,eAAe,WAAW,aAAa,CAAC,CAAC;EAC3F;CACF;AACF"}

package/dist/client/transport.d.ts

@@ -0,0 +1,11 @@
+import "../uploads/schema.js";
+import { Effect } from "effect";
+export interface UploadProgress {
+  readonly phase: "hashing" | "authorizing" | "uploading" | "verifying" | "completed";
+  readonly bytesSent?: number;
+  readonly bytesAccepted: number;
+  readonly totalBytes: number;
+  readonly measurement: "xhr" | "provider-accepted" | "indeterminate";
+}
+export type Progress = (progress: UploadProgress) => void;
+//# sourceMappingURL=transport.d.ts.map