@logixjs/core 0.0.1

package/dist/chunk-VZB726PE.js

@@ -0,0 +1,93 @@
+import {
+  Link
+} from "./chunk-JCXGZRMU.js";
+import {
+  attachMeta,
+  getDefinition,
+  getMeta
+} from "./chunk-PAYXCY6A.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/Process.ts
+var Process_exports = {};
+__export(Process_exports, {
+  attachMeta: () => attachMeta2,
+  getDefinition: () => getDefinition2,
+  getMeta: () => getMeta2,
+  link: () => link,
+  make: () => make
+});
+var DEFAULT_TRIGGERS = [{ kind: "platformEvent", platformEvent: "runtime:boot" }];
+var normalizeDefinition = (input) => {
+  const base = typeof input === "string" ? { processId: input } : input;
+  const processId = base.processId;
+  if (typeof processId !== "string" || processId.length === 0) {
+    throw new Error("[Process.make] processId must be a non-empty string");
+  }
+  const triggers = Array.isArray(base.triggers) && base.triggers.length > 0 ? base.triggers : DEFAULT_TRIGGERS;
+  const concurrency = base.concurrency ?? { mode: "latest" };
+  const errorPolicy = base.errorPolicy ?? { mode: "failStop" };
+  const diagnosticsLevel = base.diagnosticsLevel ?? "off";
+  return {
+    processId,
+    name: base.name,
+    description: base.description,
+    requires: base.requires,
+    triggers,
+    concurrency,
+    errorPolicy,
+    diagnosticsLevel
+  };
+};
+var make = (definition, effect) => attachMeta(effect, {
+  definition: normalizeDefinition(definition),
+  kind: "process"
+});
+var getDefinition2 = (effect) => getDefinition(effect);
+var getMeta2 = (effect) => getMeta(effect);
+var attachMeta2 = (effect, meta) => attachMeta(effect, meta);
+var isModuleLike = (value) => Boolean(value) && typeof value === "object" && (value._kind === "ModuleDef" || value._kind === "Module") && "tag" in value;
+var unwrapModuleTag = (module) => {
+  if (isModuleLike(module)) {
+    return module.tag;
+  }
+  return module;
+};
+function link(config, logic) {
+  const linkId = config.id ?? [...config.modules].map((m) => m.id).sort().join("~");
+  const modulesRecord = /* @__PURE__ */ Object.create(null);
+  const requires = /* @__PURE__ */ new Set();
+  for (const module of config.modules) {
+    const tag = unwrapModuleTag(module);
+    requires.add(String(tag.id));
+    modulesRecord[tag.id] = tag;
+  }
+  const effect = Link(
+    modulesRecord,
+    logic
+  );
+  const definition = {
+    processId: linkId,
+    requires: Array.from(requires),
+    triggers: [...DEFAULT_TRIGGERS, { kind: "platformEvent", platformEvent: `link:${linkId}` }],
+    concurrency: { mode: "latest" },
+    errorPolicy: { mode: "failStop" },
+    diagnosticsLevel: "off"
+  };
+  return attachMeta(effect, {
+    definition,
+    kind: "link"
+  });
+}
+
+export {
+  make,
+  getDefinition2 as getDefinition,
+  getMeta2 as getMeta,
+  attachMeta2 as attachMeta,
+  link,
+  Process_exports
+};
+//# sourceMappingURL=chunk-VZB726PE.js.map

