ttsc 0.30.3 → 0.31.0

package/lib/plugin/internal/load/hasProjectPluginEntries.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasProjectPluginEntries = hasProjectPluginEntries;
+const ProjectPluginEntries_1 = require("./ProjectPluginEntries");
+/**
+ * Return `true` when the project has at least one enabled plugin entry.
+ *
+ * Used by callers that need to skip plugin-specific work when no plugins are
+ * configured, without evaluating descriptors or building plugin artifacts.
+ * Discovery still resolves the complete entry list before checking presence;
+ * omitted entries can therefore read manifests and resolve native packages.
+ *
+ * @param entries - Explicit entries; `false` always returns `false`.
+ * @evidence contracts/common.md#principled-implementation Explicit false disables all plugin discovery; otherwise the shared entry resolver's enabled-not-false predicate checks the same population the loader would consider.
+ * @evidence contracts/common.md#clear-and-simple-design The presence query delegates config/package selection to its owner instead of reproducing descriptor evaluation or build logic.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Enabled selection follows declared configuration, without assuming a known package marker or fabricating absence after a resolver error.
+ * @evidence contracts/common.md#meaningful-documentation Native JSDoc states why the presence query exists and how explicit false differs from omitted entries; prose/tag separation follows the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation The project-entry resolver owns native config/package resolution; this adapter applies no POSIX parsing or additional path/case normalization to its answer.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This query owns no retained handle or cross-call collection; resolved entry wrappers and discovery indexes are invocation-local, with payloads borrowed from the project or parsed manifests.
+ * @evidence contracts/performance.md#efficient-algorithms Explicit false avoids discovery. Otherwise resolution materializes all entries before an at-most-linear enabled scan; explicit lists allocate one wrapper per entry, while omitted lists additionally incur ancestor, manifest-byte, dependency and native specifier-resolution work delegated to the entry resolver. No fixed project-size bound is imposed.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This fresh presence observation coordinates no reusable producer result across calls; it neither retains package authority nor promises that subsequent loading avoids discovery again.
+ */
+function hasProjectPluginEntries(project, entries) {
+    if (entries === false) {
+        return false;
+    }
+    return ProjectPluginEntries_1.ProjectPluginEntries.resolvePluginEntries(project, entries).some((entry) => entry.config.enabled !== false);
+}
+//# sourceMappingURL=hasProjectPluginEntries.js.map

package/lib/plugin/internal/load/hasProjectPluginEntries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasProjectPluginEntries.js","sourceRoot":"","sources":["../../../../src/plugin/internal/load/hasProjectPluginEntries.ts"],"names":[],"mappings":";;;AAEA,iEAA8D;AAE9D;;;;;;;;;;;;;;;;;GAiBG;AACH,iCACE,OAAiC,EACjC,OAAqD;IAErD,IAAI,OAAO,KAAK,KAAK,EAAE,CAAC;QACtB,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,2CAAoB,CAAC,oBAAoB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,IAAI,CACrE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,KAAK,KAAK,CAC1C,CAAC;AACJ,CAAC"}

package/lib/plugin/internal/load/hashHostInputPaths.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Content hash of each host input, keyed by its resolved path; `null` for an
+ * input that cannot be read. A persistent plugin cache compares these against
+ * the hashes it recorded to decide whether a descriptor must be evaluated
+ * again.
+ *
+ * @evidence contracts/common.md#principled-implementation Resolved path keys pair readable content with SHA-256, directory kind with a domain marker, and unavailable input with null; consumers must pair this content projection with physical identity.
+ * @evidence contracts/common.md#clear-and-simple-design The operation snapshots supplied inputs only, leaving discovery, read-time stability and cache acceptance with their respective owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The directory marker encodes type, not an expected answer; unreadability stays null rather than synthetic content or a known-path bypass.
+ * @evidence contracts/common.md#meaningful-documentation Native JSDoc states null's unreadable meaning and downstream comparison purpose; descriptive and acknowledgment paragraphs are separated following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path.resolve/stat/readFile preserve host path semantics and follow links; directory kind comes from actual stat rather than separators or platform-name inference.
+ * @evidence contracts/performance.md#efficient-algorithms Each input incurs native key normalization and stat; a readable nondirectory allocates and hashes its full bytes, while directories hash a fixed kind marker without scanning children. Processing includes input/path text, native queries and readable file bytes; mapped pairs and the result coexist, and duplicate keys still repeat observation before overwriting. Each file read needs a buffer proportional to its complete size.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This current-state snapshot must reread its supplied files; reusable accepted answers belong to the cache that validates these observations.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Synchronous file APIs close their own descriptors and the returned record is caller-owned; this snapshot keeps no global collection or acquired handle.
+ */
+export declare function hashHostInputPaths(files: readonly string[]): Record<string, string | null>;

