@continuum-dev/runtime 0.1.0

package/lib/reconciliation/node-resolver.js

@@ -0,0 +1,190 @@
+import { ISSUE_CODES, ISSUE_SEVERITY } from '@continuum/contract';
+import { findPriorNode, determineNodeMatchStrategy, findNewNodeByPriorNode, resolvePriorSnapshotId, } from '../context.js';
+import { addedDiff, addedResolution, typeChangedDiff, detachedResolution, migratedDiff, migratedResolution, carriedResolution, removedDiff, restoredDiff, restoredResolution, } from './differ.js';
+import { attemptMigration } from './migrator.js';
+import { carryValuesMeta } from './state-builder.js';
+import { validateNodeValue } from './validator.js';
+import { createInitialCollectionValue, reconcileCollectionValue } from './collection-resolver.js';
+export function resolveAllNodes(ctx, priorValues, priorData, now, options) {
+    const acc = {
+        values: {},
+        valueLineage: {},
+        detachedValues: {},
+        restoredDetachedKeys: new Set(),
+        diffs: [],
+        resolutions: [],
+        issues: [],
+    };
+    for (const [newId, newNode] of ctx.newById) {
+        const priorNode = findPriorNode(ctx, newNode);
+        const priorNodeId = priorNode ? (ctx.priorNodeIds.get(priorNode) ?? priorNode.id) : null;
+        const priorValue = priorValues.get(newId) ?? (priorNodeId ? priorData.values[priorNodeId] : undefined);
+        const matchedBy = determineNodeMatchStrategy(ctx, newNode, priorNode);
+        if (!priorNode) {
+            resolveNewNode(acc, newId, newNode, priorData, now);
+        }
+        else if (newNode.type === 'collection' && priorNode.type === 'collection') {
+            resolveCollectionNode(acc, newId, priorNode, priorNodeId, newNode, matchedBy, priorValue, priorData, now, options);
+        }
+        else if (priorNode.type !== newNode.type && !areCompatibleContainerTypes(priorNode.type, newNode.type)) {
+            resolveTypeMismatchedNode(acc, newId, priorNode, priorNodeId, newNode, matchedBy, priorValue, ctx, now);
+        }
+        else if (hasNodeHashChanged(priorNode, newNode)) {
+            resolveHashChangedNode(acc, newId, priorNode, priorNodeId, newNode, matchedBy, priorValue, priorData, now, options);
+        }
+        else {
+            resolveUnchangedNode(acc, newId, priorNode, priorNodeId, newNode, matchedBy, priorValue, priorData, now);
+        }
+        acc.issues.push(...validateNodeValue(newNode, acc.values[newId]));
+    }
+    return acc;
+}
+function resolveNewNode(acc, newId, newNode, priorData, now) {
+    const detachedKey = newNode.key ?? newId;
+    const detachedValue = priorData.detachedValues?.[detachedKey];
+    if (detachedValue && detachedValue.previousNodeType === newNode.type) {
+        acc.values[newId] = detachedValue.value;
+        acc.restoredDetachedKeys.add(detachedKey);
+        acc.diffs.push(restoredDiff(newId, detachedValue.value));
+        acc.resolutions.push(restoredResolution(newId, newNode.type, detachedValue.value));
+        return;
+    }
+    if (newNode.type === 'collection') {
+        acc.values[newId] = createInitialCollectionValue(newNode);
+    }
+    else if ('defaultValue' in newNode && newNode.defaultValue !== undefined) {
+        acc.values[newId] = { value: newNode.defaultValue };
+    }
+    acc.diffs.push(addedDiff(newId));
+    acc.resolutions.push(addedResolution(newId, newNode.type));
+}
+function resolveCollectionNode(acc, newId, priorNode, priorNodeId, newNode, matchedBy, priorValue, priorData, now, options) {
+    const result = reconcileCollectionValue(priorNode, newNode, priorValue, options);
+    acc.values[newId] = result.value;
+    carryValuesMeta(acc.valueLineage, newId, priorNodeId, priorData, now, result.didMigrateItems);
+    acc.issues.push(...result.issues);
+    if (result.didMigrateItems) {
+        acc.diffs.push(migratedDiff(newId, priorValue, result.value));
+        acc.resolutions.push(migratedResolution(newId, priorNodeId, matchedBy ?? 'id', priorNode.type, newNode.type, priorValue, result.value));
+        return;
+    }
+    acc.resolutions.push(carriedResolution(newId, priorNodeId, matchedBy ?? 'id', priorNode.type, priorValue, result.value));
+}
+function resolveTypeMismatchedNode(acc, newId, priorNode, priorNodeId, newNode, matchedBy, priorValue, ctx, now) {
+    acc.issues.push({
+        severity: ISSUE_SEVERITY.ERROR,
+        nodeId: newId,
+        message: `Node type mismatch: ${priorNode.type} -> ${newNode.type}`,
+        code: ISSUE_CODES.TYPE_MISMATCH,
+    });
+    acc.diffs.push(typeChangedDiff(newId, priorValue, priorNode.type, newNode.type));
+    acc.resolutions.push(detachedResolution(newId, priorNodeId, matchedBy, priorNode.type, newNode.type, priorValue));
+    if (priorValue !== undefined) {
+        const detachedKey = priorNode.key ?? priorNodeId;
+        acc.detachedValues[detachedKey] = {
+            value: priorValue,
+            previousNodeType: priorNode.type,
+            key: priorNode.key,
+            detachedAt: now,
+            viewVersion: ctx.priorView?.version ?? 'unknown',
+            reason: 'type-mismatch',
+        };
+    }
+}
+/**
+ * Container types (row, grid, group) are semantically equivalent — they all
+ * hold children. The AI may swap between them for styling reasons. Treating
+ * these as type mismatches would destroy all child values unnecessarily.
+ */
+const CONTAINER_TYPES = new Set(['row', 'grid', 'group']);
+function areCompatibleContainerTypes(a, b) {
+    return CONTAINER_TYPES.has(a) && CONTAINER_TYPES.has(b);
+}
+function hasNodeHashChanged(priorNode, newNode) {
+    return !!(priorNode.hash && newNode.hash && priorNode.hash !== newNode.hash);
+}
+function resolveHashChangedNode(acc, newId, priorNode, priorNodeId, newNode, matchedBy, priorValue, priorData, now, options) {
+    const migrationResult = attemptMigration(newId, priorNode, newNode, priorValue, options);
+    if (migrationResult.kind === 'migrated') {
+        acc.values[newId] = migrationResult.value;
+        carryValuesMeta(acc.valueLineage, newId, priorNodeId, priorData, now, true);
+        acc.diffs.push(migratedDiff(newId, priorValue, migrationResult.value));
+        acc.resolutions.push(migratedResolution(newId, priorNodeId, matchedBy, priorNode.type, newNode.type, priorValue, migrationResult.value));
+        return;
+    }
+    const message = migrationResult.kind === 'error'
+        ? `Node ${newId} migration failed: ${String(migrationResult.error)}`
+        : `Node ${newId} view changed but no migration strategy available`;
+    acc.issues.push({
+        severity: ISSUE_SEVERITY.WARNING,
+        nodeId: newId,
+        message,
+        code: ISSUE_CODES.MIGRATION_FAILED,
+    });
+    resolveUnchangedNode(acc, newId, priorNode, priorNodeId, newNode, matchedBy, priorValue, priorData, now);
+}
+function resolveUnchangedNode(acc, newId, priorNode, priorNodeId, newNode, matchedBy, priorValue, priorData, now) {
+    if (priorValue !== undefined) {
+        const priorNodeValue = priorValue;
+        const resolvedValue = { ...priorNodeValue };
+        // Check if AI provided a new defaultValue that differs from prior
+        if ('defaultValue' in newNode && newNode.defaultValue !== undefined) {
+            if ('defaultValue' in priorNode) {
+                if (JSON.stringify(priorNode.defaultValue) !== JSON.stringify(newNode.defaultValue)) {
+                    if (priorNodeValue.isDirty) {
+                        resolvedValue.suggestion = newNode.defaultValue;
+                    }
+                    else {
+                        resolvedValue.value = newNode.defaultValue;
+                    }
+                }
+            }
+            else {
+                if (priorNodeValue.isDirty) {
+                    resolvedValue.suggestion = newNode.defaultValue;
+                }
+                else {
+                    resolvedValue.value = newNode.defaultValue;
+                }
+            }
+        }
+        acc.values[newId] = resolvedValue;
+        carryValuesMeta(acc.valueLineage, newId, priorNodeId, priorData, now, false);
+    }
+    acc.resolutions.push(carriedResolution(newId, priorNodeId, matchedBy, priorNode.type, priorValue, priorValue !== undefined ? priorValue : undefined));
+}
+export function detectRemovedNodes(ctx, priorData, options, now) {
+    const diffs = [];
+    const issues = [];
+    const detachedValues = {};
+    for (const [priorId, priorValue] of Object.entries(priorData.values)) {
+        const resolvedPriorId = resolvePriorSnapshotId(ctx, priorId) ?? priorId;
+        const priorComp = ctx.priorById.get(resolvedPriorId);
+        const keyMatchedNode = priorComp ? findNewNodeByPriorNode(ctx, priorComp) : null;
+        const stillExists = ctx.newById.has(resolvedPriorId) ||
+            !!keyMatchedNode;
+        if (!stillExists) {
+            diffs.push(removedDiff(resolvedPriorId, priorValue));
+            if (priorValue !== undefined) {
+                const detachedKey = priorComp?.key ?? resolvedPriorId;
+                detachedValues[detachedKey] = {
+                    value: priorValue,
+                    previousNodeType: priorComp?.type ?? 'unknown',
+                    key: priorComp?.key,
+                    detachedAt: now,
+                    viewVersion: ctx.priorView?.version ?? 'unknown',
+                    reason: 'node-removed',
+                };
+            }
+            if (!options.allowPartialRestore) {
+                issues.push({
+                    severity: ISSUE_SEVERITY.WARNING,
+                    nodeId: resolvedPriorId,
+                    message: `Node ${resolvedPriorId} was removed from view`,
+                    code: ISSUE_CODES.NODE_REMOVED,
+                });
+            }
+        }
+    }
+    return { diffs, issues, detachedValues };
+}

