@object-ui/app-shell 6.2.3 → 7.0.0

package/dist/views/metadata-admin/previews/flow-canvas-parts.js

@@ -0,0 +1,358 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+/**
+ * flow-canvas-parts — presentational building blocks for `FlowCanvas.tsx`:
+ * the per-node-type icon/tone mapping, the node card, and the add-node
+ * palette popover. Kept dependency-free and Shadcn-native (Tailwind + lucide).
+ */
+import * as React from 'react';
+import { Code, CircleDot, CircleStop, Diamond, FilePen, FilePlus, FileSearch, FileX, GitFork, Globe, ListChecks, MonitorSmartphone, Play, Plug, Plus, Repeat, ShieldAlert, TimerReset, UserCheck, Variable, Workflow, Zap, } from 'lucide-react';
+import { cn } from '@object-ui/components';
+import { NODE_W, NODE_H } from './flow-canvas-layout';
+export function nodeIcon(type) {
+    switch (type) {
+        case 'start':
+            return Play;
+        case 'end':
+            return CircleStop;
+        case 'decision':
+        case 'branch':
+        case 'gateway':
+            return Diamond;
+        case 'wait':
+        case 'timer':
+        case 'delay':
+            return TimerReset;
+        case 'boundary_event':
+        case 'signal':
+            return Zap;
+        case 'subflow':
+        case 'flow':
+            return Workflow;
+        case 'create_record':
+            return FilePlus;
+        case 'update_record':
+            return FilePen;
+        case 'delete_record':
+            return FileX;
+        case 'get_record':
+            return FileSearch;
+        case 'http_request':
+        case 'webhook':
+            return Globe;
+        case 'script':
+        case 'script_task':
+            return Code;
+        case 'screen':
+        case 'user_task':
+            return MonitorSmartphone;
+        case 'approval':
+            return UserCheck;
+        case 'connector_action':
+        case 'service_task':
+            return Plug;
+        case 'assignment':
+            return Variable;
+        case 'loop':
+        case 'for_each':
+            return Repeat;
+        case 'map':
+            return ListChecks;
+        case 'parallel_gateway':
+        case 'join_gateway':
+        case 'parallel':
+            return GitFork;
+        case 'try_catch':
+            return ShieldAlert;
+        default:
+            return CircleDot;
+    }
+}
+const TONES = {
+    start: {
+        icon: 'text-emerald-600 dark:text-emerald-400',
+        accent: 'border-l-emerald-500',
+        label: 'text-emerald-600 dark:text-emerald-400',
+        chip: 'bg-emerald-500/10 ring-1 ring-inset ring-emerald-500/20 dark:bg-emerald-400/10',
+    },
+    end: {
+        icon: 'text-rose-600 dark:text-rose-400',
+        accent: 'border-l-rose-500',
+        label: 'text-rose-600 dark:text-rose-400',
+        chip: 'bg-rose-500/10 ring-1 ring-inset ring-rose-500/20 dark:bg-rose-400/10',
+    },
+    decision: {
+        icon: 'text-amber-600 dark:text-amber-400',
+        accent: 'border-l-amber-500',
+        label: 'text-amber-600 dark:text-amber-400',
+        chip: 'bg-amber-500/10 ring-1 ring-inset ring-amber-500/20 dark:bg-amber-400/10',
+    },
+    wait: {
+        icon: 'text-blue-600 dark:text-blue-400',
+        accent: 'border-l-blue-500',
+        label: 'text-blue-600 dark:text-blue-400',
+        chip: 'bg-blue-500/10 ring-1 ring-inset ring-blue-500/20 dark:bg-blue-400/10',
+    },
+    signal: {
+        icon: 'text-violet-600 dark:text-violet-400',
+        accent: 'border-l-violet-500',
+        label: 'text-violet-600 dark:text-violet-400',
+        chip: 'bg-violet-500/10 ring-1 ring-inset ring-violet-500/20 dark:bg-violet-400/10',
+    },
+    subflow: {
+        icon: 'text-indigo-600 dark:text-indigo-400',
+        accent: 'border-l-indigo-500',
+        label: 'text-indigo-600 dark:text-indigo-400',
+        chip: 'bg-indigo-500/10 ring-1 ring-inset ring-indigo-500/20 dark:bg-indigo-400/10',
+    },
+    task: {
+        icon: 'text-slate-500 dark:text-slate-400',
+        accent: 'border-l-slate-400',
+        label: 'text-slate-500 dark:text-slate-400',
+        chip: 'bg-slate-500/10 ring-1 ring-inset ring-slate-500/20 dark:bg-slate-400/10',
+    },
+    record: {
+        icon: 'text-cyan-600 dark:text-cyan-400',
+        accent: 'border-l-cyan-500',
+        label: 'text-cyan-600 dark:text-cyan-400',
+        chip: 'bg-cyan-500/10 ring-1 ring-inset ring-cyan-500/20 dark:bg-cyan-400/10',
+    },
+    integration: {
+        icon: 'text-fuchsia-600 dark:text-fuchsia-400',
+        accent: 'border-l-fuchsia-500',
+        label: 'text-fuchsia-600 dark:text-fuchsia-400',
+        chip: 'bg-fuchsia-500/10 ring-1 ring-inset ring-fuchsia-500/20 dark:bg-fuchsia-400/10',
+    },
+    approval: {
+        icon: 'text-teal-600 dark:text-teal-400',
+        accent: 'border-l-teal-500',
+        label: 'text-teal-600 dark:text-teal-400',
+        chip: 'bg-teal-500/10 ring-1 ring-inset ring-teal-500/20 dark:bg-teal-400/10',
+    },
+    loop: {
+        icon: 'text-sky-600 dark:text-sky-400',
+        accent: 'border-l-sky-500',
+        label: 'text-sky-600 dark:text-sky-400',
+        chip: 'bg-sky-500/10 ring-1 ring-inset ring-sky-500/20 dark:bg-sky-400/10',
+    },
+    screen: {
+        icon: 'text-pink-600 dark:text-pink-400',
+        accent: 'border-l-pink-500',
+        label: 'text-pink-600 dark:text-pink-400',
+        chip: 'bg-pink-500/10 ring-1 ring-inset ring-pink-500/20 dark:bg-pink-400/10',
+    },
+    assignment: {
+        icon: 'text-purple-600 dark:text-purple-400',
+        accent: 'border-l-purple-500',
+        label: 'text-purple-600 dark:text-purple-400',
+        chip: 'bg-purple-500/10 ring-1 ring-inset ring-purple-500/20 dark:bg-purple-400/10',
+    },
+};
+export function nodeTone(type) {
+    switch (type) {
+        case 'start':
+            return TONES.start;
+        case 'end':
+            return TONES.end;
+        case 'decision':
+        case 'branch':
+        case 'gateway':
+        case 'parallel_gateway':
+        case 'join_gateway':
+        case 'parallel':
+            return TONES.decision;
+        case 'wait':
+        case 'timer':
+        case 'delay':
+            return TONES.wait;
+        case 'boundary_event':
+        case 'signal':
+        case 'try_catch':
+            return TONES.signal;
+        case 'subflow':
+        case 'flow':
+            return TONES.subflow;
+        case 'approval':
+            return TONES.approval;
+        case 'loop':
+        case 'for_each':
+        case 'map':
+            return TONES.loop;
+        case 'screen':
+        case 'user_task':
+            return TONES.screen;
+        case 'assignment':
+            return TONES.assignment;
+        case 'create_record':
+        case 'update_record':
+        case 'delete_record':
+        case 'get_record':
+            return TONES.record;
+        case 'http_request':
+        case 'connector_action':
+        case 'script':
+        case 'webhook':
+        case 'service_task':
+        case 'script_task':
+            return TONES.integration;
+        default:
+            return TONES.task;
+    }
+}
+/**
+ * Renders the glyph for a node type. Uses `createElement` (rather than binding
+ * the resolved icon to a capitalized local) so the renderer stays a stable
+ * module-scope component instead of one re-created on every parent render.
+ */
+export function NodeTypeIcon({ type, className }) {
+    return React.createElement(nodeIcon(type), { className, 'aria-hidden': true });
+}
+/** Display order of the palette's category sections. */
+export const NODE_CATEGORY_ORDER = ['Data', 'Logic', 'Human', 'Integration', 'Flow'];
+/**
+ * Category for a node type — drives palette grouping and gives engine-only
+ * (plugin-contributed) types a sensible section. Mirrors the `nodeTone`
+ * families so color and grouping stay consistent.
+ */
+export function nodeCategory(type) {
+    switch (type) {
+        case 'create_record':
+        case 'update_record':
+        case 'delete_record':
+        case 'get_record':
+            return 'Data';
+        case 'decision':
+        case 'branch':
+        case 'gateway':
+        case 'loop':
+        case 'for_each':
+        case 'map':
+        case 'assignment':
+        case 'parallel_gateway':
+        case 'join_gateway':
+        case 'parallel':
+        case 'try_catch':
+            return 'Logic';
+        case 'approval':
+        case 'screen':
+        case 'user_task':
+            return 'Human';
+        case 'http_request':
+        case 'connector_action':
+        case 'script':
+        case 'webhook':
+        case 'service_task':
+        case 'script_task':
+            return 'Integration';
+        default:
+            // subflow, wait, boundary_event, end, and anything unknown → Flow control.
+            return 'Flow';
+    }
+}
+/** Node types offered by the add-node palette (spec `FlowNodeAction`). */
+export const NODE_PALETTE = [
+    { type: 'create_record', label: 'Create record', hint: 'Insert a new record', category: 'Data' },
+    { type: 'update_record', label: 'Update record', hint: 'Modify an existing record', category: 'Data' },
+    { type: 'get_record', label: 'Get record', hint: 'Query records', category: 'Data' },
+    { type: 'delete_record', label: 'Delete record', hint: 'Remove matching records', category: 'Data' },
+    { type: 'decision', label: 'Decision', hint: 'Branch on a condition', category: 'Logic' },
+    { type: 'loop', label: 'Loop', hint: 'Iterate over a collection', category: 'Logic' },
+    { type: 'assignment', label: 'Set variables', hint: 'Assign flow variables', category: 'Logic' },
+    // ADR-0031: authors get the structured constructs (well-formed by
+    // construction); the BPMN `parallel_gateway` / `join_gateway` pair is an
+    // import/export representation only — the engine has no executor for it.
+    { type: 'parallel', label: 'Parallel', hint: 'Run branches concurrently, join at end', category: 'Logic' },
+    { type: 'try_catch', label: 'Try / Catch', hint: 'Protect steps with error handling and retry', category: 'Logic' },
+    { type: 'approval', label: 'Approval', hint: 'Pause for a human decision', category: 'Human' },
+    { type: 'screen', label: 'Screen', hint: 'Collect input from a user', category: 'Human' },
+    { type: 'http_request', label: 'HTTP request', hint: 'Call an external API', category: 'Integration' },
+    { type: 'connector_action', label: 'Connector', hint: 'Run an integration action', category: 'Integration' },
+    { type: 'script', label: 'Script', hint: 'Run custom code', category: 'Integration' },
+    { type: 'subflow', label: 'Subflow', hint: 'Invoke another flow', category: 'Flow' },
+    { type: 'wait', label: 'Wait', hint: 'Pause for an event or timer', category: 'Flow' },
+    { type: 'end', label: 'End', hint: 'Terminate the flow', category: 'Flow' },
+];
+/** Human-friendly default label for a newly created node of `type`. */
+export function defaultNodeLabel(type) {
+    const item = NODE_PALETTE.find((p) => p.type === type);
+    if (item)
+        return item.label;
+    return type
+        .split('_')
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join(' ');
+}
+/**
+ * Spec-valid seed fields for a newly created node, so structured blocks start
+ * in a valid-ish shape (e.g. a wait node already has a timer eventType) rather
+ * than an empty intermediate state. Returns extra node props to spread in.
+ */
+export function defaultNodeExtras(type) {
+    switch (type) {
+        case 'start':
+            return {};
+        case 'wait':
+            return { waitEventConfig: { eventType: 'timer', onTimeout: 'fail' } };
+        case 'connector_action':
+            return { connectorConfig: { connectorId: '', actionId: '', input: {} } };
+        case 'boundary_event':
+            return { boundaryConfig: { attachedToNodeId: '', eventType: 'error', interrupting: true } };
+        case 'approval':
+            // Seed a node-model approval: at least one approver + spec defaults. The
+            // author wires the out-edges with labels `approve` / `reject`.
+            return { config: { approvers: [{ type: 'manager' }], behavior: 'first_response', lockRecord: true } };
+        case 'http_request':
+            return { config: { method: 'GET' } };
+        case 'script':
+            return {};
+        default:
+            return {};
+    }
+}
+/**
+ * A single draggable flow node rendered at an absolute canvas coordinate.
+ * The card body drives selection + reposition; a dedicated bottom "+" handle
+ * (edit mode only) appends a connected child without ambiguity.
+ */
+export function NodeCard({ type, label, summary, position, selected, editable, runState, dimmed, onPointerDown, onSelect, onAppend, }) {
+    const tone = nodeTone(type);
+    return (_jsxs("div", { className: "absolute transition-opacity duration-200", style: { left: position.x, top: position.y, width: NODE_W, height: NODE_H, opacity: dimmed ? 0.35 : 1 }, children: [_jsxs("div", { role: "button", tabIndex: 0, "aria-pressed": selected, onPointerDown: onPointerDown, onClick: (e) => {
+                    e.stopPropagation();
+                    onSelect?.();
+                }, onKeyDown: (e) => {
+                    if (e.key === 'Enter' || e.key === ' ') {
+                        e.preventDefault();
+                        onSelect?.();
+                    }
+                }, className: cn('group flex h-full w-full items-center gap-3 rounded-xl border bg-card px-2.5 py-2 text-left shadow-sm outline-none', 'transition-[transform,box-shadow,border-color] duration-150 ease-out will-change-transform', 'hover:-translate-y-0.5 hover:shadow-lg hover:shadow-foreground/[0.06] focus-visible:ring-2 focus-visible:ring-primary/40', editable ? 'cursor-grab active:cursor-grabbing' : 'cursor-pointer', runState === 'active'
+                    ? 'border-sky-500 shadow-md shadow-sky-500/20 ring-2 ring-sky-400/60'
+                    : runState === 'visited'
+                        ? 'border-emerald-500/70 ring-1 ring-emerald-400/40'
+                        : selected
+                            ? 'border-primary shadow-md ring-2 ring-primary/30'
+                            : 'border-border/80'), children: [_jsx("div", { className: cn('flex h-9 w-9 shrink-0 items-center justify-center rounded-lg transition-transform duration-150 group-hover:scale-105', tone.chip, runState === 'active' && 'animate-pulse'), children: _jsx(NodeTypeIcon, { type: type, className: cn('h-[18px] w-[18px]', tone.icon) }) }), _jsxs("div", { className: "min-w-0 flex-1", children: [_jsx("div", { title: label, className: "truncate text-[13px] font-semibold leading-tight text-foreground", children: label }), _jsxs("div", { className: "mt-1 flex items-baseline gap-1.5 leading-tight", children: [_jsx("span", { className: cn('shrink-0 text-[10px] font-semibold uppercase tracking-[0.08em]', tone.label), children: type }), summary && (_jsx("span", { className: "min-w-0 truncate font-mono text-[10px] text-muted-foreground", title: summary, children: summary }))] })] })] }), editable && type !== 'end' && (_jsx("button", { type: "button", title: "Add connected node", "aria-label": "Add connected node", onPointerDown: (e) => e.stopPropagation(), onClick: (e) => {
+                    e.stopPropagation();
+                    onAppend?.();
+                }, className: cn('absolute left-1/2 -bottom-3 z-10 inline-flex h-6 w-6 -translate-x-1/2 items-center justify-center rounded-full border bg-background text-muted-foreground shadow-sm transition-colors', 'opacity-0 hover:border-primary hover:text-primary group-hover:opacity-100 focus-visible:opacity-100'), children: _jsx(Plus, { className: "h-3.5 w-3.5" }) }))] }));
+}
+/** Compact popover listing the node types an author can add, grouped by category. */
+export function NodePalette({ items = NODE_PALETTE, onPick, onClose }) {
+    // Bucket items by category (falling back to the type's inferred category, so
+    // engine-only / plugin nodes still land in a sensible section), then render
+    // sections in the canonical order. Empty sections are skipped.
+    const grouped = React.useMemo(() => {
+        const buckets = new Map();
+        for (const item of items) {
+            const cat = item.category ?? nodeCategory(item.type);
+            const list = buckets.get(cat) ?? [];
+            list.push(item);
+            buckets.set(cat, list);
+        }
+        return NODE_CATEGORY_ORDER.map((cat) => [cat, buckets.get(cat) ?? []]).filter(([, list]) => list.length > 0);
+    }, [items]);
+    const renderItem = (item) => {
+        const tone = nodeTone(item.type);
+        return (_jsxs("button", { type: "button", onClick: () => onPick(item.type), className: "flex w-full items-center gap-2.5 rounded-lg px-2 py-1.5 text-left transition-colors hover:bg-accent", children: [_jsx("span", { className: cn('flex h-7 w-7 shrink-0 items-center justify-center rounded-md', tone.chip), children: _jsx(NodeTypeIcon, { type: item.type, className: cn('h-[15px] w-[15px]', tone.icon) }) }), _jsxs("div", { className: "min-w-0 flex-1", children: [_jsx("div", { className: "truncate text-[13px] font-medium", children: item.label }), item.hint && _jsx("div", { className: "truncate text-[11px] text-muted-foreground", children: item.hint })] })] }, item.type));
+    };
+    return (_jsxs(_Fragment, { children: [_jsx("div", { className: "fixed inset-0 z-20", onClick: onClose, "aria-hidden": true }), _jsx("div", { className: "absolute right-0 top-full z-30 mt-1.5 max-h-[66vh] w-60 overflow-y-auto rounded-xl border bg-popover/95 p-1.5 shadow-xl shadow-foreground/[0.08] ring-1 ring-black/[0.03] backdrop-blur-md", children: grouped.map(([category, list], gi) => (_jsxs("div", { className: cn(gi > 0 && 'mt-1 border-t border-border/60 pt-1'), children: [_jsx("div", { className: "px-2 pb-1 pt-1 text-[10px] font-semibold uppercase tracking-[0.08em] text-muted-foreground", children: category }), list.map(renderItem)] }, category))) })] }));
+}

