@coffer-org/plugin-transit 7.1.1 → 7.2.0

package/dist/schema.js

@@ -21,12 +21,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-//#region ../sdk/src/library.ts
+//#region ../sdk/dist/library.js
 function defineLibrary(v) {
 	return v;
 }
 //#endregion
-//#region ../sdk/src/plugin.ts
+//#region ../sdk/dist/plugin.js
 function definePlugin(p) {
 	if (!p.id) throw new Error("[plugin] missing id");
 	if (!p.label) throw new Error(`[plugin] ${p.id}: missing label`);
@@ -4069,7 +4069,7 @@ function number(params) {
 	return /* @__PURE__ */ _coercedNumber(ZodNumber, params);
 }
 //#endregion
-//#region ../sdk/src/units.ts
+//#region ../sdk/dist/units.js
 var UNITS_CURRENCY = [
 	{
 		value: "UAH",
@@ -4373,20 +4373,6 @@ var UNITS_MAP = {
 		label: "core.units.ppm"
 	}]
 };
-/**
-* Resolve a unit spec — a named scale or an explicit option list — to its options.
-*
-* Throws rather than returning `undefined`, because both ways of reaching `undefined` here
-* produce a field that CONSTRUCTS and then crashes when someone tries to save through it:
-* `measured`'s unit role closes over these options and calls `.some(…)` on them inside its
-* refine, so a missing spec or a typo'd scale name turns a user's save into a
-* `Cannot read properties of undefined` instead of a validation message. The golden matrix
-* recorded exactly that for `f.measured({})`.
-*
-* A declaration error belongs at declaration time, where the plugin author sees it and the
-* message can name the scale they meant — the same reason the host-services seam fails at
-* registration rather than at first render.
-*/
 function resolveUnits(u) {
 	if (typeof u === "string") {
 		const known = UNITS_MAP[u];
@@ -4397,48 +4383,25 @@ function resolveUnits(u) {
 	return u;
 }
 //#endregion
-//#region ../sdk/src/fields/validation.ts
-/** Structured message for zod: JSON {code, params}. Decoded by mutate.ts. */
+//#region ../sdk/dist/fields/validation.js
 function vmsg(code, params) {
 	return JSON.stringify(params ? {
 		code,
 		params
 	} : { code });
 }
-/** v4 error-map: message for a missing value (formerly required_error). */
 function reqErr(code = "required") {
 	return { error: (iss) => iss.input === void 0 ? vmsg(code) : void 0 };
 }
-/** v4 error-map: message for an invalid type (formerly invalid_type_error). */
 function typeErr(code = "invalid_type") {
 	return { error: (iss) => iss.code === "invalid_type" ? vmsg(code) : void 0 };
 }
-/** v4 error-map: required + invalid_type together (formerly required_error + invalid_type_error). */
 function reqTypeErr() {
 	return { error: (iss) => iss.code === "invalid_type" ? iss.input === void 0 ? vmsg("required") : vmsg("invalid_type") : void 0 };
 }
-/**
-* A string schema whose CONTENT checks only speak once the value is known to be a string.
-*
-* zod's length checks are not type-guarded: `min`/`max` read `input.length`, and an ARRAY has
-* one. So `z.string().min(1)` answers `[]` with `invalid_type` AND `too_small` — two messages
-* about a single wrongness, both of which reach the user, since `mutate.ts` and `extend-io.ts`
-* turn every issue into its own `ValidationError`. (A number answers with `invalid_type`
-* alone, having no `length` to read — so the redundancy was array-shaped and invisible until
-* the golden matrix started recording the whole issue list instead of `issues[0]`.)
-*
-* Piping puts the type question first and alone: `add` never runs on a non-string. Pass the
-* content checks as a builder rather than chaining them onto the result, because a `ZodPipe`
-* has no `.min`/`.max`/`.regex` to chain.
-*/
 function stringContent(add) {
 	return string$1(reqTypeErr()).pipe(add(string$1()));
 }
-/** Parse a JSON string, else return the native value (object/array) as-is.
-*  Tolerant input for native form-state AND legacy JSON-string payloads.
-*  A string that fails JSON.parse is returned unchanged — callers detect
-*  parse failure via `typeof result === 'string'` (inners here are object/array,
-*  never a bare string). */
 function jsonValue(raw) {
 	if (typeof raw === "string") try {
 		return JSON.parse(raw);
@@ -4447,12 +4410,6 @@ function jsonValue(raw) {
 	}
 	return raw;
 }
-/**
-* Factory for fields that store JSON and validate it with a nested zod schema.
-* Accepts a native object/array (native form state) OR a JSON string (legacy).
-* Single parse through jsonValue → inner.safeParse → issue `code`; an unparseable
-* string remains a string → code 'json'.
-*/
 function jsonRefined(inner, code) {
 	return unknown().superRefine((raw, ctx) => {
 		const parsed = jsonValue(raw);
@@ -4469,37 +4426,11 @@ function jsonRefined(inner, code) {
 		});
 	});
 }
-/**
-* An empty value is no value: `''` and `null` become `undefined`, and the field's own schema
-* never sees them. Every field is optional, so this is the ONLY shape — a field cannot demand
-* a value, and the rules it carries judge what was entered rather than whether anything was.
-*
-* This used to have a second branch, for `required` fields, which turned the same emptiness
-* into a `required` issue through a `z.unknown()` guard piped into the schema. That branch is
-* why a `.min(1)` on a required string was unreachable: the empty string had already been
-* converted to the issue before the string schema ran.
-*/
 function optionalize(schema) {
 	return preprocess((v) => v === "" || v === null ? void 0 : v, schema.optional());
 }
 //#endregion
-//#region ../sdk/src/fields/meta.ts
-/**
-* Field META modifiers — the shared machinery a built field (FieldMeta) passes through
-* regardless of its type: value options (`applyOptions`/`bindOptionsZod`), the `multiple`
-* array wrap (`applyMultiple`), and the final node-or-bare-FieldMeta shape
-* (`wrapKey`, EVERY factory's last step).
-*
-* A LEAF module, the same shape as `fields/validation.ts`/`fields/normalize.ts`: it
-* borrows the FieldMeta/LayoutNode/FieldClient/ColumnType/OptionItem SHAPES from
-* `../fields.ts` as TYPE-ONLY imports (erased at compile time — no runtime edge), but has
-* NO runtime dependency on `../fields.ts` itself. This is what lets
-* `materialize/pipeline.ts` import `applyMultiple`/`wrapKey` from here instead of from
-* `fields.ts`, which in turn is what lets `fields.ts` import `materialize` FROM
-* `materialize/pipeline.ts` without closing a cycle (`fields.ts` → `pipeline.ts` →
-* `fields/meta.ts`, nothing pointing back). `fields.ts` re-exports every symbol here, so
-* no external import path (`@coffer-org/sdk/fields`) changes.
-*/
+//#region ../sdk/dist/fields/meta.js
 function safeJsonParse(s) {
 	try {
 		return JSON.parse(s);
@@ -4507,14 +4438,6 @@ function safeJsonParse(s) {
 		return;
 	}
 }
-/**
-* Wraps a field into a JSON array of values (storage: TEXT). The inner zod is `base.zod`.
-* Modifier order: base → applyMultiple.
-*
-* Exception: kind 'image'/'media' handle multiple themselves in the renderer (gallery) —
-* the MultipleField* wrappers on the web skip them.
-*/
-/** Zod "JSON array of inner values" — used by applyMultiple. */
 function multipleZod(inner) {
 	return unknown().superRefine((raw, ctx) => {
 		let arr;
@@ -4565,15 +4488,12 @@ function applyMultiple(base, multiple) {
 		zod: optionalize(s)
 	};
 }
-/** Inline option entry → OptionItem (plain string = value and label at once). */
 function toOptionItem(o) {
 	return typeof o === "string" ? {
 		value: o,
 		title: o
 	} : o;
 }
-/** Canonical comparison form. Both the input and the option value pass through it, so a
-*  numeric field compares `100` against the option spelled `'100'`. */
 function optionKey(column, v) {
 	if (column === "integer" || column === "real") {
 		const n = Number(v);
@@ -4581,12 +4501,6 @@ function optionKey(column, v) {
 	}
 	return String(v ?? "");
 }
-/**
-* Membership check LAYERED OVER the field's own schema, never replacing it. Replacing it
-* with `z.enum` — which is what select used to do — works only over a bare string: over an
-* int it would destroy the int-ness, the coercion and the min/max, and over an ip it would
-* destroy the structure. Layering keeps every type's own error code and adds one.
-*/
 function gateZod(inner, gate, multiple, column) {
 	return inner.superRefine((v, ctx) => {
 		if (gate.values === null || v === void 0 || v === null || v === "") return;
@@ -4598,11 +4512,6 @@ function gateZod(inner, gate, multiple, column) {
 		});
 	});
 }
-/**
-* Attaches `options`/`strict` to any field. Called from `wrapKey`, which EVERY factory
-* funnels through — core and plugin-defined alike — so a new field type gets value options
-* without writing a line for them.
-*/
 function applyOptions(base, o) {
 	if (base.optionGate) return base;
 	if (base.relation || base.parts || base.options) return base;
@@ -4631,22 +4540,10 @@ function applyOptions(base, o) {
 	}
 	return m;
 }
-/**
-* Fills (or refills) a strict field's closed set. Called by composeRegistry once the full
-* option set is known — inline options, plugin contributions and the named source merged.
-* A non-strict field has no gate and is left alone.
-*/
 function bindOptionsZod(field, values) {
 	if (!field.optionGate || !values.length) return;
 	field.optionGate.values = new Set(values.map((v) => optionKey(field.column, v)));
 }
-/**
-* Wraps a FieldMeta into a node. `key` is the name the PARENT gave this child
-* (materialize/pipeline.ts) — an argument, not an option a factory reads out of its own
-* opts, which is why it comes first. Absent means the element was never declared under a
-* name: it becomes a keyless value node when it carries a `value`, and a bare FieldMeta
-* otherwise.
-*/
 function wrapKey(key, opts, meta) {
 	let m = applyOptions(meta, opts);
 	if (opts.noEditControl) m = {
@@ -4766,7 +4663,7 @@ function wrapKey(key, opts, meta) {
 	return m;
 }
 //#endregion
-//#region ../sdk/src/fields/normalize.ts
+//#region ../sdk/dist/fields/normalize.js
 function normalizeOpts(rawIn) {
 	const raw = rawIn;
 	if (raw["view"] !== void 0) throw new Error("[normalizeOpts] `view` is gone — presentational options live in `ui: {}` (see CLAUDE.md § field author options and the field-types skill).");
@@ -4813,30 +4710,8 @@ function normalizeOpts(rawIn) {
 	return Object.fromEntries(Object.entries(result).filter(([, val]) => val !== void 0));
 }
 //#endregion
-//#region ../sdk/src/materialize/decl.ts
-/**
-* PHASE 1 — declaration. A factory returns this and nothing else: plain data, no zod,
-* no column, no widget. A parent may rewrite ANY property of a child's declaration
-* before phase 2 builds it (see materialize/pipeline.ts).
-*/
+//#region ../sdk/dist/materialize/decl.js
 var BRAND = "__fieldDecl";
-/**
-* `opts.fields` vs `decl.fields` — the same author input reachable two ways, and only one of
-* them is ever safe to read as BUILT children:
-*
-*   - `opts.fields` is the RAW author input, unpacked by `normalizeOpts`'s spread (it does
-*     not know or care that `fields` is special) — never rewritten, never materialized. A
-*     composite that computes its OWN roles from what the author passed (`check`'s content
-*     fields) reads it from here, at declare() time, exactly as the author wrote it — decls
-*     and all.
-*   - `decl.fields` is what `declare()` copies from that same raw input for the tree walk
-*     (`materialize/pipeline.ts`) and for `resolveParts` to find. Once a parent has been
-*     materialized, this is where its BUILT children live.
-*
-* A consumer that wants built children — not raw author input — reads the materialized tree
-* (`materialize()`/`materializeTree()`'s output), never `decl.opts.fields`: that stays
-* exactly what the author passed, decls included, for as long as the decl is unbuilt.
-*/
 function declare(factory, raw) {
 	const opts = normalizeOpts(raw);
 	const spec = raw;
@@ -4851,9 +4726,7 @@ function isDecl(v) {
 	return typeof v === "object" && v !== null && BRAND in v;
 }
 //#endregion
-//#region ../sdk/src/materialize/registry.ts
-/** True for a type registered through `roles`/`roleZod`/`structureCode` (materialize/composite.ts)
-*  rather than a plain `build()` — read generically, never by factory name. */
+//#region ../sdk/dist/materialize/registry.js
 function isComposite(type) {
 	return "roles" in type;
 }
@@ -4867,12 +4740,6 @@ function typeOf(factory) {
 	if (!def) throw new Error(`[types] unknown factory '${factory}'`);
 	return def;
 }
-/**
-* `presetOpts` merged as DEFAULTS under the caller's own opts (`{ ...presetOpts, ...o }`) —
-* an author's own value always wins. `config` is merged the same way one level deep, so a
-* preset's own default (`weight`'s `config.min: 1`) survives an author setting a DIFFERENT
-* config key (`rules: { max: 5000 }`) without the preset needing to repeat it.
-*/
 function mergePresetOpts(presetOpts, o) {
 	const config = presetOpts.config || o.config ? {
 		...presetOpts.config,
@@ -4884,37 +4751,6 @@ function mergePresetOpts(presetOpts, o) {
 		...config ? { config } : {}
 	};
 }
-/**
-* Registers a PRESET: a type that is its base type's `TypeDef` with fixed/default opts
-* merged in, and — where it differs — its own `kind`/`widget`/`build`. This is what lets
-* `field-presets.ts` express "a preset is its base type plus these opts" as DATA instead of
-* copy-pasting normalizeOpts/optionalize/applyMultiple/wrapKey into a hand-written body:
-* `kind`/`prim`/`widget`/`selfManages` default to the base type's own — a
-* preset differs from its base in BEHAVIOUR, not in what column/prim family it belongs to; a
-* change that DOES need a different prim/column is not a preset, it is a new type — and
-* `over` replaces exactly the properties a given preset differs in.
-*
-* `presetOpts` are DEFAULTS the caller's own opts can still override (see `mergePresetOpts`
-* above). A preset that must instead FORCE a value regardless of the caller (`country`'s
-* `options: 'countries'`, `tags`'s `multiple: true`) is not this mechanism — those forward
-* directly to the base factory with the forced opts spread AFTER the caller's own
-* (`string({ ...raw, options: 'countries' })`), the pattern `country`/`currency`/`percent`/
-* `year`/`tags` already use, none of which needs its own registry entry: their `factory` IS
-* the base's, unchanged.
-*
-* `over.build`, when given, replaces the base type's `build()` entirely for THIS preset —
-* still called with the merged opts, so it may itself delegate to the base's own `build()`
-* and layer extra hints on top (`snippet` adds `hints.language` over `text`'s own build).
-*
-* Resolves `base` LAZILY (on first actual read, memoized), never at the moment
-* `registerPreset` itself is called: `field-presets.ts` calls it at MODULE TOP LEVEL, inside
-* the same circular import (`fields.ts` ⇄ `field-presets.ts`) its own header note already
-* documents — depending on which module the loader entered first, the base's own
-* `registerType` call (in `fields.ts`) may not have run yet. `text`/`i18n`/`smallText` in
-* fields.ts sidestep the same trap by calling `typeOf('string')` only from inside their
-* `build()`, never at their own `registerType()` call site; a preset's `kind`/`prim`/
-* `widget`/`selfManages` need the identical deferral since they too default from the base.
-*/
 function registerPreset(factory, base, presetOpts, over = {}) {
 	let resolved;
 	const baseType = () => {
@@ -4941,21 +4777,7 @@ function registerPreset(factory, base, presetOpts, over = {}) {
 	});
 }
 //#endregion
-//#region ../sdk/src/materialize/composite.ts
-/**
-* ONE composite transform. It was written six times (geo, illustrated, measured, range,
-* dimensions, check(single)) and differed only in the validation code and the per-role
-* default zod.
-*
-*   raw → jsonValue → carries nothing? (passthrough, when `acceptsEmptyRow`)
-*       → carries nothing at all? (pass through, there is nothing to judge)
-*       → rowSchema (partsRowShape) → stripServerOwnedParts → optional per-type refine
-*
-* A `CompositeTypeDef` names ONLY what its own type contributes: its roles, the default
-* zod per role, and how its structure failure reports. Everything else — the empty
-* check, the JSON tolerance, the row parse, stripping server-owned parts — lives here
-* exactly once.
-*/
+//#region ../sdk/dist/materialize/composite.js
 function buildComposite(def, opts, parts) {
 	const rowSchema = object(partsRowShape(def.roleZod(opts, parts), parts));
 	const roleKeys = (which) => parts.filter((p) => p.mode === "stored" && (which?.(p) ?? true)).map(partValueKey);
@@ -4964,7 +4786,6 @@ function buildComposite(def, opts, parts) {
 		const parsed = jsonValue(raw);
 		const p = parsed;
 		const isRow = p == null || typeof p === "object" && !Array.isArray(p);
-		/** Every one of `keys` empty in this value — `null`/absent alike. */
 		const allEmpty = (keys) => isRow && (p == null || keys.length > 0 && keys.every((k) => p[k] == null));
 		if (clientKeys && allEmpty(clientKeys)) return raw;
 		if (typeof parsed === "string") {
@@ -4999,27 +4820,7 @@ function buildComposite(def, opts, parts) {
 	};
 }
 //#endregion
-//#region ../sdk/src/materialize/pipeline.ts
-/**
-* PHASE 2 — materialization. The six steps every field goes through, in one place:
-* they used to be copied into 40-odd factory bodies (43 normalizeOpts heads,
-* 38 wrapKey tails, 37 optionalize calls).
-*
-* Composites (roles, the shared structure transform) arrive in materialize/composite.ts;
-* this file resolves a composite's parts and picks the right build path, but the
-* transform itself lives there, exactly once.
-*/
-/**
-* `name` is the property this declaration was declared under in its parent's map — the ONLY
-* source of a key a declared field ever has (a factory has no `key` option to read one from)
-* and it is threaded straight through to `wrapKey`, which keys the result whenever `name` is
-* defined. Absent (a top-level `materialize()` call on a standalone declaration) the result
-* is keyless: a value node if it carries a `value`, a bare FieldMeta otherwise.
-*
-* This function does not itself stamp the result's `name` (the ADDRESS, `LayoutNode.name` —
-* see that type's own doc comment) — its caller, `materializeEl`, does that for every branch,
-* including this one.
-*/
+//#region ../sdk/dist/materialize/pipeline.js
 function materialize(decl, name) {
 	const opts = decl.opts;
 	const type = typeOf(decl.factory);
@@ -5045,22 +4846,6 @@ function materialize(decl, name) {
 	};
 	return wrapKey(name, opts, type.selfManages?.has("multiple") ? base : applyMultiple(base, opts.multiple ?? false));
 }
-/**
-* The shared storage transform behind a composite's `multiple` form: a collection group
-* (child table) whose row fields ARE the given parts, under their role names — the exact
-* `ContainerNode` shape `fields.ts`'s own `group({key,label,multiple:true,required,fields,view})`
-* would build for this call pattern (no icon, no `rules`, no `value` — none of the three
-* former call sites ever passed them), constructed directly rather than through `group()`
-* itself to avoid a runtime edge back into fields.ts (see this module's own header note).
-*
-* Reached automatically, by the storage rule in `materialize()` above, for every composite
-* registered through `registerType`/`CompositeTypeDef` — `illustrated`, `check` and
-* `period` among them. `check`'s `roles(opts)` already returns checkbox-first order for
-* `multiple` and content-first for `single`, and `period`'s `roles(opts)` returns the same
-* from/until order regardless of `multiple`, so the generic path needs no special case for
-* either — the row-field ORDER is each type's own declared data (its `roles`), not
-* something this helper infers.
-*/
 function collectionGroup(key, opts, parts, collectionView) {
 	const rowFields = parts.map((p) => ({
 		...wrapKey(p.role, p.mode === "computedStored" ? { value: p.value } : {}, p.meta),
@@ -5078,22 +4863,6 @@ function collectionGroup(key, opts, parts, collectionView) {
 		fields: rowFields
 	};
 }
-/**
-* One tree node, named by the property it was declared under. Every returned node — every
-* branch below — carries that name (`name`, the ADDRESS a parent reaches it by) once `name`
-* is defined; only the STORAGE name (`key`) is conditional.
-*
-* A DECLARATION takes that name as both its `name` and its `key` (`materialize` → `wrapKey`
-* always keys a named declaration). An already-built element takes `key` too, but only if it
-* OWNS A SCOPE and has not been named yet: a `ContainerNode` that declares `scope: 'nest'`
-* owns a column prefix or a child table, and that scope has to be named — `group()`/`row()`/
-* `keyed()` no longer take a key of their own, so the parent's property name is where it
-* comes from. Everything else — a `'hoist'` group (an editorial block, a sheet row: it
-* arranges children inside the parent's scope and owns none), a node already carrying its
-* key, a keyless value node, a pseudo-element — owns no scope, so it keeps whatever `key` it
-* already had (usually none), but still gets `name` stamped: that is the whole point of this
-* task — a `'hoist'` child's declared property name used to be discarded here entirely.
-*/
 function materializeEl(el, name) {
 	if (isDecl(el)) {
 		const built = materialize(el, name);
@@ -5119,61 +4888,25 @@ function materializeEl(el, name) {
 		name
 	} : el;
 }
-/**
-* A built group that owns a scope but has not been given its storage key yet — i.e. it HAS
-* children (`fields`, the same question `hasChildren` in `../fields.ts` asks) and a `'nest'`
-* scope, but no key. Checked structurally rather than by importing `hasChildren`: this file
-* has no RUNTIME edge back into `fields.ts` (see the header note) — `Array.isArray` is the
-* same HAS-question, asked locally to keep that boundary.
-*/
 function isNamelessScope(el) {
 	const g = el;
 	return typeof g === "object" && g !== null && Array.isArray(g.fields) && g.scope === "nest" && g.key == null;
 }
-/**
-* A bare `FieldMeta`: it HAS none of a node's own marks yet — no `el` (so not a static value or
-* a pseudo-element — those are keyless ON PURPOSE and keep only an address) and no `key` (so
-* not a named field) — but it DOES carry a built field's own marks (`kind`, `zod`). This is a
-* declaration-stage shape, before it becomes a node at all, so it asks about its own
-* properties directly rather than through `hasValue`/`hasChildren` (which read `.type`/
-* `.fields`, not `.kind`/`.zod`).
-*/
 function isNamelessField(el) {
 	const m = el;
 	return typeof m === "object" && m !== null && !("el" in m) && !("key" in m) && typeof m.kind === "string" && m.zod !== void 0;
 }
-/** `group()` falls back to the key for a missing label; with the key arriving here instead,
-*  that fallback has to be applied here too, or a nameless scope would keep an empty one. */
 function labelOf(el, name) {
 	const g = el;
 	return g.label === void 0 || g.label === "" ? name : g.label;
 }
 var NUMERIC_LIKE$1 = /^\d+$/;
-/**
-* A LayoutEl tree: declarations become built elements, everything else passes through.
-* ONE input shape — a NAMED MAP, whose property name becomes the child's key. A
-* numeric-like name throws: object iteration would reorder such keys, and declaration
-* order IS the field order.
-*/
 function materializeTree(els) {
 	return Object.entries(els).map(([name, el]) => {
 		if (NUMERIC_LIKE$1.test(name)) throw new Error(`fields: numeric-like child name '${name}' (object iteration would reorder the children)`);
 		return materializeEl(el, name);
 	});
 }
-/**
-* A ShelfDef/ExtendDef/SettingsDef-shaped object: materializes its `fields` tree, every
-* other property carried through unchanged. `defineShelf`/`defineExtend`/`defineSettings`
-* (and `composeRegistry`'s defensive pass over a hand-rolled manifest) all call this instead
-* of repeating `{ ...def, fields: materializeTree(def.fields) as LayoutEl[] }` — the
-* copy-paste this refactor exists to delete, one level up from the factory bodies.
-*
-* `T`'s own `fields` may be the author-facing `LayoutInput` (a `ShelfDefInput`/
-* `ExtendDefInput`/`SettingsDefInput`) or an already-built `LayoutEl[]` (materializeDef is
-* a no-op on an already-built tree — see fields.ts's own note on that) — either way, the
-* RETURNED object's `fields` is always the built `LayoutEl[]`: the input type widens, the
-* materialized type never does.
-*/
 function materializeDef(def) {
 	const fields = Array.isArray(def.fields) ? def.fields : materializeTree(def.fields);
 	return {
@@ -5182,25 +4915,7 @@ function materializeDef(def) {
 	};
 }
 //#endregion
-//#region ../sdk/src/parts.ts
-/**
-* Composite value parts.
-*
-* A composite field type declares its ROLES (what the pieces of its value mean); the
-* author of a shelf supplies FILLINGS for those roles through `parts`. The storage
-* columns of the composite are derived from the result instead of being written by
-* hand, and each piece is an ordinary field — typed, labelled and renderable.
-*
-* The role set is closed: consumers (unit conversion, formatting, describe_shelf) rely
-* on knowing which piece is the magnitude and which is the unit. What FILLS a role is
-* open: a magnitude may be real/int/rating, a unit may be a select or a relation.
-*/
-/**
-* `NormalizedOpts` (what `FieldDecl.opts` actually is) has no single `ui` property — the
-* author's `ui` is flattened into individual fields (`hidden`, `display`, `kind`, …)
-* by `normalizeOpts`. A correction that wants to carry presentation forward has to collect
-* those flat fields back into the nested shape `declare()`'s own `normalizeOpts` call expects.
-*/
+//#region ../sdk/dist/parts.js
 var UI_KEYS = [
 	"hidden",
 	"noEditControl",
@@ -5213,40 +4928,18 @@ var UI_KEYS = [
 	"compareWith",
 	"span"
 ];
-/** The author's presentation opts, re-nested from `opts`'s flat fields — `undefined` when
-*  none were set, so a correction never adds an empty `ui: {}` no filling ever had. */
 function uiOf(opts) {
 	if (!opts) return void 0;
 	const v = {};
 	for (const k of UI_KEYS) if (opts[k] !== void 0) v[k] = opts[k];
 	return Object.keys(v).length ? v : void 0;
 }
-/** A filling built from a ported factory arrives as a FieldDecl — build it into the
-*  node or bare FieldMeta it represents; anything else (an unported factory's
-*  result, or an already-built filling) passes through unchanged. `name` (the role) is
-*  the part's own storage key (`ResolvedPart.key` is always the role, see below) — passing
-*  it to `materialize` is what lets `wrapKey` recognize a computed filling as computed
-*  (its `computed` test requires a key) and stamp `compute`/`derived`/`hints.noEditControl`
-*  on the built meta, exactly as it would for any other keyed field. */
 function built(input, name) {
 	return isDecl(input) ? materialize(input, name) : input;
 }
-/**
-* Whether `def` admits `d` as-is — the diagnostic question `RoleDef.accepts` answers.
-* `resolveParts` uses this to decide whether a correction happened (and is worth logging);
-* a role's own `normalize` uses it to decide whether to return the filling unchanged.
-*/
 function accepts(def, d) {
 	return Array.isArray(def.accepts) ? def.accepts.includes(typeOf(d.factory).prim) : def.accepts.test(d);
 }
-/**
-* The correction every role gets for free: keep what the author said ABOUT the field
-* (`label`, `ui`, `value` — a constant or a ComputeFn), replace the type, and
-* drop what belonged to the OLD type (`rules` — a number's min/max mean nothing to a
-* picture — and `multiple`, because a composite role owns exactly one column). A role whose
-* own default needs more than a bare factory (`measured`'s unit, `period`'s endpoints)
-* writes its own `normalize` instead of using this.
-*/
 function retypeTo(factory) {
 	return (d) => {
 		const { label, value } = d?.opts ?? {};
@@ -5258,12 +4951,6 @@ function retypeTo(factory) {
 		});
 	};
 }
-/**
-* Build a RoleDef whose correction is the shared default: accept a filling `accepts`
-* admits UNCHANGED, otherwise `retypeTo(defaultFactory)`. The common case — every role that
-* needs no per-instance default (a currency scaled to the field's own `units`, an endpoint
-* at the composite's own granularity) reads as one line.
-*/
 function role(name, acceptsSpec, defaultFactory) {
 	const retype = retypeTo(defaultFactory);
 	const def = {
@@ -5273,28 +4960,15 @@ function role(name, acceptsSpec, defaultFactory) {
 	};
 	return def;
 }
-/**
-* THE NAMING RULE for a composite: every part lives under its ROLE name, always — in the
-* value object (`{ value: 5, unit: 'kg' }`) and in storage (column `<field key>__<role>`,
-* `partColumns`). Consumers that reason about MEANING (a widget looking for the unit, unit
-* conversion, formatting) may hard-code the role name as a property name directly; this
-* helper exists only so a caller that already has a `ResolvedPart`/`PartSlot` need not know
-* that.
-*/
 function partValueKey(p) {
 	return p.role;
 }
-/** role → the key that role occupies in the value object. See `partValueKey`. */
 function partValueKeys(parts) {
 	const out = {};
 	for (const p of parts) out[p.role] = p.role;
 	return out;
 }
 var NUMERIC_LIKE = /^\d+$/;
-/** The three shapes a factory returns, reduced to (key, meta, value). `name` is the
-*  role this filling occupies — threaded to `built()` so a computed filling is built AS a
-*  keyed field (see `built`'s own note); `ResolvedPart.key` below still always uses the
-*  role directly, never this function's `key`. */
 function readInput(input, name) {
 	input = built(input, name);
 	if (hasValue(input) && input.key !== void 0) return {
@@ -5313,18 +4987,6 @@ function readInput(input, name) {
 		value: void 0
 	};
 }
-/**
-* Roles in declaration order, each with its filling. `owner` names the composite this
-* call resolves parts for (its own field key, supplied by the pipeline) — used only to
-* tag the one diagnostic line below.
-*
-* Throws with a message naming the composite's roles for an UNKNOWN role name — a typo
-* there fails loudly at `defineShelf` time rather than yielding a column that silently
-* never appears. It has nothing to say about a RENAMED storage key any more: a filling
-* carries no name of its own, so the role is the only source of one. A filling whose TYPE
-* the role does not accept is never rejected either: the role is a GUARD, not a filter, and
-* CORRECTS it instead (`RoleDef.normalize`) — see this module's header note.
-*/
 function resolveParts(roles, spec, owner) {
 	const known = new Set(roles.map((r) => r.role));
 	for (const r of roles) if (r.role.includes("__")) throw new Error(`parts: role name '${r.role}' contains '__', the storage path separator`);
@@ -5373,25 +5035,6 @@ function resolveParts(roles, spec, owner) {
 	for (const p of out) if (p.meta.parts) assertInertNesting(p.meta, `${owner ?? "(unkeyed)"}.${p.key}`);
 	return out;
 }
-/**
-* A composite filling a composite's role STORES fine at any depth: `partColumns` expands
-* it, and the value↔columns walks (`flattenComposite`/`nestComposite`) follow it. The
-* COMPUTE side does not follow it yet. Every engine that addresses a composite part reaches
-* exactly ONE level below a field:
-*
-*   - `completeValue` / `resolveField` (server/compute-unit.ts) — runs a part's `value`
-*   - `applyStoredParts` (server/part-injection.ts) — writes the computed column
-*   - `cacheClockColumns` / `levelClockColumnsByOwner` (server/cache-clock.ts) — the
-*     `__cachedAt` column a `cache` needs to ever refresh
-*   - the file normalizer (server/file-fields.ts) — resolves a part's `{name}` pointer
-*   - `collectMutateSources` / `collectComputeUnits` (sdk/mutate-graph.ts) — the trigger graph
-*
-* A part BELOW that level carrying any of those would own a real column that nothing ever
-* writes, refreshes, validates or triggers — the exact silent failure a storage change must
-* not ship. So it is refused where it is DECLARED, naming the path, instead of failing
-* quietly at runtime. Lifting this is a compute-engine change, not a storage one: nothing
-* about the columns needs to move for it.
-*/
 function assertInertNesting(meta, path) {
 	for (const p of meta.parts ?? []) {
 		const where = `${path}.${p.key}`;
@@ -5405,29 +5048,6 @@ function assertInertNesting(meta, path) {
 		if (p.meta.parts) assertInertNesting(p.meta, where);
 	}
 }
-/**
-* Storage columns of a composite: sub-PATH → column type. Every part contributes its own
-* columns, whatever they are.
-*
-* A part is a NODE, not necessarily a leaf: a filling that is itself a composite carries
-* its own `columns`, and those are what it contributes — under its role name as a prefix,
-* joined by the same `__` the physical column name uses (`at` filled by `f.geo` →
-* `at__lat`/`at__lng`/`at__label`). A part with no `columns` is a scalar and contributes
-* exactly one entry, its own `column`, under its role name. That is where the walk STOPS,
-* and every walk stops there: a scalar is the only thing a composite can bottom out in.
-*
-* The loop is one level deep because the result is built INDUCTIVELY, not by re-walking a
-* tree. A filling is materialized before the composite that holds it reads it, so
-* `p.meta.columns` was already produced by this same function and already carries the FULL
-* sub-path of everything below it. Depth therefore costs nothing here and is bounded by
-* nothing but the column NAME the joined path produces — see `storageColumns` (shelf.ts)
-* for the join, and `MAX_COLUMN_NAME` (compose.ts) for the budget that name must fit.
-*
-* The result is the FLAT storage projection of the composite. The STRUCTURE lives in
-* `FieldMeta.parts`, which is what the value↔columns walks (`nestComposite`/
-* `flattenComposite` in shelf.ts) read: they need to know where one nested object ends and
-* the next begins, and a joined key cannot say that on its own.
-*/
 function partColumns(parts) {
 	const cols = {};
 	for (const p of parts) {
@@ -5437,63 +5057,6 @@ function partColumns(parts) {
 	}
 	return cols;
 }
-/**
-* A composite's write-time row shape, DERIVED from its resolved parts. `shape` carries
-* the composite's DEFAULT schema per role — the literal the factory writes by hand
-* (`{ value: numSchema, unit: z.string().refine(…) }`) — and each part decides which
-* schema guards its (role-named) key:
-*
-*  - a plain STORED part is keyed by its role name, matching the value object and the
-*    column `<field>__<role>` that `flattenEmbeddedAt`/`nestEmbeddedAt` read. A role left
-*    to its default filling keeps the default schema — byte-identical to the hand-written
-*    literal, so every existing structure/unit/range code and message is preserved.
-*  - an OVERRIDDEN stored part is validated by its OWN zod (`meta.zod`) instead of the
-*    default schema for that role. This is what makes a RETYPED filling real: an
-*    `f.int({})` magnitude rejects 5.5 (its own `int` check) and gets an integer column,
-*    and an `f.relation({…})` currency accepts a record id instead of being measured
-*    against an ISO-4217 string rule it was never meant to satisfy. The filling also
-*    brings its own optionality and its own min/max — an author replacing a filling
-*    takes over that role's constraints, so `f.real({ rules: { min: 0 } })` is how a
-*    replaced magnitude keeps a bound.
-*  - a COMPUTED-AND-STORED part ('computedStored') is keyed by its role name like any
-*    other part, but its schema is `z.unknown().optional()`: the SERVER owns the value, so
-*    whatever the client sends there is ignored — `stripServerOwnedParts` deletes it a
-*    moment later and the write path recomputes the column. It is stripped rather than
-*    `z.never()`-rejected because a read hands the client that key (it is a real column,
-*    present in every response), so rejecting it would break a read → PATCH-the-whole-object
-*    round trip.
-*  - a CLIENT-OWNED stored part of a composite also accepts
-*    an explicit `null` (`tolerateNull`), which is what closes the read → write round trip
-*    for a PARTIALLY FILLED composite. A SELECT returns every sub-column, so a record whose
-*    magnitude column is set and whose unit column is empty reads back as
-*    `{value: 900, unit: null}` (`nestEmbeddedAt` drops the key only when EVERY column is
-*    empty — `0` is a value), and feeding that exact object back used to fail with
-*    `measured_structure`: the write path refused the shape its own read produced. The null
-*    slot now parses through and is written back as NULL, so the round trip is closed and
-*    clearing ONE role of a filled composite works instead of erroring.
-*    NULL, not absence: a read emits every stored role (empty ones as `null`), so `null` is
-*    how "this record has no value there" arrives, while an ABSENT key is a writer that
-*    never mentioned a role it owns — which stays the structure error it has always been
-*    (`{unit: 'kg'}` with no magnitude, `{lat: 50}` with no longitude). That is the
-*    all-or-nothing rule for a DECLARATION, and it is untouched.
-* A composite used to be able to override this: `required: true` kept every client-owned
-*    slot MANDATORY, null included, so that "tolerate null" could not turn a demanded field
-*    optional. Nothing demands a value now, so there is no override and the rule above is the
-*    only one.
-*/
-/**
-* How much a CLIENT-OWNED slot forgives in the row shape: exactly one thing, an explicit
-* `null`. `.nullable()`, never `.nullish()` — a part that is MISSING entirely is still a
-* malformed row (`{lat: 5.5}` is half a coordinate), which is the one rule about composites
-* that judges CORRECTNESS rather than presence.
-*
-* There used to be a `RowTolerance` of three levels, and the field's `required` is what chose
-* between them: 'strict' when the field demanded a value, 'null-or-missing' when the value was
-* ABSENT under that demand — the third existing only so an absent required composite did not
-* report the same absence twice, once as `required` and once as a structure code. With nothing
-* able to demand a value there is no first issue to restate, so both levels and the type
-* itself are gone.
-*/
 function partsRowShape(shape, parts) {
 	const out = { ...shape };
 	for (const p of parts) if (p.mode === "computedStored") out[p.key] = unknown().optional();
@@ -5503,16 +5066,6 @@ function partsRowShape(shape, parts) {
 	}
 	return out;
 }
-/**
-* Drops SERVER-OWNED part slots from a successfully parsed composite row: a computed-and-stored
-* role, keyed by its role name. Its value belongs to the schema, not to the writer — it is
-* recomputed and written by the server on the same write (`applyStoredParts`) — so a client
-* sending one back is stripped rather than rejected: the schema wins either way.
-*
-* Stripping (not `z.never()`-rejecting, as a computed-and-stored top-level FIELD does) is
-* what keeps a read → PATCH-the-whole-object round trip working: a read hands the client that
-* slot straight out of its column, so rejecting the echo would reject every full-object PATCH.
-*/
 function stripServerOwnedParts(value, parts) {
 	let out = value;
 	for (const p of parts) if (p.mode === "computedStored" && p.key in out) {
@@ -5522,28 +5075,7 @@ function stripServerOwnedParts(value, parts) {
 	return out;
 }
 //#endregion
-//#region ../sdk/src/field-presets.ts
-/**
-* Field presets are thin wrappers around the primitives in fields.ts.
-*
-* Each preset = one kind (one widget). Presets do not accept `format`;
-* they are semantic types themselves. min/max/step go through `config`.
-*
-* Presets are added to `f` through `composeF`, which guarantees no preset
-* overrides a primitive.
-*
-* The cyclic import from fields.ts is safe: factories/helpers are hoisted declarations,
-* and presets call them only inside their function bodies.
-*/
-/**
-* Email — kind 'email', email validation, inputType 'email'.
-*
-* @layer   preset
-* @base    string
-* @prim    text
-* @widget  email
-* @example f.email({ label: 'mod.fields.contact' })
-*/
+//#region ../sdk/dist/field-presets.js
 function email(o) {
 	return declare("email", o);
 }
@@ -5561,15 +5093,6 @@ registerPreset("email", "string", {}, {
 		};
 	}
 });
-/**
-* Phone — kind 'tel', loose format /^\+?[\d\s()-]{4,}$/, inputType 'tel'.
-*
-* @layer   preset
-* @base    string
-* @prim    text
-* @widget  tel
-* @example f.tel({ label: 'mod.fields.phone' })
-*/
 function tel(o) {
 	return declare("tel", o);
 }
@@ -5587,15 +5110,6 @@ registerPreset("tel", "string", {}, {
 		};
 	}
 });
-/**
-* Password — kind 'password', inputType 'password'. No strict schema. No multiple.
-*
-* @layer   preset
-* @base    string
-* @prim    text
-* @widget  password
-* @example f.password({ label: 'mod.fields.password' })
-*/
 function password(o) {
 	return declare("password", o);
 }
@@ -5614,20 +5128,6 @@ registerPreset("password", "string", {}, {
 		};
 	}
 });
-/**
-* Internal API-token list — keyValue-shaped collection (name + write-only
-* token + timestamps), custom renderer (`kind:'internalApiToken'`, own
-* create/revoke UI — same trick as url()/perWeekday()). "Internal" = not a
-* general-purpose field type for plugin shelves, only for the core account
-* settings page. `token` is `kind:'password'` so maskSecrets/preserveTree
-* already mask/preserve it for free.
-*
-* @layer   preset
-* @base    group
-* @prim    —
-* @widget  internalApiToken
-* @example f.internalApiToken({ label: 'mod.fields.apiTokens' })
-*/
 function internalApiToken(o) {
 	return group({
 		scope: "nest",
@@ -5643,18 +5143,6 @@ function internalApiToken(o) {
 		}
 	});
 }
-/**
-* Internal "connected apps" list — the OAuth clients (claude.ai & co) the user
-* has authorized for MCP access. Same "internal" caveat and custom-renderer
-* trick as internalApiToken(): read-only rows + a revoke action, never part of
-* the parent form's save.
-*
-* @layer   preset
-* @base    group
-* @prim    —
-* @widget  internalOauthGrants
-* @example f.internalOauthGrants({ label: 'mod.fields.oauthGrants' })
-*/
 function internalOauthGrants(o) {
 	return group({
 		scope: "nest",
@@ -5668,18 +5156,6 @@ function internalOauthGrants(o) {
 		}
 	});
 }
-/**
-* The account page's linked-accounts section. Same trick as `internalApiToken`: a container
-* with a custom `ui.kind`, drawn by its own renderer, which reads `/api/auth/links` itself.
-* The declared children are what one ROW holds — the renderer reads them through the slot
-* contract, so this is a declaration, not a layout.
-*
-* @layer preset
-* @base group
-* @prim —
-* @widget internalIdentityLinks
-* @example f.internalIdentityLinks({ label: 'auth.linksTitle' })
-*/
 function internalIdentityLinks(o) {
 	return group({
 		scope: "nest",
@@ -5694,15 +5170,6 @@ function internalIdentityLinks(o) {
 	});
 }
 var SLUG_RE = /^[a-z0-9-]+$/;
-/**
-* Slug — kind 'slug', `^[a-z0-9-]+$`.
-*
-* @layer   preset
-* @base    string
-* @prim    text
-* @widget  slug
-* @example f.slug({ label: 'mod.fields.slug' })
-*/
 function slug(o) {
 	return declare("slug", o);
 }
@@ -5717,21 +5184,6 @@ registerPreset("slug", "string", {}, {
 		};
 	}
 });
-/**
-* Identifier — a code printed for a machine and read back by one: a serial number, an order
-* number, a policy number, an IMEI. What a person actually DOES with one is copy it, which is
-* why this is a type of its own and not `f.string({ ui: { voice: 'data' } })`: the machine face
-* is one word on any string now, but the click that copies belongs to the kind.
-*
-* Deliberately unvalidated beyond a length: an identifier's format belongs to whoever issued
-* it, and a pattern here would reject the next manufacturer's.
-*
-* @layer   preset
-* @base    string
-* @prim    text
-* @widget  identifier
-* @example f.identifier({ label: 'mod.fields.serialNumber' })
-*/
 function identifier(o) {
 	return declare("identifier", o);
 }
@@ -5746,20 +5198,6 @@ registerPreset("identifier", "string", {}, {
 		};
 	}
 });
-/**
-* The machine-readable zone of a travel document — the identifier taken to its limit: printed
-* for a scanner, not for a person. Fixed pitch, chevrons kept as the filler they are, and the
-* line breaks preserved, because an MRZ's line structure is part of what it encodes.
-*
-* Unvalidated on purpose, like `identifier`: the ICAO line formats differ by document type, and
-* a strip transcribed from a real document is worth storing even when it does not check out.
-*
-* @layer   preset
-* @base    string
-* @prim    text
-* @widget  mrz
-* @example f.mrz({ label: 'documents.personal_document.fields.mrz' })
-*/
 function mrz(o) {
 	return declare("mrz", o);
 }
@@ -5775,15 +5213,6 @@ registerPreset("mrz", "string", {}, {
 	}
 });
 var COLOR_RE = /^#[0-9a-fA-F]{6}$/;
-/**
-* Hex color — kind 'color', `#rrggbb` + swatch widget.
-*
-* @layer   preset
-* @base    string
-* @prim    text
-* @widget  color
-* @example f.color({ label: 'mod.fields.color' })
-*/
 function color(o) {
 	return declare("color", o);
 }
@@ -5798,15 +5227,6 @@ registerPreset("color", "string", {}, {
 		};
 	}
 });
-/**
-* CSS color name — kind 'colorname'.
-*
-* @layer   preset
-* @base    string
-* @prim    text
-* @widget  colorname
-* @example f.colorname({ label: 'mod.fields.colorName' })
-*/
 function colorname(o) {
 	return declare("colorname", o);
 }
@@ -5821,15 +5241,6 @@ registerPreset("colorname", "string", {}, {
 		};
 	}
 });
-/**
-* Shelf heading — kind 'title'. Heading renderer.
-*
-* @layer   preset
-* @base    string
-* @prim    text
-* @widget  title
-* @example f.title({ label: 'mod.fields.name' })
-*/
 function title(o) {
 	return declare("title", o);
 }
@@ -5844,16 +5255,6 @@ registerPreset("title", "string", {}, {
 		};
 	}
 });
-/**
-* Link — kind 'link', edited as string, view = clickable <a target=_blank>.
-* Stores the raw URL as text (unlike composite f.url). Loose validation.
-*
-* @layer   preset
-* @base    string
-* @prim    text
-* @widget  link
-* @example f.link({ label: 'mod.fields.link' })
-*/
 function link(o) {
 	return declare("link", o);
 }
@@ -5872,9 +5273,7 @@ registerPreset("link", "string", {}, {
 	}
 });
 var TEL_RE = /^\+?[\d\s()-]{4,}$/;
-/** Loose URL: any scheme:// OR dotted host (optional port/path). No spaces. */
 var LINK_RE = /^([a-z][a-z0-9+.-]*:\/\/\S+|[\w-]+(\.[\w-]+)+(:\d+)?(\/\S*)?)$/i;
-/** CSS named colors (CSS Color Module L4) for f.colorname. */
 var CSS_COLOR_NAMES = /* @__PURE__ */ new Set([
 	"aliceblue",
 	"antiquewhite",
@@ -6026,15 +5425,6 @@ var CSS_COLOR_NAMES = /* @__PURE__ */ new Set([
 	"yellowgreen",
 	"transparent"
 ]);
-/**
-* Tag — non-empty string + chip widget. `multiple` → array of tags (`tags`).
-*
-* @layer   preset
-* @base    string
-* @prim    text
-* @widget  tag
-* @example f.tag({ label: 'mod.fields.tag' })
-*/
 function tag(o) {
 	return declare("tag", o);
 }
@@ -6055,21 +5445,6 @@ registerPreset("tag", "string", {}, {
 		};
 	}
 });
-/**
-* A location written the way it is said aloud: workshop › shelf 2 › box. A `string` fixed to
-* `multiple`, exactly as `f.tags` is, because a place inside a place inside a place IS a
-* sequence — the plurality is the type, not a modifier someone remembered to add.
-*
-* Distinct from `f.tags`, which stores the same shape: tags are an unordered SET, and a path is
-* an ordered CHAIN where each step is inside the one before it. Drawn as chips, that
-* containment — the only thing the value actually carries — is lost.
-*
-* @layer   preset
-* @base    string
-* @prim    text
-* @widget  path
-* @example f.path({ label: 'things.storage_location.fields.path' })
-*/
 function path(o) {
 	return declare("path", {
 		...o,
@@ -6087,30 +5462,12 @@ registerPreset("path", "string", {}, {
 		};
 	}
 });
-/**
-* Tags — `tag({ multiple: true })`.
-*
-* @layer   preset
-* @base    string
-* @prim    text
-* @widget  tag
-* @example f.tags({ label: 'mod.fields.tags' })
-*/
 function tags(o) {
 	return tag({
 		...o,
 		multiple: true
 	});
 }
-/**
-* Markdown — text() + Markdown editor.
-*
-* @layer   preset
-* @base    text
-* @prim    text
-* @widget  markdown
-* @example f.markdown({ label: 'mod.fields.body' })
-*/
 function markdown(o) {
 	return declare("markdown", o);
 }
@@ -6118,16 +5475,6 @@ registerPreset("markdown", "text", {}, {
 	kind: "markdown",
 	widget: "markdown"
 });
-/**
-* Code snippet — text() + monospace code editor.
-* `rules.language` is a highlighting hint (json/yaml/bash/ini…), stored in hints.
-*
-* @layer   preset
-* @base    text
-* @prim    text
-* @widget  snippet
-* @example f.snippet({ label: 'mod.fields.config' })
-*/
 function snippet(o) {
 	return declare("snippet", o);
 }
@@ -6146,22 +5493,9 @@ registerPreset("snippet", "text", {}, {
 		};
 	}
 });
-/** A NUL byte, or U+FFFD left behind by decoding non-UTF-8 bytes as text. */
 function isBinaryText(v) {
 	return v.includes("\0") || v.includes("�");
 }
-/**
-* Source — plain text in one column, shaped like a file in the UI.
-* Written through the API or by uploading a file; never hand-edited in the web form
-* (hints.noEditControl). The content is never rendered — only name + Upload/Download.
-* `rules.ext` is the displayed/downloaded extension, `rules.maxBytes` the size cap.
-*
-* @layer   preset
-* @base    text
-* @prim    text
-* @widget  source
-* @example f.source({ label: 'mod.fields.file' })
-*/
 function source(o) {
 	return declare("source", o);
 }
@@ -6196,15 +5530,6 @@ registerPreset("source", "text", {}, {
 		};
 	}
 });
-/**
-* Rating 1..N — integer + star widget. rules.max is the upper bound (default 5).
-*
-* @layer   preset
-* @base    int
-* @prim    number
-* @widget  rating
-* @example f.rating({ label: 'mod.fields.rating' })
-*/
 function rating(o) {
 	return declare("rating", o);
 }
@@ -6220,16 +5545,6 @@ registerPreset("rating", "int", { config: { max: 5 } }, {
 		};
 	}
 });
-/** Duration in seconds — integer + duration widget ("2d 3h 30m 15s").
-* rules.max is the maximum in seconds (default 604800 = 1 week).
-* rules.step is the step in seconds (default 60 = 1 minute).
-*
-* @layer   preset
-* @base    int
-* @prim    number
-* @widget  duration
-* @example f.duration({ label: 'mod.fields.runtime' })
-*/
 function duration(o) {
 	return declare("duration", o);
 }
@@ -6253,15 +5568,6 @@ registerPreset("duration", "int", { config: {
 		};
 	}
 });
-/** Reminder — date with visual urgency. kind 'reminder', prim 'date'.
-* rules.lead = day threshold (default 30). rules.min/rules.max = ISO dates.
-*
-* @layer   preset
-* @base    date
-* @prim    date
-* @widget  reminder
-* @example f.reminder({ label: 'mod.fields.renewal' })
-*/
 function reminder(o) {
 	return declare("reminder", o);
 }
@@ -6280,24 +5586,6 @@ registerPreset("reminder", "date", { lead: 30 }, {
 		};
 	}
 });
