ttsc 0.30.3 → 0.31.0

package/lib/flags/ParseResult.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Per-subcommand parse result. `values` is keyed by the canonical flag name
+ * (e.g. `"--singleThreaded"`); boolean flags resolve to `true`/`false`, value
+ * flags to the parsed value type. Callers narrow with the helpers below
+ * (`getBoolean`, `getString`, `getNumber`).
+ *
+ * @evidence contracts/common.md#principled-implementation Canonical-name maps retain typed launcher values separately from ordered passthrough, positional and program-tail tokens; the repeated map preserves all occurrences when last-value selection is insufficient.
+ * @evidence contracts/common.md#clear-and-simple-design Each result member names one destination or occurrence policy, so consumers need no second parsing pass to reconstruct compiler versus program arguments.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The separate tail prevents program arguments from becoming compiler flags, and canonical keys derive from FlagSpec instead of consumer-specific spelling checks.
+ * @evidence contracts/common.md#meaningful-documentation Native member comments explain canonical keys, repetition ordering and the distinction between compiler passthrough and program tail; their separated presentation follows the documentation skill without member checklist tags.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This type declaration describes a data shape only; it opens no file, builds no path and branches on no platform.
+ */
+export interface ParseResult {
+    /** Canonical flag name → resolved value. */
+    readonly values: ReadonlyMap<string, string | boolean | number>;
+    /**
+     * Canonical flag name → every accepted value, in argv order. Populated only
+     * for flags declared `repeatable` in `FLAG_SCHEMA` (`ttsx -r a -r b`), where
+     * the last-value-wins `values` entry is not the whole answer. Read it through
+     * `getStringList`.
+     */
+    readonly repeated: ReadonlyMap<string, readonly (string | boolean | number)[]>;
+    /** Flags the engine did not consume — forwarded to tsgo. */
+    readonly passthrough: readonly string[];
+    /** Bare non-flag positional arguments, in original order. */
+    readonly positional: readonly string[];
+    /**
+     * Tokens that arrived after the `forwardAfterFirstPositional` sentinel. These
+     * are intended for the user's program (e.g. ttsx's entry-file argv); they are
+     * NOT forwarded to tsgo. Always empty when `forwardAfterFirstPositional` is
+     * false.
+     */
+    readonly tail: readonly string[];
+}

package/lib/flags/ParseResult.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ParseResult.js.map

package/lib/flags/ParseResult.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParseResult.js","sourceRoot":"","sources":["../../src/flags/ParseResult.ts"],"names":[],"mappings":""}

package/lib/flags/TtscSubcommand.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Subcommands the ttsc CLI dispatches to. The bare `"ttsc"` entry covers the
+ * default lane (no explicit subcommand, e.g. `ttsc -p tsconfig.json`).
+ *
+ * @evidence contracts/common.md#principled-implementation Literal command identities distinguish the default compiler lane from named launcher commands, matching the dispatch vocabulary used by flag selection.
+ * @evidence contracts/common.md#clear-and-simple-design A single union records the permitted identities without adding a command registry or dispatch behavior to the representation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The ttsc literal intentionally represents the product's default lane rather than a special case for any project or invocation fixture.
+ * @evidence contracts/common.md#meaningful-documentation The comment explains why the default lane has a named identity and gives its invocation meaning, applying the documentation skill's purpose and context guidance.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This type declaration describes a data shape only; it opens no file, builds no path and branches on no platform.
+ */
+export type TtscSubcommand = "ttsc" | "build" | "cache" | "check" | "fix" | "format" | "prepare" | "clean";

package/lib/flags/TtscSubcommand.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=TtscSubcommand.js.map

package/lib/flags/TtscSubcommand.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TtscSubcommand.js","sourceRoot":"","sources":["../../src/flags/TtscSubcommand.ts"],"names":[],"mappings":""}

package/lib/flags/TtsxSubcommand.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The runner command identity used to select its accepted flag rows.
+ *
+ * @evidence contracts/common.md#principled-implementation The sole literal matches the current runner dispatcher and keeps runner-only flags distinct from compiler commands.
+ * @evidence contracts/common.md#clear-and-simple-design The alias supplies the identity required by the shared flag schema without implementing speculative runner subcommands.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The fixed ttsx spelling is the public command contract used by the parser's callers.
+ * @evidence contracts/common.md#meaningful-documentation The comment states the identity's selection role instead of promising future features, following the documentation skill's direct purpose-oriented prose.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This type declaration describes a data shape only; it opens no file, builds no path and branches on no platform.
+ */
+export type TtsxSubcommand = "ttsx";

package/lib/flags/TtsxSubcommand.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=TtsxSubcommand.js.map

package/lib/flags/TtsxSubcommand.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TtsxSubcommand.js","sourceRoot":"","sources":["../../src/flags/TtsxSubcommand.ts"],"names":[],"mappings":""}

