@llui/vite-plugin 0.0.3 → 0.0.5

package/dist/transform.js

@@ -139,6 +139,7 @@ export function transformLlui(source, _filename, devMode = false, mcpPort = 5200
     let usesElTemplate = false;
     let usesElSplit = false;
     let usesMemo = false;
+    let usesApplyBinding = false;
     const f = ts.factory;
     const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
     // Collect source positions of transformed nodes for source mapping
@@ -164,10 +165,27 @@ export function transformLlui(source, _filename, devMode = false, mcpPort = 5200
                 current = deduped;
                 changed = true;
             }
+            // Inject __mask for Phase 1 gating
+            const masked = tryInjectStructuralMask(current, viewHelperNames, viewHelperAliases, fieldBits, f);
+            if (masked) {
+                current = masked;
+                changed = true;
+            }
             if (changed) {
                 const result = ts.visitEachChild(current, visitor, undefined);
                 if (hasPos)
                     edits.push({ start: origStart, end: origEnd, replacement: '' });
+                // Row factory: try after children are transformed
+                if (ts.isCallExpression(result)) {
+                    try {
+                        const rf = tryEmitRowFactory(result, f, source);
+                        if (rf)
+                            return rf;
+                    }
+                    catch (err) {
+                        console.warn('[llui] Row factory failed:', err.message, '\n', err.stack?.split('\n').slice(0, 5).join('\n'));
+                    }
+                }
                 return result;
             }
         }
@@ -192,10 +210,19 @@ export function transformLlui(source, _filename, devMode = false, mcpPort = 5200
                     edits.push({ start: origStart, end: origEnd, replacement: '' });
                 return textTransformed;
             }
+            // Inject __mask into each()/branch()/show() options for Phase 1 gating
+            const structuralMasked = tryInjectStructuralMask(node, viewHelperNames, viewHelperAliases, fieldBits, f);
+            if (structuralMasked) {
+                if (hasPos)
+                    edits.push({ start: origStart, end: origEnd, replacement: '' });
+                return ts.visitEachChild(structuralMasked, visitor, undefined);
+            }
         }
