brass-runtime 1.15.0 → 1.16.0

package/dist/chunk-U5KWK3PX.mjs

@@ -0,0 +1,343 @@
+// src/schema/index.ts
+var SchemaValidationException = class extends Error {
+  issues;
+  constructor(issues) {
+    super(formatIssues(issues));
+    this.name = "SchemaValidationException";
+    this.issues = issues;
+  }
+};
+var ConfigValidationError = class extends Error {
+  _tag = "ConfigValidationError";
+  configName;
+  issues;
+  constructor(configName, issues) {
+    super(`${configName} failed validation: ${formatIssues(issues)}`);
+    this.name = "ConfigValidationError";
+    this.configName = configName;
+    this.issues = issues;
+  }
+};
+var ok = (data) => ({ success: true, data });
+var fail = (issues) => ({ success: false, issues });
+var receivedKind = (value) => {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (Array.isArray(value)) return "array";
+  if (typeof value === "number" && Number.isNaN(value)) return "NaN";
+  return typeof value;
+};
+var pathLabel = (path) => path.length === 0 ? "$" : path.reduce((acc, part) => typeof part === "number" ? `${acc}[${part}]` : `${acc}.${part}`, "$");
+var makeSchemaIssue = (path, expected, received, message) => ({
+  path,
+  expected,
+  received: receivedKind(received),
+  message: message ?? `Expected ${expected} at ${pathLabel(path)}, received ${receivedKind(received)}`
+});
+function formatIssues(issues) {
+  if (issues.length === 0) return "Validation failed";
+  const preview = issues.slice(0, 3).map((issue) => `${pathLabel(issue.path)}: ${issue.message}`).join("; ");
+  return issues.length > 3 ? `${preview}; +${issues.length - 3} more` : preview;
+}
+function makeSchema(kind, isOptional, parser, name) {
+  const self = {
+    _tag: "Schema",
+    kind,
+    name,
+    isOptional,
+    _parse: parser,
+    safeParse: (input) => parser(input, []),
+    parse: (input) => {
+      const result = parser(input, []);
+      if (result.success) return result.data;
+      throw new SchemaValidationException(result.issues);
+    },
+    optional: () => makeSchema(
+      `${kind}.optional`,
+      true,
+      (input, path) => input === void 0 ? ok(void 0) : parser(input, path),
+      name
+    ),
+    nullable: () => makeSchema(
+      `${kind}.nullable`,
+      isOptional,
+      (input, path) => input === null ? ok(null) : parser(input, path),
+      name
+    ),
+    array: () => arraySchema(self),
+    refine: (predicate, message) => makeSchema(
+      `${kind}.refine`,
+      isOptional,
+      (input, path) => {
+        const result = parser(input, path);
+        if (!result.success) return result;
+        return predicate(result.data) ? result : fail([makeSchemaIssue(path, name ?? kind, result.data, message ?? `Failed refinement for ${name ?? kind}`)]);
+      },
+      name
+    ),
+    transform: (fn, expected) => makeSchema(
+      `${kind}.transform`,
+      false,
+      (input, path) => {
+        const result = parser(input, path);
+        if (!result.success) return result;
+        try {
+          return ok(fn(result.data));
+        } catch (error) {
+          return fail([
+            makeSchemaIssue(
+              path,
+              expected ?? `transform(${name ?? kind})`,
+              result.data,
+              error instanceof Error ? error.message : String(error)
+            )
+          ]);
+        }
+      },
+      expected ?? name
+    )
+  };
+  return self;
+}
+function stringSchema(options = {}) {
+  return makeSchema("string", false, (input, path) => {
+    if (typeof input !== "string") return fail([makeSchemaIssue(path, options.name ?? "string", input)]);
+    if (options.minLength !== void 0 && input.length < options.minLength) {
+      return fail([makeSchemaIssue(path, `string length >= ${options.minLength}`, input, `Expected at least ${options.minLength} characters`)]);
+    }
+    if (options.maxLength !== void 0 && input.length > options.maxLength) {
+      return fail([makeSchemaIssue(path, `string length <= ${options.maxLength}`, input, `Expected at most ${options.maxLength} characters`)]);
+    }
+    if (options.pattern && !options.pattern.test(input)) {
+      return fail([makeSchemaIssue(path, `string matching ${String(options.pattern)}`, input)]);
+    }
+    return ok(input);
+  }, options.name);
+}
+function nonEmptyStringSchema(options = {}) {
+  return stringSchema({
+    ...options,
+    minLength: 1,
+    name: options.name ?? "non-empty string"
+  });
+}
+var EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var ISO_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?(?:Z|[+-]\d{2}:\d{2})?)?$/;
+function emailSchema() {
+  return stringSchema({ pattern: EMAIL_PATTERN, name: "email" });
+}
+function uuidSchema() {
+  return stringSchema({ pattern: UUID_PATTERN, name: "uuid" });
+}
+function urlSchema() {
+  return stringSchema({ name: "url" }).refine((value) => {
+    try {
+      new URL(value);
+      return true;
+    } catch {
+      return false;
+    }
+  }, "Expected valid URL");
+}
+function dateIsoSchema() {
+  return stringSchema({ pattern: ISO_DATE_PATTERN, name: "ISO date" }).refine((value) => Number.isFinite(Date.parse(value)), "Expected valid ISO date string");
+}
+function numberSchema(options = {}) {
+  const finite = options.finite ?? true;
+  return makeSchema("number", false, (input, path) => {
+    if (typeof input !== "number" || Number.isNaN(input)) return fail([makeSchemaIssue(path, options.name ?? "number", input)]);
+    if (finite && !Number.isFinite(input)) return fail([makeSchemaIssue(path, "finite number", input)]);
+    if (options.int && !Number.isInteger(input)) return fail([makeSchemaIssue(path, "integer", input)]);
+    if (options.min !== void 0 && input < options.min) return fail([makeSchemaIssue(path, `number >= ${options.min}`, input)]);
+    if (options.max !== void 0 && input > options.max) return fail([makeSchemaIssue(path, `number <= ${options.max}`, input)]);
+    return ok(input);
+  }, options.name);
+}
+function intSchema(options = {}) {
+  return numberSchema({
+    ...options,
+    int: true,
+    name: options.name ?? "integer"
+  });
+}
+function positiveSchema(options = {}) {
+  const min = Math.max(options.min ?? 0, 0);
+  return numberSchema({
+    ...options,
+    min,
+    name: options.name ?? "positive number"
+  }).refine((value) => value > 0, "Expected positive number");
+}
+function booleanSchema(name) {
+  return makeSchema(
+    "boolean",
+    false,
+    (input, path) => typeof input === "boolean" ? ok(input) : fail([makeSchemaIssue(path, name ?? "boolean", input)]),
+    name
+  );
+}
+function unknownSchema() {
+  return makeSchema("unknown", false, (input) => ok(input));
+}
+function anySchema() {
+  return makeSchema("any", false, (input) => ok(input));
+}
+function literalSchema(value) {
+  return makeSchema(
+    `literal(${JSON.stringify(value)})`,
+    false,
+    (input, path) => Object.is(input, value) ? ok(value) : fail([makeSchemaIssue(path, JSON.stringify(value), input)])
+  );
+}
+function enumSchema(values) {
+  const allowed = new Set(values);
+  const expected = values.map((value) => JSON.stringify(value)).join(" | ");
+  return makeSchema(
+    `enum(${expected})`,
+    false,
+    (input, path) => (typeof input === "string" || typeof input === "number") && allowed.has(input) ? ok(input) : fail([makeSchemaIssue(path, expected, input)])
+  );
+}
+function arraySchema(item) {
+  return makeSchema("array", false, (input, path) => {
+    if (!Array.isArray(input)) return fail([makeSchemaIssue(path, "array", input)]);
+    const out = [];
+    const issues = [];
+    input.forEach((value, index) => {
+      const result = item._parse(value, [...path, index]);
+      if (result.success) {
+        out.push(result.data);
+      } else {
+        issues.push(...result.issues);
+      }
+    });
+    return issues.length > 0 ? fail(issues) : ok(out);
+  });
+}
+function objectSchema(shape, options = {}) {
+  const unknownKeys = options.unknownKeys ?? "strip";
+  return makeSchema("object", false, (input, path) => {
+    if (typeof input !== "object" || input === null || Array.isArray(input)) {
+      return fail([makeSchemaIssue(path, options.name ?? "object", input)]);
+    }
+    const source = input;
+    const out = unknownKeys === "passthrough" ? { ...source } : {};
+    const issues = [];
+    const knownKeys = new Set(Object.keys(shape));
+    for (const [key, fieldSchema] of Object.entries(shape)) {
+      if (!(key in source)) {
+        if (!fieldSchema.isOptional) {
+          issues.push(makeSchemaIssue([...path, key], fieldSchema.name ?? fieldSchema.kind, void 0, "Required field is missing"));
+        }
+        continue;
+      }
+      const result = fieldSchema._parse(source[key], [...path, key]);
+      if (result.success) {
+        out[key] = result.data;
+      } else {
+        issues.push(...result.issues);
+      }
+    }
+    if (unknownKeys === "strict") {
+      for (const key of Object.keys(source)) {
+        if (!knownKeys.has(key)) {
+          issues.push(makeSchemaIssue([...path, key], "known key", source[key], "Unknown key is not allowed"));
+        }
+      }
+    }
+    return issues.length > 0 ? fail(issues) : ok(out);
+  }, options.name);
+}
+function recordSchema(valueSchema) {
+  return makeSchema("record", false, (input, path) => {
+    if (typeof input !== "object" || input === null || Array.isArray(input)) {
+      return fail([makeSchemaIssue(path, "record", input)]);
+    }
+    const out = {};
+    const issues = [];
+    for (const [key, value] of Object.entries(input)) {
+      const result = valueSchema._parse(value, [...path, key]);
+      if (result.success) {
+        out[key] = result.data;
+      } else {
+        issues.push(...result.issues);
+      }
+    }
+    return issues.length > 0 ? fail(issues) : ok(out);
+  });
+}
+function unionSchema(members) {
+  const expected = members.map((member) => member.name ?? member.kind).join(" | ");
+  return makeSchema("union", false, (input, path) => {
+    const branchIssues = [];
+    for (const member of members) {
+      const result = member._parse(input, path);
+      if (result.success) return ok(result.data);
+      branchIssues.push(result.issues);
+    }
+    const mostSpecific = branchIssues.flatMap((issues) => issues).filter((issue) => issue.path.length > path.length).sort((a, b) => b.path.length - a.path.length);
+    if (mostSpecific.length > 0) return fail(mostSpecific);
+    return fail([makeSchemaIssue(path, expected, input)]);
+  });
+}
+function customSchema(guard, expected, message) {
+  return makeSchema(
+    expected,
+    false,
+    (input, path) => guard(input) ? ok(input) : fail([makeSchemaIssue(path, expected, input, message)]),
+    expected
+  );
+}
+var schema = Object.freeze({
+  string: stringSchema,
+  nonEmptyString: nonEmptyStringSchema,
+  email: emailSchema,
+  url: urlSchema,
+  uuid: uuidSchema,
+  dateIso: dateIsoSchema,
+  number: numberSchema,
+  int: intSchema,
+  positive: positiveSchema,
+  boolean: booleanSchema,
+  literal: literalSchema,
+  enum: enumSchema,
+  array: arraySchema,
+  object: objectSchema,
+  record: recordSchema,
+  union: unionSchema,
+  optional: (inner) => inner.optional(),
+  nullable: (inner) => inner.nullable(),
+  unknown: unknownSchema,
+  any: anySchema,
+  custom: customSchema
+});
+var s = schema;
+var Schema = schema;
+function isSchema(value) {
+  return typeof value === "object" && value !== null && value._tag === "Schema" && typeof value.safeParse === "function" && typeof value._parse === "function";
+}
+function validateValue(data, validator) {
+  if (isSchema(validator)) return validator.safeParse(data);
+  const result = validator(data);
+  if (result.success) return ok(result.data);
+  return fail(result.issues ?? [makeSchemaIssue([], "valid JSON shape", data, result.error)]);
+}
+function parseConfig(configName, validator, value) {
+  const result = validateValue(value, validator);
+  if (result.success) return result.data;
+  throw new ConfigValidationError(configName, result.issues);
+}
+
+export {
+  SchemaValidationException,
+  ConfigValidationError,
+  makeSchemaIssue,
+  formatIssues,
+  schema,
+  s,
+  Schema,
+  isSchema,
+  validateValue,
+  parseConfig
+};

