@logixjs/core 0.0.1

package/dist/Kernel-8kC-jOda.d.cts

@@ -0,0 +1,171 @@
+import { Effect, Context, Layer } from 'effect';
+import { b as DiagnosticsLevel } from './Debug-Bq8Sqjcr.cjs';
+import { c as KernelId$1, d as RuntimeServiceBinding$1, K as KernelImplementationRef$1, e as RuntimeServiceOverride$1, b as RuntimeServicesOverrides$1, f as RuntimeServicesEvidence$1, g as RuntimeServiceImpl$1, h as RuntimeServicesRegistry$1 } from './Observability-COqEvp2C.cjs';
+
+interface CutoverCoverageMatrix$1 {
+    readonly version: 'v1';
+    readonly requiredServiceIds: ReadonlyArray<string>;
+}
+declare const CutoverCoverageMatrix$1: {
+    readonly version: "v1";
+    readonly requiredServiceIds: readonly ["txnQueue", "operationRunner", "transaction", "dispatch"];
+};
+type FullCutoverGateMode$1 = 'trial' | 'fullCutover';
+interface FullCutoverGateAnchor$1 {
+    readonly moduleId: string;
+    readonly instanceId: string;
+    /**
+     * Convention: txnSeq=0 denotes assembly (a wiring-time failure anchor).
+     * Full Cutover Gate is evaluated during assembly by default, so it does not depend on a real txn.
+     */
+    readonly txnSeq: number;
+}
+type FullCutoverGateVerdict$1 = 'PASS' | 'FAIL';
+interface FullCutoverGateResult$1 {
+    readonly version: 'v1';
+    readonly mode: FullCutoverGateMode$1;
+    readonly requestedKernelId: KernelId$1;
+    readonly verdict: FullCutoverGateVerdict$1;
+    /**
+     * fullyActivated: a stricter "full cutover" truth value.
+     * - Requires every serviceId in the coverage matrix to be bound to the expected implId.
+     * - Requires no fallback (any `fallback=` in overridesApplied means not fully activated).
+     *
+     * Note: in trial mode the verdict may be PASS while fullyActivated can still be false.
+     */
+    readonly fullyActivated: boolean;
+    readonly missingServiceIds: ReadonlyArray<string>;
+    readonly fallbackServiceIds: ReadonlyArray<string>;
+    readonly anchor: FullCutoverGateAnchor$1;
+    /**
+     * When diagnostics=off, it must stay slim (avoid permanent overhead).
+     * In light/full, additional explainable info is allowed (still must be serializable).
+     */
+    readonly details?: {
+        readonly expectedImplId: string;
+        readonly bindings: ReadonlyArray<RuntimeServiceBinding$1>;
+        readonly overridesApplied: ReadonlyArray<string>;
+    };
+}
+
+interface RuntimeServiceBuiltins {
+    /**
+     * Returns the make Effect of a builtin implementation (provided by ModuleRuntime during assembly, avoiding external code
+     * capturing internal closures/state).
+     * - For kernel implementors only (e.g. core-ng) to implement behavior-equivalent replacements or thin wrappers.
+     * - Not an app-facing contract; must not be depended on from business Flow/Logic.
+     */
+    readonly getBuiltinMake: (serviceId: string) => Effect.Effect<unknown, never, any>;
+}
+declare const RuntimeServiceBuiltinsTag_base: Context.TagClass<RuntimeServiceBuiltinsTag, "@logixjs/core/RuntimeServiceBuiltins", RuntimeServiceBuiltins>;
+declare class RuntimeServiceBuiltinsTag extends RuntimeServiceBuiltinsTag_base {
+}
+
+type KernelId = KernelId$1;
+interface KernelImplementationRef extends KernelImplementationRef$1 {
+}
+declare const defaultKernelImplementationRef: {
+    readonly kernelId: "core";
+    readonly packageName: "@logixjs/core";
+};
+declare const isKernelImplementationRef: (value: unknown) => value is KernelImplementationRef$1;
+type RuntimeServiceOverride = RuntimeServiceOverride$1;
+type RuntimeServicesOverrides = RuntimeServicesOverrides$1;
+type RuntimeServiceBinding = RuntimeServiceBinding$1;
+type RuntimeServicesEvidence = RuntimeServicesEvidence$1;
+type RuntimeServiceImpl<Service> = RuntimeServiceImpl$1<Service>;
+type RuntimeServicesRegistry = RuntimeServicesRegistry$1;
+type CutoverCoverageMatrix = CutoverCoverageMatrix$1;
+declare const CutoverCoverageMatrix: {
+    readonly version: "v1";
+    readonly requiredServiceIds: readonly ["txnQueue", "operationRunner", "transaction", "dispatch"];
+};
+type FullCutoverGateMode = FullCutoverGateMode$1;
+type FullCutoverGateAnchor = FullCutoverGateAnchor$1;
+type FullCutoverGateVerdict = FullCutoverGateVerdict$1;
+type FullCutoverGateResult = FullCutoverGateResult$1;
+declare const evaluateFullCutoverGate: (args: {
+    readonly mode: FullCutoverGateMode;
+    readonly requestedKernelId: KernelId;
+    readonly runtimeServicesEvidence: RuntimeServicesEvidence;
+    readonly coverageMatrix?: CutoverCoverageMatrix;
+    readonly diagnosticsLevel?: DiagnosticsLevel;
+}) => FullCutoverGateResult;
+interface KernelContractMetaAllowlistItem {
+    readonly metaKey: string;
+    readonly reason?: string;
+}
+declare const KernelContractMetaAllowlist: readonly [];
+/**
+ * kernelLayer:
+ * - Declares the requested kernel family in the current runtime tree.
+ * - This does not prove full activation; fallback/mix is decided by RuntimeServicesEvidence.
+ */
+declare const kernelLayer: (ref: KernelImplementationRef) => Layer.Layer<any, never, never>;
+/**
+ * runtimeDefaultServicesOverridesLayer:
+ * - Provides `runtime_default` scope `serviceId -> implId` overrides during ManagedRuntime assembly.
+ * - Does not set servicesByModuleId by default (do not use moduleId as the default kernel selection granularity).
+ */
+declare const runtimeDefaultServicesOverridesLayer: (services: RuntimeServicesOverrides) => Layer.Layer<any, never, never>;
+/**
+ * getRuntimeServicesEvidence:
+ * - Reads RuntimeServicesEvidence installed on a ModuleRuntime (serviceId -> implId evidence).
+ * - Public entry to avoid importing from `src/internal`.
+ */
+declare const getRuntimeServicesEvidence: (runtime: object) => RuntimeServicesEvidence$1;
+/**
+ * getKernelImplementationRef:
+ * - Reads KernelImplementationRef installed on a ModuleRuntime (requested kernel family).
+ */
+declare const getKernelImplementationRef: (runtime: object) => KernelImplementationRef$1;
+/**
+ * runtimeServicesRegistryLayer:
+ * - Injects additional `serviceId -> impls` during runtime assembly (e.g. implementations provided by core-ng).
+ */
+declare const runtimeServicesRegistryLayer: (registry: RuntimeServicesRegistry) => Layer.Layer<any, never, never>;
+/**
+ * fullCutoverGateModeLayer:
+ * - Controls cutover gate evaluation mode during runtime assembly (trial/fullCutover).
+ * - The default path (048) should explicitly set fullCutover; trial-run/comparison may override to trial.
+ */
+declare const fullCutoverGateModeLayer: (mode: FullCutoverGateMode) => Layer.Layer<any, never, never>;
+/**
+ * isKernelFullyActivated:
+ * - Minimal verdict for "full cutover": no fallbacks are allowed.
+ */
+declare const isKernelFullyActivated: (evidence: RuntimeServicesEvidence) => boolean;
+
+declare const Kernel_CutoverCoverageMatrix: typeof CutoverCoverageMatrix;
+type Kernel_FullCutoverGateAnchor = FullCutoverGateAnchor;
+type Kernel_FullCutoverGateMode = FullCutoverGateMode;
+type Kernel_FullCutoverGateResult = FullCutoverGateResult;
+type Kernel_FullCutoverGateVerdict = FullCutoverGateVerdict;
+declare const Kernel_KernelContractMetaAllowlist: typeof KernelContractMetaAllowlist;
+type Kernel_KernelContractMetaAllowlistItem = KernelContractMetaAllowlistItem;
+type Kernel_KernelId = KernelId;
+type Kernel_KernelImplementationRef = KernelImplementationRef;
+type Kernel_RuntimeServiceBinding = RuntimeServiceBinding;
+type Kernel_RuntimeServiceBuiltins = RuntimeServiceBuiltins;
+type Kernel_RuntimeServiceBuiltinsTag = RuntimeServiceBuiltinsTag;
+declare const Kernel_RuntimeServiceBuiltinsTag: typeof RuntimeServiceBuiltinsTag;
+type Kernel_RuntimeServiceImpl<Service> = RuntimeServiceImpl<Service>;
+type Kernel_RuntimeServiceOverride = RuntimeServiceOverride;
+type Kernel_RuntimeServicesEvidence = RuntimeServicesEvidence;
+type Kernel_RuntimeServicesOverrides = RuntimeServicesOverrides;
+type Kernel_RuntimeServicesRegistry = RuntimeServicesRegistry;
+declare const Kernel_defaultKernelImplementationRef: typeof defaultKernelImplementationRef;
+declare const Kernel_evaluateFullCutoverGate: typeof evaluateFullCutoverGate;
+declare const Kernel_fullCutoverGateModeLayer: typeof fullCutoverGateModeLayer;
+declare const Kernel_getKernelImplementationRef: typeof getKernelImplementationRef;
+declare const Kernel_getRuntimeServicesEvidence: typeof getRuntimeServicesEvidence;
+declare const Kernel_isKernelFullyActivated: typeof isKernelFullyActivated;
+declare const Kernel_isKernelImplementationRef: typeof isKernelImplementationRef;
+declare const Kernel_kernelLayer: typeof kernelLayer;
+declare const Kernel_runtimeDefaultServicesOverridesLayer: typeof runtimeDefaultServicesOverridesLayer;
+declare const Kernel_runtimeServicesRegistryLayer: typeof runtimeServicesRegistryLayer;
+declare namespace Kernel {
+  export { Kernel_CutoverCoverageMatrix as CutoverCoverageMatrix, type Kernel_FullCutoverGateAnchor as FullCutoverGateAnchor, type Kernel_FullCutoverGateMode as FullCutoverGateMode, type Kernel_FullCutoverGateResult as FullCutoverGateResult, type Kernel_FullCutoverGateVerdict as FullCutoverGateVerdict, Kernel_KernelContractMetaAllowlist as KernelContractMetaAllowlist, type Kernel_KernelContractMetaAllowlistItem as KernelContractMetaAllowlistItem, type Kernel_KernelId as KernelId, type Kernel_KernelImplementationRef as KernelImplementationRef, type Kernel_RuntimeServiceBinding as RuntimeServiceBinding, type Kernel_RuntimeServiceBuiltins as RuntimeServiceBuiltins, Kernel_RuntimeServiceBuiltinsTag as RuntimeServiceBuiltinsTag, type Kernel_RuntimeServiceImpl as RuntimeServiceImpl, type Kernel_RuntimeServiceOverride as RuntimeServiceOverride, type Kernel_RuntimeServicesEvidence as RuntimeServicesEvidence, type Kernel_RuntimeServicesOverrides as RuntimeServicesOverrides, type Kernel_RuntimeServicesRegistry as RuntimeServicesRegistry, Kernel_defaultKernelImplementationRef as defaultKernelImplementationRef, Kernel_evaluateFullCutoverGate as evaluateFullCutoverGate, Kernel_fullCutoverGateModeLayer as fullCutoverGateModeLayer, Kernel_getKernelImplementationRef as getKernelImplementationRef, Kernel_getRuntimeServicesEvidence as getRuntimeServicesEvidence, Kernel_isKernelFullyActivated as isKernelFullyActivated, Kernel_isKernelImplementationRef as isKernelImplementationRef, Kernel_kernelLayer as kernelLayer, Kernel_runtimeDefaultServicesOverridesLayer as runtimeDefaultServicesOverridesLayer, Kernel_runtimeServicesRegistryLayer as runtimeServicesRegistryLayer };
+}
+
+export { CutoverCoverageMatrix as C, type FullCutoverGateMode as F, Kernel as K, type RuntimeServicesOverrides as R, type FullCutoverGateResult as a, type KernelId as b, type KernelImplementationRef as c, defaultKernelImplementationRef as d, type RuntimeServiceOverride as e, type RuntimeServiceBinding as f, type RuntimeServicesEvidence as g, type RuntimeServiceImpl as h, isKernelImplementationRef as i, type RuntimeServicesRegistry as j, type FullCutoverGateAnchor as k, type FullCutoverGateVerdict as l, evaluateFullCutoverGate as m, type KernelContractMetaAllowlistItem as n, KernelContractMetaAllowlist as o, kernelLayer as p, getRuntimeServicesEvidence as q, runtimeDefaultServicesOverridesLayer as r, getKernelImplementationRef as s, runtimeServicesRegistryLayer as t, fullCutoverGateModeLayer as u, isKernelFullyActivated as v, type RuntimeServiceBuiltins as w, RuntimeServiceBuiltinsTag as x };

