From c009b582e2da398c6e229fab779b9354325fae96 Mon Sep 17 00:00:00 2001
From: Luis Alvarez D <luis@vercel.com>
Date: Thu, 22 Oct 2026 23:05:28 -0500
Subject: [PATCH 1/3] Support split CommonJS require bindings

---
 .../frontend/lowering/cjs-inline-require.ts   | 323 ++++++++++++++++++
 .../lowering/expressions/identifiers.ts       |  26 ++
 .../src/frontend/lowering/lower-modules.ts    |  24 +-
 .../src/frontend/lowering/lower-stmts.ts      |  52 +++
 .../compiler/src/frontend/lowering/lowerer.ts |  23 +-
 .../split-cjs-require-binding/main.cjs.json   |  12 +
 .../split-cjs-require-binding/chain-wrap.cjs  |   3 +
 .../split-cjs-require-binding/chain.cjs       |   1 +
 .../corpus/split-cjs-require-binding/lib.cjs  |   5 +
 .../corpus/split-cjs-require-binding/main.cjs |  55 +++
 .../split-cjs-require-binding/package.json    |   1 +
 .../reexport-extra.cjs                        |   6 +
 .../split-cjs-require-binding/reexport.cjs    |   4 +
 .../split-cjs-require-binding/whole.cjs       |   4 +
 .../split-cjs-require-binding/main.cjs.json   |   1 +
 15 files changed, 536 insertions(+), 4 deletions(-)
 create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/split-cjs-require-binding/main.cjs.json
 create mode 100644 tests/corpus/split-cjs-require-binding/chain-wrap.cjs
 create mode 100644 tests/corpus/split-cjs-require-binding/chain.cjs
 create mode 100644 tests/corpus/split-cjs-require-binding/lib.cjs
 create mode 100644 tests/corpus/split-cjs-require-binding/main.cjs
 create mode 100644 tests/corpus/split-cjs-require-binding/package.json
 create mode 100644 tests/corpus/split-cjs-require-binding/reexport-extra.cjs
 create mode 100644 tests/corpus/split-cjs-require-binding/reexport.cjs
 create mode 100644 tests/corpus/split-cjs-require-binding/whole.cjs
 create mode 100644 tests/harness/corpus-costs/split-cjs-require-binding/main.cjs.json

diff --git a/packages/compiler/src/frontend/lowering/cjs-inline-require.ts b/packages/compiler/src/frontend/lowering/cjs-inline-require.ts
index 2b28c6533..eb05550c0 100644
--- a/packages/compiler/src/frontend/lowering/cjs-inline-require.ts
+++ b/packages/compiler/src/frontend/lowering/cjs-inline-require.ts
@@ -28,6 +28,7 @@ import {
   isModuleExportsAccess,
   locOf,
   npmStaticDepSf7,
+  requireBindingEarlyUse7,
   requireSpecOf,
   resolveImport,
 } from "../program.js";
@@ -43,6 +44,328 @@ export interface InlineRequire {
   dep: ts.SourceFile;
 }
 
