@poe-platform/safe-js 0.1.799 → 0.1.801

package/dist/safe-js/portable/chunks/chunk-H5X3T5VP.js

@@ -0,0 +1,909 @@
+// packages/safe-js/src/interp/internal-symbols.ts
+var internalSymbols = /* @__PURE__ */ new Set();
+
+// packages/safe-js/src/error/shape.ts
+var wrappedErrorCause = /* @__PURE__ */ Symbol("wrappedErrorCause");
+internalSymbols.add(wrappedErrorCause);
+var sandboxErrorNames = [
+  "Error",
+  "TypeError",
+  "RangeError",
+  "ReferenceError",
+  "SyntaxError",
+  "URIError",
+  "EvalError",
+  "AbortError",
+  "AggregateError",
+  "SuppressedError",
+  "HarnessFailure"
+];
+var sandboxErrorTypes = /* @__PURE__ */ new WeakMap();
+var hostErrorData = /* @__PURE__ */ new WeakMap();
+function formatErrorStack(name, message, stackFrames = []) {
+  const header = message.length === 0 ? name : `${name}: ${message}`;
+  return [header, ...stackFrames].join("\n");
+}
+function replaceErrorStack(error, stackFrames = []) {
+  error.stack = formatErrorStack(error.name, error.message, stackFrames);
+}
+function attachErrorSpan(error, span) {
+  if (span === void 0 || hasOwnProperty(error, "span")) {
+    return;
+  }
+  Object.defineProperty(error, "span", {
+    configurable: true,
+    value: span
+  });
+}
+function attachErrorCause(error, cause) {
+  if (cause === void 0 || hasOwnProperty(error, "cause")) {
+    return;
+  }
+  Object.defineProperty(error, "cause", {
+    configurable: true,
+    value: cause
+  });
+}
+function attachWrappedErrorCause(error, cause) {
+  if (cause === void 0 || wrappedErrorCause in error) {
+    return;
+  }
+  Object.defineProperty(error, wrappedErrorCause, {
+    configurable: true,
+    value: cause
+  });
+}
+function materializeWrappedErrorCause(value) {
+  if (typeof value !== "object" || value === null || !(wrappedErrorCause in value)) {
+    return;
+  }
+  attachErrorCause(value, value[wrappedErrorCause]);
+}
+function readErrorSpan(value) {
+  if (typeof value !== "object" || value === null || !hasOwnProperty(value, "span")) {
+    return void 0;
+  }
+  const span = value.span;
+  return isErrorSourceSpan(span) ? span : void 0;
+}
+function readErrorCause(value) {
+  return typeof value === "object" && value !== null && hasOwnProperty(value, "cause") ? value.cause : void 0;
+}
+function isErrorSourceSpan(value) {
+  if (typeof value !== "object" || value === null || !hasOwnProperty(value, "start") || !hasOwnProperty(value, "end")) {
+    return false;
+  }
+  return isErrorSourcePosition(value.start) && isErrorSourcePosition(value.end);
+}
+function createSourceSpan(source, line, column, endLine, endColumn) {
+  const start = createSourcePosition(source, line, column);
+  const rawEnd = createSourcePosition(source, endLine, endColumn);
+  const end = rawEnd.offset > start.offset ? rawEnd : createSourcePositionFromOffset(source, Math.min(start.offset + 1, source.length));
+  return { start, end };
+}
+function describeThrownValue(value) {
+  if (value instanceof Error) {
+    return value.message.length > 0 ? `${value.name}: ${value.message}` : value.name;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value === void 0 || value === null || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || typeof value === "symbol") {
+    return String(value);
+  }
+  try {
+    const serialized = JSON.stringify(value);
+    return serialized === void 0 ? String(value) : serialized;
+  } catch {
+    return String(value);
+  }
+}
+function isErrorSourcePosition(value) {
+  return typeof value === "object" && value !== null && hasOwnProperty(value, "line") && typeof value.line === "number" && hasOwnProperty(value, "column") && typeof value.column === "number" && hasOwnProperty(value, "offset") && typeof value.offset === "number";
+}
+function hasOwnProperty(value, name) {
+  return Object.prototype.hasOwnProperty.call(value, name);
+}
+function createSourcePosition(source, line, column) {
+  return createSourcePositionFromOffset(source, findSourceOffset(source, line, column));
+}
+function createSourcePositionFromOffset(source, offset) {
+  let line = 1;
+  let column = 1;
+  for (let index = 0; index < offset; index += 1) {
+    const character = source[index];
+    if (character === "\r" || character === "\n" || character === "\u2028" || character === "\u2029") {
+      if (character === "\r" && source[index + 1] === "\n" && index + 1 < offset) index += 1;
+      line += 1;
+      column = 1;
+    } else {
+      column += 1;
+    }
+  }
+  return {
+    column,
+    line,
+    offset
+  };
+}
+function findSourceOffset(source, line, column) {
+  let currentLine = 1;
+  let currentColumn = 1;
+  for (let offset = 0; offset <= source.length; offset += 1) {
+    if (currentLine === line && currentColumn === column) {
+      return offset;
+    }
+    const character = source[offset];
+    if (character === void 0) {
+      return source.length;
+    }
+    if (character === "\r" || character === "\n" || character === "\u2028" || character === "\u2029") {
+      if (character === "\r" && source[offset + 1] === "\n") offset += 1;
+      currentLine += 1;
+      currentColumn = 1;
+    } else {
+      currentColumn += 1;
+    }
+  }
+  return source.length;
+}
+
+// packages/safe-js/src/interp/template-cache.ts
+var templateRealms = /* @__PURE__ */ new WeakMap();
+function releaseTemplateObjects(budget) {
+  const realm = templateRealms.get(budget);
+  if (realm !== void 0) budget.setRetainedValues(realm, void 0);
+  templateRealms.delete(budget);
+}
+
+// packages/safe-js/src/interp/budget.ts
+var REGEX_COMPILE_LIMITS = Object.freeze({
+  sourceLength: Infinity,
+  flagsLength: Infinity,
+  depth: Infinity,
+  allocations: Infinity
+});
+var DEADLINE_CHECK_INTERVAL = 1024;
+var SandboxError = class extends Error {
+  code;
+  budget;
+  current;
+  limit;
+  constructor(input) {
+    super(
+      input === "aborted" ? "aborted" : input === "reentry" ? "Sandbox object is already running." : `Sandbox budget exceeded for ${input.budget}: ${input.current} > ${input.limit}.`
+    );
+    this.name = "SandboxError";
+    replaceErrorStack(this);
+    if (input === "aborted") {
+      this.code = "aborted";
+      return;
+    }
+    if (input === "reentry") {
+      this.code = "reentry";
+      return;
+    }
+    this.code = "budgetExceeded";
+    this.budget = input.budget;
+    this.current = input.current;
+    this.limit = input.limit;
+  }
+};
+function isFatalSandboxError(error) {
+  return error instanceof SandboxError && (error.code === "budgetExceeded" || error.code === "reentry");
+}
+var BudgetAccounting = class {
+  deadline;
+  limits;
+  stepsUsed = 0;
+  peakCallDepth = 0;
+  currentDataSize = 0;
+  peakDataSize = 0;
+  currentCallDepth = 0;
+  allChecksSuspended = 0;
+  deadlineChecksSuspended = 0;
+  visitsUntilDeadlineCheck = DEADLINE_CHECK_INTERVAL;
+  pendingDeadlines;
+  earliestPendingDeadline;
+  retainedDataSize = 0;
+  retainedData = /* @__PURE__ */ new Map();
+  retainedValueSources = /* @__PURE__ */ new Map();
+  compileGeneration = 0;
+  activeCompileOwner;
+  defaultCompileOwner;
+  compileUses = 0;
+  provisionalScopes = 0;
+  compileTickets = /* @__PURE__ */ new Map();
+  completedCompileTickets = /* @__PURE__ */ new Set();
+  reconciliationHolds = 0;
+  deferredCompileDiscards = /* @__PURE__ */ new Set();
+  realmViews;
+  constructor(options = {}) {
+    this.deadline = normalizeDeadline(options.deadline);
+    this.limits = Object.freeze({
+      maxSteps: normalizeLimit("maxSteps", options.maxSteps),
+      maxCallDepth: normalizeLimit("maxCallDepth", options.maxCallDepth),
+      stringLength: normalizeLimit("stringLength", options.stringLength),
+      ...options.regexSourceLength === void 0 ? {} : {
+        regexSourceLength: normalizeRegexLimit("regexSourceLength", options.regexSourceLength)
+      },
+      ...options.regexCompileAllocations === void 0 ? {} : {
+        regexCompileAllocations: normalizeRegexLimit("regexCompileAllocations", options.regexCompileAllocations)
+      },
+      arrayLength: normalizeLimit("arrayLength", options.arrayLength),
+      dataSize: normalizeLimit("dataSize", options.dataSize)
+    });
+  }
+};
+var Budget = class _Budget {
+  accounting;
+  realmView = false;
+  realmLease = false;
+  constructor(options = {}) {
+    this.accounting = new BudgetAccounting(options);
+  }
+  get deadline() {
+    return this.accounting.deadline;
+  }
+  get limits() {
+    return this.accounting.limits;
+  }
+  get stepsUsed() {
+    return this.accounting.stepsUsed;
+  }
+  set stepsUsed(value) {
+    this.accounting.stepsUsed = value;
+  }
+  get peakCallDepth() {
+    return this.accounting.peakCallDepth;
+  }
+  set peakCallDepth(value) {
+    this.accounting.peakCallDepth = value;
+  }
+  get currentDataSize() {
+    return this.accounting.currentDataSize;
+  }
+  set currentDataSize(value) {
+    this.accounting.currentDataSize = value;
+  }
+  get peakDataSize() {
+    return this.accounting.peakDataSize;
+  }
+  set peakDataSize(value) {
+    this.accounting.peakDataSize = value;
+  }
+  get currentCallDepth() {
+    return this.accounting.currentCallDepth;
+  }
+  set currentCallDepth(value) {
+    this.accounting.currentCallDepth = value;
+  }
+  // Pending host operations keep their elapsed deadline active during sampled
+  // synchronous work. Linked private records need no observable native hooks.
+  acquireDeadline(deadline, onExceeded) {
+    if (!Number.isFinite(deadline)) throw new TypeError("Deadline must be a finite timestamp.");
+    const accounting = this.accounting;
+    const pending = {
+      deadline,
+      onExceeded,
+      next: accounting.pendingDeadlines,
+      active: true
+    };
+    if (pending.next !== void 0) pending.next.previous = pending;
+    accounting.pendingDeadlines = pending;
+    if (accounting.earliestPendingDeadline === void 0 || pending.deadline < accounting.earliestPendingDeadline.deadline)
+      accounting.earliestPendingDeadline = pending;
+    return () => {
+      if (!pending.active) return;
+      pending.active = false;
+      if (pending.previous === void 0) accounting.pendingDeadlines = pending.next;
+      else pending.previous.next = pending.next;
+      if (pending.next !== void 0) pending.next.previous = pending.previous;
+      pending.previous = pending.next = void 0;
+      pending.onExceeded = void 0;
+      if (accounting.earliestPendingDeadline !== pending) return;
+      accounting.earliestPendingDeadline = void 0;
+      for (let next = accounting.pendingDeadlines; next !== void 0; next = next.next)
+        if (accounting.earliestPendingDeadline === void 0 || next.deadline < accounting.earliestPendingDeadline.deadline)
+          accounting.earliestPendingDeadline = next;
+    };
+  }
+  forkRealm() {
+    const view = new _Budget();
+    view.accounting = this.accounting;
+    view.realmView = true;
+    const views = this.accounting.realmViews ??= /* @__PURE__ */ new Set([new WeakRef(this)]);
+    views.add(new WeakRef(view));
+    return view;
+  }
+  acquireRealmOwner() {
+    if (this.realmLease) throw new SandboxError("reentry");
+    const lease = this.acquireCompileOwner(
+      !this.realmView,
+      this.realmView ? this.accounting.activeCompileOwner : void 0
+    );
+    this.realmLease = true;
+    let released = false;
+    return {
+      owner: lease.owner,
+      release: () => {
+        if (released) return;
+        released = true;
+        this.realmLease = false;
+        lease.release();
+      }
+    };
+  }
+  visitNode(units = 1) {
+    if (!Number.isSafeInteger(units) || units < 0) {
+      throw new Error("units must be a non-negative safe integer.");
+    }
+    if (units === 0) return;
+    this.accounting.stepsUsed += units;
+    this.checkSampledDeadline(units);
+    if (this.accounting.allChecksSuspended === 0 && this.accounting.limits.maxSteps !== void 0 && this.accounting.stepsUsed > this.accounting.limits.maxSteps) {
+      throw new SandboxError({
+        budget: "steps",
+        current: this.accounting.stepsUsed,
+        limit: this.accounting.limits.maxSteps
+      });
+    }
+  }
+  allocateString(value) {
+    this.allocateStringLength(value.length);
+    return value;
+  }
+  allocateStringLength(length) {
+    if (this.accounting.allChecksSuspended === 0 && this.accounting.limits.stringLength !== void 0 && length > this.accounting.limits.stringLength) {
+      throw new SandboxError({
+        budget: "stringLength",
+        current: length,
+        limit: this.accounting.limits.stringLength
+      });
+    }
+  }
+  reserveString(length) {
+    if (!Number.isSafeInteger(length) || length < 0) {
+      throw new RangeError("string length must be a nonnegative safe integer");
+    }
+    if (this.accounting.allChecksSuspended === 0 && this.accounting.limits.stringLength !== void 0 && length > this.accounting.limits.stringLength) {
+      throw new SandboxError({ budget: "stringLength", current: length, limit: this.accounting.limits.stringLength });
+    }
+    return this.provisionDataUsage(length);
+  }
+  allocateArrayLength(length) {
+    if (this.accounting.allChecksSuspended === 0 && this.accounting.limits.arrayLength !== void 0 && length > this.accounting.limits.arrayLength) {
+      throw new SandboxError({
+        budget: "arrayLength",
+        current: length,
+        limit: this.accounting.limits.arrayLength
+      });
+    }
+  }
+  allocateCollectionEntries(count) {
+    this.allocateArrayLength(count);
+  }
+  reconcileDataUsage(usage) {
+    const measured = usage + this.accounting.retainedDataSize;
+    const total = this.reconciliationDeferred ? Math.max(measured, this.accounting.currentDataSize) : measured;
+    this.checkDataUsage(total);
+    this.accounting.currentDataSize = total;
+    this.accounting.peakDataSize = Math.max(this.accounting.peakDataSize, total);
+  }
+  setRetainedDataUsage(owner, usage) {
+    if (!Number.isSafeInteger(usage) || usage < 0) {
+      throw new TypeError("Retained data usage must be a non-negative safe integer.");
+    }
+    const delta = usage - (this.accounting.retainedData.get(owner) ?? 0);
+    const total = this.accounting.currentDataSize + delta;
+    this.checkDataUsage(total);
+    if (usage === 0) this.accounting.retainedData.delete(owner);
+    else this.accounting.retainedData.set(owner, usage);
+    this.accounting.retainedDataSize += delta;
+    this.accounting.currentDataSize = total;
+    this.accounting.peakDataSize = Math.max(this.accounting.peakDataSize, total);
+  }
+  setRetainedValues(owner, values) {
+    if (values === void 0) this.accounting.retainedValueSources.delete(owner);
+    else this.accounting.retainedValueSources.set(owner, values);
+  }
+  get reconciliationDeferred() {
+    return this.accounting.reconciliationHolds > 0;
+  }
+  deferReconciliation() {
+    this.accounting.reconciliationHolds++;
+    const generation = this.accounting.compileGeneration;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      if (generation !== this.accounting.compileGeneration) return;
+      if (--this.accounting.reconciliationHolds !== 0) return;
+      for (const ticket of this.accounting.deferredCompileDiscards)
+        this.accounting.completedCompileTickets.add(ticket);
+      this.accounting.deferredCompileDiscards.clear();
+    };
+  }
+  *retainedValues() {
+    for (const values of this.accounting.retainedValueSources.values()) {
+      const retained = values();
+      if (retained !== void 0) yield* retained;
+    }
+  }
+  acquireCompileOwner(reset = false, owner) {
+    if (owner !== void 0 && (owner.budget.accounting !== this.accounting || owner.generation !== this.accounting.compileGeneration) || this.accounting.activeCompileOwner !== void 0 && this.accounting.activeCompileOwner !== owner || reset && (this.accounting.compileUses !== 0 || owner !== void 0)) {
+      throw new SandboxError("reentry");
+    }
+    if (reset) this.reset();
+    const selected = owner ?? (this.accounting.defaultCompileOwner ??= Object.freeze({ budget: this, generation: this.accounting.compileGeneration }));
+    this.accounting.activeCompileOwner = selected;
+    this.accounting.compileUses += 1;
+    let released = false;
+    return {
+      owner: selected,
+      release: () => {
+        if (released) return;
+        released = true;
+        this.accounting.compileUses -= 1;
+        if (this.accounting.compileUses === 0) this.accounting.activeCompileOwner = void 0;
+      }
+    };
+  }
+  createCompileTicket(owner) {
+    if (owner.budget.accounting !== this.accounting || owner.generation !== this.accounting.compileGeneration || this.accounting.activeCompileOwner !== owner) {
+      throw new SandboxError("reentry");
+    }
+    const ticket = Object.freeze({ owner });
+    this.accounting.compileTickets.set(ticket, 0);
+    return ticket;
+  }
+  compileTicketUsage(ticket) {
+    return ticket.owner.generation === this.accounting.compileGeneration ? this.accounting.compileTickets.get(ticket) ?? 0 : 0;
+  }
+  resizeCompileTicket(ticket, usage) {
+    if (ticket.owner.generation !== this.accounting.compileGeneration || !this.accounting.compileTickets.has(ticket)) {
+      throw new SandboxError("reentry");
+    }
+    if (this.reconciliationDeferred) usage = Math.max(usage, this.compileTicketUsage(ticket));
+    this.setRetainedDataUsage(ticket, usage);
+    this.accounting.compileTickets.set(ticket, usage);
+  }
+  discardCompileTicket(ticket) {
+    if (ticket.owner.generation !== this.accounting.compileGeneration) return;
+    const usage = this.accounting.compileTickets.get(ticket);
+    if (usage === void 0) return;
+    if (this.reconciliationDeferred) {
+      this.accounting.deferredCompileDiscards.add(ticket);
+      return;
+    }
+    this.accounting.compileTickets.delete(ticket);
+    this.accounting.completedCompileTickets.delete(ticket);
+    this.accounting.retainedData.delete(ticket);
+    this.accounting.retainedDataSize -= usage;
+    this.accounting.currentDataSize -= usage;
+  }
+  reconcileCompileData(usage, included, transferred = included, retainedOwner, complete = false) {
+    if (this.reconciliationDeferred) {
+      if (retainedOwner !== void 0) this.setRetainedDataUsage(retainedOwner, usage);
+      else {
+        let includedUsage2 = 0;
+        for (const ticket of included) includedUsage2 += this.compileTicketUsage(ticket);
+        const measured2 = usage + this.accounting.retainedDataSize - includedUsage2;
+        const total2 = Math.max(measured2, this.accounting.currentDataSize);
+        this.checkDataUsage(total2);
+        this.accounting.currentDataSize = total2;
+        this.accounting.peakDataSize = Math.max(this.accounting.peakDataSize, total2);
+      }
+      return /* @__PURE__ */ new Set();
+    }
+    let includedUsage = 0;
+    let transferredUsage = 0;
+    let discardedUsage = 0;
+    const releasing = [];
+    const retained = /* @__PURE__ */ new Set();
+    for (const ticket of included) {
+      const charge = this.compileTicketUsage(ticket);
+      includedUsage += charge;
+      if (charge > 0 && transferred.has(ticket) && (this.accounting.provisionalScopes === 0 || retainedOwner !== void 0)) {
+        releasing.push(ticket);
+        transferredUsage += charge;
+      } else if (charge > 0 && complete && transferred.has(ticket)) {
+        retained.add(ticket);
+      }
+    }
+    if (retainedOwner === void 0) {
+      for (const ticket of this.accounting.completedCompileTickets) {
+        if (included.has(ticket)) continue;
+        releasing.push(ticket);
+        discardedUsage += this.compileTicketUsage(ticket);
+      }
+    }
+    const oldOwnerUsage = retainedOwner === void 0 ? 0 : this.accounting.retainedData.get(retainedOwner) ?? 0;
+    const nextRetained = this.accounting.retainedDataSize - transferredUsage - discardedUsage + (retainedOwner === void 0 ? 0 : usage - oldOwnerUsage);
+    const measured = retainedOwner === void 0 ? usage - includedUsage + transferredUsage : this.accounting.currentDataSize - this.accounting.retainedDataSize;
+    const total = measured + nextRetained;
+    this.checkDataUsage(total);
+    for (const ticket of releasing) {
+      this.accounting.compileTickets.delete(ticket);
+      this.accounting.completedCompileTickets.delete(ticket);
+      this.accounting.retainedData.delete(ticket);
+    }
+    if (retainedOwner !== void 0) {
+      if (usage === 0) this.accounting.retainedData.delete(retainedOwner);
+      else this.accounting.retainedData.set(retainedOwner, usage);
+    }
+    this.accounting.retainedDataSize = nextRetained;
+    this.accounting.currentDataSize = total;
+    this.accounting.peakDataSize = Math.max(this.accounting.peakDataSize, total);
+    for (const ticket of retained) this.accounting.completedCompileTickets.add(ticket);
+    return retained;
+  }
+  chargeDataUsage(usage) {
+    const total = this.accounting.currentDataSize + usage;
+    this.checkDataUsage(total);
+    this.accounting.currentDataSize = total;
+    this.accounting.peakDataSize = Math.max(this.accounting.peakDataSize, total);
+  }
+  provisionDataUsage(usage) {
+    const previous = this.accounting.currentDataSize;
+    const previousRetained = this.accounting.retainedDataSize;
+    const next = previous + usage;
+    this.checkDataUsage(next);
+    this.accounting.currentDataSize = next;
+    this.accounting.peakDataSize = Math.max(this.accounting.peakDataSize, next);
+    const generation = this.accounting.compileGeneration;
+    this.accounting.provisionalScopes += 1;
+    let released = false;
+    return (commit = false) => {
+      if (released) return;
+      released = true;
+      if (generation !== this.accounting.compileGeneration) return;
+      this.accounting.provisionalScopes -= 1;
+      if (!commit) {
+        const restored = previous + this.accounting.retainedDataSize - previousRetained;
+        this.accounting.currentDataSize = this.reconciliationDeferred ? Math.max(restored, this.accounting.currentDataSize) : restored;
+      }
+    };
+  }
+  enterCall() {
+    return this.enterDepth();
+  }
+  enterAwait() {
+    return this.enterDepth();
+  }
+  reset() {
+    if (this.accounting.compileUses !== 0) throw new SandboxError("reentry");
+    releaseTemplateObjects(this);
+    for (const reference of this.accounting.realmViews ?? []) {
+      const view = reference.deref();
+      if (view === void 0) this.accounting.realmViews.delete(reference);
+      else if (view !== this) releaseTemplateObjects(view);
+    }
+    this.accounting.compileGeneration += 1;
+    this.accounting.defaultCompileOwner = void 0;
+    this.accounting.provisionalScopes = 0;
+    this.accounting.compileTickets.clear();
+    this.accounting.completedCompileTickets.clear();
+    this.accounting.reconciliationHolds = 0;
+    this.accounting.deferredCompileDiscards.clear();
+    this.accounting.stepsUsed = 0;
+    this.accounting.peakCallDepth = 0;
+    this.accounting.currentCallDepth = 0;
+    this.accounting.currentDataSize = 0;
+    this.accounting.peakDataSize = 0;
+    this.accounting.retainedDataSize = 0;
+    this.accounting.retainedData.clear();
+    this.accounting.retainedValueSources.clear();
+    this.accounting.allChecksSuspended = 0;
+    this.accounting.deadlineChecksSuspended = 0;
+    this.accounting.visitsUntilDeadlineCheck = DEADLINE_CHECK_INTERVAL;
+  }
+  suspendChecks() {
+    this.accounting.allChecksSuspended += 1;
+    let resumed = false;
+    return () => {
+      if (resumed) {
+        return;
+      }
+      resumed = true;
+      this.accounting.allChecksSuspended -= 1;
+    };
+  }
+  suspendDeadlineChecks() {
+    this.accounting.deadlineChecksSuspended += 1;
+    let resumed = false;
+    return () => {
+      if (resumed) {
+        return;
+      }
+      resumed = true;
+      this.accounting.deadlineChecksSuspended -= 1;
+    };
+  }
+  checkDeadline() {
+    const pending = this.accounting.earliestPendingDeadline;
+    const deadline = this.accounting.deadline === void 0 ? pending?.deadline : Math.min(this.accounting.deadline, pending?.deadline ?? Infinity);
+    if (this.accounting.allChecksSuspended > 0 || this.accounting.deadlineChecksSuspended > 0 || deadline === void 0) {
+      return;
+    }
+    const now = Date.now();
+    if (now <= deadline) {
+      return;
+    }
+    const reason = new SandboxError({
+      budget: "deadline",
+      current: now,
+      limit: deadline
+    });
+    if (pending?.deadline === deadline) {
+      const notify = pending.onExceeded;
+      pending.onExceeded = void 0;
+      notify?.(reason);
+    }
+    throw reason;
+  }
+  checkDataUsage(usage) {
+    if (this.accounting.allChecksSuspended === 0 && this.accounting.limits.dataSize !== void 0 && usage > this.accounting.limits.dataSize) {
+      throw new SandboxError({
+        budget: "dataSize",
+        current: usage,
+        limit: this.accounting.limits.dataSize
+      });
+    }
+  }
+  checkSampledDeadline(units) {
+    if (this.accounting.allChecksSuspended > 0 || this.accounting.deadlineChecksSuspended > 0 || this.accounting.deadline === void 0 && this.accounting.earliestPendingDeadline === void 0) {
+      return;
+    }
+    this.accounting.visitsUntilDeadlineCheck -= units;
+    if (this.accounting.visitsUntilDeadlineCheck > 0) {
+      return;
+    }
+    this.accounting.visitsUntilDeadlineCheck = DEADLINE_CHECK_INTERVAL - -this.accounting.visitsUntilDeadlineCheck % DEADLINE_CHECK_INTERVAL;
+    this.checkDeadline();
+  }
+  enterDepth() {
+    const nextDepth = this.accounting.currentCallDepth + 1;
+    if (this.accounting.allChecksSuspended === 0 && this.accounting.limits.maxCallDepth !== void 0 && nextDepth > this.accounting.limits.maxCallDepth) {
+      throw new SandboxError({
+        budget: "callDepth",
+        current: nextDepth,
+        limit: this.accounting.limits.maxCallDepth
+      });
+    }
+    this.accounting.currentCallDepth = nextDepth;
+    if (nextDepth > this.accounting.peakCallDepth) {
+      this.accounting.peakCallDepth = nextDepth;
+    }
+    let left = false;
+    return () => {
+      if (left) {
+        return;
+      }
+      left = true;
+      this.accounting.currentCallDepth -= 1;
+    };
+  }
+};
+function normalizeDeadline(deadline) {
+  if (deadline === void 0 || deadline === Infinity) {
+    return void 0;
+  }
+  return deadline instanceof Date ? deadline.getTime() : deadline;
+}
+function normalizeLimit(name, value) {
+  if (value === void 0 || value === Infinity) {
+    return void 0;
+  }
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`${name} must be a non-negative integer.`);
+  }
+  return value;
+}
+function normalizeRegexLimit(name, value) {
+  if (value === void 0 || value === Infinity) return void 0;
+  if (!Number.isSafeInteger(value) || value < 1)
+    throw new RangeError(`${name} must be a positive safe integer.`);
+  return value;
+}
+
+// packages/safe-js/src/platform/context.ts
+var StackContext = class _StackContext {
+  static stores = /* @__PURE__ */ new Set();
+  value;
+  generation = 0;
+  constructor() {
+    _StackContext.stores.add(new WeakRef(this));
+  }
+  getStore() {
+    return this.value;
+  }
+  run(value, callback) {
+    const previous = this.value;
+    const generation = this.generation;
+    this.value = value;
+    try {
+      return callback();
+    } finally {
+      if (this.generation === generation) this.value = previous;
+    }
+  }
+  exit(callback) {
+    const previous = this.value;
+    const generation = this.generation;
+    this.value = void 0;
+    try {
+      return callback();
+    } finally {
+      if (this.generation === generation) this.value = previous;
+    }
+  }
+  disable() {
+    this.value = void 0;
+    this.generation++;
+  }
+  static snapshot() {
+    const values = [];
+    for (const reference of _StackContext.stores) {
+      const store = reference.deref();
+      if (store === void 0) _StackContext.stores.delete(reference);
+      else values.push([store, store.value, store.generation]);
+    }
+    return (callback) => {
+      const restore = values.map(([store]) => store.value);
+      for (const [store, value, generation] of values) if (store.generation === generation) store.value = value;
+      try {
+        return callback();
+      } finally {
+        values.forEach(([store, , generation], index) => {
+          if (store.generation === generation) store.value = restore[index];
+        });
+      }
+    };
+  }
+};
+
+// packages/safe-js/src/platform/types.ts
+function slot(method, value) {
+  if (typeof value !== "object" || value === null) return false;
+  try {
+    Reflect.apply(method, value, []);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var getter = (prototype, key) => Object.getOwnPropertyDescriptor(prototype, key).get;
+var regexpPrototype = RegExp.prototype;
+var regexpSource = getter(regexpPrototype, "source");
+var booleanValue = Boolean.prototype.valueOf;
+var numberValue = Number.prototype.valueOf;
+var stringValue = String.prototype.valueOf;
+var bigintValue = BigInt.prototype.valueOf;
+var symbolValue = Symbol.prototype.valueOf;
+var dateValue = Date.prototype.getTime;
+var asyncFunctionPrototype = Object.getPrototypeOf(async function() {
+});
+var generatorFunctionPrototype = Object.getPrototypeOf(function* () {
+});
+var arrayBufferLength = getter(ArrayBuffer.prototype, "byteLength");
+var dataViewBuffer = getter(DataView.prototype, "buffer");
+var mapSize = getter(Map.prototype, "size");
+var promiseThen = Promise.prototype.then;
+var NativeError = Error;
+var nativeIsError = Reflect.get(NativeError, "isError");
+var proxies = /* @__PURE__ */ new WeakSet();
+function createTrackedProxy(target, handler) {
+  const proxy = new Proxy(target, handler);
+  proxies.add(proxy);
+  return proxy;
+}
+var types = {
+  isProxy: (value) => (typeof value === "object" && value !== null || typeof value === "function") && proxies.has(value),
+  isBooleanObject: (value) => typeof value === "object" && value !== null && slot(booleanValue, value),
+  isNumberObject: (value) => typeof value === "object" && value !== null && slot(numberValue, value),
+  isStringObject: (value) => typeof value === "object" && slot(stringValue, value),
+  isBigIntObject: (value) => typeof value === "object" && value !== null && slot(bigintValue, value),
+  isSymbolObject: (value) => typeof value === "object" && value !== null && slot(symbolValue, value),
+  isDate: (value) => slot(dateValue, value),
+  isRegExp: (value) => value !== regexpPrototype && slot(regexpSource, value),
+  isArrayBuffer: (value) => slot(arrayBufferLength, value),
+  isDataView: (value) => slot(dataViewBuffer, value),
+  isMap: (value) => slot(mapSize, value),
+  isPromise(value) {
+    try {
+      Reflect.apply(promiseThen, value, [() => void 0, () => void 0]);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  isAsyncFunction: (value) => typeof value === "function" && Object.getPrototypeOf(value) === asyncFunctionPrototype,
+  isGeneratorFunction: (value) => typeof value === "function" && Object.getPrototypeOf(value) === generatorFunctionPrototype,
+  isNativeError: (value) => typeof value === "object" && value !== null && (typeof nativeIsError === "function" ? Reflect.apply(nativeIsError, NativeError, [value]) === true : value instanceof NativeError)
+};
+
+// packages/safe-js/src/platform/workerd.ts
+var AsyncLocalStorage = Reflect.get(globalThis, "AsyncLocalStorage") ?? StackContext;
+var cloneSharedBufferWrapper = structuredClone;
+function createHostCallbackContext() {
+  let storage = new AsyncLocalStorage();
+  return {
+    run(value, callback) {
+      if (storage === void 0) throw new SandboxError("reentry");
+      return storage.run(value, callback);
+    },
+    getStore() {
+      return storage?.getStore();
+    },
+    disable() {
+      storage = void 0;
+    }
+  };
+}
+var accessDeniedSystemError = [-13, "permission denied"];
+var yieldToHost = () => new Promise((resolve2) => setTimeout(resolve2, 0));
+var hostCwd = () => "/";
+var hostPlatform = "workerd";
+var fsConstants = { F_OK: 0, R_OK: 4, W_OK: 2, X_OK: 1, COPYFILE_EXCL: 1 };
+var hostFs = new Proxy({}, {
+  get() {
+    throw new TypeError("A filesystem adapter is required on this host.");
+  }
+});
+function inspect(value, _options) {
+  if (typeof value === "string") return "'" + value.replaceAll("'", "\\'") + "'";
+  if (typeof value === "object" && value !== null) return Array.isArray(value) ? "[Array]" : "[Object]";
+  return String(value);
+}
+
+// packages/safe-js/src/modules/paths.ts
+import { basename, dirname, extname, isAbsolutePath, joinPath, relativePath, resolvePath } from "@poe-platform/safe-fs/core";
+var sep = "/";
+function resolve(...paths) {
+  return resolvePath(hostCwd(), ...paths);
+}
+function relative(from, to) {
+  return relativePath(resolve(from), resolve(to));
+}
+var paths_default = { basename, dirname, extname, isAbsolute: isAbsolutePath, join: joinPath, relative, resolve, sep };
+
+export {
+  createTrackedProxy,
+  types,
+  internalSymbols,
+  sandboxErrorNames,
+  sandboxErrorTypes,
+  hostErrorData,
+  formatErrorStack,
+  replaceErrorStack,
+  attachErrorSpan,
+  attachWrappedErrorCause,
+  materializeWrappedErrorCause,
+  readErrorSpan,
+  readErrorCause,
+  createSourceSpan,
+  describeThrownValue,
+  templateRealms,
+  releaseTemplateObjects,
+  REGEX_COMPILE_LIMITS,
+  SandboxError,
+  isFatalSandboxError,
+  Budget,
+  AsyncLocalStorage,
+  cloneSharedBufferWrapper,
+  createHostCallbackContext,
+  accessDeniedSystemError,
+  yieldToHost,
+  hostPlatform,
+  fsConstants,
+  hostFs,
+  inspect,
+  basename,
+  dirname,
+  isAbsolutePath,
+  sep,
+  resolve,
+  relative,
+  paths_default
+};