@praxisui/rich-content 8.0.0-beta.11 → 8.0.0-beta.12

package/README.md

@@ -109,13 +109,21 @@ through `PRAXIS_RICH_CONTENT_AUTHORING_MANIFEST`.
 
 The manifest treats rich content as structured `RichContentDocument` data, not
 HTML or markdown patches. It governs document replacement, block add/remove,
-block order, text updates, canonical link nodes, preset refs and sanitization
-policy. Security-sensitive policy edits and destructive removals require
-confirmation before a patch can be compiled.
+block order, text updates, canonical link nodes, common node metadata,
+`mediaBlock` fields, `timeline.items[]`, preset refs and sanitization policy.
+Security-sensitive policy edits and destructive removals require confirmation
+before a patch can be compiled.
 
 Link authoring uses a first-class `link` node with `label`, `href`, `target`
 and `rel`; unsafe protocols are rejected by `validateRichContentDocument()`.
 
+Each operation declares its own editable target resolver, ambiguity policy,
+preconditions, validators, affected paths, effects and typed submission impact.
+Document, block, text, link, media, timeline, preset, metadata and sanitization
+operations are `config-only` because they edit the structured widget input
+contract. `display.mode.set` is `visual-only` because it changes `layout` and
+`rootClassName` without mutating the `RichContentDocument`.
+
 ## Layout Modes
 
 The component defaults to `layout="block"` to preserve document-style rendering.

package/fesm2022/praxisui-rich-content.mjs

