@ttsc/unplugin 0.31.0 → 0.31.1

package/lib/core/transform/tracker/broker/WatchBrokerTransport.d.cts

@@ -0,0 +1,63 @@
+import type { WatchBroker } from "./WatchBroker.cjs";
+/**
+ * Common lifecycle seam for the native Windows stdio broker and macOS IPC.
+ *
+ * The transport owns framing and demand references only. Ordered native
+ * notifications and per-registration readiness remain backend responsibilities;
+ * a successful send cannot certify coverage or cache reuse.
+ *
+ * @evidence contracts/common.md#principled-implementation One transport seam preserves explicit failure and reference ownership for both supported broker backends.
+ * @evidence contracts/common.md#clear-and-simple-design Callers express send, demand and retirement through this namespace instead of duplicating platform checks or modifying a ChildProcess.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Supported child streams and IPC APIs are used without replacing runtime methods.
+ * @evidence contracts/common.md#meaningful-documentation Native prose separates transport completion from native watch authority.
+ * @evidence contracts/portability.md#os-neutral-implementation Native selection stays at broker startup; all tracker and observer consumers share these operations.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms Member operations own their delegated cost.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The broker owner selects transport and sharing lifetime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This namespace itself retains no transport registry.
+ */
+export declare namespace WatchBrokerTransport {
+    /**
+     * Queue a message on the selected transport. False refuses delivery; true
+     * only means queued, with actual acknowledgment or failure still
+     * outstanding.
+     *
+     * @evidence contracts/common.md#principled-implementation Native and IPC transports preserve separate queue acceptance and observed backend replies.
+     * @evidence contracts/common.md#clear-and-simple-design One selection delegates framing to the startup-owned transport.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts No queue result is upgraded into readiness or a native drain.
+     * @evidence contracts/common.md#meaningful-documentation Native prose states the limited meaning of the returned boolean.
+     * @evidence contracts/portability.md#os-neutral-implementation Explicit stdio capability takes precedence over optional IPC.
+     * @evidence contracts/performance.md#efficient-algorithms Transport selection is fixed work; JSON framing, message bytes and pipe backpressure belong to the selected sender.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Sending an effect does not own computation reuse.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The selected sender and request owner retain queued bytes and outstanding acknowledgment state.
+     */
+    function send(broker: WatchBroker, message: unknown): boolean;
+    /**
+     * Keep the selected reply channel live exactly while caller demand exists.
+     * Counts belong to registration/drain owners; native references are flags.
+     *
+     * @evidence contracts/common.md#principled-implementation Outstanding requests retain both process and reply channel, preventing host exit before acknowledgment.
+     * @evidence contracts/common.md#clear-and-simple-design One operation applies the caller's aggregated demand to either transport.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Optional Bun IPC methods are used as capabilities without installing replacements.
+     * @evidence contracts/common.md#meaningful-documentation Native prose identifies count ownership and flag semantics.
+     * @evidence contracts/portability.md#os-neutral-implementation Optional IPC methods and a selected native pipe capability express runtime differences.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms Reference toggling selects no data-processing algorithm.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This effect owns no shared computation.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources The caller supplies aggregate demand; removing the last demand unreferences process and reply channel without asserting native termination.
+     */
+    function reference(broker: WatchBroker, active: boolean): void;
+    /**
+     * End this broker's request stream. The last-registration owner separately
+     * attempts process termination; closing a channel is not proof of child
+     * exit.
+     *
+     * @evidence contracts/common.md#principled-implementation Channel retirement is distinct from process exit and native resource closure.
+     * @evidence contracts/common.md#clear-and-simple-design Startup-owned transport closes its request stream without platform checks in consumers.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Supported end/disconnect operations preserve native ownership without synthetic exit acknowledgment.
+     * @evidence contracts/common.md#meaningful-documentation Native prose identifies the independent termination attempt and limited closure meaning.
+     * @evidence contracts/portability.md#os-neutral-implementation Selected stream closure and optional IPC disconnection keep platform details behind the transport seam.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms Closing one channel selects no processing algorithm.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Retirement owns no computation reuse.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources The selected transport ends its input; process kill and actual native cleanup remain the broker and backend's responsibilities.
+     */
+    function close(broker: WatchBroker): void;
+}

package/lib/core/transform/tracker/broker/WatchBrokerTransport.d.mts

