@praxisui/editorial-forms 8.0.0-beta.2 → 8.0.0-beta.20

package/README.md

@@ -40,6 +40,31 @@ Optional integration:
 
 - `@praxisui/dynamic-form` if your `dataCollection` blocks should render real forms instead of fallback content
 
+## App provider
+
+Register the package provider in hosts that render the runtime through dynamic
+widget composition, including `@praxisui/core` dynamic pages, page-builder
+previews, examples, recipes and labs:
+
+```ts
+import { providePraxisEditorialForms } from '@praxisui/editorial-forms';
+
+export const appConfig = {
+  providers: [
+    providePraxisEditorialForms(),
+  ],
+};
+```
+
+`providePraxisEditorialForms()` registers the package dynamic widget metadata for
+`praxis-editorial-form-runtime`. It does not register the optional
+`@praxisui/dynamic-form` adapter and does not create a global singleton runtime
+graph.
+
+Without this provider, hosts may still use `EditorialFormRuntimeComponent`
+directly through a standalone import, but `DynamicWidgetLoader` cannot discover
+`praxis-editorial-form-runtime` from a JSON page definition.
+
 ## Core concepts
 
 - `solution`: canonical editorial definition
@@ -78,18 +103,21 @@ import {
 export class EditorialRuntimeDemoComponent {
   solution: EditorialRuntimeInput['solution'] = {
     solutionId: 'privacy-consent',
+    version: '1.0.0',
+    problemType: 'generic',
+    title: 'Privacy consent',
     journeys: [
       {
-        id: 'privacy-consent-journey',
-        title: 'Privacy consent',
+        journeyId: 'privacy-consent-journey',
+        label: 'Privacy consent',
         steps: [
           {
-            id: 'review',
-            title: 'Review and confirm',
+            stepId: 'review',
+            label: 'Review and confirm',
             blocks: [
               {
-                id: 'consent-form',
-                type: 'dataCollection',
+                blockId: 'consent-form',
+                kind: 'dataCollection',
                 formBlockId: 'consent-form',
               },
             ],
@@ -144,6 +172,34 @@ Recommended host usage:
 - use `operationalEvent` for technical telemetry, not as primary user-facing UI content
 - keep `runtimeContext` immutable from the host side; the runtime now emits refreshed state as blocks and adapters materialize `formData`
 
+## Dynamic widget composition
+
+The runtime publishes `praxis-editorial-form-runtime` as dynamic widget metadata
+with these canonical component ports:
+
+Inputs:
+
+- `solution`
+- `instance`
+- `runtimeContext`
+- `hostConfig`
+
+Outputs:
+
+- `snapshotChange`
+- `fallbackChange`
+- `operationalEvent`
+
+Nested dynamic page links must target these ports through
+`composition.links` using `component-port` endpoints. When the editorial runtime
+is nested inside a container such as Tabs or Expansion, persist the nested child
+identity through `nestedPath` and keep the terminal segment as a widget segment
+with stable `key` and `componentType: "praxis-editorial-form-runtime"`.
+
+Do not expose `widgetEvent`, `bindingPath`, host-specific aliases, or
+container-owned child-specific ports as the final contract for editorial runtime
+composition.
+
 ## Presentation layer
 
 The runtime now supports an optional `presentation` contract inside the editorial `solution`.
@@ -267,6 +323,7 @@ Without this provider, `dataCollection` blocks degrade to an accessible fallback
 ## Public API highlights
 
 - `EditorialFormRuntimeComponent`
+- `PRAXIS_EDITORIAL_FORMS_AUTHORING_MANIFEST`
 - `resolveEditorialRuntimeSnapshot(...)`
 - `EditorialDataBlockAdapter`
 - `EDITORIAL_DATA_BLOCK_ADAPTER`
@@ -293,6 +350,30 @@ Presentation model types from `@praxisui/core`:
 - `EditorialStepperConfig`
 - `EditorialStepVisualConfig`
 
+## Agentic authoring contract
+
+`PRAXIS_EDITORIAL_FORMS_AUTHORING_MANIFEST` is the executable AI authoring contract for this package.
+
+The manifest governs editorial document orchestration:
+
+- `snapshot.set`
+- `fallback.configure`
+- `presentation.configure`
+- `adapter.bind`
+- `dataBlock.add`
+- `dataBlock.remove`
+- `fieldBinding.set`
+
+Boundary rules:
+
+- `solution`, `instance` and `runtimeContext` resolve into `EditorialRuntimeSnapshot` without hidden drift
+- `fallback` must be explicit and backed by diagnostics
+- `presentation` only changes `solution.presentation`; it must not mutate domain data
+- `dataCollection` blocks require a registered adapter that supports the requested context
+- `dataBlock` authoring uses canonical `blockId` and `kind`; `id` and `type` are not accepted aliases
+- `snapshot.set` updates canonical runtime inputs (`solution`, `instance.context`, and `runtimeContext`) and does not persist active journey state as `instance.journeyId`
+- `FieldMetadata` shape changes are delegated to `@praxisui/metadata-editor` and dynamic-fields discovery instead of being redefined here
+
 ## Resolution and fallback behavior
 
 The resolved snapshot formalizes:

package/fesm2022/praxisui-editorial-forms.mjs

@@ -1,22 +1,10 @@
 import * as i0 from '@angular/core';
-import { makeEnvironmentProviders, InjectionToken, inject, DestroyRef, viewChild, ViewContainerRef, input, output, signal, computed, effect, ChangeDetectionStrategy, Component, reflectComponentType, Input } from '@angular/core';
+import { InjectionToken, makeEnvironmentProviders, inject, DestroyRef, viewChild, ViewContainerRef, input, output, signal, computed, effect, ChangeDetectionStrategy, Component, ENVIRONMENT_INITIALIZER, reflectComponentType, Input } from '@angular/core';
+import { PraxisI18nService, PraxisIconDirective, DynamicWidgetLoaderDirective, ComponentMetadataRegistry, providePraxisI18n } from '@praxisui/core';
 import { CommonModule } from '@angular/common';
-import { PraxisI18nService, PraxisIconDirective, DynamicWidgetLoaderDirective, providePraxisI18n } from '@praxisui/core';
 import * as i1 from '@angular/material/icon';
 import { MatIconModule } from '@angular/material/icon';
 
-/**
- * Root provider entrypoint for the editorial runtime package.
- *
- * Intentionally minimal in v1:
- * - no global singleton graph yet
- * - no dependency on @praxisui/dynamic-form
- * - safe to consume from apps without pulling generic form authoring
- */
-function providePraxisEditorialForms() {
-    return makeEnvironmentProviders([]);
-}
-
 const DEFAULT_EDITORIAL_RUNTIME_HOST_CONFIG = {
     emitOperationalEvents: true,
     forwardAdapterOperationalEvents: true,
@@ -3775,6 +3763,522 @@ function formatScopeLabel(labelName, label, id) {
     return null;
 }
 
+const EDITORIAL_FORM_RUNTIME_PORTS = [
+    {
+        id: 'solution',
+        label: 'Editorial solution',
+        direction: 'input',
+        semanticKind: 'config-fragment',
+        schema: {
+            id: 'EditorialSolutionDefinition',
+            kind: 'ts-type',
+            ref: 'EditorialSolutionDefinition',
+        },
+        description: 'Canonical editorial solution definition consumed by the runtime.',
+        exposure: { public: true, group: 'config' },
+    },
+    {
+        id: 'instance',
+        label: 'Editorial instance',
+        direction: 'input',
+        semanticKind: 'config-fragment',
+        schema: {
+            id: 'EditorialTemplateInstance',
+            kind: 'ts-type',
+            ref: 'EditorialTemplateInstance',
+        },
+        description: 'Runtime instance with persisted context, overrides and selected template reference.',
+        exposure: { public: true, group: 'config' },
+    },
+    {
+        id: 'runtimeContext',
+        label: 'Runtime context',
+        direction: 'input',
+        semanticKind: 'view-context',
+        schema: {
+            id: 'Record<string, unknown>',
+            kind: 'ts-type',
+            ref: 'Record<string, unknown>',
+        },
+        description: 'Host-provided context merged with the editorial instance context.',
+        exposure: { public: true, group: 'context' },
+    },
+    {
+        id: 'snapshotChange',
+        label: 'Snapshot change',
+        direction: 'output',
+        semanticKind: 'event',
+        cardinality: 'stream',
+        schema: {
+            id: 'EditorialRuntimeSnapshot',
+            kind: 'ts-type',
+            ref: 'EditorialRuntimeSnapshot',
+        },
+        description: 'Resolved editorial runtime snapshot emitted when solution, instance or context changes.',
+        exposure: { public: true, group: 'events' },
+    },
+    {
+        id: 'fallbackChange',
+        label: 'Fallback change',
+        direction: 'output',
+        semanticKind: 'status',
+        cardinality: 'stream',
+        schema: {
+            id: 'EditorialRuntimeFallbackState',
+            kind: 'ts-type',
+            ref: 'EditorialRuntimeFallbackState',
+        },
+        description: 'Operational fallback state emitted when diagnostics affect runtime health.',
+        exposure: { public: true, group: 'status' },
+    },
+    {
+        id: 'operationalEvent',
+        label: 'Operational event',
+        direction: 'output',
+        semanticKind: 'diagnostic',
+        cardinality: 'stream',
+        schema: {
+            id: 'EditorialRuntimeOperationalEvent',
+            kind: 'ts-type',
+            ref: 'EditorialRuntimeOperationalEvent',
+        },
+        description: 'Technical event stream for diagnostics, blocking errors and adapter state.',
+        exposure: { public: true, advanced: true, group: 'diagnostics' },
+    },
+];
+const EDITORIAL_FORM_RUNTIME_COMPONENT_METADATA = {
+    id: 'praxis-editorial-form-runtime',
+    componentType: 'praxis-editorial-form-runtime',
+    selector: 'praxis-editorial-form-runtime',
+    component: EditorialFormRuntimeComponent,
+    friendlyName: 'Praxis Editorial Form Runtime',
+    displayName: 'Praxis Editorial Form Runtime',
+    description: 'Guided editorial runtime for solution and instance driven form experiences.',
+    icon: 'article',
+    lib: '@praxisui/editorial-forms',
+    tags: ['widget', 'editorial', 'forms', 'runtime', 'guided-flow'],
+    inputs: [
+        {
+            name: 'solution',
+            type: 'EditorialSolutionDefinition | null',
+            description: 'Canonical editorial solution definition.',
+        },
+        {
+            name: 'instance',
+            type: 'EditorialTemplateInstance | null',
+            description: 'Editorial instance with context and overrides.',
+        },
+        {
+            name: 'runtimeContext',
+            type: 'Record<string, unknown> | null',
+            description: 'Host context merged into the resolved runtime context.',
+        },
+        {
+            name: 'hostConfig',
+            type: 'EditorialRuntimeHostConfig | null',
+            description: 'Host controls for operational event forwarding.',
+        },
+    ],
+    outputs: [
+        {
+            name: 'snapshotChange',
+            type: 'EditorialRuntimeSnapshot',
+            description: 'Resolved snapshot emitted by the editorial runtime.',
+        },
+        {
+            name: 'fallbackChange',
+            type: 'EditorialRuntimeFallbackState',
+            description: 'Fallback state emitted when diagnostics affect runtime health.',
+        },
+        {
+            name: 'operationalEvent',
+            type: 'EditorialRuntimeOperationalEvent',
+            description: 'Operational diagnostics event stream.',
+        },
+    ],
+    ports: EDITORIAL_FORM_RUNTIME_PORTS,
+    layoutHints: {
+        recommendedCols: 6,
+        recommendedRows: 6,
+        minCols: 4,
+        minRows: 4,
+    },
+};
+function providePraxisEditorialFormRuntimeMetadata() {
+    return {
+        provide: ENVIRONMENT_INITIALIZER,
+        multi: true,
+        useFactory: (registry) => () => {
+            registry.register(EDITORIAL_FORM_RUNTIME_COMPONENT_METADATA);
+        },
+        deps: [ComponentMetadataRegistry],
+    };
+}
+
+/**
+ * Root provider entrypoint for the editorial runtime package.
+ *
+ * Registers the public DynamicWidgetLoader metadata for
+ * praxis-editorial-form-runtime in ComponentMetadataRegistry. This is the
+ * canonical setup hook for hosts that render editorial forms through dynamic
+ * composition; it does not introduce a separate global runtime singleton graph.
+ */
+function providePraxisEditorialForms() {
+    return makeEnvironmentProviders([
+        providePraxisEditorialFormRuntimeMetadata(),
+    ]);
+}
+
+const snapshotSetSchema = {
+    type: 'object',
+    required: ['solutionId'],
+    properties: {
+        solutionId: { type: 'string' },
+        instanceId: { type: 'string' },
+        journeyId: { type: 'string' },
+        stepId: { type: 'string' },
+        runtimeContextPatch: { type: 'object' },
+        instanceContextPatch: { type: 'object' },
+        preserveDiagnostics: { type: 'boolean' },
+    },
+};
+const fallbackConfigureSchema = {
+    type: 'object',
+    required: ['mode'],
+    properties: {
+        mode: { enum: ['normal', 'warning', 'degraded', 'blocked'] },
+        diagnosticCode: { type: 'string' },
+        progressionBlocked: { type: 'boolean' },
+        requiresEngineAttention: { type: 'boolean' },
+        scope: {
+            type: 'object',
+            properties: {
+                journeyId: { type: 'string' },
+                stepId: { type: 'string' },
+                blockId: { type: 'string' },
+            },
+        },
+    },
+};
+const presentationConfigureSchema = {
+    type: 'object',
+    minProperties: 1,
+    properties: {
+        layout: {
+            type: 'object',
+            properties: {
+                orientation: { enum: ['horizontal', 'vertical'] },
+                density: { enum: ['compact', 'comfortable', 'relaxed'] },
+                maxWidth: { type: 'string' },
+                shellVariant: { type: 'string' },
+                spacing: { type: 'object' },
+                responsive: { type: 'object' },
+            },
+        },
+        theme: { type: 'object' },
+        stepper: {
+            type: 'object',
+            properties: {
+                visible: { type: 'boolean' },
+                orientation: { enum: ['horizontal', 'vertical'] },
+                showLabels: { type: 'boolean' },
+                showDescriptions: { type: 'boolean' },
+                showConnectors: { type: 'boolean' },
+                connectorStyle: { type: 'string' },
+                allowStepJump: { type: 'boolean' },
+            },
+        },
+    },
+};
+const adapterBindSchema = {
+    type: 'object',
+    required: ['adapterId', 'dataBlockType'],
+    properties: {
+        adapterId: { type: 'string' },
+        dataBlockType: { enum: ['dataCollection'] },
+        componentRef: { type: 'string' },
+        requiredInputs: {
+            type: 'array',
+            items: { type: 'string' },
+        },
+        forwardOperationalEvents: { type: 'boolean' },
+        fallbackModeWhenMissing: { enum: ['warning', 'degraded', 'blocked'] },
+    },
+};
+const dataBlockAddSchema = {
+    type: 'object',
+    required: ['journeyId', 'stepId', 'block'],
+    properties: {
+        journeyId: { type: 'string' },
+        stepId: { type: 'string' },
+        insert: {
+            type: 'object',
+            properties: {
+                mode: { enum: ['append', 'insertBefore', 'insertAfter'] },
+                relativeToBlockId: { type: 'string' },
+            },
+        },
+        block: {
+            type: 'object',
+            required: ['blockId', 'kind'],
+            properties: {
+                blockId: { type: 'string' },
+                kind: { enum: ['dataCollection', 'introHero', 'selectionCards', 'reviewSections', 'successPanel'] },
+                formBlockId: { type: 'string' },
+                formConfigRef: { type: 'string' },
+                title: { type: 'string' },
+                description: { type: 'string' },
+                visibility: { type: 'array' },
+            },
+        },
+    },
+};
+const dataBlockRemoveSchema = {
+    type: 'object',
+    required: ['journeyId', 'stepId', 'blockId'],
+    properties: {
+        journeyId: { type: 'string' },
+        stepId: { type: 'string' },
+        blockId: { type: 'string' },
+        requireNoFieldBindings: { type: 'boolean' },
+    },
+};
+const fieldBindingSetSchema = {
+    type: 'object',
+    required: ['blockId', 'fieldName', 'contextPath'],
+    properties: {
+        blockId: { type: 'string' },
+        fieldName: { type: 'string' },
+        contextPath: { type: 'string' },
+        mode: { enum: ['read', 'write', 'readWrite'] },
+        valueMode: { enum: ['merge', 'replace'] },
+        delegateFieldMetadataTo: { enum: ['praxis-metadata-editor'] },
+    },
+};
+const PRAXIS_EDITORIAL_FORMS_AUTHORING_MANIFEST = {
+    schemaVersion: '1.0.0',
+    componentId: 'praxis-editorial-forms',
+    ownerPackage: '@praxisui/editorial-forms',
+    configSchemaId: 'EditorialRuntimeInput',
+    manifestVersion: '1.0.0',
+    runtimeInputs: [
+        { name: 'solution', type: 'EditorialSolutionDefinition | null', description: 'Canonical editorial solution definition with journeys, steps, blocks and presentation.' },
+        { name: 'instance', type: 'EditorialTemplateInstance | null', description: 'Runtime instance with selected journey, context, overrides and compatibility form configs.' },
+        { name: 'runtimeContext', type: 'Record<string, unknown> | null', description: 'Host-provided immutable context merged into the resolved editorial snapshot.' },
+        { name: 'hostConfig', type: 'EditorialRuntimeHostConfig | null', description: 'Host controls for operational event and adapter event forwarding.' },
+        { name: 'snapshotChange', type: 'EditorialRuntimeSnapshot', description: 'Resolved runtime snapshot emitted to hosts for product UX and audit derivation.' },
+        { name: 'fallbackChange', type: 'EditorialRuntimeFallbackState', description: 'Operational fallback state emitted when diagnostics affect runtime health.' },
+        { name: 'operationalEvent', type: 'EditorialRuntimeOperationalEvent', description: 'Technical diagnostics event stream for logs, monitoring and runbooks.' },
+    ],
+    editableTargets: [
+        { kind: 'snapshot', resolver: 'editorial-runtime-snapshot', description: 'Resolved editorial state from solution, instance and runtime context.' },
+        { kind: 'fallback', resolver: 'editorial-runtime-fallback-state', description: 'Explicit operational fallback state derived from runtime diagnostics.' },
+        { kind: 'presentation', resolver: 'editorial-solution-presentation', description: 'Editorial presentation contract under solution.presentation.' },
+        { kind: 'adapter', resolver: 'editorial-data-block-adapter-registry', description: 'Optional dataCollection adapter binding and compatibility requirements.' },
+        { kind: 'dataBlock', resolver: 'editorial-journey-step-block-by-id', description: 'Editorial blocks inside journey steps, including dataCollection and presentational blocks.' },
+        { kind: 'fieldBinding', resolver: 'editorial-data-block-field-binding', description: 'Field-to-runtime-context binding for dataCollection blocks without redefining FieldMetadata.' },
+    ],
+    operations: [
+        {
+            operationId: 'snapshot.set',
+            title: 'Set editorial snapshot inputs',
+            scope: 'global',
+            targetKind: 'snapshot',
+            target: { kind: 'snapshot', resolver: 'editorial-runtime-snapshot', ambiguityPolicy: 'fail', required: false },
+            inputSchema: snapshotSetSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'editorial-snapshot-set', handlerContract: {
+                        reads: ['EditorialSolutionDefinition', 'EditorialTemplateInstance', 'runtimeContext', 'resolveEditorialRuntimeSnapshot'],
+                        writes: ['solution.solutionId', 'instance.instanceId', 'instance.context', 'runtimeContext'],
+                        identityKeys: ['solutionId', 'instanceId', 'journeyId'],
+                        inputSchema: snapshotSetSchema,
+                        failureModes: ['solution-not-found', 'journey-not-found', 'step-not-found', 'snapshot-shape-invalid', 'diagnostics-lost'],
+                        description: 'Compiles a deterministic patch to editorial runtime inputs, validates the requested journey/step against the resolved snapshot and requires diagnostics to be preserved.',
+                    } }],
+            validators: ['snapshot-shape-canonical', 'journey-exists', 'step-exists', 'diagnostics-preserved', 'editorial-round-trip'],
+            affectedPaths: ['solution.solutionId', 'instance.instanceId', 'instance.context', 'runtimeContext'],
+            submissionImpact: 'config-only',
+            preconditions: ['editorial-runtime-inputs-loaded'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+        {
+            operationId: 'fallback.configure',
+            title: 'Configure explicit fallback behavior',
+            scope: 'meta',
+            targetKind: 'fallback',
+            target: { kind: 'fallback', resolver: 'editorial-runtime-fallback-state', ambiguityPolicy: 'fail', required: false },
+            inputSchema: fallbackConfigureSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'editorial-fallback-configure', handlerContract: {
+                        reads: ['EditorialRuntimeDiagnostics', 'deriveRuntimeFallbackState', 'EditorialRuntimeFallbackScope'],
+                        writes: ['hostConfig.emitOperationalEvents', 'snapshot.diagnostics.items'],
+                        identityKeys: ['mode', 'diagnosticCode', 'scope.journeyId', 'scope.stepId'],
+                        inputSchema: fallbackConfigureSchema,
+                        failureModes: ['fallback-mode-invalid', 'blocking-diagnostic-missing', 'scope-not-found', 'implicit-degradation-not-allowed'],
+                        description: 'Requires fallback policy to be explicit and tied to snapshot diagnostics, because fallback state is derived by deriveRuntimeFallbackState instead of persisted as domain data.',
+                    } }],
+            validators: ['fallback-explicit', 'fallback-diagnostic-backed', 'fallback-scope-exists', 'editorial-round-trip'],
+            affectedPaths: ['hostConfig.emitOperationalEvents', 'snapshot.diagnostics.items'],
+            submissionImpact: 'config-only',
+            preconditions: ['snapshot-resolved'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+        {
+            operationId: 'presentation.configure',
+            title: 'Configure editorial presentation',
+            scope: 'skin',
+            targetKind: 'presentation',
+            target: { kind: 'presentation', resolver: 'editorial-solution-presentation', ambiguityPolicy: 'fail', required: false },
+            inputSchema: presentationConfigureSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'editorial-presentation-configure', handlerContract: {
+                        reads: ['solution.presentation', 'buildRuntimeLayoutCss', 'buildRuntimeCssVars', 'resolveRuntimeOrientation'],
+                        writes: ['solution.presentation.layout', 'solution.presentation.theme', 'solution.presentation.stepper'],
+                        identityKeys: ['solutionId', 'presentation.layout.orientation', 'presentation.stepper.orientation'],
+                        inputSchema: presentationConfigureSchema,
+                        failureModes: ['presentation-key-unsupported', 'theme-token-invalid', 'domain-data-mutation-detected', 'renderer-coverage-missing'],
+                        description: 'Applies presentation-only changes under solution.presentation and rejects changes that mutate editorial domain data.',
+                    } }],
+            validators: ['presentation-supported-by-runtime', 'presentation-does-not-mutate-domain-data', 'theme-tokens-valid', 'editorial-round-trip'],
+            affectedPaths: ['solution.presentation.layout', 'solution.presentation.theme', 'solution.presentation.stepper'],
+            submissionImpact: 'visual-only',
+            preconditions: ['solution-loaded'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+        {
+            operationId: 'adapter.bind',
+            title: 'Bind data block adapter',
+            scope: 'dataBinding',
+            targetKind: 'adapter',
+            target: { kind: 'adapter', resolver: 'editorial-data-block-adapter-registry', ambiguityPolicy: 'fail', required: true },
+            inputSchema: adapterBindSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'editorial-adapter-bind', handlerContract: {
+                        reads: ['EDITORIAL_DATA_BLOCK_ADAPTER', 'EditorialDataBlockAdapterRegistry', 'EditorialDataBlockContext', 'ComponentDocMeta'],
+                        writes: ['hostConfig.forwardAdapterOperationalEvents', 'snapshot.diagnostics.items'],
+                        identityKeys: ['adapterId', 'dataBlockType'],
+                        inputSchema: adapterBindSchema,
+                        failureModes: ['adapter-not-registered', 'adapter-does-not-support-data-block', 'adapter-component-invalid', 'fallback-policy-missing'],
+                        description: 'Validates the external provider binding for a dataCollection adapter and records the host operational-event policy required when the adapter is missing or incompatible.',
+                    } }],
+            validators: ['adapter-exists', 'adapter-supports-data-block', 'adapter-component-valid', 'fallback-explicit', 'editorial-round-trip'],
+            affectedPaths: ['hostConfig.forwardAdapterOperationalEvents', 'snapshot.diagnostics.items'],
+            submissionImpact: 'config-only',
+            preconditions: ['adapter-registry-loaded'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+        {
+            operationId: 'dataBlock.add',
+            title: 'Add editorial data block',
+            scope: 'section',
+            targetKind: 'dataBlock',
+            target: { kind: 'dataBlock', resolver: 'editorial-journey-step-block-by-id', ambiguityPolicy: 'fail', required: true },
+            inputSchema: dataBlockAddSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'editorial-data-block-add', handlerContract: {
+                        reads: ['EditorialSolutionDefinition.journeys', 'EditorialResolvedStep.blocks', 'EditorialDataBlockAdapterRegistry'],
+                        writes: ['solution.journeys[].steps[].blocks'],
+                        identityKeys: ['journeyId', 'stepId', 'block.blockId'],
+                        inputSchema: dataBlockAddSchema,
+                        failureModes: ['journey-not-found', 'step-not-found', 'duplicate-block-id', 'data-collection-config-unresolved', 'adapter-not-registered'],
+                        description: 'Adds a canonical editorial block to a step and validates dataCollection readiness without redefining Dynamic Form config semantics.',
+                    } }],
+            validators: ['data-block-id-unique', 'journey-exists', 'step-exists', 'adapter-supports-data-block', 'editorial-round-trip'],
+            affectedPaths: ['solution.journeys[].steps[].blocks'],
+            submissionImpact: 'config-only',
+            preconditions: ['solution-loaded'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+        {
+            operationId: 'dataBlock.remove',
+            title: 'Remove editorial data block',
+            scope: 'section',
+            targetKind: 'dataBlock',
+            target: { kind: 'dataBlock', resolver: 'editorial-journey-step-block-by-id', ambiguityPolicy: 'fail', required: true },
+            inputSchema: dataBlockRemoveSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'editorial-data-block-remove', handlerContract: {
+                        reads: ['EditorialSolutionDefinition.journeys', 'EditorialResolvedStep.blocks', 'fieldBinding'],
+                        writes: ['solution.journeys[].steps[].blocks'],
+                        identityKeys: ['journeyId', 'stepId', 'blockId'],
+                        inputSchema: dataBlockRemoveSchema,
+                        failureModes: ['journey-not-found', 'step-not-found', 'block-not-found', 'field-bindings-still-reference-block'],
+                        description: 'Removes a block by stable id and rejects removal when governed field bindings still reference the block.',
+                    } }],
+            destructive: true,
+            requiresConfirmation: true,
+            validators: ['data-block-exists', 'field-binding-target-exists', 'editorial-round-trip'],
+            affectedPaths: ['solution.journeys[].steps[].blocks'],
+            submissionImpact: 'config-only',
+            preconditions: ['solution-loaded', 'explicit-confirmation-provided'],
+        },
+        {
+            operationId: 'fieldBinding.set',
+            title: 'Set editorial field binding',
+            scope: 'fieldMetadataPath',
+            targetKind: 'fieldBinding',
+            target: { kind: 'fieldBinding', resolver: 'editorial-data-block-field-binding', ambiguityPolicy: 'fail', required: true },
+            inputSchema: fieldBindingSetSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'editorial-field-binding-set', handlerContract: {
+                        reads: ['EditorialDataCollectionBlock', 'resolvedFormConfig.fieldMetadata', 'runtimeContext.formData', 'PRAXIS_METADATA_EDITOR_AUTHORING_MANIFEST'],
+                        writes: ['runtimeContext.formData'],
+                        identityKeys: ['blockId', 'fieldName', 'contextPath'],
+                        inputSchema: fieldBindingSetSchema,
+                        failureModes: ['block-not-found', 'field-not-found', 'context-path-invalid', 'field-metadata-delegation-required', 'domain-data-mutation-detected'],
+                        description: 'Sets the governed runtimeContext.formData path used by dataCollection adapters and delegates FieldMetadata shape changes to the metadata-editor manifest.',
+                    } }],
+            validators: ['field-binding-target-exists', 'field-binding-path-valid', 'delegates-field-metadata', 'editorial-round-trip'],
+            affectedPaths: ['runtimeContext.formData'],
+            submissionImpact: 'affects-schema-backed-data',
+            preconditions: ['data-block-resolved', 'field-metadata-loaded'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+    ],
+    validators: [
+        { validatorId: 'snapshot-shape-canonical', level: 'error', code: 'EDITORIAL_SNAPSHOT_SHAPE_CANONICAL', description: 'Resolved snapshot must remain compatible with EditorialRuntimeSnapshot.' },
+        { validatorId: 'journey-exists', level: 'error', code: 'EDITORIAL_JOURNEY_EXISTS', description: 'Target journey must exist in the editorial solution.' },
+        { validatorId: 'step-exists', level: 'error', code: 'EDITORIAL_STEP_EXISTS', description: 'Target step must exist in the selected journey.' },
+        { validatorId: 'diagnostics-preserved', level: 'error', code: 'EDITORIAL_DIAGNOSTICS_PRESERVED', description: 'Patch compilation must not drop runtime diagnostics.' },
+        { validatorId: 'fallback-explicit', level: 'error', code: 'EDITORIAL_FALLBACK_EXPLICIT', description: 'Fallback behavior must be explicit instead of implied by missing adapter or hidden diagnostics.' },
+        { validatorId: 'fallback-diagnostic-backed', level: 'error', code: 'EDITORIAL_FALLBACK_DIAGNOSTIC_BACKED', description: 'Warning, degraded and blocked fallback states must be backed by diagnostics.' },
+        { validatorId: 'fallback-scope-exists', level: 'error', code: 'EDITORIAL_FALLBACK_SCOPE_EXISTS', description: 'Fallback scope must resolve to an existing journey, step or block.' },
+        { validatorId: 'presentation-supported-by-runtime', level: 'error', code: 'EDITORIAL_PRESENTATION_SUPPORTED', description: 'Presentation keys must be supported by the runtime or intentionally diagnosed as unsupported.' },
+        { validatorId: 'presentation-does-not-mutate-domain-data', level: 'error', code: 'EDITORIAL_PRESENTATION_DOMAIN_SAFE', description: 'Presentation changes must not mutate solution journeys, blocks, field metadata or runtime context data.' },
+        { validatorId: 'theme-tokens-valid', level: 'error', code: 'EDITORIAL_THEME_TOKENS_VALID', description: 'Theme tokens must be valid runtime CSS variable inputs.' },
+        { validatorId: 'adapter-exists', level: 'error', code: 'EDITORIAL_ADAPTER_EXISTS', description: 'Requested adapter must exist in EditorialDataBlockAdapterRegistry.' },
+        { validatorId: 'adapter-supports-data-block', level: 'error', code: 'EDITORIAL_ADAPTER_SUPPORTS_DATA_BLOCK', description: 'Requested adapter must support the target data block context.' },
+        { validatorId: 'adapter-component-valid', level: 'error', code: 'EDITORIAL_ADAPTER_COMPONENT_VALID', description: 'Adapter component must expose the inputs required by the adapter contract.' },
+        { validatorId: 'data-block-id-unique', level: 'error', code: 'EDITORIAL_DATA_BLOCK_ID_UNIQUE', description: 'Block ids must be unique within the resolved editorial step.' },
+        { validatorId: 'data-block-exists', level: 'error', code: 'EDITORIAL_DATA_BLOCK_EXISTS', description: 'Target data block must exist before destructive or binding operations.' },
+        { validatorId: 'field-binding-target-exists', level: 'error', code: 'EDITORIAL_FIELD_BINDING_TARGET_EXISTS', description: 'Field binding must target an existing dataCollection block and field.' },
+        { validatorId: 'field-binding-path-valid', level: 'error', code: 'EDITORIAL_FIELD_BINDING_PATH_VALID', description: 'Field binding context path must be deterministic and inside governed runtime context data.' },
+        { validatorId: 'delegates-field-metadata', level: 'error', code: 'EDITORIAL_DELEGATES_FIELD_METADATA', description: 'FieldMetadata shape changes must be delegated to the metadata-editor manifest instead of duplicated here.' },
+        { validatorId: 'editorial-round-trip', level: 'error', code: 'EDITORIAL_ROUND_TRIP', description: 'Open, edit, apply/save, reopen and runtime consume must preserve the editorial document.' },
+    ],
+    roundTripRequirements: [
+        'EditorialRuntimeInput is the package-level authoring document; solution, instance and runtimeContext must resolve into EditorialRuntimeSnapshot without drift.',
+        'Fallback behavior must be explicit and backed by diagnostics; missing adapters cannot be hidden as successful rendering.',
+        'Presentation changes are constrained to solution.presentation and must not mutate journeys, blocks, FormConfig, FieldMetadata or runtimeContext domain data.',
+        'dataCollection blocks require an adapter that exists and supports the requested context, while Dynamic Form config semantics remain owned by @praxisui/dynamic-form.',
+        'FieldMetadata authoring is delegated to praxis-metadata-editor and dynamic-fields discovery; this manifest only governs editorial binding and orchestration.',
+        'Destructive block removal requires confirmation and must reject references from existing field bindings.',
+    ],
+    examples: [
+        { id: 'select-journey', request: 'Set the onboarding journey as the active editorial path.', operationId: 'snapshot.set', params: { solutionId: 'customer-onboarding', journeyId: 'onboarding' }, isPositive: true },
+        { id: 'merge-runtime-context', request: 'Prefill the runtime context with the selected plan.', operationId: 'snapshot.set', params: { solutionId: 'plan-signup', runtimeContextPatch: { selectedPlan: 'pro' } }, isPositive: true },
+        { id: 'configure-blocked-fallback', request: 'Block progression when the required dataCollection adapter is missing.', operationId: 'fallback.configure', params: { mode: 'blocked', diagnosticCode: 'data-collection-adapter-missing', progressionBlocked: true }, isPositive: true },
+        { id: 'configure-stepper', request: 'Use a vertical compact stepper with hidden descriptions.', operationId: 'presentation.configure', params: { layout: { orientation: 'vertical', density: 'compact' }, stepper: { showDescriptions: false } }, isPositive: true },
+        { id: 'bind-dynamic-form-adapter', request: 'Bind the dynamic-form adapter for dataCollection blocks.', operationId: 'adapter.bind', params: { adapterId: 'dynamic-form', dataBlockType: 'dataCollection', requiredInputs: ['config', 'formId', 'editorialContext'], fallbackModeWhenMissing: 'blocked' }, isPositive: true },
+        { id: 'add-data-block', request: 'Add a consent form block to the review step.', operationId: 'dataBlock.add', params: { journeyId: 'privacy', stepId: 'review', block: { blockId: 'consent-form', kind: 'dataCollection', formBlockId: 'consent-form' } }, isPositive: true },
+        { id: 'remove-block', request: 'Remove the unused legacy consent block.', operationId: 'dataBlock.remove', params: { journeyId: 'privacy', stepId: 'review', blockId: 'legacy-consent', requireNoFieldBindings: true }, isPositive: true },
+        { id: 'set-field-binding', request: 'Bind the email field into runtimeContext.formData.email.', operationId: 'fieldBinding.set', params: { blockId: 'contact-form', fieldName: 'email', contextPath: 'formData.email', mode: 'readWrite', delegateFieldMetadataTo: 'praxis-metadata-editor' }, isPositive: true },
+        { id: 'reject-presentation-domain-mutation', request: 'Change presentation and also rewrite the collected email value.', operationId: 'presentation.configure', params: { layout: { density: 'relaxed' }, runtimeContextPatch: { formData: { email: 'changed@example.com' } } }, isPositive: false },
+        { id: 'reject-missing-adapter', request: 'Render a dataCollection block with an adapter that is not registered.', operationId: 'adapter.bind', params: { adapterId: 'unknown-form-engine', dataBlockType: 'dataCollection' }, isPositive: false },
+        { id: 'reject-duplicate-block', request: 'Add another block using the existing consent-form id.', operationId: 'dataBlock.add', params: { journeyId: 'privacy', stepId: 'review', block: { blockId: 'consent-form', kind: 'dataCollection', formBlockId: 'consent-form-copy' } }, isPositive: false },
+        { id: 'reject-field-metadata-duplication', request: 'Change the control type inside editorial forms instead of metadata editor.', operationId: 'fieldBinding.set', params: { blockId: 'contact-form', fieldName: 'email', contextPath: 'formData.email', controlType: 'select' }, isPositive: false },
+    ],
+};
+
 const REQUIRED_DYNAMIC_FORM_INPUTS = ['config', 'formId', 'editorialContext'];
 function readRuntimeFormData(runtimeContext) {
     const formData = runtimeContext?.['formData'];
@@ -4301,4 +4805,4 @@ function getHarnessDataEngineComponent() {
  * Generated bundle index. Do not edit.
  */
 
-export { DEFAULT_EDITORIAL_RUNTIME_HOST_CONFIG, EDITORIAL_DATA_BLOCK_ADAPTER, EditorialBlockRendererComponent, EditorialDataBlockAdapterRegistry, EditorialDataCollectionBlockOutletComponent, EditorialFormRuntimeComponent, EditorialIntroHeroBlockComponent, EditorialReviewSectionsBlockComponent, EditorialRuntimeState, EditorialSelectionCardsBlockComponent, EditorialStepperComponent, EditorialSuccessPanelBlockComponent, HarnessDataEngineComponent, PRAXIS_EDITORIAL_FORMS_EN_US, PRAXIS_EDITORIAL_FORMS_PT_BR, buildRuntimeCssVars, buildRuntimeLayoutCss, createEditorialDynamicFormAdapter, createEditorialRuntimeHarnessCatalog, createPraxisEditorialFormsI18nConfig, deriveRuntimeFallbackState, getHarnessDataEngineComponent, getStepDisplayState, getValueAtPath, getVisibleBlocks, isBlockVisible, matchesVisibilityRule, provideEditorialDataBlockAdapter, provideEditorialDynamicFormAdapter, providePraxisEditorialForms, providePraxisEditorialFormsI18n, resolveActiveJourney, resolveActiveStep, resolveDensity, resolveEditorialDataBlockAdapter, resolveEditorialDataBlockFormConfig, resolveEditorialDataBlockFormConfigDetails, resolveEditorialRuntimeSnapshot, resolveRuntimeOrientation, resolveShellVariant };
+export { DEFAULT_EDITORIAL_RUNTIME_HOST_CONFIG, EDITORIAL_DATA_BLOCK_ADAPTER, EDITORIAL_FORM_RUNTIME_COMPONENT_METADATA, EditorialBlockRendererComponent, EditorialDataBlockAdapterRegistry, EditorialDataCollectionBlockOutletComponent, EditorialFormRuntimeComponent, EditorialIntroHeroBlockComponent, EditorialReviewSectionsBlockComponent, EditorialRuntimeState, EditorialSelectionCardsBlockComponent, EditorialStepperComponent, EditorialSuccessPanelBlockComponent, HarnessDataEngineComponent, PRAXIS_EDITORIAL_FORMS_AUTHORING_MANIFEST, PRAXIS_EDITORIAL_FORMS_EN_US, PRAXIS_EDITORIAL_FORMS_PT_BR, buildRuntimeCssVars, buildRuntimeLayoutCss, createEditorialDynamicFormAdapter, createEditorialRuntimeHarnessCatalog, createPraxisEditorialFormsI18nConfig, deriveRuntimeFallbackState, getHarnessDataEngineComponent, getStepDisplayState, getValueAtPath, getVisibleBlocks, isBlockVisible, matchesVisibilityRule, provideEditorialDataBlockAdapter, provideEditorialDynamicFormAdapter, providePraxisEditorialFormRuntimeMetadata, providePraxisEditorialForms, providePraxisEditorialFormsI18n, resolveActiveJourney, resolveActiveStep, resolveDensity, resolveEditorialDataBlockAdapter, resolveEditorialDataBlockFormConfig, resolveEditorialDataBlockFormConfigDetails, resolveEditorialRuntimeSnapshot, resolveRuntimeOrientation, resolveShellVariant };

package/index.d.ts

@@ -1,18 +1,20 @@
 import * as _angular_core from '@angular/core';
-import { EnvironmentProviders, Type, InjectionToken } from '@angular/core';
+import { EnvironmentProviders, Provider, Type, InjectionToken } from '@angular/core';
 import * as _praxisui_core from '@praxisui/core';
-import { EditorialProblemType, EditorialWizardPresentation, EditorialThemePreset, EditorialCompliancePreset, EditorialStepKind, EditorialIconSpec, EditorialStepVisualConfig, EditorialBlock, EditorialDataCollectionBlock, EditorialSolutionDefinition, EditorialTemplateInstance, PraxisTranslationParams, FormConfig, EditorialLayoutConfig, EditorialStepperConfig, EditorialOrientation, EditorialThemeTokens, EditorialBlockVisibilityRule, PraxisI18nDictionary, PraxisI18nConfig, EditorialIntroHeroBlock, EditorialHeroBlock, EditorialRichTextBlock, EditorialPolicyListBlock, EditorialTimelineStepsBlock, EditorialReviewSummaryBlock, EditorialReviewSectionsBlock, EditorialContextSummaryBlock, EditorialSelectionCardsBlock, EditorialInfoCardsBlock, EditorialSuccessPanelBlock, EditorialFaqAccordionBlock, EditorialPresentationalAction, EditorialReviewSectionField } from '@praxisui/core';
+import { ComponentAuthoringManifest, EditorialProblemType, EditorialWizardPresentation, EditorialThemePreset, EditorialCompliancePreset, EditorialStepKind, EditorialIconSpec, EditorialStepVisualConfig, EditorialBlock, EditorialDataCollectionBlock, EditorialSolutionDefinition, EditorialTemplateInstance, PraxisTranslationParams, ComponentDocMeta, FormConfig, EditorialLayoutConfig, EditorialStepperConfig, EditorialOrientation, EditorialThemeTokens, EditorialBlockVisibilityRule, PraxisI18nDictionary, PraxisI18nConfig, EditorialIntroHeroBlock, EditorialHeroBlock, EditorialRichTextBlock, EditorialPolicyListBlock, EditorialTimelineStepsBlock, EditorialReviewSummaryBlock, EditorialReviewSectionsBlock, EditorialContextSummaryBlock, EditorialSelectionCardsBlock, EditorialInfoCardsBlock, EditorialSuccessPanelBlock, EditorialFaqAccordionBlock, EditorialPresentationalAction, EditorialReviewSectionField } from '@praxisui/core';
 
 /**
  * Root provider entrypoint for the editorial runtime package.
  *
- * Intentionally minimal in v1:
- * - no global singleton graph yet
- * - no dependency on @praxisui/dynamic-form
- * - safe to consume from apps without pulling generic form authoring
+ * Registers the public DynamicWidgetLoader metadata for
+ * praxis-editorial-form-runtime in ComponentMetadataRegistry. This is the
+ * canonical setup hook for hosts that render editorial forms through dynamic
+ * composition; it does not introduce a separate global runtime singleton graph.
  */
 declare function providePraxisEditorialForms(): EnvironmentProviders;
 
+declare const PRAXIS_EDITORIAL_FORMS_AUTHORING_MANIFEST: ComponentAuthoringManifest;
+
 type EditorialRuntimeDiagnosticSeverity = 'info' | 'warning' | 'error';
 type EditorialRuntimeDiagnosticScopeKind = 'global' | 'journey' | 'step' | 'block';
 type EditorialRuntimeDiagnosticCode = 'solution-missing' | 'theme-preset-not-found' | 'compliance-preset-not-found' | 'compliance-preset-problem-type-mismatch' | 'presentation-config-unsupported' | 'context-required-missing' | 'compliance-context-required-missing' | 'compliance-evidence-missing' | 'compliance-acceptance-missing' | 'data-collection-config-missing' | 'data-collection-config-ambiguous' | 'data-collection-adapter-missing' | 'data-collection-invalid' | 'instance-journey-block-conflict' | 'journey-override-target-missing' | 'step-override-target-missing' | 'block-override-invalid' | 'block-override-conflict' | 'block-override-target-missing';
@@ -257,6 +259,9 @@ declare class EditorialFormRuntimeComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<EditorialFormRuntimeComponent, "praxis-editorial-form-runtime", never, { "solution": { "alias": "solution"; "required": false; "isSignal": true; }; "instance": { "alias": "instance"; "required": false; "isSignal": true; }; "runtimeContext": { "alias": "runtimeContext"; "required": false; "isSignal": true; }; "hostConfig": { "alias": "hostConfig"; "required": false; "isSignal": true; }; }, { "snapshotChange": "snapshotChange"; "fallbackChange": "fallbackChange"; "operationalEvent": "operationalEvent"; }, never, never, true, never>;
 }
 
+declare const EDITORIAL_FORM_RUNTIME_COMPONENT_METADATA: ComponentDocMeta;
+declare function providePraxisEditorialFormRuntimeMetadata(): Provider;
+
 type EditorialDataBlockComponentInputs = Record<string, unknown>;
 interface EditorialDataBlockValueChangeEvent {
     formData: Record<string, unknown>;
@@ -748,5 +753,5 @@ interface EditorialRuntimeHarnessCatalog {
 declare function createEditorialRuntimeHarnessCatalog(): EditorialRuntimeHarnessCatalog;
 declare function getHarnessDataEngineComponent(): Type<unknown>;
 
-export { DEFAULT_EDITORIAL_RUNTIME_HOST_CONFIG, EDITORIAL_DATA_BLOCK_ADAPTER, EditorialBlockRendererComponent, EditorialDataBlockAdapterRegistry, EditorialDataCollectionBlockOutletComponent, EditorialFormRuntimeComponent, EditorialIntroHeroBlockComponent, EditorialReviewSectionsBlockComponent, EditorialRuntimeState, EditorialSelectionCardsBlockComponent, EditorialStepperComponent, EditorialSuccessPanelBlockComponent, HarnessDataEngineComponent, PRAXIS_EDITORIAL_FORMS_EN_US, PRAXIS_EDITORIAL_FORMS_PT_BR, buildRuntimeCssVars, buildRuntimeLayoutCss, createEditorialDynamicFormAdapter, createEditorialRuntimeHarnessCatalog, createPraxisEditorialFormsI18nConfig, deriveRuntimeFallbackState, getHarnessDataEngineComponent, getStepDisplayState, getValueAtPath, getVisibleBlocks, isBlockVisible, matchesVisibilityRule, provideEditorialDataBlockAdapter, provideEditorialDynamicFormAdapter, providePraxisEditorialForms, providePraxisEditorialFormsI18n, resolveActiveJourney, resolveActiveStep, resolveDensity, resolveEditorialDataBlockAdapter, resolveEditorialDataBlockFormConfig, resolveEditorialDataBlockFormConfigDetails, resolveEditorialRuntimeSnapshot, resolveRuntimeOrientation, resolveShellVariant };
+export { DEFAULT_EDITORIAL_RUNTIME_HOST_CONFIG, EDITORIAL_DATA_BLOCK_ADAPTER, EDITORIAL_FORM_RUNTIME_COMPONENT_METADATA, EditorialBlockRendererComponent, EditorialDataBlockAdapterRegistry, EditorialDataCollectionBlockOutletComponent, EditorialFormRuntimeComponent, EditorialIntroHeroBlockComponent, EditorialReviewSectionsBlockComponent, EditorialRuntimeState, EditorialSelectionCardsBlockComponent, EditorialStepperComponent, EditorialSuccessPanelBlockComponent, HarnessDataEngineComponent, PRAXIS_EDITORIAL_FORMS_AUTHORING_MANIFEST, PRAXIS_EDITORIAL_FORMS_EN_US, PRAXIS_EDITORIAL_FORMS_PT_BR, buildRuntimeCssVars, buildRuntimeLayoutCss, createEditorialDynamicFormAdapter, createEditorialRuntimeHarnessCatalog, createPraxisEditorialFormsI18nConfig, deriveRuntimeFallbackState, getHarnessDataEngineComponent, getStepDisplayState, getValueAtPath, getVisibleBlocks, isBlockVisible, matchesVisibilityRule, provideEditorialDataBlockAdapter, provideEditorialDynamicFormAdapter, providePraxisEditorialFormRuntimeMetadata, providePraxisEditorialForms, providePraxisEditorialFormsI18n, resolveActiveJourney, resolveActiveStep, resolveDensity, resolveEditorialDataBlockAdapter, resolveEditorialDataBlockFormConfig, resolveEditorialDataBlockFormConfigDetails, resolveEditorialRuntimeSnapshot, resolveRuntimeOrientation, resolveShellVariant };
 export type { DynamicFormCompatibleComponent, EditorialDataBlockAdapter, EditorialDataBlockAdapterResolution, EditorialDataBlockAdapterResolutionStatus, EditorialDataBlockComponentInputs, EditorialDataBlockContext, EditorialDataBlockResolution, EditorialDataBlockValueChangeEvent, EditorialDynamicFormAdapterOptions, EditorialResolvedBlock, EditorialResolvedBlockBase, EditorialResolvedBlockCompositionEntry, EditorialResolvedBlockCompositionOperation, EditorialResolvedBlockProvenance, EditorialResolvedBlockSourceKind, EditorialResolvedBlockSourceRef, EditorialResolvedDataCollectionBlock, EditorialResolvedDataCollectionState, EditorialResolvedJourney, EditorialResolvedStep, EditorialRuntimeDiagnostic, EditorialRuntimeDiagnosticCode, EditorialRuntimeDiagnosticScopeKind, EditorialRuntimeDiagnosticSeverity, EditorialRuntimeDiagnostics, EditorialRuntimeFallbackMode, EditorialRuntimeFallbackScope, EditorialRuntimeFallbackState, EditorialRuntimeFixture, EditorialRuntimeHarnessCatalog, EditorialRuntimeHostConfig, EditorialRuntimeInput, EditorialRuntimeOperationalEvent, EditorialRuntimeOperationalEventBase, EditorialRuntimeOperationalEventSeverity, EditorialRuntimeOperationalEventType, EditorialRuntimeSnapshot, PraxisEditorialFormsI18nOptions, ResolveEditorialRuntimeSnapshotInput };

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@praxisui/editorial-forms",
-  "version": "8.0.0-beta.2",
+  "version": "8.0.0-beta.20",
   "description": "Editorial form runtime for Praxis UI: journeys, presets, semantic blocks, and specialist hosting for editorial experiences.",
   "peerDependencies": {
     "@angular/common": "^20.0.0",
     "@angular/core": "^20.0.0",
-    "@praxisui/core": "^8.0.0-beta.2"
+    "@praxisui/core": "^8.0.0-beta.20",
+    "@angular/material": "^20.0.0"
   },
   "dependencies": {
     "tslib": "^2.3.0"