@continuum-dev/runtime 0.1.0

package/lib/reconciliation/collection-resolver.js

@@ -0,0 +1,283 @@
+import { getChildNodes } from '@continuum/contract';
+import { ISSUE_CODES, ISSUE_SEVERITY } from '@continuum/contract';
+import { attemptMigration } from './migrator.js';
+const CONTAINER_TYPES = new Set(['row', 'grid', 'group']);
+function areCompatibleContainerTypes(a, b) {
+    return CONTAINER_TYPES.has(a) && CONTAINER_TYPES.has(b);
+}
+export function resolveCollectionDefaultValues(node) {
+    if (!node.defaultValues || !Array.isArray(node.defaultValues)) {
+        return createInitialCollectionValue(node);
+    }
+    const { keyToPath } = buildTemplatePathMap(node.template);
+    const items = node.defaultValues.map((defaultItem) => {
+        const itemValues = {};
+        // Fill in default values based on semantic keys provided in `defaultValues`
+        for (const [key, value] of Object.entries(defaultItem)) {
+            const path = keyToPath.get(key) || key; // If path not mapped, use key as path
+            itemValues[path] = { value };
+        }
+        // Fill in missing fields with template defaults
+        const templateDefaults = collectTemplateDefaults(node.template);
+        for (const [path, defaultValue] of Object.entries(templateDefaults)) {
+            if (!(path in itemValues)) {
+                itemValues[path] = defaultValue;
+            }
+        }
+        return { values: itemValues };
+    });
+    return { value: { items } };
+}
+export function createInitialCollectionValue(node) {
+    if (node.defaultValues && Array.isArray(node.defaultValues)) {
+        return resolveCollectionDefaultValues(node);
+    }
+    const minItems = normalizeMinItems(node.minItems);
+    const items = Array.from({ length: minItems }, () => ({
+        values: collectTemplateDefaults(node.template),
+    }));
+    return { value: { items } };
+}
+/**
+ * Build a bidirectional mapping between node keys and their full relative paths
+ * within a template tree. Used to remap collection item value paths when the AI
+ * restructures template containers (renames IDs) while keeping the same keys.
+ */
+function buildTemplatePathMap(node, parentPath = '') {
+    const keyToPath = new Map();
+    const pathToKey = new Map();
+    const allPaths = new Set();
+    function walk(n, parent) {
+        const nodePath = parent.length > 0 ? `${parent}/${n.id}` : n.id;
+        allPaths.add(nodePath);
+        const effectiveKey = n.key ?? n.id;
+        // Only map the first occurrence of a key (no overwrites)
+        if (!keyToPath.has(effectiveKey)) {
+            keyToPath.set(effectiveKey, nodePath);
+        }
+        pathToKey.set(nodePath, effectiveKey);
+        const children = getChildNodes(n);
+        for (const child of children) {
+            walk(child, nodePath);
+        }
+    }
+    walk(node, parentPath);
+    return { keyToPath, pathToKey, allPaths };
+}
+/**
+ * Remap collection item value keys from old template paths to new template paths.
+ * For each value key in the item:
+ *   1. Look up what key (semantic name) that old path corresponded to
+ *   2. Find the new path for that same key
+ *   3. Move the value to the new path
+ * Values that can't be remapped are kept under their original key.
+ */
+function remapCollectionItemPaths(oldValues, priorMap, newMap) {
+    const remapped = {};
+    let hasChanges = false;
+    for (const [oldPath, value] of Object.entries(oldValues)) {
+        const semanticKey = priorMap.pathToKey.get(oldPath);
+        if (semanticKey) {
+            const newPath = newMap.keyToPath.get(semanticKey);
+            if (newPath && newPath !== oldPath) {
+                remapped[newPath] = value;
+                hasChanges = true;
+                continue;
+            }
+        }
+        // If the old path exists in the new template, keep it as-is.
+        // If it doesn't exist in either map, keep it as-is (legacy data).
+        remapped[oldPath] = value;
+    }
+    return hasChanges ? remapped : oldValues;
+}
+/**
+ * Determine whether the template structure has changed enough to warrant
+ * path remapping. This is true when any node paths differ between the two
+ * templates (container IDs changed, nodes reorganized, etc.)
+ */
+function needsPathRemapping(priorMap, newMap) {
+    if (priorMap.allPaths.size !== newMap.allPaths.size)
+        return true;
+    for (const path of priorMap.allPaths) {
+        if (!newMap.allPaths.has(path))
+            return true;
+    }
+    return false;
+}
+export function reconcileCollectionValue(priorNode, newNode, priorValue, options) {
+    const issues = [];
+    const normalized = normalizeCollectionValue(newNode, priorValue);
+    if (priorNode.template.type !== newNode.template.type && !areCompatibleContainerTypes(priorNode.template.type, newNode.template.type)) {
+        issues.push({
+            severity: ISSUE_SEVERITY.ERROR,
+            nodeId: newNode.id,
+            message: `Node type mismatch: ${priorNode.template.type} -> ${newNode.template.type}`,
+            code: ISSUE_CODES.TYPE_MISMATCH,
+        });
+        return {
+            value: createInitialCollectionValue(newNode),
+            issues,
+            didMigrateItems: false,
+        };
+    }
+    let didMigrateItems = false;
+    const priorTemplate = priorNode.template;
+    const newTemplate = newNode.template;
+    // Build path maps for key-based remapping
+    const priorPathMap = buildTemplatePathMap(priorTemplate);
+    const newPathMap = buildTemplatePathMap(newTemplate);
+    const shouldRemap = needsPathRemapping(priorPathMap, newPathMap);
+    // Check if AI pushed new defaultValues that differ from the prior ones
+    let receivedNewDefaults = false;
+    let hasDirtyItems = false;
+    if (newNode.defaultValues !== undefined) {
+        if (!priorNode.defaultValues || JSON.stringify(priorNode.defaultValues) !== JSON.stringify(newNode.defaultValues)) {
+            receivedNewDefaults = true;
+        }
+    }
+    // Determine if any prior item has dirty fields
+    if (receivedNewDefaults && priorValue !== undefined) {
+        const state = priorValue.value;
+        if (state && Array.isArray(state.items)) {
+            hasDirtyItems = state.items.some(item => item.values && Object.values(item.values).some(v => v.isDirty));
+        }
+    }
+    // If AI provided new defaultValues, populate those instead
+    if (receivedNewDefaults) {
+        const defaultCollection = resolveCollectionDefaultValues(newNode);
+        const constrained = applyItemConstraints(defaultCollection.value.items, newNode.minItems, newNode.maxItems, issues, newNode.id);
+        // If there were dirty items, return the new defaults as a `suggestion` for the whole collection
+        if (hasDirtyItems) {
+            const suggestedValue = {
+                value: normalized.value, // keep prior as current
+                suggestion: { items: constrained } // new items as suggestion
+            };
+            // Keep isDirty flag from prior NodeValue if it exists
+            if (normalized.isDirty) {
+                suggestedValue.isDirty = true;
+            }
+            return {
+                value: suggestedValue,
+                issues,
+                didMigrateItems: true, // Treat as migration to force UI update
+            };
+        }
+        // If no dirty items, immediately overwrite
+        return {
+            value: { value: { items: constrained } },
+            issues,
+            didMigrateItems: true,
+        };
+    }
+    const migratedItems = normalized.value.items.map((item) => {
+        // Step 1: Remap value paths from old template structure to new
+        const values = shouldRemap
+            ? remapCollectionItemPaths(item.values, priorPathMap, newPathMap)
+            : { ...item.values };
+        if (shouldRemap && values !== item.values) {
+            didMigrateItems = true;
+        }
+        // Step 2: Handle hash-based migration for the template root value
+        const priorTemplateValue = values[priorTemplate.id];
+        if (priorTemplateValue !== undefined && hasTemplateHashChanged(priorTemplate, newTemplate)) {
+            const migrationResult = attemptMigration(priorTemplate.id, priorTemplate, newTemplate, priorTemplateValue, options);
+            if (migrationResult.kind === 'migrated') {
+                didMigrateItems = true;
+                values[newTemplate.id] = migrationResult.value;
+                if (newTemplate.id !== priorTemplate.id) {
+                    delete values[priorTemplate.id];
+                }
+            }
+            else if (migrationResult.kind === 'error') {
+                issues.push({
+                    severity: ISSUE_SEVERITY.WARNING,
+                    nodeId: newNode.id,
+                    message: `Node ${newNode.id} migration failed: ${String(migrationResult.error)}`,
+                    code: ISSUE_CODES.MIGRATION_FAILED,
+                });
+            }
+            else {
+                issues.push({
+                    severity: ISSUE_SEVERITY.WARNING,
+                    nodeId: newNode.id,
+                    message: `Node ${newNode.id} view changed but no migration strategy available`,
+                    code: ISSUE_CODES.MIGRATION_FAILED,
+                });
+            }
+        }
+        return { values };
+    });
+    const constrained = applyItemConstraints(migratedItems, newNode.minItems, newNode.maxItems, issues, newNode.id);
+    return {
+        value: { value: { items: constrained } },
+        issues,
+        didMigrateItems,
+    };
+}
+export function normalizeCollectionValue(node, value) {
+    if (!value || typeof value !== 'object' || !('value' in value)) {
+        return createInitialCollectionValue(node);
+    }
+    const state = value.value;
+    const items = Array.isArray(state?.items)
+        ? state.items.map((item) => ({ values: (item?.values ?? {}) }))
+        : [];
+    return { value: { items } };
+}
+function applyItemConstraints(items, minItems, maxItems, issues, nodeId) {
+    let constrained = [...items];
+    const min = normalizeMinItems(minItems);
+    const max = normalizeMaxItems(maxItems);
+    if (max !== undefined && constrained.length > max) {
+        constrained = constrained.slice(0, max);
+        issues.push({
+            severity: ISSUE_SEVERITY.WARNING,
+            nodeId,
+            message: `Collection ${nodeId} exceeded maxItems`,
+            code: ISSUE_CODES.COLLECTION_CONSTRAINT_VIOLATED,
+        });
+    }
+    while (constrained.length < min) {
+        constrained.push({ values: {} });
+        issues.push({
+            severity: ISSUE_SEVERITY.INFO,
+            nodeId,
+            message: `Collection ${nodeId} filled to minItems`,
+            code: ISSUE_CODES.COLLECTION_CONSTRAINT_VIOLATED,
+        });
+    }
+    return constrained;
+}
+function normalizeMinItems(value) {
+    if (value === undefined || value < 0) {
+        return 0;
+    }
+    return Math.floor(value);
+}
+function normalizeMaxItems(value) {
+    if (value === undefined || value < 0) {
+        return undefined;
+    }
+    return Math.floor(value);
+}
+function hasTemplateHashChanged(priorTemplate, newTemplate) {
+    return !!(priorTemplate.hash && newTemplate.hash && priorTemplate.hash !== newTemplate.hash);
+}
+function collectTemplateDefaults(node, parentPath = '') {
+    const nodeId = parentPath.length > 0 ? `${parentPath}/${node.id}` : node.id;
+    if (node.type === 'collection') {
+        return {
+            [nodeId]: createInitialCollectionValue(node),
+        };
+    }
+    const values = {};
+    if ('defaultValue' in node && node.defaultValue !== undefined) {
+        values[nodeId] = { value: node.defaultValue };
+    }
+    const children = getChildNodes(node);
+    for (const child of children) {
+        Object.assign(values, collectTemplateDefaults(child, nodeId));
+    }
+    return values;
+}

