@zackbart/connecta 0.24.4 → 0.26.0

package/dist/executor-admission.d.ts

@@ -23,6 +23,8 @@ export declare class ExecutorExecutionError extends ExecutorAdmissionError {
 export interface AdmissionLease {
     /** Time spent waiting behind active work. Zero for immediate admission. */
     readonly waitMs: number;
+    /** Time left in the optional total admitted-request lifetime. */
+    remainingMs(): number | undefined;
     release(): void;
 }
 export interface AdmissionControllerOptions {
@@ -31,6 +33,8 @@ export interface AdmissionControllerOptions {
     queueTimeoutMs: number;
     /** Suggested delay exposed with retryable overload failures. */
     retryAfterMs?: number;
+    /** Hard admitted-request lifetime; omitted for executor admission. */
+    maxDurationMs?: number;
 }
 /**
  * Runtime-portable bounded admission. It deliberately owns no executor or
@@ -42,7 +46,9 @@ export declare class AdmissionController {
     readonly maxQueueSize: number;
     readonly queueTimeoutMs: number;
     readonly retryAfterMs: number;
+    readonly maxDurationMs: number | undefined;
     private active;
+    private readonly leases;
     private closed;
     private readonly waiters;
     private admittedTotal;
@@ -63,7 +69,11 @@ export declare class AdmissionController {
     close(): void;
     private overloaded;
     private makeLease;
-    private release;
+    private releaseSlot;
+    private fillSlots;
+    private pruneExpiredWaiters;
+    private reapExpired;
+    private nextReapDelay;
     private remove;
     private cleanup;
 }

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.
@@ -51,7 +54,9 @@ export class AdmissionController {
     maxQueueSize;
     queueTimeoutMs;
     retryAfterMs;
+    maxDurationMs;
     active = 0;
+    leases = new Map();
     closed = false;
     waiters = [];
     admittedTotal = 0;
@@ -67,6 +72,12 @@ export class AdmissionController {
         this.maxQueueSize = nonNegativeWhole(options.maxQueueSize, "maxQueueSize");
         this.queueTimeoutMs = positiveWhole(options.queueTimeoutMs, "queueTimeoutMs");
         this.retryAfterMs = nonNegativeWhole(options.retryAfterMs ?? this.queueTimeoutMs, "retryAfterMs");
+        this.maxDurationMs = options.maxDurationMs === undefined
+            ? undefined
+            : positiveWhole(options.maxDurationMs, "maxDurationMs");
+        if (this.maxDurationMs !== undefined && this.maxDurationMs > 2_147_483_647) {
+            throw new TypeError("maxDurationMs must be at most 2,147,483,647 milliseconds.");
+        }
     }
     get activeCount() {
         return this.active;
@@ -75,11 +86,13 @@ export class AdmissionController {
         return this.waiters.length;
     }
     snapshot() {
+        this.reapExpired();
         return {
             concurrency: this.concurrency,
             maxQueueSize: this.maxQueueSize,
             queueTimeoutMs: this.queueTimeoutMs,
             retryAfterMs: this.retryAfterMs,
+            ...(this.maxDurationMs !== undefined ? { maxDurationMs: this.maxDurationMs } : {}),
             active: this.active,
             queued: this.waiters.length,
             closed: this.closed,
@@ -98,57 +111,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) {
@@ -157,33 +128,83 @@ export class AdmissionController {
         });
     }
     makeLease(waitMs) {
-        let released = false;
+        const id = Symbol("admission lease");
+        const record = this.maxDurationMs !== undefined
+            ? { expiresAt: Date.now() + this.maxDurationMs }
+            : {};
+        this.leases.set(id, record);
         return {
             waitMs,
+            remainingMs: () => !this.leases.has(id)
+                ? 0
+                : record.expiresAt === undefined
+                    ? undefined
+                    : Math.max(0, record.expiresAt - Date.now()),
             release: () => {
-                if (released)
+                if (!this.leases.delete(id))
                     return;
-                released = true;
-                this.release();
+                this.releaseSlot();
             },
         };
     }
-    release() {
+    releaseSlot() {
         if (this.active > 0)
             this.active--;
         if (this.closed)
             return;
-        const waiter = this.waiters.shift();
-        if (!waiter)
+        this.fillSlots();
+    }
+    fillSlots() {
+        this.pruneExpiredWaiters();
+        while (this.active < this.concurrency) {
+            const waiter = this.waiters.shift();
+            if (!waiter)
+                return;
+            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++;
+            Deferred.doneUnsafe(waiter.outcome, Effect.succeed(this.makeLease(waitMs)));
+        }
+    }
+    pruneExpiredWaiters() {
+        const now = Date.now();
+        for (let index = this.waiters.length - 1; index >= 0; index--) {
+            const waiter = this.waiters[index];
+            if (now - waiter.queuedAt < this.queueTimeoutMs)
+                continue;
+            this.waiters.splice(index, 1);
+            this.rejectedTotal++;
+            Deferred.doneUnsafe(waiter.outcome, Effect.fail(this.overloaded(`Executor admission timed out after ${this.queueTimeoutMs}ms.`)));
+        }
+    }
+    reapExpired() {
+        this.pruneExpiredWaiters();
+        if (this.maxDurationMs === undefined)
             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));
+        const now = Date.now();
+        for (const [id, lease] of this.leases) {
+            if (lease.expiresAt !== undefined && lease.expiresAt <= now) {
+                this.leases.delete(id);
+                this.active--;
+            }
+        }
+        if (!this.closed)
+            this.fillSlots();
+    }
+    nextReapDelay() {
+        let next = Number.POSITIVE_INFINITY;
+        for (const lease of this.leases.values()) {
+            if (lease.expiresAt !== undefined)
+                next = Math.min(next, lease.expiresAt);
+        }
+        // A queued request's own timer reaps the earliest admitted lease. A
+        // fallback check covers a briefly empty lease map after a handoff.
+        return Number.isFinite(next)
+            ? Math.max(1, next - Date.now())
+            : 250;
     }
     remove(waiter) {
         const index = this.waiters.indexOf(waiter);
@@ -192,12 +213,73 @@ 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(() => {
+            controller.reapExpired();
+            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 (controller.maxDurationMs !== undefined) {
+                contenders.push(Effect.forever(Effect.suspend(() => Effect.sleep(Duration.millis(controller.nextReapDelay()))).pipe(Effect.andThen(Effect.sync(() => controller.reapExpired())))));
+            }
+            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}`;
 }
 /**