package/lib/plugin/internal/load/hashHostInputPaths.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashHostInputPaths = hashHostInputPaths;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Content hash of each host input, keyed by its resolved path; `null` for an
+ * input that cannot be read. A persistent plugin cache compares these against
+ * the hashes it recorded to decide whether a descriptor must be evaluated
+ * again.
+ *
+ * @evidence contracts/common.md#principled-implementation Resolved path keys pair readable content with SHA-256, directory kind with a domain marker, and unavailable input with null; consumers must pair this content projection with physical identity.
+ * @evidence contracts/common.md#clear-and-simple-design The operation snapshots supplied inputs only, leaving discovery, read-time stability and cache acceptance with their respective owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The directory marker encodes type, not an expected answer; unreadability stays null rather than synthetic content or a known-path bypass.
+ * @evidence contracts/common.md#meaningful-documentation Native JSDoc states null's unreadable meaning and downstream comparison purpose; descriptive and acknowledgment paragraphs are separated following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path.resolve/stat/readFile preserve host path semantics and follow links; directory kind comes from actual stat rather than separators or platform-name inference.
+ * @evidence contracts/performance.md#efficient-algorithms Each input incurs native key normalization and stat; a readable nondirectory allocates and hashes its full bytes, while directories hash a fixed kind marker without scanning children. Processing includes input/path text, native queries and readable file bytes; mapped pairs and the result coexist, and duplicate keys still repeat observation before overwriting. Each file read needs a buffer proportional to its complete size.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This current-state snapshot must reread its supplied files; reusable accepted answers belong to the cache that validates these observations.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Synchronous file APIs close their own descriptors and the returned record is caller-owned; this snapshot keeps no global collection or acquired handle.
+ */
+function hashHostInputPaths(files) {
+    return Object.fromEntries(files.map((file) => [node_path_1.default.resolve(file), hashHostInput(file)]));
+}
+function hashHostInput(file) {
+    try {
+        if (node_fs_1.default.statSync(file).isDirectory()) {
+            return node_crypto_1.default
+                .createHash("sha256")
+                .update("ttsc:host-input:directory\0")
+                .digest("hex");
+        }
+        return node_crypto_1.default
+            .createHash("sha256")
+            .update(node_fs_1.default.readFileSync(file))
+            .digest("hex");
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=hashHostInputPaths.js.map

package/lib/plugin/internal/load/hashHostInputPaths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hashHostInputPaths.js","sourceRoot":"","sources":["../../../../src/plugin/internal/load/hashHostInputPaths.ts"],"names":[],"mappings":";;;;;;AAAA,8DAAiC;AACjC,sDAAyB;AACzB,0DAA6B;AAE7B;;;;;;;;;;;;;;;GAeG;AACH,4BACE,KAAwB;IAExB,OAAO,MAAM,CAAC,WAAW,CACvB,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,mBAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,CAC/D,CAAC;AACJ,CAAC;AAED,SAAS,aAAa,CAAC,IAAY;IACjC,IAAI,CAAC;QACH,IAAI,iBAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC;YACpC,OAAO,qBAAM;iBACV,UAAU,CAAC,QAAQ,CAAC;iBACpB,MAAM,CAAC,6BAA6B,CAAC;iBACrC,MAAM,CAAC,KAAK,CAAC,CAAC;QACnB,CAAC;QACD,OAAO,qBAAM;aACV,UAAU,CAAC,QAAQ,CAAC;aACpB,MAAM,CAAC,iBAAE,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;aAC7B,MAAM,CAAC,KAAK,CAAC,CAAC;IACnB,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC"}

package/lib/plugin/internal/load/isRelativePluginSpecifier.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Whether a plugin specifier of a `tsconfig.json` plugin entry is a relative
+ * path, including the Windows backslash spellings a user may write there.
+ *
+ * A relative `transform` resolves from the config that wrote it, where a bare
+ * package specifier resolves from the project root (`ProjectPluginEntries`).
+ * `@ttsc/unplugin` asks the same question, through the `ttsc/tsconfig` entry,
+ * of every path-valued key of a plugin entry it re-states in a wrapper config
+ * it writes outside the project, so a value the compiler would resolve from the
+ * project keeps that meaning there.
+ *
+ * @param specifier The value as written in the config.
+ * @evidence contracts/common.md#principled-implementation Dot/dot-dot and their slash/backslash prefixes distinguish explicit relative paths from package specifiers, preserving the declaring-config base for those values.
+ * @evidence contracts/common.md#clear-and-simple-design A shared lexical predicate gives wrapper rewriting and loader selection the same relative-specifier classification.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Both separator spellings are actual supported config inputs; no package-name exception is used to choose a resolution base.
+ * @evidence contracts/common.md#meaningful-documentation Native JSDoc explains the declaring-config versus project base and the wrapper consumer, with paragraphs and tag separation following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation The explicit slash and Windows backslash spellings support OS-neutral classification; this operation detects relative syntax without pretending to canonicalize or compare physical paths.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources isRelativePluginSpecifier acquires no handle, buffer or cache and retains nothing after it returns.
+ * @evidence contracts/performance.md#efficient-algorithms Two exact short-name checks and four fixed-width prefix checks inspect only the relative markers, with no suffix scan, normalization or result-string allocation; work is bounded by these marker widths rather than the full specifier length.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This lexical boolean observation coordinates no expensive producer or retained equivalent-answer state; it neither resolves the specifier nor caches mutable package or filesystem authority.
+ */
+export declare function isRelativePluginSpecifier(specifier: string): boolean;

package/lib/plugin/internal/load/isRelativePluginSpecifier.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRelativePluginSpecifier = isRelativePluginSpecifier;
+/**
+ * Whether a plugin specifier of a `tsconfig.json` plugin entry is a relative
+ * path, including the Windows backslash spellings a user may write there.
+ *
+ * A relative `transform` resolves from the config that wrote it, where a bare
+ * package specifier resolves from the project root (`ProjectPluginEntries`).
+ * `@ttsc/unplugin` asks the same question, through the `ttsc/tsconfig` entry,
+ * of every path-valued key of a plugin entry it re-states in a wrapper config
+ * it writes outside the project, so a value the compiler would resolve from the
+ * project keeps that meaning there.
+ *
+ * @param specifier The value as written in the config.
+ * @evidence contracts/common.md#principled-implementation Dot/dot-dot and their slash/backslash prefixes distinguish explicit relative paths from package specifiers, preserving the declaring-config base for those values.
+ * @evidence contracts/common.md#clear-and-simple-design A shared lexical predicate gives wrapper rewriting and loader selection the same relative-specifier classification.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Both separator spellings are actual supported config inputs; no package-name exception is used to choose a resolution base.
+ * @evidence contracts/common.md#meaningful-documentation Native JSDoc explains the declaring-config versus project base and the wrapper consumer, with paragraphs and tag separation following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation The explicit slash and Windows backslash spellings support OS-neutral classification; this operation detects relative syntax without pretending to canonicalize or compare physical paths.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources isRelativePluginSpecifier acquires no handle, buffer or cache and retains nothing after it returns.
+ * @evidence contracts/performance.md#efficient-algorithms Two exact short-name checks and four fixed-width prefix checks inspect only the relative markers, with no suffix scan, normalization or result-string allocation; work is bounded by these marker widths rather than the full specifier length.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This lexical boolean observation coordinates no expensive producer or retained equivalent-answer state; it neither resolves the specifier nor caches mutable package or filesystem authority.
+ */
+function isRelativePluginSpecifier(specifier) {
+    return (specifier === "." ||
+        specifier === ".." ||
+        specifier.startsWith("./") ||
+        specifier.startsWith("../") ||
+        specifier.startsWith(".\\") ||
+        specifier.startsWith("..\\"));
+}
+//# sourceMappingURL=isRelativePluginSpecifier.js.map

package/lib/plugin/internal/load/isRelativePluginSpecifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isRelativePluginSpecifier.js","sourceRoot":"","sources":["../../../../src/plugin/internal/load/isRelativePluginSpecifier.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,mCAA0C,SAAiB;IACzD,OAAO,CACL,SAAS,KAAK,GAAG;QACjB,SAAS,KAAK,IAAI;QAClB,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC;QAC1B,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC;QAC3B,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC;QAC3B,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,CAC7B,CAAC;AACJ,CAAC"}

package/lib/plugin/internal/load/loadProjectPlugins.d.ts

@@ -0,0 +1,113 @@
+import type { ITtscProjectPluginConfig } from "../../../structures/ITtscProjectPluginConfig";
+import type { ITtscLoadedNativePlugin } from "../../../structures/internal/ITtscLoadedNativePlugin";
+import type { ITtscParsedProjectConfig } from "../../../structures/internal/ITtscParsedProjectConfig";
+/**
+ * Resolve, load, and build all native plugin sidecars for a TypeScript project.
+ *
+ * Reads the project config, discovers plugin entries (from tsconfig and package
+ * auto-discovery), validates and composes their descriptors, then invokes
+ * `buildSourcePlugin` to compile each Go source package into a cached binary.
+ * Native ownership comes from the selected Go packages in generated build
+ * workspaces. The source-selected tool proposes nested transform ownership
+ * under generic host manifests while preserving source-relative input layout.
+ * Main proposals must agree in their full owning module; linked proposals must
+ * agree inside every selected transform host. Errors or disagreement terminate
+ * the load rather than changing the proposed kind.
+ * Watch callers first receive structurally selected source/module/contributor
+ * repair interests, before metadata can reject them. Valid records then narrow
+ * those interests to the exact build directories; interests alone never admit
+ * a plugin, certify a kind or supply reusable source-state proof.
+ * Returns the ordered native plugins, parsed project config, recorded
+ * JavaScript-host inputs and unresolved selection candidates, and the keyed
+ * state of reported Go source directories supplied to the builds
+ * (`pluginSources`): each plugin's module root and each contributor's source,
+ * with its state (`pluginSourceState`), the sources as the build read them
+ * together with the environment a build there is keyed on. Directories within
+ * ttsc's installed package, including its overlays and the fallback
+ * linked-plugin host, are keyed but omitted from this report under the
+ * installed-package/version ownership policy. That policy does not prove the
+ * installation cannot be edited in place. Descriptor completeness relies on the
+ * runtime recorder's status and the descriptor's explicit external-read
+ * declaration. Sequential content, metadata and physical-path observations are
+ * not an atomic snapshot or detection of every omitted read.
+ *
+ * @param options.binary - Absolute path to the ttsc native helper binary.
+ * @param options.cacheDir - Override the plugin binary cache directory.
+ * @param options.cwd - Working directory for resolving relative paths.
+ * @param options.entries - Explicit plugin entries; `false` disables all
+ *   plugins (skips both tsconfig entries and package auto-discovery).
+ * @param options.env - Effective environment for source-plugin builds and
+ *   isolated descriptor evaluators, including the `ttsx` fallback, merged with
+ *   native environment-name identity. Defaults to `process.env` for CLI
+ *   callers, so ambient behavior is unchanged.
+ * @param options.file - Path to the tsconfig/jsconfig file.
+ * @param options.pluginConfigDir - Caller-declared anchor for plugin
+ *   config-file discovery (see `ITtscPluginFactoryContext.pluginConfigDir`).
+ * @param options.projectRoot - Override the project root directory.
+ * @param options.tsconfig - Alias for `file`.
+ * @evidence contracts/common.md#principled-implementation The loader brackets project discovery observations, evaluates descriptors in isolated processes and validates declarations before publishing conservative source repair interests. Metadata refusal remains terminal; valid records narrow watch interests before final admission/build, while contradictory content or physical observations are omitted from proof rather than retroactively blessed.
+ * @evidence contracts/common.md#clear-and-simple-design The operation owns one ordered load generation; private helpers separate discovery, evaluation, validation, composition and proof merging, while package resolution and source building remain their own modules.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Descriptor module caches are isolated rather than deleting application singletons. ttsx retry occurs only for explicit supported TypeScript loader incompatibility, with plugins disabled to avoid recursive self-hosting; arbitrary descriptor failures are not retried into false success.
+ * @evidence contracts/common.md#meaningful-documentation Native JSDoc explains result provenance, environment and path options; helper comments explain input races, conservative proof omission, fallback authority and cleanup. Member/tag spacing and separated concepts follow the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path/file-URL conversion, createRequire and hidden spawn with explicit argv/environment implement OS-neutral selection and process execution. Physical identities are preserved separately from lexical candidates; Bun-specific differences are capability decisions, not OS guesses.
+ * @evidence contracts/performance.md#efficient-algorithms Input merging and conflicts use Sets/maps and sorted path populations, with path/key/value byte costs. Discovery can repeat config/manifest/candidate reads and full hashes; descriptor work includes runtime probes, full observation/JSON processing and possibly synchronous evaluation. Watch-only preliminary publication can temporarily digest/watch the full admitted module as well as its package before kind is known; callbacks delegate topology reconciliation. Load-local replacement readings serve preliminary and final publication. Package selection groups equivalent module contexts and batches entries through Go list without dependency compilation; per-load selected-tool manifest readers share overlay readings. Builds delegate source/environment hashing, copying, cold materialized ownership admission and Go execution; per-load digest maps share selected work. Composition can be quadratic in configured plugins/aliases, and native lookup/file/output bytes are not bounded by plugin count alone.
+ * @evidence contracts/performance.md#reuse-equivalent-work Descriptor hits require the cache's context/environment/runtime/version identity and matching recorded projections, subject to producer declarations and sequential-observation limits. Per-load source/environment maps share directory-keyed digests and one selected transform host serves linked contributors; these identities do not certify every undeclared read or atomic filesystem stability.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Finally restores injected environment locators, attempts evaluator directory removal and closes direct-evaluator diagnostic descriptors. Close/removal can fail; synchronous completion concerns the selected evaluator and does not certify arbitrary descendants are gone. Generation maps/results scale with observed data, and disk diagnostics/result/observation files have no independent byte ceiling here. Default disk pruning has its own interval/protection/failure policy; explicit roots remain caller-owned.
+ */
+export declare function loadProjectPlugins(options: {
+    /** Absolute native ttsc helper used in descriptor factory contexts. */
+    binary: string;
+    /** Caller-owned cache-root override; omitted for workspace-local policy. */
+    cacheDir?: string;
+    /** Invocation working directory for project discovery and relative inputs. */
+    cwd?: string;
+    /** Replacement plugin list, false to disable, or omitted for discovery. */
+    entries?: readonly ITtscProjectPluginConfig[] | false;
+    /** Effective build/evaluator environment, already merged by API callers. */
+    env?: NodeJS.ProcessEnv;
+    /** Explicit project config, resolved from cwd. */
+    file?: string;
+    /** Observe plugin build roots before building, including failed builds. */
+    onWatchInputs?: (inputs: readonly string[]) => void;
+    /** Caller-selected anchor for plugin-owned configuration discovery. */
+    pluginConfigDir?: string;
+    /** Project root override for generated config wrappers. */
+    projectRoot?: string;
+    /** Alias for the selected file option. */
+    tsconfig?: string;
+}): {
+    /**
+     * Whether config selection has complete observations. Module-based extends is
+     * unproved; descriptor/module proof is carried separately by host inputs.
+     */
+    discoveryInputsComplete: boolean;
+    /** Inputs only the native plugin reads, whose proof must come from it. */
+    deferredHostInputs: string[];
+    /**
+     * Whether every descriptor reported complete runtime observations and an
+     * explicit external-read declaration (`declaresHostInputReads`). This flag
+     * does not discover reads omitted by that producer. Without the declaration,
+     * the host inputs cannot prove the load's answer to a later launch. The
+     * runtime must also explicitly complete its module observations; retained
+     * partial records do not establish that declaration's input graph.
+     */
+    descriptorReadsDeclared: boolean;
+    /** Content observations captured when host inputs influenced the load. */
+    hostInputHashes: Record<string, string | null>;
+    /** Physical observations captured alongside the host-input reads. */
+    hostInputRealpaths: Record<string, string | null>;
+    /** Reported loader inputs, including unresolved discovery candidates. */
+    hostInputs: string[];
+    /**
+     * Negative-only descriptor observation status. It records an incomplete
+     * producer channel independently of external-read declarations or dropped
+     * mutation witnesses; omission makes no positive completeness claim.
+     */
+    observationsComplete?: false;
+    /** Check-stage entries followed by transform-stage entries in stable order. */
+    nativePlugins: ITtscLoadedNativePlugin[];
+    /** Plugin-provided Go directory states that the actual builds were keyed on. */
+    pluginSources: Record<string, string>;
+    /** Resolved project values and logical/physical configuration identity. */
+    project: ITtscParsedProjectConfig;
+};