package/lib/reconciliation/component-resolver.d.ts

@@ -0,0 +1,10 @@
+import type { OrphanedValue, StateSnapshot } from '@continuum/contract';
+import type { ComponentResolutionAccumulator, ReconciliationIssue, ReconciliationOptions, StateDiff } from '../types.js';
+import type { ReconciliationContext } from '../context.js';
+export declare function resolveAllComponents(ctx: ReconciliationContext, priorValues: Map<string, unknown>, priorState: StateSnapshot, now: number, options: ReconciliationOptions): ComponentResolutionAccumulator;
+export declare function detectRemovedComponents(ctx: ReconciliationContext, priorState: StateSnapshot, options: ReconciliationOptions, now: number): {
+    diffs: StateDiff[];
+    issues: ReconciliationIssue[];
+    orphanedValues: Record<string, OrphanedValue>;
+};
+//# sourceMappingURL=component-resolver.d.ts.map

package/lib/reconciliation/component-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-resolver.d.ts","sourceRoot":"","sources":["../../../../../packages/runtime/src/lib/reconciliation/component-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAuC,aAAa,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAE7G,OAAO,KAAK,EACV,8BAA8B,EAC9B,mBAAmB,EACnB,qBAAqB,EACrB,SAAS,EACV,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAqB3D,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,qBAAqB,EAC1B,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,UAAU,EAAE,aAAa,EACzB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,qBAAqB,GAC7B,8BAA8B,CAoChC;AAoID,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,qBAAqB,EAC1B,UAAU,EAAE,aAAa,EACzB,OAAO,EAAE,qBAAqB,EAC9B,GAAG,EAAE,MAAM,GACV;IAAE,KAAK,EAAE,SAAS,EAAE,CAAC;IAAC,MAAM,EAAE,mBAAmB,EAAE,CAAC;IAAC,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;CAAE,CAoCtG"}