@@ -0,0 +1,63 @@
+import type { WatchBroker } from "./WatchBroker.mjs";
+/**
+ * Common lifecycle seam for the native Windows stdio broker and macOS IPC.
+ *
+ * The transport owns framing and demand references only. Ordered native
+ * notifications and per-registration readiness remain backend responsibilities;
+ * a successful send cannot certify coverage or cache reuse.
+ *
+ * @evidence contracts/common.md#principled-implementation One transport seam preserves explicit failure and reference ownership for both supported broker backends.
+ * @evidence contracts/common.md#clear-and-simple-design Callers express send, demand and retirement through this namespace instead of duplicating platform checks or modifying a ChildProcess.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Supported child streams and IPC APIs are used without replacing runtime methods.
+ * @evidence contracts/common.md#meaningful-documentation Native prose separates transport completion from native watch authority.
+ * @evidence contracts/portability.md#os-neutral-implementation Native selection stays at broker startup; all tracker and observer consumers share these operations.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms Member operations own their delegated cost.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The broker owner selects transport and sharing lifetime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This namespace itself retains no transport registry.
+ */
+export declare namespace WatchBrokerTransport {
+    /**
+     * Queue a message on the selected transport. False refuses delivery; true
+     * only means queued, with actual acknowledgment or failure still
+     * outstanding.
+     *
+     * @evidence contracts/common.md#principled-implementation Native and IPC transports preserve separate queue acceptance and observed backend replies.
+     * @evidence contracts/common.md#clear-and-simple-design One selection delegates framing to the startup-owned transport.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts No queue result is upgraded into readiness or a native drain.
+     * @evidence contracts/common.md#meaningful-documentation Native prose states the limited meaning of the returned boolean.
+     * @evidence contracts/portability.md#os-neutral-implementation Explicit stdio capability takes precedence over optional IPC.
+     * @evidence contracts/performance.md#efficient-algorithms Transport selection is fixed work; JSON framing, message bytes and pipe backpressure belong to the selected sender.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Sending an effect does not own computation reuse.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The selected sender and request owner retain queued bytes and outstanding acknowledgment state.
+     */
+    function send(broker: WatchBroker, message: unknown): boolean;
+    /**
+     * Keep the selected reply channel live exactly while caller demand exists.
+     * Counts belong to registration/drain owners; native references are flags.
+     *
+     * @evidence contracts/common.md#principled-implementation Outstanding requests retain both process and reply channel, preventing host exit before acknowledgment.
+     * @evidence contracts/common.md#clear-and-simple-design One operation applies the caller's aggregated demand to either transport.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Optional Bun IPC methods are used as capabilities without installing replacements.
+     * @evidence contracts/common.md#meaningful-documentation Native prose identifies count ownership and flag semantics.
+     * @evidence contracts/portability.md#os-neutral-implementation Optional IPC methods and a selected native pipe capability express runtime differences.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms Reference toggling selects no data-processing algorithm.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This effect owns no shared computation.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources The caller supplies aggregate demand; removing the last demand unreferences process and reply channel without asserting native termination.
+     */
+    function reference(broker: WatchBroker, active: boolean): void;
+    /**
+     * End this broker's request stream. The last-registration owner separately
+     * attempts process termination; closing a channel is not proof of child
+     * exit.
+     *
+     * @evidence contracts/common.md#principled-implementation Channel retirement is distinct from process exit and native resource closure.
+     * @evidence contracts/common.md#clear-and-simple-design Startup-owned transport closes its request stream without platform checks in consumers.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Supported end/disconnect operations preserve native ownership without synthetic exit acknowledgment.
+     * @evidence contracts/common.md#meaningful-documentation Native prose identifies the independent termination attempt and limited closure meaning.
+     * @evidence contracts/portability.md#os-neutral-implementation Selected stream closure and optional IPC disconnection keep platform details behind the transport seam.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms Closing one channel selects no processing algorithm.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Retirement owns no computation reuse.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources The selected transport ends its input; process kill and actual native cleanup remain the broker and backend's responsibilities.
+     */
+    function close(broker: WatchBroker): void;
+}

package/lib/core/transform/tracker/broker/WatchBrokerTransport.d.ts

@@ -0,0 +1,63 @@
+import type { WatchBroker } from "./WatchBroker";
+/**
+ * Common lifecycle seam for the native Windows stdio broker and macOS IPC.
+ *
+ * The transport owns framing and demand references only. Ordered native
+ * notifications and per-registration readiness remain backend responsibilities;
+ * a successful send cannot certify coverage or cache reuse.
+ *
+ * @evidence contracts/common.md#principled-implementation One transport seam preserves explicit failure and reference ownership for both supported broker backends.
+ * @evidence contracts/common.md#clear-and-simple-design Callers express send, demand and retirement through this namespace instead of duplicating platform checks or modifying a ChildProcess.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Supported child streams and IPC APIs are used without replacing runtime methods.
+ * @evidence contracts/common.md#meaningful-documentation Native prose separates transport completion from native watch authority.
+ * @evidence contracts/portability.md#os-neutral-implementation Native selection stays at broker startup; all tracker and observer consumers share these operations.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms Member operations own their delegated cost.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The broker owner selects transport and sharing lifetime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This namespace itself retains no transport registry.
+ */
+export declare namespace WatchBrokerTransport {
+    /**
+     * Queue a message on the selected transport. False refuses delivery; true
+     * only means queued, with actual acknowledgment or failure still
+     * outstanding.
+     *
+     * @evidence contracts/common.md#principled-implementation Native and IPC transports preserve separate queue acceptance and observed backend replies.
+     * @evidence contracts/common.md#clear-and-simple-design One selection delegates framing to the startup-owned transport.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts No queue result is upgraded into readiness or a native drain.
+     * @evidence contracts/common.md#meaningful-documentation Native prose states the limited meaning of the returned boolean.
+     * @evidence contracts/portability.md#os-neutral-implementation Explicit stdio capability takes precedence over optional IPC.
+     * @evidence contracts/performance.md#efficient-algorithms Transport selection is fixed work; JSON framing, message bytes and pipe backpressure belong to the selected sender.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Sending an effect does not own computation reuse.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The selected sender and request owner retain queued bytes and outstanding acknowledgment state.
+     */
+    function send(broker: WatchBroker, message: unknown): boolean;
+    /**
+     * Keep the selected reply channel live exactly while caller demand exists.
+     * Counts belong to registration/drain owners; native references are flags.
+     *
+     * @evidence contracts/common.md#principled-implementation Outstanding requests retain both process and reply channel, preventing host exit before acknowledgment.
+     * @evidence contracts/common.md#clear-and-simple-design One operation applies the caller's aggregated demand to either transport.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Optional Bun IPC methods are used as capabilities without installing replacements.
+     * @evidence contracts/common.md#meaningful-documentation Native prose identifies count ownership and flag semantics.
+     * @evidence contracts/portability.md#os-neutral-implementation Optional IPC methods and a selected native pipe capability express runtime differences.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms Reference toggling selects no data-processing algorithm.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This effect owns no shared computation.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources The caller supplies aggregate demand; removing the last demand unreferences process and reply channel without asserting native termination.
+     */
+    function reference(broker: WatchBroker, active: boolean): void;
+    /**
+     * End this broker's request stream. The last-registration owner separately
+     * attempts process termination; closing a channel is not proof of child
+     * exit.
+     *
+     * @evidence contracts/common.md#principled-implementation Channel retirement is distinct from process exit and native resource closure.
+     * @evidence contracts/common.md#clear-and-simple-design Startup-owned transport closes its request stream without platform checks in consumers.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Supported end/disconnect operations preserve native ownership without synthetic exit acknowledgment.
+     * @evidence contracts/common.md#meaningful-documentation Native prose identifies the independent termination attempt and limited closure meaning.
+     * @evidence contracts/portability.md#os-neutral-implementation Selected stream closure and optional IPC disconnection keep platform details behind the transport seam.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms Closing one channel selects no processing algorithm.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Retirement owns no computation reuse.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources The selected transport ends its input; process kill and actual native cleanup remain the broker and backend's responsibilities.
+     */
+    function close(broker: WatchBroker): void;
+}

