better-supabase 0.12.0 → 0.14.0

package/dist/ai-files-ChFDkMLN.js

@@ -1,339 +0,0 @@
-import { n as dbError } from "./errors-BV1SKTVs.js";
-import { a as ok, r as err, t as AsyncResult } from "./result-DIeYscA3.js";
-import { n as isRecord } from "./guards-6F2bCtQR.js";
-import { t as fromStorageError } from "./errors-D3BR8iUk.js";
-import { C as optionalText, D as recordOf, I as textOf, S as optionalInstant, _ as notFoundError, b as oneOf, h as instantOf, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall } from "./block-helpers-DkVZNDrj.js";
-import { r as withBlockHooks } from "./block-hooks-C22vuIUd.js";
-import { c as withFields, n as blockFields, r as extraFieldsArg, t as allWithFields } from "./block-fields-Bv1hV855.js";
-import { n as claimsUploads, t as claimUpload } from "./upload-claim-BBFCZbBF.js";
-//#region src/blocks/ai-files/rows.ts
-const FILE_STATUSES = [
-	"pending",
-	"ready",
-	"failed"
-];
-const FILE_SOURCES = [
-	"upload",
-	"generated",
-	"provider"
-];
-const DOCUMENT_KINDS = [
-	"text",
-	"code",
-	"sheet",
-	"image"
-];
-function fileOf(value) {
-	const row = recordOf(value, "ai_files");
-	return {
-		id: textOf(row["id"]),
-		organizationId: textOf(row["organization_id"]),
-		ownerId: textOf(row["owner_id"]),
-		chatId: optionalText(row["chat_id"]),
-		projectId: optionalText(row["project_id"]),
-		bucket: textOf(row["bucket"]),
-		path: textOf(row["path"]),
-		mediaType: textOf(row["media_type"]),
-		filename: textOf(row["filename"]),
-		size: Number(row["byte_size"] ?? 0),
-		sha256: optionalText(row["sha256"]),
-		status: oneOf(textOf(row["status"]), FILE_STATUSES, "failed"),
-		source: oneOf(textOf(row["source"]), FILE_SOURCES, "upload"),
-		createdAt: instantOf(row["created_at"]),
-		uploadedAt: optionalInstant(row["uploaded_at"]),
-		expiresAt: optionalInstant(row["expires_at"])
-	};
-}
-function providerFileOf(value) {
-	const row = recordOf(value, "ai_provider_files");
-	return {
-		fileId: textOf(row["file_id"]),
-		provider: textOf(row["provider"]),
-		reference: textOf(row["reference"]),
-		expiresAt: optionalInstant(row["expires_at"])
-	};
-}
-function documentOf(value) {
-	const row = recordOf(value, "ai_documents");
-	return {
-		id: textOf(row["id"]),
-		organizationId: textOf(row["organization_id"]),
-		ownerId: textOf(row["owner_id"]),
-		chatId: optionalText(row["chat_id"]),
-		kind: oneOf(textOf(row["kind"]), DOCUMENT_KINDS, "text"),
-		title: textOf(row["title"]),
-		version: Number(row["current_version"] ?? 1),
-		createdAt: instantOf(row["created_at"]),
-		updatedAt: instantOf(row["updated_at"])
-	};
-}
-function versionOf(value) {
-	const row = recordOf(value, "ai_document_versions");
-	return {
-		documentId: textOf(row["document_id"]),
-		version: Number(row["version"]),
-		content: optionalText(row["content"]),
-		storagePath: optionalText(row["storage_path"]),
-		messageId: optionalText(row["created_by_message_id"]),
-		createdBy: optionalText(row["created_by"]),
-		createdAt: instantOf(row["created_at"])
-	};
-}
-function suggestionOf(value) {
-	const row = recordOf(value, "ai_suggestions");
-	const accepted = row["accepted"];
-	return {
-		id: textOf(row["id"]),
-		documentId: textOf(row["document_id"]),
-		version: Number(row["version"]),
-		originalText: textOf(row["original_text"]),
-		suggestedText: textOf(row["suggested_text"]),
-		description: optionalText(row["description"]),
-		createdBy: optionalText(row["created_by"]),
-		createdAt: instantOf(row["created_at"]),
-		resolvedAt: optionalInstant(row["resolved_at"]),
-		accepted: typeof accepted === "boolean" ? accepted : void 0
-	};
-}
-//#endregion
-//#region src/blocks/ai-files/ai-files.ts
-const SCHEME = "supabase-storage:";
-/** The URL a message stores for a file: `supabase-storage://{bucket}/{path}`. */
-function aiFileUrl(file) {
-	return `${SCHEME}//${file.bucket}/${file.path.split("/").map(encodeURIComponent).join("/")}`;
-}
-/** The bucket and path of a `supabase-storage://` URL, or `undefined`. */
-function parseAiFileUrl(url) {
-	let parsed;
-	try {
-		parsed = typeof url === "string" ? new URL(url) : url;
-	} catch {
-		return;
-	}
-	if (parsed.protocol !== SCHEME || parsed.hostname === "") return;
-	const segments = parsed.pathname.split("/").filter((part) => part !== "");
-	if (segments.length === 0) return;
-	try {
-		return {
-			bucket: decodeURIComponent(parsed.hostname),
-			path: segments.map(decodeURIComponent).join("/")
-		};
-	} catch {
-		return;
-	}
-}
-const notFound = () => notFoundError("No AI file you can see has this id", "AI_FILE_NOT_FOUND");
-const CLAIM_HINTS = {
-	notUploaded: "AI_FILE_NOT_UPLOADED",
-	forbidden: "AI_FILE_FORBIDDEN"
-};
-const notReady = () => dbError("invalid_request", "The file is not uploaded yet", { hint: "AI_FILE_NOT_READY" });
-function stored(reply) {
-	return AsyncResult.from(async () => {
-		try {
-			const { data, error } = await reply;
-			if (error) return err(fromStorageError(error, "storage.objects"));
-			if (data === null || data === void 0) return err(dbError("network", "Storage returned no data"));
-			return ok(data);
-		} catch (cause) {
-			return err(fromStorageError(cause, "storage.objects"));
-		}
-	});
-}
-/** 50 MB, the module's default `maxSize`. */
-const DEFAULT_MAX_BYTES = 52428800;
-/** Files and documents for AI chats, as the caller and as the service role. */
-function createAiFiles(options) {
-	applyTemporal(options);
-	const fields = blockFields(options.fields, "file fields");
-	const typed = (value) => AsyncResult.from(() => withFields(fields, value, fileOf(value)));
-	const call = blockCall(options.transport, options.schema, options.mappers);
-	const service = blockCall(options.service ?? options.transport, options.schema, options.mappers);
-	const ttl = options.downloadTtl ?? 300;
-	const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
-	const serviceStorage = options.serviceStorage ?? options.storage;
-	const found = (value) => isRecord(value) ? typed(value) : AsyncResult.err(notFound());
-	const get = (fileId) => call("get_ai_file", { file_id: fileId }, (value) => value).andThen(found);
-	const fileFrom = (file) => typeof file === "string" ? get(file) : AsyncResult.ok(file);
-	const resolve = (url) => {
-		const target = parseAiFileUrl(url);
-		if (!target) return AsyncResult.err(dbError("invalid_request", "Not a supabase-storage:// URL", { hint: "AI_FILE_URL" }));
-		return call("get_ai_file_by_path", {
-			bucket: target.bucket,
-			path: target.path
-		}, (value) => value).andThen(found);
-	};
-	const sign = (file) => fileFrom(file).andThen((row) => row.status === "ready" ? stored(options.storage.from(row.bucket).createSignedUrl(row.path, ttl)).map((url) => url.signedUrl) : Promise.resolve(err(notReady())));
-	return withBlockHooks({
-		files: {
-			upload: (organizationId, { filename, mediaType, size, chatId, projectId, ...extra }) => AsyncResult.from(() => extraFieldsArg(fields, extra)).andThen((more) => call("reserve_ai_file", {
-				tenant: organizationId,
-				filename,
-				media_type: mediaType,
-				byte_size: size,
-				chat_id: chatId,
-				project_id: projectId,
-				...more
-			}, (value) => value)).andThen(typed).andThen((created) => stored(options.storage.from(created.bucket).createSignedUploadUrl(created.path)).map((url) => ({
-				file: created,
-				signedUrl: url.signedUrl,
-				token: url.token
-			}))),
-			confirm: (fileId, sha256) => {
-				const confirmed = () => call("confirm_ai_file", {
-					file_id: fileId,
-					sha256
-				}, (value) => value).andThen(typed);
-				return claimsUploads(options.storage) ? get(fileId).andThen((row) => row.status === "pending" ? claimUpload(options.storage, row, CLAIM_HINTS).andThen(confirmed) : confirmed()) : confirmed();
-			},
-			get,
-			resolve,
-			list: (chatId) => call("list_ai_files", { chat_id: chatId }, (value) => recordsOf(value, "list_ai_files").map((raw) => [raw, fileOf(raw)])).andThen((rows) => allWithFields(fields, rows)),
-			sign,
-			read: (file) => fileFrom(file).andThen(async (row) => {
-				if (row.status !== "ready") return err(notReady());
-				if (row.size > maxBytes) return err(dbError("invalid_request", "The file is larger than maxBytes", { hint: "AI_FILE_TOO_LARGE" }));
-				const blob = await stored(options.storage.from(row.bucket).download(row.path));
-				if (!blob.ok) return err(blob.error);
-				if (blob.data.size > maxBytes) return err(dbError("invalid_request", "The file is larger than maxBytes", { hint: "AI_FILE_TOO_LARGE" }));
-				return ok({
-					file: row,
-					data: new Uint8Array(await blob.data.arrayBuffer())
-				});
-			}),
-			remove: (fileId) => call("delete_ai_file", { file_id: fileId }, (value) => value).andThen(async (value) => {
-				if (!isRecord(value)) return ok(false);
-				const removed = await stored(options.storage.from(textOf(value["bucket"])).remove([textOf(value["path"])]));
-				return removed.ok ? ok(true) : err(removed.error);
-			}),
-			store: (organizationId, file) => {
-				const { ownerId, filename, mediaType, data, chatId, source, ...extra } = file;
-				return AsyncResult.from(() => extraFieldsArg(fields, extra)).andThen((more) => service("store_ai_file", {
-					tenant: organizationId,
-					owner: ownerId,
-					filename,
-					media_type: mediaType,
-					byte_size: data instanceof Uint8Array ? data.byteLength : data.size,
-					chat_id: chatId,
-					source: source ?? "generated",
-					...more
-				}, (value) => value)).andThen(typed).andThen(async (created) => {
-					const target = serviceStorage.from(created.bucket);
-					if (!target.upload) return err(dbError("invalid_request", "The storage client has no upload", { hint: "AI_FILE_STORAGE_CLIENT" }));
-					const sent = await stored(target.upload(created.path, file.data, {
-						contentType: created.mediaType,
-						upsert: false
-					}));
-					if (sent.ok) return ok(created);
-					await service("delete_ai_file", { file_id: created.id }, () => true);
-					return err(sent.error);
-				});
-			},
-			purge: (purgeOptions = {}) => service("purge_ai_files", {
-				older_than: purgeOptions.olderThan,
-				batch: purgeOptions.batch
-			}, (value) => recordsOf(value, "purge_ai_files")).andThen(async (removed) => {
-				const byBucket = /* @__PURE__ */ new Map();
-				for (const row of removed) {
-					const bucket = textOf(row["bucket"]);
-					const paths = byBucket.get(bucket) ?? [];
-					paths.push(textOf(row["path"]));
-					byBucket.set(bucket, paths);
-				}
-				for (const [bucket, paths] of byBucket) {
-					const result = await stored(serviceStorage.from(bucket).remove(paths));
-					if (!result.ok) return err(result.error);
-				}
-				return ok(removed.length);
-			})
-		},
-		providerFiles: {
-			get: (fileId, provider) => service("get_ai_provider_file", {
-				file_id: fileId,
-				provider
-			}, (value) => isRecord(value) ? providerFileOf(value) : void 0),
-			set: (fileId, provider, reference, expiresAt) => service("set_ai_provider_file", {
-				file_id: fileId,
-				provider,
-				reference,
-				expires_at: instantArg(expiresAt)
-			}, (value) => value === true),
-			expiring: (horizon, batch) => service("expiring_ai_provider_files", {
-				horizon,
-				batch
-			}, (value) => recordsOf(value, "expiring_ai_provider_files").map(providerFileOf))
-		},
-		documents: {
-			create: (organizationId, document) => (document.ownerId === void 0 ? call : service)("create_ai_document", {
-				tenant: organizationId,
-				kind: document.kind,
-				title: document.title,
-				content: document.content,
-				chat_id: document.chatId,
-				message_id: document.messageId,
-				owner: document.ownerId,
-				storage_path: document.storagePath
-			}, documentOf),
-			get: (documentId) => call("get_ai_document", { document_id: documentId }, (value) => value).andThen((value) => Promise.resolve(isRecord(value) ? ok({
-				...documentOf(value),
-				content: optionalText(value["content"]),
-				storagePath: optionalText(value["storage_path"])
-			}) : err(dbError("not_found", "No document you can see has this id", { hint: "AI_DOCUMENT_NOT_FOUND" })))),
-			update: (documentId, edit) => call("update_ai_document", {
-				document_id: documentId,
-				content: edit.content,
-				title: edit.title,
-				message_id: edit.messageId,
-				expected_version: edit.expectedVersion,
-				storage_path: edit.storagePath
-			}, documentOf),
-			rollback: (documentId, version) => call("rollback_ai_document", {
-				document_id: documentId,
-				version
-			}, documentOf),
-			versions: (documentId) => call("list_ai_document_versions", { document_id: documentId }, (value) => recordsOf(value, "list_ai_document_versions").map(versionOf)),
-			remove: (documentId) => call("delete_ai_document", { document_id: documentId }, (value) => value === true),
-			suggest: (documentId, suggestion) => call("suggest_ai_document_edit", {
-				document_id: documentId,
-				original_text: suggestion.originalText,
-				suggested_text: suggestion.suggestedText,
-				description: suggestion.description
-			}, suggestionOf),
-			suggestions: (documentId, query = {}) => call("list_ai_suggestions", {
-				document_id: documentId,
-				open_only: query.openOnly ?? true
-			}, (value) => recordsOf(value, "list_ai_suggestions").map(suggestionOf)),
-			resolve: (suggestionId, accepted) => call("resolve_ai_suggestion", {
-				suggestion_id: suggestionId,
-				accepted
-			}, suggestionOf)
-		},
-		sign: async (messages) => {
-			const signed = /* @__PURE__ */ new Map();
-			for (const message of messages) for (const part of message.parts) {
-				if (part.type !== "file" || signed.has(part.url)) continue;
-				if (!parseAiFileUrl(part.url)) continue;
-				const result = await resolve(part.url).andThen(sign);
-				signed.set(part.url, result.ok ? result.data : void 0);
-			}
-			if (signed.size === 0) return messages;
-			const swap = (part) => {
-				if (part.type !== "file") return part;
-				const url = signed.get(part.url);
-				return url === void 0 ? part : {
-					...part,
-					url
-				};
-			};
-			return messages.map((message) => ({
-				...message,
-				parts: message.parts.map(swap)
-			}));
-		}
-	}, options.hooks, {
-		block: "ai-files",
-		...options.logger ? { logger: options.logger } : {}
-	});
-}
-//#endregion
-export { createAiFiles as n, parseAiFileUrl as r, aiFileUrl as t };