+/** A top-level `var m; m = require("./x")` binding. Node evaluates the
+ * require at the assignment; the binding is alias plumbing exactly like
+ * `const m = require("./x")` for every later read. */
+export interface SplitRequireBinding {
+  decl: ts.VariableDeclaration;
+  assign: ts.BinaryExpression;
+  call: ts.CallExpression;
+  spec: string;
+  dep: ts.SourceFile;
+}
+
+function symbolOfIdentifierValue(lowerer: Lowerer, ident: ts.Identifier): ts.Symbol | undefined {
+  const parent = ident.parent;
+  // A destructuring shorthand target resolves to the property symbol at
+  // the name, but reads/writes the variable through its value symbol.
+  if (ts.isShorthandPropertyAssignment(parent) && parent.name === ident) {
+    return (
+      lowerer.checker.getShorthandAssignmentValueSymbol(parent) ??
+      lowerer.checker.getSymbolAtLocation(ident)
+    );
+  }
+  return lowerer.checker.getSymbolAtLocation(ident);
+}
+
+function destructuringContainerOf(node: ts.Node): ts.Node | null {
+  const parent = node.parent;
+  if (ts.isShorthandPropertyAssignment(parent) && parent.name === node) return parent;
+  if (ts.isPropertyAssignment(parent) && parent.initializer === node) return parent;
+  if (ts.isSpreadElement(parent) && parent.expression === node) return parent;
+  if (ts.isSpreadAssignment(parent) && parent.expression === node) return parent;
+  return null;
+}
+
+function writeTargetOf(node: ts.Node): ts.Node | null {
+  let target = node;
+  for (;;) {
+    const parent = target.parent;
+    if (
+      ts.isParenthesizedExpression(parent) ||
+      ts.isArrayLiteralExpression(parent) ||
+      ts.isObjectLiteralExpression(parent)
+    ) {
+      target = parent;
+      continue;
+    }
+    const container = destructuringContainerOf(target);
+    if (container === null) break;
+    target = container;
+  }
+  const parent = target.parent;
+  if (
+    ts.isBinaryExpression(parent) &&
+    parent.left === target &&
+    ts.isAssignmentOperator(parent.operatorToken.kind)
+  )
+    return parent;
+  if (
+    (ts.isPrefixUnaryExpression(parent) || ts.isPostfixUnaryExpression(parent)) &&
+    parent.operand === target &&
+    (parent.operator === ts.SyntaxKind.PlusPlusToken ||
+      parent.operator === ts.SyntaxKind.MinusMinusToken)
+  )
+    return parent;
+  if ((ts.isForInStatement(parent) || ts.isForOfStatement(parent)) && parent.initializer === target)
+    return parent;
+  return null;
+}
+
+/** The split form of a top-level require binding: `var m; m = require("./x")`.
+ * Exactly one write, at a top-level `m = require("<literal>")` statement.
+ * Null for the ordinary `const m = require("./x")` declaration and for
+ * every form that needs runtime module selection. */
+export function splitRequireBindingOf(
+  lowerer: Lowerer,
+  decl: ts.VariableDeclaration,
+): SplitRequireBinding | null {
+  // Cheap shape gate before the cache: ordinary declarations never enter the
+  // per-Lowerer map.
+  if (decl.initializer !== undefined || !ts.isIdentifier(decl.name)) return null;
+  const list = decl.parent as ts.VariableDeclarationList;
+  if ((list.flags & ts.NodeFlags.Const) !== 0) return null;
+  const stmt = list.parent;
+  if (!ts.isVariableStatement(stmt) || !ts.isSourceFile(stmt.parent)) return null;
+  const cached = lowerer.cjsSplitRequireBindings.get(decl);
+  if (cached !== undefined) return cached;
+  const result = computeSplitRequireBinding(lowerer, decl);
+  lowerer.cjsSplitRequireBindings.set(decl, result);
+  return result;
+}
+
+function computeSplitRequireBinding(
+  lowerer: Lowerer,
+  decl: ts.VariableDeclaration,
+): SplitRequireBinding | null {
+  const sf = ts.getSourceFileOfNode(decl);
+  if (!isCjsJsFile(sf, lowerer.program)) return null;
+  if (!sf.text.includes("require")) return null;
+  const symbol = lowerer.checker.getSymbolAtLocation(decl.name);
+  if (symbol === undefined) return null;
+  // Merged declarations make the binding's initialization order ambiguous;
+  // keep ordinary storage instead of guessing.
+  let declarations = 0;
+  for (const other of symbol.declarations) {
+    if (!ts.isVariableDeclaration(other) || ++declarations > 1) return null;
+  }
+  if (declarations !== 1) return null;
+
+  // Find the one top-level `m = ...` statement first: most uninitialized
+  // variables never reach that shape, so they avoid the full-file write scan.
+  let assign: ts.BinaryExpression | null = null;
+  for (const stmt of sf.statements.nodes) {
+    if (!ts.isExpressionStatement(stmt)) continue;
+    const expr = stmt.expression;
+    if (
+      !ts.isBinaryExpression(expr) ||
+      expr.operatorToken.kind !== ts.SyntaxKind.EqualsToken ||
+      !ts.isIdentifier(expr.left) ||
+      expr.left.text !== decl.name.text ||
+      lowerer.checker.getSymbolAtLocation(expr.left) !== symbol
+    )
+      continue;
+    if (assign !== null) return null;
+    assign = expr;
+  }
+  if (assign === null) return null;
+
+  const req = inlineProgramRequireOf(lowerer, assign.right);
+  if (req === null) return null;
+
+  // Any other write makes the value depend on runtime control flow.
+  let writes = 0;
+  ts.walkPreorder(sf, (node) => {
+    if (!ts.isIdentifier(node) || node.text !== decl.name.text) return;
+    if (symbolOfIdentifierValue(lowerer, node) !== symbol) return;
+    if (writeTargetOf(node) === null) return;
+    if (++writes > 1) return "stop";
+  });
+  if (writes !== 1) return null;
+
+  return { decl, assign, call: req.call, spec: req.spec, dep: req.dep };
+}
+
+/** The split binding an identifier names, or null. */
+export function splitRequireBindingOfIdent(
+  lowerer: Lowerer,
+  ident: ts.Identifier,
+): SplitRequireBinding | null {
+  const symbol = symbolOfIdentifierValue(lowerer, ident);
+  return symbol === undefined ? null : splitBindingOfSymbol(lowerer, symbol);
+}
+
+/** The exact top-level assignment statement that initializes `expr`, or null. */
+export function splitRequireAssignmentOf(
+  lowerer: Lowerer,
+  expr: ts.Expression,
+): SplitRequireBinding | null {
+  if (
+    !ts.isBinaryExpression(expr) ||
+    expr.operatorToken.kind !== ts.SyntaxKind.EqualsToken ||
+    !ts.isIdentifier(expr.left)
+  )
+    return null;
+  const bindingOfIdent = splitRequireBindingOfIdent(lowerer, expr.left);
+  return bindingOfIdent !== null && bindingOfIdent.assign === expr ? bindingOfIdent : null;
+}
+
+/** The whole-export symbol a module's `module.exports = <value>` names,
+ * or null when the module is a table. */
+export function wholeExportSymbolOfModule(lowerer: Lowerer, dep: ts.SourceFile): ts.Symbol | null {
+  const cached = lowerer.cjsWholeExportSymbols.get(dep);
+  if (cached !== undefined) return cached;
+  if (cjsNamespaceModule(lowerer, dep)) {
+    lowerer.cjsWholeExportSymbols.set(dep, null);
+    return null;
+  }
+  const moduleSymbol = lowerer.checker.getSymbolAtLocation(dep);
+  let symbol = moduleSymbol?.getExports()?.get("export=" as ts.__String);
+  if (symbol === undefined) {
+    lowerer.cjsWholeExportSymbols.set(dep, null);
+    return null;
+  }
+  if (symbol.flags & ts.SymbolFlags.Alias) symbol = lowerer.checker.getAliasedSymbol(symbol);
+  lowerer.cjsWholeExportSymbols.set(dep, symbol);
+  return symbol;
+}
+
+function splitBindingOfSymbol(lowerer: Lowerer, symbol: ts.Symbol): SplitRequireBinding | null {
+  const decl = symbol.declarations.find(ts.isVariableDeclaration);
+  return decl === undefined ? null : splitRequireBindingOf(lowerer, decl);
+}
+
+/** The target whole-export symbol behind a split-binding symbol. */
+function splitWholeExportSymbolOfSymbol(lowerer: Lowerer, symbol: ts.Symbol): ts.Symbol | null {
+  const binding = splitBindingOfSymbol(lowerer, symbol);
+  return binding === null ? null : wholeExportSymbolOfModule(lowerer, binding.dep);
+}
+
+/** True when a CommonJS module has a live member export (`exports.x` or
+ * `module.exports.x`) after all `module.exports =` replacements. Those
+ * members need a mutable whole-export root. */
+export function cjsHasLiveMemberExports(lowerer: Lowerer, sf: ts.SourceFile): boolean {
+  const cached = lowerer.cjsLiveMemberExports.get(sf);
+  if (cached !== undefined) return cached;
+  const stmts = sf.statements.nodes;
+  let lastTable = -1;
+  for (let i = 0; i < stmts.length; i++) {
+    if (cjsExportAssignmentOf(stmts[i]!)?.kind === "table") lastTable = i;
+  }
+  let live = false;
+  // Only members attached after the last replacement survive in Node.
+  if (lastTable >= 0) {
+    for (let i = lastTable + 1; i < stmts.length; i++) {
+      const stmt = stmts[i]!;
+      if (cjsExportAssignmentOf(stmt)?.kind === "member" && cjsExportDiscardReason(stmt) === null) {
+        live = true;
+        break;
+      }
+    }
+  }
+  lowerer.cjsLiveMemberExports.set(sf, live);
+  return live;
+}
+
+/** The wrapper's export= symbol when a split binding is re-exported whole
+ * (`module.exports = m`) and that assignment owns storage for later member
+ * writes. Importers must read the wrapper's storage, not the split
+ * binding's underlying value. */
+function splitWholeExportStorageSymbolOf(lowerer: Lowerer, symbol: ts.Symbol): ts.Symbol | null {
+  const binding = splitBindingOfSymbol(lowerer, symbol);
+  if (binding === null) return null;
+  if (wholeExportSymbolOfModule(lowerer, binding.dep) === null) return null;
+  const sf = ts.getSourceFileOfNode(binding.decl);
+  if (!cjsHasLiveMemberExports(lowerer, sf)) return null;
+  const whole = cjsWholeExportValueOf(sf);
+  if (whole === null) return null;
+  let rhs: ts.Expression = whole.rhs;
+  while (ts.isParenthesizedExpression(rhs)) rhs = rhs.expression;
+  if (!ts.isIdentifier(rhs) || lowerer.checker.getSymbolAtLocation(rhs) !== symbol) return null;
+  const moduleSymbol = lowerer.checker.getSymbolAtLocation(sf);
+  let exportSymbol = moduleSymbol?.getExports()?.get("export=" as ts.__String);
+  if (exportSymbol === undefined) return null;
+  if (exportSymbol.flags & ts.SymbolFlags.Alias)
+    exportSymbol = lowerer.checker.getAliasedSymbol(exportSymbol);
+  return exportSymbol;
+}
+
+/** The source file whose `module.exports =` assignment declares `symbol`. */
+function moduleExportSourceFileOf(symbol: ts.Symbol): ts.SourceFile | null {
+  for (const decl of symbol.declarations) {
+    if (
+      ts.isBinaryExpression(decl) &&
+      isModuleExportsAccess(decl.left) &&
+      ts.isExpressionStatement(decl.parent) &&
+      ts.isSourceFile(decl.parent.parent)
+    )
+      return decl.getSourceFile();
+  }
+  return null;
+}
+
+/** One hop from a wrapper's export= symbol to the value it re-exports
+ * (`module.exports = require(...)` or `= <split binding>`), or null. A
+ * wrapper with live members owns storage for them, so it is not followed. */
+function wholeReexportTargetOf(lowerer: Lowerer, symbol: ts.Symbol): ts.Symbol | null {
+  const sf = moduleExportSourceFileOf(symbol);
+  if (sf === null) return null;
+  // A wrapper with live members owns storage for them; importers must keep
+  // reading that root rather than the inner value.
+  if (cjsHasLiveMemberExports(lowerer, sf)) return null;
+  const whole = cjsWholeExportValueOf(sf);
+  if (whole === null) return null;
+  const inner = inlineProgramRequireOf(lowerer, whole.rhs);
+  if (inner !== null) return wholeExportSymbolOfModule(lowerer, inner.dep);
+  let rhs: ts.Expression = whole.rhs;
+  while (ts.isParenthesizedExpression(rhs)) rhs = rhs.expression;
+  if (!ts.isIdentifier(rhs)) return null;
+  const rhsSymbol = lowerer.checker.getSymbolAtLocation(rhs);
+  return rhsSymbol === undefined ? null : splitWholeExportSymbolOfSymbol(lowerer, rhsSymbol);
+}
+
+/** Follow split bindings and whole re-exports to the ultimate value symbol. */
+function followSplitWholeTarget(lowerer: Lowerer, candidate: ts.Symbol | null): ts.Symbol | null {
+  if (candidate === null) return null;
+  let symbol = candidate;
+  const seen = new Set<ts.Symbol>();
+  for (let depth = 0; depth < 32 && !seen.has(symbol); depth++) {
+    seen.add(symbol);
+    const next =
+      splitWholeExportSymbolOfSymbol(lowerer, symbol) ?? wholeReexportTargetOf(lowerer, symbol);
+    if (next === null) break;
+    symbol = next;
+  }
+  return symbol;
+}
+
+/** The target whole-export symbol behind `module.exports = <split binding>`,
+ * letting importers of that wrapper resolve to the real value symbol. */
+export function splitWholeExportAliasTargetOf(
+  lowerer: Lowerer,
+  symbol: ts.Symbol,
+): ts.Symbol | null {
+  const storage = splitWholeExportStorageSymbolOf(lowerer, symbol);
+  if (storage !== null) return followSplitWholeTarget(lowerer, storage);
+  const direct = followSplitWholeTarget(lowerer, splitWholeExportSymbolOfSymbol(lowerer, symbol));
+  if (direct !== null) return direct;
+  return followSplitWholeTarget(lowerer, wholeReexportTargetOf(lowerer, symbol));
+}
+
+/** The first read of a split binding that code before its assignment can
+ * reach, using the same reachability model as ordinary require bindings. */
+export function splitRequireEarlyReadOf(
+  lowerer: Lowerer,
+  binding: SplitRequireBinding,
+): ts.Identifier | null {
+  const sf = ts.getSourceFileOfNode(binding.decl);
+  const stmt = binding.assign.parent;
+  // `binding` was recognized only from a top-level `m = require(...)`
+  // statement, so the statement index is always present.
+  const index = sf.statements.nodes.indexOf(stmt as ts.ExpressionStatement);
+  return requireBindingEarlyUse7(lowerer.program, sf, index, binding.decl, []);
+}
+
 /** A `require("<literal>")` call of the CommonJS global in a CommonJS JS
  * file whose target is a compiled program module (relative, aliased, or an
  * opted-in --npm-static package). Builtins, JSON documents and
diff --git a/packages/compiler/src/frontend/lowering/expressions/identifiers.ts b/packages/compiler/src/frontend/lowering/expressions/identifiers.ts
index b5f99d682..d032cb263 100644
--- a/packages/compiler/src/frontend/lowering/expressions/identifiers.ts
+++ b/packages/compiler/src/frontend/lowering/expressions/identifiers.ts
@@ -22,6 +22,11 @@ import {
 } from "../../../ir/ir.js";
 import { lowerNodeModuleIdentifier } from "../lower-node-module.js";
 import { lowerCjsExportsObjectValue } from "../cjs-exports-object.js";
+import {
+  splitRequireBindingOfIdent,
+  wholeExportSymbolOfModule,
+  wholeExportValue,
+} from "../cjs-inline-require.js";
 import { captureContextArguments } from "../function-context.js";
 import { argumentsOwner, typedArgumentsCandidate } from "../typed-arguments.js";
 import {
@@ -920,6 +925,27 @@ export function lowerIdentifierExpr(lowerer: Lowerer, expr: ts.Identifier, loc:
   // Client`): the member holds that binding's value.
   const memberAlias = cjsMemberAliasValueOf(lowerer, expr);
   if (memberAlias !== null) return lowerer.lowerExpr(memberAlias);
+  // `var m; m = require("./x")` as a bare value: a whole-export target is
+  // the exported value; a table target has no first-class module object.
+  {
+    const split = splitRequireBindingOfIdent(lowerer, expr);
+    if (split !== null) {
+      if (wholeExportSymbolOfModule(lowerer, split.dep) !== null) {
+        const value = wholeExportValue(lowerer, split.dep, expr);
+        if (value !== null) return value;
+        lowerer.unsupported(
+          "SC1090",
+          expr,
+          `the whole export of '${split.spec}' as a value (its 'module.exports =' value has no static representation)`,
+        );
+      }
+      lowerer.unsupported(
+        "SC1090",
+        expr,
+        `the exports object of '${split.spec}' as a value (its exports compile to a static table: read require(${JSON.stringify(split.spec)}).member directly)`,
+      );
+    }
+  }
   // Preflight guarantees no unresolved identifiers; anything else here
   // is a blocked declaration's binding (the SC2004 cascade) or a
   // binding form we don't model yet.
diff --git a/packages/compiler/src/frontend/lowering/lower-modules.ts b/packages/compiler/src/frontend/lowering/lower-modules.ts
index 6ca21ddaa..a86decf4c 100644
--- a/packages/compiler/src/frontend/lowering/lower-modules.ts
+++ b/packages/compiler/src/frontend/lowering/lower-modules.ts
@@ -42,10 +42,14 @@ import {
 } from "./cycle-initialization.js";
 import { markRequireEarlyBindings } from "./require-initialization.js";
 import {
+  cjsHasLiveMemberExports,
   cjsTableMethodEntry,
   inlineProgramRequireOf,
   nestedCjsExportAssignmentsOf,
   requireNestedPatternsOf,
+  splitRequireBindingOf,
+  splitRequireBindingOfIdent,
+  wholeExportSymbolOfModule,
 } from "./cjs-inline-require.js";
 import { isDeadTscHelperDecl, tscInteropBindingOfDecl } from "./cjs-tsc-interop.js";
 import { collectJsonRequires, isJsonRequireDecl } from "./json-require.js";
@@ -1588,14 +1592,26 @@ export function collectGlobals(
         // require() of a program module is not: the exporter re-exports
         // that module's exports, which requirers resolve through the
         // checker's alias (the statement lowers to the dep's %init).
+        // A split binding re-exported whole with later member writes needs
+        // a mutable root: `module.exports = m; module.exports.extra = 1`
+        // extends the SAME object Node exposes. Without later members the
+        // binder is pure alias plumbing (no storage).
+        const splitWholeBinding = ts.isIdentifier(rhs)
+          ? splitRequireBindingOfIdent(lowerer, rhs)
+          : null;
+        const hasMemberExports = cjsHasLiveMemberExports(lowerer, sf);
+        const splitWhole =
+          splitWholeBinding !== null &&
+          wholeExportSymbolOfModule(lowerer, splitWholeBinding.dep) !== null &&
+          hasMemberExports;
         const factoryValued =
-          !ts.isIdentifier(rhs) &&
+          (!ts.isIdentifier(rhs) || splitWhole) &&
           !ts.isClassExpression(rhs) &&
           !ts.isObjectLiteralExpression(rhs) &&
           !(
             requireSpecOf(rhs) !== null &&
             inlineProgramRequireOf(lowerer, rhs) !== null &&
-            !sf.statements.nodes.some((s) => cjsExportAssignmentOf(s)?.kind === "member")
+            !hasMemberExports
           ) &&
           cjsExportTargetLiteral(rhs, sf) === null;
         if (cjsScalarLiteral(rhs) || fnValued || factoryValued) {
@@ -1608,6 +1624,9 @@ export function collectGlobals(
             // A returned object remains the live CommonJS root; later
             // exports.member writes must update that same open object.
             if (factoryValued && t?.kind === "record" && lowerer.dynConvertible(t)) t = DYN;
+            // A split whole-export root is extended by later member writes;
+            // keep it checked-dynamic so those writes reach the same object.
+            if (splitWhole && t && t.kind !== "dyn") t = DYN;
             if (t && t.kind !== "void") {
               const g: IrGlobal = {
                 id: `%g.${tag}exports`,
@@ -2699,6 +2718,7 @@ function noteVarGlobalEntryInit(lowerer: Lowerer, sf: ts.SourceFile, g: IrGlobal
  * plumbing (lowerVarDeclarator): no storage, the reads resolve through to
  * the module. JSON documents and native FFI requires keep their storage. */
 function requireAliasDecl(lowerer: Lowerer, decl: ts.VariableDeclaration): boolean {
+  if (splitRequireBindingOf(lowerer, decl) !== null) return true;
   return (
     decl.initializer !== undefined &&
     requireSpecOf(decl.initializer) !== null &&
diff --git a/packages/compiler/src/frontend/lowering/lower-stmts.ts b/packages/compiler/src/frontend/lowering/lower-stmts.ts
index b04ba0b09..d10d3b9d2 100644
--- a/packages/compiler/src/frontend/lowering/lower-stmts.ts
+++ b/packages/compiler/src/frontend/lowering/lower-stmts.ts
@@ -36,6 +36,11 @@ import {
   cjsTableMethodEntry,
   inlineProgramRequireOf,
   requireNestedPatternsOf,
+  splitRequireAssignmentOf,
+  splitRequireBindingOf,
+  splitRequireBindingOfIdent,
+  splitRequireEarlyReadOf,
+  wholeExportSymbolOfModule,
 } from "./cjs-inline-require.js";
 import {
   cjsExportMemberWriteGlobalOf,
@@ -1811,6 +1816,23 @@ function lowerVarDeclarator(
   isConst: boolean,
   isLet: boolean,
 ): IrStmt[] {
+  // `var m; m = require("./x")`: the declaration is alias plumbing; the
+  // assignment owns the module's run-once %init (cjs-inline-require.ts).
+  // A read that code before the assignment can reach keeps Node's hoisted
+  // `undefined` divergence visible at build time, like a var require
+  // declaration below runnable code.
+  const split = splitRequireBindingOf(lowerer, decl);
+  if (split !== null) {
+    const early = splitRequireEarlyReadOf(lowerer, split);
+    if (early !== null) {
+      lowerer.unsupported(
+        "SC1013",
+        early,
+        `var require() binding '${(decl.name as ts.Identifier).text}' below code that can reach it (Node reads undefined before the require runs, which is not modeled — assign the require above the code that can run first)`,
+      );
+    }
+    return [];
+  }
   // The canonical ESM bridge to a compiled program module. Like a
   // top-level CommonJS require declaration, the binding is alias
   // plumbing while the dependency evaluates at this statement's
@@ -7015,6 +7037,26 @@ function lowerCjsSingleValueExport(
       return lowerer.requireInitStmt(req.spec, req.call) ?? { kind: "block", body: [], loc };
   }
   if (ts.isIdentifier(rhs)) {
+    const split = splitRequireBindingOfIdent(lowerer, rhs);
+    if (split !== null) {
+      if (wholeExportSymbolOfModule(lowerer, split.dep) === null) {
+        lowerer.unsupported(
+          "SC1090",
+          rhs,
+          `the exports object of '${split.spec}' as a value (its exports compile to a static table: read require(${JSON.stringify(split.spec)}).member directly)`,
+        );
+      }
+      const root = lowerer.globalsByDeclNode.get(expr);
+      if (root !== undefined) {
+        return {
+          kind: "assign",
+          localId: root.id,
+          value: lowerer.lowerExprExpecting(rhs, root.type),
+          loc: locOf(rhs),
+        };
+      }
+      return { kind: "block", body: [], loc };
+    }
     const sym = lowerer.resolveValueSymbol(rhs);
     if (!sym) return null;
     if (
@@ -7924,6 +7966,16 @@ export function lowerExprStatement(lowerer: Lowerer, expr: ts.Expression): IrStm
       if (!ts.isIdentifier(expr.left)) {
         lowerer.unsupported("SC1090", expr.left, "assignment to non-variables");
       }
+      const splitAssign = splitRequireAssignmentOf(lowerer, expr);
+      if (splitAssign !== null) {
+        return (
+          lowerer.requireInitStmt(splitAssign.spec, splitAssign.call) ?? {
+            kind: "block",
+            body: [],
+            loc: locOf(expr),
+          }
+        );
+      }
       const target = lowerer.resolveWritable(expr.left);
       if (!target)
         lowerer.rejectUnresolved(
diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts
index c4d24cef1..f1e7606f2 100644
--- a/packages/compiler/src/frontend/lowering/lowerer.ts
+++ b/packages/compiler/src/frontend/lowering/lowerer.ts
@@ -331,10 +331,13 @@ import {
 } from "./lower-modules.js";
 import { prepareCjsModuleGraph, usesCjsTopLevelThis } from "./lower-node-module.js";
 import {
+  type SplitRequireBinding,
   cjsNamespaceModule,
   cjsWholeExportValueOf,
   inlineNamespaceRequireOf,
   inlineProgramRequireOf,
+  splitRequireBindingOf,
+  splitWholeExportAliasTargetOf,
 } from "./cjs-inline-require.js";
 import { tscInteropModuleOf } from "./cjs-tsc-interop.js";
 import { usesCjsExportsIdentity } from "./cjs-exports-object.js";
@@ -2176,6 +2179,14 @@ export class Lowerer {
   /** Per CommonJS file using top-level `this`: the global holding the
    * object that stands for its original exports (lowerCjsTopLevelThis). */
   readonly cjsExportsThis = new Map<ts.SourceFile, IrGlobal>();
+  /** `var m; m = require("./x")` alias bindings (cjs-inline-require.ts).
+   * Null entries cache declarations that keep ordinary storage. */
+  readonly cjsSplitRequireBindings = new Map<ts.VariableDeclaration, SplitRequireBinding | null>();
+  /** Per-module whole-export symbol (cjs-inline-require.ts). Null means the
+   * module's exports are a table. */
+  readonly cjsWholeExportSymbols = new Map<ts.SourceFile, ts.Symbol | null>();
+  /** Per-module live member-export classification (cjs-inline-require.ts). */
+  readonly cjsLiveMemberExports = new Map<ts.SourceFile, boolean>();
   /** Inline program-module require calls whose %init the enclosing member
    * read or member call is already sequencing (cjs-inline-require.ts). */
   readonly inlineRequireInitDone = new Set<ts.CallExpression>();
@@ -3711,6 +3722,11 @@ export class Lowerer {
     // registry (globals, fn signatures, classes) applies unchanged.
     const cjsValue = this.cjsExportValueSymbol(symbol);
     if (cjsValue) symbol = cjsValue;
+    // `var m; m = require("./x"); module.exports = m` over a whole-export
+    // target: TS types the wrapper's export= as `any`, so reconnect it to
+    // the target's value symbol explicitly.
+    const splitAlias = splitWholeExportAliasTargetOf(this, symbol);
+    if (splitAlias) symbol = splitAlias;
     this.flushDeferred(symbol);
     return symbol;
   }
@@ -4104,8 +4120,8 @@ export class Lowerer {
     const decl = decls.find(ts.isImportClause) ?? decls[0];
     if (!decl) return null;
     if (ts.isImportClause(decl)) return this.cjsDefaultImportDepOf(decl);
-    if (!ts.isVariableDeclaration(decl) || !ts.isIdentifier(decl.name) || !decl.initializer)
-      return null;
+    if (!ts.isVariableDeclaration(decl) || !ts.isIdentifier(decl.name)) return null;
+    if (decl.initializer === undefined) return splitRequireBindingOf(this, decl)?.dep ?? null;
     {
       const interop = tscInteropModuleOf(this, expr);
       if (interop !== null) return cjsNamespaceModule(this, interop.dep) ? interop.dep : null;
@@ -4210,6 +4226,9 @@ export class Lowerer {
     // a binding (cjs-inline-require.ts sequences the module's %init).
     if (!ts.isIdentifier(expr)) return this.cjsModuleRefDepOf(expr) !== null;
     const sym = this.checker.getSymbolAtLocation(expr);
+    const splitDecl = sym?.declarations.find(ts.isVariableDeclaration);
+    const split = splitDecl === undefined ? null : splitRequireBindingOf(this, splitDecl);
+    if (split !== null) return cjsNamespaceModule(this, split.dep);
     if (this.localModuleBindingDepOf(expr) === null) return false;
     if (this.createRequireWholeExportSymbolOf(expr) !== null) return false;
     // SINGLE-VALUE exporters (`module.exports = Countdown` / `= double` /
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/split-cjs-require-binding/main.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/split-cjs-require-binding/main.cjs.json
new file mode 100644
index 000000000..c01617f80
--- /dev/null
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/split-cjs-require-binding/main.cjs.json
@@ -0,0 +1,12 @@
+{
+ "order": [
+  "<repo>/tests/corpus/split-cjs-require-binding/whole.cjs",
+  "<repo>/tests/corpus/split-cjs-require-binding/reexport.cjs",
+  "<repo>/tests/corpus/split-cjs-require-binding/reexport-extra.cjs",
+  "<repo>/tests/corpus/split-cjs-require-binding/lib.cjs",
+  "<repo>/tests/corpus/split-cjs-require-binding/chain.cjs",
+  "<repo>/tests/corpus/split-cjs-require-binding/chain-wrap.cjs",
+  "<repo>/tests/corpus/split-cjs-require-binding/main.cjs"
+ ],
+ "diags": []
+}
diff --git a/tests/corpus/split-cjs-require-binding/chain-wrap.cjs b/tests/corpus/split-cjs-require-binding/chain-wrap.cjs
new file mode 100644
index 000000000..435dcaeab
--- /dev/null
+++ b/tests/corpus/split-cjs-require-binding/chain-wrap.cjs
@@ -0,0 +1,3 @@
+var chained;
+chained = require("./chain.cjs");
+module.exports = chained;
diff --git a/tests/corpus/split-cjs-require-binding/chain.cjs b/tests/corpus/split-cjs-require-binding/chain.cjs
new file mode 100644
index 000000000..a279f456e
--- /dev/null
+++ b/tests/corpus/split-cjs-require-binding/chain.cjs
@@ -0,0 +1 @@
+module.exports = require("./whole.cjs");
diff --git a/tests/corpus/split-cjs-require-binding/lib.cjs b/tests/corpus/split-cjs-require-binding/lib.cjs
new file mode 100644
index 000000000..b318eb85c
--- /dev/null
+++ b/tests/corpus/split-cjs-require-binding/lib.cjs
@@ -0,0 +1,5 @@
+console.log("lib: init");
+exports.n = 7;
+exports.f = function (x) {
+  return x * 2;
+};
diff --git a/tests/corpus/split-cjs-require-binding/main.cjs b/tests/corpus/split-cjs-require-binding/main.cjs
new file mode 100644
index 000000000..974421bd3
--- /dev/null
+++ b/tests/corpus/split-cjs-require-binding/main.cjs
@@ -0,0 +1,55 @@
+console.log("main: start");
+var lib, whole;
+lib = require("./lib.cjs");
+whole = require("./whole.cjs");
+console.log("main: after", lib.n, lib.f(3), whole(4));
+exports.fromLib = lib.f;
+exports.whole = whole;
+console.log("main: exported", exports.fromLib(5), whole(6));
+console.log("main: identity", exports.fromLib === lib.f, exports.whole === whole);
+const re = require("./reexport.cjs");
+console.log("main: reexport", re(7));
+let later;
+later = require("./lib.cjs");
+console.log("main: let", later.n);
+const rx = require("./reexport-extra.cjs");
+console.log("main: reexport extra", rx(8), rx.extra);
+const splitObject = { whole };
+console.log("main: shorthand value", splitObject.whole(10));
+var libAgain;
+libAgain = require("./lib.cjs");
+const { n: splitN, f: splitF } = libAgain;
+console.log("main: destructured split", splitN, splitF(4));
+var chained;
+chained = require("./chain-wrap.cjs");
+console.log("main: chained", chained(11));
+
+// Any later write, including a destructuring target, keeps ordinary storage.
+var shorthand;
+shorthand = require("./whole.cjs");
+({ shorthand } = { shorthand: "shorthand" });
+console.log("main: shorthand write", shorthand);
+var renamed;
+renamed = require("./whole.cjs");
+({ value: renamed } = { value: "renamed" });
+console.log("main: renamed write", renamed);
+var nested;
+nested = require("./whole.cjs");
+({ a: { nested } } = { a: { nested: "nested" } });
+console.log("main: nested write", nested);
+var rest;
+rest = require("./whole.cjs");
+({ ...rest } = { a: 1, b: 2 });
+console.log("main: rest write", rest.a, rest.b);
+var array;
+array = require("./whole.cjs");
+[array] = ["array"];
+console.log("main: array write", array);
+var arrayRest;
+arrayRest = require("./whole.cjs");
+[...arrayRest] = [1, 2];
+console.log("main: array-rest write", arrayRest[0], arrayRest[1]);
+var each;
+each = require("./whole.cjs");
+for ({ each } of [{ each: "each" }]) {}
+console.log("main: for-of write", each);
diff --git a/tests/corpus/split-cjs-require-binding/package.json b/tests/corpus/split-cjs-require-binding/package.json
new file mode 100644
index 000000000..a3c15a7a6
--- /dev/null
+++ b/tests/corpus/split-cjs-require-binding/package.json
@@ -0,0 +1 @@
+{ "type": "commonjs" }
diff --git a/tests/corpus/split-cjs-require-binding/reexport-extra.cjs b/tests/corpus/split-cjs-require-binding/reexport-extra.cjs
new file mode 100644
index 000000000..584de98fe
--- /dev/null
+++ b/tests/corpus/split-cjs-require-binding/reexport-extra.cjs
@@ -0,0 +1,6 @@
+var whole;
+whole = require("./whole.cjs");
+console.log("extra: before", whole.extra, whole(9));
+module.exports = whole;
+module.exports.extra = 1;
+console.log("extra: after", whole.extra, module.exports.extra);
diff --git a/tests/corpus/split-cjs-require-binding/reexport.cjs b/tests/corpus/split-cjs-require-binding/reexport.cjs
new file mode 100644
index 000000000..9a931bdef
--- /dev/null
+++ b/tests/corpus/split-cjs-require-binding/reexport.cjs
@@ -0,0 +1,4 @@
+console.log("reexport: init");
+var whole;
+whole = require("./whole.cjs");
+module.exports = whole;
diff --git a/tests/corpus/split-cjs-require-binding/whole.cjs b/tests/corpus/split-cjs-require-binding/whole.cjs
new file mode 100644
index 000000000..31b476c4e
--- /dev/null
+++ b/tests/corpus/split-cjs-require-binding/whole.cjs
@@ -0,0 +1,4 @@
+console.log("whole: init");
+module.exports = function whole(x) {
+  return x + 1;
+};
diff --git a/tests/harness/corpus-costs/split-cjs-require-binding/main.cjs.json b/tests/harness/corpus-costs/split-cjs-require-binding/main.cjs.json
new file mode 100644
index 000000000..9d570f700
--- /dev/null
+++ b/tests/harness/corpus-costs/split-cjs-require-binding/main.cjs.json
@@ -0,0 +1 @@
+{ "plain": 1500, "san": 12000 }

From 70e6e9b59182af4fda8f40a48d4b923c963ba090 Mon Sep 17 00:00:00 2001
From: Luis Alvarez D <luis@vercel.com>
Date: Fri, 23 Oct 2026 11:40:15 -0500
Subject: [PATCH 2/3] Fence split requires that close a CommonJS cycle

---
 .../frontend/lowering/cjs-inline-require.ts   |  7 -----
 .../compiler/src/frontend/lowering/lowerer.ts |  7 +++++
 tests/harness/errors.test.ts                  | 30 +++++++++++++++++++
 3 files changed, 37 insertions(+), 7 deletions(-)

diff --git a/packages/compiler/src/frontend/lowering/cjs-inline-require.ts b/packages/compiler/src/frontend/lowering/cjs-inline-require.ts
index eb05550c0..3d28dfae3 100644
--- a/packages/compiler/src/frontend/lowering/cjs-inline-require.ts
+++ b/packages/compiler/src/frontend/lowering/cjs-inline-require.ts
@@ -431,13 +431,6 @@ export function inlineNamespaceRequireOf(
 /** `value` evaluated after the required module's run-once %init (and its
  * module-registry link) at the require's own position. */
 export function withRequireInit(lowerer: Lowerer, req: InlineRequire, value: IrExpr): IrExpr {
-  if (lowerer.inlineRequireCycleCalls.has(req.call)) {
-    lowerer.unsupported(
-      "SC1090",
-      req.call,
-      `require() of '${req.spec}' while it is still evaluating (a require cycle: Node answers its partial exports, which the static export table does not model)`,
-    );
-  }
   // Every inline program require is a preflight module edge, so its module
   // has an initializer; never read its exports without evaluating it.
   if (!lowerer.initNameOf.has(req.dep)) {
diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts
index 43303b4c6..2b76080fd 100644
--- a/packages/compiler/src/frontend/lowering/lowerer.ts
+++ b/packages/compiler/src/frontend/lowering/lowerer.ts
@@ -4851,6 +4851,13 @@ export class Lowerer {
    * their external dependencies by name). Null for everything else
    * (builtins load nothing; the rest kept its preflight fence). */
   requireInitStmt(spec: string, node: ts.Node): IrStmt | null {
+    if (this.inlineRequireCycleCalls.has(node)) {
+      this.unsupported(
+        "SC1090",
+        node,
+        `require() of '${spec}' while it is still evaluating (a require cycle: Node answers its partial exports, which the static export table does not model)`,
+      );
+    }
     if (canonicalBuiltinModule(spec) === "punycode") return this.punycodeRequireWarning(node);
     // Project requires resolve within the program; another bare require can
     // be a program-module edge when it names an opted-in --npm-static package
diff --git a/tests/harness/errors.test.ts b/tests/harness/errors.test.ts
index 319e7329f..f379973b3 100644
--- a/tests/harness/errors.test.ts
+++ b/tests/harness/errors.test.ts
@@ -325,6 +325,36 @@ console.log(cells.join(","));
     );
   });
 
+  test("a split require closing a CommonJS cycle throws the partial-exports fence", async () => {
+    // Node answers the closing require with the dependency's partial exports
+    // ({ fromA: 1 } at this point), which the static export model cannot
+    // represent. The split assignment must hit the same fence as an inline
+    // require in expression position instead of reading uninitialized
+    // export storage.
+    const r = await compileAndRun(
+      "split-require-cycle",
+      `require("./a.cjs");
+`,
+      "cjs",
+      {
+        "a.cjs": `exports.fromA = 1;
+const b = require("./b.cjs");
+exports.fromB = b.fromB;
+`,
+        "b.cjs": `exports.fromB = 2;
+var a;
+a = require("./a.cjs");
+console.log(a.fromA, a.fromB);
+`,
+      },
+    );
+    expect(r.exitCode).toBe(1);
+    expect(r.stdout).toBe("");
+    expect(r.stderr).toMatch(
+      /^Uncaught Error: require\(\) of '\.\/a\.cjs' while it is still evaluating \(a require cycle: Node answers its partial exports, which the static export table does not model\) is not supported yet \[SC1090 at .*b\.cjs:3\]\n$/,
+    );
+  });
+
   test("an EFFECTFUL surplus argument is a named deferred fence (JS lane)", async () => {
     // Effect-free surplus args drop at compile time, JS-exact (corpus
     // 1760 — the test-string-decoder writeSequences shape). An effectful

From bf68b3860cdf7fb7b2e5d9442fb4576d3a05bf4d Mon Sep 17 00:00:00 2001
From: Chris Tate <chris@ctate.dev>
Date: Fri, 23 Oct 2026 19:05:58 -0500
Subject: [PATCH 3/3] Skip split require calls by identity and climb
 parentheses in early-read checks

---
 packages/compiler/src/frontend/program.ts     | 21 ++++++++++++-------
 .../split-cjs-require-early/main.js.json      | 10 +++++++++
 tests/corpus/split-cjs-require-cycle/main.cjs |  3 ++-
 tests/corpus/split-cjs-require-cycle/odd.cjs  |  2 +-
 .../split-cjs-require-early/main.js           |  5 +++++
 .../split-cjs-require-early/main.js.txt       |  9 +++++++-
 6 files changed, 39 insertions(+), 11 deletions(-)

diff --git a/packages/compiler/src/frontend/program.ts b/packages/compiler/src/frontend/program.ts
index 42fa6116e..149584d00 100644
--- a/packages/compiler/src/frontend/program.ts
+++ b/packages/compiler/src/frontend/program.ts
@@ -1563,6 +1563,14 @@ function splitRequireOfStatement7(
   return null;
 }
 
+/** The top-level statement of a split require binding's assignment, from
+ * its require call (`m = require("./x")` or `m = (require("./x"))`). */
+function splitRequireStatementOf7(call: ts.CallExpression): ts.Node | undefined {
+  let node: ts.Node = call;
+  while (node.parent !== undefined && ts.isParenthesizedExpression(node.parent)) node = node.parent;
+  return node.parent?.parent;
+}
+
 /** The require call of a split require binding's declaration, or null. */
 function splitRequireCallOf7(
   program: ts.Program,
@@ -1877,7 +1885,7 @@ function requireEarlyReference7(
   const sf = ts.getSourceFileOfNode(decl);
   // A split require binding is bound at its assignment statement.
   const splitCall = splitRequireCallOf7(program, decl);
-  const stmt = splitCall !== null ? splitCall.parent?.parent : decl.parent?.parent;
+  const stmt = splitCall !== null ? splitRequireStatementOf7(splitCall) : decl.parent?.parent;
   if (
     stmt !== undefined &&
     (ts.isVariableStatement(stmt) || splitCall !== null) &&
@@ -6184,15 +6192,12 @@ function preflight7(load: LoadResult): {
       // counts, and targets outside the compiled graph add nothing here:
       // their use sites keep their existing lowering fences.
       if (jsRequireFile && !isNodeEsmFile7(sf, program)) {
+        // A split require binding's assignment is a statement-level require
+        // edge (requiresOf7 above), parenthesized or not.
+        const splitCalls = new Set(splitRequireBindings7(program, sf).values());
         for (const call of inlineRequiresOf7(sf)) {
           if (requireCallBindingKind7(program, call) !== "ambient") continue;
-          // A split require binding's assignment is a statement-level
-          // require edge (requiresOf7 above).
-          if (
-            call.parent?.parent !== undefined &&
-            splitRequireOfStatement7(program, call.parent.parent as ts.Statement) !== null
-          )
-            continue;
+          if (splitCalls.has(call)) continue;
           const spec = requireSpecOf7(call)!;
           if (load.externalTypes.has(spec) || canonicalBuiltinModule(spec) !== null) continue;
           const lazy = inDeferredPosition7(call);
diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/split-cjs-require-early/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/split-cjs-require-early/main.js.json
index a0a094bf5..acb338494 100644
--- a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/split-cjs-require-early/main.js.json
+++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/split-cjs-require-early/main.js.json
@@ -12,6 +12,16 @@
     "end": 415
    },
    "milestone": "later"
+  },
+  {
+   "code": "SC1013",
+   "message": "require() binding 'wrapped' assigned below code that can reach it (Node reads undefined before the assignment runs, which is not modeled — move the assignment above the code that can run first) is not supported yet",
+   "loc": {
+    "file": "<repo>/tests/diagnostics/split-cjs-require-early/main.js",
+    "start": 530,
+    "end": 549
+   },
+   "milestone": "later"
   }
  ]
 }
diff --git a/tests/corpus/split-cjs-require-cycle/main.cjs b/tests/corpus/split-cjs-require-cycle/main.cjs
index c4788ddbe..9ec7997db 100644
--- a/tests/corpus/split-cjs-require-cycle/main.cjs
+++ b/tests/corpus/split-cjs-require-cycle/main.cjs
@@ -1,7 +1,8 @@
 // Split require bindings (`var m; m = require("./x.cjs")`) that close a
 // CommonJS cycle: each module publishes its exports before its require, and
 // reads the other module's binding only in functions that run after both
-// modules finish, the cycle shape the const form compiles too.
+// modules finish, the cycle shape the const form compiles too. One
+// assignment parenthesizes its require.
 console.log("main: start");
 var even, odd;
 even = require("./even.cjs");
diff --git a/tests/corpus/split-cjs-require-cycle/odd.cjs b/tests/corpus/split-cjs-require-cycle/odd.cjs
index c066a1e33..d449c28e8 100644
--- a/tests/corpus/split-cjs-require-cycle/odd.cjs
+++ b/tests/corpus/split-cjs-require-cycle/odd.cjs
@@ -8,5 +8,5 @@ exports.isOdd = function (n) {
 exports.calls = function () {
   return calls;
 };
-even = require("./even.cjs");
+even = (require("./even.cjs"));
 console.log("odd: loaded");
diff --git a/tests/diagnostics/split-cjs-require-early/main.js b/tests/diagnostics/split-cjs-require-early/main.js
index 3e0e43aa3..ae1d8d770 100644
--- a/tests/diagnostics/split-cjs-require-early/main.js
+++ b/tests/diagnostics/split-cjs-require-early/main.js
@@ -9,6 +9,11 @@ let lib;
 console.log('boot', helper());
 lib = require('./lib.js');
 
+// The same with the require parenthesized.
+let wrapped;
+console.log('peek', wrapped === undefined);
+wrapped = (require('./lib.js'));
+
 function helper() {
   return lib === undefined ? 'not loaded' : lib.greet('late');
 }
diff --git a/tests/harness/__snapshots__/split-cjs-require-early/main.js.txt b/tests/harness/__snapshots__/split-cjs-require-early/main.js.txt
index 2269f906e..0496cd125 100644
--- a/tests/harness/__snapshots__/split-cjs-require-early/main.js.txt
+++ b/tests/harness/__snapshots__/split-cjs-require-early/main.js.txt
@@ -3,4 +3,11 @@ split-cjs-require-early/main.js:10:7 - error SC1013: require() binding 'lib' ass
    9 | console.log('boot', helper());
   10 | lib = require('./lib.js');
      |       ^~~~~~~~~~~~~~~~~~~
-  11 | 
\ No newline at end of file
+  11 | 
+
+split-cjs-require-early/main.js:15:12 - error SC1013: require() binding 'wrapped' assigned below code that can reach it (Node reads undefined before the assignment runs, which is not modeled — move the assignment above the code that can run first) is not supported yet
+
+  14 | console.log('peek', wrapped === undefined);
+  15 | wrapped = (require('./lib.js'));
+     |            ^~~~~~~~~~~~~~~~~~~
+  16 | 
\ No newline at end of file