-        // Pass 2: Inject __dirty and __msgSchema into component() calls
+        // Pass 2: Inject __dirty, __update, and __msgSchema into component() calls
         if (ts.isCallExpression(node) && isComponentCall(node, lluiImport)) {
             let result = tryInjectDirty(node, fieldBits, f);
+            if (result)
+                usesApplyBinding = true;
             if (devMode) {
                 const schema = extractMsgSchema(source);
                 if (schema) {
@@ -223,7 +250,7 @@ export function transformLlui(source, _filename, devMode = false, mcpPort = 5200
     // Pass 3: Clean up imports — use the old cleanupImports approach
     // which operates on the transformed SourceFile safely
     const safeToRemove = new Set([...compiledHelpers].filter((h) => !bailedHelpers.has(h)));
-    transformed = cleanupImports(transformed, lluiImport, importedHelpers, safeToRemove, usesElSplit, usesElTemplate, usesMemo, f);
+    transformed = cleanupImports(transformed, lluiImport, importedHelpers, safeToRemove, usesElSplit, usesElTemplate, usesMemo, usesApplyBinding, f);
     if (edits.length === 0)
         return null;
     // Find component declarations for HMR
@@ -752,6 +779,61 @@ function tryInjectTextMask(node, lluiImport, viewHelperNames, viewHelperAliases,
         createMaskLiteral(f, mask === 0 ? 0xffffffff | 0 : mask),
     ]);
 }
+/**
+ * Inject `__mask` into the options object of each()/branch()/show() calls.
+ *
+ * Analyzes the driving accessor (`items` for each, `on` for branch, `when`
+ * for show) and computes the bitmask of state fields it reads. The runtime
+ * uses this to skip Phase 1 reconciliation when irrelevant state changed
+ * (e.g., each() that reads `rows` is skipped when only `selected` changed).
+ */
+function tryInjectStructuralMask(node, viewHelperNames, viewHelperAliases, fieldBits, f) {
+    if (fieldBits.size === 0)
+        return null;
+    // Match each(), branch(), show() — bare, aliased, or member-call
+    const isEach = isHelperCall(node.expression, 'each', viewHelperNames, viewHelperAliases);
+    const isBranch = isHelperCall(node.expression, 'branch', viewHelperNames, viewHelperAliases);
+    const isShow = isHelperCall(node.expression, 'show', viewHelperNames, viewHelperAliases);
+    if (!isEach && !isBranch && !isShow)
+        return null;
+    const optsArg = node.arguments[0];
+    if (!optsArg || !ts.isObjectLiteralExpression(optsArg))
+        return null;
+    // Already has __mask
+    for (const prop of optsArg.properties) {
+        if (ts.isPropertyAssignment(prop) &&
+            ts.isIdentifier(prop.name) &&
+            prop.name.text === '__mask') {
+            return null;
+        }
+    }
+    // Find the driving accessor property: items/on/when
+    const driverProp = isEach ? 'items' : isBranch ? 'on' : 'when';
+    let driverAccessor = null;
+    for (const prop of optsArg.properties) {
+        if (ts.isPropertyAssignment(prop) &&
+            ts.isIdentifier(prop.name) &&
+            prop.name.text === driverProp) {
+            if (ts.isArrowFunction(prop.initializer) || ts.isFunctionExpression(prop.initializer)) {
+                driverAccessor = prop.initializer;
+            }
+            break;
+        }
+    }
+    if (!driverAccessor)
+        return null;
+    const { mask } = computeAccessorMask(driverAccessor, fieldBits);
+    if (mask === 0 || mask === (0xffffffff | 0))
+        return null; // no benefit
+    // Inject __mask into the options object
+    const maskProp = f.createPropertyAssignment('__mask', createMaskLiteral(f, mask));
+    const newProps = [...optsArg.properties, maskProp];
+    const newOpts = f.createObjectLiteralExpression(newProps, optsArg.properties.hasTrailingComma);
+    return f.createCallExpression(node.expression, node.typeArguments, [
+        newOpts,
+        ...node.arguments.slice(1),
+    ]);
+}
 function tryInjectDirty(node, fieldBits, f) {
     if (fieldBits.size === 0)
         return null;
@@ -803,12 +885,908 @@ function tryInjectDirty(node, fieldBits, f) {
         legendProps.push(f.createPropertyAssignment(field, createMaskLiteral(f, bit)));
     }
     const legendProp = f.createPropertyAssignment('__maskLegend', f.createObjectLiteralExpression(legendProps, false));
-    const newConfig = f.createObjectLiteralExpression([...configArg.properties, dirtyProp, legendProp], true);
+    // Structural mask — used by both __update and __handlers
+    const structuralMask = computeStructuralMask(configArg, fieldBits);
+    const phase2Mask = computePhase2Mask(configArg, fieldBits);
+    const updateBody = buildUpdateBody(f, structuralMask, phase2Mask);
+    const updateFn = f.createArrowFunction(undefined, undefined, [
+        f.createParameterDeclaration(undefined, undefined, 's'),
+        f.createParameterDeclaration(undefined, undefined, 'd'),
+        f.createParameterDeclaration(undefined, undefined, 'b'),
+        f.createParameterDeclaration(undefined, undefined, 'bl'),
+        f.createParameterDeclaration(undefined, undefined, 'p'),
+    ], undefined, f.createToken(ts.SyntaxKind.EqualsGreaterThanToken), updateBody);
+    const updateProp = f.createPropertyAssignment('__update', updateFn);
+    // __handlers: per-message-type specialized update functions.
+    // Analyzes the update() switch/case and generates direct handlers
+    // that bypass the generic Phase 1/2 pipeline for single-message updates.
+    const handlersProp = tryBuildHandlers(configArg, topLevelBits, structuralMask, f);
+    // Keep __update even when __handlers is present — it provides Phase 1
+    // mask gating for multi-message batches that bypass __handlers.
+    const extraProps = [dirtyProp, legendProp, updateProp];
+    if (handlersProp)
+        extraProps.push(handlersProp);
+    const newConfig = f.createObjectLiteralExpression([...configArg.properties, ...extraProps], true);
     return f.createCallExpression(node.expression, node.typeArguments, [
         newConfig,
         ...node.arguments.slice(1),
     ]);
 }
+/**
+ * Analyze update() switch/case and generate per-message-type handlers.
+ *
+ * Each handler receives (inst, msg) and returns [newState, effects].
+ * The handler calls update() to get the new state, then directly invokes
+ * the appropriate runtime primitives (reconcileItems, __directUpdate, etc.)
+ * instead of going through the generic Phase 1/2 pipeline.
+ *
+ * Conservative: only generates handlers for cases where the field
+ * modifications are statically determinable. Complex cases are skipped.
+ */
+function tryBuildHandlers(configArg, topLevelBits, structuralMask, f) {
+    if (topLevelBits.size === 0)
+        return null;
+    // Find the update function in the component config
+    let updateFn = null;
+    for (const prop of configArg.properties) {
+        if (ts.isPropertyAssignment(prop) &&
+            ts.isIdentifier(prop.name) &&
+            prop.name.text === 'update') {
+            if (ts.isArrowFunction(prop.initializer) || ts.isFunctionExpression(prop.initializer)) {
+                updateFn = prop.initializer;
+            }
+            break;
+        }
+    }
+    if (!updateFn)
+        return null;
+    // Find the switch statement in the update body
+    const body = ts.isBlock(updateFn.body) ? updateFn.body : null;
+    if (!body)
+        return null;
+    let switchStmt = null;
+    for (const stmt of body.statements) {
+        if (ts.isSwitchStatement(stmt)) {
+            switchStmt = stmt;
+            break;
+        }
+    }
+    if (!switchStmt)
+        return null;
+    // Check the switch discriminant is msg.type pattern
+    const stateParam = updateFn.parameters[0]?.name;
+    const msgParam = updateFn.parameters[1]?.name;
+    if (!stateParam || !msgParam || !ts.isIdentifier(stateParam) || !ts.isIdentifier(msgParam))
+        return null;
+    const stateName = stateParam.text;
+    const _msgName = msgParam.text;
+    // Analyze each case clause
+    const handlers = [];
+    for (const clause of switchStmt.caseBlock.clauses) {
+        if (!ts.isCaseClause(clause))
+            continue;
+        // Extract the case label — must be a string literal like 'select'
+        if (!ts.isStringLiteral(clause.expression))
+            continue;
+        const msgType = clause.expression.text;
+        // Find the return statement in the case body
+        let returnExpr = null;
+        for (const stmt of clause.statements) {
+            if (ts.isReturnStatement(stmt) &&
+                stmt.expression &&
+                ts.isArrayLiteralExpression(stmt.expression)) {
+                returnExpr = stmt.expression;
+                break;
+            }
+            // Handle block-scoped cases: case 'x': { ... return [...] }
+            if (ts.isBlock(stmt)) {
+                for (const inner of stmt.statements) {
+                    if (ts.isReturnStatement(inner) &&
+                        inner.expression &&
+                        ts.isArrayLiteralExpression(inner.expression)) {
+                        returnExpr = inner.expression;
+                        break;
+                    }
+                }
+            }
+        }
+        if (!returnExpr || returnExpr.elements.length < 2)
+            continue;
+        // Analyze the state expression (first element of return [newState, effects])
+        const stateExpr = returnExpr.elements[0];
+        // Determine which top-level fields change
+        const modifiedFields = analyzeModifiedFields(stateExpr, stateName, topLevelBits);
+        if (!modifiedFields)
+            continue; // too complex to analyze
+        // Compute the dirty mask for this case
+        let caseDirty = 0;
+        for (const field of modifiedFields) {
+            caseDirty |= topLevelBits.get(field) ?? 0xffffffff | 0;
+        }
+        // Detect array operation pattern for structural block optimization
+        const arrayOp = detectArrayOp(clause, stateName, modifiedFields, structuralMask, caseDirty);
+        const handler = buildCaseHandler(f, caseDirty, arrayOp);
+        handlers.push(f.createPropertyAssignment(f.createStringLiteral(msgType), handler));
+    }
+    if (handlers.length === 0)
+        return null;
+    return f.createPropertyAssignment('__handlers', f.createObjectLiteralExpression(handlers, true));
+}
+/**
+ * Detect the array operation pattern in a case body.
+ * - 'none': no array field modified (e.g., only `selected` changes)
+ * - 'clear': array set to empty literal `[]`
+ * - 'mutate': array created via `.slice()` then mutated in place (same keys)
+ * - 'general': unknown pattern, use generic reconcile
+ */
+function detectArrayOp(clause, stateName, modifiedFields, structuralMask, caseDirty) {
+    // No fields modified or dirty bits don't intersect any structural block →
+    // skip structural blocks entirely (e.g., only `selected` changes)
+    if (modifiedFields.length === 0)
+        return 'none';
+    if (structuralMask !== undefined && caseDirty !== undefined && (structuralMask & caseDirty) === 0)
+        return 'none';
+    // Look at the return expression's array field values
+    for (const stmt of clause.statements) {
+        const returnExpr = findReturnArray(stmt);
+        if (!returnExpr)
+            continue;
+        const stateExpr = returnExpr.elements[0];
+        if (!stateExpr || !ts.isObjectLiteralExpression(stateExpr))
+            continue;
+        for (const prop of stateExpr.properties) {
+            const name = ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)
+                ? prop.name.text
+                : ts.isShorthandPropertyAssignment(prop)
+                    ? prop.name.text
+                    : null;
+            if (!name)
+                continue;
+            // Check for empty array literal: `field: []`
+            if (ts.isPropertyAssignment(prop) &&
+                ts.isArrayLiteralExpression(prop.initializer) &&
+                prop.initializer.elements.length === 0) {
+                return 'clear';
+            }
+            // Check for shorthand `field` where field was assigned via `.slice()` earlier
+            // This catches: `const rows = state.rows.slice(); rows[i] = ...; return { ...state, rows }`
+            if (ts.isShorthandPropertyAssignment(prop)) {
+                const varName = prop.name.text;
+                if (hasSliceAssignment(clause, stateName, varName)) {
+                    // Check for strided for-loop: for (let i = 0; i < arr.length; i += STRIDE)
+                    const stride = detectStrideLoop(clause, varName);
+                    if (stride > 1)
+                        return { type: 'strided', stride };
+                    return 'mutate';
+                }
+            }
+            // Check for property assignment with filter: `field: state.field.filter(...)`
+            if (ts.isPropertyAssignment(prop) && ts.isCallExpression(prop.initializer)) {
+                const call = prop.initializer;
+                if (ts.isPropertyAccessExpression(call.expression) &&
+                    call.expression.name.text === 'filter') {
+                    return 'remove';
+                }
+            }
+        }
+    }
+    return 'general';
+}
+function findReturnArray(stmt) {
+    if (ts.isReturnStatement(stmt) && stmt.expression && ts.isArrayLiteralExpression(stmt.expression))
+        return stmt.expression;
+    if (ts.isBlock(stmt)) {
+        for (const inner of stmt.statements) {
+            const result = findReturnArray(inner);
+            if (result)
+                return result;
+        }
+    }
+    return null;
+}
+/**
+ * Detect a strided for-loop: `for (let i = 0; i < arr.length; i += STRIDE)`
+ * where `arr` is the named variable. Returns the stride or 0 if not found.
+ */
+function detectStrideLoop(clause, _arrName) {
+    function walk(node) {
+        if (ts.isForStatement(node) && node.incrementor) {
+            // Check incrementor: i += STRIDE
+            const inc = node.incrementor;
+            if (ts.isBinaryExpression(inc) &&
+                inc.operatorToken.kind === ts.SyntaxKind.PlusEqualsToken &&
+                ts.isNumericLiteral(inc.right)) {
+                const stride = parseInt(inc.right.text, 10);
+                if (stride > 1)
+                    return stride;
+            }
+        }
+        return ts.forEachChild(node, walk) ?? 0;
+    }
+    for (const stmt of clause.statements) {
+        const result = walk(stmt);
+        if (result > 0)
+            return result;
+    }
+    return 0;
+}
+function hasSliceAssignment(clause, stateName, varName) {
+    function walk(node) {
+        // Look for: const varName = stateName.field.slice()
+        if (ts.isVariableDeclaration(node) &&
+            ts.isIdentifier(node.name) &&
+            node.name.text === varName &&
+            node.initializer) {
+            const init = node.initializer;
+            if (ts.isCallExpression(init) &&
+                ts.isPropertyAccessExpression(init.expression) &&
+                init.expression.name.text === 'slice') {
+                return true;
+            }
+        }
+        return ts.forEachChild(node, walk) ?? false;
+    }
+    for (const stmt of clause.statements) {
+        if (walk(stmt))
+            return true;
+    }
+    return false;
+}
+/**
+ * Analyze which top-level state fields are modified in a return expression.
+ * Returns the set of field names, or null if too complex to determine.
+ */
+function analyzeModifiedFields(stateExpr, stateName, topLevelBits) {
+    // Pattern: { ...state, field1: ..., field2: ... } or { field1: ..., field2: ... }
+    if (ts.isObjectLiteralExpression(stateExpr)) {
+        const modified = [];
+        for (const prop of stateExpr.properties) {
+            if (ts.isSpreadAssignment(prop)) {
+                // { ...state } — the spread doesn't modify fields
+                continue;
+            }
+            if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+                const fieldName = prop.name.text;
+                if (topLevelBits.has(fieldName)) {
+                    modified.push(fieldName);
+                }
+            }
+            // Handle shorthand: { ...state, rows } where rows is a local variable
+            if (ts.isShorthandPropertyAssignment(prop)) {
+                const fieldName = prop.name.text;
+                if (topLevelBits.has(fieldName)) {
+                    modified.push(fieldName);
+                }
+            }
+        }
+        return modified.length > 0 ? modified : null;
+    }
+    // Pattern: state (no change — early return)
+    if (ts.isIdentifier(stateExpr) && stateExpr.text === stateName) {
+        return []; // no fields modified
+    }
+    return null; // too complex
+}
+/**
+ * Build a handler function for a specific message type case.
+ *
+ * Generated: (inst, msg) => {
+ *   const [s, e] = inst.def.update(inst.state, msg)
+ *   inst.state = s
+ *   const bl = inst.structuralBlocks, b = inst.allBindings, p = b.length
+ *   // Phase 1: gated by caseDirty
+ *   for (let i = 0; i < bl.length; i++) {
+ *     if (bl[i].mask & caseDirty) bl[i].reconcile(s, caseDirty)
+ *   }
+ *   // Phase 2
+ *   __runPhase2(s, caseDirty, b, p)
+ *   return [s, e]
+ * }
+ */
+/**
+ * Build a handler that delegates to __handleMsg(inst, msg, dirty, method).
+ * method: 0=reconcile, 1=reconcileItems, 2=reconcileClear, 3=reconcileRemove, -1=skip blocks
+ */
+function buildCaseHandler(f, caseDirty, arrayOp) {
+    const method = typeof arrayOp === 'object' && arrayOp.type === 'strided'
+        ? 10 + arrayOp.stride // reconcileChanged with stride
+        : arrayOp === 'none'
+            ? -1
+            : arrayOp === 'mutate'
+                ? 1
+                : arrayOp === 'clear'
+                    ? 2
+                    : arrayOp === 'remove'
+                        ? 3
+                        : 0; // general
+    // (inst, msg) => __handleMsg(inst, msg, dirty, method)
+    return f.createArrowFunction(undefined, undefined, [
+        f.createParameterDeclaration(undefined, undefined, 'inst'),
+        f.createParameterDeclaration(undefined, undefined, 'msg'),
+    ], undefined, f.createToken(ts.SyntaxKind.EqualsGreaterThanToken), f.createCallExpression(f.createIdentifier('__handleMsg'), undefined, [
+        f.createIdentifier('inst'),
+        f.createIdentifier('msg'),
+        createMaskLiteral(f, caseDirty),
+        method >= 0
+            ? f.createNumericLiteral(method)
+            : f.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, f.createNumericLiteral(1)),
+    ]));
+}
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function _deadCode_legacyCaseHandler(f, caseDirty, arrayOp) {
+    const stmts = [];
+    // const [s, e] = inst.def.update(inst.state, msg)
+    stmts.push(f.createVariableStatement(undefined, f.createVariableDeclarationList([
+        f.createVariableDeclaration(f.createArrayBindingPattern([
+            f.createBindingElement(undefined, undefined, 's'),
+            f.createBindingElement(undefined, undefined, 'e'),
+        ]), undefined, undefined, f.createCallExpression(f.createPropertyAccessExpression(f.createPropertyAccessExpression(f.createIdentifier('inst'), 'def'), 'update'), undefined, [
+            f.createPropertyAccessExpression(f.createIdentifier('inst'), 'state'),
+            f.createIdentifier('msg'),
+        ])),
+    ], ts.NodeFlags.Const)));
+    // inst.state = s
+    stmts.push(f.createExpressionStatement(f.createBinaryExpression(f.createPropertyAccessExpression(f.createIdentifier('inst'), 'state'), ts.SyntaxKind.EqualsToken, f.createIdentifier('s'))));
+    // Phase 1 + Phase 2, specialized by array operation pattern
+    if (caseDirty !== 0) {
+        // Determine the reconcile method based on array operation
+        const reconcileMethod = arrayOp === 'clear'
+            ? 'reconcileClear'
+            : arrayOp === 'mutate'
+                ? 'reconcileItems'
+                : arrayOp === 'remove'
+                    ? 'reconcileRemove'
+                    : 'reconcile';
+        if (arrayOp === 'none') {
+            // No structural changes — skip Phase 1, only run Phase 2
+            // (e.g., select: only selector binding needs updating)
+        }
+        else {
+            // Phase 1: call specialized reconciler on matching blocks
+            // const bl = inst.structuralBlocks
+            stmts.push(f.createVariableStatement(undefined, f.createVariableDeclarationList([
+                f.createVariableDeclaration('bl', undefined, undefined, f.createPropertyAccessExpression(f.createIdentifier('inst'), 'structuralBlocks')),
+            ], ts.NodeFlags.Const)));
+            // for (let i = 0; i < bl.length; i++) { if (bl[i].mask & dirty) bl[i].METHOD(s, dirty) }
+            const blockEl = f.createElementAccessExpression(f.createIdentifier('bl'), f.createIdentifier('i'));
+            const reconcileArgs = reconcileMethod === 'reconcileClear'
+                ? []
+                : [
+                    f.createIdentifier('s'),
+                    ...(reconcileMethod === 'reconcile' ? [createMaskLiteral(f, caseDirty)] : []),
+                ];
+            stmts.push(f.createForStatement(f.createVariableDeclarationList([f.createVariableDeclaration('i', undefined, undefined, f.createNumericLiteral(0))], ts.NodeFlags.Let), f.createBinaryExpression(f.createIdentifier('i'), ts.SyntaxKind.LessThanToken, f.createPropertyAccessExpression(f.createIdentifier('bl'), 'length')), f.createPostfixUnaryExpression(f.createIdentifier('i'), ts.SyntaxKind.PlusPlusToken), f.createBlock([
+                f.createIfStatement(f.createBinaryExpression(f.createPropertyAccessExpression(blockEl, 'mask'), ts.SyntaxKind.AmpersandToken, createMaskLiteral(f, caseDirty)), f.createExpressionStatement(f.createCallExpression(
+                // Use specialized method if available, fall back to reconcile
+                // bl[i].reconcileItems?.(s) ?? bl[i].reconcile(s, dirty)
+                // Simplified: just call the method — it exists on each() blocks
+                f.createPropertyAccessExpression(blockEl, reconcileMethod), undefined, reconcileArgs))),
+            ], true)));
+        }
+        // Phase 2: compact + update bindings
+        // const b = inst.allBindings, p = b.length
+        stmts.push(f.createVariableStatement(undefined, f.createVariableDeclarationList([
+            f.createVariableDeclaration('b', undefined, undefined, f.createPropertyAccessExpression(f.createIdentifier('inst'), 'allBindings')),
+            f.createVariableDeclaration('p', undefined, undefined, f.createPropertyAccessExpression(f.createIdentifier('b'), 'length')),
+        ], ts.NodeFlags.Const)));
+        // __runPhase2(s, caseDirty, b, p)
+        stmts.push(f.createExpressionStatement(f.createCallExpression(f.createIdentifier('__runPhase2'), undefined, [
+            f.createIdentifier('s'),
+            createMaskLiteral(f, caseDirty),
+            f.createIdentifier('b'),
+            f.createIdentifier('p'),
+        ])));
+    }
+    // return [s, e]
+    stmts.push(f.createReturnStatement(f.createArrayLiteralExpression([f.createIdentifier('s'), f.createIdentifier('e')])));
+    return f.createArrowFunction(undefined, undefined, [
+        f.createParameterDeclaration(undefined, undefined, 'inst'),
+        f.createParameterDeclaration(undefined, undefined, 'msg'),
+    ], undefined, f.createToken(ts.SyntaxKind.EqualsGreaterThanToken), f.createBlock(stmts, true));
+}
+// ── Row Factory ─────────────────────────────────────────────────
+/**
+ * Transform an eligible each() render to use a row factory — shared update
+ * function with zero per-row closures for bindings.
+ *
+ * Runs AFTER the element transform pass has converted tr/td/text() calls
+ * into elTemplate() calls, so we can analyze the template structure.
+ */
+function tryEmitRowFactory(eachCall, f, _originalSource) {
+    const arg = eachCall.arguments[0];
+    if (!arg || !ts.isObjectLiteralExpression(arg))
+        return null;
+    // Find render property
+    let renderProp = null;
+    for (const prop of arg.properties) {
+        if (ts.isPropertyAssignment(prop) &&
+            ts.isIdentifier(prop.name) &&
+            prop.name.text === 'render') {
+            renderProp = prop;
+            break;
+        }
+    }
+    if (!renderProp)
+        return null;
+    const renderFn = renderProp.initializer;
+    if (!ts.isArrowFunction(renderFn) && !ts.isFunctionExpression(renderFn))
+        return null;
+    const body = ts.isBlock(renderFn.body) ? renderFn.body : null;
+    if (!body)
+        return null;
+    // Find the elTemplate call in the transformed render body
+    let templateCall = null;
+    let templateVarName = null;
+    for (const stmt of body.statements) {
+        if (ts.isVariableStatement(stmt)) {
+            for (const decl of stmt.declarationList.declarations) {
+                if (ts.isIdentifier(decl.name) &&
+                    decl.initializer &&
+                    ts.isCallExpression(decl.initializer)) {
+                    if (ts.isIdentifier(decl.initializer.expression) &&
+                        decl.initializer.expression.text === 'elTemplate') {
+                        if (templateCall)
+                            return null; // multiple templates — bail
+                        templateCall = decl.initializer;
+                        templateVarName = decl.name.text;
+                    }
+                }
+            }
+        }
+        // Check for nested structural primitives — bail
+        if (containsStructuralCall(stmt))
+            return null;
+        // Bail on selector.bind() — row factory + selector causes V8 deopt
+        // even without per-row disposers (selector fn declarations per render)
+        if (_containsSelectorBind(stmt))
+            return null;
+    }
+    if (!templateCall || templateCall.arguments.length < 2)
+        return null;
+    // Extract HTML string
+    const htmlArg = templateCall.arguments[0];
+    if (!htmlArg || !ts.isStringLiteral(htmlArg))
+        return null;
+    const html = htmlArg.text;
+    // Extract patch function
+    const patchFn = templateCall.arguments[1];
+    if (!patchFn || (!ts.isArrowFunction(patchFn) && !ts.isFunctionExpression(patchFn)))
+        return null;
+    const patchBody = ts.isBlock(patchFn.body) ? patchFn.body : null;
+    if (!patchBody)
+        return null;
+    const rootParam = patchFn.parameters[0];
+    const bindParam = patchFn.parameters[1];
+    if (!rootParam || !bindParam)
+        return null;
+    const rootName = ts.isIdentifier(rootParam.name) ? rootParam.name.text : null;
+    const bindName = ts.isIdentifier(bindParam.name) ? bindParam.name.text : null;
+    if (!rootName || !bindName)
+        return null;
+    const bindings = [];
+    const nodeVarInitializers = new Map();
+    for (const stmt of patchBody.statements) {
+        if (ts.isVariableStatement(stmt)) {
+            for (const decl of stmt.declarationList.declarations) {
+                if (ts.isIdentifier(decl.name) && decl.initializer) {
+                    nodeVarInitializers.set(decl.name.text, decl.initializer);
+                }
+            }
+        }
+        if (ts.isExpressionStatement(stmt) && ts.isCallExpression(stmt.expression)) {
+            const call = stmt.expression;
+            if (ts.isIdentifier(call.expression) &&
+                call.expression.text === bindName &&
+                call.arguments.length >= 5) {
+                const nodeArg = call.arguments[0];
+                const maskArg = call.arguments[1];
+                const kindArg = call.arguments[2];
+                const keyArg = call.arguments[3];
+                const accessorArg = call.arguments[4];
+                // Must be per-item (mask -1)
+                if (ts.isPrefixUnaryExpression(maskArg) && maskArg.operator === ts.SyntaxKind.MinusToken) {
+                    // -1 → per-item ✓
+                }
+                else if (ts.isBinaryExpression(maskArg)) {
+                    // -1 | 0 or 4294967295 | 0 → per-item ✓
+                }
+                else {
+                    return null; // state-level binding — bail
+                }
+                const kind = ts.isStringLiteral(kindArg) ? kindArg.text : '';
+                const key = ts.isStringLiteral(keyArg) ? keyArg.text : undefined;
+                // Resolve node path — recursively expand variable references to get
+                // the full path from root, then create fresh factory nodes
+                function resolveNodePath(expr) {
+                    if (ts.isIdentifier(expr)) {
+                        if (expr.text === rootName)
+                            return f.createIdentifier(rootName);
+                        const init = nodeVarInitializers.get(expr.text);
+                        if (init)
+                            return resolveNodePath(init);
+                        return f.createIdentifier(expr.text);
+                    }
+                    if (ts.isPropertyAccessExpression(expr)) {
+                        return f.createPropertyAccessExpression(resolveNodePath(expr.expression), expr.name.text);
+                    }
+                    if (ts.isElementAccessExpression(expr)) {
+                        return f.createElementAccessExpression(resolveNodePath(expr.expression), expr.argumentExpression);
+                    }
+                    return expr;
+                }
+                const nodeInit = resolveNodePath(nodeArg);
+                // Clone accessor to strip source position — prevents mixed-position errors
+                const clonedAccessor = ts.isIdentifier(accessorArg)
+                    ? f.createIdentifier(accessorArg.text)
+                    : accessorArg;
+                bindings.push({ nodeInitializer: nodeInit, kind, key, accessor: clonedAccessor });
+            }
+        }
+    }
+    if (bindings.length === 0)
+        return null;
+    // Build map of __a{N} → __s{N} for rewriting accessor references.
+    // After dedup, `__a{N} = acc(__s{N})`. In the row factory, __a{N} declarations
+    // are eliminated, so all references must be rewritten to __s{N}.
+    const accToSelector = new Map();
+    for (const stmt of body.statements) {
+        if (!ts.isVariableStatement(stmt))
+            continue;
+        for (const decl of stmt.declarationList.declarations) {
+            if (!ts.isIdentifier(decl.name) || !decl.name.text.startsWith('__a'))
+                continue;
+            if (!decl.initializer || !ts.isCallExpression(decl.initializer))
+                continue;
+            const callArg0 = decl.initializer.arguments[0];
+            if (callArg0 && ts.isIdentifier(callArg0) && callArg0.text.startsWith('__s')) {
+                accToSelector.set(decl.name.text, callArg0.text);
+            }
+        }
+    }
+    // Rewrite binding accessors: __a{N} → __s{N}
+    for (const b of bindings) {
+        if (ts.isIdentifier(b.accessor) && accToSelector.has(b.accessor.text)) {
+            b.accessor = f.createIdentifier(accToSelector.get(b.accessor.text));
+        }
+    }
+    // Collect __s{N} selector definitions — needed by __rowUpd and render init.
+    // These are currently scoped to the render body; we'll hoist them into the
+    // __rowUpd IIFE so they're accessible.
+    const selectorDefs = new Map();
+    for (const stmt of body.statements) {
+        if (!ts.isVariableStatement(stmt))
+            continue;
+        for (const decl of stmt.declarationList.declarations) {
+            if (ts.isIdentifier(decl.name) && decl.name.text.startsWith('__s') && decl.initializer) {
+                selectorDefs.set(decl.name.text, decl.initializer);
+            }
+        }
+    }
+    // === Generate the row factory ===
+    // 1. __tpl: IIFE that creates + caches the template element
+    const tplInit = f.createCallExpression(f.createParenthesizedExpression(f.createArrowFunction(undefined, undefined, [], undefined, f.createToken(ts.SyntaxKind.EqualsGreaterThanToken), f.createBlock([
+        f.createVariableStatement(undefined, f.createVariableDeclarationList([
+            f.createVariableDeclaration('t', undefined, undefined, f.createCallExpression(f.createPropertyAccessExpression(f.createIdentifier('document'), 'createElement'), undefined, [f.createStringLiteral('template')])),
+        ], ts.NodeFlags.Const)),
+        f.createExpressionStatement(f.createBinaryExpression(f.createPropertyAccessExpression(f.createIdentifier('t'), 'innerHTML'), ts.SyntaxKind.EqualsToken, f.createStringLiteral(html))),
+        f.createReturnStatement(f.createIdentifier('t')),
+    ], true))), undefined, []);
+    // 2. __rowUpd: (e) => { const t = e.current; for each binding: check + write }
+    const updStmts = [];
+    updStmts.push(f.createVariableStatement(undefined, f.createVariableDeclarationList([
+        f.createVariableDeclaration('t', undefined, undefined, f.createPropertyAccessExpression(f.createIdentifier('e'), 'current')),
+    ], ts.NodeFlags.Const)));
+    for (let i = 0; i < bindings.length; i++) {
+        const b = bindings[i];
+        const vId = f.createIdentifier(`v${i}`);
+        const cachedProp = f.createElementAccessExpression(f.createIdentifier('e'), f.createStringLiteral(`_v${i}`));
+        const nodeProp = f.createElementAccessExpression(f.createIdentifier('e'), f.createStringLiteral(`_n${i}`));
+        // const v{i} = accessor(t)
+        updStmts.push(f.createVariableStatement(undefined, f.createVariableDeclarationList([
+            f.createVariableDeclaration(vId, undefined, undefined, f.createCallExpression(b.accessor, undefined, [f.createIdentifier('t')])),
+        ], ts.NodeFlags.Const)));
+        // DOM write expression
+        const domWrite = b.kind === 'text'
+            ? f.createBinaryExpression(f.createPropertyAccessExpression(nodeProp, 'nodeValue'), ts.SyntaxKind.EqualsToken, vId)
+            : b.kind === 'class'
+                ? f.createBinaryExpression(f.createPropertyAccessExpression(nodeProp, 'className'), ts.SyntaxKind.EqualsToken, vId)
+                : f.createBinaryExpression(f.createPropertyAccessExpression(nodeProp, 'nodeValue'), ts.SyntaxKind.EqualsToken, vId);
+        // if (v{i} !== e['_v{i}']) { e['_v{i}'] = v{i}; DOM_WRITE }
+        updStmts.push(f.createIfStatement(f.createBinaryExpression(vId, ts.SyntaxKind.ExclamationEqualsEqualsToken, cachedProp), f.createBlock([
+            f.createExpressionStatement(f.createBinaryExpression(cachedProp, ts.SyntaxKind.EqualsToken, vId)),
+            f.createExpressionStatement(domWrite),
+        ], true)));
+    }
+    // Wrap __rowUpd in IIFE that declares selectors (they're scoped to the
+    // render body but __rowUpd lives on the options object outside render).
+    const rawUpdFn = f.createArrowFunction(undefined, undefined, [f.createParameterDeclaration(undefined, undefined, 'e')], undefined, f.createToken(ts.SyntaxKind.EqualsGreaterThanToken), f.createBlock(updStmts, true));
+    // Build: (() => { const __s0 = ...; const __s1 = ...; return (e) => { ... } })()
+    const selectorDecls = [];
+    for (const [name, init] of selectorDefs) {
+        selectorDecls.push(f.createVariableStatement(undefined, f.createVariableDeclarationList([f.createVariableDeclaration(name, undefined, undefined, init)], ts.NodeFlags.Const)));
+    }
+    selectorDecls.push(f.createReturnStatement(rawUpdFn));
+    const rowUpdFn = f.createCallExpression(f.createParenthesizedExpression(f.createArrowFunction(undefined, undefined, [], undefined, f.createToken(ts.SyntaxKind.EqualsGreaterThanToken), f.createBlock(selectorDecls, true))), undefined, []);
+    // 3. New render callback: ({ entry: e, __tpl, __rowUpd }) => { ... }
+    const renderStmts = [];
+    // Declare selectors at the top of render body (they're used for initial values)
+    for (const [name, init] of selectorDefs) {
+        renderStmts.push(f.createVariableStatement(undefined, f.createVariableDeclarationList([f.createVariableDeclaration(name, undefined, undefined, init)], ts.NodeFlags.Const)));
+    }
+    // const r = __tpl.content.firstElementChild.cloneNode(true)
+    renderStmts.push(f.createVariableStatement(undefined, f.createVariableDeclarationList([
+        f.createVariableDeclaration('r', undefined, undefined, f.createCallExpression(f.createPropertyAccessExpression(f.createPropertyAccessExpression(f.createPropertyAccessExpression(f.createIdentifier('__tpl'), 'content'), 'firstElementChild'), 'cloneNode'), undefined, [f.createTrue()])),
+    ], ts.NodeFlags.Const)));
+    // For each binding: store node ref, compute initial, apply
+    for (let i = 0; i < bindings.length; i++) {
+        const b = bindings[i];
+        const nProp = f.createElementAccessExpression(f.createIdentifier('e'), f.createStringLiteral(`_n${i}`));
+        const vProp = f.createElementAccessExpression(f.createIdentifier('e'), f.createStringLiteral(`_v${i}`));
+        // Rewrite node path: replace root param name with 'r'
+        const rewrittenPath = rewriteRoot(b.nodeInitializer, rootName, 'r', f);
+        // e['_n{i}'] = rewrittenPath
+        renderStmts.push(f.createExpressionStatement(f.createBinaryExpression(nProp, ts.SyntaxKind.EqualsToken, rewrittenPath)));
+        // e['_v{i}'] = accessor(e.current)
+        renderStmts.push(f.createExpressionStatement(f.createBinaryExpression(vProp, ts.SyntaxKind.EqualsToken, f.createCallExpression(b.accessor, undefined, [
+            f.createPropertyAccessExpression(f.createIdentifier('e'), 'current'),
+        ]))));
+        // DOM write: e['_n{i}'].nodeValue = e['_v{i}']
+        const initWrite = b.kind === 'text'
+            ? f.createBinaryExpression(f.createPropertyAccessExpression(nProp, 'nodeValue'), ts.SyntaxKind.EqualsToken, vProp)
+            : b.kind === 'class'
+                ? f.createBinaryExpression(f.createPropertyAccessExpression(nProp, 'className'), ts.SyntaxKind.EqualsToken, vProp)
+                : f.createBinaryExpression(f.createPropertyAccessExpression(nProp, 'nodeValue'), ts.SyntaxKind.EqualsToken, vProp);
+        renderStmts.push(f.createExpressionStatement(initWrite));
+    }
+    // e.__rowUpdate = __rowUpd
+    renderStmts.push(f.createExpressionStatement(f.createBinaryExpression(f.createPropertyAccessExpression(f.createIdentifier('e'), '__rowUpdate'), ts.SyntaxKind.EqualsToken, f.createIdentifier('__rowUpd'))));
+    // Rewrite a statement: replace __a{N}() → __s{N}(e.current),
+    // replace template var → r, strip positions via deep clone.
+    function rewriteStmt(stmt) {
+        function visit(node) {
+            // Rewrite __a{N}() → __s{N}(e.current)
+            if (ts.isCallExpression(node) &&
+                ts.isIdentifier(node.expression) &&
+                accToSelector.has(node.expression.text) &&
+                node.arguments.length === 0) {
+                const selectorName = accToSelector.get(node.expression.text);
+                return f.createCallExpression(f.createIdentifier(selectorName), undefined, [
+                    f.createPropertyAccessExpression(f.createIdentifier('e'), 'current'),
+                ]);
+            }
+            // Rewrite template variable → r
+            if (ts.isIdentifier(node) && templateVarName && node.text === templateVarName) {
+                return f.createIdentifier('r');
+            }
+            // Clone identifiers to strip positions
+            if (ts.isIdentifier(node)) {
+                return f.createIdentifier(node.text);
+            }
+            return ts.visitEachChild(node, visit, undefined);
+        }
+        return ts.visitEachChild(stmt, visit, undefined);
+    }
+    // Preserve non-template, non-compiler-generated, non-return statements.
+    for (const stmt of body.statements) {
+        if (ts.isReturnStatement(stmt))
+            continue;
+        if (ts.isVariableStatement(stmt)) {
+            // Skip template declaration
+            const isTemplate = stmt.declarationList.declarations.some((d) => ts.isIdentifier(d.name) && d.name.text === templateVarName);
+            if (isTemplate)
+                continue;
+            // Skip __a{N} and __s{N} declarations (compiler-generated acc/selector)
+            const isCompilerOnly = stmt.declarationList.declarations.every((d) => ts.isIdentifier(d.name) &&
+                (d.name.text.startsWith('__a') || d.name.text.startsWith('__s')));
+            if (isCompilerOnly)
+                continue;
+        }
+        // Rewrite and include
+        renderStmts.push(rewriteStmt(stmt));
+    }
+    // return [r]
+    renderStmts.push(f.createReturnStatement(f.createArrayLiteralExpression([f.createIdentifier('r')])));
+    const newRenderFn = f.createArrowFunction(undefined, undefined, [
+        f.createParameterDeclaration(undefined, undefined, f.createObjectBindingPattern([
+            f.createBindingElement(undefined, 'entry', 'e'),
+            f.createBindingElement(undefined, undefined, '__tpl'),
+            f.createBindingElement(undefined, undefined, '__rowUpd'),
+        ])),
+    ], undefined, f.createToken(ts.SyntaxKind.EqualsGreaterThanToken), f.createBlock(renderStmts, true));
+    // 4. Build new each options. To avoid mixed-position AST issues, we keep
+    // original properties unchanged and only ADD __tpl, __rowUpd, and replace render.
+    // The trick: return the original node structure but with the render property
+    // swapped. Use ts.factory.updateObjectLiteralExpression which preserves positions.
+    const updatedProps = arg.properties.map((p) => p === renderProp ? f.createPropertyAssignment('render', newRenderFn) : p);
+    updatedProps.push(f.createPropertyAssignment('__tpl', tplInit));
+    updatedProps.push(f.createPropertyAssignment('__rowUpd', rowUpdFn));
+    const newOpts = f.updateObjectLiteralExpression(arg, updatedProps);
+    return f.updateCallExpression(eachCall, eachCall.expression, eachCall.typeArguments, [
+        newOpts,
+        ...eachCall.arguments.slice(1),
+    ]);
+}
+function _containsSelectorBind(node) {
+    if (ts.isCallExpression(node) &&
+        ts.isPropertyAccessExpression(node.expression) &&
+        node.expression.name.text === 'bind') {
+        return true;
+    }
+    return ts.forEachChild(node, _containsSelectorBind) ?? false;
+}
+function containsStructuralCall(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+        if (['each', 'branch', 'show', 'child', 'foreign'].includes(node.expression.text))
+            return true;
+    }
+    return ts.forEachChild(node, containsStructuralCall) ?? false;
+}
+/** Rewrite property access chains replacing oldRoot identifier with newRoot */
+function rewriteRoot(expr, oldRoot, newRoot, f) {
+    if (ts.isIdentifier(expr) && expr.text === oldRoot)
+        return f.createIdentifier(newRoot);
+    if (ts.isPropertyAccessExpression(expr)) {
+        return f.createPropertyAccessExpression(rewriteRoot(expr.expression, oldRoot, newRoot, f), expr.name.text);
+    }
+    if (ts.isElementAccessExpression(expr)) {
+        return f.createElementAccessExpression(rewriteRoot(expr.expression, oldRoot, newRoot, f), expr.argumentExpression);
+    }
+    return expr;
+}
+/** Parse a statement string into a fresh AST node (no source positions) */
+function _parseStmt(code) {
+    const sf = ts.createSourceFile('__gen.ts', code, ts.ScriptTarget.Latest, false);
+    return sf.statements[0] ?? null;
+}
+/**
+ * Compute the OR of all structural block masks found in the view function.
+ * Returns FULL_MASK if any structural block uses FULL_MASK or if no blocks found.
+ */
+function computeStructuralMask(configArg, fieldBits) {
+    const viewProp = configArg.properties.find((p) => ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === 'view');
+    if (!viewProp || !ts.isPropertyAssignment(viewProp))
+        return 0xffffffff | 0;
+    let mask = 0;
+    let foundStructural = false;
+    function walk(node) {
+        if (ts.isCallExpression(node)) {
+            const name = ts.isIdentifier(node.expression) ? node.expression.text : '';
+            if (['each', 'branch', 'show'].includes(name) && node.arguments[0]) {
+                foundStructural = true;
+                const opts = node.arguments[0];
+                if (ts.isObjectLiteralExpression(opts)) {
+                    // Check for __mask property (already injected by tryInjectStructuralMask)
+                    for (const prop of opts.properties) {
+                        if (ts.isPropertyAssignment(prop) &&
+                            ts.isIdentifier(prop.name) &&
+                            prop.name.text === '__mask') {
+                            if (ts.isNumericLiteral(prop.initializer)) {
+                                mask |= parseInt(prop.initializer.text, 10);
+                                return;
+                            }
+                            if (ts.isPrefixUnaryExpression(prop.initializer)) {
+                                // Handle negative literals like -1
+                                mask = 0xffffffff | 0;
+                                return;
+                            }
+                        }
+                    }
+                    // No __mask found — use driving accessor mask
+                    const driverProp = name === 'each' ? 'items' : name === 'branch' ? 'on' : 'when';
+                    for (const prop of opts.properties) {
+                        if (ts.isPropertyAssignment(prop) &&
+                            ts.isIdentifier(prop.name) &&
+                            prop.name.text === driverProp) {
+                            if (ts.isArrowFunction(prop.initializer) ||
+                                ts.isFunctionExpression(prop.initializer)) {
+                                const { mask: m } = computeAccessorMask(prop.initializer, fieldBits);
+                                mask |= m || 0xffffffff | 0;
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, walk);
+    }
+    walk(viewProp.initializer);
+    return foundStructural ? mask || 0xffffffff | 0 : 0;
+}
+/**
+ * Compute the OR of all component-level binding masks from text() calls
+ * and element bindings in the view. Returns 0 if no component-level bindings.
+ */
+function computePhase2Mask(_configArg, _fieldBits) {
+    // For now, return FULL_MASK — a future pass can analyze all binding sites
+    // in the view to compute the precise aggregate. The key optimization is
+    // already in Phase 1 gating: when structuralMask doesn't intersect dirty,
+    // the entire reconciliation is skipped.
+    return 0xffffffff | 0;
+}
+/**
+ * Build the __update function body:
+ * {
+ *   // Phase 1 — structural reconciliation (gated by structuralMask)
+ *   if (d & structuralMask) {
+ *     for (let i = 0, len = bl.length; i < len; i++) {
+ *       const block = bl[i]
+ *       if ((block.mask & d) === 0) continue
+ *       block.reconcile(s, d)
+ *     }
+ *     // Compact dead bindings
+ *     if (b.length > p || (p > 0 && b[0].dead)) {
+ *       let w = 0
+ *       for (let r = 0; r < b.length; r++) { if (!b[r].dead) b[w++] = b[r] }
+ *       b.length = w
+ *       p = Math.min(w, p)
+ *     }
+ *   }
+ *   // Phase 2 — binding updates
+ *   if (d !== 0) {
+ *     for (let i = 0; i < p; i++) {
+ *       const bn = b[i]
+ *       if (bn.dead || (bn.mask & d) === 0) continue
+ *       const v = bn.accessor(s)
+ *       const l = bn.lastValue
+ *       if (v === l || (v !== v && l !== l)) continue
+ *       bn.lastValue = v
+ *       __runPhase2(s, d, b, p)
+ *     }
+ *   }
+ * }
+ */
+function buildUpdateBody(f, structuralMask, _phase2Mask) {
+    const stmts = [];
+    // Phase 1: structural block reconciliation, gated by aggregate mask
+    if (structuralMask !== 0) {
+        const phase1Stmts = [];
+        // for (let i = 0, len = bl.length; i < len; i++) {
+        //   const block = bl[i]; if ((block.mask & d) === 0) continue; block.reconcile(s, d)
+        // }
+        const blockLoop = f.createForStatement(f.createVariableDeclarationList([
+            f.createVariableDeclaration('i', undefined, undefined, f.createNumericLiteral(0)),
+            f.createVariableDeclaration('len', undefined, undefined, f.createPropertyAccessExpression(f.createIdentifier('bl'), 'length')),
+        ], ts.NodeFlags.Let), f.createBinaryExpression(f.createIdentifier('i'), ts.SyntaxKind.LessThanToken, f.createIdentifier('len')), f.createPostfixUnaryExpression(f.createIdentifier('i'), ts.SyntaxKind.PlusPlusToken), f.createBlock([
+            f.createVariableStatement(undefined, f.createVariableDeclarationList([
+                f.createVariableDeclaration('bk', undefined, undefined, f.createElementAccessExpression(f.createIdentifier('bl'), f.createIdentifier('i'))),
+            ], ts.NodeFlags.Const)),
+            f.createIfStatement(f.createBinaryExpression(f.createParenthesizedExpression(f.createBinaryExpression(f.createPropertyAccessExpression(f.createIdentifier('bk'), 'mask'), ts.SyntaxKind.AmpersandToken, f.createIdentifier('d'))), ts.SyntaxKind.EqualsEqualsEqualsToken, f.createNumericLiteral(0)), f.createContinueStatement()),
+            f.createExpressionStatement(f.createCallExpression(f.createPropertyAccessExpression(f.createIdentifier('bk'), 'reconcile'), undefined, [f.createIdentifier('s'), f.createIdentifier('d')])),
+        ], true));
+        phase1Stmts.push(blockLoop);
+        // Compaction: if (b.length > p || (p > 0 && b[0].dead)) { ... }
+        const compactBody = f.createBlock([
+            // let w = 0
+            f.createVariableStatement(undefined, f.createVariableDeclarationList([f.createVariableDeclaration('w', undefined, undefined, f.createNumericLiteral(0))], ts.NodeFlags.Let)),
+            // for (let r = 0; r < b.length; r++) { if (!b[r].dead) b[w++] = b[r] }
+            f.createForStatement(f.createVariableDeclarationList([f.createVariableDeclaration('r', undefined, undefined, f.createNumericLiteral(0))], ts.NodeFlags.Let), f.createBinaryExpression(f.createIdentifier('r'), ts.SyntaxKind.LessThanToken, f.createPropertyAccessExpression(f.createIdentifier('b'), 'length')), f.createPostfixUnaryExpression(f.createIdentifier('r'), ts.SyntaxKind.PlusPlusToken), f.createBlock([
+                f.createIfStatement(f.createPrefixUnaryExpression(ts.SyntaxKind.ExclamationToken, f.createPropertyAccessExpression(f.createElementAccessExpression(f.createIdentifier('b'), f.createIdentifier('r')), 'dead')), f.createExpressionStatement(f.createBinaryExpression(f.createElementAccessExpression(f.createIdentifier('b'), f.createPostfixUnaryExpression(f.createIdentifier('w'), ts.SyntaxKind.PlusPlusToken)), ts.SyntaxKind.EqualsToken, f.createElementAccessExpression(f.createIdentifier('b'), f.createIdentifier('r'))))),
+            ], true)),
+            // b.length = w
+            f.createExpressionStatement(f.createBinaryExpression(f.createPropertyAccessExpression(f.createIdentifier('b'), 'length'), ts.SyntaxKind.EqualsToken, f.createIdentifier('w'))),
+            // p = Math.min(w, p)
+            f.createExpressionStatement(f.createBinaryExpression(f.createIdentifier('p'), ts.SyntaxKind.EqualsToken, f.createCallExpression(f.createPropertyAccessExpression(f.createIdentifier('Math'), 'min'), undefined, [f.createIdentifier('w'), f.createIdentifier('p')]))),
+        ], true);
+        const compactCondition = f.createBinaryExpression(f.createBinaryExpression(f.createPropertyAccessExpression(f.createIdentifier('b'), 'length'), ts.SyntaxKind.GreaterThanToken, f.createIdentifier('p')), ts.SyntaxKind.BarBarToken, f.createParenthesizedExpression(f.createBinaryExpression(f.createBinaryExpression(f.createIdentifier('p'), ts.SyntaxKind.GreaterThanToken, f.createNumericLiteral(0)), ts.SyntaxKind.AmpersandAmpersandToken, f.createPropertyAccessExpression(f.createElementAccessExpression(f.createIdentifier('b'), f.createNumericLiteral(0)), 'dead'))));
+        phase1Stmts.push(f.createIfStatement(compactCondition, compactBody));
+        // Wrap Phase 1 in mask gate
+        if (structuralMask !== (0xffffffff | 0)) {
+            stmts.push(f.createIfStatement(f.createBinaryExpression(f.createParenthesizedExpression(f.createBinaryExpression(f.createIdentifier('d'), ts.SyntaxKind.AmpersandToken, createMaskLiteral(f, structuralMask))), ts.SyntaxKind.ExclamationEqualsEqualsToken, f.createNumericLiteral(0)), f.createBlock(phase1Stmts, true)));
+        }
+        else {
+            stmts.push(...phase1Stmts);
+        }
+    }
+    // Phase 2: delegate to shared runtime — __runPhase2(s, d, b, p)
+    stmts.push(f.createExpressionStatement(f.createCallExpression(f.createIdentifier('__runPhase2'), undefined, [
+        f.createIdentifier('s'),
+        f.createIdentifier('d'),
+        f.createIdentifier('b'),
+        f.createIdentifier('p'),
+    ])));
+    return f.createBlock(stmts, true);
+}
 function buildAccess(f, root, parts) {
     let expr = f.createIdentifier(root);
     for (const part of parts) {
@@ -823,8 +1801,8 @@ function buildAccess(f, root, parts) {
     return expr;
 }
 // ── Pass 3: Import cleanup ───────────────────────────────────────
-function cleanupImports(sf, lluiImport, _helpers, compiled, usesElSplit, usesElTemplate, usesMemo, f) {
-    if (compiled.size === 0 && !usesElTemplate && !usesElSplit && !usesMemo)
+function cleanupImports(sf, lluiImport, _helpers, compiled, usesElSplit, usesElTemplate, usesMemo, usesApplyBinding, f) {
+    if (compiled.size === 0 && !usesElTemplate && !usesElSplit && !usesMemo && !usesApplyBinding)
         return sf;
     const clause = lluiImport.importClause;
     if (!clause?.namedBindings || !ts.isNamedImports(clause.namedBindings))
@@ -842,6 +1820,14 @@ function cleanupImports(sf, lluiImport, _helpers, compiled, usesElSplit, usesElT
     if (!hasMemo && usesMemo) {
         remaining.push(f.createImportSpecifier(false, undefined, f.createIdentifier('memo')));
     }
+    if (usesApplyBinding) {
+        if (!clause.namedBindings.elements.some((s) => s.name.text === '__runPhase2')) {
+            remaining.push(f.createImportSpecifier(false, undefined, f.createIdentifier('__runPhase2')));
+        }
+        if (!clause.namedBindings.elements.some((s) => s.name.text === '__handleMsg')) {
+            remaining.push(f.createImportSpecifier(false, undefined, f.createIdentifier('__handleMsg')));
+        }
+    }
     const newBindings = f.createNamedImports(remaining);
     const newClause = f.createImportClause(false, undefined, newBindings);
     const newImportDecl = f.createImportDeclaration(undefined, newClause, lluiImport.moduleSpecifier);