@object-ui/app-shell 6.2.3 → 7.0.0

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

@@ -12,24 +12,27 @@
  *   registerMetadataResource({ type: 'view', EditPage: MyViewEditor });
  */
 export { MetadataDirectoryPage } from './DirectoryPage';
+export { PackagesPage } from './PackagesPage';
+export { StudioHomePage } from './StudioHomePage';
 export { MetadataResourceRouter } from './ResourceRouter';
 export { MetadataResourceListPage } from './ResourceListPage';
 export { MetadataResourceEditPage } from './ResourceEditPage';
 export { RelatedPanel } from './RelatedPanel';
 export { MetadataDetailDrawer } from './MetadataDetailDrawer';
 export { MetadataResourceHistoryPage } from './ResourceHistoryPage';
+export { MetadataDiagnosticsPage } from './DiagnosticsPage';
 export { MetadataQuickFind } from './QuickFind';
 export { PageShell as MetadataPageShell } from './PageShell';
 export { SchemaForm } from './SchemaForm';
 export { LayeredDiff } from './LayeredDiff';
 export { PermissionMatrixEditPage } from './PermissionMatrixEditor';
-export { DesignerEditorWrapper, DesignerEditorBody } from './DesignerEditorWrapper';
-export type { DesignerEditorWrapperProps } from './DesignerEditorWrapper';
 export { translateMetadataType, translateMetadataDomain, t as translateMetadataAdmin, detectLocale, } from './i18n';
 export type { SupportedLocale } from './i18n';
 export { registerMetadataResource, getMetadataResource, listMetadataResources, listAnchorsFor, resolveResourceConfig, anchorByField, } from './registry';
 export type { MetadataResourceConfig, MetadataDomain, MetadataAnchor, } from './registry';
 export { registerMetadataPreview, getMetadataPreview, listMetadataPreviewTypes, } from './preview-registry';
-export type { MetadataPreview, MetadataPreviewProps } from './preview-registry';
-export { useMetadataClient, useMetadataTypes, useTypesIndex, matchesQuery, } from './useMetadata';
-export type { RichMetadataTypeEntry } from './useMetadata';
+export type { MetadataPreview, MetadataPreviewProps, MetadataSelection, } from './preview-registry';
+export { registerMetadataInspector, getMetadataInspector, listMetadataInspectorTypes, } from './inspector-registry';
+export type { MetadataInspector, MetadataInspectorProps, } from './inspector-registry';
+export { useMetadataClient, useMetadataTypes, useTypesIndex, useGlobalDiagnostics, matchesQuery, } from './useMetadata';
+export type { RichMetadataTypeEntry, MetadataDiagnosticsEntry, MetadataDiagnosticsSummary, } from './useMetadata';

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

@@ -13,18 +13,20 @@
  *   registerMetadataResource({ type: 'view', EditPage: MyViewEditor });
  */
 export { MetadataDirectoryPage } from './DirectoryPage';
+export { PackagesPage } from './PackagesPage';
+export { StudioHomePage } from './StudioHomePage';
 export { MetadataResourceRouter } from './ResourceRouter';
 export { MetadataResourceListPage } from './ResourceListPage';
 export { MetadataResourceEditPage } from './ResourceEditPage';
 export { RelatedPanel } from './RelatedPanel';
 export { MetadataDetailDrawer } from './MetadataDetailDrawer';
 export { MetadataResourceHistoryPage } from './ResourceHistoryPage';
+export { MetadataDiagnosticsPage } from './DiagnosticsPage';
 export { MetadataQuickFind } from './QuickFind';
 export { PageShell as MetadataPageShell } from './PageShell';
 export { SchemaForm } from './SchemaForm';
 export { LayeredDiff } from './LayeredDiff';
 export { PermissionMatrixEditPage } from './PermissionMatrixEditor';
-export { DesignerEditorWrapper, DesignerEditorBody } from './DesignerEditorWrapper';
 export { translateMetadataType, translateMetadataDomain, t as translateMetadataAdmin, detectLocale, } from './i18n';
 export { registerMetadataResource, getMetadataResource, listMetadataResources, listAnchorsFor, resolveResourceConfig, anchorByField, } from './registry';
 // Side-effect: register the built-in anchor relationships so the Related
@@ -36,10 +38,18 @@ registerBuiltinAnchors();
 // until the framework wires Zod→JSONSchema generation into /meta/types.
 import { registerDefaultMetadataSchemas } from './default-schemas';
 registerDefaultMetadataSchemas();
+import { registerDatasourceResource } from './datasource/register';
+registerDatasourceResource();
 // Side-effect: register built-in Preview-tab renderers (page, view,
 // dashboard, report, app, object, email_template). Plugins can add or
 // override entries via `registerMetadataPreview()`.
 import { registerBuiltinPreviews } from './previews';
 registerBuiltinPreviews();
+// Side-effect: register built-in scoped inspectors (dashboard widget,
+// …). Plugins can add or override entries via
+// `registerMetadataInspector()`.
+import { registerBuiltinInspectors } from './inspectors';
+registerBuiltinInspectors();
 export { registerMetadataPreview, getMetadataPreview, listMetadataPreviewTypes, } from './preview-registry';
