@praxisui/page-builder 8.0.0-beta.11 → 8.0.0-beta.13

package/README.md

@@ -100,6 +100,19 @@ Para gerar uma página a partir de um prompt usando o backend canônico do `prax
 
 O chrome conversacional do assistente usa `PraxisAiAssistantShellComponent` de `@praxisui/ai`. O Page Builder continua dono da semântica agentic de página: resolução de intenção, preview, apply, save, reopen e compilação do plano validado para `WidgetPageDefinition`.
 
+### Agentic Authoring Manifest
+
+`PRAXIS_PAGE_BUILDER_AUTHORING_MANIFEST` declara o contrato executável de authoring do pacote e é exportado pelo `public-api` de `@praxisui/page-builder`.
+
+O manifesto cobre as famílias de operação `page.configure`, `canvas.configure`, `widget.add`, `widget.remove`, `widget.moveResize`, `widget.shell.configure`, `composition.link.add`, `composition.link.remove`, `composition.plan.compile`, `state.set`, `page.preview.apply`, `page.persist.save` e `childOperation.delegate`.
+
+As fronteiras canônicas são:
+- o documento persistido continua sendo `WidgetPageDefinition`;
+- `UiCompositionPlan` é apenas o plano intermediário de IA e deve compilar antes do preview/apply local;
+- wiring persistido usa `page.composition.links`, incluindo `nestedPath` para component ports internas;
+- o Page Builder não redefine inputs de widgets filhos. Edições de `definition.inputs` devem delegar para o manifesto do componente filho ou para `ComponentDocMeta.configEditor`;
+- `pageIdentity` e ETag pertencem ao fluxo de persistência do `praxis-config-starter` e não entram no documento runtime da página.
+
 ```ts
 import { PAGE_BUILDER_AGENTIC_AUTHORING_OPTIONS } from '@praxisui/page-builder';
 

package/fesm2022/praxisui-page-builder.mjs

