@effect-kit/storage 0.0.0-stage → 0.1.0

package/dist/uploads.js

@@ -0,0 +1,330 @@
+import { GrantResponse, PartRequest, PartsRequest, UploadActor, UploadError, UploadErrorCode, UploadFile, UploadGrant, UploadId, UploadInput, UploadRecord, UploadRequest, UploadState, UploadStatus, failUpload } from "./uploads/schema.js";
+import { digestText } from "./runtime/portable-hash.js";
+import { Storage } from "./core/storage.js";
+import { StorageEvent } from "./events.js";
+import { UploadGrantDriver } from "./uploads/driver.js";
+import { UploadStore } from "./uploads/store.js";
+import { cleanup, snapshot } from "./uploads/verification.js";
+import { SignedUploadGrants } from "./uploads/signed-driver.js";
+import { Clock, Context, Effect, Layer, Redacted, Schema } from "effect";
+
+// src/uploads/index.ts
+const decode = (schema, input) => Schema.decodeUnknownEffect(schema, { onExcessProperty: "error" })(input).pipe(Effect.mapError(() => failUpload("BadRequest")));
+const status = (record) => ({
+	version: 1,
+	id: record.id,
+	state: record.state,
+	expiresAt: record.expiresAt,
+	cleanupPending: record.cleanupPending,
+	...record.state === "published" ? { result: record.result } : {}
+});
+const make = Effect.fnUntraced(function* (options) {
+	if (options.quarantine !== "private" || !Number.isSafeInteger(options.grantSeconds ?? 900) || (options.grantSeconds ?? 900) < 1 || (options.grantSeconds ?? 900) > 3600) return yield* failUpload("BadRequest");
+	const context = yield* Effect.context();
+	const storage = yield* Storage;
+	const store = yield* UploadStore;
+	const driver = yield* UploadGrantDriver;
+	const hook = (program) => Effect.provide(program, context);
+	const allowed = Effect.fnUntraced(function* (actor, record, action) {
+		const decision = yield* hook(options.authorize({
+			actor,
+			input: record.input,
+			uploadId: record.id,
+			action
+		}));
+		if (decision.key !== record.key || !Number.isSafeInteger(decision.maxBytes) || record.input.file.size > decision.maxBytes || !decision.allowedContentTypes.includes(record.input.file.contentType)) return yield* failUpload("Forbidden");
+		return decision;
+	});
+	const load = Effect.fnUntraced(function* (raw, action) {
+		const actor = yield* decode(UploadActor, raw.actor);
+		const id = yield* decode(UploadId, raw.uploadId);
+		const record = yield* store.read(id);
+		if (!record || record.storeId !== storage.storeId || record.actor.subject !== actor.subject || record.actor.tenantId !== actor.tenantId) return yield* failUpload("NotFound");
+		yield* allowed(actor, record, action);
+		return record;
+	});
+	const active = Effect.fnUntraced(function* (record) {
+		if (record.expiresAt <= (yield* Clock.currentTimeMillis)) return yield* failUpload("Expired");
+		if (!["ready", "uploading"].includes(record.state)) return yield* failUpload("Conflict");
+	});
+	const grant = Effect.fnUntraced(function* (input) {
+		const record = yield* load(input, "grant");
+		yield* active(record);
+		const now = yield* Clock.currentTimeMillis;
+		const expiresAt = driver.maximumGrantLifetimeMillis ? now + driver.maximumGrantLifetimeMillis : Math.min(record.expiresAt, now + (options.grantSeconds ?? 900) * 1e3);
+		let issuing = {
+			...record,
+			grantExpiresAt: Math.max(record.grantExpiresAt, expiresAt),
+			cleanupPending: true
+		};
+		yield* store.write(issuing);
+		if (record.remote === void 0) {
+			yield* store.write({
+				...issuing,
+				state: "initiating"
+			});
+			const remote = yield* driver.begin(issuing);
+			issuing = {
+				...issuing,
+				remote: Redacted.make(remote),
+				state: "uploading"
+			};
+			yield* store.write(issuing);
+		}
+		const native = input.partNumber !== void 0 ? yield* driver.part ? driver.part(issuing, (yield* decode(PartRequest, {
+			partNumber: input.partNumber,
+			...input.sha256 ? { sha256: input.sha256 } : {}
+		})).partNumber, expiresAt, input.sha256) : Effect.fail(failUpload("Unsupported")) : yield* driver.grant(issuing, expiresAt);
+		if (native.expiresAt > expiresAt) return yield* failUpload("Unsupported");
+		return {
+			version: 1,
+			id: record.id,
+			grant: Redacted.make({
+				...native,
+				constraints: [
+					...native.constraints ?? [],
+					{
+						kind: "size",
+						enforcement: "backend",
+						value: record.input.file.size
+					},
+					{
+						kind: "sha256",
+						enforcement: "backend",
+						value: record.input.file.sha256
+					},
+					{
+						kind: "declared-content-type",
+						enforcement: "advisory",
+						value: record.input.file.contentType
+					},
+					{
+						kind: "content-inspection",
+						enforcement: options.inspect ? "backend" : "advisory",
+						value: options.inspect ? "required" : "not-configured"
+					}
+				]
+			})
+		};
+	});
+	const complete = Effect.fnUntraced(function* (input) {
+		let record = yield* load(input, "complete");
+		if (record.state === "published") return status(record);
+		if ([
+			"aborted",
+			"rejected",
+			"reserving",
+			"initiating"
+		].includes(record.state)) return yield* failUpload("Conflict");
+		if (record.expiresAt <= (yield* Clock.currentTimeMillis) && !["publishing", "verifying"].includes(record.state)) return yield* failUpload("Expired");
+		if (input.parts && driver.complete && !record.object) {
+			if (!(yield* storage.head({ key: record.stagingKey }).pipe(Effect.catchReason("StorageError", "NotFound", () => Effect.succeed(void 0))))) yield* driver.complete(record, (yield* decode(PartsRequest, { parts: input.parts })).parts);
+		}
+		if (!record.object) {
+			if (record.state !== "verifying") yield* storage.head({ key: record.stagingKey });
+			record = {
+				...record,
+				state: "verifying"
+			};
+			yield* store.write(record);
+			const outcome = yield* Effect.result(snapshot(storage, record));
+			if (outcome._tag === "Failure") {
+				if (outcome.failure._tag === "UploadError" && outcome.failure.code === "VerificationFailed") yield* store.write({
+					...record,
+					state: "rejected"
+				});
+				return yield* outcome.failure;
+			}
+			record = {
+				...record,
+				object: outcome.success
+			};
+			yield* store.write(record);
+		}
+		const object = record.object;
+		if (!object) return yield* failUpload("Unavailable");
+		if (record.state !== "publishing" && options.inspect) {
+			const inspection = yield* Effect.result(hook(options.inspect({
+				object,
+				file: record.input.file
+			})));
+			if (inspection._tag === "Failure") {
+				if (inspection.failure._tag === "UploadError" && inspection.failure.code === "VerificationFailed") yield* store.write({
+					...record,
+					state: "rejected"
+				});
+				return yield* inspection.failure;
+			}
+		}
+		record = {
+			...record,
+			state: "publishing"
+		};
+		yield* store.write(record);
+		if (options.quota) yield* hook(options.quota.settle(record));
+		const result = yield* hook(options.publish({
+			idempotencyKey: record.id,
+			object,
+			context: record.context
+		}));
+		record = {
+			...record,
+			state: "published",
+			result
+		};
+		yield* store.write(record);
+		return status(record);
+	});
+	const reconcile = Effect.fnUntraced(function* (input) {
+		let record = yield* load(input, "reconcile");
+		if (![
+			"published",
+			"publishing",
+			"verifying",
+			"aborted",
+			"rejected"
+		].includes(record.state) && record.expiresAt <= (yield* Clock.currentTimeMillis)) {
+			record = {
+				...record,
+				state: "aborted",
+				cleanupPending: true
+			};
+			yield* store.write(record);
+		}
+		if (["aborted", "rejected"].includes(record.state)) {
+			yield* driver.abort(record);
+			if (options.quota) yield* hook(options.quota.release(record));
+		}
+		if (["verifying", "publishing"].includes(record.state)) return yield* complete(input);
+		if (record.cleanupPending && record.grantExpiresAt <= (yield* Clock.currentTimeMillis) && [
+			"aborted",
+			"published",
+			"rejected"
+		].includes(record.state)) {
+			const cleaned = yield* cleanup(storage, record);
+			record = {
+				...record,
+				cleanupPending: !cleaned || !driver.confirmsTermination && record.grantExpiresAt > 0
+			};
+			yield* store.write(record);
+		}
+		return status(record);
+	});
+	return {
+		create: (raw) => store.exclusive(Effect.gen(function* () {
+			const actor = yield* decode(UploadActor, raw.actor);
+			const request = yield* decode(UploadRequest, {
+				version: 1,
+				input: raw.input,
+				idempotencyKey: raw.idempotencyKey
+			});
+			const id = digestText(JSON.stringify([
+				actor.subject,
+				actor.tenantId,
+				storage.storeId,
+				request.idempotencyKey
+			]));
+			let record = yield* store.read(id);
+			if (record) {
+				if (digestText(JSON.stringify(record.input)) !== digestText(JSON.stringify(request.input))) return yield* failUpload("Conflict");
+				yield* allowed(actor, record, "create");
+			} else {
+				const decision = yield* hook(options.authorize({
+					actor,
+					input: request.input,
+					uploadId: id,
+					action: "create"
+				}));
+				if (!Number.isSafeInteger(decision.expiresInSeconds) || decision.expiresInSeconds < 1 || decision.expiresInSeconds > 86400 || !decision.key || !Number.isSafeInteger(decision.maxBytes) || request.input.file.size > decision.maxBytes || !decision.allowedContentTypes.includes(request.input.file.contentType)) return yield* failUpload("Forbidden");
+				record = {
+					version: 1,
+					id,
+					actor,
+					input: request.input,
+					storeId: storage.storeId,
+					key: decision.key,
+					stagingKey: `${decision.key}.upload-${id}`,
+					publishedKey: `${decision.key}.object-${id}`,
+					context: decision.context,
+					expiresAt: (yield* Clock.currentTimeMillis) + decision.expiresInSeconds * 1e3,
+					grantExpiresAt: 0,
+					state: "reserving",
+					cleanupPending: false
+				};
+				yield* store.write(record);
+			}
+			if (record.state === "reserving") {
+				if (options.quota) yield* hook(options.quota.reserve(record));
+				record = {
+					...record,
+					state: "ready"
+				};
+				yield* store.write(record);
+			}
+			return status(record);
+		})),
+		maximumContentBytes: (input) => store.exclusive(load(input, "content").pipe(Effect.map((record) => record.input.file.size))),
+		status: (input) => store.exclusive(load(input, "status").pipe(Effect.map(status))),
+		grant: (input) => store.exclusive(grant(input)),
+		part: (input) => store.exclusive(grant(input)),
+		complete: (input) => store.exclusive(complete(input)),
+		reconcile: (input) => store.exclusive(reconcile(input)),
+		observe: (input) => store.exclusive(Effect.gen(function* () {
+			const record = yield* load(input, "complete");
+			const event = yield* decode(StorageEvent, input.event);
+			if (event.provider !== storage.provider || event.ref.storeId !== storage.storeId || event.ref.key !== record.stagingKey) return yield* failUpload("Forbidden");
+			if (!["object-created", "restore-completed"].includes(event.kind)) return status(record);
+			return yield* complete(input);
+		})),
+		abort: (input) => store.exclusive(Effect.gen(function* () {
+			const record = yield* load(input, "abort");
+			if (["published", "publishing"].includes(record.state)) return yield* failUpload("Conflict");
+			const aborted = {
+				...record,
+				state: "aborted",
+				cleanupPending: true
+			};
+			yield* store.write(aborted);
+			yield* driver.abort(aborted);
+			if (options.quota) yield* hook(options.quota.release(aborted));
+			return status(aborted);
+		})),
+		content: (input) => store.exclusive(Effect.gen(function* () {
+			const record = yield* load(input, "content");
+			yield* active(record);
+			if (record.input.strategy && !["auto", "proxy"].includes(record.input.strategy)) return yield* failUpload("Conflict");
+			yield* store.write({
+				...record,
+				state: "uploading",
+				cleanupPending: true
+			});
+			yield* storage.put({
+				key: record.stagingKey,
+				body: input.body,
+				contentLength: record.input.file.size,
+				maxBytes: record.input.file.size,
+				contentType: record.input.file.contentType,
+				condition: { _tag: "CreateOnly" }
+			});
+			yield* store.write({
+				...record,
+				state: "uploading",
+				cleanupPending: true
+			});
+			return status({
+				...record,
+				state: "uploading",
+				cleanupPending: true
+			});
+		}))
+	};
+});
+var Uploads = class Uploads extends Context.Service()("@effect-kit/storage/Uploads") {
+	static make = make;
+	static layer(options) {
+		return Layer.effect(Uploads, make(options));
+	}
+};
+
+export { GrantResponse, PartRequest, PartsRequest, SignedUploadGrants, UploadActor, UploadError, UploadErrorCode, UploadFile, UploadGrant, UploadGrantDriver, UploadId, UploadInput, UploadRecord, UploadRequest, UploadState, UploadStatus, UploadStore, Uploads, failUpload };
+//# sourceMappingURL=uploads.js.map