package/lib/flags/ValueValidator.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Validation predicate for `value`-kind flags. `none` is the default (accept
+ * any string).
+ *
+ * @evidence contracts/common.md#principled-implementation The validator vocabulary distinguishes unrestricted strings from the native checkers option's positive decimal integer requirement; parseFlags owns the actual lexical and range validation.
+ * @evidence contracts/common.md#clear-and-simple-design A literal selector keeps validation choice declarative without carrying executable predicates in schema rows or duplicating parser logic.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts positiveInt represents the compiler's real minimum-value contract and does not encode expected test answers.
+ * @evidence contracts/common.md#meaningful-documentation The comment states the default's acceptance behavior; the declaration and parser documentation supply the numeric contract using the documentation skill's brief purpose-focused prose.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This type declaration describes a data shape only; it opens no file, builds no path and branches on no platform.
+ */
+export type ValueValidator = "none" | "positiveInt";

package/lib/flags/ValueValidator.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ValueValidator.js.map

package/lib/flags/ValueValidator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValueValidator.js","sourceRoot":"","sources":["../../src/flags/ValueValidator.ts"],"names":[],"mappings":""}

package/lib/flags/buildGoAllowList.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Allow-list map for the Go layer named `layer` (`"host"` or `"lint"`):
+ * flag-name (no leading dashes) → whether the flag takes a value token. The
+ * generator calls this adapter to emit literal native maps. The generated-file
+ * drift check re-runs that generator and compares the checked-out artifacts;
+ * agreement with the schema is distinct from validating native flag behavior.
+ *
+ * @evidence contracts/common.md#principled-implementation Consumer membership chooses the native lane, normalized canonical names and aliases form its keys, and value/valueOptional arity becomes the Go map's value-token boolean. Conflicting arity for one identity throws rather than choosing a declaration order.
+ * @evidence contracts/common.md#clear-and-simple-design This adapter derives the native representation from the shared schema and normalization function, keeping native allow-list ownership aligned with JavaScript flag identity.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The returned caller-owned map reflects declared host/lint CLI contracts; conflicting normalized entries remain explicit errors instead of silent consumer-specific overrides.
+ * @evidence contracts/common.md#meaningful-documentation The comment describes key grammar, value meaning and the relationship with generated native maps, following the documentation skill's representation and ownership guidance.
+ * @evidence contracts/performance.md#efficient-algorithms One schema traversal checks each row's finite consumer list and normalizes accepted canonical names and aliases. Work includes their text bytes, with expected constant-time indexed collision checks instead of pairwise comparison; returned key strings/entries grow with selected spellings, and each row's temporary spelling array grows with its aliases.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The adapter creates an independently mutable map for its caller and coordinates no completed or in-flight cross-request result.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The map's normalized key strings and boolean arity values transfer to its caller on return; the function keeps no historical entries or handles.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation The lane selects maintained schema data for text normalization; this operation opens no file, builds no native path and calls no platform or process API.
+ */
+export declare function buildGoAllowList(layer: "host" | "lint"): Map<string, boolean>;