package/lib/core/transform/tracker/broker/WatchBrokerTransport.js

@@ -0,0 +1,89 @@
+'use strict';
+
+/**
+ * Common lifecycle seam for the native Windows stdio broker and macOS IPC.
+ *
+ * The transport owns framing and demand references only. Ordered native
+ * notifications and per-registration readiness remain backend responsibilities;
+ * a successful send cannot certify coverage or cache reuse.
+ *
+ * @evidence contracts/common.md#principled-implementation One transport seam preserves explicit failure and reference ownership for both supported broker backends.
+ * @evidence contracts/common.md#clear-and-simple-design Callers express send, demand and retirement through this namespace instead of duplicating platform checks or modifying a ChildProcess.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Supported child streams and IPC APIs are used without replacing runtime methods.
+ * @evidence contracts/common.md#meaningful-documentation Native prose separates transport completion from native watch authority.
+ * @evidence contracts/portability.md#os-neutral-implementation Native selection stays at broker startup; all tracker and observer consumers share these operations.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms Member operations own their delegated cost.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The broker owner selects transport and sharing lifetime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This namespace itself retains no transport registry.
+ */
+exports.WatchBrokerTransport = void 0;
+(function (WatchBrokerTransport) {
+    /**
+     * Queue a message on the selected transport. False refuses delivery; true
+     * only means queued, with actual acknowledgment or failure still
+     * outstanding.
+     *
+     * @evidence contracts/common.md#principled-implementation Native and IPC transports preserve separate queue acceptance and observed backend replies.
+     * @evidence contracts/common.md#clear-and-simple-design One selection delegates framing to the startup-owned transport.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts No queue result is upgraded into readiness or a native drain.
+     * @evidence contracts/common.md#meaningful-documentation Native prose states the limited meaning of the returned boolean.
+     * @evidence contracts/portability.md#os-neutral-implementation Explicit stdio capability takes precedence over optional IPC.
+     * @evidence contracts/performance.md#efficient-algorithms Transport selection is fixed work; JSON framing, message bytes and pipe backpressure belong to the selected sender.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Sending an effect does not own computation reuse.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The selected sender and request owner retain queued bytes and outstanding acknowledgment state.
+     */
+    function send(broker, message) {
+        return broker.transport === undefined
+            ? broker.child.send?.(message) === true
+            : broker.transport.send(message);
+    }
+    WatchBrokerTransport.send = send;
+    /**
+     * Keep the selected reply channel live exactly while caller demand exists.
+     * Counts belong to registration/drain owners; native references are flags.
+     *
+     * @evidence contracts/common.md#principled-implementation Outstanding requests retain both process and reply channel, preventing host exit before acknowledgment.
+     * @evidence contracts/common.md#clear-and-simple-design One operation applies the caller's aggregated demand to either transport.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Optional Bun IPC methods are used as capabilities without installing replacements.
+     * @evidence contracts/common.md#meaningful-documentation Native prose identifies count ownership and flag semantics.
+     * @evidence contracts/portability.md#os-neutral-implementation Optional IPC methods and a selected native pipe capability express runtime differences.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms Reference toggling selects no data-processing algorithm.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This effect owns no shared computation.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources The caller supplies aggregate demand; removing the last demand unreferences process and reply channel without asserting native termination.
+     */
+    function reference(broker, active) {
+        if (broker.transport !== undefined)
+            broker.transport.reference(active);
+        else if (active) {
+            broker.child.ref();
+            broker.child.channel?.ref?.();
+        }
+        else {
+            broker.child.unref();
+            broker.child.channel?.unref?.();
+        }
+    }
+    WatchBrokerTransport.reference = reference;
+    /**
+     * End this broker's request stream. The last-registration owner separately
+     * attempts process termination; closing a channel is not proof of child
+     * exit.
+     *
+     * @evidence contracts/common.md#principled-implementation Channel retirement is distinct from process exit and native resource closure.
+     * @evidence contracts/common.md#clear-and-simple-design Startup-owned transport closes its request stream without platform checks in consumers.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Supported end/disconnect operations preserve native ownership without synthetic exit acknowledgment.
+     * @evidence contracts/common.md#meaningful-documentation Native prose identifies the independent termination attempt and limited closure meaning.
+     * @evidence contracts/portability.md#os-neutral-implementation Selected stream closure and optional IPC disconnection keep platform details behind the transport seam.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms Closing one channel selects no processing algorithm.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Retirement owns no computation reuse.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources The selected transport ends its input; process kill and actual native cleanup remain the broker and backend's responsibilities.
+     */
+    function close(broker) {
+        if (broker.transport !== undefined)
+            broker.transport.close();
+        else
+            broker.child.disconnect?.();
+    }
+    WatchBrokerTransport.close = close;
+})(exports.WatchBrokerTransport || (exports.WatchBrokerTransport = {}));
+//# sourceMappingURL=WatchBrokerTransport.js.map