package/dist/uploads.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploads.js","names":[],"sources":["../src/uploads/index.ts"],"sourcesContent":["import { Clock, Context, Effect, Layer, Redacted, Schema } from \"effect\";\n\nimport type { UploadBody } from \"../core/requests.js\";\nimport { Storage } from \"../core/storage.js\";\nimport { StorageEvent } from \"../lifecycle/events.js\";\nimport { UploadGrantDriver } from \"./driver.js\";\nimport type { UploadOptions, UploadAction } from \"./policy.js\";\nimport {\n  UploadActor,\n  UploadRequest,\n  UploadId,\n  PartRequest,\n  PartsRequest,\n  failUpload,\n} from \"./schema.js\";\nimport type { UploadRecord, UploadStatus, UploadInput } from \"./schema.js\";\nimport { UploadStore } from \"./store.js\";\nimport { cleanup, digestText, snapshot } from \"./verification.js\";\nexport * from \"./schema.js\";\nexport { UploadStore, UploadGrantDriver };\nexport { SignedUploadGrants } from \"./signed-driver.js\";\nexport type { UploadStoreOptions } from \"./store.js\";\nexport type { UploadOptions, UploadDecision, UploadAction } from \"./policy.js\";\nexport type { UploadGrantDriverService } from \"./driver.js\";\nconst decode = <S extends Schema.Constraint>(schema: S, input: unknown) =>\n  Schema.decodeUnknownEffect(schema, { onExcessProperty: \"error\" })(input).pipe(\n    Effect.mapError(() => failUpload(\"BadRequest\")),\n  );\nconst status = (record: UploadRecord): UploadStatus => ({\n  version: 1,\n  id: record.id,\n  state: record.state,\n  expiresAt: record.expiresAt,\n  cleanupPending: record.cleanupPending,\n  ...(record.state === \"published\" ? { result: record.result } : {}),\n});\nconst make = Effect.fnUntraced(function* <R>(options: UploadOptions<R>) {\n  if (\n    options.quarantine !== \"private\" ||\n    !Number.isSafeInteger(options.grantSeconds ?? 900) ||\n    (options.grantSeconds ?? 900) < 1 ||\n    (options.grantSeconds ?? 900) > 3600\n  )\n    return yield* failUpload(\"BadRequest\");\n  const context = yield* Effect.context<R>();\n  const storage = yield* Storage;\n  const store = yield* UploadStore;\n  const driver = yield* UploadGrantDriver;\n  const hook = <A, E>(program: Effect.Effect<A, E, R>) => Effect.provide(program, context);\n  const allowed = Effect.fnUntraced(function* (\n    actor: UploadActor,\n    record: UploadRecord,\n    action: UploadAction,\n  ) {\n    const decision = yield* hook(\n      options.authorize({ actor, input: record.input, uploadId: record.id, action }),\n    );\n    if (\n      decision.key !== record.key ||\n      !Number.isSafeInteger(decision.maxBytes) ||\n      record.input.file.size > decision.maxBytes ||\n      !decision.allowedContentTypes.includes(record.input.file.contentType)\n    )\n      return yield* failUpload(\"Forbidden\");\n    return decision;\n  });\n  const load = Effect.fnUntraced(function* (\n    raw: { readonly actor: UploadActor; readonly uploadId: string },\n    action: UploadAction,\n  ) {\n    const actor = yield* decode(UploadActor, raw.actor);\n    const id = yield* decode(UploadId, raw.uploadId);\n    const record = yield* store.read(id);\n    if (\n      !record ||\n      record.storeId !== storage.storeId ||\n      record.actor.subject !== actor.subject ||\n      record.actor.tenantId !== actor.tenantId\n    )\n      return yield* failUpload(\"NotFound\");\n    yield* allowed(actor, record, action);\n    return record;\n  });\n  const active = Effect.fnUntraced(function* (record: UploadRecord) {\n    if (record.expiresAt <= (yield* Clock.currentTimeMillis)) return yield* failUpload(\"Expired\");\n    if (![\"ready\", \"uploading\"].includes(record.state)) return yield* failUpload(\"Conflict\");\n  });\n  const grant = Effect.fnUntraced(function* (input: {\n    readonly actor: UploadActor;\n    readonly uploadId: string;\n    readonly partNumber?: number;\n    readonly sha256?: string | undefined;\n  }) {\n    const record = yield* load(input, \"grant\");\n    yield* active(record);\n    const now = yield* Clock.currentTimeMillis;\n    const expiresAt = driver.maximumGrantLifetimeMillis\n      ? now + driver.maximumGrantLifetimeMillis\n      : Math.min(record.expiresAt, now + (options.grantSeconds ?? 900) * 1000);\n    // Persist the possible grant lifetime before issuing bearer authority.\n    let issuing = {\n      ...record,\n      grantExpiresAt: Math.max(record.grantExpiresAt, expiresAt),\n      cleanupPending: true,\n    };\n    yield* store.write(issuing);\n    if (record.remote === undefined) {\n      yield* store.write({ ...issuing, state: \"initiating\" });\n      const remote = yield* driver.begin(issuing);\n      issuing = { ...issuing, remote: Redacted.make(remote), state: \"uploading\" };\n      yield* store.write(issuing);\n    }\n    const native =\n      input.partNumber !== undefined\n        ? yield* driver.part\n            ? driver.part(\n                issuing,\n                (yield* decode(PartRequest, {\n                  partNumber: input.partNumber,\n                  ...(input.sha256 ? { sha256: input.sha256 } : {}),\n                })).partNumber,\n                expiresAt,\n                input.sha256,\n              )\n            : Effect.fail(failUpload(\"Unsupported\"))\n        : yield* driver.grant(issuing, expiresAt);\n    if (native.expiresAt > expiresAt) return yield* failUpload(\"Unsupported\");\n    return {\n      version: 1 as const,\n      id: record.id,\n      grant: Redacted.make({\n        ...native,\n        constraints: [\n          ...(native.constraints ?? []),\n          { kind: \"size\", enforcement: \"backend\" as const, value: record.input.file.size },\n          { kind: \"sha256\", enforcement: \"backend\" as const, value: record.input.file.sha256 },\n          {\n            kind: \"declared-content-type\",\n            enforcement: \"advisory\" as const,\n            value: record.input.file.contentType,\n          },\n          {\n            kind: \"content-inspection\",\n            enforcement: options.inspect ? (\"backend\" as const) : (\"advisory\" as const),\n            value: options.inspect ? \"required\" : \"not-configured\",\n          },\n        ],\n      }),\n    };\n  });\n  const complete = Effect.fnUntraced(function* (input: {\n    readonly actor: UploadActor;\n    readonly uploadId: string;\n    readonly parts?: (typeof PartsRequest.Type)[\"parts\"];\n  }) {\n    let record = yield* load(input, \"complete\");\n    if (record.state === \"published\") return status(record);\n    if ([\"aborted\", \"rejected\", \"reserving\", \"initiating\"].includes(record.state))\n      return yield* failUpload(\"Conflict\");\n    if (\n      record.expiresAt <= (yield* Clock.currentTimeMillis) &&\n      ![\"publishing\", \"verifying\"].includes(record.state)\n    )\n      return yield* failUpload(\"Expired\");\n    if (input.parts && driver.complete && !record.object) {\n      const committed = yield* storage\n        .head({ key: record.stagingKey })\n        .pipe(Effect.catchReason(\"StorageError\", \"NotFound\", () => Effect.succeed(undefined)));\n      if (!committed)\n        yield* driver.complete(record, (yield* decode(PartsRequest, { parts: input.parts })).parts);\n    }\n    if (!record.object) {\n      if (record.state !== \"verifying\") yield* storage.head({ key: record.stagingKey });\n      record = { ...record, state: \"verifying\" };\n      yield* store.write(record);\n      const outcome = yield* Effect.result(snapshot(storage, record));\n      if (outcome._tag === \"Failure\") {\n        if (outcome.failure._tag === \"UploadError\" && outcome.failure.code === \"VerificationFailed\")\n          yield* store.write({ ...record, state: \"rejected\" });\n        return yield* outcome.failure;\n      }\n      record = { ...record, object: outcome.success };\n      yield* store.write(record);\n    }\n    const object = record.object;\n    if (!object) return yield* failUpload(\"Unavailable\");\n    if (record.state !== \"publishing\" && options.inspect) {\n      const inspection = yield* Effect.result(\n        hook(options.inspect({ object, file: record.input.file })),\n      );\n      if (inspection._tag === \"Failure\") {\n        if (\n          inspection.failure._tag === \"UploadError\" &&\n          inspection.failure.code === \"VerificationFailed\"\n        )\n          yield* store.write({ ...record, state: \"rejected\" });\n        return yield* inspection.failure;\n      }\n    }\n    record = { ...record, state: \"publishing\" };\n    yield* store.write(record);\n    if (options.quota) yield* hook(options.quota.settle(record));\n    const result = yield* hook(\n      options.publish({ idempotencyKey: record.id, object, context: record.context }),\n    );\n    record = { ...record, state: \"published\", result };\n    yield* store.write(record);\n    return status(record);\n  });\n  const reconcile = Effect.fnUntraced(function* (input: {\n    readonly actor: UploadActor;\n    readonly uploadId: string;\n  }) {\n    let record = yield* load(input, \"reconcile\");\n    if (\n      ![\"published\", \"publishing\", \"verifying\", \"aborted\", \"rejected\"].includes(record.state) &&\n      record.expiresAt <= (yield* Clock.currentTimeMillis)\n    ) {\n      record = { ...record, state: \"aborted\", cleanupPending: true };\n      yield* store.write(record);\n    }\n    if ([\"aborted\", \"rejected\"].includes(record.state)) {\n      yield* driver.abort(record);\n      if (options.quota) yield* hook(options.quota.release(record));\n    }\n    if ([\"verifying\", \"publishing\"].includes(record.state)) return yield* complete(input);\n    if (\n      record.cleanupPending &&\n      record.grantExpiresAt <= (yield* Clock.currentTimeMillis) &&\n      [\"aborted\", \"published\", \"rejected\"].includes(record.state)\n    ) {\n      const cleaned = yield* cleanup(storage, record);\n      record = {\n        ...record,\n        cleanupPending: !cleaned || (!driver.confirmsTermination && record.grantExpiresAt > 0),\n      };\n      yield* store.write(record);\n    }\n    return status(record);\n  });\n  return {\n    create: (raw: {\n      readonly actor: UploadActor;\n      readonly idempotencyKey: string;\n      readonly input: UploadInput;\n    }) =>\n      store.exclusive(\n        Effect.gen(function* () {\n          const actor = yield* decode(UploadActor, raw.actor);\n          const request = yield* decode(UploadRequest, {\n            version: 1,\n            input: raw.input,\n            idempotencyKey: raw.idempotencyKey,\n          });\n          const id = digestText(\n            JSON.stringify([\n              actor.subject,\n              actor.tenantId,\n              storage.storeId,\n              request.idempotencyKey,\n            ]),\n          );\n          let record = yield* store.read(id);\n          if (record) {\n            if (\n              digestText(JSON.stringify(record.input)) !== digestText(JSON.stringify(request.input))\n            )\n              return yield* failUpload(\"Conflict\");\n            yield* allowed(actor, record, \"create\");\n          } else {\n            const decision = yield* hook(\n              options.authorize({ actor, input: request.input, uploadId: id, action: \"create\" }),\n            );\n            if (\n              !Number.isSafeInteger(decision.expiresInSeconds) ||\n              decision.expiresInSeconds < 1 ||\n              decision.expiresInSeconds > 86400 ||\n              !decision.key ||\n              !Number.isSafeInteger(decision.maxBytes) ||\n              request.input.file.size > decision.maxBytes ||\n              !decision.allowedContentTypes.includes(request.input.file.contentType)\n            )\n              return yield* failUpload(\"Forbidden\");\n            record = {\n              version: 1,\n              id,\n              actor,\n              input: request.input,\n              storeId: storage.storeId,\n              key: decision.key,\n              stagingKey: `${decision.key}.upload-${id}`,\n              publishedKey: `${decision.key}.object-${id}`,\n              context: decision.context,\n              expiresAt: (yield* Clock.currentTimeMillis) + decision.expiresInSeconds * 1000,\n              grantExpiresAt: 0,\n              state: \"reserving\",\n              cleanupPending: false,\n            };\n            yield* store.write(record);\n          }\n          if (record.state === \"reserving\") {\n            if (options.quota) yield* hook(options.quota.reserve(record));\n            record = { ...record, state: \"ready\" };\n            yield* store.write(record);\n          }\n          return status(record);\n        }),\n      ),\n    maximumContentBytes: (input: { readonly actor: UploadActor; readonly uploadId: string }) =>\n      store.exclusive(load(input, \"content\").pipe(Effect.map((record) => record.input.file.size))),\n    status: (input: { readonly actor: UploadActor; readonly uploadId: string }) =>\n      store.exclusive(load(input, \"status\").pipe(Effect.map(status))),\n    grant: (input: { readonly actor: UploadActor; readonly uploadId: string }) =>\n      store.exclusive(grant(input)),\n    part: (input: {\n      readonly actor: UploadActor;\n      readonly uploadId: string;\n      readonly partNumber: number;\n      readonly sha256?: string | undefined;\n    }) => store.exclusive(grant(input)),\n    complete: (input: {\n      readonly actor: UploadActor;\n      readonly uploadId: string;\n      readonly parts?: (typeof PartsRequest.Type)[\"parts\"];\n    }) => store.exclusive(complete(input)),\n    reconcile: (input: { readonly actor: UploadActor; readonly uploadId: string }) =>\n      store.exclusive(reconcile(input)),\n    observe: (input: {\n      readonly actor: UploadActor;\n      readonly uploadId: string;\n      readonly event: StorageEvent;\n    }) =>\n      store.exclusive(\n        Effect.gen(function* () {\n          const record = yield* load(input, \"complete\");\n          const event = yield* decode(StorageEvent, input.event);\n          if (\n            event.provider !== storage.provider ||\n            event.ref.storeId !== storage.storeId ||\n            event.ref.key !== record.stagingKey\n          )\n            return yield* failUpload(\"Forbidden\");\n          if (![\"object-created\", \"restore-completed\"].includes(event.kind)) return status(record);\n          return yield* complete(input);\n        }),\n      ),\n    abort: (input: { readonly actor: UploadActor; readonly uploadId: string }) =>\n      store.exclusive(\n        Effect.gen(function* () {\n          const record = yield* load(input, \"abort\");\n          if ([\"published\", \"publishing\"].includes(record.state))\n            return yield* failUpload(\"Conflict\");\n          const aborted = { ...record, state: \"aborted\" as const, cleanupPending: true };\n          yield* store.write(aborted);\n          yield* driver.abort(aborted);\n          if (options.quota) yield* hook(options.quota.release(aborted));\n          return status(aborted);\n        }),\n      ),\n    content: <E = never, ER = never>(input: {\n      readonly actor: UploadActor;\n      readonly uploadId: string;\n      readonly body: UploadBody<E, ER>;\n    }) =>\n      store.exclusive(\n        Effect.gen(function* () {\n          const record = yield* load(input, \"content\");\n          yield* active(record);\n          if (record.input.strategy && ![\"auto\", \"proxy\"].includes(record.input.strategy))\n            return yield* failUpload(\"Conflict\");\n          yield* store.write({ ...record, state: \"uploading\", cleanupPending: true });\n          yield* storage.put({\n            key: record.stagingKey,\n            body: input.body,\n            contentLength: record.input.file.size,\n            maxBytes: record.input.file.size,\n            contentType: record.input.file.contentType,\n            condition: { _tag: \"CreateOnly\" },\n          });\n          yield* store.write({ ...record, state: \"uploading\", cleanupPending: true });\n          return status({ ...record, state: \"uploading\", cleanupPending: true });\n        }),\n      ),\n  };\n});\nexport class Uploads extends Context.Service<Uploads, Effect.Success<ReturnType<typeof make>>>()(\n  \"@effect-kit/storage/Uploads\",\n) {\n  static readonly make = make;\n  static layer<R>(options: UploadOptions<R>) {\n    return Layer.effect(Uploads, make(options));\n  }\n}\n"],"mappings":"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"}