package/lib/flags/buildGoAllowList.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGoAllowList = buildGoAllowList;
+const FLAG_SCHEMA_1 = require("./FLAG_SCHEMA");
+const normalizeFlagToken_1 = require("./normalizeFlagToken");
+/**
+ * Allow-list map for the Go layer named `layer` (`"host"` or `"lint"`):
+ * flag-name (no leading dashes) → whether the flag takes a value token. The
+ * generator calls this adapter to emit literal native maps. The generated-file
+ * drift check re-runs that generator and compares the checked-out artifacts;
+ * agreement with the schema is distinct from validating native flag behavior.
+ *
+ * @evidence contracts/common.md#principled-implementation Consumer membership chooses the native lane, normalized canonical names and aliases form its keys, and value/valueOptional arity becomes the Go map's value-token boolean. Conflicting arity for one identity throws rather than choosing a declaration order.
+ * @evidence contracts/common.md#clear-and-simple-design This adapter derives the native representation from the shared schema and normalization function, keeping native allow-list ownership aligned with JavaScript flag identity.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The returned caller-owned map reflects declared host/lint CLI contracts; conflicting normalized entries remain explicit errors instead of silent consumer-specific overrides.
+ * @evidence contracts/common.md#meaningful-documentation The comment describes key grammar, value meaning and the relationship with generated native maps, following the documentation skill's representation and ownership guidance.
+ * @evidence contracts/performance.md#efficient-algorithms One schema traversal checks each row's finite consumer list and normalizes accepted canonical names and aliases. Work includes their text bytes, with expected constant-time indexed collision checks instead of pairwise comparison; returned key strings/entries grow with selected spellings, and each row's temporary spelling array grows with its aliases.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The adapter creates an independently mutable map for its caller and coordinates no completed or in-flight cross-request result.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The map's normalized key strings and boolean arity values transfer to its caller on return; the function keeps no historical entries or handles.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation The lane selects maintained schema data for text normalization; this operation opens no file, builds no native path and calls no platform or process API.
+ */
+function buildGoAllowList(layer) {
+    const out = new Map();
+    for (const flag of FLAG_SCHEMA_1.FLAG_SCHEMA) {
+        if (!flag.consumedBy.includes(layer))
+            continue;
+        const takesValue = flag.kind === "value" || flag.kind === "valueOptional";
+        for (const name of [flag.name, ...(flag.aliases ?? [])]) {
+            // Keyed by the one normalization the runtime token lookup uses, so the
+            // generated allow-lists and `resolveFlagSpec` cannot recognise different
+            // spellings. The Go consumers apply the same normalization before the
+            // lookup (`strings.ToLower` on the dash-stripped name).
+            const key = (0, normalizeFlagToken_1.normalizeFlagToken)(name);
+            // A normalized identity must have one arity on the selected native lane.
+            const existing = out.get(key);
+            if (existing !== undefined && existing !== takesValue) {
+                throw new Error(`ttsc flag schema: conflicting Go allow-list entry for ${JSON.stringify(key)} on layer ${layer}`);
+            }
+            out.set(key, takesValue);
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=buildGoAllowList.js.map

package/lib/flags/buildGoAllowList.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildGoAllowList.js","sourceRoot":"","sources":["../../src/flags/buildGoAllowList.ts"],"names":[],"mappings":";;;AAAA,+CAA4C;AAC5C,6DAA0D;AAE1D;;;;;;;;;;;;;;;;GAgBG;AACH,0BAAiC,KAAsB;IACrD,MAAM,GAAG,GAAG,IAAI,GAAG,EAAmB,CAAC;IACvC,KAAK,MAAM,IAAI,IAAI,yBAAW,EAAE,CAAC;QAC/B,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,SAAS;QAC/C,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,KAAK,OAAO,IAAI,IAAI,CAAC,IAAI,KAAK,eAAe,CAAC;QAC1E,KAAK,MAAM,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC;YACxD,uEAAuE;YACvE,yEAAyE;YACzE,sEAAsE;YACtE,wDAAwD;YACxD,MAAM,GAAG,GAAG,IAAA,uCAAkB,EAAC,IAAI,CAAC,CAAC;YACrC,yEAAyE;YACzE,MAAM,QAAQ,GAAG,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAC9B,IAAI,QAAQ,KAAK,SAAS,IAAI,QAAQ,KAAK,UAAU,EAAE,CAAC;gBACtD,MAAM,IAAI,KAAK,CACb,yDAAyD,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,aAAa,KAAK,EAAE,CACjG,CAAC;YACJ,CAAC;YACD,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;QAC3B,CAAC;IACH,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/lib/flags/flagsForSubcommand.d.ts

@@ -0,0 +1,18 @@
+import type { AnySubcommand } from "./AnySubcommand";
+import type { FlagSpec } from "./FlagSpec";
+/**
+ * Return schema rows declared for the command, in schema order. Rows retain
+ * their aliases and consumer ownership; this function does not restrict the
+ * result to flags consumed by the JavaScript launcher.
+ *
+ * @evidence contracts/common.md#principled-implementation Array filtering selects exactly rows whose subcommands include the requested identity, preserving the schema order and original row objects.
+ * @evidence contracts/common.md#clear-and-simple-design This function owns command membership alone; parseFlags separately applies launcher ownership and expands aliases for token lookup.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Membership comes from FlagSpec rather than separate command-specific option lists that could drift from forwarding policy.
+ * @evidence contracts/common.md#meaningful-documentation The native comment correctly describes schema rows rather than tokens and explains the consumer-selection boundary, applying the documentation skill's precise responsibility guidance.
+ * @evidence contracts/performance.md#efficient-algorithms Filtering F fixed schema rows checks each row's small command list and allocates only matching rows. The scan preserves declaration order, and parseFlags reuses its derived acceptance index rather than repeating this scan for every invocation.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This selector returns an independent mutable array and owns no request coordinator; parseFlags owns reuse of the derived immutable acceptance index.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Matching row references are returned to the caller in a fresh array; no historical result or external resource is retained by this selector.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation flagsForSubcommand computes from its arguments only; it opens no file, builds no path and calls no platform or process API.
+ */
+export declare function flagsForSubcommand(subcommand: AnySubcommand): FlagSpec[];

package/lib/flags/flagsForSubcommand.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flagsForSubcommand = flagsForSubcommand;
+const FLAG_SCHEMA_1 = require("./FLAG_SCHEMA");
+/**
+ * Return schema rows declared for the command, in schema order. Rows retain
+ * their aliases and consumer ownership; this function does not restrict the
+ * result to flags consumed by the JavaScript launcher.
+ *
+ * @evidence contracts/common.md#principled-implementation Array filtering selects exactly rows whose subcommands include the requested identity, preserving the schema order and original row objects.
+ * @evidence contracts/common.md#clear-and-simple-design This function owns command membership alone; parseFlags separately applies launcher ownership and expands aliases for token lookup.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Membership comes from FlagSpec rather than separate command-specific option lists that could drift from forwarding policy.
+ * @evidence contracts/common.md#meaningful-documentation The native comment correctly describes schema rows rather than tokens and explains the consumer-selection boundary, applying the documentation skill's precise responsibility guidance.
+ * @evidence contracts/performance.md#efficient-algorithms Filtering F fixed schema rows checks each row's small command list and allocates only matching rows. The scan preserves declaration order, and parseFlags reuses its derived acceptance index rather than repeating this scan for every invocation.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This selector returns an independent mutable array and owns no request coordinator; parseFlags owns reuse of the derived immutable acceptance index.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Matching row references are returned to the caller in a fresh array; no historical result or external resource is retained by this selector.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation flagsForSubcommand computes from its arguments only; it opens no file, builds no path and calls no platform or process API.
+ */
+function flagsForSubcommand(subcommand) {
+    return FLAG_SCHEMA_1.FLAG_SCHEMA.filter((flag) => flag.subcommands.includes(subcommand));
+}
+//# sourceMappingURL=flagsForSubcommand.js.map

package/lib/flags/flagsForSubcommand.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flagsForSubcommand.js","sourceRoot":"","sources":["../../src/flags/flagsForSubcommand.ts"],"names":[],"mappings":";;;AACA,+CAA4C;AAG5C;;;;;;;;;;;;;;GAcG;AACH,4BAAmC,UAAyB;IAC1D,OAAO,yBAAW,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC;AAC7E,CAAC"}

package/lib/flags/getBoolean.d.ts

@@ -0,0 +1,19 @@
+import type { ParseResult } from "./ParseResult";
+/**
+ * Return a canonical flag's stored boolean value. Absence or a differently
+ * typed entry returns `undefined`; `false` remains a present value.
+ *
+ * One of the typed accessors over {@link ParseResult}: the parser stores raw
+ * values (`string | boolean | number`) so the engine stays untyped, and each
+ * caller picks the shape per flag.
+ *
+ * @evidence contracts/common.md#principled-implementation A typeof boolean guard narrows the canonical map entry without coercion; absence and a differently typed value both return undefined, while false remains a present value.
+ * @evidence contracts/common.md#clear-and-simple-design The accessor performs only the requested runtime narrowing, leaving flag identity and parsing policy with their existing owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No truthiness conversion substitutes for the stored value, so a false flag cannot silently become missing or true.
+ * @evidence contracts/common.md#meaningful-documentation The comment explains the typed accessor's place over ParseResult and its absent result, using a separate context paragraph as the documentation skill requires.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This lookup returns a scalar without retaining the caller's map or acquiring a handle, task or historical state.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms One existing-map lookup and a typeof guard perform scalar access; map storage and parsing algorithms remain with their owners.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Scalar access coordinates no completed or in-flight producer work and keeps no cached result.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation The canonical flag token is a map key, not a native path; inspecting its stored value uses no filesystem, process or platform capability.
+ */
+export declare function getBoolean(result: ParseResult, flag: string): boolean | undefined;

package/lib/flags/getBoolean.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBoolean = getBoolean;
+/**
+ * Return a canonical flag's stored boolean value. Absence or a differently
+ * typed entry returns `undefined`; `false` remains a present value.
+ *
+ * One of the typed accessors over {@link ParseResult}: the parser stores raw
+ * values (`string | boolean | number`) so the engine stays untyped, and each
+ * caller picks the shape per flag.
+ *
+ * @evidence contracts/common.md#principled-implementation A typeof boolean guard narrows the canonical map entry without coercion; absence and a differently typed value both return undefined, while false remains a present value.
+ * @evidence contracts/common.md#clear-and-simple-design The accessor performs only the requested runtime narrowing, leaving flag identity and parsing policy with their existing owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No truthiness conversion substitutes for the stored value, so a false flag cannot silently become missing or true.
+ * @evidence contracts/common.md#meaningful-documentation The comment explains the typed accessor's place over ParseResult and its absent result, using a separate context paragraph as the documentation skill requires.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This lookup returns a scalar without retaining the caller's map or acquiring a handle, task or historical state.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms One existing-map lookup and a typeof guard perform scalar access; map storage and parsing algorithms remain with their owners.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Scalar access coordinates no completed or in-flight producer work and keeps no cached result.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation The canonical flag token is a map key, not a native path; inspecting its stored value uses no filesystem, process or platform capability.
+ */
+function getBoolean(result, flag) {
+    const value = result.values.get(flag);
+    if (typeof value === "boolean")
+        return value;
+    return undefined;
+}
+//# sourceMappingURL=getBoolean.js.map

package/lib/flags/getBoolean.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getBoolean.js","sourceRoot":"","sources":["../../src/flags/getBoolean.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,oBACE,MAAmB,EACnB,IAAY;IAEZ,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACtC,IAAI,OAAO,KAAK,KAAK,SAAS;QAAE,OAAO,KAAK,CAAC;IAC7C,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/lib/flags/getNumber.d.ts

@@ -0,0 +1,16 @@
+import type { ParseResult } from "./ParseResult";
+/**
+ * Return the stored numeric value of a canonical flag name. Absence or a
+ * differently typed entry returns `undefined`; this accessor does not parse
+ * strings or impose a numeric range.
+ *
+ * @evidence contracts/common.md#principled-implementation typeof number retrieves exactly a numeric map entry without converting other parser values; numeric validation remains with the flag's parser rather than the accessor.
+ * @evidence contracts/common.md#clear-and-simple-design One lookup and narrowing expose the value, with no duplicated validator or fallback policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts String coercion cannot turn a differently typed option into a number, and legitimate zero is returned unchanged.
+ * @evidence contracts/common.md#meaningful-documentation The native comment states canonical-name input, undefined behavior and the lack of coercion or range validation, applying the documentation skill's contract-focused prose.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The numeric scalar transfers to the caller without retaining its map or acquiring native resources.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms One existing-map lookup and numeric type guard perform scalar access; lexical numeric parsing and range validation belong to the flag parser.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This accessor coordinates no numeric parser or other producer and retains no computed answer between calls.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation A canonical option key and stored JavaScript number carry no native path, executable, environment or OS capability here.
+ */
+export declare function getNumber(result: ParseResult, flag: string): number | undefined;

package/lib/flags/getNumber.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNumber = getNumber;
+/**
+ * Return the stored numeric value of a canonical flag name. Absence or a
+ * differently typed entry returns `undefined`; this accessor does not parse
+ * strings or impose a numeric range.
+ *
+ * @evidence contracts/common.md#principled-implementation typeof number retrieves exactly a numeric map entry without converting other parser values; numeric validation remains with the flag's parser rather than the accessor.
+ * @evidence contracts/common.md#clear-and-simple-design One lookup and narrowing expose the value, with no duplicated validator or fallback policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts String coercion cannot turn a differently typed option into a number, and legitimate zero is returned unchanged.
+ * @evidence contracts/common.md#meaningful-documentation The native comment states canonical-name input, undefined behavior and the lack of coercion or range validation, applying the documentation skill's contract-focused prose.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The numeric scalar transfers to the caller without retaining its map or acquiring native resources.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms One existing-map lookup and numeric type guard perform scalar access; lexical numeric parsing and range validation belong to the flag parser.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This accessor coordinates no numeric parser or other producer and retains no computed answer between calls.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation A canonical option key and stored JavaScript number carry no native path, executable, environment or OS capability here.
+ */
+function getNumber(result, flag) {
+    const value = result.values.get(flag);
+    if (typeof value === "number")
+        return value;
+    return undefined;
+}
+//# sourceMappingURL=getNumber.js.map

package/lib/flags/getNumber.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getNumber.js","sourceRoot":"","sources":["../../src/flags/getNumber.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;GAaG;AACH,mBACE,MAAmB,EACnB,IAAY;IAEZ,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACtC,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC5C,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/lib/flags/getString.d.ts

@@ -0,0 +1,16 @@
+import type { ParseResult } from "./ParseResult";
+/**
+ * Return the stored string value of a canonical flag name. Absence or a
+ * differently typed entry returns `undefined`; an empty string remains a
+ * present value.
+ *
+ * @evidence contracts/common.md#principled-implementation The typeof string guard preserves string values, including the empty string, and distinguishes them from missing or numeric/boolean entries without coercion.
+ * @evidence contracts/common.md#clear-and-simple-design This accessor isolates one runtime narrowing while ParseResult and parseFlags retain storage and parsing responsibilities.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts It returns the stored string directly instead of fabricating a default or stringifying another option type.
+ * @evidence contracts/common.md#meaningful-documentation The native comment makes absence and empty-string meaning explicit, following the documentation skill's useful optional-state guidance.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The stored string is returned without copying its bytes or retaining the result map; native resource lifetime is not owned here.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms A map lookup and string type guard select one scalar; flag parsing and any later path or executable selection are separate operations.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Returning an existing scalar does not coordinate a shared producer or preserve a cross-call answer.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This accessor does not interpret the string as a native path or executable; the option consumer owns that meaning and its platform boundary.
+ */
+export declare function getString(result: ParseResult, flag: string): string | undefined;

package/lib/flags/getString.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getString = getString;
+/**
+ * Return the stored string value of a canonical flag name. Absence or a
+ * differently typed entry returns `undefined`; an empty string remains a
+ * present value.
+ *
+ * @evidence contracts/common.md#principled-implementation The typeof string guard preserves string values, including the empty string, and distinguishes them from missing or numeric/boolean entries without coercion.
+ * @evidence contracts/common.md#clear-and-simple-design This accessor isolates one runtime narrowing while ParseResult and parseFlags retain storage and parsing responsibilities.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts It returns the stored string directly instead of fabricating a default or stringifying another option type.
+ * @evidence contracts/common.md#meaningful-documentation The native comment makes absence and empty-string meaning explicit, following the documentation skill's useful optional-state guidance.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The stored string is returned without copying its bytes or retaining the result map; native resource lifetime is not owned here.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms A map lookup and string type guard select one scalar; flag parsing and any later path or executable selection are separate operations.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Returning an existing scalar does not coordinate a shared producer or preserve a cross-call answer.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This accessor does not interpret the string as a native path or executable; the option consumer owns that meaning and its platform boundary.
+ */
+function getString(result, flag) {
+    const value = result.values.get(flag);
+    if (typeof value === "string")
+        return value;
+    return undefined;
+}
+//# sourceMappingURL=getString.js.map

package/lib/flags/getString.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getString.js","sourceRoot":"","sources":["../../src/flags/getString.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;GAaG;AACH,mBACE,MAAmB,EACnB,IAAY;IAEZ,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACtC,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC5C,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/lib/flags/getStringList.d.ts

@@ -0,0 +1,19 @@
+import type { ParseResult } from "./ParseResult";
+/**
+ * Return every string value accepted for a `repeatable` flag, in argv order.
+ *
+ * `values` keeps only the last occurrence, which is the wrong answer for a flag
+ * whose whole point is repetition (`ttsx -r a -r b` preloads both). Returns an
+ * empty array when the flag never appeared.
+ *
+ * @evidence contracts/common.md#principled-implementation Filtering the ordered repeated-value list with a typeof string predicate preserves the order and multiplicity of string occurrences while excluding incompatible value kinds.
+ * @evidence contracts/common.md#clear-and-simple-design The accessor consumes the parser's dedicated repetition record rather than reparsing argv or reconstructing occurrences from the last-value map.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Repetition is a declared flag contract; the accessor neither deduplicates preloads nor substitutes fixture-specific ordering.
+ * @evidence contracts/common.md#meaningful-documentation The comment explains why values is insufficient and what absence returns, with separate purpose and rationale paragraphs following the documentation skill.
+ * @evidence contracts/performance.md#efficient-algorithms Filtering R repeated entries costs O(R) time and at most O(R) returned storage; one traversal performs both narrowing and collection without reparsing argv or scanning unrelated flags.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This accessor receives caller-owned ParseResult values and produces an independently mutable array; it coordinates no stable producer identity or cross-request computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The newly allocated array transfers to the caller on return; the accessor owns no retained table, handle or task beyond the invocation.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation getStringList computes from its arguments only; it opens no file, builds no path and calls no platform or process API.
+ */
+export declare function getStringList(result: ParseResult, flag: string): string[];

package/lib/flags/getStringList.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStringList = getStringList;
+/**
+ * Return every string value accepted for a `repeatable` flag, in argv order.
+ *
+ * `values` keeps only the last occurrence, which is the wrong answer for a flag
+ * whose whole point is repetition (`ttsx -r a -r b` preloads both). Returns an
+ * empty array when the flag never appeared.
+ *
+ * @evidence contracts/common.md#principled-implementation Filtering the ordered repeated-value list with a typeof string predicate preserves the order and multiplicity of string occurrences while excluding incompatible value kinds.
+ * @evidence contracts/common.md#clear-and-simple-design The accessor consumes the parser's dedicated repetition record rather than reparsing argv or reconstructing occurrences from the last-value map.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Repetition is a declared flag contract; the accessor neither deduplicates preloads nor substitutes fixture-specific ordering.
+ * @evidence contracts/common.md#meaningful-documentation The comment explains why values is insufficient and what absence returns, with separate purpose and rationale paragraphs following the documentation skill.
+ * @evidence contracts/performance.md#efficient-algorithms Filtering R repeated entries costs O(R) time and at most O(R) returned storage; one traversal performs both narrowing and collection without reparsing argv or scanning unrelated flags.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This accessor receives caller-owned ParseResult values and produces an independently mutable array; it coordinates no stable producer identity or cross-request computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The newly allocated array transfers to the caller on return; the accessor owns no retained table, handle or task beyond the invocation.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation getStringList computes from its arguments only; it opens no file, builds no path and calls no platform or process API.
+ */
+function getStringList(result, flag) {
+    return (result.repeated.get(flag) ?? []).filter((value) => typeof value === "string");
+}
+//# sourceMappingURL=getStringList.js.map

package/lib/flags/getStringList.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getStringList.js","sourceRoot":"","sources":["../../src/flags/getStringList.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,uBAA8B,MAAmB,EAAE,IAAY;IAC7D,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAC7C,CAAC,KAAK,EAAmB,EAAE,CAAC,OAAO,KAAK,KAAK,QAAQ,CACtD,CAAC;AACJ,CAAC"}

package/lib/flags/normalizeCompilerEnumValue.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Normalize an enum discriminant at the boundary that supplied it.
+ *
+ * Native command-line enum parsing trims IsWhiteSpaceLike before lookup; JSON
+ * enum parsing does not trim. Both use Unicode simple lowercase. Generated
+ * folds into the pinned compiler's ASCII enum domain preserve the native
+ * spelling where JavaScript lowercase expands a character instead. Dashes
+ * remain value data, and an empty discriminant represents the native reset.
+ * This projection does not validate membership in an option's enum map.
+ *
+ * @evidence contracts/common.md#principled-implementation CLI-only trimming follows the generated native IsWhiteSpaceLike table; both origins use generated simple folds before lowercase, preserve leading dashes and distinguish an empty reset from a padded JSON value.
+ * @evidence contracts/common.md#clear-and-simple-design One pure boundary normalizer separates enum data from option-name normalization and makes CLI versus JSON origin explicit.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Enum membership and invalid-value diagnostics remain native-owned; the adapter does not strip a value's dash or trim JSON to admit an invalid spelling.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains origin-specific trimming, Unicode folding, the reset outcome and the projection's validation boundary.
+ * @evidence contracts/performance.md#efficient-algorithms CLI boundary scans, Unicode fold replacement and lowercase conversion are linear in token length, using immutable generated lookup tables instead of scanning declarations. Intermediate slices/replacements and the returned string grow with that token; JSON skips boundary trimming.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each token belongs to its caller's current option origin; immutable native tables are module-shared, and no invocation or historical value cache is retained.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only the normalized string is returned; transient string slices and replacements create no resource or retained history.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This origin-specific Unicode string transformation interprets no filesystem path or process capability; generated native whitespace/fold policy is module data, and callers own any native compiler validation.
+ */
+export declare function normalizeCompilerEnumValue(value: string, origin: "cli" | "json"): string | null;

package/lib/flags/normalizeCompilerEnumValue.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeCompilerEnumValue = normalizeCompilerEnumValue;
+const COMPILER_ENUM_WHITESPACE_1 = require("./COMPILER_ENUM_WHITESPACE");
+const COMPILER_OPTION_ASCII_FOLDS_1 = require("./COMPILER_OPTION_ASCII_FOLDS");
+/**
+ * Normalize an enum discriminant at the boundary that supplied it.
+ *
+ * Native command-line enum parsing trims IsWhiteSpaceLike before lookup; JSON
+ * enum parsing does not trim. Both use Unicode simple lowercase. Generated
+ * folds into the pinned compiler's ASCII enum domain preserve the native
+ * spelling where JavaScript lowercase expands a character instead. Dashes
+ * remain value data, and an empty discriminant represents the native reset.
+ * This projection does not validate membership in an option's enum map.
+ *
+ * @evidence contracts/common.md#principled-implementation CLI-only trimming follows the generated native IsWhiteSpaceLike table; both origins use generated simple folds before lowercase, preserve leading dashes and distinguish an empty reset from a padded JSON value.
+ * @evidence contracts/common.md#clear-and-simple-design One pure boundary normalizer separates enum data from option-name normalization and makes CLI versus JSON origin explicit.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Enum membership and invalid-value diagnostics remain native-owned; the adapter does not strip a value's dash or trim JSON to admit an invalid spelling.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains origin-specific trimming, Unicode folding, the reset outcome and the projection's validation boundary.
+ * @evidence contracts/performance.md#efficient-algorithms CLI boundary scans, Unicode fold replacement and lowercase conversion are linear in token length, using immutable generated lookup tables instead of scanning declarations. Intermediate slices/replacements and the returned string grow with that token; JSON skips boundary trimming.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each token belongs to its caller's current option origin; immutable native tables are module-shared, and no invocation or historical value cache is retained.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only the normalized string is returned; transient string slices and replacements create no resource or retained history.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This origin-specific Unicode string transformation interprets no filesystem path or process capability; generated native whitespace/fold policy is module data, and callers own any native compiler validation.
+ */
+function normalizeCompilerEnumValue(value, origin) {
+    let start = 0;
+    let end = value.length;
+    if (origin === "cli") {
+        while (start < end && COMPILER_ENUM_WHITESPACE_1.COMPILER_ENUM_WHITESPACE.has(value[start]))
+            start++;
+        while (end > start && COMPILER_ENUM_WHITESPACE_1.COMPILER_ENUM_WHITESPACE.has(value[end - 1]))
+            end--;
+    }
+    const normalized = value
+        .slice(start, end)
+        .replace(/[^\x00-\x7f]/gu, (character) => COMPILER_OPTION_ASCII_FOLDS_1.COMPILER_OPTION_ASCII_FOLDS.get(character) ?? character)
+        .toLowerCase();
+    return normalized === "" ? null : normalized;
+}
+//# sourceMappingURL=normalizeCompilerEnumValue.js.map

package/lib/flags/normalizeCompilerEnumValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeCompilerEnumValue.js","sourceRoot":"","sources":["../../src/flags/normalizeCompilerEnumValue.ts"],"names":[],"mappings":";;;AAAA,yEAAsE;AACtE,+EAA4E;AAE5E;;;;;;;;;;;;;;;;;;GAkBG;AACH,oCACE,KAAa,EACb,MAAsB;IAEtB,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,GAAG,GAAG,KAAK,CAAC,MAAM,CAAC;IACvB,IAAI,MAAM,KAAK,KAAK,EAAE,CAAC;QACrB,OAAO,KAAK,GAAG,GAAG,IAAI,mDAAwB,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAE,CAAC;YAAE,KAAK,EAAE,CAAC;QAC3E,OAAO,GAAG,GAAG,KAAK,IAAI,mDAAwB,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAE,CAAC;YAAE,GAAG,EAAE,CAAC;IAC7E,CAAC;IACD,MAAM,UAAU,GAAG,KAAK;SACrB,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC;SACjB,OAAO,CACN,gBAAgB,EAChB,CAAC,SAAS,EAAE,EAAE,CAAC,yDAA2B,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,SAAS,CACvE;SACA,WAAW,EAAE,CAAC;IACjB,OAAO,UAAU,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC;AAC/C,CAAC"}

package/lib/flags/normalizeFlagToken.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Normalize a CLI token to the identity the compiler ttsc wraps resolves it by:
+ * one or two leading dashes removed, the remainder lower-cased.
+ *
+ * The native compiler strips a `--` or `-` prefix and uses Unicode simple
+ * lowercase mappings. Generated folds into its ASCII option-name domain
+ * preserve mappings that JavaScript lowercase expands differently. Thus
+ * `--noEmit`, `--noemit`, `--NOEMIT`, and `-noEmit` all name the same option to
+ * the tool ttsc forwards to. Keying the index on the exact spelling would let a
+ * case variant of a ttsc-owned flag fall through the unknown-flag escape hatch:
+ * tsgo would honour it while every ttsc-side consumer of the same flag never
+ * fired, with no diagnostic.
+ *
+ * This is the single normalization. Everything that resolves a token against
+ * `FLAG_SCHEMA` — the parsing engine, the terminal / shadow / project-free
+ * classifications, and the generated Go allow-lists — keys off this function,
+ * so no two layers can disagree about which flag a spelling names.
+ *
+ * @evidence contracts/common.md#principled-implementation Removing at most two leading dashes and applying generated native Unicode folds before lowercase matches the verified ASCII option-name domain; generation rejects native or launcher names outside that domain. Callers separate an inline value before normalization because its case is data.
+ * @evidence contracts/common.md#clear-and-simple-design The shared normalization function owns spelling identity for parsing, lookup and native allow-list derivation rather than duplicating that policy in each consumer.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The regex expresses the supported dash grammar and preserves any further prefix characters; it does not recognize particular project arguments or alter the native option parser.
+ * @evidence contracts/common.md#meaningful-documentation The comment explains accepted casing and dash variants plus the shared identity boundary, following the documentation skill's explanation-of-reasons guidance.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Returns a new string and retains nothing.
+ * @evidence contracts/performance.md#efficient-algorithms Anchored prefix removal, a Unicode fold replacement and one lowercase pass process token text in linear time; non-ASCII characters use the module-built fold index rather than a scan of native declarations. Intermediate and returned strings grow with token length, and no invocation-specific index is rebuilt.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This invocation-local spelling transformation does not coordinate completed or in-flight work across requests; the generated native fold table is already shared by module identity.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation normalizeFlagToken computes from its arguments only; it opens no file, builds no path and calls no platform or process API.
+ */
+export declare function normalizeFlagToken(token: string): string;

package/lib/flags/normalizeFlagToken.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeFlagToken = normalizeFlagToken;
+const COMPILER_OPTION_ASCII_FOLDS_1 = require("./COMPILER_OPTION_ASCII_FOLDS");
+/**
+ * Normalize a CLI token to the identity the compiler ttsc wraps resolves it by:
+ * one or two leading dashes removed, the remainder lower-cased.
+ *
+ * The native compiler strips a `--` or `-` prefix and uses Unicode simple
+ * lowercase mappings. Generated folds into its ASCII option-name domain
+ * preserve mappings that JavaScript lowercase expands differently. Thus
+ * `--noEmit`, `--noemit`, `--NOEMIT`, and `-noEmit` all name the same option to
+ * the tool ttsc forwards to. Keying the index on the exact spelling would let a
+ * case variant of a ttsc-owned flag fall through the unknown-flag escape hatch:
+ * tsgo would honour it while every ttsc-side consumer of the same flag never
+ * fired, with no diagnostic.
+ *
+ * This is the single normalization. Everything that resolves a token against
+ * `FLAG_SCHEMA` — the parsing engine, the terminal / shadow / project-free
+ * classifications, and the generated Go allow-lists — keys off this function,
+ * so no two layers can disagree about which flag a spelling names.
+ *
+ * @evidence contracts/common.md#principled-implementation Removing at most two leading dashes and applying generated native Unicode folds before lowercase matches the verified ASCII option-name domain; generation rejects native or launcher names outside that domain. Callers separate an inline value before normalization because its case is data.
+ * @evidence contracts/common.md#clear-and-simple-design The shared normalization function owns spelling identity for parsing, lookup and native allow-list derivation rather than duplicating that policy in each consumer.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The regex expresses the supported dash grammar and preserves any further prefix characters; it does not recognize particular project arguments or alter the native option parser.
+ * @evidence contracts/common.md#meaningful-documentation The comment explains accepted casing and dash variants plus the shared identity boundary, following the documentation skill's explanation-of-reasons guidance.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Returns a new string and retains nothing.
+ * @evidence contracts/performance.md#efficient-algorithms Anchored prefix removal, a Unicode fold replacement and one lowercase pass process token text in linear time; non-ASCII characters use the module-built fold index rather than a scan of native declarations. Intermediate and returned strings grow with token length, and no invocation-specific index is rebuilt.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This invocation-local spelling transformation does not coordinate completed or in-flight work across requests; the generated native fold table is already shared by module identity.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation normalizeFlagToken computes from its arguments only; it opens no file, builds no path and calls no platform or process API.
+ */
+function normalizeFlagToken(token) {
+    return token
+        .replace(/^--?/, "")
+        .replace(/[^\x00-\x7f]/gu, (character) => COMPILER_OPTION_ASCII_FOLDS_1.COMPILER_OPTION_ASCII_FOLDS.get(character) ?? character)
+        .toLowerCase();
+}
+//# sourceMappingURL=normalizeFlagToken.js.map

package/lib/flags/normalizeFlagToken.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeFlagToken.js","sourceRoot":"","sources":["../../src/flags/normalizeFlagToken.ts"],"names":[],"mappings":";;;AAAA,+EAA4E;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,4BAAmC,KAAa;IAC9C,OAAO,KAAK;SACT,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;SACnB,OAAO,CACN,gBAAgB,EAChB,CAAC,SAAS,EAAE,EAAE,CAAC,yDAA2B,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,SAAS,CACvE;SACA,WAAW,EAAE,CAAC;AACnB,CAAC"}