package/dist/views/metadata-admin/previews/form-preview.d.ts

@@ -0,0 +1,24 @@
+/**
+ * form-preview — shared classifier for rendering form blocks/views on a design
+ * or preview surface (ViewPreview, the page-designer canvas).
+ *
+ * Overlay form types (`drawer` / `modal`) render their body through a portal as
+ * a modal Sheet/Dialog. On a preview canvas that overlay escapes the layout and
+ * locks the whole editor — Radix sets body `pointer-events:none` and traps focus
+ * while open — which reads as a frozen UI. Preview surfaces neutralise overlay
+ * types to an inline form before handing the schema to SchemaRenderer.
+ *
+ * This is the schema-level layer; `DrawerForm`/`ModalForm` also self-guard via
+ * `PreviewModeProvider` (rendering inline under preview), so a form rendered live
+ * can never lock the page even if a surface forgets to coerce. Keep the single
+ * source of truth here so the two preview surfaces never drift apart.
+ */
+/** Form types that render inline (no portalled overlay). */
+export declare const INLINE_FORM_TYPES: Set<string>;
+/** Form types that render as a portalled, page-locking overlay. */
+export declare const OVERLAY_FORM_TYPES: Set<string>;
+/** True when `t` is a form type that would mount a page-locking overlay. */
+export declare function isOverlayFormType(t: unknown): boolean;
+/** Map any form type to an inline one: overlay types collapse to `simple`,
+ *  inline types pass through, unknown/missing falls back to `simple`. */
+export declare function toInlineFormType(t: unknown): string;

