@zackbart/connecta 0.34.0 → 0.35.0

package/dist/runtime/native-storage.js

@@ -0,0 +1,63 @@
+// Optional native capabilities, with no SQL or platform implementation imports.
+// Custom KVStorage implementations continue through the existing Promise lift.
+import { Effect } from "effect";
+// Match the custom Promise-store lift: operation construction, validation and
+// decoding throws are ordinary failures with the exact thrown value. Interrupt
+// reasons stay interrupts; catchDefect never recovers cancellation.
+const typed = (operation) => Effect.suspend(operation).pipe(Effect.catchDefect((error) => Effect.fail(error)));
+const storage = new WeakMap();
+const storageMethods = new WeakMap();
+const activity = new WeakMap();
+/** Recheck identity when the operation runs, even for an already-selected program. */
+function current(receiver, key, own, args, native) {
+    return typed(() => {
+        const method = Reflect.get(receiver, key);
+        return method === own
+            ? native()
+            : Effect.tryPromise({
+                try: () => Promise.resolve(Reflect.apply(method, receiver, args)),
+                catch: (error) => error,
+            });
+    });
+}
+export function registerNativeStorage(edge, native) {
+    const own = { get: edge.get, set: edge.set, delete: edge.delete, list: edge.list, compareAndSet: edge.compareAndSet };
+    storageMethods.set(edge, own);
+    storage.set(edge, {
+        get: (key) => current(edge, "get", own.get, [key], () => native.get(key)),
+        set: (key, value, options) => current(edge, "set", own.set, [key, value, options], () => native.set(key, value, options)),
+        delete: (key) => current(edge, "delete", own.delete, [key], () => native.delete(key)),
+        list: (prefix) => current(edge, "list", own.list, [prefix], () => native.list(prefix)),
+        compareAndSet: (key, expected, next, options) => current(edge, "compareAndSet", own.compareAndSet, [key, expected, next, options], () => native.compareAndSet(key, expected, next, options)),
+    });
+    return edge;
+}
+/** Capability presence does not authorize bypassing a current override. */
+export function hasNativeStorage(edge) {
+    return storage.has(edge);
+}
+export function getNativeStorage(edge) {
+    const own = storageMethods.get(edge);
+    return own &&
+        own.get === edge.get &&
+        own.set === edge.set &&
+        own.delete === edge.delete &&
+        own.list === edge.list &&
+        own.compareAndSet === edge.compareAndSet
+        ? storage.get(edge)
+        : undefined;
+}
+const activityMethods = new WeakMap();
+export function registerNativeActivity(edge, native) {
+    const own = { record: edge.record, list: edge.list };
+    activityMethods.set(edge, own);
+    activity.set(edge, {
+        record: (event) => current(edge, "record", own.record, [event], () => native.record(event)),
+        list: (options) => current(edge, "list", own.list, [options], () => native.list(options)),
+    });
+    return edge;
+}
+export function getNativeActivity(edge) {
+    const own = activityMethods.get(edge);
+    return own && own.record === edge.record && own.list === edge.list ? activity.get(edge) : undefined;
+}

package/dist/runtime/registry.js

@@ -0,0 +1,27 @@
+// Private native programs for the published Promise registry. Static class
+// blocks install them without adding members to its published declaration.
+import { Effect } from "effect";
+const programs = new WeakMap();
+export function provideRegistryPrograms(prototype, entries) {
+    programs.set(prototype, new Map(Object.entries(entries).map(([name, run]) => [name, { own: Reflect.get(prototype, name), run }])));
+}
+/** A Promise method runs its own implementation, even when a wrapper calls the original. */
+export function registryEdgeProgram(prototype, view, key, ...args) {
+    return Effect.suspend(() => programs
+        .get(prototype)
+        .get(key)
+        .run(view, ...args)).pipe(Effect.catchDefect((error) => Effect.fail(error)));
+}
+/** Custom registry methods are real Promise leaves; registered methods compose directly. */
+export function registryProgram(view, key, ...args) {
+    return Effect.suspend(() => {
+        const own = view[key];
+        const entry = programs.get(Object.getPrototypeOf(view))?.get(key);
+        return entry?.own === own
+            ? entry.run(view, ...args)
+            : Effect.tryPromise({
+                try: () => Reflect.apply(own, view, args),
+                catch: (error) => error,
+            });
+    }).pipe(Effect.catchDefect((error) => Effect.fail(error)));
+}

