@object-ui/app-shell 6.2.3 → 7.0.0

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

@@ -0,0 +1,169 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+// Map metadata-type name → loader for that type's root Zod schema.
+// Each loader pulls only one spec subpath so we don't drag the whole
+// 2MB schema bundle into the studio bundle.
+//
+// Types still falling through to server-only validation:
+//   - `validation`: not a top-level metadata file; lives inside object. (DataValidationRuleSchema
+//     exists but has empty shape, so it's not useful for client validation.)
+//   - `profile`: spec ships no top-level ProfileSchema (7.1 confirmed).
+//   - `trigger`: no standalone TriggerSchema export at runtime (only
+//     ConnectorTriggerSchema / WebhookEventSchema variants).
+//   - `sharing_rule`: SharingRuleSchema is declared but has empty shape — server-only.
+//   - `translation`: TranslationBundleSchema is z.object({}) — accepts anything; server-only.
+//   - `connector`: ConnectorSchema requires an `id` field that's not in the on-disk
+//     metadata shape — the spec models the runtime connector instance, not the file.
+//     Wiring it would flag every valid connector definition.
+const LOADERS = {
+    // data
+    object: async () => (await import('@objectstack/spec/data')).ObjectSchema,
+    hook: async () => (await import('@objectstack/spec/data')).HookSchema,
+    mapping: async () => (await import('@objectstack/spec/data')).MappingSchema,
+    analytics_cube: async () => (await import('@objectstack/spec/data')).CubeSchema,
+    // ui
+    view: async () => (await import('@objectstack/spec/ui')).ViewSchema,
+    page: async () => (await import('@objectstack/spec/ui')).PageSchema,
+    app: async () => (await import('@objectstack/spec/ui')).AppSchema,
+    dashboard: async () => (await import('@objectstack/spec/ui')).DashboardSchema,
+    report: async () => (await import('@objectstack/spec/ui')).ReportSchema,
+    action: async () => (await import('@objectstack/spec/ui')).ActionSchema,
+    theme: async () => (await import('@objectstack/spec/ui')).ThemeSchema,
+    // automation
+    flow: async () => (await import('@objectstack/spec/automation')).FlowSchema,
+    // `workflow` is no longer a standalone metadata type (ADR-0020) — record
+    // state machines are a `state_machine` validation rule on the object,
+    // validated as part of ObjectSchema; there is no top-level workflow schema.
+    // `approval` is no longer a standalone metadata type — it's a flow node
+    // (`type: 'approval'`, ADR-0019). Its config (ApprovalNodeConfigSchema) is
+    // validated as part of the enclosing flow; there is no top-level schema, so
+    // it falls through to server-side validation.
+    webhook: async () => (await import('@objectstack/spec/automation')).WebhookSchema,
+    // ai
+    agent: async () => (await import('@objectstack/spec/ai')).AgentSchema,
+    tool: async () => (await import('@objectstack/spec/ai')).ToolSchema,
+    skill: async () => (await import('@objectstack/spec/ai')).SkillSchema,
+    // system
+    email_template: async () => (await import('@objectstack/spec/system')).EmailTemplateSchema,
+    job: async () => (await import('@objectstack/spec/system')).JobSchema,
+    // security
+    // NOTE: use PermissionSetSchema from /security, NOT PluginPermissionSchema from /kernel —
+    // the kernel one is the plugin-sandbox permission ({id,resource,actions}), not the
+    // metadata permission set ({name,isProfile,objects,fields}). See
+    // packages/spec/src/kernel/metadata-type-schemas.ts for the canonical mapping.
+    permission: async () => (await import('@objectstack/spec/security')).PermissionSetSchema,
+    profile: async () => (await import('@objectstack/spec/security')).PermissionSetSchema,
+    policy: async () => (await import('@objectstack/spec/security')).PolicySchema,
+    // identity
+    role: async () => (await import('@objectstack/spec/identity')).RoleSchema,
+    // api
+    api: async () => (await import('@objectstack/spec/api')).ApiEndpointSchema,
+};
+// Flow node `type` values the running server accepts but the published
+// `@objectstack/spec` FlowNodeSchema enum predates. The framework HEAD opened
+// FlowNodeSchema.type to a validated string (ADR-0019 P2) and registers these
+// as built-in node descriptors, but that spec change is not yet on npm — so the
+// published closed enum spuriously flags them. We suppress only the enum
+// mismatch on the node's `.type`; every other field is still validated.
+//   - `approval`: durable-pause approval node (ADR-0019).
+//   - `connector_action`: deliberate open extension point for connector-provided
+//     node types — must never be flagged as invalid.
+const FORWARD_COMPAT_FLOW_NODE_TYPES = new Set(['approval', 'connector_action']);
+const FLOW_NODE_TYPE_ISSUE = /^nodes\.(\d+)\.type$/;
+function nodeTypeAt(draft, index) {
+    const nodes = draft?.nodes;
+    if (!Array.isArray(nodes))
+        return undefined;
+    const node = nodes[index];
+    return typeof node?.type === 'string' ? node.type : undefined;
+}
+const SCHEMA_CACHE = new Map();
+async function getSchemaForType(type) {
+    if (SCHEMA_CACHE.has(type))
+        return SCHEMA_CACHE.get(type) ?? null;
+    const loader = LOADERS[type];
+    if (!loader) {
+        SCHEMA_CACHE.set(type, null);
+        return null;
+    }
+    try {
+        const schema = await loader();
+        const value = (schema && typeof schema.safeParse === 'function') ? schema : null;
+        SCHEMA_CACHE.set(type, value);
+        return value;
+    }
+    catch {
+        SCHEMA_CACHE.set(type, null);
+        return null;
+    }
+}
+/**
+ * Returns true if a client-side schema exists for the given metadata
+ * type. Useful for deciding whether to skip the debounce in caller.
+ */
+export function hasClientValidator(type) {
+    return type in LOADERS;
+}
+/**
+ * Run Zod validation for the given metadata draft. Returns `{ok: true,
+ * issues: []}` for types without a registered schema so callers can
+ * fall back to server-side diagnostics without special-casing.
+ */
+export async function validateMetadataDraft(type, draft, 
+/**
+ * The live server JSON schema for this type (from `/meta/types`, i.e.
+ * `RichMetadataTypeEntry.schema`). When provided it ROOT-CURES cross-repo
+ * spec skew: the bundled `@objectstack/spec` may lag the running server, so
+ * we never let the client be STRICTER than the server — a "missing required
+ * field" flagged by the (possibly stale) bundled Zod is suppressed when the
+ * server marks that field optional. The server's own validation on save
+ * stays authoritative. This makes the editor track the live schema without a
+ * per-change shim (cf. `FORWARD_COMPAT_FLOW_NODE_TYPES`).
+ */
+serverSchema) {
+    const schema = await getSchemaForType(type);
+    if (!schema)
+        return { ok: true, issues: [] };
+    const result = schema.safeParse(draft);
+    if (result.success)
+        return { ok: true, issues: [] };
+    let rawIssues = result.error?.issues ?? [];
+    // Cross-repo skew root-cure — drop "missing required field" false positives
+    // for top-level fields the SERVER schema marks optional. Only suppresses when
+    // the field is actually absent in the draft (a present-but-invalid field
+    // still surfaces), so the client can never be stricter than the live server.
+    const serverRequired = Array.isArray(serverSchema?.required)
+        ? new Set(serverSchema.required.map((x) => String(x)))
+        : undefined;
+    if (serverRequired && draft && typeof draft === 'object' && !Array.isArray(draft)) {
+        const d = draft;
+        rawIssues = rawIssues.filter((i) => {
+            const path = i.path ?? [];
+            if (path.length !== 1)
+                return true; // only top-level field issues
+            const field = String(path[0]);
+            const absent = d[field] === undefined || d[field] === null;
+            return !(absent && !serverRequired.has(field));
+        });
+    }
+    // Forward-compat: don't let the published flow schema's closed node-type
+    // enum reject node types the running server supports (see
+    // FORWARD_COMPAT_FLOW_NODE_TYPES). Suppress only the `.type` enum mismatch
+    // for those nodes; all other issues still surface.
+    if (type === 'flow') {
+        rawIssues = rawIssues.filter((i) => {
+            const path = (i.path ?? []).map((seg) => String(seg)).join('.');
+            const match = FLOW_NODE_TYPE_ISSUE.exec(path);
+            if (!match)
+                return true;
+            const nodeType = nodeTypeAt(draft, Number(match[1]));
+            return !(nodeType && FORWARD_COMPAT_FLOW_NODE_TYPES.has(nodeType));
+        });
+    }
+    if (rawIssues.length === 0)
+        return { ok: true, issues: [] };
+    const issues = rawIssues.map((i) => ({
+        path: (i.path ?? []).map((seg) => String(seg)).join('.'),
+        message: i.message,
+    }));
+    return { ok: false, issues };
+}

