ttsc 0.30.3 → 0.31.0

package/lib/compiler/internal/build/NativePluginArguments.js

@@ -0,0 +1,255 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativePluginArguments = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const createNativeProjectContextArgs_1 = require("../project/createNativeProjectContextArgs");
+const selectSharedHostPlugin_1 = require("../sharedHost/selectSharedHostPlugin");
+const PassthroughFlags_1 = require("./PassthroughFlags");
+const isAbsoluteLocalProjectInputPath_1 = require("./isAbsoluteLocalProjectInputPath");
+/**
+ * The argv ttsc hands to a native plugin host.
+ *
+ * A native host speaks its own subcommands (`build`, `check`, `fix`, `format`,
+ * `project-inputs`) and receives the project, the plugin list, and the compiler
+ * flags as separate arguments rather than one tsgo command line. Optional
+ * capabilities a host declares (threading, diagnostics timing) decide which of
+ * ttsc's optional arguments are sent. This negotiation avoids sending those
+ * extensions to undeclared hosts; it does not certify every host's acceptance
+ * of the core protocol or the truth of its capability declaration.
+ *
+ * @evidence contracts/common.md#principled-implementation The namespace separates the host subcommand protocol from compiler forwarding and uses declared capabilities for optional host fields.
+ * @evidence contracts/common.md#clear-and-simple-design Build, check and input-query composers share descriptor serialization while preserving each command's own supported modifiers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Optional protocol extensions require capabilities instead of mutating foreign flag sets or dispatching on a particular plugin name.
+ * @evidence contracts/common.md#meaningful-documentation Namespace prose states protocol separation and capability purpose; composer comments explain project context, command effects and payload fields.
+ *
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation The grouping itself defines no native path representation; its selected argv composers address the paths they carry.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms The namespace contains no processing strategy apart from its separately selected composers and serializer.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This API grouping retains no completed or in-flight host query or payload.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources No native host, buffer history or handle is owned by the namespace.
+ */
+var NativePluginArguments;
+(function (NativePluginArguments) {
+    /**
+     * Compose a shared transform host's build or no-emit check command.
+     * Project-context arguments require the selected host's capability; quiet
+     * modifiers remain absent on the compatibility check lane.
+     *
+     * A supplied provenancePath is a private absolute artifact destination and
+     * requires explicit emitProvenance support from the selected host.
+     *
+     * @evidence contracts/common.md#principled-implementation Emit selection chooses build versus check; the selected host's independent capabilities gate explicit project context and a supplied absolute emit-proof artifact destination.
+     * @evidence contracts/common.md#clear-and-simple-design Core protocol argv precedes optional project/output/verbosity fields; compiler passthrough travels separately through the environment.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Capability checks and omission of build-only modifiers protect actual strict-host protocol differences without recognizing plugin names or altering foreign flag parsers.
+     * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain shared-host selection, no-emit compatibility modifiers and the optional private provenance path's capability/absolute-path premise.
+     * @evidence contracts/portability.md#os-neutral-implementation Native output paths resolve against execution cwd and remain individual argv elements; JSON serialization preserves plugin payload without shell escaping.
+     * @evidence contracts/performance.md#efficient-algorithms Plugin projection/JSON encoding follows plugin count, name/stage text and configuration serialization work. Selected-host capability lookups may each scan the plugin list; optional project-context serialization and native output-path resolution add payload/path-text costs. Returned argv storage follows composed bytes.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This pure argv composition coordinates no shared producer or retained cross-request result.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Arguments are returned to the process owner and no process or persistent buffer is acquired here.
+     */
+    function createNativeBuildArgs(execution, options, plugins, provenancePath) {
+        const args = [
+            options.emit === false ? "check" : "build",
+            "--tsconfig=" + execution.tsconfig,
+            "--plugins-json=" + serializeNativePlugins(plugins),
+            "--cwd=" + execution.projectRoot,
+        ];
+        if (provenancePath !== undefined) {
+            if ((0, selectSharedHostPlugin_1.selectSharedHostPlugin)(plugins).capabilities?.emitProvenance !== true)
+                throw new Error("ttsc: native compiler host does not support emit provenance");
+            if (!(0, isAbsoluteLocalProjectInputPath_1.isAbsoluteLocalProjectInputPath)(provenancePath))
+                throw new Error("ttsc: emit provenance destination must be an absolute native path");
+            args.push("--emit-provenance-json=" + provenancePath);
+        }
+        if ((0, selectSharedHostPlugin_1.selectSharedHostPlugin)(plugins).capabilities?.projectContextArgs === true) {
+            args.push(...(0, createNativeProjectContextArgs_1.createNativeProjectContextArgs)(execution.project, execution.pluginConfigDir));
+        }
+        if (options.emit === true) {
+            args.push("--emit");
+        }
+        if (options.outDir) {
+            args.push("--outDir=" + node_path_1.default.resolve(execution.cwd, options.outDir));
+        }
+        // Third-party transform hosts already treat the `check` subcommand as a
+        // quiet no-emit pass. Keep ttsc-owned build modifiers off that lane so older
+        // strict hosts do not reject unknown optional flags before analysis starts.
+        if (options.emit !== false) {
+            if (options.quiet === false) {
+                args.push("--verbose");
+            }
+            else if (options.quiet === true) {
+                args.push("--quiet");
+            }
+        }
+        return args;
+    }
+    NativePluginArguments.createNativeBuildArgs = createNativeBuildArgs;
+    /**
+     * Compose one check-stage host's check, fix or format command. The full
+     * plugin configuration accompanies the command; optional threading, timing
+     * and project-context fields require that host's declared support.
+     *
+     * @evidence contracts/common.md#principled-implementation Subcommand selection follows format/fix options while capability-gated fields preserve the selected host's accepted protocol.
+     * @evidence contracts/common.md#clear-and-simple-design Shared core fields are assembled before small helpers add threading and timing, separating host capability policy from compiler argv.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Optional flags use descriptor capabilities rather than special plugin names or monkey-patched foreign flag sets.
+     * @evidence contracts/common.md#meaningful-documentation Native prose explains command effects, full configuration delivery and capability-dependent fields.
+     * @evidence contracts/portability.md#os-neutral-implementation cwd and output locations retain native path semantics; each protocol flag is a separate argv element and plugin configuration is JSON, not shell text.
+     * @evidence contracts/performance.md#efficient-algorithms Composition serializes plugin count/name/stage/config fields; capability-gated timing selection projects the unexpanded forwarded argv frame with token/name/value costs. Optional project-context encoding and native output-path resolution add text work; returned storage follows argv bytes.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Building one command does not coordinate completed or in-flight execution across consumers.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources No sidecar or persistent argument cache is owned by this composer.
+     */
+    function createNativeCheckArgs(execution, options, plugin) {
+        const args = [
+            nativeCheckSubcommand(options),
+            "--tsconfig=" + execution.tsconfig,
+            "--plugins-json=" + serializeNativePlugins(execution.nativePlugins),
+            "--cwd=" + execution.projectRoot,
+        ];
+        if (plugin.capabilities?.projectContextArgs === true) {
+            args.push(...(0, createNativeProjectContextArgs_1.createNativeProjectContextArgs)(execution.project, execution.pluginConfigDir));
+        }
+        if (options.outDir) {
+            args.push("--outDir=" + node_path_1.default.resolve(execution.cwd, options.outDir));
+        }
+        if (options.quiet === false) {
+            args.push("--verbose");
+        }
+        else if (options.quiet === true) {
+            args.push("--quiet");
+        }
+        args.push(...createNativeCheckThreadingArgs(options, plugin));
+        args.push(...createNativeCheckDiagnosticsArgs(options, plugin));
+        return args;
+    }
+    NativePluginArguments.createNativeCheckArgs = createNativeCheckArgs;
+    /**
+     * Build the argv of a native host's `project-inputs` query, which reports the
+     * non-TypeScript files (documents, schemas, configs) the host's rules read,
+     * so watch and cache invalidation can observe them.
+     *
+     * The caller must check projectInputs capability before launching this query.
+     *
+     * @evidence contracts/common.md#principled-implementation Project selection and complete plugin configuration let the host report its actual rule inputs; optional project context is sent only when supported.
+     * @evidence contracts/common.md#clear-and-simple-design This composer owns query argv while the discovery operation owns capability selection, execution and snapshot validation.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The explicit project-inputs protocol queries declared dependencies instead of guessing files from plugin names or dropping unsupported inputs.
+     * @evidence contracts/common.md#meaningful-documentation Native prose explains non-TypeScript dependencies, invalidation purpose and the caller's capability premise.
+     * @evidence contracts/portability.md#os-neutral-implementation Selected tsconfig/cwd spellings travel as separate native argv fields; no slash rewriting or shell construction is applied to paths.
+     * @evidence contracts/performance.md#efficient-algorithms Plugin descriptors are projected and JSON-encoded once, with plugin count, name/stage/config serialization costs. Optional project-context encoding and composed native path-field text add work/storage; fixed field count does not make payload cost constant.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Query composition establishes no cross-request reuse of host dependency discovery.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Returned argv has caller ownership; this function acquires no native resource or retained snapshot.
+     */
+    function createNativeProjectInputsArgs(execution, plugin) {
+        const args = [
+            "project-inputs",
+            "--tsconfig=" + execution.tsconfig,
+            "--plugins-json=" + serializeNativePlugins(execution.nativePlugins),
+            "--cwd=" + execution.projectRoot,
+        ];
+        if (plugin.capabilities?.projectContextArgs === true) {
+            args.push(...(0, createNativeProjectContextArgs_1.createNativeProjectContextArgs)(execution.project, execution.pluginConfigDir));
+        }
+        return args;
+    }
+    NativePluginArguments.createNativeProjectInputsArgs = createNativeProjectInputsArgs;
+    /**
+     * Send threading options only to check hosts declaring support. An unknown
+     * strict host may reject optional flags before it can analyze the project;
+     * transform hosts use the separate build/compiler-options channel.
+     */
+    function createNativeCheckThreadingArgs(options, plugin) {
+        if (!nativeHostAcceptsThreadingArgs(plugin))
+            return [];
+        const args = [];
+        if (options.singleThreaded === true) {
+            args.push("--singleThreaded");
+        }
+        if (options.checkers !== undefined) {
+            args.push("--checkers=" + String(options.checkers));
+        }
+        return args;
+    }
+    /**
+     * Return true when the loaded native check-stage host has declared
+     * `capabilities.threadingArgs` in its plugin descriptor.
+     *
+     * An absent declaration means unsupported, regardless of package ownership or
+     * plugin name, because the host's native flag set is otherwise unknown.
+     */
+    function nativeHostAcceptsThreadingArgs(plugin) {
+        return plugin.capabilities?.threadingArgs === true;
+    }
+    function createNativeCheckDiagnosticsArgs(options, plugin) {
+        if (!nativeHostAcceptsDiagnosticsTiming(plugin))
+            return [];
+        if (!PassthroughFlags_1.PassthroughFlags.hasDiagnosticsFlag(options))
+            return [];
+        return ["--diagnostics"];
+    }
+    function nativeHostAcceptsDiagnosticsTiming(plugin) {
+        return plugin.capabilities?.diagnosticsTiming === true;
+    }
+    /**
+     * The `--diagnostics` timing label of one transform-host run, naming every
+     * plugin that shared the host so a slow run can be attributed.
+     *
+     * @evidence contracts/common.md#principled-implementation Names of all selected participants form one label for the shared execution, rather than attributing its duration to only one plugin.
+     * @evidence contracts/common.md#clear-and-simple-design A single name projection and join supplies timing attribution without coupling labels to process selection.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Participant names come from the actual loaded selection, not a fixed benchmark label or special plugin list.
+     * @evidence contracts/common.md#meaningful-documentation Native prose identifies the shared-host timing purpose and attribution scope.
+     *
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation Formatting participant names touches no native path, filesystem or process boundary.
+     *
+     * @evidence contracts/performance.md#efficient-algorithms One projection and join cost O(P plus participant-name/output bytes) for P plugins, with no repeated string-prefix rebuilding.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work A label formatter coordinates no shared computation beyond the supplied participant list.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The formatter returns text without retaining selection history or handles.
+     */
+    function transformHostTimingLabel(plugins) {
+        return (`ttsc transform host [` +
+            `${plugins.map((plugin) => plugin.name).join(", ")}] time`);
+    }
+    NativePluginArguments.transformHostTimingLabel = transformHostTimingLabel;
+    /**
+     * Decide which native plugin subcommand the lint sidecar should run for the
+     * current `runBuild` invocation. The launcher selects exactly one of `fix` /
+     * `format` / `check` via subcommand dispatch, so at most one of the
+     * `options.fix` / `options.format` booleans is true.
+     */
+    function nativeCheckSubcommand(options) {
+        if (options.format === true)
+            return "format";
+        if (options.fix === true)
+            return "fix";
+        return "check";
+    }
+    /**
+     * Serialize the plugin list to a compact JSON string for `--plugins-json=`.
+     * Only the fields the native binary protocol requires are included.
+     *
+     * @evidence contracts/common.md#principled-implementation Projection retains config, name and stage, the protocol's declared plugin descriptor fields, without serializing host-loader implementation details.
+     * @evidence contracts/common.md#clear-and-simple-design One explicit projection defines the JSON wire representation separately from in-memory plugin metadata.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Standard JSON encoding preserves configuration structure without handcrafted quoting or mutation of foreign descriptors.
+     * @evidence contracts/common.md#meaningful-documentation Native prose states the compact protocol purpose and deliberate field restriction.
+     *
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation JSON descriptor serialization accesses no native filesystem or process and applies no path normalization.
+     *
+     * @evidence contracts/performance.md#efficient-algorithms One projection visits P plugins and standard JSON serialization traverses config/name/stage values into returned bytes. Custom getters/toJSON and exceptional or cyclic config values follow ordinary JSON semantics and can add work or throw; no serialization work ceiling is supplied here. Only required descriptor fields are explicitly projected.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Mutable plugin configuration is serialized for the current invocation without establishing cross-request equivalence.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Local projections become returned text; no persistent descriptor cache or handle is retained.
+     */
+    function serializeNativePlugins(plugins) {
+        return JSON.stringify(plugins.map((plugin) => ({
+            config: plugin.config,
+            name: plugin.name,
+            stage: plugin.stage,
+        })));
+    }
+    NativePluginArguments.serializeNativePlugins = serializeNativePlugins;
+})(NativePluginArguments || (exports.NativePluginArguments = NativePluginArguments = {}));
+//# sourceMappingURL=NativePluginArguments.js.map