package/dist/vercel/authorized-uploads.d.ts

@@ -0,0 +1,7 @@
+import { Storage } from "../core/storage.js";
+import "../index.js";
+import { UploadGrantDriver } from "../uploads/driver.js";
+import { VercelUploadGrants } from "./signing.js";
+import { Layer } from "effect";
+export declare const VercelAuthorizedUploads: Layer.Layer<UploadGrantDriver, never, Storage | VercelUploadGrants>;
+//# sourceMappingURL=authorized-uploads.d.ts.map

package/dist/vercel/authorized-uploads.js

@@ -0,0 +1,15 @@
+import { signedUploadDriver } from "../uploads/signed-driver.js";
+import { VercelUploadGrants } from "./signing.js";
+import { Effect, Layer } from "effect";
+
+// src/providers/vercel/authorized-uploads.ts
+const VercelAuthorizedUploads = Layer.unwrap(Effect.map(VercelUploadGrants, (grants) => signedUploadDriver((record, expiresInSeconds) => grants.create({
+	key: record.stagingKey,
+	expiresInSeconds,
+	maximumSizeInBytes: record.input.file.size,
+	allowedContentTypes: [record.input.file.contentType],
+	allowOverwrite: false
+}))));
+
+export { VercelAuthorizedUploads };
+//# sourceMappingURL=authorized-uploads.js.map

