Commit Graph
7 Commits
Author SHA1 Message Date
morluto 8ef5a34ff5 fix(javascript): retain array-pattern iterator close effects (#12534)
* 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
2026-11-19 21:57:50 +00:00
morlutoandSII-YDD 83192e9750 fix(javascript): keep array presence snapshots query-owned (#12511)
Reuse the capture-lifetime approach from #7716 for ordinary array-read proof.

Co-authored-by: SII-YDD <38822679+SII-YDD@users.noreply.github.com>
2026-11-19 20:24:36 +00:00
morluto 50913e3ba0 fix(javascript): observe shared array iterator prototype effects (#12493)
* fix(javascript): observe shared array iterator prototype effects

* fix(javascript): follow iterator escapes and projected receivers

* fix(javascript): retain packed prototype reads and receiver captures

* fix(javascript): treat proven prototype inspections as read-only

* fix(javascript): retain ordinary array destructuring read dependencies (#12505)
2026-11-19 20:12:54 +00:00
morluto 9efaaffd75 refactor(javascript): ask the effect log owner whether opaque and reference effects changed a read (#11252)
* 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
2026-11-16 03:10:46 +08:00
ShuaixinHuang a2134b3a74 fix(javascript): resolve module-level Electron options in functions (#8960)
* fix(javascript): resolve module-level Electron options in functions

* fix(javascript): limit module option ancestry walk

* fix(javascript): preserve uncertain captured argument ordering

* fix(javascript): retain hoisted activation uncertainty

* fix(javascript): retain function ownership through loops

* fix(javascript): account for classic global activations

* fix(javascript): bind first activations to lexical identities

* fix(javascript): retain uncertain global activation timing

* fix(javascript): isolate receiver facts and share computed reads

* fix(javascript): retain projected and opaque global activations

* fix(javascript): refresh activation bounds as opaque effects grow

* fix(ci): format website watch directories without changing configuration

* fix(javascript): share source reads across opaque-effect updates

* fix(javascript): retain constructed-code global activation bounds

* fix(javascript): share runtime activation and receiver facts

* fix(javascript): reuse pattern reads and function positions

* fix(javascript): isolate copied paths and preserve runtime reads

* style(javascript): format migrated reference imports

* fix(javascript): normalize constructor activation and receiver effects

* fix(javascript): retain aliased receiver timing and lexical global this

* fix(javascript): preserve effect-free receiver identity across activations

* fix(javascript): retain outer activation and prototype effects

* fix(javascript): index implicit reads without deep path rescans

* fix(javascript): retain aliased prototype and parameter read uncertainty

* fix(javascript): index reflected reads through intrinsic invocation facts

* fix(javascript): retain unresolved global activation reads

* chore: refresh PR branch after review fix publication

* fix(javascript): retain projected receiver reads and cache method facts

* fix(javascript): retain inherited and implicit activation reads

* fix(javascript): retain caller-owned this uncertainty

* fix(javascript): retain reflected reads with unresolved spread arguments

* fix(javascript): preserve enclosing activation for decorators

* fix(javascript): track intrinsic literal prototype effects

* fix(javascript): retain catch activation from implicit reads

* perf(javascript): reuse effective keys for projected reads

* fix(javascript): retain possible caller-owned ambient effects
2026-11-05 16:52:19 +08:00
ShuaixinHuang e9fc8fb30c fix(javascript): preserve runtime path bytes and Electron ownership (#4941)
* fix(javascript): preserve literal percent runtime paths

* fix(javascript): ignore resolve prefixes before the final anchor

* fix(electron): retain application roots for loadFile declarations

* fix(electron): resolve loadFile from enclosing application package

* fix(electron): retain outer application root across package scopes

* fix(electron): derive application ownership from inventoried packages

* fix(electron): retain resolved package entrypoint ownership

* fix(electron): preserve competing application ownership

* fix(electron): retain invalid and omitted runtime ownership

* fix(electron): preserve omitted module ownership and runtime paths

* fix(electron): preserve proven roots before confining page paths

* fix(electron): retain possible owners behind missing imports

* fix(electron): distinguish absent imports and owned page candidates

* fix(electron): keep unavailable JSON out of owner gaps

* fix(electron): retain exact loader formats and default entry status

* fix(electron): retain unavailable entrypoint ownership candidates

* test(ghidra): preserve Windows Node probe prerequisites

* test(ghidra): assert cancellation during profile shutdown

* fix(electron): separate examined imports from frontend ownership

* fix(electron): retain unavailable directory entrypoint owners

* test(jeb): retain Linux ownership prerequisite in isolation

* fix(javascript): retain unchecked loader ownership and literal main paths

* fix(javascript): preserve runtime paths and call-site module aliases

* fix(javascript): bound module alias traversal and preserve projections

* fix(javascript): retain host module and nested artifact path boundaries

* fix(javascript): preserve ESM and archive module loader provenance

* test(javascript): distinguish unmapped containers from missing exports

* fix: retain default module aliases and Electron builtin imports

* fix: preserve host file URL and inward ASAR ownership

* fix: preserve CommonJS file URL classification in CI fixtures

* fix: retain bound module loaders and Windows entrypoint uncertainty

* fix: retain ASAR uncertainty and invalidate changed Electron app roots

* fix(javascript): retain ownership uncertainty across loader boundaries

* fix(javascript): preserve loader sources and bound alias queries

* fix(javascript): retain destructured loader sources

* fix(javascript): preserve loader uncertainty at resolution boundaries

* fix(javascript): preserve callable and package launch ownership

* fix(javascript): preserve captured values across member reads

* test(process): assert tagged filesystem cancellation failures

* fix(javascript): preserve inventory bases and invocation read timing

* fix(javascript): preserve ownership across indirect and unread loads

* test(javascript): order fixture directory creation on Windows

* test(javascript): share ordered filesystem fixture writer

* fix(javascript): unify loader provenance and package validation

* fix(javascript): preserve captured Node require loader values

* fix(javascript): preserve loader invocation authority

* fix(javascript): verify generic loader invocation authority

* fix(javascript): preserve conditional loader method alternatives

* fix(javascript): require proven factories for source association

* fix(javascript): honor replaced Electron app path setters

* fix(javascript): prove path and assignment source ownership

* fix(javascript): retain native delegate eligibility through shared writes

* fix(process): settle stale baseline errors after confirmed absence

* fix(javascript): preserve assignment and path boundary evidence

* fix(javascript): prove source-directory resolve anchors

* fix: preserve application path provenance and portable schemas

* fix(javascript): retain CommonJS exported setter effects

* fix: isolate Linux identity observations and retain native module exports

* fix(javascript): preserve published app and helper provenance

* fix(javascript): normalize typed stores and native path fixtures
2026-10-20 17:25:19 +08:00
To3akaRinandmorluto dea770d5d9 fix(javascript): retain getter receivers through local aliases (#2778)
* fix(javascript): retain getter receivers through local aliases

* fix(javascript): resolve projected private getter receivers

---------

Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
2026-10-13 21:26:13 +08:00