@praxisui/core 9.0.4-rc.32 → 9.0.4-rc.34

package/fesm2022/praxisui-core.mjs

@@ -22766,696 +22766,1084 @@ function getEditorialSolutionPresetById(presetId) {
     return match ? structuredClone(match) : undefined;
 }
 
-const WIDGET_PAGE_COMPOSITION_SCHEMA_VERSION = '1.0.0';
-const STRUCTURAL_NESTED_PATH_KINDS$1 = new Set([
-    'nav',
-]);
-/**
- * Normalizes a CompositionLink for deterministic persistence.
- * Ensures explicit ordering and strips compatibility-only legacy residues.
- */
-function normalizeCompositionLink(link) {
-    const normalized = {
-        id: link.id,
-        from: normalizeEndpoint(link.from),
-        to: normalizeEndpoint(link.to),
-        intent: link.intent,
-    };
-    if (link.transform) {
-        normalized.transform = clone$1(link.transform);
-    }
-    const condition = normalizeCondition(link.condition);
-    if (condition !== undefined) {
-        normalized.condition = condition;
+class NestedWidgetConfigAccessor {
+    listNestedWidgets(owner) {
+        return this.listNestedWidgetsInDefinition(owner.key, owner.definition, []);
     }
-    const policy = normalizePolicy(link.policy);
-    if (policy) {
-        normalized.policy = policy;
+    resolveNestedWidget(owner, nestedPath) {
+        if (!nestedPath?.length) {
+            return undefined;
+        }
+        return this.resolveNestedWidgetInDefinition(owner.definition, nestedPath);
     }
-    const metadata = normalizeMetadata(link.metadata);
-    if (metadata) {
-        normalized.metadata = metadata;
+    setNestedWidgetInput(owner, nestedPath, inputName, value) {
+        const normalizedInputName = String(inputName || '').trim();
+        if (!nestedPath?.length || !normalizedInputName) {
+            return { widget: this.clone(owner), changed: false };
+        }
+        const next = this.clone(owner);
+        const changed = this.setNestedWidgetInputInDefinition(next.definition, nestedPath, normalizedInputName, this.clone(value));
+        return { widget: next, changed };
     }
-    return normalized;
-}
-/**
- * Normalizes an array of CompositionLinks for deterministic persistence.
- */
-function normalizeCompositionLinks(links) {
-    return links
-        .map(normalizeCompositionLink)
-        .sort(compareNormalizedLinks);
-}
-/**
- * Canonical persisted write surface for CompositionLink[].
- * New saved shapes must serialize links under `composition.links`.
- * Semantic guards persist only through `link.condition` as Json Logic.
- * Operational delivery behavior remains under `link.policy` and must not be
- * folded into the condition payload.
- */
-function serializeCompositionLinks(links) {
-    return {
-        version: WIDGET_PAGE_COMPOSITION_SCHEMA_VERSION,
-        links: normalizeCompositionLinks(links),
-    };
-}
-/**
- * Writes the canonical persisted composition surface into a page shape.
- * The canonical writer omits legacy `connections` to avoid dual-write ambiguity.
- */
-function writeCompositionLinksToPersistedPage(page, links) {
-    const { composition: _legacyComposition, ...rest } = clone$1(page);
-    return {
-        ...rest,
-        composition: serializeCompositionLinks(links),
-    };
-}
-function normalizeEndpoint(endpoint) {
-    if (endpoint.kind === 'component-port') {
-        const nestedPath = normalizeNestedPath(endpoint.ref.nestedPath);
-        return {
-            kind: 'component-port',
-            ref: {
-                widget: endpoint.ref.widget,
-                port: endpoint.ref.port,
-                direction: endpoint.ref.direction,
-                ...(endpoint.ref.componentType ? { componentType: endpoint.ref.componentType } : {}),
-                ...(endpoint.ref.bindingPath ? { bindingPath: endpoint.ref.bindingPath } : {}),
-                ...(nestedPath.length ? { nestedPath } : {}),
-            },
-        };
+    removeNestedWidgetInput(owner, nestedPath, inputName) {
+        const normalizedInputName = String(inputName || '').trim();
+        if (!nestedPath?.length || !normalizedInputName) {
+            return { widget: this.clone(owner), changed: false };
+        }
+        const next = this.clone(owner);
+        const changed = this.removeNestedWidgetInputInDefinition(next.definition, nestedPath, normalizedInputName);
+        return { widget: next, changed };
     }
-    if (endpoint.kind === 'global-action') {
-        return {
-            kind: 'global-action',
-            ref: normalizeGlobalActionRef(endpoint.ref),
-        };
+    listNestedWidgetsInDefinition(ownerWidgetKey, definition, basePath) {
+        const results = [];
+        for (const location of this.listChildWidgetLocations(definition)) {
+            for (const [index, widget] of location.widgets.entries()) {
+                if (!this.isWidgetDefinition(widget)) {
+                    continue;
+                }
+                const childWidgetKey = this.resolveChildWidgetKey(widget);
+                const widgetSegment = {
+                    kind: 'widget',
+                    ...(childWidgetKey ? { key: childWidgetKey } : { index }),
+                    componentType: widget.id,
+                };
+                const nestedPath = [
+                    ...basePath,
+                    ...location.path,
+                    widgetSegment,
+                ];
+                results.push({
+                    ownerWidgetKey,
+                    nestedPath,
+                    widget: this.clone(widget),
+                    componentId: widget.id,
+                    childWidgetKey,
+                });
+                results.push(...this.listNestedWidgetsInDefinition(ownerWidgetKey, widget, nestedPath));
+            }
+        }
+        return results;
     }
-    return {
-        kind: 'state',
-        ref: {
-            path: endpoint.ref.path,
-            ...(endpoint.ref.layer ? { layer: endpoint.ref.layer } : {}),
-        },
-    };
-}
-function normalizeGlobalActionRef(ref) {
-    return {
-        actionId: String(ref.actionId || '').trim(),
-        ...(ref.payload !== undefined ? { payload: clone$1(ref.payload) } : {}),
-        ...(ref.payloadExpr ? { payloadExpr: String(ref.payloadExpr).trim() } : {}),
-        ...(ref.meta && typeof ref.meta === 'object' ? { meta: { ...ref.meta } } : {}),
-    };
-}
-function normalizeNestedPath(nestedPath) {
-    if (!nestedPath?.length) {
-        return [];
+    resolveNestedWidgetInDefinition(definition, nestedPath) {
+        const location = this.resolveWidgetArrayLocation(definition, nestedPath, 0);
+        if (!location) {
+            return undefined;
+        }
+        const widgetSegment = nestedPath[location.segmentCount];
+        if (widgetSegment?.kind !== 'widget' || !widgetSegment.key) {
+            return undefined;
+        }
+        const child = location.widgets.find((widget) => widget.childWidgetKey === widgetSegment.key);
+        if (!this.isWidgetDefinition(child)) {
+            return undefined;
+        }
+        const remaining = nestedPath.slice(location.segmentCount + 1);
+        if (!remaining.length) {
+            return this.clone(child);
+        }
+        return this.resolveNestedWidgetInDefinition(child, remaining);
     }
-    return nestedPath
-        .map((segment) => {
-        const normalized = {
-            kind: segment.kind,
-        };
-        if (segment.id) {
-            normalized.id = segment.id;
+    setNestedWidgetInputInDefinition(definition, nestedPath, inputName, value) {
+        const location = this.resolveWidgetArrayLocation(definition, nestedPath, 0);
+        if (!location) {
+            return false;
         }
-        if (segment.key) {
-            normalized.key = segment.key;
+        const widgetSegment = nestedPath[location.segmentCount];
+        if (widgetSegment?.kind !== 'widget' || !widgetSegment.key) {
+            return false;
         }
-        if (typeof segment.index === 'number' && Number.isFinite(segment.index)) {
-            normalized.index = Math.trunc(segment.index);
+        const widgetIndex = location.widgets.findIndex((widget) => widget.childWidgetKey === widgetSegment.key);
+        if (widgetIndex < 0) {
+            return false;
         }
-        if (segment.componentType) {
-            normalized.componentType = segment.componentType;
+        const remaining = nestedPath.slice(location.segmentCount + 1);
+        const child = location.widgets[widgetIndex];
+        if (!this.isWidgetDefinition(child)) {
+            return false;
         }
-        return normalized;
-    })
-        .filter((segment) => !!segment.kind
-        && (!!segment.id
-            || !!segment.key
-            || typeof segment.index === 'number'
-            || !!segment.componentType
-            || segment.kind === 'widget'
-            || STRUCTURAL_NESTED_PATH_KINDS$1.has(segment.kind)));
-}
-function normalizeCondition(condition) {
-    if (condition === undefined) {
-        return undefined;
+        if (remaining.length) {
+            return this.setNestedWidgetInputInDefinition(child, remaining, inputName, value);
+        }
+        const currentInputs = child.inputs || {};
+        const nextInputs = {
+            ...currentInputs,
+            [inputName]: value,
+        };
+        if (this.isEqual(currentInputs, nextInputs)) {
+            return false;
+        }
+        location.widgets[widgetIndex] = {
+            ...child,
+            inputs: nextInputs,
+        };
+        return true;
     }
-    if (condition === null) {
-        return null;
+    removeNestedWidgetInputInDefinition(definition, nestedPath, inputName) {
+        const location = this.resolveWidgetArrayLocation(definition, nestedPath, 0);
+        if (!location) {
+            return false;
+        }
+        const widgetSegment = nestedPath[location.segmentCount];
+        if (widgetSegment?.kind !== 'widget' || !widgetSegment.key) {
+            return false;
+        }
+        const widgetIndex = location.widgets.findIndex((widget) => widget.childWidgetKey === widgetSegment.key);
+        if (widgetIndex < 0) {
+            return false;
+        }
+        const remaining = nestedPath.slice(location.segmentCount + 1);
+        const child = location.widgets[widgetIndex];
+        if (!this.isWidgetDefinition(child)) {
+            return false;
+        }
+        if (remaining.length) {
+            return this.removeNestedWidgetInputInDefinition(child, remaining, inputName);
+        }
+        const currentInputs = child.inputs || {};
+        if (!Object.prototype.hasOwnProperty.call(currentInputs, inputName)) {
+            return false;
+        }
+        const { [inputName]: _runtimeValue, ...nextInputs } = currentInputs;
+        location.widgets[widgetIndex] = {
+            ...child,
+            inputs: nextInputs,
+        };
+        return true;
     }
-    return clone$1(condition);
-}
-function normalizePolicy(policy) {
-    if (!policy) {
+    listChildWidgetLocations(definition) {
+        const config = definition.inputs?.['config'];
+        if (!config || typeof config !== 'object') {
+            return [];
+        }
+        if (definition.id === 'praxis-tabs') {
+            return this.listTabsWidgetLocations(config);
+        }
+        if (definition.id === 'praxis-expansion') {
+            return this.listExpansionWidgetLocations(config);
+        }
+        return [];
+    }
+    listTabsWidgetLocations(config) {
+        const locations = [];
+        const tabs = Array.isArray(config['tabs']) ? config['tabs'] : [];
+        for (const [index, tab] of tabs.entries()) {
+            if (!tab || typeof tab !== 'object') {
+                continue;
+            }
+            const widgets = this.asWidgetDefinitions(tab['widgets']);
+            if (!widgets.some((widget) => this.isWidgetDefinition(widget))) {
+                continue;
+            }
+            locations.push({
+                path: [{
+                        kind: 'tab',
+                        ...this.segmentIdentity(tab, index),
+                    }],
+                widgets,
+            });
+        }
+        const nav = config['nav'];
+        const links = nav && typeof nav === 'object' && Array.isArray(nav['links'])
+            ? nav['links']
+            : [];
+        for (const [index, link] of links.entries()) {
+            if (!link || typeof link !== 'object') {
+                continue;
+            }
+            const widgets = this.asWidgetDefinitions(link['widgets']);
+            if (!widgets.some((widget) => this.isWidgetDefinition(widget))) {
+                continue;
+            }
+            locations.push({
+                path: [
+                    { kind: 'nav' },
+                    {
+                        kind: 'link',
+                        ...this.segmentIdentity(link, index),
+                    },
+                ],
+                widgets,
+            });
+        }
+        return locations;
+    }
+    listExpansionWidgetLocations(config) {
+        const panels = Array.isArray(config['panels']) ? config['panels'] : [];
+        const locations = [];
+        for (const [index, panel] of panels.entries()) {
+            if (!panel || typeof panel !== 'object') {
+                continue;
+            }
+            const widgets = this.asWidgetDefinitions(panel['widgets']);
+            if (!widgets.some((widget) => this.isWidgetDefinition(widget))) {
+                continue;
+            }
+            locations.push({
+                path: [{
+                        kind: 'panel',
+                        ...this.segmentIdentity(panel, index),
+                    }],
+                widgets,
+            });
+        }
+        return locations;
+    }
+    resolveWidgetArrayLocation(definition, nestedPath, offset) {
+        if (definition.id === 'praxis-tabs') {
+            return this.resolveTabsWidgetArray(definition, nestedPath, offset);
+        }
+        if (definition.id === 'praxis-expansion') {
+            return this.resolveExpansionWidgetArray(definition, nestedPath, offset);
+        }
         return undefined;
     }
-    const normalized = {
-        ...(policy.debounceMs !== undefined ? { debounceMs: policy.debounceMs } : {}),
-        ...(policy.distinct !== undefined ? { distinct: policy.distinct } : {}),
-        ...(policy.distinctBy ? { distinctBy: policy.distinctBy } : {}),
-        ...(policy.delivery ? { delivery: policy.delivery } : {}),
-        ...(policy.missingValuePolicy ? { missingValuePolicy: policy.missingValuePolicy } : {}),
-        ...(policy.errorPolicy ? { errorPolicy: policy.errorPolicy } : {}),
-    };
-    return Object.keys(normalized).length ? normalized : undefined;
-}
-function normalizeMetadata(metadata) {
-    if (!metadata) {
+    resolveTabsWidgetArray(definition, nestedPath, offset) {
+        const config = definition.inputs?.['config'];
+        if (!config || typeof config !== 'object') {
+            return undefined;
+        }
+        const first = nestedPath[offset];
+        if (first?.kind === 'tab') {
+            const tabs = Array.isArray(config['tabs'])
+                ? config['tabs']
+                : [];
+            const tab = this.findBySegment(tabs, first);
+            const widgets = tab && typeof tab === 'object'
+                ? this.asWidgetDefinitions(tab['widgets'])
+                : [];
+            return widgets.length ? { widgets, segmentCount: offset + 1 } : undefined;
+        }
+        const linkSegment = first?.kind === 'nav'
+            ? nestedPath[offset + 1]
+            : first;
+        if (linkSegment?.kind !== 'link') {
+            return undefined;
+        }
+        const nav = config['nav'];
+        const links = nav && typeof nav === 'object' && Array.isArray(nav['links'])
+            ? nav['links']
+            : [];
+        const link = this.findBySegment(links, linkSegment);
+        const widgets = link && typeof link === 'object'
+            ? this.asWidgetDefinitions(link['widgets'])
+            : [];
+        return widgets.length
+            ? { widgets, segmentCount: first?.kind === 'nav' ? offset + 2 : offset + 1 }
+            : undefined;
+    }
+    resolveExpansionWidgetArray(definition, nestedPath, offset) {
+        const config = definition.inputs?.['config'];
+        const panelSegment = nestedPath[offset];
+        if (!config || typeof config !== 'object' || panelSegment?.kind !== 'panel') {
+            return undefined;
+        }
+        const panels = Array.isArray(config['panels'])
+            ? config['panels']
+            : [];
+        const panel = this.findBySegment(panels, panelSegment);
+        const widgets = panel && typeof panel === 'object'
+            ? this.asWidgetDefinitions(panel['widgets'])
+            : [];
+        return widgets.length ? { widgets, segmentCount: offset + 1 } : undefined;
+    }
+    findBySegment(items, segment) {
+        if (segment.id) {
+            const byId = items.find((item) => !!item
+                && typeof item === 'object'
+                && item['id'] === segment.id);
+            if (byId) {
+                return byId;
+            }
+        }
+        if (typeof segment.index === 'number') {
+            return items[segment.index];
+        }
         return undefined;
     }
-    const tags = metadata.tags?.length
-        ? [...metadata.tags].sort((a, b) => a.localeCompare(b))
-        : undefined;
-    const source = metadata.source === 'legacy-widget-connection'
-        ? undefined
-        : metadata.source;
-    const normalized = {
-        ...(metadata.label ? { label: metadata.label } : {}),
-        ...(metadata.description ? { description: metadata.description } : {}),
-        ...(tags?.length ? { tags } : {}),
-        ...(metadata.deprecated !== undefined ? { deprecated: metadata.deprecated } : {}),
-        ...(source ? { source } : {}),
-    };
-    return Object.keys(normalized).length ? normalized : undefined;
-}
-function compareNormalizedLinks(a, b) {
-    return compareValues([
-        a.id,
-        a.intent,
-        endpointSortKey(a.from),
-        endpointSortKey(a.to),
-        JSON.stringify(a.condition ?? null),
-    ], [
-        b.id,
-        b.intent,
-        endpointSortKey(b.from),
-        endpointSortKey(b.to),
-        JSON.stringify(b.condition ?? null),
-    ]);
-}
-function endpointSortKey(endpoint) {
-    if (endpoint.kind === 'component-port') {
-        return [
-            endpoint.kind,
-            endpoint.ref.widget,
-            endpoint.ref.port,
-            endpoint.ref.direction,
-            endpoint.ref.bindingPath || '',
-            endpoint.ref.componentType || '',
-            JSON.stringify(normalizeNestedPath(endpoint.ref.nestedPath)),
-        ].join('|');
+    segmentIdentity(source, index) {
+        const id = typeof source['id'] === 'string' ? source['id'].trim() : '';
+        return {
+            ...(id ? { id } : {}),
+            index,
+        };
     }
-    if (endpoint.kind === 'global-action') {
-        return [
-            endpoint.kind,
-            endpoint.ref.actionId,
-            endpoint.ref.payloadExpr || '',
-            JSON.stringify(endpoint.ref.payload ?? null),
-        ].join('|');
+    asWidgetDefinitions(value) {
+        return Array.isArray(value) ? value : [];
     }
-    return [
-        endpoint.kind,
-        endpoint.ref.path,
-        endpoint.ref.layer || '',
-    ].join('|');
-}
-function compareValues(left, right) {
-    for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
-        const comparison = (left[index] || '').localeCompare(right[index] || '');
-        if (comparison !== 0) {
-            return comparison;
+    isWidgetDefinition(value) {
+        return !!value
+            && typeof value === 'object'
+            && typeof value.id === 'string';
+    }
+    resolveChildWidgetKey(widget) {
+        return widget.childWidgetKey || '';
+    }
+    clone(value) {
+        if (value == null || typeof value !== 'object') {
+            return value;
         }
+        return JSON.parse(JSON.stringify(value));
     }
-    return 0;
-}
-function clone$1(value) {
-    if (value == null || typeof value !== 'object') {
-        return value;
+    isEqual(left, right) {
+        return JSON.stringify(left) === JSON.stringify(right);
     }
-    return JSON.parse(JSON.stringify(value));
 }
 
-/** Utility: generate a random id using crypto.randomUUID or fallback. */
-function generateId() {
-    const g = globalThis.crypto?.randomUUID?.();
-    return g || `id_${Math.random().toString(36).slice(2, 10)}_${Date.now().toString(36)}`;
-}
-/** Utility: build a natural key from identity fields. */
-function buildPageKey(identity) {
-    const app = sanitize(identity.appId || 'app');
-    const tenant = sanitize(identity.tenantId || '*');
-    const user = sanitize(identity.userId || '*');
-    const route = sanitize(identity.routePath || '/');
-    const locale = identity.locale ? `:${sanitize(identity.locale)}` : '';
-    return `${app}:${tenant}:${user}:${route}${locale}`;
-}
-function sanitize(s) {
-    return String(s).replace(/\s+/g, '_').replace(/[:]/g, '-');
-}
+const WIDGET_PAGE_COMPOSITION_SCHEMA_VERSION = '1.0.0';
+const STRUCTURAL_NESTED_PATH_KINDS$1 = new Set([
+    'nav',
+]);
 /**
- * Ensure that each widget has a stable id. If missing, assigns a new one.
- * Returns the new page definition (immutable) and an index by key/id.
+ * Normalizes a CompositionLink for deterministic persistence.
+ * Ensures explicit ordering and strips compatibility-only legacy residues.
  */
-function ensurePageIds(page) {
-    const widgets = (page.widgets || []).map((w) => ({
-        id: w.id || generateId(),
-        ...w,
-    }));
-    const withIds = { ...page, widgets };
-    const byKey = new Map();
-    const byId = new Map();
-    for (const w of widgets) {
-        byKey.set(w.key, w);
-        byId.set(w.id, w);
+function normalizeCompositionLink(link) {
+    const normalized = {
+        id: link.id,
+        from: normalizeEndpoint(link.from),
+        to: normalizeEndpoint(link.to),
+        intent: link.intent,
+    };
+    if (link.transform) {
+        normalized.transform = clone$1(link.transform);
     }
-    return { page: withIds, byKey, byId };
+    const condition = normalizeCondition(link.condition);
+    if (condition !== undefined) {
+        normalized.condition = condition;
+    }
+    const policy = normalizePolicy(link.policy);
+    if (policy) {
+        normalized.policy = policy;
+    }
+    const metadata = normalizeMetadata(link.metadata);
+    if (metadata) {
+        normalized.metadata = metadata;
+    }
+    return normalized;
 }
 /**
- * Create a persisted page record from an in-memory page definition and identity.
+ * Normalizes an array of CompositionLinks for deterministic persistence.
  */
-function createPersistedPage(identity, page, opts) {
-    const persistedPage = writeCompositionLinksToPersistedPage(page, page.composition?.links || []);
-    const { page: pageWithIds } = ensurePageIds(persistedPage);
-    const now = new Date().toISOString();
-    return {
-        id: opts?.id || generateId(),
-        key: buildPageKey(identity),
-        version: opts?.version || '1.0.0',
-        title: opts?.title,
-        description: opts?.description,
-        tags: opts?.tags || [],
-        identity,
-        status: opts?.status || 'draft',
-        page: pageWithIds,
-        owner: opts?.owner,
-        createdAt: now,
-        updatedAt: now,
-        parentId: opts?.parentId,
-    };
+function normalizeCompositionLinks(links) {
+    return links
+        .map(normalizeCompositionLink)
+        .sort(compareNormalizedLinks);
 }
-
-// Global configuration model for cross-library defaults
-// Designed to be minimal and avoid coupling to feature-library types
-
-// Global Dialog domain types for GlobalConfig (kept independent of @praxisui/dialog types)
-
-const DOMAIN_CATALOG_CONTEXT_HINT_SCHEMA_VERSION = 'praxis.ai.context-hints.domain-catalog/v0.2';
-
-const DEFAULT_TITLE$1 = 'Governed knowledge timeline';
-const DEFAULT_EMPTY_TEXT$1 = 'No safe timeline events published for this change-set.';
-function domainKnowledgeTimelineToRichContentDocument(timeline, options = {}) {
+/**
+ * Canonical persisted write surface for CompositionLink[].
+ * New saved shapes must serialize links under `composition.links`.
+ * Semantic guards persist only through `link.condition` as Json Logic.
+ * Operational delivery behavior remains under `link.policy` and must not be
+ * folded into the condition payload.
+ */
+function serializeCompositionLinks(links) {
     return {
-        kind: 'praxis.rich-content',
-        version: '1.0.0',
-        nodes: [
-            {
-                type: 'timeline',
-                id: `domain-knowledge-timeline:${timeline.changeSetId}`,
-                title: options.title ?? DEFAULT_TITLE$1,
-                emptyText: options.emptyText ?? DEFAULT_EMPTY_TEXT$1,
-                orientation: 'vertical',
-                position: 'right',
-                connectorVariant: 'solid',
-                connectorColor: 'neutral',
-                markerVariant: 'icon',
-                markerColor: 'info',
-                markerStyle: 'filled',
-                items: timeline.events
-                    .filter(isSafeTimelineEvent$1)
-                    .map((event, index) => mapTimelineEvent$1(event, index)),
-            },
-        ],
+        version: WIDGET_PAGE_COMPOSITION_SCHEMA_VERSION,
+        links: normalizeCompositionLinks(links),
     };
 }
-function isSafeTimelineEvent$1(event) {
-    return event.visibility === 'safe';
-}
-function mapTimelineEvent$1(event, index) {
-    const target = formatTarget$1(event);
-    const operations = formatOperations(event);
-    const meta = [target, operations].filter((value) => Boolean(value)).join(' | ');
+/**
+ * Writes the canonical persisted composition surface into a page shape.
+ * The canonical writer omits legacy `connections` to avoid dual-write ambiguity.
+ */
+function writeCompositionLinksToPersistedPage(page, links) {
+    const { composition: _legacyComposition, ...rest } = stripRuntimeOnlyState(clone$1(page), links);
     return {
-        id: `domain-knowledge-timeline-event:${index}:${event.eventType}`,
-        title: event.summary || event.eventType,
-        subtitle: event.actor ? `${event.actorType ?? 'actor'}: ${event.actor}` : event.actorType ?? undefined,
-        opposite: event.occurredAt ?? undefined,
-        meta: meta || undefined,
-        badge: event.validationStatus ?? event.status ?? event.eventType,
-        icon: iconForEvent$1(event.eventType),
-        markerColor: markerColorForEvent$1(event.eventType),
-        connectorColor: markerColorForEvent$1(event.eventType),
+        ...rest,
+        composition: serializeCompositionLinks(links),
     };
 }
-function formatTarget$1(event) {
-    const keys = event.targetConceptKeys?.filter(Boolean) ?? [];
-    if (!keys.length) {
-        return null;
-    }
-    return `${keys.length} governed concept${keys.length === 1 ? '' : 's'}`;
-}
-function formatOperations(event) {
-    const operationTypes = event.operationTypes?.filter(Boolean) ?? [];
-    if (!operationTypes.length && event.operationCount == null) {
-        return null;
-    }
-    const count = event.operationCount == null ? null : `${event.operationCount} operation${event.operationCount === 1 ? '' : 's'}`;
-    const types = operationTypes.length ? operationTypes.join(', ') : null;
-    return [count, types].filter((value) => Boolean(value)).join(': ') || null;
-}
-function iconForEvent$1(eventType) {
-    if (eventType.includes('applied')) {
-        return 'published_with_changes';
-    }
-    if (eventType.includes('approved')) {
-        return 'verified';
-    }
-    if (eventType.includes('rejected')) {
-        return 'block';
+function stripRuntimeOnlyState(page, links) {
+    const stateSchema = page.state?.schema || {};
+    const nonPersistentPaths = Object.keys(stateSchema)
+        .filter((path) => stateSchema[path]?.persist === false)
+        .map((path) => path.trim())
+        .filter(Boolean);
+    if (!nonPersistentPaths.length) {
+        return page;
     }
-    if (eventType.includes('validation')) {
-        return 'rule';
+    const next = clone$1(page);
+    if (next.state?.values) {
+        for (const path of nonPersistentPaths) {
+            removeValueAtPath(next.state.values, path);
+        }
     }
-    if (eventType.includes('created')) {
-        return 'add_circle';
+    const accessor = new NestedWidgetConfigAccessor();
+    for (const link of links) {
+        const source = link.from;
+        const target = link.to;
+        if (source.kind !== 'state' || target.kind !== 'component-port') {
+            continue;
+        }
+        if (!nonPersistentPaths.some((path) => isPathWithin(source.ref.path, path))) {
+            continue;
+        }
+        const widgetIndex = next.widgets?.findIndex((widget) => widget.key === target.ref.widget) ?? -1;
+        if (widgetIndex < 0 || !next.widgets) {
+            continue;
+        }
+        if (target.ref.nestedPath?.length) {
+            const result = accessor.removeNestedWidgetInput(next.widgets[widgetIndex], target.ref.nestedPath, target.ref.port);
+            if (result.changed) {
+                next.widgets[widgetIndex] = result.widget;
+            }
+            continue;
+        }
+        const inputPath = target.ref.bindingPath || target.ref.port;
+        const inputs = next.widgets[widgetIndex].definition.inputs;
+        if (inputs) {
+            removeValueAtPath(inputs, inputPath);
+        }
     }
-    return 'timeline';
+    return next;
 }
-function markerColorForEvent$1(eventType) {
-    if (eventType.includes('applied')) {
-        return 'success';
-    }
-    if (eventType.includes('approved')) {
-        return 'primary';
+function isPathWithin(candidate, parent) {
+    return candidate === parent || candidate.startsWith(`${parent}.`);
+}
+function removeValueAtPath(target, path) {
+    const segments = String(path || '')
+        .split('.')
+        .map((segment) => segment.trim())
+        .filter(Boolean);
+    if (!segments.length) {
+        return;
     }
-    if (eventType.includes('rejected')) {
-        return 'error';
+    let current = target;
+    for (const segment of segments.slice(0, -1)) {
+        const next = current[segment];
+        if (!next || typeof next !== 'object' || Array.isArray(next)) {
+            return;
+        }
+        current = next;
     }
-    if (eventType.includes('validation')) {
-        return 'warning';
+    delete current[segments[segments.length - 1]];
+}
+function normalizeEndpoint(endpoint) {
+    if (endpoint.kind === 'component-port') {
+        const nestedPath = normalizeNestedPath(endpoint.ref.nestedPath);
+        return {
+            kind: 'component-port',
+            ref: {
+                widget: endpoint.ref.widget,
+                port: endpoint.ref.port,
+                direction: endpoint.ref.direction,
+                ...(endpoint.ref.componentType ? { componentType: endpoint.ref.componentType } : {}),
+                ...(endpoint.ref.bindingPath ? { bindingPath: endpoint.ref.bindingPath } : {}),
+                ...(nestedPath.length ? { nestedPath } : {}),
+            },
+        };
     }
-    if (eventType.includes('created')) {
-        return 'info';
+    if (endpoint.kind === 'global-action') {
+        return {
+            kind: 'global-action',
+            ref: normalizeGlobalActionRef(endpoint.ref),
+        };
     }
-    return 'neutral';
+    return {
+        kind: 'state',
+        ref: {
+            path: endpoint.ref.path,
+            ...(endpoint.ref.layer ? { layer: endpoint.ref.layer } : {}),
+        },
+    };
 }
-
-const DEFAULT_TITLE = 'Governed decision timeline';
-const DEFAULT_EMPTY_TEXT = 'No safe timeline events published for this decision.';
-function domainRuleTimelineToRichContentDocument(timeline, options = {}) {
+function normalizeGlobalActionRef(ref) {
     return {
-        kind: 'praxis.rich-content',
-        version: '1.0.0',
-        nodes: [
-            {
-                type: 'timeline',
-                id: `domain-rule-timeline:${timeline.ruleDefinitionId}`,
-                title: options.title ?? DEFAULT_TITLE,
-                emptyText: options.emptyText ?? DEFAULT_EMPTY_TEXT,
-                orientation: 'vertical',
-                position: 'right',
-                connectorVariant: 'solid',
-                connectorColor: 'neutral',
-                markerVariant: 'icon',
-                markerColor: 'info',
-                markerStyle: 'filled',
-                items: timeline.events
-                    .filter(isSafeTimelineEvent)
-                    .map((event, index) => mapTimelineEvent(event, index)),
-            },
-        ],
+        actionId: String(ref.actionId || '').trim(),
+        ...(ref.payload !== undefined ? { payload: clone$1(ref.payload) } : {}),
+        ...(ref.payloadExpr ? { payloadExpr: String(ref.payloadExpr).trim() } : {}),
+        ...(ref.meta && typeof ref.meta === 'object' ? { meta: { ...ref.meta } } : {}),
     };
 }
-function isSafeTimelineEvent(event) {
-    return event.visibility === 'safe';
+function normalizeNestedPath(nestedPath) {
+    if (!nestedPath?.length) {
+        return [];
+    }
+    return nestedPath
+        .map((segment) => {
+        const normalized = {
+            kind: segment.kind,
+        };
+        if (segment.id) {
+            normalized.id = segment.id;
+        }
+        if (segment.key) {
+            normalized.key = segment.key;
+        }
+        if (typeof segment.index === 'number' && Number.isFinite(segment.index)) {
+            normalized.index = Math.trunc(segment.index);
+        }
+        if (segment.componentType) {
+            normalized.componentType = segment.componentType;
+        }
+        return normalized;
+    })
+        .filter((segment) => !!segment.kind
+        && (!!segment.id
+            || !!segment.key
+            || typeof segment.index === 'number'
+            || !!segment.componentType
+            || segment.kind === 'widget'
+            || STRUCTURAL_NESTED_PATH_KINDS$1.has(segment.kind)));
 }
-function mapTimelineEvent(event, index) {
-    const target = formatTarget(event);
-    const sourceHash = event.sourceHash ? `sourceHash: ${event.sourceHash}` : null;
-    const meta = [target, sourceHash].filter((value) => Boolean(value)).join(' | ');
-    return {
-        id: `domain-rule-timeline-event:${index}:${event.eventType}`,
-        title: event.summary || event.eventType,
-        subtitle: event.actor ? `${event.actorType ?? 'actor'}: ${event.actor}` : event.actorType ?? undefined,
-        opposite: event.occurredAt ?? undefined,
-        meta: meta || undefined,
-        badge: event.targetLayer ?? event.eventType,
-        icon: iconForEvent(event.eventType),
-        markerColor: markerColorForEvent(event.eventType),
-        connectorColor: markerColorForEvent(event.eventType),
-    };
+function normalizeCondition(condition) {
+    if (condition === undefined) {
+        return undefined;
+    }
+    if (condition === null) {
+        return null;
+    }
+    return clone$1(condition);
 }
-function formatTarget(event) {
-    const parts = [
-        event.targetLayer,
-        event.targetArtifactType,
-        event.targetArtifactKey,
-    ].filter((value) => Boolean(value));
-    return parts.length ? parts.join(' / ') : null;
+function normalizePolicy(policy) {
+    if (!policy) {
+        return undefined;
+    }
+    const normalized = {
+        ...(policy.debounceMs !== undefined ? { debounceMs: policy.debounceMs } : {}),
+        ...(policy.distinct !== undefined ? { distinct: policy.distinct } : {}),
+        ...(policy.distinctBy ? { distinctBy: policy.distinctBy } : {}),
+        ...(policy.delivery ? { delivery: policy.delivery } : {}),
+        ...(policy.missingValuePolicy ? { missingValuePolicy: policy.missingValuePolicy } : {}),
+        ...(policy.errorPolicy ? { errorPolicy: policy.errorPolicy } : {}),
+    };
+    return Object.keys(normalized).length ? normalized : undefined;
 }
-function iconForEvent(eventType) {
-    if (eventType.includes('materialization')) {
-        return 'deployed_code';
+function normalizeMetadata(metadata) {
+    if (!metadata) {
+        return undefined;
     }
-    if (eventType.includes('approved') || eventType.includes('activated')) {
-        return 'verified';
+    const tags = metadata.tags?.length
+        ? [...metadata.tags].sort((a, b) => a.localeCompare(b))
+        : undefined;
+    const source = metadata.source === 'legacy-widget-connection'
+        ? undefined
+        : metadata.source;
+    const normalized = {
+        ...(metadata.label ? { label: metadata.label } : {}),
+        ...(metadata.description ? { description: metadata.description } : {}),
+        ...(tags?.length ? { tags } : {}),
+        ...(metadata.deprecated !== undefined ? { deprecated: metadata.deprecated } : {}),
+        ...(source ? { source } : {}),
+    };
+    return Object.keys(normalized).length ? normalized : undefined;
+}
+function compareNormalizedLinks(a, b) {
+    return compareValues([
+        a.id,
+        a.intent,
+        endpointSortKey(a.from),
+        endpointSortKey(a.to),
+        JSON.stringify(a.condition ?? null),
+    ], [
+        b.id,
+        b.intent,
+        endpointSortKey(b.from),
+        endpointSortKey(b.to),
+        JSON.stringify(b.condition ?? null),
+    ]);
+}
+function endpointSortKey(endpoint) {
+    if (endpoint.kind === 'component-port') {
+        return [
+            endpoint.kind,
+            endpoint.ref.widget,
+            endpoint.ref.port,
+            endpoint.ref.direction,
+            endpoint.ref.bindingPath || '',
+            endpoint.ref.componentType || '',
+            JSON.stringify(normalizeNestedPath(endpoint.ref.nestedPath)),
+        ].join('|');
     }
-    if (eventType.includes('created')) {
-        return 'add_circle';
+    if (endpoint.kind === 'global-action') {
+        return [
+            endpoint.kind,
+            endpoint.ref.actionId,
+            endpoint.ref.payloadExpr || '',
+            JSON.stringify(endpoint.ref.payload ?? null),
+        ].join('|');
     }
-    return 'timeline';
+    return [
+        endpoint.kind,
+        endpoint.ref.path,
+        endpoint.ref.layer || '',
+    ].join('|');
 }
-function markerColorForEvent(eventType) {
-    if (eventType.includes('materialization') || eventType.includes('activated')) {
-        return 'success';
-    }
-    if (eventType.includes('approved')) {
-        return 'primary';
+function compareValues(left, right) {
+    for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+        const comparison = (left[index] || '').localeCompare(right[index] || '');
+        if (comparison !== 0) {
+            return comparison;
+        }
     }
-    if (eventType.includes('created')) {
-        return 'info';
+    return 0;
+}
+function clone$1(value) {
+    if (value == null || typeof value !== 'object') {
+        return value;
     }
-    return 'neutral';
+    return JSON.parse(JSON.stringify(value));
 }
 
-const PRAXIS_QUERY_FILTER_EXPRESSION_SCHEMA_VERSION = 'praxis.query-filter-expression.v1';
-const PRAXIS_QUERY_FILTER_GROUP_OPERATORS = new Set(['all', 'any']);
-const PRAXIS_QUERY_FILTER_PREDICATE_OPERATORS = new Set([
-    'equals',
-    'notEquals',
-    'in',
-    'notIn',
-    'contains',
-    'startsWith',
-    'between',
-    'gte',
-    'lte',
-    'isNull',
-    'isNotNull',
-]);
-const PRAXIS_QUERY_FILTER_PREDICATE_SOURCE_KINDS = new Set([
-    'selected-records',
-    'manual',
-    'workflow',
-    'current-context',
-]);
-const PRAXIS_QUERY_FILTER_GOVERNANCE_SOURCES = new Set([
-    'selected-records',
-    'manual',
-    'workflow',
-    'ai-authored',
-]);
-function normalizeRecord(record) {
-    if (!record || typeof record !== 'object')
-        return null;
-    const next = Object.entries(record).reduce((acc, [key, value]) => {
-        if (value === null || value === undefined)
-            return acc;
-        if (Array.isArray(value) && value.length === 0)
-            return acc;
-        if (typeof value === 'string' && value.trim() === '')
-            return acc;
-        acc[key] = value;
-        return acc;
-    }, {});
-    return Object.keys(next).length ? next : null;
+/** Utility: generate a random id using crypto.randomUUID or fallback. */
+function generateId() {
+    const g = globalThis.crypto?.randomUUID?.();
+    return g || `id_${Math.random().toString(36).slice(2, 10)}_${Date.now().toString(36)}`;
 }
-function isMeaningfulQueryFilterValue(value) {
-    if (value === null || value === undefined)
-        return false;
-    if (Array.isArray(value))
-        return value.some((item) => isMeaningfulQueryFilterValue(item));
-    if (typeof value === 'string')
-        return value.trim() !== '';
-    return true;
+/** Utility: build a natural key from identity fields. */
+function buildPageKey(identity) {
+    const app = sanitize(identity.appId || 'app');
+    const tenant = sanitize(identity.tenantId || '*');
+    const user = sanitize(identity.userId || '*');
+    const route = sanitize(identity.routePath || '/');
+    const locale = identity.locale ? `:${sanitize(identity.locale)}` : '';
+    return `${app}:${tenant}:${user}:${route}${locale}`;
 }
-function normalizeQueryFilterSource(source) {
-    if (!source || typeof source !== 'object')
-        return null;
-    const kind = typeof source['kind'] === 'string' ? source['kind'].trim() : '';
-    if (!PRAXIS_QUERY_FILTER_PREDICATE_SOURCE_KINDS.has(kind))
-        return null;
-    const field = typeof source['field'] === 'string' && source['field'].trim()
-        ? source['field'].trim()
-        : null;
-    const selectedIds = Array.isArray(source['selectedIds'])
-        ? source['selectedIds'].filter((id) => (typeof id === 'string' && id.trim() !== '') ||
-            (typeof id === 'number' && Number.isFinite(id)))
-        : [];
-    return {
-        kind: kind,
-        ...(field ? { field } : {}),
-        ...(selectedIds.length ? { selectedIds } : {}),
-    };
+function sanitize(s) {
+    return String(s).replace(/\s+/g, '_').replace(/[:]/g, '-');
 }
-function normalizeQueryFilterGovernance(governance) {
-    if (!governance || typeof governance !== 'object')
-        return null;
-    const source = typeof governance['source'] === 'string' ? governance['source'].trim() : '';
-    const decisionId = typeof governance['decisionId'] === 'string' && governance['decisionId'].trim()
-        ? governance['decisionId'].trim()
-        : null;
-    const explanation = typeof governance['explanation'] === 'string' && governance['explanation'].trim()
-        ? governance['explanation'].trim()
-        : null;
-    const next = {};
-    if (PRAXIS_QUERY_FILTER_GOVERNANCE_SOURCES.has(source)) {
-        next.source = source;
-    }
-    if (decisionId)
-        next.decisionId = decisionId;
-    if (explanation)
-        next.explanation = explanation;
-    return Object.keys(next).length ? next : null;
-}
-function normalizePraxisQueryFilterNode(node) {
-    if (!node || typeof node !== 'object')
-        return null;
-    const kind = typeof node['kind'] === 'string' ? node['kind'].trim() : '';
-    if (kind === 'group') {
-        const operator = typeof node['operator'] === 'string' ? node['operator'].trim() : '';
-        if (!PRAXIS_QUERY_FILTER_GROUP_OPERATORS.has(operator))
-            return null;
-        const clauses = Array.isArray(node['clauses'])
-            ? node['clauses']
-                .map((clause) => normalizePraxisQueryFilterNode(clause))
-                .filter((clause) => !!clause)
-            : [];
-        if (!clauses.length)
-            return null;
-        return {
-            kind: 'group',
-            operator: operator,
-            clauses,
-        };
-    }
-    if (kind === 'predicate') {
-        const field = typeof node['field'] === 'string' ? node['field'].trim() : '';
-        const operator = typeof node['operator'] === 'string' ? node['operator'].trim() : '';
-        if (!field || !PRAXIS_QUERY_FILTER_PREDICATE_OPERATORS.has(operator))
-            return null;
-        const values = Array.isArray(node['values'])
-            ? node['values'].filter((value) => isMeaningfulQueryFilterValue(value))
-            : [];
-        const hasValue = isMeaningfulQueryFilterValue(node['value']);
-        const label = typeof node['label'] === 'string' && node['label'].trim()
-            ? node['label'].trim()
-            : null;
-        const source = normalizeQueryFilterSource(node['source']);
-        return {
-            kind: 'predicate',
-            field,
-            operator: operator,
-            ...(hasValue ? { value: node['value'] } : {}),
-            ...(values.length ? { values } : {}),
-            ...(label ? { label } : {}),
-            ...(source ? { source } : {}),
-        };
+/**
+ * Ensure that each widget has a stable id. If missing, assigns a new one.
+ * Returns the new page definition (immutable) and an index by key/id.
+ */
+function ensurePageIds(page) {
+    const widgets = (page.widgets || []).map((w) => ({
+        id: w.id || generateId(),
+        ...w,
+    }));
+    const withIds = { ...page, widgets };
+    const byKey = new Map();
+    const byId = new Map();
+    for (const w of widgets) {
+        byKey.set(w.key, w);
+        byId.set(w.id, w);
     }
-    return null;
+    return { page: withIds, byKey, byId };
 }
-function normalizePraxisQueryFilterExpression(expression) {
-    if (!expression || typeof expression !== 'object')
-        return null;
-    if (expression.schemaVersion !== PRAXIS_QUERY_FILTER_EXPRESSION_SCHEMA_VERSION)
-        return null;
-    const root = normalizePraxisQueryFilterNode(expression.root);
-    if (!root)
-        return null;
-    const projection = expression.projection && typeof expression.projection === 'object'
-        ? {
-            filters: normalizeRecord(expression.projection.filters),
-            lossless: expression.projection.lossless === true,
-            reason: typeof expression.projection.reason === 'string' && expression.projection.reason.trim()
-                ? expression.projection.reason.trim()
-                : undefined,
-        }
-        : null;
-    const governance = normalizeQueryFilterGovernance(expression.governance);
+/**
+ * Create a persisted page record from an in-memory page definition and identity.
+ */
+function createPersistedPage(identity, page, opts) {
+    const persistedPage = writeCompositionLinksToPersistedPage(page, page.composition?.links || []);
+    const { page: pageWithIds } = ensurePageIds(persistedPage);
+    const now = new Date().toISOString();
     return {
-        schemaVersion: PRAXIS_QUERY_FILTER_EXPRESSION_SCHEMA_VERSION,
-        root,
-        ...(projection ? {
-            projection: {
-                ...(projection.filters ? { filters: projection.filters } : {}),
-                lossless: projection.lossless,
-                ...(projection.reason ? { reason: projection.reason } : {}),
+        id: opts?.id || generateId(),
+        key: buildPageKey(identity),
+        version: opts?.version || '1.0.0',
+        title: opts?.title,
+        description: opts?.description,
+        tags: opts?.tags || [],
+        identity,
+        status: opts?.status || 'draft',
+        page: pageWithIds,
+        owner: opts?.owner,
+        createdAt: now,
+        updatedAt: now,
+        parentId: opts?.parentId,
+    };
+}
+
+// Global configuration model for cross-library defaults
+// Designed to be minimal and avoid coupling to feature-library types
+
+// Global Dialog domain types for GlobalConfig (kept independent of @praxisui/dialog types)
+
+const DOMAIN_CATALOG_CONTEXT_HINT_SCHEMA_VERSION = 'praxis.ai.context-hints.domain-catalog/v0.2';
+
+const DEFAULT_TITLE$1 = 'Governed knowledge timeline';
+const DEFAULT_EMPTY_TEXT$1 = 'No safe timeline events published for this change-set.';
+function domainKnowledgeTimelineToRichContentDocument(timeline, options = {}) {
+    return {
+        kind: 'praxis.rich-content',
+        version: '1.0.0',
+        nodes: [
+            {
+                type: 'timeline',
+                id: `domain-knowledge-timeline:${timeline.changeSetId}`,
+                title: options.title ?? DEFAULT_TITLE$1,
+                emptyText: options.emptyText ?? DEFAULT_EMPTY_TEXT$1,
+                orientation: 'vertical',
+                position: 'right',
+                connectorVariant: 'solid',
+                connectorColor: 'neutral',
+                markerVariant: 'icon',
+                markerColor: 'info',
+                markerStyle: 'filled',
+                items: timeline.events
+                    .filter(isSafeTimelineEvent$1)
+                    .map((event, index) => mapTimelineEvent$1(event, index)),
             },
-        } : {}),
-        ...(governance ? { governance } : {}),
+        ],
     };
 }
-function normalizePraxisDataQueryContext(context) {
-    if (!context || typeof context !== 'object')
-        return null;
-    const filters = normalizeRecord(context.filters);
-    const filterExpression = normalizePraxisQueryFilterExpression(context.filterExpression);
-    const meta = normalizeRecord(context.meta);
-    const sort = Array.isArray(context.sort)
-        ? context.sort
-            .map((item) => (typeof item === 'string' ? item.trim() : ''))
-            .filter((item) => item.length > 0)
-        : [];
-    const limit = typeof context.limit === 'number' && Number.isFinite(context.limit)
-        ? Math.max(0, Math.trunc(context.limit))
-        : null;
-    const page = context.page && typeof context.page === 'object'
-        ? {
-            index: typeof context.page.index === 'number' && Number.isFinite(context.page.index)
-                ? Math.max(0, Math.trunc(context.page.index))
-                : null,
-            size: typeof context.page.size === 'number' && Number.isFinite(context.page.size)
-                ? Math.max(0, Math.trunc(context.page.size))
-                : null,
-        }
-        : null;
-    const next = {};
-    if (filters)
-        next.filters = filters;
-    if (filterExpression)
-        next.filterExpression = filterExpression;
-    if (sort.length)
-        next.sort = sort;
-    if (limit !== null)
-        next.limit = limit;
-    if (page && (page.index !== null || page.size !== null))
-        next.page = page;
-    if (meta)
-        next.meta = meta;
-    return Object.keys(next).length ? next : null;
+function isSafeTimelineEvent$1(event) {
+    return event.visibility === 'safe';
 }
-function resolvePraxisFilterCriteria(filterCriteria, queryContext) {
-    const normalizedFilterCriteria = normalizeRecord(filterCriteria);
-    const normalizedQueryContext = normalizePraxisDataQueryContext(queryContext);
+function mapTimelineEvent$1(event, index) {
+    const target = formatTarget$1(event);
+    const operations = formatOperations(event);
+    const meta = [target, operations].filter((value) => Boolean(value)).join(' | ');
     return {
-        ...(normalizedFilterCriteria || {}),
-        ...(normalizedQueryContext?.filters || {}),
+        id: `domain-knowledge-timeline-event:${index}:${event.eventType}`,
+        title: event.summary || event.eventType,
+        subtitle: event.actor ? `${event.actorType ?? 'actor'}: ${event.actor}` : event.actorType ?? undefined,
+        opposite: event.occurredAt ?? undefined,
+        meta: meta || undefined,
+        badge: event.validationStatus ?? event.status ?? event.eventType,
+        icon: iconForEvent$1(event.eventType),
+        markerColor: markerColorForEvent$1(event.eventType),
+        connectorColor: markerColorForEvent$1(event.eventType),
     };
 }
+function formatTarget$1(event) {
+    const keys = event.targetConceptKeys?.filter(Boolean) ?? [];
+    if (!keys.length) {
+        return null;
+    }
+    return `${keys.length} governed concept${keys.length === 1 ? '' : 's'}`;
+}
+function formatOperations(event) {
+    const operationTypes = event.operationTypes?.filter(Boolean) ?? [];
+    if (!operationTypes.length && event.operationCount == null) {
+        return null;
+    }
+    const count = event.operationCount == null ? null : `${event.operationCount} operation${event.operationCount === 1 ? '' : 's'}`;
+    const types = operationTypes.length ? operationTypes.join(', ') : null;
+    return [count, types].filter((value) => Boolean(value)).join(': ') || null;
+}
+function iconForEvent$1(eventType) {
+    if (eventType.includes('applied')) {
+        return 'published_with_changes';
+    }
+    if (eventType.includes('approved')) {
+        return 'verified';
+    }
+    if (eventType.includes('rejected')) {
+        return 'block';
+    }
+    if (eventType.includes('validation')) {
+        return 'rule';
+    }
+    if (eventType.includes('created')) {
+        return 'add_circle';
+    }
+    return 'timeline';
+}
+function markerColorForEvent$1(eventType) {
+    if (eventType.includes('applied')) {
+        return 'success';
+    }
+    if (eventType.includes('approved')) {
+        return 'primary';
+    }
+    if (eventType.includes('rejected')) {
+        return 'error';
+    }
+    if (eventType.includes('validation')) {
+        return 'warning';
+    }
+    if (eventType.includes('created')) {
+        return 'info';
+    }
+    return 'neutral';
+}
 
-const DEFAULT_FIELD_SELECTOR_CONTROL_TYPE_MAP = {
-    'pdx-text-input': FieldControlType.INPUT,
+const DEFAULT_TITLE = 'Governed decision timeline';
+const DEFAULT_EMPTY_TEXT = 'No safe timeline events published for this decision.';
+function domainRuleTimelineToRichContentDocument(timeline, options = {}) {
+    return {
+        kind: 'praxis.rich-content',
+        version: '1.0.0',
+        nodes: [
+            {
+                type: 'timeline',
+                id: `domain-rule-timeline:${timeline.ruleDefinitionId}`,
+                title: options.title ?? DEFAULT_TITLE,
+                emptyText: options.emptyText ?? DEFAULT_EMPTY_TEXT,
+                orientation: 'vertical',
+                position: 'right',
+                connectorVariant: 'solid',
+                connectorColor: 'neutral',
+                markerVariant: 'icon',
+                markerColor: 'info',
+                markerStyle: 'filled',
+                items: timeline.events
+                    .filter(isSafeTimelineEvent)
+                    .map((event, index) => mapTimelineEvent(event, index)),
+            },
+        ],
+    };
+}
+function isSafeTimelineEvent(event) {
+    return event.visibility === 'safe';
+}
+function mapTimelineEvent(event, index) {
+    const target = formatTarget(event);
+    const sourceHash = event.sourceHash ? `sourceHash: ${event.sourceHash}` : null;
+    const meta = [target, sourceHash].filter((value) => Boolean(value)).join(' | ');
+    return {
+        id: `domain-rule-timeline-event:${index}:${event.eventType}`,
+        title: event.summary || event.eventType,
+        subtitle: event.actor ? `${event.actorType ?? 'actor'}: ${event.actor}` : event.actorType ?? undefined,
+        opposite: event.occurredAt ?? undefined,
+        meta: meta || undefined,
+        badge: event.targetLayer ?? event.eventType,
+        icon: iconForEvent(event.eventType),
+        markerColor: markerColorForEvent(event.eventType),
+        connectorColor: markerColorForEvent(event.eventType),
+    };
+}
+function formatTarget(event) {
+    const parts = [
+        event.targetLayer,
+        event.targetArtifactType,
+        event.targetArtifactKey,
+    ].filter((value) => Boolean(value));
+    return parts.length ? parts.join(' / ') : null;
+}
+function iconForEvent(eventType) {
+    if (eventType.includes('materialization')) {
+        return 'deployed_code';
+    }
+    if (eventType.includes('approved') || eventType.includes('activated')) {
+        return 'verified';
+    }
+    if (eventType.includes('created')) {
+        return 'add_circle';
+    }
+    return 'timeline';
+}
+function markerColorForEvent(eventType) {
+    if (eventType.includes('materialization') || eventType.includes('activated')) {
+        return 'success';
+    }
+    if (eventType.includes('approved')) {
+        return 'primary';
+    }
+    if (eventType.includes('created')) {
+        return 'info';
+    }
+    return 'neutral';
+}
+
+const PRAXIS_QUERY_FILTER_EXPRESSION_SCHEMA_VERSION = 'praxis.query-filter-expression.v1';
+const PRAXIS_QUERY_FILTER_GROUP_OPERATORS = new Set(['all', 'any']);
+const PRAXIS_QUERY_FILTER_PREDICATE_OPERATORS = new Set([
+    'equals',
+    'notEquals',
+    'in',
+    'notIn',
+    'contains',
+    'startsWith',
+    'between',
+    'gte',
+    'lte',
+    'isNull',
+    'isNotNull',
+]);
+const PRAXIS_QUERY_FILTER_PREDICATE_SOURCE_KINDS = new Set([
+    'selected-records',
+    'manual',
+    'workflow',
+    'current-context',
+]);
+const PRAXIS_QUERY_FILTER_GOVERNANCE_SOURCES = new Set([
+    'selected-records',
+    'manual',
+    'workflow',
+    'ai-authored',
+]);
+function normalizeRecord(record) {
+    if (!record || typeof record !== 'object')
+        return null;
+    const next = Object.entries(record).reduce((acc, [key, value]) => {
+        if (value === null || value === undefined)
+            return acc;
+        if (Array.isArray(value) && value.length === 0)
+            return acc;
+        if (typeof value === 'string' && value.trim() === '')
+            return acc;
+        acc[key] = value;
+        return acc;
+    }, {});
+    return Object.keys(next).length ? next : null;
+}
+function isMeaningfulQueryFilterValue(value) {
+    if (value === null || value === undefined)
+        return false;
+    if (Array.isArray(value))
+        return value.some((item) => isMeaningfulQueryFilterValue(item));
+    if (typeof value === 'string')
+        return value.trim() !== '';
+    return true;
+}
+function normalizeQueryFilterSource(source) {
+    if (!source || typeof source !== 'object')
+        return null;
+    const kind = typeof source['kind'] === 'string' ? source['kind'].trim() : '';
+    if (!PRAXIS_QUERY_FILTER_PREDICATE_SOURCE_KINDS.has(kind))
+        return null;
+    const field = typeof source['field'] === 'string' && source['field'].trim()
+        ? source['field'].trim()
+        : null;
+    const selectedIds = Array.isArray(source['selectedIds'])
+        ? source['selectedIds'].filter((id) => (typeof id === 'string' && id.trim() !== '') ||
+            (typeof id === 'number' && Number.isFinite(id)))
+        : [];
+    return {
+        kind: kind,
+        ...(field ? { field } : {}),
+        ...(selectedIds.length ? { selectedIds } : {}),
+    };
+}
+function normalizeQueryFilterGovernance(governance) {
+    if (!governance || typeof governance !== 'object')
+        return null;
+    const source = typeof governance['source'] === 'string' ? governance['source'].trim() : '';
+    const decisionId = typeof governance['decisionId'] === 'string' && governance['decisionId'].trim()
+        ? governance['decisionId'].trim()
+        : null;
+    const explanation = typeof governance['explanation'] === 'string' && governance['explanation'].trim()
+        ? governance['explanation'].trim()
+        : null;
+    const next = {};
+    if (PRAXIS_QUERY_FILTER_GOVERNANCE_SOURCES.has(source)) {
+        next.source = source;
+    }
+    if (decisionId)
+        next.decisionId = decisionId;
+    if (explanation)
+        next.explanation = explanation;
+    return Object.keys(next).length ? next : null;
+}
+function normalizePraxisQueryFilterNode(node) {
+    if (!node || typeof node !== 'object')
+        return null;
+    const kind = typeof node['kind'] === 'string' ? node['kind'].trim() : '';
+    if (kind === 'group') {
+        const operator = typeof node['operator'] === 'string' ? node['operator'].trim() : '';
+        if (!PRAXIS_QUERY_FILTER_GROUP_OPERATORS.has(operator))
+            return null;
+        const clauses = Array.isArray(node['clauses'])
+            ? node['clauses']
+                .map((clause) => normalizePraxisQueryFilterNode(clause))
+                .filter((clause) => !!clause)
+            : [];
+        if (!clauses.length)
+            return null;
+        return {
+            kind: 'group',
+            operator: operator,
+            clauses,
+        };
+    }
+    if (kind === 'predicate') {
+        const field = typeof node['field'] === 'string' ? node['field'].trim() : '';
+        const operator = typeof node['operator'] === 'string' ? node['operator'].trim() : '';
+        if (!field || !PRAXIS_QUERY_FILTER_PREDICATE_OPERATORS.has(operator))
+            return null;
+        const values = Array.isArray(node['values'])
+            ? node['values'].filter((value) => isMeaningfulQueryFilterValue(value))
+            : [];
+        const hasValue = isMeaningfulQueryFilterValue(node['value']);
+        const label = typeof node['label'] === 'string' && node['label'].trim()
+            ? node['label'].trim()
+            : null;
+        const source = normalizeQueryFilterSource(node['source']);
+        return {
+            kind: 'predicate',
+            field,
+            operator: operator,
+            ...(hasValue ? { value: node['value'] } : {}),
+            ...(values.length ? { values } : {}),
+            ...(label ? { label } : {}),
+            ...(source ? { source } : {}),
+        };
+    }
+    return null;
+}
+function normalizePraxisQueryFilterExpression(expression) {
+    if (!expression || typeof expression !== 'object')
+        return null;
+    if (expression.schemaVersion !== PRAXIS_QUERY_FILTER_EXPRESSION_SCHEMA_VERSION)
+        return null;
+    const root = normalizePraxisQueryFilterNode(expression.root);
+    if (!root)
+        return null;
+    const projection = expression.projection && typeof expression.projection === 'object'
+        ? {
+            filters: normalizeRecord(expression.projection.filters),
+            lossless: expression.projection.lossless === true,
+            reason: typeof expression.projection.reason === 'string' && expression.projection.reason.trim()
+                ? expression.projection.reason.trim()
+                : undefined,
+        }
+        : null;
+    const governance = normalizeQueryFilterGovernance(expression.governance);
+    return {
+        schemaVersion: PRAXIS_QUERY_FILTER_EXPRESSION_SCHEMA_VERSION,
+        root,
+        ...(projection ? {
+            projection: {
+                ...(projection.filters ? { filters: projection.filters } : {}),
+                lossless: projection.lossless,
+                ...(projection.reason ? { reason: projection.reason } : {}),
+            },
+        } : {}),
+        ...(governance ? { governance } : {}),
+    };
+}
+function normalizePraxisDataQueryContext(context) {
+    if (!context || typeof context !== 'object')
+        return null;
+    const filters = normalizeRecord(context.filters);
+    const filterExpression = normalizePraxisQueryFilterExpression(context.filterExpression);
+    const meta = normalizeRecord(context.meta);
+    const sort = Array.isArray(context.sort)
+        ? context.sort
+            .map((item) => (typeof item === 'string' ? item.trim() : ''))
+            .filter((item) => item.length > 0)
+        : [];
+    const limit = typeof context.limit === 'number' && Number.isFinite(context.limit)
+        ? Math.max(0, Math.trunc(context.limit))
+        : null;
+    const page = context.page && typeof context.page === 'object'
+        ? {
+            index: typeof context.page.index === 'number' && Number.isFinite(context.page.index)
+                ? Math.max(0, Math.trunc(context.page.index))
+                : null,
+            size: typeof context.page.size === 'number' && Number.isFinite(context.page.size)
+                ? Math.max(0, Math.trunc(context.page.size))
+                : null,
+        }
+        : null;
+    const next = {};
+    if (filters)
+        next.filters = filters;
+    if (filterExpression)
+        next.filterExpression = filterExpression;
+    if (sort.length)
+        next.sort = sort;
+    if (limit !== null)
+        next.limit = limit;
+    if (page && (page.index !== null || page.size !== null))
+        next.page = page;
+    if (meta)
+        next.meta = meta;
+    return Object.keys(next).length ? next : null;
+}
+function resolvePraxisFilterCriteria(filterCriteria, queryContext) {
+    const normalizedFilterCriteria = normalizeRecord(filterCriteria);
+    const normalizedQueryContext = normalizePraxisDataQueryContext(queryContext);
+    return {
+        ...(normalizedFilterCriteria || {}),
+        ...(normalizedQueryContext?.filters || {}),
+    };
+}
+
+const DEFAULT_FIELD_SELECTOR_CONTROL_TYPE_MAP = {
+    'pdx-text-input': FieldControlType.INPUT,
     'pdx-email-input': FieldControlType.EMAIL_INPUT,
     'pdx-password-input': FieldControlType.PASSWORD,
     'pdx-color-input': FieldControlType.COLOR_INPUT,
@@ -28973,457 +29361,175 @@ const DOMAIN_CATALOG_COMPONENT_CONTEXT_PACK = {
         'domainCatalog.items[].payload.aiUsage.visibility': {
             mode: 'suggested',
             options: [
-                { value: 'public', label: 'Visible to public AI tasks' },
-                { value: 'internal', label: 'Visible to internal AI tasks' },
-                { value: 'restricted', label: 'Restricted AI visibility' },
-                { value: 'forbidden', label: 'Forbidden for AI use' },
-            ],
-        },
-    },
-    actionCatalog: [
-        {
-            id: 'domainCatalog.release.list',
-            operation: 'read',
-            scope: 'GLOBAL',
-            intentExamples: ['domain catalog releases', 'listar releases de dominio', 'catalogo semantico'],
-            patchTemplate: {},
-            safetyNotes: 'Read-only operation. Use DomainCatalogService.listReleases; do not write FormConfig or component config with returned governance rules.',
-        },
-        {
-            id: 'domainCatalog.governanceContext.read',
-            operation: 'read',
-            scope: 'GLOBAL',
-            valueType: 'OBJECT',
-            intentExamples: ['governanca', 'LGPD', 'GDPR', 'dados sensiveis', 'ai visibility'],
-            params: [
-                { name: 'resourceKey', type: 'STRING', description: 'Stable semantic resource key, for example human-resources.funcionarios.' },
-                { name: 'query', type: 'STRING', description: 'Field or concept probe, for example cpf, salario or status.' },
-            ],
-            patchTemplate: {},
-            safetyNotes: 'Read-only operation. Resolve governance through DomainCatalogService.getGovernanceContext(resourceKey, query) before proposing UI, rule or AI-use changes.',
-        },
-        {
-            id: 'contextHints.domainCatalog.forward',
-            operation: 'read',
-            scope: 'GLOBAL',
-            valueType: 'OBJECT',
-            intentExamples: ['contextHints.domainCatalog', 'authoring hints', 'semantic retrieval hint', 'llm domain context'],
-            params: [
-                { name: 'serviceKey', type: 'STRING', description: 'Semantic owner service, for example praxis-service.' },
-                { name: 'resourceKey', type: 'STRING', description: 'Stable semantic resource key, for example human-resources.funcionarios.' },
-                { name: 'type', type: 'STRING', description: 'Canonical item focus: context, node, edge, binding, evidence, governance, vocabulary or relationship.' },
-                { name: 'intent', type: 'STRING', description: 'Retrieval purpose: authoring, explain, validate or ai-access-control.' },
-                { name: 'query', type: 'STRING', description: 'Business query used to retrieve relevant domain context.' },
-            ],
-            patchTemplate: {
-                contextHints: {
-                    domainCatalog: {
-                        schemaVersion: 'praxis.ai.context-hints.domain-catalog/v0.2',
-                        recommendedAuthoringFlow: 'shared_rule_authoring',
-                        recommendedRuleType: 'privacy',
-                        serviceKey: '<serviceKey>',
-                        resourceKey: '<resourceKey>',
-                        type: 'governance',
-                        itemTypes: ['governance'],
-                        intent: 'authoring',
-                        query: '<business query>',
-                        limit: 12,
-                        relationships: {
-                            enabled: true,
-                            federated: true,
-                            query: '<business query>',
-                            limit: 8,
-                        },
-                    },
-                },
-            },
-            safetyNotes: 'Forward these hints to AI authoring calls as runtime retrieval context. Do not convert them into executable rules or persist them as FormConfig unless an approved backend materialization flow says so.',
-        },
-    ],
-    fieldResolvers: {
-        resourceKey: [
-            'Prefer backend-provided resourceKey from surfaces, actions, capabilities or api_metadata.',
-            'Do not derive resourceKey from resource.path when discovery already returned a stable semantic key.',
-        ],
-        governanceProbe: [
-            'Use the business field/concept name as query: cpf, salario, status, email, documento.',
-            'Keep probes narrow; request more context instead of loading every governance item into a prompt.',
-        ],
+                { value: 'public', label: 'Visible to public AI tasks' },
+                { value: 'internal', label: 'Visible to internal AI tasks' },
+                { value: 'restricted', label: 'Restricted AI visibility' },
+                { value: 'forbidden', label: 'Forbidden for AI use' },
+            ],
+        },
     },
-    hints: [
-        'Domain Catalog is a runtime semantic/governance context source, not a FormConfig rule store.',
-        'Use DomainCatalogService for read-only lookup of domain vocabulary, relationships and governance items.',
-        'LLM tasks must treat aiUsage.visibility and complianceTags as prompt/data-access constraints before generating patches.',
-        'Use contextHints.domainCatalog with schemaVersion praxis.ai.context-hints.domain-catalog/v0.2 to share runtime semantic retrieval intent between frontend and backend.',
-        'Shared domain rules may be referenced by resourceKey and catalog release, but should not be copied into component JSON unless intentionally materialized by a backend policy.',
-    ],
-};
-
-const OWNER_EVENT_SEGMENT_KINDS = new Set(['tabs', 'expansion', 'stepper']);
-const STRUCTURAL_NESTED_PATH_KINDS = new Set([
-    'nav',
-]);
-function normalizeWidgetEventPath(event, options = {}) {
-    const normalized = [];
-    const sourceChildWidgetKey = normalizeString(event.sourceChildWidgetKey);
-    const sourceComponentId = normalizeString(event.sourceComponentId);
-    for (const [index, segment] of (event.path || []).entries()) {
-        if (isOwnerEventSegment(segment, index, options)) {
-            continue;
-        }
-        const normalizedSegment = normalizeEventSegment(segment);
-        if (normalizedSegment) {
-            normalized.push(normalizedSegment);
-        }
-    }
-    const terminal = normalized[normalized.length - 1];
-    if (terminal?.kind === 'widget') {
-        if (!terminal.key && sourceChildWidgetKey) {
-            terminal.key = sourceChildWidgetKey;
-        }
-        if (!terminal.componentType && sourceComponentId) {
-            terminal.componentType = sourceComponentId;
-        }
-        return stripEmptySegments(normalized);
-    }
-    if (sourceChildWidgetKey) {
-        normalized.push({
-            kind: 'widget',
-            key: sourceChildWidgetKey,
-            ...(sourceComponentId ? { componentType: sourceComponentId } : {}),
-        });
-    }
-    return stripEmptySegments(normalized);
-}
-function normalizeEventSegment(segment) {
-    if (segment.kind === 'tabs') {
-        return null;
-    }
-    const kind = segment.kind === 'widget'
-        ? 'widget'
-        : segment.kind;
-    const key = normalizeString(segment.key);
-    const id = normalizeString(segment.id);
-    const componentType = normalizeString(segment.componentType);
-    const normalized = { kind };
-    if (id) {
-        normalized.id = id;
-    }
-    if (key) {
-        normalized.key = key;
-    }
-    if (typeof segment.index === 'number' && Number.isFinite(segment.index)) {
-        normalized.index = Math.trunc(segment.index);
-    }
-    if (componentType) {
-        normalized.componentType = componentType;
-    }
-    return normalized;
-}
-function isOwnerEventSegment(segment, index, options) {
-    if (index !== 0 || !OWNER_EVENT_SEGMENT_KINDS.has(segment.kind)) {
-        return false;
-    }
-    const ownerComponentId = normalizeString(options.ownerComponentId);
-    if (!ownerComponentId) {
-        return true;
-    }
-    return segment.kind === ownerComponentId
-        || segment.id === ownerComponentId;
-}
-function stripEmptySegments(segments) {
-    return segments.filter((segment) => !!segment.kind
-        && (segment.kind === 'widget'
-            || STRUCTURAL_NESTED_PATH_KINDS.has(segment.kind)
-            || !!segment.id
-            || !!segment.key
-            || typeof segment.index === 'number'
-            || !!segment.componentType));
-}
-function normalizeString(value) {
-    return typeof value === 'string' ? value.trim() : '';
-}
-
-class NestedWidgetConfigAccessor {
-    listNestedWidgets(owner) {
-        return this.listNestedWidgetsInDefinition(owner.key, owner.definition, []);
-    }
-    resolveNestedWidget(owner, nestedPath) {
-        if (!nestedPath?.length) {
-            return undefined;
-        }
-        return this.resolveNestedWidgetInDefinition(owner.definition, nestedPath);
-    }
-    setNestedWidgetInput(owner, nestedPath, inputName, value) {
-        const normalizedInputName = String(inputName || '').trim();
-        if (!nestedPath?.length || !normalizedInputName) {
-            return { widget: this.clone(owner), changed: false };
-        }
-        const next = this.clone(owner);
-        const changed = this.setNestedWidgetInputInDefinition(next.definition, nestedPath, normalizedInputName, this.clone(value));
-        return { widget: next, changed };
-    }
-    listNestedWidgetsInDefinition(ownerWidgetKey, definition, basePath) {
-        const results = [];
-        for (const location of this.listChildWidgetLocations(definition)) {
-            for (const [index, widget] of location.widgets.entries()) {
-                if (!this.isWidgetDefinition(widget)) {
-                    continue;
-                }
-                const childWidgetKey = this.resolveChildWidgetKey(widget);
-                const widgetSegment = {
-                    kind: 'widget',
-                    ...(childWidgetKey ? { key: childWidgetKey } : { index }),
-                    componentType: widget.id,
-                };
-                const nestedPath = [
-                    ...basePath,
-                    ...location.path,
-                    widgetSegment,
-                ];
-                results.push({
-                    ownerWidgetKey,
-                    nestedPath,
-                    widget: this.clone(widget),
-                    componentId: widget.id,
-                    childWidgetKey,
-                });
-                results.push(...this.listNestedWidgetsInDefinition(ownerWidgetKey, widget, nestedPath));
-            }
-        }
-        return results;
-    }
-    resolveNestedWidgetInDefinition(definition, nestedPath) {
-        const location = this.resolveWidgetArrayLocation(definition, nestedPath, 0);
-        if (!location) {
-            return undefined;
-        }
-        const widgetSegment = nestedPath[location.segmentCount];
-        if (widgetSegment?.kind !== 'widget' || !widgetSegment.key) {
-            return undefined;
-        }
-        const child = location.widgets.find((widget) => widget.childWidgetKey === widgetSegment.key);
-        if (!this.isWidgetDefinition(child)) {
-            return undefined;
-        }
-        const remaining = nestedPath.slice(location.segmentCount + 1);
-        if (!remaining.length) {
-            return this.clone(child);
-        }
-        return this.resolveNestedWidgetInDefinition(child, remaining);
-    }
-    setNestedWidgetInputInDefinition(definition, nestedPath, inputName, value) {
-        const location = this.resolveWidgetArrayLocation(definition, nestedPath, 0);
-        if (!location) {
-            return false;
-        }
-        const widgetSegment = nestedPath[location.segmentCount];
-        if (widgetSegment?.kind !== 'widget' || !widgetSegment.key) {
-            return false;
-        }
-        const widgetIndex = location.widgets.findIndex((widget) => widget.childWidgetKey === widgetSegment.key);
-        if (widgetIndex < 0) {
-            return false;
-        }
-        const remaining = nestedPath.slice(location.segmentCount + 1);
-        const child = location.widgets[widgetIndex];
-        if (!this.isWidgetDefinition(child)) {
-            return false;
-        }
-        if (remaining.length) {
-            return this.setNestedWidgetInputInDefinition(child, remaining, inputName, value);
-        }
-        const currentInputs = child.inputs || {};
-        const nextInputs = {
-            ...currentInputs,
-            [inputName]: value,
-        };
-        if (this.isEqual(currentInputs, nextInputs)) {
-            return false;
-        }
-        location.widgets[widgetIndex] = {
-            ...child,
-            inputs: nextInputs,
-        };
-        return true;
-    }
-    listChildWidgetLocations(definition) {
-        const config = definition.inputs?.['config'];
-        if (!config || typeof config !== 'object') {
-            return [];
-        }
-        if (definition.id === 'praxis-tabs') {
-            return this.listTabsWidgetLocations(config);
-        }
-        if (definition.id === 'praxis-expansion') {
-            return this.listExpansionWidgetLocations(config);
-        }
-        return [];
-    }
-    listTabsWidgetLocations(config) {
-        const locations = [];
-        const tabs = Array.isArray(config['tabs']) ? config['tabs'] : [];
-        for (const [index, tab] of tabs.entries()) {
-            if (!tab || typeof tab !== 'object') {
-                continue;
-            }
-            const widgets = this.asWidgetDefinitions(tab['widgets']);
-            if (!widgets.some((widget) => this.isWidgetDefinition(widget))) {
-                continue;
-            }
-            locations.push({
-                path: [{
-                        kind: 'tab',
-                        ...this.segmentIdentity(tab, index),
-                    }],
-                widgets,
-            });
-        }
-        const nav = config['nav'];
-        const links = nav && typeof nav === 'object' && Array.isArray(nav['links'])
-            ? nav['links']
-            : [];
-        for (const [index, link] of links.entries()) {
-            if (!link || typeof link !== 'object') {
-                continue;
-            }
-            const widgets = this.asWidgetDefinitions(link['widgets']);
-            if (!widgets.some((widget) => this.isWidgetDefinition(widget))) {
-                continue;
-            }
-            locations.push({
-                path: [
-                    { kind: 'nav' },
-                    {
-                        kind: 'link',
-                        ...this.segmentIdentity(link, index),
+    actionCatalog: [
+        {
+            id: 'domainCatalog.release.list',
+            operation: 'read',
+            scope: 'GLOBAL',
+            intentExamples: ['domain catalog releases', 'listar releases de dominio', 'catalogo semantico'],
+            patchTemplate: {},
+            safetyNotes: 'Read-only operation. Use DomainCatalogService.listReleases; do not write FormConfig or component config with returned governance rules.',
+        },
+        {
+            id: 'domainCatalog.governanceContext.read',
+            operation: 'read',
+            scope: 'GLOBAL',
+            valueType: 'OBJECT',
+            intentExamples: ['governanca', 'LGPD', 'GDPR', 'dados sensiveis', 'ai visibility'],
+            params: [
+                { name: 'resourceKey', type: 'STRING', description: 'Stable semantic resource key, for example human-resources.funcionarios.' },
+                { name: 'query', type: 'STRING', description: 'Field or concept probe, for example cpf, salario or status.' },
+            ],
+            patchTemplate: {},
+            safetyNotes: 'Read-only operation. Resolve governance through DomainCatalogService.getGovernanceContext(resourceKey, query) before proposing UI, rule or AI-use changes.',
+        },
+        {
+            id: 'contextHints.domainCatalog.forward',
+            operation: 'read',
+            scope: 'GLOBAL',
+            valueType: 'OBJECT',
+            intentExamples: ['contextHints.domainCatalog', 'authoring hints', 'semantic retrieval hint', 'llm domain context'],
+            params: [
+                { name: 'serviceKey', type: 'STRING', description: 'Semantic owner service, for example praxis-service.' },
+                { name: 'resourceKey', type: 'STRING', description: 'Stable semantic resource key, for example human-resources.funcionarios.' },
+                { name: 'type', type: 'STRING', description: 'Canonical item focus: context, node, edge, binding, evidence, governance, vocabulary or relationship.' },
+                { name: 'intent', type: 'STRING', description: 'Retrieval purpose: authoring, explain, validate or ai-access-control.' },
+                { name: 'query', type: 'STRING', description: 'Business query used to retrieve relevant domain context.' },
+            ],
+            patchTemplate: {
+                contextHints: {
+                    domainCatalog: {
+                        schemaVersion: 'praxis.ai.context-hints.domain-catalog/v0.2',
+                        recommendedAuthoringFlow: 'shared_rule_authoring',
+                        recommendedRuleType: 'privacy',
+                        serviceKey: '<serviceKey>',
+                        resourceKey: '<resourceKey>',
+                        type: 'governance',
+                        itemTypes: ['governance'],
+                        intent: 'authoring',
+                        query: '<business query>',
+                        limit: 12,
+                        relationships: {
+                            enabled: true,
+                            federated: true,
+                            query: '<business query>',
+                            limit: 8,
+                        },
                     },
-                ],
-                widgets,
-            });
-        }
-        return locations;
-    }
-    listExpansionWidgetLocations(config) {
-        const panels = Array.isArray(config['panels']) ? config['panels'] : [];
-        const locations = [];
-        for (const [index, panel] of panels.entries()) {
-            if (!panel || typeof panel !== 'object') {
-                continue;
-            }
-            const widgets = this.asWidgetDefinitions(panel['widgets']);
-            if (!widgets.some((widget) => this.isWidgetDefinition(widget))) {
-                continue;
-            }
-            locations.push({
-                path: [{
-                        kind: 'panel',
-                        ...this.segmentIdentity(panel, index),
-                    }],
-                widgets,
-            });
-        }
-        return locations;
-    }
-    resolveWidgetArrayLocation(definition, nestedPath, offset) {
-        if (definition.id === 'praxis-tabs') {
-            return this.resolveTabsWidgetArray(definition, nestedPath, offset);
+                },
+            },
+            safetyNotes: 'Forward these hints to AI authoring calls as runtime retrieval context. Do not convert them into executable rules or persist them as FormConfig unless an approved backend materialization flow says so.',
+        },
+    ],
+    fieldResolvers: {
+        resourceKey: [
+            'Prefer backend-provided resourceKey from surfaces, actions, capabilities or api_metadata.',
+            'Do not derive resourceKey from resource.path when discovery already returned a stable semantic key.',
+        ],
+        governanceProbe: [
+            'Use the business field/concept name as query: cpf, salario, status, email, documento.',
+            'Keep probes narrow; request more context instead of loading every governance item into a prompt.',
+        ],
+    },
+    hints: [
+        'Domain Catalog is a runtime semantic/governance context source, not a FormConfig rule store.',
+        'Use DomainCatalogService for read-only lookup of domain vocabulary, relationships and governance items.',
+        'LLM tasks must treat aiUsage.visibility and complianceTags as prompt/data-access constraints before generating patches.',
+        'Use contextHints.domainCatalog with schemaVersion praxis.ai.context-hints.domain-catalog/v0.2 to share runtime semantic retrieval intent between frontend and backend.',
+        'Shared domain rules may be referenced by resourceKey and catalog release, but should not be copied into component JSON unless intentionally materialized by a backend policy.',
+    ],
+};
+
+const OWNER_EVENT_SEGMENT_KINDS = new Set(['tabs', 'expansion', 'stepper']);
+const STRUCTURAL_NESTED_PATH_KINDS = new Set([
+    'nav',
+]);
+function normalizeWidgetEventPath(event, options = {}) {
+    const normalized = [];
+    const sourceChildWidgetKey = normalizeString(event.sourceChildWidgetKey);
+    const sourceComponentId = normalizeString(event.sourceComponentId);
+    for (const [index, segment] of (event.path || []).entries()) {
+        if (isOwnerEventSegment(segment, index, options)) {
+            continue;
         }
-        if (definition.id === 'praxis-expansion') {
-            return this.resolveExpansionWidgetArray(definition, nestedPath, offset);
+        const normalizedSegment = normalizeEventSegment(segment);
+        if (normalizedSegment) {
+            normalized.push(normalizedSegment);
         }
-        return undefined;
     }
-    resolveTabsWidgetArray(definition, nestedPath, offset) {
-        const config = definition.inputs?.['config'];
-        if (!config || typeof config !== 'object') {
-            return undefined;
-        }
-        const first = nestedPath[offset];
-        if (first?.kind === 'tab') {
-            const tabs = Array.isArray(config['tabs'])
-                ? config['tabs']
-                : [];
-            const tab = this.findBySegment(tabs, first);
-            const widgets = tab && typeof tab === 'object'
-                ? this.asWidgetDefinitions(tab['widgets'])
-                : [];
-            return widgets.length ? { widgets, segmentCount: offset + 1 } : undefined;
+    const terminal = normalized[normalized.length - 1];
+    if (terminal?.kind === 'widget') {
+        if (!terminal.key && sourceChildWidgetKey) {
+            terminal.key = sourceChildWidgetKey;
         }
-        const linkSegment = first?.kind === 'nav'
-            ? nestedPath[offset + 1]
-            : first;
-        if (linkSegment?.kind !== 'link') {
-            return undefined;
+        if (!terminal.componentType && sourceComponentId) {
+            terminal.componentType = sourceComponentId;
         }
-        const nav = config['nav'];
-        const links = nav && typeof nav === 'object' && Array.isArray(nav['links'])
-            ? nav['links']
-            : [];
-        const link = this.findBySegment(links, linkSegment);
-        const widgets = link && typeof link === 'object'
-            ? this.asWidgetDefinitions(link['widgets'])
-            : [];
-        return widgets.length
-            ? { widgets, segmentCount: first?.kind === 'nav' ? offset + 2 : offset + 1 }
-            : undefined;
+        return stripEmptySegments(normalized);
     }
-    resolveExpansionWidgetArray(definition, nestedPath, offset) {
-        const config = definition.inputs?.['config'];
-        const panelSegment = nestedPath[offset];
-        if (!config || typeof config !== 'object' || panelSegment?.kind !== 'panel') {
-            return undefined;
-        }
-        const panels = Array.isArray(config['panels'])
-            ? config['panels']
-            : [];
-        const panel = this.findBySegment(panels, panelSegment);
-        const widgets = panel && typeof panel === 'object'
-            ? this.asWidgetDefinitions(panel['widgets'])
-            : [];
-        return widgets.length ? { widgets, segmentCount: offset + 1 } : undefined;
+    if (sourceChildWidgetKey) {
+        normalized.push({
+            kind: 'widget',
+            key: sourceChildWidgetKey,
+            ...(sourceComponentId ? { componentType: sourceComponentId } : {}),
+        });
     }
-    findBySegment(items, segment) {
-        if (segment.id) {
-            const byId = items.find((item) => !!item
-                && typeof item === 'object'
-                && item['id'] === segment.id);
-            if (byId) {
-                return byId;
-            }
-        }
-        if (typeof segment.index === 'number') {
-            return items[segment.index];
-        }
-        return undefined;
+    return stripEmptySegments(normalized);
+}
+function normalizeEventSegment(segment) {
+    if (segment.kind === 'tabs') {
+        return null;
     }
-    segmentIdentity(source, index) {
-        const id = typeof source['id'] === 'string' ? source['id'].trim() : '';
-        return {
-            ...(id ? { id } : {}),
-            index,
-        };
+    const kind = segment.kind === 'widget'
+        ? 'widget'
+        : segment.kind;
+    const key = normalizeString(segment.key);
+    const id = normalizeString(segment.id);
+    const componentType = normalizeString(segment.componentType);
+    const normalized = { kind };
+    if (id) {
+        normalized.id = id;
     }
-    asWidgetDefinitions(value) {
-        return Array.isArray(value) ? value : [];
+    if (key) {
+        normalized.key = key;
     }
-    isWidgetDefinition(value) {
-        return !!value
-            && typeof value === 'object'
-            && typeof value.id === 'string';
+    if (typeof segment.index === 'number' && Number.isFinite(segment.index)) {
+        normalized.index = Math.trunc(segment.index);
     }
-    resolveChildWidgetKey(widget) {
-        return widget.childWidgetKey || '';
+    if (componentType) {
+        normalized.componentType = componentType;
     }
-    clone(value) {
-        if (value == null || typeof value !== 'object') {
-            return value;
-        }
-        return JSON.parse(JSON.stringify(value));
+    return normalized;
+}
+function isOwnerEventSegment(segment, index, options) {
+    if (index !== 0 || !OWNER_EVENT_SEGMENT_KINDS.has(segment.kind)) {
+        return false;
     }
-    isEqual(left, right) {
-        return JSON.stringify(left) === JSON.stringify(right);
+    const ownerComponentId = normalizeString(options.ownerComponentId);
+    if (!ownerComponentId) {
+        return true;
     }
+    return segment.kind === ownerComponentId
+        || segment.id === ownerComponentId;
+}
+function stripEmptySegments(segments) {
+    return segments.filter((segment) => !!segment.kind
+        && (segment.kind === 'widget'
+            || STRUCTURAL_NESTED_PATH_KINDS.has(segment.kind)
+            || !!segment.id
+            || !!segment.key
+            || typeof segment.index === 'number'
+            || !!segment.componentType));
+}
+function normalizeString(value) {
+    return typeof value === 'string' ? value.trim() : '';
 }
 
 const EDITORIAL_ALLOWED_CONTENT_FORMATS = ['plain', 'markdown'];
@@ -38505,10 +38611,11 @@ class DynamicWidgetPageComponent {
         this.pageState = runtime.state;
         this.pageRuntime = runtime;
         this.applyResponsivePresentation(hydrated, stateBoundWidgets, runtime);
-        this.pageChange.emit(hydrated);
+        const canonicalPage = this.toPersistedCanonicalPage(hydrated);
+        this.pageChange.emit(canonicalPage);
         this.reportStateDiagnostics(runtime.diagnostics);
         if (persist && this.autoPersist && !this.isHydrating) {
-            this.savePage(hydrated);
+            this.savePage(canonicalPage);
         }
     }
     applyLayout(layout, grouping) {