brass-runtime 1.18.0 → 1.18.2

package/dist/{chunk-Z3PSSXP3.mjs → chunk-5RVHSBJ6.mjs}

@@ -3,18 +3,18 @@ import {
 } from "./chunk-MOO4L7F4.mjs";
 import {
   streamFromReadableStream
-} from "./chunk-RREBJX2S.mjs";
+} from "./chunk-AQQQFNYD.mjs";
 import {
   layerEffect,
   makeScheduleDriver,
   makeServiceTag,
   sleep
-} from "./chunk-ELLF55ER.mjs";
+} from "./chunk-KDXNWGPB.mjs";
 import {
   fromPromiseAbortable,
   resolveWasmModule,
   toPromise
-} from "./chunk-2QNREG6K.mjs";
+} from "./chunk-MUMBUXU6.mjs";
 import {
   Cause,
   asyncEffect,
@@ -33,7 +33,7 @@ import {
   makeSchemaIssue,
   parseConfig,
   validateValue
-} from "./chunk-6MLAZPBL.mjs";
+} from "./chunk-UZQ3BB6W.mjs";
 import {
   __require
 } from "./chunk-Y6FXYEAI.mjs";
@@ -678,6 +678,18 @@ var HttpConcurrencyPool = class {
   acquire(key, signal) {
     return this.wasm ? this.acquireWasm(key, signal) : this.acquireJs(key, signal);
   }
+  /** Try synchronous acquire. Returns lease directly or undefined if contended. */
+  tryAcquireSync(key, signal) {
+    if (this.wasm) return void 0;
+    if (signal.aborted) return void 0;
+    const state = this.getState(key);
+    if (state.running < this.concurrency) {
+      state.running++;
+      state.acquired++;
+      return this.makeLease(state);
+    }
+    return void 0;
+  }
   stats() {
     const keys = Array.from(this.states.values()).map((state) => ({
       key: state.key,
@@ -1516,6 +1528,24 @@ var AdaptiveLimiter = class {
       this.enqueueWaiter(state, waiter);
     });
   }
+  /**
+   * Try to acquire a concurrency slot synchronously.
+   * Returns a lease directly if under the limit, or undefined if contended/aborted/destroyed.
+   * This avoids Promise.resolve() allocation and microtask scheduling on the uncontended path.
+   */
+  tryAcquireSync(key, signal) {
+    if (this.destroyed) return void 0;
+    if (signal.aborted) return void 0;
+    const state = this.getOrCreateState(key);
+    this.touch(state);
+    if (state.inFlight < state.limit) {
+      state.inFlight++;
+      state.acquired++;
+      state.rejectionStreak = 0;
+      return this.makeLease(state);
+    }
+    return void 0;
+  }
   /**
    * Get stats for a specific key, or aggregate stats if no key is provided.
    */
@@ -2194,6 +2224,9 @@ var mergeHeadersUnder = (under) => (req) => Lens.over(Request.headers, (h) => ({
 var setHeaderIfMissing = (k, v) => (req) => Lens.over(Request.headers, (h) => h[k] ? h : { ...h, [k]: v })(req);
 
 // src/http/transport.ts
+function isPromiseTransportDirect(transport) {
+  return transport.__promiseTransport === true;
+}
 var isTaggedHttpError = (error) => {
   return isHttpError(error);
 };
@@ -2281,6 +2314,7 @@ var linkAbortSignals = (...signals) => {
   };
 };
 var nowMs = () => typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+var isThenable = (value) => value !== null && typeof value === "object" && typeof value.then === "function";
 var hasMethod = (value, name) => typeof value === "object" && value !== null && typeof value[name] === "function";
 var defaultPromiseBody = (response, mode) => {
   if (mode === "json" && hasMethod(response, "json")) return response.json();
@@ -2325,49 +2359,107 @@ var toPromiseTransportResponse = (bodyText, info) => ({
   ...info.transportMeta !== void 0 ? { transportMeta: info.transportMeta } : {}
 });
 function makePromiseHttpTransport(config) {
-  return (context) => asyncEffect((_env, cb) => {
+  const transport = (context) => asyncEffect((_env, cb) => {
     let done = false;
+    const signal = context.signal;
+    const needsAbortListener = signal !== globalThis.__brassNoopSignal;
+    let abort;
     const finish = (exit) => {
       if (done) return;
       done = true;
-      context.signal.removeEventListener("abort", abort);
+      if (needsAbortListener && abort) signal.removeEventListener("abort", abort);
       cb(exit);
     };
     const fail = (error) => finish({ _tag: "Failure", cause: Cause.fail(error) });
-    const abort = () => fail(abortErrorForSignal(context.signal));
-    if (context.signal.aborted) {
-      abort();
+    if (signal.aborted) {
+      fail(abortErrorForSignal(signal));
       return;
     }
-    context.signal.addEventListener("abort", abort, { once: true });
-    const run = async () => {
-      const startedAt = nowMs();
-      try {
-        const raw = await config.request(context);
+    if (needsAbortListener) {
+      abort = () => fail(abortErrorForSignal(signal));
+      signal.addEventListener("abort", abort, { once: true });
+    }
+    const startedAt = nowMs();
+    let requestPromise;
+    try {
+      const result = config.request(context);
+      requestPromise = isThenable(result) ? result : Promise.resolve(result);
+    } catch (error) {
+      if (signal.aborted) {
+        fail(abortErrorForSignal(signal));
+        return;
+      }
+      fail(config.error?.(error, context) ?? normalizeHttpError(error, { signal }));
+      return;
+    }
+    requestPromise.then(
+      (raw) => {
+        if (done) return;
         const durationMs = Math.round(nowMs() - startedAt);
-        const mapped = await config.response(raw, context, { startedAt, durationMs });
-        finish({
-          _tag: "Success",
-          value: {
-            ...mapped,
-            ms: mapped.ms ?? durationMs
+        try {
+          const r = config.response(raw, context, { startedAt, durationMs });
+          if (!isThenable(r)) {
+            const mapped = r;
+            finish({
+              _tag: "Success",
+              value: mapped.ms !== void 0 ? mapped : { ...mapped, ms: durationMs }
+            });
+            return;
           }
-        });
-      } catch (error) {
-        if (context.signal.aborted) {
-          fail(abortErrorForSignal(context.signal));
+          r.then(
+            (m) => {
+              if (done) return;
+              finish({
+                _tag: "Success",
+                value: m.ms !== void 0 ? m : { ...m, ms: durationMs }
+              });
+            },
+            (error) => {
+              if (done) return;
+              if (signal.aborted) {
+                fail(abortErrorForSignal(signal));
+                return;
+              }
+              fail(config.error?.(error, context) ?? normalizeHttpError(error, { signal }));
+            }
+          );
+        } catch (error) {
+          if (signal.aborted) {
+            fail(abortErrorForSignal(signal));
+            return;
+          }
+          fail(config.error?.(error, context) ?? normalizeHttpError(error, { signal }));
+        }
+      },
+      (error) => {
+        if (done) return;
+        if (signal.aborted) {
+          fail(abortErrorForSignal(signal));
           return;
         }
-        fail(config.error?.(error, context) ?? normalizeHttpError(error, { signal: context.signal }));
+        fail(config.error?.(error, context) ?? normalizeHttpError(error, { signal }));
       }
-    };
-    void run();
+    );
     return () => {
       if (done) return;
       done = true;
-      context.signal.removeEventListener("abort", abort);
+      if (needsAbortListener && abort) signal.removeEventListener("abort", abort);
     };
   });
+  const marked = transport;
+  marked.__promiseTransport = true;
+  marked.requestDirect = async (context) => {
+    const startedAt = nowMs();
+    try {
+      const raw = await config.request(context);
+      const durationMs = Math.round(nowMs() - startedAt);
+      const mapped = await config.response(raw, context, { startedAt, durationMs });
+      return { ...mapped, ms: mapped.ms ?? durationMs };
+    } catch (error) {
+      throw config.error?.(error, context) ?? normalizeHttpError(error, { signal: context.signal });
+    }
+  };
+  return marked;
 }
 function makePromiseHttpTransportBodyBuilder(config) {
   const makeBodyTransport = (mode, body, responseMapper, currentConfig = config) => makePromiseHttpTransport({
@@ -3083,6 +3175,13 @@ function makeHttpStream(cfg = {}) {
   };
   return decorateStream(run, metrics.snapshot);
 }
+var ONCE_OPTIONS = Object.freeze({ once: true });
+var noopSignal = (() => {
+  const c = new AbortController();
+  const s = c.signal;
+  globalThis.__brassNoopSignal = s;
+  return s;
+})();
 function makeHttp(cfg = {}) {
   validateMakeHttpConfig(cfg);
   const baseUrl = cfg.baseUrl ?? "";
@@ -3226,6 +3325,53 @@ function httpBodyKeyPart(body) {
 // src/http/lifecycle/cacheKey.ts
 var SEPARATOR = "\0";
 var DEFAULT_CACHE_RELEVANT_HEADERS = ["accept", "authorization", "content-type"];
+function makeCacheKeyContext(baseUrl, extraHeaders = []) {
+  const relevantSet = new Set(DEFAULT_CACHE_RELEVANT_HEADERS);
+  for (let i = 0; i < extraHeaders.length; i++) {
+    relevantSet.add(extraHeaders[i].toLowerCase());
+  }
+  return {
+    baseUrl,
+    relevantSet,
+    cachedOrigin: baseUrl ? absoluteOrigin(baseUrl) : void 0
+  };
+}
+function computeCacheKeyFast(req, ctx) {
+  const m = req.method;
+  const method = m === "GET" || m === "POST" || m === "PUT" || m === "DELETE" || m === "PATCH" || m === "HEAD" || m === "OPTIONS" ? m : m.toUpperCase();
+  let resolvedUrl;
+  const url = req.url;
+  if (ctx.cachedOrigin && url.length > 0 && url.charCodeAt(0) === 47 && url.charCodeAt(1) !== 47) {
+    resolvedUrl = ctx.cachedOrigin + url;
+  } else {
+    resolvedUrl = new URL(url, ctx.baseUrl || void 0).toString();
+  }
+  const headers = req.headers;
+  let sortedHeaders = "";
+  if (headers) {
+    const keys = Object.keys(headers);
+    if (keys.length > 0) {
+      const matched = [];
+      for (let i = 0; i < keys.length; i++) {
+        const k = keys[i];
+        const lk = k.toLowerCase();
+        if (ctx.relevantSet.has(lk)) {
+          matched.push(`${lk}:${headers[k]}`);
+        }
+      }
+      if (matched.length > 0) {
+        if (matched.length === 1) {
+          sortedHeaders = matched[0];
+        } else {
+          matched.sort();
+          sortedHeaders = matched.join(",");
+        }
+      }
+    }
+  }
+  const body = httpBodyKeyPart(req.body);
+  return `${method}${SEPARATOR}${resolvedUrl}${SEPARATOR}${sortedHeaders}${SEPARATOR}${body}`;
+}
 function computeCacheKey(req, baseUrl, extraHeaders = []) {
   const method = req.method.toUpperCase();
   const resolvedUrl = resolveKeyUrl(req.url, baseUrl);
@@ -3279,6 +3425,48 @@ var HOP_BY_HOP = /* @__PURE__ */ new Set([
   "upgrade"
 ]);
 var SAFE_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
+function makeDedupKeyContext(baseUrl) {
+  return {
+    baseUrl,
+    cachedOrigin: baseUrl ? absoluteOrigin(baseUrl) : void 0
+  };
+}
+function computeDedupKeyFast(req, ctx) {
+  const m = req.method;
+  const method = m === "GET" || m === "POST" || m === "PUT" || m === "DELETE" || m === "PATCH" || m === "HEAD" || m === "OPTIONS" ? m : m.toUpperCase();
+  let resolvedUrl;
+  const url = req.url;
+  if (ctx.cachedOrigin && url.length > 0 && url.charCodeAt(0) === 47 && url.charCodeAt(1) !== 47) {
+    resolvedUrl = ctx.cachedOrigin + url;
+  } else {
+    resolvedUrl = resolveKeyUrl(url, ctx.baseUrl);
+  }
+  const headers = req.headers;
+  let sortedHeaders = "";
+  if (headers) {
+    const keys = Object.keys(headers);
+    if (keys.length > 0) {
+      const matched = [];
+      for (let i = 0; i < keys.length; i++) {
+        const k = keys[i];
+        const lk = k.toLowerCase();
+        if (!HOP_BY_HOP.has(lk) && lk !== "authorization") {
+          matched.push(`${lk}:${headers[k]}`);
+        }
+      }
+      if (matched.length > 0) {
+        if (matched.length === 1) {
+          sortedHeaders = matched[0];
+        } else {
+          matched.sort();
+          sortedHeaders = matched.join(",");
+        }
+      }
+    }
+  }
+  const body = httpBodyKeyPart(req.body);
+  return `${method}${SEPARATOR}${resolvedUrl}${SEPARATOR}${sortedHeaders}${SEPARATOR}${body}`;
+}
 function computeDedupKey(req, baseUrl) {
   const method = req.method.toUpperCase();
   const resolvedUrl = resolveKeyUrl(req.url, baseUrl);
@@ -3308,6 +3496,7 @@ function withDedup(config) {
   const inFlight = /* @__PURE__ */ new Map();
   const customKeyFn = config?.dedupKey;
   const onEvent = config?.onEvent;
+  const dedupKeyCtx = makeDedupKeyContext("");
   return (next) => {
     return (req) => {
       if (!SAFE_METHODS.has(req.method.toUpperCase())) {
@@ -3330,7 +3519,7 @@ function withDedup(config) {
           return next(req);
         }
       } else {
-        key = computeDedupKey(req, "");
+        key = computeDedupKeyFast(req, dedupKeyCtx);
       }
       return {
         _tag: "Async",
@@ -3859,6 +4048,7 @@ function withCache(config) {
   const baseUrl = config?.baseUrl ?? "";
   const onEvent = config?.onEvent;
   const onLifecycleEvent = config?.onLifecycleEvent;
+  const cacheKeyCtx = makeCacheKeyContext(baseUrl, cacheRelevantHeaders);
   const cache = new LRUCache({
     maxEntries,
     onEvict: (count) => onLifecycleEvent?.({ type: "cache-eviction", count })
@@ -3876,7 +4066,7 @@ function withCache(config) {
       if (!SAFE_METHODS.has(method) && !cachePolicy) {
         return next(req);
       }
-      const key = computeCacheKey(req, baseUrl, cacheRelevantHeaders);
+      const key = computeCacheKeyFast(req, cacheKeyCtx);
       return {
         _tag: "Async",
         register: (env, cb) => {
@@ -3935,7 +4125,7 @@ function withCache(config) {
       if (!SAFE_METHODS.has(method) && !cachePolicy) {
         return next(req);
       }
-      const key = computeCacheKey(req, baseUrl, cacheRelevantHeaders);
+      const key = computeCacheKeyFast(req, cacheKeyCtx);
       return {
         _tag: "Async",
         register: (env, cb) => {
@@ -5649,16 +5839,21 @@ function decodeJsonBody(bodyText, validator, options = {}) {
     };
   }
   if (!validator) return { success: true, data: parsed };
+  let validation;
   let legacyMessage;
-  const validation = isSchema(validator) ? validator.safeParse(parsed) : (() => {
+  if (isSchema(validator)) {
+    validation = validator.safeParse(parsed);
+  } else {
     const result = validator(parsed);
-    if (result.success) return { success: true, data: result.data };
+    if (result.success) {
+      return { success: true, data: result.data };
+    }
     legacyMessage = result.error;
-    return {
+    validation = {
       success: false,
       issues: result.issues ?? [makeSchemaIssue([], "valid JSON shape", parsed, result.error)]
     };
-  })();
+  }
   if (validation.success) return { success: true, data: validation.data };
   return {
     success: false,
@@ -5702,6 +5897,13 @@ function encodeJsonBodyEffect(bodyObj, validator, options = {}) {
   }
 }
 function decodeJsonBodyEffect(bodyText, validator, options) {
+  if (!validator) {
+    try {
+      return asyncSucceed(JSON.parse(bodyText));
+    } catch (error) {
+      return asyncFail(makeJsonParseValidationError(bodyText, error, options ?? {}));
+    }
+  }
   const result = decodeJsonBody(bodyText, validator, options);
   return result.success ? asyncSucceed(result.data) : asyncFail(result.error);
 }
@@ -5867,10 +6069,14 @@ function makeDefaultHttpClient(config = {}) {
     wire = wire.with(withHttpPolicyPresets(policyPresets));
   }
   const features = featureSnapshot(lifecycleConfig2, compressionResult !== void 0, middleware.length);
+  const hasMiddleware = compressionResult !== void 0 || middleware.length > 0 || policyPresets !== void 0 && Object.keys(policyPresets).length > 0;
+  const transport = lifecycleConfig2.transport;
+  const useInlineDecode = !hasMiddleware && transport !== void 0;
   return buildDefaultClient(wire, {
     preset,
     features,
-    compressionStats: compressionResult?.stats
+    compressionStats: compressionResult?.stats,
+    useInlineDecode
   });
 }
 function buildDefaultClient(wire, meta) {
@@ -5889,6 +6095,11 @@ function buildDefaultClient(wire, meta) {
     const req = setHeaderIfMissing("accept", "application/json")(
       buildHttpRequest("GET", url, init)
     );
+    if (meta.useInlineDecode) {
+      return withPromise(
+        fusedWireAndDecode(requestRaw(req), init?.schema, init?.schemaName)
+      );
+    }
     return withPromise(
       asyncFlatMap(requestRaw(req), (w) => decodeResponse(w, init?.schema, init?.schemaName))
     );
@@ -5917,6 +6128,7 @@ function buildDefaultClient(wire, meta) {
     postJson,
     with: (mw) => buildDefaultClient(wire.with(mw), {
       ...meta,
+      useInlineDecode: false,
       features: {
         ...meta.features,
         middleware: meta.features.middleware + 1
@@ -5944,6 +6156,48 @@ function toResponse(wire, body) {
     body
   };
 }
+function fusedWireAndDecode(wireEffect, schema, schemaName) {
+  return {
+    _tag: "Async",
+    register: (env, cb) => {
+      const innerEffect = wireEffect;
+      if (innerEffect._tag === "Async" && innerEffect.register) {
+        return innerEffect.register(env, (exit) => {
+          if (exit._tag !== "Success") {
+            cb(exit);
+            return;
+          }
+          const wire = exit.value;
+          inlineDecodeJson(wire, schema, schemaName, cb);
+        });
+      }
+      const decoded = asyncFlatMap(wireEffect, (w) => decodeResponse(w, schema, schemaName));
+      if (decoded._tag === "Async" && decoded.register) {
+        return decoded.register(env, cb);
+      }
+      cb({ _tag: "Failure", cause: Cause.fail({ _tag: "ValidationError", message: "Internal: unexpected effect shape", body: "", issues: [], phase: "response" }) });
+    }
+  };
+}
+function inlineDecodeJson(wire, schema, schemaName, cb) {
+  if (!schema) {
+    let parsed;
+    try {
+      parsed = JSON.parse(wire.bodyText);
+    } catch (error) {
+      cb({ _tag: "Failure", cause: Cause.fail(makeJsonParseValidationError(wire.bodyText, error, { schemaName })) });
+      return;
+    }
+    cb({ _tag: "Success", value: toResponse(wire, parsed) });
+    return;
+  }
+  const result = decodeJsonBody(wire.bodyText, schema, { schemaName });
+  if (result.success) {
+    cb({ _tag: "Success", value: toResponse(wire, result.data) });
+  } else {
+    cb({ _tag: "Failure", cause: Cause.fail(result.error) });
+  }
+}
 function decodeResponse(wire, schema, schemaName) {
   if (!schema) {
     try {
@@ -6069,6 +6323,7 @@ export {
   validateConfig,
   resolveConfig,
   AdaptiveLimiter,
+  isPromiseTransportDirect,
   isTaggedHttpError,
   isAbortError,
   normalizeHttpError,
@@ -6084,6 +6339,7 @@ export {
   withMiddleware,
   normalizeHeadersInit,
   makeHttpStream,
+  noopSignal,
   makeHttp,
   withRetryStream,
   SEPARATOR,

package/dist/{chunk-QZ6QFJNM.mjs → chunk-5UBJT4RW.mjs}

@@ -1,10 +1,10 @@
 import {
   makeRuntimeEventRecord
-} from "./chunk-OT2TESZU.mjs";
+} from "./chunk-KAPZHDO4.mjs";
 import {
   layerEffect,
   makeScheduleDriver
-} from "./chunk-ELLF55ER.mjs";
+} from "./chunk-KDXNWGPB.mjs";
 import {
   Runtime,
   getCurrentFiber,
@@ -12,7 +12,7 @@ import {
   runtimeClockFromEnv,
   toPromise,
   unsafeRunAsync
-} from "./chunk-2QNREG6K.mjs";
+} from "./chunk-MUMBUXU6.mjs";
 import {
   Cause,
   Exit,
@@ -26,7 +26,7 @@ import {
 } from "./chunk-36I3M4UC.mjs";
 import {
   parseConfig
-} from "./chunk-6MLAZPBL.mjs";
+} from "./chunk-UZQ3BB6W.mjs";
 
 // src/core/types/cancel.ts
 function makeCancelToken() {

package/dist/{chunk-7TXQJFZX.cjs → chunk-6STX4PS3.cjs}

@@ -3,7 +3,7 @@
 
 
 
-var _chunkSSQJKDN3cjs = require('./chunk-SSQJKDN3.cjs');
+var _chunkZDZNV6NAcjs = require('./chunk-ZDZNV6NA.cjs');
 
 
 
@@ -20,14 +20,14 @@ var _chunkMVGUEJ5Zcjs = require('./chunk-MVGUEJ5Z.cjs');
 // src/core/runtime/combinators.ts
 function sleep(ms) {
   return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env, cb) => {
-    const clock = _chunkSSQJKDN3cjs.runtimeClockFromEnv.call(void 0, env);
+    const clock = _chunkZDZNV6NAcjs.runtimeClockFromEnv.call(void 0, env);
     const id = clock.setTimeout(() => cb({ _tag: "Success", value: void 0 }), ms);
     return () => clock.clearTimeout(id);
   });
 }
 function timeout(effect, ms) {
   return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env, cb) => {
-    const clock = _chunkSSQJKDN3cjs.runtimeClockFromEnv.call(void 0, env);
+    const clock = _chunkZDZNV6NAcjs.runtimeClockFromEnv.call(void 0, env);
     let done = false;
     let timerId;
     let fiber;
@@ -40,7 +40,7 @@ function timeout(effect, ms) {
         cause: { _tag: "Fail", error: { _tag: "TimeoutError", ms } }
       });
     }, ms);
-    const runtime = _chunkSSQJKDN3cjs.unsafeGetCurrentRuntime.call(void 0, );
+    const runtime = _chunkZDZNV6NAcjs.unsafeGetCurrentRuntime.call(void 0, );
     fiber = runtime.fork(effect);
     fiber.join((exit) => {
       if (done) return;
@@ -82,7 +82,7 @@ function retry(effect, policy) {
   );
   return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
     { _tag: "Sync", thunk: (env) => {
-      const clock = _chunkSSQJKDN3cjs.runtimeClockFromEnv.call(void 0, env);
+      const clock = _chunkZDZNV6NAcjs.runtimeClockFromEnv.call(void 0, env);
       return { clock, startedAt: clock.now() };
     } },
     ({ clock, startedAt }) => loop(0, startedAt, clock)
@@ -110,8 +110,8 @@ function retryWithBackoff(effect, opts = {}) {
 // src/core/runtime/resource.ts
 function bracket(acquire, use, release) {
   return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env, cb) => {
-    const runtime = _chunkSSQJKDN3cjs.unsafeGetCurrentRuntime.call(void 0, );
-    const scope = new (0, _chunkSSQJKDN3cjs.Scope)(runtime);
+    const runtime = _chunkZDZNV6NAcjs.unsafeGetCurrentRuntime.call(void 0, );
+    const scope = new (0, _chunkZDZNV6NAcjs.Scope)(runtime);
     const acquireFiber = scope.fork(acquire);
     acquireFiber.join((acquireExit) => {
       if (acquireExit._tag === "Failure") {
@@ -150,7 +150,7 @@ function safeRelease(release, resource2, exit) {
 }
 function ensuring(effect, finalizer) {
   return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env, cb) => {
-    const runtime = _chunkSSQJKDN3cjs.unsafeGetCurrentRuntime.call(void 0, );
+    const runtime = _chunkZDZNV6NAcjs.unsafeGetCurrentRuntime.call(void 0, );
     const fiber = runtime.fork(effect);
     fiber.join((exit) => {
       const fin = _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
@@ -224,7 +224,7 @@ function useManaged(m, body) {
 }
 function managedAll(manageds) {
   const acquire = _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env, cb) => {
-    const runtime = _chunkSSQJKDN3cjs.unsafeGetCurrentRuntime.call(void 0, );
+    const runtime = _chunkZDZNV6NAcjs.unsafeGetCurrentRuntime.call(void 0, );
     const resources = [];
     let i = 0;
     const acquireNext = () => {
@@ -250,7 +250,7 @@ function managedAll(manageds) {
   });
   const release = (resources, exit) => {
     return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (_env, cb) => {
-      const runtime = _chunkSSQJKDN3cjs.unsafeGetCurrentRuntime.call(void 0, );
+      const runtime = _chunkZDZNV6NAcjs.unsafeGetCurrentRuntime.call(void 0, );
       releaseAcquired(runtime, manageds, resources, exit).then(() => {
         cb({ _tag: "Success", value: void 0 });
       });
@@ -593,7 +593,7 @@ function union(left, right) {
   };
 }
 function makeScheduleDriver(schedule, options = {}) {
-  const clock = _nullishCoalesce(options.clock, () => ( _chunkSSQJKDN3cjs.liveClock));
+  const clock = _nullishCoalesce(options.clock, () => ( _chunkZDZNV6NAcjs.liveClock));
   let startedAtMs = _nullishCoalesce(options.startedAtMs, () => ( clock.now()));
   let attempt = 0;
   let lastDecision;
@@ -661,7 +661,7 @@ function runSchedule(schedule, inputs, options = {}) {
 function driverFromRuntime(schedule, options = {}) {
   return _chunkMVGUEJ5Zcjs.Async.sync((env) => makeScheduleDriver(schedule, {
     ...options,
-    clock: _nullishCoalesce(options.clock, () => ( _chunkSSQJKDN3cjs.runtimeClockFromEnv.call(void 0, env)))
+    clock: _nullishCoalesce(options.clock, () => ( _chunkZDZNV6NAcjs.runtimeClockFromEnv.call(void 0, env)))
   }));
 }
 function retryWithSchedule(effect, schedule, options = {}) {
@@ -719,7 +719,7 @@ function normalizeCap(ms) {
   return normalizeDelay(ms);
 }
 function defaultClock() {
-  return _chunkSSQJKDN3cjs.liveClock.now();
+  return _chunkZDZNV6NAcjs.liveClock.now();
 }
 function nowFromContext(context) {
   return _nullishCoalesce(_optionalChain([context, 'optionalAccess', _4 => _4.clock, 'access', _5 => _5.now, 'call', _6 => _6()]), () => ( defaultClock()));