package/dist/chunk-VFIUZG7J.mjs

@@ -0,0 +1,354 @@
+import {
+  makeBoundedRingBuffer
+} from "./chunk-G6IQOE4P.mjs";
+
+// src/core/runtime/metrics.ts
+var DEFAULT_BOUNDARIES = [1, 5, 10, 25, 50, 100, 250, 500, 1e3, 5e3, 1e4];
+function makeMetrics() {
+  const counters = /* @__PURE__ */ new Map();
+  const gauges = /* @__PURE__ */ new Map();
+  const histograms = /* @__PURE__ */ new Map();
+  const key = (name, labels) => labels ? `${name}|${Object.entries(labels).sort().map(([k, v]) => `${k}=${v}`).join(",")}` : name;
+  const counter = (name, labels = {}) => {
+    const k = key(name, labels);
+    if (!counters.has(k)) counters.set(k, { labels, value: 0 });
+    const entry = counters.get(k);
+    return {
+      increment: (n = 1) => {
+        entry.value += Math.max(0, n);
+      },
+      value: () => entry.value
+    };
+  };
+  const gauge = (name, labels = {}) => {
+    const k = key(name, labels);
+    if (!gauges.has(k)) gauges.set(k, { labels, value: 0 });
+    const entry = gauges.get(k);
+    return {
+      set: (v) => {
+        entry.value = v;
+      },
+      increment: (n = 1) => {
+        entry.value += n;
+      },
+      decrement: (n = 1) => {
+        entry.value -= n;
+      },
+      value: () => entry.value
+    };
+  };
+  const histogram = (name, boundaries = DEFAULT_BOUNDARIES, labels = {}) => {
+    const k = key(name, labels);
+    if (!histograms.has(k)) {
+      const sorted = [...boundaries].sort((a, b) => a - b);
+      histograms.set(k, {
+        labels,
+        boundaries: sorted,
+        data: { boundaries: sorted, counts: new Array(sorted.length + 1).fill(0), sum: 0, count: 0, min: Infinity, max: -Infinity }
+      });
+    }
+    const entry = histograms.get(k);
+    return {
+      observe: (value, exemplar) => {
+        entry.data.sum += value;
+        entry.data.count++;
+        entry.data.min = Math.min(entry.data.min, value);
+        entry.data.max = Math.max(entry.data.max, value);
+        let placed = false;
+        let bucketIndex = entry.boundaries.length;
+        for (let i = 0; i < entry.boundaries.length; i++) {
+          if (value <= entry.boundaries[i]) {
+            entry.data.counts[i]++;
+            bucketIndex = i;
+            placed = true;
+            break;
+          }
+        }
+        if (!placed) entry.data.counts[entry.boundaries.length]++;
+        if (exemplar) {
+          const exemplars = entry.data.exemplars ?? new Array(entry.boundaries.length + 1).fill(void 0);
+          exemplars[bucketIndex] = {
+            ...exemplar,
+            value,
+            timestamp: exemplar.timestamp
+          };
+          entry.data.exemplars = exemplars;
+        }
+      },
+      buckets: () => ({ ...entry.data, counts: [...entry.data.counts], exemplars: entry.data.exemplars ? [...entry.data.exemplars] : void 0 }),
+      percentile: (p) => {
+        const target = Math.ceil(entry.data.count * (p / 100));
+        let cumulative = 0;
+        for (let i = 0; i < entry.boundaries.length; i++) {
+          cumulative += entry.data.counts[i];
+          if (cumulative >= target) return entry.boundaries[i];
+        }
+        return entry.data.max;
+      }
+    };
+  };
+  return {
+    counter,
+    gauge,
+    histogram,
+    snapshot: () => ({
+      counters: Array.from(counters.entries()).map(([k, v]) => ({ name: k.split("|")[0], labels: v.labels, value: v.value })),
+      gauges: Array.from(gauges.entries()).map(([k, v]) => ({ name: k.split("|")[0], labels: v.labels, value: v.value })),
+      histograms: Array.from(histograms.entries()).map(([k, v]) => ({ name: k.split("|")[0], labels: v.labels, buckets: v.data }))
+    }),
+    reset: () => {
+      counters.clear();
+      gauges.clear();
+      histograms.clear();
+    }
+  };
+}
+
+// src/core/runtime/events.ts
+function makeRuntimeEventRecord(ev, ctx, seq) {
+  const wallTs = Date.now();
+  const ts = typeof performance !== "undefined" ? performance.now() : wallTs;
+  return {
+    ...ctx,
+    contextFiberId: ctx.fiberId,
+    contextScopeId: ctx.scopeId,
+    ...ev,
+    seq,
+    wallTs,
+    ts
+  };
+}
+function runtimeEventRecordContext(record) {
+  return {
+    fiberId: record.contextFiberId ?? record.fiberId,
+    scopeId: record.contextScopeId ?? record.scopeId,
+    traceId: record.traceId,
+    spanId: record.spanId,
+    parentSpanId: record.parentSpanId,
+    traceState: record.traceState,
+    baggage: record.baggage,
+    sampled: record.sampled
+  };
+}
+
+// src/core/runtime/eventBus.ts
+function runtimeHooksToEventHandler(hooks) {
+  return (record) => {
+    hooks.emit(record, runtimeEventRecordContext(record));
+  };
+}
+var EventBus = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  options;
+  seq = 1;
+  subs = [];
+  flushScheduled = false;
+  boundFlush = () => this.flush();
+  emit(ev, ctx) {
+    if (this.subs.length === 0) return;
+    const full = makeRuntimeEventRecord(ev, ctx, this.seq++);
+    for (const s of this.subs) {
+      const st = s.q.push(full);
+      if (st & 2 /* Dropped */) s.dropped++;
+    }
+    if (!this.flushScheduled) {
+      this.flushScheduled = true;
+      queueMicrotask(this.boundFlush);
+    }
+  }
+  subscribe(handler, perSubscriberCapacity = 2048) {
+    this.subs.push({
+      handler,
+      q: makeBoundedRingBuffer(perSubscriberCapacity, perSubscriberCapacity, this.options),
+      dropped: 0
+    });
+    return () => {
+      this.subs = this.subs.filter((s) => s.handler !== handler);
+    };
+  }
+  subscribeHooks(hooks, perSubscriberCapacity = 2048) {
+    return this.subscribe(runtimeHooksToEventHandler(hooks), perSubscriberCapacity);
+  }
+  flush(budget = 4096) {
+    this.flushScheduled = false;
+    for (const s of this.subs) {
+      let n = 0;
+      if (s.dropped > 0) {
+        const dropEv = makeRuntimeEventRecord(
+          {
+            type: "log",
+            level: "warn",
+            message: "eventbus.dropped",
+            fields: { dropped: s.dropped }
+          },
+          {},
+          0
+        );
+        try {
+          s.handler(dropEv);
+        } catch {
+        }
+        s.dropped = 0;
+      }
+      while (n++ < budget) {
+        const ev = s.q.shift();
+        if (!ev) break;
+        try {
+          s.handler(ev);
+        } catch {
+        }
+      }
+    }
+  }
+};
+
+// src/core/runtime/tracingSink.ts
+var InMemoryTracer = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  options;
+  spans = /* @__PURE__ */ new Map();
+  // key: spanId
+  prunedFinishedSpans = 0;
+  emit(ev, ctx) {
+    if (ctx.sampled === false) return;
+    const wallTs = this.now();
+    const traceId = ctx.traceId ?? "no-trace";
+    const spanId = ctx.spanId;
+    if (ev.type === "fiber.start") {
+      if (!spanId) return;
+      this.spans.set(spanId, {
+        traceId,
+        spanId,
+        parentSpanId: ctx.parentSpanId,
+        traceState: ctx.traceState,
+        name: ev.name ?? `fiber#${ev.fiberId}`,
+        startWallTs: wallTs,
+        attrs: this.attrs({ fiberId: ev.fiberId, parentFiberId: ev.parentFiberId, scopeId: ev.scopeId }),
+        links: [],
+        events: []
+      });
+      return;
+    }
+    if (ev.type === "fiber.end") {
+      if (!spanId) return;
+      const sp = this.spans.get(spanId);
+      if (sp) {
+        sp.endWallTs = wallTs;
+        sp.events.push({ wallTs, name: "fiber.end", attrs: this.attrs({ status: ev.status, error: this.error(ev.error) }) });
+        this.pruneFinished();
+      }
+      return;
+    }
+    if (ev.type === "span.start") {
+      if (!spanId) return;
+      this.spans.set(spanId, {
+        traceId,
+        spanId,
+        parentSpanId: ctx.parentSpanId,
+        traceState: ctx.traceState,
+        name: ev.name,
+        startWallTs: wallTs,
+        attrs: this.attrs(ev.attributes ?? {}),
+        links: ev.links ?? [],
+        events: []
+      });
+      return;
+    }
+    if (ev.type === "span.event") {
+      if (!spanId) return;
+      const sp = this.spans.get(spanId);
+      if (!sp) return;
+      sp.events.push({ wallTs, name: ev.name, attrs: this.attrs(ev.attributes ?? {}) });
+      return;
+    }
+    if (ev.type === "span.end") {
+      if (!spanId) return;
+      const sp = this.spans.get(spanId);
+      if (sp) {
+        sp.endWallTs = wallTs;
+        sp.events.push({ wallTs, name: "span.end", attrs: this.attrs({ status: ev.status, error: this.error(ev.error), ...ev.attributes ?? {} }) });
+        this.pruneFinished();
+      }
+      return;
+    }
+    if (ev.type === "fiber.suspend" || ev.type === "fiber.resume" || ev.type === "scope.open" || ev.type === "scope.close") {
+      if (!spanId) return;
+      const sp = this.spans.get(spanId);
+      if (!sp) return;
+      sp.events.push({ wallTs, name: ev.type, attrs: this.attrs(ev) });
+    }
+  }
+  exportFinished() {
+    this.pruneFinished();
+    return Array.from(this.spans.values()).filter((s) => s.endWallTs != null);
+  }
+  pruneFinished(spanIds) {
+    let dropped = 0;
+    if (spanIds) {
+      for (const spanId of spanIds) {
+        const span = this.spans.get(spanId);
+        if (span?.endWallTs == null) continue;
+        if (this.spans.delete(spanId)) dropped++;
+      }
+      this.prunedFinishedSpans += dropped;
+      return dropped;
+    }
+    dropped += this.pruneExpiredFinished();
+    dropped += this.pruneFinishedOverLimit();
+    this.prunedFinishedSpans += dropped;
+    return dropped;
+  }
+  stats() {
+    return {
+      storedSpans: this.spans.size,
+      finishedSpans: Array.from(this.spans.values()).filter((s) => s.endWallTs != null).length,
+      prunedFinishedSpans: this.prunedFinishedSpans
+    };
+  }
+  attrs(attrs) {
+    return this.options.sanitizeAttributes?.(attrs) ?? attrs;
+  }
+  error(error) {
+    return error === void 0 ? void 0 : this.options.sanitizeError?.(error) ?? error;
+  }
+  now() {
+    return this.options.clock?.() ?? Date.now();
+  }
+  pruneExpiredFinished() {
+    const maxAgeMs = this.options.maxSpanAgeMs;
+    if (maxAgeMs === void 0 || maxAgeMs <= 0) return 0;
+    const now = this.now();
+    let dropped = 0;
+    for (const [spanId, span] of this.spans) {
+      if (span.endWallTs == null) continue;
+      if (now - span.endWallTs > maxAgeMs && this.spans.delete(spanId)) dropped++;
+    }
+    return dropped;
+  }
+  pruneFinishedOverLimit() {
+    const maxFinishedSpans = this.options.maxFinishedSpans;
+    if (maxFinishedSpans === void 0 || maxFinishedSpans < 0) return 0;
+    const finished = Array.from(this.spans.values()).filter((span) => span.endWallTs != null).sort((a, b) => (a.endWallTs ?? 0) - (b.endWallTs ?? 0));
+    const overflow = finished.length - maxFinishedSpans;
+    if (overflow <= 0) return 0;
+    let dropped = 0;
+    for (let i = 0; i < overflow; i++) {
+      const span = finished[i];
+      if (this.spans.delete(span.spanId)) dropped++;
+    }
+    return dropped;
+  }
+};
+
+export {
+  makeMetrics,
+  makeRuntimeEventRecord,
+  runtimeEventRecordContext,
+  runtimeHooksToEventHandler,
+  EventBus,
+  InMemoryTracer
+};