package/dist/runtime/request-scope.js

@@ -0,0 +1,72 @@
+// One owner per existing upstream request identity. Facts survive revocation;
+// retaining them never reconstitutes a call capability or a live operation.
+import { Context, Exit, Scope } from "effect";
+import { detach } from "./run.js";
+export class RequestOwner {
+    identity;
+    open = true;
+    admitted = false;
+    controller = new AbortController();
+    finalizers = [];
+    entries = new Set();
+    calls = new Set();
+    signals = new WeakMap();
+    scope = Scope.makeUnsafe();
+    // Initialize secrets only when data is sent. Metadata-only UI imports must
+    // not retain the payload matcher merely to revoke a request.
+    retained = {
+        secrets: undefined,
+        invocations: { entered: [], authFailures: new Map(), retryReads: new Map() },
+        handoffs: undefined,
+    };
+    constructor(identity) {
+        this.identity = identity;
+    }
+    own(finalizer) {
+        if (this.open)
+            this.finalizers.push(finalizer);
+        else
+            finalizer();
+    }
+    close() {
+        if (!this.open)
+            return;
+        this.open = false;
+        const failures = [];
+        const attempt = (step) => {
+            try {
+                step();
+            }
+            catch (failure) {
+                failures.push(failure);
+            }
+        };
+        for (const call of this.calls) {
+            try {
+                call.close();
+            }
+            catch (failure) {
+                failures.push(...(failure instanceof AggregateError ? failure.errors : [failure]));
+            }
+        }
+        this.calls.clear();
+        this.entries.clear();
+        attempt(() => this.controller.abort(new Error("The request ended.")));
+        for (const finalizer of this.finalizers.splice(0).reverse())
+            attempt(finalizer);
+        // A synchronous published close revokes first. The runtime scope contains
+        // only native children and their cleanup; it cannot renew live authority.
+        void detach(Scope.close(this.scope, Exit.void));
+        if (failures.length)
+            throw new AggregateError(failures, `Closing the request: ${failures.length} cleanup step(s) failed.`);
+    }
+}
+export class RequestScope extends Context.Service()("connecta/request/Scope") {
+}
+const requests = new WeakMap();
+export function requestOwner(identity) {
+    let owner = requests.get(identity);
+    if (!owner)
+        requests.set(identity, (owner = new RequestOwner(identity)));
+    return owner;
+}

package/dist/runtime/run.js

@@ -31,7 +31,7 @@ function setMicrotask(task) {
     };
 }
 /** The scheduler every edge-run fiber uses; see the header for why. */