package/lib/compiler/internal/build/NativePluginArguments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativePluginArguments.js","sourceRoot":"","sources":["../../../../src/compiler/internal/build/NativePluginArguments.ts"],"names":[],"mappings":"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"}

package/lib/compiler/internal/build/PassthroughFlags.d.ts

@@ -0,0 +1,137 @@
+import type { TtscCommonOptions } from "../../../structures/internal/TtscCommonOptions";
+/**
+ * Questions about the compiler flags a user forwarded through ttsc.
+ *
+ * Ttsc forwards every flag it does not own to TypeScript-Go verbatim, then has
+ * to answer a few questions about them itself: whether timing was asked for,
+ * whether a flag turns the build into a terminal command, whether a flag is one
+ * ttsc consumes internally. Every answer resolves the token through the flag
+ * schema, so a question is decided by the flag's identity (any case, one or two
+ * dashes) and, for a boolean flag, by the value TypeScript-Go gives it.
+ *
+ * Classification observes this unexpanded argv frame. It does not read response
+ * files; their contents and effects remain owned by the native compiler and
+ * cannot be certified by these predicates.
+ *
+ * @evidence contracts/common.md#principled-implementation Schema identities and compiler-compatible boolean occurrence parsing distinguish effective flags from mere user-owned presence.
+ * @evidence contracts/common.md#clear-and-simple-design The grouping centralizes forwarding classification and preservation policy so higher build layers do not maintain parallel literal flag sets.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Shared schema metadata replaces producer-name or exact-spelling exceptions, and malformed argv remains under compiler diagnostic ownership.
+ * @evidence contracts/common.md#meaningful-documentation Namespace prose explains why forwarding also needs classification; public comments document precedence, preservation and distinct presence semantics.
+ *
+ * @evidenceExclude contracts/performance.md#efficient-algorithms The namespace groups APIs; selected predicates and argv transformation functions own their scans and allocations.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work No completed or in-flight computation is retained by this API grouping.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The namespace owns no persistent map, task or handle; helper parser state is invocation-local.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation A namespace only groups the declarations inside it; each carries its own acknowledgments.
+ */
+export declare namespace PassthroughFlags {
+    /**
+     * Whether a visible `--diagnostics` or `--extendedDiagnostics` occurrence
+     * remains enabled in this unexpanded argv frame, using native boolean rules.
+     *
+     * @evidence contracts/common.md#principled-implementation Last-occurrence boolean interpretation matches compiler option assignment, so a later false or null disables earlier diagnostics selection.
+     * @evidence contracts/common.md#clear-and-simple-design Shared boolean parsing resolves schema identities; this predicate asks only whether either timing flag remains enabled.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The actual forwarded tokens and schema determine timing rather than exact-spelling checks or benchmark-only flag handling.
+     * @evidence contracts/common.md#meaningful-documentation Native prose identifies effective rather than merely present flags and compiler-compatible precedence.
+     * @evidence contracts/performance.md#efficient-algorithms One native-occurrence cursor records final values per schema flag, then scans enabled schema references. Work includes argv count, token-name normalization and list-lookahead text bytes; local maps/arrays are bounded by distinct schema flags and transient parsing by the current value's bytes.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This predicate inspects current mutable options and coordinates no retained or in-flight computation.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Boolean state is local to the call; no argument history or resource is retained.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation hasDiagnosticsFlag computes from its arguments only; it opens no file, builds no path and calls no platform or process API.
+     */
+    function hasDiagnosticsFlag(options: TtscCommonOptions): boolean;
+    /**
+     * Report whether this unexpanded argv frame includes an enabled
+     * print-and-exit tsgo flag (`--showConfig`, `--listFilesOnly`, `--all`,
+     * `--init`, `-?`) that is in effect, so ttsc can avoid adding compile-only
+     * flags to a command that is not going to compile.
+     *
+     * Schema-derived, and resolved by flag identity rather than by exact
+     * spelling: adding a new terminal flag means editing `FLAG_SCHEMA.ts` and
+     * re-running `pnpm run gen:flags`; this predicate needs no edit. A terminal
+     * flag the user turned off (`--showConfig false`) is an ordinary compile to
+     * TypeScript-Go, so it must not lift the emit guards of one.
+     *
+     * @evidence contracts/common.md#principled-implementation Only enabled boolean flags carrying schema terminal semantics classify a print-and-exit request; disabled occurrences cannot lift compilation guards.
+     * @evidence contracts/common.md#clear-and-simple-design Schema metadata owns terminal classification and the shared parser owns value precedence, avoiding parallel flag lists in build orchestration.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts This uses supported flag metadata rather than selected spelling exceptions or treating malformed argv as a successful terminal request.
+     * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain terminal effects, schema ownership and the significance of a disabled occurrence.
+     * @evidence contracts/performance.md#efficient-algorithms A native-occurrence cursor interprets argv once, including token-name and list-lookahead bytes, then short-circuits on an enabled terminal schema flag. Local final-value references are bounded by distinct schema flags; transient parsing scales with the current lookahead value.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Classification reads one options value and establishes no reusable producer or cross-request state.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only invocation-local parser state is allocated; no process or retained history is owned.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation Terminal metadata and native-compatible boolean assignments classify compiler argv only; no native path is resolved or process/OS capability acquired here.
+     */
+    function forwardsTerminalTsgoFlag(options: TtscCommonOptions): boolean;
+    /**
+     * Report whether an enabled terminal flag visible in this unexpanded frame
+     * has project-independent meaning (`--init`, `--all`, `-?`).
+     *
+     * Derived from `FLAG_SCHEMA[*].projectFree`, through the same identity
+     * resolution as every other classification — never a literal list of flag
+     * names beside this branch. Project dependence stays owned by the schema.
+     *
+     * @evidence contracts/common.md#principled-implementation Project-free classification requires both enabled terminal behavior and schema projectFree metadata, distinguishing config-independent commands from show-config requests.
+     * @evidence contracts/common.md#clear-and-simple-design The same final boolean interpretation serves all classifications while schema metadata owns which commands require a project.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Project bypass is granted by declared flag semantics, not by catching arbitrary setup failures and pretending compilation succeeded.
+     * @evidence contracts/common.md#meaningful-documentation The preceding native prose explains the project-independent meaning and schema source; acknowledgments are kept apart from descriptive paragraphs.
+     * @evidence contracts/performance.md#efficient-algorithms The shared occurrence cursor scans token names and list-lookahead text before a short-circuit scan of distinct enabled schema references. Parsing and local value/reference arrays remain invocation-bound; no project read or response-file expansion is added.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This classification does not coordinate repeated production or retain option interpretation between requests.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources All parser state is local and no native resource is acquired.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation A schema projectFree boolean classifies option meaning without resolving configs, reading paths or probing executables; those native capabilities belong to the execution owner.
+     */
+    function forwardsProjectFreeTerminalTsgoFlag(options: TtscCommonOptions): boolean;
+    /**
+     * Report whether this unexpanded frame visibly names a flag ttsc adds
+     * internally — e.g. `--listEmittedFiles` (ttsc adds it to learn emitted
+     * paths) or `--noEmit` (ttsc adds it for the pre-emit type-check). When the
+     * user also forwards the same flag, post-processing must keep the
+     * user-visible effect intact instead of stripping it as ttsc-internal noise.
+     *
+     * Schema-derived: `FLAG_SCHEMA[*].internalShadow === true`.
+     *
+     * Presence identifies a user-owned option spelling, including malformed
+     * inline-value spelling that must remain available for the compiler to
+     * reject. This predicate does not decide whether the boolean occurrence is
+     * enabled.
+     *
+     * @evidence contracts/common.md#principled-implementation Schema identity plus internalShadow metadata distinguishes user-owned output/option selection from flags introduced only for internal collection.
+     * @evidence contracts/common.md#clear-and-simple-design Presence recognition is separate from effective boolean parsing because preservation and execution classification have different requirements.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Recognizing malformed user spelling prevents internally supplied values from erasing its compiler error; no producer method or argv is patched.
+     * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes presence from enabled state and explains why malformed inline spelling is still recognized.
+     * @evidence contracts/performance.md#efficient-algorithms A short-circuit native-occurrence cursor resolves visible flag names and skips consumed operands; work includes visited token-name and list-lookahead bytes. Only transient current-value parsing is allocated, with no final flag table or argv copy.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Current argv presence is inspected directly without coordinating a shared or retained producer.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This lookup owns no persistent state or handle.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation Canonical shadow identity and argv consumption are compiler-token policy; no token is resolved as a native filesystem path and no process or OS capability is accessed.
+     */
+    function forwardsInternalShadowFlag(options: TtscCommonOptions, flag: string): boolean;
+    /**
+     * This unexpanded argv frame without visible occurrences of the named boolean
+     * flags, each removed with the value token TypeScript-Go would consume for
+     * it.
+     *
+     * Only an occurrence TypeScript-Go itself accepts is removed. An inline
+     * spelling it rejects (`--diagnostics=false`) stays for native diagnosis.
+     * Unconsumed data also stays: `--diagnostics TRUE` removes the enabled option
+     * but leaves `TRUE` as a native input file. Its acceptance or failure belongs
+     * to the compiler, rather than being certified as a malformed boolean here.
+     *
+     * An empty token preserves an unconsumed lookahead boundary when deletion
+     * would otherwise bind later data to a retained boolean, list or config-only
+     * option. A surviving dash option already preserves that boundary; adjacent
+     * removals defer the fence until they expose data or the end of the frame.
+     * Native parsing ignores the empty token as a positional input.
+     *
+     * @evidence contracts/common.md#principled-implementation The native cursor identifies valid boolean assignments and skips scalar operands. Removal retains malformed spelling and inserts a native-ignored empty lookahead fence when needed to preserve the remaining options, files and diagnostics.
+     * @evidence contracts/common.md#clear-and-simple-design One indexed argv walk uses the shared occurrence parser and builds a fresh output array without modifying caller tokens.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Invalid argv is preserved for the compiler's real diagnostic instead of being normalized into a successful request.
+     * @evidence contracts/common.md#meaningful-documentation Native examples explain inline rejection and unconsumed uppercase values, giving the reason preservation matters.
+     * @evidence contracts/performance.md#efficient-algorithms The cursor visits A argv tokens with linear membership checks over D supplied removal names, giving O(A times D) membership work plus visited token/lookahead text bytes. Production consumers supply one or two names; consumed operands are skipped. Returned references grow with A, and transient list parsing with the current value's bytes.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This transforms one argv sequence without retaining or coordinating equivalent computation across requests.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The new array is transferred to the caller and no token history or handle remains owned here.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation Removing compiler-token occurrences and inserting native-ignored empty fences interprets no filesystem path and accesses no process, shell or OS capability; the downstream compiler owns response-file expansion and execution.
+     */
+    function withoutBooleanFlags(passthrough: readonly string[], names: readonly string[]): string[];
+}