package/dist/views/metadata-admin/color-variant-field.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Shared color-variant swatch picker.
+ *
+ * Metadata color fields (`colorVariant` on metrics / dashboard widgets, badge
+ * tones, …) are a fixed SEMANTIC palette, not arbitrary hex. A row of colored
+ * swatches is far more scannable than a text dropdown — the admin sees the
+ * actual color, like Linear/Notion label pickers. Reused by the generic
+ * SchemaForm `color-picker` widget and the curated inspectors so every color
+ * field looks and behaves the same.
+ */
+import * as React from 'react';
+export interface ColorVariant {
+    value: string;
+    label: string;
+    css: string;
+}
+/** Canonical semantic palette (mirrors the renderer's colorVariant tokens). */
+export declare const COLOR_VARIANTS: ColorVariant[];
+/** Resolve a token (or hex) to a CSS color; unknown tokens fall back to neutral. */
+export declare function colorVariantCss(value: string | undefined): string;
+export declare function ColorVariantPicker({ value, onChange, disabled, options }: {
+    value: string | undefined;
+    onChange: (v: string) => void;
+    disabled?: boolean;
+    /** Restrict/relabel the choices; defaults to the full canonical palette. */
+    options?: Array<{
+        value: string;
+        label?: string;
+    }>;
+}): React.JSX.Element;

