@zackbart/connecta 0.24.3 → 0.25.0

package/dist/executor-admission.js

@@ -1,3 +1,6 @@
+import { Deferred, Duration, Effect } from "effect";
+import { admit, provideAdmissionProgram } from "./runtime/admission.js";
+import { fromSignal, runEdge } from "./runtime/run.js";
 /**
  * A stable, machine-readable admission failure. Overload is retryable; caller
  * cancellation and shutdown are terminal for this invocation.
@@ -98,57 +101,15 @@ export class AdmissionController {
         };
     }
     acquire(options = {}) {
-        if (this.closed) {
-            this.closedTotal++;
-            return Promise.reject(new ExecutorAdmissionError("executor_closed", "Executor is shutting down."));
-        }
-        if (options.signal?.aborted) {
-            this.cancelledTotal++;
-            return Promise.reject(new ExecutorAdmissionError("executor_cancelled", "Execution was cancelled before admission."));
-        }
-        if (this.active < this.concurrency) {
-            this.active++;
-            this.admittedTotal++;
-            return Promise.resolve(this.makeLease(0));
-        }
-        if (this.waiters.length >= this.maxQueueSize) {
-            this.rejectedTotal++;
-            return Promise.reject(this.overloaded("Executor queue is full."));
-        }
-        return new Promise((resolve, reject) => {
-            const waiter = {
-                queuedAt: Date.now(),
-                resolve,
-                reject,
-                ...(options.signal ? { signal: options.signal } : {}),
-            };
-            waiter.onAbort = () => {
-                if (!this.remove(waiter))
-                    return;
-                this.cleanup(waiter);
-                this.cancelledTotal++;
-                reject(new ExecutorAdmissionError("executor_cancelled", "Execution was cancelled while queued."));
-            };
-            options.signal?.addEventListener("abort", waiter.onAbort, { once: true });
-            waiter.timer = setTimeout(() => {
-                if (!this.remove(waiter))
-                    return;
-                this.cleanup(waiter);
-                this.rejectedTotal++;
-                reject(this.overloaded(`Executor admission timed out after ${this.queueTimeoutMs}ms.`));
-            }, this.queueTimeoutMs);
-            this.waiters.push(waiter);
-            this.queuedTotal++;
-        });
+        return runEdge(admit(this, options));
     }
     close() {
         if (this.closed)
             return;
         this.closed = true;
         for (const waiter of this.waiters.splice(0)) {
-            this.cleanup(waiter);
             this.closedTotal++;
-            waiter.reject(new ExecutorAdmissionError("executor_closed", "Executor is shutting down."));
+            Deferred.doneUnsafe(waiter.outcome, Effect.fail(new ExecutorAdmissionError("executor_closed", "Executor is shutting down.")));
         }
     }
     overloaded(message) {
@@ -176,14 +137,13 @@ export class AdmissionController {
         const waiter = this.waiters.shift();
         if (!waiter)
             return;
-        this.cleanup(waiter);
         const waitMs = Math.max(0, Date.now() - waiter.queuedAt);
         this.admittedTotal++;
         this.queueWaitCount++;
         this.queueWaitTotalMs += waitMs;
         this.queueWaitMaxMs = Math.max(this.queueWaitMaxMs, waitMs);
         this.active++;
-        waiter.resolve(this.makeLease(waitMs));
+        Deferred.doneUnsafe(waiter.outcome, Effect.succeed(this.makeLease(waitMs)));
     }
     remove(waiter) {
         const index = this.waiters.indexOf(waiter);
@@ -192,12 +152,69 @@ export class AdmissionController {
         this.waiters.splice(index, 1);
         return true;
     }
+    // The waiting fiber was interrupted — an Effect caller's scope closed, not a
+    // signal. Withdraw the waiter if it is still queued; if release() handed it
+    // a slot in the same breath, give the slot back, because nobody is left to
+    // receive the lease. (A line comment, not JSDoc: TypeScript copies a private
+    // member's JSDoc into the published declaration.)
     cleanup(waiter) {
-        if (waiter.timer !== undefined)
-            clearTimeout(waiter.timer);
-        if (waiter.onAbort) {
-            waiter.signal?.removeEventListener("abort", waiter.onAbort);
+        if (this.remove(waiter)) {
+            this.cancelledTotal++;
+            return Effect.void;
         }
+        if (!Deferred.isDoneUnsafe(waiter.outcome))
+            return Effect.void;
+        return Deferred.await(waiter.outcome).pipe(Effect.tap((lease) => Effect.sync(() => lease.release())), Effect.ignore);
+    }
+    // The admission program, handed to src/runtime/admission.ts. It lives in a
+    // static block because the class declaration ships, private member names
+    // and all: a new method or field would change the published `.d.ts`, and a
+    // static block is the one place outside an instance method that may read
+    // this bookkeeping while emitting nothing there.
+    static {
+        provideAdmissionProgram((controller, signal) => Effect.suspend(() => {
+            if (controller.closed) {
+                controller.closedTotal++;
+                return Effect.fail(new ExecutorAdmissionError("executor_closed", "Executor is shutting down."));
+            }
+            if (signal?.aborted) {
+                controller.cancelledTotal++;
+                return Effect.fail(new ExecutorAdmissionError("executor_cancelled", "Execution was cancelled before admission."));
+            }
+            if (controller.active < controller.concurrency) {
+                controller.active++;
+                controller.admittedTotal++;
+                return Effect.succeed(controller.makeLease(0));
+            }
+            if (controller.waiters.length >= controller.maxQueueSize) {
+                controller.rejectedTotal++;
+                return Effect.fail(controller.overloaded("Executor queue is full."));
+            }
+            const waiter = {
+                queuedAt: Date.now(),
+                outcome: Deferred.makeUnsafe(),
+            };
+            controller.waiters.push(waiter);
+            controller.queuedTotal++;
+            // A timeout or abort settles the waiter only if it takes it out of the
+            // queue first. Otherwise release() or close() got there in the same
+            // tick, and the outcome they recorded is the answer.
+            const giveUp = (count, error) => Effect.suspend(() => {
+                if (!controller.remove(waiter))
+                    return Deferred.await(waiter.outcome);
+                count();
+                return Effect.fail(error());
+            });
+            // One flat race; each contender is a forked fiber.
+            const contenders = [
+                Deferred.await(waiter.outcome),
+                Effect.sleep(Duration.millis(controller.queueTimeoutMs)).pipe(Effect.andThen(giveUp(() => controller.rejectedTotal++, () => controller.overloaded(`Executor admission timed out after ${controller.queueTimeoutMs}ms.`)))),
+            ];
+            if (signal) {
+                contenders.push(fromSignal(signal).pipe(Effect.catch(() => giveUp(() => controller.cancelledTotal++, () => new ExecutorAdmissionError("executor_cancelled", "Execution was cancelled while queued.")))));
+            }
+            return Effect.raceAllFirst(contenders).pipe(Effect.onInterrupt(() => controller.cleanup(waiter)));
+        }));
     }
 }
 /** Preserve the one-method Workers seam while recognizing richer Node executors. */

package/dist/executors/quickjs-runtime.js

@@ -9,6 +9,7 @@
 // provider args/results must be JSON-serializable.
 import { getQuickJS, } from "quickjs-emscripten";
 import { msg } from "../errors.js";
+import { withoutProgramTerminator } from "../program-source.js";
 import { hostCallLabel, MAX_QUICKJS_LOG_TRANSPORT_BYTES, serializedBytes, } from "./quickjs-protocol.js";
 /** Load and compile the shared QuickJS WASM module before a run budget starts. */
 export async function prepareQuickJs() {
@@ -70,8 +71,9 @@ export function normalizeCode(code) {
     // lines — models routinely prefix their code with a `//` or `/* */` note,
     // which would otherwise defeat the detection and wrap the whole thing.
     const head = c.replace(/^(?:\s+|\/\/[^\n]*|\/\*[\s\S]*?\*\/)+/, "");
-    if (/^async\b/.test(head) || head.startsWith("("))
-        return c;
+    if (/^async\b/.test(head) || head.startsWith("(")) {
+        return withoutProgramTerminator(c);
+    }
     return `async () => {\n${c}\n}`;
 }
 /**