package/dist/vercel/authorized-uploads.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorized-uploads.js","names":[],"sources":["../../src/providers/vercel/authorized-uploads.ts"],"sourcesContent":["import { Effect, Layer } from \"effect\";\n\nimport { signedUploadDriver } from \"../../uploads/signed-driver.js\";\nimport { VercelUploadGrants } from \"./signing.js\";\nexport const VercelAuthorizedUploads = Layer.unwrap(\n  Effect.map(VercelUploadGrants, (grants) =>\n    signedUploadDriver((record, expiresInSeconds) =>\n      grants.create({\n        key: record.stagingKey,\n        expiresInSeconds,\n        maximumSizeInBytes: record.input.file.size,\n        allowedContentTypes: [record.input.file.contentType],\n        allowOverwrite: false,\n      }),\n    ),\n  ),\n);\n"],"mappings":";;;;;AAIA,MAAa,0BAA0B,MAAM,OAC3C,OAAO,IAAI,qBAAqB,WAC9B,oBAAoB,QAAQ,qBAC1B,OAAO,OAAO;CACZ,KAAK,OAAO;CACZ;CACA,oBAAoB,OAAO,MAAM,KAAK;CACtC,qBAAqB,CAAC,OAAO,MAAM,KAAK,WAAW;CACnD,gBAAgB;AAClB,CAAC,CACH,CACF,CACF"}

