brass-runtime 1.16.0 → 1.16.1

package/dist/chunk-PD4EJTQC.cjs

@@ -0,0 +1,229 @@
+"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 _chunk52PPNNI4cjs = require('./chunk-52PPNNI4.cjs');
+
+
+
+var _chunkGLE2WY7Zcjs = require('./chunk-GLE2WY7Z.cjs');
+
+
+
+
+var _chunkMVGUEJ5Zcjs = require('./chunk-MVGUEJ5Z.cjs');
+
+// src/core/runtime/fiberRef.ts
+var nextFiberRefId = 1;
+function makeFiberRef(initial) {
+  const ref = {
+    id: nextFiberRefId++,
+    initial,
+    get: () => getFiberRef(ref),
+    set: (value) => setFiberRef(ref, value),
+    update: (f) => updateFiberRef(ref, f),
+    modify: (f) => modifyFiberRef(ref, f),
+    locally: (value, effect) => locallyFiberRef(ref, value, effect),
+    locallyWith: (f, effect) => locallyFiberRefWith(ref, f, effect),
+    unsafeGet: () => unsafeGetFiberRef(ref),
+    unsafeSet: (value) => unsafeSetFiberRef(ref, value)
+  };
+  return ref;
+}
+function getFiberRef(ref) {
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => unsafeGetFiberRef(ref));
+}
+function setFiberRef(ref, value) {
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => {
+    unsafeSetFiberRef(ref, value);
+  });
+}
+function updateFiberRef(ref, f) {
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => {
+    const next = f(unsafeGetFiberRef(ref));
+    unsafeSetFiberRef(ref, next);
+    return next;
+  });
+}
+function modifyFiberRef(ref, f) {
+  return _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => {
+    const [result, next] = f(unsafeGetFiberRef(ref));
+    unsafeSetFiberRef(ref, next);
+    return result;
+  });
+}
+function locallyFiberRef(ref, value, effect) {
+  return {
+    _tag: "FiberRefLocally",
+    refId: ref.id,
+    value,
+    effect
+  };
+}
+function locallyFiberRefWith(ref, f, effect) {
+  return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, getFiberRef(ref), (value) => locallyFiberRef(ref, f(value), effect));
+}
+function unsafeGetFiberRef(ref) {
+  const refs = currentFiberRefs(false);
+  return _optionalChain([refs, 'optionalAccess', _ => _.has, 'call', _2 => _2(ref.id)]) ? refs.get(ref.id) : ref.initial;
+}
+function unsafeSetFiberRef(ref, value) {
+  const refs = currentFiberRefs(true);
+  _optionalChain([refs, 'optionalAccess', _3 => _3.set, 'call', _4 => _4(ref.id, value)]);
+}
+function fiberRefSnapshot() {
+  return new Map(currentFiberRefs(false));
+}
+function currentFiberRefs(create) {
+  const fiber = _chunkGLE2WY7Zcjs.getCurrentFiber.call(void 0, );
+  if (!fiber) return void 0;
+  fiber.fiberContext ??= { log: _chunkGLE2WY7Zcjs.emptyContext, trace: null };
+  if (!fiber.fiberContext.fiberRefs && create) fiber.fiberContext.fiberRefs = /* @__PURE__ */ new Map();
+  return fiber.fiberContext.fiberRefs;
+}
+
+// src/core/runtime/recorder.ts
+function makeRuntimeRecorder(options = {}) {
+  const capacity = Math.max(1, Math.floor(_nullishCoalesce(options.maxEvents, () => ( 2048))));
+  const records = new Array(capacity);
+  let next = 0;
+  let size = 0;
+  let dropped = 0;
+  let seq = 1;
+  const snapshot = () => {
+    const out = [];
+    const start = size === capacity ? next : 0;
+    for (let i = 0; i < size; i++) {
+      const record = records[(start + i) % capacity];
+      if (record) out.push(record);
+    }
+    return out;
+  };
+  const emit = (ev, ctx) => {
+    records[next] = _chunk52PPNNI4cjs.makeRuntimeEventRecord.call(void 0, ev, ctx, seq++);
+    next = (next + 1) % capacity;
+    if (size < capacity) size++;
+    else dropped++;
+  };
+  const clear = () => {
+    records.fill(void 0);
+    next = 0;
+    size = 0;
+    dropped = 0;
+  };
+  const stats = () => {
+    const current = snapshot();
+    return {
+      size,
+      capacity,
+      dropped,
+      ...current[0] ? { firstSeq: current[0].seq } : {},
+      ...current[current.length - 1] ? { lastSeq: current[current.length - 1].seq } : {}
+    };
+  };
+  const recorder = {
+    emit,
+    snapshot,
+    clear,
+    stats,
+    explain: (explainOptions = {}) => explainRuntimeEvents(snapshot(), dropped, explainOptions)
+  };
+  return Object.assign(recorder, { hooks: recorder });
+}
+function explainRuntimeEvents(events, dropped, options) {
+  const maxEvents = Math.max(1, Math.floor(_nullishCoalesce(options.maxEvents, () => ( 80))));
+  const slice = events.length > maxEvents ? events.slice(events.length - maxEvents) : events;
+  const fiberStarts = /* @__PURE__ */ new Map();
+  const fiberSuspends = /* @__PURE__ */ new Map();
+  const lines = [`Runtime flight recorder: ${events.length} event${events.length === 1 ? "" : "s"}${dropped > 0 ? `, ${dropped} dropped` : ""}.`];
+  for (const event of slice) {
+    switch (event.type) {
+      case "fiber.start": {
+        fiberStarts.set(event.fiberId, event);
+        lines.push(`fiber#${event.fiberId} started${event.name ? ` "${event.name}"` : ""}${event.parentFiberId !== void 0 ? ` parent=fiber#${event.parentFiberId}` : ""}`);
+        break;
+      }
+      case "fiber.suspend": {
+        fiberSuspends.set(event.fiberId, event);
+        lines.push(`fiber#${event.fiberId} suspended awaiting ${_nullishCoalesce(event.reason, () => ( "unknown"))}`);
+        break;
+      }
+      case "fiber.resume": {
+        const suspended = fiberSuspends.get(event.fiberId);
+        fiberSuspends.delete(event.fiberId);
+        lines.push(`fiber#${event.fiberId} resumed${suspended ? ` after ${durationMs(suspended, event)} awaiting ${fiberSuspendReason(suspended)}` : ""}`);
+        break;
+      }
+      case "fiber.end": {
+        const started = fiberStarts.get(event.fiberId);
+        const suspended = fiberSuspends.get(event.fiberId);
+        fiberSuspends.delete(event.fiberId);
+        lines.push(`fiber#${event.fiberId} ended ${event.status}${started ? ` after ${durationMs(started, event)}` : ""}${suspended ? ` while awaiting ${fiberSuspendReason(suspended)}` : ""}${event.error ? ` error=${formatUnknown(event.error)}` : ""}`);
+        break;
+      }
+      case "scope.open":
+        lines.push(`scope#${event.scopeId} opened${event.parentScopeId !== void 0 ? ` parent=scope#${event.parentScopeId}` : ""}`);
+        break;
+      case "scope.close":
+        lines.push(`scope#${event.scopeId} closed ${event.status}${event.error ? ` error=${formatUnknown(event.error)}` : ""}`);
+        break;
+      case "supervisor.child.restart":
+        lines.push(`supervisor#${event.supervisorId} restarting child#${event.childId} attempt=${event.restartCount} delay=${event.delayMs}ms${event.reason ? ` reason=${event.reason}` : ""}`);
+        break;
+      case "supervisor.child.escalate":
+        lines.push(`supervisor#${event.supervisorId} escalated child#${event.childId}${event.reason ? ` reason=${event.reason}` : ""}${event.error ? ` error=${formatUnknown(event.error)}` : ""}`);
+        break;
+      case "schedule.decision":
+        lines.push(`schedule${event.name ? ` "${event.name}"` : ""} attempt=${event.attempt} ${event.continue ? "continues" : "stops"} delay=${event.delayMs}ms elapsed=${Math.round(event.elapsedMs)}ms${event.reason ? ` reason=${event.reason}` : ""}`);
+        break;
+      case "log":
+        if (event.level === "warn" || event.level === "error") {
+          lines.push(`${event.level}: ${_nullishCoalesce(event.message, () => ( ""))}${event.fields ? ` ${JSON.stringify(event.fields)}` : ""}`);
+        }
+        break;
+      case "span.start":
+        lines.push(`span started "${event.name}"${event.traceId ? ` trace=${event.traceId}` : ""}`);
+        break;
+      case "span.end":
+        lines.push(`span ended ${event.status}${event.name ? ` "${event.name}"` : ""}${event.error ? ` error=${formatUnknown(event.error)}` : ""}`);
+        break;
+      default:
+        break;
+    }
+  }
+  for (const suspended of fiberSuspends.values()) {
+    lines.push(`fiber#${suspended.fiberId} still suspended for ${durationFromNowMs(suspended)} awaiting ${fiberSuspendReason(suspended)}`);
+  }
+  return lines.join("\n");
+}
+function durationMs(start, end) {
+  return `${Math.max(0, Math.round(end.wallTs - start.wallTs))}ms`;
+}
+function durationFromNowMs(start) {
+  return `${Math.max(0, Math.round(Date.now() - start.wallTs))}ms`;
+}
+function formatUnknown(value) {
+  if (_chunkMVGUEJ5Zcjs.Cause.isCause(value)) return _chunkMVGUEJ5Zcjs.Cause.pretty(value, { singleLine: true });
+  if (value instanceof Error) return value.message;
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch (e) {
+    return String(value);
+  }
+}
+function fiberSuspendReason(record) {
+  return record.type === "fiber.suspend" ? _nullishCoalesce(record.reason, () => ( "unknown")) : "unknown";
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.makeFiberRef = makeFiberRef; exports.getFiberRef = getFiberRef; exports.setFiberRef = setFiberRef; exports.updateFiberRef = updateFiberRef; exports.modifyFiberRef = modifyFiberRef; exports.locallyFiberRef = locallyFiberRef; exports.locallyFiberRefWith = locallyFiberRefWith; exports.unsafeGetFiberRef = unsafeGetFiberRef; exports.unsafeSetFiberRef = unsafeSetFiberRef; exports.fiberRefSnapshot = fiberRefSnapshot; exports.makeRuntimeRecorder = makeRuntimeRecorder;

package/dist/chunk-PWC3RBQE.mjs

@@ -0,0 +1,300 @@
+import {
+  asyncFlatMap,
+  asyncSync
+} from "./chunk-36I3M4UC.mjs";
+
+// src/http/requestPolicy.ts
+var hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+var isPolicyObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var defineHttpPolicyPresets = (presets) => presets;
+var httpPolicy = Object.freeze({
+  preset: (preset, overrides = {}) => ({
+    preset,
+    ...overrides
+  }),
+  lane: (lane, overrides = {}) => ({
+    preset: lane,
+    lane,
+    ...overrides
+  }),
+  define: defineHttpPolicyPresets
+});
+var getHttpRequestPolicy = (req, options = {}) => {
+  const legacy = req;
+  const source = req.policy;
+  const sourcePolicy = resolvePolicySource(req, source, options.presets);
+  const policy = {
+    ...legacy.lane !== void 0 ? { lane: legacy.lane } : {},
+    ...legacy.dedupKey !== void 0 ? { dedupKey: legacy.dedupKey } : {},
+    ...legacy.priority !== void 0 ? { priority: legacy.priority } : {},
+    ...legacy.retry !== void 0 ? { retry: legacy.retry } : {},
+    ...req.poolKey !== void 0 ? { poolKey: req.poolKey } : {},
+    ...sourcePolicy
+  };
+  return policy;
+};
+var withHttpRequestPolicy = (req, patch) => {
+  const current = getHttpRequestPolicy(req);
+  const next = {
+    ...req,
+    policy: {
+      ...current,
+      ...patch
+    }
+  };
+  if (hasOwn(patch, "poolKey")) {
+    next.poolKey = patch.poolKey;
+  }
+  if (hasOwn(patch, "lane")) {
+    next.lane = patch.lane;
+  }
+  if (hasOwn(patch, "dedupKey")) {
+    next.dedupKey = patch.dedupKey;
+  }
+  if (hasOwn(patch, "priority")) {
+    next.priority = patch.priority;
+  }
+  if (hasOwn(patch, "retry")) {
+    next.retry = patch.retry;
+  }
+  return next;
+};
+var resolveHttpRequestPolicyPresets = (req, presets) => {
+  const policy = getHttpRequestPolicy(req, { presets });
+  return withHttpRequestPolicy({ ...req, policy }, policy);
+};
+var withHttpPolicyPresets = (presets) => {
+  return (next) => (req) => asyncFlatMap(
+    asyncSync(() => resolveHttpRequestPolicyPresets(req, presets)),
+    (resolved) => next(resolved)
+  );
+};
+function resolvePolicySource(req, source, presets) {
+  if (typeof source === "string") {
+    return resolveNamedPolicy(req, source, {}, presets);
+  }
+  if (!isPolicyObject(source)) return {};
+  if (!source.preset) return source;
+  return resolveNamedPolicy(req, source.preset, source, presets);
+}
+function resolveNamedPolicy(req, presetName, overrides, presets) {
+  const named = presets?.[presetName];
+  const resolved = typeof named === "function" ? named(req, presetName) : named;
+  return {
+    lane: presetName,
+    ...isPolicyObject(resolved) ? resolved : {},
+    ...overrides,
+    preset: presetName
+  };
+}
+
+// src/http/errors.ts
+var HTTP_ERROR_TAGS = /* @__PURE__ */ new Set([
+  "Abort",
+  "BadUrl",
+  "FetchError",
+  "Timeout",
+  "PoolRejected",
+  "PoolTimeout",
+  "PoolClosed",
+  "BatchSplitError"
+]);
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+var TIMEOUT_CODES = /* @__PURE__ */ new Set([
+  "ECONNABORTED",
+  "ETIMEDOUT",
+  "ESOCKETTIMEDOUT",
+  "UND_ERR_CONNECT_TIMEOUT",
+  "UND_ERR_HEADERS_TIMEOUT",
+  "UND_ERR_BODY_TIMEOUT"
+]);
+var ABORT_CODES = /* @__PURE__ */ new Set(["ERR_CANCELED", "ABORT_ERR"]);
+function isHttpError(error) {
+  return hasTag(error) && HTTP_ERROR_TAGS.has(error._tag);
+}
+function isValidationError(error) {
+  return hasTag(error) && error._tag === "ValidationError";
+}
+function isCircuitBreakerOpen(error) {
+  return hasTag(error) && error._tag === "CircuitBreakerOpen";
+}
+function isKnownHttpError(error) {
+  return isHttpError(error) || isValidationError(error) || isCircuitBreakerOpen(error);
+}
+function isAbortHttpError(error) {
+  return isHttpError(error) && error._tag === "Abort";
+}
+function isTimeoutHttpError(error) {
+  return isHttpError(error) && (error._tag === "Timeout" || error._tag === "PoolTimeout");
+}
+function isFetchHttpError(error) {
+  return isHttpError(error) && error._tag === "FetchError";
+}
+function httpErrorStatus(error) {
+  if (!isFetchHttpError(error)) return void 0;
+  return typeof error.status === "number" && Number.isFinite(error.status) ? error.status : void 0;
+}
+function isRetryableHttpStatus(status) {
+  return RETRYABLE_STATUS.has(status);
+}
+function isRetryableHttpError(error, options = {}) {
+  if (!isHttpError(error)) return false;
+  switch (error._tag) {
+    case "Timeout":
+    case "PoolTimeout":
+      return true;
+    case "FetchError": {
+      const status = httpErrorStatus(error);
+      if (status !== void 0) return (options.retryOnStatus ?? isRetryableHttpStatus)(status);
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+function isExternalAbortError(error) {
+  if (typeof error !== "object" || error === null) return false;
+  const record = error;
+  return record.name === "AbortError" || ABORT_CODES.has(String(record.code ?? ""));
+}
+function isExternalTimeoutError(error) {
+  if (typeof error !== "object" || error === null) return false;
+  const record = error;
+  return record.name === "TimeoutError" || TIMEOUT_CODES.has(String(record.code ?? ""));
+}
+function toHttpError(error, options = {}) {
+  if (isHttpError(error)) return error;
+  if (options.signal?.aborted || isExternalAbortError(error)) {
+    return { _tag: "Abort" };
+  }
+  const status = externalStatus(error);
+  const statusText = externalStatusText(error);
+  const code = externalCode(error);
+  const message = resolveMessage(error, options.message);
+  if (isExternalTimeoutError(error)) {
+    return {
+      _tag: "Timeout",
+      timeoutMs: options.timeoutMs ?? 0,
+      phase: options.phase ?? "request",
+      message
+    };
+  }
+  return {
+    _tag: "FetchError",
+    message,
+    ...code !== void 0 ? { code } : {},
+    ...status !== void 0 ? { status } : {},
+    ...statusText !== void 0 ? { statusText } : {},
+    ...retryAfterMsFromExternal(error) !== void 0 ? { retryAfterMs: retryAfterMsFromExternal(error) } : {},
+    cause: error
+  };
+}
+function matchHttpError(error, handlers) {
+  if (isKnownHttpError(error)) {
+    const handler = handlers[error._tag];
+    if (handler) return handler(error);
+  }
+  return handlers.default?.(error);
+}
+function formatHttpError(error) {
+  if (isValidationError(error)) {
+    const phase = error.phase ? `${error.phase} ` : "";
+    return `${phase}validation failed: ${error.message}`;
+  }
+  if (isCircuitBreakerOpen(error)) {
+    return `Circuit breaker is open after ${error.failures} failure(s)`;
+  }
+  if (!isHttpError(error)) {
+    return error instanceof Error ? error.message : String(error);
+  }
+  switch (error._tag) {
+    case "Abort":
+      return "HTTP request aborted";
+    case "BadUrl":
+    case "PoolRejected":
+    case "PoolTimeout":
+    case "PoolClosed":
+    case "BatchSplitError":
+      return error.message;
+    case "FetchError":
+      return formatFetchError(error);
+    case "Timeout":
+      return error.message;
+  }
+}
+function hasTag(error) {
+  return typeof error === "object" && error !== null && typeof error._tag === "string";
+}
+function externalCode(error) {
+  if (typeof error !== "object" || error === null) return void 0;
+  const code = error.code;
+  return typeof code === "string" && code.length > 0 ? code : void 0;
+}
+function externalStatus(error) {
+  if (typeof error !== "object" || error === null) return void 0;
+  const record = error;
+  const response = typeof record.response === "object" && record.response !== null ? record.response : void 0;
+  const status = response?.status ?? record.status ?? record.statusCode;
+  return typeof status === "number" && Number.isFinite(status) ? status : void 0;
+}
+function externalStatusText(error) {
+  if (typeof error !== "object" || error === null) return void 0;
+  const record = error;
+  const response = typeof record.response === "object" && record.response !== null ? record.response : void 0;
+  const statusText = response?.statusText ?? record.statusText ?? record.statusMessage;
+  return typeof statusText === "string" && statusText.length > 0 ? statusText : void 0;
+}
+function retryAfterMsFromExternal(error) {
+  if (typeof error !== "object" || error === null) return void 0;
+  const record = error;
+  const response = typeof record.response === "object" && record.response !== null ? record.response : void 0;
+  const headers = response?.headers ?? record.headers;
+  if (typeof headers !== "object" || headers === null) return void 0;
+  const headerRecord = headers;
+  const raw = headerRecord["retry-after"] ?? headerRecord["Retry-After"];
+  if (raw === void 0 || raw === null) return void 0;
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds)) return Math.max(0, Math.floor(seconds * 1e3));
+  const dateMs = Date.parse(String(raw));
+  return Number.isFinite(dateMs) ? Math.max(0, dateMs - Date.now()) : void 0;
+}
+function resolveMessage(error, message) {
+  if (typeof message === "function") return message(error);
+  if (typeof message === "string") return message;
+  if (error instanceof Error && error.message) return error.message;
+  if (typeof error === "object" && error !== null) {
+    const value = error.message;
+    if (typeof value === "string" && value.length > 0) return value;
+  }
+  return String(error);
+}
+function formatFetchError(error) {
+  const status = httpErrorStatus(error);
+  if (status === void 0) return error.message;
+  const statusText = error.statusText ? ` ${error.statusText}` : "";
+  return `HTTP ${status}${statusText}: ${error.message}`;
+}
+
+export {
+  defineHttpPolicyPresets,
+  httpPolicy,
+  getHttpRequestPolicy,
+  withHttpRequestPolicy,
+  resolveHttpRequestPolicyPresets,
+  withHttpPolicyPresets,
+  isHttpError,
+  isValidationError,
+  isCircuitBreakerOpen,
+  isKnownHttpError,
+  isAbortHttpError,
+  isTimeoutHttpError,
+  isFetchHttpError,
+  httpErrorStatus,
+  isRetryableHttpStatus,
+  isRetryableHttpError,
+  isExternalAbortError,
+  isExternalTimeoutError,
+  toHttpError,
+  matchHttpError,
+  formatHttpError
+};