package/dist/ai-tasks-ZvPnNudQ.d.ts

@@ -1,157 +0,0 @@
-/// <reference lib="esnext.temporal" />
-import { T as ErrorMapper, t as AsyncResult } from "./result-BREt7qOh.js";
-import { n as Logger } from "./logger-DWVYUmwi.js";
-import { t as StandardSchemaV1 } from "./standard-BcUQuUgu.js";
-import { t as BlockTransport } from "./block-transport-DezJPPA0.js";
-import { r as BlockTemporalOptions } from "./block-helpers-CjcQM1yA.js";
-import { n as BlockHooks } from "./block-hooks-DcPJHztl.js";
-import { r as FieldsOf } from "./block-fields-DnaDbgZS.js";
-import { g as JobHandler } from "./types-BEEFkNFY.js";
-import { r as RunState } from "./run-state-CPo-1X2B.js";
-import { n as Notifier } from "./ports-P0A5wo_-.js";
-//#region src/blocks/ai-tasks/ai-tasks.d.ts
-/** A task run's state, in the words ai-chat and workflow runs share. */
-type AiTaskRunStatus = Extract<RunState, "queued" | "running" | "completed" | "failed">;
-interface AiTaskRun {
-  readonly id: string;
-  readonly taskId: string;
-  readonly organizationId: string;
-  readonly userId: string;
-  readonly status: AiTaskRunStatus;
-  readonly scheduledFor: Temporal.Instant;
-  readonly chatId: string | undefined;
-  readonly error: string | undefined;
-  readonly startedAt: Temporal.Instant | undefined;
-  readonly finishedAt: Temporal.Instant | undefined;
-  readonly createdAt: Temporal.Instant;
-}
-interface AiTask {
-  readonly id: string;
-  readonly organizationId: string;
-  readonly userId: string;
-  /** The chat each run writes to; the first run's chat when unset. */
-  readonly chatId: string | undefined;
-  readonly agentId: string | undefined;
-  readonly title: string;
-  readonly prompt: string;
-  /** Five-field cron or an interval such as `30 minutes`. */
-  readonly cron: string;
-  /** An IANA time zone the cron runs in. */
-  readonly timezone: string;
-  readonly enabled: boolean;
-  readonly nextRunAt: Temporal.Instant | undefined;
-  readonly lastRunAt: Temporal.Instant | undefined;
-  /** Only `list` sets it. */
-  readonly lastRun: AiTaskRun | undefined;
-  readonly createdAt: Temporal.Instant;
-  readonly updatedAt: Temporal.Instant;
-}
-interface AiTaskFields {
-  readonly title?: string;
-  readonly prompt?: string;
-  readonly cron?: string;
-  readonly timezone?: string;
-  readonly chatId?: string | null;
-  readonly agentId?: string | null;
-}
-type NewAiTask = AiTaskFields & {
-  readonly title: string;
-  readonly prompt: string;
-  readonly cron: string;
-};
-/**
- * Runs one occurrence of a task, as the task's user: sends the prompt to the
- * assistant and returns the chat it wrote to. A throw fails the run.
- */
-type AiTaskRunner = ((task: AiTask, run: AiTaskRun, signal: AbortSignal) => Promise<{
-  readonly chatId?: string;
-} | void>) & {
-  /** The runner contract version. Omitted means 1. */
-  readonly apiVersion?: 1;
-};
-interface AiTaskOutcome {
-  readonly task: AiTask;
-  readonly run: AiTaskRun;
-  readonly ok: boolean;
-  readonly error?: string;
-  readonly chatId?: string;
-}
-interface AiTasksOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions {
-  /**
-   * A Standard Schema for the task columns the app adds
-   * (`blocks.ai-tasks.options.extraColumns`), keyed by column name. It
-   * types and parses them on `create`, `update`, `pause`, `resume` and
-   * `list`, and validates them on `create` and `update`, which return a
-   * `validation` error for a bad value.
-   */
-  readonly fields?: S;
-  /** `withBlockHooks` hooks around the client's methods. */
-  readonly hooks?: NoInfer<BlockHooks<AiTasks<FieldsOf<S>>>>;
-  /** Receives the errors `after` hooks throw. Default: `console`. */
-  readonly logger?: Logger;
-  /** Calls as the user: `rpcTransport(supabase)`. */
-  readonly transport: BlockTransport;
-  /** Calls as the service role, for `tick`, `execute` and `runJob`. */
-  readonly service?: BlockTransport;
-  /** The module schema, or its API schema: `defineBlocks` passes it from `blocks.generated.ts`. Default `better_supabase`. */
-  readonly schema?: string;
-  readonly mappers?: readonly ErrorMapper[];
-  readonly run?: AiTaskRunner;
-  /** Called after each run finishes, to notify the task's user. Defaults to `notification` through `notifier`. */
-  readonly notify?: (outcome: AiTaskOutcome) => unknown;
-  /** The `notifier` port: the `notifications` block, from `createBlocks`. */
-  readonly notifier?: Notifier;
-  /**
-   * The notification type `notifier` sends the task's user after each run.
-   * Its data is `{ taskId, runId, ok, error?, chatId? }`.
-   */
-  readonly notification?: string;
-  /** The clock, for tests. */
-  readonly now?: () => Temporal.Instant;
-}
-/** `F` is the extra task fields `options.fields` describes. */
-interface AiTasks<F extends object = Record<never, never>> {
-  /** Keys besides the task's own are its extra columns. */
-  create(organizationId: string, task: NewAiTask & Partial<F>): AsyncResult<AiTask & F>;
-  update(organizationId: string, taskId: string, fields: AiTaskFields & Partial<F>): AsyncResult<AiTask & F>;
-  pause(organizationId: string, taskId: string): AsyncResult<AiTask & F>;
-  /** Enables a task again; it runs at its next occurrence. */
-  resume(organizationId: string, taskId: string): AsyncResult<AiTask & F>;
-  remove(taskId: string): AsyncResult<boolean>;
-  /** The caller's tasks, or every task in the tenant with `all` and `ai.admin`. */
-  list(organizationId: string, options?: {
-    readonly all?: boolean;
-  }): AsyncResult<readonly (AiTask & F)[]>;
-  runs(taskId: string, options?: {
-    readonly limit?: number;
-  }): AsyncResult<readonly AiTaskRun[]>;
-  /**
-   * Claims due tasks (service role): queues a run for each, which the
-   * `ai_task_run` queue picks up when jobs is installed, and computes the
-   * next occurrence of every task that needs one. Returns the queued runs.
-   */
-  tick(options?: {
-    readonly batch?: number;
-  }): AsyncResult<readonly AiTaskRun[]>;
-  /** Starts, runs and finishes a queued run (service role). `false` when another worker has it. */
-  execute(runId: string, options?: {
-    readonly signal?: AbortSignal;
-  }): AsyncResult<boolean>;
-  /** The handler for the `ai_task_run` queue. */
-  runJob(): JobHandler<{
-    readonly run_id: string;
-  }>;
-  /**
-   * `tick` then `execute` each run in turn, without a queue. Returns how many
-   * ran. A failed run does not stop the others; when any failed, the result
-   * is the first error, with every failed run listed in `details`.
-   */
-  drain(options?: {
-    readonly batch?: number;
-    readonly signal?: AbortSignal;
-  }): AsyncResult<number>;
-}
-/** Prompts users schedule on a cron, and the scheduler that runs them. */
-declare function createAiTasks<S extends StandardSchemaV1 | undefined = undefined>(options: AiTasksOptions<S>): AiTasks<FieldsOf<S>>;
-//#endregion
-export { AiTaskRunStatus as a, AiTasksOptions as c, AiTaskRun as i, NewAiTask as l, AiTaskFields as n, AiTaskRunner as o, AiTaskOutcome as r, AiTasks as s, AiTask as t, createAiTasks as u };