package/dist/vercel/client.d.ts

@@ -0,0 +1,16 @@
+import { StorageError } from "../core/errors.js";
+import "../index.js";
+import { Effect, Redacted } from "effect";
+/** Native browser upload flow. Managed browser transfers and framework handlers are completed in phase 11. */
+export declare const VercelClient: {
+  upload: (input: {
+    readonly key: string;
+    readonly file: Blob;
+    readonly access: "public" | "private";
+    readonly handleUploadUrl: string;
+    readonly clientPayload?: string;
+    readonly headers?: Redacted.Redacted<Readonly<Record<string, string>>>;
+    readonly multipart?: boolean;
+  }) => Effect.Effect<import("@vercel/blob").PutBlobResult, StorageError, never>;
+};
+//# sourceMappingURL=client.d.ts.map

package/dist/vercel/client.js

@@ -0,0 +1,28 @@
+import { storageError } from "../core/errors.js";
+import { providerError, validateKey } from "../providers/vercel/mapping.js";
+import { Effect, Redacted } from "effect";
+import { upload } from "@vercel/blob/client";
+
+// src/providers/vercel/client.ts
+/** Native browser upload flow. Managed browser transfers and framework handlers are completed in phase 11. */
+const VercelClient = { upload: Effect.fnUntraced(function* (input) {
+	yield* validateKey(input.key, "client.upload");
+	if (!(input.file instanceof Blob)) return yield* storageError("client.upload", "vercel", {
+		_tag: "InvalidInput",
+		field: "file"
+	}, "not-started");
+	return yield* Effect.tryPromise({
+		try: (signal) => upload(input.key, input.file, {
+			access: input.access,
+			handleUploadUrl: input.handleUploadUrl,
+			abortSignal: signal,
+			...input.clientPayload === void 0 ? {} : { clientPayload: input.clientPayload },
+			...input.headers ? { headers: Redacted.value(input.headers) } : {},
+			multipart: input.multipart ?? false
+		}),
+		catch: (error) => providerError("client.upload", true, error)
+	});
+}) };
+
+export { VercelClient };
+//# sourceMappingURL=client.js.map