package/dist/Kernel-CnGE1Fyk.d.ts

@@ -0,0 +1,171 @@
+import { Effect, Context, Layer } from 'effect';
+import { b as DiagnosticsLevel } from './Debug-B5q5Bkzx.js';
+import { c as KernelId$1, d as RuntimeServiceBinding$1, K as KernelImplementationRef$1, e as RuntimeServiceOverride$1, b as RuntimeServicesOverrides$1, f as RuntimeServicesEvidence$1, g as RuntimeServiceImpl$1, h as RuntimeServicesRegistry$1 } from './Observability-cY4kLn0S.js';
+
+interface CutoverCoverageMatrix$1 {
+    readonly version: 'v1';
+    readonly requiredServiceIds: ReadonlyArray<string>;
+}
+declare const CutoverCoverageMatrix$1: {
+    readonly version: "v1";
+    readonly requiredServiceIds: readonly ["txnQueue", "operationRunner", "transaction", "dispatch"];
+};
+type FullCutoverGateMode$1 = 'trial' | 'fullCutover';
+interface FullCutoverGateAnchor$1 {
+    readonly moduleId: string;
+    readonly instanceId: string;
+    /**
+     * Convention: txnSeq=0 denotes assembly (a wiring-time failure anchor).
+     * Full Cutover Gate is evaluated during assembly by default, so it does not depend on a real txn.
+     */
+    readonly txnSeq: number;
+}
+type FullCutoverGateVerdict$1 = 'PASS' | 'FAIL';
+interface FullCutoverGateResult$1 {
+    readonly version: 'v1';
+    readonly mode: FullCutoverGateMode$1;
+    readonly requestedKernelId: KernelId$1;
+    readonly verdict: FullCutoverGateVerdict$1;
+    /**
+     * fullyActivated: a stricter "full cutover" truth value.
+     * - Requires every serviceId in the coverage matrix to be bound to the expected implId.
+     * - Requires no fallback (any `fallback=` in overridesApplied means not fully activated).
+     *
+     * Note: in trial mode the verdict may be PASS while fullyActivated can still be false.
+     */
+    readonly fullyActivated: boolean;
+    readonly missingServiceIds: ReadonlyArray<string>;
+    readonly fallbackServiceIds: ReadonlyArray<string>;
+    readonly anchor: FullCutoverGateAnchor$1;
+    /**
+     * When diagnostics=off, it must stay slim (avoid permanent overhead).
+     * In light/full, additional explainable info is allowed (still must be serializable).
+     */
+    readonly details?: {
+        readonly expectedImplId: string;
+        readonly bindings: ReadonlyArray<RuntimeServiceBinding$1>;
+        readonly overridesApplied: ReadonlyArray<string>;
+    };
+}
+
+interface RuntimeServiceBuiltins {
+    /**
+     * Returns the make Effect of a builtin implementation (provided by ModuleRuntime during assembly, avoiding external code
+     * capturing internal closures/state).
+     * - For kernel implementors only (e.g. core-ng) to implement behavior-equivalent replacements or thin wrappers.
+     * - Not an app-facing contract; must not be depended on from business Flow/Logic.
+     */
+    readonly getBuiltinMake: (serviceId: string) => Effect.Effect<unknown, never, any>;
+}
+declare const RuntimeServiceBuiltinsTag_base: Context.TagClass<RuntimeServiceBuiltinsTag, "@logixjs/core/RuntimeServiceBuiltins", RuntimeServiceBuiltins>;
+declare class RuntimeServiceBuiltinsTag extends RuntimeServiceBuiltinsTag_base {
+}
+
+type KernelId = KernelId$1;
+interface KernelImplementationRef extends KernelImplementationRef$1 {
+}
+declare const defaultKernelImplementationRef: {
+    readonly kernelId: "core";
+    readonly packageName: "@logixjs/core";
+};
+declare const isKernelImplementationRef: (value: unknown) => value is KernelImplementationRef$1;
+type RuntimeServiceOverride = RuntimeServiceOverride$1;
+type RuntimeServicesOverrides = RuntimeServicesOverrides$1;
+type RuntimeServiceBinding = RuntimeServiceBinding$1;
+type RuntimeServicesEvidence = RuntimeServicesEvidence$1;
+type RuntimeServiceImpl<Service> = RuntimeServiceImpl$1<Service>;
+type RuntimeServicesRegistry = RuntimeServicesRegistry$1;
+type CutoverCoverageMatrix = CutoverCoverageMatrix$1;
+declare const CutoverCoverageMatrix: {
+    readonly version: "v1";
+    readonly requiredServiceIds: readonly ["txnQueue", "operationRunner", "transaction", "dispatch"];
+};
+type FullCutoverGateMode = FullCutoverGateMode$1;
+type FullCutoverGateAnchor = FullCutoverGateAnchor$1;
+type FullCutoverGateVerdict = FullCutoverGateVerdict$1;
+type FullCutoverGateResult = FullCutoverGateResult$1;
+declare const evaluateFullCutoverGate: (args: {
+    readonly mode: FullCutoverGateMode;
+    readonly requestedKernelId: KernelId;
+    readonly runtimeServicesEvidence: RuntimeServicesEvidence;
+    readonly coverageMatrix?: CutoverCoverageMatrix;
+    readonly diagnosticsLevel?: DiagnosticsLevel;
+}) => FullCutoverGateResult;
+interface KernelContractMetaAllowlistItem {
+    readonly metaKey: string;
+    readonly reason?: string;
+}
+declare const KernelContractMetaAllowlist: readonly [];
+/**
+ * kernelLayer:
+ * - Declares the requested kernel family in the current runtime tree.
+ * - This does not prove full activation; fallback/mix is decided by RuntimeServicesEvidence.
+ */
+declare const kernelLayer: (ref: KernelImplementationRef) => Layer.Layer<any, never, never>;
+/**
+ * runtimeDefaultServicesOverridesLayer:
+ * - Provides `runtime_default` scope `serviceId -> implId` overrides during ManagedRuntime assembly.
+ * - Does not set servicesByModuleId by default (do not use moduleId as the default kernel selection granularity).
+ */
+declare const runtimeDefaultServicesOverridesLayer: (services: RuntimeServicesOverrides) => Layer.Layer<any, never, never>;
+/**
+ * getRuntimeServicesEvidence:
+ * - Reads RuntimeServicesEvidence installed on a ModuleRuntime (serviceId -> implId evidence).
+ * - Public entry to avoid importing from `src/internal`.
+ */
+declare const getRuntimeServicesEvidence: (runtime: object) => RuntimeServicesEvidence$1;
+/**
+ * getKernelImplementationRef:
+ * - Reads KernelImplementationRef installed on a ModuleRuntime (requested kernel family).
+ */
+declare const getKernelImplementationRef: (runtime: object) => KernelImplementationRef$1;
+/**
+ * runtimeServicesRegistryLayer:
+ * - Injects additional `serviceId -> impls` during runtime assembly (e.g. implementations provided by core-ng).
+ */
+declare const runtimeServicesRegistryLayer: (registry: RuntimeServicesRegistry) => Layer.Layer<any, never, never>;
+/**
+ * fullCutoverGateModeLayer:
+ * - Controls cutover gate evaluation mode during runtime assembly (trial/fullCutover).
+ * - The default path (048) should explicitly set fullCutover; trial-run/comparison may override to trial.
+ */
+declare const fullCutoverGateModeLayer: (mode: FullCutoverGateMode) => Layer.Layer<any, never, never>;
+/**
+ * isKernelFullyActivated:
+ * - Minimal verdict for "full cutover": no fallbacks are allowed.
+ */
+declare const isKernelFullyActivated: (evidence: RuntimeServicesEvidence) => boolean;
+
+declare const Kernel_CutoverCoverageMatrix: typeof CutoverCoverageMatrix;
+type Kernel_FullCutoverGateAnchor = FullCutoverGateAnchor;
+type Kernel_FullCutoverGateMode = FullCutoverGateMode;
+type Kernel_FullCutoverGateResult = FullCutoverGateResult;
+type Kernel_FullCutoverGateVerdict = FullCutoverGateVerdict;
+declare const Kernel_KernelContractMetaAllowlist: typeof KernelContractMetaAllowlist;
+type Kernel_KernelContractMetaAllowlistItem = KernelContractMetaAllowlistItem;
+type Kernel_KernelId = KernelId;
+type Kernel_KernelImplementationRef = KernelImplementationRef;
+type Kernel_RuntimeServiceBinding = RuntimeServiceBinding;
+type Kernel_RuntimeServiceBuiltins = RuntimeServiceBuiltins;
+type Kernel_RuntimeServiceBuiltinsTag = RuntimeServiceBuiltinsTag;
+declare const Kernel_RuntimeServiceBuiltinsTag: typeof RuntimeServiceBuiltinsTag;
+type Kernel_RuntimeServiceImpl<Service> = RuntimeServiceImpl<Service>;
+type Kernel_RuntimeServiceOverride = RuntimeServiceOverride;
+type Kernel_RuntimeServicesEvidence = RuntimeServicesEvidence;
+type Kernel_RuntimeServicesOverrides = RuntimeServicesOverrides;
+type Kernel_RuntimeServicesRegistry = RuntimeServicesRegistry;
+declare const Kernel_defaultKernelImplementationRef: typeof defaultKernelImplementationRef;
+declare const Kernel_evaluateFullCutoverGate: typeof evaluateFullCutoverGate;
+declare const Kernel_fullCutoverGateModeLayer: typeof fullCutoverGateModeLayer;
+declare const Kernel_getKernelImplementationRef: typeof getKernelImplementationRef;
+declare const Kernel_getRuntimeServicesEvidence: typeof getRuntimeServicesEvidence;
+declare const Kernel_isKernelFullyActivated: typeof isKernelFullyActivated;
+declare const Kernel_isKernelImplementationRef: typeof isKernelImplementationRef;
+declare const Kernel_kernelLayer: typeof kernelLayer;
+declare const Kernel_runtimeDefaultServicesOverridesLayer: typeof runtimeDefaultServicesOverridesLayer;
+declare const Kernel_runtimeServicesRegistryLayer: typeof runtimeServicesRegistryLayer;
+declare namespace Kernel {
+  export { Kernel_CutoverCoverageMatrix as CutoverCoverageMatrix, type Kernel_FullCutoverGateAnchor as FullCutoverGateAnchor, type Kernel_FullCutoverGateMode as FullCutoverGateMode, type Kernel_FullCutoverGateResult as FullCutoverGateResult, type Kernel_FullCutoverGateVerdict as FullCutoverGateVerdict, Kernel_KernelContractMetaAllowlist as KernelContractMetaAllowlist, type Kernel_KernelContractMetaAllowlistItem as KernelContractMetaAllowlistItem, type Kernel_KernelId as KernelId, type Kernel_KernelImplementationRef as KernelImplementationRef, type Kernel_RuntimeServiceBinding as RuntimeServiceBinding, type Kernel_RuntimeServiceBuiltins as RuntimeServiceBuiltins, Kernel_RuntimeServiceBuiltinsTag as RuntimeServiceBuiltinsTag, type Kernel_RuntimeServiceImpl as RuntimeServiceImpl, type Kernel_RuntimeServiceOverride as RuntimeServiceOverride, type Kernel_RuntimeServicesEvidence as RuntimeServicesEvidence, type Kernel_RuntimeServicesOverrides as RuntimeServicesOverrides, type Kernel_RuntimeServicesRegistry as RuntimeServicesRegistry, Kernel_defaultKernelImplementationRef as defaultKernelImplementationRef, Kernel_evaluateFullCutoverGate as evaluateFullCutoverGate, Kernel_fullCutoverGateModeLayer as fullCutoverGateModeLayer, Kernel_getKernelImplementationRef as getKernelImplementationRef, Kernel_getRuntimeServicesEvidence as getRuntimeServicesEvidence, Kernel_isKernelFullyActivated as isKernelFullyActivated, Kernel_isKernelImplementationRef as isKernelImplementationRef, Kernel_kernelLayer as kernelLayer, Kernel_runtimeDefaultServicesOverridesLayer as runtimeDefaultServicesOverridesLayer, Kernel_runtimeServicesRegistryLayer as runtimeServicesRegistryLayer };
+}
+
+export { CutoverCoverageMatrix as C, type FullCutoverGateMode as F, Kernel as K, type RuntimeServicesOverrides as R, type FullCutoverGateResult as a, type KernelId as b, type KernelImplementationRef as c, defaultKernelImplementationRef as d, type RuntimeServiceOverride as e, type RuntimeServiceBinding as f, type RuntimeServicesEvidence as g, type RuntimeServiceImpl as h, isKernelImplementationRef as i, type RuntimeServicesRegistry as j, type FullCutoverGateAnchor as k, type FullCutoverGateVerdict as l, evaluateFullCutoverGate as m, type KernelContractMetaAllowlistItem as n, KernelContractMetaAllowlist as o, kernelLayer as p, getRuntimeServicesEvidence as q, runtimeDefaultServicesOverridesLayer as r, getKernelImplementationRef as s, runtimeServicesRegistryLayer as t, fullCutoverGateModeLayer as u, isKernelFullyActivated as v, type RuntimeServiceBuiltins as w, RuntimeServiceBuiltinsTag as x };