package/lib/compiler/internal/build/PassthroughFlags.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PassthroughFlags = void 0;
+const readCompilerOptionOccurrence_1 = require("../../../flags/readCompilerOptionOccurrence");
+const resolveFlagSpec_1 = require("../../../flags/resolveFlagSpec");
+/**
+ * Questions about the compiler flags a user forwarded through ttsc.
+ *
+ * Ttsc forwards every flag it does not own to TypeScript-Go verbatim, then has
+ * to answer a few questions about them itself: whether timing was asked for,
+ * whether a flag turns the build into a terminal command, whether a flag is one
+ * ttsc consumes internally. Every answer resolves the token through the flag
+ * schema, so a question is decided by the flag's identity (any case, one or two
+ * dashes) and, for a boolean flag, by the value TypeScript-Go gives it.
+ *
+ * Classification observes this unexpanded argv frame. It does not read response
+ * files; their contents and effects remain owned by the native compiler and
+ * cannot be certified by these predicates.
+ *
+ * @evidence contracts/common.md#principled-implementation Schema identities and compiler-compatible boolean occurrence parsing distinguish effective flags from mere user-owned presence.
+ * @evidence contracts/common.md#clear-and-simple-design The grouping centralizes forwarding classification and preservation policy so higher build layers do not maintain parallel literal flag sets.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Shared schema metadata replaces producer-name or exact-spelling exceptions, and malformed argv remains under compiler diagnostic ownership.
+ * @evidence contracts/common.md#meaningful-documentation Namespace prose explains why forwarding also needs classification; public comments document precedence, preservation and distinct presence semantics.
+ *
+ * @evidenceExclude contracts/performance.md#efficient-algorithms The namespace groups APIs; selected predicates and argv transformation functions own their scans and allocations.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work No completed or in-flight computation is retained by this API grouping.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The namespace owns no persistent map, task or handle; helper parser state is invocation-local.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation A namespace only groups the declarations inside it; each carries its own acknowledgments.
+ */
+var PassthroughFlags;
+(function (PassthroughFlags) {
+    /**
+     * Whether a visible `--diagnostics` or `--extendedDiagnostics` occurrence
+     * remains enabled in this unexpanded argv frame, using native boolean rules.
+     *
+     * @evidence contracts/common.md#principled-implementation Last-occurrence boolean interpretation matches compiler option assignment, so a later false or null disables earlier diagnostics selection.
+     * @evidence contracts/common.md#clear-and-simple-design Shared boolean parsing resolves schema identities; this predicate asks only whether either timing flag remains enabled.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The actual forwarded tokens and schema determine timing rather than exact-spelling checks or benchmark-only flag handling.
+     * @evidence contracts/common.md#meaningful-documentation Native prose identifies effective rather than merely present flags and compiler-compatible precedence.
+     * @evidence contracts/performance.md#efficient-algorithms One native-occurrence cursor records final values per schema flag, then scans enabled schema references. Work includes argv count, token-name normalization and list-lookahead text bytes; local maps/arrays are bounded by distinct schema flags and transient parsing by the current value's bytes.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This predicate inspects current mutable options and coordinates no retained or in-flight computation.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Boolean state is local to the call; no argument history or resource is retained.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation hasDiagnosticsFlag computes from its arguments only; it opens no file, builds no path and calls no platform or process API.
+     */
+    function hasDiagnosticsFlag(options) {
+        const enabled = effectiveBooleanFlags(options);
+        return enabled.some((flag) => flag.name === "--diagnostics" || flag.name === "--extendedDiagnostics");
+    }
+    PassthroughFlags.hasDiagnosticsFlag = hasDiagnosticsFlag;
+    /**
+     * Report whether this unexpanded argv frame includes an enabled
+     * print-and-exit tsgo flag (`--showConfig`, `--listFilesOnly`, `--all`,
+     * `--init`, `-?`) that is in effect, so ttsc can avoid adding compile-only
+     * flags to a command that is not going to compile.
+     *
+     * Schema-derived, and resolved by flag identity rather than by exact
+     * spelling: adding a new terminal flag means editing `FLAG_SCHEMA.ts` and
+     * re-running `pnpm run gen:flags`; this predicate needs no edit. A terminal
+     * flag the user turned off (`--showConfig false`) is an ordinary compile to
+     * TypeScript-Go, so it must not lift the emit guards of one.
+     *
+     * @evidence contracts/common.md#principled-implementation Only enabled boolean flags carrying schema terminal semantics classify a print-and-exit request; disabled occurrences cannot lift compilation guards.
+     * @evidence contracts/common.md#clear-and-simple-design Schema metadata owns terminal classification and the shared parser owns value precedence, avoiding parallel flag lists in build orchestration.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts This uses supported flag metadata rather than selected spelling exceptions or treating malformed argv as a successful terminal request.
+     * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain terminal effects, schema ownership and the significance of a disabled occurrence.
+     * @evidence contracts/performance.md#efficient-algorithms A native-occurrence cursor interprets argv once, including token-name and list-lookahead bytes, then short-circuits on an enabled terminal schema flag. Local final-value references are bounded by distinct schema flags; transient parsing scales with the current lookahead value.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Classification reads one options value and establishes no reusable producer or cross-request state.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only invocation-local parser state is allocated; no process or retained history is owned.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation Terminal metadata and native-compatible boolean assignments classify compiler argv only; no native path is resolved or process/OS capability acquired here.
+     */
+    function forwardsTerminalTsgoFlag(options) {
+        return effectiveBooleanFlags(options).some((flag) => flag.terminal === true);
+    }
+    PassthroughFlags.forwardsTerminalTsgoFlag = forwardsTerminalTsgoFlag;
+    /**
+     * Report whether an enabled terminal flag visible in this unexpanded frame
+     * has project-independent meaning (`--init`, `--all`, `-?`).
+     *
+     * Derived from `FLAG_SCHEMA[*].projectFree`, through the same identity
+     * resolution as every other classification — never a literal list of flag
+     * names beside this branch. Project dependence stays owned by the schema.
+     *
+     * @evidence contracts/common.md#principled-implementation Project-free classification requires both enabled terminal behavior and schema projectFree metadata, distinguishing config-independent commands from show-config requests.
+     * @evidence contracts/common.md#clear-and-simple-design The same final boolean interpretation serves all classifications while schema metadata owns which commands require a project.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Project bypass is granted by declared flag semantics, not by catching arbitrary setup failures and pretending compilation succeeded.
+     * @evidence contracts/common.md#meaningful-documentation The preceding native prose explains the project-independent meaning and schema source; acknowledgments are kept apart from descriptive paragraphs.
+     * @evidence contracts/performance.md#efficient-algorithms The shared occurrence cursor scans token names and list-lookahead text before a short-circuit scan of distinct enabled schema references. Parsing and local value/reference arrays remain invocation-bound; no project read or response-file expansion is added.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This classification does not coordinate repeated production or retain option interpretation between requests.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources All parser state is local and no native resource is acquired.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation A schema projectFree boolean classifies option meaning without resolving configs, reading paths or probing executables; those native capabilities belong to the execution owner.
+     */
+    function forwardsProjectFreeTerminalTsgoFlag(options) {
+        return effectiveBooleanFlags(options).some((flag) => flag.terminal === true && flag.projectFree === true);
+    }
+    PassthroughFlags.forwardsProjectFreeTerminalTsgoFlag = forwardsProjectFreeTerminalTsgoFlag;
+    /**
+     * Report whether this unexpanded frame visibly names a flag ttsc adds
+     * internally — e.g. `--listEmittedFiles` (ttsc adds it to learn emitted
+     * paths) or `--noEmit` (ttsc adds it for the pre-emit type-check). When the
+     * user also forwards the same flag, post-processing must keep the
+     * user-visible effect intact instead of stripping it as ttsc-internal noise.
+     *
+     * Schema-derived: `FLAG_SCHEMA[*].internalShadow === true`.
+     *
+     * Presence identifies a user-owned option spelling, including malformed
+     * inline-value spelling that must remain available for the compiler to
+     * reject. This predicate does not decide whether the boolean occurrence is
+     * enabled.
+     *
+     * @evidence contracts/common.md#principled-implementation Schema identity plus internalShadow metadata distinguishes user-owned output/option selection from flags introduced only for internal collection.
+     * @evidence contracts/common.md#clear-and-simple-design Presence recognition is separate from effective boolean parsing because preservation and execution classification have different requirements.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Recognizing malformed user spelling prevents internally supplied values from erasing its compiler error; no producer method or argv is patched.
+     * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes presence from enabled state and explains why malformed inline spelling is still recognized.
+     * @evidence contracts/performance.md#efficient-algorithms A short-circuit native-occurrence cursor resolves visible flag names and skips consumed operands; work includes visited token-name and list-lookahead bytes. Only transient current-value parsing is allocated, with no final flag table or argv copy.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Current argv presence is inspected directly without coordinating a shared or retained producer.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This lookup owns no persistent state or handle.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation Canonical shadow identity and argv consumption are compiler-token policy; no token is resolved as a native filesystem path and no process or OS capability is accessed.
+     */
+    function forwardsInternalShadowFlag(options, flag) {
+        const passthrough = options.passthrough;
+        if (passthrough === undefined)
+            return false;
+        // Resolution covers the bare form (`--pretty`), the inline-value form
+        // (`--pretty=true`), and case variants (`--PRETTY`). This is identity
+        // recognition, not acceptance of an inline boolean value by tsgo.
+        for (let index = 0; index < passthrough.length;) {
+            const spec = (0, resolveFlagSpec_1.resolveFlagSpec)(passthrough[index]);
+            if (spec?.internalShadow === true && spec.name === flag)
+                return true;
+            index += (0, readCompilerOptionOccurrence_1.readCompilerOptionOccurrence)(passthrough, index).width;
+        }
+        return false;
+    }
+    PassthroughFlags.forwardsInternalShadowFlag = forwardsInternalShadowFlag;
+    /**
+     * This unexpanded argv frame without visible occurrences of the named boolean
+     * flags, each removed with the value token TypeScript-Go would consume for
+     * it.
+     *
+     * Only an occurrence TypeScript-Go itself accepts is removed. An inline
+     * spelling it rejects (`--diagnostics=false`) stays for native diagnosis.
+     * Unconsumed data also stays: `--diagnostics TRUE` removes the enabled option
+     * but leaves `TRUE` as a native input file. Its acceptance or failure belongs
+     * to the compiler, rather than being certified as a malformed boolean here.
+     *
+     * An empty token preserves an unconsumed lookahead boundary when deletion
+     * would otherwise bind later data to a retained boolean, list or config-only
+     * option. A surviving dash option already preserves that boundary; adjacent
+     * removals defer the fence until they expose data or the end of the frame.
+     * Native parsing ignores the empty token as a positional input.
+     *
+     * @evidence contracts/common.md#principled-implementation The native cursor identifies valid boolean assignments and skips scalar operands. Removal retains malformed spelling and inserts a native-ignored empty lookahead fence when needed to preserve the remaining options, files and diagnostics.
+     * @evidence contracts/common.md#clear-and-simple-design One indexed argv walk uses the shared occurrence parser and builds a fresh output array without modifying caller tokens.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Invalid argv is preserved for the compiler's real diagnostic instead of being normalized into a successful request.
+     * @evidence contracts/common.md#meaningful-documentation Native examples explain inline rejection and unconsumed uppercase values, giving the reason preservation matters.
+     * @evidence contracts/performance.md#efficient-algorithms The cursor visits A argv tokens with linear membership checks over D supplied removal names, giving O(A times D) membership work plus visited token/lookahead text bytes. Production consumers supply one or two names; consumed operands are skipped. Returned references grow with A, and transient list parsing with the current value's bytes.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This transforms one argv sequence without retaining or coordinating equivalent computation across requests.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The new array is transferred to the caller and no token history or handle remains owned here.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation Removing compiler-token occurrences and inserting native-ignored empty fences interprets no filesystem path and accesses no process, shell or OS capability; the downstream compiler owns response-file expansion and execution.
+     */
+    function withoutBooleanFlags(passthrough, names) {
+        const out = [];
+        let previousNeedsFence = false;
+        for (let i = 0; i < passthrough.length;) {
+            const occurrence = (0, readCompilerOptionOccurrence_1.readCompilerOptionOccurrence)(passthrough, i);
+            const flag = (0, resolveFlagSpec_1.resolveFlagSpec)(passthrough[i]);
+            if (occurrence.booleanValue !== undefined &&
+                flag !== undefined &&
+                names.includes(flag.name)) {
+                // Native ignores an empty positional token. It also prevents a
+                // retained boolean/list/config-only option from consuming newly
+                // adjacent data after the removed option disappears.
+                const next = passthrough[i + occurrence.width];
+                if (previousNeedsFence &&
+                    (next === undefined || !next.startsWith("-"))) {
+                    out.push("");
+                    previousNeedsFence = false;
+                }
+                i += occurrence.width;
+                continue;
+            }
+            out.push(...passthrough.slice(i, i + occurrence.width));
+            previousNeedsFence = occurrence.needsFence;
+            i += occurrence.width;
+        }
+        return out;
+    }
+    PassthroughFlags.withoutBooleanFlags = withoutBooleanFlags;
+    /**
+     * Every schema boolean flag whose last forwarded occurrence turns it on.
+     * TypeScript-Go assigns an option at each occurrence, so the last one wins.
+     */
+    function effectiveBooleanFlags(options) {
+        const passthrough = options.passthrough ?? [];
+        const values = new Map();
+        for (let i = 0; i < passthrough.length;) {
+            const occurrence = (0, readCompilerOptionOccurrence_1.readCompilerOptionOccurrence)(passthrough, i);
+            if (occurrence.booleanValue !== undefined) {
+                const flag = (0, resolveFlagSpec_1.resolveFlagSpec)(passthrough[i]);
+                if (flag !== undefined)
+                    values.set(flag, occurrence.booleanValue);
+            }
+            i += occurrence.width;
+        }
+        return [...values].filter(([, value]) => value).map(([flag]) => flag);
+    }
+})(PassthroughFlags || (exports.PassthroughFlags = PassthroughFlags = {}));
+//# sourceMappingURL=PassthroughFlags.js.map