{
    "schemaVersion": 1,
    "lane": "esbuild",
    "priority": 12,
    "upstream": {
        "name": "evanw/esbuild",
        "url": "https://github.com/evanw/esbuild",
        "commit": "6a794dff68e6a43539f6da671e3080efdf11ca70",
        "license": "MIT",
        "architecture": "Go JS/TS/JSX/CSS parser, transformer, printer, linker, bundler, minifier, plugin API, CLI, Node API, browser/WASM runtime, and resolver."
    },
    "benchmarkDenominator": {
        "status": "cloned-static-inventory-plus-make-test-runner-evidence",
        "total": 2567,
        "mapped": 259,
        "source": "Shallow blob-filtered upstream clone in .upstream-cache/esbuild at 6a794dff68e6a43539f6da671e3080efdf11ca70; counted paths with git ls-tree and hydrated only targeted metadata/test files with git show. A separate detached runner worktree in .upstream-cache/esbuild-runner was materialized at the same commit so the dirty/no-checkout inventory cache did not need destructive restoration. With Go, Node, npm, and OpenSSL supplied by nix-shell, upstream `make test` passes locally.",
        "inventory": {
            "repositoryPaths": 349,
            "testRelatedPaths": 63,
            "goTestFiles": 33,
            "goTopLevelTestFunctions": 1391,
            "goHelperInvocationSubcases": 9950,
            "bundlerExpectBundledCases": 1059,
            "bundlerSnapshotFiles": 14,
            "nodeAndBrowserTestScripts": 12,
            "jsApiAsyncCases": 331,
            "pluginAsyncCases": 97,
            "endToEndCliCases": 748,
            "goTestFileBreakdown": {
                "internal/bundler_tests": 15,
                "internal/compat": 1,
                "internal/css_lexer": 1,
                "internal/css_parser": 1,
                "internal/css_printer": 1,
                "internal/fs": 1,
                "internal/helpers": 1,
                "internal/js_ast": 1,
                "internal/js_lexer": 1,
                "internal/js_parser": 4,
                "internal/js_printer": 1,
                "internal/logger": 1,
                "internal/resolver": 1,
                "internal/runtime": 1,
                "pkg/api": 2
            }
        },
        "runnerStatus": {
            "executed": true,
            "summary": "The prior missing Go/Node dependency and checkout-hydration blocker is resolved for the core upstream runner. A detached runner worktree was created from the upstream cache, Nix supplied the missing toolchain, `scripts/npm ci` installed the locked Node test dependencies, and `make test` passes locally.",
            "environment": {
                "go": "go1.24.10 from `nix-shell -p go`",
                "node": "22.20.0 from `nix-shell -p nodejs`",
                "npm": "10.9.3",
                "openssl": "OpenSSL 3.4.3 from `nix-shell -p openssl`",
                "denoAvailable": "deno 2.2.12 from `nix-shell -p deno`; not used by `make test`"
            },
            "commands": [
                {
                    "command": "git worktree add --detach ../esbuild-runner HEAD",
                    "result": "passed; materialized a clean upstream runner worktree at 6a794dff68e6a43539f6da671e3080efdf11ca70 without restoring the dirty inventory cache"
                },
                {
                    "command": "nix-shell -p go nodejs --run 'go version && node -v && npm -v && make test'",
                    "result": "passed the core upstream runner, but end-to-end HTTPS cases were skipped because openssl was absent from PATH"
                },
                {
                    "command": "nix-shell -p go nodejs openssl --run 'go version && node -v && openssl version && make test'",
                    "result": "passed: Go tests and vet plus source-map, end-to-end, JS API, plugin, register, node-unref, and decorator Node test targets all completed successfully"
                },
                {
                    "command": "nix-shell -p deno --run 'deno --version'",
                    "result": "passed; Deno 2.2.12 is available in the Nix store for the later release-extra `make test-all` lane"
                }
            ],
            "releaseExtrasNotRun": "`make test-all` was not executed in this slice. It adds Deno tests, WASM node/browser tests, TypeScript typechecks, and Yarn PnP coverage and would also build the upstream custom Go 1.26.1 compiler plus browser/WASM artifacts. The core upstream `make test` runner now has local pass evidence."
        },
        "mappedSemantics": [
            "Comments are skipped, and unterminated multi-line comments raise a native lexer error corresponding to upstream TestComment coverage.",
            "File-start hashbangs produce a hashbang token corresponding to upstream TestHashbang coverage.",
            "Binary, octal, hexadecimal-with-separators, leading-dot decimal, exponent, and trailing-dot number literals produce numeric tokens with PHP numeric values corresponding to a focused TestNumericLiteral subset.",
            "Malformed base-prefixed numeric literals such as 0b, 0b012, 0o018, and 0xGFEDCBA are rejected.",
            "Token offsets remain byte offsets into the original source.",
            "A WordPress block view script fixture using @wordpress/dom-ready tokenizes natively without Node/npm.",
            "Selected `TestImport` static import forms are analyzed: side-effect imports, named imports with aliases/trailing commas, default+namespace imports, and dynamic import string sources.",
            "Selected export/re-export forms are analyzed: empty/named exports, named re-exports, star-as re-exports, and export default declarations.",
            "Invalid namespace imports without `as` are rejected, matching the upstream `import * from` parse error edge.",
            "WordPress package imports are distinguished from relative asset imports and URL imports without invoking Node/npm.",
            "Selected `TestImportAssertions` static import/export `assert { type: \"json\" }` clauses are preserved as native module metadata.",
            "Selected `TestImportAttributes` static import/export `with { ... }` clauses and direct-string dynamic import options are preserved, including duplicate-key and non-string-value rejection.",
            "A WordPress `block.json` metadata import using `with { type: \"json\" }` is classified as a relative JSON metadata dependency without invoking Node/npm.",
            "Selected `TestES6Syntax`/`TestImportMeta*` semantics are mapped: `import.meta` is tracked as an ESM marker, and `import.meta.url`/`import.meta.path` property reads are preserved as native metadata.",
            "Selected `TestNew`/`TestCall` printer semantics around `new URL(\"path\", import.meta.url)` are mapped as asset references, including `new Worker(new URL(...))` and `import(new URL(...))` contexts.",
            "A bounded analyzer-only no-substitution template literal and CommonJS source slice is mapped: path-like ``import(`./preview.js`)``, `import metadata = require(`./block.json`)`, `require(`./legacy-preview.js`)`, `require.resolve(`./preview-worker.js`)`, and ``new URL(`./preview-worker.js`, import.meta.url)`` forms are normalized into native string-source analyzer records without invoking Node or replaying the broader source-map/metafile/TypeScript pile.",
            "Selected upstream CommonJS import-record semantics are mapped for direct `require(\"...\")` and `require.resolve(\"...\")` string calls, including no-substitution template literals; non-string/dynamic arguments, bad argument counts, `module.require`, and package/node_modules resolution remain future slices.",
            "Selected `TestConditionalRequire` plus parser dead-control-flow require semantics are mapped: conditional `require(...)` ternary string branches emit ordered CommonJS records, non-string branches are ignored, direct `require.resolve(\"...\")` stays mapped while conditional `require.resolve(...)` branches intentionally remain unrecorded to match this upstream commit, and `require`/`require.resolve` calls inside provably dead `if (false)` bodies are omitted.",
            "Selected `TestConditionalImport` plus parser dead-control-flow dynamic import semantics are mapped: conditional `import(...)` ternary string branches emit ordered dynamic import records, non-string branches are ignored, no-substitution template string branches are normalized, and dynamic imports inside provably dead `if (false)` bodies are omitted.",
            "Selected `TestRequireResolve` dead control-flow expression semantics are mapped for analyzer import records: `require(...)`, `require.resolve(...)`, and dynamic `import(...)` calls inside `false &&`, `true ||`, `true ??`, and constant ternary dead branches are omitted while live fallback branches remain recorded.",
            "Selected upstream glob-pattern import semantics are mapped at the analyzer boundary: relative `require(...)` and dynamic `import(...)` string-concatenation/template-substitution expressions such as `require('./src/' + name)`, `require('./src/file-' + name + '.js')`, and `import(`./chunks/${name}.js`)` are converted to esbuild-style glob patterns such as `./src/**/*`, `./src/file-*.js`, and `./chunks/**/*.js` without package resolution.",
            "A bounded native glob fixture-resolution slice maps upstream `ResolveGlob` behavior for relative glob records: PHP scans a source-relative file graph without following directory symlinks, applies esbuild-style `*` versus `**` matching, sorts keys, and returns `commonjs-require-glob`/`dynamic-glob` matches such as WordPress block `view.js`, variation JS, and CSS assets while excluding non-matching editor/SVG/root-view files.",
            "A bounded native package/node_modules resolver slice maps selected `TestPackageJsonMain`, `TestPackageJsonModule`, `TestPackageJsonBrowserString`, `TestPackageJsonBadMain`, neutral main-field, scoped package, package subpath, and self-import semantics: PHP resolves package imports by walking `node_modules`, parsing package names including `@scope/name`, selecting browser/module/main fields by platform, falling back to extension and `index` lookup, and resolving package self imports by package.json `name` without invoking Node/npm.",
            "A bounded native package `exports` map slice maps selected `TestPackageJsonExportsRequireOverImport`, `TestPackageJsonExportsImportOverRequire`, `TestPackageJsonExportsDefaultOverImportAndRequire`, `TestPackageJsonExportsBrowser`, `TestPackageJsonExportsNode`, `TestPackageJsonExportsNeutral`, `TestPackageJsonExportsWildcard`, prefix subpath, exact-missing-extension, and invalid target/path traversal boundaries: PHP resolves root exports, condition objects, subpath keys, wildcard keys, and slash-prefix keys without falling back to `main` or extension probing where upstream treats the export as exact.",
            "A bounded package `exports` array and custom-condition slice is mapped: invalid array entries are skipped before valid browser/default condition targets are selected, and an explicit WordPress condition can select a WordPress-specific package runtime path without invoking Node/npm.",
            "A bounded native package `browser` object-map slice maps selected `TestPackageJsonBrowserWithModuleBrowser`, `TestPackageJsonBrowserMapRelativeDisabled`, `TestPackageJsonBrowserMapModuleToRelative`, `TestPackageJsonBrowserMapModuleToModule`, and subpath remap behavior: browser-platform PHP remaps package root main/module targets, direct package subpaths, and package imports inside a containing package through package-local browser maps, records `browser` as the selected field, and treats false browser-map entries as disabled without affecting node or neutral resolution.",
            "A bounded native Node builtin resolver slice maps esbuild's node-platform builtin externalization boundary plus containing-package browser-map shims: node-platform imports such as `path`, `node:path`, and `fs/promises` become explicit external `PackageResolution` records without probing fixture `node_modules`, while browser-platform package maps can redirect `path`/`node:path` to a local shim or disable `crypto` with `false`.",
            "A bounded node-builtin import-record propagation slice maps resolved package records into native import records: static `import path from \"path\"`, CommonJS `require(\"fs/promises\")`, and dynamic `import(\"node:crypto\")` preserve kind/source while carrying `external=true`, `node-builtin` main-field metadata, package/subpath names, and empty paths for later bundler/metafile surfaces.",
            "A bounded first bundler graph assembly slice maps selected upstream bundler dependency traversal semantics: PHP starts from an entry file, analyzes static/CommonJS/dynamic import records, resolves relative imports with extension/index probing, resolves package and package-import specifiers through the existing native resolver, records node-platform builtins as external graph edges without probing `node_modules`, records missing edges without aborting traversal, avoids revisiting already-seen modules, and does not include plugin callbacks, code splitting, tree shaking, source maps, metafile output, or linker printing.",
            "A bounded loader-aware graph edge slice maps selected esbuild loader-boundary behavior for terminal CSS and JSON imports: resolved `.css` and `.json` dependencies carry `css`/`json` loader metadata, stay in the graph as resolved edges, and are not parsed as JavaScript modules during the native graph walk.",
            "A bounded unsupported-loader diagnostic slice maps the graph boundary for resolved assets with no configured loader: resolved unknown-extension imports are recorded as unsupported graph edges with no loader, remain distinct from missing/external edges, and are not parsed as JavaScript modules during the native graph walk.",
            "A bounded metafile preflight slice maps selected esbuild metafile-style input/import reporting over the existing native graph: PHP emits entry-relative inputs with byte counts, import records with kind/external/loader/missing/unsupported flags, and separate external/missing/unsupported diagnostic buckets without linker output, source maps, output byte accounting, plugins, or code splitting.",
            "A bounded explicit `node:` browser/neutral resolver boundary is mapped: unshimmed `node:path`/`node:fs` specifiers are not resolved through fixture `node_modules` packages on browser or neutral platforms, while node-platform imports still emit external builtin records.",
            "A bounded native tsconfig `baseUrl`/`paths` resolver slice maps selected `TestTsconfigPaths`, `TestTsconfigPathsOverriddenBaseURL`, `TestTsconfigBaseURLExtendsPaths`, and `TestTsconfigPathsExtendsBaseURL` behavior for exact aliases, single-star aliases, target fallback arrays, extension/index probing, relative and package-exported `extends`, inherited `paths`, overridden `baseUrl`, merged multi-extends `paths`, and absolute-looking virtual aliases such as `/virtual/*` against a source-nearest `tsconfig.json` without invoking Node/npm.",
            "A bounded tsconfig package-extends fallback slice is mapped: when package `exports`/`tsconfig` field resolution cannot produce a JSON config, package-root default `tsconfig.json` and package subpath `.json` probing can still load an inherited config under that package boundary.",
            "A bounded `TestTsconfigBaseURL` fallback slice is mapped: when no `paths` entry matches, a bare import can resolve relative to an explicit `baseUrl` with extension/index probing while relative, URL-like, missing, and path-escape cases remain ignored.",
            "Expression-form dynamic imports are accepted without being counted as direct string import records, while malformed `import()` and `import(...a)` calls are rejected.",
            "Selected `TestTSImportEquals` and `TestTSExportEquals` semantics are mapped: `import x = require(\"...\")`, qualified import-equals aliases, and `export =` are classified as TypeScript/CommonJS forms instead of ESM syntax.",
            "Selected `TestTSTypeOnlyImport` forms are mapped: top-level `import type`, mixed `import { value, type Type }`, and malformed combined default type imports are classified without turning erased type dependencies into runtime imports.",
            "Selected `TestTSTypeOnlyExport` forms are mapped: `export type { ... } from`, mixed value/type export clauses, type-only star exports, and invalid local `export type { default }` are distinguished.",
            "Selected `TestTSNamespaceExports` semantics are mapped: namespace declarations, exported namespace members, declared namespace exports, nested namespace names, and namespace-local import-equals aliases are recorded separately from top-level module exports.",
            "Selected `TestTSImport` import pruning semantics are mapped: unused value imports are omitted, live default/named/namespace bindings are retained, and bindings referenced only from dead `if (false)` control flow are downgraded to side-effect-only imports.",
            "Selected `TestTSImportEquals` fixed-point pruning semantics are mapped: `require(...)` import-equals aliases are retained for side effects, unused qualified-reference aliases are removed, and chained qualified aliases are retained when a later live use depends on them.",
            "Selected `TestTSImportEqualsInNamespace` printer semantics are mapped by a native TypeScript namespace lowerer for namespace-local import-equals elision, runtime const aliases, exported namespace assignments, alias reference rewriting, and invalid nested/import-form rejection.",
            "Selected `TestTSNamespace`/`TestTSNamespaceExports` printer semantics are mapped by the native TypeScript namespace lowerer for exported `var`/`let`/`const` namespace property assignments, initialized multi-declarator exports, exported value reference substitution, and namespace parameter renaming when an export shares the namespace name.",
            "Selected `TestTSNamespaceExports` printer semantics are mapped by the native TypeScript namespace lowerer for exported namespace `function` and `class` declarations, including local declaration emission, namespace property assignment, and namespace parameter renaming when the export shares the namespace name.",
            "Selected `TestTSNamespaceExports` nested namespace printer semantics are mapped: nested exported namespaces use a namespace property initializer, non-exported nested namespaces remain local, exported namespace functions are assigned back to the nested namespace object, and namespace-local runtime enums emit nested enum IIFEs.",
            "Selected `TestTSNamespace` dot nested namespace syntax is mapped: `namespace foo.bar { ... }`, `module foo.bar { ... }`, and namespace/module aliases lower to nested namespace IIFEs with `bar = foo.bar || (foo.bar = {})` initialization, and analyzer metadata records `foo` plus exported child namespace `foo.bar` instead of treating `foo.bar` as a flat name.",
            "A bounded `export declare const` namespace reference case is mapped so simple declared namespace variables are omitted from output but later value references are rewritten to namespace properties.",
            "A bounded `TestTSNamespaceExports` declared binding-pattern case is mapped so `export declare let [[L2 = x, { [y]: L3 }]]` records `L2`/`L3` as declared namespace exports and rewrites later value references while leaving initializer/computed-key identifiers alone.",
            "Selected `TestTSNamespaceDestructuring` printer semantics are mapped: exported namespace array/object binding patterns are lowered to namespace-object assignment targets while computed property names and default initializer expressions remain ordinary expressions, and later references to destructured exported bindings are rewritten to namespace properties.",
            "Selected `TestTSNamespace` namespace/value merge semantics are mapped: namespaces with runtime values reject `var`/`let`/`const` collisions, merge with preceding function/class/enum declarations, permit repeated runtime namespace blocks without duplicate `var` declarations, omit namespace declarations before later enum hoists, and reject function declarations that first appear after a runtime namespace.",
            "Selected `TestTSExportEquals` printer semantics are mapped by a native TypeScript module lowerer that lowers top-level `export = value` to `module.exports = value` and appends that assignment after ordinary statements.",
            "Selected top-level `TestTSImportEquals` printer semantics are mapped: `import x = require(\"...\")`, `import x = foo.bar`, and `export import x = ...` lower to runtime `const`/`export const` declarations with malformed import-equals targets rejected.",
            "Selected `TestTSTypes` printer semantics are mapped by the module lowerer for variable, function parameter, arrow return, `as`, and `satisfies` type erasure without shelling out to esbuild.",
            "Selected `TestTSEnum` printer semantics are mapped by the module lowerer for normal and exported runtime enums, including numeric auto-increment, string literal members, `void 0` after non-numeric members, malformed missing separators, split enum block emission, enum member constant aliases, additive member-reference folding, use-before-declaration direct member substitution, and same-file dot/bracket enum member inlining while leaving optional access un-inlined.",
            "Selected same-file `const enum` behavior is mapped for non-exported declarations: the declaration is erased and direct dot/bracket member accesses are substituted with numeric comments.",
            "Selected `TestTSDeclare` ambient declaration semantics are mapped: top-level `declare var`/`let`/`const`/`function`/`class`/`enum`/`namespace`/`module`/`global` declarations are erased, `declare` followed by a line break remains ordinary runtime syntax, and `export as namespace` is erased while malformed dotted or unterminated forms are rejected.",
            "Selected `TestTSDeclare`/`TestTSExperimentalDecorator` ambient class boundaries are mapped: decorator tokens and private identifiers can be lexed, `declare abstract class` and `export declare abstract class` are erased, and decorators/private accessors inside erased ambient class bodies do not block later runtime statements.",
            "Selected `TestTSDeclare` class member semantics are mapped: `declare` fields are erased for plain, public, override, static, static-declare, accessor, and initialized forms while runtime class members are preserved; invalid private identifiers, index signatures, methods, getters, setters, and decorated declare fields are rejected at the native PHP boundary.",
            "Selected `TestTSClass` abstract class semantics are mapped: `abstract` class headers are erased, abstract method signatures are omitted, ordinary class method return types are erased, and ASI-sensitive `abstract` line breaks remain runtime statements.",
            "Selected `TestTSClass` constructor parameter property semantics are mapped: public/protected/private/readonly/override parameter properties are lowered to ordinary parameters, `this.<name> = <name>` assignments, and matching class field declarations, while destructured parameter properties and missing access-modifier names are rejected.",
            "Selected assign-semantics `TestTSClass` constructor parameter property behavior is mapped: `useDefineForClassFields=false` omits the extra class field declarations, simple derived constructors insert parameter-property assignments after a direct `super(...)` call, and multiple or conditional derived `super(...)` paths are wrapped in an upstream-style `__super` helper before assigning parameter properties.",
            "Selected `TestTSSuperCall` assign-semantics field-injection behavior is mapped for one-line derived constructors: native PHP normalizes constructor bodies before injecting `this.*` field assignments after the direct `super(...)` call instead of appending outside the constructor body.",
            "Selected `TestTSSuperCall` logical-assignment helper behavior is mapped for initialized assign-semantics class fields: constructor `y ||= super(...)` calls are wrapped with an upstream-style `__super` helper so field initializers run immediately after `super(...)`, while uninitialized fields preserve the direct logical-assignment `super(...)` call.",
            "Selected `TestTSSuperCall` dead-branch behavior is mapped for constructor parameter properties: a dead `if (false) super(...)` branch is rewritten to dead `__super(...)`, while the live direct `super(...)` call receives the parameter-property assignments without forcing the whole constructor through a helper.",
            "Selected `TestTSSuperCall` comma-expression insertion behavior is mapped for expression, return, and throw statements: native PHP splits a top-level comma chain around one direct `super(...)`, emits pre-super side effects before `super(...)`, injects parameter/property or field assignments immediately after it, and preserves post-super comma-chain side effects without using the `__super` helper.",
            "Selected `TestTSSuperCall` private field assign-semantics behavior is mapped: initialized private class fields keep their `#field;` declaration, move initializer assignments into the constructor after `super(...)`, and stay after the constructor when field assignments require constructor injection.",
            "Selected `TestTSClass` method type-parameter semantics are mapped: class methods erase `<T>` lists for identifier and computed names, optional method markers are erased, parameter and return type annotations are erased, and definite-assignment method markers such as `foo!()` and `foo!<T>()` are rejected.",
            "Selected `TestTSUsing` printer/error semantics are mapped: top-level `using` declarations erase type annotations across single, multi-declarator, comma-continued multiline, and `await using` forms; `using` followed by a line break preserves the upstream ASI split, missing initializers are rejected, and `export using`/`export await using` are rejected at top level and inside namespaces.",
            "Selected `TestUsing` switch-case diagnostics are mapped: direct `using` and `await using` declarations under `case` or `default` clauses are rejected unless block-wrapped, matching the upstream explicit-resource-management parser boundary.",
            "A bounded `TestUsing`/explicit-resource-management helper slice is mapped for block-wrapped switch case bodies: `{ using ... }` and `{ await using ... }` under `case` or `default` clauses lower through native `__using`/`__callDispose` cleanup instead of leaving unsupported resource-management syntax in the output.",
            "A bounded `TestLowerUsing` switch-clause loop slice is mapped: top-level `for (using ... of ...)` and `for (await using ... of ...)` statements inside `case` or `default` clauses lower each iteration through native `__using`/`__callDispose` cleanup.",
            "Selected `TestUsing` explicit resource management optimization/lowering boundaries are mapped: `undefined` initializers print as `void 0`, minify-syntax mode converts all-nullish `using` declarations to `const` or legacy `var`, mixed non-nullish declarations keep `using`, opt-in unsupported-target lowering wraps top-level `using` declarations with native `__using`/`__callDispose` helpers, and a bounded `TestLowerUsing` slice helper-lowers function-body and block-scoped `using`/`await using` declarations inside simple functions and `if`/block bodies with function-local and per-block disposal.",
            "Selected `TestUsing` function-scope printer semantics are mapped: `using` declarations inside function declarations and function expressions erase TypeScript annotations, `await using` is preserved inside async arrow/function bodies, and `await using` in non-async function bodies is rejected at the native PHP boundary.",
            "Selected `TestUsing` for-loop printer/error semantics are mapped: `for (using x: T of y)`, `for await (using x: T of y)`, `for (await using x: T of y)`, and `for await (await using x: T of y)` erase type annotations while preserving the `of` clause, and invalid `for-in`, classic `await using`, and initialized for-of `using` declarations are rejected.",
            "Selected `TestLowerUsing` for-loop helper semantics are mapped: unsupported-target `for`/`for await` loops with `using` or `await using` lower each iteration through a temporary loop value, a per-iteration `__using` stack, `try`/`catch`/`finally`, and awaited `__callDispose` cleanup for async disposables.",
            "A bounded control-flow block-body explicit-resource-management slice is mapped: ordinary `while`, `for`, and `for await` statement bodies containing `using` or `await using` declarations reuse the native block-scope helper cleanup so disposables are released per iteration.",
            "A bounded `TestLowerAsyncGenerator` runtime slice is mapped: selected `async function*` declarations and function expressions lower to ordinary functions returning native `__asyncGenerator`, direct and parenthesized default-export async-generator functions plus non-default parenthesized expression/call-argument forms, nested array elements, later call arguments, and object-property values opt into the same runtime path, class/object async-generator methods can opt into the same runtime path, `yield*` routes through `__yieldStar`, `await` in generator bodies becomes `yield new __await(...)`, `await using` cleanup uses generator-safe `yield new __await(_promise)` disposal, and simple `for await` plus `for await (await using ...)` loops lower through `__forAwait`. The previous preserve-modern-syntax class/object `await using` cleanup remains available when async-generator runtime lowering is not requested.",
            "A bounded `TestLowerUsingHoisting` module-boundary slice is mapped for unsupported-target top-level `using` helper scopes: directive strings, ES import declarations, export-star/export-from declarations, and trailing export clauses stay outside the generated top-level `try`/`catch` cleanup wrapper.",
            "A bounded `TestLowerUsingHoisting` local-export slice is mapped for unsupported-target top-level `using` helper scopes: simple `export const`/`export let`/`export var` declarations become runtime `var` declarations inside the cleanup scope, simple `export class` declarations become class expressions inside that scope, and matching export clauses are emitted after disposal.",
            "A bounded `TestLowerUsingHoisting` class self-reference slice is mapped: exported class/default class declarations that are hoisted into cleanup-scope class expressions drop unused class names but preserve used class self-references through an upstream-style private `_Name` class binding.",
            "A bounded `TestLowerUsingHoisting` destructured local-export slice is mapped: direct `export var`/`export let`/`export const` object and array binding patterns, including nested bindings, computed properties, default initializers, and rest bindings, are lowered to cleanup-scope `var` declarations with export clauses emitted after disposal.",
            "A bounded `TestLowerUsingHoisting` function-hoist slice is mapped for unsupported-target top-level `using` helper scopes: plain function declarations, direct `export function` declarations, and `export default function` declarations remain outside the generated cleanup `try` block while top-level `using` declarations still lower to helper-wrapped `var` bindings.",
            "A bounded `TestLowerUsingHoisting` default-export slice is mapped for unsupported-target top-level `using` helper scopes: `export default class` and `export default <expr>` are rewritten to cleanup-scope variables and post-disposal default export clauses instead of trapping `export` syntax inside the generated `try` block.",
            "A bounded helper-symbol collision slice is mapped for explicit resource management lowering: generated `__knownSymbol`, `__typeError`, `__using`, and `__callDispose` runtime helper names are renamed when source identifiers already use those names, and helper call sites use the renamed symbols.",
            "A bounded for-loop helper-symbol collision slice is mapped for explicit resource management lowering: `for (using ... of ...)` and `for (await using ... of ...)` acquisition call sites use the renamed generated helper symbol instead of hardcoding `__using` when source identifiers collide.",
            "A bounded `TestLowerUsingHoisting` local-class slice is mapped: ordinary top-level class declarations inside explicit-resource-management helper scopes are rewritten to cleanup-scope `var Name = class ...` assignments, with `_Name` self-reference bindings when class bodies refer to their own name.",
            "A bounded `TestLowerUsingInsideTSNamespace` slice is mapped: namespace-local `using` declarations erase TypeScript type annotations, wrap namespace IIFE bodies in `try`/`catch`/`finally` cleanup with native `__using`/`__callDispose` helpers, preserve exported namespace property assignments around the cleanup scope, and reject unsupported namespace `await using` at this boundary.",
            "A bounded namespace helper-symbol collision slice is mapped: generated explicit-resource-management helper names are renamed when namespace input already binds `__knownSymbol`, `__typeError`, `__using`, or `__callDispose`, and namespace-local `using` call sites plus disposal finally blocks use the renamed helper names.",
            "A bounded namespace function explicit-resource-management helper slice is mapped: `using` declarations inside namespace function bodies and `await using` declarations inside async namespace function bodies erase TypeScript resource annotations, lower through function-local `_stack`/`try`/`catch`/`finally` cleanup with native `__using`/`__callDispose` helpers, await async disposal promises, and still rewrite exported namespace values to namespace properties; top-level namespace `await using` and `await using` inside non-async namespace functions are rejected.",
            "Selected `TestTSAutoAccessors` printer semantics are mapped: plain `accessor`, identifier, static identifier, computed, private, and initialized accessor members normalize through the class printer; optional and definite markers plus type annotations are erased for identifier, computed, and private auto-accessor names; `readonly accessor` preserves runtime accessor syntax; malformed `accessor x<T>`/`accessor x<T>()` forms are rejected; and auto-accessor members in type literals are erased from variable declarations.",
            "Selected `TestTSDecorators` plus `TestTSAutoAccessors` printer semantics are mapped for decorated class members: decorator expression boundaries now stop before decorated class members, while decorated auto-accessor members such as `@x accessor y: any`, `@x static accessor y?: any`, and `@x accessor #y: any` preserve the decorator and accessor runtime syntax with TypeScript-only annotations erased.",
            "Selected `TestTSDecorators` decorator type-argument erasure is mapped for class member decorators: `@x<{}> y: any`, `@x<{}>() y: any`, chained decorators, and dotted decorator expressions erase TypeScript-only decorator type arguments while preserving runtime decorator calls and member spacing.",
            "Selected `TestTSDecorators` malformed decorator-call chain diagnostics are mapped: `@x<{}>().y<[], () => {}>() z: any` is rejected because JavaScript decorator syntax does not allow a property access after a decorator call expression.",
            "Selected `TestTSDecorators` class-statement decorator placement and target interaction semantics are mapped: decorated class statements remain class statements when TypeScript class lowering is needed, `export @x class Foo` normalizes to `@x export class Foo`, TypeScript-only class decorator type arguments are erased, double decorator placement such as `@x export @y class Foo` is rejected, and ES2021 after-class public static assignments stay after the decorated class instead of forcing an invalid decorated class expression.",
            "A bounded unsupported-target `TestTSDecorators` class-decorator slice is mapped behind an opt-in native helper-lowering path: `@dec class Foo {}`, exported class statements, and anonymous `export default @dec class {}` emit decorator arrays, `__decoratorStart`, `__decorateElement`, and `__runInitializers` calls, type arguments inside class decorators are erased, anonymous default classes get a generated binding with an empty decorator context name, and generated `_init` helper names avoid source collisions.",
            "A bounded unsupported-target `TestTSDecorators` instance-method decorator slice is mapped behind the same opt-in helper path: simple named instance methods such as `class Foo { @dec x(): any {} }` erase TypeScript return annotations, insert or reuse an instance initializer constructor, emit method decorator arrays, call `__decorateElement(..., 1, \"x\", ...)`, emit `__decoratorMetadata`, preserve `_init` collision avoidance, and compose with the bounded mixed class/member decorator slice.",
            "A bounded unsupported-target `TestTSDecorators` static method decorator slice is mapped behind the opt-in helper path: simple named static methods such as `class Foo { @dec static x(): any {} }` erase TypeScript return annotations, keep existing constructors untouched, emit method decorator arrays, call `__decorateElement(..., 9, \"x\", ...)`, emit `__decoratorMetadata`, run static initializers with `__runInitializers(_init, 3, Foo)`, and preserve `_init` collision avoidance.",
            "A bounded unsupported-target `TestTSDecorators` public field decorator slice is mapped behind the opt-in helper path: simple public fields such as `class Foo { @dec x: any = y }` and `class Foo { @dec static x: any = y }` erase TypeScript field annotations, emit field decorator arrays, call `__decorateElement(..., 5|13, \"x\", ...)`, emit `__decoratorMetadata`, and initialize instance/static fields through `__publicField` plus `__runInitializers(_init, 8|11, ...)` in the upstream order.",
            "A bounded unsupported-target `TestTSDecorators` private field decorator slice is mapped behind the opt-in helper path: simple private fields such as `class Foo { @dec #x: any = y }` and `class Foo { @dec static #x: any = y }` erase TypeScript field annotations, allocate WeakMap storage, call `__decorateElement(..., 21|29, \"#x\", decorators, storage)`, emit `__decoratorMetadata`, and initialize instance/static private storage through `__privateAdd` plus `__runInitializers(_init, 8|11, ...)` in the upstream order.",
            "A bounded unsupported-target `TestTSDecorators` private auto-accessor decorator slice is mapped behind the opt-in helper path: simple instance/static forms such as `class Foo { @dec accessor #x: any = y }` allocate private WeakMap storage plus a WeakSet private brand, call `__decorateElement(..., 20|28, \"#x\", decorators, brand, storage)`, capture generated get/set functions from the decorator result, and initialize instance/static brand plus storage in upstream order.",
            "A bounded unsupported-target `TestTSDecorators` auto-accessor decorator slice is mapped behind the opt-in helper path: simple public accessors such as `class Foo { @dec accessor x: any = y }` and `class Foo { @dec static accessor x: any = y }` erase TypeScript accessor annotations, allocate collision-safe WeakMap storage, call `__decorateElement(..., 4|12, \"x\", ..., storage)`, emit `__decoratorMetadata`, and initialize instance/static accessors through `__privateAdd` plus `__runInitializers(_init, 8|11, ...)` in the upstream order.",
            "A bounded unsupported-target `TestTSDecorators` computed public field/accessor decorator slice is mapped behind the opt-in helper path: simple computed members such as `class Foo { @dec [x]: any = y }`, `class Foo { @dec static [x]: any = y }`, and `class Foo { @dec accessor [x]: any = y }` cache the computed key in a generated temp, initialize the decorator array during key evaluation, pass that temp to `__decorateElement`, and initialize field/accessor storage through `__publicField` or `__privateAdd` plus `__runInitializers` in upstream order.",
            "A bounded unsupported-target `TestTSDecorators` computed public method decorator slice is mapped behind the opt-in helper path: simple instance and static computed methods such as `class Foo { @dec [x](): any {} }` and `class Foo { @dec static [x](): any {} }` emit the decorator array assignment inside the computed method key, pass the generated key temp to `__decorateElement(..., 1|9, key, ...)`, insert instance initializers when needed, run static initializers for static methods, and capture derived class bases before `__decoratorStart(base)`.",
            "A bounded unsupported-target `TestTSDecorators` public getter/setter decorator slice is mapped behind the opt-in helper path: simple instance/static and computed `get`/`set` members erase TypeScript return/parameter types, emit `__decorateElement(..., 2|3|10|11, key, ...)`, initialize computed decorator arrays inside the computed key, run only one instance extra-initializer constructor call for paired accessors, run static initializers for static accessors, and preserve derived class base metadata.",
            "A bounded unsupported-target `TestTSDecorators` private getter/setter decorator slice is mapped behind the opt-in helper path: simple instance/static private `get #x` and `set #x(value)` members erase TypeScript return/parameter types, move accessor bodies into generated functions, allocate WeakSet private brands, call `__decorateElement(..., 18|19|26|27, \"#x\", decorators, brand, fn)`, assign decorated results back to those functions, and initialize instance/static brands plus extra initializers in upstream order.",
            "A bounded unsupported-target `TestTSDecorators` existing-constructor decorator initializer slice is mapped: simple non-derived instance method, public field, and public auto-accessor decorators inject their helper initializers into existing constructors, ordinary user constructor body statements run after the decorator initializers, and generated TypeScript constructor-parameter-property assignments remain before method decorator initializers.",
            "A bounded unsupported-target `TestTSDecorators` derived member decorator slice is mapped: simple derived class method, public field, and public auto-accessor member decorators capture the base class in the `extends` expression, initialize decorator arrays there, call `__decoratorStart(base)`, insert synthetic derived constructors when needed, and inject instance decorator initializers immediately after direct `super(...)` calls or through the existing `__super` helper for conditional/multiple `super(...)` paths.",
            "A bounded unsupported-target `TestTSDecorators` mixed class/member decorator slice is mapped behind the opt-in helper path: simple named, exported named, and anonymous default-exported classes share one decorator init sequence for class and member decorators, member `__decorateElement` calls run before the class decorator, static member initializers run after class decoration, derived classes preserve base metadata with `__decoratorStart(base)`, anonymous defaults get a generated class binding with an empty decorator context name, and explicit member `__decoratorMetadata` is omitted because the class decorator call records metadata.",
            "Selected `TestTSDecorators` parser diagnostic boundaries are mapped: parameter decorators, decorators before non-class declarations such as `enum`/`namespace`/`function`, computed decorator property access, optional-chain decorator expressions, and `new`-started decorator expressions are rejected at the native PHP boundary.",
            "Selected `TestTSClass` assign-semantics class-field behavior is mapped behind the native `useDefineForClassFields=false` option: uninitialized public typed fields and index signatures are erased, initialized optional/definite/string/computed fields move into constructor `this.*` assignments, and bounded static typed field initializers lower to static blocks.",
            "Selected `TestTSClass` computed class field key behavior is mapped behind `useDefineForClassFields=false`: public computed instance/static field keys are evaluated once into class-scope temporaries before constructor/static assignment emission, and uninitialized computed fields preserve their key side effects even when the field declaration is erased.",
            "Selected `TestTSSuperCall` computed class field ordering is mapped behind `useDefineForClassFields=false`: derived class `extends` expressions are cached before computed field keys so base-class lookup side effects run before field-key side effects while constructor assignments still run after `super(...)`.",
            "A bounded `TestTSClassSideEffectOrder` assign-semantics slice is mapped for computed methods interleaved with erased/initialized computed fields: erased field key effects fold into the next computed method key, initialized computed field keys are cached before constructor/static assignments use them, trailing erased field key effects fold back into the previous computed method key while preserving that method name, static assignment blocks stay before later class members for modern targets, and ES2021 target output emits static field assignments after named classes.",
            "A bounded default-export static-field slice is mapped for ES2021 assign-semantics output: named `export default class Foo` declarations are rewritten to a local class plus trailing `export { Foo as default }`, anonymous default classes receive a generated local default binding, computed static field keys are cached before the class, and colliding generated default names are avoided.",
            "A bounded class-expression static-field slice is mapped for ES2021 assign-semantics output: class expressions in variable initializers and call arguments wrap after-class static public field assignments in upstream-style comma expressions, preserve computed key caching, and keep derived-class base lookup before computed field-key side effects.",
            "Selected `TestTSDecorators` class-expression decorator semantics are mapped: decorators before class expressions stay attached when TypeScript member lowering or ES2021 after-class static assignment lowering is needed, class-expression statements regain semicolons, decorator type arguments are erased, and static public field assignments wrap around the decorated class expression instead of producing invalid `@decorator (...)` output.",
            "A bounded `TestTSPrivateIdentifiers` static-private-field slice is mapped for assign-semantics classes: initialized `static #field` declarations keep the initializer inside the class while public static fields can still move to after-class assignments for ES2021 static-block-free output, avoiding invalid `Class.#field = ...` emission.",
            "A bounded `TestTSPrivateIdentifiers` private accessor/method slice is mapped: TypeScript return and parameter annotations are erased from private getters, setters, static private accessors, computed accessors, and private methods while preserving required `get #x`/`set [x]` spacing.",
            "Selected `TestTSSuperCall` control-statement insertion semantics are mapped: top-level `if`/`switch` tests and `for` initializers split one direct derived-constructor `super(...)` call so pre-super side effects run before base initialization, parameter-property and assign-semantics field assignments run immediately after `super(...)`, and the resumed control statement keeps post-super order without using the `__super` helper.",
            "A WordPress TypeScript block fixture separates runtime `@wordpress/dom-ready`, `./block.json`, and legacy `wp.blocks` dependencies from erased `@wordpress/blocks`/`@wordpress/element` type imports after TypeScript import pruning, while recording namespace-backed block registration metadata. WordPress lowering scenarios now map `export import blocks = wp.blocks` to a namespace property assignment, exported namespace block settings to namespace property assignments with later reference rewrites, exported namespace registration functions/classes to local declarations plus namespace assignments, nested exported namespace settings with a runtime `DisplayMode` enum to nested namespace/enum IIFEs, dot-qualified `PortLibs.CardBlock` namespace block registration to a nested namespace initializer, destructured block settings inside a namespace to namespace property assignment targets, a function/namespace merged `registerBlock.settings` runtime to an IIFE without a duplicate `var registerBlock`, a CommonJS-style `export = registerBlock` block runtime to `module.exports = registerBlock`, typed block edit callbacks plus `satisfies BlockConfiguration` annotations to plain runtime JavaScript, a runtime `DisplayMode` enum used in block configuration, a runtime enum alias block config with member-reference folding, a non-exported `const enum` display-mode config that erases the enum while preserving block registration runtime code, ambient `@wordpress/blocks`/global `wp` declarations plus `export as namespace wp`, decorated exported ambient block controller declarations with private accessors erased before runtime block registration, declared class-field block-controller metadata erased before runtime registration, constructor-parameter-property block controllers lowered to runtime assignments after `super()`, assign-semantics constructor controllers lowered without duplicate field declarations, class-field assign-semantics block controllers lowered to constructor/static assignments, computed-super block controllers cache base-controller lookup before computed settings-key evaluation, conditional-super and lazy-super block controllers lowered through an upstream-style `__super` helper, comma-super and return-super block controllers split around a direct `super(metadata)` call, private-settings block controllers preserve `#settings` while moving initialization after `super(metadata)`, a typed-decorator auto-accessor block controller erases `BlockConfiguration` type metadata and `@trackAccessor<BlockConfiguration>()` type arguments while preserving runtime `@trackAccessor()` settings and worker asset accessors, a multiline `using` disposable asset fixture erases typed asset handles before block registration without invoking Node, a destructured top-level `using` fixture keeps exported block metadata/settings names outside the cleanup scope while it closes over a helper-lowered preview asset, an exported-function top-level `using` fixture keeps a WordPress block registration function outside the cleanup scope while it closes over a helper-lowered preview asset, a function-scoped `using` disposable asset fixture erases typed preview handles inside an exported block-registration helper and helper-lowers the function body through native `__using`/`__callDispose`, a block-scoped disposable preview-asset fixture lowers conditional cleanup through native `__using`/`__callDispose` helpers, a namespace-scoped disposable preview asset fixture lowers a WordPress block namespace IIFE through native `__using`/`__callDispose` helpers while rewriting exported settings and preview references to namespace properties, and a namespace-backed async preview registration fixture helper-lowers `await using` inside an exported async namespace function with awaited disposal before assigning the helper back to the namespace.",
            "A bounded same-statement `TestLowerAsyncGenerator` slice is mapped: multiple supported `async function*` expressions in one array, call-argument, or object-literal statement are all lowered through native `__asyncGenerator` helpers instead of only the first expression being transformed.",
            "A bounded `TestLowerAsyncGenerator` await operand slice is mapped: awaited calls with nested comma arguments, parenthesized comma expressions, and `yield await` operands are rewritten to native `yield new __await(...)` without truncating the operand at inner commas.",
            "A bounded `TestAwait`/`TestLowerAsyncGenerator` await precedence slice is mapped: unsupported-target async-generator lowering now stops awaited operands before top-level binary, logical, conditional, `in`, and `instanceof` operators while preserving grouped and unary awaited operands.",
            "A bounded optional-chain/nullish await precedence slice is mapped: optional calls/properties such as `await queue.resolve?.(...)` and `await queue.assets?.[name]` remain inside `__await(...)`, while top-level `??` and `||` fallbacks remain outside the awaited operand.",
            "A bounded async-generator helper-hygiene slice is mapped: top-level `async function*` declarations after prior statements are still lowered, and generated `__knownSymbol`, `__typeError`, `__await`, `__asyncGenerator`, `__yieldStar`, and `__forAwait` helper names are renamed when source identifiers already bind them.",
            "A bounded linker-adjacent output slice maps already-resolved JavaScript graph modules into a deterministic entry-first output preview with per-input/output byte accounting, removes static import declarations whose JavaScript target is already present in the graph, rewrites retained terminal CSS/JSON static import specifiers relative to the output file, and preserves/accounts for node-platform external imports such as `path` and `node:crypto` while leaving broader linker path rewriting, tree shaking, source maps, plugins, CSS/JSON bundling, output format semantics, external chunk generation, and code splitting out of scope.",
            "A focused current-base rework regression maps the static import elision conflict boundary: multiple static JavaScript imports to an already-included graph module are removed using resolved graph edges while terminal CSS/JSON imports in the same entry remain retained and rewritten relative to a nested output path.",
            "A bounded output-format preview slice maps named ESM re-export clauses for already-bundled JavaScript modules: graph traversal follows runtime re-export sources, and output preview rewrites `export { preview } from \"./local-preview.js\"` or package re-exports to source-less export clauses while retaining terminal CSS/JSON imports and leaving star re-export/linker symbol semantics out of scope."
        ],
        "inventoryPath": "lanes/esbuild/notes/upstream-inventory.md",
        "warning": "The core upstream esbuild `make test` runner now passes locally against the upstream Go/Node implementation at this checkout. Native PHP progress still maps 259 focused lane tests against the 2,567-entry upstream test inventory; this is not full native PHP parity yet. Release-extra `make test-all` coverage remains separate.",
        "totalDescription": "2,567 counted upstream test entry points: 1,391 Go func Test* functions, 331 JS API async cases, 97 plugin async cases, and 748 end-to-end CLI cases"
    },
    "nativeImplementation": {
        "language": "PHP",
        "shellOutsAllowedForProgress": false,
        "currentSlice": "Native JavaScript lexer plus module analyzer for static imports, expression/direct-string dynamic imports, exports, re-exports, import assertions/attributes, import.meta ESM markers, new URL(import.meta.url) asset references, TypeScript import-equals/export-equals/type-only import/export forms, TypeScript namespace/export namespace metadata including dot-qualified namespace chains and declared binding-pattern exports, `export as namespace` type-only metadata, TypeScript import pruning metadata, package/relative source classification, WordPress package imports, WordPress block metadata JSON imports, a narrow TypeScript namespace import-equals plus exported variable/function/class/nested-namespace/namespace-enum/dot-qualified namespace lowerer, simple declared namespace variable and declared binding-pattern reference rewriting, namespace destructuring export assignment targets, namespace/value merge declaration rules, namespace-scoped `using` helper cleanup with generated helper-symbol collision avoidance, namespace function-scoped `using`/`await using` helper cleanup and non-async diagnostics, and a narrow top-level TypeScript module lowerer for `import =`, `export import =`, `export =`, selected type annotation/cast erasure forms, selected explicit resource management `using` declaration erasure/rejection including multiline `using`/`await using`, ASI, missing-initializer boundaries, switch-case direct `using`/`await using` diagnostics, block-wrapped case helper lowering, and switch-clause `for using` helper lowering, nullish-initializer minify optimization, opt-in top-level helper lowering through native `__using`/`__callDispose`, bounded function-body and block-scoped helper lowering for simple functions and `if`/`while`/ordinary `for`/`for await` block bodies, bounded class and object-literal async-generator method `await using` erasure/helper cleanup plus opt-in unsupported-target async-generator runtime lowering for function declarations/expressions, direct and parenthesized default-export functions, parenthesized non-default expression/call-argument forms, nested array-element, later call-argument, and object-property value forms, repeated same-statement async-generator expressions, bounded await operand scanning for calls with nested comma arguments, parenthesized comma expressions, optional-chain/nullish fallbacks, and top-level binary/logical/conditional precedence boundaries, class/object methods, `yield*`, `await`, simple `for await` loops, top-level async-generator declarations after prior statements, and generated async-helper collision avoidance, per-iteration helper lowering for simple `for`/`for await` `using` loops with helper-symbol collision avoidance, bounded top-level helper hoisting for directive/import/export module statements, simple and destructured local `export const`/`export let`/`export var` declarations, simple `export class` declarations with class self-reference rewriting, ordinary local class declaration hoisting with class self-reference rewriting, top-level plain/exported/default function declarations, default class/expression export hoisting with class self-reference rewriting, helper-symbol collision avoidance for the explicit-resource-management runtime, function-scope `using` annotation erasure with async-boundary validation, and for/for-await `using` header type erasure plus invalid for-in/initializer rejection, selected runtime enum declarations, split enum block emission, enum member constant folding, same-file enum member access substitution, non-exported const enum erasure, selected ambient declaration/export-as-namespace erasure, decorated/exported/abstract ambient class erasure with private/accessor tokens, selected decorated class-member and class-statement decorator boundaries, decorator type-argument erasure, invalid decorator-call chain and decorator-boundary diagnostics, opt-in class-decorator plus instance/static method, public/private identifier field, private identifier auto-accessor, public identifier/computed field, public identifier/computed method, public getter/setter and computed getter/setter, private getter/setter, public identifier/computed auto-accessor, named/default-exported mixed class/member decorator helper lowering, existing non-derived constructor decorator-initializer insertion, and bounded derived member decorator base-capture/super-ordering with `__decoratorStart`/`__decorateElement`/`__runInitializers`/`__decoratorMetadata`/`__publicField`/`__privateAdd`/WeakMap/WeakSet storage, ES2021 decorated class-statement after-class static assignment preservation, decorated class-expression preservation through ES2021 after-class static assignment lowering, selected class member `declare` field erasure plus invalid private/index/method/decorated field boundaries, selected `TestTSClass` abstract class/member erasure, constructor parameter property lowering, assign-semantics constructor parameter property field omission, simple/multiple/conditional derived `super()` helper ordering, one-line derived constructor field-injection normalization, logical-assignment derived `super()` helper wrapping, dead `if (false) super(...)` branch handling, top-level expression/return/throw comma-expression plus `if`/`switch` test and `for` initializer derived `super()` splitting before assignment injection, initialized private class-field assign-semantics lowering, static private class-field initializers retained inside assign-semantics classes, private method/getter/setter type annotation erasure with correct private-name spacing, selected class method type-parameter erasure and definite-assignment method rejection, bounded opt-in class-field assign-semantics lowering, computed public class field key temp caching for the assign-semantics mode, derived-class computed field key ordering through the `extends` expression, a bounded computed method/field side-effect-order slice from `TestTSClassSideEffectOrder` including ES2021 after-class public static field assignments for named/default-exported classes and class expressions, and selected `TestTSAutoAccessors` plain/decorated accessor normalization, marker/type erasure, decorator type-argument erasure, invalid decorator-call chain/boundary diagnostics, and malformed accessor rejection. Current reduced analyzer/resolver handoff adds no-substitution template literal path sources, direct CommonJS `require`/`require.resolve` records, ordered conditional `require(...)` and dynamic `import(...)` string branch records, dead `if (false)` and dead logical/constant-conditional require/import omission, relative glob `require(...)`/dynamic `import(...)` pattern records, bounded native glob fixture expansion/matching, bounded package/node_modules package root/subpath/default main-field resolution, bounded package `exports` root/subpath/condition/pattern/array fallback resolution including custom WordPress condition selection, package `imports` maps, bounded package-local browser object root/subpath/disabled remapping, bounded containing-package browser object package remapping, explicit node-platform Node builtin external records with browser-map shim behavior, unshimmed `node:` browser/neutral builtin exclusion, first bundler graph assembly over relative/package import records, loader-aware terminal CSS/JSON graph edges, unsupported-loader graph diagnostics, a bounded graph-metafile diagnostic summary, and a bounded JS output-byte preview over already-resolved graph modules with static bundled-JS import elision, output-byte propagation into the metafile outputs surface, bounded terminal CSS/JSON import-path rewriting relative to output paths, and named ESM re-export clause rewriting for already-bundled JavaScript modules, without including Yarn PnP, plugin callbacks, source-map, data-URL, code splitting, broader import-path rewriting, tree shaking, full linker printing, CSS/JSON bundling, or broad TypeScript work.",
        "phpBehaviorTests": 259
    },
    "wordpressScenario": "Node-free asset tooling for shared hosting, Playground, PHAR tools, and browser-backed PHP environments; current fixtures preflight a WordPress block view script importing @wordpress/dom-ready, block metadata via `./block.json` with `{ type: \"json\" }`, relative stylesheet/worker assets via `new URL(..., import.meta.url)`, and TypeScript block scripts that keep erased @wordpress type imports out of pruned runtime dependency lists while preserving runtime `@wordpress/dom-ready`, `./block.json`, and legacy `wp.blocks` import-equals dependencies. The namespace lowerer maps WordPress namespace-backed block registrations, disposable preview cleanup, and async preview registration into native namespace property assignments/IIFEs with helper-backed disposal without Node. The module lowerer maps WordPress CommonJS exports, typed callbacks, enum configs, ambient declaration erasure, constructor-property controllers, assign-semantics class fields, decorated controller diagnostics, opt-in legacy decorator helper lowering for named/default-exported block controllers plus instance/static method-decorated, constructor-backed method-decorated, static field-decorated, private-field-decorated, private-getter-decorated, accessor-decorated, computed-field-decorated, computed-method-decorated, computed-getter/setter-decorated, mixed class-plus-method-decorated block registration classes, and anonymous default-exported mixed decorator block registration classes, explicit-resource-management asset cleanup, switch-case asset cleanup, for-using asset loops, async-generator preview asset streams, auto-accessor block controllers, and namespace-scoped disposable previews. The top-level, imported/exported, function/block/switch/loop, async-generator, class/object async-generator, and namespace disposable asset fixtures have opt-in native helper-lowering paths with collision-safe helper names. This reduced analyzer slice also preflights WordPress preview chunk and worker asset references written as no-substitution template literals, block metadata loaded through `import metadata = require(`./block.json`)`, conditional legacy preview chunks loaded through `require(metadata.viewScript ? `./legacy-preview.js` : `./legacy-editor.js`)`, conditional dynamic preview chunks loaded through `import(metadata.viewScript ? `./view-preview.js` : `./editor-preview.js`)`, relative glob assets such as `require(`./blocks/${metadata.name}/view.js`)`, `import('./variations/' + metadata.variation + '.js')`, and `require('./styles/' + metadata.style + '.css')`, a direct resolved worker path through `require.resolve(`./preview-worker.js`)`, and dead debug preview require/import calls skipped from `if (false)`, `false &&`, `true ||`, `true ??`, and constant ternary branches while live preview fallbacks remain in the dependency list. The bounded glob fixture resolver now expands those relative glob records against a WordPress asset graph and reports matched block view scripts, variation chunks, and CSS files without invoking Node. The package fixture resolver now preflights `@wordpress/interactivity`, a block runtime package, package subpath helpers, package self-imports, bad-main/index fallback, package `exports` root/subpath/condition/pattern/array maps with browser and node main-field order, custom WordPress condition selection, containing-package browser-map shims/disabled entries for Node builtins such as `path`, `node:path`, and `crypto`, explicit node-platform external records for `path`, `node:path`, and `fs/promises`, and unshimmed browser/neutral `node:` builtin exclusion without invoking npm. The tsconfig fixture now also resolves a WordPress block view import through bare `baseUrl` fallback (`blocks/card/view`) after `paths` misses and inherits `@legacy-fallback/*` through a package subpath JSON fallback when package `exports` does not expose the config. The bounded output smoke now emits a deterministic WordPress block JavaScript preview from already-resolved graph modules, reports output bytes and input contribution bytes, skips terminal CSS/JSON plus unsupported assets, removes static bundled-JS import declarations, rewrites retained terminal CSS/JSON import specifiers relative to the output file, propagates output byte contributions into a bounded metafile outputs map, and carries unsupported-loader diagnostics, and rewrites named re-export clauses for already-bundled local/package JavaScript modules without invoking Node/npm.",
    "nextTask": "After integrator/root acceptance, the next best lane task is a tiny bounded output-format follow-up for star re-export diagnostics or export-star preservation around already-bundled local modules. Dependency checkpoint: no new support component is needed for this slice; it reuses the existing bounded lane-local `JsModuleAnalyzer`, `PackageResolver`, graph value objects, `BundlerMetafile`, and `BundlerOutput` summary class. Keep `js-package-resolution-core` deferred until a cross-lane resolver gate is accepted."
}