@chenglou/freerange 0.0.3 → 0.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chenglou/freerange",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Static numeric range analysis for TypeScript",
   "license": "MIT",
   "repository": {

package/src/audit.ts

@@ -415,10 +415,8 @@ function guidesForUnsupportedReason(reason: UnsupportedReason): RefactorGuideID[
     case 'computedPropertyName':
     case 'objectSpread':
     case 'asyncOrGeneratorFunction':
-    case 'typePredicate':
     case 'protoProperty':
     case 'enumMemberRead':
-    case 'prototypeMemberRead':
     case 'binaryOperator':
     case 'callWithFewerArguments':
     case 'callWithMoreArguments':

package/src/ir/program.ts

@@ -97,11 +97,8 @@ export type UnsupportedReason =
   | {kind: 'computedPropertyName'}
   | {kind: 'objectSpread'}
   | {kind: 'asyncOrGeneratorFunction'}
-  | {kind: 'typePredicate'}
   | {kind: 'protoProperty'}
   | {kind: 'enumMemberRead'}
-  // point.toString and friends: a prototype member the record value cannot answer.
-  | {kind: 'prototypeMemberRead'; property: string}
   // e.g. '**', '>>', 'instanceof' in value position — the operators arithmetic and
   // comparison lowering do not claim ('%' and '??' lower now and no longer land here)
   | {kind: 'binaryOperator'; operator: string}

package/src/lower/context.ts

@@ -31,6 +31,7 @@ export type TopLevelFunction = TopLevelFunctionUnit & {
 export type FunctionContext = {
   sourceFile: ts.SourceFile
   checker: ts.TypeChecker
+  program: ts.Program
   functionsBySymbol: Map<ts.Symbol, TopLevelFunction>
   moduleBindingsBySymbol: Map<ts.Symbol, ModuleBindingID>
   staticAnnotations: Map<ts.CallExpression, StaticAnnotation>
@@ -60,6 +61,7 @@ export type LoopTarget = {
 export function createFunctionContext(
   sourceFile: ts.SourceFile,
   checker: ts.TypeChecker,
+  program: ts.Program,
   functionsBySymbol: Map<ts.Symbol, TopLevelFunction>,
   moduleBindingsBySymbol: Map<ts.Symbol, ModuleBindingID>,
   sites: SourceSpan[],
@@ -70,6 +72,7 @@ export function createFunctionContext(
   return {
     sourceFile,
     checker,
+    program,
     functionsBySymbol,
     moduleBindingsBySymbol,
     staticAnnotations: new Map(staticAnnotations.map(annotation => [annotation.call, annotation])),

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'})
       }
@@ -463,12 +470,14 @@ export function lowerExpression(expression: ts.Expression, context: FunctionCont
       })
     }
     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)
@@ -493,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).
@@ -522,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})
     }