package/lib/reconciliation/state-builder.d.ts

@@ -0,0 +1,13 @@
+import type { DataSnapshot, DetachedValue, ValueLineage, ViewDefinition } from '@continuum/contract';
+import type { NodeResolutionAccumulator, ReconciliationIssue, ReconciliationOptions, ReconciliationResult, StateDiff } from '../types.js';
+export declare function buildFreshSessionResult(newView: ViewDefinition, now: number): ReconciliationResult;
+export declare function buildBlindCarryResult(newView: ViewDefinition, priorData: DataSnapshot, now: number, options: ReconciliationOptions): ReconciliationResult;
+export declare function assembleReconciliationResult(resolved: NodeResolutionAccumulator, removals: {
+    diffs: StateDiff[];
+    issues: ReconciliationIssue[];
+    detachedValues?: Record<string, DetachedValue>;
+}, priorData: DataSnapshot, newView: ViewDefinition, now: number): ReconciliationResult;
+export declare function carryValuesMeta(target: Record<string, ValueLineage>, newId: string, priorId: string, priorData: DataSnapshot, now: number, isMigrated: boolean): void;
+export declare function computeViewHash(view: ViewDefinition): string | undefined;
+export declare function generateSessionId(now: number): string;
+//# sourceMappingURL=state-builder.d.ts.map