package/lib/reconciliation/differ.d.ts

@@ -0,0 +1,12 @@
+import type { StateDiff, ReconciliationResolution } from '../types.js';
+export declare function addedDiff(nodeId: string): StateDiff;
+export declare function removedDiff(nodeId: string, oldValue: unknown): StateDiff;
+export declare function typeChangedDiff(nodeId: string, oldValue: unknown, priorType: string, newType: string): StateDiff;
+export declare function migratedDiff(nodeId: string, oldValue: unknown, newValue: unknown): StateDiff;
+export declare function restoredDiff(nodeId: string, newValue: unknown): StateDiff;
+export declare function addedResolution(nodeId: string, newType: string): ReconciliationResolution;
+export declare function carriedResolution(nodeId: string, priorId: string, matchedBy: 'id' | 'key', nodeType: string, priorValue: unknown, reconciledValue: unknown): ReconciliationResolution;
+export declare function detachedResolution(nodeId: string, priorId: string, matchedBy: 'id' | 'key' | null, priorType: string, newType: string, priorValue: unknown): ReconciliationResolution;
+export declare function migratedResolution(nodeId: string, priorId: string, matchedBy: 'id' | 'key' | null, priorType: string, newType: string, priorValue: unknown, reconciledValue: unknown): ReconciliationResolution;
+export declare function restoredResolution(nodeId: string, priorType: string, reconciledValue: unknown): ReconciliationResolution;
+//# sourceMappingURL=differ.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"differ.d.ts","sourceRoot":"","sources":["../../../../../packages/runtime/src/lib/reconciliation/differ.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAEvE,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAOnD;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,SAAS,CAOxE;AAED,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,OAAO,EACjB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd,SAAS,CAOX;AAED,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,OAAO,EACjB,QAAQ,EAAE,OAAO,GAChB,SAAS,CAQX;AAED,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,OAAO,GAChB,SAAS,CAOX;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,wBAAwB,CAWzF;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,IAAI,GAAG,KAAK,EACvB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,OAAO,EACnB,eAAe,EAAE,OAAO,GACvB,wBAAwB,CAW1B;AAED,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,IAAI,GAAG,KAAK,GAAG,IAAI,EAC9B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,OAAO,GAClB,wBAAwB,CAW1B;AAED,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,IAAI,GAAG,KAAK,GAAG,IAAI,EAC9B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,OAAO,EACnB,eAAe,EAAE,OAAO,GACvB,wBAAwB,CAW1B;AAED,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,OAAO,GACvB,wBAAwB,CAW1B"}