package/lib/core/transform/tracker/broker/WatchBrokerTransport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WatchBrokerTransport.js","sources":["../../../../../src/core/transform/tracker/broker/WatchBrokerTransport.ts"],"sourcesContent":[null],"names":["WatchBrokerTransport"],"mappings":";;AAEA;;;;;;;;;;;;;;;AAeG;AACcA;AAAjB,CAAA,UAAiB,oBAAoB,EAAA;AACnC;;;;;;;;;;;;;AAaG;AACH,IAAA,SAAgB,IAAI,CAAC,MAAmB,EAAE,OAAgB,EAAA;AACxD,QAAA,OAAO,MAAM,CAAC,SAAS,KAAK;cACxB,MAAM,CAAC,KAAK,CAAC,IAAI,GAAG,OAAiB,CAAC,KAAK;cAC3C,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC;IACpC;AAJgB,IAAA,oBAAA,CAAA,IAAI,OAInB;AAED;;;;;;;;;;;;AAYG;AACH,IAAA,SAAgB,SAAS,CAAC,MAAmB,EAAE,MAAe,EAAA;AAC5D,QAAA,IAAI,MAAM,CAAC,SAAS,KAAK,SAAS;AAAE,YAAA,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC;aACjE,IAAI,MAAM,EAAE;AACf,YAAA,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE;YAClB,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,GAAG,IAAI;QAC/B;aAAO;AACL,YAAA,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE;YACpB,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,IAAI;QACjC;IACF;AATgB,IAAA,oBAAA,CAAA,SAAS,YASxB;AAED;;;;;;;;;;;;;AAaG;IACH,SAAgB,KAAK,CAAC,MAAmB,EAAA;AACvC,QAAA,IAAI,MAAM,CAAC,SAAS,KAAK,SAAS;AAAE,YAAA,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE;;AACvD,YAAA,MAAM,CAAC,KAAK,CAAC,UAAU,IAAI;IAClC;AAHgB,IAAA,oBAAA,CAAA,KAAK,QAGpB;AACH,CAAC,EA/DgBA,4BAAoB,KAApBA,4BAAoB,GAAA,EAAA,CAAA,CAAA;;"}

package/lib/core/transform/tracker/broker/WatchBrokerTransport.mjs

