ttsc 0.30.4 → 0.31.1

package/lib/launcher/internal/watch/syncWatchers.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncWatchers = syncWatchers;
+/**
+ * Reconcile the live watchers with the desired set, transactionally.
+ *
+ * Missing watchers are created first. Only when every desired watcher exists
+ * are the ones no longer desired closed, so a failed or interrupted creation
+ * retains the previously live watcher map. This ordering alone does not prove
+ * native coverage during backend failure. A watcher that later errors removes
+ * itself and reports through `onError`.
+ *
+ * @returns `false` when a creation failed or `shouldContinue` stopped the pass.
+ * @evidence contracts/common.md#principled-implementation New coverage is admitted before obsolete watchers are retired, so a failed creation leaves the previously live observation set intact.
+ * @evidence contracts/common.md#clear-and-simple-design Creation and retirement are two explicit passes; one captured watcher identity qualifies later error removal.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Failed creation is reported instead of replacing the missing watcher with a fake success or discarding old coverage.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain transaction order, late failure and interruption following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native watcher construction is injected through one supported boundary while the shared reconciler preserves its error and close semantics.
+ * @evidence contracts/performance.md#efficient-algorithms One desired-map pass and, if complete, one live-map pass inspect D desired and L live entries. Indexed key text, shouldContinue, create, error subscription and close callbacks contribute their own costs, including delegated native observation/lifecycle work. Partial creation stops retirement; D/L and key text are uncapped here.
+ * @evidence contracts/performance.md#reuse-equivalent-work A still-live watcher under the same desired key is reused; changed desired membership creates replacement coverage before retiring old keys.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The caller owns the live map and handles. Obsolete and failed watchers receive close attempts, while partial creation retains old entries until later reconciliation or shutdown. Backend close/callback failures can propagate; map ownership does not certify native release or uninterrupted event coverage.
+ */
+function syncWatchers(watchers, desired, create, onError, shouldContinue = () => true) {
+    let complete = true;
+    for (const [key, location] of desired) {
+        if (!shouldContinue()) {
+            complete = false;
+            break;
+        }
+        if (watchers.has(key))
+            continue;
+        let watcher;
+        try {
+            watcher = create(location, key);
+            const registered = watcher;
+            watcher.on("error", (error) => {
+                if (watchers.get(key) === registered) {
+                    watchers.delete(key);
+                }
+                registered.close();
+                onError(location, error);
+            });
+            watchers.set(key, watcher);
+        }
+        catch (error) {
+            watcher?.close();
+            complete = false;
+            onError(location, error);
+        }
+    }
+    if (!complete)
+        return false;
+    for (const [key, watcher] of watchers) {
+        if (desired.has(key))
+            continue;
+        watcher.close();
+        watchers.delete(key);
+    }
+    return true;
+}
+//# sourceMappingURL=syncWatchers.js.map

