@logixjs/core 0.0.1 → 1.0.0

package/dist/{chunk-IHVBV5C2.js → chunk-SOOBFXRR.js}

@@ -4,6 +4,7 @@ var normalizePatchReason = (reason) => {
     case "reducer":
     case "trait-computed":
     case "trait-link":
+    case "trait-external-store":
     case "source-refresh":
     case "devtools":
     case "perf":
@@ -56,6 +57,17 @@ var isPrefixOf = (prefix, full) => {
   }
   return true;
 };
+var toKey = (path) => {
+  let key = "";
+  for (let i = 0; i < path.length; i++) {
+    if (i > 0) key += "|";
+    const seg = path[i];
+    key += seg.length;
+    key += ":";
+    key += seg;
+  }
+  return key;
+};
 var makeFieldPathIdRegistry = (fieldPaths) => {
   const root = { children: /* @__PURE__ */ new Map() };
   const pathStringToId = /* @__PURE__ */ new Map();
@@ -108,20 +120,75 @@ var hashFieldPathIds = (ids) => {
   }
   return hash >>> 0;
 };
+var makeDirtyAllSet = (reason) => ({
+  dirtyAll: true,
+  reason,
+  rootIds: [],
+  rootCount: 0,
+  keySize: 0,
+  keyHash: 0
+});
+var buildSpecificDirtySetFromIds = (ids, fieldPathsById) => {
+  const sorted = Array.from(ids);
+  sorted.sort((a, b) => {
+    const ap = fieldPathsById[a];
+    const bp = fieldPathsById[b];
+    const cmp = compareFieldPath(ap, bp);
+    return cmp !== 0 ? cmp : a - b;
+  });
+  const rootIds = [];
+  let prev;
+  for (let i = 0; i < sorted.length; i++) {
+    const id = sorted[i];
+    const path = fieldPathsById[id];
+    if (prev && isPrefixOf(prev, path)) continue;
+    rootIds.push(id);
+    prev = path;
+  }
+  if (rootIds.length === 0) {
+    return makeDirtyAllSet("unknownWrite");
+  }
+  rootIds.sort((a, b) => a - b);
+  const keyHash = hashFieldPathIds(rootIds);
+  return {
+    dirtyAll: false,
+    rootIds,
+    rootCount: rootIds.length,
+    keySize: rootIds.length,
+    keyHash
+  };
+};
+var buildSpecificDirtySetFromIdsShallowFast = (ids) => {
+  const sorted = Array.from(ids);
+  sorted.sort((a, b) => a - b);
+  const rootIds = [];
+  let prev;
+  for (let i = 0; i < sorted.length; i++) {
+    const id = sorted[i];
+    if (prev === id) continue;
+    rootIds.push(id);
+    prev = id;
+  }
+  if (rootIds.length === 0) {
+    return makeDirtyAllSet("unknownWrite");
+  }
+  const keyHash = hashFieldPathIds(rootIds);
+  return {
+    dirtyAll: false,
+    rootIds,
+    rootCount: rootIds.length,
+    keySize: rootIds.length,
+    keyHash
+  };
+};
 var dirtyPathsToRootIds = (options) => {
   if (options.dirtyAllReason) {
-    return {
-      dirtyAll: true,
-      reason: options.dirtyAllReason,
-      rootIds: [],
-      rootCount: 0,
-      keySize: 0,
-      keyHash: 0
-    };
+    return makeDirtyAllSet(options.dirtyAllReason);
   }
   let sawStar = false;
   let hasInvalid = false;
   let missing = false;
+  let allShallow = true;
   const ids = [];
   for (const raw of options.dirtyPaths ?? []) {
     if (raw === "*") {
@@ -138,16 +205,23 @@ var dirtyPathsToRootIds = (options) => {
         hasInvalid = true;
         continue;
       }
-      if (!options.registry.fieldPaths[id2]) {
+      const fieldPath = options.registry.fieldPaths[id2];
+      if (!fieldPath) {
         missing = true;
         continue;
       }
+      if (allShallow && fieldPath.length !== 1) {
+        allShallow = false;
+      }
       ids.push(id2);
       continue;
     }
     if (typeof raw === "string") {
       const direct = options.registry.pathStringToId?.get(raw);
       if (direct != null) {
+        if (allShallow && options.registry.fieldPaths[direct]?.length !== 1) {
+          allShallow = false;
+        }
         ids.push(direct);
         continue;
       }
@@ -164,76 +238,24 @@ var dirtyPathsToRootIds = (options) => {
       missing = true;
       continue;
     }
+    if (allShallow && options.registry.fieldPaths[id]?.length !== 1) {
+      allShallow = false;
+    }
     ids.push(id);
   }
   if (hasInvalid) {
-    return {
-      dirtyAll: true,
-      reason: "nonTrackablePatch",
-      rootIds: [],
-      rootCount: 0,
-      keySize: 0,
-      keyHash: 0
-    };
+    return makeDirtyAllSet("nonTrackablePatch");
   }
   if (missing) {
-    return {
-      dirtyAll: true,
-      reason: "fallbackPolicy",
-      rootIds: [],
-      rootCount: 0,
-      keySize: 0,
-      keyHash: 0
-    };
+    return makeDirtyAllSet("fallbackPolicy");
   }
   if (sawStar) {
-    return {
-      dirtyAll: true,
-      reason: "unknownWrite",
-      rootIds: [],
-      rootCount: 0,
-      keySize: 0,
-      keyHash: 0
-    };
+    return makeDirtyAllSet("unknownWrite");
   }
-  const fieldPathsById = options.registry.fieldPaths;
-  ids.sort((a, b) => {
-    const ap = fieldPathsById[a];
-    const bp = fieldPathsById[b];
-    if (!ap || !bp) return a - b;
-    const cmp = compareFieldPath(ap, bp);
-    return cmp !== 0 ? cmp : a - b;
-  });
-  const rootIds = [];
-  let prev;
-  for (let i = 0; i < ids.length; i++) {
-    const id = ids[i];
-    const path = fieldPathsById[id];
-    if (!path) continue;
-    if (prev && isPrefixOf(prev, path)) continue;
-    rootIds.push(id);
-    prev = path;
-  }
-  const hasSpecific = rootIds.length > 0;
-  if (!hasSpecific) {
-    return {
-      dirtyAll: true,
-      reason: "unknownWrite",
-      rootIds: [],
-      rootCount: 0,
-      keySize: 0,
-      keyHash: 0
-    };
+  if (allShallow) {
+    return buildSpecificDirtySetFromIdsShallowFast(ids);
   }
-  rootIds.sort((a, b) => a - b);
-  const keyHash = hashFieldPathIds(rootIds);
-  return {
-    dirtyAll: false,
-    rootIds,
-    rootCount: rootIds.length,
-    keySize: rootIds.length,
-    keyHash
-  };
+  return buildSpecificDirtySetFromIds(ids, options.registry.fieldPaths);
 };
 var splitSegments = (path) => {
   if (!path) return void 0;
@@ -272,8 +294,9 @@ export {
   normalizeFieldPath,
   compareFieldPath,
   isPrefixOf,
+  toKey,
   makeFieldPathIdRegistry,
   getFieldPathId,
   dirtyPathsToRootIds
 };
-//# sourceMappingURL=chunk-IHVBV5C2.js.map
+//# sourceMappingURL=chunk-SOOBFXRR.js.map

package/dist/chunk-SOOBFXRR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/field-path.ts"],"sourcesContent":["export type FieldPath = ReadonlyArray<string>\nexport type FieldPathId = number\n\nexport type DirtyAllReason = 'unknownWrite' | 'customMutation' | 'nonTrackablePatch' | 'fallbackPolicy'\n\nexport type PatchReason =\n  | 'reducer'\n  | 'trait-computed'\n  | 'trait-link'\n  | 'trait-external-store'\n  | 'source-refresh'\n  | 'devtools'\n  | 'perf'\n  | 'unknown'\n\nexport const normalizePatchReason = (reason: unknown): PatchReason => {\n  switch (reason) {\n    case 'reducer':\n    case 'trait-computed':\n    case 'trait-link':\n    case 'trait-external-store':\n    case 'source-refresh':\n    case 'devtools':\n    case 'perf':\n    case 'unknown':\n      return reason\n    default:\n      return typeof reason === 'string' && reason.startsWith('source:') ? 'source-refresh' : 'unknown'\n  }\n}\n\nexport interface DirtySet {\n  readonly dirtyAll: boolean\n  /**\n   * When dirtyAll=true, a stable reason code must be provided; when dirtyAll=false, it should be omitted.\n   */\n  readonly reason?: DirtyAllReason\n  /**\n   * FieldPathId (Static IR table index).\n   * - When dirtyAll=true, must be an empty array;\n   * - When dirtyAll=false, roots are deduped / prefix-free / stably sorted.\n   */\n  readonly rootIds: ReadonlyArray<FieldPathId>\n  readonly rootCount: number\n  readonly keySize: number\n  readonly keyHash: number\n  /**\n   * Optional: mark when the output is TopK-truncated (light/full).\n   * Note: truncation does not affect the definition of keyHash/keySize/rootCount (they still refer to full roots).\n   */\n  readonly rootIdsTruncated?: boolean\n}\n\ninterface FieldPathTrieNode {\n  id?: FieldPathId\n  children: Map<string, FieldPathTrieNode>\n}\n\nexport interface FieldPathIdRegistry {\n  readonly fieldPaths: ReadonlyArray<FieldPath>\n  readonly root: FieldPathTrieNode\n  /**\n   * Fast path: direct lookup for common string inputs (e.g. 'a.b').\n   *\n   * Note: This map is only safe for \"dot-separated\" paths. If a schema key itself contains '.',\n   * it is ambiguous with nested paths and should not rely on string-path APIs.\n   */\n  readonly pathStringToId?: ReadonlyMap<string, FieldPathId>\n}\n\nexport const isFieldPathSegment = (seg: string): boolean => {\n  if (!seg) return false\n  if (seg === '*') return false\n  if (/^\\d+$/.test(seg)) return false\n  if (seg.includes('[') || seg.includes(']')) return false\n  return true\n}\n\nexport const normalizeFieldPath = (input: string | FieldPath): FieldPath | undefined => {\n  if (typeof input === 'string') {\n    const segs = splitSegments(input)\n    if (!segs || segs.length === 0) return undefined\n    const normalized = segs.filter(isFieldPathSegment)\n    return normalized.length > 0 ? normalized : undefined\n  }\n\n  if (input.length === 0) return undefined\n\n  let needsFilter = false\n  for (const seg of input) {\n    if (!isFieldPathSegment(seg)) {\n      needsFilter = true\n      break\n    }\n  }\n\n  if (!needsFilter) return input\n\n  const normalized = input.filter(isFieldPathSegment)\n  return normalized.length > 0 ? normalized : undefined\n}\n\nexport const compareFieldPath = (a: FieldPath, b: FieldPath): number => {\n  const len = Math.min(a.length, b.length)\n  for (let i = 0; i < len; i++) {\n    const as = a[i]!\n    const bs = b[i]!\n    if (as === bs) continue\n    return as < bs ? -1 : 1\n  }\n  return a.length - b.length\n}\n\nexport const isPrefixOf = (prefix: FieldPath, full: FieldPath): boolean => {\n  if (prefix.length > full.length) return false\n  for (let i = 0; i < prefix.length; i++) {\n    if (prefix[i] !== full[i]) return false\n  }\n  return true\n}\n\nexport const toKey = (path: FieldPath): string => {\n  let key = ''\n  for (let i = 0; i < path.length; i++) {\n    if (i > 0) key += '|'\n    const seg = path[i]!\n    key += seg.length\n    key += ':'\n    key += seg\n  }\n  return key\n}\n\nexport const toPathString = (path: FieldPath): string => path.join('.')\n\nexport const canonicalizeRoots = (roots: Iterable<FieldPath>): ReadonlyArray<FieldPath> => {\n  const byKey = new Map<string, FieldPath>()\n  for (const root of roots) {\n    const key = toKey(root)\n    if (!byKey.has(key)) byKey.set(key, root)\n  }\n\n  const sorted = Array.from(byKey.values()).sort(compareFieldPath)\n  const out: Array<FieldPath> = []\n  for (const next of sorted) {\n    const prev = out[out.length - 1]\n    if (prev && isPrefixOf(prev, next)) {\n      continue\n    }\n    out.push(next)\n  }\n  return out\n}\n\nexport const canonicalizeRootsFast = (roots: Iterable<FieldPath>): ReadonlyArray<FieldPath> => {\n  const sorted = Array.from(roots).sort(compareFieldPath)\n  const out: Array<FieldPath> = []\n  for (const next of sorted) {\n    const prev = out[out.length - 1]\n    if (prev && isPrefixOf(prev, next)) continue\n    out.push(next)\n  }\n  return out\n}\n\nexport const makeFieldPathIdRegistry = (fieldPaths: ReadonlyArray<FieldPath>): FieldPathIdRegistry => {\n  const root: FieldPathTrieNode = { children: new Map() }\n  const pathStringToId = new Map<string, FieldPathId>()\n  const ambiguousPathStrings = new Set<string>()\n\n  for (let id = 0; id < fieldPaths.length; id++) {\n    const path = fieldPaths[id]!\n    let node = root\n    for (const seg of path) {\n      const children = node.children\n      let next = children.get(seg)\n      if (!next) {\n        next = { children: new Map() }\n        children.set(seg, next)\n      }\n      node = next\n    }\n    node.id = id\n\n    if (path.length > 0 && path.some((seg) => seg.includes('.'))) {\n      const key = path.join('.')\n      ambiguousPathStrings.add(key)\n      pathStringToId.delete(key)\n    }\n\n    if (path.length > 0 && path.every((seg) => !seg.includes('.') && !seg.includes('[') && !seg.includes(']'))) {\n      const key = path.join('.')\n      if (ambiguousPathStrings.has(key)) continue\n      if (pathStringToId.has(key)) {\n        ambiguousPathStrings.add(key)\n        pathStringToId.delete(key)\n        continue\n      }\n      pathStringToId.set(key, id)\n    }\n  }\n\n  return { fieldPaths, root, pathStringToId }\n}\n\nexport const getFieldPathId = (registry: FieldPathIdRegistry, path: FieldPath): FieldPathId | undefined => {\n  let node = registry.root\n  for (const seg of path) {\n    const next = node.children.get(seg)\n    if (!next) return undefined\n    node = next\n  }\n  return node.id\n}\n\nexport const getFieldPathIdFromString = (registry: FieldPathIdRegistry, path: string): FieldPathId | undefined => {\n  if (!path || path === '*') return undefined\n  const normalized = normalizeFieldPath(path)\n  if (!normalized) return undefined\n  return getFieldPathId(registry, normalized)\n}\n\nexport const hashFieldPathIds = (ids: ReadonlyArray<number>): number => {\n  // FNV-1a (32-bit)\n  let hash = 2166136261 >>> 0\n  for (const id of ids) {\n    hash ^= id >>> 0\n    hash = Math.imul(hash, 16777619)\n  }\n  return hash >>> 0\n}\n\nconst makeDirtyAllSet = (reason: DirtyAllReason): DirtySet => ({\n  dirtyAll: true,\n  reason,\n  rootIds: [],\n  rootCount: 0,\n  keySize: 0,\n  keyHash: 0,\n})\n\nconst buildSpecificDirtySetFromIds = (\n  ids: ReadonlyArray<number>,\n  fieldPathsById: ReadonlyArray<FieldPath>,\n): DirtySet => {\n  const sorted = Array.from(ids)\n  sorted.sort((a, b) => {\n    const ap = fieldPathsById[a]\n    const bp = fieldPathsById[b]\n    const cmp = compareFieldPath(ap!, bp!)\n    return cmp !== 0 ? cmp : a - b\n  })\n\n  const rootIds: Array<number> = []\n  let prev: FieldPath | undefined\n  for (let i = 0; i < sorted.length; i++) {\n    const id = sorted[i]!\n    const path = fieldPathsById[id]!\n    if (prev && isPrefixOf(prev, path)) continue\n    rootIds.push(id)\n    prev = path\n  }\n\n  if (rootIds.length === 0) {\n    return makeDirtyAllSet('unknownWrite')\n  }\n\n  rootIds.sort((a, b) => a - b)\n  const keyHash = hashFieldPathIds(rootIds)\n  return {\n    dirtyAll: false,\n    rootIds,\n    rootCount: rootIds.length,\n    keySize: rootIds.length,\n    keyHash,\n  }\n}\n\nconst buildSpecificDirtySetFromIdsShallowFast = (ids: ReadonlyArray<number>): DirtySet => {\n  // Fast path: if all dirty paths are single-segment (no structural prefixes possible),\n  // roots are just the unique ids in numeric order.\n  const sorted = Array.from(ids)\n  sorted.sort((a, b) => a - b)\n\n  const rootIds: Array<number> = []\n  let prev: number | undefined\n  for (let i = 0; i < sorted.length; i++) {\n    const id = sorted[i]!\n    if (prev === id) continue\n    rootIds.push(id)\n    prev = id\n  }\n\n  if (rootIds.length === 0) {\n    return makeDirtyAllSet('unknownWrite')\n  }\n\n  const keyHash = hashFieldPathIds(rootIds)\n  return {\n    dirtyAll: false,\n    rootIds,\n    rootCount: rootIds.length,\n    keySize: rootIds.length,\n    keyHash,\n  }\n}\n\nexport const dirtyPathIdsToRootIds = (options: {\n  readonly dirtyPathIds?: Iterable<FieldPathId>\n  readonly registry: FieldPathIdRegistry\n  readonly dirtyAllReason?: DirtyAllReason\n}): DirtySet => {\n  if (options.dirtyAllReason) {\n    return makeDirtyAllSet(options.dirtyAllReason)\n  }\n\n  let hasInvalid = false\n  let missing = false\n  let allShallow = true\n  const ids: Array<number> = []\n\n  for (const raw of options.dirtyPathIds ?? []) {\n    if (!Number.isFinite(raw)) {\n      hasInvalid = true\n      continue\n    }\n    const id = Math.floor(raw)\n    if (id < 0) {\n      hasInvalid = true\n      continue\n    }\n    const fieldPath = options.registry.fieldPaths[id]\n    if (!fieldPath) {\n      missing = true\n      continue\n    }\n    if (allShallow && fieldPath.length !== 1) {\n      allShallow = false\n    }\n    ids.push(id)\n  }\n\n  if (hasInvalid) {\n    return makeDirtyAllSet('nonTrackablePatch')\n  }\n\n  if (missing) {\n    return makeDirtyAllSet('fallbackPolicy')\n  }\n\n  if (allShallow) {\n    return buildSpecificDirtySetFromIdsShallowFast(ids)\n  }\n\n  return buildSpecificDirtySetFromIds(ids, options.registry.fieldPaths)\n}\n\nexport const dirtyPathsToRootIds = (options: {\n  readonly dirtyPaths?: Iterable<string | FieldPath | FieldPathId>\n  readonly registry: FieldPathIdRegistry\n  readonly dirtyAllReason?: DirtyAllReason\n}): DirtySet => {\n  if (options.dirtyAllReason) {\n    return makeDirtyAllSet(options.dirtyAllReason)\n  }\n\n  let sawStar = false\n  let hasInvalid = false\n  let missing = false\n  let allShallow = true\n\n  const ids: Array<number> = []\n  for (const raw of options.dirtyPaths ?? []) {\n    if (raw === '*') {\n      sawStar = true\n      continue\n    }\n\n    if (typeof raw === 'number') {\n      if (!Number.isFinite(raw)) {\n        hasInvalid = true\n        continue\n      }\n      const id = Math.floor(raw)\n      if (id < 0) {\n        hasInvalid = true\n        continue\n      }\n      const fieldPath = options.registry.fieldPaths[id]\n      if (!fieldPath) {\n        missing = true\n        continue\n      }\n      if (allShallow && fieldPath.length !== 1) {\n        allShallow = false\n      }\n      ids.push(id)\n      continue\n    }\n\n    if (typeof raw === 'string') {\n      const direct = options.registry.pathStringToId?.get(raw)\n      if (direct != null) {\n        if (allShallow && options.registry.fieldPaths[direct]?.length !== 1) {\n          allShallow = false\n        }\n        ids.push(direct)\n        continue\n      }\n\n      // String path is treated as dot-separated boundary input only.\n      // If it cannot be mapped directly, it is considered ambiguous/unmappable.\n      missing = true\n      continue\n    }\n\n    const normalized = normalizeFieldPath(raw)\n    if (!normalized) {\n      hasInvalid = true\n      continue\n    }\n\n    const id = getFieldPathId(options.registry, normalized)\n    if (id == null) {\n      missing = true\n      continue\n    }\n    if (allShallow && options.registry.fieldPaths[id]?.length !== 1) {\n      allShallow = false\n    }\n    ids.push(id)\n  }\n\n  if (hasInvalid) {\n    return makeDirtyAllSet('nonTrackablePatch')\n  }\n\n  if (missing) {\n    return makeDirtyAllSet('fallbackPolicy')\n  }\n\n  // Any non-trackable write must explicitly degrade (do not \"ignore *\" when roots exist).\n  if (sawStar) {\n    return makeDirtyAllSet('unknownWrite')\n  }\n\n  if (allShallow) {\n    return buildSpecificDirtySetFromIdsShallowFast(ids)\n  }\n\n  return buildSpecificDirtySetFromIds(ids, options.registry.fieldPaths)\n}\n\nconst splitSegments = (path: string): Array<string> | undefined => {\n  if (!path) return undefined\n  if (path === '*') return undefined\n\n  const parts = path.split('.').filter((p) => p.length > 0)\n  const segs: Array<string> = []\n\n  for (const part of parts) {\n    if (!part) continue\n    if (part === '*') {\n      return undefined\n    }\n    if (part.endsWith('[]')) {\n      const base = part.slice(0, -2)\n      if (base) segs.push(base)\n      continue\n    }\n    const bracket = /^(.+)\\[(\\d+)\\]$/.exec(part)\n    if (bracket) {\n      segs.push(bracket[1]!)\n      continue\n    }\n    if (/^\\d+$/.test(part)) {\n      continue\n    }\n    if (part.includes('[') || part.includes(']')) {\n      return undefined\n    }\n    segs.push(part)\n  }\n\n  return segs\n}\n"],"mappings":"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","names":["normalized","id"]}

package/dist/{chunk-ZDTRWK5F.js → chunk-TAHFWKS6.js}

@@ -1,6 +1,6 @@
 import {
   Tag
-} from "./chunk-KL5ACTCT.js";
+} from "./chunk-UEFFTVPY.js";
 import {
   __export
 } from "./chunk-PZ5AY32C.js";
@@ -37,4 +37,4 @@ export {
   defaultLayer,
   Platform_exports
 };
-//# sourceMappingURL=chunk-ZDTRWK5F.js.map
+//# sourceMappingURL=chunk-TAHFWKS6.js.map

package/dist/chunk-UEFFTVPY.js

@@ -0,0 +1,9 @@
+// src/internal/runtime/core/Platform.ts
+import { ServiceMap } from "effect";
+var Tag = class extends ServiceMap.Service()("@logixjs/Platform") {
+};
+
+export {
+  Tag
+};
+//# sourceMappingURL=chunk-UEFFTVPY.js.map

package/dist/chunk-UEFFTVPY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/runtime/core/Platform.ts"],"sourcesContent":["import { Effect, ServiceMap } from 'effect'\n\nexport interface Service {\n  readonly lifecycle: {\n    readonly onSuspend: (eff: Effect.Effect<void, never, any>) => Effect.Effect<void, never, any>\n    readonly onResume: (eff: Effect.Effect<void, never, any>) => Effect.Effect<void, never, any>\n    readonly onReset?: (eff: Effect.Effect<void, never, any>) => Effect.Effect<void, never, any>\n  }\n\n  /**\n   * Platform signal broadcaster (for host integration and tests): triggers registered lifecycle handlers.\n   *\n   * Notes:\n   * - The default implementation should be a safe no-op.\n   * - Failure policy is decided by the platform implementation; the runtime should ensure \"do not terminate the instance by default\".\n   */\n  readonly emitSuspend: () => Effect.Effect<void, never, any>\n  readonly emitResume: () => Effect.Effect<void, never, any>\n  readonly emitReset: () => Effect.Effect<void, never, any>\n}\n\nexport class Tag extends ServiceMap.Service<Tag, Service>()('@logixjs/Platform') {}\n"],"mappings":";AAAA,SAAiB,kBAAkB;AAqB5B,IAAM,MAAN,cAAkB,WAAW,QAAsB,EAAE,mBAAmB,EAAE;AAAC;","names":[]}

package/dist/{chunk-24VULZ7A.js → chunk-UR5BXLBP.js}

@@ -2,7 +2,7 @@ import {
   CutoverCoverageMatrix,
   RuntimeServiceBuiltinsTag,
   evaluateFullCutoverGate
-} from "./chunk-KP7MUZNX.js";
+} from "./chunk-RLXO27MW.js";
 import {
   FullCutoverGateModeTag,
   KernelImplementationRefTag,
@@ -12,7 +12,7 @@ import {
   getKernelImplementationRef,
   getRuntimeServicesEvidence,
   isKernelImplementationRef
-} from "./chunk-ZGDVUPTM.js";
+} from "./chunk-IOZ3VKPK.js";
 import {
   __export
 } from "./chunk-PZ5AY32C.js";
@@ -73,4 +73,4 @@ export {
   isKernelFullyActivated,
   Kernel_exports
 };
-//# sourceMappingURL=chunk-24VULZ7A.js.map
+//# sourceMappingURL=chunk-UR5BXLBP.js.map

package/dist/chunk-UR5BXLBP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/Kernel.ts"],"sourcesContent":["import { Layer } from 'effect'\nimport type { Layer as LayerType } from 'effect'\nimport type * as Debug from './Debug.js'\nimport * as FullCutoverGate from './internal/runtime/core/FullCutoverGate.js'\nimport * as RuntimeKernel from './internal/runtime/core/RuntimeKernel.js'\nimport * as KernelRef from './internal/runtime/core/KernelRef.js'\nexport type { RuntimeServiceBuiltins } from './internal/runtime/core/RuntimeServiceBuiltins.js'\nexport { RuntimeServiceBuiltinsTag } from './internal/runtime/core/RuntimeServiceBuiltins.js'\n\nexport type KernelId = KernelRef.KernelId\n\nexport interface KernelImplementationRef extends KernelRef.KernelImplementationRef {}\n\nexport const defaultKernelImplementationRef = KernelRef.defaultKernelImplementationRef\n\nexport const isKernelImplementationRef = KernelRef.isKernelImplementationRef\n\nexport type RuntimeServiceOverride = RuntimeKernel.RuntimeServiceOverride\nexport type RuntimeServicesOverrides = RuntimeKernel.RuntimeServicesOverrides\nexport type RuntimeServiceBinding = RuntimeKernel.RuntimeServiceBinding\nexport type RuntimeServicesEvidence = RuntimeKernel.RuntimeServicesEvidence\n\nexport type RuntimeServiceImpl<Service> = RuntimeKernel.RuntimeServiceImpl<Service>\nexport type RuntimeServicesRegistry = RuntimeKernel.RuntimeServicesRegistry\n\nexport type CutoverCoverageMatrix = FullCutoverGate.CutoverCoverageMatrix\n\nexport const CutoverCoverageMatrix = FullCutoverGate.CutoverCoverageMatrix\n\nexport type FullCutoverGateMode = FullCutoverGate.FullCutoverGateMode\n\nexport type FullCutoverGateReason = FullCutoverGate.FullCutoverGateReason\n\nexport type FullCutoverGateAnchor = FullCutoverGate.FullCutoverGateAnchor\n\nexport type FullCutoverGateVerdict = FullCutoverGate.FullCutoverGateVerdict\n\nexport type FullCutoverGateResult = FullCutoverGate.FullCutoverGateResult\n\nexport const evaluateFullCutoverGate = (args: {\n  readonly mode: FullCutoverGateMode\n  readonly requestedKernelId: KernelId\n  readonly runtimeServicesEvidence: RuntimeServicesEvidence\n  readonly coverageMatrix?: CutoverCoverageMatrix\n  readonly diagnosticsLevel?: Debug.DiagnosticsLevel\n}): FullCutoverGateResult => {\n  return FullCutoverGate.evaluateFullCutoverGate({\n    mode: args.mode,\n    requestedKernelId: args.requestedKernelId,\n    runtimeServicesEvidence: args.runtimeServicesEvidence,\n    coverageMatrix: args.coverageMatrix,\n    diagnosticsLevel: args.diagnosticsLevel,\n  })\n}\n\nexport interface KernelContractMetaAllowlistItem {\n  readonly metaKey: string\n  readonly reason?: string\n}\n\nexport const KernelContractMetaAllowlist = [] as const satisfies ReadonlyArray<KernelContractMetaAllowlistItem>\n\n/**\n * kernelLayer:\n * - Declares the requested kernel family in the current runtime tree.\n * - This does not prove full activation; fallback/mix is decided by RuntimeServicesEvidence.\n */\nexport const kernelLayer = (ref: KernelImplementationRef): LayerType.Layer<any, never, never> =>\n  Layer.succeed(KernelRef.KernelImplementationRefTag, ref) as LayerType.Layer<any, never, never>\n\n/**\n * runtimeDefaultServicesOverridesLayer:\n * - Provides `runtime_default` scope `serviceId -> implId` overrides during ManagedRuntime assembly.\n * - Does not set servicesByModuleId by default (do not use moduleId as the default kernel selection granularity).\n */\nexport const runtimeDefaultServicesOverridesLayer = (\n  services: RuntimeServicesOverrides,\n): LayerType.Layer<any, never, never> =>\n  Layer.succeed(RuntimeKernel.RuntimeServicesRuntimeConfigTag, {\n    services,\n  }) as LayerType.Layer<any, never, never>\n\n/**\n * getRuntimeServicesEvidence:\n * - Reads RuntimeServicesEvidence installed on a ModuleRuntime (serviceId -> implId evidence).\n * - Public entry to avoid importing from `src/internal`.\n */\nexport const getRuntimeServicesEvidence = RuntimeKernel.getRuntimeServicesEvidence\n\n/**\n * getKernelImplementationRef:\n * - Reads KernelImplementationRef installed on a ModuleRuntime (requested kernel family).\n */\nexport const getKernelImplementationRef = KernelRef.getKernelImplementationRef\n\n/**\n * runtimeServicesRegistryLayer:\n * - Injects additional `serviceId -> impls` during runtime assembly (e.g. implementations provided by core-ng).\n */\nexport const runtimeServicesRegistryLayer = (registry: RuntimeServicesRegistry): LayerType.Layer<any, never, never> =>\n  Layer.succeed(RuntimeKernel.RuntimeServicesRegistryTag, registry) as LayerType.Layer<any, never, never>\n\n/**\n * fullCutoverGateModeLayer:\n * - Controls cutover gate evaluation mode during runtime assembly (trial/fullCutover).\n * - Default is fullCutover; trial-run/comparison may override to trial explicitly.\n */\nexport const fullCutoverGateModeLayer = (mode: FullCutoverGateMode): LayerType.Layer<any, never, never> =>\n  Layer.succeed(RuntimeKernel.FullCutoverGateModeTag, mode) as LayerType.Layer<any, never, never>\n\n/**\n * isKernelFullyActivated:\n * - Minimal verdict for \"full cutover\": no fallbacks are allowed.\n */\nexport const isKernelFullyActivated = (evidence: RuntimeServicesEvidence): boolean =>\n  !evidence.overridesApplied.some((s) => s.includes('fallback='))\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA,+BAAAA;AAAA,EAAA;AAAA;AAAA,wCAAAC;AAAA,EAAA,+BAAAC;AAAA,EAAA;AAAA,oCAAAC;AAAA,EAAA,kCAAAC;AAAA,EAAA;AAAA,mCAAAC;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,SAAS,aAAa;AAaf,IAAMC,kCAA2C;AAEjD,IAAMC,6BAAsC;AAY5C,IAAMC,yBAAwC;AAY9C,IAAMC,2BAA0B,CAAC,SAMX;AAC3B,SAAuB,wBAAwB;AAAA,IAC7C,MAAM,KAAK;AAAA,IACX,mBAAmB,KAAK;AAAA,IACxB,yBAAyB,KAAK;AAAA,IAC9B,gBAAgB,KAAK;AAAA,IACrB,kBAAkB,KAAK;AAAA,EACzB,CAAC;AACH;AAOO,IAAM,8BAA8B,CAAC;AAOrC,IAAM,cAAc,CAAC,QAC1B,MAAM,QAAkB,4BAA4B,GAAG;AAOlD,IAAM,uCAAuC,CAClD,aAEA,MAAM,QAAsB,iCAAiC;AAAA,EAC3D;AACF,CAAC;AAOI,IAAMC,8BAA2C;AAMjD,IAAMC,8BAAuC;AAM7C,IAAM,+BAA+B,CAAC,aAC3C,MAAM,QAAsB,4BAA4B,QAAQ;AAO3D,IAAM,2BAA2B,CAAC,SACvC,MAAM,QAAsB,wBAAwB,IAAI;AAMnD,IAAM,yBAAyB,CAAC,aACrC,CAAC,SAAS,iBAAiB,KAAK,CAAC,MAAM,EAAE,SAAS,WAAW,CAAC;","names":["CutoverCoverageMatrix","defaultKernelImplementationRef","evaluateFullCutoverGate","getKernelImplementationRef","getRuntimeServicesEvidence","isKernelImplementationRef","defaultKernelImplementationRef","isKernelImplementationRef","CutoverCoverageMatrix","evaluateFullCutoverGate","getRuntimeServicesEvidence","getKernelImplementationRef"]}