@chenglou/freerange 0.0.2 → 0.0.4

package/src/lower/expression.ts

@@ -2,7 +2,12 @@ import * as ts from 'typescript'
 import type {ValueID} from '../ir/ids.ts'
 import type {ComparisonOperator, InstructionIR} from '../ir/instructions.ts'
 import type {StaticAssertionProblem} from '../ir/program.ts'
-import {declaredOnlyInDeclarationFiles, platformFact} from './platform.ts'
+import {numberConstituent} from './numeric-intersection.ts'
+import {
+  declaredOnlyInDeclarationFiles,
+  hasDefaultLibraryDeclaration,
+  platformFact,
+} from './platform.ts'
 import {
   addInstruction,
   addInstructionAtSite,
@@ -152,7 +157,7 @@ export function lowerExpression(expression: ts.Expression, context: FunctionCont
     if (ts.isNumericLiteral(negated)) {
       return addInstruction(context, current, {kind: 'constant', value: -Number(negated.text)})
     }
-    if (isGlobalInfinity(negated, context.checker)) {
+    if (isStandardGlobal(negated, 'Infinity', context)) {
       return addInstruction(context, current, {kind: 'constant', value: Number.NEGATIVE_INFINITY})
     }
     const zero = addInstruction(context, current, {kind: 'constant', value: 0})
@@ -346,7 +351,8 @@ export function lowerExpression(expression: ts.Expression, context: FunctionCont
     // `el instanceof HTMLDivElement` on a carried value: no narrowing (the analyzer does
     // not model classes), but the check itself is an effect-free operator, so it answers
     // unknown and both branches analyze — the function's other paths survive. The
-    // declaration-file check is the same shadowing defense Math uses.
+    // A declaration-file constructor is opaque but safe to test; a local constructor is
+    // runtime code outside the accepted subset.
     if (current.operatorToken.kind === ts.SyntaxKind.InstanceOfKeyword
       && ts.isIdentifier(current.right)
       && declaredOnlyInDeclarationFiles(context.checker.getSymbolAtLocation(current.right))) {
@@ -394,10 +400,11 @@ export function lowerExpression(expression: ts.Expression, context: FunctionCont
     if (staticAnnotation != null) return lowerStaticAnnotation(staticAnnotation, context)
     if (ts.isIdentifier(current.expression)) {
       // Global parseFloat / parseInt / Number(x): honest NaN-carrying results, like their
-      // Number.* spellings below (the declaration-file check defends against shadowing).
+      // Number.* spellings below. Standard-library identity defends against shadows and
+      // project declarations that merely reuse a built-in name.
       const globalName = current.expression.text
       if ((globalName === 'parseFloat' || globalName === 'parseInt' || globalName === 'Number')
-        && declaredOnlyInDeclarationFiles(context.checker.getSymbolAtLocation(current.expression))) {
+        && isStandardGlobal(current.expression, globalName, context)) {
         for (const argument of current.arguments) lowerExpression(argument, context)
         return addInstruction(context, current, {kind: 'parsedNumber', integer: globalName === 'parseInt'})
       }
@@ -420,7 +427,10 @@ export function lowerExpression(expression: ts.Expression, context: FunctionCont
             arguments_.push(lowerParameterDefault(default_, parameter.initializer, context))
             continue
           }
-          if (parameter.questionToken != null) {
+          const callableParameter = callee.signature?.declaration?.parameters[index]
+          if (callableParameter != null
+            && ts.isParameter(callableParameter)
+            && callableParameter.questionToken != null) {
             arguments_.push(addInstruction(context, parameter, {kind: 'nullishConstant', sentinel: 'undefined'}))
             continue
           }
@@ -452,15 +462,22 @@ export function lowerExpression(expression: ts.Expression, context: FunctionCont
           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 (ts.isPropertyAccessExpression(current.expression)) {
-      const platformCall = current.arguments.length === 0 ? platformFact(current.expression, true, context.checker) : null
+      const platformCall = current.arguments.length === 0
+        ? platformFact(current.expression, true, context.checker, context.program)
+        : null
       if (platformCall != null) {
         return addInstruction(context, current, {kind: 'platformValue', ...platformCall})
       }
       const method = current.expression.name.text
-      const standardMath = isStandardMathObject(current.expression.expression, context.checker)
+      const standardMath = isStandardGlobal(current.expression.expression, 'Math', context)
       if (standardMath && method === 'floor' && current.arguments.length === 1) {
         requireNumberType(current.arguments[0]!, context.checker)
         const value = lowerExpression(current.arguments[0]!, context)
@@ -485,7 +502,7 @@ export function lowerExpression(expression: ts.Expression, context: FunctionCont
       // Number.isInteger / Number.isFinite: predicate checks whose branches narrow — the
       // missing halves of the bounds-check idiom (`i >= 0 && i < arr.length` proves the
       // range; Number.isInteger(i) proves the read hits an element rather than arr[1.5]).
-      const standardNumber = isStandardNumberObject(current.expression.expression, context.checker)
+      const standardNumber = isStandardGlobal(current.expression.expression, 'Number', context)
       // Number.parseFloat / Number.parseInt: honest NaN sources — the result is any
       // number including NaN, and the isFinite/isNaN/isInteger narrowing downstream is
       // exactly what launders it. Arguments still lower (opaque strings carry).
@@ -514,7 +531,7 @@ export function lowerExpression(expression: ts.Expression, context: FunctionCont
     }
   }
   if (ts.isPropertyAccessExpression(current)) {
-    const platform = platformFact(current, false, context.checker)
+    const platform = platformFact(current, false, context.checker, context.program)
     if (platform != null) {
       return addInstruction(context, current, {kind: 'platformValue', ...platform})
     }
@@ -589,15 +606,15 @@ function lowerStaticAnnotation(annotation: StaticAnnotation, context: FunctionCo
     if (requirement == null) {
       throw unsupported(condition, {
         kind: 'staticAssertionForm',
-        problem: staticAssertionProblem(condition, context.checker, 'callerRequirement'),
+        problem: staticAssertionProblem(condition, context, 'callerRequirement'),
       })
     }
     value = lowerWrittenRequirement(requirement, condition, context)
   } else {
-    if (!supportedWrittenAssertion(condition, context.checker)) {
+    if (!supportedWrittenAssertion(condition, context)) {
       throw unsupported(condition, {
         kind: 'staticAssertionForm',
-        problem: staticAssertionProblem(condition, context.checker, 'directCheck'),
+        problem: staticAssertionProblem(condition, context, 'directCheck'),
       })
     }
     value = lowerExpression(condition, context)
@@ -634,7 +651,7 @@ function writtenRequirement(condition: ts.Expression, context: FunctionContext):
   if (ts.isCallExpression(current) && current.questionDotToken == null
     && current.arguments.length === 1 && ts.isPropertyAccessExpression(current.expression)
     && current.expression.questionDotToken == null
-    && isStandardNumberObject(current.expression.expression, context.checker)
+    && isStandardGlobal(current.expression.expression, 'Number', context)
     && (current.expression.name.text === 'isInteger' || current.expression.name.text === 'isFinite')) {
     const argument = current.arguments[0]!
     const value = staticRequirementParameterPathValue(argument, context)
@@ -736,13 +753,14 @@ function lowerWrittenRequirement(
 // calculation is written and checked as normal code, then the assertion names its result.
 // This gives agents one syntax boundary instead of exposing whichever instructions happen
 // to be removable after general expression lowering.
-function supportedWrittenAssertion(condition: ts.Expression, checker: ts.TypeChecker): boolean {
+function supportedWrittenAssertion(condition: ts.Expression, context: FunctionContext): boolean {
   const current = unwrapParentheses(condition)
   if (ts.isBinaryExpression(current) && staticAssertionComparison(current.operatorToken.kind)) {
-    return staticAssertionNumericAtom(current.left, checker) && staticAssertionNumericAtom(current.right, checker)
+    return staticAssertionNumericAtom(current.left, context.checker)
+      && staticAssertionNumericAtom(current.right, context.checker)
   }
-  const operand = staticNumberCheckOperand(current, checker)
-  return operand != null && staticAssertionNumericAtom(operand, checker)
+  const operand = staticNumberCheckOperand(current, context)
+  return operand != null && staticAssertionNumericAtom(operand, context.checker)
 }
 
 function staticAssertionNumericAtom(expression: ts.Expression, checker: ts.TypeChecker): boolean {
@@ -794,25 +812,25 @@ function staticAssertionAtom(expression: ts.Expression): boolean {
 
 function staticAssertionProblem(
   condition: ts.Expression,
-  checker: ts.TypeChecker,
+  context: FunctionContext,
   fallback: 'directCheck' | 'callerRequirement',
 ): StaticAssertionProblem {
   const current = unwrapParentheses(condition)
   if (ts.isBinaryExpression(current) && staticAssertionComparison(current.operatorToken.kind)) {
     return staticAssertionAtomProblem(current.left) ?? staticAssertionAtomProblem(current.right) ?? fallback
   }
-  const operand = staticNumberCheckOperand(current, checker)
+  const operand = staticNumberCheckOperand(current, context)
   if (operand != null) return staticAssertionAtomProblem(operand) ?? fallback
   if (ts.isCallExpression(current)) return 'functionCall'
   return 'directCheck'
 }
 
-function staticNumberCheckOperand(expression: ts.Expression, checker: ts.TypeChecker): ts.Expression | null {
+function staticNumberCheckOperand(expression: ts.Expression, context: FunctionContext): ts.Expression | null {
   if (!ts.isCallExpression(expression) || expression.questionDotToken != null
     || expression.arguments.length !== 1 || !ts.isPropertyAccessExpression(expression.expression)
     || expression.expression.questionDotToken != null) return null
   const callee = expression.expression
-  return isStandardNumberObject(callee.expression, checker)
+  return isStandardGlobal(callee.expression, 'Number', context)
     && (callee.name.text === 'isInteger' || callee.name.text === 'isFinite' || callee.name.text === 'isNaN')
     ? expression.arguments[0]!
     : null
@@ -882,12 +900,10 @@ export function compoundAssignmentOperator(kind: ts.SyntaxKind): Extract<Instruc
   }
 }
 
-// The shared value-producing branch shape: branch on the condition, lower each arm in its
-// own block, and join at a continuation whose single parameter carries the result. Arms are
-// provably assignment-free — assignments lower only through lowerStatementExpression — so
-// no bindings can change across the arms and the join needs no binding merge. Ternaries and
-// the logical operators are the two consumers; lowerIfStatement stays separate (no result
-// value, arms may terminate, and assignments are allowed there).
+// The shared value-producing branch shape: lower each arm in its own block, then join at
+// a continuation whose single parameter carries the result. Arms are assignment-free, so
+// the join needs no binding merge. One entry accepts an existing condition value; the other
+// keeps a compound condition split into branches so each check can narrow later operands.
 function lowerValueBranch(
   node: ts.Expression,
   condition: ValueID,
@@ -904,6 +920,44 @@ function lowerValueBranch(
     whenFalse: {block: whenFalse, arguments: []},
     site: addSite(context, node),
   })
+  return joinValueBranches(
+    node,
+    whenTrue,
+    whenFalse,
+    lowerTrueArm,
+    lowerFalseArm,
+    context,
+  )
+}
+
+function lowerBranchingValue(
+  node: ts.Expression,
+  condition: ts.Expression,
+  lowerTrueArm: () => ValueID,
+  lowerFalseArm: () => ValueID,
+  context: FunctionContext,
+): ValueID {
+  const whenTrue = createBlock(context)
+  const whenFalse = createBlock(context)
+  lowerBranchingCondition(condition, whenTrue, whenFalse, context)
+  return joinValueBranches(
+    node,
+    whenTrue,
+    whenFalse,
+    lowerTrueArm,
+    lowerFalseArm,
+    context,
+  )
+}
+
+function joinValueBranches(
+  node: ts.Expression,
+  whenTrue: number,
+  whenFalse: number,
+  lowerTrueArm: () => ValueID,
+  lowerFalseArm: () => ValueID,
+  context: FunctionContext,
+): ValueID {
   context.currentBlock = context.blocks[whenTrue]!
   const trueValue = lowerTrueArm()
   const trueBlock = context.currentBlock
@@ -937,28 +991,13 @@ function lowerConditionalExpression(expression: ts.ConditionalExpression, contex
   // condition as one boolean expression (the previous shape) hid the conjuncts behind a
   // joined block parameter no branch refinement could see through; a conversion pass on
   // the owner's repo caught the asymmetry.
-  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,
+  )
 }
 
 // `a && b` evaluates b only when a is true and yields false otherwise; `a || b` mirrors it —
@@ -1017,10 +1056,9 @@ function lowerLogicalExpression(expression: ts.BinaryExpression, context: Functi
   requireBooleanCondition(expression.left, context.checker)
   requireBooleanCondition(expression.right, context.checker)
   const isAnd = expression.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken
-  const condition = lowerExpression(expression.left, context)
-  return lowerValueBranch(
+  return lowerBranchingValue(
     expression,
-    condition,
+    expression.left,
     () => isAnd
       ? lowerExpression(expression.right, context)
       : addInstruction(context, expression, {kind: 'booleanConstant', value: true}),
@@ -1122,7 +1160,7 @@ export function valueKind(type: ts.Type, checker: ts.TypeChecker, depth = 0): Va
 }
 
 function valueKindUncached(type: ts.Type, checker: ts.TypeChecker, depth: number): ValueKindResult {
-  if ((type.flags & ts.TypeFlags.NumberLike) !== 0) return 'number'
+  if (numberConstituent(type) != null) return 'number'
   if ((type.flags & ts.TypeFlags.BooleanLike) !== 0) return 'boolean'
   // Strings are carried without claims: a label or id must not reject the numeric
   // contract of the function around it.
@@ -1412,22 +1450,6 @@ export function requireBooleanCondition(node: ts.Node, checker: ts.TypeChecker):
 }
 
 function requireAccessedPropertyKind(access: ts.PropertyAccessExpression, checker: ts.TypeChecker): void {
-  // An optional property reads as its maybe-undefined value: declared kinds wrap it in
-  // the undefined sentinel and object literals fill omitted ones explicitly, so a record
-  // value always carries every property its static type declares — there is always
-  // something honest to read.
-  const receiverType = checker.getTypeAtLocation(access.expression)
-  // For an optional read the receiver includes the missing sentinels; the property lives
-  // on the non-missing part, which getNonNullableType strips to.
-  const presentType = access.questionDotToken != null ? checker.getNonNullableType(receiverType) : receiverType
-  const property = checker.getPropertyOfType(presentType, access.name.text)
-  // point.toString type-checks on every object literal, but the record value carries only
-  // its own properties — an inherited prototype member has no honest answer. The
-  // ownership test is the .d.ts rule: a property symbol declared only in declaration
-  // files was not written by the project, and on a project record that means prototype.
-  if (valueKind(presentType, checker) === 'object' && property != null && declaredOnlyInDeclarationFiles(property)) {
-    throw unsupported(access, {kind: 'prototypeMemberRead', property: access.name.text})
-  }
   const type = checker.getTypeAtLocation(access)
   if (valueKind(type, checker) != null) return
   throw unsupported(access, {kind: 'valueType', typeText: checker.typeToString(type)})
@@ -1438,14 +1460,12 @@ function resolvedSymbol(symbol: ts.Symbol | undefined, checker: ts.TypeChecker):
   return (symbol.flags & ts.SymbolFlags.Alias) === 0 ? symbol : checker.getAliasedSymbol(symbol)
 }
 
-function isStandardMathObject(expression: ts.Expression, checker: ts.TypeChecker): boolean {
-  if (!ts.isIdentifier(expression) || expression.text !== 'Math') return false
-  return declaredOnlyInDeclarationFiles(checker.getSymbolAtLocation(expression))
-}
-
-function isStandardNumberObject(expression: ts.Expression, checker: ts.TypeChecker): boolean {
-  if (!ts.isIdentifier(expression) || expression.text !== 'Number') return false
-  return declaredOnlyInDeclarationFiles(checker.getSymbolAtLocation(expression))
+function isStandardGlobal(expression: ts.Expression, name: string, context: FunctionContext): boolean {
+  if (!ts.isIdentifier(expression) || expression.text !== name) return false
+  return hasDefaultLibraryDeclaration(
+    context.checker.getSymbolAtLocation(expression),
+    context.program,
+  )
 }
 
 function lowerElementAccess(access: ts.ElementAccessExpression, asserted: boolean, context: FunctionContext): ValueID {
@@ -1608,7 +1628,10 @@ function missingSentinelCheck(expression: ts.BinaryExpression, context: Function
     const missing = ts.TypeFlags.Null | ts.TypeFlags.Undefined
     const members = operandType.isUnion() ? operandType.types : [operandType]
     const restMatches = members.every(member =>
-      (member.flags & missing) !== 0 || (member.flags & typeofSide.flags) !== 0)
+      (member.flags & missing) !== 0
+      || (typeofSide.flags === ts.TypeFlags.NumberLike
+        ? valueKind(member, context.checker) === 'number'
+        : (member.flags & typeofSide.flags) !== 0))
     && members.some(member => (member.flags & missing) === 0)
     const value = lowerExpression(typeofSide.operand.expression, context)
     if (restMatches) {
@@ -1642,22 +1665,17 @@ function missingSentinelCheck(expression: ts.BinaryExpression, context: Function
   })
 }
 
-function isGlobalInfinity(expression: ts.Expression, checker: ts.TypeChecker): boolean {
-  if (!ts.isIdentifier(expression) || expression.text !== 'Infinity') return false
-  return declaredOnlyInDeclarationFiles(checker.getSymbolAtLocation(expression))
-}
-
 // Resolves an identifier read: a function-local binding first, then a module binding
 // (which reads the binding's slot), then the global `Infinity` as an exact constant,
 // else the identifier is unknown. A local or module binding named Infinity has a
-// different symbol and wins above; the global check is the same declaration-file
-// defense the Math and platform dispatches use.
+// different symbol and wins above; only TypeScript's standard Infinity receives the
+// exact constant.
 function identifierValue(symbol: ts.Symbol, node: ts.Identifier, context: FunctionContext): ValueID {
   const local = context.bindings.get(symbol)
   if (local != null) return local
   const binding = context.moduleBindingsBySymbol.get(symbol)
   if (binding != null) return addInstruction(context, node, {kind: 'moduleRead', binding})
-  if (isGlobalInfinity(node, context.checker)) {
+  if (isStandardGlobal(node, 'Infinity', context)) {
     return addInstruction(context, node, {kind: 'constant', value: Number.POSITIVE_INFINITY})
   }
   if (isUndefinedGlobal(node, context.checker)) {

package/src/lower/function-unit.ts

@@ -0,0 +1,64 @@
+import * as ts from 'typescript'
+
+export type TopLevelFunctionNode =
+  | ts.FunctionDeclaration
+  | ts.ArrowFunction
+  | ts.FunctionExpression
+
+export type TopLevelFunctionUnit = {
+  name: ts.Identifier
+  declaration: TopLevelFunctionNode
+  initializer: ts.VariableDeclaration | null
+}
+
+export function callableSignature(
+  unit: TopLevelFunctionUnit,
+  checker: ts.TypeChecker,
+): ts.Signature | null {
+  if (unit.initializer == null) {
+    return checker.getSignatureFromDeclaration(unit.declaration) ?? null
+  }
+  const signatures = checker.getSignaturesOfType(
+    checker.getTypeAtLocation(unit.name),
+    ts.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 =>
+      !ts.isParameter(parameter) || parameter.dotDotDotToken != null)) {
+    return null
+  }
+  return signature
+}
+
+export function topLevelFunctionUnits(sourceFile: ts.SourceFile): TopLevelFunctionUnit[] {
+  const units: TopLevelFunctionUnit[] = []
+  for (const statement of sourceFile.statements) {
+    if (ts.isFunctionDeclaration(statement) && statement.name != null) {
+      units.push({name: statement.name, declaration: statement, initializer: null})
+      continue
+    }
+    if (!ts.isVariableStatement(statement)
+      || (statement.declarationList.flags & ts.NodeFlags.Const) === 0) continue
+    for (const initializer of statement.declarationList.declarations) {
+      if (!ts.isIdentifier(initializer.name) || initializer.initializer == null) continue
+      const declaration = directFunctionExpression(initializer.initializer)
+      if (declaration != null) {
+        units.push({name: initializer.name, declaration, initializer})
+      }
+    }
+  }
+  return units
+}
+
+export function directFunctionExpression(
+  expression: ts.Expression,
+): ts.ArrowFunction | ts.FunctionExpression | null {
+  return ts.isArrowFunction(expression) || ts.isFunctionExpression(expression)
+    ? expression
+    : null
+}

package/src/lower/module.ts

@@ -18,6 +18,8 @@ import {numericLiteralValue} from './literals.ts'
 import {declaredOnlyInDeclarationFiles} from './platform.ts'
 import {addInstruction, addSite, createFunctionContext, LoweringStop, restoreLowering, sealBlocks, snapshotLowering, terminate, type FunctionContext, type TopLevelFunction} from './context.ts'
 import {lowerExpression, nonMissingUnionMembers, tagLiteralValues, taggedUnionProperty, valueKind} from './expression.ts'
+import {directFunctionExpression} from './function-unit.ts'
+import {numberConstituent} from './numeric-intersection.ts'
 import {lowerStatement} from './statements.ts'
 
 export type ModuleScan = {
@@ -45,9 +47,16 @@ export function scanModuleBindings(sourceFile: ts.SourceFile, checker: ts.TypeCh
       // the statement itself is skipped when the initializer reaches it, and functions
       // reading the name are rejected as unknown identifiers.
       if ((statement.declarationList.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) === 0) continue
+      const isConst = (statement.declarationList.flags & ts.NodeFlags.Const) !== 0
       for (const declarator of statement.declarationList.declarations) {
         if (ts.isIdentifier(declarator.name)) {
-          register(declarator.name, declaredCategory(declarator.name, checker))
+          register(
+            declarator.name,
+            isConst && declarator.initializer != null
+              && directFunctionExpression(declarator.initializer) != null
+              ? {kind: 'function'}
+              : declaredCategory(declarator.name, checker),
+          )
           continue
         }
         // `const {cols} = gridSize` at the top level: each destructured name is its own
@@ -189,11 +198,12 @@ function demoteModuleWritesInNode(
 export function lowerModuleInitializer(
   sourceFile: ts.SourceFile,
   checker: ts.TypeChecker,
+  program: ts.Program,
   functionsBySymbol: Map<ts.Symbol, TopLevelFunction>,
   scan: ModuleScan,
   sites: SourceSpan[],
 ): {initializer: FunctionIR; skips: InitializerSkip[]} {
-  const context = createFunctionContext(sourceFile, checker, functionsBySymbol, scan.bindingsBySymbol, sites)
+  const context = createFunctionContext(sourceFile, checker, program, functionsBySymbol, scan.bindingsBySymbol, sites)
   const skips: InitializerSkip[] = []
   const statements = sourceFile.statements
   // Each statement gets its own catch: an unsupported one is skipped — its half-lowered
@@ -206,7 +216,7 @@ export function lowerModuleInitializer(
     if (skippedAtTopLevel(statement)) continue
     const recovery = snapshotLowering(context)
     try {
-      assertAccepted(statement)
+      assertAccepted(statement, true)
       if (ts.isVariableStatement(statement)) {
         lowerTopLevelDeclarations(statement, context, scan)
         continue
@@ -354,6 +364,12 @@ function lowerTopLevelDeclarations(statement: ts.VariableStatement, context: Fun
     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 & ts.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 value = lowerExpression(declarator.initializer, context)
     addInstruction(context, declarator, {kind: 'moduleWrite', binding, value})
   }
@@ -361,8 +377,9 @@ function lowerTopLevelDeclarations(statement: ts.VariableStatement, context: Fun
 
 function skippedAtTopLevel(statement: ts.Statement): boolean {
   // `export {alreadyDeclaredName}` and import declarations create bindings but run nothing.
-  // Only NAMED function declarations pass: those become program.functions entries, so
-  // unsupported code inside them keeps the fully-analyzed publish gate honest. An
+  // Named declarations pass here: those become program.functions entries, so unsupported
+  // code inside them keeps the fully-analyzed publish gate honest. Const-bound functions
+  // remain variable statements and lower above as function-initialization markers. An
   // anonymous `export default function` has no name to collect under, so it falls through
   // to ordinary statement lowering, which records it as an initializer skip — otherwise
   // its body would be runtime code invisible to every gate.
@@ -667,14 +684,15 @@ function declaredKindUncached(type: ts.Type, checker: ts.TypeChecker, seen: ts.T
 
 function numericLiteralInterval(type: ts.Type): DeclaredNumberInterval | 'nonFinite' | null {
   const members = type.isUnion() ? type.types : [type]
-  if (!members.every(member =>
-    (member.flags & ts.TypeFlags.NumberLiteral) !== 0
-    && (member.flags & ts.TypeFlags.EnumLiteral) === 0)) return null
   let lower = Infinity
   let upper = -Infinity
   let integer = true
   for (const member of members) {
-    const value = (member as ts.NumberLiteralType).value
+    const number = numberConstituent(member)
+    if (number == null
+      || (number.flags & ts.TypeFlags.NumberLiteral) === 0
+      || (number.flags & ts.TypeFlags.EnumLiteral) !== 0) return null
+    const value = (number as ts.NumberLiteralType).value
     if (!Number.isFinite(value)) return 'nonFinite'
     lower = Math.min(lower, value)
     upper = Math.max(upper, value)
@@ -741,6 +759,7 @@ function demote(bindings: ModuleBindingIR[], binding: ModuleBindingID): void {
       break
     }
     case 'kind':
+    case 'function':
     case 'import':
     case 'opaque':
       break

package/src/lower/numeric-intersection.ts

@@ -0,0 +1,15 @@
+import * as ts from 'typescript'
+
+// TypeScript represents numeric brands as a number intersected with object metadata.
+// Freerange uses the number and ignores the metadata; reading that metadata still stops
+// because the runtime value is modeled as a number, not a record.
+export function numberConstituent(type: ts.Type): ts.Type | null {
+  if ((type.flags & ts.TypeFlags.NumberLike) !== 0) return type
+  if (!type.isIntersection()) return null
+  const numberTypes = type.types.filter(member => (member.flags & ts.TypeFlags.NumberLike) !== 0)
+  if (numberTypes.length !== 1) return null
+  for (const member of type.types) {
+    if (member !== numberTypes[0] && (member.flags & ts.TypeFlags.Object) === 0) return null
+  }
+  return numberTypes[0]!
+}

package/src/lower/platform.ts

@@ -29,6 +29,7 @@ type PlatformEntry = {
 }
 
 const anyFinite = {lower: -Number.MAX_VALUE, upper: Number.MAX_VALUE}
+const maximumDateTime = 8_640_000_000_000_000
 
 const catalog: PlatformEntry[] = [
   // Element layout sizes are nonnegative integers (the spec rounds them).
@@ -43,16 +44,23 @@ const catalog: PlatformEntry[] = [
   {path: ['window', 'scrollY'], call: false, fact: {...anyFinite, integer: false}},
   {path: ['document', 'body', 'scrollTop'], call: false, fact: {...anyFinite, integer: false}},
   {path: ['document', 'body', 'scrollLeft'], call: false, fact: {...anyFinite, integer: false}},
-  // Monotonic clocks: finite, nonnegative, fractional (performance.now has sub-millisecond
-  // resolution); Date.now is an integer count of milliseconds.
+  // performance.now is monotonic, finite, nonnegative, and fractional. Date.now is an
+  // integer UTC time value and may be negative for a clock set before the Unix epoch.
   {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: -maximumDateTime, upper: maximumDateTime, integer: true}},
+  // Math.random returns one of JavaScript's discrete floating-point numbers below 1.
+  // Writing the predecessor of 1 keeps the exact closed range without adding open bounds.
+  {path: ['Math', 'random'], call: true, fact: {lower: 0, upper: 0.9999999999999999, integer: false}},
 ]
 
-// Matches a property chain rooted at a global whose symbol resolves into a declaration
-// file — the same shadowing defense the Math dispatch uses, so a local variable named
-// `document` never matches.
-export function platformFact(expression: ts.Expression, call: boolean, checker: ts.TypeChecker): PlatformFact | null {
+// Matches a property chain rooted at a global from TypeScript's standard library. A local
+// variable or a project-supplied ambient declaration with the same name never matches.
+export function platformFact(
+  expression: ts.Expression,
+  call: boolean,
+  checker: ts.TypeChecker,
+  program: ts.Program,
+): PlatformFact | null {
   const parts: string[] = []
   let current: ts.Expression = expression
   while (ts.isPropertyAccessExpression(current)) {
@@ -66,14 +74,22 @@ export function platformFact(expression: ts.Expression, call: boolean, checker:
     && candidate.path.length === parts.length
     && candidate.path.every((segment, index) => segment === parts[index]))
   if (entry == null) return null
-  if (!declaredOnlyInDeclarationFiles(checker.getSymbolAtLocation(current))) return null
+  if (!hasDefaultLibraryDeclaration(checker.getSymbolAtLocation(current), program)) return null
   return entry.fact
 }
 
-// The shadowing defense shared by every trusted-global dispatch (this catalog, `Math`,
-// `Infinity`): the identifier counts as the real global only when every declaration of its
-// symbol lives in a declaration file, so a local or module binding of the same name never
-// matches.
+// A standard-library declaration anchors the symbol to the real JavaScript or browser
+// global. Additional project declarations may augment that symbol; a lookalike symbol
+// declared only by the project does not receive Freerange's built-in behavior.
+export function hasDefaultLibraryDeclaration(
+  symbol: ts.Symbol | undefined,
+  program: ts.Program,
+): boolean {
+  const declarations = symbol?.declarations
+  if (declarations == null || declarations.length === 0) return false
+  return declarations.some(declaration => program.isSourceFileDefaultLibrary(declaration.getSourceFile()))
+}
+
 export function declaredOnlyInDeclarationFiles(symbol: ts.Symbol | undefined): boolean {
   const declarations = symbol?.declarations
   if (declarations == null || declarations.length === 0) return false