@object-ui/app-shell 6.2.3 → 7.1.0

package/dist/views/metadata-admin/previews/simulator/flow-simulator.js

@@ -0,0 +1,426 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+import { evalCondition, validateFlowDraft } from './flow-sim-validate';
+const MAX_STEPS = 500;
+const PASS_THROUGH = new Set(['start']);
+const MOCKED_SIDE_EFFECT = new Set([
+    'create_record',
+    'update_record',
+    'delete_record',
+    'get_record',
+    'http_request',
+    'connector_action',
+]);
+// `parallel` / `try_catch` carry nested body regions (ADR-0031) the flat
+// stepper can't walk — pass through honestly instead of faking their semantics.
+const UNSUPPORTED = new Set(['join_gateway', 'subflow', 'boundary_event', 'parallel', 'try_catch']);
+const edgeId = (e, i) => e.id || `${e.source}->${e.target}#${i}`;
+const condStr = (c) => (typeof c === 'string' ? c : undefined);
+const str = (v) => (typeof v === 'string' && v ? v : undefined);
+export class FlowSimulator {
+    constructor(nodes, edges) {
+        Object.defineProperty(this, "nodes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "edges", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "mocks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "seq", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                status: 'idle',
+                variables: {},
+                steps: [],
+                frontier: [],
+                activeNodeId: null,
+                visitedNodeIds: [],
+                traversedEdgeIds: [],
+            }
+        });
+        for (const n of nodes)
+            this.nodes.set(n.id, n);
+        this.edges = edges;
+    }
+    /** Validate + seed variables and queue the entry node. Returns the validation. */
+    reset(seedVariables = {}, mocks = {}) {
+        const validation = validateFlowDraft([...this.nodes.values()], this.edges);
+        this.mocks = mocks;
+        this.seq = 0;
+        this.state = {
+            status: validation.errors.length ? 'error' : 'idle',
+            variables: { ...seedVariables },
+            steps: [],
+            frontier: validation.startNodeId ? [validation.startNodeId] : [],
+            activeNodeId: null,
+            visitedNodeIds: [],
+            traversedEdgeIds: [],
+            error: validation.errors.length ? validation.errors[0].message : undefined,
+        };
+        return validation;
+    }
+    get done() {
+        return this.state.status === 'done' || this.state.status === 'error';
+    }
+    /** Execute one queued node. Returns the recorded step, or null when idle. */
+    step() {
+        const s = this.state;
+        if (s.status === 'error' || s.status === 'done' || s.status === 'paused')
+            return null;
+        if (this.seq >= MAX_STEPS) {
+            s.status = 'error';
+            s.error = `Step limit (${MAX_STEPS}) exceeded — the flow may contain an infinite loop.`;
+            return null;
+        }
+        const nodeId = s.frontier.shift();
+        if (!nodeId) {
+            s.status = 'done';
+            s.activeNodeId = null;
+            return null;
+        }
+        const node = this.nodes.get(nodeId);
+        if (!node) {
+            return this.record(nodeId, 'unknown', nodeId, 'error', { error: `Node "${nodeId}" not found.` });
+        }
+        s.status = 'running';
+        s.activeNodeId = nodeId;
+        if (!s.visitedNodeIds.includes(nodeId))
+            s.visitedNodeIds.push(nodeId);
+        const step = this.execute(node);
+        // Settle the run status. A pause halts the queue until resume(); a decision
+        // dead-end / missing node already set 'error' inside execute(). Only a still
+        // -'running' branch that drained the frontier completes as 'done'.
+        if (s.status === 'running' && s.frontier.length === 0) {
+            s.status = 'done';
+            s.activeNodeId = null;
+        }
+        return step;
+    }
+    /** Run to completion (or until a pause / error). */
+    runToEnd() {
+        let guard = 0;
+        while (this.state.status !== 'done' && this.state.status !== 'error' && this.state.status !== 'paused') {
+            if (++guard > MAX_STEPS + 5)
+                break;
+            this.step();
+        }
+        return this.state;
+    }
+    /**
+     * Continue a flow paused on a `wait`, `screen`, or `approval` node.
+     *  - `screenOutputs` — inputs captured from a paused screen.
+     *  - `decision` — the branch an approval resumes down (ADR-0019/0044:
+     *    `approve` / `reject` / `revise`). The run takes ONLY the out-edge whose
+     *    label matches, mirroring how the engine resumes a suspended approval by
+     *    branch label — instead of fanning out to every out-edge.
+     */
+    resume(opts = {}) {
+        const s = this.state;
+        if (s.status !== 'paused' || !s.activeNodeId)
+            return;
+        const node = this.nodes.get(s.activeNodeId);
+        if (opts.screenOutputs && node?.type === 'screen') {
+            Object.assign(s.variables, opts.screenOutputs);
+        }
+        s.pausedReason = undefined;
+        s.status = 'running';
+        if (node?.type === 'approval')
+            this.resumeApproval(node, opts.decision);
+        else if (node)
+            this.enqueueSuccessors(node);
+        if (s.frontier.length === 0) {
+            s.status = 'done';
+            s.activeNodeId = null;
+        }
+    }
+    /**
+     * Resume a suspended approval down the chosen decision's out-edge: the one
+     * whose `label` equals `decision` (case-insensitive — `approve` / `reject` /
+     * `revise`). With no match (or no decision) it falls back to fanning out —
+     * mirroring the engine's unmatched-`branchLabel` fallback — and logs that so
+     * the author notices the unrouted decision.
+     */
+    resumeApproval(node, decision) {
+        const out = this.edges.map((e, i) => ({ e, i })).filter((x) => x.e.source === node.id);
+        const want = (decision ?? '').trim().toLowerCase();
+        const chosen = want ? out.find((x) => (x.e.label ?? '').trim().toLowerCase() === want) : undefined;
+        if (chosen) {
+            this.traverse(chosen.e, chosen.i);
+            this.record(node.id, 'approval', node.label, 'ok', { note: `Decision: ${decision} → ${chosen.e.target}` });
+        }
+        else {
+            for (const x of out)
+                this.traverse(x.e, x.i);
+            this.record(node.id, 'approval', node.label, 'ok', {
+                note: want
+                    ? `No out-edge labelled "${decision}"; took all branches (engine label-fallback).`
+                    : 'No decision supplied; took all branches.',
+            });
+        }
+    }
+    // ---- node execution -----------------------------------------------------
+    execute(node) {
+        const type = node.type;
+        if (type === 'end') {
+            // Terminate this branch only; other queued branches still run.
+            return this.record(node.id, type, node.label, 'ok', { note: 'Flow end reached.' });
+        }
+        if (type === 'decision')
+            return this.executeDecision(node);
+        if (type === 'assignment')
+            return this.executeAssignment(node);
+        if (UNSUPPORTED.has(type)) {
+            this.enqueueSuccessors(node);
+            return this.record(node.id, type, node.label, 'skipped', {
+                note: `"${type}" is not modelled by the simulator; passing through without its real semantics.`,
+            });
+        }
+        if (type === 'parallel_gateway') {
+            this.enqueueSuccessors(node);
+            return this.record(node.id, type, node.label, 'ok', {
+                note: 'Parallel split — branches fan out (no join synchronization is simulated).',
+            });
+        }
+        if (type === 'approval') {
+            // ADR-0019: an approval node opens a request and SUSPENDS the run until a
+            // decision is recorded. Model that as a pause; the author resumes down the
+            // chosen approve / reject / revise out-edge (see resumeApproval) rather
+            // than fanning out to every out-edge at once.
+            this.state.status = 'paused';
+            this.state.pausedReason = 'approval';
+            return this.record(node.id, type, node.label, 'paused', { note: 'Approval reached — choose a decision to continue.' });
+        }
+        if (type === 'wait') {
+            this.state.status = 'paused';
+            this.state.pausedReason = 'wait';
+            return this.record(node.id, type, node.label, 'paused', { note: 'Wait reached — continue manually.' });
+        }
+        if (type === 'screen') {
+            // Mirror the engine's `shouldPause`: a screen suspends only when it
+            // collects input (`fields`) or explicitly opts in (`waitForInput`).
+            // A field-less / `waitForInput:false` screen is a server pass-through.
+            const fields = Array.isArray(node.config?.fields) ? node.config.fields : [];
+            const waitForInput = node.config?.waitForInput;
+            const shouldPause = waitForInput === true || (fields.length > 0 && waitForInput !== false);
+            if (shouldPause) {
+                this.state.status = 'paused';
+                this.state.pausedReason = 'screen';
+                return this.record(node.id, type, node.label, 'paused', { note: 'Screen reached — provide inputs, then continue.' });
+            }
+            this.enqueueSuccessors(node);
+            return this.record(node.id, type, node.label, 'ok', { note: 'Screen has no input — passed through (matches runtime).' });
+        }
+        if (type === 'loop') {
+            const step = this.executeLoop(node);
+            this.enqueueSuccessors(node);
+            return step;
+        }
+        if (MOCKED_SIDE_EFFECT.has(type) || type === 'script') {
+            const wrote = this.applyMock(node);
+            this.enqueueSuccessors(node);
+            return this.record(node.id, type, node.label, 'mocked', {
+                wrote,
+                note: this.mockNote(node),
+            });
+        }
+        // start / assignment / anything else: pass straight through.
+        this.enqueueSuccessors(node);
+        return this.record(node.id, type, node.label, 'ok', {
+            note: PASS_THROUGH.has(type) ? undefined : `Type "${type}" treated as pass-through.`,
+        });
+    }
+    executeDecision(node) {
+        const out = this.edges
+            .map((e, i) => ({ e, i }))
+            .filter((x) => x.e.source === node.id);
+        const evals = [];
+        let chosen;
+        let firstError;
+        // Evaluate conditional edges in declared order; first truthy wins.
+        for (const { e, i } of out) {
+            if (e.isDefault)
+                continue;
+            const cond = condStr(e.condition);
+            if (!cond) {
+                evals.push({ edgeId: edgeId(e, i), target: e.target, result: false, selected: false, error: 'Branch has no condition.' });
+                continue;
+            }
+            const r = evalCondition(cond, this.state.variables);
+            if (r.error && !firstError)
+                firstError = `${cond}: ${r.error}`;
+            const selected = r.result && !chosen;
+            if (selected)
+                chosen = { e, i };
+            evals.push({ edgeId: edgeId(e, i), target: e.target, condition: cond, result: r.result, error: r.error, selected });
+        }
+        // Fall back to the default branch when no condition matched.
+        if (!chosen) {
+            const def = out.find((x) => x.e.isDefault);
+            if (def) {
+                chosen = def;
+                evals.push({ edgeId: edgeId(def.e, def.i), target: def.e.target, isDefault: true, result: true, selected: true });
+            }
+        }
+        const multiMatch = evals.filter((x) => x.result && !x.isDefault).length > 1;
+        if (chosen)
+            this.traverse(chosen.e, chosen.i);
+        return this.record(node.id, 'decision', node.label, chosen ? 'ok' : 'error', {
+            edges: evals,
+            error: chosen ? undefined : firstError ?? 'No branch matched and there is no default branch.',
+            note: multiMatch ? 'Multiple conditions matched; the first declared branch was taken.' : undefined,
+        });
+    }
+    /**
+     * assignment node — set flow variables. Normalizes the three authoring
+     * shapes the engine accepts (Studio's `{ assignments: { var: value } }`
+     * map, the example `{ assignments: [{ variable, value }] }` array, and the
+     * legacy flat `{ var: value }`) and interpolates `{var}` templates — so the
+     * Debug run mirrors runtime instead of silently no-oping.
+     */
+    executeAssignment(node) {
+        const cfg = node.config ?? {};
+        const raw = cfg.assignments;
+        const pairs = [];
+        if (Array.isArray(raw)) {
+            for (const item of raw) {
+                if (item && typeof item === 'object') {
+                    const e = item;
+                    const name = e.variable ?? e.name ?? e.key;
+                    if (typeof name === 'string' && name)
+                        pairs.push([name, e.value]);
+                }
+            }
+        }
+        else if (raw && typeof raw === 'object') {
+            for (const [k, v] of Object.entries(raw))
+                pairs.push([k, v]);
+        }
+        else {
+            for (const [k, v] of Object.entries(cfg))
+                pairs.push([k, v]);
+        }
+        const wrote = {};
+        for (const [key, value] of pairs) {
+            const resolved = this.interpolateValue(value);
+            this.state.variables[key] = resolved;
+            wrote[key] = resolved;
+        }
+        this.enqueueSuccessors(node);
+        return this.record(node.id, 'assignment', node.label, 'ok', {
+            wrote: Object.keys(wrote).length ? wrote : undefined,
+            note: Object.keys(wrote).length ? undefined : 'No assignments defined.',
+        });
+    }
+    /** Resolve `{var}` templates in an assignment value against live variables. */
+    interpolateValue(value) {
+        if (typeof value !== 'string')
+            return value;
+        const whole = value.match(/^\{([^}]+)\}$/);
+        if (whole) {
+            const v = this.state.variables[whole[1].trim()];
+            return v !== undefined ? v : value;
+        }
+        return value.replace(/\{([^}]+)\}/g, (_m, k) => {
+            const v = this.state.variables[String(k).trim()];
+            return v === undefined || v === null ? '' : String(v);
+        });
+    }
+    executeLoop(node) {
+        const ref = str(node.config?.collection);
+        const iterVar = str(node.config?.iteratorVariable);
+        let note = 'Loop simulated as a single pass (body re-execution is not modelled).';
+        if (ref) {
+            const resolved = this.resolveRef(ref);
+            if (Array.isArray(resolved)) {
+                note = `Collection "${ref}" has ${resolved.length} item(s); simulated as a single pass.`;
+                if (iterVar && resolved.length)
+                    this.state.variables[iterVar] = resolved[0];
+            }
+            else if (resolved !== undefined) {
+                note = `Collection "${ref}" is not an array; loop may not run at runtime.`;
+            }
+        }
+        return this.record(node.id, 'loop', node.label, 'ok', { note });
+    }
+    // ---- helpers ------------------------------------------------------------
+    /** Resolve a `{var}` template ref or a plain variable name from `variables`. */
+    resolveRef(ref) {
+        const m = ref.match(/^\{(.+)\}$/);
+        const key = (m ? m[1] : ref).trim();
+        return this.state.variables[key];
+    }
+    /** Apply a node's mock output to the simulation variables; returns what it wrote. */
+    applyMock(node) {
+        const cfg = node.config ?? {};
+        const mock = this.mocks[node.id];
+        const wrote = {};
+        const single = str(cfg.outputVariable);
+        if (single) {
+            wrote[single] = mock !== undefined ? mock : {};
+            this.state.variables[single] = wrote[single];
+        }
+        const list = Array.isArray(cfg.outputVariables) ? cfg.outputVariables : [];
+        if (list.length) {
+            const m = mock && typeof mock === 'object' ? mock : {};
+            for (const name of list) {
+                if (typeof name !== 'string')
+                    continue;
+                wrote[name] = name in m ? m[name] : undefined;
+                this.state.variables[name] = wrote[name];
+            }
+        }
+        return Object.keys(wrote).length ? wrote : undefined;
+    }
+    mockNote(node) {
+        if (node.type === 'script') {
+            const action = str(node.config?.actionType);
+            if (action && action !== 'code') {
+                const recips = Array.isArray(node.config?.recipients) ? node.config.recipients.length : 0;
+                return `Mocked ${action} notification${recips ? ` to ${recips} recipient(s)` : ''}.`;
+            }
+            return 'Mocked code script (no real code executed).';
+        }
+        return `Mocked ${node.type.replace(/_/g, ' ')} (no backend call).`;
+    }
+    /** Enqueue every outgoing target (linear nodes have one; parallel fans out). */
+    enqueueSuccessors(node) {
+        this.edges.forEach((e, i) => {
+            if (e.source === node.id)
+                this.traverse(e, i);
+        });
+    }
+    traverse(e, i) {
+        const id = edgeId(e, i);
+        if (!this.state.traversedEdgeIds.includes(id))
+            this.state.traversedEdgeIds.push(id);
+        if (this.nodes.has(e.target))
+            this.state.frontier.push(e.target);
+    }
+    record(nodeId, type, label, status, extra = {}) {
+        const step = { seq: this.seq++, nodeId, type, label: label || nodeId, status, ...extra };
+        this.state.steps.push(step);
+        if (status === 'error' && this.state.status !== 'paused') {
+            this.state.status = 'error';
+            this.state.error = extra.error;
+        }
+        return step;
+    }
+}