-/** Timetable — a set of times of day, read as a schedule rather than as a bag of values.
-* kind 'timetable', prim 'time', always `multiple`.
-*
-* Same shape as `f.reminder`/`f.age` over `date`: a semantic type whose renderer knows what
-* the values MEAN. Everything it shows beyond the times themselves — when the service starts
-* and ends, how many runs there are, which one is next — is derived from the values at render
-* time, never stored: a "next departure" is wrong the moment it is written down, exactly the
-* argument `f.age` already makes for an age.
-*
-* Storage is a plain multiple `time`, so a field can be switched to this from
-* `f.time({ multiple: true })` and back with no migration.
-*
-* @layer   preset
-* @base    time
-* @prim    time
-* @widget  timetable
-* @example f.timetable({ label: 'mod.fields.weekdays' })
-*/
 function timetable(o) {
 	return declare("timetable", {
 		...o,
@@ -6308,18 +5596,6 @@ registerPreset("timetable", "time", {}, {
 	kind: "timetable",
 	widget: "timetable"
 });
-/** Age — date whose whole-year age (as of today) renders alongside it, e.g. a birth date.
-* kind 'age', prim 'date'. The age itself is computed at RENDER time, never stored: unlike a
-* `mutate`-driven computed field, it must be right on every day that passes, not only the day
-* the record was last written, so this is display metadata over `date`, the same shape as
-* `f.reminder`'s own relative-to-today note.
-*
-* @layer   preset
-* @base    date
-* @prim    date
-* @widget  age
-* @example f.age({ label: 'mod.fields.birthDate' })
-*/
 function age(o) {
 	return declare("age", o);
 }
@@ -6330,15 +5606,6 @@ registerPreset("age", "date", {}, {
 		return typeOf("date").build(o, parts);
 	}
 });
-/**
-* Percentage 0..100 — real with rules:{min:0,max:100}.
-*
-* @layer   preset
-* @base    real
-* @prim    number
-* @widget  number
-* @example f.percent({ label: 'mod.fields.progress' })
-*/
 function percent(o) {
 	return real({
 		...o,
@@ -6349,15 +5616,6 @@ function percent(o) {
 		}
 	});
 }
-/**
-* Year — int with rules:{min:1900,max:2100}; bounds can be overridden via rules.min/max.
-*
-* @layer   preset
-* @base    int
-* @prim    number
-* @widget  number
-* @example f.year({ label: 'mod.fields.releaseYear' })
-*/
 function year(o) {
 	return int({
 		...o,
@@ -6368,15 +5626,6 @@ function year(o) {
 		}
 	});
 }
-/**
-* Weight — always grams (int). kind 'weight', prim 'number'.
-*
-* @layer   preset
-* @base    int
-* @prim    number
-* @widget  weight
-* @example f.weight({ label: 'mod.fields.weight' })
-*/
 function weight(o) {
 	return declare("weight", o);
 }
@@ -6394,12 +5643,6 @@ registerPreset("weight", "int", { config: { min: 1 } }, {
 		};
 	}
 });
