@chenglou/freerange 0.0.2 → 0.0.3

package/dist/fr.js

@@ -3,7 +3,7 @@
 // src/project.ts
 import { existsSync, realpathSync } from "node:fs";
 import { resolve as resolve3 } from "node:path";
-import * as ts12 from "typescript";
+import * as ts13 from "typescript";
 
 // src/domain/number.ts
 var float64Scratch = new Float64Array(1);
@@ -663,6 +663,7 @@ function declaredKindOf(category) {
     case "kind":
       return category.declaredKind;
     case "importedConstant":
+    case "function":
     case "import":
     case "opaque":
       return null;
@@ -775,20 +776,61 @@ function siteLocation(program, site) {
   return { line: low + 1, column: span.start - lineStarts[low] + 1 };
 }
 
-// src/requirements/infer.ts
-function createExpressionContext(fn, parameterExpressions, parameterIdentityKeys, identityNamespace = `${fn.name}/`) {
-  const identityKeys = parameterIdentityKeys ?? fn.parameters.map((_, index) => `p${index}`);
-  if (identityKeys.length !== fn.parameters.length) {
-    throw new Error(`Expected ${fn.parameters.length} parameter identity keys for ${fn.name}`);
+// src/domain/value-identity.ts
+function createValueIdentityOwner(parent = null) {
+  return { kind: "valueIdentityOwner", parent };
+}
+function sameValueIdentity(left, right) {
+  if (left === right)
+    return true;
+  if (left.kind !== right.kind)
+    return false;
+  switch (left.kind) {
+    case "local":
+      return right.kind === "local" && left.owner === right.owner && left.value === right.value;
+    case "property":
+      return right.kind === "property" && left.property === right.property && sameValueIdentity(left.object, right.object);
+    case "arrayIndex":
+      return right.kind === "arrayIndex" && sameValueIdentity(left.array, right.array) && sameValueIdentity(left.index, right.index);
   }
+}
+function valueIdentityUsesOwner(identity, owner) {
+  switch (identity.kind) {
+    case "local": {
+      let current = identity.owner;
+      while (current != null) {
+        if (current === owner)
+          return true;
+        current = current.parent;
+      }
+      return false;
+    }
+    case "property":
+      return valueIdentityUsesOwner(identity.object, owner);
+    case "arrayIndex":
+      return valueIdentityUsesOwner(identity.array, owner) || valueIdentityUsesOwner(identity.index, owner);
+  }
+}
+
+// src/requirements/infer.ts
+function createExpressionContext(fn, parameterExpressions, parameterIdentities, identityOwner = createValueIdentityOwner()) {
   const context = {
     parameterExpressions,
-    parameterIdentityKeys: identityKeys,
-    identityNamespace,
+    parameterIdentities: [],
+    identityOwner,
+    identityByValue: [],
     parameterIndexByValue: [],
     instructionByValue: [],
     instructionCount: 0
   };
+  context.parameterIdentities = parameterIdentities ?? fn.parameters.map((parameter) => ({
+    kind: "local",
+    owner: identityOwner,
+    value: parameter.value
+  }));
+  if (context.parameterIdentities.length !== fn.parameters.length) {
+    throw new Error(`Expected ${fn.parameters.length} parameter identities for ${fn.name}`);
+  }
   for (let index = 0;index < fn.parameters.length; index++) {
     context.parameterIndexByValue[fn.parameters[index].value] = index;
   }
@@ -891,28 +933,58 @@ function staticRequirement(instruction, site, context, purpose) {
   }
   return null;
 }
-function canonicalValueKey(value, context) {
+function canonicalValueIdentity(value, context) {
+  const cached = context.identityByValue[value];
+  if (cached != null)
+    return cached;
   const stored = resolveStoredValue(value, context);
-  if (stored !== value)
-    return canonicalValueKey(stored, context);
+  if (stored !== value) {
+    const identity2 = canonicalValueIdentity(stored, context);
+    context.identityByValue[value] = identity2;
+    return identity2;
+  }
   const parameterIndex = context.parameterIndexByValue[value];
-  if (parameterIndex != null)
-    return context.parameterIdentityKeys[parameterIndex] ?? `p${parameterIndex}`;
+  if (parameterIndex != null) {
+    const identity2 = context.parameterIdentities[parameterIndex];
+    if (identity2 == null)
+      throw new Error(`Missing identity for parameter ${parameterIndex}`);
+    context.identityByValue[value] = identity2;
+    return identity2;
+  }
   const producer = context.instructionByValue[value];
+  let identity;
   if (producer?.kind === "property") {
-    return `${canonicalValueKey(producer.object, context)}.${JSON.stringify(producer.property)}`;
-  }
-  if (producer?.kind === "arrayLength")
-    return `${canonicalValueKey(producer.array, context)}.length`;
-  if (producer?.kind === "stringLength")
-    return `${canonicalValueKey(producer.value, context)}.length`;
-  if (producer?.kind === "arrayIndex") {
-    return `${canonicalValueKey(producer.array, context)}[${canonicalValueKey(producer.index, context)}]`;
+    identity = {
+      kind: "property",
+      object: canonicalValueIdentity(producer.object, context),
+      property: producer.property
+    };
+  } else if (producer?.kind === "arrayLength") {
+    identity = {
+      kind: "property",
+      object: canonicalValueIdentity(producer.array, context),
+      property: "length"
+    };
+  } else if (producer?.kind === "stringLength") {
+    identity = {
+      kind: "property",
+      object: canonicalValueIdentity(producer.value, context),
+      property: "length"
+    };
+  } else if (producer?.kind === "arrayIndex") {
+    identity = {
+      kind: "arrayIndex",
+      array: canonicalValueIdentity(producer.array, context),
+      index: canonicalValueIdentity(producer.index, context)
+    };
+  } else {
+    identity = { kind: "local", owner: context.identityOwner, value };
   }
-  return `v:${context.identityNamespace}${value}`;
+  context.identityByValue[value] = identity;
+  return identity;
 }
 function sameRuntimeValue(left, right, context) {
-  return left === right || canonicalValueKey(left, context) === canonicalValueKey(right, context);
+  return left === right || sameValueIdentity(canonicalValueIdentity(left, context), canonicalValueIdentity(right, context));
 }
 function addPrecondition(preconditions, candidate) {
   if (candidate.kind === "declaredNumberCheck") {
@@ -1078,10 +1150,10 @@ function completedEvaluation(evaluation) {
 
 // src/engine/state.ts
 function hasNonzeroFact(facts, value) {
-  return facts.some((fact) => fact.kind === "nonzero" && fact.value === value);
+  return facts.some((fact) => fact.kind === "nonzero" && sameValueIdentity(fact.value, value));
 }
 function hasIndexFact(facts, kind, index, array) {
-  return facts.some((fact) => fact.kind === kind && fact.index === index && fact.array === array);
+  return facts.some((fact) => fact.kind === kind && sameValueIdentity(fact.index, index) && sameValueIdentity(fact.array, array));
 }
 function addValueFact(facts, candidate) {
   if (!facts.some((fact) => sameValueFact(fact, candidate)))
@@ -1103,18 +1175,19 @@ function intersectValueFact(left, right) {
     return left;
   if (left.kind === "nonzero" || right.kind === "nonzero")
     return null;
-  if (left.index !== right.index || left.array !== right.array)
+  if (!sameValueIdentity(left.index, right.index) || !sameValueIdentity(left.array, right.array))
     return null;
   return { kind: "belowLength", index: left.index, array: left.array };
 }
 function sameValueFact(left, right) {
   if (left.kind !== right.kind)
     return false;
-  if (left.kind === "nonzero" && right.kind === "nonzero")
-    return left.value === right.value;
+  if (left.kind === "nonzero" && right.kind === "nonzero") {
+    return sameValueIdentity(left.value, right.value);
+  }
   if (left.kind === "nonzero" || right.kind === "nonzero")
     return false;
-  return left.index === right.index && left.array === right.array;
+  return sameValueIdentity(left.index, right.index) && sameValueIdentity(left.array, right.array);
 }
 function emptySharedState(moduleCount) {
   return Array.from({ length: moduleCount }, () => null);
@@ -1268,10 +1341,10 @@ function evaluateInstructionKinded(instruction, state, context) {
       const index = requiredNumberWithFacts(state, instruction.index, context.expressionContext);
       const element = sequence.kind === "tuple" ? tupleElement(sequence, index) : sequence.element;
       const length = sequence.kind === "tuple" ? constantNumber(sequence.elements.length) : sequence.length;
-      const indexKey = canonicalValueKey(instruction.index, context.expressionContext);
-      const arrayKey = canonicalValueKey(instruction.array, context.expressionContext);
-      const assumedValid = hasIndexFact(state.valueFacts, "validIndex", indexKey, arrayKey);
-      const inBounds = assumedValid || index.integer && !index.mayBeNaN && index.lower >= 0 && index.upper < length.lower || index.integer && !index.mayBeNaN && index.lower >= 0 && hasIndexFact(state.valueFacts, "belowLength", indexKey, arrayKey);
+      const indexIdentity = canonicalValueIdentity(instruction.index, context.expressionContext);
+      const arrayIdentity = canonicalValueIdentity(instruction.array, context.expressionContext);
+      const assumedValid = hasIndexFact(state.valueFacts, "validIndex", indexIdentity, arrayIdentity);
+      const inBounds = assumedValid || index.integer && !index.mayBeNaN && index.lower >= 0 && index.upper < length.lower || index.integer && !index.mayBeNaN && index.lower >= 0 && hasIndexFact(state.valueFacts, "belowLength", indexIdentity, arrayIdentity);
       const firstPossibleIndex = Math.ceil(Math.max(index.lower, 0));
       const lastPossibleIndex = Math.floor(Math.min(index.upper, length.upper - 1));
       const provablyOut = element == null || firstPossibleIndex > lastPossibleIndex;
@@ -1298,7 +1371,11 @@ function evaluateInstructionKinded(instruction, state, context) {
           addBoundsAssumption(context.boundsAssumptions, { site: instruction.site, kind: "elementInBounds" });
         }
         writeThroughProducers(state, instruction.index, validIndexNumber(index), context.expressionContext.instructionByValue);
-        addValueFact(state.valueFacts, { kind: "validIndex", index: indexKey, array: arrayKey });
+        addValueFact(state.valueFacts, {
+          kind: "validIndex",
+          index: indexIdentity,
+          array: arrayIdentity
+        });
       }
       return passthroughValue(element);
     }
@@ -1507,6 +1584,15 @@ function evaluateInstructionKinded(instruction, state, context) {
       return computedNumber(maximumNumbers(operands), operands, instruction.site);
     }
     case "call": {
+      if (instruction.binding != null && state.shared[instruction.binding] == null) {
+        return {
+          kind: "stop",
+          stop: {
+            site: instruction.site,
+            reason: { kind: "moduleRead", binding: instruction.binding }
+          }
+        };
+      }
       const callee = context.program.functions[instruction.function];
       if (callee == null)
         throw new Error(`Unknown function ${instruction.function}`);
@@ -1518,9 +1604,9 @@ function evaluateInstructionKinded(instruction, state, context) {
       }
       const arguments_ = instruction.arguments.map((id) => requiredValue(state, id));
       const argumentExpressions = instruction.arguments.map((id) => numericExpression(id, context.expressionContext));
-      const argumentKeys = instruction.arguments.map((id) => canonicalValueKey(id, context.expressionContext));
-      const calleeNamespace = `${context.expressionContext.identityNamespace}call:${instruction.function}:${instruction.site}/`;
-      const evaluation = context.evaluateFunction(instruction.function, arguments_, argumentExpressions, state.shared, context.callStack, state.valueFacts, argumentKeys, calleeNamespace);
+      const argumentIdentities = instruction.arguments.map((id) => canonicalValueIdentity(id, context.expressionContext));
+      const calleeOwner = createValueIdentityOwner(context.expressionContext.identityOwner);
+      const evaluation = context.evaluateFunction(instruction.function, arguments_, argumentExpressions, state.shared, context.callStack, state.valueFacts, argumentIdentities, calleeOwner);
       const completed = completedEvaluation(evaluation);
       if (completed == null) {
         if (evaluation.stops.length === 0 && evaluation.normal == null) {
@@ -1541,7 +1627,7 @@ function evaluateInstructionKinded(instruction, state, context) {
         return { kind: "stop", stop: { site: instruction.site, reason: { kind: "calleeStopped", callee: instruction.function } } };
       }
       state.shared = completed.sharedState;
-      state.valueFacts = completed.valueFacts.filter((fact) => !valueFactUsesNamespace(fact, calleeNamespace));
+      state.valueFacts = completed.valueFacts.filter((fact) => !valueFactUsesOwner(fact, calleeOwner));
       for (let index = 0;index < callee.parameters.length; index++) {
         refineFiniteCallArgument(state, instruction.arguments[index], callee.parameters[index].type, context.expressionContext);
       }
@@ -1583,11 +1669,10 @@ function addBoundsAssumption(assumptions, candidate) {
     assumptions.push(candidate);
   }
 }
-function valueFactUsesNamespace(fact, namespace) {
-  const marker = `v:${namespace}`;
+function valueFactUsesOwner(fact, owner) {
   if (fact.kind === "nonzero")
-    return fact.value.includes(marker);
-  return fact.index.includes(marker) || fact.array.includes(marker);
+    return valueIdentityUsesOwner(fact.value, owner);
+  return valueIdentityUsesOwner(fact.index, owner) || valueIdentityUsesOwner(fact.array, owner);
 }
 function sentinelsAdmit(sentinels, sentinel) {
   return sentinels === "both" || sentinels === sentinel;
@@ -1947,8 +2032,8 @@ function refineComparison(state, comparison, truth, expressionContext) {
     if (rightProducer?.kind === "arrayLength") {
       addValueFact(result.valueFacts, {
         kind: "belowLength",
-        index: canonicalValueKey(comparison.left, expressionContext),
-        array: canonicalValueKey(rightProducer.array, expressionContext)
+        index: canonicalValueIdentity(comparison.left, expressionContext),
+        array: canonicalValueIdentity(rightProducer.array, expressionContext)
       });
     }
   }
@@ -1957,8 +2042,8 @@ function refineComparison(state, comparison, truth, expressionContext) {
     if (leftProducer?.kind === "arrayLength") {
       addValueFact(result.valueFacts, {
         kind: "belowLength",
-        index: canonicalValueKey(comparison.right, expressionContext),
-        array: canonicalValueKey(leftProducer.array, expressionContext)
+        index: canonicalValueIdentity(comparison.right, expressionContext),
+        array: canonicalValueIdentity(leftProducer.array, expressionContext)
       });
     }
   }
@@ -2013,12 +2098,13 @@ function numberWithFacts(state, id, expressionContext) {
   if (held?.kind !== "number")
     return null;
   let result = held;
-  const key = canonicalValueKey(id, expressionContext);
-  if (state.valueFacts.some((fact) => fact.kind === "validIndex" && fact.index === key)) {
+  const identity = canonicalValueIdentity(id, expressionContext);
+  if (state.valueFacts.some((fact) => fact.kind === "validIndex" && sameValueIdentity(fact.index, identity))) {
     result = validIndexNumber(result);
   }
-  if (hasNonzeroFact(state.valueFacts, key))
+  if (hasNonzeroFact(state.valueFacts, identity)) {
     result = excludePointFrom(result, constantNumber(0));
+  }
   return result;
 }
 function validIndexNumber(value2) {
@@ -2040,7 +2126,10 @@ function recordNonzeroComparisonFacts(state, check, expressionContext) {
   }
 }
 function recordNonzeroValueFact(state, value2, expressionContext) {
-  addValueFact(state.valueFacts, { kind: "nonzero", value: canonicalValueKey(value2, expressionContext) });
+  addValueFact(state.valueFacts, {
+    kind: "nonzero",
+    value: canonicalValueIdentity(value2, expressionContext)
+  });
 }
 function requiredBoolean(state, id) {
   const value2 = requiredValue(state, id);
@@ -2431,7 +2520,7 @@ function analyzeProgram(program) {
       initializerState[binding] = constantNumber(category.value);
     }
   }
-  const initializer = runEvaluation(program.initializer, null, [], [], initializerState, program, [], { identityNamespace: "module/" });
+  const initializer = runEvaluation(program.initializer, null, [], [], initializerState, program, []);
   const moduleValues = publishedModuleValues(program, initializer.run, initializer.evaluation);
   const functionEntrySharedState = seedModuleSlots(program, moduleValues);
   const moduleReads = transitiveModuleBindings(functionUsage(program));
@@ -2452,8 +2541,7 @@ function analyzeProgram(program) {
       argumentExpressions.push({ kind: "parameter", index });
     }
     const { evaluation } = runEvaluation(fn, functionID, arguments_, argumentExpressions, sharedState, program, [], {
-      boundsAssumptions: moduleReads[functionID].size > 0 ? initializerBounds : [],
-      identityNamespace: `function:${functionID}/`
+      boundsAssumptions: moduleReads[functionID].size > 0 ? initializerBounds : []
     });
     functions.push(publishedAnalysis(fn, evaluation));
   }
@@ -2567,9 +2655,9 @@ function publishedModuleValues(program, run, evaluation) {
   }
   const fullyAnalyzed = evaluation.stops.length === 0 && program.initializerSkips.length === 0 && program.functions.every((lowered) => lowered.kind === "lowered");
   return program.moduleBindings.map((binding, index) => {
-    if (binding.category.kind !== "value" || demoted.has(index))
+    if (binding.category.kind !== "value" && binding.category.kind !== "function" || demoted.has(index))
       return null;
-    if (holdsMutableStructure(binding.category.declaredKind) && !fullyAnalyzed)
+    if (binding.category.kind === "value" && holdsMutableStructure(binding.category.declaredKind) && !fullyAnalyzed)
       return null;
     const slot = end?.[index];
     return slot ?? null;
@@ -2588,7 +2676,7 @@ function runEvaluation(fn, functionID, arguments_, argumentExpressions, sharedSt
   for (let index = 0;index < fn.parameters.length; index++) {
     initial.values[fn.parameters[index].value] = arguments_[index];
   }
-  const expressionContext = createExpressionContext(fn, argumentExpressions, seed.parameterIdentityKeys, seed.identityNamespace ?? fn.name);
+  const expressionContext = createExpressionContext(fn, argumentExpressions, seed.parameterIdentities, seed.identityOwner);
   const preconditions = [];
   const boundsAssumptions = [...seed.boundsAssumptions ?? []];
   const successors = blockSuccessors(fn);
@@ -2607,13 +2695,13 @@ function runEvaluation(fn, functionID, arguments_, argumentExpressions, sharedSt
     expressionContext,
     preconditions,
     boundsAssumptions,
-    evaluateFunction: (callee, values, expressions, calleeState, stack, valueFacts, parameterIdentityKeys, identityNamespace) => {
+    evaluateFunction: (callee, values, expressions, calleeState, stack, valueFacts, parameterIdentities, identityOwner) => {
       const calleeFn = program.functions[callee];
       if (calleeFn == null)
         throw new Error(`Unknown function ${callee}`);
       if (calleeFn.kind !== "lowered")
         throw new Error(`Analysis reached unlowered function ${calleeFn.name}`);
-      return runEvaluation(calleeFn, callee, values, expressions, calleeState, program, stack, { valueFacts, parameterIdentityKeys, identityNamespace }).evaluation;
+      return runEvaluation(calleeFn, callee, values, expressions, calleeState, program, stack, { valueFacts, parameterIdentities, identityOwner }).evaluation;
     }
   };
   let queueIndex = 0;
@@ -2887,13 +2975,13 @@ function reachableFrom(successors, start) {
 }
 
 // src/lower/program.ts
-import * as ts8 from "typescript";
+import * as ts9 from "typescript";
 
 // src/lower/accept.ts
 import * as ts from "typescript";
 
 // src/lower/context.ts
-function createFunctionContext(sourceFile, checker, functionsBySymbol, moduleBindingsBySymbol, sites, staticAnnotations = []) {
+function createFunctionContext(sourceFile, checker, functionsBySymbol, moduleBindingsBySymbol, sites, staticAnnotations = [], returnsVoid = true) {
   const entry = { loopHeader: null, parameters: [], instructions: [], terminator: null };
   return {
     sourceFile,
@@ -2908,6 +2996,7 @@ function createFunctionContext(sourceFile, checker, functionsBySymbol, moduleBin
     bindings: new Map,
     parameters: [],
     assertions: [],
+    returnsVoid,
     loops: []
   };
 }
@@ -3025,8 +3114,10 @@ function unsupported(node, reason) {
 }
 
 // src/lower/accept.ts
-function assertAccepted(root) {
+function assertAccepted(root, deferFunctionBodies = false) {
   const visit = (node) => {
+    if (deferFunctionBodies && node !== root && ts.isFunctionLike(node))
+      return;
     if (ts.isTypeNode(node))
       return;
     if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node) || ts.isJsxFragment(node)) {
@@ -3116,7 +3207,8 @@ var catalog = [
   { path: ["document", "body", "scrollTop"], call: false, fact: { ...anyFinite, integer: false } },
   { path: ["document", "body", "scrollLeft"], call: false, fact: { ...anyFinite, integer: false } },
   { path: ["performance", "now"], call: true, fact: { lower: 0, upper: Number.MAX_VALUE, integer: false } },
-  { path: ["Date", "now"], call: true, fact: { lower: 0, upper: Number.MAX_VALUE, integer: true } }
+  { path: ["Date", "now"], call: true, fact: { lower: 0, upper: Number.MAX_VALUE, integer: true } },
+  { path: ["Math", "random"], call: true, fact: { lower: 0, upper: 0.9999999999999999, integer: false } }
 ];
 function platformFact(expression, call, checker) {
   const parts = [];
@@ -3499,7 +3591,8 @@ function lowerExpression(expression, context) {
             arguments_.push(lowerParameterDefault(default_2, parameter.initializer, context));
             continue;
           }
-          if (parameter.questionToken != null) {
+          const callableParameter = callee.signature?.declaration?.parameters[index];
+          if (callableParameter != null && ts4.isParameter(callableParameter) && callableParameter.questionToken != null) {
             arguments_.push(addInstruction(context, parameter, { kind: "nullishConstant", sentinel: "undefined" }));
             continue;
           }
@@ -3519,7 +3612,12 @@ function lowerExpression(expression, context) {
         });
         arguments_.push(lowerValueBranch(argument, supplied, () => value2, () => lowerParameterDefault(default_, parameter.initializer, context), context));
       }
-      return addInstruction(context, current, { kind: "call", function: callee.id, arguments: arguments_ });
+      return addInstruction(context, current, {
+        kind: "call",
+        function: callee.id,
+        arguments: arguments_,
+        binding: callee.binding
+      });
     }
     if (ts4.isPropertyAccessExpression(current.expression)) {
       const platformCall = current.arguments.length === 0 ? platformFact(current.expression, true, context.checker) : null;
@@ -3871,6 +3969,15 @@ function lowerValueBranch(node, condition, lowerTrueArm, lowerFalseArm, context)
     whenFalse: { block: whenFalse, arguments: [] },
     site: addSite(context, node)
   });
+  return joinValueBranches(node, whenTrue, whenFalse, lowerTrueArm, lowerFalseArm, context);
+}
+function lowerBranchingValue(node, condition, lowerTrueArm, lowerFalseArm, context) {
+  const whenTrue = createBlock(context);
+  const whenFalse = createBlock(context);
+  lowerBranchingCondition(condition, whenTrue, whenFalse, context);
+  return joinValueBranches(node, whenTrue, whenFalse, lowerTrueArm, lowerFalseArm, context);
+}
+function joinValueBranches(node, whenTrue, whenFalse, lowerTrueArm, lowerFalseArm, context) {
   context.currentBlock = context.blocks[whenTrue];
   const trueValue = lowerTrueArm();
   const trueBlock = context.currentBlock;
@@ -3897,28 +4004,7 @@ function lowerConditionalExpression(expression, context) {
   if (valueKind(resultType, context.checker) == null) {
     throw unsupported(expression, { kind: "valueType", typeText: context.checker.typeToString(resultType) });
   }
-  const whenTrue = createBlock(context);
-  const whenFalse = createBlock(context);
-  lowerBranchingCondition(expression.condition, whenTrue, whenFalse, context);
-  context.currentBlock = context.blocks[whenTrue];
-  const trueValue = lowerExpression(expression.whenTrue, context);
-  const trueBlock = context.currentBlock;
-  context.currentBlock = context.blocks[whenFalse];
-  const falseValue = lowerExpression(expression.whenFalse, context);
-  const falseBlock = context.currentBlock;
-  const continuation = createBlock(context, 1);
-  terminate(trueBlock, {
-    kind: "jump",
-    target: { block: continuation, arguments: [trueValue] },
-    site: addSite(context, expression)
-  });
-  terminate(falseBlock, {
-    kind: "jump",
-    target: { block: continuation, arguments: [falseValue] },
-    site: addSite(context, expression)
-  });
-  context.currentBlock = context.blocks[continuation];
-  return context.currentBlock.parameters[0];
+  return lowerBranchingValue(expression, expression.condition, () => lowerExpression(expression.whenTrue, context), () => lowerExpression(expression.whenFalse, context), context);
 }
 function lowerBranchingCondition(expression, whenTrue, whenFalse, context) {
   const current = unwrap(expression, context.checker);
@@ -3953,8 +4039,7 @@ function lowerLogicalExpression(expression, context) {
   requireBooleanCondition(expression.left, context.checker);
   requireBooleanCondition(expression.right, context.checker);
   const isAnd = expression.operatorToken.kind === ts4.SyntaxKind.AmpersandAmpersandToken;
-  const condition = lowerExpression(expression.left, context);
-  return lowerValueBranch(expression, condition, () => isAnd ? lowerExpression(expression.right, context) : addInstruction(context, expression, { kind: "booleanConstant", value: true }), () => isAnd ? addInstruction(context, expression, { kind: "booleanConstant", value: false }) : lowerExpression(expression.right, context), context);
+  return lowerBranchingValue(expression, expression.left, () => isAnd ? lowerExpression(expression.right, context) : addInstruction(context, expression, { kind: "booleanConstant", value: true }), () => isAnd ? addInstruction(context, expression, { kind: "booleanConstant", value: false }) : lowerExpression(expression.right, context), context);
 }
 function arithmeticOperator(kind) {
   switch (kind) {
@@ -4492,11 +4577,51 @@ function unwrap(expression, checker) {
   }
 }
 
+// src/lower/function-unit.ts
+import * as ts5 from "typescript";
+function callableSignature(unit, checker) {
+  if (unit.initializer == null) {
+    return checker.getSignatureFromDeclaration(unit.declaration) ?? null;
+  }
+  const signatures = checker.getSignaturesOfType(checker.getTypeAtLocation(unit.name), ts5.SignatureKind.Call);
+  if (signatures.length !== 1)
+    return null;
+  const signature = signatures[0];
+  const signatureDeclaration = signature.declaration;
+  if (signatureDeclaration == null || signature.thisParameter != null || signature.parameters.length !== unit.declaration.parameters.length || signatureDeclaration.parameters.some((parameter) => !ts5.isParameter(parameter) || parameter.dotDotDotToken != null)) {
+    return null;
+  }
+  return signature;
+}
+function topLevelFunctionUnits(sourceFile) {
+  const units = [];
+  for (const statement of sourceFile.statements) {
+    if (ts5.isFunctionDeclaration(statement) && statement.name != null) {
+      units.push({ name: statement.name, declaration: statement, initializer: null });
+      continue;
+    }
+    if (!ts5.isVariableStatement(statement) || (statement.declarationList.flags & ts5.NodeFlags.Const) === 0)
+      continue;
+    for (const initializer of statement.declarationList.declarations) {
+      if (!ts5.isIdentifier(initializer.name) || initializer.initializer == null)
+        continue;
+      const declaration = directFunctionExpression(initializer.initializer);
+      if (declaration != null) {
+        units.push({ name: initializer.name, declaration, initializer });
+      }
+    }
+  }
+  return units;
+}
+function directFunctionExpression(expression) {
+  return ts5.isArrowFunction(expression) || ts5.isFunctionExpression(expression) ? expression : null;
+}
+
 // src/lower/module.ts
-import * as ts6 from "typescript";
+import * as ts7 from "typescript";
 
 // src/lower/statements.ts
-import * as ts5 from "typescript";
+import * as ts6 from "typescript";
 function lowerStatements(statements, context) {
   for (const statement of statements) {
     if (context.currentBlock.terminator != null)
@@ -4505,61 +4630,57 @@ function lowerStatements(statements, context) {
   }
 }
 function lowerStatement(statement, context) {
-  if (ts5.isVariableStatement(statement)) {
+  if (ts6.isVariableStatement(statement)) {
     lowerVariableDeclarationList(statement.declarationList, context);
     return;
   }
-  if (ts5.isReturnStatement(statement)) {
+  if (ts6.isReturnStatement(statement)) {
     let value2 = statement.expression == null ? null : lowerExpression(statement.expression, context);
-    if (value2 == null) {
-      const enclosing = ts5.findAncestor(statement, ts5.isFunctionDeclaration);
-      const signature = enclosing == null ? undefined : context.checker.getSignatureFromDeclaration(enclosing);
-      const returnType = signature == null ? null : context.checker.getReturnTypeOfSignature(signature);
-      const returnsVoid = returnType == null || (returnType.flags & (ts5.TypeFlags.Void | ts5.TypeFlags.Undefined)) !== 0;
-      if (!returnsVoid) {
-        value2 = addInstruction(context, statement, { kind: "nullishConstant", sentinel: "undefined" });
-      }
+    if (context.returnsVoid)
+      value2 = null;
+    if (value2 == null && !context.returnsVoid) {
+      value2 = addInstruction(context, statement, { kind: "nullishConstant", sentinel: "undefined" });
     }
     terminate(context.currentBlock, { kind: "return", value: value2, site: addSite(context, statement) });
     return;
   }
-  if (ts5.isExpressionStatement(statement)) {
+  if (ts6.isExpressionStatement(statement)) {
     lowerStatementExpression(statement.expression, context);
     return;
   }
-  if (ts5.isIfStatement(statement)) {
+  if (ts6.isIfStatement(statement)) {
     lowerIfStatement(statement, context);
     return;
   }
-  if (ts5.isForOfStatement(statement)) {
+  if (ts6.isForOfStatement(statement)) {
     lowerForOfStatement(statement, context);
     return;
   }
-  if (ts5.isForStatement(statement)) {
+  if (ts6.isForStatement(statement)) {
     lowerForStatement(statement, context);
     return;
   }
-  if (ts5.isWhileStatement(statement)) {
+  if (ts6.isWhileStatement(statement)) {
     lowerWhileStatement(statement, context);
     return;
   }
-  if (ts5.isContinueStatement(statement)) {
+  if (ts6.isContinueStatement(statement)) {
     lowerContinueStatement(statement, context);
     return;
   }
-  if (ts5.isBlock(statement)) {
+  if (ts6.isBlock(statement)) {
     lowerStatements(statement.statements, context);
     return;
   }
-  if (ts5.isSwitchStatement(statement)) {
+  if (ts6.isSwitchStatement(statement)) {
     lowerSwitchStatement(statement, context);
     return;
   }
-  if (ts5.isThrowStatement(statement)) {
+  if (ts6.isThrowStatement(statement)) {
     terminate(context.currentBlock, { kind: "thrown", site: addSite(context, statement) });
     return;
   }
-  throw unsupported(statement, { kind: "statementForm", syntax: ts5.SyntaxKind[statement.kind] });
+  throw unsupported(statement, { kind: "statementForm", syntax: ts6.SyntaxKind[statement.kind] });
 }
 function lowerIfStatement(statement, context) {
   const bindingsBeforeBranch = new Map(context.bindings);
@@ -4586,7 +4707,7 @@ function lowerSwitchStatement(statement, context) {
   const subjectType = context.checker.getTypeAtLocation(statement.expression);
   const subjectKind = valueKind(subjectType, context.checker);
   const tagUnionExpression = taggedUnionTagRead(statement.expression, context);
-  const missingFlags = ts5.TypeFlags.Null | ts5.TypeFlags.Undefined;
+  const missingFlags = ts6.TypeFlags.Null | ts6.TypeFlags.Undefined;
   const nullableOpaqueSubject = subjectKind === "nullable" && subjectType.isUnion() && subjectType.types.every((member) => (member.flags & missingFlags) !== 0 || valueKind(member, context.checker) === "opaque");
   if (tagUnionExpression == null && subjectKind !== "number" && subjectKind !== "opaque" && !nullableOpaqueSubject) {
     throw unsupported(statement.expression, { kind: "switchSubject", typeText: context.checker.typeToString(subjectType) });
@@ -4598,7 +4719,7 @@ function lowerSwitchStatement(statement, context) {
   const clauses = statement.caseBlock.clauses;
   for (let index = 0;index < clauses.length; index++) {
     const clause = clauses[index];
-    if (ts5.isDefaultClause(clause)) {
+    if (ts6.isDefaultClause(clause)) {
       if (index !== clauses.length - 1 || pendingLabels.length > 0) {
         throw unsupported(clause, { kind: "switchDefaultNotLast" });
       }
@@ -4619,7 +4740,7 @@ function lowerSwitchStatement(statement, context) {
   const lowerBody = (group) => {
     const body = group.statements;
     const last = body[body.length - 1];
-    const endsWithBreak = last != null && ts5.isBreakStatement(last);
+    const endsWithBreak = last != null && ts6.isBreakStatement(last);
     lowerStatements(endsWithBreak ? body.slice(0, -1) : body, context);
     if (context.currentBlock.terminator == null) {
       if (!endsWithBreak)
@@ -4638,7 +4759,7 @@ function lowerSwitchStatement(statement, context) {
       let condition;
       if (tagUnionExpression != null) {
         const unwrappedLabel = label;
-        if (!ts5.isStringLiteral(unwrappedLabel) && !ts5.isNoSubstitutionTemplateLiteral(unwrappedLabel)) {
+        if (!ts6.isStringLiteral(unwrappedLabel) && !ts6.isNoSubstitutionTemplateLiteral(unwrappedLabel)) {
           throw unsupported(label, { kind: "switchLabel", typeText: context.checker.typeToString(context.checker.getTypeAtLocation(label)) });
         }
         condition = addInstruction(context, label, { kind: "tagCheck", union: subject, tagValue: unwrappedLabel.text, negated: false });
@@ -4680,7 +4801,7 @@ function lowerSwitchStatement(statement, context) {
   mergeAtContinuation(exits, bindingsBefore, statement, context);
 }
 function lowerForOfStatement(statement, context) {
-  if (!ts5.isVariableDeclarationList(statement.initializer) || statement.initializer.declarations.length !== 1 || !ts5.isIdentifier(statement.initializer.declarations[0].name)) {
+  if (!ts6.isVariableDeclarationList(statement.initializer) || statement.initializer.declarations.length !== 1 || !ts6.isIdentifier(statement.initializer.declarations[0].name)) {
     throw unsupported(statement.initializer, { kind: "variableDeclarationShape" });
   }
   const elementName = statement.initializer.declarations[0].name;
@@ -4757,7 +4878,7 @@ function lowerForOfStatement(statement, context) {
 }
 function lowerForStatement(statement, context) {
   if (statement.initializer != null) {
-    if (ts5.isVariableDeclarationList(statement.initializer)) {
+    if (ts6.isVariableDeclarationList(statement.initializer)) {
       lowerVariableDeclarationList(statement.initializer, context);
     } else {
       lowerStatementExpression(statement.initializer, context);
@@ -4866,13 +4987,13 @@ function lowerBranch(statement, block, bindings, context) {
 }
 function lowerVariableDeclarationList(declarations, context) {
   for (const declaration of declarations.declarations) {
-    if (ts5.isObjectBindingPattern(declaration.name) && declaration.initializer != null) {
+    if (ts6.isObjectBindingPattern(declaration.name) && declaration.initializer != null) {
       const source = lowerExpression(declaration.initializer, context);
       for (const element of declaration.name.elements) {
-        if (!ts5.isIdentifier(element.name) || element.dotDotDotToken != null || element.initializer != null) {
+        if (!ts6.isIdentifier(element.name) || element.dotDotDotToken != null || element.initializer != null) {
           throw unsupported(element, { kind: "variableDeclarationShape" });
         }
-        const property = element.propertyName == null ? element.name.text : ts5.isIdentifier(element.propertyName) ? element.propertyName.text : null;
+        const property = element.propertyName == null ? element.name.text : ts6.isIdentifier(element.propertyName) ? element.propertyName.text : null;
         if (property == null)
           throw unsupported(element, { kind: "variableDeclarationShape" });
         const elementType = context.checker.getTypeAtLocation(element.name);
@@ -4889,7 +5010,7 @@ function lowerVariableDeclarationList(declarations, context) {
       }
       continue;
     }
-    if (!ts5.isIdentifier(declaration.name) || declaration.initializer == null) {
+    if (!ts6.isIdentifier(declaration.name) || declaration.initializer == null) {
       throw unsupported(declaration, { kind: "variableDeclarationShape" });
     }
     const value2 = lowerExpression(declaration.initializer, context);
@@ -4908,12 +5029,12 @@ function lowerVariableDeclarationList(declarations, context) {
 function assignedSymbols(nodes, checker) {
   const symbols = new Set;
   const visit = (node) => {
-    if (ts5.isFunctionLike(node))
+    if (ts6.isFunctionLike(node))
       return;
     const assignment = identifierAssignment(node);
     if (assignment != null)
       symbols.add(requiredSymbol(assignment.target, checker));
-    ts5.forEachChild(node, visit);
+    ts6.forEachChild(node, visit);
   };
   for (const node of nodes)
     visit(node);
@@ -4932,45 +5053,46 @@ function scanModuleBindings(sourceFile, checker) {
     bindings.push({ name: name.text, category });
   };
   for (const statement of sourceFile.statements) {
-    if (ts6.isVariableStatement(statement)) {
-      if ((statement.declarationList.flags & (ts6.NodeFlags.Let | ts6.NodeFlags.Const)) === 0)
+    if (ts7.isVariableStatement(statement)) {
+      if ((statement.declarationList.flags & (ts7.NodeFlags.Let | ts7.NodeFlags.Const)) === 0)
         continue;
+      const isConst = (statement.declarationList.flags & ts7.NodeFlags.Const) !== 0;
       for (const declarator of statement.declarationList.declarations) {
-        if (ts6.isIdentifier(declarator.name)) {
-          register(declarator.name, declaredCategory(declarator.name, checker));
+        if (ts7.isIdentifier(declarator.name)) {
+          register(declarator.name, isConst && declarator.initializer != null && directFunctionExpression(declarator.initializer) != null ? { kind: "function" } : declaredCategory(declarator.name, checker));
           continue;
         }
-        if (ts6.isObjectBindingPattern(declarator.name)) {
+        if (ts7.isObjectBindingPattern(declarator.name)) {
           for (const element of declarator.name.elements) {
-            if (ts6.isIdentifier(element.name))
+            if (ts7.isIdentifier(element.name))
               register(element.name, declaredCategory(element.name, checker));
           }
         }
       }
       continue;
     }
-    if (ts6.isImportDeclaration(statement)) {
+    if (ts7.isImportDeclaration(statement)) {
       const clause = statement.importClause;
       if (clause == null || clause.isTypeOnly)
         continue;
       if (clause.name != null)
         register(clause.name, importedCategory(clause.name, checker));
       const named = clause.namedBindings;
-      if (named != null && ts6.isNamedImports(named)) {
+      if (named != null && ts7.isNamedImports(named)) {
         for (const element of named.elements) {
           if (!element.isTypeOnly)
             register(element.name, importedCategory(element.name, checker));
         }
       }
-      if (named != null && ts6.isNamespaceImport(named))
+      if (named != null && ts7.isNamespaceImport(named))
         register(named.name, { kind: "import" });
     }
   }
   const visit = (node, insideFunction) => {
     if (insideFunction)
       demoteModuleWritesInNode(node, checker, bindingsBySymbol, bindings);
-    const enteringFunction = insideFunction || ts6.isFunctionLike(node);
-    ts6.forEachChild(node, (child) => {
+    const enteringFunction = insideFunction || ts7.isFunctionLike(node);
+    ts7.forEachChild(node, (child) => {
       visit(child, enteringFunction);
     });
   };
@@ -4979,13 +5101,13 @@ function scanModuleBindings(sourceFile, checker) {
 }
 function importedCategory(name, checker) {
   const symbol = checker.getSymbolAtLocation(name);
-  if (symbol == null || (symbol.flags & ts6.SymbolFlags.Alias) === 0)
+  if (symbol == null || (symbol.flags & ts7.SymbolFlags.Alias) === 0)
     return { kind: "import" };
   const target = checker.getAliasedSymbol(symbol);
   const declaration = target.valueDeclaration;
-  if (declaration == null || !ts6.isVariableDeclaration(declaration))
+  if (declaration == null || !ts7.isVariableDeclaration(declaration))
     return { kind: "import" };
-  if ((ts6.getCombinedNodeFlags(declaration) & ts6.NodeFlags.Const) === 0)
+  if ((ts7.getCombinedNodeFlags(declaration) & ts7.NodeFlags.Const) === 0)
     return { kind: "import" };
   if (declaration.getSourceFile().isDeclarationFile)
     return { kind: "import" };
@@ -5001,7 +5123,7 @@ function demoteModuleWritesInNode(node, checker, bindingsBySymbol, bindings, wri
       written[binding] = true;
   };
   const target = (expression) => {
-    if (ts6.isIdentifier(expression)) {
+    if (ts7.isIdentifier(expression)) {
       const symbol = checker.getSymbolAtLocation(expression);
       const binding = symbol == null ? undefined : bindingsBySymbol.get(symbol);
       if (binding != null)
@@ -5009,34 +5131,34 @@ function demoteModuleWritesInNode(node, checker, bindingsBySymbol, bindings, wri
       return;
     }
     const visitPattern = (child) => {
-      if (ts6.isShorthandPropertyAssignment(child)) {
+      if (ts7.isShorthandPropertyAssignment(child)) {
         const symbol = checker.getShorthandAssignmentValueSymbol(child);
         const binding = symbol == null ? undefined : bindingsBySymbol.get(symbol);
         if (binding != null)
           record(binding);
-        ts6.forEachChild(child, visitPattern);
+        ts7.forEachChild(child, visitPattern);
         return;
       }
-      if (ts6.isIdentifier(child)) {
+      if (ts7.isIdentifier(child)) {
         const symbol = checker.getSymbolAtLocation(child);
         const binding = symbol == null ? undefined : bindingsBySymbol.get(symbol);
         if (binding != null)
           record(binding);
         return;
       }
-      ts6.forEachChild(child, visitPattern);
+      ts7.forEachChild(child, visitPattern);
     };
-    ts6.forEachChild(expression, visitPattern);
+    ts7.forEachChild(expression, visitPattern);
   };
-  if (ts6.isBinaryExpression(node)) {
+  if (ts7.isBinaryExpression(node)) {
     const kind = node.operatorToken.kind;
-    if (kind >= ts6.SyntaxKind.FirstAssignment && kind <= ts6.SyntaxKind.LastAssignment)
+    if (kind >= ts7.SyntaxKind.FirstAssignment && kind <= ts7.SyntaxKind.LastAssignment)
       target(node.left);
   }
-  if ((ts6.isPrefixUnaryExpression(node) || ts6.isPostfixUnaryExpression(node)) && (node.operator === ts6.SyntaxKind.PlusPlusToken || node.operator === ts6.SyntaxKind.MinusMinusToken) && ts6.isExpression(node.operand)) {
+  if ((ts7.isPrefixUnaryExpression(node) || ts7.isPostfixUnaryExpression(node)) && (node.operator === ts7.SyntaxKind.PlusPlusToken || node.operator === ts7.SyntaxKind.MinusMinusToken) && ts7.isExpression(node.operand)) {
     target(node.operand);
   }
-  if ((ts6.isForOfStatement(node) || ts6.isForInStatement(node)) && ts6.isExpression(node.initializer)) {
+  if ((ts7.isForOfStatement(node) || ts7.isForInStatement(node)) && ts7.isExpression(node.initializer)) {
     target(node.initializer);
   }
 }
@@ -5049,8 +5171,8 @@ function lowerModuleInitializer(sourceFile, checker, functionsBySymbol, scan, si
       continue;
     const recovery = snapshotLowering(context);
     try {
-      assertAccepted(statement);
-      if (ts6.isVariableStatement(statement)) {
+      assertAccepted(statement, true);
+      if (ts7.isVariableStatement(statement)) {
         lowerTopLevelDeclarations(statement, context, scan);
         continue;
       }
@@ -5088,31 +5210,31 @@ function lowerModuleInitializer(sourceFile, checker, functionsBySymbol, scan, si
   };
 }
 function containsArrayLiteral(root) {
-  if (ts6.isArrayLiteralExpression(root))
+  if (ts7.isArrayLiteralExpression(root))
     return true;
   let found = false;
-  ts6.forEachChild(root, (child) => {
+  ts7.forEachChild(root, (child) => {
     if (!found && containsArrayLiteral(child))
       found = true;
   });
   return found;
 }
 function forEachImmediatelyEvaluatedChild(node, visit) {
-  if (ts6.isFunctionLike(node)) {
-    if (node.name != null && ts6.isComputedPropertyName(node.name)) {
+  if (ts7.isFunctionLike(node)) {
+    if (node.name != null && ts7.isComputedPropertyName(node.name)) {
       visit(node.name.expression);
     }
     return;
   }
-  ts6.forEachChild(node, visit);
+  ts7.forEachChild(node, visit);
 }
 function lowerSupportedArgumentsOfSkippedTopLevelCall(statement, stop, context) {
-  if (!ts6.isExpressionStatement(statement))
+  if (!ts7.isExpressionStatement(statement))
     return;
   let expression = statement.expression;
-  while (ts6.isParenthesizedExpression(expression))
+  while (ts7.isParenthesizedExpression(expression))
     expression = expression.expression;
-  if (!ts6.isCallExpression(expression) || expression !== stop.node || expression.questionDotToken != null || !plainCallTarget(expression.expression))
+  if (!ts7.isCallExpression(expression) || expression !== stop.node || expression.questionDotToken != null || !plainCallTarget(expression.expression))
     return;
   for (const argument of expression.arguments) {
     const recovery = snapshotLowering(context);
@@ -5127,23 +5249,23 @@ function lowerSupportedArgumentsOfSkippedTopLevelCall(statement, stop, context)
   }
 }
 function plainCallTarget(expression) {
-  if (ts6.isIdentifier(expression))
+  if (ts7.isIdentifier(expression))
     return true;
-  if (ts6.isParenthesizedExpression(expression))
+  if (ts7.isParenthesizedExpression(expression))
     return plainCallTarget(expression.expression);
-  return ts6.isPropertyAccessExpression(expression) && expression.questionDotToken == null && plainCallTarget(expression.expression);
+  return ts7.isPropertyAccessExpression(expression) && expression.questionDotToken == null && plainCallTarget(expression.expression);
 }
 function lowerTopLevelDeclarations(statement, context, scan) {
   for (const declarator of statement.declarationList.declarations) {
     if (declarator.initializer == null)
       throw new LoweringStop(declarator, { kind: "variableDeclarationShape" });
-    if (ts6.isObjectBindingPattern(declarator.name)) {
+    if (ts7.isObjectBindingPattern(declarator.name)) {
       const source = lowerExpression(declarator.initializer, context);
       for (const element of declarator.name.elements) {
-        if (!ts6.isIdentifier(element.name) || element.dotDotDotToken != null || element.initializer != null) {
+        if (!ts7.isIdentifier(element.name) || element.dotDotDotToken != null || element.initializer != null) {
           throw new LoweringStop(element, { kind: "variableDeclarationShape" });
         }
-        const property = element.propertyName == null ? element.name.text : ts6.isIdentifier(element.propertyName) ? element.propertyName.text : null;
+        const property = element.propertyName == null ? element.name.text : ts7.isIdentifier(element.propertyName) ? element.propertyName.text : null;
         if (property == null)
           throw new LoweringStop(element, { kind: "variableDeclarationShape" });
         const elementType = context.checker.getTypeAtLocation(element.name);
@@ -5159,27 +5281,32 @@ function lowerTopLevelDeclarations(statement, context, scan) {
       }
       continue;
     }
-    if (!ts6.isIdentifier(declarator.name)) {
+    if (!ts7.isIdentifier(declarator.name)) {
       throw new LoweringStop(declarator, { kind: "variableDeclarationShape" });
     }
     const symbol = context.checker.getSymbolAtLocation(declarator.name);
     const binding = symbol == null ? undefined : scan.bindingsBySymbol.get(symbol);
     if (binding == null)
       throw new LoweringStop(declarator, { kind: "variableDeclarationShape" });
+    if ((statement.declarationList.flags & ts7.NodeFlags.Const) !== 0 && directFunctionExpression(declarator.initializer) != null) {
+      const marker = addInstruction(context, declarator.initializer, { kind: "opaqueConstant" });
+      addInstruction(context, declarator, { kind: "moduleWrite", binding, value: marker });
+      continue;
+    }
     const value2 = lowerExpression(declarator.initializer, context);
     addInstruction(context, declarator, { kind: "moduleWrite", binding, value: value2 });
   }
 }
 function skippedAtTopLevel(statement) {
-  return ts6.isFunctionDeclaration(statement) && statement.name != null || ts6.isImportDeclaration(statement) || ts6.isTypeAliasDeclaration(statement) || ts6.isInterfaceDeclaration(statement) || ts6.isExportDeclaration(statement);
+  return ts7.isFunctionDeclaration(statement) && statement.name != null || ts7.isImportDeclaration(statement) || ts7.isTypeAliasDeclaration(statement) || ts7.isInterfaceDeclaration(statement) || ts7.isExportDeclaration(statement);
 }
 function scanSkippedModuleEffects(root, checker, bindingsBySymbol, bindings) {
   const directWrites = [];
   let invokesUnknownCode = false;
   const visit = (node) => {
     demoteModuleWritesInNode(node, checker, bindingsBySymbol, bindings, directWrites);
-    invokesUnknownCode ||= ts6.isCallExpression(node) || ts6.isNewExpression(node) || ts6.isTaggedTemplateExpression(node) || ts6.isAwaitExpression(node) || ts6.isYieldExpression(node) || ts6.isForOfStatement(node) || ts6.isSpreadElement(node) || ts6.isArrayBindingPattern(node) || ts6.isVariableDeclarationList(node) && (node.flags & ts6.NodeFlags.Using) !== 0 || ts6.isBinaryExpression(node) && (node.operatorToken.kind === ts6.SyntaxKind.InstanceOfKeyword || node.operatorToken.kind === ts6.SyntaxKind.EqualsToken && containsArrayLiteral(node.left)) || ts6.isJsxElement(node) || ts6.isJsxSelfClosingElement(node) || ts6.isJsxFragment(node) || ts6.isClassDeclaration(node) || ts6.isClassExpression(node);
-    if (ts6.isVariableDeclaration(node) && ts6.isIdentifier(node.name)) {
+    invokesUnknownCode ||= ts7.isCallExpression(node) || ts7.isNewExpression(node) || ts7.isTaggedTemplateExpression(node) || ts7.isAwaitExpression(node) || ts7.isYieldExpression(node) || ts7.isForOfStatement(node) || ts7.isSpreadElement(node) || ts7.isArrayBindingPattern(node) || ts7.isVariableDeclarationList(node) && (node.flags & ts7.NodeFlags.Using) !== 0 || ts7.isBinaryExpression(node) && (node.operatorToken.kind === ts7.SyntaxKind.InstanceOfKeyword || node.operatorToken.kind === ts7.SyntaxKind.EqualsToken && containsArrayLiteral(node.left)) || ts7.isJsxElement(node) || ts7.isJsxSelfClosingElement(node) || ts7.isJsxFragment(node) || ts7.isClassDeclaration(node) || ts7.isClassExpression(node);
+    if (ts7.isVariableDeclaration(node) && ts7.isIdentifier(node.name)) {
       const symbol = checker.getSymbolAtLocation(node.name);
       const binding = symbol == null ? undefined : bindingsBySymbol.get(symbol);
       if (binding != null) {
@@ -5201,7 +5328,7 @@ function declaredRecordProperties(type, checker, seen) {
     return null;
   const properties = [];
   for (const property of checker.getPropertiesOfType(type)) {
-    const optional = (property.flags & ts6.SymbolFlags.Optional) !== 0;
+    const optional = (property.flags & ts7.SymbolFlags.Optional) !== 0;
     const walked = declaredKind(checker.getTypeOfSymbol(property), checker, [...seen, type]);
     const opaqueLeaf = { kind: "opaque" };
     const propertyDeclared = declaredOnlyInDeclarationFiles(property) ? opaqueLeaf : walked ?? opaqueLeaf;
@@ -5307,14 +5434,14 @@ function declaredKindUncached(type, checker, seen) {
       }
       if (inner == null)
         return null;
-      const admitsNull = type.types.some((member) => (member.flags & ts6.TypeFlags.Null) !== 0);
-      const admitsUndefined = type.types.some((member) => (member.flags & ts6.TypeFlags.Undefined) !== 0);
+      const admitsNull = type.types.some((member) => (member.flags & ts7.TypeFlags.Null) !== 0);
+      const admitsUndefined = type.types.some((member) => (member.flags & ts7.TypeFlags.Undefined) !== 0);
       return { kind: "nullish", inner, sentinels: admitsNull && admitsUndefined ? "both" : admitsNull ? "null" : "undefined" };
     }
     case "opaque":
       return { kind: "opaque" };
     case "array": {
-      const element = checker.getIndexTypeOfType(type, ts6.IndexKind.Number);
+      const element = checker.getIndexTypeOfType(type, ts7.IndexKind.Number);
       if (element == null)
         return null;
       const elementKind = declaredKind(element, checker, [...seen, type]);
@@ -5366,7 +5493,7 @@ function declaredKindUncached(type, checker, seen) {
 }
 function numericLiteralInterval(type) {
   const members = type.isUnion() ? type.types : [type];
-  if (!members.every((member) => (member.flags & ts6.TypeFlags.NumberLiteral) !== 0 && (member.flags & ts6.TypeFlags.EnumLiteral) === 0))
+  if (!members.every((member) => (member.flags & ts7.TypeFlags.NumberLiteral) !== 0 && (member.flags & ts7.TypeFlags.EnumLiteral) === 0))
     return null;
   let lower = Infinity;
   let upper = -Infinity;
@@ -5419,7 +5546,7 @@ function joinScalarDeclaredKinds(members) {
 function tupleHasOptionalOrRestPositions(type, checker) {
   if (!checker.isTupleType(type))
     return false;
-  return type.target.elementFlags.some((flags) => (flags & ts6.ElementFlags.Required) === 0);
+  return type.target.elementFlags.some((flags) => (flags & ts7.ElementFlags.Required) === 0);
 }
 function demote(bindings, binding) {
   const category = bindings[binding].category;
@@ -5433,6 +5560,7 @@ function demote(bindings, binding) {
       break;
     }
     case "kind":
+    case "function":
     case "import":
     case "opaque":
       break;
@@ -5440,31 +5568,31 @@ function demote(bindings, binding) {
 }
 
 // src/lower/static-intrinsics.ts
-import * as ts7 from "typescript";
-function scanStaticAnnotations(sourceFile, declarations, checker) {
-  const ownerIndex = new Map(declarations.map((declaration, index) => [declaration, index]));
-  const callsByFunction = declarations.map(() => []);
+import * as ts8 from "typescript";
+function scanStaticAnnotations(sourceFile, functions, checker) {
+  const ownerIndex = new Map(functions.map((unit, index) => [unit.declaration, index]));
+  const callsByFunction = functions.map(() => []);
   const outsideTopLevelFunctions = [];
   const visit = (node) => {
-    if (ts7.isCallExpression(node) && isStaticIntent(node, checker)) {
-      const owner = ts7.findAncestor(node, ts7.isFunctionLike);
-      const index = owner != null && ts7.isFunctionDeclaration(owner) ? ownerIndex.get(owner) : undefined;
+    if (ts8.isCallExpression(node) && isStaticIntent(node, checker)) {
+      const owner = ts8.findAncestor(node, ts8.isFunctionLike);
+      const index = owner == null ? undefined : ownerIndex.get(owner);
       if (index == null)
         outsideTopLevelFunctions.push(node);
       else
         callsByFunction[index].push(node);
     }
-    ts7.forEachChild(node, visit);
+    ts8.forEachChild(node, visit);
   };
   visit(sourceFile);
   return {
-    functions: declarations.map((declaration, index) => {
+    functions: functions.map((unit, index) => {
       const calls = callsByFunction[index];
       const callSet = new Set(calls);
       const leading = new Set;
-      if (declaration.body != null) {
-        for (const statement of declaration.body.statements) {
-          if (!ts7.isExpressionStatement(statement) || !ts7.isCallExpression(statement.expression) || !callSet.has(statement.expression))
+      if (unit.declaration.body != null && ts8.isBlock(unit.declaration.body)) {
+        for (const statement of unit.declaration.body.statements) {
+          if (!ts8.isExpressionStatement(statement) || !ts8.isCallExpression(statement.expression) || !callSet.has(statement.expression))
             break;
           leading.add(statement.expression);
         }
@@ -5478,34 +5606,30 @@ function annotationForCall(call, role) {
   if (call.arguments.length !== 1) {
     return { kind: "invalid", call, role, node: call, problem: "argumentCount" };
   }
-  if (!ts7.isExpressionStatement(call.parent) || call.parent.expression !== call) {
+  if (!ts8.isExpressionStatement(call.parent) || call.parent.expression !== call) {
     return { kind: "invalid", call, role, node: call, problem: "position" };
   }
   const callee = call.expression;
-  if (call.questionDotToken != null || ts7.isPropertyAccessExpression(callee) && callee.questionDotToken != null) {
+  if (call.questionDotToken != null || ts8.isPropertyAccessExpression(callee) && callee.questionDotToken != null) {
     return { kind: "invalid", call, role, node: call, problem: "optionalCall" };
   }
   return { kind: "valid", call, role, condition: call.arguments[0] };
 }
 function isStaticIntent(call, checker) {
-  if (!ts7.isPropertyAccessExpression(call.expression))
+  if (!ts8.isPropertyAccessExpression(call.expression))
     return false;
   const access = call.expression;
-  if (!ts7.isIdentifier(access.expression) || access.expression.text !== "console" || access.name.text !== "assert")
+  if (!ts8.isIdentifier(access.expression) || access.expression.text !== "console" || access.name.text !== "assert")
     return false;
   const resolved = checker.getSymbolAtLocation(access.expression);
-  const globalConsole = checker.resolveName("console", undefined, ts7.SymbolFlags.Value, false);
+  const globalConsole = checker.resolveName("console", undefined, ts8.SymbolFlags.Value, false);
   return resolved != null && resolved === globalConsole;
 }
 
 // src/lower/program.ts
 function lowerSource(checked, baseDirectory = process.cwd()) {
   const { sourceFile, checker } = checked;
-  const declarations = [];
-  for (const statement of sourceFile.statements) {
-    if (ts8.isFunctionDeclaration(statement) && statement.name != null)
-      declarations.push(statement);
-  }
+  const declarations = topLevelFunctionUnits(sourceFile);
   const staticScan = scanStaticAnnotations(sourceFile, declarations, checker);
   const recordStaticAnnotationIssues = (sites2) => staticScan.outsideTopLevelFunctions.map((call) => {
     sites2.push(nodeSpan(sourceFile, call));
@@ -5519,9 +5643,9 @@ function lowerSource(checked, baseDirectory = process.cwd()) {
       baseDirectory,
       lineStarts: [...sourceFile.getLineStarts()],
       sites: sites2,
-      functions: declarations.map((declaration, index) => ({
+      functions: declarations.map((unit, index) => ({
         kind: "unsupported",
-        name: declaration.name.text,
+        name: unit.name.text,
         hasStaticAnnotations: staticScan.functions[index].length > 0,
         site: 0,
         reason
@@ -5548,19 +5672,31 @@ function lowerSource(checked, baseDirectory = process.cwd()) {
     return rejectFile(nodeSpan(sourceFile, evalNode), { kind: "evalInFile" });
   }
   const functionsBySymbol = new Map;
+  const scan = scanModuleBindings(sourceFile, checker);
+  const topLevelFunctions = [];
   for (let index = 0;index < declarations.length; index++) {
-    const declaration = declarations[index];
-    const symbol = checker.getSymbolAtLocation(declaration.name);
+    const unit = declarations[index];
+    const symbol = checker.getSymbolAtLocation(unit.name);
     if (symbol == null)
-      throw new Error(`Function declaration ${declaration.name.text} has no TypeScript symbol`);
-    functionsBySymbol.set(symbol, { id: index, declaration });
+      throw new Error(`Function ${unit.name.text} has no TypeScript symbol`);
+    const binding = scan.bindingsBySymbol.get(symbol);
+    if (unit.initializer != null && binding == null) {
+      throw new Error(`Const-bound function ${unit.name.text} has no module binding`);
+    }
+    const fn = {
+      ...unit,
+      id: index,
+      binding: unit.initializer == null ? null : binding,
+      signature: callableSignature(unit, checker)
+    };
+    topLevelFunctions.push(fn);
+    functionsBySymbol.set(symbol, fn);
   }
-  const scan = scanModuleBindings(sourceFile, checker);
   const sites = [];
   const staticAnnotationIssues = recordStaticAnnotationIssues(sites);
   const functions = [];
-  for (let index = 0;index < declarations.length; index++) {
-    const declaration = declarations[index];
+  for (let index = 0;index < topLevelFunctions.length; index++) {
+    const declaration = topLevelFunctions[index];
     const staticAnnotations = staticScan.functions[index];
     try {
       functions.push(lowerFunction(declaration, staticAnnotations, sourceFile, checker, functionsBySymbol, scan, sites));
@@ -5590,7 +5726,8 @@ function lowerSource(checked, baseDirectory = process.cwd()) {
     initializerSkips: skips
   };
 }
-function lowerFunction(declaration, staticAnnotations, sourceFile, checker, functionsBySymbol, scan, sites) {
+function lowerFunction(unit, staticAnnotations, sourceFile, checker, functionsBySymbol, scan, sites) {
+  const { declaration } = unit;
   for (const annotation of staticAnnotations) {
     if (annotation.kind === "invalid") {
       throw unsupported(annotation.node, { kind: "staticAssertionForm", problem: annotation.problem });
@@ -5598,24 +5735,31 @@ function lowerFunction(declaration, staticAnnotations, sourceFile, checker, func
   }
   if (declaration.body == null)
     throw unsupported(declaration, { kind: "functionWithoutBody" });
-  if (declaration.asteriskToken != null || declaration.modifiers?.some((modifier) => modifier.kind === ts8.SyntaxKind.AsyncKeyword) === true) {
+  if (!ts9.isArrowFunction(declaration) && declaration.asteriskToken != null || declaration.modifiers?.some((modifier) => modifier.kind === ts9.SyntaxKind.AsyncKeyword) === true) {
     throw unsupported(declaration, { kind: "asyncOrGeneratorFunction" });
   }
   assertAccepted(declaration);
-  const signature = checker.getSignatureFromDeclaration(declaration);
-  if (signature != null && checker.getTypePredicateOfSignature(signature) != null) {
+  const signature = unit.signature;
+  if (signature == null) {
+    throw unsupported(unit.name, {
+      kind: unit.initializer == null ? "functionWithoutSignature" : "constFunctionSignature"
+    });
+  }
+  if (checker.getTypePredicateOfSignature(signature) != null) {
     throw unsupported(declaration, { kind: "typePredicate" });
   }
-  const returnType = functionReturnType(declaration, checker);
-  const returnsVoid = (returnType.flags & (ts8.TypeFlags.Void | ts8.TypeFlags.Undefined | ts8.TypeFlags.Never)) !== 0;
+  const returnType = checker.getReturnTypeOfSignature(signature);
+  const returnsVoid = (returnType.flags & (ts9.TypeFlags.Void | ts9.TypeFlags.Undefined | ts9.TypeFlags.Never)) !== 0;
   if (!returnsVoid && valueKind(returnType, checker) == null) {
     throw unsupported(declaration.type ?? declaration, { kind: "valueType", typeText: checker.typeToString(returnType) });
   }
-  const context = createFunctionContext(sourceFile, checker, functionsBySymbol, scan.bindingsBySymbol, sites, staticAnnotations);
+  const context = createFunctionContext(sourceFile, checker, functionsBySymbol, scan.bindingsBySymbol, sites, staticAnnotations, returnsVoid);
   const entry = context.currentBlock;
-  for (const parameter of declaration.parameters) {
-    if (ts8.isObjectBindingPattern(parameter.name)) {
-      const type2 = lowerParameterType(parameter, checker);
+  for (let parameterIndex = 0;parameterIndex < declaration.parameters.length; parameterIndex++) {
+    const parameter = declaration.parameters[parameterIndex];
+    const parameterType = unit.initializer == null ? checker.getTypeAtLocation(parameter) : checker.getTypeOfSymbolAtLocation(signature.parameters[parameterIndex], signature.declaration);
+    if (ts9.isObjectBindingPattern(parameter.name)) {
+      const type2 = lowerParameterType(parameter, parameterType, checker);
       const patternName = parameter.name.getText(sourceFile).replace(/\s+/g, " ");
       if (parameter.initializer != null) {
         throw unsupported(parameter, { kind: "parameterDefaultValue", name: patternName });
@@ -5624,10 +5768,10 @@ function lowerFunction(declaration, staticAnnotations, sourceFile, checker, func
       const bindings = [];
       context.parameters.push({ value: value3, name: patternName, type: type2, site: addSite(context, parameter), bindings });
       for (const element of parameter.name.elements) {
-        if (!ts8.isIdentifier(element.name) || element.dotDotDotToken != null || element.initializer != null) {
+        if (!ts9.isIdentifier(element.name) || element.dotDotDotToken != null || element.initializer != null) {
           throw unsupported(element, { kind: "destructuredParameter" });
         }
-        const property = element.propertyName == null ? element.name.text : ts8.isIdentifier(element.propertyName) ? element.propertyName.text : null;
+        const property = element.propertyName == null ? element.name.text : ts9.isIdentifier(element.propertyName) ? element.propertyName.text : null;
         if (property == null)
           throw unsupported(element, { kind: "destructuredParameter" });
         bindings.push({ property, local: element.name.text });
@@ -5643,12 +5787,12 @@ function lowerFunction(declaration, staticAnnotations, sourceFile, checker, func
       }
       continue;
     }
-    if (!ts8.isIdentifier(parameter.name))
+    if (!ts9.isIdentifier(parameter.name))
       throw unsupported(parameter.name, { kind: "destructuredParameter" });
     if (parameter.dotDotDotToken != null) {
       throw unsupported(parameter, { kind: "parameterType", typeText: `...${checker.typeToString(checker.getTypeAtLocation(parameter))}`, optionalOrRestTuple: false });
     }
-    let type = lowerParameterType(parameter, checker);
+    let type = lowerParameterType(parameter, parameterType, checker);
     if (parameter.initializer != null) {
       const default_ = parameterDefaultLiteral(parameter.initializer, checker);
       if (default_ == null || !parameterDefaultFits(default_, type)) {
@@ -5661,7 +5805,16 @@ function lowerFunction(declaration, staticAnnotations, sourceFile, checker, func
     context.parameters.push({ value: value2, name: parameter.name.text, type, site: addSite(context, parameter), bindings: null });
   }
   lowerFiniteInputRequirements(context);
-  lowerStatements(declaration.body.statements, context);
+  if (ts9.isBlock(declaration.body)) {
+    lowerStatements(declaration.body.statements, context);
+  } else {
+    const value2 = lowerExpression(declaration.body, context);
+    terminate(context.currentBlock, {
+      kind: "return",
+      value: returnsVoid ? null : value2,
+      site: addSite(context, declaration.body)
+    });
+  }
   if (context.currentBlock.terminator == null) {
     if (!returnsVoid) {
       terminate(context.currentBlock, { kind: "stop", site: addSite(context, declaration), reason: { kind: "missingReturn" } });
@@ -5671,12 +5824,12 @@ function lowerFunction(declaration, staticAnnotations, sourceFile, checker, func
   }
   return {
     kind: "lowered",
-    name: declaration.name.text,
+    name: unit.name.text,
     assertions: context.assertions,
     parameters: context.parameters,
     returnPropertyNames: declaredRecordReturnNames(returnType, checker),
     entry: 0,
-    blocks: sealBlocks(context.blocks, declaration.name.text)
+    blocks: sealBlocks(context.blocks, unit.name.text)
   };
 }
 function lowerFiniteInputRequirements(context) {
@@ -5710,7 +5863,7 @@ function declaredRecordReturnNames(returnType, checker) {
   if (kind === "object")
     return checker.getPropertiesOfType(returnType).map((property) => property.name);
   if (kind === "nullable" && returnType.isUnion()) {
-    const missing = ts8.TypeFlags.Null | ts8.TypeFlags.Undefined;
+    const missing = ts9.TypeFlags.Null | ts9.TypeFlags.Undefined;
     const members = returnType.types.filter((member) => (member.flags & missing) === 0);
     if (members.length > 0 && members.every((member) => valueKind(member, checker) === "object")) {
       const names = new Set;
@@ -5723,8 +5876,7 @@ function declaredRecordReturnNames(returnType, checker) {
   }
   return null;
 }
-function lowerParameterType(parameter, checker) {
-  const type = checker.getTypeAtLocation(parameter);
+function lowerParameterType(parameter, type, checker) {
   const declared = declaredKind(type, checker, []);
   if (declared == null) {
     throw unsupported(parameter, {
@@ -5735,12 +5887,6 @@ function lowerParameterType(parameter, checker) {
   }
   return declared;
 }
-function functionReturnType(declaration, checker) {
-  const signature = checker.getSignatureFromDeclaration(declaration);
-  if (signature == null)
-    throw unsupported(declaration, { kind: "functionWithoutSignature" });
-  return checker.getReturnTypeOfSignature(signature);
-}
 
 // src/analyze.ts
 function analyzeCheckedSource(checked, baseDirectory) {
@@ -6505,6 +6651,7 @@ function formatStop(stop, program, analysis) {
           return `reads ${binding.name}, whose value the analysis does not track (read at ${formatSite(program, stop.site)})`;
         case "value":
         case "kind":
+        case "function":
           return `reads ${binding.name} before it is initialized (read at ${formatSite(program, stop.site)})`;
       }
     }
@@ -6563,6 +6710,8 @@ function formatUnsupportedReason(reason) {
       return "node without a TypeScript symbol";
     case "functionWithoutSignature":
       return "function without a TypeScript signature";
+    case "constFunctionSignature":
+      return "a top-level const function whose declared call shape differs from its implementation";
     case "functionWithoutBody":
       return "function declarations need bodies";
     case "destructuredParameter":
@@ -6788,7 +6937,7 @@ function formatNumber(value2) {
 }
 
 // src/typescript/diagnostics.ts
-import * as ts9 from "typescript";
+import * as ts10 from "typescript";
 
 class TypeScriptDiagnosticsError extends Error {
   diagnostics;
@@ -6805,10 +6954,10 @@ class TypeScriptDiagnosticsError extends Error {
 function formatTypeScriptDiagnostics(diagnostics, options, currentDirectory) {
   const host = {
     getCurrentDirectory: () => currentDirectory,
-    getCanonicalFileName: ts9.sys.useCaseSensitiveFileNames ? (file) => file : (file) => file.toLowerCase(),
-    getNewLine: () => ts9.sys.newLine
+    getCanonicalFileName: ts10.sys.useCaseSensitiveFileNames ? (file) => file : (file) => file.toLowerCase(),
+    getNewLine: () => ts10.sys.newLine
   };
-  return usePrettyOutput(options["pretty"]) ? ts9.formatDiagnosticsWithColorAndContext(diagnostics, host) : ts9.formatDiagnostics(diagnostics, host);
+  return usePrettyOutput(options["pretty"]) ? ts10.formatDiagnosticsWithColorAndContext(diagnostics, host) : ts10.formatDiagnostics(diagnostics, host);
 }
 function usePrettyOutput(configured) {
   if (typeof configured === "boolean")
@@ -6819,7 +6968,7 @@ function usePrettyOutput(configured) {
   const forceColor = process.env["FORCE_COLOR"];
   if (forceColor != null && forceColor !== "")
     return true;
-  return ts9.sys.writeOutputIsTTY?.() === true;
+  return ts10.sys.writeOutputIsTTY?.() === true;
 }
 function color(code, text) {
   return `\x1B[${code}m${text}\x1B[0m`;
@@ -7046,7 +7195,7 @@ function createFileAudit({ program, analysis }) {
   };
 }
 function formatAuditCoverage(coverage) {
-  const parts = coverage.functions === 0 ? ["no named function declarations"] : [`${coverage.analyzed}/${coverage.functions} functions fully analyzed`];
+  const parts = coverage.functions === 0 ? ["no named top-level functions"] : [`${coverage.analyzed}/${coverage.functions} functions fully analyzed`];
   if (coverage.partial > 0)
     parts.push(`${coverage.partial} partially supported`);
   if (coverage.unsupported > 0)
@@ -7141,6 +7290,7 @@ function guidesForUnsupportedReason(reason) {
     case "unknownIdentifier":
     case "missingSymbol":
     case "functionWithoutSignature":
+    case "constFunctionSignature":
     case "functionWithoutBody":
     case "destructuredParameter":
     case "parameterType":
@@ -7211,12 +7361,12 @@ function isCallerInput(expression) {
 
 // src/typescript/check.ts
 import { resolve } from "node:path";
-import * as ts10 from "typescript";
+import * as ts11 from "typescript";
 var fallbackOptions = {
-  target: ts10.ScriptTarget.ESNext,
-  module: ts10.ModuleKind.ESNext,
-  moduleResolution: ts10.ModuleResolutionKind.Bundler,
-  moduleDetection: ts10.ModuleDetectionKind.Force,
+  target: ts11.ScriptTarget.ESNext,
+  module: ts11.ModuleKind.ESNext,
+  moduleResolution: ts11.ModuleResolutionKind.Bundler,
+  moduleDetection: ts11.ModuleDetectionKind.Force,
   strict: true,
   noUncheckedIndexedAccess: true,
   exactOptionalPropertyTypes: true,
@@ -7226,11 +7376,11 @@ var fallbackOptions = {
 };
 function checkFile(file) {
   const absoluteFile = resolve(file);
-  const program = ts10.createProgram([absoluteFile], fallbackOptions);
+  const program = ts11.createProgram([absoluteFile], fallbackOptions);
   return checkedSource(program, absoluteFile, fallbackOptions);
 }
 function checkedSource(program, file, options) {
-  const diagnostics = ts10.getPreEmitDiagnostics(program);
+  const diagnostics = ts11.getPreEmitDiagnostics(program);
   if (diagnostics.length > 0) {
     throw new TypeScriptDiagnosticsError(diagnostics, options, process.cwd());
   }
@@ -7242,9 +7392,9 @@ function checkedSource(program, file, options) {
 
 // src/typescript/project.ts
 import { dirname, isAbsolute, relative as relative2, resolve as resolve2, sep } from "node:path";
-import * as ts11 from "typescript";
+import * as ts12 from "typescript";
 function findTypeScriptConfig(searchFrom) {
-  return ts11.findConfigFile(resolve2(searchFrom), (file) => ts11.sys.fileExists(file), "tsconfig.json") ?? null;
+  return ts12.findConfigFile(resolve2(searchFrom), (file) => ts12.sys.fileExists(file), "tsconfig.json") ?? null;
 }
 function loadTypeScriptProjectGraph(configPath) {
   const loaded = [];
@@ -7261,8 +7411,8 @@ function loadTypeScriptProjectGraph(configPath) {
     const parsed = parseConfig(absoluteConfigPath);
     requireStrictNullChecks(parsed.options, absoluteConfigPath);
     for (const reference of parsed.projectReferences ?? [])
-      load(ts11.resolveProjectReferencePath(reference));
-    const program = ts11.createProgram({
+      load(ts12.resolveProjectReferencePath(reference));
+    const program = ts12.createProgram({
       rootNames: parsed.fileNames,
       options: parsed.options,
       configFileParsingDiagnostics: parsed.errors,
@@ -7297,8 +7447,8 @@ function projectSources(projects) {
   return [...sources.values()].sort((left, right) => left.sourceFile.fileName.localeCompare(right.sourceFile.fileName));
 }
 function parseConfig(configPath) {
-  const parsed = ts11.getParsedCommandLineOfConfigFile(configPath, undefined, {
-    ...ts11.sys,
+  const parsed = ts12.getParsedCommandLineOfConfigFile(configPath, undefined, {
+    ...ts12.sys,
     onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
       throw new TypeScriptDiagnosticsError([diagnostic], {}, dirname(configPath));
     }
@@ -7359,7 +7509,7 @@ function analyzeProject(searchFrom) {
   const projects = loadTypeScriptProjectGraph(configPath);
   const rootProject = projects.at(-1);
   const sources = projectSources(projects);
-  const diagnostics = uniqueDiagnostics(projects.flatMap((project) => ts12.getPreEmitDiagnostics(project.program)));
+  const diagnostics = uniqueDiagnostics(projects.flatMap((project) => ts13.getPreEmitDiagnostics(project.program)));
   requireNoTypeScriptErrors(diagnostics, rootProject.parsed.options);
   const files = [];
   let analyzed = 0;
@@ -7483,7 +7633,7 @@ function collectLintFindings({ program, analysis }) {
   collectStops(analysis.initializer);
   collectAssertions(analysis.initializer);
   for (const issue of program.staticAnnotationIssues) {
-    addError(issue.site, "console-assert", "console.assert is only supported inside a named top-level function declaration");
+    addError(issue.site, "console-assert", "console.assert is only supported inside a named top-level function");
   }
   for (const fn of analysis.functions) {
     collectStops(fn);
@@ -7580,7 +7730,7 @@ function formatLintPrefix(finding, rule, pretty) {
   return formatDiagnosticPrefix(finding, lintLevel(finding), rule, pretty);
 }
 function formatCoverage(coverage) {
-  return `coverage: ${coverage.analyzed}/${coverage.functions} named top-level function declarations fully analyzed; ${coverage.partial} partially supported; ${coverage.unsupported} unsupported.`;
+  return `coverage: ${coverage.analyzed}/${coverage.functions} named top-level functions fully analyzed; ${coverage.partial} partially supported; ${coverage.unsupported} unsupported.`;
 }
 function analyzeTargetFile(file) {
   const absoluteFile = resolve3(file);
@@ -7596,7 +7746,7 @@ function analyzeTargetFile(file) {
   if (source == null) {
     throw new Error(`File is not part of the project resolved from ${configPath}: ${absoluteFile}`);
   }
-  const diagnostics = ts12.getPreEmitDiagnostics(source.project.program, source.sourceFile);
+  const diagnostics = ts13.getPreEmitDiagnostics(source.project.program, source.sourceFile);
   requireNoTypeScriptErrors(diagnostics, rootProject.parsed.options);
   return {
     detailed: analyzeProjectSource(source, process.cwd()),
@@ -7605,7 +7755,7 @@ function analyzeTargetFile(file) {
 }
 function canonicalFilePath(file) {
   const real = realpathSync.native(file);
-  return ts12.sys.useCaseSensitiveFileNames ? real : real.toLowerCase();
+  return ts13.sys.useCaseSensitiveFileNames ? real : real.toLowerCase();
 }
 function analyzeFileAlone(absoluteFile) {
   return {
@@ -7622,7 +7772,7 @@ function analyzeProjectSource(source, reportBaseDirectory) {
 function uniqueDiagnostics(diagnostics) {
   const seen = new Set;
   return diagnostics.filter((diagnostic) => {
-    const message = ts12.flattenDiagnosticMessageText(diagnostic.messageText, `
+    const message = ts13.flattenDiagnosticMessageText(diagnostic.messageText, `
 `);
     const key = `${diagnostic.file?.fileName ?? ""}:${diagnostic.start ?? ""}:${diagnostic.length ?? ""}:${diagnostic.code}:${message}`;
     if (seen.has(key))
@@ -7643,7 +7793,7 @@ function requireNoTypeScriptErrors(diagnostics, options) {
   printTypeScriptDiagnostics(diagnostics, options, process.cwd());
 }
 function hasErrorDiagnostics(diagnostics) {
-  return diagnostics.some((diagnostic) => diagnostic.category === ts12.DiagnosticCategory.Error);
+  return diagnostics.some((diagnostic) => diagnostic.category === ts13.DiagnosticCategory.Error);
 }
 
 // fr.ts