package/lib/reconciliation/differ.js

@@ -0,0 +1,102 @@
+import { VIEW_DIFFS, DATA_RESOLUTIONS } from '@continuum/contract';
+export function addedDiff(nodeId) {
+    return {
+        nodeId,
+        type: VIEW_DIFFS.ADDED,
+        newValue: undefined,
+        reason: 'Node added to view',
+    };
+}
+export function removedDiff(nodeId, oldValue) {
+    return {
+        nodeId,
+        type: VIEW_DIFFS.REMOVED,
+        oldValue,
+        reason: 'Node removed from view',
+    };
+}
+export function typeChangedDiff(nodeId, oldValue, priorType, newType) {
+    return {
+        nodeId,
+        type: VIEW_DIFFS.TYPE_CHANGED,
+        oldValue,
+        reason: `Type changed from ${priorType} to ${newType}`,
+    };
+}
+export function migratedDiff(nodeId, oldValue, newValue) {
+    return {
+        nodeId,
+        type: VIEW_DIFFS.MIGRATED,
+        oldValue,
+        newValue,
+        reason: 'Node view changed, migration applied',
+    };
+}
+export function restoredDiff(nodeId, newValue) {
+    return {
+        nodeId,
+        type: VIEW_DIFFS.RESTORED,
+        newValue,
+        reason: 'Node restored from detached values',
+    };
+}
+export function addedResolution(nodeId, newType) {
+    return {
+        nodeId,
+        priorId: null,
+        matchedBy: null,
+        priorType: null,
+        newType,
+        resolution: DATA_RESOLUTIONS.ADDED,
+        priorValue: undefined,
+        reconciledValue: undefined,
+    };
+}
+export function carriedResolution(nodeId, priorId, matchedBy, nodeType, priorValue, reconciledValue) {
+    return {
+        nodeId,
+        priorId,
+        matchedBy,
+        priorType: nodeType,
+        newType: nodeType,
+        resolution: DATA_RESOLUTIONS.CARRIED,
+        priorValue,
+        reconciledValue,
+    };
+}
+export function detachedResolution(nodeId, priorId, matchedBy, priorType, newType, priorValue) {
+    return {
+        nodeId,
+        priorId,
+        matchedBy,
+        priorType,
+        newType,
+        resolution: DATA_RESOLUTIONS.DETACHED,
+        priorValue,
+        reconciledValue: undefined,
+    };
+}
+export function migratedResolution(nodeId, priorId, matchedBy, priorType, newType, priorValue, reconciledValue) {
+    return {
+        nodeId,
+        priorId,
+        matchedBy,
+        priorType,
+        newType,
+        resolution: DATA_RESOLUTIONS.MIGRATED,
+        priorValue,
+        reconciledValue,
+    };
+}
+export function restoredResolution(nodeId, priorType, reconciledValue) {
+    return {
+        nodeId,
+        priorId: null,
+        matchedBy: null,
+        priorType,
+        newType: priorType,
+        resolution: DATA_RESOLUTIONS.RESTORED,
+        priorValue: undefined,
+        reconciledValue,
+    };
+}

