better-supabase 0.14.0 → 0.15.1

package/dist/blocks/forms/index.js

@@ -1,13 +1,13 @@
-import { a as ok, t as AsyncResult } from "../../result-B3m7xtRY.js";
 import { n as isRecord } from "../../guards-6F2bCtQR.js";
-import { t as formsSqlOptions } from "../../options-70OsM-wK.js";
+import { a as ok, t as AsyncResult } from "../../result-ntFBW2p2.js";
+import { t as formsSqlOptions } from "../../options-21s0dpnX.js";
 import { a as NPS_MAX, c as formSchema, i as FORM_SCHEMA_DIALECT, l as isFormDefinition, n as FORM_FIELD_TYPES, o as UNSCORED_FIELD_TYPES, s as formDefinitionProblems, t as FORM_DEFINITION_SCHEMA } from "../../form-definition-BTpM_tz1.js";
-import { A as requiredInstant, B as dbTransport, C as optionalText, D as recordOf, H as rpcTransport, I as textOf, O as recordOrEmpty, S as optionalInstant, U as sqlTransport, d as enumOrThrow, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall } from "../../block-helpers-CiKtrb6g.js";
-import { r as withBlockHooks } from "../../block-hooks-BymdcD0V.js";
+import { t as defineController } from "../../controller-BEliOBOv.js";
+import { A as requiredInstant, B as dbTransport, C as optionalText, D as recordOf, H as rpcTransport, I as textOf, O as recordOrEmpty, S as optionalInstant, U as sqlTransport, d as enumOrThrow, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall } from "../../block-helpers-CtBdjgO4.js";
+import { r as withBlockHooks } from "../../block-hooks-BfxX3682.js";
 import { n as event, t as defineEvents } from "../../event-map-CtPFhcOp.js";
-import { n as blockFields } from "../../block-fields-DBSJSeaO.js";
-import { n as defineBlock } from "../../define-block-Dze77QTw.js";
-import { a as pruneAnswers, c as stepIssues, d as answersSchema, f as validateAnswers, i as initialQuestionnaire, l as visibleFields, n as conditionHolds, o as questionnaireReducer, r as finishQuestionnaire, s as questionnaireSteps, t as createQuestionnaireController, u as visibleSteps } from "../../client-BKGVUgo7.js";
+import { n as blockFields } from "../../block-fields-DE_FgpOU.js";
+import { n as defineBlock } from "../../define-block-BGqOO8B3.js";
 //#region src/blocks/forms/forms.ts
 const FORM_STATUSES = [
 	"draft",
@@ -218,6 +218,295 @@ function createForms(options) {
 	});
 }
 //#endregion