package/lib/reconciliation/state-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-builder.d.ts","sourceRoot":"","sources":["../../../../../packages/runtime/src/lib/reconciliation/state-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EAEb,YAAY,EACZ,cAAc,EAEf,MAAM,qBAAqB,CAAC;AAO7B,OAAO,KAAK,EACV,yBAAyB,EACzB,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,EACpB,SAAS,EAEV,MAAM,aAAa,CAAC;AAIrB,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,cAAc,EACvB,GAAG,EAAE,MAAM,GACV,oBAAoB,CA8BtB;AA8CD,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,cAAc,EACvB,SAAS,EAAE,YAAY,EACvB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,qBAAqB,GAC7B,oBAAoB,CA4EtB;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,yBAAyB,EACnC,QAAQ,EAAE;IAAE,KAAK,EAAE,SAAS,EAAE,CAAC;IAAC,MAAM,EAAE,mBAAmB,EAAE,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;CAAE,EAC/G,SAAS,EAAE,YAAY,EACvB,OAAO,EAAE,cAAc,EACvB,GAAG,EAAE,MAAM,GACV,oBAAoB,CA8BtB;AAED,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EACpC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,YAAY,EACvB,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,OAAO,GAClB,IAAI,CAON;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,GAAG,SAAS,CAmBxE;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAErD"}

