better-supabase 0.13.0 → 0.15.0

package/dist/blocks/assignment/index.js

@@ -0,0 +1,141 @@
+import { A as requiredInstant, B as dbTransport, D as recordOf, H as rpcTransport, I as textOf, S as optionalInstant, U as sqlTransport, d as enumOrThrow, k as recordsOf, n as applyTemporal, o as blockCall } from "../../block-helpers-CtBdjgO4.js";
+import { i as wrapTransport, n as extendBlock, r as withBlockHooks } from "../../block-hooks-BfxX3682.js";
+import { n as entitySchema } from "../../entity-schema-BDv6w-OQ.js";
+import { n as event, t as defineEvents } from "../../event-map-CtPFhcOp.js";
+import { n as defineBlock } from "../../define-block-BGqOO8B3.js";
+import { t as conditionsOf } from "../../automations-BYsz43AG.js";
+//#region src/blocks/assignment/assignment.ts
+const STRATEGIES = ["round_robin", "weighted"];
+const strategyOf = (value) => enumOrThrow(value, STRATEGIES, "assignment strategy");
+function memberOf(row) {
+	return {
+		userId: textOf(row["userId"]),
+		weight: Number(row["weight"]),
+		active: row["active"] === true,
+		assignedCount: Number(row["assignedCount"]),
+		lastAssignedAt: optionalInstant(row["lastAssignedAt"])
+	};
+}
+function queueOf(value) {
+	const row = recordOf(value, "assignment queue");
+	const conditions = row["conditions"];
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organizationId"]),
+		name: textOf(row["name"]),
+		subjectType: textOf(row["subjectType"]),
+		strategy: strategyOf(row["strategy"]),
+		conditions: conditions === null || conditions === void 0 ? void 0 : conditionsOf(conditions),
+		rank: Number(row["rank"]),
+		enabled: row["enabled"] === true,
+		members: recordsOf(row["members"], "assignment queue members").map(memberOf),
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt")
+	};
+}
+const optionalId = (value) => typeof value === "string" ? value : void 0;
+function createAssignment(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	return withBlockHooks({
+		saveQueue: (organizationId, queue) => call("save_assignment_queue", {
+			tenant: organizationId,
+			queue
+		}, queueOf),
+		setMembers: (queueId, members) => call("set_assignment_members", {
+			queue: queueId,
+			members
+		}, queueOf),
+		removeQueue: (queueId) => call("remove_assignment_queue", { queue: queueId }, (value) => value === true),
+		queues: (organizationId, list = {}) => call("list_assignment_queues", {
+			tenant: organizationId,
+			subject_type: list.subjectType ?? null
+		}, (value) => recordsOf(value, "list_assignment_queues").map(queueOf)),
+		assign: (organizationId, subject) => call("assign_subject", {
+			tenant: organizationId,
+			subject_type: subject.type,
+			subject_id: subject.id,
+			subject: subject.fields ?? {}
+		}, (value) => {
+			if (value === null || value === void 0) return;
+			const row = recordOf(value, "assign_subject");
+			return {
+				queueId: textOf(row["queueId"]),
+				userId: textOf(row["userId"]),
+				strategy: strategyOf(row["strategy"])
+			};
+		}),
+		history: (organizationId, subject, page = {}) => call("assignment_history", {
+			tenant: organizationId,
+			subject_type: subject.type,
+			subject_id: subject.id,
+			max_count: page.limit ?? null
+		}, (value) => recordsOf(value, "assignment_history").map((row) => ({
+			queueId: optionalId(row["queueId"]),
+			userId: optionalId(row["userId"]),
+			assignedAt: requiredInstant(row["assignedAt"], "assignedAt")
+		})))
+	}, options.hooks, {
+		block: "assignment",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/assignment/events.ts
+/** The `assignment` block's event types, for its manifest and `onBlockEvent`. */
+const assignmentEvents = defineEvents({ "subject.assigned": event() });
+//#endregion
+//#region src/blocks/assignment/schemas.ts
+/** What `saveQueue` takes. The SQL checks the territory against the rule fields. */
+const assignmentQueueInputSchema = entitySchema({
+	title: "AssignmentQueueInput",
+	fields: {
+		id: {
+			kind: "uuid",
+			optional: true
+		},
+		name: {
+			kind: "string",
+			minLength: 1,
+			maxLength: 200,
+			optional: true
+		},
+		subjectType: {
+			kind: "string",
+			minLength: 1,
+			maxLength: 63,
+			optional: true
+		},
+		strategy: {
+			kind: "enum",
+			values: ["round_robin", "weighted"],
+			optional: true
+		},
+		conditions: {
+			kind: "json",
+			optional: true,
+			description: "The territory, a FilterQuery over the rule fields."
+		},
+		rank: {
+			kind: "integer",
+			optional: true
+		},
+		enabled: {
+			kind: "boolean",
+			optional: true
+		}
+	}
+});
+//#endregion
+//#region src/blocks/assignment/manifest.ts
+/** The `assignment` block's manifest (ADR 0029). */
+const assignmentBlock = defineBlock({
+	name: "assignment",
+	sql: ["assignment"],
+	events: assignmentEvents,
+	schemas: { assignment_queue: { input: assignmentQueueInputSchema } },
+	create: createAssignment,
+	category: "crm"
+});
+//#endregion
+export { assignmentBlock, assignmentEvents, assignmentQueueInputSchema, createAssignment, dbTransport, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

package/dist/blocks/attachments/index.d.ts

@@ -1,19 +1,143 @@
-import { ot as StorageObjectEventData, wt as Events, y as AttachmentEventData } from "../../events-DhGgwqQA.js";
-import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DBPhgF3W.js";
-import { s as BlockOf } from "../../define-block-MyM4lH42.js";
-import { C as createAttachments, S as createAttachmentScanner, _ as ObjectScanJob, a as Attachment, b as ScanVerdict, c as AttachmentScanJob, d as AttachmentStatus, f as AttachmentStorage, g as NewAttachment, h as AttachmentsOptions, l as AttachmentScanner, m as Attachments, o as AttachmentBucket, p as AttachmentUpload, s as AttachmentDownload, u as AttachmentScannerOptions, v as ObjectScanner, w as createObjectScanner, x as ScannedObject, y as ObjectScannerOptions } from "../../ports-BltcWsHf.js";
+import { b as DbError, f as Result } from "../../result-DZeA5KS6.js";
+import { Ct as Events, ot as StorageObjectEventData, y as AttachmentEventData } from "../../events-vcqenSYU.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DWZSJrwN.js";
+import { t as Author } from "../../block-authors-DzXLUiIq.js";
+import { At as NewAttachment, Ct as AttachmentScannerOptions, Dt as AttachmentVersion, Et as AttachmentUpload, Ft as ScannedObject, It as attachmentVersionOf, Lt as createAttachmentScanner, Mt as ObjectScanner, Nt as ObjectScannerOptions, Ot as Attachments, Pt as ScanVerdict, Rt as createAttachments, Sn as EntitySchema, St as AttachmentScanner, Tt as AttachmentStorage, _t as AttachmentDownload, bt as AttachmentReplacement, c as BlockOf, gt as AttachmentBucket, ht as Attachment, jt as ObjectScanJob, kt as AttachmentsOptions, ln as RecordBindingWrite, mn as RecordRowInput, rn as RecordBinding, vt as AttachmentImageUrlOptions, wt as AttachmentStatus, xt as AttachmentScanJob, yt as AttachmentImages, zt as createObjectScanner } from "../../define-block-BVcLQ3DF.js";
+import { n as Controller } from "../../controller-BrP0gn47.js";
+//#region src/blocks/attachments/record-binding.d.ts
+/** A pending write to a record's files, for `useOptimistic`. */
+type AttachmentsOptimisticAction = {
+  readonly type: "add";
+  readonly attachment: Attachment;
+} | {
+  readonly type: "update";
+  readonly attachment: Attachment;
+} | {
+  readonly type: "remove";
+  readonly id: string;
+};
+/**
+ * The files with a pending write applied: `add` puts the attachment first (or
+ * replaces the one with the same id), `update` swaps the one with the same id
+ * where it is (a new version from `replace` or `restore`), `remove` takes it
+ * out.
+ */
+export declare function attachmentsOptimistic(state: readonly Attachment[], action: AttachmentsOptimisticAction): readonly Attachment[];
+/**
+ * The writes of the attachments binding. An upload takes two steps through the
+ * browser (`upload`, then `confirm`), so it isn't one.
+ */
+type AttachmentsWrites = {
+  /** Removes one file. */
+  readonly remove: RecordBindingWrite<Attachments, RecordRowInput, boolean>;
+};
+/** A record's files. */
+export declare const attachmentsBinding: RecordBinding<Attachments, readonly Attachment[], never, AttachmentsOptimisticAction, AttachmentsWrites>;
+//#endregion
 //#region src/blocks/attachments/events.d.ts
 /** The events of the `attachments` block: type to data. */
 type AttachmentsEvents = {
   readonly "object.uploaded": StorageObjectEventData;
   readonly "attachment.uploaded": AttachmentEventData;
   readonly "attachment.scanned": AttachmentEventData;
+  readonly "attachment.replaced": AttachmentEventData;
+  readonly "attachment.restored": AttachmentEventData;
 };
 /** The `attachments` block's event types, for its manifest and `onBlockEvent`. */
 export declare const attachmentsEvents: Events<AttachmentsEvents>;
 //#endregion
 //#region src/blocks/attachments/manifest.d.ts
 /** The `attachments` block's manifest (ADR 0029). */
-export declare const attachmentsBlock: BlockOf<"attachments", typeof createAttachments, AttachmentsEvents, Record<never, never>, "attachments">;
+export declare const attachmentsBlock: BlockOf<"attachments", typeof createAttachments, AttachmentsEvents, Record<never, never>, "attachments", typeof attachmentsBinding>;
+//#endregion
+//#region src/blocks/attachments/schemas.d.ts
+/** What `upload` takes after the subject, with the bounds the SQL checks. */
+export declare const attachmentInputSchema: EntitySchema<NewAttachment>;
+//#endregion
+//#region src/blocks/attachments/client.d.ts
+/** Where `start` told the browser to send the bytes. */
+interface AttachmentUploadTicket {
+  readonly id: string;
+  /** The signed upload URL from `attachments.upload` or `replace`. */
+  readonly signedUrl: string;
+}
+/** What `confirm` and `refresh` answer: `null` when the caller can't tell. */
+type AttachmentScanState = {
+  readonly status: AttachmentStatus;
+} | null;
+/** One file to upload. */
+interface AttachmentFileInput {
+  readonly file: Blob;
+  readonly name: string;
+  /** Default the blob's `type`, or `application/octet-stream`. */
+  readonly mimeType?: string;
+  readonly width?: number;
+  readonly height?: number;
+  readonly pages?: number;
+}
+/**
+ * Sends `body` to the signed URL and reports the share sent, from 0 to 1. The
+ * default PUTs it with `XMLHttpRequest`, which React DOM and React Native both
+ * have.
+ */
+type AttachmentSend = (ticket: AttachmentUploadTicket, body: Blob, progress: (fraction: number) => void, signal: AbortSignal) => Promise<Result<null>>;
+interface AttachmentUploadControllerOptions {
+  /**
+   * Creates the pending record and signs the upload:
+   * `attachments.upload(subject, file)`, or a server action that calls it.
+   */
+  readonly start: (file: NewAttachment) => PromiseLike<Result<AttachmentUploadTicket>>;
+  /** Marks the upload done: `attachments.confirm(id)`, or a server action. */
+  readonly confirm: (id: string) => PromiseLike<Result<AttachmentScanState>>;
+  /**
+   * Reads the file's scan status again, so an upload waits in `scanning` until
+   * the scanner answers. Without it an upload ends once confirmed.
+   */
+  readonly refresh?: (id: string) => PromiseLike<Result<AttachmentScanState>>;
+  readonly send?: AttachmentSend;
+  /** Milliseconds between scan checks. Default 2000. */
+  readonly pollInterval?: number;
+  /** Runs once a file is uploaded (and scanned clean, with `refresh`). */
+  readonly onUploaded?: (id: string) => void | Promise<void>;
+}
+type AttachmentUploadStatus = "uploading" | "confirming" | "scanning" | "done" | "blocked" | "error";
+interface AttachmentUploadItem {
+  /** A local key, stable for the upload's life. */
+  readonly key: string;
+  readonly name: string;
+  readonly mimeType: string;
+  readonly size: number;
+  readonly status: AttachmentUploadStatus;
+  /** The share of the bytes sent, from 0 to 1. */
+  readonly progress: number;
+  /** The attachment id once `start` created the record. */
+  readonly id: string | undefined;
+  readonly error: DbError | undefined;
+}
+interface AttachmentUploadSnapshot {
+  readonly uploads: readonly AttachmentUploadItem[];
+  /** Whether any upload is still sending, confirming or waiting for its scan. */
+  readonly busy: boolean;
+}
+interface AttachmentUploadActions {
+  /** Starts uploading each file, side by side. */
+  readonly add: (files: readonly AttachmentFileInput[]) => void;
+  /** Starts a failed upload again from the beginning. */
+  readonly retry: (key: string) => void;
+  /** Stops an upload and drops it from the list. */
+  readonly dismiss: (key: string) => void;
+  /** Drops the uploads that ended. */
+  readonly clear: () => void;
+}
+type AttachmentUploadController = Controller<AttachmentUploadSnapshot, AttachmentUploadActions>;
+/** The default `send`: a PUT to the signed URL with upload progress. */
+export declare const xhrSend: AttachmentSend;
+/**
+ * Uploads files to a record: each one is created (`start`), sent to its signed
+ * URL with progress (`send`), confirmed (`confirm`) and, with `refresh`,
+ * watched until the scan answers. Uploads run side by side; a failed one stays
+ * in the list with its error until it is retried or dismissed.
+ */
+export declare function createAttachmentUploadController(options: AttachmentUploadControllerOptions): AttachmentUploadController;
 //#endregion
-export { type Attachment, type AttachmentBucket, type AttachmentDownload, type AttachmentScanJob, type AttachmentScanner, type AttachmentScannerOptions, type AttachmentStatus, type AttachmentStorage, type AttachmentUpload, type Attachments, type AttachmentsEvents, type AttachmentsOptions, type BlockTransport, type NewAttachment, type ObjectScanJob, type ObjectScanner, type ObjectScannerOptions, type ScanVerdict, type ScannedObject, createAttachmentScanner, createAttachments, createObjectScanner, dbTransport, rpcTransport, sqlTransport };
+export { type Attachment, type AttachmentBucket, type AttachmentDownload, type AttachmentFileInput, type AttachmentImageUrlOptions, type AttachmentImages, type AttachmentReplacement, type AttachmentScanJob, type AttachmentScanState, type AttachmentScanner, type AttachmentScannerOptions, type AttachmentSend, type AttachmentStatus, type AttachmentStorage, type AttachmentUpload, type AttachmentUploadActions, type AttachmentUploadController, type AttachmentUploadControllerOptions, type AttachmentUploadItem, type AttachmentUploadSnapshot, type AttachmentUploadStatus, type AttachmentUploadTicket, type AttachmentVersion, type Attachments, type AttachmentsEvents, type AttachmentsOptimisticAction, type AttachmentsOptions, type AttachmentsWrites, type Author, type BlockTransport, type NewAttachment, type ObjectScanJob, type ObjectScanner, type ObjectScannerOptions, type ScanVerdict, type ScannedObject, attachmentVersionOf, createAttachmentScanner, createAttachments, createObjectScanner, dbTransport, rpcTransport, sqlTransport };

package/dist/blocks/attachments/index.js

@@ -1,14 +1,99 @@
-import { t as attachmentsSqlOptions } from "../../options-CyD7OObW.js";
+import { n as dbError } from "../../errors-BVFgt8BZ.js";
+import { a as ok, r as err, s as toDbError } from "../../result-ntFBW2p2.js";
+import { t as attachmentsSqlOptions } from "../../options-CtUUU71w.js";
+import { t as defineController } from "../../controller-BEliOBOv.js";
+import { B as dbTransport, H as rpcTransport, U as sqlTransport } from "../../block-helpers-CtBdjgO4.js";
+import { n as entitySchema } from "../../entity-schema-BDv6w-OQ.js";
+import { i as recordRowInput, t as defineRecordBinding } from "../../record-bindings-DkBJpC5A.js";
 import { n as event, t as defineEvents } from "../../event-map-CtPFhcOp.js";
-import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-Ds0C2mUf.js";
-import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
-import { i as createObjectScanner, n as createAttachmentScanner, r as createAttachments } from "../../attachments-CPkGJVfk.js";
+import { n as defineBlock } from "../../define-block-BGqOO8B3.js";
+import { a as createObjectScanner, i as createAttachments, n as attachmentVersionOf, r as createAttachmentScanner } from "../../attachments-aJYgdYtB.js";
 //#region src/blocks/attachments/events.ts
 /** The `attachments` block's event types, for its manifest and `onBlockEvent`. */
 const attachmentsEvents = defineEvents({
 	"object.uploaded": event(),
 	"attachment.uploaded": event(),
-	"attachment.scanned": event()
+	"attachment.scanned": event(),
+	"attachment.replaced": event(),
+	"attachment.restored": event()
+});
+//#endregion
+//#region src/blocks/attachments/record-binding.ts
+/**
+* The files with a pending write applied: `add` puts the attachment first (or
+* replaces the one with the same id), `update` swaps the one with the same id
+* where it is (a new version from `replace` or `restore`), `remove` takes it
+* out.
+*/
+function attachmentsOptimistic(state, action) {
+	switch (action.type) {
+		case "add": return [action.attachment, ...state.filter((attachment) => attachment.id !== action.attachment.id)];
+		case "update": return state.map((attachment) => attachment.id === action.attachment.id ? action.attachment : attachment);
+		case "remove": return state.filter((attachment) => attachment.id !== action.id);
+		default: return action;
+	}
+}
+/** A record's files. */
+const attachmentsBinding = defineRecordBinding({
+	permissions: {
+		read: "read",
+		write: "upload"
+	},
+	load: (client, subject) => client.list(subject),
+	timeline: (attachments) => attachments.map((attachment) => ({
+		id: attachment.id,
+		kind: "attachment",
+		at: attachment.uploadedAt ?? attachment.createdAt,
+		...attachment.uploadedBy === void 0 ? {} : { actor: attachment.uploadedBy },
+		row: attachment
+	})),
+	events: ["attachment.*"],
+	optimistic: attachmentsOptimistic,
+	writes: { remove: {
+		permission: "manage",
+		input: recordRowInput,
+		run: (client, _subject, { id }) => client.remove(id)
+	} }
+});
+//#endregion
+//#region src/blocks/attachments/schemas.ts
+/** What `upload` takes after the subject, with the bounds the SQL checks. */
+const attachmentInputSchema = entitySchema({
+	title: "NewAttachment",
+	fields: {
+		name: {
+			kind: "string",
+			minLength: 1,
+			maxLength: 255
+		},
+		mimeType: {
+			kind: "string",
+			minLength: 1
+		},
+		size: {
+			kind: "integer",
+			minimum: 0
+		},
+		metadata: {
+			kind: "json",
+			optional: true
+		},
+		width: {
+			kind: "integer",
+			minimum: 1,
+			optional: true
+		},
+		height: {
+			kind: "integer",
+			minimum: 1,
+			optional: true
+		},
+		pages: {
+			kind: "integer",
+			minimum: 1,
+			optional: true
+		}
+	}
 });
 //#endregion
 //#region src/blocks/attachments/manifest.ts
@@ -18,10 +103,246 @@ const attachmentsBlock = defineBlock({
 	sql: ["attachments"],
 	options: { attachments: attachmentsSqlOptions },
 	events: attachmentsEvents,
+	schemas: { attachment: { input: attachmentInputSchema } },
 	provides: { attachments: (client) => client },
 	create: createAttachments,
+	record: attachmentsBinding,
 	category: "collaboration",
-	recipes: ["attachments-uploader"]
+	recipes: [
+		"attachments-uploader",
+		"subject-timeline",
+		"message-composer"
+	]
+});
+//#endregion
+//#region src/blocks/attachments/client.ts
+const uploadFailed = (status) => dbError("network", status === void 0 ? "The upload did not reach Storage" : `Storage refused the upload (${String(status)})`, { hint: "ATTACHMENT_UPLOAD_FAILED" });
+/** The default `send`: a PUT to the signed URL with upload progress. */
+const xhrSend = (ticket, body, progress, signal) => new Promise((resolve) => {
+	const Request = globalThis.XMLHttpRequest;
+	if (Request === void 0) {
+		resolve(err(dbError("invalid_request", "This runtime has no XMLHttpRequest", { hint: "ATTACHMENT_UPLOAD_FAILED" })));
+		return;
+	}
+	const request = new Request();
+	request.open("PUT", ticket.signedUrl);
+	request.setRequestHeader("x-upsert", "false");
+	if (body.type !== "") request.setRequestHeader("content-type", body.type);
+	request.upload.addEventListener("progress", (event) => {
+		if (event.total > 0) progress(event.loaded / event.total);
+	});
+	request.addEventListener("load", () => {
+		resolve(request.status >= 200 && request.status < 300 ? ok(null) : err(uploadFailed(request.status)));
+	});
+	request.addEventListener("error", () => {
+		resolve(err(uploadFailed()));
+	});
+	request.addEventListener("abort", () => {
+		resolve(err(dbError("aborted", "The upload was stopped")));
+	});
+	signal.addEventListener("abort", () => {
+		request.abort();
+	});
+	request.send(body);
 });
+const ENDED = /* @__PURE__ */ new Set([
+	"done",
+	"blocked",
+	"error"
+]);
+const scanFailed = () => dbError("raised", "The malware scan failed", { hint: "ATTACHMENT_SCAN_FAILED" });
+/**
+* Uploads files to a record: each one is created (`start`), sent to its signed
+* URL with progress (`send`), confirmed (`confirm`) and, with `refresh`,
+* watched until the scan answers. Uploads run side by side; a failed one stays
+* in the list with its error until it is retried or dismissed.
+*/
+function createAttachmentUploadController(options) {
+	const send = options.send ?? xhrSend;
+	const interval = options.pollInterval ?? 2e3;
+	return defineController({
+		uploads: [],
+		busy: false
+	}, (state) => {
+		let counter = 0;
+		const inputs = /* @__PURE__ */ new Map();
+		const aborts = /* @__PURE__ */ new Map();
+		const timers = /* @__PURE__ */ new Set();
+		const patch = (key, change) => {
+			state.set((current) => {
+				const uploads = current.uploads.map((item) => item.key === key ? {
+					...item,
+					...change
+				} : item);
+				return {
+					uploads,
+					busy: uploads.some((item) => !ENDED.has(item.status))
+				};
+			});
+		};
+		const alive = (key, signal) => !signal.aborted && inputs.has(key);
+		const finish = async (key, id) => {
+			patch(key, {
+				status: "done",
+				progress: 1
+			});
+			try {
+				await options.onUploaded?.(id);
+			} catch (cause) {
+				patch(key, { error: toDbError(cause) });
+			}
+		};
+		const settle = async (key, id, scan, signal) => {
+			if (!alive(key, signal)) return;
+			if (scan?.status === "infected") {
+				patch(key, { status: "blocked" });
+				return;
+			}
+			if (scan?.status === "failed") {
+				patch(key, {
+					status: "error",
+					error: scanFailed()
+				});
+				return;
+			}
+			if (scan === null || scan.status === "clean" || options.refresh === void 0) {
+				await finish(key, id);
+				return;
+			}
+			patch(key, { status: "scanning" });
+			const { refresh } = options;
+			const timer = setTimeout(() => {
+				timers.delete(timer);
+				Promise.resolve(refresh(id)).then(async (next) => {
+					if (!next.ok) {
+						if (alive(key, signal)) patch(key, {
+							status: "error",
+							error: next.error
+						});
+						return;
+					}
+					await settle(key, id, next.data, signal);
+				});
+			}, interval);
+			timers.add(timer);
+		};
+		const run = async (key) => {
+			const input = inputs.get(key);
+			if (input === void 0) return;
+			const abort = new AbortController();
+			aborts.get(key)?.abort();
+			aborts.set(key, abort);
+			const { signal } = abort;
+			patch(key, {
+				status: "uploading",
+				progress: 0,
+				error: void 0,
+				id: void 0
+			});
+			const fail = (error) => {
+				if (alive(key, signal)) patch(key, {
+					status: "error",
+					error
+				});
+			};
+			const started = await options.start({
+				name: input.name,
+				mimeType: mimeOf(input),
+				size: input.file.size,
+				...input.width === void 0 ? {} : { width: input.width },
+				...input.height === void 0 ? {} : { height: input.height },
+				...input.pages === void 0 ? {} : { pages: input.pages }
+			});
+			if (!started.ok) {
+				fail(started.error);
+				return;
+			}
+			const ticket = started.data;
+			if (!alive(key, signal)) return;
+			patch(key, { id: ticket.id });
+			const sent = await send(ticket, input.file, (fraction) => {
+				if (alive(key, signal)) patch(key, { progress: Math.min(1, Math.max(0, fraction)) });
+			}, signal);
+			if (!sent.ok) {
+				fail(sent.error);
+				return;
+			}
+			if (!alive(key, signal)) return;
+			patch(key, {
+				status: "confirming",
+				progress: 1
+			});
+			const confirmed = await options.confirm(ticket.id);
+			if (!confirmed.ok) {
+				fail(confirmed.error);
+				return;
+			}
+			await settle(key, ticket.id, confirmed.data, signal);
+		};
+		const add = (files) => {
+			const added = files.map((input) => {
+				counter += 1;
+				const key = `upload-${String(counter)}`;
+				inputs.set(key, input);
+				return {
+					key,
+					name: input.name,
+					mimeType: mimeOf(input),
+					size: input.file.size,
+					status: "uploading",
+					progress: 0,
+					id: void 0,
+					error: void 0
+				};
+			});
+			if (added.length === 0) return;
+			state.set((current) => ({
+				uploads: [...current.uploads, ...added],
+				busy: true
+			}));
+			for (const item of added) run(item.key);
+		};
+		const drop = (keep) => {
+			state.set((current) => {
+				const uploads = current.uploads.filter((item) => {
+					if (keep(item)) return true;
+					inputs.delete(item.key);
+					aborts.get(item.key)?.abort();
+					aborts.delete(item.key);
+					return false;
+				});
+				return {
+					uploads,
+					busy: uploads.some((item) => !ENDED.has(item.status))
+				};
+			});
+		};
+		return {
+			actions: {
+				add,
+				retry: (key) => {
+					if (state.get().uploads.find((each) => each.key === key)?.status === "error") run(key);
+				},
+				dismiss: (key) => {
+					drop((item) => item.key !== key);
+				},
+				clear: () => {
+					drop((item) => !ENDED.has(item.status));
+				}
+			},
+			start: () => {
+				for (const item of state.get().uploads) {
+					const signal = aborts.get(item.key)?.signal;
+					if (item.status === "scanning" && item.id !== void 0 && signal) settle(item.key, item.id, { status: "pending" }, signal);
+				}
+				return () => {
+					for (const timer of timers) clearTimeout(timer);
+					timers.clear();
+				};
+			}
+		};
+	});
+}
+const mimeOf = (input) => input.mimeType ?? (input.file.type || "application/octet-stream");
 //#endregion
-export { attachmentsBlock, attachmentsEvents, createAttachmentScanner, createAttachments, createObjectScanner, dbTransport, rpcTransport, sqlTransport };
+export { attachmentInputSchema, attachmentVersionOf, attachmentsBinding, attachmentsBlock, attachmentsEvents, attachmentsOptimistic, createAttachmentScanner, createAttachmentUploadController, createAttachments, createObjectScanner, dbTransport, rpcTransport, sqlTransport, xhrSend };