package/lib/reconciliation/migrator.d.ts

@@ -0,0 +1,13 @@
+import type { ViewNode } from '@continuum/contract';
+import type { ReconciliationOptions } from '../types.js';
+export type MigrationAttemptResult = {
+    kind: 'migrated';
+    value: unknown;
+} | {
+    kind: 'none';
+} | {
+    kind: 'error';
+    error: unknown;
+};
+export declare function attemptMigration(nodeId: string, priorNode: ViewNode, newNode: ViewNode, priorValue: unknown, options: ReconciliationOptions): MigrationAttemptResult;
+//# sourceMappingURL=migrator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"migrator.d.ts","sourceRoot":"","sources":["../../../../../packages/runtime/src/lib/reconciliation/migrator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEzD,MAAM,MAAM,sBAAsB,GAC9B;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAUtC,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,QAAQ,EACnB,OAAO,EAAE,QAAQ,EACjB,UAAU,EAAE,OAAO,EACnB,OAAO,EAAE,qBAAqB,GAC7B,sBAAsB,CA4ExB"}

package/lib/reconciliation/migrator.js

@@ -0,0 +1,92 @@
+const MAX_CHAIN_DEPTH = 10;
+export function attemptMigration(nodeId, priorNode, newNode, priorValue, options) {
+    if (options.migrationStrategies?.[nodeId]) {
+        try {
+            return {
+                kind: 'migrated',
+                value: options.migrationStrategies[nodeId](nodeId, priorNode, newNode, priorValue),
+            };
+        }
+        catch (error) {
+            return { kind: 'error', error };
+        }
+    }
+    if (newNode.migrations && priorNode.hash && newNode.hash) {
+        if (!options.strategyRegistry) {
+            return { kind: 'none' };
+        }
+        const directRule = newNode.migrations.find((m) => m.fromHash === priorNode.hash &&
+            m.toHash === newNode.hash &&
+            !!m.strategyId &&
+            !!options.strategyRegistry?.[m.strategyId]);
+        if (directRule?.strategyId) {
+            try {
+                return {
+                    kind: 'migrated',
+                    value: options.strategyRegistry[directRule.strategyId](nodeId, priorNode, newNode, priorValue),
+                };
+            }
+            catch (error) {
+                return { kind: 'error', error };
+            }
+        }
+        const path = findMigrationPath(newNode.migrations, priorNode.hash, newNode.hash, options.strategyRegistry);
+        if (!path) {
+            return { kind: 'none' };
+        }
+        try {
+            let currentValue = priorValue;
+            let currentHash = priorNode.hash;
+            for (const step of path) {
+                const strategy = options.strategyRegistry[step.strategyId];
+                const stepPriorNode = { ...priorNode, hash: currentHash };
+                const stepNewNode = { ...newNode, hash: step.toHash };
+                currentValue = strategy(nodeId, stepPriorNode, stepNewNode, currentValue);
+                currentHash = step.toHash;
+            }
+            return { kind: 'migrated', value: currentValue };
+        }
+        catch (error) {
+            return { kind: 'error', error };
+        }
+    }
+    if (priorNode.type === newNode.type) {
+        return { kind: 'migrated', value: priorValue };
+    }
+    return { kind: 'none' };
+}
+function findMigrationPath(rules, fromHash, toHash, strategyRegistry) {
+    const edges = rules
+        .filter((rule) => !!rule.strategyId && !!strategyRegistry[rule.strategyId])
+        .map((rule) => ({
+        fromHash: rule.fromHash,
+        toHash: rule.toHash,
+        strategyId: rule.strategyId,
+    }));
+    const byFrom = new Map();
+    for (const edge of edges) {
+        const existing = byFrom.get(edge.fromHash) ?? [];
+        existing.push(edge);
+        byFrom.set(edge.fromHash, existing);
+    }
+    const queue = [{ hash: fromHash, path: [] }];
+    const seen = new Set([fromHash]);
+    while (queue.length > 0) {
+        const current = queue.shift();
+        const nextEdges = byFrom.get(current.hash) ?? [];
+        for (const edge of nextEdges) {
+            const nextPath = [...current.path, edge];
+            if (nextPath.length > MAX_CHAIN_DEPTH) {
+                continue;
+            }
+            if (edge.toHash === toHash) {
+                return nextPath;
+            }
+            if (!seen.has(edge.toHash)) {
+                seen.add(edge.toHash);
+                queue.push({ hash: edge.toHash, path: nextPath });
+            }
+        }
+    }
+    return null;
+}