package/dist/chunk-VZB726PE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/Process.ts"],"sourcesContent":["import { Effect } from 'effect'\nimport * as ModuleFactory from './internal/runtime/ModuleFactory.js'\nimport type * as Protocol from './internal/runtime/core/process/protocol.js'\nimport * as Meta from './internal/runtime/core/process/meta.js'\nimport type { AnyModuleShape, ModuleHandle, ModuleLike, ModuleTag } from './internal/module.js'\n\nexport type DiagnosticsLevel = Protocol.DiagnosticsLevel\nexport type ProcessScope = Protocol.ProcessScope\nexport type ProcessIdentity = Protocol.ProcessIdentity\nexport type ProcessInstanceIdentity = Protocol.ProcessInstanceIdentity\nexport type ProcessTriggerSpec = Protocol.ProcessTriggerSpec\nexport type ProcessTrigger = Protocol.ProcessTrigger\nexport type ProcessConcurrencyPolicy = Protocol.ProcessConcurrencyPolicy\nexport type ProcessErrorPolicy = Protocol.ProcessErrorPolicy\nexport type ProcessDefinition = Protocol.ProcessDefinition\nexport type ProcessInstallation = Protocol.ProcessInstallation\nexport type SerializableErrorSummary = Protocol.SerializableErrorSummary\nexport type ProcessInstanceStatus = Protocol.ProcessInstanceStatus\nexport type ProcessEvent = Protocol.ProcessEvent\nexport type ProcessControlRequest = Protocol.ProcessControlRequest\nexport type ProcessPlatformEvent = Protocol.ProcessPlatformEvent\n\nexport type ProcessEffect<E = never, R = never> = Meta.ProcessEffect<E, R>\n\nexport type ProcessMakeDefinition =\n  | string\n  | {\n      readonly processId: string\n      readonly name?: string\n      readonly description?: string\n      readonly requires?: ReadonlyArray<string>\n      readonly triggers?: ReadonlyArray<ProcessTriggerSpec>\n      readonly concurrency?: ProcessConcurrencyPolicy\n      readonly errorPolicy?: ProcessErrorPolicy\n      readonly diagnosticsLevel?: DiagnosticsLevel\n    }\n\nconst DEFAULT_TRIGGERS: ReadonlyArray<ProcessTriggerSpec> = [{ kind: 'platformEvent', platformEvent: 'runtime:boot' }]\n\nconst normalizeDefinition = (input: ProcessMakeDefinition): ProcessDefinition => {\n  const base = typeof input === 'string' ? ({ processId: input } satisfies { readonly processId: string }) : input\n\n  const processId = base.processId\n  if (typeof processId !== 'string' || processId.length === 0) {\n    throw new Error('[Process.make] processId must be a non-empty string')\n  }\n\n  const triggers = Array.isArray(base.triggers) && base.triggers.length > 0 ? base.triggers : DEFAULT_TRIGGERS\n\n  const concurrency = base.concurrency ?? ({ mode: 'latest' } satisfies ProcessConcurrencyPolicy)\n  const errorPolicy = base.errorPolicy ?? ({ mode: 'failStop' } satisfies ProcessErrorPolicy)\n  const diagnosticsLevel = base.diagnosticsLevel ?? 'off'\n\n  return {\n    processId,\n    name: base.name,\n    description: base.description,\n    requires: base.requires,\n    triggers,\n    concurrency,\n    errorPolicy,\n    diagnosticsLevel,\n  }\n}\n\nexport const make = <E, R>(definition: ProcessMakeDefinition, effect: Effect.Effect<void, E, R>): ProcessEffect<E, R> =>\n  Meta.attachMeta(effect, {\n    definition: normalizeDefinition(definition),\n    kind: 'process',\n  })\n\nexport const getDefinition = (effect: Effect.Effect<void, any, any>): ProcessDefinition | undefined =>\n  Meta.getDefinition(effect)\n\nexport const getMeta = (effect: Effect.Effect<void, any, any>): Meta.ProcessMeta | undefined => Meta.getMeta(effect)\n\nexport const attachMeta = <E, R>(effect: Effect.Effect<void, E, R>, meta: Meta.ProcessMeta): ProcessEffect<E, R> =>\n  Meta.attachMeta(effect, meta)\n\ntype LinkModuleToken<Id extends string, Sh extends AnyModuleShape> = ModuleTag<Id, Sh> | ModuleLike<Id, Sh, object>\n\ntype LinkModuleIdOf<M> = M extends { readonly id: infer Id } ? Id : never\ntype LinkModuleShapeOf<M> =\n  M extends ModuleLike<string, infer Sh, object> ? Sh : M extends ModuleTag<string, infer Sh> ? Sh : never\ntype LinkModuleTagOf<M> =\n  M extends ModuleLike<string, infer Sh, object>\n    ? ModuleTag<string, Sh>\n    : M extends ModuleTag<string, AnyModuleShape>\n      ? M\n      : never\n\nconst isModuleLike = (value: unknown): value is ModuleLike<string, AnyModuleShape, object> =>\n  Boolean(value) &&\n  typeof value === 'object' &&\n  ((value as { readonly _kind?: unknown })._kind === 'ModuleDef' ||\n    (value as { readonly _kind?: unknown })._kind === 'Module') &&\n  'tag' in (value as object)\n\nconst unwrapModuleTag = <Id extends string, Sh extends AnyModuleShape>(\n  module: LinkModuleToken<Id, Sh>,\n): ModuleTag<Id, Sh> => {\n  if (isModuleLike(module)) {\n    return module.tag\n  }\n  return module as ModuleTag<Id, Sh>\n}\n\nexport interface LinkConfig<Ms extends readonly LinkModuleToken<string, AnyModuleShape>[]> {\n  readonly id?: string\n  readonly modules: Ms\n}\n\nexport type LinkHandles<Ms extends readonly LinkModuleToken<string, AnyModuleShape>[]> = {\n  [M in Ms[number] as LinkModuleIdOf<M>]: ModuleHandle<LinkModuleShapeOf<M>>\n}\n\ntype ModulesRecord<Ms extends readonly LinkModuleToken<string, AnyModuleShape>[]> = {\n  [M in Ms[number] as LinkModuleIdOf<M>]: LinkModuleTagOf<M>\n}\n\nexport function link<Ms extends readonly LinkModuleToken<string, AnyModuleShape>[], E = never, R = never>(\n  config: LinkConfig<Ms>,\n  logic: ($: LinkHandles<Ms>) => Effect.Effect<void, E, R>,\n): ProcessEffect<E, R> {\n  const linkId =\n    config.id ??\n    [...config.modules]\n      .map((m) => m.id)\n      .sort()\n      .join('~')\n\n  const modulesRecord = Object.create(null) as ModulesRecord<Ms>\n  const requires = new Set<string>()\n\n  for (const module of config.modules) {\n    const tag = unwrapModuleTag(module)\n    requires.add(String(tag.id))\n    ;(modulesRecord as Record<string, ModuleTag<string, AnyModuleShape>>)[tag.id] = tag as unknown as ModuleTag<\n      string,\n      AnyModuleShape\n    >\n  }\n\n  const effect = ModuleFactory.Link(\n    modulesRecord as unknown as Record<string, ModuleTag<string, AnyModuleShape>>,\n    logic as unknown as ($: Record<string, ModuleHandle<AnyModuleShape>>) => Effect.Effect<void, E, R>,\n  )\n\n  const definition: ProcessDefinition = {\n    processId: linkId,\n    requires: Array.from(requires),\n    triggers: [...DEFAULT_TRIGGERS, { kind: 'platformEvent', platformEvent: `link:${linkId}` }],\n    concurrency: { mode: 'latest' },\n    errorPolicy: { mode: 'failStop' },\n    diagnosticsLevel: 'off',\n  }\n\n  return Meta.attachMeta(effect, {\n    definition,\n    kind: 'link',\n  }) as ProcessEffect<E, R>\n}\n"],"mappings":";;;;;;;;;;;;;AAAA;AAAA;AAAA,oBAAAA;AAAA,EAAA,qBAAAC;AAAA,EAAA,eAAAC;AAAA,EAAA;AAAA;AAAA;AAqCA,IAAM,mBAAsD,CAAC,EAAE,MAAM,iBAAiB,eAAe,eAAe,CAAC;AAErH,IAAM,sBAAsB,CAAC,UAAoD;AAC/E,QAAM,OAAO,OAAO,UAAU,WAAY,EAAE,WAAW,MAAM,IAA8C;AAE3G,QAAM,YAAY,KAAK;AACvB,MAAI,OAAO,cAAc,YAAY,UAAU,WAAW,GAAG;AAC3D,UAAM,IAAI,MAAM,qDAAqD;AAAA,EACvE;AAEA,QAAM,WAAW,MAAM,QAAQ,KAAK,QAAQ,KAAK,KAAK,SAAS,SAAS,IAAI,KAAK,WAAW;AAE5F,QAAM,cAAc,KAAK,eAAgB,EAAE,MAAM,SAAS;AAC1D,QAAM,cAAc,KAAK,eAAgB,EAAE,MAAM,WAAW;AAC5D,QAAM,mBAAmB,KAAK,oBAAoB;AAElD,SAAO;AAAA,IACL;AAAA,IACA,MAAM,KAAK;AAAA,IACX,aAAa,KAAK;AAAA,IAClB,UAAU,KAAK;AAAA,IACf;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAEO,IAAM,OAAO,CAAO,YAAmC,WACvD,WAAW,QAAQ;AAAA,EACtB,YAAY,oBAAoB,UAAU;AAAA,EAC1C,MAAM;AACR,CAAC;AAEI,IAAMC,iBAAgB,CAAC,WACvB,cAAc,MAAM;AAEpB,IAAMC,WAAU,CAAC,WAA6E,QAAQ,MAAM;AAE5G,IAAMC,cAAa,CAAO,QAAmC,SAC7D,WAAW,QAAQ,IAAI;AAc9B,IAAM,eAAe,CAAC,UACpB,QAAQ,KAAK,KACb,OAAO,UAAU,aACf,MAAuC,UAAU,eAChD,MAAuC,UAAU,aACpD,SAAU;AAEZ,IAAM,kBAAkB,CACtB,WACsB;AACtB,MAAI,aAAa,MAAM,GAAG;AACxB,WAAO,OAAO;AAAA,EAChB;AACA,SAAO;AACT;AAeO,SAAS,KACd,QACA,OACqB;AACrB,QAAM,SACJ,OAAO,MACP,CAAC,GAAG,OAAO,OAAO,EACf,IAAI,CAAC,MAAM,EAAE,EAAE,EACf,KAAK,EACL,KAAK,GAAG;AAEb,QAAM,gBAAgB,uBAAO,OAAO,IAAI;AACxC,QAAM,WAAW,oBAAI,IAAY;AAEjC,aAAW,UAAU,OAAO,SAAS;AACnC,UAAM,MAAM,gBAAgB,MAAM;AAClC,aAAS,IAAI,OAAO,IAAI,EAAE,CAAC;AAC1B,IAAC,cAAoE,IAAI,EAAE,IAAI;AAAA,EAIlF;AAEA,QAAM,SAAuB;AAAA,IAC3B;AAAA,IACA;AAAA,EACF;AAEA,QAAM,aAAgC;AAAA,IACpC,WAAW;AAAA,IACX,UAAU,MAAM,KAAK,QAAQ;AAAA,IAC7B,UAAU,CAAC,GAAG,kBAAkB,EAAE,MAAM,iBAAiB,eAAe,QAAQ,MAAM,GAAG,CAAC;AAAA,IAC1F,aAAa,EAAE,MAAM,SAAS;AAAA,IAC9B,aAAa,EAAE,MAAM,WAAW;AAAA,IAChC,kBAAkB;AAAA,EACpB;AAEA,SAAY,WAAW,QAAQ;AAAA,IAC7B;AAAA,IACA,MAAM;AAAA,EACR,CAAC;AACH;","names":["attachMeta","getDefinition","getMeta","getDefinition","getMeta","attachMeta"]}