package/dist/views/metadata-admin/previews/useDatasetCatalog.d.ts

@@ -0,0 +1,47 @@
+export interface DatasetDimensionInfo {
+    /** Dimension name (snake_case, referenced by `report.rows`). */
+    name: string;
+    /** Raw field type id when declared (e.g. 'text', 'date'). */
+    type?: string;
+}
+export interface DatasetMeasureInfo {
+    /** Measure name (snake_case, referenced by `report.values`). */
+    name: string;
+    /** Aggregate function (sum / avg / count / …) — display hint only. */
+    aggregate?: string;
+    /** Whether the dataset author certified this measure. */
+    certified?: boolean;
+}
+export interface DatasetCatalogEntry {
+    /** Dataset unique name (what `report.dataset` stores). */
+    name: string;
+    /** Human label (falls back to the name). */
+    label: string;
+    dimensions: DatasetDimensionInfo[];
+    measures: DatasetMeasureInfo[];
+}
+export interface UseDatasetCatalogResult {
+    datasets: DatasetCatalogEntry[];
+    loading: boolean;
+    error: string | null;
+}
+/** Normalize a raw dataset document into a catalog entry. */
+export declare function toCatalogEntry(doc: Record<string, unknown>): DatasetCatalogEntry | null;
+export declare function useDatasetCatalog(
+/**
+ * Pre-resolved catalog. When supplied the hook skips the network fetch
+ * entirely and returns this list verbatim.
+ */
+override?: DatasetCatalogEntry[]): UseDatasetCatalogResult;
+export interface UseDatasetSemanticsResult {
+    dimensions: DatasetDimensionInfo[];
+    measures: DatasetMeasureInfo[];
+    loading: boolean;
+    error: string | null;
+}
+/**
+ * Resolve the bound dataset's dimensions/measures from the catalog, lazily
+ * hydrating via `client.get('dataset', name)` when the list endpoint returned
+ * a summary without them (some servers list names only).
+ */
+export declare function useDatasetSemantics(name: string | undefined, catalog: UseDatasetCatalogResult): UseDatasetSemanticsResult;

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

