@stonecrop/schema 0.13.14 → 0.14.0

package/dist/src/doctype.d.ts

@@ -116,17 +116,87 @@ export type LinkDeclaration = z.infer<typeof LinkDeclaration>;
  */
 export declare const ActionDefinition: z.ZodObject<{
     label: z.ZodString;
-    handler: z.ZodString;
     requiredFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     allowedStates: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    confirm: z.ZodOptional<z.ZodBoolean>;
-    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    nextState: z.ZodOptional<z.ZodString>;
+    stateless: z.ZodOptional<z.ZodBoolean>;
+    selfTransition: z.ZodOptional<z.ZodBoolean>;
+    clientHandler: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 /**
  * Action definition type inferred from Zod schema
  * @public
  */
 export type ActionDefinition = z.infer<typeof ActionDefinition>;
+/**
+ * Reactive field-validation trigger — advisory, client-side only.
+ *
+ * A Trigger is a docbuilder-authored validator: when any field in `on` is edited, its
+ * `clientHandler` runs (client-side, no rollback) and may flag a field inline to block save
+ * in the UI. It is deliberately a **sibling** to {@link (ActionDefinition:type)}, not a member of it —
+ * a reactive validator is not a user-invoked action, so it lives in the `triggers` map on
+ * {@link (WorkflowMeta:type)} and never appears to action readers (transition/command dropdowns, the FSM graph).
+ *
+ * The two bindings are independent: `on` is the fire-set (which fields' edits run it), while the
+ * `setError(field, msg)` call inside `clientHandler` chooses which field displays the error.
+ * @public
+ */
+export declare const TriggerDefinition: z.ZodObject<{
+    label: z.ZodOptional<z.ZodString>;
+    on: z.ZodArray<z.ZodString>;
+    clientHandler: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Trigger definition type inferred from Zod schema
+ * @public
+ */
+export type TriggerDefinition = z.infer<typeof TriggerDefinition>;
+/**
+ * Whether a workflow action may run from `currentState`.
+ *
+ * Single source of truth for the "is this action available here" rule, shared by
+ * the frontend (`getAvailableTransitions`) and the server-side dispatch guard so
+ * the two can never disagree. Empty or absent `allowedStates` means the action is
+ * available in ALL states — a plain `allowedStates.includes(currentState)` would
+ * wrongly block such actions everywhere.
+ *
+ * @public
+ */
+export declare function isActionAllowedInState(action: {
+    allowedStates?: string[] | null;
+}, currentState: string): boolean;
+/**
+ * DocBuilder graph layout — node positions for the workflow-state graph, keyed by state name.
+ * Pure authoring view-state: persisted in the doctype JSON so an author's manual arrangement
+ * survives reloads, but — exactly like {@link (WorkflowMeta:type)}'s `triggers` — it is client-only
+ * and never mirrored into the runtime GraphQL SDL (see the WorkflowMeta type in the host SDLs, which
+ * expose only `states`/`actions`). The shape mirrors VueFlow's node fields; `position` is the node's
+ * canvas coordinate and `targetPosition`/`sourcePosition` are the handle sides.
+ * @public
+ */
+export declare const WorkflowLayout: z.ZodRecord<z.ZodString, z.ZodObject<{
+    position: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    targetPosition: z.ZodOptional<z.ZodEnum<{
+        left: "left";
+        right: "right";
+        top: "top";
+        bottom: "bottom";
+    }>>;
+    sourcePosition: z.ZodOptional<z.ZodEnum<{
+        left: "left";
+        right: "right";
+        top: "top";
+        bottom: "bottom";
+    }>>;
+}, z.core.$strip>>;
+/**
+ * Workflow layout type inferred from Zod schema
+ * @public
+ */
+export type WorkflowLayout = z.infer<typeof WorkflowLayout>;
 /**
  * Workflow metadata - states and actions for a doctype
  * @public
@@ -135,11 +205,35 @@ export declare const WorkflowMeta: z.ZodObject<{
     states: z.ZodOptional<z.ZodArray<z.ZodString>>;
     actions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         label: z.ZodString;
-        handler: z.ZodString;
         requiredFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
         allowedStates: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        confirm: z.ZodOptional<z.ZodBoolean>;
-        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        nextState: z.ZodOptional<z.ZodString>;
+        stateless: z.ZodOptional<z.ZodBoolean>;
+        selfTransition: z.ZodOptional<z.ZodBoolean>;
+        clientHandler: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    triggers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        label: z.ZodOptional<z.ZodString>;
+        on: z.ZodArray<z.ZodString>;
+        clientHandler: z.ZodString;
+    }, z.core.$strip>>>;
+    layout: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        position: z.ZodOptional<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>;
+        targetPosition: z.ZodOptional<z.ZodEnum<{
+            left: "left";
+            right: "right";
+            top: "top";
+            bottom: "bottom";
+        }>>;
+        sourcePosition: z.ZodOptional<z.ZodEnum<{
+            left: "left";
+            right: "right";
+            top: "top";
+            bottom: "bottom";
+        }>>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 /**
@@ -181,11 +275,35 @@ export declare const DoctypeMeta: z.ZodObject<{
         states: z.ZodOptional<z.ZodArray<z.ZodString>>;
         actions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
             label: z.ZodString;
-            handler: z.ZodString;
             requiredFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
             allowedStates: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            confirm: z.ZodOptional<z.ZodBoolean>;
-            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            nextState: z.ZodOptional<z.ZodString>;
+            stateless: z.ZodOptional<z.ZodBoolean>;
+            selfTransition: z.ZodOptional<z.ZodBoolean>;
+            clientHandler: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        triggers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            label: z.ZodOptional<z.ZodString>;
+            on: z.ZodArray<z.ZodString>;
+            clientHandler: z.ZodString;
+        }, z.core.$strip>>>;
+        layout: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            position: z.ZodOptional<z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$strip>>;
+            targetPosition: z.ZodOptional<z.ZodEnum<{
+                left: "left";
+                right: "right";
+                top: "top";
+                bottom: "bottom";
+            }>>;
+            sourcePosition: z.ZodOptional<z.ZodEnum<{
+                left: "left";
+                right: "right";
+                top: "top";
+                bottom: "bottom";
+            }>>;
         }, z.core.$strip>>>;
     }, z.core.$strip>>;
     inherits: z.ZodOptional<z.ZodString>;

package/dist/src/doctype.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"doctype.d.ts","sourceRoot":"","sources":["../../src/doctype.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"doctype.d.ts","sourceRoot":"","sources":["../../src/doctype.ts"],"names":[],"mappings":"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"}

package/dist/src/doctype.js

@@ -95,21 +95,86 @@ export const ActionDefinition = z
     .object({
     /** Display label for the action */
     label: z.string().min(1),
-    /** Handler function name or path */
-    handler: z.string().min(1),
     /** Fields that must have values before action can execute */
     requiredFields: z.array(z.string()).optional(),
     /** Workflow states where this action is available */
     allowedStates: z.array(z.string()).optional(),
-    /** Whether to show a confirmation dialog */
-    confirm: z.boolean().optional(),
-    /** Additional arguments for the action */
-    args: z.record(z.string(), z.unknown()).optional(),
+    /** The state the record transitions to after this action executes */
+    nextState: z.string().optional(),
+    /** True for stateless command actions with no workflow effect at all (print, email, etc.) */
+    stateless: z.boolean().optional(),
+    /**
+     * True for an internal self-transition: the action runs within the current state without
+     * advancing the workflow (e.g. `save`, which mutates record data but stays put). Scoped by
+     * `allowedStates`, rendered as a self-loop in the graph, and has no `nextState`. Distinct from
+     * `stateless` (which has no workflow presence at all): a self-transition is graph-owned and,
+     * unlike a stateless command, persists record data on dispatch.
+     */
+    selfTransition: z.boolean().optional(),
+    /** JS function body stored as a string; executed client-side via AsyncFunction with injected API surface */
+    clientHandler: z.string().optional(),
 })
     .meta({
     title: 'ActionDefinition',
     description: 'Action definition within a workflow',
 });
