@object-ui/app-shell 6.2.3 → 7.0.0

package/dist/views/metadata-admin/inspectors/flow-node-config.js

@@ -0,0 +1,461 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+/** Convenience: a `['config', key]`-rooted field (the common case). */
+function cfg(key, label, kind, extra = {}) {
+    return { id: key, path: ['config', key], label, kind, ...extra };
+}
+/** Convenience: a top-level node field at `[block, key]` (spec-structured). */
+function at(block, key, label, kind, extra = {}) {
+    return { id: `${block}.${key}`, path: [block, key], label, kind, ...extra };
+}
+/** Reusable HTTP method options. */
+const HTTP_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'].map((m) => ({ value: m, label: m }));
+/**
+ * Config groups keyed by the spec `FlowNodeAction` type. CRUD/script/http
+ * fields live under `config`; wait/connector/boundary use the spec's
+ * top-level structured blocks.
+ */
+const FLOW_NODE_CONFIG = {
+    // Trigger — the start node IS the flow trigger (spec: `'start' // Trigger`).
+    // The trigger CATEGORY is flow-level (`flow.type`); the start node's `config`
+    // carries the trigger PARAMETERS. Keys match real production metadata:
+    // record-change starts use objectName + criteria; scheduled starts use a cron
+    // `schedule`. All optional and shown together (no category gating) so every
+    // real start node renders without falling back to JSON.
+    start: [
+        cfg('triggerType', 'Trigger', 'select', {
+            help: 'When this flow starts. Record triggers fire on data changes; schedule triggers fire on a cron.',
+            options: [
+                { value: 'record-after-create', label: 'Record created' },
+                { value: 'record-after-update', label: 'Record updated' },
+                { value: 'record-before-update', label: 'Record before update' },
+                { value: 'record-after-delete', label: 'Record deleted' },
+                { value: 'record-change', label: 'Record changed (any)' },
+                { value: 'schedule', label: 'Schedule (cron)' },
+                { value: 'manual', label: 'Manual / autolaunched' },
+                { value: 'webhook', label: 'Webhook / API' },
+                { value: 'event', label: 'Platform event' },
+            ],
+        }),
+        cfg('objectName', 'Object', 'reference', {
+            ref: { kind: 'object' },
+            placeholder: 'crm_lead',
+            help: 'Target object for record / scheduled-scan triggers.',
+        }),
+        cfg('condition', 'Entry condition', 'expression', {
+            placeholder: 'status == "qualifying" && previous.status != "qualifying"',
+            help: 'CEL predicate — the flow runs only when this is true. Leave empty to run on every event.',
+        }),
+        cfg('cron', 'Cron schedule', 'text', {
+            placeholder: '0 7 * * *',
+            help: 'Cron expression for scheduled triggers.',
+            showWhen: { field: 'triggerType', equals: ['schedule'] },
+        }),
+        // Legacy keys — rendered only when present so older metadata never falls
+        // back to raw JSON. Prefer `condition` / `cron` above for new flows.
+        cfg('criteria', 'Entry condition (legacy)', 'expression', {
+            placeholder: 'status == "active"',
+            help: 'Legacy key — prefer "Entry condition" (condition).',
+            showWhen: { field: '__legacy__', equals: [] },
+        }),
+        cfg('schedule', 'Cron schedule (legacy)', 'text', {
+            placeholder: '0 9 * * *',
+            help: 'Legacy key — prefer "Cron schedule" (cron).',
+            showWhen: { field: '__legacy__', equals: [] },
+        }),
+    ],
+    end: [
+        cfg('outcome', 'Outcome', 'text', { placeholder: 'success · failure' }),
+        cfg('outputVariable', 'Output variable', 'text', { placeholder: 'result' }),
+    ],
+    decision: [
+        cfg('conditions', 'Branches', 'objectList', {
+            help: 'Each branch has a label and a CEL expression (spec decision shape). A branch whose expression is "true" is the default/else path.',
+            columns: [
+                { key: 'label', label: 'Label', kind: 'text', placeholder: 'Has deals' },
+                { key: 'expression', label: 'Expression', kind: 'expression', placeholder: 'expiring_deals.length > 0' },
+            ],
+        }),
+        cfg('condition', 'Condition (single)', 'expression', {
+            placeholder: 'amount > 10000',
+            help: 'Legacy single-branch condition (CEL). Prefer Branches above; per-edge conditions also live on the outgoing edges.',
+            showWhen: { field: '__legacy__', equals: [] },
+        }),
+    ],
+    assignment: [
+        cfg('assignments', 'Assignments', 'keyValue', {
+            help: 'Set variables: each key is a variable, each value an expression or literal.',
+        }),
+    ],
+    loop: [
+        cfg('collection', 'Collection', 'expression', { placeholder: '{leadList}', help: 'Expression resolving to the items to iterate.' }),
+        cfg('iteratorVariable', 'Item variable', 'text', { placeholder: 'currentItem' }),
+    ],
+    // Sequential multi-instance (ADR-0037 A2): a per-item subflow, one at a time;
+    // each item may durably pause (e.g. a per-item approval).
+    map: [
+        cfg('collection', 'Collection', 'expression', { placeholder: '{items}', help: 'Expression resolving to the array to process, one item at a time.' }),
+        cfg('flowName', 'Per-item flow', 'reference', { ref: { kind: 'flow' }, placeholder: 'one_task_signoff', help: 'Subflow run for each item — it may pause (e.g. an approval).' }),
+        cfg('iteratorVariable', 'Item variable', 'text', { placeholder: 'item' }),
+        cfg('itemObject', 'Item object', 'reference', { ref: { kind: 'object' }, placeholder: 'showcase_task', help: 'When items are records, the object they belong to (exposes each item as the child’s record).' }),
+        cfg('outputVariable', 'Output variable', 'text', { placeholder: 'results', help: 'Each item’s subflow output, collected in order.' }),
+    ],
+    create_record: [
+        cfg('objectName', 'Object', 'reference', { ref: { kind: 'object' }, placeholder: 'contract' }),
+        cfg('fields', 'Field values', 'keyValue', { help: 'Field values to write on the new record.' }),
+        cfg('outputVariable', 'Output variable', 'text', { placeholder: 'newRecord' }),
+    ],
+    update_record: [
+        cfg('objectName', 'Object', 'reference', { ref: { kind: 'object' }, placeholder: 'contract' }),
+        cfg('filter', 'Filter', 'keyValue', { help: 'Field/value pairs identifying the record(s) to update (e.g. id → {recordId}).' }),
+        cfg('fields', 'Field values', 'keyValue', { help: 'Field values to write.' }),
+    ],
+    delete_record: [
+        cfg('objectName', 'Object', 'reference', { ref: { kind: 'object' }, placeholder: 'contract' }),
+        cfg('filter', 'Filter', 'keyValue', { help: 'Field/value pairs identifying the record(s) to delete.' }),
+    ],
+    get_record: [
+        cfg('objectName', 'Object', 'reference', { ref: { kind: 'object' }, placeholder: 'contract' }),
+        cfg('filter', 'Filter', 'keyValue', { help: 'Field/value pairs to match (e.g. status → active). Operator values like {"$ne": null} are preserved.' }),
+        cfg('limit', 'Limit', 'number', { placeholder: '100' }),
+        cfg('outputVariable', 'Output variable', 'text', { placeholder: 'records' }),
+    ],
+    http_request: [
+        cfg('method', 'Method', 'select', { options: HTTP_METHODS, defaultValue: 'GET' }),
+        cfg('url', 'URL', 'text', { placeholder: 'https://api.example.com/v1/contracts' }),
+        cfg('headers', 'Headers', 'keyValue', { help: 'Request headers (e.g. Authorization, Content-Type).' }),
+        cfg('body', 'Body', 'textarea', { placeholder: '{ "key": "value" }', help: 'Request payload (JSON or expression).' }),
+        cfg('outputVariable', 'Output variable', 'text', { placeholder: 'response' }),
+        { id: 'timeoutMs', path: ['timeoutMs'], label: 'Timeout (ms)', kind: 'number', placeholder: '30000' },
+    ],
+    // Script — overloaded in real metadata. Two observed shapes, discriminated by
+    // `actionType`: notification (actionType: email/sms/... → template/recipients/
+    // variables) and code (no actionType → script/outputVariables). The form adapts
+    // on actionType; unknown values still show the code fields so nothing is lost.
+    script: [
+        cfg('actionType', 'Action type', 'select', {
+            options: [
+                { value: 'code', label: 'Code' },
+                { value: 'email', label: 'Email' },
+                { value: 'sms', label: 'SMS' },
+                { value: 'notification', label: 'Notification' },
+            ],
+            defaultValue: 'code',
+            help: 'How this step runs. Leave as Code for a raw script.',
+        }),
+        cfg('template', 'Template', 'reference', {
+            // Polymorphic: an email step picks from the email-template catalog; sms /
+            // notification have no flat catalog yet, so they degrade to free text.
+            ref: { kindFrom: 'actionType', map: { email: 'email-template' } },
+            placeholder: 'case_escalated',
+            help: 'Message template id.',
+            showWhen: { field: 'actionType', equals: ['email', 'sms', 'notification'] },
+        }),
+        cfg('recipients', 'Recipients', 'stringList', {
+            help: 'One recipient per row (user id, field ref, or address).',
+            showWhen: { field: 'actionType', equals: ['email', 'sms', 'notification'] },
+        }),
+        cfg('variables', 'Template variables', 'keyValue', {
+            help: 'Values injected into the template.',
+            showWhen: { field: 'actionType', equals: ['email', 'sms', 'notification'] },
+        }),
+        cfg('script', 'Code', 'textarea', {
+            placeholder: 'return { ok: true };',
+            help: 'Script body (JS/TS).',
+            showWhen: { field: 'actionType', equals: ['code'] },
+        }),
+        cfg('outputVariables', 'Output variables', 'stringList', {
+            help: 'Names of variables this script writes back.',
+            showWhen: { field: 'actionType', equals: ['code'] },
+        }),
+        { id: 'timeoutMs', path: ['timeoutMs'], label: 'Timeout (ms)', kind: 'number', placeholder: '30000' },
+    ],
+    screen: [
+        cfg('fields', 'Fields', 'objectList', {
+            help: 'Fields presented on this screen.',
+            columns: [
+                { key: 'name', label: 'Name', kind: 'text', placeholder: 'discount' },
+                { key: 'label', label: 'Label', kind: 'text', placeholder: 'Discount %' },
+                { key: 'type', label: 'Type', kind: 'text', placeholder: 'number' },
+                { key: 'required', label: 'Required', kind: 'boolean' },
+                { key: 'visibleWhen', label: 'Visible when', kind: 'expression', placeholder: 'stage == "review"' },
+            ],
+        }),
+    ],
+    // Approval node (ADR-0019). The node opens an approval request on entry,
+    // suspends the run, and resumes down its `approve` / `reject` out-edge once a
+    // decision is recorded. Config mirrors `@objectstack/spec`
+    // ApprovalNodeConfigSchema; entry criteria and on-approve / on-reject actions
+    // are NOT here — they live on the graph (the edge into this node, and the
+    // nodes wired to its `approve` / `reject` out-edges).
+    approval: [
+        cfg('approvers', 'Approvers', 'objectList', {
+            help: 'Who may act on this step. Wire the node’s out-edges with labels "approve" and "reject".',
+            columns: [
+                {
+                    key: 'type',
+                    label: 'Type',
+                    kind: 'select',
+                    options: [
+                        { value: 'user', label: 'User' },
+                        { value: 'role', label: 'Role' },
+                        { value: 'team', label: 'Team' },
+                        { value: 'department', label: 'Department' },
+                        { value: 'manager', label: 'Manager' },
+                        { value: 'field', label: 'Field' },
+                        { value: 'queue', label: 'Queue' },
+                    ],
+                },
+                {
+                    // Polymorphic: the picker follows the row's `type`. `manager` takes no
+                    // value (resolved from the submitter's manager_id) so it stays unmapped
+                    // → free text; unmapped/empty types likewise fall back to free text.
+                    key: 'value',
+                    label: 'Value',
+                    kind: 'reference',
+                    placeholder: 'user id / role / field — per type',
+                    ref: {
+                        kindFrom: 'type',
+                        objectSource: '$trigger',
+                        map: {
+                            user: 'user',
+                            role: 'role',
+                            team: 'team',
+                            department: 'department',
+                            field: 'object-field',
+                            queue: 'queue',
+                        },
+                    },
+                },
+            ],
+        }),
+        cfg('behavior', 'Behavior', 'select', {
+            options: [
+                { value: 'first_response', label: 'First response wins' },
+                { value: 'unanimous', label: 'Unanimous (all approve)' },
+            ],
+            defaultValue: 'first_response',
+            help: 'How multiple approvers combine.',
+        }),
+        cfg('lockRecord', 'Lock record', 'boolean', {
+            help: 'Lock the triggering record from edits while this node is pending.',
+        }),
+        cfg('approvalStatusField', 'Status field', 'reference', {
+            ref: { kind: 'object-field', objectSource: '$trigger' },
+            placeholder: 'approval_status',
+            help: 'Business-object field to mirror request status onto (pending/approved/rejected). Should be readonly.',
+        }),
+        // Per-node SLA escalation (spec ApprovalEscalationSchema, nested under
+        // config.escalation). Sub-fields reveal once escalation is enabled.
+        { id: 'escalation.enabled', path: ['config', 'escalation', 'enabled'], label: 'SLA escalation', kind: 'boolean', defaultValue: 'false', help: 'Escalate when a decision is not recorded within the timeout.' },
+        { id: 'escalation.timeoutHours', path: ['config', 'escalation', 'timeoutHours'], label: 'Timeout (hours)', kind: 'number', placeholder: '24', showWhen: { field: 'escalation.enabled', equals: ['true'] } },
+        {
+            id: 'escalation.action', path: ['config', 'escalation', 'action'], label: 'On timeout', kind: 'select', defaultValue: 'notify',
+            options: [
+                { value: 'notify', label: 'Notify' },
+                { value: 'reassign', label: 'Reassign' },
+                { value: 'auto_approve', label: 'Auto-approve' },
+                { value: 'auto_reject', label: 'Auto-reject' },
+            ],
+            showWhen: { field: 'escalation.enabled', equals: ['true'] },
+        },
+        { id: 'escalation.escalateTo', path: ['config', 'escalation', 'escalateTo'], label: 'Escalate to', kind: 'reference', ref: { kind: 'role' }, placeholder: 'user id / role / manager level', showWhen: { field: 'escalation.enabled', equals: ['true'] } },
+        { id: 'escalation.notifySubmitter', path: ['config', 'escalation', 'notifySubmitter'], label: 'Notify submitter', kind: 'boolean', showWhen: { field: 'escalation.enabled', equals: ['true'] } },
+    ],
+    wait: [
+        at('waitEventConfig', 'eventType', 'Wait for', 'select', {
+            options: [
+                { value: 'timer', label: 'Timer' },
+                { value: 'signal', label: 'Signal' },
+                { value: 'webhook', label: 'Webhook' },
+                { value: 'manual', label: 'Manual' },
+                { value: 'condition', label: 'Condition' },
+            ],
+            defaultValue: 'timer',
+        }),
+        at('waitEventConfig', 'timerDuration', 'Duration', 'text', {
+            placeholder: 'PT1H · P3D',
+            help: 'ISO 8601 duration (e.g. PT1H, P3D).',
+            showWhen: { field: 'waitEventConfig.eventType', equals: ['timer'] },
+        }),
+        at('waitEventConfig', 'signalName', 'Signal name', 'text', {
+            placeholder: 'contract.renewed',
+            showWhen: { field: 'waitEventConfig.eventType', equals: ['signal', 'webhook'] },
+        }),
+        at('waitEventConfig', 'timeoutMs', 'Timeout (ms)', 'number', { placeholder: '3600000' }),
+        at('waitEventConfig', 'onTimeout', 'On timeout', 'select', {
+            options: [
+                { value: 'fail', label: 'Fail' },
+                { value: 'continue', label: 'Continue' },
+            ],
+            defaultValue: 'fail',
+        }),
+    ],
+    subflow: [
+        cfg('flowName', 'Flow', 'reference', { ref: { kind: 'flow' }, placeholder: 'escalation_flow' }),
+        cfg('input', 'Input mapping', 'keyValue', { help: 'Values passed to the subflow\u2019s input variables.' }),
+        cfg('outputVariable', 'Output variable', 'text', { placeholder: 'subResult' }),
+        { id: 'timeoutMs', path: ['timeoutMs'], label: 'Timeout (ms)', kind: 'number', placeholder: '60000' },
+    ],
+    connector_action: [
+        at('connectorConfig', 'connectorId', 'Connector', 'reference', { ref: { kind: 'connector' }, placeholder: 'slack · email · salesforce' }),
+        // actionId is polymorphic on the chosen connector and has no flat catalog
+        // (a deliberate open extension point) — stays free text.
+        at('connectorConfig', 'actionId', 'Action', 'text', { placeholder: 'sendMessage · send' }),
+        at('connectorConfig', 'input', 'Input', 'keyValue', { help: 'Mapped inputs for the connector action.' }),
+        { id: 'timeoutMs', path: ['timeoutMs'], label: 'Timeout (ms)', kind: 'number', placeholder: '30000' },
+    ],
+    // ADR-0031 structured constructs. Their bodies are nested regions
+    // (config.branches / config.try / config.catch) — sub-graphs the flat field
+    // kinds can't model; authors edit them in the JSON source editor. Only the
+    // scalar knobs surface here.
+    parallel: [],
+    try_catch: [
+        cfg('errorVariable', 'Error variable', 'text', {
+            placeholder: '$error',
+            help: 'Variable the caught error is bound to inside the catch region.',
+        }),
+    ],
+    // Legacy BPMN interop pair — kept so imported flows still render an
+    // inspector, but no longer offered by the palette / type picker (the engine
+    // has no executor; ADR-0031 makes them import/export-only).
+    parallel_gateway: [],
+    join_gateway: [],
+    boundary_event: [
+        at('boundaryConfig', 'attachedToNodeId', 'Attached to', 'reference', { ref: { kind: 'node' }, placeholder: 'host node id', help: 'Host node this boundary event monitors.' }),
+        at('boundaryConfig', 'eventType', 'Event type', 'select', {
+            options: [
+                { value: 'error', label: 'Error' },
+                { value: 'timer', label: 'Timer' },
+                { value: 'signal', label: 'Signal' },
+                { value: 'cancel', label: 'Cancel' },
+            ],
+            defaultValue: 'error',
+        }),
+        at('boundaryConfig', 'interrupting', 'Interrupting', 'boolean', { help: 'Cancel the host activity when this event fires.' }),
+        at('boundaryConfig', 'errorCode', 'Error code', 'text', {
+            placeholder: 'TIMEOUT (empty = all)',
+            showWhen: { field: 'boundaryConfig.eventType', equals: ['error'] },
+        }),
+        at('boundaryConfig', 'timerDuration', 'Duration', 'text', {
+            placeholder: 'PT1H',
+            showWhen: { field: 'boundaryConfig.eventType', equals: ['timer'] },
+        }),
+        at('boundaryConfig', 'signalName', 'Signal name', 'text', {
+            placeholder: 'contract.cancelled',
+            showWhen: { field: 'boundaryConfig.eventType', equals: ['signal'] },
+        }),
+    ],
+    /**
+     * Legacy generic "action" group — retained for flows authored before the
+     * spec node types were adopted. Never auto-migrated to a spec type (the old
+     * `action` could mean create/update/query/email/webhook); authors re-pick a
+     * precise type explicitly.
+     */
+    legacy_action: [
+        cfg('action', 'Action', 'text', { placeholder: 'sendEmail · createTask · update · query' }),
+        cfg('objectName', 'Object', 'reference', { ref: { kind: 'object' }, placeholder: 'contract' }),
+        cfg('recordId', 'Record', 'expression', { placeholder: 'record.id' }),
+        cfg('params', 'Parameters', 'keyValue', { help: 'Action inputs. Values auto-typed: 3 \u2192 number, true \u2192 boolean.' }),
+        cfg('fields', 'Field values', 'keyValue'),
+        cfg('outputVariable', 'Output variable', 'text', { placeholder: 'result' }),
+    ],
+};
+/**
+ * Maps legacy / alias designer node types onto a spec config group. The spec
+ * `FlowNodeAction` types resolve to themselves; older designer types resolve to
+ * the closest spec group. Legacy generic `action` resolves to `legacy_action`
+ * (kept deliberately distinct — never silently rewritten to a CRUD type).
+ */
+const TYPE_ALIASES = {
+    action: 'legacy_action',
+    branch: 'decision',
+    gateway: 'decision',
+    condition: 'decision',
+    timer: 'wait',
+    delay: 'wait',
+    flow: 'subflow',
+    invoke: 'subflow',
+    task: 'legacy_action',
+    user_task: 'screen',
+    service_task: 'connector_action',
+    script_task: 'script',
+    notification: 'connector_action',
+    signal: 'boundary_event',
+    webhook: 'connector_action',
+    for_each: 'loop',
+};
+/** Resolve the config fields for a node type (alias-aware). */
+export function fieldsForNodeType(type) {
+    if (!type)
+        return [];
+    const canonical = TYPE_ALIASES[type] ?? type;
+    return FLOW_NODE_CONFIG[canonical] ?? [];
+}
+/** Read the current value at a field's node path. */
+export function getFieldValue(node, field) {
+    let cur = node;
+    for (const seg of field.path) {
+        if (cur && typeof cur === 'object' && !Array.isArray(cur))
+            cur = cur[seg];
+        else
+            return undefined;
+    }
+    return cur;
+}
+/**
+ * The `config` key this field owns, or `undefined` for fields stored outside
+ * `config` (spec-structured blocks, top-level `timeoutMs`). Used by the
+ * inspector to compute "extra" config keys for the optional Advanced block —
+ * only config-rooted fields suppress an Advanced key.
+ */
+export function configKeyOf(field) {
+    // Any config-rooted field claims its first config segment — so nested groups
+    // (e.g. `['config','escalation','enabled']`) all claim `escalation`, keeping
+    // the whole block out of the Advanced editor.
+    return field.path.length >= 2 && field.path[0] === 'config' ? field.path[1] : undefined;
+}
+/**
+ * Whether a field should render. Conditional fields show when their controller
+ * (by `id`) resolves — via stored value, else spec `defaultValue` — to one of
+ * `equals`, OR when the field already holds a stored value (so existing config
+ * is never hidden).
+ */
+export function isFieldVisible(field, node, fields) {
+    if (!field.showWhen)
+        return true;
+    const own = getFieldValue(node, field);
+    if (own !== undefined && own !== null && own !== '')
+        return true;
+    const controller = fields.find((f) => f.id === field.showWhen.field);
+    if (!controller)
+        return false;
+    const raw = getFieldValue(node, controller);
+    const resolved = raw === undefined || raw === null || raw === '' ? controller.defaultValue : raw;
+    // Boolean controllers (e.g. `escalation.enabled`) compare against 'true'/'false'.
+    const value = typeof resolved === 'boolean' ? String(resolved) : resolved;
+    return typeof value === 'string' && field.showWhen.equals.includes(value);
+}
+/** Node types offered in the inspector's type picker (spec `FlowNodeAction`). */
+export const FLOW_NODE_TYPE_OPTIONS = [
+    'start',
+    'create_record',
+    'update_record',
+    'delete_record',
+    'get_record',
+    'decision',
+    'assignment',
+    'loop',
+    'http_request',
+    'script',
+    'screen',
+    'approval',
+    'wait',
+    'subflow',
+    'map',
+    'connector_action',
+    // ADR-0031: structured constructs replace the BPMN gateway/boundary types in
+    // the picker — those remain import/export-only (no engine executor).
+    'parallel',
+    'try_catch',
+    'end',
+];

