@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,271 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  isDevEnv
+} from "./chunk-XE7ULSGQ.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 FullCutoverGateModeTagImpl = class extends Context.Tag("@logix/core/FullCutoverGateMode")() {
+};
+var FullCutoverGateModeTag = FullCutoverGateModeTagImpl;
+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 RuntimeServicesRegistryTagImpl = class extends Context.Tag("@logix/core/RuntimeServicesRegistry")() {
+};
+var RuntimeServicesRegistryTag = RuntimeServicesRegistryTagImpl;
+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 formatScope = (moduleId, instanceId) => {
+  const m = typeof moduleId === "string" && moduleId.length > 0 ? moduleId : "unknown";
+  const i = typeof instanceId === "string" && instanceId.length > 0 ? instanceId : "unknown";
+  return `moduleId=${m}, instanceId=${i}`;
+};
+var setRuntimeServicesEvidence = (runtime, evidence) => {
+  defineHidden(runtime, RUNTIME_SERVICES_EVIDENCE, evidence);
+};
+var getRuntimeServicesEvidence = (runtime) => {
+  const scope = runtime;
+  const evidence = runtime[RUNTIME_SERVICES_EVIDENCE];
+  if (!evidence) {
+    const msg = isDevEnv() ? [
+      "[MissingRuntimeServicesEvidence] Runtime services evidence not installed on ModuleRuntime instance.",
+      `scope: ${formatScope(scope.moduleId, scope.instanceId)}`,
+      "fix:",
+      "- Ensure ModuleRuntime.make assembles RuntimeKernel and attaches evidence (020 US2).",
+      "- If you created a mock runtime for tests, attach evidence or avoid calling evidence-only APIs."
+    ].join("\n") : "Runtime services evidence not installed";
+    throw new Error(msg);
+  }
+  const runtimeInstanceId = scope.instanceId;
+  if (typeof runtimeInstanceId === "string" && runtimeInstanceId.length > 0 && runtimeInstanceId !== evidence.instanceId) {
+    throw new Error(
+      isDevEnv() ? [
+        "[InconsistentRuntimeServicesEvidence] Runtime services evidence instanceId mismatch.",
+        `runtime: ${formatScope(scope.moduleId, runtimeInstanceId)}`,
+        `evidence: ${formatScope(evidence.moduleId, evidence.instanceId)}`
+      ].join("\n") : "Runtime services evidence mismatch"
+    );
+  }
+  return evidence;
+};
+
+// ../logix-core/src/internal/runtime/core/KernelRef.ts
+import { Context as Context2, Effect as Effect2, Option as Option2 } from "../effect.js";
+var defaultKernelImplementationRef = {
+  kernelId: "core",
+  packageName: "@logix/core"
+};
+var isKernelImplementationRef = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const keys = Object.keys(value);
+  for (const k of keys) {
+    if (k !== "kernelId" && k !== "packageName" && k !== "packageVersion" && k !== "buildId" && k !== "capabilities") {
+      return false;
+    }
+  }
+  const v = value;
+  if (v.kernelId !== "core" && v.kernelId !== "core-ng") return false;
+  if (typeof v.packageName !== "string" || v.packageName.length === 0) return false;
+  if (v.packageVersion !== void 0 && (typeof v.packageVersion !== "string" || v.packageVersion.length === 0)) {
+    return false;
+  }
+  if (v.buildId !== void 0 && (typeof v.buildId !== "string" || v.buildId.length === 0)) {
+    return false;
+  }
+  if (v.capabilities !== void 0) {
+    if (!Array.isArray(v.capabilities)) return false;
+    if (!v.capabilities.every((c) => typeof c === "string")) return false;
+  }
+  return true;
+};
+var normalizeKernelImplementationRef = (value, fallback = defaultKernelImplementationRef) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return fallback;
+  const v = value;
+  if (v.kernelId !== "core" && v.kernelId !== "core-ng") return fallback;
+  if (typeof v.packageName !== "string" || v.packageName.length === 0) return fallback;
+  return {
+    kernelId: v.kernelId,
+    packageName: v.packageName,
+    ...typeof v.packageVersion === "string" && v.packageVersion.length > 0 ? { packageVersion: v.packageVersion } : {},
+    ...typeof v.buildId === "string" && v.buildId.length > 0 ? { buildId: v.buildId } : {},
+    ...Array.isArray(v.capabilities) && v.capabilities.every((c) => typeof c === "string") ? { capabilities: v.capabilities } : {}
+  };
+};
+var KernelImplementationRefTagImpl = class extends Context2.Tag("@logix/core/KernelImplementationRef")() {
+};
+var KernelImplementationRefTag = KernelImplementationRefTagImpl;
+var resolveKernelImplementationRef = () => Effect2.gen(function* () {
+  const opt = yield* Effect2.serviceOption(KernelImplementationRefTag);
+  return normalizeKernelImplementationRef(Option2.isSome(opt) ? opt.value : void 0);
+});
+var KERNEL_IMPLEMENTATION_REF = /* @__PURE__ */ Symbol.for("@logix/core/kernelImplementationRef");
+var defineHidden2 = (target, key, value) => {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+};
+var formatScope2 = (moduleId, instanceId) => {
+  const m = typeof moduleId === "string" && moduleId.length > 0 ? moduleId : "unknown";
+  const i = typeof instanceId === "string" && instanceId.length > 0 ? instanceId : "unknown";
+  return `moduleId=${m}, instanceId=${i}`;
+};
+var setKernelImplementationRef = (runtime, ref) => {
+  defineHidden2(runtime, KERNEL_IMPLEMENTATION_REF, ref);
+};
+var getKernelImplementationRef = (runtime) => {
+  const scope = runtime;
+  const ref = runtime[KERNEL_IMPLEMENTATION_REF];
+  if (!ref) {
+    const msg = isDevEnv() ? [
+      "[MissingKernelImplementationRef] KernelImplementationRef not installed on ModuleRuntime instance.",
+      `scope: ${formatScope2(scope.moduleId, scope.instanceId)}`,
+      "fix:",
+      "- Ensure ModuleRuntime.make installs KernelImplementationRef (045 kernel contract).",
+      "- If you created a mock runtime for tests, attach KernelImplementationRef or avoid calling kernel-only APIs."
+    ].join("\n") : "KernelImplementationRef not installed";
+    throw new Error(msg);
+  }
+  return ref;
+};
+
+export {
+  RuntimeServicesRuntimeConfigTag,
+  RuntimeServicesInstanceOverridesTag,
+  FullCutoverGateModeTag,
+  resolveRuntimeServicesOverrides,
+  RuntimeServicesRegistryTag,
+  selectRuntimeService,
+  makeRuntimeServicesEvidence,
+  setRuntimeServicesEvidence,
+  getRuntimeServicesEvidence,
+  defaultKernelImplementationRef,
+  isKernelImplementationRef,
+  normalizeKernelImplementationRef,
+  KernelImplementationRefTag,
+  resolveKernelImplementationRef,
+  setKernelImplementationRef,
+  getKernelImplementationRef
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/runtime/core/RuntimeKernel.ts", "../../../../logix-core/src/internal/runtime/core/KernelRef.ts"],
  "sourcesContent": ["import { Context, Effect, Option } from 'effect'\nimport { isDevEnv } from './env.js'\n\nexport type OverrideScope = 'builtin' | 'runtime_default' | 'runtime_module' | 'provider' | '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<Record<string, RuntimeServiceOverride>>\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('@logix/core/RuntimeServicesRuntimeConfig')<\n  RuntimeServicesRuntimeConfigTagImpl,\n  RuntimeServicesRuntimeConfig\n>() {}\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('@logix/core/RuntimeServicesProviderOverrides')<\n  RuntimeServicesProviderOverridesTagImpl,\n  RuntimeServicesProviderOverrides\n>() {}\n\nexport const RuntimeServicesProviderOverridesTag = RuntimeServicesProviderOverridesTagImpl\n\nclass RuntimeServicesInstanceOverridesTagImpl extends Context.Tag('@logix/core/RuntimeServicesInstanceOverrides')<\n  RuntimeServicesInstanceOverridesTagImpl,\n  RuntimeServicesOverrides\n>() {}\n\nexport const RuntimeServicesInstanceOverridesTag = RuntimeServicesInstanceOverridesTagImpl\n\n/**\n * FullCutoverGateMode\uFF1A\u63A7\u5236\u201Cfallback \u662F\u5426\u5141\u8BB8\u201D\u5728\u88C5\u914D\u671F\u7684\u8BED\u4E49\u3002\n *\n * - trial\uFF1A\u5141\u8BB8 fallback\uFF08\u7528\u4E8E trial-run / \u5BF9\u7167 / \u8BCA\u65AD\uFF09\uFF1B\n * - fullCutover\uFF1A\u7981\u6B62 fallback\uFF08\u51FA\u73B0 fallback \u6216\u7F3A\u5931\u7ED1\u5B9A\u5373\u5931\u8D25\uFF09\u3002\n *\n * \u9ED8\u8BA4\uFF1Atrial\uFF08\u82E5\u9700\u8981\u5F3A\u95E8\u7981\uFF0C\u7531 public Runtime \u9ED8\u8BA4\u5C42\u663E\u5F0F\u8BBE\u7F6E\u4E3A fullCutover\uFF09\u3002\n */\nexport type FullCutoverGateMode = 'trial' | 'fullCutover'\n\nclass FullCutoverGateModeTagImpl extends Context.Tag('@logix/core/FullCutoverGateMode')<\n  FullCutoverGateModeTagImpl,\n  FullCutoverGateMode\n>() {}\n\nexport const FullCutoverGateModeTag = FullCutoverGateModeTagImpl\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(RuntimeServicesRuntimeConfigTag)\n    const providerOverridesOpt = yield* Effect.serviceOption(RuntimeServicesProviderOverridesTag)\n    const instanceOverridesOpt = yield* Effect.serviceOption(RuntimeServicesInstanceOverridesTag)\n\n    const runtimeConfig = Option.isSome(runtimeConfigOpt) ? runtimeConfigOpt.value : undefined\n    const providerOverrides = Option.isSome(providerOverridesOpt) ? providerOverridesOpt.value : undefined\n    const instanceOverrides = Option.isSome(instanceOverridesOpt) ? instanceOverridesOpt.value : undefined\n\n    const moduleId = args.moduleId\n\n    const runtimeModule =\n      moduleId && runtimeConfig?.servicesByModuleId ? runtimeConfig.servicesByModuleId[moduleId] : undefined\n\n    const providerModule =\n      moduleId && providerOverrides?.servicesByModuleId ? providerOverrides.servicesByModuleId[moduleId] : 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\n/**\n * RuntimeServicesRegistry\uFF1A\n * - \u7528\u4E8E\u6CE8\u5165\u989D\u5916\u7684 serviceId \u2192 impls\uFF08\u4F8B\u5982 core-ng \u63D0\u4F9B\u7684\u5B9E\u73B0\uFF09\u3002\n * - \u4F5C\u4E3A\u975E\u5E8F\u5217\u5316\u5951\u7EA6\uFF0C\u4EC5\u7528\u4E8E\u88C5\u914D\u9636\u6BB5\uFF1B\u9009\u62E9\u8BC1\u636E\u4ECD\u7531 RuntimeServicesOverrides + RuntimeServicesEvidence \u627F\u8F7D\u3002\n */\nexport interface RuntimeServicesRegistry {\n  readonly implsByServiceId: Readonly<Record<string, ReadonlyArray<RuntimeServiceImpl<any>>>>\n}\n\nclass RuntimeServicesRegistryTagImpl extends Context.Tag('@logix/core/RuntimeServicesRegistry')<\n  RuntimeServicesRegistryTagImpl,\n  RuntimeServicesRegistry\n>() {}\n\nexport const RuntimeServicesRegistryTag = RuntimeServicesRegistryTagImpl\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 = 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, Option } from 'effect'\nimport { isDevEnv } from './env.js'\n\nexport type KernelId = 'core' | 'core-ng'\n\nexport interface KernelImplementationRef {\n  /**\n   * Requested kernel family id (not a version number).\n   * Actual activation / fallback must be interpreted via RuntimeServicesEvidence.\n   */\n  readonly kernelId: KernelId\n  /** The npm package that provides the kernel implementation. */\n  readonly packageName: string\n  /** Optional semver for explainability (not used as a semantic anchor). */\n  readonly packageVersion?: string\n  /** Optional build hash/id for evidence diff explainability. */\n  readonly buildId?: string\n  /** Explainability-only labels; must not become semantic switches. */\n  readonly capabilities?: ReadonlyArray<string>\n}\n\nexport const defaultKernelImplementationRef = {\n  kernelId: 'core',\n  packageName: '@logix/core',\n} as const satisfies KernelImplementationRef\n\nexport const isKernelImplementationRef = (value: unknown): value is KernelImplementationRef => {\n  if (typeof value !== 'object' || value === null || Array.isArray(value)) return false\n\n  const keys = Object.keys(value)\n  for (const k of keys) {\n    if (\n      k !== 'kernelId' &&\n      k !== 'packageName' &&\n      k !== 'packageVersion' &&\n      k !== 'buildId' &&\n      k !== 'capabilities'\n    ) {\n      return false\n    }\n  }\n\n  const v: any = value\n  if (v.kernelId !== 'core' && v.kernelId !== 'core-ng') return false\n  if (typeof v.packageName !== 'string' || v.packageName.length === 0) return false\n\n  if (v.packageVersion !== undefined && (typeof v.packageVersion !== 'string' || v.packageVersion.length === 0)) {\n    return false\n  }\n  if (v.buildId !== undefined && (typeof v.buildId !== 'string' || v.buildId.length === 0)) {\n    return false\n  }\n  if (v.capabilities !== undefined) {\n    if (!Array.isArray(v.capabilities)) return false\n    if (!v.capabilities.every((c: unknown) => typeof c === 'string')) return false\n  }\n\n  return true\n}\n\nexport const normalizeKernelImplementationRef = (\n  value: unknown,\n  fallback: KernelImplementationRef = defaultKernelImplementationRef,\n): KernelImplementationRef => {\n  if (typeof value !== 'object' || value === null || Array.isArray(value)) return fallback\n\n  const v: any = value\n  if (v.kernelId !== 'core' && v.kernelId !== 'core-ng') return fallback\n  if (typeof v.packageName !== 'string' || v.packageName.length === 0) return fallback\n\n  return {\n    kernelId: v.kernelId,\n    packageName: v.packageName,\n    ...(typeof v.packageVersion === 'string' && v.packageVersion.length > 0 ? { packageVersion: v.packageVersion } : {}),\n    ...(typeof v.buildId === 'string' && v.buildId.length > 0 ? { buildId: v.buildId } : {}),\n    ...(Array.isArray(v.capabilities) && v.capabilities.every((c: unknown) => typeof c === 'string')\n      ? { capabilities: v.capabilities as ReadonlyArray<string> }\n      : {}),\n  }\n}\n\nclass KernelImplementationRefTagImpl extends Context.Tag('@logix/core/KernelImplementationRef')<\n  KernelImplementationRefTagImpl,\n  KernelImplementationRef\n>() {}\n\nexport const KernelImplementationRefTag = KernelImplementationRefTagImpl\n\nexport const resolveKernelImplementationRef = (): Effect.Effect<KernelImplementationRef, never, any> =>\n  Effect.gen(function* () {\n    const opt = yield* Effect.serviceOption(KernelImplementationRefTag)\n    return normalizeKernelImplementationRef(Option.isSome(opt) ? opt.value : undefined)\n  })\n\nconst KERNEL_IMPLEMENTATION_REF = Symbol.for('@logix/core/kernelImplementationRef')\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 setKernelImplementationRef = (runtime: object, ref: KernelImplementationRef): void => {\n  defineHidden(runtime, KERNEL_IMPLEMENTATION_REF, ref)\n}\n\nexport const getKernelImplementationRef = (runtime: object): KernelImplementationRef => {\n  const scope = runtime as { readonly moduleId?: unknown; readonly instanceId?: unknown }\n  const ref = (runtime as any)[KERNEL_IMPLEMENTATION_REF] as KernelImplementationRef | undefined\n  if (!ref) {\n    const msg = isDevEnv()\n      ? [\n          '[MissingKernelImplementationRef] KernelImplementationRef not installed on ModuleRuntime instance.',\n          `scope: ${formatScope(scope.moduleId, scope.instanceId)}`,\n          'fix:',\n          '- Ensure ModuleRuntime.make installs KernelImplementationRef (045 kernel contract).',\n          '- If you created a mock runtime for tests, attach KernelImplementationRef or avoid calling kernel-only APIs.',\n        ].join('\\n')\n      : 'KernelImplementationRef not installed'\n    throw new Error(msg)\n  }\n  return ref\n}\n"],
  "mappings": "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",
  "names": ["Context", "Effect", "Option", "Context", "Effect", "Option", "defineHidden", "formatScope"]
}