-/**
-* The three extents of a box, in declaration order — which is also the column order, so
-* `w` is the magnitude `magnitudeSub()` hands to list sorting and to a filter by field key.
-* The unit is NOT a role: dimensions are always millimetres, and nothing in the app converts
-* units (see `docs/decisions.md`, 2026-08-05), so it stays a hint rather than a fourth column.
-*/
 var DIMENSION_ROLES = () => [
 	role("w", ["number"], "int"),
 	role("h", ["number"], "int"),
@@ -6423,27 +5666,9 @@ registerType("dimensions", {
 	structureCode: "dimensions_structure",
 	hints: () => ({ unit: "mm" })
 });
-/**
-* Dimensions — box dimensions {w,h,d}, int mm across the real sub-columns `key__w|h|d`.
-*
-* @layer   preset
-* @base    int
-* @prim    text
-* @widget  dimensions
-* @example f.dimensions({ label: 'mod.fields.size' })
-*/
 function dimensions(o) {
 	return declare("dimensions", o);
 }
-/**
-* Country — a string whose values are the country list, rendered with flags.
-*
-* @layer   preset
-* @base    string
-* @prim    text
-* @widget  text
-* @example f.country({ label: 'mod.fields.country' })
-*/
 function country(raw) {
 	return string({
 		...raw,
@@ -6453,22 +5678,6 @@ function country(raw) {
 		noSearch: true
 	});
 }
-/**
-* Currency — the ISO 4217 code the record's amounts are in, declared ONCE per record.
-* The money twin of `f.unit`: an ordinary string over the global `currencies` list, so it
-* is an ordinary column (groupable, filterable) and its picker is an expanded list rather
-* than a combobox wedged into some amount's editor.
-*
-* A record carries ONE currency. Two amounts on one record that need different currencies
-* are two records — `multiple: true` here means "the currencies this record deals in"
-* (what an account holds), and binds no amount.
-*
-* @layer   preset
-* @base    string
-* @prim    text
-* @widget  text
-* @example f.currency({ label: 'mod.fields.currency' })
-*/
 function currency(raw) {
 	return string({
 		...raw,
@@ -6478,22 +5687,6 @@ function currency(raw) {
 		noSearch: true
 	});
 }
-/**
-* A monetary amount — a plain number in a `real` column, whose currency is a field of the
-* record (`currencyFrom`). Summable, sortable and filterable by its own name, like any
-* other number.
-*
-* It used to be a composite `{value, currency}`: the amount then lived in `price__value`,
-* reachable only through `magnitudeSub`, a sum over a collection had to re-assemble
-* objects in JavaScript, and the currency needed a second control inside the amount's own
-* editor — the one place a collapsed control must never be (skill field-render).
-*
-* @layer   preset
-* @base    real
-* @prim    number
-* @widget  money
-* @example f.money({ label: 'mod.fields.price' })
-*/
 function money(o) {
 	return declare("money", o);
 }
@@ -6552,57 +5745,13 @@ var presets = {
 	internalOauthGrants
 };
 //#endregion
-//#region ../sdk/src/blocks.ts
-/**
-* Editorial "blocks" — record-page layout sugar over `group()` (bento grids, split
-* columns, tabs, …), exactly like `row`/`sheet` in fields.ts. Each factory sets
-* the group's `kind` (renderer resolution — see `elementKind()`) and stashes its own
-* layout metadata on `ContainerNode.view`, read by the block's own renderer, never by the
-* generic layout core.
-*
-* `calendar`/`journal`/`manifest`/`table` are the one exception to "sugar over a fresh
-* `group()`": their `source` is already a KEYED, `multiple: true` collection built
-* elsewhere (`row`/`sheet` in fields.ts — there is no separate factory to DECLARE a
-* tabular collection), and they stamp `kind`/`view` directly onto THAT group
-* (`stampCollection`) rather than wrapping it in a new keyless one — see
-* `stampCollection`'s own comment for why the wrapping shape does not reach the layout
-* engine's storage-group branch. `table` specifically is a VIEW over a collection built
-* elsewhere, never a second way to declare one. `calendar`/`journal`/`manifest`/`table`'s
-* `source` stays typed `ContainerNode` (already built, already keyed) — the exception is about
-* this wrapping, not about naming, so it is untouched by `SlotInput` below.
-*
-* Every OTHER el-valued slot a factory here declares — a single element (`figure.image`,
-* `masthead.title`, `route.from`, …) or a list (`masthead.meta`, `compare.left`, …) — takes
-* a NAMED MAP: see `SlotInput`'s own doc comment for the single case, `LayoutInput`
-* (materialize/decl.ts) for the list case. The slot names the ROLE; the map's own property
-* name(s) become the STORAGE key(s).
-*/
+//#region ../sdk/dist/blocks.js
 var isSpanned = (i) => typeof i === "object" && i !== null && "span" in i && "el" in i;
-/**
-* Validates a block's single-element slot and hands back the one-entry map it is. A slot
-* is not built here: every slot a block lays out is merged into ONE map (`merge` below)
-* and walked by `group()` exactly once, like any other container's `fields`.
-*
-* A missing/nullish slot is the same "got 0" failure as an empty map, not a native
-* TypeError from `Object.keys(undefined)` — every empty-slot failure mode speaks the same
-* message, whether the author wrote `{}`, left the option out, or passed `undefined`.
-*/
 function slot(block, name, input) {
 	const count = input == null ? 0 : Object.keys(input).length;
 	if (count !== 1) throw new Error(`[field.${block}] slot '${name}' expects exactly one entry, got ${count}`);
 	return input;
 }
-/**
-* A block's children, in the order the block lays them out. Every slot is a NAMED MAP, so
-* flattening several slots into one child list is a MERGE: the names the author gave are
-* already there and nothing has to be generated or derived from a position. Insertion
-* order is declaration order, which is also the order every ORDERED NAME LIST the layout
-* metadata below carries (`first`/`second`, `meta`, `conditions`, …) reports its names in —
-* a NAME, never a count against a flattened position (Task 5).
-*
-* A name claimed by two slots is a storage-key collision, not a layout choice — the flat
-* form used to let both through and store one of them nowhere.
-*/
 function merge(block, ...slots) {
 	const out = {};
 	for (const s of slots) {
@@ -6614,21 +5763,6 @@ function merge(block, ...slots) {
 	}
 	return out;
 }
-/**
-* Asymmetric card grid. '1x1' is the implicit default — only wider spans are recorded, BY
-* NAME (Task 5): each tile IS one declared field, so `spans` is keyed by that field's own
-* storage name — the same name the renderer already addresses it by — never a position in
-* the built list.
-*
-* `fields` takes a NAMED MAP of `BentoItem` values, handed to `group()` which walks it
-* exactly like every other container's `fields`.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  bento
-* @example f.bento({ fields: { name: f.string({ label: '…' }), model: { span: '2x1', el: f.string({ label: '…' }) } } })
-*/
 function bento(opts) {
 	const spans = {};
 	const fields = Object.fromEntries(Object.entries(opts.fields).map(([name, item]) => {
@@ -6649,23 +5783,6 @@ function bento(opts) {
 		}
 	};
 }
-/**
-* Two-column split (default ratio 1:1). Columns are flattened; the left/right boundary is
-* remembered.
-*
-* Each column is a LIST slot (a named map — see `LayoutInput`'s own doc comment). The
-* tuple POSITION (index 0/1) stays the left/right layout signal, unrelated to storage
-* naming; each column's own fields are named the same way `fields` is everywhere else, and
-* the two columns are MERGED into one map for `group()` (`merge`, above). `view.first`/
-* `view.second` (Task 5) are the ORDERED LISTS of each column's own field names — the
-* renderer reaches every child by name, never a count against a flattened position.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  split
-* @example f.split({ columns: [{ left: f.string({ label: '…' }) }, { right: f.string({ label: '…' }) }] })
-*/
 function split(opts) {
 	return {
 		...group({
@@ -6680,14 +5797,6 @@ function split(opts) {
 		}
 	};
 }
-/** Even N-column grid (default 3).
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  grid
-* @example f.grid({ columns: 3, fields: { a: f.string({ label: '…' }), b: f.string({ label: '…' }) } })
-*/
 function grid(opts) {
 	return {
 		...group({
@@ -6702,17 +5811,6 @@ function grid(opts) {
 		}
 	};
 }
-/**
-* A visual, an optional pull quote, and supporting facts. `view` names each role (Task 5):
-* `visual`/`quote` are single field names (`quote` `undefined` when not declared),
-* `facts` is the ORDERED LIST of the fact fields' own storage names.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  spread
-* @example f.spread({ visual: { photo: f.image({ label: '…' }) }, quote: { quote: f.string({ label: '…' }) }, facts: { fact: f.string({ label: '…' }) } })
-*/
 function spread(opts) {
 	const visual = slot("spread", "visual", opts.visual);
 	const quote = opts.quote !== void 0 ? slot("spread", "quote", opts.quote) : void 0;
@@ -6729,17 +5827,6 @@ function spread(opts) {
 		}
 	};
 }
-/**
-* Main content plus a side rail. Flattened main-then-aside; the boundary is remembered.
-* `view.main`/`view.aside` (Task 5) are the ORDERED LISTS of each region's own field
-* names — see `split`'s own doc comment for what that means and why.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  aside
-* @example f.aside({ fields: { main: f.string({ label: '…' }) }, aside: { side: f.string({ label: '…' }) } })
-*/
 function aside(opts) {
 	return {
 		...group({
@@ -6753,20 +5840,6 @@ function aside(opts) {
 		}
 	};
 }
-/**
-* Tabbed sections. Each tab is a NAMED GROUP of its own fields (Task 5) — `t.name` becomes
-* the storage key of a NESTED, keyless (`scope: 'hoist'`, storage-transparent — see
-* `group`'s own `scope` doc comment) group wrapping `t.fields`, so the renderer reaches a
-* tab's own children by descending into that name (`SlotScope`, `render/slot.tsx`) instead
-* of slicing a flattened list by a cumulative per-tab count. A duplicate `name` across
-* tabs is a storage-key collision, exactly like `merge`'s own duplicate-name guard.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  tabs
-* @example f.tabs({ tabs: [{ name: 'overview', label: '…', fields: { a: f.string({ label: '…' }) } }] })
-*/
 function tabs(opts) {
 	const fields = {};
 	for (const t of opts.tabs) {
@@ -6788,17 +5861,6 @@ function tabs(opts) {
 		}
 	};
 }
-/**
-* Collapsible sections. Each section is a NAMED GROUP of its own fields (Task 5) — see
-* `tabs`'s own doc comment for what that means and why; the renderer descends into a
-* section's own children by name (`SlotScope`) instead of a cumulative count.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  accordion
-* @example f.accordion({ sections: [{ name: 'details', label: '…', fields: { a: f.string({ label: '…' }) } }] })
-*/
 function accordion(opts) {
 	const fields = {};
 	for (const s of opts.sections) {
@@ -6821,16 +5883,6 @@ function accordion(opts) {
 		}
 	};
 }
-/** Flowing prose paragraph, optionally with a dropped first capital letter on ONE named
-* field — `dropCap` names WHICH one (Task 5), never "whichever field was declared
-* first." Must be one of `fields`'s own storage keys.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  prose
-* @example f.prose({ fields: { body: f.text({ label: '…' }) }, dropCap: 'body' })
-*/
 function prose(opts) {
 	if (opts.dropCap !== void 0 && !(opts.dropCap in opts.fields)) throw new Error(`[field.prose] dropCap '${opts.dropCap}' is not one of this block's own fields`);
 	return {
@@ -6846,17 +5898,6 @@ function prose(opts) {
 		}
 	};
 }
-/** A small labeled plate of fields: one TITLE (large, semibold), then zero or more
-* SUBTITLE fields (small, tracked-out, muted) beneath it. Which field is the title is
-* NAMED (Task 5), the same way `figure.image`/`masthead.title` is — never "whichever
-* field was declared first."
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  plaque
-* @example f.plaque({ title: { a: f.string({ label: '…' }) }, subtitle: { b: f.string({ label: '…' }) } })
-*/
 function plaque(opts) {
 	const title = slot("plaque", "title", opts.title);
 	return {
@@ -6873,14 +5914,6 @@ function plaque(opts) {
 		}
 	};
 }
-/** A ledger-style stack of label/value rows.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  ledger
-* @example f.ledger({ fields: { a: f.string({ label: '…' }) } })
-*/
 function ledger(opts) {
 	return {
 		...group({
@@ -6892,14 +5925,6 @@ function ledger(opts) {
 		view: { kind: "ledger" }
 	};
 }
-/** A row of headline statistics.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  stats
-* @example f.stats({ fields: { count: f.real({ label: '…' }) } })
-*/
 function stats(opts) {
 	return {
 		...group({
@@ -6911,14 +5936,6 @@ function stats(opts) {
 		view: { kind: "stats" }
 	};
 }
-/** A cluster of small tag-like facets.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  facets
-* @example f.facets({ fields: { tag: f.string({ label: '…' }) } })
-*/
 function facets(opts) {
 	return {
 		...group({
@@ -6930,14 +5947,6 @@ function facets(opts) {
 		view: { kind: "facets" }
 	};
 }
-/** A monospace terminal/code block, with an optional i18n caption.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  terminal
-* @example f.terminal({ fields: { log: f.text({ label: '…' }) }, caption: 'mod.blocks.terminalCaption' })
-*/
 function terminal(opts) {
 	return {
 		...group({
@@ -6952,14 +5961,6 @@ function terminal(opts) {
 		}
 	};
 }
-/** A toned callout box (default tone: note).
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  callout
-* @example f.callout({ tone: 'warn', fields: { note: f.string({ label: '…' }) } })
-*/
 function callout(opts) {
 	return {
 		...group({
@@ -6974,17 +5975,6 @@ function callout(opts) {
 		}
 	};
 }
-/**
-* Two side-by-side sets of fields. Flattened left-then-right; the boundary is remembered.
-* `view.left`/`view.right` (Task 5) are the ORDERED LISTS of each column's own field
-* names — see `split`'s own doc comment for what that means and why.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  compare
-* @example f.compare({ left: { a: f.string({ label: '…' }) }, right: { b: f.string({ label: '…' }) } })
-*/
 function compare(opts) {
 	return {
 		...group({
@@ -7002,20 +5992,6 @@ function compare(opts) {
 		}
 	};
 }
-/**
-* A picture and its caption as one typographic unit.
-*
-* `view` carries the STORAGE NAME of each role (not a count/boolean, Task 5): `image` is
-* always declared; `caption` is `undefined` when the slot was never given. The renderer
-* reaches each child through `useSlot`/`<Slot>` by this name — never by position in
-* `el.fields`, so reordering how `merge()` (above) assembles the fields never matters.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  figure
-* @example f.figure({ image: { photo: f.image({ label: '…' }) }, caption: { caption: f.string({ label: '…' }) } })
-*/
 function figure(opts) {
 	const image = slot("figure", "image", opts.image);
 	const caption = opts.caption !== void 0 ? slot("figure", "caption", opts.caption) : void 0;
@@ -7031,16 +6007,6 @@ function figure(opts) {
 		}
 	};
 }
-/**
-* A quoted source with an optional attribution. `view` names each role (Task 5) — see
-* `figure`'s own doc comment for what that means and why.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  epigraph
-* @example f.epigraph({ source: { quote: f.text({ label: '…' }) }, attribution: { author: f.string({ label: '…' }) } })
-*/
 function epigraph(opts) {
 	const source = slot("epigraph", "source", opts.source);
 	const attribution = opts.attribution !== void 0 ? slot("epigraph", "attribution", opts.attribution) : void 0;
@@ -7056,17 +6022,6 @@ function epigraph(opts) {
 		}
 	};
 }
-/**
-* A masthead header: optional overline, title, and trailing meta fields. `view` names each
-* role (Task 5) — `meta` is the ORDERED LIST of the meta fields' own storage names (declared
-* insertion order of `opts.meta`), not a count against a flattened position.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  masthead
-* @example f.masthead({ title: { title: f.string({ label: '…' }) }, meta: { subtitle: f.string({ label: '…' }) } })
-*/
 function masthead(opts) {
 	const overline = opts.overline !== void 0 ? slot("masthead", "overline", opts.overline) : void 0;
 	const title = slot("masthead", "title", opts.title);
@@ -7083,14 +6038,6 @@ function masthead(opts) {
 		}
 	};
 }
-/** A vertical timeline of dated entries.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  timeline
-* @example f.timeline({ fields: { date: f.date({ label: '…' }) } })
-*/
 function timeline(opts) {
 	return {
 		...group({
@@ -7102,14 +6049,6 @@ function timeline(opts) {
 		view: { kind: "timeline" }
 	};
 }
-/** A single value counting down (or up) to/from a target, with an optional i18n caption.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  countdown
-* @example f.countdown({ source: { deadline: f.date({ label: '…' }) }, caption: 'mod.blocks.countdownCaption' })
-*/
 function countdown(opts) {
 	const source = slot("countdown", "source", opts.source);
 	return {
@@ -7125,14 +6064,6 @@ function countdown(opts) {
 		}
 	};
 }
-/** A card deck rendered from a single collection source.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  deck
-* @example f.deck({ source: { cards: f.group({ scope: 'nest', multiple: true, fields: { name: f.string({ label: '…' }) } }) } })
-*/
 function deck(opts) {
 	const source = slot("deck", "source", opts.source);
 	return {
@@ -7147,14 +6078,6 @@ function deck(opts) {
 		}
 	};
 }
-/** A roster rendered from a single collection source.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  people
-* @example f.people({ source: { members: f.group({ scope: 'nest', multiple: true, fields: { name: f.string({ label: '…' }) } }) } })
-*/
 function people(opts) {
 	const source = slot("people", "source", opts.source);
 	return {
@@ -7169,17 +6092,6 @@ function people(opts) {
 		}
 	};
 }
-/**
-* A person/entity identity block: optional avatar, name, optional role, and channel links.
-* `view` names each role (Task 5): `avatar`/`role` are the declared field's own storage
-* name or `undefined`; `channels` is the ORDERED LIST of the channel fields' own names.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  identity
-* @example f.identity({ name: { name: f.string({ label: '…' }) }, role: { role: f.string({ label: '…' }) } })
-*/
 function identity(opts) {
 	const avatar = opts.avatar !== void 0 ? slot("identity", "avatar", opts.avatar) : void 0;
 	const name = slot("identity", "name", opts.name);
@@ -7198,25 +6110,6 @@ function identity(opts) {
 		}
 	};
 }
-/** One measure out of an optional max, from ONE OR MORE named sources, with an optional verdict.
-*
-* `source` takes several entries for the same reason `f.identity`'s `channels` does — it is a
-* role that holds a LIST, so `view.source` is an ordered list of names rather than one name.
-* Two ratings of the same film out of ten are one measure read twice, and drawing them apart is
-* what makes them incomparable: the eye has to carry the scale between two figures instead of
-* reading them against a shared one. `media/title` had exactly that, two `f.score` blocks of
-* `max: 10` held apart inside an `f.compare`, until this took the restriction off.
-*
-* NOT `multiple`. A multiple field is an anonymous array; these are NAMED sources, and the name
-* is what says which reading came from where. The two are different shapes and the block wants
-* this one.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  score
-* @example f.score({ source: { imdb: f.real({ label: '…' }), tmdb: f.real({ label: '…' }) }, max: 10 })
-*/
 function score(opts) {
 	const names = Object.keys(opts.source ?? {});
 	if (names.length === 0) throw new Error(`[field.score] slot 'source' expects at least one entry, got 0`);
@@ -7235,14 +6128,6 @@ function score(opts) {
 		}
 	};
 }
-/** A status value with an optional "since" timestamp.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  status
-* @example f.status({ source: { state: f.string({ label: '…' }) }, since: { since: f.date({ label: '…' }) } })
-*/
 function status(opts) {
 	const source = slot("status", "source", opts.source);
 	const since = opts.since !== void 0 ? slot("status", "since", opts.since) : void 0;
@@ -7259,23 +6144,6 @@ function status(opts) {
 		}
 	};
 }
-/** A gauge value between an optional min and max, with an optional "of" total.
-*
-* `direction` is opt-in: when given, the gauge decides in plain JavaScript whether its own
-* value crossed the bound that matters (`meterTone`, `blocks/meter.tsx`) and reaches for the
-* tone palette — the fill, the value text and the `of` companion all move together, never
-* colour alone (a glyph rides along, see the renderer's own comment). Omit it and nothing
-* about the gauge changes from today. A `'ceiling'` gauge with no declared `max` (config or
-* the source field's own hints) resolves it from `of`'s own value instead — a budget's cap is
-* a per-record field, never a compile-time constant.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  meter
-* @example f.meter({ source: { used: f.real({ label: '…' }) }, min: 0, max: 100 })
-* @example f.meter({ source: { spent: f.real({ label: '…' }) }, of: { budget: f.real({ label: '…' }) }, direction: 'ceiling' })
-*/
 function meter(opts) {
 	const source = slot("meter", "source", opts.source);
 	const of = opts.of !== void 0 ? slot("meter", "of", opts.of) : void 0;
@@ -7295,16 +6163,6 @@ function meter(opts) {
 		}
 	};
 }
-/**
-* A line-item receipt with a trailing total. `view.lines` (Task 5) is the ORDERED LIST of
-* the line fields' own storage names; `view.total` is the total field's own name.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  receipt
-* @example f.receipt({ fields: { line: f.real({ label: '…' }) }, total: { total: f.real({ label: '…' }) } })
-*/
 function receipt(opts) {
 	const total = slot("receipt", "total", opts.total);
 	return {
@@ -7320,14 +6178,6 @@ function receipt(opts) {
 		}
 	};
 }
-/** A financial balance value, with an optional i18n caption.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  balance
-* @example f.balance({ source: { balance: f.real({ label: '…' }) }, caption: 'mod.blocks.balanceCaption' })
-*/
 function balance(opts) {
 	const source = slot("balance", "source", opts.source);
 	return {
@@ -7343,21 +6193,6 @@ function balance(opts) {
 		}
 	};
 }
-/**
-* A from/to route with optional depart/arrive times and duration. `view` names each role
-* (Task 5) — see `figure`'s own doc comment for what that means and why.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  route
-* A `stub` is the part of the ticket that is TORN OFF and kept — a seat, a gate, a booking
-* reference. Declaring one makes the block a ticket rather than a line: the two halves are
-* separated by a perforation, and the fields in the stub sit below it. Without one the block
-* is exactly what it was, a route from here to there, so no existing call changes.
-*
-* @example f.route({ from: { from: f.string({ label: '…' }) }, to: { to: f.string({ label: '…' }) } })
-*/
 function route(opts) {
 	const from = slot("route", "from", opts.from);
 	const to = slot("route", "to", opts.to);
@@ -7381,25 +6216,6 @@ function route(opts) {
 		}
 	};
 }
-/**
-* Stamps a block's `kind` (and, for journal/manifest, its part-key config) directly onto
-* the collection `source` itself, rather than wrapping it in a keyless layout group.
-*
-* The earlier shape (`group({ fields: [source], view: {kind} })`) put `kind` on an outer,
-* KEYLESS wrapper and left `source` — a KEYED, `multiple: true` collection — as an ordinary
-* child. `elementKind()` (`web-ui/registry.ts`) resolves a group's `kind` ahead of its
-* storage kind, so that wrapper WOULD have resolved through the registry — but only the
-* layout engine's KEYLESS-group dispatch (a declared `kind`, resolved through the field
-* renderer registry — `layout.tsx`) ever looks at it there; the actual collection one level
-* down still elementKind()s to the generic 'collection' and renders through the ordinary
-* CollectionPage widget, opaque to the block.
-*
-* Stamping `source` itself instead routes it through the layout engine's STORAGE-group
-* branch (`isStorageGroup`, `layout.tsx`) exactly like `field.check({multiple:true})`'s
-* `checklist` kind: an ordinary `registerRenderer({kinds:[...]})` Page receives the raw row
-* array as `value` and the collection's own write path as `onChange` directly — see
-* `render/blocks/{calendar,journal,manifest,table}.tsx`.
-*/
 function stampCollection(block, slotted, label, view) {
 	const [name, source] = Object.entries(slot(block, "source", slotted))[0];
 	if (!hasChildren(source) || source.scope !== "nest" || source.multiple !== true) throw new Error(`[field.${block}] source must be a collection (a 'nest', multiple:true group)`);
@@ -7411,45 +6227,12 @@ function stampCollection(block, slotted, label, view) {
 		view
 	};
 }
-/**
-* A calendar rendered from a single collection source — see `stampCollection`. `date` is a
-* part KEY inside each collection row (a `date` or `datetime` field), same as `journal`'s
-* `date`/`manifest`'s `quantity`/`item` — an explicit key, not a guess: a collection with
-* more than one date-shaped part (e.g. `start`/`end`) would otherwise mark the grid by
-* whichever one is found first, silently.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  calendar
-* @example f.calendar({ source: { entries: f.group({ scope: 'nest', multiple: true, fields: { day: f.date({ label: '…' }) } }) }, date: 'day' })
-*/
 function calendar(opts) {
 	return stampCollection("calendar", opts.source, opts.label, {
 		kind: "calendar",
 		date: opts.date
 	});
 }
-/**
-* A sparkline over a series held in a collection source — see `stampCollection`. `value`
-* and `date` are part KEYS inside each collection row, the same explicit addressing
-* `calendar`'s `date` and `journal`'s `date`/`text` use: a collection with more than one
-* numeric or date-shaped part would otherwise be charted by whichever one is found first.
-* `date` orders the series; it is never an axis (the sparkline spaces its points evenly —
-* `render/blocks/series.ts` says why). `delta: true` adds the change against the previous
-* reading beside the last value.
-*
-* The design sketched this as `f.chart({ source: collectionKey, … })`. There is no
-* `collectionKey` type and no resolver for one anywhere in the tree — the design's own
-* "As shipped" note had already retired that sketch for journal/manifest/calendar without
-* updating this row.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  chart
-* @example f.chart({ source: { readings: f.group({ scope: 'nest', multiple: true, fields: { day: f.date({ label: '…' }), kg: f.real({ label: '…' }) } }) }, value: 'kg', date: 'day', delta: true })
-*/
 function chart(opts) {
 	return stampCollection("chart", opts.source, opts.label, {
 		kind: "chart",
@@ -7458,45 +6241,12 @@ function chart(opts) {
 		delta: opts.delta
 	});
 }
-/**
-* A calendar heat map of event DENSITY rendered from a collection source — see
-* `stampCollection`. `date` is a part KEY inside each collection row, the same explicit
-* addressing `calendar`'s `date` and `chart`'s `value`/`date` use.
-*
-* `heatmap` counts ROWS PER DAY; it reads no value column at all, which is the whole
-* difference from `chart`: a chart plots what a row measured, a heat map plots how often
-* rows happened. That is why there is no `value` option here and why one must not be added
-* as a shortcut for "colour by amount" — a magnitude per day is a different question from a
-* count per day, and answering it through the same cells would make the picture ambiguous.
-*
-* The design sketched this as `f.heatmap({ source: collectionKey, … })`. There is no
-* `collectionKey` type and no resolver for one anywhere in the tree — the same correction
-* `f.chart` records above.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  heatmap
-* @example f.heatmap({ source: { sessions: f.group({ scope: 'nest', multiple: true, fields: { day: f.date({ label: '…' }) } }) }, date: 'day' })
-*/
 function heatmap(opts) {
 	return stampCollection("heatmap", opts.source, opts.label, {
 		kind: "heatmap",
 		date: opts.date
 	});
-}
-/**
-* A journal-style log rendered from a single collection source — see `stampCollection`.
-* `date` and `text` are part KEYS inside each collection row, NOT `LayoutEl` positions:
-* they address parts INSIDE the collection's own rows, which is not a slot a block lays
-* out itself.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  journal
-* @example f.journal({ source: { entries: f.group({ scope: 'nest', multiple: true, fields: { day: f.date({ label: '…' }), note: f.text({ label: '…' }) } }) }, date: 'day', text: 'note' })
-*/
+}
 function journal(opts) {
 	return stampCollection("journal", opts.source, opts.label, {
 		kind: "journal",
@@ -7504,14 +6254,6 @@ function journal(opts) {
 		text: opts.text
 	});
 }
-/** A nutrition facts panel, with an optional leading energy value.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  nutrition
-* @example f.nutrition({ fields: { fat: f.real({ label: '…' }) }, energy: { calories: f.real({ label: '…' }) } })
-*/
 function nutrition(opts) {
 	const energy = opts.energy !== void 0 ? slot("nutrition", "energy", opts.energy) : void 0;
 	return {
@@ -7527,17 +6269,6 @@ function nutrition(opts) {
 		}
 	};
 }
-/**
-* A specimen card: a title, an optional subtitle, and a set of condition facets. `view`
-* names each role (Task 5) — `conditions` is the ORDERED LIST of the condition fields' own
-* storage names, not a count against a flattened position.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  specimen
-* @example f.specimen({ title: { name: f.string({ label: '…' }) }, conditions: { condition: f.string({ label: '…' }) } })
-*/
 function specimen(opts) {
 	const title = slot("specimen", "title", opts.title);
 	const subtitle = opts.subtitle !== void 0 ? slot("specimen", "subtitle", opts.subtitle) : void 0;
@@ -7554,26 +6285,6 @@ function specimen(opts) {
 		}
 	};
 }
-/**
-* Measurements against the range they were supposed to fall in, rendered from a single
-* collection source — see `stampCollection`. `analyte`, `value`, `unit`, `low` and `high` are
-* part KEYS inside each collection row, NOT `LayoutEl` positions — the same reasoning as
-* `manifest`'s `quantity`/`item`.
-*
-* The point is the COMPARISON. A `f.table` over the same rows prints the bounds as two more
-* columns and leaves the reader to do it; here each value sits on its own band with the
-* reference span marked on it, so "outside the range" is seen rather than worked out. That is
-* also the only thing on the row worth a colour — it is what the reader has to act on.
-*
-* `unit`, `low` and `high` are optional: a measurement with no published range (a culture, a
-* description) still belongs in the same list and simply gets no band.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  assay
-* @example f.assay({ source: { results: f.group({ scope: 'nest', multiple: true, fields: { analyte: f.string({ label: '…' }), value: f.real({ label: '…' }) } }) }, analyte: 'analyte', value: 'value' })
-*/
 function assay(opts) {
 	return stampCollection("assay", opts.source, opts.label, {
 		kind: "assay",
@@ -7584,32 +6295,6 @@ function assay(opts) {
 		...opts.high ? { high: opts.high } : {}
 	});
 }
-/**
-* Value moving from one place to another, where the MOVEMENT is the subject — not one more
-* labelled row among the record's fields. The sum is set large in the machine voice, and the two
-* ends read as a path beneath it.
-*
-*   amount — what moved. The one required role, and the reason the block exists
-*   from   — where it left. Absent on money that only arrived
-*   to     — where it arrived. Absent on money that only left
-*   meta   — the record's own remaining fields, under a rule: date, category, reference
-*
-* An absent end is not drawn, and that is the whole reading: money that left an account and
-* arrived nowhere IS an expense. It is read off which ends the record actually has, never
-* guessed from the shape of a value. What the movement MEANS beyond that — whether this
-* particular kind of transfer is good news — is carried by the classifier's own option `tone`,
-* the same declaration every other coloured value in the product uses.
-*
-* Distinct from `f.route`, which also has two ends: there the journey is the subject and the
-* ends are places, so it carries times and a duration; here the ends are accounts and the
-* subject is the quantity.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  flow
-* @example f.flow({ amount: { amount: f.money({ label: '…' }) }, from: { source: f.relation({ label: '…' }) } })
-*/
 function flow(opts) {
 	const amount = slot("flow", "amount", opts.amount);
 	const from = opts.from !== void 0 ? slot("flow", "from", opts.from) : void 0;
@@ -7629,17 +6314,6 @@ function flow(opts) {
 		}
 	};
 }
-/**
-* A packing/cargo manifest rendered from a single collection source — see `stampCollection`.
-* `quantity` and `item` are part KEYS inside each collection row, NOT `LayoutEl` positions —
-* the same reasoning as `journal`'s `date`/`text`.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  manifest
-* @example f.manifest({ source: { cargo: f.group({ scope: 'nest', multiple: true, fields: { item: f.string({ label: '…' }), qty: f.real({ label: '…' }) } }) }, quantity: 'qty', item: 'item' })
-*/
 function manifest(opts) {
 	return stampCollection("manifest", opts.source, opts.label, {
 		kind: "manifest",
@@ -7647,26 +6321,6 @@ function manifest(opts) {
 		item: opts.item
 	});
 }
-/**
-* A real table over a single collection source — see `stampCollection`.
-*
-* A plain collection (`f.row({ key, multiple })`) is a LAYOUT: repeated rows whose columns
-* line up. A table is an INSTRUMENT: its header sorts, `groupBy` buckets the rows, `totals`
-* closes it with an aggregate, `numbered` counts them. The server sees the same rows either
-* way — this factory declares no storage and changes none.
-*
-* `sort`, `groupBy` and every key of `totals` name a field of the ROW, exactly as `journal`'s
-* `date`/`text` and `manifest`'s `quantity`/`item` do: an explicit key, never a guess at which
-* column looks sortable or summable. `groupBy` needs no categorical filter — the list panel
-* groups a text field only when `views.groupBy` names it explicitly (`sdk/shelf.ts`), and this
-* IS that explicit naming.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  table
-* @example f.table({ source: { rows: f.row({ scope: 'nest', multiple: true, fields: { a: f.string({ label: 'mod.fields.a' }) } }) }, sort: 'a' })
-*/
 function table(opts) {
 	return stampCollection("table", opts.source, opts.label, {
 		kind: "table",
@@ -7680,28 +6334,6 @@ function table(opts) {
 		...opts.numbered ? { numbered: true } : {}
 	});
 }
-/**
-* An identity document, drawn as the card it is: a caption and its number across the top, a
-* portrait beside the holder's own fields, the issuing details under a rule, and the
-* machine-readable strip at the foot. `view` names each role (Task 5) — see `masthead`'s own
-* doc comment for what an ordered name list means.
-*
-*   overline — the caption at the top left ("PASSPORT", "DRIVING LICENCE")
-*   number   — the document's number, set apart at the top right
-*   photo    — the portrait. One field, rendered in a portrait frame beside the body
-*   meta     — the card's OWN fields, labelled, at each field's declared span
-*   footer   — the fields below the rule: issued, authority, record number
-*   mrz      — the machine-readable strip, set in monospace at the foot
-*
-* Every role is optional but `number`: a bank card has no `mrz`, a library card no `photo`,
-* and the card simply omits the part it was given nothing for.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  idcard
-* @example f.idcard({ number: { number: f.string({ label: '…' }) }, meta: { issued: f.string({ label: '…' }) } })
-*/
 function idcard(opts) {
 	const overline = opts.overline !== void 0 ? slot("idcard", "overline", opts.overline) : void 0;
 	const number = slot("idcard", "number", opts.number);
@@ -7723,16 +6355,6 @@ function idcard(opts) {
 		}
 	};
 }
-/**
-* Properties inspector — a compact key-value metadata grid (columns default 2).
-* Formatted pairs with clear labels and concise values (like Notion / Linear property bars).
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  properties
-* @example f.properties({ columns: 2, fields: { a: f.string({ label: '…' }) } })
-*/
 function properties(opts) {
 	return {
 		...group({
@@ -7747,14 +6369,6 @@ function properties(opts) {
 		}
 	};
 }
-/** Vertical stack — 1-column full-width flow of fields.
-*
-* @layer   block
-* @base    group
-* @prim    —
-* @widget  stack
-* @example f.stack({ fields: { a: f.string({ label: '…' }) } })
-*/
 function stack(opts) {
 	return {
 		...group({
@@ -7766,7 +6380,6 @@ function stack(opts) {
 		view: { kind: "stack" }
 	};
 }
-/** The block factories, merged into the `f` namespace beside row/table/sheet — see fields.ts. */
 var blocks = {
 	bento,
 	split,
@@ -8550,7 +7163,7 @@ var require_data = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	};
 }));
 //#endregion
-//#region ../sdk/src/fields/constants.ts
+//#region ../sdk/dist/fields/constants.js
 var import_src = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var LANGUAGES_LIST = require_data();
 	var LANGUAGES = {};
@@ -8606,58 +7219,10 @@ import_src.default.getAllCodes().map((code) => ({
 	name: import_src.default.getNativeName(code)
 })).sort((a, b) => a.name.localeCompare(b.name));
 //#endregion
-//#region ../sdk/src/fields.ts
-/**
-* The field type system — the heart of the platform. A pure, isomorphic module.
-* One field description → three consumers:
-*   1. `zod`    — validation (identical on server and client)
-*   2. `column` — the DB column type
-*   3. `prim`/`kind` — keys for resolving the renderer (see web/render/registry)
-*/
-/**
-* Does this node carry a value of its own? True for a leaf field, for a static display
-* value, and for a composite — a composite's parts do not replace its own meta.
-*/
+//#region ../sdk/dist/fields.js
 var hasValue = (x) => x.type !== void 0 && typeof x.type === "object";
-/**
-* Does this node carry children? True for every container and for a composite. An EMPTY
-* `fields` still counts: a row with no cells is a container that happens to hold nothing,
-* not a leaf.
-*/
 var hasChildren = (x) => Array.isArray(x.fields);
-/**
-* Is this node an ORDINARY NAMED FIELD — the case almost every call site actually means by
-* "a field", as opposed to a keyless display value (a computed value with no storage) or a
-* container? `hasValue(x) && !hasChildren(x) && x.key !== undefined` is this exact test,
-* spelled out by hand at some twenty call sites before this predicate existed.
-*
-* That duplication is why this predicate exists: today `hasValue(x) && !hasChildren(x)`
-* alone answers the same question, because no composite in today's composed schema is a
-* both-node (see `LayoutNode`'s own doc comment above). The day one exists, a hand-spelled
-* `hasValue && !hasChildren` silently reclassifies it as a container, while this predicate
-* — which also checks `key` — still has to be taught what to do with it. One place to fix
-* instead of twenty. See docs/decisions.md, 2026-08-26, "HAZARD for whoever produces the
-* first both-node".
-*/
 var isNamedField = (x) => hasValue(x) && !hasChildren(x) && x.key !== void 0;
-/**
-* A visual or storage group of fields, nestable to any depth — a group inside a group
-* inside a group, columns expanding recursively (`key__child__grandchild__…`, see
-* `checkStorage` in `compose.ts`). There is no level count: the only ceiling is the
-* identifier budget PostgreSQL imposes on a generated name, checked at composition time
-* (`MAX_COLUMN_NAME`/`MAX_TABLE_NAME`, `packages/sdk/src/compose.ts`), not a depth guard.
-* `scope` decides which: `'hoist'` (the default) arranges children inside the PARENT's
-* scope and stores nothing of its own; `'nest'` owns a scope and is stored —
-*   - embedded (no multiple): a nested object over `key__sub` columns;
-*   - collection (multiple): a child table (array of rows).
-* A 'nest' group is NAMED BY ITS PARENT — the property it is declared under — and takes
-* only NAMED children (each with a storage key of its own).
-*
-* @layer   primitive
-* @prim    —
-* @widget  group
-* @example f.group({ scope: 'nest', label: 'mod.fields.contact', fields: { name: f.string({}) } })
-*/
 function group(o) {
 	if (o["view"] !== void 0) throw new Error("[group] `view` is gone — presentational options live in `ui: {}` (see CLAUDE.md § field author options and the field-types skill).");
 	const r = o.rules ?? {};
@@ -8688,21 +7253,6 @@ function group(o) {
 		fields
 	};
 }
-/**
-* Layout group, flow nowrap + horizontal scroll (single line). Sugar over group().
-*
-* `multiple` is an ordinary modifier here as everywhere else: `f.row({ scope: 'nest',
-* multiple: true })` is a COLLECTION of rows, and the renderer aligns its columns (a repeated row is what a
-* table is). There is no separate factory and no separate `display` value to DECLARE a
-* tabular collection — `f.table` (`blocks.ts`) is a VIEW stamped onto a collection built
-* here, never a second way to declare one.
-*
-* @layer   primitive
-* @prim    —
-* @widget  group
-* @example f.row({ label: 'mod.fields.row', fields: {} })
-* @example f.row({ scope: 'nest', label: 'mod.fields.items', multiple: true, fields: {} })
-*/
 function row(o) {
 	return group({
 		scope: o.scope,
@@ -8714,22 +7264,6 @@ function row(o) {
 		ui: { display: "scroll" }
 	});
 }
-/**
-* Layout group with a 2D layout (rows×columns → aligned CSS grid). Sugar over group().
-*
-* A ROW IS A GROUP. `fields` is a map of rows, each row a map of its cells: the outer
-* property names the row, the inner ones name the cells (their storage keys, like any
-* other named child). Each row materializes into a nested `scope: 'hoist'` group, so a
-* row boundary is the nesting itself and the renderer reads `group.fields` as its rows
-* instead of scanning a flat list for separator markers. The cells still belong to the
-* PARENT's scope — a hoist group owns none — so the columns are exactly the ones the flat
-* form produced, an empty row included (a row group with no cells).
-*
-* @layer   primitive
-* @prim    —
-* @widget  group
-* @example f.sheet({ label: 'mod.fields.sheet', fields: { net: { ip: f.string({}) }, hw: { mac: f.string({}) } } })
-*/
 function sheet(o) {
 	const rows = Object.fromEntries(Object.entries(o.fields).map(([name, cells]) => [name, group({
 		scope: "hoist",
@@ -8742,17 +7276,6 @@ function sheet(o) {
 		ui: { display: "sheet" }
 	});
 }
-/**
-* Composite URL — embedded-group sugar. Storage: separate nested columns
-* (`key__scheme`, `key__host`, `key__port`, …) in the same table. The renderer
-* is custom (a single link/input, `kind:'url'`) — string↔parts via
-* parseUrl/buildUrl. Partial/invalid URLs are stored by parts.
-*
-* @layer   primitive
-* @prim    —
-* @widget  url
-* @example f.url({ label: 'mod.fields.website' })
-*/
 function url(o) {
 	return group({
 		scope: "nest",
@@ -8770,16 +7293,6 @@ function url(o) {
 		}
 	});
 }
-/**
-* Keyed collection: one row per value of a single named field of that row — `by` names
-* which one (default: the first), and its own name is the row's storage key. See the block
-* comment above for the full contract (container, fixed, unique).
-*
-* @layer   primitive
-* @prim    —
-* @widget  group
-* @example f.keyed({ label: 'mod.fields.translations', fields: { lang: f.string({ options: ['en', 'uk'] }) } })
-*/
 function keyed(o) {
 	const entries = Object.entries(o.fields);
 	if (entries.length === 0) throw new Error(`[field.keyed] fields must declare at least the key field`);
@@ -8815,58 +7328,18 @@ function keyed(o) {
 }
 var isCollectionGroup = (g) => g.scope === "nest" && g.multiple === true;
 var isEmbeddedGroup = (g) => g.scope === "nest" && g.multiple !== true;
-/**
-* Horizontal divider, optionally labeled (a section heading).
-*
-* @layer   primitive
-* @prim    —
-* @widget  divider
-* @example f.divider({ label: 'mod.fields.section' })
-*/
 function divider(o) {
 	return {
 		el: "divider",
 		label: o?.label
 	};
 }
-/**
-* Reference markdown block by i18n key.
-*
-* The key is resolved WITH the variables of the running instance, so the locale string
-* may name facts that are not constants: `{{origin}}` is this instance's own address
-* (`https://coffer.example`), which is how a block documents an endpoint without
-* freezing a developer's `localhost` into every translation. The set is fixed and
-* ambient — the block declares only its key. See `web-ui/src/render/info-text.ts`.
-*
-* @layer   primitive
-* @prim    —
-* @widget  info
-* @example f.info('mod.fields.infoText')
-*/
 function info(textKey) {
 	return {
 		el: "info",
 		text: textKey
 	};
 }
-/**
-* What else points AT this record — the inverse of a relation, which is often the more useful
-* direction on a record page: a box is more usefully "what is in it" than "what it is in".
-*
-* Stores NOTHING and has no column: it declares where to look, and the server answers by asking
-* the pointing shelf. That is why it is a pseudo-element beside `divider` and `info` rather than
-* a field — there is no value here to validate or save.
-*
-* `from` names the pointing side explicitly (which shelf, and WHICH of its fields), never
-* "everything that happens to point here": a shelf may point at the same target through two
-* fields — a transaction has a source account and a destination account — and a panel that
-* merged them would answer a question nobody asked.
-*
-* @layer   primitive
-* @prim    —
-* @widget  backrefs
-* @example f.backrefs({ label: 'mod.fields.storedHere', from: { library: 'things', shelf: 'item', field: 'location' } })
-*/
 function backrefs(o) {
 	return {
 		el: "backrefs",
@@ -8874,14 +7347,6 @@ function backrefs(o) {
 		from: o.from
 	};
 }
-/**
-* Action button: invokes the handler registered in actionRegistry under the key `value`.
-*
-* @layer   primitive
-* @prim    —
-* @widget  button
-* @example f.button({ label: 'mod.fields.run', value: 'runAction' })
-*/
 function button(o) {
 	return {
 		el: "button",
@@ -8891,38 +7356,14 @@ function button(o) {
 		variant: o.variant
 	};
 }
-/**
-* Brand for `fromShelf()` — a private key, never producible by a plain object literal, so
-* `isShelfSource` tells a dynamic options source apart from a literal array or a named-list
-* string CHEAPLY (one property read) and WITHOUT guessing from shape (`{library,shelf}`
-* alone is not enough: a plugin's own option-list item could coincidentally carry those
-* keys). Not exported — callers only ever get a `ShelfOptionsSource` back from `fromShelf`.
-*/
 var SHELF_SOURCE = Symbol("shelfSource");
-/** Runtime discriminator for `ShelfOptionsSource` — see `SHELF_SOURCE`'s own doc comment. */
 function isShelfSource(v) {
 	return typeof v === "object" && v !== null && v[SHELF_SOURCE] === true;
 }
 function resolveDate(v) {
 	return v === "today" ? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10) : v;
 }
-/**
-* Does this field offer preset values? Not `options.length`: a field whose options come
-* from a NAMED source carries an empty array until composeRegistry resolves it, and every
-* consumer that asks the question earlier (a `keyed({fixed})` check at declaration time, a
-* role's `accepts`) would get the wrong answer.
-*/
 var hasOptions = (f) => (f.options?.length ?? 0) > 0 || f.hints["source"] != null;
-/**
-* `hasOptions`'s own companion for phase 1 (a DECLARATION, not a built meta) — the same
-* question ENUMERATED's `test` asks further down. Now that `options` means the same thing
-* for every type — a literal list, a named list, or `fromShelf(...)` all describe where
-* this field's choices come from — the question is exactly "is `options` present?", nothing
-* more: a `relation` field's choices come from records, which is as much an answer as a
-* literal array is. No separate `opts.source` to check either: composeRegistry only
-* resolves the two STATIC forms into values, but `opts.options` itself is set at
-* declaration time regardless of which form it is.
-*/
 var declHasOptions = (d) => d.opts.options != null;
 registerType("string", {
 	kind: "text",
@@ -8947,18 +7388,9 @@ registerType("string", {
 		};
 	}
 });
-/**
-* Single-line text. Arbitrary pattern/messageKey — via `rules`. Multi-line — `text()`.
-*
-* @layer   primitive
-* @prim    text
-* @widget  text
-* @example f.string({ label: 'mod.fields.name' })
-*/
 function string(o) {
 	return declare("string", o);
 }
-/** Shared by localDir/localFile's build(): a server path, judged only when one was entered. */
 function pathZod(_o) {
 	return stringContent((s) => s);
 }
@@ -8975,14 +7407,6 @@ registerType("localDir", {
 		};
 	}
 });
-/**
-* Path to a DIRECTORY on the server (autocomplete, within home only).
-*
-* @layer   primitive
-* @prim    text
-* @widget  localDir
-* @example f.localDir({ label: 'mod.fields.path' })
-*/
 function localDir(o) {
 	return declare("localDir", o);
 }
@@ -9000,14 +7424,6 @@ registerType("localFile", {
 		};
 	}
 });
-/**
-* Path to a FILE on the server (autocomplete; config.exts filters extensions).
-*
-* @layer   primitive
-* @prim    text
-* @widget  localFile
-* @example f.localFile({ label: 'mod.fields.path' })
-*/
 function localFile(o) {
 	return declare("localFile", o);
 }
@@ -9019,14 +7435,6 @@ registerType("text", {
 		return typeOf("string").build(o, []);
 	}
 });
-/**
-* Multi-line text (`kind: 'textarea'`). No `multiple`.
-*
-* @layer   primitive
-* @prim    text
-* @widget  textarea
-* @example f.text({ label: 'mod.fields.notes' })
-*/
 function text(o) {
 	return declare("text", o);
 }
@@ -9038,17 +7446,6 @@ registerType("i18n", {
 		return typeOf("text").build(o, []);
 	}
 });
-/**
-* Translatable text (kind 'i18n'). Stores a string — an i18n key OR a literal.
-* In view it shows `t(value, { defaultValue: value })`: a known key → translation,
-* any other text → shown as-is. Edit — raw input (key/literal without t()).
-* Built-in reference catalogs write a key; user records — a plain literal.
-*
-* @layer   primitive
-* @prim    text
-* @widget  i18n
-* @example f.i18n({ label: 'mod.fields.title' })
-*/
 function i18n(o) {
 	return declare("i18n", o);
 }
@@ -9060,14 +7457,6 @@ registerType("smallText", {
 		return typeOf("text").build(o, []);
 	}
 });
-/**
-* Multi-line text, scalar size (narrow column ~2 rows). Full-width — `text()`.
-*
-* @layer   primitive
-* @prim    text
-* @widget  smalltext
-* @example f.smallText({ label: 'mod.fields.summary' })
-*/
 function smallText(o) {
 	return declare("smallText", o);
 }
@@ -9091,14 +7480,6 @@ registerType("real", {
 		};
 	}
 });
-/**
-* Real number (column 'real'). min/max/step — via `rules`.
-*
-* @layer   primitive
-* @prim    number
-* @widget  number
-* @example f.real({ label: 'mod.fields.weight' })
-*/
 function real(o) {
 	return declare("real", o);
 }
@@ -9122,14 +7503,6 @@ registerType("int", {
 		};
 	}
 });
-/**
-* Integer (column 'integer'). min/max/step — via `rules`.
-*
-* @layer   primitive
-* @prim    number
-* @widget  number
-* @example f.int({ label: 'mod.fields.count' })
-*/
 function int(o) {
 	return declare("int", o);
 }
@@ -9183,14 +7556,6 @@ registerType("date", {
 		};
 	}
 });
-/**
-* Date value with configurable granularity ('day' | 'month' | 'year', default 'day').
-*
-* @layer   primitive
-* @prim    date
-* @widget  date
-* @example f.date({ label: 'mod.fields.purchaseDate' })
-*/
 function date(o) {
 	return declare("date", o);
 }
@@ -9212,15 +7577,6 @@ registerType("time", {
 		};
 	}
 });
-/**
-* Time-of-day value with configurable granularity ('hour' | 'minute' | 'second', default
-* 'minute' — the same default `f.datetime` has always had).
-*
-* @layer   primitive
-* @prim    time
-* @widget  time
-* @example f.time({ label: 'mod.fields.startTime' })
-*/
 function time(o) {
 	return declare("time", o);
 }
@@ -9241,14 +7597,6 @@ registerType("datetime", {
 		};
 	}
 });
-/**
-* Combined date-and-time value with configurable granularity ('hour' | 'minute' | 'second', default 'minute').
-*
-* @layer   primitive
-* @prim    datetime
-* @widget  datetime
-* @example f.datetime({ label: 'mod.fields.startedAt' })
-*/
 function datetime(o) {
 	return declare("datetime", o);
 }
@@ -9265,15 +7613,6 @@ registerType("boolean", {
 		};
 	}
 });
-/**
-* Boolean value rendered as a checkbox; defaults to false, nullable in storage (an
-* unchanged collection row sends `null`, not `undefined`).
-*
-* @layer   primitive
-* @prim    checkbox
-* @widget  boolean
-* @example f.boolean({ label: 'mod.fields.active' })
-*/
 function boolean(o) {
 	return declare("boolean", o);
 }
@@ -9294,14 +7633,6 @@ registerType("triState", {
 		};
 	}
 });
-/**
-* Three-way choice: 'yes' / 'no' / 'unknown'.
-*
-* @layer   primitive
-* @prim    triState
-* @widget  triState
-* @example f.triState({ label: 'mod.fields.reviewed' })
-*/
 function triState(o) {
 	return declare("triState", o);
 }
@@ -9319,60 +7650,12 @@ registerType("stepper", {
 		};
 	}
 });
-/**
-* The REACHED stage of an ORDERED set of options. ONE value, so a gap is UNREPRESENTABLE
-* rather than merely rejected: reaching stage 3 IS stages 1 and 2 having happened, and
-* "3 but not 2" cannot be written down at all — there is no sequential-gate rule anywhere,
-* in zod or in the UI, because there is nothing to gate. That is the whole difference from
-* `f.string({ options, strict })`, whose options are PEERS (a weekday, a category), and
-* from `f.check`, whose boxes tick independently. An empty value is the legitimate
-* "not started" state, and going back a stage is legitimate too: the field stores where
-* the record IS, never a history of how it got there.
-*
-* STORAGE — the stage's own VALUE, not its index, and which one it is matters because the
-* two fail differently. An index survives renaming a stage and breaks on a reorder or an
-* insertion; a value survives a reorder and breaks on a rename. Inserting a stage into the
-* middle of the set ('customs' between 'shipped' and 'delivered') is the ORDINARY edit of a
-* domain that grows, and under index storage it silently reinterprets every row already
-* stored — corruption with no symptom anywhere. A rename is the rarer edit, it leaves a
-* value the option set no longer contains, and THAT state is loud at both ends: `strict`
-* (forced, below) rejects the next write of it, and the renderer draws it as an unknown
-* stage rather than guessing a position for it or clamping it to a neighbour. A rename is
-* also the case the tree already has a migration for (`TableOps.fill`/`convert`, skill
-* `data-migrations`); nothing in it renumbers stored rows after an insertion. So: the
-* stored value is the option's `value`, and the ORDER is `options`' declaration order.
-*
-* What "loud" costs, stated plainly because this field advertises it: `strict` rejects on
-* WRITE, so a record carrying a stale stage cannot be saved AT ALL until the stage is
-* repaired — not even for an unrelated edit to another field. That is ordinary strict-field
-* behaviour rather than anything new here, but on a field whose whole promise is failing
-* loudly it is the half of the promise that costs something.
-*
-* `strict` is forced on and is not the author's to choose — a value outside the ordered set
-* has no position in it, so it can never be a legitimate entry. Never `multiple`: a record
-* is at exactly one stage.
-*
-* @layer   primitive
-* @prim    text
-* @widget  stepper
-* @example f.stepper({ label: 'mod.fields.stage', options: ['ordered', 'shipped', 'delivered'] })
-*/
 function stepper(o) {
 	return declare("stepper", {
 		...o,
 		strict: true
 	});
 }
-/**
-* Reject anything beyond a flat equality map: an operator key (`$in`, `$and`, …), an
-* object-valued entry (which is how a nested operator like `{ type: { $in: [...] } }`
-* would smuggle itself in), or an explicit `undefined` value all throw, naming the
-* offending key. `undefined` is rejected alongside objects because it would otherwise
-* slip through every later layer unnoticed: `Condition` types it as a valid value,
-* `conditionKeys` skips it so compose validates nothing against the target shelf, and
-* the picker's query-string builder turns it into the literal string `'undefined'`
-* (an empty picker with no error anywhere).
-*/
 function assertFlatEqualityFilter(filter) {
 	for (const [key, value] of Object.entries(filter)) {
 		if (key.startsWith("$")) throw new Error(`[relation] filter key '${key}' is an operator — only flat equality is allowed here`);
@@ -9415,17 +7698,6 @@ registerType("relation", {
 		};
 	}
 });
-/**
-* Link to records of another shelf (`{library, shelf}`). Stores an integer id (single)
-* or a JSON array of integer ids (multiple). Rendered as RecordInline + a record picker.
-* This used to be the record branch of `select()`; split out into a separate primitive
-* so select stays a pure enum/source list.
-*
-* @layer   primitive
-* @prim    relation
-* @widget  relation
-* @example f.relation({ label: 'mod.fields.owner', options: fromShelf({ library: 'people', shelf: 'person' }) })
-*/
 function relation(o) {
 	return declare("relation", o);
 }
@@ -9452,49 +7724,13 @@ registerType("json", {
 		};
 	}
 });
-/**
-* Arbitrary JSON value: a native object/array, or a string parsed as JSON.
-*
-* @layer   primitive
-* @prim    json
-* @widget  json
-* @example f.json({ label: 'mod.fields.raw' })
-*/
 function json(o) {
 	return declare("json", o);
 }
-/**
-* A content role accepts whatever the author declared, because for `check` the author's
-* field IS the filling: there is no second override channel to correct one AGAINST (see
-* `contentRole` below — both branches of its `normalize` hand back the same declaration).
-*
-* It used to demand a field owning ONE column, on the grounds that "a composite inside a
-* composite would need `key__sub__sub`, which nothing on the flatten/nest path builds".
-* `partColumns` builds it now, and the flatten/nest walks follow it — so the ground is
-* gone and with it the only thing this role ever refused.
-*/
 var ANY_CONTENT = {
 	test: () => true,
 	describe: "the author's own content field"
 };
-/**
-* A single check's roles are not a fixed table: they come from the author's own `fields`
-* and `slots`, the way `measured`'s unit role comes from its `units`. There is no second
-* override channel: `fields` IS how an author fills the content roles, so every role
-* resolves through its own `fallback` and `check` takes no `parts` spec. Reusing the
-* author's `FieldMeta` as that fallback is safe for the same reason — the node was
-* built inside this one `f.check(…)` call and is shared with nothing else.
-*
-* The two forms use DIFFERENT role orders, both load-bearing — `roles(opts)` reads
-* `opts.multiple` (declared data, already resolved to a concrete boolean for THIS
-* declaration by the time the pipeline calls it once) and returns the matching order, the
-* same way `numberRange`/`realRange`'s own `roleZod` reads `opts.config`:
-*   - single: content first, then one boolean per slot — declaration order is column
-*     order, so the leading content field is the magnitude `magnitudeSub()` sorts and
-*     filters by;
-*   - multiple: checkbox columns first, then content — its own established child-table
-*     shape (the renderer's checklist reads the toggles as the row's leading columns).
-*/
 var contentRole = (f) => {
 	const def = {
 		role: f.key,
@@ -9511,55 +7747,25 @@ var checkboxRole = (label, i) => {
 	};
 	return def;
 };
-/** `opts.slots`, defaulted to one unnamed checkbox — read the same way by `roles`/`roleZod`/`hints`. */
 function checkSlots(opts) {
 	const slots = opts.slots;
 	return slots && slots.length > 0 ? slots : [""];
 }
-/**
-* The content fields of one `f.check(…)` call: materialized, and validated at `roles()`
-* time — declaration-time-equivalent, since every real entry point (`defineShelf`, `group()`,
-* …) materializes synchronously at shelf-definition time — no duplicate key, no
-* `check\d+`-shaped key (reserved for the checkbox slots).
-*
-* A composite content field is ordinary now: `partColumns` expands it into
-* `<content>__<sub>` and the single form stores it across `<field>__<content>__<sub>`,
-* exactly as the multiple form has always stored it in its child table. The guard that
-* refused one in the single form is gone with the flat collector that made it necessary.
-*/
 function checkContentFields(opts) {
 	const fields = opts.fields;
 	const contentFields = materializeTree(fields !== void 0 && Object.keys(fields).length > 0 ? fields : { text: string({ label: "core.fields.text" }) });
 	for (const f of contentFields) if (/^check\d+$/.test(f.key)) throw new Error(`[field.check] content field '${f.key}' is reserved for checkbox slots`);
 	return contentFields;
 }
-/** `check`'s roles, in the order its CURRENT form (single vs multiple) stores them — see
-*  this section's own header note for why the order differs and why reading `opts.multiple`
-*  here is enough: one `materialize()` call means one already-resolved `multiple`. This is
-*  the ONE call `checkContentFields` gets per build — the pipeline calls `roles(opts)`
-*  once and resolves the result into `parts`, which `roleZod`/`hints` below read back
-*  instead of recomputing. */
 function checkRoles(opts) {
 	const contentRoles = checkContentFields(opts).map(contentRole);
 	const checkboxRoles = checkSlots(opts).map(checkboxRole);
 	return opts.multiple ? [...checkboxRoles, ...contentRoles] : [...contentRoles, ...checkboxRoles];
 }
-/**
-* The CONTENT slice of `check`'s own already-resolved `parts` — everything but the
-* checkbox roles `roleZod`/`hints` handle separately (the checkbox roles' default zod is
-* a bare `z.boolean()` with no content behind it; `hints.fields` is documented content-
-* only). Sliced by the checkbox COUNT (`checkSlots`, declared data, no materialize), off
-* whichever end `checkRoles` put them on for this form — not a role-name pattern match,
-* which would re-hardcode the very `check\d+` shape `checkContentFields` already guards as
-* a RESERVED key, not a way to recognize one.
-*/
 function checkContentParts(opts, parts) {
 	const slotCount = checkSlots(opts).length;
 	return opts.multiple ? parts.slice(slotCount) : parts.slice(0, parts.length - slotCount);
 }
-/** `check`'s per-role default zod, from the parts the pipeline already resolved — reading
-*  `p.meta.zod`/`p.role` off each content part instead of re-materializing the author's
-*  `fields` a second time (see `checkContentParts`). */
 function checkRoleZod(opts, parts) {
 	const shape = {};
 	for (const p of checkContentParts(opts, parts)) shape[p.role] = p.meta.zod;
@@ -9582,37 +7788,13 @@ registerType("check", {
 		}))
 	})
 });
-/**
-* Row(s) of N labeled checkboxes plus content fields. Single (non-multiple) stores real
-* columns (`check0`, `check1`, …) alongside the content fields; multiple stores a child
-* table with the checkbox columns first, then the content fields.
-*
-* @layer   primitive
-* @prim    check
-* @widget  check
-* @example f.check({ label: 'mod.fields.tasks' })
-*/
 function check(o) {
 	return declare("check", o);
 }
-/**
-* A role whose filling must be ENUMERATED: a unit, a currency. Now that `options` means the
-* same thing for every type — a literal list, a named list, or `fromShelf(...)` all describe
-* where this field's choices come from — the question is exactly "is `options` present?": a
-* `relation` filling qualifies exactly like a select does, its choices being its target
-* shelf's records rather than a literal list.
-*
-* Tests the DECLARED opts (`d.opts.options`), not `hasOptions` on a BUILT meta: a named
-* option source is bound later, at `composeRegistry`, so asking `hasOptions` here — in
-* phase 1, before that binding — would read an empty array and reject a perfectly good
-* named-source declaration.
-*/
 var ENUMERATED = {
 	test: (d) => d.opts.options != null,
 	describe: "a field with options, or a relation"
 };
-/** Roles of `measured`: the magnitude and its unit. The unit's default depends on THIS
-*  field's own `units`, so it writes its own `normalize` rather than using `role()`. */
 var MEASURED_ROLES = (opts) => {
 	const unitRole = {
 		role: "unit",
@@ -9632,8 +7814,6 @@ var MEASURED_ROLES = (opts) => {
 	};
 	return [role("value", ["number"], "real"), unitRole];
 };
-/** `measured`'s per-role default zod: the magnitude (int via step:1, kept for compat) and
-*  the unit, validated against `opts.units`. */
 function measuredRoleZod(opts) {
 	const cfg = opts.config ?? {};
 	const units = resolveUnits(opts.units);
@@ -9646,14 +7826,6 @@ function measuredRoleZod(opts) {
 		unit: string$1().refine((v) => units.some((u) => u.value === v), { message: vmsg("measured_unit") })
 	};
 }
-/**
-* `measured`'s own structure-failure report: not a flat code, but a SEARCH of the failed
-* `rowSchema`'s own issues for one that already carries a vmsg-coded message (the unit
-* role's own `measured_unit` refine) — that message is forwarded verbatim instead of the
-* flat `measured_structure` code, so the caller learns WHICH part failed. Falls back to
-* `measured_structure` when no such issue is found (a genuinely malformed row, not a bad
-* unit).
-*/
 function measuredStructureCode(error) {
 	const vmsgIssue = error.issues.find((iss) => {
 		try {
@@ -9682,15 +7854,6 @@ registerType("measured", {
 		};
 	}
 });
-/**
-* Magnitude + per-row unit stored together as a composite {value, unit}; the unit is
-* validated against `units`.
-*
-* @layer   primitive
-* @prim    measured
-* @widget  measured
-* @example f.measured({ label: 'mod.fields.weight', units: 'weight' })
-*/
 function measured(o) {
 	return declare("measured", o);
 }
@@ -9713,16 +7876,6 @@ registerType("unit", {
 		};
 	}
 });
-/**
-* Declares the unit ONCE per record. Every `amount` below it is a plain number on
-* this scale, so sums and comparisons are ordinary SQL. Deliberately not a
-* conversion mechanism: units.ts holds labels, not factors.
-*
-* @layer   primitive
-* @prim    text
-* @widget  unit
-* @example f.unit({ label: 'mod.fields.unit', options: 'weight' })
-*/
 function unit(o) {
 	return declare("unit", o);
 }
@@ -9749,20 +7902,9 @@ registerType("amount", {
 		};
 	}
 });
-/**
-* A plain number whose unit is declared elsewhere (`unitFrom`). Stored in a `real`
-* column: summable, comparable and orderable in SQL, unlike `measured`, which pairs
-* a number with a per-row unit across two sub-columns.
-*
-* @layer   primitive
-* @prim    number
-* @widget  amount
-* @example f.amount({ label: 'mod.fields.quantity', unitFrom: 'unit' })
-*/
 function amount(o) {
 	return declare("amount", o);
 }
-/** Roles of `geo`: the coordinate pair and an optional human label. */
 var GEO_ROLES = () => [
 	role("lat", ["number"], "real"),
 	role("lng", ["number"], "real"),
@@ -9782,30 +7924,9 @@ registerType("geo", {
 	structureCode: "geo_structure",
 	acceptsEmptyRow: true
 });
-/**
-* Geographic point composite {lat, lng, label?}; lat/lng validated to valid coordinate
-* ranges.
-*
-* @layer   primitive
-* @prim    geo
-* @widget  geo
-* @example f.geo({ label: 'mod.fields.location' })
-*/
 function geo(o) {
 	return declare("geo", o);
 }
-/**
-* Roles of `illustrated`: the prose and the picture that illustrates it.
-*
-* ORDER IS LOAD-BEARING. `partColumns` emits columns in role order and `magnitudeSub`
-* (sdk/shelf.ts) takes the first one, so it decides what `?about=…` filters and what a list
-* column sorts by. `text` first points both at the prose; `image` first would point them at a
-* file name.
-*
-* Both roles use a PREDICATE rather than a prim list: "renders as a picture" and "is prose" are
-* properties of the field's `kind`, not of its storage family — every file field stores JSON and
-* every text field stores `text`, so a prim list could not tell an image from a PDF.
-*/
 var ILLUSTRATED_IMAGE_KINDS = /* @__PURE__ */ new Set([
 	"image",
 	"media",
@@ -9826,23 +7947,6 @@ var ILLUSTRATED_ROLES = () => [role("text", {
 	test: (d) => ILLUSTRATED_IMAGE_KINDS.has(typeOf(d.factory).kind),
 	describe: "an image field (image, media, avatar, cover, poster)"
 }, "image")];
-/**
-* A composite's per-role default zod, read from each role's OWN fallback filling instead of
-* being hand-written per type — `partsRowShape` substitutes a part's zod only when the
-* author OVERRODE the filling (`p.overridden`), so whatever this returns is the entire
-* validation a DEFAULT filling gets. Hand-writing it is how `illustrated`'s picture role
-* ended up with `z.unknown()`: a bare `f.illustrated({})`, the factory's own @example,
-* accepted any garbage in `image` and lost whatever rules the prose filling declares.
-* Reading the fallbacks makes the two agree by construction, the way `f.period` builds its
-* own default shape from its resolved sub-fields. Each fallback's zod is already
-* `optionalize(…, false)`, which maps `''`/`null` to `undefined` — the nullish tolerance the
-* previous literal spelled out by hand.
-*
-* Shared by every composite whose default schema needs nothing from the call's own opts
-* (`illustrated`, `attachment`) — a type whose per-role shape IS derived from its opts
-* (`period`'s granularity) or from the resolved fillings (`check`'s content roles) builds
-* its own instead.
-*/
 function defaultRoleZod(roles) {
 	const shape = {};
 	for (const r of roles()) {
@@ -9862,38 +7966,9 @@ registerType("illustrated", {
 	collectionView: "illustratedList",
 	hints: (o) => o.config ? { config: o.config } : {}
 });
-/**
-* A picture and its description as ONE value: `{ text, image }`, stored across
-* `<key>__text` / `<key>__image`. The renderer wraps the prose around the picture, so a
-* record page states "what this is, shown and told" as one editorial unit instead of two
-* fields with an empty rectangle between them.
-*
-* `multiple: true` is the ordinary modifier and takes the collection-group path, exactly as
-* `f.period` and `f.check` do — a child table whose columns are the resolved parts.
-*
-* @layer   primitive
-* @prim    illustrated
-* @widget  illustrated
-* @example f.illustrated({ label: 'mod.fields.about' })
-*/
 function illustrated(o) {
 	return declare("illustrated", o);
 }
-/**
-* Roles of `attachment`: the name the owner gives the document, and the document itself.
-*
-* ORDER IS LOAD-BEARING, for the same reason it is in `ILLUSTRATED_ROLES` above:
-* `partColumns` emits columns in role order and `magnitudeSub` (sdk/shelf.ts) takes the
-* first one, so it decides what `?<key>=…` filters and what a list column sorts by. `label`
-* first points both at the words a person wrote; `file` first would point them at a JSON
-* blob whose lexical order is an accident of how the entry's keys happen to be serialized.
-*
-* Both roles are PRIM LISTS, not predicates — unlike `illustrated`, which needs a predicate
-* because it must tell a picture from a PDF and every file kind stores the same prim. This
-* type accepts the whole file family, which is exactly what `prim: 'file'` names
-* (`registerFileType`, below in this file — the roles resolve lazily, long after it runs),
-* so a list says it precisely and a predicate would only restate it at more length.
-*/
 var ATTACHMENT_ROLES = () => [role("label", ["text"], "string"), role("file", ["file"], "file")];
 registerType("attachment", {
 	kind: "attachment",
@@ -9905,35 +7980,9 @@ registerType("attachment", {
 	acceptsEmptyRow: true,
 	collectionView: "attachmentList"
 });
-/**
-* An uploaded file and the label that names it as ONE value: `{ label, file }`, stored
-* across `<key>__label` / `<key>__file`. A file field alone can only ever show what the
-* uploader happened to call the file — `scan_20240817_final(2).pdf` — so the record page
-* states what a document IS beside it instead of leaving the reader to open every one.
-*
-* `multiple: true` is the ordinary modifier and takes the collection-group path, exactly as
-* `f.illustrated` and `f.period` do — a child table whose columns are the resolved parts.
-* The `file` role accepts any of the file family and defaults to `f.file` (accept `*`); a
-* shelf that wants the narrower document uploader fills it: `fields: { file: f.document({}) }`.
-*
-* @layer   primitive
-* @prim    attachment
-* @widget  attachment
-* @example f.attachment({ label: 'mod.fields.attachment' })
-*/
 function attachment(o) {
 	return declare("attachment", o);
 }
-/**
-* 7 values, Mon–Sun. A thin wrapper over keyed({fixed}): a fixed collection,
-* keyed by the weekday list, one real value per day. Its own kind 'per-weekday'
-* dispatches a compact renderer. Storage: a grandchild table of {day, value} rows.
-*
-* @layer   primitive
-* @prim    —
-* @widget  per-weekday
-* @example f.perWeekday({ label: 'mod.fields.hours' })
-*/
 function perWeekday(o) {
 	return {
 		...keyed({
@@ -9956,45 +8005,18 @@ function perWeekday(o) {
 		kind: "per-weekday"
 	};
 }
-/**
-* How a cross-field ordering check (a range's `from > to`, a period's) reads one endpoint
-* once `stripServerOwnedParts` has removed the slots the schema owns. The check must judge
-* the value the record will actually CARRY, never the client's echo of a server-owned slot:
-* that echo is discarded on the same write, so letting it decide would reject legitimate
-* writes over a value that never reaches storage, and would never see the value that does.
-*
-*  - a CLIENT-owned (plain `stored`) endpoint → the parsed value, under its role name;
-*  - a COMPUTED-AND-STORED endpoint → undefined, so the pair is not compared at all: the
-*    server produces that value later in the write (a constant included — it is written by
-*    the same pass as a function) and nothing here can know it ahead of time.
-*
-* With every role left to its default filling every endpoint is client-owned, and this is
-* exactly `row[role]` — the comparison, its code and its message are unchanged.
-*/
 function endpointReader(parts, keys) {
 	return (role, stored) => stored?.[keys[role]];
 }
-/** period's own granularity, defaulted like every other config-driven composite —
-*  read the same way by `roles`/`roleZod`/`hints`. */
 function periodGranularity(opts) {
 	return opts.config?.granularity ?? "day";
 }
-/** The endpoint factory at a given granularity — a ported date/datetime FieldDecl. It
-*  takes no key: an endpoint stores under its ROLE name (`from`/`until`), which
-*  `resolveParts` supplies, so there was never a second name to pass here. */
 function periodMkSubDecl(granularity) {
 	return (label) => granularity === "datetime" ? datetime({ label }) : date({
 		label,
 		rules: { granularity: granularity === "month" ? "month" : "day" }
 	});
 }
-/**
-* One endpoint role of a `period`: its default depends on THIS field's own granularity
-* (`mkSubDecl`), so it writes its own `normalize` rather than using `role()`. A CORRECTED
-* filling still keeps the composite's own granularity (`canonical.opts`) — the same
-* `date`/`datetime` config the role's own default carries — with the author's
-* label/required/ui/value layered on top, exactly like `retypeTo`'s default.
-*/
 function periodRole(key, label, mkSubDecl) {
 	const def = {
 		role: key,
@@ -10015,15 +8037,10 @@ function periodRole(key, label, mkSubDecl) {
 	};
 	return def;
 }
-/** Roles of a single `period`: the two date/datetime endpoints, at the type's granularity. */
 function periodRoles(opts) {
 	const mkSubDecl = periodMkSubDecl(periodGranularity(opts));
 	return [periodRole("from", "core.period.from", mkSubDecl), periodRole("until", "core.period.until", mkSubDecl)];
 }
-/** period's per-role default zod: each role unconditionally `.optional()`, at the type's
-*  own granularity (`periodMkSubDecl`) — the schema a role falls back to when the author
-*  did not override it (`partsRowShape`'s own rule: an overridden part is validated by its
-*  OWN zod instead, never this default). */
 function periodRoleZod(opts) {
 	const zod = materialize(periodMkSubDecl(periodGranularity(opts))("")).zod.optional();
 	return {
@@ -10031,9 +8048,6 @@ function periodRoleZod(opts) {
 		until: zod
 	};
 }
-/** period's own ordering check: `from > until` is rejected — the same `endpointReader`
-*  `rangeRefine` uses, comparing the ISO date/datetime strings directly (they sort
-*  lexicographically) instead of `rangeRefine`'s numeric endpoints. */
 function periodRefine(stored, parts) {
 	const endpoint = endpointReader(parts, partValueKeys(parts));
 	const f = endpoint("from", stored);
@@ -10058,39 +8072,20 @@ registerType("period", {
 		granularity: periodGranularity(opts)
 	})
 });
-/**
-* Date/datetime period composite {from, until}; `multiple` → an array of periods stored
-* as a child table.
-*
-* @layer   primitive
-* @prim    period
-* @widget  period
-* @example f.period({ label: 'mod.fields.employment' })
-*/
 function period(raw) {
 	return declare("period", raw);
 }
-/** Keys a file entry may carry. Everything else is rejected — see fileEntryIssue. */
 var FILE_KEYS = /* @__PURE__ */ new Set([
 	"name",
 	"mime",
 	"size"
 ]);
-/** Keys that mean "the author pasted a remote address" — the one mistake worth naming. */
 var FILE_URL_KEYS = [
 	"url",
 	"src",
 	"href",
 	"link"
 ];
-/**
-* A file entry points at a file already uploaded to the server: `{ name }`, where
-* name is the bare filename returned by POST /api/upload. Anything else — a remote
-* URL, an extra key, a path — is refused here, so a record can never hold a
-* reference the server cannot serve. `mime`/`size` are accepted (legacy payloads
-* and the web uploader send them) but the server overwrites them from disk.
-* Returns a vmsg code, or null when the entry is well-formed.
-*/
 function fileEntryIssue(it) {
 	if (typeof it !== "object" || it === null || Array.isArray(it)) return "file_structure";
 	const rec = it;
@@ -10104,11 +8099,6 @@ function fileEntryIssue(it) {
 	if (rec["size"] !== void 0 && typeof rec["size"] !== "number") return "file_structure";
 	return null;
 }
-/**
-* Shared by the whole file family's build(): a scalar {name,...} OR an array
-* [{name,...},...], native or JSON-string, stored as JSON regardless of `multiple` (the
-* renderer's gallery mode draws the single/many difference, not zod).
-*/
 function fileZod() {
 	return unknown().superRefine((raw, ctx) => {
 		if (typeof raw === "string") try {
@@ -10134,10 +8124,6 @@ function fileZod() {
 		}
 	});
 }
-/**
-* Registers one file-family TypeDef: same zod/column/json for all of them, `kind` (and
-* `widget`, always identical to `kind` in this family) is the only thing that varies.
-*/
 function registerFileType(kind) {
 	registerType(kind, {
 		kind,
@@ -10155,123 +8141,41 @@ function registerFileType(kind) {
 	});
 }
 registerFileType("file");
-/**
-* Generic uploaded file reference `{ name }`, pointing at a file already on the server.
-*
-* @layer   primitive
-* @prim    file
-* @widget  file
-* @example f.file({ label: 'mod.fields.attachment' })
-*/
 function file(o) {
 	return declare("file", o);
 }
 registerFileType("document");
-/**
-* Uploaded document reference `{ name }`, rendered as a document widget.
-*
-* @layer   primitive
-* @prim    file
-* @widget  document
-* @example f.document({ label: 'mod.fields.doc' })
-*/
 function document(o) {
 	return declare("document", o);
 }
 registerFileType("audio");
-/**
-* Uploaded audio file reference `{ name }`, rendered as an audio player.
-*
-* @layer   primitive
-* @prim    file
-* @widget  audio
-* @example f.audio({ label: 'mod.fields.recording' })
-*/
 function audio(o) {
 	return declare("audio", o);
 }
 registerFileType("video");
-/**
-* Uploaded video file reference `{ name }`, rendered as a video player.
-*
-* @layer   primitive
-* @prim    file
-* @widget  video
-* @example f.video({ label: 'mod.fields.clip' })
-*/
 function video(o) {
 	return declare("video", o);
 }
 registerFileType("image");
-/**
-* Uploaded image reference `{ name }`, rendered as an inline image.
-*
-* @layer   primitive
-* @prim    file
-* @widget  image
-* @example f.image({ label: 'mod.fields.photo' })
-*/
 function image(o) {
 	return declare("image", o);
 }
 registerFileType("media");
-/**
-* Uploaded media reference `{ name }`, rendered as a generic media widget (mixed
-* image/video).
-*
-* @layer   primitive
-* @prim    file
-* @widget  media
-* @example f.media({ label: 'mod.fields.attachment' })
-*/
 function media(o) {
 	return declare("media", o);
 }
 registerFileType("avatar");
-/**
-* Uploaded image reference `{ name }`, rendered as a circular avatar.
-*
-* @layer   primitive
-* @prim    file
-* @widget  avatar
-* @example f.avatar({ label: 'mod.fields.avatar' })
-*/
 function avatar(o) {
 	return declare("avatar", o);
 }
 registerFileType("cover");
-/**
-* Uploaded image reference `{ name }`, rendered as a wide cover image.
-*
-* @layer   primitive
-* @prim    file
-* @widget  cover
-* @example f.cover({ label: 'mod.fields.cover' })
-*/
 function cover(o) {
 	return declare("cover", o);
 }
 registerFileType("poster");
-/**
-* Like `image` on the backend, but rendered large (portrait 2:3 poster).
-*
-* @layer   primitive
-* @prim    file
-* @widget  poster
-* @example f.poster({ label: 'mod.fields.poster' })
-*/
 function poster(o) {
 	return declare("poster", o);
 }
-/**
-* Sugar over `keyed`: a collection table of {key, value} rows, `key` unique within a
-* record; the value cell's type is set via `fields.value` (default: plain string).
-*
-* @layer   primitive
-* @prim    —
-* @widget  group
-* @example f.keyValue({ label: 'mod.fields.secrets' })
-*/
 function keyValue(raw) {
 	const { fields, ...rest } = raw;
 	const o = normalizeOpts(rest);
@@ -10293,9 +8197,7 @@ function keyValue(raw) {
 		by: "key"
 	});
 }
-/** Roles of a range: the two endpoints, integer or real depending on `isInt`. */
 var RANGE_ROLES = (isInt) => [role("from", ["number"], isInt ? "int" : "real"), role("to", ["number"], isInt ? "int" : "real")];
-/** Shared by numberRange/realRange's `roleZod`: the endpoint schema, int or real per `isInt`. */
 function rangeEndpointZod(isInt, opts) {
 	const cfg = opts.config ?? {};
 	let n = number$1().finite();
@@ -10304,11 +8206,6 @@ function rangeEndpointZod(isInt, opts) {
 	if (cfg.max != null) n = n.max(cfg.max);
 	return n;
 }
-/** Shared by numberRange/realRange's `refine`: `from > to` is rejected. Strip FIRST, then
-*  compare — the check must judge the value the record will actually carry, never the
-*  client's echo of an endpoint the SCHEMA owns (buildComposite strips it before calling
-*  this). Each endpoint is read under the key it occupies in the value object — its role
-*  name, always, now. */
 function rangeRefine(stored, parts) {
 	const endpoint = endpointReader(parts, partValueKeys(parts));
 	const fromV = endpoint("from", stored);
@@ -10340,25 +8237,9 @@ function registerRangeType(kind, isInt) {
 }
 registerRangeType("numberRange", true);
 registerRangeType("realRange", false);
-/**
-* Integer range composite {from, to}; `from > to` is rejected.
-*
-* @layer   primitive
-* @prim    numberRange
-* @widget  numberRange
-* @example f.numberRange({ label: 'mod.fields.ageRange' })
-*/
 function numberRange(o) {
 	return declare("numberRange", o);
 }
-/**
-* Real-number range composite {from, to}; `from > to` is rejected.
-*
-* @layer   primitive
-* @prim    realRange
-* @widget  realRange
-* @example f.realRange({ label: 'mod.fields.priceRange' })
-*/
 function realRange(o) {
 	return declare("realRange", o);
 }
@@ -10393,23 +8274,9 @@ registerType("embed", {
 		};
 	}
 });
-/**
-* External content snapshot by URL — oEmbed/OpenGraph metadata (title, thumbnail,
-* provider, …) captured at save time via /api/embed.
-*
-* @layer   primitive
-* @prim    embed
-* @widget  embed
-* @example f.embed({ label: 'mod.fields.link' })
-*/
 function embed(o) {
 	return declare("embed", o);
 }
-/**
-* Base primitives (storage-aligned) + structural types. Presets (thin wrappers
-* over these primitives) are added below from field-presets.ts and CANNOT override
-* any key from here (guard in composeF).
-*/
 var PRIMITIVES = {
 	string,
 	text,
@@ -10459,7 +8326,6 @@ var PRIMITIVES = {
 	button,
 	backrefs
 };
-/** Assembles `f`, guaranteeing no preset/block shadows a primitive. */
 function composeF(presets, blocks) {
 	for (const k of Object.keys(presets)) if (k in PRIMITIVES) throw new Error(`[f] preset '${k}' overrides a primitive`);
 	for (const k of Object.keys(blocks)) if (k in PRIMITIVES) throw new Error(`[f] block '${k}' overrides a primitive`);
@@ -10500,14 +8366,12 @@ function toClient(field) {
 	};
 }
 //#endregion
-//#region ../sdk/src/settings.ts
+//#region ../sdk/dist/settings.js
 function defineSettings(s) {
 	return materializeDef(s);
 }
 //#endregion
-//#region ../sdk/src/shelf.ts
-/** Flat [storageKey, FieldMeta] pairs of the parent table's columns.
-*  layout group → flattened; embedded group → prefix `key__`; collection → skipped. */
+//#region ../sdk/dist/shelf.js
 function fieldEntries(items) {
 	const out = [];
 	for (const raw of items) {
@@ -10521,38 +8385,12 @@ function fieldEntries(items) {
 	}
 	return out;
 }
-/**
-* Rejects a keyless computed element (`field.x({ value: fn })`, no `key`) anywhere in
-* the tree: at the shelf's own top level, inside a keyless layout group (`f.group`/
-* `f.row`/`f.sheet` without a storage key), AND inside a keyed embedded group or
-* collection row. A keyless computed node never carries a key of its own regardless of what it is
-* nested in, so the enclosing group having a storage key does not give it one — there
-* is still no mechanism that computes and returns such an element: `applyStoredParts`
-* (`@coffer-org/server/part-injection`) only ever writes into a KEYED unit — a
-* top-level field with `fm.compute`, or a composite part, and every composite part now
-* always has a key too (its role name) — so a bare keyless value node has no column to
-* land in either way. Left unrejected, a keyless computed element nested inside a
-* keyed group would silently render blank forever instead of failing loudly at
-* `defineShelf` time — recurse into every group, not only keyless ones.
-*/
 function assertNoKeylessCompute(items, owner) {
 	for (const it of items) {
 		if ("value" in it && typeof it.value === "function") throw new Error(`${owner}: computed element needs a key — the server computes it and needs a name to return it under`);
 		if (hasChildren(it)) assertNoKeylessCompute(it.fields, owner);
 	}
 }
-/**
-* The declaration-time checks that are about a FIELD LIST, not about a shelf: they read
-* `fields` and nothing else, so they are equally true of an extend's fields — an extend
-* stores composites in its own table through the very same write path (`upsertExtendRecord`
-* → `applyStoredParts`) and renders them through the same layout walk.
-*
-* They live in ONE function called by both `defineShelf` and `defineExtend` rather than
-* being copied: `defineExtend` had NEITHER, so a keyless computed element on an extend
-* rendered blank forever instead of throwing, and a mixed-ownership composite on an extend
-* warned about nothing at all. `owner` is the prefix each diagnostic is tagged with
-* (`[shelf] things/item`, `[extend] device_info`), the one thing the two callers differ in.
-*/
 function checkFieldDeclaration(fields, owner) {
 	assertNoKeylessCompute(fields, owner);
 }
@@ -10572,32 +8410,12 @@ function defineShelf(m) {
 	checkFieldDeclaration(built.fields, `[shelf] ${built.library}/${built.shelf}`);
 	return built;
 }
-/**
-* Contract of a real entity:
-*   id — uuid (the ONLY required system field, auto).
-* The rest (including name) are regular fields in ShelfDef.fields.
-* created_at/updated_at — system infrastructure (outside fields, auto-managed).
-*/
-/**
-* Keyed fields of the record itself, in declaration order: top level and plain
-* layout groups. An embedded group or a collection describes a sub-record, so its
-* fields are not candidates for the record's own heading.
-*/
 function ownFieldEntries(items) {
 	const out = [];
 	for (const it of items) if (isNamedField(it)) out.push([it.key, it.type]);
 	else if (hasChildren(it) && !isCollectionGroup(it) && !isEmbeddedGroup(it)) out.push(...ownFieldEntries(it.fields));
 	return out;
 }
-/**
-* Key of the record's title field (lists, relation pickers, inlines, record heading).
-* Priority: views.title → the first keyed kind:'title' field → 'id'.
-*
-* The title is declared, never guessed: a shelf that wants a heading marks the field
-* with field.title(), or names another field through views.title when the heading is
-* not a text field (a date, a computed value). A shelf that declares nothing resolves
-* to 'id' and renders no heading — every field stays in the body with its own label.
-*/
 function titleKey(m) {
 	if (m.views?.title) return m.views.title;
 	const declared = ownFieldEntries(m.fields).find(([, f]) => f.kind === "title");