package/dist/views/metadata-admin/previews/form-preview.js

@@ -0,0 +1,29 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+/**
+ * form-preview — shared classifier for rendering form blocks/views on a design
+ * or preview surface (ViewPreview, the page-designer canvas).
+ *
+ * Overlay form types (`drawer` / `modal`) render their body through a portal as
+ * a modal Sheet/Dialog. On a preview canvas that overlay escapes the layout and
+ * locks the whole editor — Radix sets body `pointer-events:none` and traps focus
+ * while open — which reads as a frozen UI. Preview surfaces neutralise overlay
+ * types to an inline form before handing the schema to SchemaRenderer.
+ *
+ * This is the schema-level layer; `DrawerForm`/`ModalForm` also self-guard via
+ * `PreviewModeProvider` (rendering inline under preview), so a form rendered live
+ * can never lock the page even if a surface forgets to coerce. Keep the single
+ * source of truth here so the two preview surfaces never drift apart.
+ */
+/** Form types that render inline (no portalled overlay). */
+export const INLINE_FORM_TYPES = new Set(['simple', 'tabbed', 'wizard', 'split']);
+/** Form types that render as a portalled, page-locking overlay. */
+export const OVERLAY_FORM_TYPES = new Set(['drawer', 'modal']);
+/** True when `t` is a form type that would mount a page-locking overlay. */
+export function isOverlayFormType(t) {
+    return typeof t === 'string' && OVERLAY_FORM_TYPES.has(t);
+}
+/** Map any form type to an inline one: overlay types collapse to `simple`,
+ *  inline types pass through, unknown/missing falls back to `simple`. */
+export function toInlineFormType(t) {
+    return typeof t === 'string' && INLINE_FORM_TYPES.has(t) ? t : 'simple';
+}

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