package/dist/vercel/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","names":[],"sources":["../../src/providers/vercel/client.ts"],"sourcesContent":["import { Effect, Redacted } from \"effect\";\n\nimport { upload } from \"@vercel/blob/client\";\n\nimport { storageError } from \"../../core/errors.js\";\nimport { providerError, validateKey } from \"./mapping.js\";\n\n/** Native browser upload flow. Managed browser transfers and framework handlers are completed in phase 11. */\nexport const VercelClient = {\n  upload: Effect.fnUntraced(function* (input: {\n    readonly key: string;\n    readonly file: Blob;\n    readonly access: \"public\" | \"private\";\n    readonly handleUploadUrl: string;\n    readonly clientPayload?: string;\n    readonly headers?: Redacted.Redacted<Readonly<Record<string, string>>>;\n    readonly multipart?: boolean;\n  }) {\n    yield* validateKey(input.key, \"client.upload\");\n    if (!(input.file instanceof Blob))\n      return yield* storageError(\n        \"client.upload\",\n        \"vercel\",\n        { _tag: \"InvalidInput\", field: \"file\" },\n        \"not-started\",\n      );\n    return yield* Effect.tryPromise({\n      try: (signal) =>\n        upload(input.key, input.file, {\n          access: input.access,\n          handleUploadUrl: input.handleUploadUrl,\n          abortSignal: signal,\n          ...(input.clientPayload === undefined ? {} : { clientPayload: input.clientPayload }),\n          ...(input.headers ? { headers: Redacted.value(input.headers) } : {}),\n          multipart: input.multipart ?? false,\n        }),\n      catch: (error) => providerError(\"client.upload\", true, error),\n    });\n  }),\n};\n"],"mappings":";;;;;;;AAQA,MAAa,eAAe,EAC1B,QAAQ,OAAO,WAAW,WAAW,OAQlC;CACD,OAAO,YAAY,MAAM,KAAK,eAAe;CAC7C,IAAI,EAAE,MAAM,gBAAgB,OAC1B,OAAO,OAAO,aACZ,iBACA,UACA;EAAE,MAAM;EAAgB,OAAO;CAAO,GACtC,aACF;CACF,OAAO,OAAO,OAAO,WAAW;EAC9B,MAAM,WACJ,OAAO,MAAM,KAAK,MAAM,MAAM;GAC5B,QAAQ,MAAM;GACd,iBAAiB,MAAM;GACvB,aAAa;GACb,GAAI,MAAM,kBAAkB,SAAY,CAAC,IAAI,EAAE,eAAe,MAAM,cAAc;GAClF,GAAI,MAAM,UAAU,EAAE,SAAS,SAAS,MAAM,MAAM,OAAO,EAAE,IAAI,CAAC;GAClE,WAAW,MAAM,aAAa;EAChC,CAAC;EACH,QAAQ,UAAU,cAAc,iBAAiB,MAAM,KAAK;CAC9D,CAAC;AACH,CAAC,EACH"}

package/dist/vercel/signing.d.ts

@@ -0,0 +1,19 @@
+import { storageError } from "../core/errors.js";
+import { SignedRequest, StorageSigning } from "../core/capabilities.js";
+import { VercelStorage } from "../vercel.js";
+import { Context, Effect, Layer } from "effect";
+declare const VercelUploadGrants_base: Context.ServiceClass<VercelUploadGrants, "@effect-kit/storage/vercel/VercelUploadGrants", {
+  readonly create: (input: {
+    readonly key: string;
+    readonly expiresInSeconds: number;
+    readonly maximumSizeInBytes: number;
+    readonly allowedContentTypes?: ReadonlyArray<string>;
+    readonly allowOverwrite?: boolean;
+  }) => Effect.Effect<SignedRequest, ReturnType<typeof storageError>>;
+}>;
+export declare class VercelUploadGrants extends VercelUploadGrants_base {}
+export declare const VercelSigning: {
+  layer(): Layer.Layer<StorageSigning | VercelUploadGrants, never, VercelStorage>;
+};
+export {};
+//# sourceMappingURL=signing.d.ts.map

package/dist/vercel/signing.js