@@ -0,0 +1,133 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+/**
+ * useDatasetCatalog — loads the analytics dataset catalog for the Report
+ * inspector's dataset binding controls (ADR-0021 single-form).
+ *
+ * A 9.0 report binds a semantic-layer `dataset` and selects its `values`
+ * (measure names) grouped by `rows` (dimension names) — so the editor needs
+ * (a) the list of datasets to bind, and (b) the bound dataset's
+ * dimensions/measures to offer as picker options.
+ *
+ * Mirrors {@link useObjectFields}: defensive (a 404 or transport error
+ * resolves to an empty catalog with `error` set, the inspector falls back to
+ * manual entry) and override-friendly (hosts that already hold the catalog
+ * pass it to keep the inspector network-free, e.g. tests and the runtime
+ * config panel).
+ */
+import * as React from 'react';
+import { useMetadataClient } from '../useMetadata';
+function resolveLabel(label, fallback) {
+    if (typeof label === 'string' && label)
+        return label;
+    if (label && typeof label === 'object') {
+        const def = label.default;
+        if (typeof def === 'string' && def)
+            return def;
+    }
+    return fallback;
+}
+/** Normalize a raw dataset document into a catalog entry. */
+export function toCatalogEntry(doc) {
+    const name = typeof doc.name === 'string' ? doc.name : '';
+    if (!name)
+        return null;
+    const dimensions = Array.isArray(doc.dimensions)
+        ? doc.dimensions
+            .filter((d) => d && typeof d.name === 'string' && d.name)
+            .map((d) => ({
+            name: d.name,
+            type: typeof d.type === 'string' ? d.type : undefined,
+        }))
+        : [];
+    const measures = Array.isArray(doc.measures)
+        ? doc.measures
+            .filter((m) => m && typeof m.name === 'string' && m.name)
+            .map((m) => ({
+            name: m.name,
+            aggregate: typeof m.aggregate === 'string' ? m.aggregate : undefined,
+            certified: m.certified === true,
+        }))
+        : [];
+    return { name, label: resolveLabel(doc.label, name), dimensions, measures };
+}
+export function useDatasetCatalog(
+/**
+ * Pre-resolved catalog. When supplied the hook skips the network fetch
+ * entirely and returns this list verbatim.
+ */
+override) {
+    const client = useMetadataClient();
+    const [state, setState] = React.useState({
+        datasets: override ?? [],
+        loading: !override,
+        error: null,
+    });
+    React.useEffect(() => {
+        if (override) {
+            setState({ datasets: override, loading: false, error: null });
+            return;
+        }
+        let cancelled = false;
+        setState((s) => ({ ...s, loading: true, error: null }));
+        client
+            .list('dataset')
+            .then((docs) => {
+            if (cancelled)
+                return;
+            const datasets = (Array.isArray(docs) ? docs : [])
+                .map(toCatalogEntry)
+                .filter((e) => e !== null);
+            setState({ datasets, loading: false, error: null });
+        })
+            .catch((err) => {
+            if (cancelled)
+                return;
+            setState({ datasets: [], loading: false, error: err?.message ?? String(err) });
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [client, override]);
+    return state;
+}
+/**
+ * Resolve the bound dataset's dimensions/measures from the catalog, lazily
+ * hydrating via `client.get('dataset', name)` when the list endpoint returned
+ * a summary without them (some servers list names only).
+ */
+export function useDatasetSemantics(name, catalog) {
+    const client = useMetadataClient();
+    const entry = name ? catalog.datasets.find((d) => d.name === name) : undefined;
+    const needsFetch = !!name && !catalog.loading &&
+        (!entry || (entry.dimensions.length === 0 && entry.measures.length === 0));
+    const [fetched, setFetched] = React.useState(null);
+    React.useEffect(() => {
+        if (!needsFetch || !name)
+            return;
+        if (fetched?.name === name)
+            return;
+        let cancelled = false;
+        client
+            .get('dataset', name)
+            .then((doc) => {
+            if (cancelled)
+                return;
+            setFetched({ name, entry: doc ? toCatalogEntry(doc) : null, error: doc ? null : 'Dataset not found' });
+        })
+            .catch((err) => {
+            if (cancelled)
+                return;
+            setFetched({ name, entry: null, error: err?.message ?? String(err) });
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [client, name, needsFetch, fetched]);
+    const resolved = needsFetch && fetched?.name === name ? fetched.entry : entry;
+    return {
+        dimensions: resolved?.dimensions ?? [],
+        measures: resolved?.measures ?? [],
+        loading: catalog.loading || (needsFetch && fetched?.name !== name),
+        error: (needsFetch && fetched?.name === name ? fetched.error : null) ?? catalog.error,
+    };
+}

package/dist/views/metadata-admin/previews/useFlowNodePalette.d.ts

@@ -0,0 +1,44 @@
+import { type PaletteItem } from './flow-canvas-parts';
+/** Minimal shape of an engine action descriptor we consume. */
+interface ActionDescriptorLite {
+    type: string;
+    name?: string;
+    description?: string;
+    paradigms?: string[];
+    deprecated?: boolean;
+    /**
+     * JSON Schema for the node's `config` (ADR-0018 §configSchema). Present only
+     * for actions whose executor publishes one (e.g. the ADR-0019 approval node).
+     * Drives the inspector's server-rendered property form.
+     */
+    configSchema?: unknown;
+}
+/** Server API base — shared by the palette fetch and the runs panel. */
+export declare function apiBase(): string;
+/**
+ * Merge engine descriptors onto the hardcoded base. Base order is canonical;
+ * a descriptor overlays its base entry's label/hint (so the engine is the
+ * source of truth for naming), and engine-only types are appended.
+ */
+export declare function mergePalette(base: PaletteItem[], descriptors: ActionDescriptorLite[]): PaletteItem[];
+/**
+ * Fetch the running engine's published action descriptors from
+ * `GET /api/v1/automation/actions`. Returns `[]` while loading or on any error
+ * (offline / plugin absent / older backend), so consumers fall back to their
+ * hardcoded defaults. Shared by both the palette and the inspector's
+ * server-driven config form.
+ */
+export declare function useActionDescriptors(): ActionDescriptorLite[];
+/**
+ * Returns the node palette merged with the running engine's published
+ * descriptors. Falls back to {@link NODE_PALETTE} while loading or on any
+ * error, so the designer always has a usable palette.
+ */
+export declare function useFlowNodePalette(): PaletteItem[];
+/**
+ * Map of node `type` → published config JSON Schema, for the actions whose
+ * executor publishes one. Empty while loading / offline, so the inspector
+ * falls back to its hardcoded field group for every type.
+ */
+export declare function useActionConfigSchemas(): Record<string, unknown>;
+export {};