ttsc 0.30.4 → 0.31.0

package/lib/launcher/internal/linkVirtualEntry.d.ts

@@ -0,0 +1,31 @@
+import fs from "node:fs";
+/**
+ * Mirror one directory entry of the project into ttsx's virtual layout.
+ *
+ * Directories become junctions on Windows and symlinks elsewhere; files are
+ * hard-linked, or copied when hard-link creation fails. On Windows a symbolic
+ * link whose target is observed as a directory becomes a junction. Other
+ * entries get a symlink to the original entry path, rather than a copy of its
+ * readlink text. If that creation fails on any host, an existsSync false result
+ * skips the entry; otherwise a hard-link attempt falls back to copying on
+ * failure. A dangling target can therefore be mirrored successfully or skipped
+ * after a failed symlink attempt. Failure alone does not identify a privilege
+ * error.
+ *
+ * The launcher enumerates source entries and avoids known existing virtual
+ * entries before calling this operation. That is not an atomic destination
+ * reservation: a racing or direct caller can reach the copy fallback with an
+ * existing destination. Native copy defaults can replace its bytes. The runtime
+ * generation owner controls destination lifetime and cleanup; this operation
+ * retains no open descriptor or cleanup handle after returning.
+ *
+ * @evidence contracts/common.md#principled-implementation The entry kind selects a directory link, file hard-link/copy or symlink route; a missing target cannot be materialized by the file-copy fallback.
+ * @evidence contracts/common.md#clear-and-simple-design One mirror operation owns link creation and its native fallback; the private target-kind helper only resolves directory symlinks.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Windows directory targets select junctions directly; hard-link and final symlink failures trigger the documented native fallbacks without errno attribution. No test identity changes production behavior, and copy/skip outcomes retain their documented ownership and failure limits.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain link-to-original-path representation, failure-driven copy/absence behavior, destination replacement and caller-owned lifetime, with acknowledgment tags separated from that explanation.
+ * @evidence contracts/portability.md#os-neutral-implementation Node filesystem APIs represent actual link/copy capabilities; Windows junction selection is explicit, while failed hard-link/symlink operations determine the fallback rather than guessed volume policy.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Synchronous native operations leave no retained descriptor or in-memory entry history. Created links/files persist until the caller removes the virtual generation; copying can allocate the full target contents, with no byte quota at this boundary.
+ * @evidence contracts/performance.md#efficient-algorithms One entry selects a fixed number of native link/stat/existence attempts, without recursive directory enumeration. Copy fallback performs content-sized native work; path/target lookup and payload sizes are not capped by the entry count.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This operation establishes a caller-owned destination rather than coordinating an equivalent producer or caching native capability/target observations. Different destinations require their own materialization and current native failures select the fallback.
+ */
+export declare function linkVirtualEntry(realEntry: string, virtualEntry: string, entry: fs.Dirent): void;