@@ -15,12 +15,55 @@ import { ReportPreview } from './ReportPreview';
 import { AppPreview } from './AppPreview';
 import { ObjectPreview } from './ObjectPreview';
 import { EmailTemplatePreview } from './EmailTemplatePreview';
+import { FlowPreview } from './FlowPreview';
+import { AgentPreview } from './AgentPreview';
+import { ToolPreview } from './ToolPreview';
+import { PermissionPreview } from './PermissionPreview';
+import { ActionPreview } from './ActionPreview';
+import { JobPreview } from './JobPreview';
+import { TranslationPreview } from './TranslationPreview';
+import { RolePreview } from './RolePreview';
+import { SkillPreview } from './SkillPreview';
+import { DatasourcePreview } from './DatasourcePreview';
+import { ValidationPreview } from './ValidationPreview';
+import { DatasetPreview } from './DatasetPreview';
+import { BookPreview } from './BookPreview';
 export function registerBuiltinPreviews() {
+    // UI surfaces
     registerMetadataPreview('page', PagePreview);
     registerMetadataPreview('view', ViewPreview);
     registerMetadataPreview('dashboard', DashboardPreview);
     registerMetadataPreview('report', ReportPreview);
     registerMetadataPreview('app', AppPreview);
+    registerMetadataPreview('action', ActionPreview);
+    // Data
     registerMetadataPreview('object', ObjectPreview);
+    registerMetadataPreview('datasource', DatasourcePreview);
+    registerMetadataPreview('validation', ValidationPreview);
+    // Analytics (ADR-0021): live cross-object dataset preview.
+    registerMetadataPreview('dataset', DatasetPreview);
+    // System
     registerMetadataPreview('email_template', EmailTemplatePreview);
+    registerMetadataPreview('translation', TranslationPreview);
+    // Documentation navigation spine (ADR-0046 §6): ordered groups with
+    // derived membership over docs.
+    registerMetadataPreview('book', BookPreview);
+    // Automation
+    // Approval is a flow node (`type: 'approval'`) since ADR-0019 — it renders on
+    // the Flow canvas with its `approve` / `reject` branches; no standalone
+    // approval-process preview.
+    registerMetadataPreview('flow', FlowPreview);
+    // ADR-0020: `workflow` retired as a metadata type — record state machines
+    // are now a `state_machine` validation rule (rendered by ValidationPreview)
+    // and side-effecting automation is a Flow. No standalone workflow preview.
+    registerMetadataPreview('job', JobPreview);
+    // AI
+    registerMetadataPreview('agent', AgentPreview);
+    registerMetadataPreview('tool', ToolPreview);
+    registerMetadataPreview('skill', SkillPreview);
+    // Security & Identity
+    // `profile` is a PermissionSet with `isProfile: true` — reuse the same preview.
+    registerMetadataPreview('permission', PermissionPreview);
+    registerMetadataPreview('profile', PermissionPreview);
+    registerMetadataPreview('role', RolePreview);
 }