@@ -597,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)
@@ -642,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)
@@ -744,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 {
@@ -802,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
@@ -1150,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.
@@ -1440,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)})
@@ -1466,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 {
@@ -1636,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) {
@@ -1670,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/module.ts

@@ -19,6 +19,7 @@ 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 = {
@@ -197,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
@@ -682,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)

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,19 +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)) {
@@ -69,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

package/src/lower/program.ts

@@ -12,7 +12,8 @@ import {scanStaticAnnotations, type StaticAnnotation} from './static-intrinsics.
 import {lowerStatements} from './statements.ts'
 
 export function lowerSource(checked: CheckedSource, baseDirectory: string = process.cwd()): ProgramIR {
-  const {sourceFile, checker} = checked
+  const {sourceFile, program} = checked
+  const checker = program.getTypeChecker()
   const declarations = topLevelFunctionUnits(sourceFile)
   const staticScan = scanStaticAnnotations(sourceFile, declarations, checker)
   const recordStaticAnnotationIssues = (sites: SourceSpan[]): ProgramIR['staticAnnotationIssues'] =>
@@ -91,7 +92,7 @@ export function lowerSource(checked: CheckedSource, baseDirectory: string = proc
     // A failed function lowering discards the half-built FunctionContext wholesale; only
     // the name, annotation presence, offending node's site, and tagged reason survive.
     try {
-      functions.push(lowerFunction(declaration, staticAnnotations, sourceFile, checker, functionsBySymbol, scan, sites))
+      functions.push(lowerFunction(declaration, staticAnnotations, sourceFile, checker, program, functionsBySymbol, scan, sites))
     } catch (error) {
       if (!(error instanceof LoweringStop)) throw error
       sites.push(nodeSpan(sourceFile, error.node))
@@ -104,7 +105,7 @@ export function lowerSource(checked: CheckedSource, baseDirectory: string = proc
       })
     }
   }
-  const {initializer, skips} = lowerModuleInitializer(sourceFile, checker, functionsBySymbol, scan, sites)
+  const {initializer, skips} = lowerModuleInitializer(sourceFile, checker, program, functionsBySymbol, scan, sites)
   return {
     file: sourceFile.fileName,
     baseDirectory,
@@ -123,6 +124,7 @@ function lowerFunction(
   staticAnnotations: StaticAnnotation[],
   sourceFile: ts.SourceFile,
   checker: ts.TypeChecker,
+  program: ts.Program,
   functionsBySymbol: Map<ts.Symbol, TopLevelFunction>,
   scan: ModuleScan,
   sites: SourceSpan[],
@@ -148,12 +150,6 @@ function lowerFunction(
       kind: unit.initializer == null ? 'functionWithoutSignature' : 'constFunctionSignature',
     })
   }
-  // A type predicate (`shape is Circle`, `asserts x`) is the checker taking the author's
-  // word: callers' narrowing then exposes properties the analysis cannot confirm the
-  // value carries. Rejecting the declaring function stops every caller at the call.
-  if (checker.getTypePredicateOfSignature(signature) != null) {
-    throw unsupported(declaration, {kind: 'typePredicate'})
-  }
   const returnType = checker.getReturnTypeOfSignature(signature)
   // `never` counts as returning nothing: the idiomatic annotation for an always-throwing
   // helper (`function fail(code: number): never`), whose paths all end in throw — the
@@ -167,6 +163,7 @@ function lowerFunction(
   const context = createFunctionContext(
     sourceFile,
     checker,
+    program,
     functionsBySymbol,
     scan.bindingsBySymbol,
     sites,

package/src/lower/statements.ts

@@ -14,7 +14,6 @@ import {
   type MutableBlock,
 } from './context.ts'
 import {taggedUnionTagRead, identifierAssignment, lowerBranchingCondition, lowerExpression, lowerStatementExpression, requireBooleanCondition, valueKind} from './expression.ts'
-import {declaredOnlyInDeclarationFiles} from './platform.ts'
 
 export function lowerStatements(statements: readonly ts.Statement[], context: FunctionContext): void {
   for (const statement of statements) {
@@ -489,15 +488,8 @@ function lowerVariableDeclarationList(declarations: ts.VariableDeclarationList,
             : null
         if (property == null) throw unsupported(element, {kind: 'variableDeclarationShape'})
         const elementType = context.checker.getTypeAtLocation(element.name)
-        const sourceType = context.checker.getTypeAtLocation(declaration.initializer)
-        const propertySymbol = context.checker.getPropertyOfType(sourceType, property)
-        // Optional properties destructure like any other read now that the filling
-        // invariant guarantees the record value carries them as maybe-undefined (the old
-        // gate here predated the optionals milestone). Prototype members stay out via
-        // the same ownership rule property reads use.
-        if (propertySymbol != null && declaredOnlyInDeclarationFiles(propertySymbol)) {
-          throw unsupported(element, {kind: 'prototypeMemberRead', property})
-        }
+        // Optional properties destructure like other reads because the record carries
+        // omitted properties as maybe-undefined values.
         if (valueKind(elementType, context.checker) == null) {
           throw unsupported(element, {kind: 'valueType', typeText: context.checker.typeToString(elementType)})
         }

package/src/project.ts

@@ -461,7 +461,7 @@ function analyzeProjectSource(
 ): DetailedAnalysis {
   return analyzeCheckedSource({
     sourceFile: source.sourceFile,
-    checker: source.project.program.getTypeChecker(),
+    program: source.project.program,
   }, reportBaseDirectory)
 }
 

package/src/report/index.ts

@@ -918,10 +918,8 @@ export function formatUnsupportedReason(reason: UnsupportedReason): string {
     case 'computedPropertyName': return 'computed object property name'
     case 'objectSpread': return 'object spread (list every field explicitly, e.g. {gain: config.gain})'
     case 'asyncOrGeneratorFunction': return 'an async or generator function (the runtime result is a Promise or iterator, not the body\'s return value)'
-    case 'typePredicate': return 'a type predicate (the checker takes the predicate on faith; return a plain boolean and check properties where they are read)'
     case 'protoProperty': return 'a property named __proto__ (prototype-setting syntax at runtime, not a data property)'
     case 'enumMemberRead': return 'an enum member read (replace the enum with plain module consts, e.g. const directionUp = 1)'
-    case 'prototypeMemberRead': return `read of the inherited prototype member ${reason.property} (records carry only their own data properties)`
     case 'binaryOperator': return reason.operator === 'in'
       ? 'the `in` operator (use a distinct string or boolean tag when property presence distinguishes union variants)'
       : `binary operator ${reason.operator} (supported: + - * / %, comparisons, and boolean && || !)`

package/src/typescript/check.ts

@@ -4,7 +4,7 @@ import {TypeScriptDiagnosticsError} from './diagnostics.ts'
 
 export type CheckedSource = {
   sourceFile: ts.SourceFile
-  checker: ts.TypeChecker
+  program: ts.Program
 }
 
 // When no tsconfig is in scope, single-file analysis gets the recommended authoring
@@ -52,5 +52,5 @@ function checkedSource(program: ts.Program, file: string, options: ts.CompilerOp
   }
   const sourceFile = program.getSourceFile(file)
   if (sourceFile == null) throw new Error(`TypeScript did not load ${file}`)
-  return {sourceFile, checker: program.getTypeChecker()}
+  return {sourceFile, program}
 }