package/dist/views/metadata-admin/inspectors/index.d.ts

@@ -0,0 +1 @@
+export declare function registerBuiltinInspectors(): void;

package/dist/views/metadata-admin/inspectors/index.js

@@ -0,0 +1,45 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+/**
+ * Registers built-in metadata inspectors. Mirrors `previews/index.ts`.
+ * Imported as a side effect from `metadata-admin/index.ts`.
+ */
+import { registerMetadataInspector } from '../inspector-registry';
+import { registerMetadataDefaultInspector } from '../default-inspector-registry';
+import { DashboardWidgetInspector } from './DashboardWidgetInspector';
+import { DashboardDefaultInspector } from './DashboardDefaultInspector';
+import { FlowInspector } from './FlowInspector';
+import { AppNavInspector } from './AppNavInspector';
+import { ViewInspector, ViewDefaultInspector } from './ViewInspector';
+import { PageBlockInspector } from './PageBlockInspector';
+import { ReportDefaultInspector } from './ReportDefaultInspector';
+import { ObjectFieldInspector } from './ObjectFieldInspector';
+import { ObjectDefaultInspector } from './ObjectDefaultInspector';
+import { DatasetDefaultInspector } from './DatasetDefaultInspector';
+import { ActionDefaultInspector } from './ActionDefaultInspector';
+export function registerBuiltinInspectors() {
+    registerMetadataInspector('dashboard', DashboardWidgetInspector);
+    registerMetadataDefaultInspector('dashboard', DashboardDefaultInspector);
+    // Approval is authored as a flow node (`type: 'approval'`) since ADR-0019 —
+    // edited through FlowInspector, not a standalone step inspector. FlowInspector
+    // routes node vs. edge selections to the right scoped editor.
+    registerMetadataInspector('flow', FlowInspector);
+    // ADR-0020: `workflow` retired as a metadata type — no workflow-action
+    // inspector. State machines live on the object as a `state_machine`
+    // validation rule.
+    registerMetadataInspector('app', AppNavInspector);
+    registerMetadataInspector('view', ViewInspector);
+    registerMetadataDefaultInspector('view', ViewDefaultInspector);
+    registerMetadataInspector('page', PageBlockInspector);
+    // ADR-0021 single-form: a 9.0 report selects dataset measures/dimensions
+    // by NAME (no per-column config document), so there is no scoped column
+    // inspector — the default inspector owns the whole editing surface.
+    registerMetadataDefaultInspector('report', ReportDefaultInspector);
+    registerMetadataInspector('object', ObjectFieldInspector);
+    registerMetadataDefaultInspector('object', ObjectDefaultInspector);
+    // ADR-0021: structured dataset designer (object/include/dimensions/measures).
+    registerMetadataDefaultInspector('dataset', DatasetDefaultInspector);
+    // Type-aware Action authoring (Salesforce/ServiceNow-style): branch the form
+    // by action type, group inputs/placement/feedback/conditions/AI, fall back to
+    // SchemaForm for advanced props.
+    registerMetadataDefaultInspector('action', ActionDefaultInspector);
+}