package/dist/announcements-BNxTW5HJ.js

@@ -1,128 +0,0 @@
-import { t as AsyncResult } from "./result-DIeYscA3.js";
-import { C as optionalText, D as recordOf, F as stringsOf, I as textOf, R as toInstant, S as optionalInstant, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall } from "./block-helpers-DkVZNDrj.js";
-import { r as withBlockHooks } from "./block-hooks-C22vuIUd.js";
-import { c as withFields, i as extraOf, n as blockFields, t as allWithFields } from "./block-fields-Bv1hV855.js";
-//#region src/blocks/announcements/announcements.ts
-const SEVERITIES = /* @__PURE__ */ new Set([
-	"info",
-	"success",
-	"warning",
-	"critical"
-]);
-function severityOf(value) {
-	const text = textOf(value);
-	return SEVERITIES.has(text) ? text : "info";
-}
-function announcementOf(value) {
-	const row = recordOf(value, "announcements");
-	return {
-		id: textOf(row["id"]),
-		title: textOf(row["title"]),
-		body: textOf(row["body"] ?? ""),
-		severity: severityOf(row["severity"]),
-		href: optionalText(row["href"]),
-		startsAt: toInstant(textOf(row["starts_at"])),
-		endsAt: optionalInstant(row["ends_at"]),
-		dismissible: row["dismissible"] !== false,
-		createdAt: toInstant(textOf(row["created_at"])),
-		updatedAt: toInstant(textOf(row["updated_at"]))
-	};
-}
-function audienceOf(type, targets) {
-	const values = stringsOf(targets);
-	switch (type) {
-		case "tenant": return {
-			type,
-			organizationIds: values
-		};
-		case "role": return {
-			type,
-			roles: values
-		};
-		case "plan": return {
-			type,
-			plans: values
-		};
-		default: return { type: "all" };
-	}
-}
-function managedOf(value) {
-	const row = recordOf(value, "announcements");
-	return {
-		...announcementOf(row),
-		audience: audienceOf(row["audience"], row["targets"]),
-		createdBy: optionalText(row["created_by"])
-	};
-}
-function audienceFields(audience) {
-	switch (audience.type) {
-		case "all": return {
-			audience: "all",
-			targets: []
-		};
-		case "tenant": return {
-			audience: "tenant",
-			targets: audience.organizationIds
-		};
-		case "role": return {
-			audience: "role",
-			targets: audience.roles
-		};
-		case "plan": return {
-			audience: "plan",
-			targets: audience.plans
-		};
-		default: throw new TypeError(`Unknown audience ${JSON.stringify(audience)}`);
-	}
-}
-/** The columns `save_announcement` sets, from the fields the input names. */
-function fieldsOf(input) {
-	const fields = {};
-	if (input.title !== void 0) fields["title"] = input.title;
-	if (input.body !== void 0) fields["body"] = input.body;
-	if (input.severity !== void 0) fields["severity"] = input.severity;
-	if (input.href !== void 0) fields["href"] = input.href;
-	if (input.audience !== void 0) Object.assign(fields, audienceFields(input.audience));
-	if (input.startsAt !== void 0) fields["starts_at"] = instantArg(input.startsAt);
-	if (input.endsAt !== void 0) fields["ends_at"] = instantArg(input.endsAt);
-	if (input.dismissible !== void 0) fields["dismissible"] = input.dismissible;
-	return fields;
-}
-const INPUT_KEYS = /* @__PURE__ */ new Set([
-	"title",
-	"body",
-	"severity",
-	"href",
-	"audience",
-	"startsAt",
-	"endsAt",
-	"dismissible"
-]);
-function createAnnouncements(options) {
-	applyTemporal(options);
-	const call = blockCall(options.transport, options.schema, options.mappers);
-	const fields = blockFields(options.fields, "announcement fields");
-	const save = (id, input) => {
-		const columns = fieldsOf(input);
-		return AsyncResult.from(() => fields.write(extraOf(input, INPUT_KEYS))).andThen((extra) => call("save_announcement", {
-			id,
-			fields: {
-				...extra,
-				...columns
-			}
-		}, (value) => value)).andThen((value) => withFields(fields, value, managedOf(value)));
-	};
-	return withBlockHooks({
-		listActive: (organizationId) => call("active_announcements", { tenant: organizationId ?? null }, (value) => recordsOf(value, "active_announcements").map((raw) => [raw, announcementOf(raw)])).andThen((rows) => allWithFields(fields, rows)),
-		dismiss: (announcementId) => call("dismiss_announcement", { id: announcementId }, (value) => value === true),
-		list: () => call("list_announcements", {}, (value) => recordsOf(value, "list_announcements").map((raw) => [raw, managedOf(raw)])).andThen((rows) => allWithFields(fields, rows)),
-		publish: (input) => save(null, input),
-		update: (announcementId, input) => save(announcementId, input),
-		remove: (announcementId) => call("delete_announcement", { id: announcementId }, (value) => value === true)
-	}, options.hooks, {
-		block: "announcements",
-		...options.logger ? { logger: options.logger } : {}
-	});
-}
-//#endregion
-export { createAnnouncements as t };