-export { useMetadataClient, useMetadataTypes, useTypesIndex, matchesQuery, } from './useMetadata';
+export { registerMetadataInspector, getMetadataInspector, listMetadataInspectorTypes, } from './inspector-registry';
+export { useMetadataClient, useMetadataTypes, useTypesIndex, useGlobalDiagnostics, matchesQuery, } from './useMetadata';

package/dist/views/metadata-admin/inspector-registry.d.ts

@@ -0,0 +1,51 @@
+/**
+ * MetadataInspectorRegistry — per-type "scoped sub-form" renderers.
+ *
+ * The inspector is the right-side property panel of the split editor.
+ * By default, the inspector renders the generic `SchemaForm` bound to
+ * the entire draft. When a type registers an inspector here AND the
+ * preview emits a {@link MetadataSelection}, the host swaps the
+ * generic form for the registered component so the user edits the
+ * *selected sub-element* (e.g. one dashboard widget) instead of the
+ * top-level metadata.
+ *
+ * Clearing the selection (Esc key, click background) drops back to
+ * the generic form automatically.
+ *
+ * Example:
+ *
+ *   registerMetadataInspector('dashboard', DashboardWidgetInspector);
+ *   // → preview emits onSelectionChange({kind:'widget', id:'kpi_1'})
+ *   // → host renders <DashboardWidgetInspector ... /> on the right
+ */
+import type { ComponentType } from 'react';
+import type { MetadataSelection } from './preview-registry';
+import type { SupportedLocale } from './i18n';
+export interface MetadataInspectorProps {
+    /** Metadata type, e.g. 'dashboard'. */
+    type: string;
+    /** Item primary-key name (may be empty in create mode). */
+    name: string;
+    /** Current draft from the editor. Treat as immutable. */
+    draft: Record<string, unknown>;
+    /** The selection emitted by the matching preview. Never null here. */
+    selection: MetadataSelection;
+    /** Apply a shallow patch to the draft. */
+    onPatch: (patch: Record<string, unknown>) => void;
+    /** Clear the selection (returns the inspector to the top-level form). */
+    onClearSelection: () => void;
+    /**
+     * Replace the current selection. Used by reorder buttons to follow
+     * the moved item to its new index, and by other inspector affordances
+     * that need to redirect the focused sub-element.
+     */
+    onSelectionChange?: (next: MetadataSelection | null) => void;
+    /** Whether the host is in edit mode. False → disable inputs. */
+    readOnly: boolean;
+    /** Active UI locale for i18n. */
+    locale: SupportedLocale;
+}
+export type MetadataInspector = ComponentType<MetadataInspectorProps>;
+export declare function registerMetadataInspector(type: string, component: MetadataInspector): void;
+export declare function getMetadataInspector(type: string): MetadataInspector | undefined;
+export declare function listMetadataInspectorTypes(): string[];

package/dist/views/metadata-admin/inspector-registry.js

@@ -0,0 +1,11 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+const REGISTRY = new Map();
+export function registerMetadataInspector(type, component) {
+    REGISTRY.set(type, component);
+}
+export function getMetadataInspector(type) {
+    return REGISTRY.get(type);
+}
+export function listMetadataInspectorTypes() {
+    return Array.from(REGISTRY.keys()).sort();
+}

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

@@ -0,0 +1,30 @@
+/**
+ * ActionDefaultInspector — type-aware authoring panel for an Action.
+ *
+ * Replaces the flat, everything-at-once SchemaForm for `action` with a
+ * progressively-disclosed editor organised around how an action is actually
+ * designed (mirroring Salesforce Quick Actions / ServiceNow UI Actions):
+ *
+ *   1. Basics       — label / name / object scope / icon / variant
+ *   2. Behavior     — type-FIRST, then only the fields that `type` needs
+ *                     (script → body editor; api → method + endpoint;
+ *                      url/flow/modal/form → a single target binding)
+ *   3. Inputs       — the params dialog the user fills before it runs
+ *                     (field-backed picks reuse the object's field metadata)
+ *   4. Placement    — where the button surfaces + object-vs-global scope hint
+ *   5. Feedback     — confirm / success / error / refresh / undo / mode
+ *   6. Conditions   — visible / disabled CEL predicates
+ *   7. AI exposure  — opt-in tool exposure (ADR-0011)
+ *
+ * Rare/advanced props (resultDialog, bodyExtra, recordId mapping, new-tab,
+ * timeout, aria, …) are NOT hand-curated here — they fall through to a
+ * collapsed "More fields" SchemaForm fed the live server schema, with the
+ * curated keys hidden so nothing is double-edited and nothing is lost.
+ *
+ * AI exposure uses the flattened `aiExposed` / `aiDescription` keys (the
+ * objectui/server convention that ActionPreview reads), not the nested `ai`
+ * block, so the curated control and the runtime/preview agree.
+ */
+import * as React from 'react';
+import type { MetadataDefaultInspectorProps } from '../default-inspector-registry';
+export declare function ActionDefaultInspector({ draft, onPatch, readOnly, locale, serverSchema, }: MetadataDefaultInspectorProps): React.JSX.Element;

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