package/lib/launcher/internal/linkVirtualEntry.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linkVirtualEntry = linkVirtualEntry;
+const node_fs_1 = __importDefault(require("node:fs"));
+/**
+ * Mirror one directory entry of the project into ttsx's virtual layout.
+ *
+ * Directories become junctions on Windows and symlinks elsewhere; files are
+ * hard-linked, or copied when hard-link creation fails. On Windows a symbolic
+ * link whose target is observed as a directory becomes a junction. Other
+ * entries get a symlink to the original entry path, rather than a copy of its
+ * readlink text. If that creation fails on any host, an existsSync false result
+ * skips the entry; otherwise a hard-link attempt falls back to copying on
+ * failure. A dangling target can therefore be mirrored successfully or skipped
+ * after a failed symlink attempt. Failure alone does not identify a privilege
+ * error.
+ *
+ * The launcher enumerates source entries and avoids known existing virtual
+ * entries before calling this operation. That is not an atomic destination
+ * reservation: a racing or direct caller can reach the copy fallback with an
+ * existing destination. Native copy defaults can replace its bytes. The runtime
+ * generation owner controls destination lifetime and cleanup; this operation
+ * retains no open descriptor or cleanup handle after returning.
+ *
+ * @evidence contracts/common.md#principled-implementation The entry kind selects a directory link, file hard-link/copy or symlink route; a missing target cannot be materialized by the file-copy fallback.
+ * @evidence contracts/common.md#clear-and-simple-design One mirror operation owns link creation and its native fallback; the private target-kind helper only resolves directory symlinks.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Windows directory targets select junctions directly; hard-link and final symlink failures trigger the documented native fallbacks without errno attribution. No test identity changes production behavior, and copy/skip outcomes retain their documented ownership and failure limits.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain link-to-original-path representation, failure-driven copy/absence behavior, destination replacement and caller-owned lifetime, with acknowledgment tags separated from that explanation.
+ * @evidence contracts/portability.md#os-neutral-implementation Node filesystem APIs represent actual link/copy capabilities; Windows junction selection is explicit, while failed hard-link/symlink operations determine the fallback rather than guessed volume policy.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Synchronous native operations leave no retained descriptor or in-memory entry history. Created links/files persist until the caller removes the virtual generation; copying can allocate the full target contents, with no byte quota at this boundary.
+ * @evidence contracts/performance.md#efficient-algorithms One entry selects a fixed number of native link/stat/existence attempts, without recursive directory enumeration. Copy fallback performs content-sized native work; path/target lookup and payload sizes are not capped by the entry count.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This operation establishes a caller-owned destination rather than coordinating an equivalent producer or caching native capability/target observations. Different destinations require their own materialization and current native failures select the fallback.
+ */
+function linkVirtualEntry(realEntry, virtualEntry, entry) {
+    if (entry.isDirectory()) {
+        // Use junction points on Windows; plain symlinks elsewhere.
+        node_fs_1.default.symlinkSync(realEntry, virtualEntry, process.platform === "win32" ? "junction" : undefined);
+        return;
+    }
+    if (entry.isFile()) {
+        try {
+            // Hard-link first: cheap, preserves inode, no extra disk usage.
+            node_fs_1.default.linkSync(realEntry, virtualEntry);
+        }
+        catch {
+            // Cross-device or unsupported filesystem: fall back to a full copy.
+            node_fs_1.default.copyFileSync(realEntry, virtualEntry);
+        }
+        return;
+    }
+    if (process.platform === "win32" &&
+        entry.isSymbolicLink() &&
+        isDirectorySymlinkTarget(realEntry)) {
+        node_fs_1.default.symlinkSync(realEntry, virtualEntry, "junction");
+        return;
+    }
+    // Link to the original entry path, including for symlinks and special entries.
+    // Windows file-link privilege restrictions motivated the fallback, but any
+    // creation error reaches it on every host. Only after that failure does an
+    // existsSync false result skip the entry; otherwise attempt hard-link/copy.
+    try {
+        node_fs_1.default.symlinkSync(realEntry, virtualEntry);
+    }
+    catch {
+        if (!node_fs_1.default.existsSync(realEntry)) {
+            return;
+        }
+        try {
+            node_fs_1.default.linkSync(realEntry, virtualEntry);
+        }
+        catch {
+            node_fs_1.default.copyFileSync(realEntry, virtualEntry);
+        }
+    }
+}
+function isDirectorySymlinkTarget(realEntry) {
+    try {
+        return node_fs_1.default.statSync(realEntry).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=linkVirtualEntry.js.map

package/lib/launcher/internal/linkVirtualEntry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"linkVirtualEntry.js","sourceRoot":"","sources":["../../../src/launcher/internal/linkVirtualEntry.ts"],"names":[],"mappings":";;;;;;AAAA,sDAAyB;AAEzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,0BACE,SAAiB,EACjB,YAAoB,EACpB,KAAgB;IAEhB,IAAI,KAAK,CAAC,WAAW,EAAE,EAAE,CAAC;QACxB,4DAA4D;QAC5D,iBAAE,CAAC,WAAW,CACZ,SAAS,EACT,YAAY,EACZ,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CACtD,CAAC;QACF,OAAO;IACT,CAAC;IACD,IAAI,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;QACnB,IAAI,CAAC;YACH,gEAAgE;YAChE,iBAAE,CAAC,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;QACvC,CAAC;QAAC,MAAM,CAAC;YACP,oEAAoE;YACpE,iBAAE,CAAC,YAAY,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;QAC3C,CAAC;QACD,OAAO;IACT,CAAC;IACD,IACE,OAAO,CAAC,QAAQ,KAAK,OAAO;QAC5B,KAAK,CAAC,cAAc,EAAE;QACtB,wBAAwB,CAAC,SAAS,CAAC,EACnC,CAAC;QACD,iBAAE,CAAC,WAAW,CAAC,SAAS,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;QACpD,OAAO;IACT,CAAC;IACD,+EAA+E;IAC/E,2EAA2E;IAC3E,2EAA2E;IAC3E,4EAA4E;IAC5E,IAAI,CAAC;QACH,iBAAE,CAAC,WAAW,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;IAC1C,CAAC;IAAC,MAAM,CAAC;QACP,IAAI,CAAC,iBAAE,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC;YAC9B,OAAO;QACT,CAAC;QACD,IAAI,CAAC;YACH,iBAAE,CAAC,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;QACvC,CAAC;QAAC,MAAM,CAAC;YACP,iBAAE,CAAC,YAAY,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;QAC3C,CAAC;IACH,CAAC;AACH,CAAC;AAED,SAAS,wBAAwB,CAAC,SAAiB;IACjD,IAAI,CAAC;QACH,OAAO,iBAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,CAAC;IAC9C,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC"}

package/lib/launcher/internal/parseCommonJsExports.d.ts

@@ -0,0 +1,17 @@
+import { parse as parseCommonJs } from "cjs-module-lexer";
+/**
+ * CommonJS lexer metadata plus the scoped star helpers ttsx already supports.
+ * Base lexer patterns can omit helpers inside blocks and functions. An AST
+ * supplies those calls without interpreting regex or template text as code.
+ *
+ * @evidence contracts/common.md#principled-implementation The maintained cjs-module-lexer metadata remains the base, while Acorn node kinds identify supported literal require/export-star shapes without treating comments or string contents as code; this is metadata discovery, not evaluation or lexical binding analysis.
+ * @evidence contracts/common.md#clear-and-simple-design A native parse plus one optional AST walk isolates supplemental star discovery; the node predicate admits only structured parser nodes.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Supported helper spellings are the transform protocol, and parser failures preserve native metadata so Node's actual loader still owns syntax rejection.
+ * @evidence contracts/common.md#meaningful-documentation Native prose states the metadata boundary and why an AST supplements the frozen lexer; failure comments distinguish discovery from loading.
+ * @evidence contracts/performance.md#efficient-algorithms The lexer and helper-marker scan process source text. Supplemental Acorn parsing/walking visits AST child references and property arrays; K matched calls sort by numeric source position in O(K log K). Deduplication hashes specifier text; AST/pending/matches and returned name arrays scale with source and discovered metadata, without a configured source-size or recursion-depth cap.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This per-source parser owns no cross-request coordinator; consumers choose whether identical transformed source metadata can be reused.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources AST, pending references and matches are call-local; returned lexer arrays/deduplicated specifier strings belong to the caller. No native handle, task or historical cache is retained.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation The body interprets in-memory JavaScript syntax and literal reexport strings, without resolving native paths or executing loader/process APIs. The consuming runtime owns native resolution and module loading.
+ */
+export declare function parseCommonJsExports(source: string): ReturnType<typeof parseCommonJs>;

package/lib/launcher/internal/{commonJsExportMetadata.js → parseCommonJsExports.js}

@@ -4,9 +4,19 @@ exports.parseCommonJsExports = parseCommonJsExports;
 const acorn_1 = require("acorn");
 const cjs_module_lexer_1 = require("cjs-module-lexer");
 /**
- * Node's export metadata plus the scoped star helpers ttsx already supports.
- * Node's frozen lexer patterns omit helpers inside blocks and functions. An AST
+ * CommonJS lexer metadata plus the scoped star helpers ttsx already supports.
+ * Base lexer patterns can omit helpers inside blocks and functions. An AST
  * supplies those calls without interpreting regex or template text as code.
+ *
+ * @evidence contracts/common.md#principled-implementation The maintained cjs-module-lexer metadata remains the base, while Acorn node kinds identify supported literal require/export-star shapes without treating comments or string contents as code; this is metadata discovery, not evaluation or lexical binding analysis.
+ * @evidence contracts/common.md#clear-and-simple-design A native parse plus one optional AST walk isolates supplemental star discovery; the node predicate admits only structured parser nodes.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Supported helper spellings are the transform protocol, and parser failures preserve native metadata so Node's actual loader still owns syntax rejection.
+ * @evidence contracts/common.md#meaningful-documentation Native prose states the metadata boundary and why an AST supplements the frozen lexer; failure comments distinguish discovery from loading.
+ * @evidence contracts/performance.md#efficient-algorithms The lexer and helper-marker scan process source text. Supplemental Acorn parsing/walking visits AST child references and property arrays; K matched calls sort by numeric source position in O(K log K). Deduplication hashes specifier text; AST/pending/matches and returned name arrays scale with source and discovered metadata, without a configured source-size or recursion-depth cap.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This per-source parser owns no cross-request coordinator; consumers choose whether identical transformed source metadata can be reused.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources AST, pending references and matches are call-local; returned lexer arrays/deduplicated specifier strings belong to the caller. No native handle, task or historical cache is retained.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation The body interprets in-memory JavaScript syntax and literal reexport strings, without resolving native paths or executing loader/process APIs. The consuming runtime owns native resolution and module loading.
  */
 function parseCommonJsExports(source) {
     let parsed;
@@ -86,4 +96,4 @@ function isJavaScriptNode(value) {
         typeof node.start === "number" &&
         typeof node.end === "number");
 }
-//# sourceMappingURL=commonJsExportMetadata.js.map
+//# sourceMappingURL=parseCommonJsExports.js.map

package/lib/launcher/internal/parseCommonJsExports.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseCommonJsExports.js","sourceRoot":"","sources":["../../../src/launcher/internal/parseCommonJsExports.ts"],"names":[],"mappings":";;;AAAA,iCAA+D;AAC/D,uDAA0D;AAE1D;;;;;;;;;;;;;;GAcG;AACH,8BACE,MAAc;IAEd,IAAI,MAAwC,CAAC;IAC7C,IAAI,CAAC;QACH,MAAM,GAAG,IAAA,wBAAa,EAAC,MAAM,CAAC,CAAC;IACjC,CAAC;IAAC,MAAM,CAAC;QACP,yEAAyE;QACzE,MAAM,GAAG,EAAE,OAAO,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC;IAC1C,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAAC;QAAE,OAAO,MAAM,CAAC;IACpD,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,IAAA,aAAe,EAAC,MAAM,EAAE;YACnC,WAAW,EAAE,QAAQ;YACrB,UAAU,EAAE,UAAU;YACtB,0DAA0D;YAC1D,2BAA2B,EAAE,IAAI;SAClC,CAAC,CAAC;QACH,MAAM,OAAO,GAAc,CAAC,IAAI,CAAC,CAAC;QAClC,MAAM,KAAK,GAA2C,EAAE,CAAC;QACzD,OAAO,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC5B,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,EAAG,CAAC;YAC5B,IAAI,IAAI,CAAC,IAAI,KAAK,gBAAgB,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACrD,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;gBAC3B,MAAM,IAAI,GACR,CAAC,MAAM,CAAC,IAAI,KAAK,YAAY,IAAI,MAAM,CAAC,IAAI,KAAK,cAAc,CAAC;oBAChE,CAAC,MAAM,CAAC,IAAI,KAAK,kBAAkB;wBACjC,CAAC,MAAM,CAAC,QAAQ;wBAChB,CAAC,MAAM,CAAC,QAAQ;wBAChB,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,YAAY;wBACnC,MAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,YAAY;wBACrC,MAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,cAAc,CAAC,CAAC;gBAC7C,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC;gBAC1C,IACE,IAAI;oBACJ,MAAM,EAAE,IAAI,KAAK,YAAY;oBAC7B,MAAM,CAAC,IAAI,KAAK,SAAS;oBACzB,QAAQ,EAAE,IAAI,KAAK,gBAAgB;oBACnC,CAAC,QAAQ,CAAC,QAAQ;oBAClB,QAAQ,CAAC,MAAM,CAAC,IAAI,KAAK,YAAY;oBACrC,QAAQ,CAAC,MAAM,CAAC,IAAI,KAAK,SAAS;oBAClC,QAAQ,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,EAC/B,CAAC;oBACD,MAAM,SAAS,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;oBACxC,IACE,SAAS,EAAE,IAAI,KAAK,SAAS;wBAC7B,OAAO,SAAS,CAAC,KAAK,KAAK,QAAQ,EACnC,CAAC;wBACD,KAAK,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC;oBAChE,CAAC;gBACH,CAAC;YACH,CAAC;YACD,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;gBACxC,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;oBAC3D,IAAI,gBAAgB,CAAC,KAAK,CAAC;wBAAE,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBACnD,CAAC;YACH,CAAC;QACH,CAAC;QACD,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC;QACxC,OAAO;YACL,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,SAAS,EAAE;gBACT,GAAG,IAAI,GAAG,CAAC;oBACT,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;oBACxC,GAAG,MAAM,CAAC,SAAS;iBACpB,CAAC;aACH;SACF,CAAC;IACJ,CAAC;IAAC,MAAM,CAAC;QACP,mFAAmF;QACnF,OAAO,MAAM,CAAC;IAChB,CAAC;AACH,CAAC;AAED,SAAS,gBAAgB,CAAC,KAAc;IACtC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC9D,MAAM,IAAI,GAAG,KAA2D,CAAC;IACzE,OAAO,CACL,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ;QAC7B,OAAO,IAAI,CAAC,KAAK,KAAK,QAAQ;QAC9B,OAAO,IAAI,CAAC,GAAG,KAAK,QAAQ,CAC7B,CAAC;AACJ,CAAC"}

package/lib/launcher/internal/parseTtscBuildArgs.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Parse launcher build arguments without resolving a project or starting a
+ * host.
+ *
+ * @evidence contracts/common.md#principled-implementation The schema parser and solution-build guard decide ownership of each flag; emit stays tri-state (absent, true, false) with `--emit` taking precedence over `--noEmit`, and forwarded flags and their values keep argv order because the parser routes non-input tokens into passthrough in place.
+ * @evidence contracts/common.md#clear-and-simple-design One authored adapter returns launcher-owned values; its two local helpers only resolve emit precedence and identify source extensions.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unknown compiler flags and adjacent values remain in original order; invalid owned values use the schema errors without coercion or fake compiler execution.
+ * @evidence contracts/common.md#meaningful-documentation The comment states the execution-free parser boundary; inline comments retain the default quiet, emit and positional-file decisions.
+ * @evidence contracts/performance.md#efficient-algorithms Shared parsing and the solution-build guard traverse argv and parsed flag identities; name normalization, operand lookahead and validation also depend on token text lengths. Fixed option accessors add bounded field projections, and the returned file/passthrough snapshots copy at most the parsed argument references without reparsing them.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each invocation owns different argv; this parser coordinates no shared computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Returned options are invocation values; no retained memo, process or handle is acquired.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Parses argv tokens only; file arguments are returned verbatim and are neither resolved nor normalized here.
+ */
+export declare function parseTtscBuildArgs(argv: readonly string[]): {
+    binary: string | undefined;
+    cacheDir: string | undefined;
+    checkers: number | undefined;
+    compilerProjectSelections: {
+        passthroughIndex: number;
+        value: string;
+    }[];
+    cwd: string | undefined;
+    emit: boolean | undefined;
+    files: string[];
+    fix: boolean;
+    format: boolean;
+    outDir: string | undefined;
+    passthrough: string[];
+    preserveWatchOutput: boolean;
+    quiet: boolean;
+    singleThreaded: boolean;
+    tsconfig: string | undefined;
+    watch: boolean;
+};

package/lib/launcher/internal/parseTtscBuildArgs.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTtscBuildArgs = parseTtscBuildArgs;
+const getBoolean_1 = require("../../flags/getBoolean");
+const getNumber_1 = require("../../flags/getNumber");
+const getString_1 = require("../../flags/getString");
+const parseFlags_1 = require("../../flags/parseFlags");
+const assertNoSolutionBuild_1 = require("./assertNoSolutionBuild");
+/**
+ * Parse launcher build arguments without resolving a project or starting a
+ * host.
+ *
+ * @evidence contracts/common.md#principled-implementation The schema parser and solution-build guard decide ownership of each flag; emit stays tri-state (absent, true, false) with `--emit` taking precedence over `--noEmit`, and forwarded flags and their values keep argv order because the parser routes non-input tokens into passthrough in place.
+ * @evidence contracts/common.md#clear-and-simple-design One authored adapter returns launcher-owned values; its two local helpers only resolve emit precedence and identify source extensions.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unknown compiler flags and adjacent values remain in original order; invalid owned values use the schema errors without coercion or fake compiler execution.
+ * @evidence contracts/common.md#meaningful-documentation The comment states the execution-free parser boundary; inline comments retain the default quiet, emit and positional-file decisions.
+ * @evidence contracts/performance.md#efficient-algorithms Shared parsing and the solution-build guard traverse argv and parsed flag identities; name normalization, operand lookahead and validation also depend on token text lengths. Fixed option accessors add bounded field projections, and the returned file/passthrough snapshots copy at most the parsed argument references without reparsing them.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each invocation owns different argv; this parser coordinates no shared computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Returned options are invocation values; no retained memo, process or handle is acquired.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Parses argv tokens only; file arguments are returned verbatim and are neither resolved nor normalized here.
+ */
+function parseTtscBuildArgs(argv) {
+    const compilerProjectSelections = [];
+    const result = (0, parseFlags_1.parseFlags)({
+        argv,
+        errorPrefix: "ttsc:",
+        // A bare token is a single-file input only when it carries a TypeScript
+        // source extension. Other bare tokens remain passthrough data, including
+        // space-separated values (e.g. the `es2020` in `--target es2020`); this
+        // predicate does not certify that a preceding flag owns each token. The
+        // parser routes those tokens into `passthrough` in place, so the forwarded
+        // flag/value pairs reach tsgo in their original order.
+        isPositional: looksLikeInputFile,
+        onConsumedFlag: (name, value, passthroughIndex) => {
+            if (name === "--tsconfig" && typeof value === "string")
+                compilerProjectSelections.push({ passthroughIndex, value });
+        },
+        subcommand: "build",
+    });
+    (0, assertNoSolutionBuild_1.assertNoSolutionBuild)(result, "ttsc:");
+    // Defaults: `quiet` is true, `--verbose` flips it to false; `emit` is
+    // `undefined` so the resolved project controls ordinary build mode.
+    // `runCompatibleBuild` applies the check/fix/format no-emit decision before
+    // either execution lane runs.
+    const verbose = (0, getBoolean_1.getBoolean)(result, "--verbose");
+    const quietFlag = (0, getBoolean_1.getBoolean)(result, "--quiet");
+    const quiet = verbose === true ? false : (quietFlag ?? true);
+    const explicitEmit = (0, getBoolean_1.getBoolean)(result, "--emit");
+    const explicitNoEmit = (0, getBoolean_1.getBoolean)(result, "--noEmit");
+    const emit = resolveExplicitEmit(explicitEmit, explicitNoEmit);
+    // `isPositional: looksLikeInputFile` guarantees every `result.positional`
+    // token is a TypeScript input file; forwarded flag values already live in
+    // `result.passthrough` in their original order, so no reconstruction is
+    // needed here.
+    const files = [...result.positional];
+    const passthrough = [...result.passthrough];
+    return {
+        binary: (0, getString_1.getString)(result, "--binary"),
+        cacheDir: (0, getString_1.getString)(result, "--cache-dir"),
+        checkers: (0, getNumber_1.getNumber)(result, "--checkers"),
+        compilerProjectSelections,
+        cwd: (0, getString_1.getString)(result, "--cwd"),
+        emit,
+        files,
+        fix: false,
+        format: false,
+        outDir: (0, getString_1.getString)(result, "--outDir"),
+        passthrough,
+        preserveWatchOutput: (0, getBoolean_1.getBoolean)(result, "--preserveWatchOutput") === true,
+        quiet,
+        singleThreaded: (0, getBoolean_1.getBoolean)(result, "--singleThreaded") === true,
+        tsconfig: (0, getString_1.getString)(result, "--tsconfig"),
+        watch: (0, getBoolean_1.getBoolean)(result, "--watch") === true,
+    };
+}
+/**
+ * Collapse the two launcher-owned emit switches into the tri-state consumed by
+ * `runBuild` and the single-file lane. A specified boolean is significant even
+ * when it is `false`: `--emit=false` is analysis-only and `--noEmit=false`
+ * explicitly overrides a project's `noEmit`. `--emit` retains precedence when
+ * callers supply both switches.
+ */
+function resolveExplicitEmit(explicitEmit, explicitNoEmit) {
+    if (explicitEmit !== undefined)
+        return explicitEmit;
+    return explicitNoEmit === undefined ? undefined : !explicitNoEmit;
+}
+/**
+ * Report whether a bare CLI token is a TypeScript source file ttsc should
+ * compile in single-file mode. Anything without a TypeScript source extension
+ * remains passthrough data rather than a launcher input file; the native
+ * compiler decides whether an unowned token is valid.
+ */
+function looksLikeInputFile(token) {
+    return [".ts", ".tsx", ".mts", ".cts"].some((ext) => token.endsWith(ext));
+}
+//# sourceMappingURL=parseTtscBuildArgs.js.map

package/lib/launcher/internal/parseTtscBuildArgs.js.map

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

package/lib/launcher/internal/parseTtsxCLI.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Parse ttsx options while preserving the program's own argument boundary.
+ *
+ * Compiler flags before the first entry, repeated preloads and launcher-owned
+ * settings are separated once through the shared flag schema. Terminal requests
+ * are recognized only before the entry; unsupported watch/build requests fail
+ * before a check, build or program is started. These decisions inspect the supplied
+ * argv frame; this parser does not read response-file contents or certify their
+ * eventual native effects. Preparation inspects response frames at the selected
+ * project's actual compiler directory before requesting its build.
+ *
+ * @param argv Command tokens as received from the launcher.
+ * @returns A terminal request or the launcher's typed option record.
+ * @evidence contracts/common.md#principled-implementation The shared schema owns option arity and first-positional/tail boundaries; terminal requests use that same flag resolution, with a schema-derived prefix scan only when parsing itself fails.
+ * @evidence contracts/common.md#clear-and-simple-design One pure launcher option boundary owns value projection, repeatable preloads and build/watch rejection, delegating schema mechanics rather than rescanning entry extensions.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Accepted spellings follow the actual flag schema/compiler option kinds, not source extensions or consumer-specific rewrites; unsupported modes throw their supported diagnostics.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain compiler/program separation, terminal precedence and early rejection; private helper comments state why the failed-parse prefix scan exists.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This function classifies argument tokens without resolving filesystem paths or starting processes; native representations remain with its launcher caller.
+ * @evidence contracts/performance.md#efficient-algorithms Shared parsing and fixed-count terminal/watch scans advance through at most the supplied argv frame and its parsed projections. Delegated token normalization and native operand lookahead also cost time and transient space proportional to the text they inspect; repeated preloads and tail/compiler snapshots add at most O(A) argument references. The failure-only prefix scan advances by each owning option's width without reparsing program-tail tokens.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each pure option parse belongs to one invocation; it coordinates no completed or in-flight shared work and has no historical result cache.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Local arrays and the returned option record transfer to the caller; this parser owns no retained state, directory, handle or task.
+ */
+export declare function parseTtsxCLI(argv: readonly string[]): "help" | "version" | {
+    binary: string | undefined;
+    cacheDir: string | undefined;
+    checkers: number | undefined;
+    cwd: string | undefined;
+    entry: string;
+    noPlugins: boolean;
+    passthrough: string[];
+    preload: string[];
+    project: string | undefined;
+    singleThreaded: boolean;
+    tsgoFlags: string[];
+};

package/lib/launcher/internal/parseTtsxCLI.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTtsxCLI = parseTtsxCLI;
+const getBoolean_1 = require("../../flags/getBoolean");
+const getNumber_1 = require("../../flags/getNumber");
+const getString_1 = require("../../flags/getString");
+const getStringList_1 = require("../../flags/getStringList");
+const parseFlags_1 = require("../../flags/parseFlags");
+const readCompilerOptionOccurrence_1 = require("../../flags/readCompilerOptionOccurrence");
+const resolveFlagSpec_1 = require("../../flags/resolveFlagSpec");
+const assertNoSolutionBuild_1 = require("./assertNoSolutionBuild");
+const assertTtsxNoWatch_1 = require("./assertTtsxNoWatch");
+/**
+ * Parse ttsx options while preserving the program's own argument boundary.
+ *
+ * Compiler flags before the first entry, repeated preloads and launcher-owned
+ * settings are separated once through the shared flag schema. Terminal requests
+ * are recognized only before the entry; unsupported watch/build requests fail
+ * before a check, build or program is started. These decisions inspect the supplied
+ * argv frame; this parser does not read response-file contents or certify their
+ * eventual native effects. Preparation inspects response frames at the selected
+ * project's actual compiler directory before requesting its build.
+ *
+ * @param argv Command tokens as received from the launcher.
+ * @returns A terminal request or the launcher's typed option record.
+ * @evidence contracts/common.md#principled-implementation The shared schema owns option arity and first-positional/tail boundaries; terminal requests use that same flag resolution, with a schema-derived prefix scan only when parsing itself fails.
+ * @evidence contracts/common.md#clear-and-simple-design One pure launcher option boundary owns value projection, repeatable preloads and build/watch rejection, delegating schema mechanics rather than rescanning entry extensions.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Accepted spellings follow the actual flag schema/compiler option kinds, not source extensions or consumer-specific rewrites; unsupported modes throw their supported diagnostics.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain compiler/program separation, terminal precedence and early rejection; private helper comments state why the failed-parse prefix scan exists.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This function classifies argument tokens without resolving filesystem paths or starting processes; native representations remain with its launcher caller.
+ * @evidence contracts/performance.md#efficient-algorithms Shared parsing and fixed-count terminal/watch scans advance through at most the supplied argv frame and its parsed projections. Delegated token normalization and native operand lookahead also cost time and transient space proportional to the text they inspect; repeated preloads and tail/compiler snapshots add at most O(A) argument references. The failure-only prefix scan advances by each owning option's width without reparsing program-tail tokens.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each pure option parse belongs to one invocation; it coordinates no completed or in-flight shared work and has no historical result cache.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Local arrays and the returned option record transfer to the caller; this parser owns no retained state, directory, handle or task.
+ */
+function parseTtsxCLI(argv) {
+    // ttsx accepts ttsc-style flags plus its own `--no-plugins` / `--require`.
+    // The shared schema engine recognises both; after empty/response-token rules,
+    // it returns the first unconsumed bare token as the entry, earlier flags/values as compiler
+    // passthrough and later tokens as the program tail, regardless of extension.
+    //
+    // The legacy uppercase `-P` spelling ttsx has always accepted needs no
+    // rewrite: the engine resolves a token to the flag the compiler resolves it
+    // to, so `-P` and `-P=<file>` reach `--tsconfig` by the same rule that makes
+    // `-p` reach it. A textual pre-rewrite here would be a second rule for a job
+    // the engine owns.
+    //
+    // Terminal flags (--help / --version) belong to ttsx only before the entry;
+    // after it they are the program's own argv, exactly as `node entry.js
+    // --version` hands `--version` to the program. The
+    // parser already draws that boundary, so they are read off its result, and
+    // resolved through the schema so every spelling the compiler accepts
+    // (`--HELP`, `-Version`) reaches the same branch.
+    let result;
+    try {
+        result = (0, parseFlags_1.parseFlags)({
+            argv,
+            errorPrefix: "ttsx:",
+            forwardAfterFirstPositional: true,
+            honorDoubleDashSeparator: true,
+            // After empty/response-token handling, the entry is the first bare token
+            // that is no option's value, whatever its extension: the schema and the
+            // compiler's own option table say
+            // which options take a value (the `es2020` of `--target es2020`), so a
+            // JavaScript entry is the entry too rather than a forwarded value.
+            subcommand: "ttsx",
+        });
+    }
+    catch (error) {
+        // Help still prints when the other options do not parse, as long as it was
+        // asked for before anything that looks like the entry.
+        const terminal = terminalRequest(argv.slice(0, firstPositionalIndex(argv)));
+        if (terminal !== null)
+            return terminal;
+        throw error;
+    }
+    // Parsed launcher identities are not argv: a scalar key carries no value
+    // here, so joining it to the next key would invent an operand boundary.
+    let terminal = null;
+    for (const key of result.values.keys()) {
+        if (key === "--help") {
+            terminal = "help";
+            break;
+        }
+        if (key === "--version") {
+            terminal = "version";
+            break;
+        }
+    }
+    terminal ??= terminalRequest(result.passthrough);
+    if (terminal !== null)
+        return terminal;
+    (0, assertNoSolutionBuild_1.assertNoSolutionBuild)(result, "ttsx:");
+    (0, assertTtsxNoWatch_1.assertTtsxNoWatch)(result.values.has("--watch") ? ["--watch"] : result.passthrough);
+    const entry = result.positional[0];
+    if (entry === undefined) {
+        throw new Error("ttsx: entry file is required");
+    }
+    // With `forwardAfterFirstPositional: true`, the parser reports
+    // `result.positional` as just the entry, `result.passthrough` as the
+    // tsgo-forwarded flags (and their in-order space values) arriving BEFORE the
+    // entry, and `result.tail` as every token AFTER the entry — the user
+    // program's argv (e.g. the `generate --input src/input` tail of `ttsx
+    // typia.ts generate --input src/input`), which MUST NOT reach tsgo.
+    const postEntryArgs = [...result.tail];
+    // `--require` is declared `repeatable`, so the engine records every accepted
+    // value in argv order and the launcher reads the list straight off the parse
+    // result.
+    //
+    // Preload values may themselves carry TypeScript extensions, so entry
+    // classification must follow option arity rather than an extension scan.
+    // The engine owns that boundary:
+    // `forwardAfterFirstPositional` routes every post-entry token to
+    // `result.tail` without parsing it, so `ttsx entry.ts -r preload.cjs` still
+    // forwards the pair to the program instead of preloading it.
+    const preload = (0, getStringList_1.getStringList)(result, "--require");
+    return {
+        binary: (0, getString_1.getString)(result, "--binary"),
+        cacheDir: (0, getString_1.getString)(result, "--cache-dir"),
+        checkers: (0, getNumber_1.getNumber)(result, "--checkers"),
+        cwd: (0, getString_1.getString)(result, "--cwd"),
+        entry,
+        noPlugins: (0, getBoolean_1.getBoolean)(result, "--no-plugins") === true,
+        passthrough: postEntryArgs,
+        preload,
+        project: (0, getString_1.getString)(result, "--tsconfig"),
+        singleThreaded: (0, getBoolean_1.getBoolean)(result, "--singleThreaded") === true,
+        tsgoFlags: [...result.passthrough],
+    };
+}
+/**
+ * `"help"` or `"version"` when one of `tokens` asks for it, else `null`. Only
+ * dash-prefixed tokens can name a flag; a bare value such as the `all` of
+ * `--target all` must not read as `--all`.
+ */
+function terminalRequest(tokens) {
+    for (let index = 0; index < tokens.length;) {
+        const token = tokens[index];
+        const flag = (0, resolveFlagSpec_1.resolveFlagSpec)(token)?.name;
+        if (flag === "--help")
+            return "help";
+        if (flag === "--version")
+            return "version";
+        index += ttsxOptionWidth(tokens, index);
+    }
+    return null;
+}
+/**
+ * Index of the first nonempty, non-response bare token that is no option's
+ * value, or the length. Used only where the parser itself failed, to still find
+ * the options before the entry.
+ */
+function firstPositionalIndex(argv) {
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token.startsWith("@"))
+            continue;
+        if (token === "")
+            continue;
+        if (!token.startsWith("-"))
+            return index;
+        if (token.includes("="))
+            continue;
+        index += ttsxOptionWidth(argv, index) - 1;
+    }
+    return argv.length;
+}
+/**
+ * Launcher values keep their missing-value policy; forwarded options use native
+ * grammar.
+ */
+function ttsxOptionWidth(argv, index) {
+    const token = argv[index];
+    if (token.includes("="))
+        return 1;
+    const flag = (0, resolveFlagSpec_1.resolveFlagSpec)(token);
+    if (flag?.consumedBy.includes("launcher") === true &&
+        flag.subcommands.includes("ttsx")) {
+        const next = argv[index + 1];
+        if (next === undefined)
+            return 1;
+        if (flag.kind === "boolean")
+            return next === "true" || next === "false" ? 2 : 1;
+        return next.startsWith("-") ? 1 : 2;
+    }
+    return (0, readCompilerOptionOccurrence_1.readCompilerOptionOccurrence)(argv, index).width;
+}
+//# sourceMappingURL=parseTtsxCLI.js.map

package/lib/launcher/internal/parseTtsxCLI.js.map

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