@@ -0,0 +1,120 @@
+import { ObjectKey } from "../core/object.js";
+import { storageError } from "../core/errors.js";
+import { StorageSigning } from "../core/capabilities.js";
+import { signingRequest } from "../internal/signing-request.js";
+import { validateKey } from "../providers/vercel/mapping.js";
+import { call } from "../providers/vercel/transport.js";
+import { VercelStorage } from "../vercel.js";
+import { Clock, Context, DateTime, Effect, Layer, Redacted, Schema } from "effect";
+import { issueSignedToken, parseStoreIdFromDelegationToken, presignUrl } from "@vercel/blob";
+
+// src/providers/vercel/signing.ts
+var VercelUploadGrants = class extends Context.Service()("@effect-kit/storage/vercel/VercelUploadGrants") {};
+const VercelSigning = { layer() {
+	return Layer.effectContext(Effect.gen(function* () {
+		const storage = yield* VercelStorage;
+		const issue = Effect.fnUntraced(function* (ref, method, expiresInSeconds, upload) {
+			yield* signingRequest({
+				ref,
+				method,
+				expiresInSeconds
+			}, "vercel");
+			yield* validateKey(ref.key, "sign");
+			if (ref.storeId !== storage.storeId || ref.version || /[*?#%\\]/u.test(ref.key)) return yield* storageError("sign", "vercel", {
+				_tag: "InvalidInput",
+				field: "ref"
+			}, "not-started");
+			const requestedExpiry = (yield* Clock.currentTimeMillis) + expiresInSeconds * 1e3;
+			const operation = method.toLowerCase();
+			const signed = yield* call(storage, "sign", false, (options) => issueSignedToken({
+				...options,
+				pathname: ref.key,
+				operations: [operation],
+				validUntil: requestedExpiry,
+				...upload ? {
+					maximumSizeInBytes: upload.maximumSizeInBytes,
+					...upload.allowedContentTypes ? { allowedContentTypes: [...upload.allowedContentTypes] } : {}
+				} : {}
+			}));
+			yield* Schema.decodeUnknownEffect(Schema.Struct({
+				validUntil: Schema.Natural,
+				delegationToken: Schema.NonEmptyString,
+				clientSigningToken: Schema.NonEmptyString
+			}))(signed).pipe(Effect.mapError(() => storageError("sign", "vercel", { _tag: "ProviderFailure" })));
+			if ((yield* Effect.try({
+				try: () => parseStoreIdFromDelegationToken(signed.delegationToken),
+				catch: () => storageError("sign", "vercel", { _tag: "ProviderFailure" })
+			})) !== storage.config.storeId) return yield* storageError("sign", "vercel", { _tag: "ProviderFailure" });
+			const expiry = Math.min(requestedExpiry, signed.validUntil);
+			if (expiry <= (yield* Clock.currentTimeMillis)) return yield* storageError("sign", "vercel", { _tag: "Expired" });
+			const result = yield* Effect.tryPromise({
+				try: () => presignUrl(signed, {
+					operation,
+					pathname: ref.key,
+					access: storage.config.access,
+					validUntil: expiry,
+					...operation === "put" ? {
+						addRandomSuffix: false,
+						allowOverwrite: upload?.allowOverwrite ?? false,
+						...upload ? {
+							maximumSizeInBytes: upload.maximumSizeInBytes,
+							...upload.allowedContentTypes ? { allowedContentTypes: [...upload.allowedContentTypes] } : {}
+						} : {}
+					} : {}
+				}),
+				catch: () => storageError("sign", "vercel", { _tag: "ProviderFailure" })
+			});
+			return {
+				method,
+				ref,
+				url: Redacted.make(result.presignedUrl),
+				headers: Redacted.make({}),
+				expiresAt: DateTime.makeUnsafe(expiry),
+				constraints: upload ? [
+					{
+						kind: "maximum-size",
+						value: upload.maximumSizeInBytes,
+						enforcement: "provider"
+					},
+					{
+						kind: "overwrite",
+						value: String(upload.allowOverwrite ?? false),
+						enforcement: "provider"
+					},
+					...upload.allowedContentTypes ? [{
+						kind: "content-types",
+						value: upload.allowedContentTypes.join(","),
+						enforcement: "provider"
+					}] : []
+				] : []
+			};
+		});
+		const create = Effect.fnUntraced(function* (input) {
+			yield* Schema.decodeUnknownEffect(Schema.Struct({
+				key: ObjectKey,
+				expiresInSeconds: Schema.Int.check(Schema.isBetween({
+					minimum: 1,
+					maximum: 604800
+				})),
+				maximumSizeInBytes: Schema.Int.check(Schema.isGreaterThan(0)),
+				allowedContentTypes: Schema.optional(Schema.Array(Schema.NonEmptyString).check(Schema.isMinLength(1))),
+				allowOverwrite: Schema.optional(Schema.Boolean)
+			}))(input).pipe(Effect.mapError(() => storageError("grant", "vercel", {
+				_tag: "InvalidInput",
+				field: "request"
+			}, "not-started")));
+			if (input.maximumSizeInBytes > storage.config.maxObjectBytes) return yield* storageError("grant", "vercel", {
+				_tag: "LimitExceeded",
+				limit: storage.config.maxObjectBytes
+			}, "not-started");
+			return yield* issue({
+				storeId: storage.storeId,
+				key: input.key
+			}, "PUT", input.expiresInSeconds, input);
+		});
+		return Context.make(StorageSigning, { sign: (input) => issue(input.ref, input.method, input.expiresInSeconds) }).pipe(Context.add(VercelUploadGrants, { create }));
+	}));
+} };
+
+export { VercelSigning, VercelUploadGrants };
+//# sourceMappingURL=signing.js.map