package/lib/reconciliation/state-builder.js

@@ -0,0 +1,211 @@
+import { ISSUE_CODES, ISSUE_SEVERITY, } from '@continuum/contract';
+import { collectDuplicateIssues } from '../context.js';
+import { traverseViewNodes } from './view-traversal.js';
+import { addedDiff, addedResolution } from './differ.js';
+import { createInitialCollectionValue } from './collection-resolver.js';
+export function buildFreshSessionResult(newView, now) {
+    const values = {};
+    const diffs = [];
+    const resolutions = [];
+    collectNodesAsFreshlyAdded(newView.nodes, values, diffs, resolutions);
+    const duplicateIssues = collectDuplicateIssues(newView.nodes);
+    return {
+        reconciledState: {
+            values,
+            lineage: {
+                timestamp: now,
+                sessionId: generateSessionId(now),
+                viewId: newView.viewId,
+                viewVersion: newView.version,
+            },
+        },
+        diffs,
+        issues: [
+            {
+                severity: ISSUE_SEVERITY.INFO,
+                message: 'No prior state found, starting fresh',
+                code: ISSUE_CODES.NO_PRIOR_DATA,
+            },
+            ...duplicateIssues,
+        ],
+        resolutions,
+    };
+}
+function collectNodesAsFreshlyAdded(nodes, values, diffs, resolutions) {
+    const traversal = traverseViewNodes(nodes);
+    for (const entry of traversal.visited) {
+        const node = entry.node;
+        const nodeId = entry.nodeId;
+        if (node.type === 'collection') {
+            values[nodeId] = createInitialCollectionValue(node);
+        }
+        else if ('defaultValue' in node && node.defaultValue !== undefined) {
+            values[nodeId] = { value: node.defaultValue };
+        }
+        diffs.push(addedDiff(nodeId));
+        resolutions.push(addedResolution(nodeId, node.type));
+    }
+}
+function collectNodeIds(nodes) {
+    const ids = new Set();
+    const traversal = traverseViewNodes(nodes);
+    for (const entry of traversal.visited) {
+        ids.add(entry.nodeId);
+    }
+    return ids;
+}
+function collectNodeKeyToIdMap(nodes) {
+    const keyToId = new Map();
+    const traversal = traverseViewNodes(nodes);
+    for (const entry of traversal.visited) {
+        const node = entry.node;
+        if (node.key) {
+            const scopedKey = buildNodePath(entry.parentPath, node.key);
+            if (!keyToId.has(scopedKey)) {
+                keyToId.set(scopedKey, entry.nodeId);
+            }
+        }
+    }
+    return keyToId;
+}
+export function buildBlindCarryResult(newView, priorData, now, options) {
+    const duplicateIssues = collectDuplicateIssues(newView.nodes);
+    const issues = [
+        {
+            severity: ISSUE_SEVERITY.WARNING,
+            message: 'Prior data exists but no prior view provided; cannot reconcile',
+            code: ISSUE_CODES.NO_PRIOR_VIEW,
+        },
+        ...duplicateIssues,
+    ];
+    if (options.allowBlindCarry) {
+        const newIds = collectNodeIds(newView.nodes);
+        const keyToId = collectNodeKeyToIdMap(newView.nodes);
+        const carriedValues = {};
+        const carriedNodeIds = new Set();
+        for (const [id, value] of Object.entries(priorData.values)) {
+            if (newIds.has(id)) {
+                carriedValues[id] = value;
+                carriedNodeIds.add(id);
+                issues.push({
+                    severity: ISSUE_SEVERITY.INFO,
+                    nodeId: id,
+                    message: `Node ${id} data carried without view validation`,
+                    code: ISSUE_CODES.UNVALIDATED_CARRY,
+                });
+            }
+        }
+        for (const [id, value] of Object.entries(priorData.values)) {
+            if (newIds.has(id)) {
+                continue;
+            }
+            const matchedNodeId = keyToId.get(id);
+            if (!matchedNodeId || carriedNodeIds.has(matchedNodeId)) {
+                continue;
+            }
+            carriedValues[matchedNodeId] = value;
+            carriedNodeIds.add(matchedNodeId);
+            issues.push({
+                severity: ISSUE_SEVERITY.INFO,
+                nodeId: matchedNodeId,
+                message: `Node ${id} data carried to ${matchedNodeId} via key match without view validation`,
+                code: ISSUE_CODES.UNVALIDATED_CARRY,
+            });
+        }
+        return {
+            reconciledState: {
+                values: carriedValues,
+                lineage: {
+                    ...priorData.lineage,
+                    timestamp: now,
+                    viewId: newView.viewId,
+                    viewVersion: newView.version,
+                },
+            },
+            diffs: [],
+            issues,
+            resolutions: [],
+        };
+    }
+    return {
+        reconciledState: {
+            values: {},
+            lineage: {
+                ...priorData.lineage,
+                timestamp: now,
+                viewId: newView.viewId,
+                viewVersion: newView.version,
+            },
+        },
+        diffs: [],
+        issues,
+        resolutions: [],
+    };
+}
+export function assembleReconciliationResult(resolved, removals, priorData, newView, now) {
+    const viewHash = computeViewHash(newView);
+    const hasValueLineage = Object.keys(resolved.valueLineage).length > 0;
+    const detachedValues = {
+        ...(priorData.detachedValues ?? {}),
+        ...(resolved.detachedValues ?? {}),
+        ...(removals.detachedValues ?? {}),
+    };
+    for (const restoredKey of resolved.restoredDetachedKeys ?? []) {
+        delete detachedValues[restoredKey];
+    }
+    const hasDetachedValues = Object.keys(detachedValues).length > 0;
+    return {
+        reconciledState: {
+            values: resolved.values,
+            lineage: {
+                ...priorData.lineage,
+                timestamp: now,
+                viewId: newView.viewId,
+                viewVersion: newView.version,
+                ...(viewHash !== undefined ? { viewHash } : {}),
+            },
+            ...(hasValueLineage ? { valueLineage: resolved.valueLineage } : {}),
+            ...(hasDetachedValues ? { detachedValues } : {}),
+        },
+        diffs: [...resolved.diffs, ...removals.diffs],
+        issues: [...resolved.issues, ...removals.issues],
+        resolutions: resolved.resolutions,
+    };
+}
+export function carryValuesMeta(target, newId, priorId, priorData, now, isMigrated) {
+    const priorMeta = priorData.valueLineage?.[priorId];
+    if (priorMeta) {
+        target[newId] = isMigrated
+            ? { ...priorMeta, lastUpdated: now }
+            : { ...priorMeta };
+    }
+}
+export function computeViewHash(view) {
+    const traversal = traverseViewNodes(view.nodes);
+    let hasHash = false;
+    const descriptors = traversal.visited.map((entry) => {
+        if (entry.node.hash) {
+            hasHash = true;
+        }
+        return {
+            positionPath: entry.positionPath,
+            nodeId: entry.nodeId,
+            type: entry.node.type,
+            hash: entry.node.hash ?? null,
+        };
+    });
+    if (!hasHash) {
+        return undefined;
+    }
+    descriptors.sort((a, b) => a.positionPath.localeCompare(b.positionPath));
+    return JSON.stringify(descriptors);
+}
+export function generateSessionId(now) {
+    return `session_${now}_${Math.random().toString(36).substring(2, 9)}`;
+}
+function buildNodePath(parentPath, nodeId) {
+    if (parentPath.length === 0) {
+        return nodeId;
+    }
+    return `${parentPath}/${nodeId}`;
+}