-export const microtaskScheduler = new Scheduler.MixedScheduler("async", setMicrotask);
+const microtaskScheduler = new Scheduler.MixedScheduler("async", setMicrotask);
 const runExit = Effect.runPromiseExitWith(Context.make(Scheduler.Scheduler, microtaskScheduler));
 function abortReason(signal) {
     return signal && signal.reason !== undefined ? signal.reason : new DOMException("aborted", "AbortError");
@@ -44,18 +44,18 @@ function abortReason(signal) {
  * then the first defect — never a wrapper, because callers check `instanceof`,
  * `name`, and `message` on connecta's own error classes.
  */
-function rethrow(cause, signal) {
+export function causeError(cause, signal) {
     const reasons = cause.reasons;
     if (signal?.aborted && reasons.some(Cause.isInterruptReason)) {
-        throw abortReason(signal);
+        return abortReason(signal);
     }
     const failure = reasons.find(Cause.isFailReason);
     if (failure)
-        throw failure.error;
+        return failure.error;
     const defect = reasons.find(Cause.isDieReason);
     if (defect)
-        throw defect.defect;
-    throw abortReason(signal);
+        return defect.defect;
+    return abortReason(signal);
 }
 /**
  * Run an effect at a Promise boundary.
@@ -69,7 +69,7 @@ export async function runEdge(effect, options = {}) {
     const exit = await runExit(effect, options.signal ? { signal: options.signal } : undefined);
     if (Exit.isSuccess(exit))
         return exit.value;
-    return rethrow(exit.cause, options.signal);
+    throw causeError(exit.cause, options.signal);
 }
 /**
  * Fail with the signal's abort reason once it aborts; never succeed.
@@ -149,3 +149,11 @@ export function detach(effect, ctx) {
     ctx?.waitUntil?.(settled);
     return settled;
 }
+/** Native children of one request, independent of any individual waiter. */
+export function forkRequest(effect, scope) {
+    return forkOwned(effect, scope);
+}
+/** A native host child owned by an explicit run or process Scope. */
+export function forkOwned(effect, scope) {
+    return Effect.forkIn(effect, scope, { startImmediately: true });
+}

package/dist/runtime/shared-read.js

@@ -14,25 +14,54 @@
 // is waited on only by that request's fibers, which is why a plain count of
 // readers is enough and no edge is needed between them.
 import { Deferred, Effect, Exit } from "effect";
+import { forkRequest } from "./run.js";
+import { requestOwner } from "./request-scope.js";
 export class SharedRead {
+    read;
     onEnd;
+    request;
     controller = new AbortController();
     outcome = Deferred.makeUnsafe();
     readers = 0;
     ended = false;
+    started = false;
+    releaseRequest;
     /**
-     * Start `read` at once, under a signal the read owns. `onEnd` runs once:
+     * The first join starts `read` under a signal the read owns. `onEnd` runs once:
      * when the read settles, with whether it succeeded, or when it is cancelled
      * first, with `false`. It runs before any reader hears the outcome, so an
      * owner that evicts the read there sends a reader who retries on hearing of
      * a failure to a fresh read, never back to this one.
      */
-    constructor(read, onEnd = () => { }) {
+    constructor(read, onEnd = () => { }, request = {}) {
+        this.read = read;
         this.onEnd = onEnd;
-        // The executor turns a synchronous throw from `read` into a rejection.
-        new Promise((resolve) => resolve(read(this.controller.signal))).then((value) => this.settle(Exit.succeed(value)), (cause) => this.settle(Exit.fail(cause)));
+        this.request = request;
+    }
+    start() {
+        return Effect.gen({ self: this }, function* () {
+            if (this.started)
+                return;
+            this.started = true;
+            const owner = requestOwner(this.request);
+            if (!owner.open) {
+                this.cancel(owner.controller.signal.reason);
+                this.settle(Exit.fail(owner.controller.signal.reason));
+                return;
+            }
+            const close = () => this.cancel(owner.controller.signal.reason);
+            owner.own(close);
+            this.releaseRequest = () => {
+                const index = owner.finalizers.indexOf(close);
+                if (index !== -1)
+                    owner.finalizers.splice(index, 1);
+            };
+            yield* forkRequest(Effect.suspend(() => this.read(this.controller.signal)).pipe(Effect.onExit((exit) => Effect.sync(() => this.settle(exit)))), owner.scope);
+        });
     }
     settle(exit) {
+        this.releaseRequest?.();
+        this.releaseRequest = undefined;
         this.end(Exit.isSuccess(exit));
         Deferred.doneUnsafe(this.outcome, exit);
     }
@@ -74,7 +103,7 @@ export class SharedRead {
                 if (this.readers === 0)
                     this.cancel(signal?.reason);
             });
-            const answer = Deferred.await(this.outcome);
+            const answer = this.start().pipe(Effect.andThen(Deferred.await(this.outcome)));
             const own = signal ? Effect.raceFirst(answer, this.leftBy(signal)) : answer;
             return Effect.ensuring(own, leave);
         });

package/dist/runtime/storage.js

@@ -2,9 +2,9 @@
 //
 // KVStorage stays Promise-shaped: it is what a deployment author implements,
 // and nobody should need Effect to write a storage adapter. The operations
-// below lift one call each into an effect that reads the adapter from the
-// Storage service and fails with whatever the adapter threw, unwrapped, so a
-// warning built from it reads exactly as it did.
+// below compose a registered built-in native program, or lift one custom
+// adapter call, using the Storage service. Failures retain the original thrown
+// object so warnings keep the same checked facts.
 //
 // Which Storage a program sees is the registry's decision, not the runtime's.
 // The Connecta runtime (src/runtime/services.ts) is keyed by the root
@@ -20,36 +20,49 @@
 // because its capacity is deployment-wide.
 import { Context, Effect } from "effect";
 import { runEdge } from "./run.js";
+import { getNativeStorage } from "./native-storage.js";
 import { Logger, Storage } from "./services.js";
 /** Read one key; null when absent. */
 export function storageGet(key) {
-    return Storage.use((storage) => Effect.tryPromise({
-        // Promise.resolve keeps an adapter that answers synchronously working,
-        // as `await` did; a synchronous throw is caught either way.
-        try: () => Promise.resolve(storage.get(key)),
-        catch: (error) => error,
-    }));
+    return Storage.use((storage) => getNativeStorage(storage)?.get(key) ??
+        Effect.tryPromise({
+            // Promise.resolve keeps an adapter that answers synchronously working,
+            // as `await` did; a synchronous throw is caught either way.
+            try: () => Promise.resolve(storage.get(key)),
+            catch: (error) => error,
+        }));
 }
 /** Write one key, with the adapter's optional TTL. */
 export function storageSet(key, value, options) {
-    return Storage.use((storage) => Effect.tryPromise({
-        try: () => Promise.resolve(storage.set(key, value, options)),
-        catch: (error) => error,
-    }));
+    return Storage.use((storage) => getNativeStorage(storage)?.set(key, value, options) ??
+        Effect.tryPromise({
+            try: () => Promise.resolve(storage.set(key, value, options)),
+            catch: (error) => error,
+        }));
 }
 /** Delete one key. */
 export function storageDelete(key) {
-    return Storage.use((storage) => Effect.tryPromise({
-        try: () => Promise.resolve(storage.delete(key)),
-        catch: (error) => error,
-    }));
+    return Storage.use((storage) => getNativeStorage(storage)?.delete(key) ??
+        Effect.tryPromise({
+            try: () => Promise.resolve(storage.delete(key)),
+            catch: (error) => error,
+        }));
 }
 /** Atomic compare-and-set of one key, as `KVStorage.compareAndSet`. */
 export function storageCompareAndSet(key, expected, next, options) {
-    return Storage.use((storage) => Effect.tryPromise({
-        try: () => Promise.resolve(storage.compareAndSet(key, expected, next, options)),
-        catch: (error) => error,
-    }));
+    return Storage.use((storage) => getNativeStorage(storage)?.compareAndSet(key, expected, next, options) ??
+        Effect.tryPromise({
+            try: () => Promise.resolve(storage.compareAndSet(key, expected, next, options)),
+            catch: (error) => error,
+        }));
+}
+/** List keys under one literal prefix, preserving the adapter's ordering. */
+export function storageList(prefix) {
+    return Storage.use((storage) => getNativeStorage(storage)?.list(prefix) ??
+        Effect.tryPromise({
+            try: () => Promise.resolve(storage.list(prefix)),
+            catch: (error) => error,
+        }));
 }
 // One context per partition object, built on first use. A registry's options
 // object lives exactly as long as the registry, so the WeakMap never holds a