+//#region src/blocks/forms/validate.ts
+/**
+* `email` as the HTML `<input type="email">` grammar, `date` as RFC 3339
+* `full-date`. Postgres asserts the same formats, so a value this accepts can
+* still fail there only for a mailbox the HTML grammar allows and pg_jsonschema
+* does not.
+*/
+const EMAIL = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+const DATE = /^(\d{4})-(\d{2})-(\d{2})$/;
+const URI_SCHEME = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function schemaOf(value) {
+	return isObject(value) ? value : {};
+}
+function typeMatches(type, value) {
+	switch (type) {
+		case "string": return typeof value === "string";
+		case "number": return typeof value === "number" && Number.isFinite(value);
+		case "integer": return typeof value === "number" && Number.isInteger(value);
+		case "boolean": return typeof value === "boolean";
+		case "array": return Array.isArray(value);
+		case "object": return isObject(value);
+		case "null": return value === null;
+		default: return true;
+	}
+}
+function equal(a, b) {
+	if (a === b) return true;
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((item, i) => equal(item, b[i]));
+	if (isObject(a) && isObject(b)) {
+		const keys = Object.keys(a);
+		return keys.length === Object.keys(b).length && keys.every((key) => key in b && equal(a[key], b[key]));
+	}
+	return false;
+}
+function validDate(value) {
+	const match = DATE.exec(value);
+	if (match === null) return false;
+	const [year, month, day] = [
+		Number(match[1]),
+		Number(match[2]),
+		Number(match[3])
+	];
+	const last = new Date(Date.UTC(year, month, 0)).getUTCDate();
+	return month >= 1 && month <= 12 && day >= 1 && day <= last;
+}
+function formatMatches(format, value) {
+	switch (format) {
+		case "email": return EMAIL.test(value);
+		case "date": return validDate(value);
+		case "uri": return URI_SCHEME.test(value) && URL.canParse(value);
+		default: return true;
+	}
+}
+const SURROGATE_PAIR = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+/** Code points, as JSON Schema counts string length. */
+const lengthOf = (value) => value.length - (value.match(SURROGATE_PAIR)?.length ?? 0);
+const items = (count) => count === 1 ? "1 item" : `${count} items`;
+function check(schema, value, path, issues) {
+	const at = (message) => issues.push({
+		message,
+		path
+	});
+	if ("type" in schema && !typeMatches(schema["type"], value)) {
+		at(`must be ${String(schema["type"])}`);
+		return;
+	}
+	if ("const" in schema && !equal(schema["const"], value)) at(`must be ${JSON.stringify(schema["const"])}`);
+	const allowed = schema["enum"];
+	if (Array.isArray(allowed) && !allowed.some((item) => equal(item, value))) at("must be one of the options");
+	if ("not" in schema) {
+		const inner = [];
+		check(schemaOf(schema["not"]), value, path, inner);
+		if (inner.length === 0) at("is required");
+	}
+	if (typeof value === "string") {
+		const { minLength, maxLength, pattern, format } = schema;
+		if (typeof minLength === "number" && lengthOf(value) < minLength) at(minLength === 1 ? "is required" : `must be at least ${minLength} characters`);
+		if (typeof maxLength === "number" && lengthOf(value) > maxLength) at(`must be at most ${maxLength} characters`);
+		if (typeof pattern === "string" && !new RegExp(pattern, "u").test(value)) at("has the wrong format");
+		if (format !== void 0 && !formatMatches(format, value)) at(`must be a valid ${String(format)}`);
+	}
+	if (typeof value === "number") {
+		const { minimum, maximum } = schema;
+		if (typeof minimum === "number" && value < minimum) at(`must be at least ${minimum}`);
+		if (typeof maximum === "number" && value > maximum) at(`must be at most ${maximum}`);
+	}
+	if (Array.isArray(value)) {
+		const { minItems, maxItems, uniqueItems } = schema;
+		const each = schema["items"];
+		if (typeof minItems === "number" && value.length < minItems) at(`must have at least ${items(minItems)}`);
+		if (typeof maxItems === "number" && value.length > maxItems) at(`must have at most ${items(maxItems)}`);
+		if (uniqueItems === true && value.some((item, i) => value.findIndex((other) => equal(item, other)) !== i)) at("must not repeat an item");
+		if (each !== void 0) for (const [i, item] of value.entries()) check(schemaOf(each), item, [...path, i], issues);
+	}
+	if (isObject(value)) {
+		const properties = schemaOf(schema["properties"]);
+		const required = schema["required"];
+		if (Array.isArray(required)) {
+			for (const key of required) if (typeof key === "string" && !(key in value)) issues.push({
+				message: "is required",
+				path: [...path, key]
+			});
+		}
+		for (const [key, item] of Object.entries(value)) if (key in properties) check(schemaOf(properties[key]), item, [...path, key], issues);
+		else if (schema["additionalProperties"] === false) issues.push({
+			message: "is not a field of this form",
+			path: [...path, key]
+		});
+	}
+	const all = schema["allOf"];
+	if (Array.isArray(all)) for (const part of all) check(schemaOf(part), value, path, issues);
+	if ("if" in schema) {
+		const condition = [];
+		check(schemaOf(schema["if"]), value, path, condition);
+		if (condition.length === 0 && "then" in schema) check(schemaOf(schema["then"]), value, path, issues);
+	}
+}
+/**
+* Checks answers against a form version's schema with the keywords the
+* generator emits, so a form can show errors before it submits. Postgres checks
+* the same schema again on submit; this is not a general JSON Schema
+* validator.
+*/
+function validateAnswers(schema, answers) {
+	const issues = [];
+	check(schema, answers, [], issues);
+	return issues;
+}
+/** A form version's schema as a Standard Schema, for form libraries. */
+function answersSchema(schema) {
+	return { "~standard": {
+		version: 1,
+		vendor: "better-supabase",
+		validate: (value) => {
+			const issues = validateAnswers(schema, value);
+			return issues.length === 0 ? { value } : { issues };
+		}
+	} };
+}
+//#endregion
+//#region src/blocks/forms/questionnaire.ts
+function same(a, b) {
+	return JSON.stringify(a) === JSON.stringify(b);
+}
+const EMPTY = /* @__PURE__ */ new Set([null, ""]);
+/**
+* Whether `condition` holds for `answers`, with the semantics of its JSON
+* Schema `if`.
+*/
+function conditionHolds(condition, answers) {
+	if (condition === void 0) return true;
+	if (!(condition.field in answers)) return false;
+	const value = answers[condition.field];
+	if ("equals" in condition) return same(value, condition.equals);
+	if ("in" in condition) return condition.in.some((item) => same(value, item));
+	return !(value === void 0 || EMPTY.has(value) || Array.isArray(value) && value.length === 0);
+}
+/** The steps whose `showIf` holds. */
+function visibleSteps(definition, answers) {
+	return definition.steps.filter((step) => conditionHolds(step.showIf, answers));
+}
+/** The step's fields whose `showIf` holds. */
+function visibleFields(step, answers) {
+	return step.fields.filter((field) => conditionHolds(field.showIf, answers));
+}
+function visibleKeys(definition, answers) {
+	return new Set(visibleSteps(definition, answers).flatMap((step) => visibleFields(step, answers).map((field) => field.key)));
+}
+/**
+* The answers without the ones for hidden steps and fields. Removing an answer
+* can hide a later field, so it repeats until nothing changes.
+*/
+function pruneAnswers(definition, answers) {
+	const keep = visibleKeys(definition, answers);
+	const next = Object.fromEntries(Object.entries(answers).filter(([key]) => keep.has(key)));
+	return Object.keys(next).length === Object.keys(answers).length ? next : pruneAnswers(definition, next);
+}
+/** The schema's issues for the fields `step` shows. */
+function stepIssues(schema, step, answers) {
+	const keys = new Set(visibleFields(step, answers).map((field) => field.key));
+	return validateAnswers(schema, answers).filter((issue) => {
+		const key = issue.path?.[0];
+		return typeof key === "string" && keys.has(key);
+	});
+}
+/** The state before the first answer. */
+function initialQuestionnaire(form, answers = {}) {
+	return {
+		step: (visibleSteps(form.definition, answers)[0] ?? form.definition.steps[0])?.key ?? "",
+		answers,
+		completed: [],
+		issues: []
+	};
+}
+/**
+* The step on screen, or the nearest visible one before it when an answer hid
+* it.
+*/
+function stepAfterAnswer(form, step, answers) {
+	const visible = new Set(visibleSteps(form.definition, answers).map((item) => item.key));
+	if (visible.has(step)) return step;
+	const order = form.definition.steps.map((item) => item.key);
+	return order.slice(0, Math.max(order.indexOf(step), 0)).toReversed().find((key) => visible.has(key)) ?? order.find((key) => visible.has(key)) ?? step;
+}
+/**
+* The questionnaire as a reducer: answers, the current step and the steps done.
+* `next` checks the step's fields against the version's schema and stays put
+* with `issues` when one fails; hidden steps are skipped.
+*/
+function questionnaireReducer(form, state, action) {
+	const steps = visibleSteps(form.definition, state.answers);
+	const index = steps.findIndex((step) => step.key === state.step);
+	switch (action.type) {
+		case "answer": {
+			const answers = { ...state.answers };
+			if (action.value === void 0) delete answers[action.key];
+			else answers[action.key] = action.value;
+			const issues = state.issues.filter((issue) => issue.path?.[0] !== action.key);
+			return {
+				...state,
+				step: stepAfterAnswer(form, state.step, answers),
+				answers,
+				issues
+			};
+		}
+		case "next": {
+			const current = steps[index];
+			if (current === void 0) return state;
+			const issues = stepIssues(form.schema, current, state.answers);
+			if (issues.length > 0) return {
+				...state,
+				issues
+			};
+			const completed = state.completed.includes(current.key) ? state.completed : [...state.completed, current.key];
+			const following = steps[index + 1];
+			return {
+				...state,
+				step: following?.key ?? current.key,
+				completed,
+				issues: []
+			};
+		}
+		case "back": {
+			const previous = steps[index - 1];
+			return previous === void 0 ? state : {
+				...state,
+				step: previous.key,
+				issues: []
+			};
+		}
+		case "goTo": {
+			const target = steps.findIndex((step) => step.key === action.step);
+			return target !== -1 && steps.slice(0, target).every((step) => state.completed.includes(step.key)) ? {
+				...state,
+				step: action.step,
+				issues: []
+			} : state;
+		}
+		case "reset": return initialQuestionnaire(form, action.answers);
+		default: return action;
+	}
+}
+/** The visible steps with their status, in the shape a Stepper renders. */
+function questionnaireSteps(form, state) {
+	return visibleSteps(form.definition, state.answers).map((step) => ({
+		key: step.key,
+		...step.title === void 0 ? {} : { title: step.title },
+		...step.description === void 0 ? {} : { description: step.description },
+		fields: visibleFields(step, state.answers),
+		completed: state.completed.includes(step.key),
+		active: step.key === state.step
+	}));
+}
+/** The pruned answers, or every issue when the whole form does not pass. */
+function finishQuestionnaire(form, state) {
+	const answers = pruneAnswers(form.definition, state.answers);
+	const issues = validateAnswers(form.schema, answers);
+	return issues.length === 0 ? {
+		ok: true,
+		answers
+	} : {
+		ok: false,
+		issues
+	};
+}
+//#endregion
 //#region src/blocks/forms/scoring.ts
 const trimmed = (value) => value.replaceAll(/^ +| +$/g, "").toLowerCase();
 const TEXT_TYPES = /* @__PURE__ */ new Set([
@@ -279,6 +568,95 @@ function npsScore(counts) {
 	return tenths < 0 && rounded > 0 ? -rounded : rounded;
 }
 //#endregion
+//#region src/blocks/forms/client.ts
+function byField(issues) {
+	const out = {};
+	for (const issue of issues) {
+		const key = issue.path?.[0];
+		const name = typeof key === "string" ? key : "";
+		(out[name] ??= []).push(issue.message);
+	}
+	return out;
+}
+function viewOf(form, current, finalIssues, submitting) {
+	const steps = questionnaireSteps(form, current);
+	const index = steps.findIndex((step) => step.active);
+	return {
+		steps,
+		step: steps[index],
+		answers: current.answers,
+		issues: byField([...current.issues, ...finalIssues]),
+		isFirst: index <= 0,
+		isLast: index === steps.length - 1,
+		submitting
+	};
+}
+/**
+* A multi-step form over a form version: the visible steps, the answers, and
+* per-field issues checked against the version's JSON Schema.
+*/
+function createQuestionnaireController(options) {
+	const { form } = options;
+	let current = initialQuestionnaire(form, options.initialAnswers);
+	let finalIssues = [];
+	let submitting = false;
+	return defineController(viewOf(form, current, finalIssues, submitting), (state) => {
+		const show = () => {
+			state.set(viewOf(form, current, finalIssues, submitting));
+		};
+		const dispatch = (action) => {
+			current = questionnaireReducer(form, current, action);
+			show();
+		};
+		return { actions: {
+			setAnswer: (key, value) => {
+				finalIssues = finalIssues.filter((issue) => issue.path?.[0] !== key);
+				dispatch({
+					type: "answer",
+					key,
+					value
+				});
+			},
+			next: () => {
+				dispatch({ type: "next" });
+			},
+			back: () => {
+				dispatch({ type: "back" });
+			},
+			goTo: (step) => {
+				dispatch({
+					type: "goTo",
+					step
+				});
+			},
+			reset: (answers) => {
+				finalIssues = [];
+				dispatch(answers === void 0 ? { type: "reset" } : {
+					type: "reset",
+					answers
+				});
+			},
+			submit: async () => {
+				const result = finishQuestionnaire(form, current);
+				if (!result.ok) {
+					finalIssues = result.issues;
+					show();
+					return false;
+				}
+				submitting = true;
+				show();
+				try {
+					await options.onSubmit(result.answers);
+				} finally {
+					submitting = false;
+					show();
+				}
+				return true;
+			}
+		} };
+	});
+}
+//#endregion
 //#region src/blocks/forms/events.ts
 /** The `forms` block's event types, for its manifest and `onBlockEvent`. */
 const formsEvents = defineEvents({

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

@@ -0,0 +1,82 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult } from "../../result-DZeA5KS6.js";
+import { t as StandardSchemaV1 } from "../../standard-DBV730sF.js";
+import { n as ExtraFields, r as FieldsOf } from "../../block-fields-BE7pInWZ.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { n as BlockOptions } from "../../block-helpers-CRpAHrp_.js";
+import { a as dbTransport, i as RpcClient, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DWZSJrwN.js";
+import { a as BlockTransportMiddleware, d as extendBlock, f as withBlockHooks, n as BlockHooks, p as wrapTransport } from "../../block-hooks-DZN2w69m.js";
+import { c as BlockOf } from "../../define-block-DvvcM54N.js";
+//#region src/blocks/goals/goals.d.ts
+/**
+ * A metric the database computes, or any other name the app keeps the actual
+ * value of itself.
+ */
+type TargetMetric = "deals.won_amount" | "deals.won_count" | "work_items.completed" | "invoices.paid_amount" | (string & {});
+/** A target. `F` types the extra columns the `fields` schema describes. */
+interface Target<F extends object = Record<never, never>> {
+  readonly id: string;
+  readonly name: string;
+  readonly metric: TargetMetric;
+  /** The member it is for; `undefined` for a team or the organization. */
+  readonly ownerId?: string;
+  readonly teamId?: string;
+  readonly periodStart: Temporal.PlainDate;
+  readonly periodEnd: Temporal.PlainDate;
+  /** For amount metrics. */
+  readonly currency?: string;
+  /** Minor units for amounts, a count otherwise. */
+  readonly goal: bigint;
+  /** The extra columns, keyed by database name. */
+  readonly fields: ExtraFields<F>;
+}
+interface TargetProgress<F extends object = Record<never, never>> extends Target<F> {
+  readonly progress: bigint;
+  /** Progress over the goal: 0.5 is halfway. */
+  readonly attainment: number;
+}
+interface TargetInput<F extends object = Record<never, never>> {
+  readonly id?: string;
+  readonly name?: string;
+  readonly metric?: TargetMetric;
+  readonly ownerId?: string;
+  readonly teamId?: string;
+  readonly periodStart?: Temporal.PlainDate;
+  readonly periodEnd?: Temporal.PlainDate;
+  readonly currency?: string;
+  readonly goal?: bigint;
+  /** The value of a metric no block computes. */
+  readonly actual?: bigint;
+  readonly archived?: boolean;
+  /** The extra columns to set. */
+  readonly fields?: Partial<F>;
+}
+interface Goals<F extends object = Record<never, never>> {
+  upsert(organizationId: string, target: TargetInput<F>): AsyncResult<Target<F>>;
+  /** The targets running on `on` (today by default), with progress. */
+  progress(organizationId: string, options?: {
+    readonly on?: Temporal.PlainDate;
+    readonly ownerId?: string;
+  }): AsyncResult<TargetProgress<F>[]>;
+}
+interface GoalsOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockOptions {
+  /**
+   * A Standard Schema for the target's extra columns
+   * (`blocks.goals.options.extraColumns`), keyed by database name. It types and
+   * parses them on reads, and validates them on `save`.
+   */
+  readonly fields?: S;
+  readonly hooks?: NoInfer<BlockHooks<Goals<FieldsOf<S>>>>;
+  readonly logger?: Logger;
+}
+/**
+ * The targets block: goals per period for a member, a team or the organization,
+ * and their progress.
+ */
+export declare function createGoals<S extends StandardSchemaV1 | undefined = undefined>(options: GoalsOptions<S>): Goals<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/goals/manifest.d.ts
+/** The `targets` block's manifest (ADR 0029). */
+export declare const goalsBlock: BlockOf<"goals", typeof createGoals>;
+//#endregion
+export { type BlockHooks, type BlockTransport, type BlockTransportMiddleware, type Goals, type GoalsOptions, type RpcClient, type Target, type TargetInput, type TargetMetric, type TargetProgress, dbTransport, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

package/dist/blocks/goals/index.js

@@ -0,0 +1,72 @@
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { t as goalsSqlOptions } from "../../options-B-cxGmRA.js";
+import { B as dbTransport, C as optionalText, D as recordOf, H as rpcTransport, I as textOf, U as sqlTransport, a as bigintOf, 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 blockFields } from "../../block-fields-DE_FgpOU.js";
+import { n as defineBlock } from "../../define-block-BGqOO8B3.js";
+import { n as compact, r as plainDate, t as attrsArg } from "../../sales-shared-DXGFJP4g.js";
+//#region src/blocks/goals/goals.ts
+function targetOf(value) {
+	const row = recordOf(value, "target");
+	return compact({
+		id: textOf(row["id"]),
+		name: textOf(row["name"]),
+		metric: textOf(row["metric"]),
+		ownerId: optionalText(row["owner_user_id"]),
+		teamId: optionalText(row["team_id"]),
+		periodStart: plainDate(row["period_start"]) ?? plainDate("1970-01-01"),
+		periodEnd: plainDate(row["period_end"]) ?? plainDate("1970-01-01"),
+		currency: optionalText(row["currency"]),
+		goal: bigintOf(row["goal"], "target goal"),
+		fields: isRecord(row["fields"]) ? row["fields"] : {}
+	});
+}
+/**
+* The targets block: goals per period for a member, a team or the organization,
+* and their progress.
+*/
+function createGoals(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const fields = blockFields(options.fields, "target fields");
+	return withBlockHooks({
+		upsert: (organizationId, target) => {
+			const { id, goal, actual, fields: extra, ...rest } = target;
+			return fields.args(extra).andThen((checked) => call("save_target", {
+				tenant: organizationId,
+				target: id ?? null,
+				attrs: {
+					...attrsArg(rest),
+					...goal === void 0 ? {} : { goal: goal.toString() },
+					...actual === void 0 ? {} : { actual: actual.toString() },
+					...checked === void 0 ? {} : { fields: checked }
+				}
+			}, targetOf).andThen(fields.row));
+		},
+		progress: (organizationId, progress = {}) => call("target_progress", {
+			tenant: organizationId,
+			on_date: progress.on === void 0 ? null : progress.on.toString(),
+			owner: progress.ownerId ?? null
+		}, (value) => recordsOf(value, "target_progress").map((row) => ({
+			...targetOf(row),
+			progress: bigintOf(row["progress"], "target progress"),
+			attainment: Number(row["attainment"] ?? 0)
+		}))).andThen(fields.rows)
+	}, options.hooks, {
+		block: "goals",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/goals/manifest.ts
+/** The `targets` block's manifest (ADR 0029). */
+const goalsBlock = defineBlock({
+	name: "goals",
+	sql: ["goals"],
+	options: { goals: goalsSqlOptions },
+	create: createGoals,
+	category: "crm",
+	recipes: ["targets-progress"]
+});
+//#endregion
+export { createGoals, dbTransport, extendBlock, goalsBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

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

@@ -1,12 +1,12 @@
 /// <reference lib="esnext.temporal" />
-import { T as ErrorMapper, t as AsyncResult } from "../../result-C6jDfedy.js";
-import { dt as SubjectRef } from "../../executor-CPyrQdjh.js";
-import { Ct as Events } from "../../events-DbLjvxDX.js";
+import { T as ErrorMapper, t as AsyncResult } from "../../result-DZeA5KS6.js";
+import { $ as RecordRef } from "../../types-DFdg_4yN.js";
+import { Ct as Events } from "../../events-vcqenSYU.js";
 import { n as Logger } from "../../logger-DWVYUmwi.js";
-import { a as BlockTenantOptions, r as BlockTemporalOptions } from "../../block-helpers-BaugZlJV.js";
-import { a as dbTransport, i as RpcClient, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-d53POsem.js";
-import { a as BlockTransportMiddleware, d as extendBlock, f as withBlockHooks, n as BlockHooks, p as wrapTransport } from "../../block-hooks-CmjPKqQ_.js";
-import { Gt as SectionWrite, Lt as Section, Wt as SectionRowInput, c as BlockOf, rn as EntitySchema } from "../../define-block-COpcS6aT.js";
+import { a as BlockTenantOptions, r as BlockTemporalOptions } from "../../block-helpers-CRpAHrp_.js";
+import { a as dbTransport, i as RpcClient, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DWZSJrwN.js";
+import { a as BlockTransportMiddleware, d as extendBlock, f as withBlockHooks, n as BlockHooks, p as wrapTransport } from "../../block-hooks-DZN2w69m.js";
+import { Sn as EntitySchema, c as BlockOf, ln as RecordBindingWrite, mn as RecordRowInput, rn as RecordBinding } from "../../define-block-DvvcM54N.js";
 import { t as GuestAction } from "../../guest-actions-1T1DeS5Y.js";
 //#region src/blocks/guests/guests.d.ts
 interface GuestsOptions extends BlockTemporalOptions, BlockTenantOptions {
@@ -35,7 +35,7 @@ interface Guest {
    * The party the guest acts for, such as a customer company: they see its
    * invoices and bookings.
    */
-  readonly party?: SubjectRef;
+  readonly party?: RecordRef;
   readonly status: GuestStatus;
   readonly invitedBy?: string;
   readonly expiresAt?: Temporal.Instant;
@@ -57,7 +57,7 @@ interface GuestGrant {
   readonly id: string;
   readonly organizationId: string;
   readonly guestId: string;
-  readonly subject: SubjectRef;
+  readonly subject: RecordRef;
   /** Always holds `read`. */
   readonly actions: readonly GuestAction[];
   readonly grantedBy?: string;
@@ -77,7 +77,7 @@ interface GuestInviteInput {
   readonly email: string;
   readonly name?: string;
   /** The customer company or person the guest acts for. */
-  readonly party?: SubjectRef;
+  readonly party?: RecordRef;
   /** When the invite stops working. */
   readonly expiresAt?: Temporal.Instant;
 }
@@ -111,15 +111,15 @@ interface Guests {
    * Lets a guest reach one record. Needs `guests.manage`; the record must be in
    * the guest's organization.
    */
-  grant(guestId: string, subject: SubjectRef, input?: GuestGrantInput): AsyncResult<GuestGrant>;
+  grant(guestId: string, subject: RecordRef, input?: GuestGrantInput): AsyncResult<GuestGrant>;
   /** `false` when the grant is gone or the caller can't manage it. */
   revokeGrant(grantId: string): AsyncResult<boolean>;
   /** The guests who reach a record. The record decides the tenant. */
-  grants(subject: SubjectRef): AsyncResult<readonly RecordGuestGrant[]>;
+  grants(subject: RecordRef): AsyncResult<readonly RecordGuestGrant[]>;
   /** What the caller reaches as a guest, for a portal's home page. */
   mine(): AsyncResult<readonly GuestMembership[]>;
   /** Whether the caller reaches a record as a guest for an action. */
-  can(subject: SubjectRef, action?: GuestAction): AsyncResult<boolean>;
+  can(subject: RecordRef, action?: GuestAction): AsyncResult<boolean>;
 }
 /** The `guests` SQL module as typed calls. */
 export declare function createGuests(options: GuestsOptions): Guests;
@@ -180,21 +180,19 @@ interface GuestSectionGrantInput extends GuestGrantInput {
 }
 export declare const guestSectionGrantSchema: EntitySchema<GuestSectionGrantInput>;
 //#endregion
-//#region src/blocks/guests/section.d.ts
-/** The writes of the guests section. */
+//#region src/blocks/guests/record-binding.d.ts
+/** The writes of the guests binding. */
 type GuestsWrites = {
   /** Lets a guest reach the record. */
-  readonly grant: SectionWrite<Guests, GuestSectionGrantInput, GuestGrant>;
+  readonly grant: RecordBindingWrite<Guests, GuestSectionGrantInput, GuestGrant>;
   /** Takes one guest's access to the record away. */
-  readonly revoke: SectionWrite<Guests, SectionRowInput, boolean>;
+  readonly revoke: RecordBindingWrite<Guests, RecordRowInput, boolean>;
 };
 /** The guests who reach a record: a sharing panel. */
-export declare const guestsSection: Section<Guests, readonly RecordGuestGrant[], undefined, never, GuestsWrites>;
+export declare const guestsBinding: RecordBinding<Guests, readonly RecordGuestGrant[], undefined, never, GuestsWrites>;
 //#endregion
 //#region src/blocks/guests/manifest.d.ts
 /** The `guests` block's manifest (ADR 0029). */
-export declare const guestsBlock: BlockOf<"guests", typeof createGuests, GuestsEvents, Record<never, never>, never, {
-  readonly guests: typeof guestsSection;
-}>;
+export declare const guestsBlock: BlockOf<"guests", typeof createGuests, GuestsEvents, Record<never, never>, never, typeof guestsBinding>;
 //#endregion
 export { type BlockHooks, type BlockTransport, type BlockTransportMiddleware, type Guest, type GuestAcceptedEventData, type GuestAction, type GuestGrant, type GuestGrantEventData, type GuestGrantInput, type GuestInvite, type GuestInviteInput, type GuestInvitedEventData, type GuestListOptions, type GuestMembership, type GuestRevokedEventData, type GuestSectionGrantInput, type GuestStatus, type Guests, type GuestsEvents, type GuestsOptions, type GuestsWrites, type RecordGuestGrant, type RpcClient, dbTransport, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };