better-supabase 0.7.1 → 0.9.0

package/dist/blocks/hiring/index.js

@@ -0,0 +1,180 @@
+import { t as AsyncResult } from "../../result-BlgnMB0H.js";
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { n as event, t as defineEvents } from "../../event-map-Dy2vKHai.js";
+import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-G4t1umrR.js";
+import { A as requiredInstant, C as optionalText, D as recordOf, I as textOf, S as optionalInstant, d as enumOrThrow, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall } from "../../block-helpers-CfG_MvDR.js";
+import { i as wrapTransport, n as extendBlock, r as withBlockHooks } from "../../block-hooks-BsXncUlZ.js";
+import { n as blockFields } from "../../block-fields-ffD6Gxe4.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+import { i as refOf, n as compact } from "../../sales-shared-SblIgCgI.js";
+import { t as hiringSqlOptions } from "../../options-D2Gd6VfS.js";
+//#region src/blocks/hiring/hiring.ts
+const JOB_STATUSES = [
+	"draft",
+	"open",
+	"closed"
+];
+const STATES = [
+	"active",
+	"hired",
+	"rejected",
+	"withdrawn"
+];
+const RECOMMENDATIONS = [
+	"strong_no",
+	"no",
+	"yes",
+	"strong_yes"
+];
+function jobOf(value) {
+	const row = recordOf(value, "job");
+	return compact({
+		id: textOf(row["id"]),
+		title: textOf(row["title"]),
+		teamId: optionalText(row["team_id"]),
+		location: optionalText(row["location"]),
+		employmentType: optionalText(row["employment_type"]),
+		description: optionalText(row["description"]),
+		hiringManagerId: optionalText(row["hiring_manager_user_id"]),
+		status: enumOrThrow(row["status"], JOB_STATUSES, "job status"),
+		openedAt: optionalInstant(row["opened_at"]),
+		closedAt: optionalInstant(row["closed_at"]),
+		fields: isRecord(row["fields"]) ? row["fields"] : {}
+	});
+}
+function applicationOf(value) {
+	const row = recordOf(value, "application");
+	return compact({
+		id: textOf(row["id"]),
+		jobId: textOf(row["job_id"]),
+		candidate: refOf(row["candidate_type"], row["candidate_id"]) ?? {
+			type: "",
+			id: ""
+		},
+		source: optionalText(row["source"]),
+		ownerId: optionalText(row["owner_user_id"]),
+		pipelineId: optionalText(row["pipeline_id"]),
+		stageId: optionalText(row["stage_id"]),
+		stageEnteredAt: optionalInstant(row["stage_entered_at"]),
+		state: enumOrThrow(row["state"], STATES, "application state"),
+		rejectionReason: optionalText(row["rejection_reason"]),
+		hiredAt: optionalInstant(row["hired_at"]),
+		createdAt: requiredInstant(row["created_at"], "createdAt")
+	});
+}
+function scorecardOf(value) {
+	const row = recordOf(value, "scorecard");
+	return compact({
+		id: textOf(row["id"]),
+		stageId: optionalText(row["stage_id"]),
+		reviewerId: textOf(row["reviewer_user_id"]),
+		rating: Number(row["rating"]),
+		recommendation: enumOrThrow(row["recommendation"], RECOMMENDATIONS, "recommendation"),
+		notes: optionalText(row["notes"]),
+		submittedAt: requiredInstant(row["submitted_at"], "submittedAt")
+	});
+}
+function interviewOf(value) {
+	const row = recordOf(value, "interview");
+	return compact({
+		id: textOf(row["id"]),
+		kind: optionalText(row["kind"]),
+		startsAt: requiredInstant(row["starts_at"], "startsAt"),
+		endsAt: requiredInstant(row["ends_at"], "endsAt"),
+		location: optionalText(row["location"]),
+		interviewerIds: Array.isArray(row["interviewer_user_ids"]) ? row["interviewer_user_ids"].map(String) : []
+	});
+}
+/**
+* The hiring block: jobs and applications on a pipeline per job, with
+* scorecards and interviews. Act on `application.hired` to create the
+* employee in your app.
+*/
+function createHiring(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const fields = blockFields(options.fields, "job fields");
+	const close = (applicationId, outcome, reason) => call("close_application", {
+		application: applicationId,
+		outcome,
+		reason: reason ?? null
+	}, applicationOf);
+	return withBlockHooks({
+		saveJob: (organizationId, job) => {
+			const { id, fields: extra, ...attrs } = job;
+			return AsyncResult.from(() => fields.write({ ...extra })).andThen((valid) => call("save_job", {
+				tenant: organizationId,
+				job: id ?? null,
+				attrs: extra === void 0 ? attrs : {
+					...attrs,
+					fields: valid
+				}
+			}, jobOf)).andThen((saved) => AsyncResult.from(() => fields.read(saved.fields)).map((value) => ({
+				...saved,
+				fields: value
+			})));
+		},
+		apply: (jobId, candidate, apply = {}) => call("apply_to_job", {
+			job: jobId,
+			candidate: { ...candidate },
+			source: apply.source ?? null,
+			owner: apply.ownerId ?? null
+		}, applicationOf),
+		hire: (applicationId) => close(applicationId, "hired"),
+		reject: (applicationId, reason) => close(applicationId, "rejected", reason),
+		withdraw: (applicationId) => close(applicationId, "withdrawn"),
+		score: (applicationId, card) => call("submit_scorecard", {
+			application: applicationId,
+			rating: card.rating,
+			recommendation: card.recommendation,
+			notes: card.notes ?? null
+		}, scorecardOf),
+		scheduleInterview: (applicationId, interview) => call("schedule_interview", {
+			application: applicationId,
+			starts_at: instantArg(interview.startsAt),
+			ends_at: instantArg(interview.endsAt),
+			interviewers: [...interview.interviewerIds ?? []],
+			kind: interview.kind ?? null,
+			location: interview.location ?? null
+		}, interviewOf),
+		detail: (applicationId) => call("application_detail", { application: applicationId }, (value) => {
+			const row = recordOf(value, "application_detail");
+			return compact({
+				...applicationOf(row),
+				scorecards: recordsOf(row["scorecards"], "scorecards").map(scorecardOf),
+				interviews: recordsOf(row["interviews"], "interviews").map(interviewOf),
+				averageRating: row["averageRating"] === null || row["averageRating"] === void 0 ? void 0 : Number(row["averageRating"])
+			});
+		})
+	}, options.hooks, {
+		block: "hiring",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/hiring/events.ts
+/** The `hiring` block's event types, for its manifest and `onBlockEvent`. */
+const hiringEvents = defineEvents({
+	"job.opened": event(),
+	"job.closed": event(),
+	"application.created": event(),
+	"application.hired": event(),
+	"application.rejected": event(),
+	"application.retracted": event(),
+	"scorecard.submitted": event(),
+	"interview.scheduled": event()
+});
+//#endregion
+//#region src/blocks/hiring/manifest.ts
+/** The `hiring` block's manifest (ADR 0029). */
+const hiringBlock = defineBlock({
+	name: "hiring",
+	sql: ["hiring"],
+	options: { hiring: hiringSqlOptions },
+	events: hiringEvents,
+	create: createHiring,
+	category: "people",
+	recipes: ["hiring-board"]
+});
+//#endregion
+export { createHiring, dbTransport, extendBlock, hiringBlock, hiringEvents, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

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

@@ -0,0 +1,83 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult, w as ErrorMapper } from "../../result-Cj3yWhjH.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DaGGXjIw.js";
+import { r as BlockTemporalOptions } from "../../block-helpers-C86hPEjI.js";
+import { n as BlockHooks } from "../../block-hooks-BLPWD3Jt.js";
+import { d as IdentityRef, f as IdentityTarget, p as PrincipalByIdentity } from "../../authorization-hooks-DkmrnDX7.js";
+import { s as BlockOf } from "../../define-block-CLZMEFeK.js";
+//#region src/blocks/identities/identities.d.ts
+interface IdentitiesOptions extends BlockTemporalOptions {
+  /**
+   * `sqlTransport(postgres.asUser(claims))` for `beginLink`, `list` and
+   * `unlink`; a service transport for `redeemLink`, `resolve` and
+   * `backfillVerifiedEmails`.
+   */
+  readonly transport: 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[];
+  /** `withBlockHooks` hooks around the methods (ADR 0015). */
+  readonly hooks?: NoInfer<BlockHooks<Identities>>;
+  /** Receives the errors `after` hooks throw. */
+  readonly logger?: Logger;
+}
+/** A one-time code from `beginLink`. Only its SHA-256 is stored. */
+interface LinkCode {
+  readonly code: string;
+  readonly expiresAt: Temporal.Instant;
+}
+/** The link `redeemLink` created or found. */
+interface RedeemedLink {
+  readonly id: string;
+  readonly userId: string;
+}
+type IdentitySource = "link" | "verified_email";
+/** One of the caller's identities. */
+interface LinkedIdentity {
+  readonly id: string;
+  readonly kind: IdentityRef["kind"];
+  readonly provider: string | null;
+  readonly value: string;
+  readonly workspace: string | null;
+  readonly source: IdentitySource;
+  readonly createdAt: Temporal.Instant;
+}
+/** The `identities` SQL module as typed calls. */
+interface Identities {
+  /** Signed-in user: issues a one-time code for the bot or the mail side to redeem. */
+  readonly beginLink: (kind: IdentityRef["kind"], provider?: string) => AsyncResult<LinkCode>;
+  /**
+   * Service role: binds `identity` to the user who issued `code`. Pass only
+   * an identity the platform authenticated, such as the author of a signed
+   * Slack event or a DKIM-verified sender.
+   */
+  readonly redeemLink: (code: string, identity: IdentityRef) => AsyncResult<RedeemedLink>;
+  /** Service role: the user or contact `identity` is linked to, or `null`. */
+  readonly resolve: (identity: IdentityRef) => AsyncResult<IdentityTarget | null>;
+  /** The caller's identities, oldest first. */
+  readonly list: () => AsyncResult<readonly LinkedIdentity[]>;
+  /** Removes one of the caller's identities; `false` when the caller has none with `id`. */
+  readonly unlink: (id: string) => AsyncResult<boolean>;
+  /** Service role: email identities for users confirmed before the module was installed. */
+  readonly backfillVerifiedEmails: () => AsyncResult<number>;
+}
+export declare function createIdentities(options: IdentitiesOptions): Identities;
+/**
+ * A `PrincipalByIdentity` over the `identities` table, for
+ * `createServer(bs, { authorization: { identities: { principalByIdentity } } })`
+ * or a chat helper's `principalByIdentity` option. `transport` runs as the
+ * service role. A database error rejects, so the caller retries instead of
+ * treating a linked author as anonymous.
+ */
+export declare function identityResolver(transport: BlockTransport, options?: Omit<IdentitiesOptions, "transport">): PrincipalByIdentity;
+/** `createIdentities({ transport }).beginLink(kind, provider)`, as the signed-in user. */
+export declare function beginLink(transport: BlockTransport, kind: IdentityRef["kind"], provider?: string): AsyncResult<LinkCode>;
+/** `createIdentities({ transport }).redeemLink(code, identity)`, as the service role. */
+export declare function redeemLink(transport: BlockTransport, code: string, identity: IdentityRef): AsyncResult<RedeemedLink>;
+//#endregion
+//#region src/blocks/identities/manifest.d.ts
+/** The `identities` block's manifest (ADR 0029). */
+export declare const identitiesBlock: BlockOf<"identities", typeof createIdentities>;
+//#endregion
+export { type BlockTransport, type Identities, type IdentitiesOptions, type IdentityRef, type IdentitySource, type IdentityTarget, type LinkCode, type LinkedIdentity, type PrincipalByIdentity, type RedeemedLink, dbTransport, rpcTransport, sqlTransport };

package/dist/blocks/identities/index.js

@@ -0,0 +1,103 @@
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-G4t1umrR.js";
+import { A as requiredInstant, D as recordOf, I as textOf, d as enumOrThrow, k as recordsOf, n as applyTemporal, o as blockCall, y as nullableText } from "../../block-helpers-CfG_MvDR.js";
+import { r as withBlockHooks } from "../../block-hooks-BsXncUlZ.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+import { t as identitiesSqlOptions } from "../../options-CXFz0xxS.js";
+//#region src/blocks/identities/identities.ts
+const KINDS = ["email", "chat"];
+const SOURCES = ["link", "verified_email"];
+/** The `principal_by_identity` result, or `null` for anything that names no one. */
+function targetOf(value) {
+	if (!isRecord(value)) return null;
+	if (value["kind"] === "user" && typeof value["userId"] === "string") return {
+		kind: "user",
+		userId: value["userId"]
+	};
+	if (value["kind"] === "contact" && typeof value["contactId"] === "string") return {
+		kind: "contact",
+		contactId: value["contactId"]
+	};
+	return null;
+}
+const identityArgs = (identity) => ({
+	kind: identity.kind,
+	provider: identity.provider ?? null,
+	value: identity.value,
+	workspace: identity.workspace ?? null
+});
+function createIdentities(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	return withBlockHooks({
+		beginLink: (kind, provider) => call("begin_identity_link", {
+			kind,
+			provider: provider ?? null
+		}, (value) => {
+			const row = recordOf(value, "begin_identity_link");
+			return {
+				code: textOf(row["code"]),
+				expiresAt: requiredInstant(row["expires_at"], "expires_at")
+			};
+		}),
+		redeemLink: (code, identity) => call("redeem_identity_link", {
+			code,
+			...identityArgs(identity)
+		}, (value) => {
+			const row = recordOf(value, "redeem_identity_link");
+			return {
+				id: textOf(row["id"]),
+				userId: textOf(row["user_id"])
+			};
+		}),
+		resolve: (identity) => call("principal_by_identity", identityArgs(identity), targetOf),
+		list: () => call("my_identities", {}, (value) => recordsOf(value, "my_identities").map((row) => ({
+			id: textOf(row["id"]),
+			kind: enumOrThrow(row["kind"], KINDS, "identity kind"),
+			provider: nullableText(row["provider"]),
+			value: textOf(row["value"]),
+			workspace: nullableText(row["workspace"]),
+			source: enumOrThrow(row["source"], SOURCES, "identity source"),
+			createdAt: requiredInstant(row["created_at"], "created_at")
+		}))),
+		unlink: (id) => call("unlink_identity", { id }, (value) => value === true),
+		backfillVerifiedEmails: () => call("backfill_verified_emails", {}, (value) => typeof value === "number" ? value : Number(value))
+	}, options.hooks, {
+		block: "identities",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+/**
+* A `PrincipalByIdentity` over the `identities` table, for
+* `createServer(bs, { authorization: { identities: { principalByIdentity } } })`
+* or a chat helper's `principalByIdentity` option. `transport` runs as the
+* service role. A database error rejects, so the caller retries instead of
+* treating a linked author as anonymous.
+*/
+function identityResolver(transport, options = {}) {
+	const identities = createIdentities({
+		...options,
+		transport
+	});
+	return (identity) => identities.resolve(identity).orThrow();
+}
+/** `createIdentities({ transport }).beginLink(kind, provider)`, as the signed-in user. */
+function beginLink(transport, kind, provider) {
+	return createIdentities({ transport }).beginLink(kind, provider);
+}
+/** `createIdentities({ transport }).redeemLink(code, identity)`, as the service role. */
+function redeemLink(transport, code, identity) {
+	return createIdentities({ transport }).redeemLink(code, identity);
+}
+//#endregion
+//#region src/blocks/identities/manifest.ts
+/** The `identities` block's manifest (ADR 0029). */
+const identitiesBlock = defineBlock({
+	name: "identities",
+	sql: ["identities"],
+	options: { identities: identitiesSqlOptions },
+	create: createIdentities,
+	category: "identity"
+});
+//#endregion
+export { beginLink, createIdentities, dbTransport, identitiesBlock, identityResolver, redeemLink, rpcTransport, sqlTransport };

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

@@ -0,0 +1,91 @@
+import { t as AsyncResult, w as ErrorMapper } from "../../result-Cj3yWhjH.js";
+import { $ as SaasEventData, wt as Events } from "../../events-CTreRrgP.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { t as BlockTransport } from "../../block-transport-DaGGXjIw.js";
+import { n as BlockHooks } from "../../block-hooks-BLPWD3Jt.js";
+import { s as BlockOf } from "../../define-block-CLZMEFeK.js";
+import { r as parseCsv } from "../../csv-D3eKxV1T.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/blocks/imports/define-import.d.ts
+interface ImportColumn {
+  readonly name: string;
+  readonly label?: string;
+}
+interface ImportDefinition<T> {
+  readonly kind: string;
+  readonly columns: StandardSchemaV1<unknown, T>;
+  /** Stable id of a row, so a rerun skips a row that already imported. */
+  readonly key: (row: T) => string;
+  readonly insert: (batch: readonly T[], ctx: {
+    readonly organizationId: string;
+  }) => Promise<void>;
+}
+interface ImportRowError {
+  readonly row: number;
+  readonly message: string;
+}
+interface DryRunResult<T> {
+  readonly rows: readonly T[];
+  readonly errors: readonly ImportRowError[];
+}
+/** Registers an import. The jobs handler calls `insert` in batches. */
+export declare function defineImport<T>(definition: ImportDefinition<T>): ImportDefinition<T>;
+/**
+ * Pairs CSV headers with import fields. A header matches a field when they
+ * are equal after lowercasing and dropping spaces and underscores.
+ */
+export declare function suggestMapping(headers: readonly string[], fields: readonly string[]): Readonly<Record<string, string | undefined>>;
+/**
+ * Parses CSV, applies `mapping` (CSV header to field name) and validates
+ * every row. Nothing is written.
+ */
+export declare function dryRun<T>(definition: ImportDefinition<T>, csv: string, mapping: Readonly<Record<string, string>>): Promise<DryRunResult<T>>;
+interface RunImportResult<T> {
+  readonly id: string;
+  readonly status: "completed" | "failed";
+  readonly imported: number;
+  readonly errors: readonly ImportRowError[];
+  readonly rows: readonly T[];
+}
+/**
+ * Validates the file, skips rows whose key was already imported, inserts the
+ * rest in batches and finishes the run as `import.completed` or `import.failed`.
+ */
+export declare function runImport<T>(definition: ImportDefinition<T>, csv: string, mapping: Readonly<Record<string, string>>, hooks: {
+  readonly organizationId: string;
+  readonly importedKeys?: ReadonlySet<string>;
+  readonly start: () => Promise<string>;
+  readonly finish: (id: string, status: "completed" | "failed", count: number, error: string | null) => Promise<void>;
+}): Promise<RunImportResult<T>>;
+//#endregion
+//#region src/blocks/imports/imports.d.ts
+interface ImportsOptions {
+  readonly transport: BlockTransport;
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+  /** `withBlockHooks` hooks around the methods (ADR 0015). */
+  readonly hooks?: NoInfer<BlockHooks<Imports>>;
+  /** Receives the errors `after` hooks throw. */
+  readonly logger?: Logger;
+}
+interface Imports {
+  start(organizationId: string, kind: string, mapping?: Readonly<Record<string, string>>): AsyncResult<{
+    readonly id: string;
+  }>;
+}
+export declare function createImports(options: ImportsOptions): Imports;
+//#endregion
+//#region src/blocks/imports/events.d.ts
+/** The events of the `imports` block: type to data. */
+type ImportsEvents = {
+  readonly "import.completed": SaasEventData;
+  readonly "import.failed": SaasEventData;
+};
+/** The `imports` block's event types, for its manifest and `onBlockEvent`. */
+export declare const importsEvents: Events<ImportsEvents>;
+//#endregion
+//#region src/blocks/imports/manifest.d.ts
+/** The `imports` block's manifest (ADR 0029). */
+export declare const importsBlock: BlockOf<"imports", typeof createImports, ImportsEvents>;
+//#endregion
+export { type DryRunResult, type ImportColumn, type ImportDefinition, type ImportRowError, type Imports, type ImportsEvents, type ImportsOptions, type RunImportResult, parseCsv };

package/dist/blocks/imports/index.js

@@ -0,0 +1,123 @@
+import { n as validate } from "../../standard-B5fe2gnW.js";
+import { n as parseCsv } from "../../csv-CVfXqaAu.js";
+import { n as event, t as defineEvents } from "../../event-map-Dy2vKHai.js";
+import { D as recordOf, I as textOf, o as blockCall } from "../../block-helpers-CfG_MvDR.js";
+import { r as withBlockHooks } from "../../block-hooks-BsXncUlZ.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+//#region src/blocks/imports/define-import.ts
+/** Registers an import. The jobs handler calls `insert` in batches. */
+function defineImport(definition) {
+	return definition;
+}
+/**
+* Pairs CSV headers with import fields. A header matches a field when they
+* are equal after lowercasing and dropping spaces and underscores.
+*/
+function suggestMapping(headers, fields) {
+	const byKey = new Map(fields.map((field) => [normalize(field), field]));
+	const mapping = {};
+	for (const header of headers) mapping[header] = byKey.get(normalize(header));
+	return mapping;
+}
+/**
+* Parses CSV, applies `mapping` (CSV header to field name) and validates
+* every row. Nothing is written.
+*/
+async function dryRun(definition, csv, mapping) {
+	const [header, ...body] = parseCsv(csv);
+	if (header === void 0) return {
+		rows: [],
+		errors: []
+	};
+	const rows = [];
+	const errors = [];
+	for (const [index, cells] of body.entries()) {
+		const record = {};
+		for (const [column, cell] of cells.entries()) {
+			const name = mapping[header[column] ?? ""];
+			if (name !== void 0) record[name] = cell;
+		}
+		const parsed = await validate(definition.columns, record, `${definition.kind} row ${index + 2}`);
+		if (parsed.ok) rows.push(parsed.data);
+		else errors.push({
+			row: index + 2,
+			message: parsed.error.message
+		});
+	}
+	return {
+		rows,
+		errors
+	};
+}
+const BATCH = 100;
+/**
+* Validates the file, skips rows whose key was already imported, inserts the
+* rest in batches and finishes the run as `import.completed` or `import.failed`.
+*/
+async function runImport(definition, csv, mapping, hooks) {
+	const preview = await dryRun(definition, csv, mapping);
+	const id = await hooks.start();
+	if (preview.errors.length > 0) {
+		const error = preview.errors.map((item) => `row ${item.row}: ${item.message}`).join("; ");
+		await hooks.finish(id, "failed", 0, error);
+		return {
+			id,
+			status: "failed",
+			imported: 0,
+			errors: preview.errors,
+			rows: []
+		};
+	}
+	const seen = new Set(hooks.importedKeys);
+	const fresh = preview.rows.filter((row) => {
+		const key = definition.key(row);
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+	for (let index = 0; index < fresh.length; index += BATCH) await definition.insert(fresh.slice(index, index + BATCH), { organizationId: hooks.organizationId });
+	await hooks.finish(id, "completed", fresh.length, null);
+	return {
+		id,
+		status: "completed",
+		imported: fresh.length,
+		errors: [],
+		rows: fresh
+	};
+}
+function normalize(value) {
+	return value.toLowerCase().replaceAll(/[\s_]+/g, "");
+}
+//#endregion
+//#region src/blocks/imports/imports.ts
+function createImports(options) {
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	return withBlockHooks({ start: (organizationId, kind, mapping) => call("start_import", {
+		tenant: organizationId,
+		kind,
+		mapping: mapping ?? {}
+	}, (value) => ({ id: textOf(recordOf(value, "start_import")["id"]) })) }, options.hooks, {
+		block: "imports",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/imports/events.ts
+/** The `imports` block's event types, for its manifest and `onBlockEvent`. */
+const importsEvents = defineEvents({
+	"import.completed": event(),
+	"import.failed": event()
+});
+//#endregion
+//#region src/blocks/imports/manifest.ts
+/** The `imports` block's manifest (ADR 0029). */
+const importsBlock = defineBlock({
+	name: "imports",
+	sql: ["imports"],
+	events: importsEvents,
+	create: createImports,
+	category: "content",
+	recipes: ["csv-import-wizard"]
+});
+//#endregion
+export { createImports, defineImport, dryRun, importsBlock, importsEvents, parseCsv, runImport, suggestMapping };

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

@@ -1,6 +1,25 @@
-import { i as sqlTransport, n as RpcClient, r as rpcTransport, t as BlockTransport } from "../../block-transport-DvaoPuZ9.js";
-import { A as PurgedContact, C as InboxMessage, D as MessageDirection, E as MessageDelivery, O as MessageKind, S as InboxCounts, T as MessageAttachment, _ as ConversationPriority, a as Inbox, b as InboundResult, c as MessageInput, d as createInbox, f as AuthorType, g as ConversationEvent, h as Conversation, i as InboundInput, j as StoredInboundEvent, k as MessageTemplate, l as StartConversationInput, m as Contact, n as ConversationFilter, o as InboxOptions, p as BotMode, r as CreateInboxInput, s as InboxPatch, t as ContactInput, u as TemplateInput, v as ConversationStatus, w as InboxRow, x as InboxChannel, y as DeliveryStatus } from "../../inbox-i7E1ppo6.js";
+import { H as InboxEventData, wt as Events } from "../../events-CTreRrgP.js";
+import { a as dbTransport, i as RpcClient, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DaGGXjIw.js";
+import { s as BlockOf } from "../../define-block-CLZMEFeK.js";
+import { A as MessageTemplate, C as InboxCounts, D as MessageDelivery, E as MessageAttachment, M as StoredInboundEvent, O as MessageDirection, S as InboxChannel, T as InboxRow, _ as ConversationEvent, a as Inbox, b as DeliveryStatus, c as InboxPatch, d as TemplateInput, f as createInbox, g as Conversation, h as Contact, i as InboundInput, j as PurgedContact, k as MessageKind, l as MessageInput, m as BotMode, n as ConversationFilter, o as InboxHooks, p as AuthorType, r as CreateInboxInput, s as InboxOptions, t as ContactInput, u as StartConversationInput, v as ConversationPriority, w as InboxMessage, x as InboundResult, y as ConversationStatus } from "../../inbox-3ql4phyr.js";
+import { a as InboxController, c as InboxListSnapshot, d as InboxWidgetController, f as InboxWidgetControllerOptions, g as createInboxWidgetController, h as createInboxController, i as ConversationSnapshot, l as InboxSource, m as createConversationController, n as ConversationController, o as InboxControllerOptions, p as InboxWidgetSnapshot, r as ConversationControllerOptions, s as InboxListActions, t as ConversationActions, u as InboxWidgetActions } from "../../client-Lx3mlvKO.js";
 //#region src/blocks/inbox/rows.d.ts
 export declare const INBOX_CHANNELS: readonly InboxChannel[];
 //#endregion
-export { type AuthorType, type BlockTransport, type BotMode, type Contact, type ContactInput, type Conversation, type ConversationEvent, type ConversationFilter, type ConversationPriority, type ConversationStatus, type CreateInboxInput, type DeliveryStatus, type InboundInput, type InboundResult, type Inbox, type InboxChannel, type InboxCounts, type InboxMessage, type InboxOptions, type InboxPatch, type InboxRow, type MessageAttachment, type MessageDelivery, type MessageDirection, type MessageInput, type MessageKind, type MessageTemplate, type PurgedContact, type RpcClient, type StartConversationInput, type StoredInboundEvent, type TemplateInput, createInbox, rpcTransport, sqlTransport };
+//#region src/blocks/inbox/events.d.ts
+/** The events of the `inbox` block: type to data. */
+type InboxEvents = {
+  readonly "inbox_conversation.opened": InboxEventData;
+  readonly "inbox_conversation.assigned": InboxEventData;
+  readonly "inbox_conversation.resolved": InboxEventData;
+  readonly "inbox_conversation.reopened": InboxEventData;
+  readonly "inbox_message.received": InboxEventData;
+};
+/** The `inbox` block's event types, for its manifest and `onBlockEvent`. */
+export declare const inboxEvents: Events<InboxEvents>;
+//#endregion
+//#region src/blocks/inbox/manifest.d.ts
+/** The `inbox` block's manifest (ADR 0029). */
+export declare const inboxBlock: BlockOf<"inbox", typeof createInbox, InboxEvents>;
+//#endregion
+export { type AuthorType, type BlockTransport, type BotMode, type Contact, type ContactInput, type Conversation, type ConversationActions, type ConversationController, type ConversationControllerOptions, type ConversationEvent, type ConversationFilter, type ConversationPriority, type ConversationSnapshot, type ConversationStatus, type CreateInboxInput, type DeliveryStatus, type InboundInput, type InboundResult, type Inbox, type InboxChannel, type InboxController, type InboxControllerOptions, type InboxCounts, type InboxEvents, type InboxHooks, type InboxListActions, type InboxListSnapshot, type InboxMessage, type InboxOptions, type InboxPatch, type InboxRow, type InboxSource, type InboxWidgetActions, type InboxWidgetController, type InboxWidgetControllerOptions, type InboxWidgetSnapshot, type MessageAttachment, type MessageDelivery, type MessageDirection, type MessageInput, type MessageKind, type MessageTemplate, type PurgedContact, type RpcClient, type StartConversationInput, type StoredInboundEvent, type TemplateInput, createConversationController, createInbox, createInboxController, createInboxWidgetController, dbTransport, rpcTransport, sqlTransport };