@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,255 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  currentDiagnosticsLevel,
+  toRuntimeDebugEventRef
+} from "./chunk-CVZPRIDB.js";
+import {
+  makeEvidenceSink
+} from "./chunk-RS5FFPUV.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": "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",
  "names": ["Context", "Effect", "Context", "Effect", "setRuntimeServicesEvidence"]
}


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

@@ -0,0 +1,26 @@
+// @logixjs/core subpath bundles for @logixjs/sandbox
+
+
+// ../logix-core/src/internal/external-store-descriptor.ts
+var EXTERNAL_STORE_DESCRIPTOR = /* @__PURE__ */ Symbol.for("@logixjs/core/externalStoreDescriptor");
+var defineHidden = (target, key, value) => {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+};
+var attachExternalStoreDescriptor = (store, descriptor) => {
+  defineHidden(store, EXTERNAL_STORE_DESCRIPTOR, descriptor);
+};
+var getExternalStoreDescriptor = (store) => {
+  if (!store || typeof store !== "object" && typeof store !== "function") return void 0;
+  return store[EXTERNAL_STORE_DESCRIPTOR];
+};
+
+export {
+  attachExternalStoreDescriptor,
+  getExternalStoreDescriptor
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,71 @@
+// @logixjs/core subpath bundles for @logixjs/sandbox
+
+import {
+  RootContextTag
+} from "./chunk-UBMUY7WO.js";
+import {
+  isDevEnv
+} from "./chunk-YMVMZA3U.js";
+
+// ../logix-core/src/internal/root.ts
+import { Context, Deferred, Effect, Layer } from "../effect.js";
+var tagIdOf = (tag) => typeof tag?.id === "string" ? String(tag.id) : typeof tag?.key === "string" ? String(tag.key) : "<unknown tag>";
+var makeMissingRootProviderError = (tag, entrypoint, extra) => {
+  const dev = isDevEnv();
+  const tokenId = tagIdOf(tag);
+  const fix = dev ? [
+    "- Provide it when creating the runtime tree (Logix.Runtime.make(...,{ layer }) / ManagedRuntime.make(Layer.mergeAll(...))).",
+    "- If you're in React and want the current runtime environment singleton, use useModule(ModuleTag).",
+    "- Do not rely on nested RuntimeProvider.layer to mock Root.resolve."
+  ] : [];
+  const message = dev ? [
+    "[MissingRootProviderError] Cannot resolve Tag from root provider.",
+    extra ? `
+${extra}` : "",
+    `tokenId: ${tokenId}`,
+    `entrypoint: ${entrypoint}`,
+    "mode: global",
+    "startScope: root",
+    "",
+    "fix:",
+    ...fix
+  ].filter((s) => s.length > 0).join("\n") : "[MissingRootProviderError] tag not found in root provider";
+  const err = new Error(message);
+  err.name = "MissingRootProviderError";
+  err.tokenId = tokenId;
+  err.entrypoint = entrypoint;
+  err.mode = "global";
+  err.startScope = { kind: "root" };
+  err.fix = fix;
+  return err;
+};
+var resolve = (tag, options) => Effect.gen(function* () {
+  const entrypoint = options?.entrypoint ?? "logic.root.resolve";
+  const root = yield* RootContextTag;
+  const rootContext = root.context ?? (options?.waitForReady ? yield* root.ready : void 0);
+  if (!rootContext) {
+    return yield* Effect.die(
+      makeMissingRootProviderError(tag, entrypoint, "reason: rootContextNotReady")
+    );
+  }
+  try {
+    return Context.get(rootContext, tag);
+  } catch {
+    return yield* Effect.die(makeMissingRootProviderError(tag, entrypoint));
+  }
+});
+var layerFromContext = (context) => Layer.scoped(
+  RootContextTag,
+  Effect.gen(function* () {
+    const ready = yield* Deferred.make();
+    yield* Deferred.succeed(ready, context);
+    const root = { context, ready };
+    return root;
+  })
+);
+
+export {
+  resolve,
+  layerFromContext
+};
+//# sourceMappingURL=data:application/json;base64,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