@@ -0,0 +1,89 @@
+/**
+ * Common lifecycle seam for the native Windows stdio broker and macOS IPC.
+ *
+ * The transport owns framing and demand references only. Ordered native
+ * notifications and per-registration readiness remain backend responsibilities;
+ * a successful send cannot certify coverage or cache reuse.
+ *
+ * @evidence contracts/common.md#principled-implementation One transport seam preserves explicit failure and reference ownership for both supported broker backends.
+ * @evidence contracts/common.md#clear-and-simple-design Callers express send, demand and retirement through this namespace instead of duplicating platform checks or modifying a ChildProcess.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Supported child streams and IPC APIs are used without replacing runtime methods.
+ * @evidence contracts/common.md#meaningful-documentation Native prose separates transport completion from native watch authority.
+ * @evidence contracts/portability.md#os-neutral-implementation Native selection stays at broker startup; all tracker and observer consumers share these operations.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms Member operations own their delegated cost.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The broker owner selects transport and sharing lifetime.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This namespace itself retains no transport registry.
+ */
+var WatchBrokerTransport;
+(function (WatchBrokerTransport) {
+    /**
+     * Queue a message on the selected transport. False refuses delivery; true
+     * only means queued, with actual acknowledgment or failure still
+     * outstanding.
+     *
+     * @evidence contracts/common.md#principled-implementation Native and IPC transports preserve separate queue acceptance and observed backend replies.
+     * @evidence contracts/common.md#clear-and-simple-design One selection delegates framing to the startup-owned transport.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts No queue result is upgraded into readiness or a native drain.
+     * @evidence contracts/common.md#meaningful-documentation Native prose states the limited meaning of the returned boolean.
+     * @evidence contracts/portability.md#os-neutral-implementation Explicit stdio capability takes precedence over optional IPC.
+     * @evidence contracts/performance.md#efficient-algorithms Transport selection is fixed work; JSON framing, message bytes and pipe backpressure belong to the selected sender.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Sending an effect does not own computation reuse.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The selected sender and request owner retain queued bytes and outstanding acknowledgment state.
+     */
+    function send(broker, message) {
+        return broker.transport === undefined
+            ? broker.child.send?.(message) === true
+            : broker.transport.send(message);
+    }
+    WatchBrokerTransport.send = send;
+    /**
+     * Keep the selected reply channel live exactly while caller demand exists.
+     * Counts belong to registration/drain owners; native references are flags.
+     *
+     * @evidence contracts/common.md#principled-implementation Outstanding requests retain both process and reply channel, preventing host exit before acknowledgment.
+     * @evidence contracts/common.md#clear-and-simple-design One operation applies the caller's aggregated demand to either transport.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Optional Bun IPC methods are used as capabilities without installing replacements.
+     * @evidence contracts/common.md#meaningful-documentation Native prose identifies count ownership and flag semantics.
+     * @evidence contracts/portability.md#os-neutral-implementation Optional IPC methods and a selected native pipe capability express runtime differences.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms Reference toggling selects no data-processing algorithm.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This effect owns no shared computation.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources The caller supplies aggregate demand; removing the last demand unreferences process and reply channel without asserting native termination.
+     */
+    function reference(broker, active) {
+        if (broker.transport !== undefined)
+            broker.transport.reference(active);
+        else if (active) {
+            broker.child.ref();
+            broker.child.channel?.ref?.();
+        }
+        else {
+            broker.child.unref();
+            broker.child.channel?.unref?.();
+        }
+    }
+    WatchBrokerTransport.reference = reference;
+    /**
+     * End this broker's request stream. The last-registration owner separately
+     * attempts process termination; closing a channel is not proof of child
+     * exit.
+     *
+     * @evidence contracts/common.md#principled-implementation Channel retirement is distinct from process exit and native resource closure.
+     * @evidence contracts/common.md#clear-and-simple-design Startup-owned transport closes its request stream without platform checks in consumers.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Supported end/disconnect operations preserve native ownership without synthetic exit acknowledgment.
+     * @evidence contracts/common.md#meaningful-documentation Native prose identifies the independent termination attempt and limited closure meaning.
+     * @evidence contracts/portability.md#os-neutral-implementation Selected stream closure and optional IPC disconnection keep platform details behind the transport seam.
+     * @evidenceExclude contracts/performance.md#efficient-algorithms Closing one channel selects no processing algorithm.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Retirement owns no computation reuse.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources The selected transport ends its input; process kill and actual native cleanup remain the broker and backend's responsibilities.
+     */
+    function close(broker) {
+        if (broker.transport !== undefined)
+            broker.transport.close();
+        else
+            broker.child.disconnect?.();
+    }
+    WatchBrokerTransport.close = close;
+})(WatchBrokerTransport || (WatchBrokerTransport = {}));
+
+export { WatchBrokerTransport };
+//# sourceMappingURL=WatchBrokerTransport.mjs.map

package/lib/core/transform/tracker/broker/WatchBrokerTransport.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"WatchBrokerTransport.mjs","sources":["../../../../../src/core/transform/tracker/broker/WatchBrokerTransport.ts"],"sourcesContent":[null],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;AAeG;AACG,IAAW;AAAjB,CAAA,UAAiB,oBAAoB,EAAA;AACnC;;;;;;;;;;;;;AAaG;AACH,IAAA,SAAgB,IAAI,CAAC,MAAmB,EAAE,OAAgB,EAAA;AACxD,QAAA,OAAO,MAAM,CAAC,SAAS,KAAK;cACxB,MAAM,CAAC,KAAK,CAAC,IAAI,GAAG,OAAiB,CAAC,KAAK;cAC3C,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC;IACpC;AAJgB,IAAA,oBAAA,CAAA,IAAI,OAInB;AAED;;;;;;;;;;;;AAYG;AACH,IAAA,SAAgB,SAAS,CAAC,MAAmB,EAAE,MAAe,EAAA;AAC5D,QAAA,IAAI,MAAM,CAAC,SAAS,KAAK,SAAS;AAAE,YAAA,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC;aACjE,IAAI,MAAM,EAAE;AACf,YAAA,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE;YAClB,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,GAAG,IAAI;QAC/B;aAAO;AACL,YAAA,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE;YACpB,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,IAAI;QACjC;IACF;AATgB,IAAA,oBAAA,CAAA,SAAS,YASxB;AAED;;;;;;;;;;;;;AAaG;IACH,SAAgB,KAAK,CAAC,MAAmB,EAAA;AACvC,QAAA,IAAI,MAAM,CAAC,SAAS,KAAK,SAAS;AAAE,YAAA,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE;;AACvD,YAAA,MAAM,CAAC,KAAK,CAAC,UAAU,IAAI;IAClC;AAHgB,IAAA,oBAAA,CAAA,KAAK,QAGpB;AACH,CAAC,EA/DgB,oBAAoB,KAApB,oBAAoB,GAAA,EAAA,CAAA,CAAA;;;;"}

package/lib/core/transform/tracker/broker/drainWatchBroker.d.cts