package/dist/chunk-W3TEWHLO.js

@@ -0,0 +1,568 @@
+import {
+  getModuleProgramById
+} from "./chunk-66ALHVEX.js";
+import {
+  appendConvergeStaticIrCollectors
+} from "./chunk-M3BFQ7HK.js";
+import {
+  getModuleTraitsProgram,
+  getRuntimeInternals
+} from "./chunk-3RMKLXHX.js";
+import {
+  getNodeEnv
+} from "./chunk-3QMIVH35.js";
+import {
+  browserConsoleLayer,
+  browserDiagnosticConsoleLayer,
+  clearRuntimeDebugEventSeq,
+  currentDebugSinks,
+  currentDiagnosticsLevel,
+  currentRuntimeLabel,
+  currentTraitConvergeDiagnosticsSampling,
+  errorOnlyLayer,
+  noopLayer,
+  record,
+  toRuntimeDebugEventRef,
+  traitConvergeDiagnosticsSampling
+} from "./chunk-DMBALCE2.js";
+import {
+  OBSERVABILITY_PROTOCOL_VERSION,
+  exportEvidencePackage
+} from "./chunk-M7IYCTJV.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/Debug.ts
+var Debug_exports = {};
+__export(Debug_exports, {
+  appendSinks: () => appendSinks,
+  clearDevtoolsEvents: () => clearDevtoolsEvents2,
+  devtoolsHubLayer: () => devtoolsHubLayer,
+  diagnosticsLevel: () => diagnosticsLevel,
+  exportEvidencePackage: () => exportEvidencePackage2,
+  getDevtoolsRunId: () => getDevtoolsRunId2,
+  getDevtoolsSnapshot: () => getDevtoolsSnapshot2,
+  getDevtoolsSnapshotToken: () => getDevtoolsSnapshotToken2,
+  getInstanceLabel: () => getInstanceLabel2,
+  getModuleFinalTraits: () => getModuleFinalTraits,
+  getModuleTraits: () => getModuleTraits,
+  getModuleTraitsById: () => getModuleTraitsById,
+  getModuleTraitsSnapshot: () => getModuleTraitsSnapshot,
+  internal: () => internal,
+  isDevtoolsEnabled: () => isDevtoolsEnabled2,
+  layer: () => layer,
+  makeModuleRuntimeCounterSink: () => makeModuleRuntimeCounterSink,
+  makeRingBufferSink: () => makeRingBufferSink,
+  noopLayer: () => noopLayer2,
+  record: () => record2,
+  replace: () => replace,
+  runtimeLabel: () => runtimeLabel,
+  setDevtoolsRunId: () => setDevtoolsRunId2,
+  setInstanceLabel: () => setInstanceLabel2,
+  startDevtoolsRun: () => startDevtoolsRun2,
+  subscribeDevtoolsSnapshot: () => subscribeDevtoolsSnapshot2,
+  toRuntimeDebugEventRef: () => toRuntimeDebugEventRef2,
+  traceLayer: () => traceLayer,
+  traitConvergeDiagnosticsSampling: () => traitConvergeDiagnosticsSampling2,
+  withPrettyLogger: () => withPrettyLogger
+});
+import { Effect as Effect2, Layer, Logger } from "effect";
+
+// src/internal/runtime/core/DevtoolsHub.ts
+import { Effect, FiberRef } from "effect";
+var instances = /* @__PURE__ */ new Map();
+var latestStates = /* @__PURE__ */ new Map();
+var latestTraitSummaries = /* @__PURE__ */ new Map();
+var instanceLabels = /* @__PURE__ */ new Map();
+var convergeStaticIrByDigest = /* @__PURE__ */ new Map();
+var liveInstanceKeys = /* @__PURE__ */ new Set();
+var exportBudget = {
+  dropped: 0,
+  oversized: 0
+};
+var lastRunTs = 0;
+var lastRunTsSeq = 0;
+var nextRunId = () => {
+  const ts = Date.now();
+  if (ts === lastRunTs) {
+    lastRunTsSeq += 1;
+  } else {
+    lastRunTs = ts;
+    lastRunTsSeq = 0;
+  }
+  return lastRunTsSeq === 0 ? `run-${ts}` : `run-${ts}.${lastRunTsSeq}`;
+};
+var currentRunId = nextRunId();
+var nextSeq = 1;
+var bufferSize = 500;
+var ringBuffer = [];
+var ringBufferSeq = [];
+var snapshotToken = 0;
+var ensureRingBufferSize = () => {
+  if (bufferSize <= 0) {
+    ringBuffer.length = 0;
+    ringBufferSeq.length = 0;
+    return;
+  }
+  if (ringBuffer.length <= bufferSize) return;
+  const excess = ringBuffer.length - bufferSize;
+  ringBuffer.splice(0, excess);
+  ringBufferSeq.splice(0, excess);
+};
+var trimRingBufferIfNeeded = () => {
+  if (bufferSize <= 0) {
+    ringBuffer.length = 0;
+    ringBufferSeq.length = 0;
+    return;
+  }
+  if (bufferSize <= 64) {
+    ensureRingBufferSize();
+    return;
+  }
+  const slack = Math.min(1024, Math.floor(bufferSize / 2));
+  const threshold = bufferSize + Math.max(1, slack);
+  if (ringBuffer.length <= threshold) return;
+  const excess = ringBuffer.length - bufferSize;
+  ringBuffer.splice(0, excess);
+  ringBufferSeq.splice(0, excess);
+};
+var currentSnapshot = {
+  snapshotToken,
+  instances,
+  events: ringBuffer,
+  latestStates,
+  latestTraitSummaries,
+  exportBudget
+};
+var listeners = /* @__PURE__ */ new Set();
+var notifyScheduled = false;
+var scheduleNotify = () => {
+  if (notifyScheduled) return;
+  notifyScheduled = true;
+  queueMicrotask(() => {
+    notifyScheduled = false;
+    for (const listener of listeners) {
+      listener();
+    }
+  });
+};
+var devtoolsEnabled = false;
+var bumpSnapshotToken = () => {
+  snapshotToken += 1;
+  currentSnapshot.snapshotToken = snapshotToken;
+};
+var markSnapshotChanged = () => {
+  bumpSnapshotToken();
+  scheduleNotify();
+};
+var configureDevtoolsHub = (options) => {
+  devtoolsEnabled = true;
+  if (typeof options?.bufferSize === "number" && Number.isFinite(options.bufferSize)) {
+    const next = Math.floor(options.bufferSize);
+    const nextBufferSize = next >= 0 ? next : 0;
+    if (nextBufferSize !== bufferSize) {
+      bufferSize = nextBufferSize;
+      ensureRingBufferSize();
+      markSnapshotChanged();
+    }
+  }
+};
+var isDevtoolsEnabled = () => devtoolsEnabled;
+var getDevtoolsSnapshot = () => currentSnapshot;
+var getDevtoolsSnapshotToken = () => snapshotToken;
+var subscribeDevtoolsSnapshot = (listener) => {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+};
+var getDevtoolsRunId = () => currentRunId;
+var setDevtoolsRunId = (runId) => {
+  if (typeof runId !== "string" || runId.length === 0) return;
+  if (runId !== currentRunId) {
+    currentRunId = runId;
+    markSnapshotChanged();
+  }
+};
+var startDevtoolsRun = (runId) => {
+  currentRunId = typeof runId === "string" && runId.length > 0 ? runId : nextRunId();
+  nextSeq = 1;
+  clearRuntimeDebugEventSeq();
+  clearDevtoolsEvents();
+  return currentRunId;
+};
+var clearDevtoolsEvents = () => {
+  ringBuffer.length = 0;
+  ringBufferSeq.length = 0;
+  exportBudget.dropped = 0;
+  exportBudget.oversized = 0;
+  markSnapshotChanged();
+};
+var setInstanceLabel = (instanceId, label) => {
+  instanceLabels.set(instanceId, label);
+  markSnapshotChanged();
+};
+var getInstanceLabel = (instanceId) => instanceLabels.get(instanceId);
+var registerConvergeStaticIr = (ir) => {
+  convergeStaticIrByDigest.set(ir.staticIrDigest, ir);
+};
+var devtoolsHubConvergeStaticIrCollector = {
+  register: registerConvergeStaticIr
+};
+var exportDevtoolsEvidencePackage = (options) => {
+  const protocolVersion = options?.protocolVersion ?? OBSERVABILITY_PROTOCOL_VERSION;
+  const runId = options?.runId ?? currentRunId;
+  const source = options?.source ?? { host: "unknown" };
+  const events = ringBuffer.map((payload, i) => ({
+    protocolVersion,
+    runId,
+    seq: ringBufferSeq[i] ?? i + 1,
+    timestamp: payload.timestamp,
+    type: "debug:event",
+    payload
+  }));
+  const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  const convergeDigests = /* @__PURE__ */ new Set();
+  let sawFullConverge = false;
+  for (const ref of ringBuffer) {
+    if (ref.kind !== "trait:converge") continue;
+    const meta = ref.meta;
+    if (!isRecord(meta)) continue;
+    const digest = meta.staticIrDigest;
+    if (typeof digest === "string" && digest.length > 0) {
+      convergeDigests.add(digest);
+    }
+    const dirty = meta.dirty;
+    if (isRecord(dirty) && typeof dirty.rootCount === "number") {
+      sawFullConverge = true;
+    }
+  }
+  let summary;
+  if (sawFullConverge && convergeDigests.size > 0) {
+    const staticIrByDigest = {};
+    for (const digest of convergeDigests) {
+      const ir = convergeStaticIrByDigest.get(digest);
+      if (ir) {
+        staticIrByDigest[digest] = ir;
+      }
+    }
+    if (Object.keys(staticIrByDigest).length > 0) {
+      summary = { converge: { staticIrByDigest } };
+    }
+  }
+  return exportEvidencePackage({
+    protocolVersion,
+    runId,
+    source,
+    events,
+    summary
+  });
+};
+var devtoolsHubSink = {
+  record: (event) => Effect.gen(function* () {
+    const level = yield* FiberRef.get(currentDiagnosticsLevel);
+    let changed = false;
+    if (event.type === "trace:instanceLabel") {
+      const instanceId = event.instanceId;
+      const data = event.data;
+      const label = data && typeof data === "object" && "label" in data ? String(data.label) : void 0;
+      if (instanceId && label) {
+        instanceLabels.set(instanceId, label);
+        changed = true;
+      }
+    }
+    if (event.type === "module:init" || event.type === "module:destroy") {
+      const moduleId = event.moduleId ?? "unknown";
+      const runtimeLabel2 = event.runtimeLabel ?? "unknown";
+      const instanceId = event.instanceId;
+      const key = `${runtimeLabel2}::${moduleId}`;
+      const prev = instances.get(key) ?? 0;
+      if (event.type === "module:init") {
+        instances.set(key, prev + 1);
+        changed = true;
+        if (instanceId) {
+          const instanceKey = `${runtimeLabel2}::${moduleId}::${instanceId}`;
+          liveInstanceKeys.add(instanceKey);
+          if (latestStates.delete(instanceKey)) changed = true;
+          if (latestTraitSummaries.delete(instanceKey)) changed = true;
+        }
+      } else {
+        const next = prev - 1;
+        if (next <= 0) {
+          if (instances.delete(key)) changed = true;
+        } else {
+          instances.set(key, next);
+          changed = true;
+        }
+        if (instanceId) {
+          const instanceKey = `${runtimeLabel2}::${moduleId}::${instanceId}`;
+          liveInstanceKeys.delete(instanceKey);
+          if (latestStates.delete(instanceKey)) changed = true;
+          if (latestTraitSummaries.delete(instanceKey)) changed = true;
+          if (instanceLabels.delete(instanceId)) changed = true;
+          changed = true;
+        }
+      }
+    }
+    let exportBudgetChanged = false;
+    const ref = toRuntimeDebugEventRef(event, {
+      diagnosticsLevel: level,
+      resolveConvergeStaticIr: (staticIrDigest) => convergeStaticIrByDigest.get(staticIrDigest),
+      onMetaProjection: ({ stats }) => {
+        if (stats.dropped !== 0 || stats.oversized !== 0) {
+          exportBudgetChanged = true;
+        }
+        exportBudget.dropped += stats.dropped;
+        exportBudget.oversized += stats.oversized;
+      }
+    });
+    if (exportBudgetChanged) {
+      changed = true;
+    }
+    if (!ref) {
+      if (changed) {
+        markSnapshotChanged();
+      }
+      return;
+    }
+    if (ref.kind === "state" && ref.label === "state:update") {
+      const runtimeLabel2 = ref.runtimeLabel ?? "unknown";
+      const key = `${runtimeLabel2}::${ref.moduleId}::${ref.instanceId}`;
+      if (liveInstanceKeys.has(key)) {
+        if (ref.meta && typeof ref.meta === "object" && !Array.isArray(ref.meta)) {
+          const anyMeta = ref.meta;
+          if ("state" in anyMeta) {
+            latestStates.set(key, anyMeta.state);
+            changed = true;
+          }
+          if ("traitSummary" in anyMeta && anyMeta.traitSummary !== void 0) {
+            latestTraitSummaries.set(key, anyMeta.traitSummary);
+            changed = true;
+          }
+        }
+      }
+    }
+    if (bufferSize > 0) {
+      const seq = nextSeq++;
+      ringBuffer.push(ref);
+      ringBufferSeq.push(seq);
+      trimRingBufferIfNeeded();
+      changed = true;
+    }
+    if (changed) {
+      markSnapshotChanged();
+    }
+  })
+};
+
+// src/Debug.ts
+var toRuntimeDebugEventRef2 = toRuntimeDebugEventRef;
+var internal = {
+  currentDebugSinks,
+  currentRuntimeLabel,
+  currentDiagnosticsLevel,
+  currentTraitConvergeDiagnosticsSampling,
+  toRuntimeDebugEventRef
+};
+var getDevtoolsSnapshot2 = getDevtoolsSnapshot;
+var getDevtoolsSnapshotToken2 = getDevtoolsSnapshotToken;
+var subscribeDevtoolsSnapshot2 = subscribeDevtoolsSnapshot;
+var clearDevtoolsEvents2 = clearDevtoolsEvents;
+var getDevtoolsRunId2 = getDevtoolsRunId;
+var setDevtoolsRunId2 = setDevtoolsRunId;
+var startDevtoolsRun2 = startDevtoolsRun;
+var setInstanceLabel2 = setInstanceLabel;
+var getInstanceLabel2 = getInstanceLabel;
+var exportEvidencePackage2 = (options) => exportDevtoolsEvidencePackage(options);
+var diagnosticsLevel = (level) => Layer.fiberRefLocallyScopedWith(currentDiagnosticsLevel, () => level);
+var traitConvergeDiagnosticsSampling2 = (config) => traitConvergeDiagnosticsSampling(config);
+var isDevtoolsEnabled2 = isDevtoolsEnabled;
+var makeModuleRuntimeCounterSink = () => {
+  const counts = /* @__PURE__ */ new Map();
+  const sink = {
+    record: (event) => Effect2.sync(() => {
+      if (event.type === "module:init") {
+        const moduleId = event.moduleId ?? "unknown";
+        const runtimeLabel2 = "runtimeLabel" in event && event.runtimeLabel ? event.runtimeLabel : "unknown";
+        const key = `${runtimeLabel2}::${moduleId}`;
+        const prev = counts.get(key) ?? 0;
+        counts.set(key, prev + 1);
+        return;
+      }
+      if (event.type === "module:destroy") {
+        const moduleId = event.moduleId ?? "unknown";
+        const runtimeLabel2 = "runtimeLabel" in event && event.runtimeLabel ? event.runtimeLabel : "unknown";
+        const key = `${runtimeLabel2}::${moduleId}`;
+        const prev = counts.get(key) ?? 0;
+        const next = prev - 1;
+        if (next <= 0) {
+          counts.delete(key);
+        } else {
+          counts.set(key, next);
+        }
+      }
+    })
+  };
+  const getSnapshot = () => new Map(counts);
+  return { sink, getSnapshot };
+};
+var makeRingBufferSink = (capacity = 1e3) => {
+  const buffer = [];
+  const sink = {
+    record: (event) => Effect2.sync(() => {
+      if (capacity <= 0) {
+        return;
+      }
+      if (buffer.length >= capacity) {
+        buffer.shift();
+      }
+      buffer.push(event);
+    })
+  };
+  const getSnapshot = () => buffer.slice();
+  const clear = () => {
+    buffer.length = 0;
+  };
+  return { sink, getSnapshot, clear };
+};
+var record2 = record;
+var noopLayer2 = noopLayer;
+var resolveMode = (mode) => {
+  if (mode && mode !== "auto") {
+    return mode;
+  }
+  const env = getNodeEnv();
+  return env === "production" ? "prod" : "dev";
+};
+var layer = (options) => {
+  const mode = resolveMode(options?.mode);
+  const diagnostics = options?.diagnosticsLevel;
+  const sinks = (() => {
+    switch (mode) {
+      case "off":
+        return noopLayer;
+      case "prod":
+        return errorOnlyLayer;
+      case "dev":
+      case "auto": {
+        return options?.devConsole === "diagnostic" ? browserDiagnosticConsoleLayer : browserConsoleLayer;
+      }
+    }
+  })();
+  return diagnostics ? Layer.mergeAll(sinks, diagnosticsLevel(diagnostics)) : sinks;
+};
+var withPrettyLogger = (base, options) => Layer.merge(
+  base,
+  Logger.replace(Logger.defaultLogger, Logger.prettyLogger(options))
+);
+var replace = (sinks) => Layer.locallyScoped(internal.currentDebugSinks, sinks);
+var appendSinks = (sinks) => Layer.fiberRefLocallyScopedWith(currentDebugSinks, (current) => [
+  ...current,
+  ...sinks
+]);
+function devtoolsHubLayer(baseOrOptions, maybeOptions) {
+  const isLayerValue = (value) => typeof value === "object" && value !== null && "_op_layer" in value;
+  const hasBase = isLayerValue(baseOrOptions);
+  const base = hasBase ? baseOrOptions : Layer.empty;
+  const options = hasBase ? maybeOptions : baseOrOptions;
+  configureDevtoolsHub(options);
+  const append = appendSinks([devtoolsHubSink]);
+  const appendConvergeStaticIr = appendConvergeStaticIrCollectors([
+    devtoolsHubConvergeStaticIrCollector
+  ]);
+  const enableExportableDiagnostics = diagnosticsLevel(options?.diagnosticsLevel ?? "light");
+  const convergeSamplingLayer = options?.traitConvergeDiagnosticsSampling ? traitConvergeDiagnosticsSampling2(options.traitConvergeDiagnosticsSampling) : Layer.empty;
+  return Layer.provideMerge(
+    Layer.mergeAll(append, enableExportableDiagnostics, convergeSamplingLayer, appendConvergeStaticIr),
+    base
+  );
+}
+var runtimeLabel = (label) => Layer.fiberRefLocallyScopedWith(internal.currentRuntimeLabel, () => label);
+var getModuleTraits = (module) => {
+  const moduleTag = module.tag ? module.tag : module;
+  const program = getModuleTraitsProgram(moduleTag);
+  if (!program) {
+    return {};
+  }
+  return {
+    program,
+    graph: program.graph,
+    plan: program.plan
+  };
+};
+var getModuleTraitsById = (moduleId) => {
+  const program = getModuleProgramById(moduleId);
+  if (!program) {
+    return void 0;
+  }
+  return {
+    program,
+    graph: program.graph,
+    plan: program.plan
+  };
+};
+var getModuleTraitsSnapshot = (runtime) => {
+  try {
+    const internals = getRuntimeInternals(runtime);
+    return internals.traits.getModuleTraitsSnapshot();
+  } catch {
+    return void 0;
+  }
+};
+var getModuleFinalTraits = (runtime) => {
+  const snapshot = getModuleTraitsSnapshot(runtime);
+  if (!snapshot) return [];
+  return snapshot.traits.map((t) => ({
+    traitId: t.traitId,
+    name: t.name,
+    description: t.description,
+    provenance: snapshot.provenanceIndex[t.traitId]
+  }));
+};
+var isLayer = (value) => typeof value === "object" && value !== null && "_op_layer" in value;
+function traceLayer(baseOrHandler, maybeOnTrace) {
+  const hasBase = isLayer(baseOrHandler);
+  const base = hasBase ? baseOrHandler : Layer.empty;
+  const onTrace = hasBase ? maybeOnTrace : baseOrHandler;
+  const traceSink = {
+    record: (event) => typeof event.type === "string" && event.type.startsWith("trace:") ? onTrace ? onTrace(event) : Effect2.logDebug({ traceEvent: event }) : Effect2.void
+  };
+  const appendTrace = Layer.fiberRefLocallyScopedWith(currentDebugSinks, (sinks) => [...sinks, traceSink]);
+  return Layer.provideMerge(appendTrace, base);
+}
+
+export {
+  toRuntimeDebugEventRef2 as toRuntimeDebugEventRef,
+  internal,
+  getDevtoolsSnapshot2 as getDevtoolsSnapshot,
+  getDevtoolsSnapshotToken2 as getDevtoolsSnapshotToken,
+  subscribeDevtoolsSnapshot2 as subscribeDevtoolsSnapshot,
+  clearDevtoolsEvents2 as clearDevtoolsEvents,
+  getDevtoolsRunId2 as getDevtoolsRunId,
+  setDevtoolsRunId2 as setDevtoolsRunId,
+  startDevtoolsRun2 as startDevtoolsRun,
+  setInstanceLabel2 as setInstanceLabel,
+  getInstanceLabel2 as getInstanceLabel,
+  exportEvidencePackage2 as exportEvidencePackage,
+  diagnosticsLevel,
+  traitConvergeDiagnosticsSampling2 as traitConvergeDiagnosticsSampling,
+  isDevtoolsEnabled2 as isDevtoolsEnabled,
+  makeModuleRuntimeCounterSink,
+  makeRingBufferSink,
+  record2 as record,
+  noopLayer2 as noopLayer,
+  layer,
+  withPrettyLogger,
+  replace,
+  appendSinks,
+  devtoolsHubLayer,
+  runtimeLabel,
+  getModuleTraits,
+  getModuleTraitsById,
+  getModuleTraitsSnapshot,
+  getModuleFinalTraits,
+  traceLayer,
+  Debug_exports
+};
+//# sourceMappingURL=chunk-W3TEWHLO.js.map