package/lib/reconciliation/node-resolver.d.ts

@@ -0,0 +1,10 @@
+import type { DataSnapshot, DetachedValue } from '@continuum/contract';
+import type { NodeResolutionAccumulator, ReconciliationIssue, ReconciliationOptions, StateDiff } from '../types.js';
+import type { ReconciliationContext } from '../context.js';
+export declare function resolveAllNodes(ctx: ReconciliationContext, priorValues: Map<string, unknown>, priorData: DataSnapshot, now: number, options: ReconciliationOptions): NodeResolutionAccumulator;
+export declare function detectRemovedNodes(ctx: ReconciliationContext, priorData: DataSnapshot, options: ReconciliationOptions, now: number): {
+    diffs: StateDiff[];
+    issues: ReconciliationIssue[];
+    detachedValues: Record<string, DetachedValue>;
+};
+//# sourceMappingURL=node-resolver.d.ts.map

package/lib/reconciliation/node-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-resolver.d.ts","sourceRoot":"","sources":["../../../../../packages/runtime/src/lib/reconciliation/node-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAuB,MAAM,qBAAqB,CAAC;AAE5F,OAAO,KAAK,EACV,yBAAyB,EACzB,mBAAmB,EACnB,qBAAqB,EACrB,SAAS,EACV,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAwB3D,wBAAgB,eAAe,CAC7B,GAAG,EAAE,qBAAqB,EAC1B,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,SAAS,EAAE,YAAY,EACvB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,qBAAqB,GAC7B,yBAAyB,CAiF3B;AAgOD,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,qBAAqB,EAC1B,SAAS,EAAE,YAAY,EACvB,OAAO,EAAE,qBAAqB,EAC9B,GAAG,EAAE,MAAM,GACV;IAAE,KAAK,EAAE,SAAS,EAAE,CAAC;IAAC,MAAM,EAAE,mBAAmB,EAAE,CAAC;IAAC,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;CAAE,CAsCtG"}