@softr/sdk 0.0.68-props.0 → 0.0.69-alpha.0

package/dist/codegen/fetch-metadata.js

@@ -1,4 +1,4 @@
-import { assert, panic } from "../assertions.js";
+import { panic } from "../assertions.js";
 import { fetch } from "../fetch.js";
 
 //#region src/codegen/fetch-metadata.ts
@@ -17,54 +17,27 @@ function metadataSourceFromEnv(env = process.env) {
 		token: env.SOFTR_STUDIO_TOKEN
 	};
 }
-async function fetchSoftrEnvInput(source, aliases) {
+async function fetchSoftrEnvInput(source) {
 	const { studioApiUrl, datasourceApiUrl, applicationId, token } = source;
 	const [registered, userGroups] = await Promise.all([apiFetch(`${studioApiUrl}/v1/applications/${applicationId}/datasources`, token), apiFetch(`${studioApiUrl}/v1/applications/${applicationId}/access-control/user-groups`, token)]);
-	const datasources = await Promise.all(registered.map(async ({ name, datasource }) => {
-		const metadata = await apiFetch(`${datasourceApiUrl}/v1/datasource/vibe/studio/applications/${applicationId}/datasources/${datasource.id}/metadata`, token);
-		return {
-			...metadata,
-			id: datasource.id,
-			tableId: metadata.id,
-			name
-		};
-	}));
-	let users = null;
-	if (Object.keys(aliases).length > 0) {
-		const { payload } = await apiFetch(`${studioApiUrl}/v1/applications/${applicationId}`, token);
-		const connection = payload.user_connection?.datasource ?? panic("softr.json declares user.properties, but this app has no users table.");
-		const metadata = await apiFetch(`${datasourceApiUrl}/v1/datasource/${applicationId}/${connection.integration_id}/metadata`, token, {
-			datasourceType: connection.datasource_integration_type,
-			resourceIdentifier: { keys: connection.resource_identifier.keys }
-		});
-		users = {
-			datasourceId: connection.id,
-			tableId: metadata.id,
-			name: metadata.name,
-			properties: {}
-		};
-		for (const [alias, fieldId] of Object.entries(aliases)) {
-			const field = metadata.fields.find(({ id }) => id === fieldId) ?? panic(`softr.json user.properties.${alias} names "${fieldId}", which is not a field of the users table.`);
-			assert(field.type !== "ATTACHMENT" && field.type !== "LONG_TEXT" && !(field.allowMultipleEntries && (field.type === "LINKED_RECORD" || field.type === "LOOKUP")), `softr.json user.properties.${alias} names "${field.name}", a ${field.allowMultipleEntries ? "multiple " : ""}${field.type} field, which can be too big to read with the signed-in user. Remove it, and read it with defineQuery on the users table instead.`);
-			users.properties[alias] = field;
-		}
-	}
 	return {
-		datasources,
-		userGroups,
-		users
+		datasources: await Promise.all(registered.map(async ({ name, datasource }) => {
+			const metadata = await apiFetch(`${datasourceApiUrl}/v1/datasource/vibe/studio/applications/${applicationId}/datasources/${datasource.id}/metadata`, token);
+			return {
+				...metadata,
+				id: datasource.id,
+				tableId: metadata.id,
+				name
+			};
+		})),
+		userGroups
 	};
 }
-async function apiFetch(url, token, body) {
-	const response = await fetch(url, {
-		method: body === void 0 ? "GET" : "POST",
-		headers: {
-			accept: "application/json",
-			...body === void 0 ? {} : { "content-type": "application/json" },
-			Authorization: `Bearer ${token}`
-		},
-		body: body === void 0 ? void 0 : JSON.stringify(body)
-	}).catch(() => panic(`Could not reach ${url}`));
+async function apiFetch(url, token) {
+	const response = await fetch(url, { headers: {
+		accept: "application/json",
+		Authorization: `Bearer ${token}`
+	} }).catch(() => panic(`Could not reach ${url}`));
 	if (!response.ok) panic(`${url} answered ${response.status}`);
 	return await response.json();
 }

package/dist/codegen/softr-env.js

@@ -1,4 +1,4 @@
-import { renderDatasourceTypes, renderUserProperties } from "./datasource-types.js";
+import { renderDatasourceTypes } from "./datasource-types.js";
 import { renderUserGroups } from "./user-groups.js";
 
 //#region src/codegen/softr-env.ts
@@ -15,7 +15,6 @@ function renderSoftrEnv(input, sdkVersion) {
 		indent(interfaces),
 		"",
 		indent(renderUserGroups(input.userGroups)),
-		...input.users === null ? [] : ["", indent(renderUserProperties(input.users.properties, input.datasources))],
 		"}",
 		""
 	].join("\n");

package/dist/codegen/softr-fields.js

@@ -0,0 +1,41 @@
+//#region src/codegen/softr-fields.ts
+/**
+* Renders the app's `src/softr-fields.ts`: every registered datasource's fields by id, with the type
+* and options a value's text depends on, registered with the SDK as a side effect of being imported.
+* The root route imports it once, and `formatValue(query, alias, value, formatting)` then formats any
+* value a query read by its field's own type.
+*/
+function renderSoftrFields(datasources, sdkVersion) {
+	const entries = [...datasources].sort((a, b) => a.id.localeCompare(b.id)).map((datasource) => {
+		const fields = [...datasource.fields].sort((a, b) => a.id.localeCompare(b.id)).map((field) => {
+			const shape = { type: field.type };
+			if (field.options !== null && field.options !== void 0 && Object.keys(field.options).length > 0) shape.options = field.options;
+			if (field.allowMultipleEntries) shape.allowMultipleEntries = true;
+			return `    ${JSON.stringify(field.id)}: ${JSON.stringify(shape)},`;
+		});
+		return [
+			`  // ${datasource.name}`,
+			`  ${JSON.stringify(datasource.id)}: {`,
+			...fields,
+			"  },"
+		].join("\n");
+	});
+	return [
+		`// Generated by @softr/sdk ${sdkVersion}. Do not edit: the SDK's codegen rewrites it after a schema change.`,
+		"//",
+		"// The type and options of every field, by datasource and field id, for `formatValue` and",
+		"// `fieldShape` from @softr/sdk. Imported once, in the root route, it registers them with the SDK.",
+		"import { registerSoftrFields } from \"@softr/sdk\";",
+		"import type { SoftrFieldRegistry } from \"@softr/sdk\";",
+		"",
+		"export const softrFields = {",
+		...entries,
+		"} as const satisfies SoftrFieldRegistry;",
+		"",
+		"registerSoftrFields(softrFields);",
+		""
+	].join("\n");
+}
+
+//#endregion
+export { renderSoftrFields };

package/dist/cookies.js

@@ -1,4 +1,3 @@
-import { softAssert } from "./assertions.js";
 import { getRequestHeader, getResponseHeaders, setResponseHeader } from "@tanstack/react-start/server";
 
 //#region src/cookies.ts
@@ -39,16 +38,9 @@ const USER_TIMEZONE_COOKIE = "user-timezone";
 function readUserTimezone() {
 	return readRequestCookies()[USER_TIMEZONE_COOKIE] ?? null;
 }
-/** What browsers keep of one cookie's name and value. They drop a larger one silently. */
-const COOKIE_MAX_BYTES = 4096;
 function writeCookies(cookies) {
-	const written = cookies.filter((cookie) => {
-		const size = cookie.split(";")[0].length;
-		softAssert(size <= COOKIE_MAX_BYTES, () => `The ${cookie.slice(0, cookie.indexOf("="))} cookie is ${size} bytes, over the ${COOKIE_MAX_BYTES} a browser keeps. It was not written.`);
-		return size <= COOKIE_MAX_BYTES;
-	});
-	if (written.length === 0) return;
-	setResponseHeader("Set-Cookie", [...getResponseHeaders().getSetCookie(), ...written]);
+	if (cookies.length === 0) return;
+	setResponseHeader("Set-Cookie", [...getResponseHeaders().getSetCookie(), ...cookies]);
 }
 
 //#endregion

package/dist/core/options.d.ts

@@ -0,0 +1,36 @@
+import { DatasourceAction, ReadShape } from "../action.js";
+import "@tanstack/react-start/server-only";
+
+//#region src/core/options.d.ts
+/** One row a linked-record picker offers. */
+type RecordOption = {
+  id: string;
+  label: string;
+};
+/** A page of a picker's rows, in the shape `LinkedRecordPicker`'s `load` answers with. */
+type RecordOptions = {
+  options: RecordOption[];
+  nextOffset: number | null;
+};
+/**
+ * The rows a linked field can point at, for a picker: each record of the query as its id and the text
+ * of one field, searched on that field when a term is given, a page at a time.
+ *
+ * @example
+ * const loadCompanies = createServerFn()
+ *   .validator(z.object({ term: z.string(), offset: z.number().nullable() }))
+ *   .handler(({ data }) => ds.options(companiesQuery, { label: 'name', ...data }))
+ */
+declare function listOptions<TShape extends ReadShape>(query: DatasourceAction<TShape>, {
+  label,
+  term,
+  offset,
+  limit
+}: {
+  label: keyof TShape["fields"] & string;
+  term?: string;
+  offset?: number | null;
+  limit?: number;
+}): Promise<RecordOptions>;
+//#endregion
+export { RecordOption, RecordOptions, listOptions };

package/dist/core/options.js

@@ -0,0 +1,39 @@
+import { makeChain } from "../datasource/fields.js";
+import { listRecords } from "../datasource/record.js";
+import "@tanstack/react-start/server-only";
+
+//#region src/core/options.ts
+/**
+* The rows a linked field can point at, for a picker: each record of the query as its id and the text
+* of one field, searched on that field when a term is given, a page at a time.
+*
+* @example
+* const loadCompanies = createServerFn()
+*   .validator(z.object({ term: z.string(), offset: z.number().nullable() }))
+*   .handler(({ data }) => ds.options(companiesQuery, { label: 'name', ...data }))
+*/
+async function listOptions(query, { label, term = "", offset = null, limit = 20 }) {
+	let list = listRecords(query).limit(limit).offset(offset);
+	const needle = term.trim();
+	if (needle !== "") list = list.where(() => makeChain(label).contains(needle));
+	const page = await list;
+	return {
+		options: page.records.map((record) => ({
+			id: record.id,
+			label: labelOf(record.fields[label])
+		})),
+		nextOffset: page.nextOffset
+	};
+}
+/** The text a label field holds: its own text, or the label of the choice or record it names. */
+function labelOf(value) {
+	if (value === null || value === void 0) return "";
+	if (typeof value === "object") {
+		const label = value.label;
+		return typeof label === "string" ? label : "";
+	}
+	return String(value);
+}
+
+//#endregion
+export { listOptions };

package/dist/core/use-overrides.d.ts

@@ -0,0 +1,17 @@
+//#region src/core/use-overrides.d.ts
+/**
+ * The edits a page has saved that its loader has not re-run for, keyed by record id: what a drawer or
+ * an inline control wrote, merged over the loader's rows until a fresh read replaces them.
+ *
+ * `onSaved` is the shape a drawer's `onSaved` callback takes: it fires before the write, and again
+ * with the old value if the write fails, so the row moves at once and moves back on failure.
+ */
+declare function useOverrides<TPatch extends object>(): {
+  /** What is pending for one record, or undefined when nobody has touched it. */
+  of: (recordId: string) => TPatch | undefined;
+  onSaved: (recordId: string, patch: TPatch) => void;
+  /** Drops what is pending for one record, once a fresh read of it has replaced the row. */
+  clear: (recordId: string) => void;
+};
+//#endregion
+export { useOverrides };

package/dist/core/use-overrides.js

@@ -0,0 +1,30 @@
+import { useState } from "react";
+
+//#region src/core/use-overrides.ts
+/**
+* The edits a page has saved that its loader has not re-run for, keyed by record id: what a drawer or
+* an inline control wrote, merged over the loader's rows until a fresh read replaces them.
+*
+* `onSaved` is the shape a drawer's `onSaved` callback takes: it fires before the write, and again
+* with the old value if the write fails, so the row moves at once and moves back on failure.
+*/
+function useOverrides() {
+	const [pending, setPending] = useState({});
+	return {
+		of: (recordId) => pending[recordId],
+		onSaved: (recordId, patch) => setPending((current) => ({
+			...current,
+			[recordId]: {
+				...current[recordId],
+				...patch
+			}
+		})),
+		clear: (recordId) => setPending((current) => ({
+			...current,
+			[recordId]: void 0
+		}))
+	};
+}
+
+//#endregion
+export { useOverrides };

package/dist/datasource/datasource.d.ts

@@ -1,4 +1,5 @@
 import { createRecord, deleteRecord, getRecord, listRecords, updateRecord } from "./record.js";
+import { listOptions } from "../core/options.js";
 import { chart, metric } from "./chart.js";
 import "@tanstack/react-start/server-only";
 
@@ -11,6 +12,7 @@ declare const ds: {
   delete: typeof deleteRecord;
   metric: typeof metric;
   chart: typeof chart;
+  options: typeof listOptions;
 };
 //#endregion
 export { ds };

package/dist/datasource/datasource.js

@@ -1,5 +1,6 @@
 import { createRecord, deleteRecord, getRecord, listRecords, updateRecord } from "./record.js";
 import { chart, metric } from "./chart.js";
+import { listOptions } from "../core/options.js";
 import "@tanstack/react-start/server-only";
 
 //#region src/datasource/datasource.ts
@@ -10,7 +11,8 @@ const ds = {
 	update: updateRecord,
 	delete: deleteRecord,
 	metric,
-	chart
+	chart,
+	options: listOptions
 };
 
 //#endregion

package/dist/datasource/fields.js

@@ -46,7 +46,8 @@ function group(logicalOperator, filters) {
 /**
 * One chain per alias, carrying every operator whatever the alias reads as. Only the types
 * narrow: a call the types reject cannot reach here, so there is nothing for a per-type
-* runtime chain to catch.
+* runtime chain to catch. Exported for a filter built on an alias the caller named, where no
+* type stands behind the chain.
 */
 function makeChain(subject) {
 	return {
@@ -87,4 +88,4 @@ function leaf(subject, operator, value) {
 }
 
 //#endregion
-export { andAll, makeFieldSet, makeSortSet };
+export { andAll, makeChain, makeFieldSet, makeSortSet };

package/dist/datasource/record.d.ts

@@ -68,6 +68,7 @@ interface ListResult<TRecord extends SoftrRecord = SoftrRecord> {
   total: number;
   nextOffset: number | null;
 }
+type GetRecord<TShape extends ReadShape> = SoftrRecord<ActionRecord<TShape>> | null;
 /**
  * Queries a list of records from the datasource.
  *
@@ -135,4 +136,4 @@ declare function deleteRecord<TShape extends ActionShape & {
   id: string;
 }): Promise<void>;
 //#endregion
-export { WhereCallback, createRecord, deleteRecord, getRecord, listRecords, updateRecord };
+export { GetRecord, WhereCallback, createRecord, deleteRecord, getRecord, listRecords, updateRecord };

package/dist/default-error-overlay.d.ts

@@ -1,4 +1,4 @@
-import * as react6 from "react";
+import * as react4 from "react";
 
 //#region src/default-error-overlay.d.ts
 type Props = {
@@ -8,6 +8,6 @@ type Props = {
 declare function DefaultErrorOverlay({
   error,
   reset
-}: Props): react6.JSX.Element;
+}: Props): react4.JSX.Element;
 //#endregion
 export { DefaultErrorOverlay };

package/dist/fields/format.d.ts

@@ -0,0 +1,45 @@
+import { Formatting } from "../formatting.js";
+
+//#region src/fields/format.d.ts
+
+/**
+ * A field's type and options, which is all its text depends on. The generated `src/softr-fields.ts`
+ * holds one per field of every registered datasource.
+ */
+type FieldShape = {
+  type: string;
+  options?: Record<string, unknown> | null;
+  /** True when the field holds several values, which read back as an array. */
+  allowMultipleEntries?: boolean;
+};
+/** The fields of every registered datasource, by datasource id then field id. */
+type SoftrFieldRegistry = Record<string, Record<string, FieldShape>>;
+/**
+ * Makes the app's fields known to `fieldShape` and `formatValue`. The generated `src/softr-fields.ts`
+ * calls it once as a side effect of being imported; the root route imports that file.
+ */
+declare function registerSoftrFields(fields: SoftrFieldRegistry): void;
+/**
+ * The shape of a field a query reads, by the alias the query holds it under. Throws when the app has
+ * not registered its fields: the generated `src/softr-fields.ts` is not imported.
+ */
+declare function fieldShape(query: {
+  datasourceId: string;
+  fields: Record<string, string>;
+}, alias: string): FieldShape;
+/**
+ * A value a query read, as the text a page shows it as, by the field's own type and options: money with
+ * its symbol, a date in the app's format, a choice or a linked record by its label, a rating out of its
+ * scale, a duration in hours and minutes, a checkbox as Yes or No. '' for a value the record does not
+ * hold. Several values read joined by a comma.
+ */
+declare function formatValue(query: {
+  datasourceId: string;
+  fields: Record<string, string>;
+}, alias: string, value: unknown, formatting: Formatting): string;
+/** `formatValue` for a shape in hand, such as one from `src/softr-fields.ts` or a `returnedField`. */
+declare function formatField(shape: FieldShape, value: unknown, formatting: Formatting): string;
+/** A duration, which the datasource holds in milliseconds, as hours and minutes; seconds only under an hour. */
+declare function formatDuration(milliseconds: number): string;
+//#endregion
+export { FieldShape, SoftrFieldRegistry, fieldShape, formatDuration, formatField, formatValue, registerSoftrFields };

package/dist/fields/format.js

@@ -0,0 +1,140 @@
+import { formatDate, formatDateTime, formatNumber } from "../formatting.js";
+
+//#region src/fields/format.ts
+let registry = {};
+/**
+* Makes the app's fields known to `fieldShape` and `formatValue`. The generated `src/softr-fields.ts`
+* calls it once as a side effect of being imported; the root route imports that file.
+*/
+function registerSoftrFields(fields) {
+	registry = {
+		...registry,
+		...fields
+	};
+}
+/**
+* The shape of a field a query reads, by the alias the query holds it under. Throws when the app has
+* not registered its fields: the generated `src/softr-fields.ts` is not imported.
+*/
+function fieldShape(query, alias) {
+	const fieldId = query.fields[alias];
+	if (fieldId === void 0) throw new Error(`The query has no field "${alias}"; it reads ${Object.keys(query.fields).join(", ")}.`);
+	const shape = registry[query.datasourceId]?.[fieldId];
+	if (shape === void 0) throw new Error(`No shape is registered for field ${fieldId} of datasource ${query.datasourceId}. Import the generated src/softr-fields.ts once, in the root route, and run the SDK's codegen after a schema change.`);
+	return shape;
+}
+/**
+* A value a query read, as the text a page shows it as, by the field's own type and options: money with
+* its symbol, a date in the app's format, a choice or a linked record by its label, a rating out of its
+* scale, a duration in hours and minutes, a checkbox as Yes or No. '' for a value the record does not
+* hold. Several values read joined by a comma.
+*/
+function formatValue(query, alias, value, formatting) {
+	return formatField(fieldShape(query, alias), value, formatting);
+}
+/** `formatValue` for a shape in hand, such as one from `src/softr-fields.ts` or a `returnedField`. */
+function formatField(shape, value, formatting) {
+	if (value === null || value === void 0) return "";
+	if (Array.isArray(value)) return value.map((entry) => formatField({
+		...shape,
+		allowMultipleEntries: false
+	}, entry, formatting)).filter((text$1) => text$1 !== "").join(", ");
+	const returned = computedReturns(shape);
+	if (returned !== null) return formatField(returned, value, formatting);
+	const options = shape.options ?? {};
+	switch (shape.type) {
+		case "CHECKBOX": return value === true ? "Yes" : "No";
+		case "NUMBER":
+		case "COUNT":
+		case "PROGRESS": return typeof value === "number" ? formatNumber(value, formatting, digits(precisionOf(options))) : text(value);
+		case "AUTONUMBER": return text(value);
+		case "CURRENCY": {
+			if (typeof value !== "number") return text(value);
+			const code = options.isoCode;
+			const precision = precisionOf(options) ?? 2;
+			const cents = {
+				minimumFractionDigits: Number.isInteger(value) ? 0 : precision,
+				maximumFractionDigits: precision
+			};
+			if (typeof code === "string" && /^[A-Z]{3}$/.test(code)) return formatNumber(value, formatting, {
+				style: "currency",
+				currency: code,
+				...cents
+			});
+			const amount = formatNumber(value, formatting, cents);
+			const symbol = typeof options.customSymbol === "string" ? options.customSymbol : "";
+			if (symbol === "") return amount;
+			return options.symbolOrCodePosition === "AFTER" ? `${amount} ${symbol}` : `${symbol}${amount}`;
+		}
+		case "PERCENT": return typeof value === "number" ? `${formatNumber(value, formatting, digits(precisionOf(options)))}%` : text(value);
+		case "RATING": return typeof value === "number" ? `${value}/${numberOption(options, "max") ?? 5}` : text(value);
+		case "DURATION": return typeof value === "number" ? formatDuration(value) : text(value);
+		case "DATE":
+		case "DATETIME": return isDateValue(value) ? formatDateTime(value, formatting, { dateStyle: "medium" }) : text(value);
+		case "CREATED_AT":
+		case "UPDATED_AT":
+			if (!isDateValue(value)) return text(value);
+			return options.precision === "DATE" ? formatDate(value, formatting, { dateStyle: "medium" }) : formatDateTime(value, formatting, { dateStyle: "medium" });
+		case "DATE_RANGE": {
+			const range = value;
+			return [isDateValue(range.from) ? formatDateTime(range.from, formatting, { dateStyle: "medium" }) : "", isDateValue(range.to) ? formatDateTime(range.to, formatting, { dateStyle: "medium" }) : ""].filter((part) => part !== "").join(" – ");
+		}
+		case "USER": {
+			const person = value;
+			return text(person.name ?? person.email);
+		}
+		case "ATTACHMENT": {
+			const file = value;
+			return typeof file.filename === "string" && file.filename !== "" ? file.filename : "File";
+		}
+		default:
+			if (typeof value === "object" && "label" in value) return text(value.label);
+			return text(value);
+	}
+}
+/** The shape a FORMULA, LOOKUP or ROLLUP reads as, when its options say; null for any other field. */
+function computedReturns(shape) {
+	if (shape.type !== "FORMULA" && shape.type !== "LOOKUP" && shape.type !== "ROLLUP") return null;
+	const returned = shape.options?.returnedField;
+	if (typeof returned !== "object" || returned === null || !("type" in returned) || typeof returned.type !== "string") return null;
+	const options = "options" in returned && typeof returned.options === "object" ? returned.options : null;
+	return {
+		type: returned.type,
+		options
+	};
+}
+function text(value) {
+	return value === null || value === void 0 ? "" : String(value);
+}
+function isDateValue(value) {
+	return typeof value === "string" && value !== "" || typeof value === "number" || value instanceof Date;
+}
+function numberOption(options, key) {
+	const value = options[key];
+	return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : void 0;
+}
+function precisionOf(options) {
+	return numberOption(options, "precision");
+}
+function digits(precision) {
+	return precision === void 0 ? void 0 : {
+		minimumFractionDigits: precision,
+		maximumFractionDigits: precision
+	};
+}
+/** A duration, which the datasource holds in milliseconds, as hours and minutes; seconds only under an hour. */
+function formatDuration(milliseconds) {
+	const total = Math.round(milliseconds / 1e3);
+	const hours = Math.floor(total / 3600);
+	const minutes = Math.floor(total % 3600 / 60);
+	const rest = total % 60;
+	const parts = [
+		hours > 0 ? `${hours}h` : "",
+		minutes > 0 ? `${minutes}m` : "",
+		hours === 0 && rest > 0 ? `${rest}s` : ""
+	].filter((part) => part !== "");
+	return parts.length === 0 ? "0m" : parts.join(" ");
+}
+
+//#endregion
+export { fieldShape, formatDuration, formatField, formatValue, registerSoftrFields };

package/dist/formatting.d.ts

@@ -1,6 +1,6 @@
-import { z } from "zod";
-import * as react2 from "react";
+import * as react0 from "react";
 import { ReactNode } from "react";
+import { z } from "zod";
 
 //#region src/formatting.d.ts
 type FixedDateFormat = "FRIENDLY" | "DD-MM-YYYY" | "MM-DD-YYYY" | "YYYY-MM-DD";
@@ -94,7 +94,7 @@ declare function FormattingScope({
   /** A BCP 47 locale, such as `de-DE`. It drops the app's fixed date format inside the scope. */
   locale?: string;
   children?: ReactNode;
-}): react2.FunctionComponentElement<react2.ProviderProps<Scope>>;
+}): react0.FunctionComponentElement<react0.ProviderProps<Scope>>;
 /**
  * A date in the app's format, safe to render on the server. A timestamp whose
  * zone is not known yet renders `fallback` until the browser supplies it, so
@@ -115,6 +115,6 @@ declare function FormattedDate({
   time?: boolean;
   /** What renders while the visitor's zone is unknown. */
   fallback?: ReactNode;
-}): react2.FunctionComponentElement<react2.FragmentProps>;
+}): react0.FunctionComponentElement<react0.FragmentProps>;
 //#endregion
 export { DateOptions, DateParts, DateSeparator, DateValue, FixedDateFormat, FormattedDate, Formatting, FormattingScope, WeekDay, formatDate, formatDateTime, formatNumber, useFormatting };