@@ -4811,6 +4811,7 @@ const PAGE_BUILDER_AI_CAPABILITIES = {
         'Para criacao agentic de paginas, o preview pode trazer uiCompositionPlan como plano intermediario validavel; o page-builder compila esse plano para WidgetPageDefinition antes de aplicar.',
         'UiCompositionPlan usa widgets[].componentId e bindings declarativos. O JSON persistido continua sendo page.widgets[].definition.id e page.composition.links.',
         'Nested component ports usam endpoint component-port com nestedPath. O owner em ref.widget, bindings[].from.widget ou bindings[].to.widget continua sendo o widget top-level; a porta real do filho fica em port/direction e o caminho ate o filho fica em nestedPath.',
+        'Nested component ports usam endpoint component-port com nestedPath. O owner em ref.widget ou bindings[].*.widget continua sendo o widget top-level; a porta real do filho fica em port/direction e o caminho ate o filho fica em nestedPath.',
         'Nao gere links nested via owner.widgetEvent, bindingPath profundo, page.connections ou wrappers host-specific. widgetEvent e bridge legada/avancada, nao contrato principal de authoring.',
         'Payloads legados de layout ainda podem ser ingeridos, mas sao normalizados para canvas e nao devem ser reemitidos.',
         'pageIdentity identifica o escopo de persistencia e nao pertence ao objeto page.',
@@ -5080,7 +5081,7 @@ class PageBuilderAgenticAuthoringService {
         return this.http.post(`${this.baseUrl}/resource-candidates`, request, { headers: this.buildHeaders() });
     }
     streamTurn(request) {
-        return this.http.post(`${this.baseUrl}/turn/stream/start`, request, { headers: this.buildHeaders() }).pipe(switchMap((start) => this.connectTurnStream(start)));
+        return this.http.post(`${this.baseUrl}/turn/stream/start`, request, { headers: this.buildHeaders(), withCredentials: true }).pipe(switchMap((start) => this.connectTurnStream(start)));
     }
     applyPage(request) {
         const { ifMatch, ...body } = request;
@@ -5114,17 +5115,14 @@ class PageBuilderAgenticAuthoringService {
     connectTurnStream(start) {
         return new Observable((observer) => {
             const url = this.buildStreamUrl(start);
-            let source;
+            const probeUrl = this.buildStreamProbeUrl(start);
+            let source = null;
             let closed = false;
             let connectionErrorTimer = null;
             const connectionErrorGraceMs = Math.max(0, this.options?.streamConnectionErrorGraceMs ?? 1500);
-            try {
-                source = this.createEventSource(url);
-            }
-            catch (error) {
-                observer.error(this.streamConnectionError(error));
-                return undefined;
-            }
+            let probeAbort = typeof AbortController !== 'undefined'
+                ? new AbortController()
+                : null;
             const clearConnectionErrorTimer = () => {
                 if (connectionErrorTimer) {
                     clearTimeout(connectionErrorTimer);
@@ -5137,7 +5135,7 @@ class PageBuilderAgenticAuthoringService {
                 }
                 closed = true;
                 clearConnectionErrorTimer();
-                source.close();
+                source?.close();
             };
             const failConnection = (event) => {
                 if (closed) {
@@ -5161,23 +5159,58 @@ class PageBuilderAgenticAuthoringService {
                     closeSource();
                 }
             };
-            source.onmessage = handleMessage;
-            if (source.addEventListener) {
-                for (const type of AI_STREAM_EVENT_TYPES) {
-                    source.addEventListener(type, handleMessage);
+            void this.probeTurnStreamEndpoint(probeUrl, probeAbort)
+                .then((status) => {
+                probeAbort = null;
+                if (closed) {
+                    return;
                 }
-            }
-            source.onerror = (event) => {
-                if (closed || connectionErrorTimer) {
+                if (typeof status === 'number' && status >= 400) {
+                    closed = true;
+                    observer.error(this.streamConnectionError({ status }));
                     return;
                 }
-                if (connectionErrorGraceMs === 0) {
-                    failConnection(event);
+                try {
+                    source = this.createEventSource(url);
+                }
+                catch (error) {
+                    closed = true;
+                    observer.error(this.streamConnectionError(error));
                     return;
                 }
-                connectionErrorTimer = setTimeout(() => failConnection(event), connectionErrorGraceMs);
+                source.onmessage = handleMessage;
+                if (source.addEventListener) {
+                    for (const type of AI_STREAM_EVENT_TYPES) {
+                        source.addEventListener(type, handleMessage);
+                    }
+                }
+                source.onerror = (event) => {
+                    if (closed || connectionErrorTimer) {
+                        return;
+                    }
+                    if (connectionErrorGraceMs === 0) {
+                        failConnection(event);
+                        return;
+                    }
+                    connectionErrorTimer = setTimeout(() => failConnection(event), connectionErrorGraceMs);
+                };
+            })
+                .catch((error) => {
+                if (closed) {
+                    return;
+                }
+                closed = true;
+                observer.error(this.streamConnectionError(error));
+            });
+            return () => {
+                probeAbort?.abort();
+                if (source) {
+                    closeSource();
+                    return;
+                }
+                closed = true;
+                clearConnectionErrorTimer();
             };
-            return () => closeSource();
         });
     }
     streamConnectionError(cause) {
@@ -5195,6 +5228,15 @@ class PageBuilderAgenticAuthoringService {
             ? url.toString()
             : url.pathname + url.search;
     }
+    buildStreamProbeUrl(start) {
+        const url = new URL(`${this.baseUrl}/turn/stream/${start.streamId}/probe`, typeof window !== 'undefined' ? window.location.origin : 'http://localhost');
+        if (start.streamAccessToken) {
+            url.searchParams.set('accessToken', start.streamAccessToken);
+        }
+        return /^https?:\/\//i.test(this.baseUrl)
+            ? url.toString()
+            : url.pathname + url.search;
+    }
     createEventSource(url) {
         const factory = this.options?.eventSourceFactory;
         if (factory) {
@@ -5202,6 +5244,18 @@ class PageBuilderAgenticAuthoringService {
         }
         return new EventSource(url);
     }
+    async probeTurnStreamEndpoint(url, abort) {
+        if (typeof fetch === 'undefined') {
+            return null;
+        }
+        const response = await fetch(url, {
+            method: 'GET',
+            credentials: 'include',
+            cache: 'no-store',
+            signal: abort?.signal,
+        });
+        return response.status;
+    }
     formatEtag(etag) {
         const trimmed = etag.trim();
         return trimmed.startsWith('"') ? trimmed : `"${trimmed}"`;
@@ -5214,6 +5268,522 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
             args: [{ providedIn: 'root' }]
         }] });
 
+const pageSchema = {
+    type: 'object',
+    properties: {
+        title: { type: 'string' },
+        layoutPreset: { type: 'string' },
+        context: { type: 'object' },
+        metadata: { type: 'object' },
+    },
+};
+const canvasSchema = {
+    type: 'object',
+    properties: {
+        columns: { type: 'number' },
+        rowUnit: { type: 'number' },
+        gap: { type: 'number' },
+        items: { type: 'array' },
+    },
+};
+const widgetSchema = {
+    type: 'object',
+    required: ['widgetKey', 'componentId'],
+    properties: {
+        widgetKey: { type: 'string' },
+        componentId: { type: 'string' },
+        title: { type: 'string' },
+        inputs: { type: 'object' },
+        canvasItem: { type: 'object' },
+    },
+};
+const compositionLinkSchema = {
+    type: 'object',
+    required: ['linkId', 'from', 'to'],
+    properties: {
+        linkId: { type: 'string' },
+        from: { type: 'object' },
+        to: { type: 'object' },
+        condition: { type: 'object' },
+        policy: { type: 'object' },
+    },
+};
+const childOperationSchema = {
+    type: 'object',
+    required: ['widgetKey', 'childComponentId', 'childOperationId', 'reason'],
+    properties: {
+        widgetKey: { type: 'string' },
+        childComponentId: { type: 'string' },
+        childOperationId: { type: 'string' },
+        reason: { type: 'string' },
+        childTarget: { type: 'object' },
+        childParams: { type: 'object' },
+    },
+};
+const PRAXIS_PAGE_BUILDER_AUTHORING_MANIFEST = {
+    schemaVersion: '1.0.0',
+    componentId: 'praxis-page-builder',
+    ownerPackage: '@praxisui/page-builder',
+    configSchemaId: 'WidgetPageDefinition',
+    manifestVersion: '1.0.0',
+    runtimeInputs: [
+        { name: 'page', type: 'WidgetPageDefinition', description: 'Canonical renderable page document consumed by praxis-dynamic-page.' },
+        { name: 'pageIdentity', type: 'PageIdentity | null', description: 'Persistence identity for ui_user_config save/apply flows; not persisted inside page.' },
+        { name: 'enableCustomization', type: 'boolean', description: 'Enables page-builder authoring chrome around the runtime page.' },
+        { name: 'context', type: 'Record<string, unknown>', description: 'Opaque host context passed to catalog resolution and agentic authoring.' },
+        { name: 'pageChange', type: 'WidgetPageDefinition', description: 'Emitted after local apply/preview produces a renderable page.' },
+        { name: 'agenticAuthoringEnableStreaming', type: 'boolean', description: 'Opt-in flag for the canonical streaming turn endpoints.' },
+    ],
+    editableTargets: [
+        { kind: 'page', resolver: 'widget-page-definition-root', description: 'Root WidgetPageDefinition document: title, metadata, context and renderable page envelope.' },
+        { kind: 'canvas', resolver: 'widget-page-canvas', description: 'Canvas geometry and item placement for top-level widgets.' },
+        { kind: 'widget', resolver: 'widget-by-stable-key', description: 'Widget definitions addressed by stable widgetKey, never by array index.' },
+        { kind: 'widgetShell', resolver: 'widget-shell-by-widget-key', description: 'Dashboard-card shell metadata such as title, action chrome and visual preset.' },
+        { kind: 'compositionLink', resolver: 'composition-link-by-id', description: 'Declarative wiring in page.composition.links, including component-port nestedPath endpoints.' },
+        { kind: 'state', resolver: 'page-state-path', description: 'Page-level state entries referenced by composition links.' },
+        { kind: 'pageIdentity', resolver: 'page-builder-persistence-identity', description: 'ui_user_config identity, scope and ETag used by applyPage/save.' },
+        { kind: 'agenticPreview', resolver: 'agentic-preview-result', description: 'Compiled backend preview envelope whose patch.page is applied locally.' },
+        { kind: 'childOperation', resolver: 'widget-child-authoring-manifest-operation', description: 'Delegated operation owned by the child widget component manifest or configEditor.' },
+    ],
+    operations: [
+        {
+            operationId: 'page.configure',
+            title: 'Configure page metadata',
+            scope: 'global',
+            targetKind: 'page',
+            target: { kind: 'page', resolver: 'widget-page-definition-root', ambiguityPolicy: 'fail', required: false },
+            inputSchema: pageSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'page-builder-page-configure', handlerContract: {
+                        reads: ['WidgetPageDefinition', 'DynamicPageConfigEditorComponent', 'SettingsPanelBridge'],
+                        writes: ['page.title', 'page.layoutPreset', 'page.context', 'page.metadata'],
+                        identityKeys: ['pageIdentity.componentId', 'pageIdentity.scope'],
+                        inputSchema: pageSchema,
+                        failureModes: ['page-not-loaded', 'context-not-json', 'settings-panel-bridge-missing'],
+                        description: 'Updates root page metadata while preserving the renderable WidgetPageDefinition shape.',
+                    } }],
+            validators: ['widget-page-definition-valid', 'no-legacy-grid-page-definition', 'page-context-json-valid', 'settings-panel-round-trip-valid'],
+            affectedPaths: ['title', 'layoutPreset', 'context', 'metadata'],
+            submissionImpact: 'config-only',
+            preconditions: ['page-loaded'],
+        },
+        {
+            operationId: 'canvas.configure',
+            title: 'Configure page canvas',
+            scope: 'layout',
+            targetKind: 'canvas',
+            target: { kind: 'canvas', resolver: 'widget-page-canvas', ambiguityPolicy: 'fail', required: true },
+            inputSchema: canvasSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'page-builder-canvas-configure', handlerContract: {
+                        reads: ['WidgetPageDefinition.canvas', 'DynamicPageBuilderComponent'],
+                        writes: ['page.canvas.columns', 'page.canvas.rowUnit', 'page.canvas.gap', 'page.canvas.items'],
+                        identityKeys: ['canvas'],
+                        inputSchema: canvasSchema,
+                        failureModes: ['canvas-missing', 'canvas-item-references-missing-widget', 'invalid-grid-geometry'],
+                        description: 'Configures the top-level canvas without introducing legacy GridPageDefinition semantics.',
+                    } }],
+            validators: ['canvas-columns-integer', 'canvas-row-unit-valid', 'canvas-gap-valid', 'canvas-items-reference-existing-widgets'],
+            affectedPaths: ['canvas.columns', 'canvas.rowUnit', 'canvas.gap', 'canvas.items'],
+            submissionImpact: 'config-only',
+            preconditions: ['page-loaded'],
+        },
+        {
+            operationId: 'widget.add',
+            title: 'Add widget to page',
+            scope: 'layout',
+            targetKind: 'widget',
+            target: { kind: 'widget', resolver: 'widget-by-stable-key', ambiguityPolicy: 'fail', required: true },
+            inputSchema: widgetSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'page-builder-widget-add', handlerContract: {
+                        reads: ['WidgetPageDefinition.widgets', 'WidgetPageDefinition.canvas', 'ComponentDocRegistry', 'PAGE_BUILDER_WIDGET_AI_CATALOGS'],
+                        writes: ['page.widgets[]', 'page.canvas.items[]'],
+                        identityKeys: ['widgetKey'],
+                        inputSchema: widgetSchema,
+                        failureModes: ['widget-key-duplicate', 'component-not-registered', 'canvas-item-invalid', 'child-input-contract-unknown'],
+                        description: 'Adds a registered component as a widget and places it on the canvas using a stable widgetKey.',
+                    } }],
+            validators: ['widget-key-unique', 'component-registered', 'canvas-item-valid', 'child-inputs-delegated', 'widget-key-not-array-index'],
+            affectedPaths: ['widgets[]', 'canvas.items[]'],
+            submissionImpact: 'config-only',
+            preconditions: ['page-loaded', 'component-catalog-loaded'],
+        },
+        {
+            operationId: 'widget.remove',
+            title: 'Remove widget from page',
+            scope: 'layout',
+            targetKind: 'widget',
+            target: { kind: 'widget', resolver: 'widget-by-stable-key', ambiguityPolicy: 'fail', required: true },
+            inputSchema: { type: 'object', required: ['widgetKey'], properties: { widgetKey: { type: 'string' }, confirmed: { type: 'boolean' } } },
+            effects: [{ kind: 'compile-domain-patch', handler: 'page-builder-widget-remove', handlerContract: {
+                        reads: ['WidgetPageDefinition.widgets', 'WidgetPageDefinition.canvas.items', 'WidgetPageDefinition.composition.links'],
+                        writes: ['page.widgets[]', 'page.canvas.items[]', 'page.composition.links[]'],
+                        identityKeys: ['widgetKey'],
+                        failureModes: ['widget-not-found', 'destructive-removal-not-confirmed', 'dangling-composition-link'],
+                        description: 'Removes a widget and cleans canvas items and composition links that reference it.',
+                    } }],
+            destructive: true,
+            requiresConfirmation: true,
+            validators: ['widget-exists', 'destructive-removal-confirmed', 'composition-links-cleaned', 'canvas-items-reference-existing-widgets'],
+            affectedPaths: ['widgets[]', 'canvas.items[]', 'composition.links[]'],
+            submissionImpact: 'config-only',
+            preconditions: ['page-loaded', 'target-widget-exists'],
+        },
+        {
+            operationId: 'widget.moveResize',
+            title: 'Move or resize widget',
+            scope: 'layout',
+            targetKind: 'widget',
+            target: { kind: 'widget', resolver: 'widget-by-stable-key', ambiguityPolicy: 'fail', required: true },
+            inputSchema: { type: 'object', required: ['widgetKey', 'canvasItem'], properties: { widgetKey: { type: 'string' }, canvasItem: { type: 'object' } } },
+            effects: [{ kind: 'compile-domain-patch', handler: 'page-builder-widget-move-resize', handlerContract: {
+                        reads: ['WidgetPageDefinition.canvas.items', 'WidgetPageDefinition.widgets'],
+                        writes: ['page.canvas.items[]'],
+                        identityKeys: ['widgetKey'],
+                        failureModes: ['widget-not-found', 'canvas-item-invalid', 'canvas-overlap-invalid'],
+                        description: 'Updates canvas placement for an existing widget using widgetKey as the stable identity.',
+                    } }],
+            validators: ['widget-exists', 'canvas-item-valid', 'canvas-item-targets-existing-widget', 'canvas-overlap-policy-valid'],
+            affectedPaths: ['canvas.items[]'],
+            submissionImpact: 'config-only',
+            preconditions: ['page-loaded', 'target-widget-exists'],
+        },
+        {
+            operationId: 'widget.shell.configure',
+            title: 'Configure widget shell',
+            scope: 'templating',
+            targetKind: 'widgetShell',
+            target: { kind: 'widgetShell', resolver: 'widget-shell-by-widget-key', ambiguityPolicy: 'fail', required: true },
+            inputSchema: { type: 'object', required: ['widgetKey'], properties: { widgetKey: { type: 'string' }, shell: { type: 'object' } } },
+            effects: [{ kind: 'compile-domain-patch', handler: 'page-builder-widget-shell-configure', handlerContract: {
+                        reads: ['WidgetPageDefinition.widgets', 'WidgetShellEditorComponent', 'SettingsPanelBridge'],
+                        writes: ['page.widgets[].shell'],
+                        identityKeys: ['widgetKey'],
+                        failureModes: ['widget-not-found', 'settings-panel-bridge-missing', 'shell-config-invalid'],
+                        description: 'Updates the page-builder-owned widget shell without editing child component inputs.',
+                    } }],
+            validators: ['widget-exists', 'widget-shell-shape-valid', 'settings-panel-bridge-available', 'child-inputs-not-mutated'],
+            affectedPaths: ['widgets[].shell'],
+            submissionImpact: 'config-only',
+            preconditions: ['page-loaded', 'target-widget-exists'],
+        },
+        {
+            operationId: 'composition.link.add',
+            title: 'Add page composition link',
+            scope: 'dataBinding',
+            targetKind: 'compositionLink',
+            target: { kind: 'compositionLink', resolver: 'composition-link-by-id', ambiguityPolicy: 'fail', required: true },
+            inputSchema: compositionLinkSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'page-builder-composition-link-add', handlerContract: {
+                        reads: ['WidgetPageDefinition.composition.links', 'WidgetPageDefinition.widgets', 'PAGE_BUILDER_AI_CAPABILITIES'],
+                        writes: ['page.composition.links[]'],
+                        identityKeys: ['linkId'],
+                        inputSchema: compositionLinkSchema,
+                        failureModes: ['link-id-duplicate', 'endpoint-not-found', 'nested-path-invalid', 'json-logic-invalid'],
+                        description: 'Adds canonical declarative wiring in page.composition.links, including component-port nestedPath endpoints.',
+                    } }],
+            validators: ['composition-link-id-unique', 'composition-endpoints-resolve', 'nested-path-terminal-widget-key-required', 'json-logic-condition-valid', 'no-legacy-connections-write'],
+            affectedPaths: ['composition.links[]'],
+            submissionImpact: 'config-only',
+            preconditions: ['page-loaded', 'widgets-resolvable'],
+        },
+        {
+            operationId: 'composition.link.remove',
+            title: 'Remove page composition link',
+            scope: 'dataBinding',
+            targetKind: 'compositionLink',
+            target: { kind: 'compositionLink', resolver: 'composition-link-by-id', ambiguityPolicy: 'fail', required: true },
+            inputSchema: { type: 'object', required: ['linkId'], properties: { linkId: { type: 'string' }, confirmed: { type: 'boolean' } } },
+            effects: [{ kind: 'compile-domain-patch', handler: 'page-builder-composition-link-remove', handlerContract: {
+                        reads: ['WidgetPageDefinition.composition.links'],
+                        writes: ['page.composition.links[]'],
+                        identityKeys: ['linkId'],
+                        failureModes: ['composition-link-not-found', 'destructive-removal-not-confirmed'],
+                        description: 'Removes a canonical composition link by stable linkId.',
+                    } }],
+            destructive: true,
+            requiresConfirmation: true,
+            validators: ['composition-link-exists', 'destructive-removal-confirmed', 'composition-links-still-valid'],
+            affectedPaths: ['composition.links[]'],
+            submissionImpact: 'config-only',
+            preconditions: ['page-loaded', 'target-link-exists'],
+        },
+        {
+            operationId: 'composition.plan.compile',
+            title: 'Compile UI composition plan',
+            scope: 'rules',
+            targetKind: 'agenticPreview',
+            target: { kind: 'agenticPreview', resolver: 'agentic-preview-result', ambiguityPolicy: 'fail', required: true },
+            inputSchema: { type: 'object', required: ['uiCompositionPlan'], properties: { uiCompositionPlan: { type: 'object' } } },
+            effects: [{ kind: 'compile-domain-patch', handler: 'page-builder-ui-composition-plan-compile', handlerContract: {
+                        reads: ['UiCompositionPlan', 'compileUiCompositionPlan', 'PAGE_BUILDER_WIDGET_AI_CATALOGS', 'ComponentDocMeta.configEditor'],
+                        writes: ['compiledFormPatch.patch.page'],
+                        identityKeys: ['uiCompositionPlan.id', 'widgetKey', 'linkId'],
+                        failureModes: ['ui-composition-plan-invalid', 'widget-catalog-missing', 'compiled-page-invalid', 'child-config-editor-missing'],
+                        description: 'Compiles the agentic intermediate UiCompositionPlan into a renderable WidgetPageDefinition patch.page.',
+                    } }],
+            validators: ['ui-composition-plan-valid', 'compiled-page-valid', 'widget-keys-unique', 'composition-endpoints-resolve', 'canvas-items-reference-existing-widgets'],
+            affectedPaths: ['uiCompositionPlan', 'compiledFormPatch.patch.page'],
+            submissionImpact: 'none',
+            preconditions: ['agentic-preview-loaded', 'component-catalog-loaded'],
+        },
+        {
+            operationId: 'state.set',
+            title: 'Set page state value',
+            scope: 'dataBinding',
+            targetKind: 'state',
+            target: { kind: 'state', resolver: 'page-state-path', ambiguityPolicy: 'fail', required: true },
+            inputSchema: { type: 'object', required: ['path', 'value'], properties: { path: { type: 'string' }, value: {}, layer: { enum: ['page', 'session'] } } },
+            effects: [{ kind: 'compile-domain-patch', handler: 'page-builder-state-set', handlerContract: {
+                        reads: ['WidgetPageDefinition.state', 'WidgetPageDefinition.composition.links'],
+                        writes: ['page.state'],
+                        identityKeys: ['path'],
+                        failureModes: ['state-path-invalid', 'state-json-invalid', 'composition-state-link-invalid'],
+                        description: 'Sets canonical page state used by composition links without creating host-only binding paths.',
+                    } }],
+            validators: ['state-path-valid', 'state-layer-valid', 'state-json-valid', 'composition-state-links-still-valid'],
+            affectedPaths: ['state'],
+            submissionImpact: 'config-only',
+            preconditions: ['page-loaded'],
+        },
+        {
+            operationId: 'page.preview.apply',
+            title: 'Apply agentic preview locally',
+            scope: 'interaction',
+            targetKind: 'agenticPreview',
+            target: { kind: 'agenticPreview', resolver: 'agentic-preview-result', ambiguityPolicy: 'fail', required: true },
+            inputSchema: { type: 'object', required: ['previewId'], properties: { previewId: { type: 'string' }, compiledFormPatch: { type: 'object' } } },
+            effects: [{ kind: 'compile-domain-patch', handler: 'page-builder-preview-apply', handlerContract: {
+                        reads: ['PageBuilderAiAdapter.applyCompiledFormPatch', 'compiledFormPatch.patch.page', 'PraxisAssistantTurnViewState'],
+                        writes: ['DynamicPageBuilderComponent.page', 'pageChange'],
+                        identityKeys: ['previewId'],
+                        failureModes: ['preview-result-invalid', 'patch-page-missing', 'runtime-page-invalid', 'patch-envelope-persistence-attempted'],
+                        description: 'Applies only compiledFormPatch.patch.page to the local runtime page; the backend envelope remains diagnostic data.',
+                    } }],
+            validators: ['preview-result-valid', 'compiled-page-patch-present', 'no-envelope-runtime-persistence', 'runtime-page-valid'],
+            affectedPaths: ['compiledFormPatch.patch.page', 'page'],
+            submissionImpact: 'visual-only',
+            preconditions: ['agentic-preview-loaded'],
+        },
+        {
+            operationId: 'page.persist.save',
+            title: 'Persist page through config API',
+            scope: 'interaction',
+            targetKind: 'pageIdentity',
+            target: { kind: 'pageIdentity', resolver: 'page-builder-persistence-identity', ambiguityPolicy: 'fail', required: true },
+            inputSchema: { type: 'object', required: ['pageIdentity'], properties: { pageIdentity: { type: 'object' }, page: { type: 'object' }, etag: { type: 'string' } } },
+            effects: [{ kind: 'compile-domain-patch', handler: 'page-builder-page-persist-save', handlerContract: {
+                        reads: ['pageIdentity', 'WidgetPageDefinition', 'PAGE_BUILDER_AGENTIC_AUTHORING_OPTIONS', 'ui_user_config ETag'],
+                        writes: ['POST/PUT /api/praxis/config/ui-user-config', 'If-Match'],
+                        identityKeys: ['pageIdentity.componentType', 'pageIdentity.componentId', 'pageIdentity.scope'],
+                        failureModes: ['page-identity-incomplete', 'etag-conflict', 'runtime-page-invalid', 'patch-envelope-persistence-attempted'],
+                        description: 'Persists the renderable WidgetPageDefinition with pageIdentity and ETag delegated to praxis-config-starter.',
+                    } }],
+            validators: ['page-identity-complete', 'etag-policy-valid', 'runtime-page-valid', 'no-envelope-runtime-persistence'],
+            affectedPaths: ['page', 'pageIdentity', 'etag'],
+            submissionImpact: 'config-only',
+            preconditions: ['page-loaded', 'page-identity-known'],
+        },
+        {
+            operationId: 'childOperation.delegate',
+            title: 'Delegate widget child operation',
+            scope: 'global',
+            targetKind: 'childOperation',
+            target: { kind: 'childOperation', resolver: 'widget-child-authoring-manifest-operation', ambiguityPolicy: 'fail', required: false },
+            inputSchema: childOperationSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'page-builder-child-operation-delegate', handlerContract: {
+                        reads: ['WidgetPageDefinition.widgets', 'ComponentDocMeta.configEditor', 'child ComponentAuthoringManifest', 'PAGE_BUILDER_WIDGET_AI_CATALOGS'],
+                        writes: ['page.widgets[].definition.inputs'],
+                        identityKeys: ['widgetKey', 'childComponentId', 'childOperationId'],
+                        inputSchema: childOperationSchema,
+                        failureModes: ['widget-not-found', 'child-manifest-missing', 'child-operation-unknown', 'local-child-input-write-attempted'],
+                        description: 'Delegates child widget input edits to the owning manifest or configEditor instead of redefining child semantics in page-builder.',
+                    } }],
+            validators: ['widget-exists', 'child-manifest-available', 'child-operation-known', 'component-config-editor-respected', 'no-local-child-input-write'],
+            affectedPaths: ['widgets[].definition.inputs'],
+            submissionImpact: 'config-only',
+            preconditions: ['page-loaded', 'target-widget-exists', 'child-authoring-contract-available'],
+        },
+    ],
+    validators: [
+        { validatorId: 'widget-page-definition-valid', level: 'error', code: 'PAGE_BUILDER_PAGE_VALID', description: 'The document must remain a renderable WidgetPageDefinition.' },
+        { validatorId: 'no-legacy-grid-page-definition', level: 'error', code: 'PAGE_BUILDER_NO_GRID_PAGE', description: 'Legacy GridPageDefinition semantics cannot be reintroduced.' },
+        { validatorId: 'page-context-json-valid', level: 'error', code: 'PAGE_BUILDER_CONTEXT_JSON', description: 'Page context must stay JSON-serializable.' },
+        { validatorId: 'settings-panel-round-trip-valid', level: 'error', code: 'PAGE_BUILDER_SETTINGS_ROUND_TRIP', description: 'Settings panel apply/save/reset/reopen must preserve the same page shape.' },
+        { validatorId: 'canvas-columns-integer', level: 'error', code: 'PAGE_BUILDER_CANVAS_COLUMNS', description: 'Canvas columns must be an integer grid count.' },
+        { validatorId: 'canvas-row-unit-valid', level: 'error', code: 'PAGE_BUILDER_CANVAS_ROW_UNIT', description: 'Canvas row unit must be a positive layout unit.' },
+        { validatorId: 'canvas-gap-valid', level: 'error', code: 'PAGE_BUILDER_CANVAS_GAP', description: 'Canvas gap must be a valid non-negative spacing value.' },
+        { validatorId: 'canvas-items-reference-existing-widgets', level: 'error', code: 'PAGE_BUILDER_CANVAS_WIDGET_REFS', description: 'Every canvas item must reference an existing widgetKey.' },
+        { validatorId: 'widget-key-unique', level: 'error', code: 'PAGE_BUILDER_WIDGET_KEY_UNIQUE', description: 'Widget keys must be unique.' },
+        { validatorId: 'component-registered', level: 'error', code: 'PAGE_BUILDER_COMPONENT_REGISTERED', description: 'Widget component id must exist in the component registry/catalog.' },
+        { validatorId: 'canvas-item-valid', level: 'error', code: 'PAGE_BUILDER_CANVAS_ITEM', description: 'Canvas item geometry must be valid.' },
+        { validatorId: 'child-inputs-delegated', level: 'error', code: 'PAGE_BUILDER_CHILD_INPUTS_DELEGATED', description: 'Child component input edits must delegate to the child owner.' },
+        { validatorId: 'widget-key-not-array-index', level: 'error', code: 'PAGE_BUILDER_WIDGET_KEY_INDEX', description: 'Array index is not a stable widget identity.' },
+        { validatorId: 'widget-exists', level: 'error', code: 'PAGE_BUILDER_WIDGET_EXISTS', description: 'Target widget must exist.' },
+        { validatorId: 'destructive-removal-confirmed', level: 'error', code: 'PAGE_BUILDER_DESTRUCTIVE_CONFIRMED', description: 'Destructive removals require explicit confirmation.' },
+        { validatorId: 'composition-links-cleaned', level: 'error', code: 'PAGE_BUILDER_LINKS_CLEANED', description: 'Removing a widget must remove dangling composition links.' },
+        { validatorId: 'canvas-item-targets-existing-widget', level: 'error', code: 'PAGE_BUILDER_CANVAS_ITEM_TARGET', description: 'Moved canvas item must target an existing widget.' },
+        { validatorId: 'canvas-overlap-policy-valid', level: 'warning', code: 'PAGE_BUILDER_CANVAS_OVERLAP', description: 'Canvas overlap policy must be respected.' },
+        { validatorId: 'widget-shell-shape-valid', level: 'error', code: 'PAGE_BUILDER_SHELL_SHAPE', description: 'Widget shell config must match the shell editor contract.' },
+        { validatorId: 'settings-panel-bridge-available', level: 'error', code: 'PAGE_BUILDER_SETTINGS_BRIDGE', description: 'Settings panel bridge must be available for shell/page editors.' },
+        { validatorId: 'child-inputs-not-mutated', level: 'error', code: 'PAGE_BUILDER_CHILD_INPUTS_NOT_MUTATED', description: 'Shell edits cannot mutate child inputs.' },
+        { validatorId: 'composition-link-id-unique', level: 'error', code: 'PAGE_BUILDER_LINK_ID_UNIQUE', description: 'Composition link ids must be unique.' },
+        { validatorId: 'composition-endpoints-resolve', level: 'error', code: 'PAGE_BUILDER_LINK_ENDPOINTS', description: 'Composition endpoints must resolve to known widgets, ports and nested paths.' },
+        { validatorId: 'nested-path-terminal-widget-key-required', level: 'error', code: 'PAGE_BUILDER_NESTED_PATH_WIDGET_KEY', description: 'Nested component-port paths must terminate at a stable widget key.' },
+        { validatorId: 'json-logic-condition-valid', level: 'error', code: 'PAGE_BUILDER_JSON_LOGIC', description: 'Composition link condition must be valid Json Logic.' },
+        { validatorId: 'no-legacy-connections-write', level: 'error', code: 'PAGE_BUILDER_NO_LEGACY_CONNECTIONS', description: 'Operations must write page.composition.links, not legacy connections.' },
+        { validatorId: 'composition-link-exists', level: 'error', code: 'PAGE_BUILDER_LINK_EXISTS', description: 'Target composition link must exist.' },
+        { validatorId: 'composition-links-still-valid', level: 'error', code: 'PAGE_BUILDER_LINKS_STILL_VALID', description: 'Remaining composition links must still validate after the operation.' },
+        { validatorId: 'ui-composition-plan-valid', level: 'error', code: 'PAGE_BUILDER_UI_PLAN_VALID', description: 'UiCompositionPlan must match the intermediate agentic plan contract.' },
+        { validatorId: 'compiled-page-valid', level: 'error', code: 'PAGE_BUILDER_COMPILED_PAGE_VALID', description: 'Compiled output must be a valid WidgetPageDefinition.' },
+        { validatorId: 'widget-keys-unique', level: 'error', code: 'PAGE_BUILDER_WIDGET_KEYS_UNIQUE', description: 'Compiled plan must produce unique widget keys.' },
+        { validatorId: 'state-path-valid', level: 'error', code: 'PAGE_BUILDER_STATE_PATH', description: 'State paths must be valid page state paths.' },
+        { validatorId: 'state-layer-valid', level: 'error', code: 'PAGE_BUILDER_STATE_LAYER', description: 'State layer must be page or session.' },
+        { validatorId: 'state-json-valid', level: 'error', code: 'PAGE_BUILDER_STATE_JSON', description: 'State values must be JSON-serializable.' },
+        { validatorId: 'composition-state-links-still-valid', level: 'error', code: 'PAGE_BUILDER_STATE_LINKS', description: 'State edits must not break composition links.' },
+        { validatorId: 'preview-result-valid', level: 'error', code: 'PAGE_BUILDER_PREVIEW_VALID', description: 'Agentic preview result must be structurally valid.' },
+        { validatorId: 'compiled-page-patch-present', level: 'error', code: 'PAGE_BUILDER_PATCH_PAGE_PRESENT', description: 'Preview envelope must include compiledFormPatch.patch.page.' },
+        { validatorId: 'no-envelope-runtime-persistence', level: 'error', code: 'PAGE_BUILDER_NO_ENVELOPE_PERSISTENCE', description: 'Runtime persistence cannot save the full preview envelope.' },
+        { validatorId: 'runtime-page-valid', level: 'error', code: 'PAGE_BUILDER_RUNTIME_PAGE_VALID', description: 'Runtime page must remain renderable by praxis-dynamic-page.' },
+        { validatorId: 'page-identity-complete', level: 'error', code: 'PAGE_BUILDER_PAGE_IDENTITY', description: 'Save requires component type, component id and scope identity.' },
+        { validatorId: 'etag-policy-valid', level: 'error', code: 'PAGE_BUILDER_ETAG_POLICY', description: 'Save must respect backend ETag/If-Match policy.' },
+        { validatorId: 'child-manifest-available', level: 'error', code: 'PAGE_BUILDER_CHILD_MANIFEST_AVAILABLE', description: 'Delegated child component must expose an authoring manifest or configEditor.' },
+        { validatorId: 'child-operation-known', level: 'error', code: 'PAGE_BUILDER_CHILD_OPERATION_KNOWN', description: 'Delegated child operation id must be known.' },
+        { validatorId: 'component-config-editor-respected', level: 'error', code: 'PAGE_BUILDER_CONFIG_EDITOR_RESPECTED', description: 'ComponentDocMeta.configEditor must remain the source for child input editing.' },
+        { validatorId: 'no-local-child-input-write', level: 'error', code: 'PAGE_BUILDER_NO_LOCAL_CHILD_INPUT_WRITE', description: 'Page-builder must not define child component input semantics locally.' },
+    ],
+    roundTripRequirements: [
+        'WidgetPageDefinition is the canonical persisted runtime page shape for page-builder.',
+        'UiCompositionPlan is an intermediate agentic plan and must compile before local preview/apply.',
+        'Widget keys and composition link ids are stable identities; array indexes are never canonical identities.',
+        'Persisted wiring uses page.composition.links and must not write legacy connections.',
+        'Nested component ports use component-port refs with nestedPath ending in a stable widget key.',
+        'Child widget definition.inputs edits delegate to the child manifest or ComponentDocMeta.configEditor.',
+        'Agentic preview applies only compiledFormPatch.patch.page to runtime; the full patch envelope is diagnostics/audit data.',
+        'Save uses pageIdentity and ETag policy from praxis-config-starter; pageIdentity is not persisted inside WidgetPageDefinition.',
+        'Settings panel apply/save/reset/reopen must preserve page settings and widget shell config without hidden normalization drift.',
+    ],
+    examples: [
+        {
+            id: 'configure-dashboard-page',
+            request: 'Set this page title to Payroll Overview and store payrollPeriod in the page context.',
+            operationId: 'page.configure',
+            params: { title: 'Payroll Overview', context: { payrollPeriod: 'current' } },
+            isPositive: true,
+        },
+        {
+            id: 'configure-canvas-grid',
+            request: 'Use a 12 column dashboard grid with compact gaps.',
+            operationId: 'canvas.configure',
+            target: 'canvas',
+            params: { columns: 12, rowUnit: 8, gap: 8 },
+            isPositive: true,
+        },
+        {
+            id: 'add-employees-table-widget',
+            request: 'Add an employees table widget to the left half of the first row.',
+            operationId: 'widget.add',
+            target: 'employees-table',
+            params: { widgetKey: 'employees-table', componentId: 'praxis-table', canvasItem: { x: 0, y: 0, w: 6, h: 8 } },
+            isPositive: true,
+        },
+        {
+            id: 'remove-summary-card',
+            request: 'Remove the summary-card widget and its links.',
+            operationId: 'widget.remove',
+            target: 'summary-card',
+            params: { widgetKey: 'summary-card', confirmed: true },
+            isPositive: true,
+        },
+        {
+            id: 'move-payroll-chart',
+            request: 'Move payroll-chart to the right column and make it taller.',
+            operationId: 'widget.moveResize',
+            target: 'payroll-chart',
+            params: { widgetKey: 'payroll-chart', canvasItem: { x: 6, y: 0, w: 6, h: 10 } },
+            isPositive: true,
+        },
+        {
+            id: 'configure-widget-shell',
+            request: 'Rename the employees widget card and enable the refresh shell action.',
+            operationId: 'widget.shell.configure',
+            target: 'employees-table',
+            params: { widgetKey: 'employees-table', shell: { title: 'Employees', actions: [{ id: 'refresh' }] } },
+            isPositive: true,
+        },
+        {
+            id: 'link-department-selection-to-table',
+            request: 'When department-list selection changes, filter employees-table by department id.',
+            operationId: 'composition.link.add',
+            target: 'department-selection-to-employees',
+            params: { linkId: 'department-selection-to-employees', from: { widget: 'department-list', port: 'selection' }, to: { widget: 'employees-table', port: 'filter' } },
+            isPositive: true,
+        },
+        {
+            id: 'remove-obsolete-link',
+            request: 'Remove the old payroll-filter-link composition link.',
+            operationId: 'composition.link.remove',
+            target: 'payroll-filter-link',
+            params: { linkId: 'payroll-filter-link', confirmed: true },
+            isPositive: true,
+        },
+        {
+            id: 'compile-resource-dashboard-plan',
+            request: 'Compile the resource-dashboard plan returned by the assistant into a renderable page preview.',
+            operationId: 'composition.plan.compile',
+            target: 'preview-payroll-dashboard',
+            params: { uiCompositionPlan: { layoutPreset: 'resource-dashboard' } },
+            isPositive: true,
+        },
+        {
+            id: 'set-selected-department-state',
+            request: 'Store selectedDepartmentId in page state for downstream links.',
+            operationId: 'state.set',
+            target: 'state.selectedDepartmentId',
+            params: { path: 'selectedDepartmentId', value: 'sales', layer: 'page' },
+            isPositive: true,
+        },
+        {
+            id: 'apply-agentic-preview',
+            request: 'Apply the current assistant preview to the local page.',
+            operationId: 'page.preview.apply',
+            target: 'preview-current',
+            params: { previewId: 'preview-current' },
+            isPositive: true,
+        },
+        {
+            id: 'persist-page',
+            request: 'Save this page configuration using the current ETag.',
+            operationId: 'page.persist.save',
+            target: 'tenant-dashboard-page',
+            params: { pageIdentity: { componentType: 'page-builder', componentId: 'tenant-dashboard', scope: 'tenant' }, etag: '"v7"' },
+            isPositive: true,
+        },
+        {
+            id: 'delegate-table-column-edit',
+            request: 'Add a salary column to the employees table widget.',
+            operationId: 'childOperation.delegate',
+            target: 'employees-table',
+            params: { widgetKey: 'employees-table', childComponentId: 'praxis-table', childOperationId: 'column.add', reason: 'TableConfig is owned by praxis-table.' },
+            isPositive: true,
+        },
+        {
+            id: 'reject-direct-dynamic-form-field-write',
+            request: 'Directly write a new dynamic-form field into the widget inputs from page-builder.',
+            operationId: 'childOperation.delegate',
+            target: 'employee-form',
+            params: { widgetKey: 'employee-form', childComponentId: 'praxis-dynamic-form', childOperationId: 'field.add', reason: 'Dynamic form fields are delegated.' },
+            isPositive: false,
+        },
+        {
+            id: 'reject-legacy-connections',
+            request: 'Create the widget link under the old connections collection.',
+            operationId: 'composition.link.add',
+            target: 'legacy-connection',
+            params: { linkId: 'legacy-connection', collection: 'connections' },
+            isPositive: false,
+        },
+    ],
+};
+
 function compileUiCompositionPlan(plan) {
     const diagnostics = validateUiCompositionPlan(plan);
     if (diagnostics.length) {
@@ -8216,4 +8786,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { ComponentPaletteDialogComponent, ConfirmDialogComponent, DynamicPageBuilderComponent, DynamicPageConfigEditorComponent, FloatingToolbarComponent, PAGE_BUILDER_AGENTIC_AUTHORING_OPTIONS, PAGE_BUILDER_AI_CAPABILITIES, PAGE_BUILDER_WIDGET_AI_CATALOGS, PLACEHOLDER, PageBuilderAgenticAuthoringService, PageConfigEditorComponent, TileToolbarComponent, WidgetShellEditorComponent, clearWidgetAiCatalogs, getPageAiCatalog, getWidgetAiCapabilities, providePageBuilderWidgetAiCatalogs, registerWidgetAiCatalog, registerWidgetAiCatalogs };
+export { ComponentPaletteDialogComponent, ConfirmDialogComponent, DynamicPageBuilderComponent, DynamicPageConfigEditorComponent, FloatingToolbarComponent, PAGE_BUILDER_AGENTIC_AUTHORING_OPTIONS, PAGE_BUILDER_AI_CAPABILITIES, PAGE_BUILDER_WIDGET_AI_CATALOGS, PLACEHOLDER, PRAXIS_PAGE_BUILDER_AUTHORING_MANIFEST, PageBuilderAgenticAuthoringService, PageConfigEditorComponent, TileToolbarComponent, WidgetShellEditorComponent, clearWidgetAiCatalogs, getPageAiCatalog, getWidgetAiCapabilities, providePageBuilderWidgetAiCatalogs, registerWidgetAiCatalog, registerWidgetAiCatalogs };

package/index.d.ts

@@ -1,13 +1,13 @@
 import { MatDialogRef, MatDialog } from '@angular/material/dialog';
 import * as _angular_core from '@angular/core';
 import { EventEmitter, OnInit, WritableSignal, InjectionToken, Provider, OnChanges, Type, SimpleChanges } from '@angular/core';
-import { ComponentDocMeta, ComponentMetadataRegistry, WidgetShellConfig, WidgetShellAction, SettingsValueProvider as SettingsValueProvider$1, WidgetPageDefinition, WidgetPageGroupingDefinition, BUILTIN_PAGE_LAYOUT_PRESETS, BUILTIN_PAGE_THEME_PRESETS, PageIdentity, WidgetStateNode, WidgetDerivedStateNode, AiCapabilityCategory, AiValueKind, AiCapability, AiCapabilityCatalog, WidgetInstance, WidgetPageStateInput, CompositionLink, DynamicWidgetPageComponent, SettingsPanelBridge } from '@praxisui/core';
+import { ComponentDocMeta, ComponentMetadataRegistry, WidgetShellConfig, WidgetShellAction, SettingsValueProvider as SettingsValueProvider$1, WidgetPageDefinition, WidgetPageGroupingDefinition, BUILTIN_PAGE_LAYOUT_PRESETS, BUILTIN_PAGE_THEME_PRESETS, PageIdentity, WidgetStateNode, WidgetDerivedStateNode, AiCapabilityCategory, AiValueKind, AiCapability, AiCapabilityCatalog, WidgetInstance, WidgetPageStateInput, CompositionLink, ComponentAuthoringManifest, DynamicWidgetPageComponent, SettingsPanelBridge } from '@praxisui/core';
 export { WidgetShellComponent } from '@praxisui/core';
 import * as rxjs from 'rxjs';
 import { BehaviorSubject, Observable } from 'rxjs';
 import { FormGroup, FormControl, FormArray } from '@angular/forms';
 import { SettingsValueProvider } from '@praxisui/settings-panel';
-import { AgenticAuthoringPlanRequestContract, AgenticAuthoringCandidateContract, AiJsonValue, AgenticAuthoringQuickReplyContract, AgenticAuthoringPendingClarificationContract, AiJsonObject, AgenticAuthoringComponentCapabilitiesResultContract, AgenticAuthoringComponentCapabilityCatalogContract, AgenticAuthoringComponentCapabilityContract, AgenticAuthoringComponentFieldAliasContract, AgenticAuthoringComponentCapabilityExampleContract, AgenticAuthoringAttachmentSummaryContract, AgenticAuthoringIntentResolutionRequestContract, AgenticAuthoringConversationMessageContract, AgenticAuthoringResourceCandidatesRequestContract, AgenticAuthoringResourceCandidatesResultContract, AgenticAuthoringTurnStreamStartResponseContract, AgenticAuthoringTurnStreamEnvelopeContract, PraxisAssistantShellMessage, PraxisAssistantShellQuickReply, PraxisAssistantShellAttachment, PraxisAssistantShellLayout, PraxisAssistantShellLabels, PraxisAssistantShellState, PraxisAssistantShellContextItem } from '@praxisui/ai';
+import { AgenticAuthoringPlanRequestContract, AgenticAuthoringCandidateContract, AiJsonValue, AgenticAuthoringQuickReplyContract, AgenticAuthoringPendingClarificationContract, AiJsonObject, AgenticAuthoringComponentCapabilitiesResultContract, AgenticAuthoringComponentCapabilityCatalogContract, AgenticAuthoringComponentCapabilityContract, AgenticAuthoringComponentFieldAliasContract, AgenticAuthoringComponentCapabilityExampleContract, AgenticAuthoringAttachmentSummaryContract, AgenticAuthoringIntentResolutionRequestContract, AgenticAuthoringConversationMessageContract, AiContextHintsContract, AgenticAuthoringResourceCandidatesRequestContract, AgenticAuthoringResourceCandidatesResultContract, AgenticAuthoringTurnStreamStartResponseContract, AgenticAuthoringTurnStreamEnvelopeContract, PraxisAssistantShellMessage, PraxisAssistantShellQuickReply, PraxisAssistantShellAttachment, PraxisAssistantShellLayout, PraxisAssistantShellLabels, PraxisAssistantShellState, PraxisAssistantShellContextItem } from '@praxisui/ai';
 
 declare const PLACEHOLDER = 1;
 
@@ -589,7 +589,7 @@ interface PageBuilderAgenticAuthoringTurnStreamRequest {
     pendingClarification?: PageBuilderAgenticAuthoringPendingClarification | null;
     componentCapabilities?: PageBuilderAgenticAuthoringComponentCapabilitiesResult | null;
     attachmentSummaries?: PageBuilderAgenticAuthoringAttachmentSummary[];
-    contextHints?: AiJsonObject | null;
+    contextHints?: AiContextHintsContract | null;
 }
 type PageBuilderAgenticAuthoringConversationMessage = AgenticAuthoringConversationMessageContract;
 type PageBuilderAgenticAuthoringPendingClarification = AgenticAuthoringPendingClarificationContract;
@@ -748,7 +748,9 @@ declare class PageBuilderAgenticAuthoringService {
     private connectTurnStream;
     private streamConnectionError;
     private buildStreamUrl;
+    private buildStreamProbeUrl;
     private createEventSource;
+    private probeTurnStreamEndpoint;
     private formatEtag;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageBuilderAgenticAuthoringService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<PageBuilderAgenticAuthoringService>;
@@ -812,6 +814,8 @@ declare const PAGE_BUILDER_WIDGET_AI_CATALOGS: InjectionToken<Record<string, AiC
 
 declare function providePageBuilderWidgetAiCatalogs(): Provider;
 
+declare const PRAXIS_PAGE_BUILDER_AUTHORING_MANIFEST: ComponentAuthoringManifest;
+
 interface AgenticAuthoringQuickReply extends PraxisAssistantShellQuickReply {
     kind: string;
 }
@@ -917,5 +921,5 @@ declare class DynamicPageBuilderComponent implements OnChanges {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<DynamicPageBuilderComponent, "praxis-dynamic-page-builder", never, { "page": { "alias": "page"; "required": false; }; "context": { "alias": "context"; "required": false; }; "strictValidation": { "alias": "strictValidation"; "required": false; }; "autoPersist": { "alias": "autoPersist"; "required": false; }; "enableCustomization": { "alias": "enableCustomization"; "required": false; }; "showSettingsButton": { "alias": "showSettingsButton"; "required": false; }; "pageIdentity": { "alias": "pageIdentity"; "required": false; }; "componentInstanceId": { "alias": "componentInstanceId"; "required": false; }; "pageEditorComponent": { "alias": "pageEditorComponent"; "required": false; }; "enableAgenticAuthoring": { "alias": "enableAgenticAuthoring"; "required": false; }; "agenticAuthoringProvider": { "alias": "agenticAuthoringProvider"; "required": false; }; "agenticAuthoringModel": { "alias": "agenticAuthoringModel"; "required": false; }; "agenticAuthoringApiKey": { "alias": "agenticAuthoringApiKey"; "required": false; }; "agenticAuthoringComponentId": { "alias": "agenticAuthoringComponentId"; "required": false; }; "agenticAuthoringScope": { "alias": "agenticAuthoringScope"; "required": false; }; "agenticAuthoringEtag": { "alias": "agenticAuthoringEtag"; "required": false; }; "agenticAuthoringIncludeLlmDiagnostics": { "alias": "agenticAuthoringIncludeLlmDiagnostics"; "required": false; }; "agenticAuthoringEnableStreaming": { "alias": "agenticAuthoringEnableStreaming"; "required": false; }; }, { "pageChange": "pageChange"; "agenticAuthoringApplied": "agenticAuthoringApplied"; }, never, never, true, never>;
 }
 
-export { ComponentPaletteDialogComponent, ConfirmDialogComponent, DynamicPageBuilderComponent, DynamicPageConfigEditorComponent, FloatingToolbarComponent, PAGE_BUILDER_AGENTIC_AUTHORING_OPTIONS, PAGE_BUILDER_AI_CAPABILITIES, PAGE_BUILDER_WIDGET_AI_CATALOGS, PLACEHOLDER, PageBuilderAgenticAuthoringService, PageConfigEditorComponent, TileToolbarComponent, WidgetShellEditorComponent, clearWidgetAiCatalogs, getPageAiCatalog, getWidgetAiCapabilities, providePageBuilderWidgetAiCatalogs, registerWidgetAiCatalog, registerWidgetAiCatalogs };
+export { ComponentPaletteDialogComponent, ConfirmDialogComponent, DynamicPageBuilderComponent, DynamicPageConfigEditorComponent, FloatingToolbarComponent, PAGE_BUILDER_AGENTIC_AUTHORING_OPTIONS, PAGE_BUILDER_AI_CAPABILITIES, PAGE_BUILDER_WIDGET_AI_CATALOGS, PLACEHOLDER, PRAXIS_PAGE_BUILDER_AUTHORING_MANIFEST, PageBuilderAgenticAuthoringService, PageConfigEditorComponent, TileToolbarComponent, WidgetShellEditorComponent, clearWidgetAiCatalogs, getPageAiCatalog, getWidgetAiCapabilities, providePageBuilderWidgetAiCatalogs, registerWidgetAiCatalog, registerWidgetAiCatalogs };
 export type { Capability, CapabilityCatalog, CapabilityCategory, ComponentPaletteData, ConfirmDialogData, PageBuilderAgenticAuthoringAttachmentSummary, PageBuilderAgenticAuthoringCandidate, PageBuilderAgenticAuthoringComponentCapabilitiesResult, PageBuilderAgenticAuthoringComponentCapability, PageBuilderAgenticAuthoringComponentCapabilityCatalog, PageBuilderAgenticAuthoringComponentCapabilityExample, PageBuilderAgenticAuthoringComponentFieldAlias, PageBuilderAgenticAuthoringConversationMessage, PageBuilderAgenticAuthoringEventSource, PageBuilderAgenticAuthoringEventSourceFactory, PageBuilderAgenticAuthoringGateResult, PageBuilderAgenticAuthoringIntentResolutionRequest, PageBuilderAgenticAuthoringIntentResolutionResult, PageBuilderAgenticAuthoringOptions, PageBuilderAgenticAuthoringPendingClarification, PageBuilderAgenticAuthoringPromptRequest, PageBuilderAgenticAuthoringProvider, PageBuilderAgenticAuthoringQuickReply, PageBuilderAgenticAuthoringResourceCandidatesRequest, PageBuilderAgenticAuthoringResourceCandidatesResult, PageBuilderAgenticAuthoringTarget, PageBuilderAgenticAuthoringTurnStreamConnectionError, PageBuilderAgenticAuthoringTurnStreamEvent, PageBuilderAgenticAuthoringTurnStreamRequest, PageBuilderAgenticAuthoringTurnStreamStartResponse, PageBuilderApplyRequest, PageBuilderApplyResult, PageBuilderCompiledFormPatch, PageBuilderMinimalFormPlanResult, PageBuilderPreviewDiagnostics, PageBuilderPreviewResult, ValueKind };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@praxisui/page-builder",
-  "version": "8.0.0-beta.11",
+  "version": "8.0.0-beta.13",
   "description": "Page and widget builder utilities for Praxis UI (grid, dynamic widgets, editors).",
   "peerDependencies": {
     "@angular/common": "^20.0.0",
@@ -8,9 +8,9 @@
     "@angular/forms": "^20.0.0",
     "@angular/cdk": "^20.0.0",
     "@angular/material": "^20.0.0",
-    "@praxisui/ai": "^8.0.0-beta.11",
-    "@praxisui/core": "^8.0.0-beta.11",
-    "@praxisui/settings-panel": "^8.0.0-beta.11"
+    "@praxisui/ai": "^8.0.0-beta.13",
+    "@praxisui/core": "^8.0.0-beta.13",
+    "@praxisui/settings-panel": "^8.0.0-beta.13"
   },
   "dependencies": {
     "tslib": "^2.3.0"