package/dist/views/metadata-admin/previews/object-fields-bridge.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Bridge between framework metadata `Object.fields` (a record of rich
+ * 48-type field definitions) and the lighter `DesignerFieldDefinition[]`
+ * shape consumed by `@object-ui/plugin-designer`'s `FieldDesigner`.
+ *
+ * Why this exists: the designer ships with a curated subset (27 types,
+ * no `master_detail`, no `tree`, no `multiselect`, etc.). Letting it
+ * own the full draft would silently drop properties on round-trip. So
+ * the bridge:
+ *
+ *  - converts the supported subset for editing,
+ *  - quarantines unknown types into a "preserved" bucket keyed by
+ *    field name, and
+ *  - reassembles the full record on commit, putting preserved entries
+ *    back in their original order/shape so nothing the user can't see
+ *    is destroyed.
+ */
+import type { DesignerFieldDefinition } from '@object-ui/types';
+interface FrameworkFieldDef {
+    type?: string;
+    label?: string;
+    required?: boolean;
+    unique?: boolean;
+    readonly?: boolean;
+    hidden?: boolean;
+    description?: string;
+    default?: unknown;
+    placeholder?: string;
+    options?: Array<{
+        label?: string;
+        value: string;
+        color?: string;
+    }>;
+    reference?: string;
+    formula?: string;
+    group?: string;
+    [k: string]: unknown;
+}
+export interface FieldsBridgeResult {
+    /** Editable subset shaped for FieldDesigner. */
+    designerFields: DesignerFieldDefinition[];
+    /**
+     * Preserves the original framework definitions for fields the
+     * designer can't edit losslessly. Keyed by field name. Round-tripped
+     * verbatim on commit.
+     */
+    preserved: Map<string, FrameworkFieldDef>;
+    /**
+     * Captured input shape (`'record'` or `'array'`) so we commit back
+     * in the same shape we received.
+     */
+    inputShape: 'record' | 'array';
+    /**
+     * Ordered list of all field names as they appeared on input; the
+     * commit function uses it to preserve user-visible ordering.
+     */
+    originalOrder: string[];
+}
+export declare function bridgeFromDraft(fieldsInput: unknown): FieldsBridgeResult;
+/**
+ * Reassemble the framework-shape fields record from designer output.
+ * Preserved fields are spliced back in their original order. Newly
+ * added fields land at the end.
+ */
+export declare function commitToDraft(designerFields: DesignerFieldDefinition[], prev: FieldsBridgeResult): Record<string, FrameworkFieldDef> | FrameworkFieldDef[];
+export {};