package/dist/views/metadata-admin/color-variant-field.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cn } from '@object-ui/components';
+/** Canonical semantic palette (mirrors the renderer's colorVariant tokens). */
+export const COLOR_VARIANTS = [
+    { value: 'default', label: 'Default', css: '#9ca3af' },
+    { value: 'blue', label: 'Blue', css: '#3b82f6' },
+    { value: 'teal', label: 'Teal', css: '#14b8a6' },
+    { value: 'orange', label: 'Orange', css: '#f97316' },
+    { value: 'purple', label: 'Purple', css: '#a855f7' },
+    { value: 'success', label: 'Success', css: '#22c55e' },
+    { value: 'warning', label: 'Warning', css: '#f59e0b' },
+    { value: 'danger', label: 'Danger', css: '#ef4444' },
+    // common aliases so non-canonical tokens still get a sensible swatch
+    { value: 'green', label: 'Green', css: '#22c55e' },
+    { value: 'red', label: 'Red', css: '#ef4444' },
+    { value: 'amber', label: 'Amber', css: '#f59e0b' },
+];
+const CSS_BY_VALUE = Object.fromEntries(COLOR_VARIANTS.map((c) => [c.value, c.css]));
+/** Resolve a token (or hex) to a CSS color; unknown tokens fall back to neutral. */
+export function colorVariantCss(value) {
+    if (!value)
+        return '#9ca3af';
+    if (/^#([0-9a-f]{3}|[0-9a-f]{6})$/i.test(value))
+        return value;
+    return CSS_BY_VALUE[value] ?? '#9ca3af';
+}
+export function ColorVariantPicker({ value, onChange, disabled, options }) {
+    const opts = options
+        ? options.map((o) => ({ value: o.value, label: o.label ?? o.value, css: colorVariantCss(o.value) }))
+        : COLOR_VARIANTS.slice(0, 8); // canonical 8 (skip aliases in the default row)
+    const current = value ?? 'default';
+    return (_jsx("div", { className: "flex flex-wrap gap-1.5", role: "radiogroup", children: opts.map((o) => {
+            const on = current === o.value;
+            return (_jsx("button", { type: "button", role: "radio", "aria-checked": on, "aria-label": o.label, title: o.label, disabled: disabled, onClick: () => onChange(o.value), className: cn('flex h-7 w-7 items-center justify-center rounded-full border transition-all', on
+                    ? 'border-transparent ring-2 ring-foreground/60 ring-offset-1 ring-offset-background'
+                    : 'border-border hover:scale-110', disabled && 'cursor-not-allowed opacity-50'), children: _jsx("span", { className: "h-4 w-4 rounded-full", style: { backgroundColor: o.css } }) }, o.value));
+        }) }));
+}

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

@@ -0,0 +1,75 @@
+/**
+ * createDerive — declarative live-derivation helpers for the generic
+ * metadata create form.
+ *
+ * The goal is to keep "smart" UX behaviors (auto slug, plural label)
+ * out of bespoke per-type pages. Instead, a small closed set of named
+ * transforms is exposed; types pick which ones they want via the
+ * registry's `createDerive` config.
+ */
+import type { CreateDeriveRule } from './registry';
+/**
+ * Convert a human label into a snake_case identifier.
+ *
+ * Strategy: NFKD-normalise, lowercase, replace runs of non-alphanum
+ * with `_`, trim, strip leading digit, clamp to 64 chars.
+ *
+ * Non-Latin scripts (CJK, Arabic, …) leave the result empty — the
+ * caller surface is expected to detect that and prompt the user to
+ * enter `name` manually rather than silently writing garbage.
+ */
+export declare function slugify(input: string): string;
+/**
+ * Naive English pluraliser. Handles -y → -ies, sibilants → -es, else
+ * appends -s. Returns input unchanged when it contains no ASCII
+ * letters (CJK passes through).
+ */
+export declare function naivePlural(input: string): string;
+/**
+ * snake_case / kebab-case → "Title Case".
+ */
+export declare function titlecase(input: string): string;
+/**
+ * Take everything up to the first space / underscore / dash.
+ */
+export declare function firstToken(input: string): string;
+export declare function applyTransform(transform: CreateDeriveRule['transform'], value: unknown): string;
+export interface UseCreateDeriveArgs<T extends Record<string, unknown>> {
+    /** Rules from `MetadataResourceConfig.createDerive` (may be undefined). */
+    rules: readonly CreateDeriveRule[] | undefined;
+    /** Current draft object. */
+    draft: T;
+    /** Setter — receives a partial patch to merge. */
+    onPatch: (patch: Partial<T>) => void;
+    /** When true, suspend derivation entirely (e.g. not in create mode). */
+    enabled?: boolean;
+}
+export interface UseCreateDeriveResult {
+    /**
+     * Mark a target field as user-touched so future derivations leave it
+     * alone. Call from input `onChange` handlers in the create form.
+     */
+    markTouched: (path: string) => void;
+    /** Read-only set of currently touched target paths. */
+    touched: ReadonlySet<string>;
+}
+/**
+ * Watches `draft[from]` and writes derived values into `draft[to]`.
+ *
+ * Why a hook (not inline state machine in ResourceEditPage):
+ *  - The "stop when user edits target" behavior needs persistent
+ *    touched-set state across renders.
+ *  - Multiple rules may target the same field; the hook resolves them
+ *    deterministically in registry order.
+ *  - Keeping the logic here lets us unit-test the derivation without
+ *    spinning up the whole edit page.
+ */
+export declare function useCreateDerive<T extends Record<string, unknown>>(args: UseCreateDeriveArgs<T>): UseCreateDeriveResult;
+/**
+ * When a type doesn't declare `createFields`, fall back to a sensible
+ * default: every required field, plus `name` and `label` if present.
+ *
+ * Returns a stable, order-preserving array (required first in their
+ * schema order, then `name`/`label` if not already included).
+ */
+export declare function deriveDefaultCreateFields(schemaProperties: Record<string, unknown> | undefined, required: readonly string[] | undefined): string[];

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

@@ -0,0 +1,179 @@
+/**
+ * createDerive — declarative live-derivation helpers for the generic
+ * metadata create form.
+ *
+ * The goal is to keep "smart" UX behaviors (auto slug, plural label)
+ * out of bespoke per-type pages. Instead, a small closed set of named
+ * transforms is exposed; types pick which ones they want via the
+ * registry's `createDerive` config.
+ */
+import { useCallback, useEffect, useRef } from 'react';
+// ── Pure transforms ───────────────────────────────────────────────────
+/**
+ * Convert a human label into a snake_case identifier.
+ *
+ * Strategy: NFKD-normalise, lowercase, replace runs of non-alphanum
+ * with `_`, trim, strip leading digit, clamp to 64 chars.
+ *
+ * Non-Latin scripts (CJK, Arabic, …) leave the result empty — the
+ * caller surface is expected to detect that and prompt the user to
+ * enter `name` manually rather than silently writing garbage.
+ */
+export function slugify(input) {
+    if (typeof input !== 'string')
+        return '';
+    const normalised = input.normalize('NFKD').replace(/[\u0300-\u036f]/g, '');
+    let out = normalised
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '');
+    if (/^\d/.test(out))
+        out = `n_${out}`;
+    if (out.length > 64)
+        out = out.slice(0, 64).replace(/_+$/g, '');
+    return out;
+}
+/**
+ * Naive English pluraliser. Handles -y → -ies, sibilants → -es, else
+ * appends -s. Returns input unchanged when it contains no ASCII
+ * letters (CJK passes through).
+ */
+export function naivePlural(input) {
+    if (typeof input !== 'string')
+        return '';
+    const trimmed = input.trim();
+    if (!trimmed)
+        return '';
+    if (!/[A-Za-z]/.test(trimmed))
+        return trimmed;
+    // Already plural? Cheap heuristic — avoid double-pluralising.
+    if (/(s|ses|xes|zes|ches|shes|ies)$/i.test(trimmed))
+        return trimmed;
+    if (/[^aeiou]y$/i.test(trimmed))
+        return trimmed.replace(/y$/i, 'ies');
+    if (/(s|x|z|ch|sh)$/i.test(trimmed))
+        return `${trimmed}es`;
+    return `${trimmed}s`;
+}
+/**
+ * snake_case / kebab-case → "Title Case".
+ */
+export function titlecase(input) {
+    if (typeof input !== 'string')
+        return '';
+    return input
+        .replace(/[_-]+/g, ' ')
+        .split(/\s+/)
+        .filter(Boolean)
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+        .join(' ');
+}
+/**
+ * Take everything up to the first space / underscore / dash.
+ */
+export function firstToken(input) {
+    if (typeof input !== 'string')
+        return '';
+    const m = input.trim().match(/^[^\s_-]+/);
+    return m ? m[0] : '';
+}
+export function applyTransform(transform, value) {
+    const str = typeof value === 'string' ? value : value == null ? '' : String(value);
+    switch (transform) {
+        case 'slugify':
+            return slugify(str);
+        case 'plural-en':
+            return naivePlural(str);
+        case 'titlecase':
+            return titlecase(str);
+        case 'first-token':
+            return firstToken(str);
+        default:
+            return str;
+    }
+}
+/**
+ * Watches `draft[from]` and writes derived values into `draft[to]`.
+ *
+ * Why a hook (not inline state machine in ResourceEditPage):
+ *  - The "stop when user edits target" behavior needs persistent
+ *    touched-set state across renders.
+ *  - Multiple rules may target the same field; the hook resolves them
+ *    deterministically in registry order.
+ *  - Keeping the logic here lets us unit-test the derivation without
+ *    spinning up the whole edit page.
+ */
+export function useCreateDerive(args) {
+    const { rules, draft, onPatch, enabled = true } = args;
+    // Targets the user has typed into directly. Once a target appears
+    // here, no rule will overwrite it again for the lifetime of the
+    // create form (the form unmounts on submit, so this naturally resets).
+    const touchedRef = useRef(new Set());
+    // Snapshot of `from` values from the prior render — lets us detect
+    // *changes* and avoid re-firing on every keystroke unrelated to a
+    // given source field.
+    const prevFromRef = useRef({});
+    const markTouched = useCallback((path) => {
+        touchedRef.current.add(path);
+    }, []);
+    useEffect(() => {
+        if (!enabled || !rules || rules.length === 0)
+            return;
+        const patch = {};
+        const prev = prevFromRef.current;
+        const nextSnapshot = {};
+        for (const rule of rules) {
+            const fromVal = draft[rule.from];
+            nextSnapshot[rule.from] = fromVal;
+            const fromChanged = !Object.is(prev[rule.from], fromVal);
+            if (!fromChanged)
+                continue;
+            const respectTouched = rule.untilUserEdits !== false;
+            if (respectTouched && touchedRef.current.has(rule.to))
+                continue;
+            // Don't fight other rules in the same batch.
+            if (rule.to in patch)
+                continue;
+            const derived = applyTransform(rule.transform, fromVal);
+            // Empty derivations (e.g. CJK → slugify) just clear the target;
+            // that's intentional — the UI then knows to prompt for manual entry.
+            if (draft[rule.to] !== derived) {
+                patch[rule.to] = derived;
+            }
+        }
+        prevFromRef.current = { ...prev, ...nextSnapshot };
+        if (Object.keys(patch).length > 0) {
+            onPatch(patch);
+        }
+        // We deliberately depend on `draft` (referential) rather than every
+        // rule.from — the rules array is treated as stable across the
+        // lifetime of the form.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [draft, enabled]);
+    return { markTouched, touched: touchedRef.current };
+}
+// ── Default field selection ───────────────────────────────────────────
+/**
+ * When a type doesn't declare `createFields`, fall back to a sensible
+ * default: every required field, plus `name` and `label` if present.
+ *
+ * Returns a stable, order-preserving array (required first in their
+ * schema order, then `name`/`label` if not already included).
+ */
+export function deriveDefaultCreateFields(schemaProperties, required) {
+    const propKeys = schemaProperties ? Object.keys(schemaProperties) : [];
+    const result = [];
+    const push = (k) => {
+        if (!result.includes(k) && propKeys.includes(k))
+            result.push(k);
+    };
+    // 1. Required fields, in JSONSchema order.
+    for (const k of propKeys) {
+        if (required?.includes(k))
+            push(k);
+    }
+    // 2. Then label/pluralLabel/name if not already in.
+    for (const k of ['label', 'pluralLabel', 'name', 'description'])
+        push(k);
+    return result;
+}

package/dist/views/metadata-admin/dashboard-schema.d.ts

@@ -0,0 +1,12 @@
+import type { FormViewSpec } from './SchemaForm';
+type JsonSchema = Record<string, any>;
+/** JSONSchema for the whole (flat) Dashboard document. */
+export declare function getDashboardSchema(): JsonSchema | undefined;
+/**
+ * The canonical authoring FormView, with the fields the curated inspector
+ * owns directly (widgets / label / description / name) pruned from every
+ * section so they are not double-rendered. Everything else — layout,
+ * filters, performance — flows through verbatim from the spec.
+ */
+export declare function getDashboardForm(): FormViewSpec | undefined;
+export {};

package/dist/views/metadata-admin/dashboard-schema.js

@@ -0,0 +1,80 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+/**
+ * dashboard-schema.ts — the SINGLE source of truth for Dashboard authoring
+ * metadata, sourced directly from `@objectstack/spec` (the protocol) rather
+ * than hand-written field lists. Mirrors {@link ./report-schema.ts}.
+ *
+ * Why: the Dashboard inspector must render the CORRECT config fields
+ * (layout / filters / performance / …) without hardcoding them. The spec
+ * already describes this:
+ *
+ *   • `dashboardForm`   — the canonical authoring FormView: sections for
+ *                         basics, layout, widgets, filters and advanced.
+ *   • `DashboardSchema` — the zod schema for the whole (flat) Dashboard
+ *                         document (name / label / widgets[] / columns /
+ *                         gap / dateRange / globalFilters / performance / …).
+ *
+ * We convert the zod schema to JSONSchema once (memoised) via zod 4's native
+ * `z.toJSONSchema`, and feed `{ form, schema }` straight into the existing
+ * {@link SchemaForm}. Adding a new dashboard config prop to the spec therefore
+ * flows through automatically — zero code changes here.
+ */
+import { z } from 'zod';
+import { DashboardSchema, dashboardForm as specDashboardForm } from '@objectstack/spec/ui';
+const TO_JSON_OPTS = { io: 'input', unrepresentable: 'any' };
+/** Fields the curated inspector owns directly, pruned from the spec form. */
+const FORM_FIELDS_OWNED_ELSEWHERE = new Set([
+    'widgets', // managed by the dedicated widgets list + per-widget inspector
+    'label', // dashboard display name rendered as a dedicated control
+    'description', // rendered as a dedicated control
+    'name', // record identity — not user-editable here
+]);
+let _dashboardDocSchema;
+let _dashboardDocFailed = false;
+/** JSONSchema for the whole (flat) Dashboard document. */
+export function getDashboardSchema() {
+    if (_dashboardDocSchema || _dashboardDocFailed)
+        return _dashboardDocSchema;
+    try {
+        _dashboardDocSchema = z.toJSONSchema(DashboardSchema, TO_JSON_OPTS);
+    }
+    catch (err) {
+        _dashboardDocFailed = true;
+        if (typeof console !== 'undefined') {
+            console.warn('[dashboard-schema] failed to derive Dashboard JSONSchema from spec', err);
+        }
+    }
+    return _dashboardDocSchema;
+}
+let _dashboardForm;
+/**
+ * The canonical authoring FormView, with the fields the curated inspector
+ * owns directly (widgets / label / description / name) pruned from every
+ * section so they are not double-rendered. Everything else — layout,
+ * filters, performance — flows through verbatim from the spec.
+ */
+export function getDashboardForm() {
+    if (_dashboardForm)
+        return _dashboardForm;
+    if (!specDashboardForm || typeof specDashboardForm !== 'object')
+        return undefined;
+    try {
+        const clone = JSON.parse(JSON.stringify(specDashboardForm));
+        for (const section of clone.sections ?? []) {
+            section.fields = (section.fields ?? []).filter((f) => {
+                const name = typeof f === 'string' ? f : f?.field;
+                return !FORM_FIELDS_OWNED_ELSEWHERE.has(name);
+            });
+        }
+        // Drop now-empty sections so we don't render bare headers.
+        clone.sections = (clone.sections ?? []).filter((s) => (s.fields ?? []).length > 0);
+        _dashboardForm = clone;
+    }
+    catch (err) {
+        if (typeof console !== 'undefined') {
+            console.warn('[dashboard-schema] failed to prepare dashboardForm from spec', err);
+        }
+        return undefined;
+    }
+    return _dashboardForm;
+}

package/dist/views/metadata-admin/datasource/DatasourceResourcePage.d.ts

@@ -0,0 +1,35 @@
+/**
+ * DatasourceResourcePage — the `datasource` metadata type's custom ListPage,
+ * registered into the metadata-admin engine (`registerMetadataResource`) and
+ * reached via the engine route `…/component/metadata/resource?type=datasource`
+ * (and the setup left-nav "Datasources" item → `system/metadata/datasource`).
+ *
+ * datasource is a *side-effectful* metadata type: its records are managed by
+ * the framework `datasource-admin` service (secret encryption + connection-pool
+ * registration + origin gating), so create/edit/delete + test go through that
+ * service's REST (`/api/v1/datasources/*`) rather than the generic sys_metadata
+ * write path. The engine still owns the route, shell, and registry slot.
+ *
+ * Capabilities:
+ *  - **List** datasources (driver/status/origin).
+ *  - **Create / edit** a connection with a typed form generated from the
+ *    selected driver's JSON-Schema `configSchema` (`GET /datasources/drivers`).
+ *    Credential fields (`format: 'password'`) are routed to the top-level
+ *    `secret` so they are encrypted into `sys_secret` and never persisted in
+ *    `config` metadata. Edit prefills from `GET /datasources/:name` (which
+ *    returns `config` + a `hasSecret` flag, never the credential itself).
+ *  - **Test** a connection (saved → `POST …/:name/test`; draft in the editor →
+ *    `POST …/test`).
+ *  - **Sync objects**: introspect remote tables (`GET …/remote-tables`), pick
+ *    which to import, generate an object definition for each (`POST …/object-draft`),
+ *    and create it through the normal metadata channel (`MetadataClient.save('object', …)`).
+ *  - **Delete** a runtime datasource (`DELETE …/:name`; blocked by the backend
+ *    while objects are still bound).
+ *
+ * Code-defined (`origin: 'code'`) datasources are read-only: edit/delete are
+ * hidden for them.
+ */
+import * as React from 'react';
+export declare function DatasourceResourcePage(_props: {
+    type?: string;
+}): React.ReactElement;