package/dist/Kernel.cjs

@@ -0,0 +1,284 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Kernel.ts
+var Kernel_exports = {};
+__export(Kernel_exports, {
+  CutoverCoverageMatrix: () => CutoverCoverageMatrix2,
+  KernelContractMetaAllowlist: () => KernelContractMetaAllowlist,
+  RuntimeServiceBuiltinsTag: () => RuntimeServiceBuiltinsTag,
+  defaultKernelImplementationRef: () => defaultKernelImplementationRef2,
+  evaluateFullCutoverGate: () => evaluateFullCutoverGate2,
+  fullCutoverGateModeLayer: () => fullCutoverGateModeLayer,
+  getKernelImplementationRef: () => getKernelImplementationRef2,
+  getRuntimeServicesEvidence: () => getRuntimeServicesEvidence2,
+  isKernelFullyActivated: () => isKernelFullyActivated,
+  isKernelImplementationRef: () => isKernelImplementationRef2,
+  kernelLayer: () => kernelLayer,
+  runtimeDefaultServicesOverridesLayer: () => runtimeDefaultServicesOverridesLayer,
+  runtimeServicesRegistryLayer: () => runtimeServicesRegistryLayer
+});
+module.exports = __toCommonJS(Kernel_exports);
+var import_effect5 = require("effect");
+
+// src/internal/runtime/core/FullCutoverGate.ts
+var CutoverCoverageMatrix = {
+  version: "v1",
+  requiredServiceIds: ["txnQueue", "operationRunner", "transaction", "dispatch"]
+};
+var expectedImplIdForKernel = (kernelId) => kernelId === "core" ? "builtin" : kernelId;
+var parseFallbackServiceIds = (overridesApplied) => {
+  const out = /* @__PURE__ */ new Set();
+  for (const entry of overridesApplied) {
+    if (!entry.includes("(fallback=")) continue;
+    const colon = entry.indexOf(":");
+    if (colon < 0) continue;
+    const eq = entry.indexOf("=", colon + 1);
+    if (eq < 0) continue;
+    const serviceId = entry.slice(colon + 1, eq);
+    if (serviceId.length > 0) out.add(serviceId);
+  }
+  return Array.from(out).sort((a, b) => a.localeCompare(b));
+};
+var collectMissingServiceIds = (args) => {
+  const bindingByServiceId = /* @__PURE__ */ new Map();
+  for (const b of args.bindings) {
+    bindingByServiceId.set(b.serviceId, b);
+  }
+  const missing = [];
+  for (const serviceId of args.requiredServiceIds) {
+    const binding = bindingByServiceId.get(serviceId);
+    const implId = binding?.implId;
+    if (!implId || implId !== args.expectedImplId) {
+      missing.push(serviceId);
+    }
+  }
+  return missing;
+};
+var evaluateFullCutoverGate = (args) => {
+  const expectedImplId = expectedImplIdForKernel(args.requestedKernelId);
+  const matrix = args.coverageMatrix ?? CutoverCoverageMatrix;
+  const fallbackServiceIds = parseFallbackServiceIds(args.runtimeServicesEvidence.overridesApplied);
+  const missingServiceIds = collectMissingServiceIds({
+    expectedImplId,
+    requiredServiceIds: matrix.requiredServiceIds,
+    bindings: args.runtimeServicesEvidence.bindings
+  });
+  const fullyActivated = missingServiceIds.length === 0 && fallbackServiceIds.length === 0;
+  const verdict = args.mode === "fullCutover" ? fullyActivated ? "PASS" : "FAIL" : "PASS";
+  const moduleIdRaw = args.runtimeServicesEvidence.moduleId;
+  const moduleId = typeof moduleIdRaw === "string" && moduleIdRaw.length > 0 ? moduleIdRaw : "unknown";
+  const anchor = {
+    moduleId,
+    instanceId: args.runtimeServicesEvidence.instanceId,
+    txnSeq: 0
+  };
+  const level = args.diagnosticsLevel ?? "off";
+  return {
+    version: "v1",
+    mode: args.mode,
+    requestedKernelId: args.requestedKernelId,
+    verdict,
+    fullyActivated,
+    missingServiceIds,
+    fallbackServiceIds,
+    anchor,
+    ...level === "off" ? {} : {
+      details: {
+        expectedImplId,
+        bindings: args.runtimeServicesEvidence.bindings,
+        overridesApplied: args.runtimeServicesEvidence.overridesApplied
+      }
+    }
+  };
+};
+
+// src/internal/runtime/core/RuntimeKernel.ts
+var import_effect2 = require("effect");
+
+// src/internal/runtime/core/env.ts
+var import_effect = require("effect");
+var getNodeEnv = () => {
+  try {
+    const env = globalThis?.process?.env;
+    return typeof env?.NODE_ENV === "string" ? env.NODE_ENV : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var isDevEnv = () => getNodeEnv() !== "production";
+var StateTransactionConfigTagImpl = class extends import_effect.Context.Tag("@logixjs/core/StateTransactionRuntimeConfig")() {
+};
+var ReadQueryStrictGateConfigTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ReadQueryStrictGateRuntimeConfig")() {
+};
+var ReplayModeConfigTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ReplayModeConfig")() {
+};
+var StateTransactionOverridesTagImpl = class extends import_effect.Context.Tag("@logixjs/core/StateTransactionOverrides")() {
+};
+var ConcurrencyPolicyTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ConcurrencyPolicy")() {
+};
+var ConcurrencyPolicyOverridesTagImpl = class extends import_effect.Context.Tag("@logixjs/core/ConcurrencyPolicyOverrides")() {
+};
+
+// src/internal/runtime/core/RuntimeKernel.ts
+var RuntimeServicesRuntimeConfigTagImpl = class extends import_effect2.Context.Tag("@logixjs/core/RuntimeServicesRuntimeConfig")() {
+};
+var RuntimeServicesRuntimeConfigTag = RuntimeServicesRuntimeConfigTagImpl;
+var RuntimeServicesProviderOverridesTagImpl = class extends import_effect2.Context.Tag("@logixjs/core/RuntimeServicesProviderOverrides")() {
+};
+var RuntimeServicesInstanceOverridesTagImpl = class extends import_effect2.Context.Tag("@logixjs/core/RuntimeServicesInstanceOverrides")() {
+};
+var FullCutoverGateModeTagImpl = class extends import_effect2.Context.Tag("@logixjs/core/FullCutoverGateMode")() {
+};
+var FullCutoverGateModeTag = FullCutoverGateModeTagImpl;
+var RuntimeServicesRegistryTagImpl = class extends import_effect2.Context.Tag("@logixjs/core/RuntimeServicesRegistry")() {
+};
+var RuntimeServicesRegistryTag = RuntimeServicesRegistryTagImpl;
+var RUNTIME_SERVICES_EVIDENCE = /* @__PURE__ */ Symbol.for("@logixjs/core/runtimeServicesEvidence");
+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 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;
+};
+
+// src/internal/runtime/core/KernelRef.ts
+var import_effect3 = require("effect");
+var isKernelId = (value) => typeof value === "string" && value.length > 0 && /^[a-z0-9-]+$/.test(value);
+var defaultKernelImplementationRef = {
+  kernelId: "core",
+  packageName: "@logixjs/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 (!isKernelId(v.kernelId)) 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 KernelImplementationRefTagImpl = class extends import_effect3.Context.Tag("@logixjs/core/KernelImplementationRef")() {
+};
+var KernelImplementationRefTag = KernelImplementationRefTagImpl;
+var KERNEL_IMPLEMENTATION_REF = /* @__PURE__ */ Symbol.for("@logixjs/core/kernelImplementationRef");
+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 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;
+};
+
+// src/internal/runtime/core/RuntimeServiceBuiltins.ts
+var import_effect4 = require("effect");
+var RuntimeServiceBuiltinsTag = class extends import_effect4.Context.Tag("@logixjs/core/RuntimeServiceBuiltins")() {
+};
+
+// src/Kernel.ts
+var defaultKernelImplementationRef2 = defaultKernelImplementationRef;
+var isKernelImplementationRef2 = isKernelImplementationRef;
+var CutoverCoverageMatrix2 = CutoverCoverageMatrix;
+var evaluateFullCutoverGate2 = (args) => {
+  return evaluateFullCutoverGate({
+    mode: args.mode,
+    requestedKernelId: args.requestedKernelId,
+    runtimeServicesEvidence: args.runtimeServicesEvidence,
+    coverageMatrix: args.coverageMatrix,
+    diagnosticsLevel: args.diagnosticsLevel
+  });
+};
+var KernelContractMetaAllowlist = [];
+var kernelLayer = (ref) => import_effect5.Layer.succeed(KernelImplementationRefTag, ref);
+var runtimeDefaultServicesOverridesLayer = (services) => import_effect5.Layer.succeed(RuntimeServicesRuntimeConfigTag, {
+  services
+});
+var getRuntimeServicesEvidence2 = getRuntimeServicesEvidence;
+var getKernelImplementationRef2 = getKernelImplementationRef;
+var runtimeServicesRegistryLayer = (registry) => import_effect5.Layer.succeed(RuntimeServicesRegistryTag, registry);
+var fullCutoverGateModeLayer = (mode) => import_effect5.Layer.succeed(FullCutoverGateModeTag, mode);
+var isKernelFullyActivated = (evidence) => !evidence.overridesApplied.some((s) => s.includes("fallback="));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CutoverCoverageMatrix,
+  KernelContractMetaAllowlist,
+  RuntimeServiceBuiltinsTag,
+  defaultKernelImplementationRef,
+  evaluateFullCutoverGate,
+  fullCutoverGateModeLayer,
+  getKernelImplementationRef,
+  getRuntimeServicesEvidence,
+  isKernelFullyActivated,
+  isKernelImplementationRef,
+  kernelLayer,
+  runtimeDefaultServicesOverridesLayer,
+  runtimeServicesRegistryLayer
+});
+//# sourceMappingURL=Kernel.cjs.map