package/dist/views/metadata-admin/inspectors/json-schema-to-fields.d.ts

@@ -0,0 +1,40 @@
+/**
+ * json-schema-to-fields — adapt an engine-published config JSON Schema into the
+ * inspector's {@link FlowConfigField} model, so the flow designer renders a
+ * node's property form **from the server** rather than a hardcoded client form.
+ *
+ * The automation engine owns each node type's config contract: built-in node
+ * packs and plugins publish an `ActionDescriptor` whose `configSchema` is the
+ * JSON Schema compiled from the executor's Zod (ADR-0018 §configSchema). The
+ * approval plugin (ADR-0019) is the first to publish one. Driving the inspector
+ * from that schema keeps the property form in lock-step with what the running
+ * backend actually validates — when a plugin evolves its config, the designer
+ * updates with no client release.
+ *
+ * We map onto `FlowConfigField[]` (rather than rendering JSON Schema directly)
+ * so the existing, polished field widgets — select, boolean, the `objectList`
+ * repeater (e.g. approvers), the optional Advanced-JSON escape hatch — are
+ * reused unchanged. Anything the mapping can't express (deeply nested objects,
+ * unions) is simply left off the form and remains editable in the Advanced
+ * block, so authors are never locked out.
+ *
+ * Scope mirrors what `z.toJSONSchema` emits for real node configs:
+ *   • string                      → text  (enum → select)
+ *   • number / integer            → number
+ *   • boolean                     → boolean
+ *   • array of string             → stringList
+ *   • array of object             → objectList (columns from item props)
+ *   • object (one level)          → flattened sub-fields under config.<key>.*
+ *                                   (a nested `enabled: boolean` makes the
+ *                                    group's other fields reveal when enabled)
+ */
+import type { FlowConfigField } from './flow-node-config';
+/** "approvalStatusField" → "Approval Status Field"; "approve" → "Approve". */
+export declare function humanizeKey(key: string): string;
+/**
+ * Convert a published config JSON Schema (an object schema) into the inspector's
+ * `FlowConfigField[]`. Property order is preserved. Returns `null` when the
+ * schema is not a usable object schema, so callers fall back to their hardcoded
+ * field group.
+ */
+export declare function jsonSchemaToFlowFields(schema: unknown): FlowConfigField[] | null;