@@ -0,0 +1,180 @@
+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.
+/**
+ * ActionDefaultInspector — type-aware authoring panel for an Action.
+ *
+ * Replaces the flat, everything-at-once SchemaForm for `action` with a
+ * progressively-disclosed editor organised around how an action is actually
+ * designed (mirroring Salesforce Quick Actions / ServiceNow UI Actions):
+ *
+ *   1. Basics       — label / name / object scope / icon / variant
+ *   2. Behavior     — type-FIRST, then only the fields that `type` needs
+ *                     (script → body editor; api → method + endpoint;
+ *                      url/flow/modal/form → a single target binding)
+ *   3. Inputs       — the params dialog the user fills before it runs
+ *                     (field-backed picks reuse the object's field metadata)
+ *   4. Placement    — where the button surfaces + object-vs-global scope hint
+ *   5. Feedback     — confirm / success / error / refresh / undo / mode
+ *   6. Conditions   — visible / disabled CEL predicates
+ *   7. AI exposure  — opt-in tool exposure (ADR-0011)
+ *
+ * Rare/advanced props (resultDialog, bodyExtra, recordId mapping, new-tab,
+ * timeout, aria, …) are NOT hand-curated here — they fall through to a
+ * collapsed "More fields" SchemaForm fed the live server schema, with the
+ * curated keys hidden so nothing is double-edited and nothing is lost.
+ *
+ * AI exposure uses the flattened `aiExposed` / `aiDescription` keys (the
+ * objectui/server convention that ActionPreview reads), not the nested `ai`
+ * block, so the curated control and the runtime/preview agree.
+ */
+import * as React from 'react';
+import { Plus, Trash2 } from 'lucide-react';
+import { Button, Label, Textarea, } from '@object-ui/components';
+import { SchemaForm } from '../SchemaForm';
+import { t } from '../i18n';
+import { InspectorShell, InspectorTextField, InspectorSelectField, InspectorCheckboxField, appendArray, moveArray, spliceArray, } from './_shared';
+import { useObjectOptions } from '../previews/useObjectOptions';
+import { useObjectFields } from '../previews/useObjectFields';
+import { useMetaOptions } from '../previews/useMetaOptions';
+import { ConditionBuilder } from './ConditionBuilder';
+import { IconPickerWidget } from '../widgets';
+/* ─────────────── constants ─────────────── */
+const ACTION_TYPES = [
+    { value: 'script', label: 'Script — run an expression / sandboxed JS' },
+    { value: 'api', label: 'API — call an endpoint' },
+    { value: 'flow', label: 'Flow — invoke a flow' },
+    { value: 'modal', label: 'Modal — open a modal/page' },
+    { value: 'form', label: 'Form — open a FormView' },
+    { value: 'url', label: 'URL — navigate to a link' },
+];
+const VARIANT_OPTS = [
+    { value: 'primary', label: 'Primary' },
+    { value: 'secondary', label: 'Secondary' },
+    { value: 'danger', label: 'Danger' },
+    { value: 'ghost', label: 'Ghost' },
+    { value: 'link', label: 'Link' },
+];
+const COMPONENT_OPTS = [
+    { value: 'action:button', label: 'Button' },
+    { value: 'action:icon', label: 'Icon only' },
+    { value: 'action:menu', label: 'Menu item' },
+    { value: 'action:group', label: 'Button group' },
+];
+const MODE_OPTS = [
+    { value: 'create', label: 'Create' },
+    { value: 'edit', label: 'Edit' },
+    { value: 'delete', label: 'Delete' },
+    { value: 'custom', label: 'Custom' },
+];
+const METHOD_OPTS = [
+    { value: 'POST', label: 'POST' },
+    { value: 'PATCH', label: 'PATCH' },
+    { value: 'PUT', label: 'PUT' },
+    { value: 'DELETE', label: 'DELETE' },
+];
+const BODY_LANG_OPTS = [
+    { value: 'expression', label: 'Expression (L1)' },
+    { value: 'js', label: 'Sandboxed JS (L2)' },
+];
+const PARAM_TYPE_OPTS = [
+    { value: 'text', label: 'Text' },
+    { value: 'textarea', label: 'Long text' },
+    { value: 'number', label: 'Number' },
+    { value: 'boolean', label: 'Checkbox' },
+    { value: 'select', label: 'Select' },
+    { value: 'date', label: 'Date' },
+    { value: 'datetime', label: 'Date/time' },
+    { value: 'lookup', label: 'Lookup' },
+];
+/** Canonical action locations (mirrors spec ACTION_LOCATIONS) with friendly labels. */
+const LOCATIONS = [
+    { value: 'record_header', label: 'Record header' },
+    { value: 'record_more', label: 'Record · more menu' },
+    { value: 'record_section', label: 'Record · section' },
+    { value: 'record_related', label: 'Record · related list' },
+    { value: 'list_toolbar', label: 'List toolbar' },
+    { value: 'list_item', label: 'List · row' },
+    { value: 'global_nav', label: 'Global nav / command palette' },
+];
+/** Per-type binding hints for the single `target` field. */
+const TARGET_FIELD = {
+    url: { label: 'URL', placeholder: 'https://… or /path?x=${param.x}', hint: 'Supports ${param.x} and ${ctx.x} interpolation.' },
+    flow: { label: 'Flow name', placeholder: 'snake_case flow', hint: 'The flow to invoke when clicked.' },
+    modal: { label: 'Modal / page name', placeholder: 'snake_case page', hint: 'The modal or page to open.' },
+    form: { label: 'Form view name', placeholder: 'object.viewKey', hint: 'Opens /console/forms/<name>.' },
+    api: { label: 'API endpoint', placeholder: '/api/v1/…', hint: 'Endpoint called with the request body below.' },
+};
+/** Action types whose `target` names another metadata record — render a picker
+ *  of real names instead of free text (flow → flow, modal → page, form → view). */
+const TARGET_META_TYPE = { flow: 'flow', modal: 'page', form: 'view' };
+/** Target binding: a reference picker for flow/modal/form (names come from the
+ *  matching metadata type), else a free-text input (url/api). An out-of-catalog
+ *  value is preserved as a synthesized option so it is never silently dropped. */
+function ActionTargetField({ type, value, onCommit, cfg, readOnly }) {
+    const metaType = TARGET_META_TYPE[type] ?? null;
+    const { options } = useMetaOptions(metaType);
+    const usePicker = !!metaType && options.length > 0;
+    const opts = usePicker && value && !options.some((o) => o.value === value)
+        ? [{ value, label: `${value} (not found)` }, ...options]
+        : options;
+    return (_jsxs("div", { className: "space-y-1", children: [usePicker ? (_jsx(InspectorSelectField, { label: `${cfg.label} *`, value: value || undefined, options: opts, onCommit: onCommit, disabled: readOnly })) : (_jsx(InspectorTextField, { label: `${cfg.label} *`, value: value, onCommit: onCommit, placeholder: cfg.placeholder, disabled: readOnly, mono: true })), _jsx("div", { className: "text-[11px] text-muted-foreground/70", children: cfg.hint })] }));
+}
+/** Keys this inspector edits with its own controls — hidden from the fallback. */
+const CURATED_FIELDS = [
+    'name', 'label', 'objectName', 'icon', 'variant', 'component',
+    'type', 'target', 'execute', 'body', 'method',
+    'params', 'locations', 'bulkEnabled',
+    'confirmText', 'successMessage', 'errorMessage', 'refreshAfter', 'undoable', 'mode', 'shortcut',
+    'visible', 'disabled', 'aiExposed', 'aiDescription',
+];
+/* ─────────────── small helpers ─────────────── */
+function SectionHeader({ title, hint }) {
+    return (_jsxs("div", { className: "space-y-0.5", children: [_jsx("div", { className: "text-xs font-medium uppercase tracking-wide text-muted-foreground", children: title }), hint && _jsx("div", { className: "text-[11px] text-muted-foreground/70", children: hint })] }));
+}
+function localize(v) {
+    if (v == null)
+        return '';
+    if (typeof v === 'string')
+        return v;
+    if (typeof v === 'object') {
+        const o = v;
+        return o.en ?? o['en-US'] ?? Object.values(o)[0] ?? '';
+    }
+    return String(v);
+}
+/** Object dropdown (falls back to free text when no objects are resolvable). */
+function ObjectPicker({ label, value, onCommit, disabled, hint }) {
+    const { options } = useObjectOptions();
+    return (_jsxs("div", { className: "space-y-1", children: [options.length === 0 ? (_jsx(InspectorTextField, { label: label, value: value ?? '', placeholder: "snake_case object", onCommit: onCommit, disabled: disabled, mono: true })) : (_jsx(InspectorSelectField, { label: label, value: value || undefined, options: [{ value: '', label: '— None (global) —' }, ...options], onCommit: onCommit, disabled: disabled })), hint && _jsx("div", { className: "text-[11px] text-muted-foreground/70", children: hint })] }));
+}
+/** Field dropdown bound to an object (free text when unresolved). */
+function FieldPicker({ label, objectName, value, onCommit, disabled }) {
+    const { fields } = useObjectFields(objectName);
+    const options = React.useMemo(() => fields.filter((f) => !f.hidden).map((f) => ({ value: f.name, label: f.label && f.label !== f.name ? `${f.label} (${f.name})` : f.name })), [fields]);
+    if (!objectName || options.length === 0) {
+        return _jsx(InspectorTextField, { label: label, value: value ?? '', onCommit: onCommit, disabled: disabled, mono: true });
+    }
+    return _jsx(InspectorSelectField, { label: label, value: value || undefined, options: [{ value: '', label: '—' }, ...options], onCommit: onCommit, disabled: disabled });
+}
+/* ─────────────── inspector ─────────────── */
+export function ActionDefaultInspector({ draft, onPatch, readOnly, locale, serverSchema, }) {
+    const tr = React.useCallback((key) => t(key, locale), [locale]);
+    const str = (k) => (typeof draft[k] === 'string' ? draft[k] : '');
+    const type = str('type') || 'script';
+    const objectName = str('objectName');
+    const body = (draft.body && typeof draft.body === 'object' ? draft.body : {});
+    const params = Array.isArray(draft.params) ? draft.params : [];
+    const locations = Array.isArray(draft.locations) ? draft.locations : [];
+    // AI exposure — flattened keys (objectui/server convention, read by ActionPreview).
+    const aiExposed = draft.aiExposed === true;
+    const aiDescription = typeof draft.aiDescription === 'string' ? draft.aiDescription : '';
+    const patchBody = (p) => onPatch({ body: { ...body, ...p } });
+    const patchParam = (i, p) => onPatch({ params: params.map((it, j) => (j === i ? { ...it, ...p } : it)) });
+    const toggleLocation = (loc, on) => {
+        const next = on ? [...new Set([...locations, loc])] : locations.filter((l) => l !== loc);
+        onPatch({ locations: next });
+    };
+    const targetCfg = TARGET_FIELD[type];
+    const fallbackSchema = serverSchema;
+    return (_jsxs(InspectorShell, { kindLabel: tr('engine.inspector.action.kind'), title: String(localize(draft.label) || draft.name || tr('engine.inspector.action.kind')), onClose: () => { }, closeLabel: tr('engine.inspector.action.close'), hideClose: true, children: [_jsx(SectionHeader, { title: "Basics" }), _jsx(InspectorTextField, { label: "Label", value: localize(draft.label), onCommit: (v) => onPatch({ label: v }), placeholder: "Button text shown to users", disabled: readOnly }), _jsx(InspectorTextField, { label: "Name", value: str('name'), onCommit: (v) => onPatch({ name: v }), placeholder: "snake_case identifier", disabled: readOnly, mono: true }), _jsx(ObjectPicker, { label: "Object", value: objectName, onCommit: (v) => onPatch({ objectName: v || undefined }), disabled: readOnly, hint: objectName ? 'Bound action — surfaces in this object’s views per the placement below.' : 'Empty = global action — must be referenced by a page’s quick actions, global nav, a flow, or AI to appear.' }), _jsxs("div", { className: "grid grid-cols-2 gap-2", children: [_jsxs("div", { className: "space-y-1", children: [_jsx(Label, { className: "text-xs text-muted-foreground", children: "Icon" }), _jsx(IconPickerWidget, { schema: { type: 'string' }, value: str('icon'), onChange: (v) => onPatch({ icon: v || undefined }), readOnly: readOnly })] }), _jsx(InspectorSelectField, { label: "Variant", value: str('variant') || undefined, options: VARIANT_OPTS, onCommit: (v) => onPatch({ variant: v }), disabled: readOnly })] }), _jsxs("div", { className: "border-t pt-3 space-y-3", children: [_jsx(SectionHeader, { title: "Behavior", hint: "What happens when the action is triggered." }), _jsx(InspectorSelectField, { label: "Type", value: type, options: ACTION_TYPES, onCommit: (v) => onPatch({ type: v }), disabled: readOnly }), type === 'script' ? (_jsxs(_Fragment, { children: [_jsx(InspectorSelectField, { label: "Script language", value: (typeof body.language === 'string' ? body.language : undefined) || 'expression', options: BODY_LANG_OPTS, onCommit: (v) => patchBody({ language: v }), disabled: readOnly }), _jsxs("div", { className: "space-y-1", children: [_jsx(Label, { className: "text-xs text-muted-foreground", children: "Script body" }), _jsx(Textarea, { value: typeof body.source === 'string' ? body.source : '', onChange: (e) => patchBody({ source: e.target.value }), disabled: readOnly, spellCheck: false, rows: 5, placeholder: '// (input, ctx) => result\nreturn { ok: true }', className: "text-xs font-mono" }), _jsxs("div", { className: "text-[11px] text-muted-foreground/70", children: ["Runs in the sandbox as ", _jsx("code", { children: "(input, ctx) => Promise<output>" }), "."] })] })] })) : (_jsxs(_Fragment, { children: [type === 'api' && (_jsx(InspectorSelectField, { label: "Method", value: str('method') || 'POST', options: METHOD_OPTS, onCommit: (v) => onPatch({ method: v }), disabled: readOnly })), targetCfg && (_jsx(ActionTargetField, { type: type, value: str('target'), onCommit: (v) => onPatch({ target: v }), cfg: targetCfg, readOnly: readOnly }))] }))] }), _jsxs("div", { className: "border-t pt-3 space-y-2", children: [_jsx(SectionHeader, { title: "Inputs", hint: "Collected from the user in a dialog before the action runs." }), params.length === 0 ? (_jsx("p", { className: "rounded-md border border-dashed bg-muted/30 px-3 py-2.5 text-center text-[11px] text-muted-foreground", children: "No inputs \u2014 the action runs immediately on click." })) : (params.map((p, i) => (_jsxs("div", { className: "space-y-2 rounded-md border border-border p-2", children: [_jsxs("div", { className: "flex items-center justify-between", children: [_jsxs("span", { className: "text-[11px] text-muted-foreground", children: ["#", i + 1] }), _jsxs("div", { className: "flex items-center gap-0.5", children: [_jsx(Button, { type: "button", variant: "ghost", size: "icon", className: "h-6 w-6", disabled: readOnly || i === 0, "aria-label": "Move up", onClick: () => onPatch({ params: moveArray(params, i, i - 1) }), children: "\u2191" }), _jsx(Button, { type: "button", variant: "ghost", size: "icon", className: "h-6 w-6", disabled: readOnly || i === params.length - 1, "aria-label": "Move down", onClick: () => onPatch({ params: moveArray(params, i, i + 1) }), children: "\u2193" }), _jsx(Button, { type: "button", variant: "ghost", size: "icon", className: "h-6 w-6", disabled: readOnly, "aria-label": "Remove input", onClick: () => onPatch({ params: spliceArray(params, i, null) }), children: _jsx(Trash2, { className: "h-3.5 w-3.5" }) })] })] }), objectName ? (_jsx(FieldPicker, { label: "Bind to field", objectName: objectName, value: p.field, onCommit: (v) => patchParam(i, { field: v || undefined }), disabled: readOnly })) : null, !p.field && (_jsx(InspectorTextField, { label: "Name", value: p.name ?? '', onCommit: (v) => patchParam(i, { name: v }), placeholder: "request-body key", disabled: readOnly, mono: true })), _jsx(InspectorTextField, { label: "Label", value: localize(p.label), onCommit: (v) => patchParam(i, { label: v }), disabled: readOnly }), !p.field && (_jsx(InspectorSelectField, { label: "Type", value: p.type || undefined, options: PARAM_TYPE_OPTS, onCommit: (v) => patchParam(i, { type: v }), disabled: readOnly })), _jsx(InspectorTextField, { label: "Placeholder", value: p.placeholder ?? '', onCommit: (v) => patchParam(i, { placeholder: v }), disabled: readOnly }), _jsxs("div", { className: "flex flex-wrap gap-x-4 gap-y-1", children: [_jsx(InspectorCheckboxField, { label: "Required", value: !!p.required, onCommit: (v) => patchParam(i, { required: v }), disabled: readOnly }), _jsx(InspectorCheckboxField, { label: "Pre-fill from row", value: !!p.defaultFromRow, onCommit: (v) => patchParam(i, { defaultFromRow: v }), disabled: readOnly })] })] }, i)))), !readOnly && (_jsxs(Button, { type: "button", variant: "outline", size: "sm", onClick: () => onPatch({ params: appendArray(params, {}) }), children: [_jsx(Plus, { className: "mr-1 h-3.5 w-3.5" }), " Add input"] }))] }), _jsxs("div", { className: "border-t pt-3 space-y-2", children: [_jsx(SectionHeader, { title: "Placement", hint: "Where this action surfaces in the UI." }), _jsx("div", { className: "grid grid-cols-1 gap-1", children: LOCATIONS.map((loc) => (_jsx(InspectorCheckboxField, { label: loc.label, value: locations.includes(loc.value), onCommit: (v) => toggleLocation(loc.value, v), disabled: readOnly }, loc.value))) }), _jsx("div", { className: "grid grid-cols-2 gap-2 pt-1", children: _jsx(InspectorSelectField, { label: "Component", value: str('component') || undefined, options: COMPONENT_OPTS, onCommit: (v) => onPatch({ component: v }), disabled: readOnly }) }), _jsx(InspectorCheckboxField, { label: "Bulk \u2014 apply to multiple selected rows", value: !!draft.bulkEnabled, onCommit: (v) => onPatch({ bulkEnabled: v }), disabled: readOnly })] }), _jsxs("div", { className: "border-t pt-3 space-y-2", children: [_jsx(SectionHeader, { title: "Feedback", hint: "Confirmation and post-run messaging." }), _jsx(InspectorTextField, { label: "Confirm prompt", value: localize(draft.confirmText), onCommit: (v) => onPatch({ confirmText: v }), placeholder: "Ask before running (leave blank to skip)", disabled: readOnly }), _jsx(InspectorTextField, { label: "Success message", value: localize(draft.successMessage), onCommit: (v) => onPatch({ successMessage: v }), disabled: readOnly }), _jsx(InspectorTextField, { label: "Error message", value: localize(draft.errorMessage), onCommit: (v) => onPatch({ errorMessage: v }), disabled: readOnly }), _jsxs("div", { className: "grid grid-cols-2 gap-2", children: [_jsx(InspectorSelectField, { label: "Mode", value: str('mode') || undefined, options: MODE_OPTS, onCommit: (v) => onPatch({ mode: v }), disabled: readOnly }), _jsx(InspectorTextField, { label: "Shortcut", value: str('shortcut'), onCommit: (v) => onPatch({ shortcut: v }), placeholder: "e.g. Ctrl+S", disabled: readOnly, mono: true })] }), _jsxs("div", { className: "flex flex-wrap gap-x-4 gap-y-1", children: [_jsx(InspectorCheckboxField, { label: "Refresh view after", value: !!draft.refreshAfter, onCommit: (v) => onPatch({ refreshAfter: v }), disabled: readOnly }), _jsx(InspectorCheckboxField, { label: "Offer undo", value: !!draft.undoable, onCommit: (v) => onPatch({ undoable: v }), disabled: readOnly })] })] }), _jsxs("div", { className: "border-t pt-3 space-y-3", children: [_jsx(SectionHeader, { title: "Conditions", hint: "No-code predicates over the record / user / ctx (compiled to CEL)." }), _jsx(ConditionBuilder, { label: "Visible when", value: typeof draft.visible === 'string' ? draft.visible : '', onCommit: (v) => onPatch({ visible: v || undefined }), objectName: objectName, disabled: readOnly }), _jsx(ConditionBuilder, { label: "Disabled when", value: typeof draft.disabled === 'string' ? draft.disabled : '', onCommit: (v) => onPatch({ disabled: v || undefined }), objectName: objectName, disabled: readOnly })] }), _jsxs("div", { className: "border-t pt-3 space-y-2", children: [_jsx(SectionHeader, { title: "AI exposure", hint: "Opt-in: expose this action to AI agents as a callable tool." }), _jsx(InspectorCheckboxField, { label: "Expose to AI agents", value: aiExposed, onCommit: (v) => onPatch({ aiExposed: v }), disabled: readOnly }), aiExposed ? (_jsxs("div", { className: "space-y-1", children: [_jsx(Label, { className: "text-xs text-muted-foreground", children: "Tool description (required, \u226540 chars)" }), _jsx(Textarea, { value: aiDescription, onChange: (e) => onPatch({ aiDescription: e.target.value }), disabled: readOnly, rows: 3, placeholder: "When and why an agent should call this action\u2026", className: "text-xs" }), aiDescription.length < 40 && (_jsx("div", { className: "text-[11px] text-destructive", children: "A \u226540-character description is required while exposed." }))] })) : null] }), fallbackSchema && (_jsxs("div", { className: "border-t pt-3 space-y-1.5", children: [_jsx(SectionHeader, { title: tr('engine.inspector.moreFields'), hint: "Advanced / rarely-used properties." }), _jsx(SchemaForm, { schema: fallbackSchema, value: draft, hiddenFields: CURATED_FIELDS, readOnly: readOnly, onChange: (next) => onPatch(next) })] }))] }));
+}

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