+/**
+ * Reactive field-validation trigger — advisory, client-side only.
+ *
+ * A Trigger is a docbuilder-authored validator: when any field in `on` is edited, its
+ * `clientHandler` runs (client-side, no rollback) and may flag a field inline to block save
+ * in the UI. It is deliberately a **sibling** to {@link (ActionDefinition:type)}, not a member of it —
+ * a reactive validator is not a user-invoked action, so it lives in the `triggers` map on
+ * {@link (WorkflowMeta:type)} and never appears to action readers (transition/command dropdowns, the FSM graph).
+ *
+ * The two bindings are independent: `on` is the fire-set (which fields' edits run it), while the
+ * `setError(field, msg)` call inside `clientHandler` chooses which field displays the error.
+ * @public
+ */
+export const TriggerDefinition = z
+    .object({
+    /** Optional display label; the map key is the trigger's identity */
+    label: z.string().optional(),
+    /** Fieldnames whose edits fire this trigger (fires when any listed field changes) */
+    on: z.array(z.string()),
+    /** JS function body stored as a string; run client-side with `{ record, value, setError }`. Advisory. */
+    clientHandler: z.string(),
+})
+    .meta({
+    title: 'TriggerDefinition',
+    description: 'Reactive field-validation trigger — advisory client-side',
+});
+/**
+ * Whether a workflow action may run from `currentState`.
+ *
+ * Single source of truth for the "is this action available here" rule, shared by
+ * the frontend (`getAvailableTransitions`) and the server-side dispatch guard so
+ * the two can never disagree. Empty or absent `allowedStates` means the action is
+ * available in ALL states — a plain `allowedStates.includes(currentState)` would
+ * wrongly block such actions everywhere.
+ *
+ * @public
+ */
+export function isActionAllowedInState(action, currentState) {
+    const allowedStates = action.allowedStates;
+    if (!allowedStates || allowedStates.length === 0)
+        return true;
+    return allowedStates.includes(currentState);
+}
+/**
+ * DocBuilder graph layout — node positions for the workflow-state graph, keyed by state name.
+ * Pure authoring view-state: persisted in the doctype JSON so an author's manual arrangement
+ * survives reloads, but — exactly like {@link (WorkflowMeta:type)}'s `triggers` — it is client-only
+ * and never mirrored into the runtime GraphQL SDL (see the WorkflowMeta type in the host SDLs, which
+ * expose only `states`/`actions`). The shape mirrors VueFlow's node fields; `position` is the node's
+ * canvas coordinate and `targetPosition`/`sourcePosition` are the handle sides.
+ * @public
+ */
+export const WorkflowLayout = z.record(z.string(), z.object({
+    position: z.object({ x: z.number(), y: z.number() }).optional(),
+    targetPosition: z.enum(['left', 'top', 'right', 'bottom']).optional(),
+    sourcePosition: z.enum(['left', 'top', 'right', 'bottom']).optional(),
+}));
 /**
  * Workflow metadata - states and actions for a doctype
  * @public
@@ -120,6 +185,14 @@ export const WorkflowMeta = z
     states: z.array(z.string()).optional(),
     /** Actions available in this workflow */
     actions: z.record(z.string(), ActionDefinition).optional(),