@@ -3982,6 +3982,8 @@ const RICH_CONTENT_AI_CAPABILITIES = {
         { path: 'document.nodes[].icon', category: 'richNode', valueKind: 'string', description: 'Nome do icone Material Symbols para node icon ou badge.' },
         { path: 'document.nodes[].label', category: 'richNode', valueKind: 'string', description: 'Label literal para badge, metric ou progress.' },
         { path: 'document.nodes[].labelExpr', category: 'richNode', valueKind: 'string', description: 'Path simples resolvido contra o contexto para label.' },
+        { path: 'document.nodes[].title', category: 'richNode', valueKind: 'string', description: 'Titulo literal para card, mediaBlock ou timeline.' },
+        { path: 'document.nodes[].subtitle', category: 'richNode', valueKind: 'string', description: 'Subtitulo literal para card ou mediaBlock.' },
         { path: 'document.nodes[].src', category: 'richNode', valueKind: 'string', description: 'URL literal para image.' },
         { path: 'document.nodes[].srcExpr', category: 'richNode', valueKind: 'string', description: 'Path simples resolvido contra o contexto para image src.' },
         { path: 'document.nodes[].alt', category: 'richNode', valueKind: 'string', description: 'Texto alternativo literal para image.' },
@@ -3992,7 +3994,12 @@ const RICH_CONTENT_AI_CAPABILITIES = {
         { path: 'document.nodes[].nameExpr', category: 'richNode', valueKind: 'string', description: 'Path simples resolvido contra o contexto para avatar.' },
         { path: 'document.nodes[].valueExpr', category: 'richNode', valueKind: 'string', description: 'Path simples resolvido contra o contexto para metric/progress.' },
         { path: 'document.nodes[].items', category: 'richNode', valueKind: 'array', description: 'Itens internos de compose.' },
+        { path: 'document.nodes[].items[].title', category: 'richNode', valueKind: 'string', description: 'Titulo de item de timeline quando document.nodes[].type for timeline.' },
+        { path: 'document.nodes[].items[].subtitle', category: 'richNode', valueKind: 'string', description: 'Subtitulo de item de timeline quando document.nodes[].type for timeline.' },
+        { path: 'document.nodes[].items[].badge', category: 'richNode', valueKind: 'string', description: 'Badge de item de timeline quando document.nodes[].type for timeline.' },
+        { path: 'document.nodes[].items[].icon', category: 'richNode', valueKind: 'string', description: 'Icone de item de timeline quando document.nodes[].type for timeline.' },
         { path: 'document.nodes[].content', category: 'richNode', valueKind: 'array', description: 'Conteudo interno de card.' },
+        { path: 'document.nodes[].avatar', category: 'richNode', valueKind: 'object', description: 'Avatar estruturado de mediaBlock.' },
         { path: 'document.nodes[].trailing', category: 'richNode', valueKind: 'array', description: 'Conteudo trailing de mediaBlock.' },
         { path: 'document.nodes[].ref', category: 'richNode', valueKind: 'object', description: 'Referencia registravel de preset rich-block.' },
         { path: 'context', category: 'richContent', valueKind: 'object', description: 'Contexto externo injetado pelo host ou page-builder.' },
@@ -4002,23 +4009,6 @@ const RICH_CONTENT_AI_CAPABILITIES = {
     ],
 };
 
-const nodeTypeEnum = [
-    'text',
-    'icon',
-    'image',
-    'link',
-    'badge',
-    'avatar',
-    'metric',
-    'progress',
-    'compose',
-    'card',
-    'mediaBlock',
-    'timeline',
-    'preset',
-];
-const layoutEnum = ['block', 'inline'];
-const linkTargetEnum = ['_self', '_blank'];
 const richContentDocumentSchema = {
     type: 'object',
     required: ['kind', 'version', 'nodes'],
@@ -4043,7 +4033,7 @@ const blockPatchSchema = {
         label: { type: 'string' },
         labelExpr: { type: 'string' },
         href: { type: 'string' },
-        target: { enum: linkTargetEnum },
+        target: { enum: ['_self', '_blank'] },
         rel: { type: 'string' },
         src: { type: 'string' },
         alt: { type: 'string' },
@@ -4062,7 +4052,7 @@ const PRAXIS_RICH_CONTENT_AUTHORING_MANIFEST = {
         { name: 'nodes', type: 'RichBlockNode[] | null', description: 'Direct node list used only when the host controls the document envelope.' },
         { name: 'context', type: 'JsonLogicDataRecord | null', description: 'External context used by expression paths and Json Logic rules.' },
         { name: 'hostCapabilities', type: 'RichBlockHostCapabilities | null', description: 'Host-mediated preset, action, data and embed capabilities; functions are not serialized in public contracts.' },
-        { name: 'layout', type: "'block' | 'inline'", allowedValues: layoutEnum, description: 'Renderer layout mode.' },
+        { name: 'layout', type: "'block' | 'inline'", allowedValues: ['block', 'inline'], description: 'Renderer layout mode.' },
         { name: 'rootClassName', type: 'string', description: 'CSS class applied to the renderer root.' },
     ],
     editableTargets: [
@@ -4071,6 +4061,8 @@ const PRAXIS_RICH_CONTENT_AUTHORING_MANIFEST = {
         { kind: 'text', resolver: 'rich-text-node-by-id-or-path', description: 'Text-bearing nodes, including text, badge, metric, progress, card and timeline labels.' },
         { kind: 'link', resolver: 'rich-link-node-by-id-or-path', description: 'Canonical link node with label, href, target and rel.' },
         { kind: 'media', resolver: 'rich-media-node-by-id-or-path', description: 'Image, avatar image and mediaBlock child nodes.' },
+        { kind: 'timelineItem', resolver: 'rich-timeline-item-by-block-id-and-item-id', description: 'Timeline items nested inside timeline nodes; stable item id is preferred over index.' },
+        { kind: 'metadata', resolver: 'rich-block-common-metadata', description: 'Common node metadata such as testId, className, visibleWhen and safe style.' },
         { kind: 'preset', resolver: 'rich-block-preset-ref', description: 'Preset nodes resolved through PRAXIS_RICH_BLOCK_PRESETS or hostCapabilities.resolvePreset.' },
         { kind: 'sanitizationPolicy', resolver: 'rich-content-validation-policy', description: 'Document validation policy enforced by validateRichContentDocument.' },
         { kind: 'display', resolver: 'rich-content-layout-and-root-class', description: 'Layout and rootClassName runtime inputs.' },
@@ -4084,9 +4076,11 @@ const PRAXIS_RICH_CONTENT_AUTHORING_MANIFEST = {
             target: { kind: 'document', resolver: 'rich-content-document-root', ambiguityPolicy: 'fail', required: false },
             inputSchema: richContentDocumentSchema,
             effects: [{ kind: 'set-value', path: 'document' }],
+            destructive: false,
+            requiresConfirmation: false,
             validators: ['document-shape-canonical', 'document-version-supported', 'node-types-supported', 'unsafe-url-rejected', 'unsafe-style-rejected', 'editor-runtime-round-trip'],
             affectedPaths: ['document'],
-            submissionImpact: false,
+            submissionImpact: 'config-only',
             preconditions: ['config-initialized'],
         },
         {
@@ -4099,7 +4093,7 @@ const PRAXIS_RICH_CONTENT_AUTHORING_MANIFEST = {
                 type: 'object',
                 required: ['type'],
                 properties: {
-                    type: { enum: nodeTypeEnum },
+                    type: { enum: ['text', 'icon', 'image', 'link', 'badge', 'avatar', 'metric', 'progress', 'compose', 'card', 'mediaBlock', 'timeline', 'preset'] },
                     node: { type: 'object' },
                     afterBlockId: { type: 'string' },
                     beforeBlockId: { type: 'string' },
@@ -4109,13 +4103,15 @@ const PRAXIS_RICH_CONTENT_AUTHORING_MANIFEST = {
                         reads: ['document.nodes[]'],
                         writes: ['document.nodes[]'],
                         identityKeys: ['document.nodes[].id'],
-                        inputSchema: { type: 'object', required: ['type'], properties: { type: { enum: nodeTypeEnum }, node: { type: 'object' }, afterBlockId: { type: 'string' }, beforeBlockId: { type: 'string' } } },
+                        inputSchema: { type: 'object', required: ['type'], properties: { type: { enum: ['text', 'icon', 'image', 'link', 'badge', 'avatar', 'metric', 'progress', 'compose', 'card', 'mediaBlock', 'timeline', 'preset'] }, node: { type: 'object' }, afterBlockId: { type: 'string' }, beforeBlockId: { type: 'string' } } },
                         failureModes: ['unsupported-node-type', 'duplicate-node-id', 'invalid-node-shape', 'unsafe-url', 'unsafe-style'],
                         description: 'Creates a supported RichBlockNode, validates it with validateRichContentDocument semantics and inserts it by stable neighbor id when provided.',
                     } }],
+            destructive: false,
+            requiresConfirmation: false,
             validators: ['node-types-supported', 'block-id-unique', 'document-shape-canonical', 'unsafe-url-rejected', 'unsafe-style-rejected', 'editor-runtime-round-trip'],
             affectedPaths: ['document.nodes[]'],
-            submissionImpact: false,
+            submissionImpact: 'config-only',
             preconditions: ['config-initialized'],
         },
         {
@@ -4130,7 +4126,7 @@ const PRAXIS_RICH_CONTENT_AUTHORING_MANIFEST = {
             requiresConfirmation: true,
             validators: ['block-exists', 'destructive-removal-confirmed', 'document-not-empty-when-required', 'editor-runtime-round-trip'],
             affectedPaths: ['document.nodes[]'],
-            submissionImpact: false,
+            submissionImpact: 'config-only',
             preconditions: ['config-initialized', 'target-block-exists', 'confirmation-collected'],
         },
         {
@@ -4141,9 +4137,11 @@ const PRAXIS_RICH_CONTENT_AUTHORING_MANIFEST = {
             target: { kind: 'block', resolver: 'rich-block-by-id-or-index', ambiguityPolicy: 'fail', required: true },
             inputSchema: { type: 'object', required: ['blockId'], properties: { blockId: { type: 'string' }, beforeBlockId: { type: 'string' }, afterBlockId: { type: 'string' } } },
             effects: [{ kind: 'reorder-by-key', path: 'document.nodes[]', key: 'id' }],
+            destructive: false,
+            requiresConfirmation: false,
             validators: ['block-exists', 'block-order-deterministic', 'document-shape-canonical', 'editor-runtime-round-trip'],
             affectedPaths: ['document.nodes[]'],
-            submissionImpact: false,
+            submissionImpact: 'config-only',
             preconditions: ['config-initialized', 'target-block-exists'],
         },
         {
@@ -4154,9 +4152,11 @@ const PRAXIS_RICH_CONTENT_AUTHORING_MANIFEST = {
             target: { kind: 'text', resolver: 'rich-text-node-by-id-or-path', ambiguityPolicy: 'fail', required: true },
             inputSchema: { type: 'object', minProperties: 1, properties: { text: { type: 'string' }, textExpr: { type: 'string' }, label: { type: 'string' }, labelExpr: { type: 'string' }, title: { type: 'string' }, subtitle: { type: 'string' } } },
             effects: [{ kind: 'merge-by-key', path: 'document.nodes[]', key: 'id' }],
+            destructive: false,
+            requiresConfirmation: false,
             validators: ['block-exists', 'text-target-supports-field', 'expression-path-safe', 'document-shape-canonical', 'editor-runtime-round-trip'],
             affectedPaths: ['document.nodes[].text', 'document.nodes[].textExpr', 'document.nodes[].label', 'document.nodes[].labelExpr', 'document.nodes[].title', 'document.nodes[].subtitle'],
-            submissionImpact: false,
+            submissionImpact: 'config-only',
             preconditions: ['config-initialized', 'target-block-exists'],
         },
         {
@@ -4165,11 +4165,13 @@ const PRAXIS_RICH_CONTENT_AUTHORING_MANIFEST = {
             scope: 'templating',
             targetKind: 'link',
             target: { kind: 'link', resolver: 'document-nodes-array', ambiguityPolicy: 'fail', required: false },
-            inputSchema: { type: 'object', required: ['label', 'href'], properties: { id: { type: 'string' }, label: { type: 'string' }, labelExpr: { type: 'string' }, href: { type: 'string' }, target: { enum: linkTargetEnum }, rel: { type: 'string' } } },
+            inputSchema: { type: 'object', required: ['label', 'href'], properties: { id: { type: 'string' }, label: { type: 'string' }, labelExpr: { type: 'string' }, href: { type: 'string' }, target: { enum: ['_self', '_blank'] }, rel: { type: 'string' } } },
             effects: [{ kind: 'append-unique', path: 'document.nodes[]', key: 'id' }],
+            destructive: false,
+            requiresConfirmation: false,
             validators: ['link-url-safe', 'link-policy-explicit', 'node-types-supported', 'block-id-unique', 'editor-runtime-round-trip'],
             affectedPaths: ['document.nodes[]', 'document.nodes[].href', 'document.nodes[].target', 'document.nodes[].rel'],
-            submissionImpact: false,
+            submissionImpact: 'config-only',
             preconditions: ['config-initialized'],
         },
         {
@@ -4191,7 +4193,7 @@ const PRAXIS_RICH_CONTENT_AUTHORING_MANIFEST = {
             requiresConfirmation: true,
             validators: ['link-target-exists', 'destructive-removal-confirmed', 'document-shape-canonical', 'editor-runtime-round-trip'],
             affectedPaths: ['document.nodes[]'],
-            submissionImpact: false,
+            submissionImpact: 'config-only',
             preconditions: ['config-initialized', 'target-link-exists', 'confirmation-collected'],
         },
         {
@@ -4209,11 +4211,116 @@ const PRAXIS_RICH_CONTENT_AUTHORING_MANIFEST = {
                         failureModes: ['preset-not-found', 'preset-kind-invalid', 'preset-document-invalid', 'preset-cycle-detected'],
                         description: 'Resolves a rich-block preset through the governed registry/host mediation and inserts or replaces a preset reference without serializing functions.',
                     } }],
+            destructive: false,
+            requiresConfirmation: false,
             validators: ['preset-ref-valid', 'preset-exists-or-host-mediated', 'host-capabilities-serializable', 'document-shape-canonical', 'editor-runtime-round-trip'],
-            affectedPaths: ['document.nodes[]', 'document.nodes[].ref', 'document.nodes[].inputs', 'hostCapabilities'],
-            submissionImpact: false,
+            affectedPaths: ['document.nodes[]', 'document.nodes[].ref', 'document.nodes[].inputs'],
+            submissionImpact: 'config-only',
             preconditions: ['config-initialized'],
         },
+        {
+            operationId: 'metadata.update',
+            title: 'Update rich block metadata',
+            scope: 'templating',
+            targetKind: 'metadata',
+            target: { kind: 'metadata', resolver: 'rich-block-by-id-or-index', ambiguityPolicy: 'fail', required: true },
+            inputSchema: { type: 'object', minProperties: 1, properties: { blockId: { type: 'string' }, testId: { type: 'string' }, className: { type: 'string' }, visibleWhen: { type: 'object' }, style: { type: 'object' } } },
+            effects: [{ kind: 'merge-by-key', path: 'document.nodes[]', key: 'id' }],
+            destructive: false,
+            requiresConfirmation: false,
+            validators: ['block-exists', 'class-name-safe', 'visible-when-json-logic', 'unsafe-style-rejected', 'document-shape-canonical', 'editor-runtime-round-trip'],
+            affectedPaths: ['document.nodes[].testId', 'document.nodes[].className', 'document.nodes[].visibleWhen', 'document.nodes[].style'],
+            submissionImpact: 'config-only',
+            preconditions: ['config-initialized', 'target-block-exists'],
+        },
+        {
+            operationId: 'mediaBlock.update',
+            title: 'Update media block fields',
+            scope: 'templating',
+            targetKind: 'media',
+            target: { kind: 'media', resolver: 'rich-media-node-by-id-or-path', ambiguityPolicy: 'fail', required: true },
+            inputSchema: { type: 'object', minProperties: 1, properties: { blockId: { type: 'string' }, avatarName: { type: 'string' }, avatarImageSrc: { type: 'string' }, title: { type: 'string' }, titleExpr: { type: 'string' }, subtitle: { type: 'string' }, subtitleExpr: { type: 'string' } } },
+            effects: [{ kind: 'compile-domain-patch', handler: 'rich-content-media-block-update', handlerContract: {
+                        reads: ['document.nodes[]', 'document.nodes[].id', 'document.nodes[].type'],
+                        writes: ['document.nodes[].avatar', 'document.nodes[].title', 'document.nodes[].subtitle'],
+                        identityKeys: ['document.nodes[].id'],
+                        inputSchema: { type: 'object', minProperties: 1, properties: { blockId: { type: 'string' }, avatarName: { type: 'string' }, avatarImageSrc: { type: 'string' }, title: { type: 'string' }, titleExpr: { type: 'string' }, subtitle: { type: 'string' }, subtitleExpr: { type: 'string' } } },
+                        failureModes: ['media-block-not-found', 'target-not-media-block', 'unsafe-url', 'invalid-text-node'],
+                        description: 'Updates the structured mediaBlock avatar/title/subtitle fields while preserving meta and trailing content for advanced JSON authoring.',
+                    } }],
+            destructive: false,
+            requiresConfirmation: false,
+            validators: ['block-exists', 'media-block-target-valid', 'unsafe-url-rejected', 'expression-path-safe', 'document-shape-canonical', 'editor-runtime-round-trip'],
+            affectedPaths: ['document.nodes[].avatar', 'document.nodes[].title', 'document.nodes[].subtitle'],
+            submissionImpact: 'config-only',
+            preconditions: ['config-initialized', 'target-block-exists'],
+        },
+        {
+            operationId: 'timeline.item.add',
+            title: 'Add timeline item',
+            scope: 'templating',
+            targetKind: 'timelineItem',
+            target: { kind: 'timelineItem', resolver: 'rich-timeline-node-by-id-or-path', ambiguityPolicy: 'fail', required: true },
+            inputSchema: { type: 'object', required: ['timelineBlockId', 'item'], properties: { timelineBlockId: { type: 'string' }, item: { type: 'object' }, afterItemId: { type: 'string' }, beforeItemId: { type: 'string' } } },
+            effects: [{ kind: 'compile-domain-patch', handler: 'rich-content-timeline-item-add', handlerContract: {
+                        reads: ['document.nodes[]', 'document.nodes[].items[]'],
+                        writes: ['document.nodes[].items[]'],
+                        identityKeys: ['document.nodes[].id', 'document.nodes[].items[].id'],
+                        inputSchema: { type: 'object', required: ['timelineBlockId', 'item'], properties: { timelineBlockId: { type: 'string' }, item: { type: 'object' }, afterItemId: { type: 'string' }, beforeItemId: { type: 'string' } } },
+                        failureModes: ['timeline-not-found', 'duplicate-timeline-item-id', 'invalid-timeline-item'],
+                        description: 'Adds a timeline item to a timeline node using stable timeline and item ids when present; array index is a resolver fallback only.',
+                    } }],
+            destructive: false,
+            requiresConfirmation: false,
+            validators: ['block-exists', 'timeline-target-valid', 'timeline-item-valid', 'timeline-item-id-unique', 'document-shape-canonical', 'editor-runtime-round-trip'],
+            affectedPaths: ['document.nodes[].items[]'],
+            submissionImpact: 'config-only',
+            preconditions: ['config-initialized', 'target-block-exists'],
+        },
+        {
+            operationId: 'timeline.item.update',
+            title: 'Update timeline item',
+            scope: 'templating',
+            targetKind: 'timelineItem',
+            target: { kind: 'timelineItem', resolver: 'rich-timeline-item-by-block-id-and-item-id', ambiguityPolicy: 'fail', required: true },
+            inputSchema: { type: 'object', required: ['timelineBlockId'], minProperties: 2, properties: { timelineBlockId: { type: 'string' }, itemId: { type: 'string' }, itemIndex: { type: 'number' }, field: { enum: ['title', 'titleExpr', 'subtitle', 'subtitleExpr', 'meta', 'metaExpr', 'icon', 'iconExpr', 'badge', 'badgeExpr'] }, value: { type: 'string' }, patch: { type: 'object' } } },
+            effects: [{ kind: 'compile-domain-patch', handler: 'rich-content-timeline-item-update', handlerContract: {
+                        reads: ['document.nodes[]', 'document.nodes[].items[]'],
+                        writes: ['document.nodes[].items[]'],
+                        identityKeys: ['document.nodes[].id', 'document.nodes[].items[].id'],
+                        inputSchema: { type: 'object', required: ['timelineBlockId'], properties: { timelineBlockId: { type: 'string' }, itemId: { type: 'string' }, itemIndex: { type: 'number' }, field: { enum: ['title', 'titleExpr', 'subtitle', 'subtitleExpr', 'meta', 'metaExpr', 'icon', 'iconExpr', 'badge', 'badgeExpr'] }, value: { type: 'string' }, patch: { type: 'object' } } },
+                        failureModes: ['timeline-not-found', 'timeline-item-not-found', 'unsupported-timeline-field', 'invalid-timeline-item'],
+                        description: 'Updates a timeline item by stable item id when available, preserving the item object shape accepted by RichTimelineItem.',
+                    } }],
+            destructive: false,
+            requiresConfirmation: false,
+            validators: ['block-exists', 'timeline-target-valid', 'timeline-item-exists', 'timeline-item-field-supported', 'document-shape-canonical', 'editor-runtime-round-trip'],
+            affectedPaths: ['document.nodes[].items[].title', 'document.nodes[].items[].subtitle', 'document.nodes[].items[].meta', 'document.nodes[].items[].icon', 'document.nodes[].items[].badge'],
+            submissionImpact: 'config-only',
+            preconditions: ['config-initialized', 'target-block-exists', 'target-timeline-item-exists'],
+        },
+        {
+            operationId: 'timeline.item.remove',
+            title: 'Remove timeline item',
+            scope: 'templating',
+            targetKind: 'timelineItem',
+            target: { kind: 'timelineItem', resolver: 'rich-timeline-item-by-block-id-and-item-id', ambiguityPolicy: 'fail', required: true },
+            inputSchema: { type: 'object', required: ['timelineBlockId'], properties: { timelineBlockId: { type: 'string' }, itemId: { type: 'string' }, itemIndex: { type: 'number' } } },
+            effects: [{ kind: 'compile-domain-patch', handler: 'rich-content-timeline-item-remove', handlerContract: {
+                        reads: ['document.nodes[]', 'document.nodes[].items[]'],
+                        writes: ['document.nodes[].items[]'],
+                        identityKeys: ['document.nodes[].id', 'document.nodes[].items[].id'],
+                        inputSchema: { type: 'object', required: ['timelineBlockId'], properties: { timelineBlockId: { type: 'string' }, itemId: { type: 'string' }, itemIndex: { type: 'number' } } },
+                        failureModes: ['timeline-not-found', 'timeline-item-not-found', 'ambiguous-timeline-item'],
+                        description: 'Removes a timeline item from a timeline node after explicit confirmation; stable item id is preferred over index.',
+                    } }],
+            destructive: true,
+            requiresConfirmation: true,
+            validators: ['timeline-target-valid', 'timeline-item-exists', 'destructive-removal-confirmed', 'document-shape-canonical', 'editor-runtime-round-trip'],
+            affectedPaths: ['document.nodes[].items[]'],
+            submissionImpact: 'config-only',
+            preconditions: ['config-initialized', 'target-timeline-item-exists', 'confirmation-collected'],
+        },
         {
             operationId: 'sanitizationPolicy.set',
             title: 'Set rich content sanitization policy',
@@ -4223,7 +4330,7 @@ const PRAXIS_RICH_CONTENT_AUTHORING_MANIFEST = {
             inputSchema: { type: 'object', properties: { allowHtml: { const: false }, allowedUrlProtocols: { type: 'array', items: { type: 'string' } }, allowImageDataUrls: { type: 'boolean' }, maxNodeDepth: { type: 'number' }, maxNodeCount: { type: 'number' } } },
             effects: [{ kind: 'compile-domain-patch', handler: 'rich-content-sanitization-policy', handlerContract: {
                         reads: ['document', 'validateRichContentDocument'],
-                        writes: ['diagnostics'],
+                        writes: ['document'],
                         identityKeys: ['document.kind', 'document.version'],
                         inputSchema: { type: 'object', properties: { allowHtml: { const: false }, allowedUrlProtocols: { type: 'array', items: { type: 'string' } }, allowImageDataUrls: { type: 'boolean' }, maxNodeDepth: { type: 'number' }, maxNodeCount: { type: 'number' } } },
                         failureModes: ['html-not-supported', 'unsafe-protocol', 'max-depth-too-high', 'max-node-count-too-high'],
@@ -4232,8 +4339,8 @@ const PRAXIS_RICH_CONTENT_AUTHORING_MANIFEST = {
             destructive: true,
             requiresConfirmation: true,
             validators: ['sanitization-policy-explicit', 'unsafe-html-rejected', 'unsafe-url-rejected', 'security-change-confirmed', 'editor-runtime-round-trip'],
-            affectedPaths: ['document', 'diagnostics'],
-            submissionImpact: false,
+            affectedPaths: ['document'],
+            submissionImpact: 'config-only',
             preconditions: ['config-initialized', 'confirmation-collected'],
         },
         {
@@ -4242,11 +4349,13 @@ const PRAXIS_RICH_CONTENT_AUTHORING_MANIFEST = {
             scope: 'global',
             targetKind: 'display',
             target: { kind: 'display', resolver: 'rich-content-layout-and-root-class', ambiguityPolicy: 'fail', required: false },
-            inputSchema: { type: 'object', properties: { layout: { enum: layoutEnum }, rootClassName: { type: 'string' } } },
+            inputSchema: { type: 'object', properties: { layout: { enum: ['block', 'inline'] }, rootClassName: { type: 'string' } } },
             effects: [{ kind: 'set-value', path: 'layout' }, { kind: 'set-value', path: 'rootClassName' }],
+            destructive: false,
+            requiresConfirmation: false,
             validators: ['layout-valid', 'root-class-safe', 'editor-runtime-round-trip'],
             affectedPaths: ['layout', 'rootClassName'],
-            submissionImpact: false,
+            submissionImpact: 'visual-only',
             preconditions: ['config-initialized'],
         },
     ],
@@ -4275,12 +4384,21 @@ const PRAXIS_RICH_CONTENT_AUTHORING_MANIFEST = {
         { validatorId: 'layout-valid', level: 'error', code: 'PRC022', description: 'Layout must be block or inline.' },
         { validatorId: 'root-class-safe', level: 'warning', code: 'PRC023', description: 'rootClassName must contain safe CSS class tokens.' },
         { validatorId: 'editor-runtime-round-trip', level: 'error', code: 'PRC024', description: 'Config editor, Settings Panel payload and runtime renderer must preserve document structure, layout and rootClassName.' },
+        { validatorId: 'class-name-safe', level: 'error', code: 'PRC025', description: 'Node className values must contain safe CSS class tokens.' },
+        { validatorId: 'visible-when-json-logic', level: 'error', code: 'PRC026', description: 'visibleWhen must be a Json Logic expression object and not a string DSL.' },
+        { validatorId: 'media-block-target-valid', level: 'error', code: 'PRC027', description: 'Media operations must target a mediaBlock node and preserve structured avatar/text child nodes.' },
+        { validatorId: 'timeline-target-valid', level: 'error', code: 'PRC028', description: 'Timeline item operations must target a timeline node with an items array.' },
+        { validatorId: 'timeline-item-valid', level: 'error', code: 'PRC029', description: 'Timeline items must be objects matching RichTimelineItem fields.' },
+        { validatorId: 'timeline-item-id-unique', level: 'warning', code: 'PRC030', description: 'Timeline item ids should be unique inside a timeline node when present.' },
+        { validatorId: 'timeline-item-exists', level: 'error', code: 'PRC031', description: 'Timeline item updates and removals must resolve an existing item by stable id or explicit fallback index.' },
+        { validatorId: 'timeline-item-field-supported', level: 'error', code: 'PRC032', description: 'Timeline item updates may only target supported RichTimelineItem fields.' },
     ],
     roundTripRequirements: [
         'The editor must produce the same widget input envelope consumed by page-builder: inputs.document, inputs.layout and inputs.rootClassName.',
         'Rich content must remain structured RichContentDocument JSON; arbitrary HTML and script URL patches are rejected before persistence.',
         'Block identity should prefer document.nodes[].id; array index is a resolver fallback only and cannot be the canonical identity for generated patches.',
         'Link authoring uses canonical link nodes with safe href/target/rel instead of markdown or raw HTML embedded in text nodes.',
+        'MediaBlock, timeline item, metadata, visibleWhen and safe style authoring use the same structured paths exposed by the visual config editor.',
         'Preset authoring persists only rich-block refs and inputs; host capability functions remain runtime-mediated and are not serialized.',
     ],
     examples: [
@@ -4293,6 +4411,10 @@ const PRAXIS_RICH_CONTENT_AUTHORING_MANIFEST = {
         { id: 'reject-script-link', request: 'Add a link to javascript:alert(1).', operationId: 'link.add', params: { label: 'Bad link', href: 'javascript:alert(1)' }, isPositive: false },
         { id: 'remove-docs-link', request: 'Remove the documentation link but keep its label as text.', operationId: 'link.remove', target: 'docs-link', params: { linkId: 'docs-link', preserveLabelAsText: true }, isPositive: true },
         { id: 'apply-profile-preset', request: 'Apply the profile summary rich-block preset.', operationId: 'preset.apply', params: { ref: { kind: 'rich-block', namespace: 'praxis.rich-content', presetId: 'profile-summary', version: '1.0.0' } }, isPositive: true },
+        { id: 'show-only-active-row', request: 'Show the status block only when row.active is true.', operationId: 'metadata.update', target: 'status', params: { blockId: 'status', visibleWhen: { '===': [{ var: 'row.active' }, true] } }, isPositive: true },
+        { id: 'update-media-title', request: 'Update the profile media block title and avatar name.', operationId: 'mediaBlock.update', target: 'profile-media', params: { blockId: 'profile-media', avatarName: 'Ana Silva', title: 'Profile summary' }, isPositive: true },
+        { id: 'add-created-timeline-item', request: 'Add a Created item to the activity timeline.', operationId: 'timeline.item.add', target: 'activity', params: { timelineBlockId: 'activity', item: { id: 'created', title: 'Created', badge: 'Done' } }, isPositive: true },
+        { id: 'reject-unknown-timeline-field', request: 'Set a custom script field on a timeline item.', operationId: 'timeline.item.update', target: 'activity.created', params: { timelineBlockId: 'activity', itemId: 'created', field: 'script', value: 'alert(1)' }, isPositive: false },
         { id: 'reject-html-policy', request: 'Allow arbitrary HTML in this rich content document.', operationId: 'sanitizationPolicy.set', params: { allowHtml: true }, isPositive: false },
         { id: 'compact-inline-layout', request: 'Render this rich content inline with root class status-line.', operationId: 'display.mode.set', params: { layout: 'inline', rootClassName: 'status-line' }, isPositive: true },
     ],

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@praxisui/rich-content",
-  "version": "8.0.0-beta.11",
+  "version": "8.0.0-beta.12",
   "peerDependencies": {
     "@angular/common": "^20.3.0",
     "@angular/core": "^20.3.0",
-    "@praxisui/core": "^8.0.0-beta.11"
+    "@praxisui/core": "^8.0.0-beta.12"
   },
   "dependencies": {
     "tslib": "^2.3.0"