@@ -0,0 +1,16 @@
+/**
+ * AppNavInspector — scoped editor for the selected app navigation item.
+ *
+ * Apps accept nav under several keys (nav / navigation / tabs / items
+ * / menu). The preview emits selection id as a dotted path
+ * `<rootKey>[i]` for top-level items, `<rootKey>[i].children[j]` for
+ * nested. This inspector walks the same path to read/write.
+ *
+ * For simplicity v1 only edits the leaf node (label / path / icon /
+ * kind). Reparenting and re-ordering happen elsewhere (drag handles,
+ * the top-level SchemaForm).
+ */
+import * as React from 'react';
+import type { MetadataInspectorProps } from '../inspector-registry';
+export declare function AppNavInspector({ selection, draft, onPatch, onClearSelection, onSelectionChange, locale, readOnly }: MetadataInspectorProps): React.JSX.Element;
+export declare const APP_NAV_ROOT_KEYS: string[];

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

@@ -0,0 +1,110 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { t } from '../i18n';
+import { InspectorShell, InspectorReorderButtons, InspectorTextField, InspectorSelectField, InspectorRemoveButton, InspectorEmptyState, spliceArray, moveArray, } from './_shared';
+const ROOT_KEYS = ['nav', 'navigation', 'tabs', 'items', 'menu'];
+const KINDS = ['object', 'page', 'dashboard', 'report', 'link', 'group'];
+/** Parse "nav[0].children[2]" → [{key:'nav', index:0}, {key:'children', index:2}]. */
+function parsePath(id) {
+    const segs = id.split('.');
+    const hops = [];
+    for (const s of segs) {
+        const m = /^([a-zA-Z_]\w*)\[(\d+)\]$/.exec(s);
+        if (!m)
+            return null;
+        hops.push({ key: m[1], index: Number(m[2]) });
+    }
+    return hops.length > 0 ? hops : null;
+}
+function readAt(draft, hops) {
+    let arr = draft[hops[0].key];
+    if (!Array.isArray(arr))
+        return { parent: [], node: null, index: -1 };
+    let node = arr[hops[0].index] ?? null;
+    for (let h = 1; h < hops.length; h++) {
+        if (!node)
+            return { parent: arr, node: null, index: hops[h].index };
+        arr = node[hops[h].key];
+        if (!Array.isArray(arr))
+            return { parent: [], node: null, index: -1 };
+        node = arr[hops[h].index] ?? null;
+    }
+    return { parent: arr, node, index: hops[hops.length - 1].index };
+}
+function writeAt(draft, hops, replacement) {
+    // Walk down cloning, then splice at the leaf.
+    const rootKey = hops[0].key;
+    const root = Array.isArray(draft[rootKey]) ? [...draft[rootKey]] : [];
+    if (hops.length === 1) {
+        return { [rootKey]: spliceArray(root, hops[0].index, replacement) };
+    }
+    // Walk + clone.
+    let arr = root;
+    const stack = [];
+    for (let h = 0; h < hops.length - 1; h++) {
+        const node = { ...(arr[hops[h].index] ?? {}) };
+        stack.push({ arr, index: hops[h].index, node });
+        const nextKey = hops[h + 1].key;
+        const childArr = Array.isArray(node[nextKey]) ? [...node[nextKey]] : [];
+        node[nextKey] = childArr;
+        arr[hops[h].index] = node;
+        arr = childArr;
+    }
+    // Splice at leaf:
+    const leafSpliced = spliceArray(arr, hops[hops.length - 1].index, replacement);
+    // Re-attach.
+    stack[stack.length - 1].node[hops[hops.length - 1].key] = leafSpliced;
+    return { [rootKey]: root };
+}
+/**
+ * Replace the sibling array of the leaf hop with `nextSiblings`.
+ * Mirrors `writeAt`'s clone-down strategy but operates on the
+ * containing array rather than a single index.
+ */
+function writeSiblings(draft, hops, nextSiblings) {
+    const rootKey = hops[0].key;
+    if (hops.length === 1) {
+        return { [rootKey]: nextSiblings };
+    }
+    const root = Array.isArray(draft[rootKey]) ? [...draft[rootKey]] : [];
+    let arr = root;
+    for (let h = 0; h < hops.length - 2; h++) {
+        const node = { ...(arr[hops[h].index] ?? {}) };
+        const nextKey = hops[h + 1].key;
+        const childArr = Array.isArray(node[nextKey]) ? [...node[nextKey]] : [];
+        node[nextKey] = childArr;
+        arr[hops[h].index] = node;
+        arr = childArr;
+    }
+    const parentHop = hops[hops.length - 2];
+    const leafKey = hops[hops.length - 1].key;
+    const parentCopy = { ...(arr[parentHop.index] ?? {}) };
+    parentCopy[leafKey] = nextSiblings;
+    arr[parentHop.index] = parentCopy;
+    return { [rootKey]: root };
+}
+export function AppNavInspector({ selection, draft, onPatch, onClearSelection, onSelectionChange, locale, readOnly }) {
+    const hops = parsePath(selection.id);
+    const { node, parent, index } = hops ? readAt(draft, hops) : { node: null, parent: [], index: -1 };
+    if (!hops || !node) {
+        return (_jsx(InspectorShell, { kindLabel: t('engine.inspector.appNav.kind', locale), title: selection.label ?? selection.id, onClose: onClearSelection, closeLabel: t('engine.inspector.appNav.close', locale), children: _jsx(InspectorEmptyState, { message: selection.id }) }));
+    }
+    const labelOf = node.label ?? node.title ?? node.name ?? node.path ?? selection.id;
+    const path = node.path ?? node.href ?? node.route ?? '';
+    const patch = (updates) => {
+        onPatch(writeAt(draft, hops, { ...node, ...updates }));
+    };
+    const remove = () => {
+        onPatch(writeAt(draft, hops, null));
+        onClearSelection();
+    };
+    const move = (to) => {
+        const next = moveArray(parent, index, to);
+        onPatch(writeSiblings(draft, hops, next));
+        const prefix = hops.slice(0, -1).map((h) => `${h.key}[${h.index}]`).join('.');
+        const leafKey = hops[hops.length - 1].key;
+        const newId = prefix ? `${prefix}.${leafKey}[${to}]` : `${leafKey}[${to}]`;
+        onSelectionChange?.({ kind: 'nav', id: newId, label: String(labelOf) });
+    };
+    return (_jsxs(InspectorShell, { kindLabel: t('engine.inspector.appNav.kind', locale), title: String(labelOf), onClose: onClearSelection, closeLabel: t('engine.inspector.appNav.close', locale), headerActions: _jsx(InspectorReorderButtons, { index: index, total: parent.length, onMove: move, upLabel: t('engine.inspector.reorder.up', locale), downLabel: t('engine.inspector.reorder.down', locale), disabled: readOnly }), footer: _jsx(InspectorRemoveButton, { label: t('engine.inspector.appNav.remove', locale), onClick: remove, disabled: readOnly }), children: [_jsx(InspectorTextField, { label: t('engine.inspector.appNav.label', locale), value: String(node.label ?? node.title ?? node.name ?? ''), onCommit: (v) => patch({ label: v }), disabled: readOnly }), _jsx(InspectorTextField, { label: t('engine.inspector.appNav.path', locale), value: String(path), onCommit: (v) => patch({ path: v }), disabled: readOnly, mono: true }), _jsx(InspectorTextField, { label: t('engine.inspector.appNav.icon', locale), value: String(node.icon ?? ''), onCommit: (v) => patch({ icon: v }), disabled: readOnly }), _jsx(InspectorSelectField, { label: t('engine.inspector.appNav.kindField', locale), value: node.kind, options: KINDS.map((v) => ({ value: v, label: v })), onCommit: (v) => patch({ kind: v }), disabled: readOnly })] }));
+}
+export const APP_NAV_ROOT_KEYS = ROOT_KEYS;

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

