* fix(javascript): retain array-pattern iterator close effects
* fix(javascript): bound array-pattern close exposure
* fix(javascript): follow stored array elements at iterator close
* fix(javascript): retain iterator closes before array rest
* fix(javascript): count escapes of Function.prototype before trusting call and apply
* fix(javascript): key cached returned references on ambient escapes too
* fix(javascript): track arguments of directly invoked functions through their parameters (#11538)
* fix(javascript): track arguments of directly invoked functions through their parameters
Passing a value to a function expression invoked where it is defined, such
as a UMD header (function(root, factory){...})(this, ...), recorded an
escape of the argument to unevaluated code although the callee's body is
source code whose effects are indexed. javascriptSemanticDirectInvocations
owns which arguments reach such a callee only through a plain parameter;
the ambient path resolver and member mutation indexing follow that
parameter back to its argument, and neither records an escape for it.
Spread and rest lists, pattern or default parameters, arguments and direct
eval keep the escape, as do unknown callees.
Refs #11499
* fix(javascript): escape values thrown out of a function and scan arguments once
A value thrown out of a function or class body reaches handlers the
throw-to-catch index does not link to it. Arguments of a directly invoked
function used to hide this behind the call escape; they no longer do, and
captured values had the same gap. The binding pass records such throws,
and ambient and member effect indexing escape their values at the throw.
Which functions name 'arguments' is now found in one program walk instead
of one subtree scan per directly invoked function.
* perf(javascript): find shadowed direct-invocation parameters in one pass
* fix(javascript): settle Object and Reflect static call receivers in one owner (#11543)
* fix(javascript): settle Object and Reflect static call receivers in one owner
Ambient write indexing skipped the receiver escape of any resolved Object
or Reflect static call, even when source code had replaced the method,
while member mutation indexing escaped the constructor for every such
call. The second escape (global.Object contents) made each later
Function.prototype.call/apply check uncertain in bundles that call
Object.defineProperty or Object.freeze. Ambient indexing now settles these
receivers once all ambient writes are known: the constructor escapes only
when a write or escape may replace the method before the call, and member
mutation reuses that decision through retainedGlobalCallReceivers.
Refs #11535
* fix(javascript): retain the receiver only for native Object and Reflect statics
A resolved Object member that is not one of the language's own static
methods (for example one Object inherits from Function.prototype, or an
unknown name) may be user code that receives the constructor, so its call
keeps the receiver escape.
* fix(javascript): look up intrinsic and builtin method tables by own key only
NATIVE_STATIC_METHODS and BUILTIN_RECEIVER_METHODS were plain objects, so
an owner such as globalThis.constructor or a module named 'constructor' or
'toString' found an inherited Object.prototype function and analysis threw
a TypeError on '.has'. Both are Maps now.
* fix(javascript): escape values thrown uncaught at the top level (#11556)
A value thrown uncaught at the top level reaches the host's uncaught-exception handlers (process.on('uncaughtException'), window.onerror), which may change it before a timer or callback reads it. The binding pass recorded escaping throws only when the walk reached a function or class body; a throw that reaches the program without a handler now escapes the same way.
* fix(javascript): follow direct-invocation arguments through returned references and function arguments properties
A callable argument of a directly invoked function no longer escapes at the call, but the shared returned-reference owner could not follow the parameter to it, so patch(get()) inside the callee lost the escape of the value get returns. The returned-reference walk now follows the parameter to its argument like the write and escape walkers.
A sloppy function's arguments property (f["arguments"], g.caller.arguments from a function it calls) exposes its activation's arguments. A non-strict callee is no longer tracked through its parameters when the program reads an arguments or caller property by a static key. The strictness reader moves beside javaScriptProgramStrictness so both modules share it.
* refactor(javascript): move the last reader effect reads into the effect log
* refactor(javascript): skip escapes when a reader asks only about member writes
* fix(javascript): order require and process rebinding by activation timing (#11479)
* refactor(javascript): ask one ordering whether require was rebound before a call
* refactor(javascript): order process replacement by activation, like require
* fix(javascript): keep instance field values out of literal-loop source ordering
* fix(javascript): stop effect ordering at instance field values inside the effect
semanticEffectFollowsReference proved that an assignment follows a read
written inside its own right-hand side, even when the read sits in an
instance field value, which runs on construction after the assignment.
process = class { value = process.env.MODE; }; new process() therefore kept
the original process identity, and require = class { fs = require('fs') }
kept a Node module origin. The first walk now stops at instance field
values like it stops at function bodies.
* fix(javascript): attribute process effects that may reach the original object (#11521)
* fix(javascript): attribute process effects that may reach the original object
A write or escape through the global process object was attributed to
node:process only when no replacement of process may precede it. Effects
need the opposite question: they reach the original unless a replacement
with a fresh object is proven to run before them. The effect log gains
ambientReplacementPrecedes (the must counterpart of the may-observe
queries), RequireOrigin owns the effect question, and member mutation
asks it for direct, qualified and ambient process effects.
Refs #11488
* fix(javascript): prove a process replacement with the global path reader
ambientReplacementPrecedes accepted any earlier fresh assignment of the
process path, even when a later write might restore the original or when
the assignment went through a possible alias of the global object. The
global path reader already owns definite replacement at a site (it checks
the written namespace and every competing write), so the effect question
asks it and keeps only the freshness check. ambientReplacementPrecedes is
removed.
* refactor(javascript): ask one owner whether opaque code changed an intrinsic global read
Six intrinsic global readers combined semanticOpaqueGlobalMayHaveChanged and semanticOpaqueNameMayHaveChanged themselves, each choosing which effect kinds applied and where to time them.
isIntrinsicGlobalReference and opaqueCodeMayChangeGlobalRead in javascriptSemanticGlobalReference.ts now own both proofs: a sloppy direct eval visible from the reference may introduce its root name, and global code that may run before the observation site may replace a writable global. The owner also knows that undefined, NaN and Infinity are non-writable, so global code cannot replace them. Map lookups and XMLHttpRequest open calls pass the call as the observation site, keeping their call-time timing. An architecture guard forbids the two helpers outside their owners.
Slice 1 of docs/adr/javascript/pushed-effect-invalidation.md (#11188).
* refactor(javascript): ask one owner whether opaque code rebound a binding (#11254)
Ten binding readers combined semanticBindingCanBeRebound, semanticBindingMayHaveOpaqueEffect and semanticOpaqueBindingReadMayHaveChanged themselves; three repeated the same rebindability-and-effect pairing.
opaqueCodeMayRebindBinding(binding, state, read?) and opaqueCodeMayReachBindingReference(binding, state, capturePoint) in javascriptSemanticOpaqueEffects.ts now own the rebinding, read-timing, capture and introduced-name proofs. semanticBindingMayHaveOpaqueEffect is private to the owner and semanticOpaqueBindingReadMayHaveChanged is removed, so a reader cannot pick effect kinds again.
Slice 2 of docs/adr/javascript/pushed-effect-invalidation.md (#11188).
* refactor(javascript): ask one owner whether an intrinsic instance method changed (#11266)
* refactor(javascript): ask one owner whether an intrinsic instance method changed
Map lookups and XMLHttpRequest.open each walked receiver aliases and combined
member-effect checks for the method, the instance prototype link and the
intrinsic prototypes. isIntrinsicInstanceMethodCall now owns that walk; Map
lookups also gain the prototype-link check XHR already made. The member-effect
view asks semanticOpaqueReferenceEffects for opaque sites instead of combining
the rebinding and reach helpers, which become private.
Refs docs/adr/javascript/pushed-effect-invalidation.md (slice 3).
* refactor(javascript): keep global opaque-effect checks private to their owner
opaqueCodeMayChangeGlobalRead moves into javascriptSemanticOpaqueEffects.ts, so
semanticOpaqueGlobalMayHaveChanged and semanticOpaqueNameMayHaveChanged are no
longer exported and the slice 1 text guard is replaced by the compiler.
* refactor(javascript): make the effect log the one reader of recorded opaque sites (#11282)
* refactor(javascript): make the effect log the one reader of recorded opaque sites
Rename javascriptSemanticOpaqueEffects.ts to javascriptSemanticEffectLog.ts
(ADR decision 1) and move the reference-effects view
(visitSemanticReferenceEffectsAtSite, the effect report, the member-path
query and its completeness gate) out of javascriptSemanticAnalysis.ts into it.
Recorded opaque sites move behind javascriptSemanticEffectRecord.ts accessors
(direct-eval site, recorded direct eval, global-code sites), which the timing
producer in javascriptSemanticMutationInitializers.ts and the call frontier in
javascriptSemanticCalls.ts now ask instead of reading state.opaqueEffects.
The member-mutation completeness WeakSet duplicated
state.memberMutationFactsComplete and is removed.
An architecture guard keeps `.opaqueEffects` reads inside the log and its
record module.
* refactor(javascript): keep the opaque reference-effect generator private to the effect log
* refactor(javascript): drop analysis-hub imports that only the moved effect queries used
* refactor(javascript): ask the effect log for a binding reference's recorded effects (#11295)
The value engine applied member writes, escapes and direct-eval reach to a
binding's reference itself, with its own capture proofs. That application
moves into javascriptSemanticEffectLog.ts as
applySemanticBindingReferenceEffects, and opaqueCodeMayReachBindingReference
becomes private to the log.
A counted guard (javascript-effect-index-read) records every remaining read
of the per-kind effect indexes outside the log; it can only shrink, so new
reader-side checks fail the guard.
* refactor(javascript): ask the effect log whether an ambient path may have changed (#11308)
* refactor(javascript): ask the effect log mayObserve for member-path reads (#11313)
* refactor(javascript): name the member-path effect query mayObserve
* refactor(javascript): ask the effect log whether an ambient path effect may precede a read
* refactor(javascript): ask the effect log about require and process rebinding (#11318)
refactor(javascript): ask the effect log about require and process rebinding and effect generations
* refactor(javascript): build the ambient-write module interop in one owner (#11323)
* refactor(javascript): build the ambient-write module interop in one owner and ask the effect log in CommonJS receivers
* refactor(javascript): ask the effect log whether binding assignments precede a read (#11329)
refactor(javascript): ask the effect log whether binding assignments or prototype writes precede a read
* fix(javascript): count prototype escapes before resolving a URL object request target (#11368)
fix(javascript): count URL and Object prototype escapes before resolving a URL object target
* feat(javascript): make the member-mutation work allowance a runtime setting
The member-mutation alias-state allowance from #11144 was a fixed constant, so a refused source could not be admitted without a code change.
Register javascript.member_mutation_alias_states (default 524288, 1 to 8388608 alias states) with the launch seed REA_JAVASCRIPT_MEMBER_MUTATION_ALIAS_STATES. The application, web bundle and reference-source boundaries resolve it from the accepted operation snapshot and launch environment, refuse a malformed seed before analysis, and send it to the workers with each source. A refusal names the setting, its effective value, source and range, and the recovery; worker parents rebuild it from the allowance they sent.
Refs #8294
* fix(javascript): keep the setting and recovery of a refused web script
A web bundle script refused by the member-mutation allowance kept only its reason and reported limits, so the public unknown lost the setting, value, source and recovery. Carry the refusal's structured limit and remediation on the per-script result and its javascript_analysis unknown, grouping scripts only when that recovery agrees. Assert structured limit facts and the owning formatter's recovery instead of fixed wording.
* fix(browser): keep only registered setting limits on a refused web script
* feat(javascript): keep syntax facts for a source whose member-mutation phase is refused (#11187)
* feat(javascript): keep syntax facts for a source whose member-mutation phase is refused
A source refused by the member-mutation work allowance during static analysis lost every fact, so the application graph counted it as skipped. Reference-source import failed outright on such a file.
Checkpoint the parser, comment and text facts the static owner can still state, with parse status partial, examination not-examined and refused_phase member-mutations, before reporting the refusal; the semantic phase is not started because it indexes the same mutations. Reference-source import keeps the file's declaration-level imports and records that its CommonJS require calls were not examined.
Refs #8294
* test(javascript): compare the reference-source refusal with its owning formatter
* feat(javascript): keep a refused web script's parse and text facts
A captured script whose member-mutation phase was refused lost every fact in analyze_web_bundle, so it was neither counted as parsed nor kept its vendor markers.
The analyzer now returns the script as unavailable with partial facts: refused phase, parse status and the inferences read from script text alone. Findings gathered before the refusal are dropped, because they may have read an incomplete mutation index. The worker parent states the refusal and its setting recovery from the allowance it sent, through the same helper the isolated analyzer uses for every unavailable script. The bundle counts the script as parsed, keeps its text inferences, and its javascript_analysis unknown carries refused_phase.
Refs #8294
* chore(mcp): record the member-mutation setting in the advertised summary
* fix(javascript): rebuild a parked source worker when the member-mutation allowance changes
A worker parked on a resource scope was reused when heap, timeout and precision matched, but its requests carry the allowance it was built with. After update_analysis_settings accepted a new allowance, the next analysis on that scope kept the old one.
The reuse check now compares the allowance's value and source, so a changed setting gets a worker built with it. The web bundle worker already takes the allowance per script.
* fix(javascript): refuse member-mutation work beyond a fixed allowance
Member-mutation indexing retained every scheduled alias state until its query finished, with no bound on the phase. Conditional self-selections before one member write (#8294) multiplied those states until the worker heap was exhausted.
Charge each scheduled alias state to a per-phase work meter. Past 524,288 states the phase is refused with a resource_constraint that names the fixed work allowance. The application and web bundle workers carry the reported limit to the parent, which rebuilds the refusal with that allowance instead of heap advice.
Refs #8294#6127#6344#7170#7510#8298
* test(javascript): prove the member-mutation meter spans the phase
* fix(javascript): expose operands of unmodelled implicit execution
The member-mutation collectors now escape the operands of every execution
kind they did not apply: yielded values, JSX element operands, dynamic
import specifiers and options, decorated classes, with-statement scope
objects, iteration inside accessors and syntax the classification does not
describe. Each of these left a literal where the equivalent explicit call
already yields unknown.
Decorators are classified at the class definition that calls them and are
evaluated as definition-time expressions.
* fix(javascript): expose decorated instance members and keep a decorator's outer this
A class's decorator execution now exposes decorated members' functions and initializers, which a decorator can call without the class running them. The getter receiver walk uses the shared javaScriptDefinitionExpression owner, so class and member decorators see the enclosing this like heritage and computed keys.
* refactor(javascript): classify implicit execution in one owner
Add javascriptSemanticExecutionPoints, a total classification of every
runtime Babel node type into the ways its evaluation can run code without
call syntax. The member-mutation escape walk, the accessor operand
collector and the catch-source reachability check consult it instead of
their own syntax lists. Kinds those collectors have never applied are now
named in exhaustive switches rather than absent.
A guard test fails when the installed @babel/types defines a node type the
table does not classify, and unknown node types classify as unsupported
syntax rather than inert.
* test(hopper): retry cleanup after confirmed application exit
* fix(javascript): classify enumeration and catch binding effects
* fix(javascript): retain catch uncertainty for identifier reads
Static blocks and static field values run when a class is defined, so a
getter that returns a class whose static work writes through an alias of the
getter's receiver changes that receiver. The definition-time walk now visits
static work too; `this` inside it stays the class.
Refs #9229
Co-Authored-By: gensokyo-dev <342580529+gensokyo-dev@users.noreply.github.com>
Defining a computed class or object member converts its key to a property
name, so preserve that coercion escape alongside the key expression walk.
Reuse javaScriptComputedDefinitionKey for computed-key ownership in the
getter result walker instead of repeating the check.
Refs #9229
Co-Authored-By: gensokyo-dev <342580529+gensokyo-dev@users.noreply.github.com>
Computed keys and superclass expressions evaluate against the enclosing
getter receiver. Visit those definition-time expressions when collecting
accessor effects, and walk past class/method boundaries in #ownsThis when
the path arrives from heritage or a computed key so receiver writes are
not dropped.
Fixes#9229
Supersedes #9233
Co-Authored-By: gensokyo-dev <342580529+gensokyo-dev@users.noreply.github.com>
* refactor: prune internal seams and preserve configuration ownership
* fix(setup): keep YAML aliases and inherited registration settings on refresh
- Reuse an unchanged YAML collection only while every alias in it still
resolves after the edit; otherwise rebuild it so the alias becomes its
value. A sibling anchor replaced or moved in the same refresh no longer
leaves an unresolved alias in Hermes or Goose output.
- Keep a connection selector whose existing value already chooses stdio
(for example an inherited Hermes transport: stdio) instead of superseding
it; remote selectors are still replaced. Explicit stdio selectors are
therefore no longer rewritten (Kimi expectation updated).
- When the whole Hermes registration is inherited through a merge,
override it with that merge and write only the changed fields.
* fix(setup): edit registration fields whose YAML key is an alias
A key written as an alias to a string scalar (for example *field with
field: &field env) was treated as a source-only key, so any change to
its value was refused in Hermes and Goose. Resolve such keys to their
string, keep the aliased spelling while its anchor survives the edit,
and write the plain key when the same edit rebuilds the anchor.
* test(process): bound cleanup-boundary waits and always release gates
Both cancellation tests awaited a bare started promise and released
their gates only on success, so a missed boundary waited for the outer
deadline and could leave cleanup parked. Use awaitAcknowledgement and
release and join the cleanup in finally.
* fix(setup): repair only aliases an edit leaves unresolved
Replace the pre-edit alias survival guess, which expanded aliases to
sibling anchors that survive unchanged, with an exact repair: record
what each alias in the replaced value resolves to, write the edit, then
replace only aliases left without a preceding anchor by that value.
- Keep an aliased key's source position, so its anchor stays ahead of
later aliases.
- Treat an aliased key as its string only when no other key in the map
resolves to the same string; an ambiguous one stays guarded.
- Override an inherited Hermes registration only when the requested
entry keeps every inherited field, so an explicit replacement can drop
remote selectors.
* fix(setup): repair aliases whose binding an edit changes, keeping comments
An alias whose own anchor was removed could resolve to an earlier anchor
with the same name and silently change value. Record the node each alias
resolved to and repair any alias that no longer resolves to that node.
Carry the alias's comments and spacing onto the repaired value.
* test(setup): split the Hermes anchor and merge refresh cases
* fix(setup): refuse removing an overridden key its merge would restore
The merge-retention check skipped keys the mapping also overrides, so
dropping such a key (for example a remote url during an explicit stdio
replacement) let the retained merge restore it. Check removal before
skipping overridden keys, so the edit is refused with the existing
message instead of producing a registration that cannot be applied.
* fix(javascript): preserve semantic facts across writes and implicit effects
* fix(javascript): preserve bundler identities and helper bindings
* fix(javascript): retain semantic graph evidence and coverage
* test(javascript): include the request link in endpoint traces
Response consumers now also link the originating request to the response, so an endpoint trace reports both that association and the response's json consumer.
* fix(javascript): keep source accessors known after a copied value escapes
An unknown computed getter makes accessor lookup consider every property.
A spread copy already records a value escape, and that escape was treated
as an unknown getter on the source, so the next read escaped the whole
object. Accessor lookup still fails closed for unknown writes and calls.
* fix(javascript): keep Object.defineProperty identified at its own call
The call that escapes Object was treated as a prior replacement of
defineProperty, so a descriptor value never replaced the exported sender
and bundled IPC paths were dropped.
* fix(javascript): keep Vite preload calls that precede reassignment
Helper identity used every write to the binding, so a later assignment
erased a call that had already read the canonical helper. Use the binding
value at the call when that order is known.
* fix(javascript): apply Vite cache mutations before a later reassignment
A later helper write made the whole-binding initializer check ignore an earlier cache mutation. Identity at that mutation uses the same ordered read as the call.
---------
Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Member-mutation indexing appended a binding write or escape record for
every traversal state that reached it. States that differ only in
coverage fields the record never stores (origin, owner initializer,
getter widening) produced identical records, and each later receiver
query rescanned all of them. Record each stored fact once, alongside the
existing required-module effect deduplication. Propagation is unchanged.
Effect ordering also re-walked the same top-level statement ancestry for
every candidate record. Cache it with the other initializer positions,
and test the selected path before the costlier receiver comparison.
On the #7774 reproducer the semantic IR and the complete
analyze-javascript-application Evidence are byte-identical, while the
CLI run drops from 146 s to 40 s.
Refs #7774
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
A write below a slot that stores a value read from the same slot, such
as `s.c = s.c.p; s.c.i = 1` on a parameter, revisits the binding with
one more segment after the stored key on every turn. The cycle closure
only recognized segments added at the front of the path (`node =
node[key]`), so the work-list never terminated and exhausted the owned
worker heap (CodeMirror 5 `mode/stylus/stylus.js`).
Recognize a contiguous segment inserted after a stable base, check that
repeating it after that base can never be pruned, and escape through it
once, as the self-alias rule already does. Front insertions keep their
existing order and result.
Fixes#7130
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Record erasure during definition indexing and reuse it across runtime references, captures, effects, module links, routes, Electron and Vite. Preserve source type links and emitted decorator and computed-key effects; keep actual runtime reads and escapes conservative.
Validation: 1,647 focused tests and 9 documentation tests passed, with build, static and documentation gates. The inherited reference-lifetimes stress file exhausts a 512 MiB worker on both unmodified 18451e479 and this change; that file remains unverified. TypeScript 7.0.2 emit was inspected for ES2022 and ES2018 without executing emitted code.
Preserve load and resolve operations through semantic facts, worker transfer and graph Evidence. Only loads propagate executable ownership. Project ambient member writes and escapes through the shared path- and site-aware mutation owner; retain source literals, bases and uncertainty. Cover ownership and mutation boundaries through CLI and MCP.
Replace initializer-history and full-path enumeration with a finite projection
join at each source read. Retain conservative local returned-reference effects
and disclose precision loss through static, semantic and captured-web results.
Close full-binding callback cycles while preserving narrowed read semantics.
Fixes#4348Fixes#5138
Refs #4349
Refs #4364
Co-authored-by: Kaoru0822 <208281322+kaoru0822-kitauji@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Fuxuan-CN <3072252442@qq.com>
Resolve unchanged Map operations through shared binding, capture, mutation,
and ambient escape facts. Reuse that proof in application and captured
bundle analysis; unresolved get/delete receivers remain inferred candidates.
Preserve repeated native operations without manufacturing receiver escapes.
Retain uncertainty for real escapes, opaque eval, and changed constructor
adder hooks. Converge stored aliases at the producing boundary.
Adapt the JavaScript changes from #4863, excluding its Linux resource fix.
Add captured-bundle parity, repeated-operation and constructor-hook coverage.
Fixes#4853
Co-authored-by: abdooo2235 <abdalrhmantheiv15@gmail.com>
Model the CommonJS wrapper binding and query shared lexical identity, mutation, and evaluation timing at each call. Remove duplicate importer interpretation and preserve uncertainty for with scopes, prototypes, repeated writes, and opaque object escapes.
Validate generated fixtures against bounded Node oracles; no analyzed target execution is added.
Refs: #3982, #4072
Co-authored-by: Geronimo <varungore1@gmail.com>
Replace recursive getter histories with a query-owned worklist and memo. Bound
precise expansion at 512 states and widen growing receiver cycles; retain
escaped roots and constructed children rather than silently dropping suffixes.
Carry the resource limit through semantic coverage, worker transport and graph
Evidence while preserving direct writes, imports and unrelated literal facts.
The small source probe reduced 65/326 paths to one widened reference for five
and six getters. The original large Claude artifact was not rerun. Validate
receiver/alias/mutation controls and compiled CLI/MCP consumers.
Refs #3839, #3848
Co-authored-by: Yi Han <yhan606@aucklanduni.ac.nz>