package/lib/launcher/internal/watch/syncWatchers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"syncWatchers.js","sourceRoot":"","sources":["../../../../src/launcher/internal/watch/syncWatchers.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,sBACE,QAAwB,EACxB,OAAoC,EACpC,MAA4C,EAC5C,OAAmD,EACnD,cAAc,GAAkB,GAAG,EAAE,CAAC,IAAI;IAE1C,IAAI,QAAQ,GAAG,IAAI,CAAC;IACpB,KAAK,MAAM,CAAC,GAAG,EAAE,QAAQ,CAAC,IAAI,OAAO,EAAE,CAAC;QACtC,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC;YACtB,QAAQ,GAAG,KAAK,CAAC;YACjB,MAAM;QACR,CAAC;QACD,IAAI,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,SAAS;QAChC,IAAI,OAAsB,CAAC;QAC3B,IAAI,CAAC;YACH,OAAO,GAAG,MAAM,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;YAChC,MAAM,UAAU,GAAG,OAAO,CAAC;YAC3B,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE;gBAC5B,IAAI,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,UAAU,EAAE,CAAC;oBACrC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;gBACvB,CAAC;gBACD,UAAU,CAAC,KAAK,EAAE,CAAC;gBACnB,OAAO,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;YAC3B,CAAC,CAAC,CAAC;YACH,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;QAC7B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,EAAE,KAAK,EAAE,CAAC;YACjB,QAAQ,GAAG,KAAK,CAAC;YACjB,OAAO,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;QAC3B,CAAC;IACH,CAAC;IACD,IAAI,CAAC,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC5B,KAAK,MAAM,CAAC,GAAG,EAAE,OAAO,CAAC,IAAI,QAAQ,EAAE,CAAC;QACtC,IAAI,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,SAAS;QAC/B,OAAO,CAAC,KAAK,EAAE,CAAC;QAChB,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACvB,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/lib/launcher/internal/watch/watchDirectory.d.ts

@@ -0,0 +1,28 @@
+import type { DirectoryWatcher } from "./DirectoryWatcher";
+/**
+ * Watch a directory's entries, or everything below it when `recursive`.
+ *
+ * On macOS, the `fsevents` binding keeps directory streams independent of
+ * libuv's process-wide `fs.watch` stream. A dropped-events notice reaches each
+ * affected watch with a `null` filename, so its owner re-reads its inputs.
+ * Other platforms use `fs.watch`; macOS does too, with one warning, when the
+ * optional binding cannot be loaded.
+ *
+ * @param location The directory, spelled as the filesystem names it.
+ * @param recursive Whether entries below subdirectories are heard.
+ * @param listener Receives `change` or `rename` and a relative entry name, or
+ *   `null` when anything below the directory may have changed. The final flag
+ *   marks an observation gap that needs a content recheck.
+ * @returns The open watch.
+ * @evidence contracts/common.md#principled-implementation Backend selection preserves relative names and observation-gap notifications through one shared subscription contract.
+ * @evidence contracts/common.md#clear-and-simple-design The dispatcher chooses the process registry or the fs.watch adapter without duplicating event interpretation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The fallback serves an unavailable optional production binding and emits its warning; no foreign watcher method is monkeypatched.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs and parameters explain backend choice, relative names, gaps and returned ownership following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation macOS's optional FSEvents binding is isolated explicitly; all other native subscriptions use Node's supported fs.watch API.
+ *
+ * @evidence contracts/performance.md#efficient-algorithms Cached availability selects one backend. Registration delegates path resolution, native subscription setup and, for FSEvents, ancestor lookup/descendant subscription transfers; event work remains with the selected backend. Delegated path/depth/watch populations are not bounded by this one-watch result.
+ *
+ * @evidence contracts/performance.md#reuse-equivalent-work The optional binding is loaded once per process; eligible macOS subscriptions share the registry's ancestor streams rather than constructing independent registries.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Returned subscriptions transfer close responsibility to their caller; the process registry retains binding availability and active stream/watch indexes. Closing the last stream subscriber removes logical ownership and attempts native stop; FSEvents stop errors are swallowed, so physical release is not confirmed on failure.
+ */
+export declare function watchDirectory(location: string, recursive: boolean, listener: (event: "change" | "rename", filename: string | null, gap?: boolean) => void): DirectoryWatcher;

package/lib/launcher/internal/watch/watchDirectory.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchDirectory = watchDirectory;
+const FseventsStreams_1 = require("./FseventsStreams");
+const watchDirectoryThroughFsWatch_1 = require("./watchDirectoryThroughFsWatch");
+/**
+ * Watch a directory's entries, or everything below it when `recursive`.
+ *
+ * On macOS, the `fsevents` binding keeps directory streams independent of
+ * libuv's process-wide `fs.watch` stream. A dropped-events notice reaches each
+ * affected watch with a `null` filename, so its owner re-reads its inputs.
+ * Other platforms use `fs.watch`; macOS does too, with one warning, when the
+ * optional binding cannot be loaded.
+ *
+ * @param location The directory, spelled as the filesystem names it.
+ * @param recursive Whether entries below subdirectories are heard.
+ * @param listener Receives `change` or `rename` and a relative entry name, or
+ *   `null` when anything below the directory may have changed. The final flag
+ *   marks an observation gap that needs a content recheck.
+ * @returns The open watch.
+ * @evidence contracts/common.md#principled-implementation Backend selection preserves relative names and observation-gap notifications through one shared subscription contract.
+ * @evidence contracts/common.md#clear-and-simple-design The dispatcher chooses the process registry or the fs.watch adapter without duplicating event interpretation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The fallback serves an unavailable optional production binding and emits its warning; no foreign watcher method is monkeypatched.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs and parameters explain backend choice, relative names, gaps and returned ownership following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation macOS's optional FSEvents binding is isolated explicitly; all other native subscriptions use Node's supported fs.watch API.
+ *
+ * @evidence contracts/performance.md#efficient-algorithms Cached availability selects one backend. Registration delegates path resolution, native subscription setup and, for FSEvents, ancestor lookup/descendant subscription transfers; event work remains with the selected backend. Delegated path/depth/watch populations are not bounded by this one-watch result.
+ *
+ * @evidence contracts/performance.md#reuse-equivalent-work The optional binding is loaded once per process; eligible macOS subscriptions share the registry's ancestor streams rather than constructing independent registries.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Returned subscriptions transfer close responsibility to their caller; the process registry retains binding availability and active stream/watch indexes. Closing the last stream subscriber removes logical ownership and attempts native stop; FSEvents stop errors are swallowed, so physical release is not confirmed on failure.
+ */
+function watchDirectory(location, recursive, listener) {
+    const streams = fseventsStreams();
+    if (streams !== undefined)
+        return streams.open(location, recursive, listener);
+    return (0, watchDirectoryThroughFsWatch_1.watchDirectoryThroughFsWatch)(location, recursive, listener);
+}
+let registry;
+/** The shared streams, or `undefined` where watches go through `fs.watch`. */
+function fseventsStreams() {
+    if (registry === undefined) {
+        registry = process.platform === "darwin" ? FseventsStreams_1.FseventsStreams.load() : null;
+    }
+    return registry ?? undefined;
+}
+//# sourceMappingURL=watchDirectory.js.map

package/lib/launcher/internal/watch/watchDirectory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchDirectory.js","sourceRoot":"","sources":["../../../../src/launcher/internal/watch/watchDirectory.ts"],"names":[],"mappings":";;;AACA,uDAAoD;AACpD,iFAA8E;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBACE,QAAgB,EAChB,SAAkB,EAClB,QAIS;IAET,MAAM,OAAO,GAAG,eAAe,EAAE,CAAC;IAClC,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC;IAC9E,OAAO,IAAA,2DAA4B,EAAC,QAAQ,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC;AACrE,CAAC;AAED,IAAI,QAA4C,CAAC;AAEjD,8EAA8E;AAC9E,SAAS,eAAe;IACtB,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,QAAQ,GAAG,OAAO,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,iCAAe,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;IAC3E,CAAC;IACD,OAAO,QAAQ,IAAI,SAAS,CAAC;AAC/B,CAAC"}

package/lib/launcher/internal/watch/watchDirectoryThroughFsWatch.d.ts

@@ -0,0 +1,28 @@
+import fs from "node:fs";
+import type { DirectoryWatcher } from "./DirectoryWatcher";
+/**
+ * Watch a directory through `fs.watch`, with the signature of `watchDirectory`:
+ * `change` for an entry whose content moved, `rename` for every other event,
+ * and a `null` name with a gap flag when anything below may have changed.
+ *
+ * This is the backend of every platform but macOS with the `fsevents` binding,
+ * and the one a caller chooses to observe the watch set through `fs.watch`.
+ *
+ * @param location The directory, spelled as the filesystem names it.
+ * @param recursive Whether entries below subdirectories are heard.
+ * @param listener Receives each event.
+ * @param openWatch Owned native-compatible subscription operation; fs.watch by
+ *   default.
+ * @returns The open watch.
+ * @evidence contracts/common.md#principled-implementation The native event and optional filename are normalized to the common watch contract; an absent name explicitly marks an observation gap.
+ * @evidence contracts/common.md#clear-and-simple-design One supported fs.watch subscription maps its event callback without another scheduling or polling layer.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unknown native events become the declared rename category, without invented filenames or patched fs methods. An explicitly supplied observer is invoked through this parameter rather than installed into the global filesystem.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs and parameters explain backend role, recursion and returned watch ownership following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Node owns native recursive-watch support and filename representation; this adapter preserves null names and converts present names through their native string boundary.
+ *
+ * @evidence contracts/performance.md#efficient-algorithms Subscription setup is delegated to the supplied native-compatible observer. Each callback selects one event category and converts present filename text through toString before invoking the listener; name-byte conversion and listener/native observer costs are not bounded by the fixed scalar mapping.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each requested subscription has its own listener and lifetime; registry sharing belongs to the selecting owner.
+ *
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The native default acquires one persistent FSWatcher; a supplied observer owns its corresponding subscription. The returned owner must close it on retirement, failure or shutdown. This adapter performs no close or release confirmation itself.
+ */
+export declare function watchDirectoryThroughFsWatch(location: string, recursive: boolean, listener: (event: "change" | "rename", filename: string | null, gap?: boolean) => void, openWatch?: typeof fs.watch): DirectoryWatcher;

package/lib/launcher/internal/watch/watchDirectoryThroughFsWatch.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchDirectoryThroughFsWatch = watchDirectoryThroughFsWatch;
+const node_fs_1 = __importDefault(require("node:fs"));
+/**
+ * Watch a directory through `fs.watch`, with the signature of `watchDirectory`:
+ * `change` for an entry whose content moved, `rename` for every other event,
+ * and a `null` name with a gap flag when anything below may have changed.
+ *
+ * This is the backend of every platform but macOS with the `fsevents` binding,
+ * and the one a caller chooses to observe the watch set through `fs.watch`.
+ *
+ * @param location The directory, spelled as the filesystem names it.
+ * @param recursive Whether entries below subdirectories are heard.
+ * @param listener Receives each event.
+ * @param openWatch Owned native-compatible subscription operation; fs.watch by
+ *   default.
+ * @returns The open watch.
+ * @evidence contracts/common.md#principled-implementation The native event and optional filename are normalized to the common watch contract; an absent name explicitly marks an observation gap.
+ * @evidence contracts/common.md#clear-and-simple-design One supported fs.watch subscription maps its event callback without another scheduling or polling layer.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unknown native events become the declared rename category, without invented filenames or patched fs methods. An explicitly supplied observer is invoked through this parameter rather than installed into the global filesystem.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs and parameters explain backend role, recursion and returned watch ownership following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Node owns native recursive-watch support and filename representation; this adapter preserves null names and converts present names through their native string boundary.
+ *
+ * @evidence contracts/performance.md#efficient-algorithms Subscription setup is delegated to the supplied native-compatible observer. Each callback selects one event category and converts present filename text through toString before invoking the listener; name-byte conversion and listener/native observer costs are not bounded by the fixed scalar mapping.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each requested subscription has its own listener and lifetime; registry sharing belongs to the selecting owner.
+ *
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The native default acquires one persistent FSWatcher; a supplied observer owns its corresponding subscription. The returned owner must close it on retirement, failure or shutdown. This adapter performs no close or release confirmation itself.
+ */
+function watchDirectoryThroughFsWatch(location, recursive, listener, openWatch = node_fs_1.default.watch) {
+    return openWatch(location, { persistent: true, recursive }, (event, name) => {
+        listener(event === "change" ? "change" : "rename", name === null ? null : name.toString(), name === null);
+    });
+}
+//# sourceMappingURL=watchDirectoryThroughFsWatch.js.map

package/lib/launcher/internal/watch/watchDirectoryThroughFsWatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchDirectoryThroughFsWatch.js","sourceRoot":"","sources":["../../../../src/launcher/internal/watch/watchDirectoryThroughFsWatch.ts"],"names":[],"mappings":";;;;;;AAAA,sDAAyB;AAIzB;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sCACE,QAAgB,EAChB,SAAkB,EAClB,QAIS,EACT,SAAS,GAAoB,iBAAE,CAAC,KAAK;IAErC,OAAO,SAAS,CAAC,QAAQ,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;QAC1E,QAAQ,CACN,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,EACxC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,EACtC,IAAI,KAAK,IAAI,CACd,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC"}

package/lib/launcher/ttscserver.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const runTtscserver_1 = require("./internal/runTtscserver");
+const runTtscserver_1 = require("./internal/ttscserver/runTtscserver");
 const code = (0, runTtscserver_1.runTtscserver)(process.argv.slice(2));
 if (typeof code === "number") {
     process.exitCode = code;

package/lib/launcher/ttscserver.js.map

@@ -1 +1 @@
-{"version":3,"file":"ttscserver.js","sourceRoot":"","sources":["../../src/launcher/ttscserver.ts"],"names":[],"mappings":";;;AAEA,4DAAyD;AAEzD,MAAM,IAAI,GAAG,IAAA,6BAAa,EAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAClD,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;IAC7B,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;AAC1B,CAAC"}
+{"version":3,"file":"ttscserver.js","sourceRoot":"","sources":["../../src/launcher/ttscserver.ts"],"names":[],"mappings":";;;AAEA,uEAAoE;AAEpE,MAAM,IAAI,GAAG,IAAA,6BAAa,EAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAClD,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;IAC7B,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;AAC1B,CAAC"}

package/lib/launcher/ttsx.js

@@ -2,8 +2,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const runTtsx_1 = require("./internal/runTtsx");
-const code = (0, runTtsx_1.runTtsx)(process.argv.slice(2));
-if (typeof code === "number") {
+void (0, runTtsx_1.runTtsx)(process.argv.slice(2)).then((code) => {
     process.exitCode = code;
-}
+});
 //# sourceMappingURL=ttsx.js.map

package/lib/launcher/ttsx.js.map

@@ -1 +1 @@
-{"version":3,"file":"ttsx.js","sourceRoot":"","sources":["../../src/launcher/ttsx.ts"],"names":[],"mappings":";;;AAEA,gDAA6C;AAE7C,MAAM,IAAI,GAAG,IAAA,iBAAO,EAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAC5C,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;IAC7B,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;AAC1B,CAAC"}
+{"version":3,"file":"ttsx.js","sourceRoot":"","sources":["../../src/launcher/ttsx.ts"],"names":[],"mappings":";;;AAEA,gDAA6C;AAE7C,KAAK,IAAA,iBAAO,EAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE;IAChD,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;AAC1B,CAAC,CAAC,CAAC"}

package/lib/plugin/CapabilityPluginResolver.d.ts

@@ -0,0 +1,140 @@
+import type { SpawnSyncOptions, SpawnSyncReturns } from "node:child_process";
+import type { ITtscCapabilityPlugin } from "./ITtscCapabilityPlugin";
+/**
+ * Own asynchronous capability discovery and its opaque freshness proofs. The
+ * same worker executes the existing synchronous resolver and keeps each
+ * original proof closure. Its native commands are relayed to a joined process
+ * supervisor, so cancellation unwinds build cleanup rather than killing the
+ * resolver thread while it holds a lease.
+ *
+ * @evidence contracts/common.md#principled-implementation Serial worker requests preserve the original resolver and proof objects; command containment completes before cancellation resumes their synchronous stacks.
+ * @evidence contracts/common.md#clear-and-simple-design This owner controls admission, worker RPC, opaque proof handles and shutdown; the worker owns synchronous discovery and the native owner controls process trees.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No consumer inventory replaces resolver authority and no warmup, altered timeout or uncontained fallback hides a cold producer.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains proof lifetime, cancellation cleanup and the independent native process owner.
+ * @evidence contracts/portability.md#os-neutral-implementation The compiled worker uses the SDK's CommonJS file layout, cloned environments and platform helper resolution rather than consumer-specific paths.
+ * @evidence contracts/performance.md#efficient-algorithms One worker serves serialized requests and retains original proof closures; command output serialization scales with returned bytes and request admission grows with submitted demand.
+ * @evidence contracts/performance.md#reuse-equivalent-work Worker reuse retains validated SDK caches but every resolve and currentness request still calls its original authority; proof handles never transfer freshness between generations.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Explicit release drops proof handles. Close aborts admitted work, joins command supervisors and waits for worker exit; private command exchange storage is removed after its request settles.
+ */
+export declare class CapabilityPluginResolver {
+    private worker;
+    private queue;
+    private nextId;
+    private generation;
+    private closed;
+    private closing;
+    private readonly controllers;
+    private readonly native;
+    private readonly failures;
+    private readonly exits;
+    /**
+     * Resolve through the SDK owner, retaining this exact answer's opaque proof.
+     *
+     * @evidence contracts/common.md#principled-implementation The original resolver creates the answer and closure; worker-generation-qualified handles prevent a restarted worker from reinterpreting an earlier proof number.
+     * @evidence contracts/common.md#clear-and-simple-design Returned currentness and release callbacks retain one answer while the owner serializes all worker operations.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Discovery and currentness execute the existing authority instead of substituting an inventory or inferring freshness from a cache path.
+     * @evidence contracts/common.md#meaningful-documentation The method describes retained opaque ownership; member types distinguish asynchronous proof queries and release.
+     * @evidence contracts/portability.md#os-neutral-implementation Cloned options and environment reach the packaged Node worker; native commands use the separate platform supervisor.
+     * @evidence contracts/performance.md#efficient-algorithms Resolution cost remains with the original resolver; the RPC copies returned plugin metadata and retains one closure per unreleased answer.
+     * @evidence contracts/performance.md#reuse-equivalent-work Every currentness query calls the original closure in its original worker generation; release or worker loss makes that proof unusable.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Explicit release removes the worker proof, while close clears all remaining proofs after cancelling and joining admitted work.
+     */
+    resolve(options: {
+        capability: string;
+        cwd?: string;
+        tsconfig?: string;
+    }, request?: {
+        signal?: AbortSignal;
+    }): Promise<CapabilityPluginResolver.Resolution>;
+    /**
+     * Execute an admitted publisher verb with the same native lifetime owner.
+     *
+     * @evidence contracts/common.md#principled-implementation Admission checks terminal ownership before registering a linked controller; the native owner supplies actual joined command outcomes.
+     * @evidence contracts/common.md#clear-and-simple-design This method links caller cancellation and owner shutdown to one native operation and removes both links on settlement.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts No synchronous fallback bypasses native containment when a publisher cannot use its resident daemon.
+     * @evidence contracts/common.md#meaningful-documentation Native prose identifies publisher execution and the shared lifetime owner; option support is enforced by that native owner.
+     * @evidence contracts/portability.md#os-neutral-implementation Exact argv and options reach the platform supervisor through OwnedNativeProcess rather than shell reconstruction in this method.
+     * @evidence contracts/performance.md#efficient-algorithms Admission and retirement use sets with one operation entry; output costs belong to the native operation.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Publisher verbs can have effects and must execute per admitted request.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Close can abort every registered operation, waits for its real completion, and retains non-cancellation failures instead of silently certifying clean shutdown.
+     */
+    runCommand(command: string, args: readonly string[], options: SpawnSyncOptions, request?: {
+        signal?: AbortSignal;
+    }): Promise<SpawnSyncReturns<string | Buffer>>;
+    /**
+     * Withdraw all admission and join native owners before releasing the worker.
+     *
+     * @evidence contracts/common.md#principled-implementation Terminal admission is set synchronously, then cancellation unwinds request cleanup before idle worker shutdown; every worker exit is joined even after an error event.
+     * @evidence contracts/common.md#clear-and-simple-design One memoized shutdown promise orders queue drain, native joining and worker exit.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts An error event is not treated as thread exit and a failed native receipt cannot become successful close.
+     * @evidence contracts/common.md#meaningful-documentation Native prose states admission withdrawal and join order; retained failures become an aggregate terminal error.
+     * @evidence contracts/portability.md#os-neutral-implementation AbortController and Worker exit events provide the Node lifetime boundary while platform process cleanup remains native-owned.
+     * @evidence contracts/performance.md#efficient-algorithms Shutdown visits admitted controllers, outstanding native operations and created worker exits once; their actual cleanup durations remain delegated.
+     * @evidence contracts/performance.md#reuse-equivalent-work Repeated close calls share the same terminal promise without reopening admission.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Queue completion and real native retirement precede worker close, and all created worker exit promises settle before the owner reports terminal success or retained failure.
+     */
+    close(): Promise<void>;
+    private request;
+    private call;
+    /** Keep idle worker failures observed and prevent reuse of a retired thread. */
+    private createWorker;
+    /** Retain failed ownership outcomes while treating requested abort as normal. */
+    private rememberFailure;
+    /** Refuse new work after a thread fails with potentially unknown lease state. */
+    private failWorker;
+}
+/**
+ * Public data and lifetime contract of an asynchronously owned lookup.
+ *
+ * This namespace augments the class's single semantic owner with the result
+ * type. The class acknowledges that owner; Resolution describes its data and
+ * callback contract separately.
+ */
+export declare namespace CapabilityPluginResolver {
+    /**
+     * The original lookup's data and asynchronous proof lifetime.
+     *
+     * @evidence contracts/common.md#principled-implementation The proof callbacks refer to this exact lookup and its worker generation rather than a reconstructed cache witness.
+     * @evidence contracts/common.md#clear-and-simple-design Status and plugin data are separate from asynchronous currentness and terminal release.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The type promises an opaque query, not an inferred freshness flag or bypass of resolver authority.
+     * @evidence contracts/common.md#meaningful-documentation Member prose identifies answer data, optional cancellation and explicit proof retirement.
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation This data and callback type chooses no filesystem or process primitive.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms The interface chooses no execution strategy; resolve and its request owner implement the operations.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work The interface defines proof identity but performs no result sharing.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Actual proof retention and release belong to the resolver callbacks, not this declaration.
+     */
+    interface Resolution {
+        /** Original resolver availability classification. */
+        readonly status: "resolved" | "unavailable";
+        /** Published capability metadata from this lookup. */
+        readonly plugins: readonly ITtscCapabilityPlugin[];
+        /**
+         * Query the retained proof, optionally withdrawing payload admission.
+         *
+         * @evidence contracts/common.md#principled-implementation This callback refers to the original lookup and worker generation, so only its original authority can establish currentness.
+         * @evidence contracts/common.md#clear-and-simple-design An optional signal controls one asynchronous proof query and the boolean conveys only its acceptance.
+         * @evidence contracts/common.md#prohibited-implementation-shortcuts The contract does not allow rebuilding a partial inventory or treating an unavailable answer as a reusable result.
+         * @evidence contracts/common.md#meaningful-documentation Native prose explains retained proof identity and cancellation without claiming that the type performs the query.
+         * @evidenceExclude contracts/portability.md#os-neutral-implementation This callable field declares a query; the resolver implements its actual native boundary.
+         * @evidenceExclude contracts/performance.md#efficient-algorithms A function type declares no algorithm; resolve and request own execution costs.
+         * @evidenceExclude contracts/performance.md#reuse-equivalent-work The type establishes proof identity but itself shares no computation.
+         * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The field declares no acquired resource; its owning resolver retains and releases the proof.
+         */
+        readonly isCurrent: (options?: {
+            signal?: AbortSignal;
+        }) => Promise<boolean>;
+        /**
+         * Retire this proof without affecting a later worker generation.
+         *
+         * @evidence contracts/common.md#principled-implementation Release is bound to this answer's generation-qualified handle and cannot retire a later answer with a repeated numeric handle.
+         * @evidence contracts/common.md#clear-and-simple-design One asynchronous terminal callback withdraws this answer's reusable proof.
+         * @evidence contracts/common.md#prohibited-implementation-shortcuts The callback describes real proof retirement rather than changing its currentness flag while retaining its closure indefinitely.
+         * @evidence contracts/common.md#meaningful-documentation Native prose identifies which proof is retired and excludes later generations.
+         * @evidenceExclude contracts/portability.md#os-neutral-implementation This callable type selects no platform primitive; the owner implements its worker communication.
+         * @evidenceExclude contracts/performance.md#efficient-algorithms The field declares a callback and performs no processing.
+         * @evidenceExclude contracts/performance.md#reuse-equivalent-work Release is terminal proof ownership, not a computation-sharing operation.
+         * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The declaration itself acquires no resource; resolve's closure and close implement actual retirement.
+         */
+        readonly release: () => Promise<void>;
+    }
+}