@@ -0,0 +1,29 @@
+/**
+ * ConditionBuilder — a no-code editor for a CEL predicate (ServiceNow-style),
+ * compiling rows of [subject][operator][value] joined by AND/OR into a CEL
+ * string emitted via onCommit (empty ⇒ '' ⇒ caller should unset).
+ *
+ * Stateful by design: rows live in local state so an in-progress row (no
+ * subject yet) stays on screen instead of vanishing the moment it compiles to
+ * an empty string. The emitted CEL is recomputed from rows on every edit.
+ *
+ * Safety: on (re)load the builder only adopts an existing expression when it
+ * parses AND round-trips byte-for-byte (whitespace-normalised). Anything it
+ * can't round-trip cleanly opens in a raw expression textarea, so hand-authored
+ * complex CEL is never silently rewritten.
+ */
+import * as React from 'react';
+export declare function ConditionBuilder({ label, value, onCommit, objectName, fields: fieldsProp, disabled }: {
+    label?: string;
+    value: string;
+    onCommit: (cel: string) => void;
+    objectName?: string;
+    /** Pre-fetched field catalog (e.g. from the generic form's widget context);
+     *  when omitted, fields are loaded from `objectName`. */
+    fields?: Array<{
+        name: string;
+        label?: string;
+        hidden?: boolean;
+    }>;
+    disabled?: boolean;
+}): React.JSX.Element;