package/dist/formatting.js

@@ -1,6 +1,6 @@
 import { logger } from "./logger.js";
-import { z } from "zod";
 import { Fragment, createContext, createElement, useContext, useMemo, useSyncExternalStore } from "react";
+import { z } from "zod";
 import { rootRouteId, useRouteContext } from "@tanstack/react-router";
 
 //#region src/formatting.ts

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { SoftrUserGroupId, SoftrUserGroups, SoftrUserProperties, User } from "./auth/user.js";
+import { SoftrUserGroupId, SoftrUserGroups, User } from "./auth/user.js";
 import { ActionPermissions, SoftrDatasources, defineIntegration, defineMutation, defineQuery, defineWorkflow } from "./action.js";
 import { FileAttachment } from "./core/file-upload.js";
 import { FileItem, useFileUpload } from "./core/use-file-upload.js";
@@ -10,8 +10,10 @@ import { assertRouteAccess, guardRoute, isAccessError, isAlreadyAuthenticatedErr
 import { toReturnPath } from "./auth/returnPath.js";
 import { AuthOptions, AuthSettingsProvider, getAuthSettings, getSoftrContext, initialSoftrContext, softrAuthMiddleware, useAuthSettings, useCurrentUser } from "./auth/isomorphic.js";
 import { softrMcpMiddleware } from "./mcp.js";
+import { FieldShape, SoftrFieldRegistry, fieldShape, formatDuration, formatField, formatValue, registerSoftrFields } from "./fields/format.js";
+import { useOverrides } from "./core/use-overrides.js";
 import { useUserTimezone } from "./timezone.js";
 import { PwaInstall, PwaPlatform, SoftrPwaHead, usePwaInstall } from "./pwa.js";
 import { DefaultErrorOverlay } from "./default-error-overlay.js";
 import { Audience } from "./visibility/audience.js";
-export { type ActionPermissions, Audience, type AuthOptions, type AuthSettings, AuthSettingsProvider, type DateOptions, type DateParts, type DateSeparator, type DateValue, DefaultErrorOverlay, type FileAttachment, type FileItem, type FixedDateFormat, FormattedDate, type Formatting, FormattingScope, type PwaInstall, type PwaPlatform, type SoftrContext, type SoftrDatasources, SoftrPwaHead, type SoftrUserGroupId, type SoftrUserGroups, type SoftrUserProperties, type User, type WeekDay, assertRouteAccess, checkAccess, defineIntegration, defineMutation, defineQuery, defineVisibility, defineWorkflow, formatDate, formatDateTime, formatNumber, getAuthSettings, getSoftrContext, guardRoute, initialSoftrContext, isAccessError, isAlreadyAuthenticatedError, isAuthorized, isForbiddenError, isUnauthenticatedError, softrAuthMiddleware, softrMcpMiddleware, toReturnPath, useAuthSettings, useCurrentUser, useFileUpload, useFormatting, usePwaInstall, useUserTimezone };
+export { type ActionPermissions, Audience, type AuthOptions, type AuthSettings, AuthSettingsProvider, type DateOptions, type DateParts, type DateSeparator, type DateValue, DefaultErrorOverlay, type FieldShape, type FileAttachment, type FileItem, type FixedDateFormat, FormattedDate, type Formatting, FormattingScope, type PwaInstall, type PwaPlatform, type SoftrContext, type SoftrDatasources, type SoftrFieldRegistry, SoftrPwaHead, type SoftrUserGroupId, type SoftrUserGroups, type User, type WeekDay, assertRouteAccess, checkAccess, defineIntegration, defineMutation, defineQuery, defineVisibility, defineWorkflow, fieldShape, formatDate, formatDateTime, formatDuration, formatField, formatNumber, formatValue, getAuthSettings, getSoftrContext, guardRoute, initialSoftrContext, isAccessError, isAlreadyAuthenticatedError, isAuthorized, isForbiddenError, isUnauthenticatedError, registerSoftrFields, softrAuthMiddleware, softrMcpMiddleware, toReturnPath, useAuthSettings, useCurrentUser, useFileUpload, useFormatting, useOverrides, usePwaInstall, useUserTimezone };

package/dist/index.js

@@ -7,8 +7,10 @@ import { FormattedDate, FormattingScope, formatDate, formatDateTime, formatNumbe
 import { SoftrPwaHead, usePwaInstall } from "./pwa.js";
 import { AuthSettingsProvider, getAuthSettings, getSoftrContext, initialSoftrContext, softrAuthMiddleware, useAuthSettings, useCurrentUser } from "./auth/isomorphic.js";
 import { softrMcpMiddleware } from "./mcp.js";
+import { fieldShape, formatDuration, formatField, formatValue, registerSoftrFields } from "./fields/format.js";
+import { useOverrides } from "./core/use-overrides.js";
 import { useUserTimezone } from "./timezone.js";
 import { DefaultErrorOverlay } from "./default-error-overlay.js";
 import { Audience } from "./visibility/audience.js";
 
-export { Audience, AuthSettingsProvider, DefaultErrorOverlay, FormattedDate, FormattingScope, SoftrPwaHead, assertRouteAccess, checkAccess, defineIntegration, defineMutation, defineQuery, defineVisibility, defineWorkflow, formatDate, formatDateTime, formatNumber, getAuthSettings, getSoftrContext, guardRoute, initialSoftrContext, isAccessError, isAlreadyAuthenticatedError, isAuthorized, isForbiddenError, isUnauthenticatedError, softrAuthMiddleware, softrMcpMiddleware, toReturnPath, useAuthSettings, useCurrentUser, useFileUpload, useFormatting, usePwaInstall, useUserTimezone };
+export { Audience, AuthSettingsProvider, DefaultErrorOverlay, FormattedDate, FormattingScope, SoftrPwaHead, assertRouteAccess, checkAccess, defineIntegration, defineMutation, defineQuery, defineVisibility, defineWorkflow, fieldShape, formatDate, formatDateTime, formatDuration, formatField, formatNumber, formatValue, getAuthSettings, getSoftrContext, guardRoute, initialSoftrContext, isAccessError, isAlreadyAuthenticatedError, isAuthorized, isForbiddenError, isUnauthenticatedError, registerSoftrFields, softrAuthMiddleware, softrMcpMiddleware, toReturnPath, useAuthSettings, useCurrentUser, useFileUpload, useFormatting, useOverrides, usePwaInstall, useUserTimezone };

package/dist/mcp.d.ts

@@ -1,5 +1,5 @@
 import { DatasourceAction } from "./action.js";
-import * as _tanstack_react_start4 from "@tanstack/react-start";
+import * as _tanstack_react_start0 from "@tanstack/react-start";
 
 //#region src/mcp.d.ts
 
@@ -31,6 +31,6 @@ type SoftrMcpOptions = {
  *   ],
  * }))
  */
-declare function softrMcpMiddleware(options?: SoftrMcpOptions): _tanstack_react_start4.RequestMiddlewareAfterServer<{}, undefined, undefined>;
+declare function softrMcpMiddleware(options?: SoftrMcpOptions): _tanstack_react_start0.RequestMiddlewareAfterServer<{}, undefined, undefined>;
 //#endregion
 export { softrMcpMiddleware };

package/dist/mcp.js

@@ -2,12 +2,12 @@ import { assert } from "./assertions.js";
 import { fetch } from "./fetch.js";
 import { sessionConfig } from "./auth/config.js";
 import { readSessionToken, withSessionToken } from "./auth/session.js";
-import { softrConfig } from "./softr-config.js";
 import { makePlatform, platformApiUrl } from "./auth/platform.js";
 import { isDatasourceAction } from "./action.js";
+import { softrConfig } from "./softr-config.js";
 import { ds } from "./datasource/datasource.js";
-import { z } from "zod";
 import { createMiddleware } from "@tanstack/react-start";
+import { z } from "zod";
 
 //#region src/mcp.ts
 const MCP_PATH = "/_softr/mcp";