@@ -2,13 +2,13 @@ import type { WatchBroker } from "./WatchBroker.cjs";
 /**
  * Ask the watch broker to acknowledge, and resolve with whether it did.
  *
- * The child answers after two turns of its own loop, so a watch callback it had
- * already queued has run, and the ordered IPC channel puts every message it
- * sent before the reply ahead of the reply. That is the same proof an
- * in-process watcher gets from a macrotask turn, rather than the fixed wait
- * this replaces, which guessed at the crossing (samchon/ttsc#1272). On macOS
- * the child answers once each stream it can prove has delivered a probe, which
- * takes the service's latency (samchon/ttsc#1453).
+ * Windows answers after consuming currently queued native completions to an
+ * observed empty port. macOS answers once each provable stream has delivered a
+ * probe, including the service's latency (#1453). Ordered transport applies
+ * every preceding event before the reply. These are current backend frontiers,
+ * not atomic timestamp classification of concurrent writes. The optional direct
+ * fs.watch program retains its explicit two-turn frontier for protocol tests;
+ * it does not supply Windows production proof (#1719).
  *
  * A broker that never answers must not hold a delivery, so the wait gives up
  * after a threshold of twice the probe timeout: the child itself gives up on a
@@ -48,7 +48,7 @@ import type { WatchBroker } from "./WatchBroker.cjs";
  *   Native paragraphs and parameters explain ordering, coverage, sharing and
  *   false deadlines under the documentation skill.
  * @evidence contracts/portability.md#os-neutral-implementation
- *   OS-neutral host delivery delegates Windows loop ordering and macOS stream
+ *   OS-neutral host delivery delegates Windows completion-port drainage and macOS stream
  *   probing to the native broker rather than applying one universal timing guess.
  * @evidence contracts/performance.md#efficient-algorithms
  *   A covering memo query uses fixed identity/id lookup. New requests copy all N

package/lib/core/transform/tracker/broker/drainWatchBroker.d.mts

@@ -2,13 +2,13 @@ import type { WatchBroker } from "./WatchBroker.mjs";
 /**
  * Ask the watch broker to acknowledge, and resolve with whether it did.
  *
- * The child answers after two turns of its own loop, so a watch callback it had
- * already queued has run, and the ordered IPC channel puts every message it
- * sent before the reply ahead of the reply. That is the same proof an
- * in-process watcher gets from a macrotask turn, rather than the fixed wait
- * this replaces, which guessed at the crossing (samchon/ttsc#1272). On macOS
- * the child answers once each stream it can prove has delivered a probe, which
- * takes the service's latency (samchon/ttsc#1453).
+ * Windows answers after consuming currently queued native completions to an
+ * observed empty port. macOS answers once each provable stream has delivered a
+ * probe, including the service's latency (#1453). Ordered transport applies
+ * every preceding event before the reply. These are current backend frontiers,
+ * not atomic timestamp classification of concurrent writes. The optional direct
+ * fs.watch program retains its explicit two-turn frontier for protocol tests;
+ * it does not supply Windows production proof (#1719).
  *
  * A broker that never answers must not hold a delivery, so the wait gives up
  * after a threshold of twice the probe timeout: the child itself gives up on a
@@ -48,7 +48,7 @@ import type { WatchBroker } from "./WatchBroker.mjs";
  *   Native paragraphs and parameters explain ordering, coverage, sharing and
  *   false deadlines under the documentation skill.
  * @evidence contracts/portability.md#os-neutral-implementation
- *   OS-neutral host delivery delegates Windows loop ordering and macOS stream
+ *   OS-neutral host delivery delegates Windows completion-port drainage and macOS stream
  *   probing to the native broker rather than applying one universal timing guess.
  * @evidence contracts/performance.md#efficient-algorithms
  *   A covering memo query uses fixed identity/id lookup. New requests copy all N

package/lib/core/transform/tracker/broker/drainWatchBroker.d.ts

@@ -2,13 +2,13 @@ import type { WatchBroker } from "./WatchBroker";
 /**
  * Ask the watch broker to acknowledge, and resolve with whether it did.
  *
- * The child answers after two turns of its own loop, so a watch callback it had
- * already queued has run, and the ordered IPC channel puts every message it
- * sent before the reply ahead of the reply. That is the same proof an
- * in-process watcher gets from a macrotask turn, rather than the fixed wait
- * this replaces, which guessed at the crossing (samchon/ttsc#1272). On macOS
- * the child answers once each stream it can prove has delivered a probe, which
- * takes the service's latency (samchon/ttsc#1453).
+ * Windows answers after consuming currently queued native completions to an
+ * observed empty port. macOS answers once each provable stream has delivered a
+ * probe, including the service's latency (#1453). Ordered transport applies
+ * every preceding event before the reply. These are current backend frontiers,
+ * not atomic timestamp classification of concurrent writes. The optional direct
+ * fs.watch program retains its explicit two-turn frontier for protocol tests;
+ * it does not supply Windows production proof (#1719).
  *
  * A broker that never answers must not hold a delivery, so the wait gives up
  * after a threshold of twice the probe timeout: the child itself gives up on a
@@ -48,7 +48,7 @@ import type { WatchBroker } from "./WatchBroker";
  *   Native paragraphs and parameters explain ordering, coverage, sharing and
  *   false deadlines under the documentation skill.
  * @evidence contracts/portability.md#os-neutral-implementation
- *   OS-neutral host delivery delegates Windows loop ordering and macOS stream
+ *   OS-neutral host delivery delegates Windows completion-port drainage and macOS stream
  *   probing to the native broker rather than applying one universal timing guess.
  * @evidence contracts/performance.md#efficient-algorithms
  *   A covering memo query uses fixed identity/id lookup. New requests copy all N

package/lib/core/transform/tracker/broker/drainWatchBroker.js

@@ -1,17 +1,18 @@
 'use strict';
 
 var WATCH_PROBE_TIMEOUT_MS = require('./WATCH_PROBE_TIMEOUT_MS.js');
+var WatchBrokerTransport = require('./WatchBrokerTransport.js');
 
 /**
  * Ask the watch broker to acknowledge, and resolve with whether it did.
  *
- * The child answers after two turns of its own loop, so a watch callback it had
- * already queued has run, and the ordered IPC channel puts every message it
- * sent before the reply ahead of the reply. That is the same proof an
- * in-process watcher gets from a macrotask turn, rather than the fixed wait
- * this replaces, which guessed at the crossing (samchon/ttsc#1272). On macOS
- * the child answers once each stream it can prove has delivered a probe, which
- * takes the service's latency (samchon/ttsc#1453).
+ * Windows answers after consuming currently queued native completions to an
+ * observed empty port. macOS answers once each provable stream has delivered a
+ * probe, including the service's latency (#1453). Ordered transport applies
+ * every preceding event before the reply. These are current backend frontiers,
+ * not atomic timestamp classification of concurrent writes. The optional direct
+ * fs.watch program retains its explicit two-turn frontier for protocol tests;
+ * it does not supply Windows production proof (#1719).
  *
  * A broker that never answers must not hold a delivery, so the wait gives up
  * after a threshold of twice the probe timeout: the child itself gives up on a
@@ -51,7 +52,7 @@ var WATCH_PROBE_TIMEOUT_MS = require('./WATCH_PROBE_TIMEOUT_MS.js');
  *   Native paragraphs and parameters explain ordering, coverage, sharing and
  *   false deadlines under the documentation skill.
  * @evidence contracts/portability.md#os-neutral-implementation
- *   OS-neutral host delivery delegates Windows loop ordering and macOS stream
+ *   OS-neutral host delivery delegates Windows completion-port drainage and macOS stream
  *   probing to the native broker rather than applying one universal timing guess.
  * @evidence contracts/performance.md#efficient-algorithms
  *   A covering memo query uses fixed identity/id lookup. New requests copy all N
@@ -108,8 +109,7 @@ function startWatchBrokerDrain(broker, timeout, scope) {
             broker.drainScopes?.delete(id);
             broker.pendingDrains -= 1;
             if (broker.pendingDrains === 0 && broker.pendingRegistrations === 0) {
-                broker.child.unref();
-                broker.child.channel?.unref?.();
+                WatchBrokerTransport.WatchBrokerTransport.reference(broker, false);
             }
             resolve(answered);
         };
@@ -119,12 +119,11 @@ function startWatchBrokerDrain(broker, timeout, scope) {
         // the reference the loop can empty while a delivery waits here, and the
         // process exits mid-build with nothing to report.
         broker.pendingDrains += 1;
-        broker.child.ref();
-        broker.child.channel?.ref?.();
+        WatchBrokerTransport.WatchBrokerTransport.reference(broker, true);
         const timer = setTimeout(() => release(false), timeout);
         broker.drains.set(id, release);
         (broker.drainScopes ??= new Map()).set(id, scope);
-        if (broker.child.send?.({ id, op: "drain" }) !== true) {
+        if (WatchBrokerTransport.WatchBrokerTransport.send(broker, { id, op: "drain" }) !== true) {
             release(false);
         }
     });

package/lib/core/transform/tracker/broker/drainWatchBroker.js.map

@@ -1 +1 @@
-{"version":3,"file":"drainWatchBroker.js","sources":["../../../../../src/core/transform/tracker/broker/drainWatchBroker.ts"],"sourcesContent":[null],"names":["WATCH_PROBE_TIMEOUT_MS"],"mappings":";;;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuEG;AACG,SAAU,gBAAgB,CAC9B,MAAmB,EACnB,UAAkB,CAAC,GAAGA,6CAAsB,EAC5C,YAAqB,EAAA;;;AAIrB,IAAA,IACE,MAAM,CAAC,QAAQ,KAAK,SAAS;SAC5B,YAAY,KAAK,SAAS;YACzB,MAAM,CAAC,aAAa,EAAE,GAAG,CAAC,YAAY,CAAC,KAAK,IAAI,CAAC,EACnD;QACA,OAAO,MAAM,CAAC,QAAQ;IACxB;IACA,MAAM,KAAK,GAAG,IAAI,GAAG,CACnB,CAAC,GAAG,MAAM,CAAC,aAAa;AACrB,SAAA,MAAM,CAAC,CAAC,GAAG,KAAK,CAAC,KAAK,KAAK,CAAC,MAAM;SAClC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,CACrB;AACD,IAAA,MAAM,QAAQ,GAAqB,qBAAqB,CACtD,MAAM,EACN,OAAO,EACP,KAAK,CACN,CAAC,OAAO,CAAC,MAAK;AACb,QAAA,IAAI,MAAM,CAAC,QAAQ,KAAK,QAAQ,EAAE;AAChC,YAAA,MAAM,CAAC,QAAQ,GAAG,SAAS;AAC3B,YAAA,MAAM,CAAC,aAAa,GAAG,SAAS;QAClC;AACF,IAAA,CAAC,CAAC;AACF,IAAA,MAAM,CAAC,QAAQ,GAAG,QAAQ;AAC1B,IAAA,MAAM,CAAC,aAAa,GAAG,KAAK;AAC5B,IAAA,OAAO,QAAQ;AACjB;AAEA,SAAS,qBAAqB,CAC5B,MAAmB,EACnB,OAAe,EACf,KAA0B,EAAA;AAE1B,IAAA,OAAO,IAAI,OAAO,CAAU,CAAC,OAAO,KAAI;AACtC,QAAA,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE;QAC1B,IAAI,OAAO,GAAG,KAAK;AACnB,QAAA,MAAM,OAAO,GAAG,CAAC,QAAiB,KAAU;AAC1C,YAAA,IAAI,OAAO;gBAAE;YACb,OAAO,GAAG,IAAI;YACd,YAAY,CAAC,KAAK,CAAC;AACnB,YAAA,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;AACxB,YAAA,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,EAAE,CAAC;AAC9B,YAAA,MAAM,CAAC,aAAa,IAAI,CAAC;AACzB,YAAA,IAAI,MAAM,CAAC,aAAa,KAAK,CAAC,IAAI,MAAM,CAAC,oBAAoB,KAAK,CAAC,EAAE;AACnE,gBAAA,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE;gBACpB,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,IAAI;YACjC;YACA,OAAO,CAAC,QAAQ,CAAC;AACnB,QAAA,CAAC;;;;;;AAMD,QAAA,MAAM,CAAC,aAAa,IAAI,CAAC;AACzB,QAAA,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE;QAClB,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,GAAG,IAAI;AAC7B,QAAA,MAAM,KAAK,GAAG,UAAU,CAAC,MAAM,OAAO,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QACvD,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE,OAAO,CAAC;AAC9B,QAAA,CAAC,MAAM,CAAC,WAAW,KAAK,IAAI,GAAG,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,KAAK,CAAC;AACjD,QAAA,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,CAAC,KAAK,IAAI,EAAE;YACrD,OAAO,CAAC,KAAK,CAAC;QAChB;AACF,IAAA,CAAC,CAAC;AACJ;;;;"}
+{"version":3,"file":"drainWatchBroker.js","sources":["../../../../../src/core/transform/tracker/broker/drainWatchBroker.ts"],"sourcesContent":[null],"names":["WATCH_PROBE_TIMEOUT_MS","WatchBrokerTransport"],"mappings":";;;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuEG;AACG,SAAU,gBAAgB,CAC9B,MAAmB,EACnB,UAAkB,CAAC,GAAGA,6CAAsB,EAC5C,YAAqB,EAAA;;;AAIrB,IAAA,IACE,MAAM,CAAC,QAAQ,KAAK,SAAS;SAC5B,YAAY,KAAK,SAAS;YACzB,MAAM,CAAC,aAAa,EAAE,GAAG,CAAC,YAAY,CAAC,KAAK,IAAI,CAAC,EACnD;QACA,OAAO,MAAM,CAAC,QAAQ;IACxB;IACA,MAAM,KAAK,GAAG,IAAI,GAAG,CACnB,CAAC,GAAG,MAAM,CAAC,aAAa;AACrB,SAAA,MAAM,CAAC,CAAC,GAAG,KAAK,CAAC,KAAK,KAAK,CAAC,MAAM;SAClC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,CACrB;AACD,IAAA,MAAM,QAAQ,GAAqB,qBAAqB,CACtD,MAAM,EACN,OAAO,EACP,KAAK,CACN,CAAC,OAAO,CAAC,MAAK;AACb,QAAA,IAAI,MAAM,CAAC,QAAQ,KAAK,QAAQ,EAAE;AAChC,YAAA,MAAM,CAAC,QAAQ,GAAG,SAAS;AAC3B,YAAA,MAAM,CAAC,aAAa,GAAG,SAAS;QAClC;AACF,IAAA,CAAC,CAAC;AACF,IAAA,MAAM,CAAC,QAAQ,GAAG,QAAQ;AAC1B,IAAA,MAAM,CAAC,aAAa,GAAG,KAAK;AAC5B,IAAA,OAAO,QAAQ;AACjB;AAEA,SAAS,qBAAqB,CAC5B,MAAmB,EACnB,OAAe,EACf,KAA0B,EAAA;AAE1B,IAAA,OAAO,IAAI,OAAO,CAAU,CAAC,OAAO,KAAI;AACtC,QAAA,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE;QAC1B,IAAI,OAAO,GAAG,KAAK;AACnB,QAAA,MAAM,OAAO,GAAG,CAAC,QAAiB,KAAU;AAC1C,YAAA,IAAI,OAAO;gBAAE;YACb,OAAO,GAAG,IAAI;YACd,YAAY,CAAC,KAAK,CAAC;AACnB,YAAA,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;AACxB,YAAA,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,EAAE,CAAC;AAC9B,YAAA,MAAM,CAAC,aAAa,IAAI,CAAC;AACzB,YAAA,IAAI,MAAM,CAAC,aAAa,KAAK,CAAC,IAAI,MAAM,CAAC,oBAAoB,KAAK,CAAC,EAAE;AACnE,gBAAAC,yCAAoB,CAAC,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC;YAC/C;YACA,OAAO,CAAC,QAAQ,CAAC;AACnB,QAAA,CAAC;;;;;;AAMD,QAAA,MAAM,CAAC,aAAa,IAAI,CAAC;AACzB,QAAAA,yCAAoB,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,CAAC;AAC5C,QAAA,MAAM,KAAK,GAAG,UAAU,CAAC,MAAM,OAAO,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QACvD,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE,OAAO,CAAC;AAC9B,QAAA,CAAC,MAAM,CAAC,WAAW,KAAK,IAAI,GAAG,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,KAAK,CAAC;AACjD,QAAA,IAAIA,yCAAoB,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,CAAC,KAAK,IAAI,EAAE;YACnE,OAAO,CAAC,KAAK,CAAC;QAChB;AACF,IAAA,CAAC,CAAC;AACJ;;;;"}