package/lib/reconciliation/validator.d.ts

@@ -0,0 +1,14 @@
+import type { NodeValue, ViewNode } from '@continuum/contract';
+import type { ReconciliationIssue } from '../types.js';
+/**
+ * Validates a node value against contract constraints and emits runtime issues.
+ *
+ * This helper is exported so host applications can run the same validation
+ * semantics used during reconciliation for custom workflows.
+ *
+ * @param node View node containing optional constraint metadata.
+ * @param state Current node state value to validate.
+ * @returns Zero or more validation issues.
+ */
+export declare function validateNodeValue(node: ViewNode, state: NodeValue | undefined): ReconciliationIssue[];
+//# sourceMappingURL=validator.d.ts.map

package/lib/reconciliation/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../../../../packages/runtime/src/lib/reconciliation/validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAE/D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAgBvD;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,SAAS,GAAG,SAAS,GAC3B,mBAAmB,EAAE,CA4EvB"}

package/lib/reconciliation/validator.js

@@ -0,0 +1,100 @@
+import { ISSUE_CODES, ISSUE_SEVERITY } from '@continuum/contract';
+function readStateValue(state) {
+    if (!state) {
+        return undefined;
+    }
+    return state.value;
+}
+function isEmptyValue(value) {
+    if (value == null)
+        return true;
+    if (typeof value === 'string')
+        return value.trim().length === 0;
+    if (Array.isArray(value))
+        return value.length === 0;
+    return false;
+}
+/**
+ * Validates a node value against contract constraints and emits runtime issues.
+ *
+ * This helper is exported so host applications can run the same validation
+ * semantics used during reconciliation for custom workflows.
+ *
+ * @param node View node containing optional constraint metadata.
+ * @param state Current node state value to validate.
+ * @returns Zero or more validation issues.
+ */
+export function validateNodeValue(node, state) {
+    const constraints = 'constraints' in node ? node.constraints : undefined;
+    if (!constraints)
+        return [];
+    const value = readStateValue(state);
+    const issues = [];
+    if (constraints.required && isEmptyValue(value)) {
+        issues.push({
+            severity: ISSUE_SEVERITY.WARNING,
+            nodeId: node.id,
+            message: `Node ${node.id} failed required validation`,
+            code: ISSUE_CODES.VALIDATION_FAILED,
+        });
+        return issues;
+    }
+    if (typeof value === 'number') {
+        if (typeof constraints.min === 'number' && value < constraints.min) {
+            issues.push({
+                severity: ISSUE_SEVERITY.WARNING,
+                nodeId: node.id,
+                message: `Node ${node.id} is below minimum ${constraints.min}`,
+                code: ISSUE_CODES.VALIDATION_FAILED,
+            });
+        }
+        if (typeof constraints.max === 'number' && value > constraints.max) {
+            issues.push({
+                severity: ISSUE_SEVERITY.WARNING,
+                nodeId: node.id,
+                message: `Node ${node.id} is above maximum ${constraints.max}`,
+                code: ISSUE_CODES.VALIDATION_FAILED,
+            });
+        }
+    }
+    if (typeof value === 'string') {
+        if (typeof constraints.minLength === 'number' && value.length < constraints.minLength) {
+            issues.push({
+                severity: ISSUE_SEVERITY.WARNING,
+                nodeId: node.id,
+                message: `Node ${node.id} is shorter than minLength ${constraints.minLength}`,
+                code: ISSUE_CODES.VALIDATION_FAILED,
+            });
+        }
+        if (typeof constraints.maxLength === 'number' && value.length > constraints.maxLength) {
+            issues.push({
+                severity: ISSUE_SEVERITY.WARNING,
+                nodeId: node.id,
+                message: `Node ${node.id} is longer than maxLength ${constraints.maxLength}`,
+                code: ISSUE_CODES.VALIDATION_FAILED,
+            });
+        }
+        if (constraints.pattern) {
+            try {
+                const pattern = new RegExp(constraints.pattern);
+                if (!pattern.test(value)) {
+                    issues.push({
+                        severity: ISSUE_SEVERITY.WARNING,
+                        nodeId: node.id,
+                        message: `Node ${node.id} does not match pattern ${constraints.pattern}`,
+                        code: ISSUE_CODES.VALIDATION_FAILED,
+                    });
+                }
+            }
+            catch {
+                issues.push({
+                    severity: ISSUE_SEVERITY.WARNING,
+                    nodeId: node.id,
+                    message: `Node ${node.id} has invalid validation pattern`,
+                    code: ISSUE_CODES.VALIDATION_FAILED,
+                });
+            }
+        }
+    }
+    return issues;
+}