package/dist/vercel/signing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signing.js","names":[],"sources":["../../src/providers/vercel/signing.ts"],"sourcesContent":["import { Clock, Context, DateTime, Effect, Layer, Redacted, Schema } from \"effect\";\n\nimport { issueSignedToken, parseStoreIdFromDelegationToken, presignUrl } from \"@vercel/blob\";\nimport type { DelegationOperation } from \"@vercel/blob\";\n\nimport { StorageSigning } from \"../../core/capabilities.js\";\nimport type { SignedRequest } from \"../../core/capabilities.js\";\nimport { storageError } from \"../../core/errors.js\";\nimport type { ObjectRef } from \"../../core/object.js\";\nimport { ObjectKey } from \"../../core/object.js\";\nimport { signingRequest } from \"../../internal/signing-request.js\";\nimport { VercelStorage } from \"./index.js\";\nimport { validateKey } from \"./mapping.js\";\nimport { call } from \"./transport.js\";\n\nexport class VercelUploadGrants extends Context.Service<\n  VercelUploadGrants,\n  {\n    readonly create: (input: {\n      readonly key: string;\n      readonly expiresInSeconds: number;\n      readonly maximumSizeInBytes: number;\n      readonly allowedContentTypes?: ReadonlyArray<string>;\n      readonly allowOverwrite?: boolean;\n    }) => Effect.Effect<SignedRequest, ReturnType<typeof storageError>>;\n  }\n>()(\"@effect-kit/storage/vercel/VercelUploadGrants\") {}\n\nexport const VercelSigning = {\n  layer() {\n    return Layer.effectContext(\n      Effect.gen(function* () {\n        const storage = yield* VercelStorage;\n        const issue = Effect.fnUntraced(function* (\n          ref: ObjectRef,\n          method: SignedRequest[\"method\"],\n          expiresInSeconds: number,\n          upload?: {\n            maximumSizeInBytes: number;\n            allowedContentTypes?: ReadonlyArray<string>;\n            allowOverwrite?: boolean;\n          },\n        ) {\n          yield* signingRequest({ ref, method, expiresInSeconds }, \"vercel\");\n          yield* validateKey(ref.key, \"sign\");\n          if (ref.storeId !== storage.storeId || ref.version || /[*?#%\\\\]/u.test(ref.key))\n            return yield* storageError(\n              \"sign\",\n              \"vercel\",\n              { _tag: \"InvalidInput\", field: \"ref\" },\n              \"not-started\",\n            );\n          const now = yield* Clock.currentTimeMillis;\n          const requestedExpiry = now + expiresInSeconds * 1000;\n          const operation = method.toLowerCase() as DelegationOperation;\n          const signed = yield* call(storage, \"sign\", false, (options) =>\n            issueSignedToken({\n              ...options,\n              pathname: ref.key,\n              operations: [operation],\n              validUntil: requestedExpiry,\n              ...(upload\n                ? {\n                    maximumSizeInBytes: upload.maximumSizeInBytes,\n                    ...(upload.allowedContentTypes\n                      ? { allowedContentTypes: [...upload.allowedContentTypes] }\n                      : {}),\n                  }\n                : {}),\n            }),\n          );\n          yield* Schema.decodeUnknownEffect(\n            Schema.Struct({\n              validUntil: Schema.Natural,\n              delegationToken: Schema.NonEmptyString,\n              clientSigningToken: Schema.NonEmptyString,\n            }),\n          )(signed).pipe(\n            Effect.mapError(() => storageError(\"sign\", \"vercel\", { _tag: \"ProviderFailure\" })),\n          );\n          const signedStoreId = yield* Effect.try({\n            try: () => parseStoreIdFromDelegationToken(signed.delegationToken),\n            catch: () => storageError(\"sign\", \"vercel\", { _tag: \"ProviderFailure\" }),\n          });\n          if (signedStoreId !== storage.config.storeId)\n            return yield* storageError(\"sign\", \"vercel\", { _tag: \"ProviderFailure\" });\n          const expiry = Math.min(requestedExpiry, signed.validUntil);\n          if (expiry <= (yield* Clock.currentTimeMillis))\n            return yield* storageError(\"sign\", \"vercel\", { _tag: \"Expired\" });\n          const result = yield* Effect.tryPromise({\n            try: () =>\n              presignUrl(signed, {\n                operation,\n                pathname: ref.key,\n                access: storage.config.access,\n                validUntil: expiry,\n                ...(operation === \"put\"\n                  ? {\n                      addRandomSuffix: false,\n                      allowOverwrite: upload?.allowOverwrite ?? false,\n                      ...(upload\n                        ? {\n                            maximumSizeInBytes: upload.maximumSizeInBytes,\n                            ...(upload.allowedContentTypes\n                              ? { allowedContentTypes: [...upload.allowedContentTypes] }\n                              : {}),\n                          }\n                        : {}),\n                    }\n                  : {}),\n              }),\n            catch: () => storageError(\"sign\", \"vercel\", { _tag: \"ProviderFailure\" }),\n          });\n          return {\n            method,\n            ref,\n            url: Redacted.make(result.presignedUrl),\n            headers: Redacted.make({}),\n            expiresAt: DateTime.makeUnsafe(expiry),\n            constraints: upload\n              ? [\n                  {\n                    kind: \"maximum-size\",\n                    value: upload.maximumSizeInBytes,\n                    enforcement: \"provider\" as const,\n                  },\n                  {\n                    kind: \"overwrite\",\n                    value: String(upload.allowOverwrite ?? false),\n                    enforcement: \"provider\" as const,\n                  },\n                  ...(upload.allowedContentTypes\n                    ? [\n                        {\n                          kind: \"content-types\",\n                          value: upload.allowedContentTypes.join(\",\"),\n                          enforcement: \"provider\" as const,\n                        },\n                      ]\n                    : []),\n                ]\n              : [],\n          } satisfies SignedRequest;\n        });\n        const create: VercelUploadGrants[\"Service\"][\"create\"] = Effect.fnUntraced(\n          function* (input) {\n            yield* Schema.decodeUnknownEffect(\n              Schema.Struct({\n                key: ObjectKey,\n                expiresInSeconds: Schema.Int.check(\n                  Schema.isBetween({ minimum: 1, maximum: 604800 }),\n                ),\n                maximumSizeInBytes: Schema.Int.check(Schema.isGreaterThan(0)),\n                allowedContentTypes: Schema.optional(\n                  Schema.Array(Schema.NonEmptyString).check(Schema.isMinLength(1)),\n                ),\n                allowOverwrite: Schema.optional(Schema.Boolean),\n              }),\n            )(input).pipe(\n              Effect.mapError(() =>\n                storageError(\n                  \"grant\",\n                  \"vercel\",\n                  { _tag: \"InvalidInput\", field: \"request\" },\n                  \"not-started\",\n                ),\n              ),\n            );\n            if (input.maximumSizeInBytes > storage.config.maxObjectBytes)\n              return yield* storageError(\n                \"grant\",\n                \"vercel\",\n                { _tag: \"LimitExceeded\", limit: storage.config.maxObjectBytes },\n                \"not-started\",\n              );\n            return yield* issue(\n              { storeId: storage.storeId, key: input.key },\n              \"PUT\",\n              input.expiresInSeconds,\n              input,\n            );\n          },\n        );\n        return Context.make(StorageSigning, {\n          sign: (input) => issue(input.ref, input.method, input.expiresInSeconds),\n        }).pipe(Context.add(VercelUploadGrants, { create }));\n      }),\n    );\n  },\n};\n"],"mappings":"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"}