brass-runtime 1.18.0 → 1.18.2

package/dist/{chunk-H5GYX7RZ.js → chunk-RZGB3DXR.js}

@@ -3,18 +3,18 @@ import {
 } from "./chunk-TRM4JUZQ.js";
 import {
   streamFromReadableStream
-} from "./chunk-JH4GI3DW.js";
+} from "./chunk-4PKBNG2H.js";
 import {
   layerEffect,
   makeScheduleDriver,
   makeServiceTag,
   sleep
-} from "./chunk-IBRHSH5H.js";
+} from "./chunk-EXBGIC66.js";
 import {
   fromPromiseAbortable,
   resolveWasmModule,
   toPromise
-} from "./chunk-XSAHV5HQ.js";
+} from "./chunk-APQBU7TM.js";
 import {
   Cause,
   asyncEffect,
@@ -33,7 +33,7 @@ import {
   makeSchemaIssue,
   parseConfig,
   validateValue
-} from "./chunk-HCJ4S3YB.js";
+} from "./chunk-FNWOH2T2.js";
 import {
   __require
 } from "./chunk-3RG5ZIWI.js";
@@ -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-KRYP6CAE.mjs → chunk-URVS2OE2.mjs}

@@ -2,14 +2,14 @@ import {
   EventBus,
   InMemoryTracer,
   makeMetrics
-} from "./chunk-OT2TESZU.mjs";
+} from "./chunk-KAPZHDO4.mjs";
 import {
   Runtime,
   ctxExtend,
   ctxToObject,
   emptyContext,
   getCurrentFiber
-} from "./chunk-2QNREG6K.mjs";
+} from "./chunk-MUMBUXU6.mjs";
 import {
   asyncFail,
   asyncFlatMap,
@@ -20,7 +20,7 @@ import {
 import {
   Schema,
   parseConfig
-} from "./chunk-6MLAZPBL.mjs";
+} from "./chunk-UZQ3BB6W.mjs";
 
 // src/observability/health.ts
 function snapshotRuntimeHealth(options = {}) {

package/dist/{chunk-HCJ4S3YB.js → chunk-UZQ3BB6W.mjs}

@@ -237,7 +237,14 @@ function arraySchema(item) {
 function objectSchema(shape, options = {}) {
   const unknownKeys = options.unknownKeys ?? "strip";
   const shapeEntries = Object.entries(shape);
-  const knownKeys = unknownKeys === "strict" ? new Set(shapeEntries.map(([key]) => key)) : void 0;
+  const fieldKeys = new Array(shapeEntries.length);
+  const fieldSchemas = new Array(shapeEntries.length);
+  for (let i = 0; i < shapeEntries.length; i++) {
+    fieldKeys[i] = shapeEntries[i][0];
+    fieldSchemas[i] = shapeEntries[i][1];
+  }
+  const fieldCount = fieldKeys.length;
+  const knownKeys = unknownKeys === "strict" ? new Set(fieldKeys) : void 0;
   return makeSchema("object", false, (input, path) => {
     if (typeof input !== "object" || input === null || Array.isArray(input)) {
       return fail([makeSchemaIssue(path, options.name ?? "object", input)]);
@@ -246,11 +253,13 @@ function objectSchema(shape, options = {}) {
     const out = unknownKeys === "passthrough" ? { ...source } : {};
     const childPath = path.length === 0 ? [] : [...path];
     let issues;
-    for (const [key, fieldSchema] of shapeEntries) {
+    for (let i = 0; i < fieldCount; i++) {
+      const key = fieldKeys[i];
+      const fieldSchema = fieldSchemas[i];
       childPath.push(key);
       if (!(key in source)) {
         if (!fieldSchema.isOptional) {
-          issues ??= [];
+          if (!issues) issues = [];
           issues.push(makeSchemaIssue(childPath, fieldSchema.name ?? fieldSchema.kind, void 0, "Required field is missing"));
         }
         childPath.pop();
@@ -261,15 +270,18 @@ function objectSchema(shape, options = {}) {
       if (result.success) {
         out[key] = result.data;
       } else {
-        issues ??= [];
-        issues.push(...result.issues);
+        if (!issues) issues = [];
+        const resultIssues = result.issues;
+        for (let j = 0; j < resultIssues.length; j++) {
+          issues.push(resultIssues[j]);
+        }
       }
     }
     if (knownKeys) {
       for (const key of Object.keys(source)) {
         if (!knownKeys.has(key)) {
           childPath.push(key);
-          issues ??= [];
+          if (!issues) issues = [];
           issues.push(makeSchemaIssue(childPath, "known key", source[key], "Unknown key is not allowed"));
           childPath.pop();
         }

package/dist/{chunk-N6QNSTWD.cjs → chunk-YQWZ7FZX.cjs}

@@ -1,10 +1,10 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
-var _chunkAJMKZXRBcjs = require('./chunk-AJMKZXRB.cjs');
+var _chunkFYWWU3Z7cjs = require('./chunk-FYWWU3Z7.cjs');
 
 
 
-var _chunkSSQJKDN3cjs = require('./chunk-SSQJKDN3.cjs');
+var _chunkZDZNV6NAcjs = require('./chunk-ZDZNV6NA.cjs');
 
 
 
@@ -73,9 +73,9 @@ function fiberRefSnapshot() {
   return new Map(currentFiberRefs(false));
 }
 function currentFiberRefs(create) {
-  const fiber = _chunkSSQJKDN3cjs.getCurrentFiber.call(void 0, );
+  const fiber = _chunkZDZNV6NAcjs.getCurrentFiber.call(void 0, );
   if (!fiber) return void 0;
-  fiber.fiberContext ??= { log: _chunkSSQJKDN3cjs.emptyContext, trace: null };
+  fiber.fiberContext ??= { log: _chunkZDZNV6NAcjs.emptyContext, trace: null };
   if (!fiber.fiberContext.fiberRefs && create) fiber.fiberContext.fiberRefs = /* @__PURE__ */ new Map();
   return fiber.fiberContext.fiberRefs;
 }
@@ -98,7 +98,7 @@ function makeRuntimeRecorder(options = {}) {
     return out;
   };
   const emit = (ev, ctx) => {
-    records[next] = _chunkAJMKZXRBcjs.makeRuntimeEventRecord.call(void 0, ev, ctx, seq++);
+    records[next] = _chunkFYWWU3Z7cjs.makeRuntimeEventRecord.call(void 0, ev, ctx, seq++);
     next = (next + 1) % capacity;
     if (size < capacity) size++;
     else dropped++;

package/dist/{chunk-5XADBMSU.cjs → chunk-Z2YIDHRI.cjs}

@@ -1,22 +1,22 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
 
-var _chunk7TXQJFZXcjs = require('./chunk-7TXQJFZX.cjs');
+var _chunk6STX4PS3cjs = require('./chunk-6STX4PS3.cjs');
 
 
-var _chunkSSQJKDN3cjs = require('./chunk-SSQJKDN3.cjs');
+var _chunkZDZNV6NAcjs = require('./chunk-ZDZNV6NA.cjs');
 
 
 var _chunkMVGUEJ5Zcjs = require('./chunk-MVGUEJ5Z.cjs');
 
 // src/core/runtime/runtimeLayer.ts
-var RuntimeService = _chunk7TXQJFZXcjs.makeServiceTag.call(void 0, "Runtime");
+var RuntimeService = _chunk6STX4PS3cjs.makeServiceTag.call(void 0, "Runtime");
 function makeRuntimeLayer(env = {}, options = {}) {
   const { tag = RuntimeService, ...runtimeOptions } = options;
-  return _chunk7TXQJFZXcjs.layerEffect.call(void 0, 
+  return _chunk6STX4PS3cjs.layerEffect.call(void 0, 
     tag,
     (context) => _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, 
-      () => new (0, _chunkSSQJKDN3cjs.Runtime)({
+      () => new (0, _chunkZDZNV6NAcjs.Runtime)({
         ...runtimeOptions,
         env: resolveRuntimeLayerEnv(env, context)
       })