@logixjs/sandbox 0.0.1 → 0.0.2

package/public/sandbox/chunks/chunk-HGV3VNH3.js

@@ -0,0 +1,255 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  makeEvidenceSink
+} from "./chunk-RS5FFPUV.js";
+import {
+  currentDiagnosticsLevel,
+  toRuntimeDebugEventRef
+} from "./chunk-CVZPRIDB.js";
+import {
+  projectJsonValue
+} from "./chunk-RYSSJBGX.js";
+
+// ../logix-core/src/internal/runtime/core/RuntimeKernel.ts
+import { Context, Effect, Option } from "../effect.js";
+var RuntimeServicesRuntimeConfigTagImpl = class extends Context.Tag(
+  "@logix/core/RuntimeServicesRuntimeConfig"
+)() {
+};
+var RuntimeServicesRuntimeConfigTag = RuntimeServicesRuntimeConfigTagImpl;
+var RuntimeServicesProviderOverridesTagImpl = class extends Context.Tag(
+  "@logix/core/RuntimeServicesProviderOverrides"
+)() {
+};
+var RuntimeServicesProviderOverridesTag = RuntimeServicesProviderOverridesTagImpl;
+var RuntimeServicesInstanceOverridesTagImpl = class extends Context.Tag(
+  "@logix/core/RuntimeServicesInstanceOverrides"
+)() {
+};
+var RuntimeServicesInstanceOverridesTag = RuntimeServicesInstanceOverridesTagImpl;
+var ORDERED_SCOPES = [
+  "builtin",
+  "runtime_default",
+  "runtime_module",
+  "provider",
+  "instance"
+];
+var maxScope = (a, b) => {
+  const ai = ORDERED_SCOPES.indexOf(a);
+  const bi = ORDERED_SCOPES.indexOf(b);
+  return ai >= bi ? a : b;
+};
+var isPlainRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var normalizeOverride = (value) => {
+  if (!isPlainRecord(value)) return void 0;
+  const implIdRaw = value.implId;
+  const notesRaw = value.notes;
+  return {
+    implId: typeof implIdRaw === "string" && implIdRaw.length > 0 ? implIdRaw : void 0,
+    notes: typeof notesRaw === "string" && notesRaw.length > 0 ? notesRaw : void 0
+  };
+};
+var resolveRuntimeServicesOverrides = (args) => Effect.gen(function* () {
+  const runtimeConfigOpt = yield* Effect.serviceOption(
+    RuntimeServicesRuntimeConfigTag
+  );
+  const providerOverridesOpt = yield* Effect.serviceOption(
+    RuntimeServicesProviderOverridesTag
+  );
+  const instanceOverridesOpt = yield* Effect.serviceOption(
+    RuntimeServicesInstanceOverridesTag
+  );
+  const runtimeConfig = Option.isSome(runtimeConfigOpt) ? runtimeConfigOpt.value : void 0;
+  const providerOverrides = Option.isSome(providerOverridesOpt) ? providerOverridesOpt.value : void 0;
+  const instanceOverrides = Option.isSome(instanceOverridesOpt) ? instanceOverridesOpt.value : void 0;
+  const moduleId = args.moduleId;
+  const runtimeModule = moduleId && runtimeConfig?.servicesByModuleId ? runtimeConfig.servicesByModuleId[moduleId] : void 0;
+  const providerModule = moduleId && providerOverrides?.servicesByModuleId ? providerOverrides.servicesByModuleId[moduleId] : void 0;
+  return {
+    runtimeDefault: runtimeConfig?.services,
+    runtimeModule,
+    provider: providerOverrides?.services,
+    providerModule,
+    instance: instanceOverrides
+  };
+});
+var selectRuntimeService = (serviceId, impls, overrides) => {
+  const builtin = impls[0];
+  if (!builtin) {
+    throw new Error(`[Logix] RuntimeKernel registry missing builtin impl for: ${serviceId}`);
+  }
+  let desired;
+  const consider = (scope, patch) => {
+    const next = patch ? normalizeOverride(patch[serviceId]) : void 0;
+    if (!next || !next.implId) return;
+    desired = { scope, override: next };
+  };
+  consider("runtime_default", overrides.runtimeDefault);
+  consider("runtime_module", overrides.runtimeModule);
+  consider("provider", overrides.provider);
+  consider("provider", overrides.providerModule);
+  consider("instance", overrides.instance);
+  if (!desired) {
+    return {
+      impl: builtin,
+      binding: {
+        serviceId,
+        implId: builtin.implId,
+        implVersion: builtin.implVersion,
+        scope: "builtin",
+        overridden: false,
+        notes: builtin.notes
+      },
+      overridesApplied: []
+    };
+  }
+  const desiredImplId = desired.override.implId;
+  const selected = impls.find((i) => i.implId === desiredImplId);
+  const impl = selected ?? builtin;
+  const didFallback = selected == null;
+  const fallbackNote = didFallback ? `Unknown implId "${desiredImplId}", falling back to builtin "${builtin.implId}"` : void 0;
+  const notes = [desired.override.notes, impl.notes, fallbackNote].filter((s) => typeof s === "string" && s.length > 0).join("; ");
+  return {
+    impl,
+    binding: {
+      serviceId,
+      implId: impl.implId,
+      implVersion: impl.implVersion,
+      scope: desired.scope,
+      overridden: true,
+      notes: notes.length > 0 ? notes : void 0
+    },
+    overridesApplied: [
+      didFallback ? `${desired.scope}:${serviceId}=${desiredImplId} (fallback=${builtin.implId})` : `${desired.scope}:${serviceId}=${desiredImplId}`
+    ]
+  };
+};
+var makeRuntimeServicesEvidence = (args) => {
+  let scope = "builtin";
+  for (const b of args.bindings) {
+    scope = maxScope(scope, b.scope);
+  }
+  return {
+    moduleId: args.moduleId,
+    instanceId: args.instanceId,
+    scope,
+    bindings: args.bindings,
+    overridesApplied: args.overridesApplied
+  };
+};
+var RUNTIME_SERVICES_EVIDENCE = /* @__PURE__ */ Symbol.for("@logix/core/runtimeServicesEvidence");
+var defineHidden = (target, key, value) => {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+};
+var setRuntimeServicesEvidence = (runtime, evidence) => {
+  defineHidden(runtime, RUNTIME_SERVICES_EVIDENCE, evidence);
+};
+
+// ../logix-core/src/internal/observability/evidenceCollector.ts
+import { Context as Context2, Effect as Effect2, FiberRef, Layer } from "../effect.js";
+var EvidenceCollectorTagImpl = class extends Context2.Tag(
+  "@logix/core/EvidenceCollector"
+)() {
+};
+var EvidenceCollectorTag = EvidenceCollectorTagImpl;
+var evidenceCollectorLayer = (collector) => Layer.succeed(EvidenceCollectorTag, collector);
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var makeEvidenceCollector = (session) => {
+  const sink = makeEvidenceSink(session);
+  const convergeStaticIrByDigest = /* @__PURE__ */ new Map();
+  let runtimeServicesEvidence;
+  const exportBudget = {
+    dropped: 0,
+    oversized: 0,
+    nonSerializable: 0
+  };
+  const debugSink = {
+    record: (event) => Effect2.gen(function* () {
+      const level = yield* FiberRef.get(currentDiagnosticsLevel);
+      const instanceIdRaw = event.instanceId;
+      const instanceId = typeof instanceIdRaw === "string" && instanceIdRaw.length > 0 ? instanceIdRaw : "unknown";
+      const eventSeq = level === "off" ? void 0 : session.local.nextSeq("eventSeq", instanceId);
+      const ref = toRuntimeDebugEventRef(event, {
+        diagnosticsLevel: level,
+        eventSeq,
+        onMetaProjection: ({ stats }) => {
+          exportBudget.dropped += stats.dropped;
+          exportBudget.oversized += stats.oversized;
+        }
+      });
+      if (!ref) return;
+      const projected = projectJsonValue(ref);
+      exportBudget.dropped += projected.stats.dropped;
+      exportBudget.oversized += projected.stats.oversized;
+      exportBudget.nonSerializable += projected.stats.nonSerializable;
+      sink.record("debug:event", projected.value, {
+        timestamp: ref.timestamp
+      });
+    })
+  };
+  const registerConvergeStaticIr = (staticIr) => {
+    if (!isRecord(staticIr)) return;
+    const digest = staticIr.staticIrDigest;
+    if (typeof digest !== "string" || digest.length === 0) return;
+    const projected = projectJsonValue(staticIr);
+    exportBudget.dropped += projected.stats.dropped;
+    exportBudget.oversized += projected.stats.oversized;
+    exportBudget.nonSerializable += projected.stats.nonSerializable;
+    convergeStaticIrByDigest.set(digest, projected.value);
+  };
+  const setRuntimeServicesEvidence2 = (evidence) => {
+    const projected = projectJsonValue(evidence);
+    exportBudget.dropped += projected.stats.dropped;
+    exportBudget.oversized += projected.stats.oversized;
+    exportBudget.nonSerializable += projected.stats.nonSerializable;
+    runtimeServicesEvidence = projected.value;
+  };
+  const exportEvidencePackage = (options) => {
+    const convergeSummary = convergeStaticIrByDigest.size > 0 ? {
+      staticIrByDigest: Object.fromEntries(convergeStaticIrByDigest)
+    } : void 0;
+    const runtimeSummary = runtimeServicesEvidence != null ? { services: runtimeServicesEvidence } : void 0;
+    const summary = convergeSummary != null || runtimeSummary != null ? {
+      ...convergeSummary != null ? { converge: convergeSummary } : {},
+      ...runtimeSummary != null ? { runtime: runtimeSummary } : {}
+    } : void 0;
+    return sink.export({
+      maxEvents: options?.maxEvents,
+      summary
+    });
+  };
+  const clear = () => {
+    sink.clear();
+    convergeStaticIrByDigest.clear();
+    runtimeServicesEvidence = void 0;
+    exportBudget.dropped = 0;
+    exportBudget.oversized = 0;
+    exportBudget.nonSerializable = 0;
+  };
+  return {
+    session,
+    debugSink,
+    registerConvergeStaticIr,
+    setRuntimeServicesEvidence: setRuntimeServicesEvidence2,
+    exportEvidencePackage,
+    clear
+  };
+};
+
+export {
+  RuntimeServicesInstanceOverridesTag,
+  resolveRuntimeServicesOverrides,
+  selectRuntimeService,
+  makeRuntimeServicesEvidence,
+  setRuntimeServicesEvidence,
+  EvidenceCollectorTag,
+  evidenceCollectorLayer,
+  makeEvidenceCollector
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/runtime/core/RuntimeKernel.ts", "../../../../logix-core/src/internal/observability/evidenceCollector.ts"],
  "sourcesContent": ["import { Context, Effect, Option } from \"effect\"\nimport { isDevEnv } from \"./env.js\"\n\nexport type OverrideScope =\n  | \"builtin\"\n  | \"runtime_default\"\n  | \"runtime_module\"\n  | \"provider\"\n  | \"instance\"\n\nexport type RuntimeServiceOverride = {\n  readonly implId?: string\n  readonly notes?: string\n}\n\n/**\n * RuntimeServicesOverrides\uFF1A\u53EF\u5E8F\u5217\u5316\u7684\u201C\u670D\u52A1\u5B9E\u73B0\u9009\u62E9\u201D\u8986\u5199\u3002\n *\n * - key \u4E3A\u7A33\u5B9A serviceId\uFF1B\n * - value \u4EC5\u5141\u8BB8\u5305\u542B\u53EF\u5E8F\u5217\u5316\u5B57\u6BB5\uFF08\u7981\u6B62\u51FD\u6570/\u95ED\u5305\uFF09\uFF0C\u4EE5\u4FBF\u751F\u6210\u53EF\u89E3\u91CA\u8BC1\u636E\u3002\n */\nexport type RuntimeServicesOverrides = Readonly<\n  Record<string, RuntimeServiceOverride>\n>\n\nexport interface RuntimeServicesRuntimeConfig {\n  /** Runtime \u7EA7\u9ED8\u8BA4\u8986\u5199\uFF08runtime_default\uFF09\u3002 */\n  readonly services?: RuntimeServicesOverrides\n  /** \u6309 moduleId \u7684\u5DEE\u91CF\u8986\u5199\uFF08runtime_module\uFF09\u3002 */\n  readonly servicesByModuleId?: Readonly<Record<string, RuntimeServicesOverrides>>\n}\n\nclass RuntimeServicesRuntimeConfigTagImpl extends Context.Tag(\n  \"@logix/core/RuntimeServicesRuntimeConfig\",\n)<RuntimeServicesRuntimeConfigTagImpl, RuntimeServicesRuntimeConfig>() {}\n\nexport const RuntimeServicesRuntimeConfigTag = RuntimeServicesRuntimeConfigTagImpl\n\nexport interface RuntimeServicesProviderOverrides {\n  /** Provider \u8303\u56F4\u9ED8\u8BA4\u8986\u5199\uFF08provider\uFF09\u3002 */\n  readonly services?: RuntimeServicesOverrides\n  /** Provider \u8303\u56F4\u6309 moduleId \u7684\u5DEE\u91CF\u8986\u5199\uFF08provider\uFF09\u3002 */\n  readonly servicesByModuleId?: Readonly<Record<string, RuntimeServicesOverrides>>\n}\n\nclass RuntimeServicesProviderOverridesTagImpl extends Context.Tag(\n  \"@logix/core/RuntimeServicesProviderOverrides\",\n)<RuntimeServicesProviderOverridesTagImpl, RuntimeServicesProviderOverrides>() {}\n\nexport const RuntimeServicesProviderOverridesTag = RuntimeServicesProviderOverridesTagImpl\n\nclass RuntimeServicesInstanceOverridesTagImpl extends Context.Tag(\n  \"@logix/core/RuntimeServicesInstanceOverrides\",\n)<RuntimeServicesInstanceOverridesTagImpl, RuntimeServicesOverrides>() {}\n\nexport const RuntimeServicesInstanceOverridesTag = RuntimeServicesInstanceOverridesTagImpl\n\nexport interface RuntimeServiceBinding {\n  readonly serviceId: string\n  readonly implId?: string\n  readonly implVersion?: string\n  readonly scope: OverrideScope\n  readonly overridden: boolean\n  readonly notes?: string\n}\n\nexport interface RuntimeServicesEvidence {\n  readonly moduleId?: string\n  readonly instanceId: string\n  readonly scope: OverrideScope\n  readonly bindings: ReadonlyArray<RuntimeServiceBinding>\n  readonly overridesApplied: ReadonlyArray<string>\n}\n\nconst ORDERED_SCOPES: ReadonlyArray<OverrideScope> = [\n  \"builtin\",\n  \"runtime_default\",\n  \"runtime_module\",\n  \"provider\",\n  \"instance\",\n]\n\nconst maxScope = (a: OverrideScope, b: OverrideScope): OverrideScope => {\n  const ai = ORDERED_SCOPES.indexOf(a)\n  const bi = ORDERED_SCOPES.indexOf(b)\n  return (ai >= bi ? a : b) as OverrideScope\n}\n\nconst isPlainRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value)\n\nconst normalizeOverride = (value: unknown): RuntimeServiceOverride | undefined => {\n  if (!isPlainRecord(value)) return undefined\n\n  const implIdRaw = value.implId\n  const notesRaw = value.notes\n\n  return {\n    implId: typeof implIdRaw === \"string\" && implIdRaw.length > 0 ? implIdRaw : undefined,\n    notes: typeof notesRaw === \"string\" && notesRaw.length > 0 ? notesRaw : undefined,\n  }\n}\n\nexport const resolveRuntimeServicesOverrides = (args: {\n  readonly moduleId: string | undefined\n}): Effect.Effect<\n  {\n    readonly runtimeDefault?: RuntimeServicesOverrides\n    readonly runtimeModule?: RuntimeServicesOverrides\n    readonly provider?: RuntimeServicesOverrides\n    readonly providerModule?: RuntimeServicesOverrides\n    readonly instance?: RuntimeServicesOverrides\n  },\n  never,\n  any\n> =>\n  Effect.gen(function* () {\n    const runtimeConfigOpt = yield* Effect.serviceOption(\n      RuntimeServicesRuntimeConfigTag,\n    )\n    const providerOverridesOpt = yield* Effect.serviceOption(\n      RuntimeServicesProviderOverridesTag,\n    )\n    const instanceOverridesOpt = yield* Effect.serviceOption(\n      RuntimeServicesInstanceOverridesTag,\n    )\n\n    const runtimeConfig = Option.isSome(runtimeConfigOpt)\n      ? runtimeConfigOpt.value\n      : undefined\n    const providerOverrides = Option.isSome(providerOverridesOpt)\n      ? providerOverridesOpt.value\n      : undefined\n    const instanceOverrides = Option.isSome(instanceOverridesOpt)\n      ? instanceOverridesOpt.value\n      : undefined\n\n    const moduleId = args.moduleId\n\n    const runtimeModule =\n      moduleId && runtimeConfig?.servicesByModuleId\n        ? runtimeConfig.servicesByModuleId[moduleId]\n        : undefined\n\n    const providerModule =\n      moduleId && providerOverrides?.servicesByModuleId\n        ? providerOverrides.servicesByModuleId[moduleId]\n        : undefined\n\n    return {\n      runtimeDefault: runtimeConfig?.services,\n      runtimeModule,\n      provider: providerOverrides?.services,\n      providerModule,\n      instance: instanceOverrides,\n    }\n  })\n\nexport interface RuntimeServiceImpl<Service> {\n  readonly implId: string\n  readonly implVersion: string\n  readonly make: Effect.Effect<Service, never, any>\n  readonly notes?: string\n}\n\nexport interface RuntimeServiceSelection<Service> {\n  readonly binding: RuntimeServiceBinding\n  readonly impl: RuntimeServiceImpl<Service>\n  readonly overridesApplied: ReadonlyArray<string>\n}\n\nexport const selectRuntimeService = <Service>(\n  serviceId: string,\n  impls: ReadonlyArray<RuntimeServiceImpl<Service>>,\n  overrides: {\n    readonly runtimeDefault?: RuntimeServicesOverrides\n    readonly runtimeModule?: RuntimeServicesOverrides\n    readonly provider?: RuntimeServicesOverrides\n    readonly providerModule?: RuntimeServicesOverrides\n    readonly instance?: RuntimeServicesOverrides\n  },\n): RuntimeServiceSelection<Service> => {\n  const builtin = impls[0]\n  if (!builtin) {\n    throw new Error(`[Logix] RuntimeKernel registry missing builtin impl for: ${serviceId}`)\n  }\n\n  let desired: { readonly scope: OverrideScope; readonly override: RuntimeServiceOverride } | undefined\n  const consider = (scope: OverrideScope, patch: RuntimeServicesOverrides | undefined): void => {\n    const next = patch ? normalizeOverride(patch[serviceId]) : undefined\n    if (!next || !next.implId) return\n    desired = { scope, override: next }\n  }\n\n  // priority: builtin < runtime_default < runtime_module < provider < instance\n  consider(\"runtime_default\", overrides.runtimeDefault)\n  consider(\"runtime_module\", overrides.runtimeModule)\n  consider(\"provider\", overrides.provider)\n  consider(\"provider\", overrides.providerModule)\n  consider(\"instance\", overrides.instance)\n\n  if (!desired) {\n    return {\n      impl: builtin,\n      binding: {\n        serviceId,\n        implId: builtin.implId,\n        implVersion: builtin.implVersion,\n        scope: \"builtin\",\n        overridden: false,\n        notes: builtin.notes,\n      },\n      overridesApplied: [],\n    }\n  }\n\n  const desiredImplId = desired.override.implId!\n  const selected = impls.find((i) => i.implId === desiredImplId)\n  const impl = selected ?? builtin\n\n  const didFallback = selected == null\n  const fallbackNote =\n    didFallback\n      ? `Unknown implId \"${desiredImplId}\", falling back to builtin \"${builtin.implId}\"`\n      : undefined\n\n  const notes = [desired.override.notes, impl.notes, fallbackNote]\n    .filter((s): s is string => typeof s === \"string\" && s.length > 0)\n    .join(\"; \")\n\n  return {\n    impl,\n    binding: {\n      serviceId,\n      implId: impl.implId,\n      implVersion: impl.implVersion,\n      scope: desired.scope,\n      overridden: true,\n      notes: notes.length > 0 ? notes : undefined,\n    },\n    overridesApplied: [\n      didFallback\n        ? `${desired.scope}:${serviceId}=${desiredImplId} (fallback=${builtin.implId})`\n        : `${desired.scope}:${serviceId}=${desiredImplId}`,\n    ],\n  }\n}\n\nexport const makeRuntimeServicesEvidence = (args: {\n  readonly moduleId: string | undefined\n  readonly instanceId: string\n  readonly bindings: ReadonlyArray<RuntimeServiceBinding>\n  readonly overridesApplied: ReadonlyArray<string>\n}): RuntimeServicesEvidence => {\n  let scope: OverrideScope = \"builtin\"\n  for (const b of args.bindings) {\n    scope = maxScope(scope, b.scope)\n  }\n\n  return {\n    moduleId: args.moduleId,\n    instanceId: args.instanceId,\n    scope,\n    bindings: args.bindings,\n    overridesApplied: args.overridesApplied,\n  }\n}\n\nconst RUNTIME_SERVICES_EVIDENCE = Symbol.for(\"@logix/core/runtimeServicesEvidence\")\n\nconst defineHidden = (target: object, key: symbol, value: unknown): void => {\n  Object.defineProperty(target, key, {\n    value,\n    enumerable: false,\n    configurable: true,\n    writable: false,\n  })\n}\n\nconst formatScope = (moduleId: unknown, instanceId: unknown): string => {\n  const m = typeof moduleId === \"string\" && moduleId.length > 0 ? moduleId : \"unknown\"\n  const i = typeof instanceId === \"string\" && instanceId.length > 0 ? instanceId : \"unknown\"\n  return `moduleId=${m}, instanceId=${i}`\n}\n\nexport const setRuntimeServicesEvidence = (runtime: object, evidence: RuntimeServicesEvidence): void => {\n  defineHidden(runtime, RUNTIME_SERVICES_EVIDENCE, evidence)\n}\n\nexport const getRuntimeServicesEvidence = (runtime: object): RuntimeServicesEvidence => {\n  const scope = runtime as { readonly moduleId?: unknown; readonly instanceId?: unknown }\n  const evidence = (runtime as any)[RUNTIME_SERVICES_EVIDENCE] as RuntimeServicesEvidence | undefined\n  if (!evidence) {\n    const msg = isDevEnv()\n      ? [\n          \"[MissingRuntimeServicesEvidence] Runtime services evidence not installed on ModuleRuntime instance.\",\n          `scope: ${formatScope(scope.moduleId, scope.instanceId)}`,\n          \"fix:\",\n          \"- Ensure ModuleRuntime.make assembles RuntimeKernel and attaches evidence (020 US2).\",\n          \"- If you created a mock runtime for tests, attach evidence or avoid calling evidence-only APIs.\",\n        ].join(\"\\n\")\n      : \"Runtime services evidence not installed\"\n    throw new Error(msg)\n  }\n\n  const runtimeInstanceId = scope.instanceId\n  if (\n    typeof runtimeInstanceId === \"string\" &&\n    runtimeInstanceId.length > 0 &&\n    runtimeInstanceId !== evidence.instanceId\n  ) {\n    throw new Error(\n      isDevEnv()\n        ? [\n            \"[InconsistentRuntimeServicesEvidence] Runtime services evidence instanceId mismatch.\",\n            `runtime: ${formatScope(scope.moduleId, runtimeInstanceId)}`,\n            `evidence: ${formatScope(evidence.moduleId, evidence.instanceId)}`,\n          ].join(\"\\n\")\n        : \"Runtime services evidence mismatch\",\n    )\n  }\n\n  return evidence\n}\n", "import { Context, Effect, FiberRef, Layer } from \"effect\"\nimport type { JsonValue } from \"./jsonValue.js\"\nimport { projectJsonValue } from \"./jsonValue.js\"\nimport type { EvidencePackage } from \"./evidence.js\"\nimport type { RunSession } from \"./runSession.js\"\nimport { makeEvidenceSink } from \"./runSession.js\"\nimport {\n  currentDiagnosticsLevel,\n  toRuntimeDebugEventRef,\n  type Event as DebugEvent,\n  type Sink as DebugSink,\n} from \"../runtime/core/DebugSink.js\"\n\nexport interface EvidenceCollector {\n  readonly session: RunSession\n  readonly debugSink: DebugSink\n  readonly registerConvergeStaticIr: (staticIr: unknown) => void\n  readonly setRuntimeServicesEvidence: (evidence: unknown) => void\n  readonly exportEvidencePackage: (options?: { readonly maxEvents?: number }) => EvidencePackage\n  readonly clear: () => void\n}\n\nclass EvidenceCollectorTagImpl extends Context.Tag(\n  \"@logix/core/EvidenceCollector\",\n)<EvidenceCollectorTagImpl, EvidenceCollector>() {}\n\nexport const EvidenceCollectorTag = EvidenceCollectorTagImpl\n\nexport const evidenceCollectorLayer = (\n  collector: EvidenceCollector,\n): Layer.Layer<EvidenceCollectorTagImpl, never, never> =>\n  Layer.succeed(EvidenceCollectorTag, collector) as Layer.Layer<\n    EvidenceCollectorTagImpl,\n    never,\n    never\n  >\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value)\n\nexport const makeEvidenceCollector = (session: RunSession): EvidenceCollector => {\n  const sink = makeEvidenceSink(session)\n\n  const convergeStaticIrByDigest = new Map<string, JsonValue>()\n  let runtimeServicesEvidence: JsonValue | undefined\n\n  const exportBudget = {\n    dropped: 0,\n    oversized: 0,\n    nonSerializable: 0,\n  }\n\n  const debugSink: DebugSink = {\n    record: (event: DebugEvent) =>\n      Effect.gen(function* () {\n        const level = yield* FiberRef.get(currentDiagnosticsLevel)\n        const instanceIdRaw = (event as any).instanceId\n        const instanceId =\n          typeof instanceIdRaw === \"string\" && instanceIdRaw.length > 0\n            ? instanceIdRaw\n            : \"unknown\"\n        const eventSeq =\n          level === \"off\"\n            ? undefined\n            : session.local.nextSeq(\"eventSeq\", instanceId)\n        const ref = toRuntimeDebugEventRef(event, {\n          diagnosticsLevel: level,\n          eventSeq,\n          onMetaProjection: ({ stats }) => {\n            exportBudget.dropped += stats.dropped\n            exportBudget.oversized += stats.oversized\n          },\n        })\n        if (!ref) return\n\n        const projected = projectJsonValue(ref)\n        exportBudget.dropped += projected.stats.dropped\n        exportBudget.oversized += projected.stats.oversized\n        exportBudget.nonSerializable += projected.stats.nonSerializable\n\n        sink.record(\"debug:event\", projected.value, {\n          timestamp: ref.timestamp,\n        })\n      }),\n  }\n\n  const registerConvergeStaticIr = (staticIr: unknown): void => {\n    if (!isRecord(staticIr)) return\n    const digest = staticIr.staticIrDigest\n    if (typeof digest !== \"string\" || digest.length === 0) return\n    const projected = projectJsonValue(staticIr)\n    exportBudget.dropped += projected.stats.dropped\n    exportBudget.oversized += projected.stats.oversized\n    exportBudget.nonSerializable += projected.stats.nonSerializable\n    convergeStaticIrByDigest.set(digest, projected.value)\n  }\n\n  const setRuntimeServicesEvidence = (evidence: unknown): void => {\n    const projected = projectJsonValue(evidence)\n    exportBudget.dropped += projected.stats.dropped\n    exportBudget.oversized += projected.stats.oversized\n    exportBudget.nonSerializable += projected.stats.nonSerializable\n    runtimeServicesEvidence = projected.value\n  }\n\n  const exportEvidencePackage = (options?: {\n    readonly maxEvents?: number\n  }): EvidencePackage => {\n    const convergeSummary =\n      convergeStaticIrByDigest.size > 0\n        ? ({\n            staticIrByDigest: Object.fromEntries(convergeStaticIrByDigest),\n          } as unknown as JsonValue)\n        : undefined\n\n    const runtimeSummary =\n      runtimeServicesEvidence != null\n        ? ({ services: runtimeServicesEvidence } as unknown as JsonValue)\n        : undefined\n\n    const summary =\n      convergeSummary != null || runtimeSummary != null\n        ? ({\n            ...(convergeSummary != null ? { converge: convergeSummary } : {}),\n            ...(runtimeSummary != null ? { runtime: runtimeSummary } : {}),\n          } as unknown as JsonValue)\n        : undefined\n\n    return sink.export({\n      maxEvents: options?.maxEvents,\n      summary,\n    })\n  }\n\n  const clear = (): void => {\n    sink.clear()\n    convergeStaticIrByDigest.clear()\n    runtimeServicesEvidence = undefined\n    exportBudget.dropped = 0\n    exportBudget.oversized = 0\n    exportBudget.nonSerializable = 0\n  }\n\n  return {\n    session,\n    debugSink,\n    registerConvergeStaticIr,\n    setRuntimeServicesEvidence,\n    exportEvidencePackage,\n    clear,\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;AAAA,SAAS,SAAS,QAAQ,cAAc;AAgCxC,IAAM,sCAAN,cAAkD,QAAQ;AAAA,EACxD;AACF,EAAqE,EAAE;AAAC;AAEjE,IAAM,kCAAkC;AAS/C,IAAM,0CAAN,cAAsD,QAAQ;AAAA,EAC5D;AACF,EAA6E,EAAE;AAAC;AAEzE,IAAM,sCAAsC;AAEnD,IAAM,0CAAN,cAAsD,QAAQ;AAAA,EAC5D;AACF,EAAqE,EAAE;AAAC;AAEjE,IAAM,sCAAsC;AAmBnD,IAAM,iBAA+C;AAAA,EACnD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAEA,IAAM,WAAW,CAAC,GAAkB,MAAoC;AACtE,QAAM,KAAK,eAAe,QAAQ,CAAC;AACnC,QAAM,KAAK,eAAe,QAAQ,CAAC;AACnC,SAAQ,MAAM,KAAK,IAAI;AACzB;AAEA,IAAM,gBAAgB,CAAC,UACrB,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAErE,IAAM,oBAAoB,CAAC,UAAuD;AAChF,MAAI,CAAC,cAAc,KAAK,EAAG,QAAO;AAElC,QAAM,YAAY,MAAM;AACxB,QAAM,WAAW,MAAM;AAEvB,SAAO;AAAA,IACL,QAAQ,OAAO,cAAc,YAAY,UAAU,SAAS,IAAI,YAAY;AAAA,IAC5E,OAAO,OAAO,aAAa,YAAY,SAAS,SAAS,IAAI,WAAW;AAAA,EAC1E;AACF;AAEO,IAAM,kCAAkC,CAAC,SAa9C,OAAO,IAAI,aAAa;AACtB,QAAM,mBAAmB,OAAO,OAAO;AAAA,IACrC;AAAA,EACF;AACA,QAAM,uBAAuB,OAAO,OAAO;AAAA,IACzC;AAAA,EACF;AACA,QAAM,uBAAuB,OAAO,OAAO;AAAA,IACzC;AAAA,EACF;AAEA,QAAM,gBAAgB,OAAO,OAAO,gBAAgB,IAChD,iBAAiB,QACjB;AACJ,QAAM,oBAAoB,OAAO,OAAO,oBAAoB,IACxD,qBAAqB,QACrB;AACJ,QAAM,oBAAoB,OAAO,OAAO,oBAAoB,IACxD,qBAAqB,QACrB;AAEJ,QAAM,WAAW,KAAK;AAEtB,QAAM,gBACJ,YAAY,eAAe,qBACvB,cAAc,mBAAmB,QAAQ,IACzC;AAEN,QAAM,iBACJ,YAAY,mBAAmB,qBAC3B,kBAAkB,mBAAmB,QAAQ,IAC7C;AAEN,SAAO;AAAA,IACL,gBAAgB,eAAe;AAAA,IAC/B;AAAA,IACA,UAAU,mBAAmB;AAAA,IAC7B;AAAA,IACA,UAAU;AAAA,EACZ;AACF,CAAC;AAeI,IAAM,uBAAuB,CAClC,WACA,OACA,cAOqC;AACrC,QAAM,UAAU,MAAM,CAAC;AACvB,MAAI,CAAC,SAAS;AACZ,UAAM,IAAI,MAAM,4DAA4D,SAAS,EAAE;AAAA,EACzF;AAEA,MAAI;AACJ,QAAM,WAAW,CAAC,OAAsB,UAAsD;AAC5F,UAAM,OAAO,QAAQ,kBAAkB,MAAM,SAAS,CAAC,IAAI;AAC3D,QAAI,CAAC,QAAQ,CAAC,KAAK,OAAQ;AAC3B,cAAU,EAAE,OAAO,UAAU,KAAK;AAAA,EACpC;AAGA,WAAS,mBAAmB,UAAU,cAAc;AACpD,WAAS,kBAAkB,UAAU,aAAa;AAClD,WAAS,YAAY,UAAU,QAAQ;AACvC,WAAS,YAAY,UAAU,cAAc;AAC7C,WAAS,YAAY,UAAU,QAAQ;AAEvC,MAAI,CAAC,SAAS;AACZ,WAAO;AAAA,MACL,MAAM;AAAA,MACN,SAAS;AAAA,QACP;AAAA,QACA,QAAQ,QAAQ;AAAA,QAChB,aAAa,QAAQ;AAAA,QACrB,OAAO;AAAA,QACP,YAAY;AAAA,QACZ,OAAO,QAAQ;AAAA,MACjB;AAAA,MACA,kBAAkB,CAAC;AAAA,IACrB;AAAA,EACF;AAEA,QAAM,gBAAgB,QAAQ,SAAS;AACvC,QAAM,WAAW,MAAM,KAAK,CAAC,MAAM,EAAE,WAAW,aAAa;AAC7D,QAAM,OAAO,YAAY;AAEzB,QAAM,cAAc,YAAY;AAChC,QAAM,eACJ,cACI,mBAAmB,aAAa,+BAA+B,QAAQ,MAAM,MAC7E;AAEN,QAAM,QAAQ,CAAC,QAAQ,SAAS,OAAO,KAAK,OAAO,YAAY,EAC5D,OAAO,CAAC,MAAmB,OAAO,MAAM,YAAY,EAAE,SAAS,CAAC,EAChE,KAAK,IAAI;AAEZ,SAAO;AAAA,IACL;AAAA,IACA,SAAS;AAAA,MACP;AAAA,MACA,QAAQ,KAAK;AAAA,MACb,aAAa,KAAK;AAAA,MAClB,OAAO,QAAQ;AAAA,MACf,YAAY;AAAA,MACZ,OAAO,MAAM,SAAS,IAAI,QAAQ;AAAA,IACpC;AAAA,IACA,kBAAkB;AAAA,MAChB,cACI,GAAG,QAAQ,KAAK,IAAI,SAAS,IAAI,aAAa,cAAc,QAAQ,MAAM,MAC1E,GAAG,QAAQ,KAAK,IAAI,SAAS,IAAI,aAAa;AAAA,IACpD;AAAA,EACF;AACF;AAEO,IAAM,8BAA8B,CAAC,SAKb;AAC7B,MAAI,QAAuB;AAC3B,aAAW,KAAK,KAAK,UAAU;AAC7B,YAAQ,SAAS,OAAO,EAAE,KAAK;AAAA,EACjC;AAEA,SAAO;AAAA,IACL,UAAU,KAAK;AAAA,IACf,YAAY,KAAK;AAAA,IACjB;AAAA,IACA,UAAU,KAAK;AAAA,IACf,kBAAkB,KAAK;AAAA,EACzB;AACF;AAEA,IAAM,4BAA4B,uBAAO,IAAI,qCAAqC;AAElF,IAAM,eAAe,CAAC,QAAgB,KAAa,UAAyB;AAC1E,SAAO,eAAe,QAAQ,KAAK;AAAA,IACjC;AAAA,IACA,YAAY;AAAA,IACZ,cAAc;AAAA,IACd,UAAU;AAAA,EACZ,CAAC;AACH;AAQO,IAAM,6BAA6B,CAAC,SAAiB,aAA4C;AACtG,eAAa,SAAS,2BAA2B,QAAQ;AAC3D;;;AC/RA,SAAS,WAAAA,UAAS,UAAAC,SAAQ,UAAU,aAAa;AAsBjD,IAAM,2BAAN,cAAuCC,SAAQ;AAAA,EAC7C;AACF,EAA+C,EAAE;AAAC;AAE3C,IAAM,uBAAuB;AAE7B,IAAM,yBAAyB,CACpC,cAEA,MAAM,QAAQ,sBAAsB,SAAS;AAM/C,IAAM,WAAW,CAAC,UAChB,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAE9D,IAAM,wBAAwB,CAAC,YAA2C;AAC/E,QAAM,OAAO,iBAAiB,OAAO;AAErC,QAAM,2BAA2B,oBAAI,IAAuB;AAC5D,MAAI;AAEJ,QAAM,eAAe;AAAA,IACnB,SAAS;AAAA,IACT,WAAW;AAAA,IACX,iBAAiB;AAAA,EACnB;AAEA,QAAM,YAAuB;AAAA,IAC3B,QAAQ,CAAC,UACPC,QAAO,IAAI,aAAa;AACtB,YAAM,QAAQ,OAAO,SAAS,IAAI,uBAAuB;AACzD,YAAM,gBAAiB,MAAc;AACrC,YAAM,aACJ,OAAO,kBAAkB,YAAY,cAAc,SAAS,IACxD,gBACA;AACN,YAAM,WACJ,UAAU,QACN,SACA,QAAQ,MAAM,QAAQ,YAAY,UAAU;AAClD,YAAM,MAAM,uBAAuB,OAAO;AAAA,QACxC,kBAAkB;AAAA,QAClB;AAAA,QACA,kBAAkB,CAAC,EAAE,MAAM,MAAM;AAC/B,uBAAa,WAAW,MAAM;AAC9B,uBAAa,aAAa,MAAM;AAAA,QAClC;AAAA,MACF,CAAC;AACD,UAAI,CAAC,IAAK;AAEV,YAAM,YAAY,iBAAiB,GAAG;AACtC,mBAAa,WAAW,UAAU,MAAM;AACxC,mBAAa,aAAa,UAAU,MAAM;AAC1C,mBAAa,mBAAmB,UAAU,MAAM;AAEhD,WAAK,OAAO,eAAe,UAAU,OAAO;AAAA,QAC1C,WAAW,IAAI;AAAA,MACjB,CAAC;AAAA,IACH,CAAC;AAAA,EACL;AAEA,QAAM,2BAA2B,CAAC,aAA4B;AAC5D,QAAI,CAAC,SAAS,QAAQ,EAAG;AACzB,UAAM,SAAS,SAAS;AACxB,QAAI,OAAO,WAAW,YAAY,OAAO,WAAW,EAAG;AACvD,UAAM,YAAY,iBAAiB,QAAQ;AAC3C,iBAAa,WAAW,UAAU,MAAM;AACxC,iBAAa,aAAa,UAAU,MAAM;AAC1C,iBAAa,mBAAmB,UAAU,MAAM;AAChD,6BAAyB,IAAI,QAAQ,UAAU,KAAK;AAAA,EACtD;AAEA,QAAMC,8BAA6B,CAAC,aAA4B;AAC9D,UAAM,YAAY,iBAAiB,QAAQ;AAC3C,iBAAa,WAAW,UAAU,MAAM;AACxC,iBAAa,aAAa,UAAU,MAAM;AAC1C,iBAAa,mBAAmB,UAAU,MAAM;AAChD,8BAA0B,UAAU;AAAA,EACtC;AAEA,QAAM,wBAAwB,CAAC,YAER;AACrB,UAAM,kBACJ,yBAAyB,OAAO,IAC3B;AAAA,MACC,kBAAkB,OAAO,YAAY,wBAAwB;AAAA,IAC/D,IACA;AAEN,UAAM,iBACJ,2BAA2B,OACtB,EAAE,UAAU,wBAAwB,IACrC;AAEN,UAAM,UACJ,mBAAmB,QAAQ,kBAAkB,OACxC;AAAA,MACC,GAAI,mBAAmB,OAAO,EAAE,UAAU,gBAAgB,IAAI,CAAC;AAAA,MAC/D,GAAI,kBAAkB,OAAO,EAAE,SAAS,eAAe,IAAI,CAAC;AAAA,IAC9D,IACA;AAEN,WAAO,KAAK,OAAO;AAAA,MACjB,WAAW,SAAS;AAAA,MACpB;AAAA,IACF,CAAC;AAAA,EACH;AAEA,QAAM,QAAQ,MAAY;AACxB,SAAK,MAAM;AACX,6BAAyB,MAAM;AAC/B,8BAA0B;AAC1B,iBAAa,UAAU;AACvB,iBAAa,YAAY;AACzB,iBAAa,kBAAkB;AAAA,EACjC;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,4BAAAA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;",
  "names": ["Context", "Effect", "Context", "Effect", "setRuntimeServicesEvidence"]
}