package/lib/reconciliation/view-traversal.d.ts

@@ -0,0 +1,14 @@
+import { type ViewNode } from '@continuum/contract';
+import type { ReconciliationIssue } from '../types.js';
+export interface TraversedViewNode {
+    node: ViewNode;
+    parentPath: string;
+    nodeId: string;
+    depth: number;
+    positionPath: string;
+}
+export declare function traverseViewNodes(nodes: ViewNode[], maxDepth?: number): {
+    visited: TraversedViewNode[];
+    issues: ReconciliationIssue[];
+};
+//# sourceMappingURL=view-traversal.d.ts.map

package/lib/reconciliation/view-traversal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-traversal.d.ts","sourceRoot":"","sources":["../../../../../packages/runtime/src/lib/reconciliation/view-traversal.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8C,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAChG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAIvD,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,QAAQ,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;CACtB;AAeD,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,QAAQ,EAAE,EACjB,QAAQ,SAAyB,GAChC;IAAE,OAAO,EAAE,iBAAiB,EAAE,CAAC;IAAC,MAAM,EAAE,mBAAmB,EAAE,CAAA;CAAE,CAwEjE"}

package/lib/reconciliation/view-traversal.js

@@ -0,0 +1,72 @@
+import { getChildNodes, ISSUE_CODES, ISSUE_SEVERITY } from '@continuum/contract';
+const DEFAULT_MAX_VIEW_DEPTH = 128;
+export function traverseViewNodes(nodes, maxDepth = DEFAULT_MAX_VIEW_DEPTH) {
+    const visited = [];
+    const issues = [];
+    const active = new Set();
+    const stack = [];
+    for (let i = nodes.length - 1; i >= 0; i--) {
+        stack.push({
+            kind: 'enter',
+            node: nodes[i],
+            parentPath: '',
+            depth: 0,
+            positionPath: `${i}`,
+        });
+    }
+    while (stack.length > 0) {
+        const frame = stack.pop();
+        if (!frame) {
+            continue;
+        }
+        if (frame.kind === 'exit') {
+            active.delete(frame.node);
+            continue;
+        }
+        if (frame.depth > maxDepth) {
+            issues.push({
+                severity: ISSUE_SEVERITY.ERROR,
+                nodeId: toIndexedId(frame.node.id, frame.parentPath),
+                message: `View node depth exceeds max depth of ${maxDepth}`,
+                code: ISSUE_CODES.VIEW_MAX_DEPTH_EXCEEDED,
+            });
+            continue;
+        }
+        if (active.has(frame.node)) {
+            issues.push({
+                severity: ISSUE_SEVERITY.ERROR,
+                nodeId: toIndexedId(frame.node.id, frame.parentPath),
+                message: `Cycle detected while traversing children for node ${frame.node.id}`,
+                code: ISSUE_CODES.VIEW_CHILD_CYCLE_DETECTED,
+            });
+            continue;
+        }
+        active.add(frame.node);
+        const nodeId = toIndexedId(frame.node.id, frame.parentPath);
+        visited.push({
+            node: frame.node,
+            parentPath: frame.parentPath,
+            nodeId,
+            depth: frame.depth,
+            positionPath: frame.positionPath,
+        });
+        stack.push({ kind: 'exit', node: frame.node });
+        const children = getChildNodes(frame.node);
+        for (let i = children.length - 1; i >= 0; i--) {
+            stack.push({
+                kind: 'enter',
+                node: children[i],
+                parentPath: nodeId,
+                depth: frame.depth + 1,
+                positionPath: `${frame.positionPath}.${i}`,
+            });
+        }
+    }
+    return { visited, issues };
+}
+function toIndexedId(id, parentPath) {
+    if (parentPath.length > 0) {
+        return `${parentPath}/${id}`;
+    }
+    return id;
+}