+    /** Reactive field-validation triggers (advisory, client-side), keyed by trigger name */
+    triggers: z.record(z.string(), TriggerDefinition).optional(),
+    /**
+     * DocBuilder node positions keyed by state name — authoring view-state. Persisted here so a
+     * doctype author's manual graph arrangement survives reloads; like `triggers`, it is client-only
+     * and never enters the runtime GraphQL SDL. See {@link (WorkflowLayout:variable)}.
+     */
+    layout: WorkflowLayout.optional(),
 })
     .meta({
     title: 'WorkflowMeta',
@@ -135,7 +208,7 @@ export const DoctypeMeta = z
     name: z.string().min(1),
     /** URL-friendly slug (kebab-case) */
     slug: z.string().min(1).optional(),
-    /** Field definitions (including link fields with fieldtype: 'Link') */
+    /** Field definitions (a link field is one carrying `doctype`) */
     fields: z.array(DoctypeFieldSchema),
     /** Relationship links to other doctypes */
     links: z.record(z.string(), LinkDeclaration).optional(),

package/dist/src/field.d.ts

@@ -5,15 +5,18 @@ import { TableViewConfig } from './table';
 /**
  * Field options - flexible bag for type-specific configuration.
  *
- * Usage by fieldtype:
- * - Link/Doctype: target doctype slug as string ("customer", "sales-order-item")
+ * Usage:
  * - Select: array of choices (["Draft", "Submitted", "Cancelled"])
  * - Decimal: config object (\{ precision: 10, scale: 2 \})
  * - Code: config object (\{ language: "python" \})
  *
+ * Deliberately *not* a bare string: a string once meant "link target", which made the value's
+ * shape encode its meaning. That job belongs to `ValueField.doctype`, leaving this a plain
+ * choices-or-config bag.
+ *
  * @public
  */
-export declare const FieldOptions: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+export declare const FieldOptions: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
 /**
  * Field options type inferred from Zod schema
  * @public
@@ -34,7 +37,8 @@ export declare const FieldValidation: z.ZodObject<{
 export type FieldValidation = z.infer<typeof FieldValidation>;
 /**
  * A field that holds a scalar value, a link to another record, or a select choice.
- * The most common kind of field. `fieldtype` determines the default component and behavior.
+ * The most common kind of field. `component` determines how it renders; the attributes below
+ * carry everything else that is not a rendering concern.
  * @public
  */
 export interface ValueField {
@@ -42,10 +46,29 @@ export interface ValueField {
     kind: 'field';
     /** Unique identifier for this field within its doctype */
     fieldname: string;
-    /** Semantic field type — determines behavior and default rendering component */
-    fieldtype: string;
-    /** Vue component to render this field. Derived from `fieldtype` when absent. */
-    component?: string;
+    /**
+     * Vue component that renders this field — the primary (and only) rendering axis. Required:
+     * there is nothing left to derive it from, and a field without one has nothing to render it.
+     * Any string is valid; naming a custom component is how an app renders a field Stonecrop
+     * ships no widget for. See `CANONICAL_COMPONENTS` for the set Stonecrop provides.
+     */
+    component: string;
+    /** True for the field that identifies the record's primary-key column. */
+    primaryKey?: boolean;
+    /** True for a computed/display field with no backing DB column — excluded from SQL SELECT. */
+    computed?: boolean;
+    /** Editor language for code fields (e.g. `'json'`, `'typescript'`) — the only thing distinguishing
+     *  a JSON editor from a code editor, since both render with `ACodeEditor`. */
+    language?: string;
+    /**
+     * Target doctype slug. Presence is what makes a field a link.
+     *
+     * How it renders is decided by `component`, not by this: `AFormLink` renders an
+     * inline id-picker, while `AForm`/`ATable` expand the target (see `linkRenderMode`). Expansion
+     * metadata — backlink, fetch strategy, authoritative cardinality — lives in the doctype's
+     * `links` map, which is additive and never required for a plain foreign key.
+     */
+    doctype?: string;
     /** Human-readable label */
     label?: string;
     /** CSS width (e.g. `"40ch"`, `"200px"`) */
@@ -56,9 +79,14 @@ export interface ValueField {
     edit?: boolean;
     /** Input mask pattern or serialized function */
     mask?: string;
+    /** Serialized `(value) => string` function for display formatting — distinct from `mask` (input).
+     *  Spreads through `schemaToColumns` to `ColumnSchema.format`; deserialized at render time by
+     *  ATable's `getFormattedValue`. */
+    format?: string;
     /** Per-field interaction mode override */
     mode?: InteractionMode;
-    /** Type-specific options: Link target slug, Select choices, Decimal precision config, etc. */
+    /** Type-specific options: Select choices, Decimal precision config, etc. A link's target is not
+     *  here — it is `doctype`. */
     options?: FieldOptions;
     /** Whether the field is required */
     required?: boolean;
@@ -72,6 +100,14 @@ export interface ValueField {
     validation?: FieldValidation;
     /** Cardinality for Link fields — authoritative value on LinkDeclaration takes precedence */
     cardinality?: 'atMostOne' | 'one' | 'noneOrMany' | 'atLeastOne';
+    /**
+     * Provenance marker — stamped only by the GraphQL converter; absence means hand-authored.
+     * When present, the docbuilder freezes the field's identity set (`fieldname`, `primaryKey`,
+     * `required`, `options`, `cardinality`, `doctype`), since `fieldname` is the GraphQL/column
+     * binding and `doctype` is the FK's target. `component` is deliberately **not** frozen: it
+     * chooses the widget, which is an authoring decision the database has no opinion about.
+     */
+    source?: 'introspected';
 }
 /**
  * A layout container that groups other fields. Resolves to a nested AForm.
@@ -120,6 +156,22 @@ export interface TableField {
  * @public
  */
 export type DoctypeField = ValueField | FieldsetField | TableField;
+/**
+ * Recursively injects the `kind` discriminant into a raw field object and, for fieldsets,
+ * into each of its nested `schema` children — mirroring exactly what Zod's `preprocess`
+ * does at every level of the discriminated union.
+ *
+ * Table `columns` are {@link ColumnSchema} entries, not `DoctypeField`s, so they are left
+ * untouched — the Zod table schema validates them with a plain passthrough and never injects
+ * `kind` there either.
+ *
+ * Needed because `Doctype.fromObject` constructs a Doctype without running Zod, yet the
+ * registry's `resolveFields` gates link and fieldset handling on `field.kind`. Without this,
+ * a JSON-authored link resolves to a flat scalar and a fieldset's children are dropped.
+ *
+ * @public
+ */
+export declare function normalizeFieldKind(field: unknown): unknown;
 /**
  * Zod runtime validation schema for ValueField.
  * @public
@@ -127,8 +179,11 @@ export type DoctypeField = ValueField | FieldsetField | TableField;
 export declare const ValueFieldSchema: z.ZodObject<{
     kind: z.ZodLiteral<"field">;
     fieldname: z.ZodString;
-    fieldtype: z.ZodString;
-    component: z.ZodOptional<z.ZodString>;
+    component: z.ZodString;
+    primaryKey: z.ZodOptional<z.ZodBoolean>;
+    computed: z.ZodOptional<z.ZodBoolean>;
+    language: z.ZodOptional<z.ZodString>;
+    doctype: z.ZodOptional<z.ZodString>;
     label: z.ZodOptional<z.ZodString>;
     width: z.ZodOptional<z.ZodString>;
     align: z.ZodOptional<z.ZodEnum<{
@@ -140,12 +195,13 @@ export declare const ValueFieldSchema: z.ZodObject<{
     }>>;
     edit: z.ZodOptional<z.ZodBoolean>;
     mask: z.ZodOptional<z.ZodString>;
+    format: z.ZodOptional<z.ZodString>;
     mode: z.ZodOptional<z.ZodEnum<{
         edit: "edit";
         read: "read";
         display: "display";
     }>>;
-    options: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+    options: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
     required: z.ZodOptional<z.ZodBoolean>;
     readOnly: z.ZodOptional<z.ZodBoolean>;
     hidden: z.ZodOptional<z.ZodBoolean>;
@@ -160,6 +216,7 @@ export declare const ValueFieldSchema: z.ZodObject<{
         noneOrMany: "noneOrMany";
         atLeastOne: "atLeastOne";
     }>>;
+    source: z.ZodOptional<z.ZodLiteral<"introspected">>;
 }, z.core.$strip>;
 /**
  * Zod runtime validation schema for FieldsetField.

package/dist/src/field.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"field.d.ts","sourceRoot":"","sources":["../../src/field.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"field.d.ts","sourceRoot":"","sources":["../../src/field.ts"],"names":[],"mappings":"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"}

package/dist/src/field.js

@@ -1,20 +1,21 @@
 import { z } from 'zod';
-import { StonecropFieldType } from './fieldtype';
 import { TableViewConfig } from './table';
 /**
  * Field options - flexible bag for type-specific configuration.
  *
- * Usage by fieldtype:
- * - Link/Doctype: target doctype slug as string ("customer", "sales-order-item")
+ * Usage:
  * - Select: array of choices (["Draft", "Submitted", "Cancelled"])
  * - Decimal: config object (\{ precision: 10, scale: 2 \})
  * - Code: config object (\{ language: "python" \})
  *
+ * Deliberately *not* a bare string: a string once meant "link target", which made the value's
+ * shape encode its meaning. That job belongs to `ValueField.doctype`, leaving this a plain
+ * choices-or-config bag.
+ *
  * @public
  */
 export const FieldOptions = z
     .union([
-    z.string(), // Link/Doctype target: "customer"
     z.array(z.string()), // Select choices: ["A", "B", "C"]
     z.record(z.string(), z.unknown()), // Config: \{ precision: 10, scale: 2 \}
 ])
@@ -41,7 +42,8 @@ export const FieldValidation = z
 /**
  * Infers the `kind` discriminant from the structural properties of a raw field
  * object, then injects it if absent. This allows authored JSON to omit `kind`
- * entirely — authors write only `fieldtype`, `schema`, or `columns`.
+ * entirely — a `schema` key means fieldset, `columns` means table, anything else
+ * is a value field.
  *
  * Rules (applied in order):
  *   has `schema`  → fieldset
@@ -49,6 +51,11 @@ export const FieldValidation = z
  *   otherwise     → field (value-holding scalar or link)
  *
  * Objects that already carry `kind` pass through unchanged (backward-compatible).
+ *
+ * Single-node only. Zod applies this at every level of the discriminated union (via the
+ * `z.lazy` in the fieldset schema), so nested fieldset children are normalized during a
+ * parse. Callers that bypass Zod — notably `Doctype.fromObject` — must use the exported
+ * {@link normalizeFieldKind} instead, which replicates that recursion.
  */
 function injectKind(data) {
     if (typeof data !== 'object' || data === null || Array.isArray(data))
@@ -63,18 +70,48 @@ function injectKind(data) {
         return { kind: 'table', ...obj };
     return { kind: 'field', ...obj };
 }
+/**
+ * Recursively injects the `kind` discriminant into a raw field object and, for fieldsets,
+ * into each of its nested `schema` children — mirroring exactly what Zod's `preprocess`
+ * does at every level of the discriminated union.
+ *
+ * Table `columns` are {@link ColumnSchema} entries, not `DoctypeField`s, so they are left
+ * untouched — the Zod table schema validates them with a plain passthrough and never injects
+ * `kind` there either.
+ *
+ * Needed because `Doctype.fromObject` constructs a Doctype without running Zod, yet the
+ * registry's `resolveFields` gates link and fieldset handling on `field.kind`. Without this,
+ * a JSON-authored link resolves to a flat scalar and a fieldset's children are dropped.
+ *
+ * @public
+ */
+export function normalizeFieldKind(field) {
+    const injected = injectKind(field);
+    if (typeof injected !== 'object' || injected === null)
+        return injected;
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- injectKind returns a non-null object for object input; guarded above
+    const obj = injected;
+    if (obj.kind === 'fieldset' && Array.isArray(obj.schema)) {
+        return { ...obj, schema: obj.schema.map(normalizeFieldKind) };
+    }
+    return injected;
+}
 function createDoctypeFieldSchemas() {
     const ValueFieldSchema = z
         .object({
         kind: z.literal('field'),
         fieldname: z.string().min(1),
-        fieldtype: StonecropFieldType,
-        component: z.string().optional(),
+        component: z.string().min(1),
+        primaryKey: z.boolean().optional(),
+        computed: z.boolean().optional(),
+        language: z.string().optional(),
+        doctype: z.string().min(1).optional(),
         label: z.string().optional(),
         width: z.string().optional(),
         align: z.enum(['left', 'center', 'right', 'start', 'end']).optional(),
         edit: z.boolean().optional(),
         mask: z.string().optional(),
+        format: z.string().optional(),
         mode: z.enum(['edit', 'read', 'display']).optional(),
         options: FieldOptions.optional(),
         required: z.boolean().optional(),
@@ -83,6 +120,7 @@ function createDoctypeFieldSchemas() {
         default: z.unknown().optional(),
         validation: FieldValidation.optional(),
         cardinality: z.enum(['atMostOne', 'one', 'noneOrMany', 'atLeastOne']).optional(),
+        source: z.literal('introspected').optional(),
     })
         .meta({ title: 'ValueField' });
     const TableFieldSchema = z

package/dist/src/fieldtype.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fieldtype.d.ts","sourceRoot":"","sources":["../../src/fieldtype.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,6NAsBtB,CAAA;AAEV;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEnE;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,aAG7B,CAAA;AAEF;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,IAAI,gBAAgB,CAEnF;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC7B;;OAEG;IACH,SAAS,EAAE,MAAM,CAAA;IACjB;;OAEG;IACH,SAAS,EAAE,gBAAgB,CAAA;CAC3B;AAED;;;;GAIG;AACH,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,gBAAgB,EAAE,aAAa,CAyC5D,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,gBAAgB,GAAG,MAAM,CAEvE;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE1D"}
+{"version":3,"file":"fieldtype.d.ts","sourceRoot":"","sources":["../../src/fieldtype.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,6NAsBtB,CAAA;AAEV;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEnE;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,aAG7B,CAAA;AAEF;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,IAAI,gBAAgB,CAEnF;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC7B;;OAEG;IACH,SAAS,EAAE,MAAM,CAAA;IACjB;;OAEG;IACH,SAAS,EAAE,gBAAgB,CAAA;CAC3B;AAED;;;;GAIG;AACH,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,gBAAgB,EAAE,aAAa,CA0C5D,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,gBAAgB,GAAG,MAAM,CAEvE;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE1D"}

package/dist/src/fieldtype.js

@@ -53,29 +53,30 @@ export function isBuiltinFieldType(fieldtype) {
 export const TYPE_MAP = {
     // Text
     Data: { component: 'ATextInput', fieldtype: 'Data' },
-    Text: { component: 'ATextInput', fieldtype: 'Text' },
-    // Numeric
+    Text: { component: 'ATextarea', fieldtype: 'Text' },
+    // Numeric — all numeric variants render with ANumericInput; display differences (currency,
+    // precision, unit) are carried by `format`/`mask`, not a distinct component.
     Int: { component: 'ANumericInput', fieldtype: 'Int' },
     Float: { component: 'ANumericInput', fieldtype: 'Float' },
-    Decimal: { component: 'ADecimalInput', fieldtype: 'Decimal' },
+    Decimal: { component: 'ANumericInput', fieldtype: 'Decimal' },
     // Boolean
     Check: { component: 'ACheckbox', fieldtype: 'Check' },
-    // Date/Time
+    // Date/Time — no dedicated Time SFC exists; Time falls back to a plain text input.
     Date: { component: 'ADate', fieldtype: 'Date' },
-    Time: { component: 'ATimeInput', fieldtype: 'Time' },
-    Datetime: { component: 'ADatetimePicker', fieldtype: 'Datetime' },
-    Duration: { component: 'ADurationInput', fieldtype: 'Duration' },
-    DateRange: { component: 'ADateRangePicker', fieldtype: 'DateRange' },
-    // Structured
+    Time: { component: 'ATextInput', fieldtype: 'Time' },
+    Datetime: { component: 'ADateTime', fieldtype: 'Datetime' },
+    Duration: { component: 'ADuration', fieldtype: 'Duration' },
+    DateRange: { component: 'ADateRange', fieldtype: 'DateRange' },
+    // Structured — JSON vs Code is disambiguated by the field's `language`, not the component.
     JSON: { component: 'ACodeEditor', fieldtype: 'JSON' },
     Code: { component: 'ACodeEditor', fieldtype: 'Code' },
     // Relational
-    Link: { component: 'ALink', fieldtype: 'Link' },
+    Link: { component: 'AFormLink', fieldtype: 'Link' },
     // Files
     Attach: { component: 'AFileAttach', fieldtype: 'Attach' },
-    // Specialized
-    Currency: { component: 'ACurrencyInput', fieldtype: 'Currency' },
-    Quantity: { component: 'AQuantityInput', fieldtype: 'Quantity' },
+    // Specialized — Currency/Quantity are numeric with a display format.
+    Currency: { component: 'ANumericInput', fieldtype: 'Currency' },
+    Quantity: { component: 'ANumericInput', fieldtype: 'Quantity' },
     Select: { component: 'ADropdown', fieldtype: 'Select' },
     // Identity — PK fields are typically hidden; no interactive component is needed
     PrimaryKey: { component: 'ATextInput', fieldtype: 'PrimaryKey' },

package/dist/src/index.d.ts

@@ -1,9 +1,10 @@
 export type { InteractionMode } from './mode';
 export { TableViewConfig } from './table';
-export { StonecropFieldType, BUILTIN_FIELD_TYPES, TYPE_MAP, getDefaultComponent, resolveComponent, isBuiltinFieldType, type BuiltinFieldType, type FieldTemplate, } from './fieldtype';
+export { CANONICAL_COMPONENTS, COMPONENT_CATEGORY, COMPONENT_LINK_EXPANSION, componentCategory, componentLinkExpansion, resolveLinkRenderMode, type ComponentCategory, type LinkExpansion, type LinkRenderMode, } from './component-meta';
 export type { DoctypeField, FieldOptions, FieldValidation, FieldsetField, TableField, ValueField } from './field';
-export { DoctypeFieldSchema, FieldsetFieldSchema, TableFieldSchema, ValueFieldSchema } from './field';
-export type { ActionDefinition, Cardinality, CustomFetch, DataClient, DoctypeContext, DoctypeMeta, DoctypeRef, FetchStrategy, GetRecordOptions, GetRecordResult, GetRecordsOptions, LazyFetch, LinkDeclaration, SerializedFunction, SyncFetch, WorkflowMeta, } from './doctype';
+export { DoctypeFieldSchema, FieldsetFieldSchema, normalizeFieldKind, TableFieldSchema, ValueFieldSchema, } from './field';
+export { ActionDefinition, TriggerDefinition, WorkflowLayout, WorkflowMeta, isActionAllowedInState } from './doctype';
+export type { Cardinality, CustomFetch, DataClient, DoctypeContext, DoctypeMeta, DoctypeRef, FetchStrategy, GetRecordOptions, GetRecordResult, GetRecordsOptions, LazyFetch, LinkDeclaration, SerializedFunction, SyncFetch, } from './doctype';
 export { parseDoctype, parseField, validateDoctype, validateField, type ValidationError, type ValidationResult, } from './validation';
 export { buildScalarMap, classifyFieldType, convertGraphQLSchema, defaultIsEntityField, defaultIsEntityType, GQL_SCALAR_MAP, INTERNAL_SCALARS, WELL_KNOWN_SCALARS, type ConvertedGraphQLDoctype, type GraphQLConversionFieldMeta, type GraphQLConversionOptions, type IntrospectionSource, } from './converter';
 export { toSlug, toPascalCase, pascalToSnake, snakeToCamel, camelToSnake, snakeToLabel, camelToLabel } from './naming';