graphddb 0.7.9 → 0.8.0

package/dist/transform/index.js

@@ -1,3 +1,11 @@
+import {
+  EXPR_VERSION,
+  SCP_LOWERED_MARKER,
+  canonicalizeExpressionSpec
+} from "../chunk-L4QRCHRQ.js";
+import "../chunk-L2NEDS7U.js";
+import "../chunk-XTWXMOHD.js";
+
 // src/transform/prepared-transform.ts
 import ts from "typescript";
 var HOIST_SLOT_PREFIX = "__gddbPrepared";
@@ -923,7 +931,7 @@ function transformPreparedSourceAot(fileName, sourceText, options) {
     let header = "";
     const nl = sourceText.includes("\r\n") ? "\r\n" : "\n";
     if (needsHeaderImports && !bindings.has(AOT_LOADER_LOCAL)) {
-      header += `${nl}${nl}// graphddb transform prepared --aot (#208): static prepared plans \u2014 each${nl}// call site loads its build-time-compiled plan; the body stays in source as${nl}// the plan's compile source (drift regeneration) and typed fallback.${nl}import { loadPreparedPlan as ${AOT_LOADER_LOCAL} } from 'graphddb';${nl}import ${AOT_PLANS_LOCAL} from '${options.artifactImport}';`;
+      header += `${nl}${nl}// graphddb transform prepared --aot (#208): static prepared plans \u2014 each${nl}// call site loads its build-time-compiled plan; the body stays in source as${nl}// the plan's compile source (drift regeneration) and typed fallback.${nl}import { loadPreparedPlan as ${AOT_LOADER_LOCAL} } from 'graphddb/internal';${nl}import ${AOT_PLANS_LOCAL} from '${options.artifactImport}';`;
     }
     if (slotNames.length > 0) {
       header += `${nl}${nl}// graphddb transform prepared (#206): module-scope lazy slots.` + slotNames.map((s) => `${nl}let ${s};`).join("");
@@ -971,12 +979,2087 @@ function resolveBodyFn(arg, bindings) {
   }
   return void 0;
 }
+
+// src/transform/expression-lower.ts
+import ts2 from "typescript";
+function formatExpressionLowerDiagnostic(d) {
+  return `${d.file}:${d.line}:${d.column} \u2014 SCP lowering error [${d.construct}]: ${d.message}`;
+}
+var ExpressionLowerError = class extends Error {
+  diagnostics;
+  constructor(diagnostics) {
+    super(diagnostics.map(formatExpressionLowerDiagnostic).join("\n"));
+    this.name = "ExpressionLowerError";
+    this.diagnostics = diagnostics;
+  }
+};
+var NUMERIC_KINDS = /* @__PURE__ */ new Set(["int", "float", "num"]);
+function scopeOfRoot(ctx, id) {
+  const symbol = ctx.checker.getSymbolAtLocation(id);
+  if (symbol === void 0) return void 0;
+  if (ctx.inputRootSymbols.has(symbol)) return "input";
+  if (ctx.itemRootSymbols.has(symbol)) return "item";
+  return void 0;
+}
+function shadowsRootName(ctx, name) {
+  for (const s of ctx.inputRootSymbols) if (s.getName() === name) return true;
+  for (const s of ctx.itemRootSymbols) if (s.getName() === name) return true;
+  return false;
+}
+function report2(ctx, node, code, construct, message) {
+  const { line, character } = ctx.sf.getLineAndCharacterOfPosition(
+    node.getStart(ctx.sf)
+  );
+  ctx.diagnostics.push({
+    code,
+    category: "error",
+    message,
+    construct,
+    file: ctx.fileName,
+    line: line + 1,
+    column: character + 1
+  });
+  return void 0;
+}
+function unwrapExpr2(e) {
+  let cur = e;
+  for (; ; ) {
+    if (ts2.isParenthesizedExpression(cur)) cur = cur.expression;
+    else if (ts2.isAsExpression(cur)) cur = cur.expression;
+    else if (ts2.isSatisfiesExpression(cur)) cur = cur.expression;
+    else if (ts2.isNonNullExpression(cur)) cur = cur.expression;
+    else if (ts2.isTypeAssertionExpression(cur)) cur = cur.expression;
+    else return cur;
+  }
+}
+function classifyType(type, checker) {
+  const NULLISH = ts2.TypeFlags.Null | ts2.TypeFlags.Undefined | ts2.TypeFlags.VoidLike;
+  const parts = type.isUnion() ? type.types : [type];
+  let nullable = false;
+  let kind;
+  let seen = false;
+  for (const part of parts) {
+    if (part.flags & NULLISH) {
+      nullable = true;
+      continue;
+    }
+    const k = classifySingle(part, checker);
+    if (k === void 0) return { kind: void 0, nullable };
+    if (!seen) {
+      kind = k;
+      seen = true;
+    } else if (kind !== k) {
+      if (kind !== void 0 && NUMERIC_KINDS.has(kind) && NUMERIC_KINDS.has(k)) {
+        kind = "num";
+      } else {
+        return { kind: void 0, nullable };
+      }
+    }
+  }
+  if (!seen) return { kind: "null", nullable: true };
+  return { kind, nullable };
+}
+function classifySingle(type, checker) {
+  const f = type.flags;
+  if (f & (ts2.TypeFlags.Any | ts2.TypeFlags.Unknown | ts2.TypeFlags.Never)) {
+    return void 0;
+  }
+  if (f & ts2.TypeFlags.StringLike) return "string";
+  if (f & ts2.TypeFlags.BooleanLike) return "bool";
+  if (f & ts2.TypeFlags.NumberLike) {
+    if (type.isNumberLiteral()) {
+      return Number.isInteger(type.value) ? "int" : "float";
+    }
+    return "num";
+  }
+  if (f & ts2.TypeFlags.Null) return "null";
+  if (f & ts2.TypeFlags.Object) {
+    return checker.isArrayLikeType(type) ? "arr" : "obj";
+  }
+  return void 0;
+}
+function classifyAt(ctx, expr) {
+  return classifyType(ctx.checker.getTypeAtLocation(expr), ctx.checker);
+}
+function unifyNumeric(a, b) {
+  if (!NUMERIC_KINDS.has(a) || !NUMERIC_KINDS.has(b)) return void 0;
+  if (a === b) return a;
+  if (a === "num" || b === "num") return "num";
+  return void 0;
+}
+function unifyBranch(a, b) {
+  if (a === "null") return b;
+  if (b === "null") return a;
+  if (a === b) return a;
+  return unifyNumeric(a, b);
+}
+var KNOWN_HOST_GLOBALS = /* @__PURE__ */ new Set([
+  "Date",
+  "Math",
+  "JSON",
+  "RegExp",
+  "Symbol",
+  "Number",
+  "String",
+  "Boolean",
+  "Object",
+  "Array",
+  "Promise",
+  "Reflect",
+  "BigInt",
+  "globalThis",
+  "process",
+  "window",
+  "console"
+]);
+function lower(ctx, expr) {
+  const e = unwrapExpr2(expr);
+  if (ts2.isStringLiteral(e) || ts2.isNoSubstitutionTemplateLiteral(e)) {
+    return { node: e.text, kind: "string", nullable: false };
+  }
+  if (ts2.isNumericLiteral(e)) return lowerNumericLiteral(ctx, e, false);
+  if (e.kind === ts2.SyntaxKind.TrueKeyword) {
+    return { node: true, kind: "bool", nullable: false };
+  }
+  if (e.kind === ts2.SyntaxKind.FalseKeyword) {
+    return { node: false, kind: "bool", nullable: false };
+  }
+  if (e.kind === ts2.SyntaxKind.NullKeyword) {
+    return { node: null, kind: "null", nullable: true };
+  }
+  if (ts2.isBigIntLiteral(e)) {
+    return report2(
+      ctx,
+      e,
+      "scp-closed-set",
+      "bigint literal",
+      'A bigint literal (`\u2026n`) is outside the Expression IR closed set \u2014 write a plain integer literal instead (the lowerer reads the token text, so values beyond \xB12^53\u22121 are carried exactly as `{int:"\u2026"}`).'
+    );
+  }
+  if (ts2.isPrefixUnaryExpression(e)) return lowerPrefixUnary(ctx, e);
+  if (ts2.isPostfixUnaryExpression(e)) {
+    const op = e.operator === ts2.SyntaxKind.PlusPlusToken ? "++" : "--";
+    return report2(
+      ctx,
+      e,
+      "scp-closed-set",
+      op,
+      `The mutation operator \`${op}\` is outside the Expression IR closed set (expressions are pure \u2014 no assignment, no mutation).`
+    );
+  }
+  if (ts2.isBinaryExpression(e)) return lowerBinary(ctx, e);
+  if (ts2.isConditionalExpression(e)) return lowerConditional(ctx, e);
+  if (ts2.isObjectLiteralExpression(e)) return lowerObjectLiteral(ctx, e);
+  if (ts2.isArrayLiteralExpression(e)) return lowerArrayLiteral(ctx, e);
+  if (ts2.isTemplateExpression(e)) return lowerTemplate(ctx, e);
+  if (ts2.isPropertyAccessExpression(e)) return lowerPropertyAccess(ctx, e);
+  if (ts2.isIdentifier(e)) return lowerBareIdentifier(ctx, e);
+  return lowerReject(ctx, e);
+}
+function lowerNumericLiteral(ctx, lit, negate) {
+  const raw = lit.getText(ctx.sf).replace(/_/g, "");
+  const isRadixInt = /^0[xob]/i.test(raw);
+  const isFloat = !isRadixInt && /[.eE]/.test(raw);
+  if (isFloat) {
+    const value = Number(raw) * (negate ? -1 : 1);
+    if (!Number.isFinite(value)) {
+      return report2(
+        ctx,
+        lit,
+        "scp-type",
+        "non-finite literal",
+        `The float literal ${raw} evaluates to a non-finite value \u2014 NaN / \xB1Infinity cannot exist in the Expression IR (expression-ir.md \xA72.1).`
+      );
+    }
+    return { node: { float: value }, kind: "float", nullable: false };
+  }
+  const v = BigInt(raw) * (negate ? -1n : 1n);
+  if (v >= BigInt(Number.MIN_SAFE_INTEGER) && v <= BigInt(Number.MAX_SAFE_INTEGER)) {
+    return { node: Number(v), kind: "int", nullable: false };
+  }
+  return { node: { int: v.toString() }, kind: "int", nullable: false };
+}
+function lowerPrefixUnary(ctx, e) {
+  const operand = unwrapExpr2(e.operand);
+  switch (e.operator) {
+    case ts2.SyntaxKind.MinusToken: {
+      if (ts2.isNumericLiteral(operand)) return lowerNumericLiteral(ctx, operand, true);
+      const a = lower(ctx, operand);
+      if (a === void 0) return void 0;
+      if (!NUMERIC_KINDS.has(a.kind) || a.nullable) {
+        return report2(
+          ctx,
+          e,
+          "scp-type",
+          "unary -",
+          `The operand of unary \`-\` must be a non-null number, got ${describeKind(a)} \u2014 the IR \`neg\` operator is numeric-only.`
+        );
+      }
+      return { node: { neg: [a.node] }, kind: a.kind, nullable: false };
+    }
+    case ts2.SyntaxKind.PlusToken:
+      if (ts2.isNumericLiteral(operand)) return lowerNumericLiteral(ctx, operand, false);
+      return report2(
+        ctx,
+        e,
+        "scp-closed-set",
+        "unary +",
+        "Unary `+` (numeric coercion) is outside the Expression IR closed set \u2014 implicit type conversion does not exist (expression-ir.md \xA75)."
+      );
+    case ts2.SyntaxKind.ExclamationToken: {
+      const a = lower(ctx, operand);
+      if (a === void 0) return void 0;
+      if (a.kind !== "bool" || a.nullable) {
+        return report2(
+          ctx,
+          e,
+          "scp-type",
+          "truthiness",
+          `The operand of \`!\` must be a non-null boolean, got ${describeKind(a)} \u2014 truthiness coercion is outside the closed set (compare explicitly instead).`
+        );
+      }
+      return { node: { not: [a.node] }, kind: "bool", nullable: false };
+    }
+    case ts2.SyntaxKind.TildeToken:
+      return report2(
+        ctx,
+        e,
+        "scp-closed-set",
+        "bitwise ~",
+        "The bitwise operator `~` is outside the Expression IR closed set (bitwise semantics are undefined in v1 \u2014 expression-ir.md \xA73)."
+      );
+    default: {
+      const op = e.operator === ts2.SyntaxKind.PlusPlusToken ? "++" : "--";
+      return report2(
+        ctx,
+        e,
+        "scp-closed-set",
+        op,
+        `The mutation operator \`${op}\` is outside the Expression IR closed set (expressions are pure \u2014 no assignment, no mutation).`
+      );
+    }
+  }
+}
+var BITWISE_TOKENS = /* @__PURE__ */ new Map([
+  [ts2.SyntaxKind.AmpersandToken, "&"],
+  [ts2.SyntaxKind.BarToken, "|"],
+  [ts2.SyntaxKind.CaretToken, "^"],
+  [ts2.SyntaxKind.LessThanLessThanToken, "<<"],
+  [ts2.SyntaxKind.GreaterThanGreaterThanToken, ">>"],
+  [ts2.SyntaxKind.GreaterThanGreaterThanGreaterThanToken, ">>>"]
+]);
+var COMPARISON_TOKENS = /* @__PURE__ */ new Map([
+  [ts2.SyntaxKind.LessThanToken, "lt"],
+  [ts2.SyntaxKind.LessThanEqualsToken, "le"],
+  [ts2.SyntaxKind.GreaterThanToken, "gt"],
+  [ts2.SyntaxKind.GreaterThanEqualsToken, "ge"]
+]);
+var ARITH_TOKENS = /* @__PURE__ */ new Map([
+  [ts2.SyntaxKind.MinusToken, "sub"],
+  [ts2.SyntaxKind.AsteriskToken, "mul"],
+  [ts2.SyntaxKind.SlashToken, "div"],
+  [ts2.SyntaxKind.PercentToken, "mod"]
+]);
+function lowerBinary(ctx, e) {
+  const opKind = e.operatorToken.kind;
+  const opText = e.operatorToken.getText(ctx.sf);
+  if (opKind === ts2.SyntaxKind.EqualsEqualsToken || opKind === ts2.SyntaxKind.ExclamationEqualsToken) {
+    return report2(
+      ctx,
+      e,
+      "scp-closed-set",
+      opText,
+      `Loose equality \`${opText}\` is outside the Expression IR closed set \u2014 use \`${opText === "==" ? "===" : "!=="}\` (strict, monomorphic comparison; expression-ir.md \xA73).`
+    );
+  }
+  {
+    const bit = BITWISE_TOKENS.get(opKind);
+    if (bit !== void 0) {
+      return report2(
+        ctx,
+        e,
+        "scp-closed-set",
+        `bitwise ${bit}`,
+        `The bitwise operator \`${bit}\` is outside the Expression IR closed set (bitwise semantics are undefined in v1 \u2014 expression-ir.md \xA73).`
+      );
+    }
+  }
+  if (opKind === ts2.SyntaxKind.InstanceOfKeyword) {
+    return report2(
+      ctx,
+      e,
+      "scp-closed-set",
+      "instanceof",
+      "`instanceof` is outside the Expression IR closed set (no runtime type reflection \u2014 expression-ir.md \xA73)."
+    );
+  }
+  if (opKind === ts2.SyntaxKind.InKeyword) {
+    return report2(
+      ctx,
+      e,
+      "scp-closed-set",
+      "in",
+      "The `in` operator is outside the Expression IR closed set."
+    );
+  }
+  if (opKind === ts2.SyntaxKind.CommaToken) {
+    return report2(
+      ctx,
+      e,
+      "scp-closed-set",
+      "comma operator",
+      "The comma operator is outside the Expression IR closed set (expressions are single pure values)."
+    );
+  }
+  if (opKind === ts2.SyntaxKind.AsteriskAsteriskToken) {
+    return report2(
+      ctx,
+      e,
+      "scp-closed-set",
+      "**",
+      "Exponentiation `**` is outside the Expression IR closed set."
+    );
+  }
+  if (opKind >= ts2.SyntaxKind.FirstAssignment && opKind <= ts2.SyntaxKind.LastAssignment) {
+    return report2(
+      ctx,
+      e,
+      "scp-closed-set",
+      "assignment",
+      `Assignment (\`${opText}\`) is outside the Expression IR closed set (expressions are pure \u2014 no assignment, no mutation).`
+    );
+  }
+  if (opKind === ts2.SyntaxKind.QuestionQuestionToken) {
+    const a = lower(ctx, e.left);
+    const b = lower(ctx, e.right);
+    if (a === void 0 || b === void 0) return void 0;
+    const kind = unifyBranch(a.kind, b.kind);
+    if (kind === void 0) {
+      return report2(
+        ctx,
+        e,
+        "scp-type",
+        "??",
+        `The sides of \`??\` must have the same type, got ${describeKind(a)} and ${describeKind(b)} (expression-ir.md \xA73: monomorphic branches).`
+      );
+    }
+    return { node: { coalesce: [a.node, b.node] }, kind, nullable: b.nullable };
+  }
+  if (opKind === ts2.SyntaxKind.AmpersandAmpersandToken || opKind === ts2.SyntaxKind.BarBarToken) {
+    const op = opKind === ts2.SyntaxKind.AmpersandAmpersandToken ? "and" : "or";
+    const a = lower(ctx, e.left);
+    const b = lower(ctx, e.right);
+    if (a === void 0 || b === void 0) return void 0;
+    for (const [side, v] of [
+      ["left", a],
+      ["right", b]
+    ]) {
+      if (v.kind !== "bool" || v.nullable) {
+        return report2(
+          ctx,
+          e,
+          "scp-type",
+          "truthiness",
+          `The ${side} operand of \`${opText}\` must be a non-null boolean, got ${describeKind(v)} \u2014 truthiness coercion is outside the closed set (expression-ir.md \xA73: bool\xD7bool only).`
+        );
+      }
+    }
+    return { node: { [op]: [a.node, b.node] }, kind: "bool", nullable: false };
+  }
+  if (opKind === ts2.SyntaxKind.EqualsEqualsEqualsToken || opKind === ts2.SyntaxKind.ExclamationEqualsEqualsToken) {
+    const op = opKind === ts2.SyntaxKind.EqualsEqualsEqualsToken ? "eq" : "ne";
+    const a = lower(ctx, e.left);
+    const b = lower(ctx, e.right);
+    if (a === void 0 || b === void 0) return void 0;
+    const isNullCheck = a.kind === "null" || b.kind === "null";
+    if (!isNullCheck) {
+      const kind = unifyNumeric(a.kind, b.kind) ?? (a.kind === b.kind ? a.kind : void 0);
+      if (kind === void 0 || kind === "obj" || kind === "arr") {
+        return report2(
+          ctx,
+          e,
+          "scp-type",
+          opText,
+          `\`${opText}\` compares same-type scalars only (int / float / string / bool \u2014 or \`x === null\`), got ${describeKind(a)} and ${describeKind(b)} (expression-ir.md \xA73).`
+        );
+      }
+      if (a.nullable || b.nullable) {
+        return report2(
+          ctx,
+          e,
+          "scp-type",
+          opText,
+          `An operand of \`${opText}\` is possibly null \u2014 compare against \`null\` explicitly or coalesce (\`??\`) first.`
+        );
+      }
+    }
+    return { node: { [op]: [a.node, b.node] }, kind: "bool", nullable: false };
+  }
+  {
+    const cmp = COMPARISON_TOKENS.get(opKind);
+    if (cmp !== void 0) {
+      const a = lower(ctx, e.left);
+      const b = lower(ctx, e.right);
+      if (a === void 0 || b === void 0) return void 0;
+      const numeric = unifyNumeric(a.kind, b.kind);
+      const stringPair = a.kind === "string" && b.kind === "string";
+      if (numeric === void 0 && !stringPair || a.nullable || b.nullable) {
+        return report2(
+          ctx,
+          e,
+          "scp-type",
+          opText,
+          `\`${opText}\` compares two non-null ints, floats, or strings, got ${describeKind(a)} and ${describeKind(b)} (expression-ir.md \xA73; int\xD7float mixing needs an explicit float literal \u2014 \xA75).`
+        );
+      }
+      return { node: { [cmp]: [a.node, b.node] }, kind: "bool", nullable: false };
+    }
+  }
+  if (opKind === ts2.SyntaxKind.PlusToken) {
+    const a = lower(ctx, e.left);
+    const b = lower(ctx, e.right);
+    if (a === void 0 || b === void 0) return void 0;
+    if (a.nullable || b.nullable) {
+      return report2(
+        ctx,
+        e,
+        "scp-type",
+        "+",
+        "An operand of `+` is possibly null \u2014 coalesce (`??`) it first (the IR has no null-tolerant arithmetic)."
+      );
+    }
+    if (a.kind === "string" && b.kind === "string") {
+      return { node: { concat: [a.node, b.node] }, kind: "string", nullable: false };
+    }
+    const numeric = unifyNumeric(a.kind, b.kind);
+    if (numeric !== void 0) {
+      return { node: { add: [a.node, b.node] }, kind: numeric, nullable: false };
+    }
+    if (a.kind === "string" && NUMERIC_KINDS.has(b.kind) || NUMERIC_KINDS.has(a.kind) && b.kind === "string") {
+      return report2(
+        ctx,
+        e,
+        "scp-type",
+        "+",
+        `\`+\` on ${describeKind(a)} and ${describeKind(b)}: implicit number\u2192string conversion is outside the closed set (expression-ir.md \xA73 \u2014 \`concat\` is string\xD7string only; no implicit toString).`
+      );
+    }
+    return report2(
+      ctx,
+      e,
+      "scp-type",
+      "+",
+      `\`+\` needs two numbers (\u2192 \`add\`) or two strings (\u2192 \`concat\`), got ${describeKind(a)} and ${describeKind(b)} \u2014 the lowerer resolves \`+\` statically and never guesses (expression-ir.md \xA75; int\xD7float mixing needs an explicit float literal).`
+    );
+  }
+  {
+    const arith = ARITH_TOKENS.get(opKind);
+    if (arith !== void 0) {
+      const a = lower(ctx, e.left);
+      const b = lower(ctx, e.right);
+      if (a === void 0 || b === void 0) return void 0;
+      const numeric = unifyNumeric(a.kind, b.kind);
+      if (numeric === void 0 || a.nullable || b.nullable) {
+        return report2(
+          ctx,
+          e,
+          "scp-type",
+          opText,
+          `\`${opText}\` needs two non-null numbers of the same kind, got ${describeKind(a)} and ${describeKind(b)} (expression-ir.md \xA75: int\xD7float mixing needs an explicit float literal).`
+        );
+      }
+      const kind = arith === "div" ? "float" : numeric;
+      return { node: { [arith]: [a.node, b.node] }, kind, nullable: false };
+    }
+  }
+  return report2(
+    ctx,
+    e,
+    "scp-closed-set",
+    opText,
+    `The operator \`${opText}\` is outside the Expression IR closed set (expression-ir.md \xA73).`
+  );
+}
+function lowerConditional(ctx, e) {
+  const c = lower(ctx, e.condition);
+  const t = lower(ctx, e.whenTrue);
+  const f = lower(ctx, e.whenFalse);
+  if (c === void 0 || t === void 0 || f === void 0) return void 0;
+  if (c.kind !== "bool" || c.nullable) {
+    return report2(
+      ctx,
+      e.condition,
+      "scp-type",
+      "truthiness",
+      `The condition of \`?:\` must be a non-null boolean, got ${describeKind(c)} \u2014 truthiness coercion is outside the closed set (compare explicitly instead).`
+    );
+  }
+  const kind = unifyBranch(t.kind, f.kind);
+  if (kind === void 0) {
+    return report2(
+      ctx,
+      e,
+      "scp-type",
+      "?:",
+      `The branches of \`?:\` must have the same type, got ${describeKind(t)} and ${describeKind(f)} (expression-ir.md \xA73: t/e \u306F\u540C\u4E00\u578B).`
+    );
+  }
+  return {
+    node: { cond: [c.node, t.node, f.node] },
+    kind,
+    nullable: t.nullable || f.nullable || t.kind === "null" || f.kind === "null"
+  };
+}
+function lowerObjectLiteral(ctx, e) {
+  const out = {};
+  let failed = false;
+  for (const prop of e.properties) {
+    if (ts2.isPropertyAssignment(prop)) {
+      if (ts2.isComputedPropertyName(prop.name)) {
+        report2(
+          ctx,
+          prop.name,
+          "scp-closed-set",
+          "computed property name",
+          "A computed property name is outside the Expression IR closed set \u2014 `obj` construction needs statically known keys."
+        );
+        failed = true;
+        continue;
+      }
+      if (!ts2.isIdentifier(prop.name) && !ts2.isStringLiteralLike(prop.name)) {
+        report2(
+          ctx,
+          prop.name,
+          "scp-closed-set",
+          "property name",
+          "Only identifier / string-literal property names are supported in `obj` construction."
+        );
+        failed = true;
+        continue;
+      }
+      if (prop.name.text === "__proto__") {
+        reportProtoKey(ctx, prop.name);
+        failed = true;
+        continue;
+      }
+      const v = lower(ctx, prop.initializer);
+      if (v === void 0) {
+        failed = true;
+        continue;
+      }
+      out[prop.name.text] = v.node;
+    } else if (ts2.isShorthandPropertyAssignment(prop)) {
+      if (prop.name.text === "__proto__") {
+        reportProtoKey(ctx, prop.name);
+        failed = true;
+        continue;
+      }
+      const v = lower(ctx, prop.name);
+      if (v === void 0) {
+        failed = true;
+        continue;
+      }
+      out[prop.name.text] = v.node;
+    } else if (ts2.isSpreadAssignment(prop)) {
+      report2(
+        ctx,
+        prop,
+        "scp-closed-set",
+        "spread",
+        "Spread is outside the Expression IR closed set (expression-ir.md \xA73)."
+      );
+      failed = true;
+    } else {
+      report2(
+        ctx,
+        prop,
+        "scp-closed-set",
+        "object member",
+        "Only plain property assignments are supported in `obj` construction (no methods / accessors)."
+      );
+      failed = true;
+    }
+  }
+  if (failed) return void 0;
+  return { node: { obj: out }, kind: "obj", nullable: false };
+}
+function reportProtoKey(ctx, name) {
+  return report2(
+    ctx,
+    name,
+    "scp-closed-set",
+    "__proto__",
+    "The property name `__proto__` cannot be an `obj` construction key \u2014 in a JS object literal it sets the prototype rather than carrying data, and Expression IR obj keys are plain data. Choose a different key."
+  );
+}
+function lowerArrayLiteral(ctx, e) {
+  const items = [];
+  let failed = false;
+  for (const el of e.elements) {
+    if (ts2.isSpreadElement(el)) {
+      report2(
+        ctx,
+        el,
+        "scp-closed-set",
+        "spread",
+        "Spread is outside the Expression IR closed set (expression-ir.md \xA73)."
+      );
+      failed = true;
+      continue;
+    }
+    if (ts2.isOmittedExpression(el)) {
+      report2(
+        ctx,
+        el,
+        "scp-closed-set",
+        "array hole",
+        "An array hole (elision) is outside the Expression IR closed set."
+      );
+      failed = true;
+      continue;
+    }
+    const v = lower(ctx, el);
+    if (v === void 0) {
+      failed = true;
+      continue;
+    }
+    items.push(v.node);
+  }
+  if (failed) return void 0;
+  return { node: { arr: items }, kind: "arr", nullable: false };
+}
+function lowerTemplate(ctx, e) {
+  const parts = [];
+  let failed = false;
+  if (e.head.text !== "") parts.push(e.head.text);
+  for (const span of e.templateSpans) {
+    const v = lower(ctx, span.expression);
+    if (v === void 0) {
+      failed = true;
+    } else if (v.kind !== "string" || v.nullable) {
+      report2(
+        ctx,
+        span.expression,
+        "scp-type",
+        "template literal",
+        `A template substitution must be a non-null string, got ${describeKind(v)} \u2014 implicit toString is outside the closed set (expression-ir.md \xA73: \u5168\u30D1\u30FC\u30C8\u304C string \u578B\u3067\u3042\u308B\u3053\u3068).`
+      );
+      failed = true;
+    } else {
+      parts.push(v.node);
+    }
+    if (span.literal.text !== "") parts.push(span.literal.text);
+  }
+  if (failed) return void 0;
+  if (parts.length === 0) return { node: "", kind: "string", nullable: false };
+  let node = parts[0];
+  for (let i = 1; i < parts.length; i += 1) {
+    node = { concat: [node, parts[i]] };
+  }
+  return { node, kind: "string", nullable: false };
+}
+function lowerPropertyAccess(ctx, e) {
+  if (e.name.text === "length") {
+    const receiver = e.expression;
+    const recType = classifyAt(ctx, receiver);
+    if (recType.kind === void 0) {
+      return report2(
+        ctx,
+        e,
+        "scp-type",
+        ".length",
+        "The static type of the `.length` receiver is unresolvable (any / unknown) \u2014 the lowerer cannot disambiguate array `len` and never guesses."
+      );
+    }
+    if (recType.kind === "string") {
+      return report2(
+        ctx,
+        e,
+        "scp-closed-set",
+        "string .length",
+        "`.length` on a string is outside the Expression IR v1 closed set (expression-ir.md \xA78: the string-length unit differs across runtimes \u2014 arrays only)."
+      );
+    }
+    if (recType.kind === "arr") {
+      if (recType.nullable || e.questionDotToken !== void 0) {
+        return report2(
+          ctx,
+          e,
+          "scp-type",
+          ".length",
+          "The receiver of `.length` is possibly null \u2014 `len` needs a non-null array (coalesce or null-check first)."
+        );
+      }
+      const xs = lower(ctx, receiver);
+      if (xs === void 0) return void 0;
+      return { node: { len: [xs.node] }, kind: "int", nullable: false };
+    }
+  }
+  const segments = [];
+  const links = [];
+  let optional = false;
+  let cur = e;
+  for (; ; ) {
+    const u = unwrapExpr2(cur);
+    if (ts2.isPropertyAccessExpression(u)) {
+      if (u.questionDotToken !== void 0) optional = true;
+      segments.unshift(u.name.text);
+      links.unshift(u);
+      cur = u.expression;
+      continue;
+    }
+    cur = u;
+    break;
+  }
+  if (!ts2.isIdentifier(cur)) {
+    if (ts2.isElementAccessExpression(cur)) return lowerReject(ctx, cur);
+    if (ts2.isCallExpression(cur) || ts2.isNewExpression(cur)) {
+      return lowerReject(ctx, cur);
+    }
+    return report2(
+      ctx,
+      e,
+      "scp-ref",
+      "computed reference root",
+      "A reference must be a plain property chain rooted at an input binding (`$.<field>\u2026`) \u2014 property access on a computed value is outside the closed set."
+    );
+  }
+  const rootScope = scopeOfRoot(ctx, cur);
+  if (rootScope === void 0) {
+    if (shadowsRootName(ctx, cur.text)) {
+      return report2(
+        ctx,
+        cur,
+        "scp-ref",
+        cur.text,
+        `'${cur.text}' does not resolve to the Input Port binding here \u2014 it is shadowed by a local declaration (a nested parameter, a block-scoped binding, or an import of the same name). Roots are matched by symbol identity, never by name (issue #264); rename the shadowing binding.`
+      );
+    }
+    if (KNOWN_HOST_GLOBALS.has(cur.text)) {
+      return report2(
+        ctx,
+        cur,
+        "scp-closed-set",
+        cur.text,
+        `The host global \`${cur.text}\` is outside the Expression IR closed set (no host objects, no runtime environment access \u2014 expression-ir.md \xA73).`
+      );
+    }
+    return report2(
+      ctx,
+      cur,
+      "scp-ref",
+      cur.text,
+      `'${cur.text}' does not resolve to a recognized input binding \u2014 an expression may reference the Input Port (\`$.<field>\`, scope \`input\`) or a fan-out element (scope \`item\`) only (issue #264 unified reference model).`
+    );
+  }
+  const declared = rootScope === "input" ? ctx.inputFields : ctx.itemFields;
+  if (declared !== void 0 && segments.length > 0 && !declared.has(segments[0])) {
+    const surface = rootScope === "input" ? "input" : "fan-out element";
+    return report2(
+      ctx,
+      e,
+      "scp-ref",
+      `${cur.text}.${segments[0]}`,
+      `'${segments[0]}' is not a declared ${surface} field \u2014 declared: ${[...declared].sort().map((f) => `'${f}'`).join(", ") || "(none)"}. An expression reference must name a declared \`param.*\` input (issue #264: expression refs and ParamSpec names share one namespace; #243: unbound references are compile errors, never runtime leaks).`
+    );
+  }
+  for (const link of links) {
+    if (link.questionDotToken !== void 0) continue;
+    const recv = classifyAt(ctx, link.expression);
+    if (recv.kind !== void 0 && recv.nullable) {
+      return report2(
+        ctx,
+        link,
+        "scp-type",
+        "reference",
+        `The intermediate value \`${link.expression.getText(ctx.sf)}\` of this reference is possibly null \u2014 use \`?.\` (refOpt) or coalesce (\`??\`) it first (expression-ir.md \xA73: \`a.b.c\` requires type-level non-null intermediates).`
+      );
+    }
+  }
+  const cls = classifyAt(ctx, e);
+  if (cls.kind === void 0) {
+    return report2(
+      ctx,
+      e,
+      "scp-type",
+      "reference",
+      `The static type of \`${e.getText(ctx.sf)}\` is unresolvable (any / unknown / unsupported) \u2014 every reference must carry a resolvable scalar / obj / arr type (the lowerer never guesses).`
+    );
+  }
+  const path = [rootScope, ...segments];
+  return optional ? { node: { refOpt: path }, kind: cls.kind, nullable: true } : { node: { ref: path }, kind: cls.kind, nullable: cls.nullable };
+}
+function lowerBareIdentifier(ctx, e) {
+  const name = e.text;
+  if (name === "undefined") {
+    return report2(
+      ctx,
+      e,
+      "scp-closed-set",
+      "undefined",
+      "`undefined` does not exist in the Expression IR (\xA72.1) \u2014 use `null`."
+    );
+  }
+  if (name === "NaN" || name === "Infinity") {
+    return report2(
+      ctx,
+      e,
+      "scp-closed-set",
+      name,
+      `\`${name}\` cannot exist in the Expression IR (\xA72.1: non-finite values are Failures, never values).`
+    );
+  }
+  const scope = scopeOfRoot(ctx, e);
+  if (scope !== void 0) {
+    return report2(
+      ctx,
+      e,
+      "scp-ref",
+      name,
+      `The ${scope === "item" ? "element" : "input"} placeholder \`${name}\` itself is not a value \u2014 reference a specific field (\`${name}.<field>\`).`
+    );
+  }
+  if (shadowsRootName(ctx, name)) {
+    return report2(
+      ctx,
+      e,
+      "scp-ref",
+      name,
+      `'${name}' does not resolve to the Input Port binding here \u2014 it is shadowed by a local declaration (a nested parameter, a block-scoped binding, or an import of the same name). Roots are matched by symbol identity, never by name (issue #264); rename the shadowing binding.`
+    );
+  }
+  if (KNOWN_HOST_GLOBALS.has(name)) {
+    return report2(
+      ctx,
+      e,
+      "scp-closed-set",
+      name,
+      `The host global \`${name}\` is outside the Expression IR closed set (no host objects \u2014 expression-ir.md \xA73).`
+    );
+  }
+  return report2(
+    ctx,
+    e,
+    "scp-ref",
+    name,
+    `'${name}' does not resolve to a recognized input binding \u2014 an expression may reference the Input Port (\`$.<field>\`, scope \`input\`) or a fan-out element (scope \`item\`) only (issue #264 unified reference model).`
+  );
+}
+function lowerReject(ctx, e) {
+  if (ts2.isCallExpression(e)) {
+    return report2(
+      ctx,
+      e,
+      "scp-closed-set",
+      "function call",
+      "A function call is outside the Expression IR closed set \u2014 `Math.*`, methods, and user functions cannot be lowered (expression-ir.md \xA73; the sole planned exception, structural `.map` lowering, is Phase 3 S3 \u2014 issue #263)."
+    );
+  }
+  if (ts2.isNewExpression(e)) {
+    return report2(
+      ctx,
+      e,
+      "scp-closed-set",
+      "new",
+      "`new` is outside the Expression IR closed set \u2014 no object construction beyond `obj` / `arr` literals (and `Date` etc. are host objects; expression-ir.md \xA73)."
+    );
+  }
+  if (ts2.isElementAccessExpression(e)) {
+    return report2(
+      ctx,
+      e,
+      "scp-closed-set",
+      "element access",
+      "Element access (`a[i]` / `a?.[i]`) is outside the Expression IR closed set \u2014 references are plain property chains (`ref` / `refOpt`) only."
+    );
+  }
+  if (ts2.isTypeOfExpression(e)) {
+    return report2(
+      ctx,
+      e,
+      "scp-closed-set",
+      "typeof",
+      "`typeof` is outside the Expression IR closed set (no runtime type reflection \u2014 expression-ir.md \xA73)."
+    );
+  }
+  if (ts2.isRegularExpressionLiteral(e)) {
+    return report2(
+      ctx,
+      e,
+      "scp-closed-set",
+      "regex literal",
+      "A regex literal is outside the Expression IR closed set (`RegExp` is a host object \u2014 expression-ir.md \xA73)."
+    );
+  }
+  if (ts2.isTaggedTemplateExpression(e)) {
+    return report2(
+      ctx,
+      e,
+      "scp-closed-set",
+      "tagged template",
+      "A tagged template is a function call \u2014 outside the Expression IR closed set."
+    );
+  }
+  if (ts2.isArrowFunction(e) || ts2.isFunctionExpression(e)) {
+    return report2(
+      ctx,
+      e,
+      "scp-closed-set",
+      "function expression",
+      "A closure is outside the Expression IR closed set (expression-ir.md \xA73; inline arrows are only meaningful under the S3 structural `.map` lowering \u2014 issue #263)."
+    );
+  }
+  if (e.kind === ts2.SyntaxKind.ThisKeyword) {
+    return report2(
+      ctx,
+      e,
+      "scp-closed-set",
+      "this",
+      "`this` is outside the Expression IR closed set (expressions are pure over their declared inputs)."
+    );
+  }
+  if (ts2.isVoidExpression(e)) {
+    return report2(
+      ctx,
+      e,
+      "scp-closed-set",
+      "void",
+      "`void` is outside the Expression IR closed set (`undefined` does not exist in the IR)."
+    );
+  }
+  if (ts2.isDeleteExpression(e)) {
+    return report2(
+      ctx,
+      e,
+      "scp-closed-set",
+      "delete",
+      "`delete` is outside the Expression IR closed set (expressions are pure)."
+    );
+  }
+  if (ts2.isAwaitExpression(e)) {
+    return report2(
+      ctx,
+      e,
+      "scp-closed-set",
+      "await",
+      "`await` is outside the Expression IR closed set (expressions are synchronous and pure)."
+    );
+  }
+  return report2(
+    ctx,
+    e,
+    "scp-closed-set",
+    ts2.SyntaxKind[e.kind],
+    `Unsupported expression construct (${ts2.SyntaxKind[e.kind]}) \u2014 outside the Expression IR closed set (expression-ir.md \xA73: \u3053\u306E\u8868\u306B\u306A\u3044\u3082\u306E\u306F\u3059\u3079\u3066\u30B3\u30F3\u30D1\u30A4\u30EB\u30A8\u30E9\u30FC).`
+  );
+}
+function describeKind(v) {
+  const base = v.kind === "num" ? "number (int-or-float)" : v.kind === "bool" ? "boolean" : v.kind;
+  return v.nullable && v.kind !== "null" ? `${base} | null` : base;
+}
+var EMPTY_SYMBOLS = /* @__PURE__ */ new Set();
+function lowerTsExpression(expr, options) {
+  return lowerTsExpressionWithKind(expr, options).result;
+}
+function lowerTsExpressionWithKind(expr, options) {
+  const ctx = {
+    checker: options.checker,
+    sf: options.sourceFile,
+    fileName: options.fileName ?? options.sourceFile.fileName,
+    inputRootSymbols: options.inputRootSymbols,
+    itemRootSymbols: options.itemRootSymbols ?? EMPTY_SYMBOLS,
+    inputFields: options.inputFields,
+    itemFields: options.itemFields,
+    diagnostics: []
+  };
+  const lowered = lower(ctx, expr);
+  if (ctx.diagnostics.length > 0 || lowered === void 0) {
+    if (ctx.diagnostics.length === 0) {
+      report2(
+        ctx,
+        expr,
+        "scp-closed-set",
+        "expression",
+        "The expression could not be lowered to the Expression IR closed set."
+      );
+    }
+    return {
+      result: { diagnostics: ctx.diagnostics, errorCount: ctx.diagnostics.length }
+    };
+  }
+  try {
+    const expression = canonicalizeExpressionSpec(
+      { exprVersion: EXPR_VERSION, expr: lowered.node },
+      "expression lowering"
+    );
+    return {
+      result: { expression, diagnostics: [], errorCount: 0 },
+      kind: lowered.kind,
+      nullable: lowered.nullable
+    };
+  } catch (err) {
+    report2(
+      ctx,
+      expr,
+      "scp-closed-set",
+      "expression",
+      `Lowered node failed spec validation: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return {
+      result: { diagnostics: ctx.diagnostics, errorCount: ctx.diagnostics.length }
+    };
+  }
+}
+function inputParamTypeText(d) {
+  switch (d.kind) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "literal": {
+      const parts = (d.literals ?? []).map(
+        (v) => typeof v === "string" ? JSON.stringify(v) : String(v)
+      );
+      if (parts.length === 0) {
+        throw new Error(
+          "expression lowering: a `literal` input param descriptor must carry its allowed values (fail-closed \u2014 an unconstrained literal cannot be typed)."
+        );
+      }
+      return parts.join(" | ");
+    }
+    case "array": {
+      const fields = Object.entries(d.element ?? {}).map(
+        ([f, fd]) => `readonly ${JSON.stringify(f)}: ${inputParamTypeText(fd)};`
+      );
+      return `ReadonlyArray<{ ${fields.join(" ")} }>`;
+    }
+  }
+}
+var LIB_CACHE = /* @__PURE__ */ new Map();
+var TEXT_ENTRY_BINDING = "__scpLowerTarget";
+function lowerExpressionText(exprText, options = {}) {
+  return lowerExpressionTextWithLayout(exprText, options).result;
+}
+function lowerExpressionTextWithLayout(exprText, options = {}) {
+  const inputName = options.inputName ?? "$";
+  const fileName = options.fileName ?? "scp-expression.ts";
+  const inputs = {};
+  for (const [name, d] of Object.entries(options.params ?? {})) {
+    inputs[name] = inputParamTypeText(d);
+  }
+  Object.assign(inputs, options.inputs ?? {});
+  const declareOf = (name, record) => {
+    const fields = Object.entries(record).map(([k, t]) => `  readonly ${JSON.stringify(k)}: ${t};`).join("\n");
+    return `declare const ${name}: {
+${fields}
+};
+`;
+  };
+  let declares = declareOf(inputName, inputs);
+  const itemName = options.itemName ?? "$el";
+  if (options.itemInputs !== void 0 && itemName === inputName) {
+    throw new Error(
+      `expression lowering: the element binding '${itemName}' collides with the input binding \u2014 the input/item scopes are one namespace of distinct bindings (fail-closed; rename one).`
+    );
+  }
+  if (options.itemInputs !== void 0) {
+    declares += declareOf(itemName, options.itemInputs);
+  }
+  const prefix = declares + `const ${TEXT_ENTRY_BINDING} = (
+`;
+  const exprLine = prefix.split("\n").length;
+  const source = prefix + `${exprText}
+);
+export default ${TEXT_ENTRY_BINDING};
+`;
+  const compilerOptions = {
+    strict: true,
+    target: ts2.ScriptTarget.ES2022,
+    module: ts2.ModuleKind.ESNext,
+    lib: ["lib.es2022.d.ts"],
+    types: [],
+    skipLibCheck: true,
+    noEmit: true,
+    noResolve: true
+  };
+  const base = ts2.createCompilerHost(compilerOptions, true);
+  const host = {
+    ...base,
+    getSourceFile: (name, languageVersionOrOptions) => {
+      if (name === fileName) {
+        return ts2.createSourceFile(
+          fileName,
+          source,
+          ts2.ScriptTarget.ES2022,
+          /* setParentNodes */
+          true
+        );
+      }
+      const cached = LIB_CACHE.get(name);
+      if (cached !== void 0) return cached;
+      const sf2 = base.getSourceFile(name, languageVersionOrOptions);
+      if (sf2 !== void 0) LIB_CACHE.set(name, sf2);
+      return sf2;
+    },
+    fileExists: (name) => name === fileName || base.fileExists(name),
+    readFile: (name) => name === fileName ? source : base.readFile(name),
+    writeFile: () => {
+    }
+  };
+  const program = ts2.createProgram([fileName], compilerOptions, host);
+  const sf = program.getSourceFile(fileName);
+  if (sf === void 0) {
+    throw new Error(`expression lowering: virtual source file '${fileName}' missing.`);
+  }
+  const syntactic = program.getSyntacticDiagnostics(sf);
+  if (syntactic.length > 0) {
+    const diagnostics = syntactic.map((d) => {
+      const pos = d.start ?? 0;
+      const { line, character } = sf.getLineAndCharacterOfPosition(pos);
+      return {
+        code: "scp-syntax",
+        category: "error",
+        message: `Expression does not parse: ${ts2.flattenDiagnosticMessageText(d.messageText, " ")}`,
+        construct: "syntax error",
+        file: fileName,
+        line: line + 1,
+        column: character + 1
+      };
+    });
+    return { result: { diagnostics, errorCount: diagnostics.length }, exprLine };
+  }
+  let target;
+  let inputDecl;
+  let itemDecl;
+  for (const stmt of sf.statements) {
+    if (!ts2.isVariableStatement(stmt)) continue;
+    for (const decl of stmt.declarationList.declarations) {
+      if (!ts2.isIdentifier(decl.name)) continue;
+      if (decl.name.text === TEXT_ENTRY_BINDING && decl.initializer !== void 0) {
+        target = decl.initializer;
+      } else if (decl.name.text === inputName && inputDecl === void 0) {
+        inputDecl = decl.name;
+      } else if (decl.name.text === itemName && itemDecl === void 0) {
+        itemDecl = decl.name;
+      }
+    }
+  }
+  if (target === void 0) {
+    throw new Error("expression lowering: synthesized target binding missing.");
+  }
+  const checker = program.getTypeChecker();
+  const inputSymbol = inputDecl !== void 0 ? checker.getSymbolAtLocation(inputDecl) : void 0;
+  if (inputSymbol === void 0) {
+    throw new Error(
+      `expression lowering: the synthesized input binding '${inputName}' did not resolve to a symbol (internal error \u2014 fail-closed).`
+    );
+  }
+  const itemSymbol = options.itemInputs !== void 0 && itemDecl !== void 0 ? checker.getSymbolAtLocation(itemDecl) : void 0;
+  if (options.itemInputs !== void 0 && itemSymbol === void 0) {
+    throw new Error(
+      `expression lowering: the synthesized element binding '${itemName}' did not resolve to a symbol (internal error \u2014 fail-closed).`
+    );
+  }
+  const { result, kind, nullable } = lowerTsExpressionWithKind(target, {
+    checker,
+    sourceFile: sf,
+    fileName,
+    inputRootSymbols: /* @__PURE__ */ new Set([inputSymbol]),
+    inputFields: new Set(Object.keys(inputs)),
+    ...itemSymbol !== void 0 ? {
+      itemRootSymbols: /* @__PURE__ */ new Set([itemSymbol]),
+      itemFields: new Set(Object.keys(options.itemInputs ?? {}))
+    } : {}
+  });
+  return {
+    result,
+    exprLine,
+    ...kind !== void 0 ? { kind } : {},
+    ...nullable !== void 0 ? { nullable } : {}
+  };
+}
+function lowerExpressionTextOrThrow(exprText, options = {}) {
+  const result = lowerExpressionText(exprText, options);
+  if (result.expression === void 0) {
+    throw new ExpressionLowerError(result.diagnostics);
+  }
+  return result.expression;
+}
+
+// src/transform/structural-lower.ts
+import ts3 from "typescript";
+var WRITE_OPS = /* @__PURE__ */ new Set([
+  "put",
+  "update",
+  "delete",
+  "conditionCheck"
+]);
+var OPTIONS_ARG_INDEX = {
+  put: 2,
+  update: 3,
+  delete: 2,
+  conditionCheck: 2
+};
+function unwrapExpr3(e) {
+  let cur = e;
+  for (; ; ) {
+    if (ts3.isParenthesizedExpression(cur)) cur = cur.expression;
+    else if (ts3.isAsExpression(cur)) cur = cur.expression;
+    else if (ts3.isSatisfiesExpression(cur)) cur = cur.expression;
+    else if (ts3.isNonNullExpression(cur)) cur = cur.expression;
+    else if (ts3.isTypeAssertionExpression(cur)) cur = cur.expression;
+    else return cur;
+  }
+}
+function referencesIdentifier(node, name) {
+  let found = false;
+  const visit = (n) => {
+    if (found) return;
+    if (ts3.isIdentifier(n) && n.text === name) {
+      const parent = n.parent;
+      if (parent !== void 0) {
+        if (ts3.isPropertyAccessExpression(parent) && parent.name === n) return;
+        if (ts3.isPropertyAssignment(parent) && parent.name === n) return;
+        if (ts3.isQualifiedName(parent) && parent.right === n) return;
+      }
+      found = true;
+      return;
+    }
+    ts3.forEachChild(n, visit);
+  };
+  visit(node);
+  return found;
+}
+function scalarParamTypeText(expr) {
+  const e = unwrapExpr3(expr);
+  if (!ts3.isCallExpression(e) || !ts3.isPropertyAccessExpression(e.expression)) {
+    return void 0;
+  }
+  const kind = e.expression.name.text;
+  if (kind === "string") return "string";
+  if (kind === "number") return "number";
+  if (kind !== "literal") return void 0;
+  const parts = [];
+  for (let i = 0; i < e.arguments.length; i += 1) {
+    const arg = unwrapExpr3(e.arguments[i]);
+    if (i === e.arguments.length - 1 && ts3.isObjectLiteralExpression(arg)) break;
+    if (ts3.isStringLiteralLike(arg)) {
+      parts.push(JSON.stringify(arg.text));
+    } else if (ts3.isNumericLiteral(arg)) {
+      parts.push(arg.text);
+    } else if (ts3.isPrefixUnaryExpression(arg) && arg.operator === ts3.SyntaxKind.MinusToken && ts3.isNumericLiteral(arg.operand)) {
+      parts.push(`-${arg.operand.text}`);
+    } else {
+      return void 0;
+    }
+  }
+  return parts.length > 0 ? parts.join(" | ") : void 0;
+}
+function readParamsModel(expr) {
+  const obj = unwrapExpr3(expr);
+  if (!ts3.isObjectLiteralExpression(obj)) return void 0;
+  const scalars = /* @__PURE__ */ new Map();
+  const arrays = /* @__PURE__ */ new Map();
+  for (const prop of obj.properties) {
+    if (!ts3.isPropertyAssignment(prop) || !ts3.isIdentifier(prop.name) && !ts3.isStringLiteralLike(prop.name)) {
+      return void 0;
+    }
+    const name = prop.name.text;
+    const init = unwrapExpr3(prop.initializer);
+    if (ts3.isCallExpression(init) && ts3.isPropertyAccessExpression(init.expression) && init.expression.name.text === "array") {
+      const shape = init.arguments.length >= 1 ? unwrapExpr3(init.arguments[0]) : void 0;
+      if (shape === void 0 || !ts3.isObjectLiteralExpression(shape)) return void 0;
+      const fields = /* @__PURE__ */ new Map();
+      for (const f of shape.properties) {
+        if (!ts3.isPropertyAssignment(f) || !ts3.isIdentifier(f.name) && !ts3.isStringLiteralLike(f.name)) {
+          return void 0;
+        }
+        const t2 = scalarParamTypeText(f.initializer);
+        if (t2 === void 0) return void 0;
+        fields.set(f.name.text, t2);
+      }
+      arrays.set(name, fields);
+      continue;
+    }
+    const t = scalarParamTypeText(prop.initializer);
+    if (t === void 0) return void 0;
+    scalars.set(name, t);
+  }
+  return { scalars, arrays };
+}
+function conditionInputs(params) {
+  const out = {};
+  for (const [name, t] of params.scalars) out[name] = t;
+  for (const [name, fields] of params.arrays) {
+    const rec = [...fields].map(([f, t]) => `readonly ${JSON.stringify(f)}: ${t};`);
+    out[name] = `ReadonlyArray<{ ${rec.join(" ")} }>`;
+  }
+  return out;
+}
+function report3(ctx, node, code, construct, message) {
+  const { line, character } = ctx.sf.getLineAndCharacterOfPosition(node.getStart(ctx.sf));
+  ctx.diagnostics.push({
+    code,
+    category: "error",
+    message,
+    construct,
+    file: ctx.fileName,
+    line: line + 1,
+    column: character + 1
+  });
+  return void 0;
+}
+function formatStructuralLowerDiagnostic(d) {
+  return `${d.file}:${d.line}:${d.column} \u2014 SCP structural lowering error [${d.construct}]: ${d.message}`;
+}
+function createSingleFileChecker(sf, fileName, sourceText) {
+  const compilerOptions = {
+    noResolve: true,
+    noLib: true,
+    allowJs: true,
+    noEmit: true,
+    target: ts3.ScriptTarget.Latest,
+    module: ts3.ModuleKind.ESNext
+  };
+  const host = {
+    getSourceFile: (name) => name === fileName ? sf : void 0,
+    getDefaultLibFileName: () => "lib.d.ts",
+    writeFile: () => {
+    },
+    getCurrentDirectory: () => "",
+    getCanonicalFileName: (f) => f,
+    useCaseSensitiveFileNames: () => true,
+    getNewLine: () => "\n",
+    fileExists: (name) => name === fileName,
+    readFile: (name) => name === fileName ? sourceText : void 0
+  };
+  return ts3.createProgram([fileName], compilerOptions, host).getTypeChecker();
+}
+function verifyConditionRootBindings(ctx, scope, cond) {
+  const expected = /* @__PURE__ */ new Map();
+  if (scope.element !== void 0) {
+    expected.set(scope.element.name, {
+      symbol: scope.element.symbol,
+      origin: "fan-out element parameter"
+    });
+  }
+  if (scope.pName !== void 0 && !expected.has(scope.pName)) {
+    expected.set(scope.pName, {
+      symbol: scope.pSymbol,
+      origin: "defineScpTransaction params parameter"
+    });
+  }
+  if (expected.size === 0) return true;
+  let ok = true;
+  const visit = (n) => {
+    if (ts3.isIdentifier(n)) {
+      const exp = expected.get(n.text);
+      if (exp !== void 0) {
+        const parent = n.parent;
+        const isPropertyPosition = parent !== void 0 && (ts3.isPropertyAccessExpression(parent) && parent.name === n || ts3.isPropertyAssignment(parent) && parent.name === n || ts3.isQualifiedName(parent) && parent.right === n);
+        if (!isPropertyPosition) {
+          const symbol = ctx.checker.getSymbolAtLocation(n);
+          if (exp.symbol === void 0 || symbol === void 0 || symbol !== exp.symbol) {
+            report3(
+              ctx,
+              n,
+              "scp-ref",
+              n.text,
+              `'${n.text}' here does not resolve to the ${exp.origin} \u2014 it is shadowed by another declaration (a nested parameter, a block-scoped binding, or an import of the same name). Input Port references are matched by symbol identity, never by name (issue #264); rename the shadowing binding.`
+            );
+            ok = false;
+          }
+        }
+      }
+    }
+    ts3.forEachChild(n, visit);
+  };
+  visit(cond);
+  return ok;
+}
+function lowerCondition(ctx, scope, cond) {
+  if (scope.params === void 0) {
+    return report3(
+      ctx,
+      scope.paramsNode,
+      "scp-params",
+      "params",
+      "The defineScpTransaction params map must be an inline object literal of `param.*` factories \u2014 the guard condition types are derived from it for the monomorphic Expression IR lowering (fail-closed)."
+    );
+  }
+  if (!verifyConditionRootBindings(ctx, scope, cond)) return void 0;
+  const exprText = ctx.sourceText.slice(cond.getStart(ctx.sf), cond.getEnd());
+  const { result, exprLine, kind, nullable } = lowerExpressionTextWithLayout(exprText, {
+    inputs: conditionInputs(scope.params),
+    inputName: scope.pName ?? "$",
+    ...scope.element !== void 0 ? {
+      itemInputs: Object.fromEntries(scope.element.fields),
+      itemName: scope.element.name
+    } : {},
+    fileName: ctx.fileName
+  });
+  if (result.expression !== void 0) {
+    if (kind !== "bool" || nullable === true) {
+      return report3(
+        ctx,
+        cond,
+        "scp-type",
+        "truthiness",
+        `A structural guard condition must be a non-null boolean expression, got ${kind === void 0 ? "an unresolvable type" : `${kind}${nullable === true ? " | null" : ""}`} \u2014 truthiness coercion is outside the Expression IR closed set (compare explicitly instead, e.g. \`!== null\` / \`=== value\`).`
+      );
+    }
+    return result.expression;
+  }
+  const { line: condLine0, character: condCol0 } = ctx.sf.getLineAndCharacterOfPosition(
+    cond.getStart(ctx.sf)
+  );
+  for (const d of result.diagnostics) {
+    ctx.diagnostics.push(remapDiagnostic(d, exprLine, condLine0 + 1, condCol0 + 1));
+  }
+  return void 0;
+}
+function remapDiagnostic(d, exprLine, condLine, condCol) {
+  const inExpr = d.line >= exprLine;
+  return {
+    code: d.code,
+    category: "error",
+    message: d.message,
+    construct: d.construct,
+    file: d.file,
+    line: inExpr ? condLine + (d.line - exprLine) : condLine,
+    column: inExpr ? d.line === exprLine ? condCol + d.column - 1 : d.column : condCol
+  };
+}
+function notOf(expression) {
+  return canonicalizeExpressionSpec(
+    { exprVersion: EXPR_VERSION, expr: { not: [expression.expr] } },
+    "structural lowering (\u03A6 else-guard)"
+  );
+}
+function writeCallOp(e, txName) {
+  if (!ts3.isCallExpression(e)) return void 0;
+  const callee = e.expression;
+  if (!ts3.isPropertyAccessExpression(callee)) return void 0;
+  const recv = unwrapExpr3(callee.expression);
+  if (!ts3.isIdentifier(recv) || recv.text !== txName) return void 0;
+  return WRITE_OPS.has(callee.name.text) ? callee.name.text : void 0;
+}
+function validateWriteTarget(ctx, call, op, txName, attachingGuard) {
+  for (const arg of call.arguments) {
+    if (referencesIdentifier(arg, txName)) {
+      report3(
+        ctx,
+        arg,
+        "scp-structural",
+        op,
+        `A recorder reference ('${txName}') inside a write's arguments is not a lowerable structural shape \u2014 writes do not nest (semantic-contract-programming.md: Component \u5BA3\u8A00\u306F\u69CB\u9020\u5316\u69CB\u6587\u306E\u672C\u4F53\u306B\u306E\u307F\u73FE\u308C\u308B).`
+      );
+      return false;
+    }
+  }
+  if (attachingGuard) {
+    const options = optionsArgument(call, op);
+    if (options !== void 0 && ts3.isObjectLiteralExpression(options)) {
+      for (const prop of options.properties) {
+        if (ts3.isSpreadAssignment(prop)) {
+          report3(
+            ctx,
+            prop,
+            "scp-structural",
+            op,
+            "A spread inside the options of a guarded write is not lowerable \u2014 it could carry a `guard` member that silently overrides the lowered condition at runtime. Spell the options out as plain properties (fail-closed, issue #263)."
+          );
+          return false;
+        }
+        const name = prop.name;
+        if (name !== void 0 && ts3.isComputedPropertyName(name)) {
+          report3(
+            ctx,
+            name,
+            "scp-structural",
+            op,
+            "A computed property name inside the options of a guarded write is not lowerable \u2014 it could evaluate to `guard` and silently override the lowered condition at runtime. Use a statically named property (fail-closed, issue #263)."
+          );
+          return false;
+        }
+        if (name !== void 0 && (ts3.isIdentifier(name) || ts3.isStringLiteralLike(name)) && name.text === "guard") {
+          report3(
+            ctx,
+            prop,
+            "scp-nesting",
+            "guard",
+            "guard-in-guard is a loud reject in v1 (issue #263): this write already carries a `guard` option. Compose the conditions into one guard instead \u2014 `(a && b) && tx.put(\u2026)`."
+          );
+          return false;
+        }
+      }
+    } else if (options !== void 0) {
+      report3(
+        ctx,
+        options,
+        "scp-structural",
+        op,
+        "A structural guard can only be merged into an inline options object literal \u2014 this write passes a non-literal options argument."
+      );
+      return false;
+    }
+  }
+  return true;
+}
+function optionsArgument(call, op) {
+  const idx = OPTIONS_ARG_INDEX[op];
+  return call.arguments.length > idx ? call.arguments[idx] : void 0;
+}
+function guardOptionEdit(ctx, call, op, guardJson) {
+  const options = optionsArgument(call, op);
+  if (options !== void 0 && ts3.isObjectLiteralExpression(options)) {
+    if (options.properties.length > 0) {
+      const at2 = options.properties[0].getStart(ctx.sf);
+      return { pos: at2, end: at2, insert: `guard: ${guardJson}, ` };
+    }
+    return {
+      pos: options.getStart(ctx.sf),
+      end: options.getEnd(),
+      insert: `{ guard: ${guardJson} }`
+    };
+  }
+  const lastArg = call.arguments[call.arguments.length - 1];
+  const at = lastArg.getEnd();
+  return { pos: at, end: at, insert: `, { guard: ${guardJson} }` };
+}
+function writeCallTextWithGuard(ctx, call, op, guardJson) {
+  const start = call.getStart(ctx.sf);
+  const edit = guardOptionEdit(ctx, call, op, guardJson);
+  return ctx.sourceText.slice(start, edit.pos) + edit.insert + ctx.sourceText.slice(edit.end, call.getEnd());
+}
+function processStatementExpression(ctx, scope, expr, container, exprBody) {
+  if (!referencesIdentifier(expr, scope.txName)) return;
+  const e = unwrapExpr3(expr);
+  {
+    const op = writeCallOp(e, scope.txName);
+    if (op !== void 0) {
+      validateWriteTarget(ctx, e, op, scope.txName, false);
+      return;
+    }
+  }
+  if (isForEachCall(e, scope.txName)) {
+    processForEachCall(ctx, scope, e);
+    return;
+  }
+  if (ts3.isBinaryExpression(e) && e.operatorToken.kind === ts3.SyntaxKind.AmpersandAmpersandToken) {
+    processGuard(ctx, scope, e);
+    return;
+  }
+  if (ts3.isConditionalExpression(e)) {
+    processConditional(ctx, scope, e, container, exprBody);
+    return;
+  }
+  if (ts3.isCallExpression(e) && ts3.isPropertyAccessExpression(e.expression) && e.expression.name.text === "map") {
+    processMap(ctx, scope, e);
+    return;
+  }
+  report3(
+    ctx,
+    expr,
+    "scp-structural",
+    ts3.SyntaxKind[e.kind],
+    `This statement contains a write declaration ('${scope.txName}.*') in an undecidable structural shape. The lowerable forms are: a plain write, \`cond && tx.<write>(\u2026)\` (Guard), \`cond ? tx.<write>(\u2026) : tx.<write>(\u2026)\` (Conditional), and \`p.<arrayParam>.map(($el) => \u2026)\` (Map) \u2014 anything else is a loud reject, never a silent path (issue #263).`
+  );
+}
+function isForEachCall(e, txName) {
+  return ts3.isCallExpression(e) && ts3.isPropertyAccessExpression(e.expression) && e.expression.name.text === "forEach" && ts3.isIdentifier(unwrapExpr3(e.expression.expression)) && unwrapExpr3(e.expression.expression).text === txName;
+}
+function assertPureCondition(ctx, scope, cond, construct) {
+  if (referencesIdentifier(cond, scope.txName)) {
+    report3(
+      ctx,
+      cond,
+      "scp-structural",
+      construct,
+      `The condition of a structural \`${construct}\` must be a pure expression \u2014 it contains a write declaration ('${scope.txName}.*'). A Component-bearing branch is structure, never Expression IR (semantic-contract-programming.md: \u69CB\u9020\u5316 / Expression \u306E dispatch).`
+    );
+    return false;
+  }
+  return true;
+}
+function processGuard(ctx, scope, e) {
+  const right = unwrapExpr3(e.right);
+  const op = writeCallOp(right, scope.txName);
+  if (op === void 0) {
+    if (ts3.isBinaryExpression(right) && right.operatorToken.kind === ts3.SyntaxKind.AmpersandAmpersandToken && referencesIdentifier(right, scope.txName)) {
+      report3(
+        ctx,
+        right,
+        "scp-nesting",
+        "&&",
+        "guard-in-guard is a loud reject in v1 (decided in issue #263): nest no guard inside a guard body \u2014 compose the conditions instead: `(a && b) && tx.put(\u2026)` (note `a && b && tx.put(\u2026)` already parses that way)."
+      );
+      return;
+    }
+    if (ts3.isConditionalExpression(right) && referencesIdentifier(right, scope.txName)) {
+      report3(
+        ctx,
+        right,
+        "scp-nesting",
+        "&&",
+        "A guarded conditional (`a && (b ? A(\u2026) : B(\u2026))`) is a loud reject in v1 (issue #263) \u2014 write two guarded items or compose each branch condition with `&&`."
+      );
+      return;
+    }
+    report3(
+      ctx,
+      e,
+      "scp-structural",
+      "&&",
+      "The right side of a structural guard must be a single write declaration (`cond && tx.put(\u2026)`); this shape is undecidable and loud-rejected (issue #263)."
+    );
+    return;
+  }
+  if (!assertPureCondition(ctx, scope, e.left, "&&")) return;
+  if (!validateWriteTarget(ctx, right, op, scope.txName, true)) {
+    return;
+  }
+  const guard = lowerCondition(ctx, scope, e.left);
+  if (guard === void 0) return;
+  ctx.edits.push({
+    pos: e.getStart(ctx.sf),
+    end: e.right.getStart(ctx.sf),
+    insert: ""
+  });
+  ctx.edits.push(
+    guardOptionEdit(ctx, right, op, JSON.stringify(guard))
+  );
+  ctx.guardCount += 1;
+}
+function processConditional(ctx, scope, e, container, exprBody) {
+  const whenTrue = unwrapExpr3(e.whenTrue);
+  const whenFalse = unwrapExpr3(e.whenFalse);
+  const opTrue = writeCallOp(whenTrue, scope.txName);
+  const opFalse = writeCallOp(whenFalse, scope.txName);
+  if (opTrue === void 0 || opFalse === void 0) {
+    const offending = opTrue === void 0 ? whenTrue : whenFalse;
+    if (referencesIdentifier(offending, scope.txName)) {
+      report3(
+        ctx,
+        offending,
+        "scp-nesting",
+        "?:",
+        "A conditional branch may only be a single write declaration in v1 (issue #263) \u2014 nested guards / ternary chains are loud rejects. Write explicit guarded items (`cond && tx.put(\u2026)`) with composed conditions instead."
+      );
+      return;
+    }
+    report3(
+      ctx,
+      offending,
+      "scp-structural",
+      "?:",
+      "Both branches of a structural conditional must be write declarations (`cond ? tx.put(A, \u2026) : tx.put(B, \u2026)`). For a one-sided write use the guard form `cond && tx.put(\u2026)` (an unguarded else does not exist at the transaction seam \u2014 semantic-contract-programming.md \u03A6)."
+    );
+    return;
+  }
+  if (!assertPureCondition(ctx, scope, e.condition, "?:")) return;
+  const okTrue = validateWriteTarget(
+    ctx,
+    whenTrue,
+    opTrue,
+    scope.txName,
+    true
+  );
+  const okFalse = validateWriteTarget(
+    ctx,
+    whenFalse,
+    opFalse,
+    scope.txName,
+    true
+  );
+  if (!okTrue || !okFalse) return;
+  const guard = lowerCondition(ctx, scope, e.condition);
+  if (guard === void 0) return;
+  const thenText = writeCallTextWithGuard(
+    ctx,
+    whenTrue,
+    opTrue,
+    JSON.stringify(guard)
+  );
+  const elseText = writeCallTextWithGuard(
+    ctx,
+    whenFalse,
+    opFalse,
+    JSON.stringify(notOf(guard))
+  );
+  if (exprBody) {
+    ctx.edits.push({
+      pos: e.getStart(ctx.sf),
+      end: e.getEnd(),
+      insert: `{ ${thenText}; ${elseText}; }`
+    });
+  } else {
+    const stmtStart = container.getStart(ctx.sf);
+    const lineStart = ctx.sourceText.lastIndexOf("\n", stmtStart - 1) + 1;
+    const lead = ctx.sourceText.slice(lineStart, stmtStart);
+    const indent = /^[ \t]*$/.test(lead) ? lead : "";
+    ctx.edits.push({
+      pos: container.getStart(ctx.sf),
+      end: container.getEnd(),
+      insert: `${thenText};
+${indent}${elseText};`
+    });
+  }
+  ctx.conditionalCount += 1;
+}
+function processMap(ctx, scope, e) {
+  const callee = e.expression;
+  const recv = unwrapExpr3(callee.expression);
+  if (scope.element !== void 0) {
+    report3(
+      ctx,
+      e,
+      "scp-map",
+      ".map",
+      "Nested `.map` fan-out is not supported \u2014 the forEach seam is single-level (the recorder rejects nested forEach identically); flatten the iteration."
+    );
+    return;
+  }
+  const recvRoot = ts3.isPropertyAccessExpression(recv) ? unwrapExpr3(recv.expression) : void 0;
+  const recvOk = ts3.isPropertyAccessExpression(recv) && recvRoot !== void 0 && ts3.isIdentifier(recvRoot) && scope.pName !== void 0 && recvRoot.text === scope.pName && scope.pSymbol !== void 0 && ctx.checker.getSymbolAtLocation(recvRoot) === scope.pSymbol;
+  const arrayName = recvOk ? recv.name.text : void 0;
+  if (scope.params === void 0) {
+    report3(
+      ctx,
+      scope.paramsNode,
+      "scp-params",
+      ".map",
+      "The defineScpTransaction params map must be an inline object literal of `param.*` factories \u2014 the `.map` fan-out binds to a declared array param (fail-closed)."
+    );
+    return;
+  }
+  const fields = arrayName !== void 0 ? scope.params.arrays.get(arrayName) : void 0;
+  if (!recvOk || arrayName === void 0 || fields === void 0) {
+    report3(
+      ctx,
+      recv,
+      "scp-map",
+      ".map",
+      `A \`.map\` fan-out is only lowerable over a declared array param (\`${scope.pName ?? "p"}.<name>\` where the params map declares \`param.array({\u2026})\`) \u2014 the array-Port restriction that guarantees termination (semantic-contract-programming.md Map).`
+    );
+    return;
+  }
+  if (e.arguments.length !== 1) {
+    report3(
+      ctx,
+      e,
+      "scp-map",
+      ".map",
+      "A `.map` fan-out takes exactly the inline callback (no thisArg)."
+    );
+    return;
+  }
+  const cb = unwrapExpr3(e.arguments[0]);
+  if (!ts3.isArrowFunction(cb)) {
+    report3(
+      ctx,
+      e.arguments[0],
+      "scp-map",
+      ".map",
+      "The `.map` callback must be an inline arrow function (the AST must be lowerable \u2014 semantic-contract-programming.md Map)."
+    );
+    return;
+  }
+  if (cb.parameters.length !== 1 || !ts3.isIdentifier(cb.parameters[0].name)) {
+    report3(
+      ctx,
+      cb,
+      "scp-map",
+      ".map",
+      "The `.map` callback takes exactly one plain identifier parameter (the element, v1) \u2014 no destructuring, no index parameter."
+    );
+    return;
+  }
+  const elName = cb.parameters[0].name.text;
+  if (elName === scope.txName || scope.pName !== void 0 && elName === scope.pName) {
+    report3(
+      ctx,
+      cb.parameters[0],
+      "scp-map",
+      ".map",
+      `The element parameter '${elName}' shadows the ${elName === scope.txName ? "recorder" : "params"} parameter \u2014 rename it.`
+    );
+    return;
+  }
+  const before = ctx.diagnostics.length;
+  const elementScope = {
+    ...scope,
+    element: {
+      name: elName,
+      symbol: ctx.checker.getSymbolAtLocation(cb.parameters[0].name),
+      fields
+    }
+  };
+  if (ts3.isBlock(cb.body)) {
+    for (const stmt of cb.body.statements) {
+      processBodyStatement(ctx, elementScope, stmt);
+    }
+  } else {
+    processStatementExpression(ctx, elementScope, cb.body, cb.body, true);
+  }
+  if (ctx.diagnostics.length > before) return;
+  ctx.edits.push({
+    pos: recv.getStart(ctx.sf),
+    end: recv.getStart(ctx.sf),
+    insert: `${scope.txName}.forEach(`
+  });
+  ctx.edits.push({
+    pos: recv.getEnd(),
+    end: cb.getStart(ctx.sf),
+    insert: ", "
+  });
+  ctx.mapCount += 1;
+}
+function processForEachCall(ctx, scope, e) {
+  if (scope.element !== void 0) {
+    report3(
+      ctx,
+      e,
+      "scp-map",
+      "forEach",
+      "Nested fan-out (`tx.forEach` inside a `.map` body) is not supported \u2014 the forEach seam is single-level; flatten the iteration."
+    );
+    return;
+  }
+  if (e.arguments.length < 2) return;
+  const cb = unwrapExpr3(e.arguments[1]);
+  if (!ts3.isArrowFunction(cb) && !ts3.isFunctionExpression(cb)) {
+    return;
+  }
+  const src = unwrapExpr3(e.arguments[0]);
+  let fields;
+  if (ts3.isPropertyAccessExpression(src) && scope.pName !== void 0) {
+    const srcRoot = unwrapExpr3(src.expression);
+    if (ts3.isIdentifier(srcRoot) && srcRoot.text === scope.pName && scope.pSymbol !== void 0 && ctx.checker.getSymbolAtLocation(srcRoot) === scope.pSymbol) {
+      fields = scope.params?.arrays.get(src.name.text);
+    }
+  }
+  const elParam = cb.parameters[0];
+  const elName = elParam !== void 0 && ts3.isIdentifier(elParam.name) ? elParam.name.text : void 0;
+  if (elName !== void 0 && (elName === scope.txName || scope.pName !== void 0 && elName === scope.pName)) {
+    report3(
+      ctx,
+      elParam,
+      "scp-map",
+      "forEach",
+      `The forEach element parameter '${elName}' shadows the ${elName === scope.txName ? "recorder" : "params"} parameter \u2014 rename it.`
+    );
+    return;
+  }
+  const elementScope = elName !== void 0 ? {
+    ...scope,
+    element: {
+      name: elName,
+      symbol: ctx.checker.getSymbolAtLocation(elParam.name),
+      fields: fields ?? /* @__PURE__ */ new Map()
+    }
+  } : scope;
+  if (ts3.isBlock(cb.body)) {
+    for (const stmt of cb.body.statements) {
+      processBodyStatement(ctx, elementScope, stmt);
+    }
+  } else if (ts3.isArrowFunction(cb)) {
+    processStatementExpression(ctx, elementScope, cb.body, cb.body, true);
+  }
+}
+function processBodyStatement(ctx, scope, stmt) {
+  if (ts3.isExpressionStatement(stmt)) {
+    processStatementExpression(ctx, scope, stmt.expression, stmt, false);
+    return;
+  }
+  if (referencesIdentifier(stmt, scope.txName)) {
+    report3(
+      ctx,
+      stmt,
+      "scp-structural",
+      ts3.SyntaxKind[stmt.kind],
+      `A write declaration ('${scope.txName}.*') inside a ${ts3.SyntaxKind[stmt.kind]} is not a lowerable structural shape \u2014 only expression statements lower (issue #263; loud, never silent).`
+    );
+  }
+}
+var SCP_DEFINE_NAME = "defineScpTransaction";
+function collectScpImportNames(sf) {
+  const locals = /* @__PURE__ */ new Set();
+  const namespaces = /* @__PURE__ */ new Set();
+  for (const stmt of sf.statements) {
+    if (!ts3.isImportDeclaration(stmt) || stmt.importClause === void 0) continue;
+    const bindings = stmt.importClause.namedBindings;
+    if (bindings === void 0) continue;
+    if (ts3.isNamespaceImport(bindings)) {
+      namespaces.add(bindings.name.text);
+    } else {
+      for (const spec of bindings.elements) {
+        if ((spec.propertyName ?? spec.name).text === SCP_DEFINE_NAME) {
+          locals.add(spec.name.text);
+        }
+      }
+    }
+  }
+  return { locals, namespaces };
+}
+function isScpDefineCall(node, names) {
+  const callee = unwrapExpr3(node.expression);
+  if (ts3.isIdentifier(callee)) return names.locals.has(callee.text);
+  if (ts3.isPropertyAccessExpression(callee) && callee.name.text === SCP_DEFINE_NAME) {
+    const root = unwrapExpr3(callee.expression);
+    return ts3.isIdentifier(root) && names.namespaces.has(root.text);
+  }
+  return false;
+}
+function transformScpTransactionSource(fileName, sourceText, options = {}) {
+  const mode = options.mode ?? "transform";
+  const scriptKind = fileName.endsWith(".tsx") ? ts3.ScriptKind.TSX : fileName.endsWith(".jsx") ? ts3.ScriptKind.JSX : ts3.ScriptKind.TS;
+  const sf = ts3.createSourceFile(
+    fileName,
+    sourceText,
+    ts3.ScriptTarget.Latest,
+    /* setParentNodes */
+    true,
+    scriptKind
+  );
+  const ctx = {
+    sf,
+    fileName,
+    sourceText,
+    checker: createSingleFileChecker(sf, fileName, sourceText),
+    diagnostics: [],
+    edits: [],
+    guardCount: 0,
+    conditionalCount: 0,
+    mapCount: 0
+  };
+  const names = collectScpImportNames(sf);
+  const visit = (node) => {
+    if (ts3.isCallExpression(node) && isScpDefineCall(node, names)) {
+      processDefineCall(ctx, node);
+    }
+    ts3.forEachChild(node, visit);
+  };
+  visit(sf);
+  const errorCount = ctx.diagnostics.length;
+  if (errorCount > 0 || mode === "check" || ctx.edits.length === 0) {
+    return {
+      fileName,
+      text: sourceText,
+      changed: false,
+      guardCount: errorCount > 0 ? 0 : ctx.guardCount,
+      conditionalCount: errorCount > 0 ? 0 : ctx.conditionalCount,
+      mapCount: errorCount > 0 ? 0 : ctx.mapCount,
+      diagnostics: ctx.diagnostics,
+      errorCount
+    };
+  }
+  const edits = [...ctx.edits].sort((a, b) => b.pos - a.pos || b.end - a.end);
+  let text = sourceText;
+  for (const e of edits) {
+    text = text.slice(0, e.pos) + e.insert + text.slice(e.end);
+  }
+  return {
+    fileName,
+    text,
+    changed: text !== sourceText,
+    guardCount: ctx.guardCount,
+    conditionalCount: ctx.conditionalCount,
+    mapCount: ctx.mapCount,
+    diagnostics: ctx.diagnostics,
+    errorCount: 0
+  };
+}
+function processDefineCall(ctx, call) {
+  if (call.arguments.length < 2) {
+    report3(
+      ctx,
+      call,
+      "scp-params",
+      SCP_DEFINE_NAME,
+      "defineScpTransaction takes (params, (tx, p) => { \u2026 })."
+    );
+    return;
+  }
+  const cb = unwrapExpr3(call.arguments[1]);
+  if (!ts3.isArrowFunction(cb) && !ts3.isFunctionExpression(cb)) {
+    report3(
+      ctx,
+      call.arguments[1],
+      "scp-params",
+      SCP_DEFINE_NAME,
+      "The defineScpTransaction body must be an inline arrow / function expression \u2014 the native-syntax form is lowered from the source AST and cannot be verified through an indirect reference (fail-closed)."
+    );
+    return;
+  }
+  const txParam = cb.parameters[0];
+  if (txParam === void 0 || !ts3.isIdentifier(txParam.name)) {
+    report3(
+      ctx,
+      cb,
+      "scp-params",
+      SCP_DEFINE_NAME,
+      "The defineScpTransaction body must name its recorder parameter as a plain identifier (`(tx, p) => \u2026`)."
+    );
+    return;
+  }
+  const pParam = cb.parameters[1];
+  if (pParam !== void 0 && !ts3.isIdentifier(pParam.name)) {
+    report3(
+      ctx,
+      pParam,
+      "scp-params",
+      SCP_DEFINE_NAME,
+      "The defineScpTransaction params parameter must be a plain identifier (no destructuring) \u2014 conditions are typed from the params map."
+    );
+    return;
+  }
+  if (call.arguments.length >= 3) {
+    const third = call.arguments[2];
+    if (!ts3.isStringLiteral(third) || third.text !== SCP_LOWERED_MARKER) {
+      report3(
+        ctx,
+        third,
+        "scp-params",
+        SCP_DEFINE_NAME,
+        `Unexpected third argument to defineScpTransaction \u2014 the lowered-body marker ('${SCP_LOWERED_MARKER}') is stamped by the transform itself; remove the argument and re-run the transform.`
+      );
+      return;
+    }
+  } else {
+    const at = call.arguments[1].getEnd();
+    ctx.edits.push({ pos: at, end: at, insert: `, '${SCP_LOWERED_MARKER}'` });
+  }
+  const pSymbol = pParam !== void 0 ? ctx.checker.getSymbolAtLocation(pParam.name) : void 0;
+  const scope = {
+    txName: txParam.name.text,
+    pName: pParam !== void 0 ? pParam.name.text : void 0,
+    pSymbol,
+    params: readParamsModel(call.arguments[0]),
+    paramsNode: call.arguments[0]
+  };
+  if (ts3.isBlock(cb.body)) {
+    for (const stmt of cb.body.statements) {
+      processBodyStatement(ctx, scope, stmt);
+    }
+  } else {
+    processStatementExpression(ctx, scope, cb.body, cb.body, true);
+  }
+}
 export {
   AOT_LOADER_LOCAL,
   AOT_PLANS_LOCAL,
   AOT_SHIM_EXPORT,
+  ExpressionLowerError,
   HOIST_SLOT_PREFIX,
+  formatExpressionLowerDiagnostic,
+  formatStructuralLowerDiagnostic,
+  inputParamTypeText,
   lintPreparedSource,
+  lowerExpressionText,
+  lowerExpressionTextOrThrow,
+  lowerTsExpression,
   transformPreparedSource,
-  transformPreparedSourceAot
+  transformPreparedSourceAot,
+  transformScpTransactionSource
 };