@logixjs/core 0.0.1 → 1.0.0

package/dist/{chunk-PYOE4VSI.js → chunk-IVXSVHO4.js}

@@ -4,186 +4,51 @@ import {
   parseListItemFieldPath,
   setAtPathMutating,
   toListItemValuePath
-} from "./chunk-BABLDP24.js";
+} from "./chunk-EPQFNJU3.js";
 import {
   Snapshot,
   internal,
   keyHash
-} from "./chunk-NZJKFF45.js";
+} from "./chunk-EKCDHWRK.js";
 import {
-  forceSourceRefresh,
-  inSyncTransactionFiber
-} from "./chunk-ZFLHVFUC.js";
+  mergeCanonical,
+  sanitize
+} from "./chunk-J3CWXIPV.js";
 import {
   compareFieldPath,
   getFieldPathId,
   makeFieldPathIdRegistry,
   normalizeFieldPath
-} from "./chunk-IHVBV5C2.js";
+} from "./chunk-SOOBFXRR.js";
 import {
   getBoundInternals
-} from "./chunk-3RMKLXHX.js";
+} from "./chunk-63ZQ5RIN.js";
 import {
   ReplayModeConfigTag,
+  forceSourceRefresh,
+  inSyncTransactionFiber,
   isDevEnv
-} from "./chunk-3QMIVH35.js";
-import {
-  record
-} from "./chunk-DMBALCE2.js";
-import {
-  fnv1a32,
-  stableStringify
-} from "./chunk-GMPEOUP2.js";
+} from "./chunk-S4S5N4BJ.js";
 import {
   RunSessionTag,
   make,
   run
-} from "./chunk-OFADUJWJ.js";
+} from "./chunk-CYYSQMLO.js";
+import {
+  currentDiagnosticsLevel,
+  record
+} from "./chunk-V2SBGVDO.js";
 import {
   EffectOpMiddlewareTag
-} from "./chunk-JWOYLO27.js";
+} from "./chunk-LPPZDFTD.js";
+import {
+  fnv1a32,
+  stableStringify
+} from "./chunk-4MZ7BT3R.js";
 
 // src/internal/state-trait/build.ts
 import * as SchemaAST from "effect/SchemaAST";
 
-// src/internal/state-trait/meta.ts
-var uniqSortedStrings = (input) => {
-  const set = /* @__PURE__ */ new Set();
-  for (const item of input) {
-    const v = item.trim();
-    if (!v) continue;
-    set.add(v);
-  }
-  return Array.from(set).sort((a, b) => a.localeCompare(b));
-};
-var isPlainRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var sanitizeJsonValue = (input, depth) => {
-  if (input === null) return null;
-  if (typeof input === "string") return input;
-  if (typeof input === "boolean") return input;
-  if (typeof input === "number") {
-    return Number.isFinite(input) ? input : void 0;
-  }
-  if (depth >= 6) return void 0;
-  if (Array.isArray(input)) {
-    const out = [];
-    for (const item of input) {
-      const v = sanitizeJsonValue(item, depth + 1);
-      if (v !== void 0) out.push(v);
-    }
-    return out;
-  }
-  if (isPlainRecord(input)) {
-    const keys = Object.keys(input).sort();
-    const out = {};
-    for (const key of keys) {
-      const v = sanitizeJsonValue(input[key], depth + 1);
-      if (v !== void 0) out[key] = v;
-    }
-    return out;
-  }
-  return void 0;
-};
-var sanitize = (input) => {
-  if (input === null || input === void 0) return void 0;
-  if (typeof input !== "object" || Array.isArray(input)) return void 0;
-  const record2 = input;
-  const out = {};
-  const pickString = (key) => {
-    const value = record2[key];
-    if (typeof value !== "string") return;
-    const trimmed = value.trim();
-    if (!trimmed) return;
-    out[key] = trimmed;
-  };
-  pickString("label");
-  pickString("description");
-  pickString("group");
-  pickString("docsUrl");
-  pickString("cacheGroup");
-  const canonical = record2.canonical;
-  if (typeof canonical === "boolean") {
-    out.canonical = canonical;
-  }
-  const tagsRaw = record2.tags;
-  if (typeof tagsRaw === "string") {
-    const tags = uniqSortedStrings([tagsRaw]);
-    if (tags.length > 0) out.tags = tags;
-  } else if (Array.isArray(tagsRaw)) {
-    const tags = uniqSortedStrings(tagsRaw.filter((x) => typeof x === "string"));
-    if (tags.length > 0) out.tags = tags;
-  }
-  const annotations = {};
-  const annotationKeys = Object.keys(record2).filter((k) => k.startsWith("x-")).sort((a, b) => a.localeCompare(b));
-  for (const key of annotationKeys) {
-    const v = sanitizeJsonValue(record2[key], 0);
-    if (v !== void 0) annotations[key] = v;
-  }
-  const annotationsRaw = record2.annotations;
-  if (isPlainRecord(annotationsRaw)) {
-    const keys = Object.keys(annotationsRaw).filter((k) => k.startsWith("x-")).sort((a, b) => a.localeCompare(b));
-    for (const key of keys) {
-      const v = sanitizeJsonValue(annotationsRaw[key], 0);
-      if (v !== void 0) annotations[key] = v;
-    }
-  }
-  if (Object.keys(annotations).length > 0) out.annotations = annotations;
-  return Object.keys(out).length > 0 ? out : void 0;
-};
-var stableStringify2 = (meta) => {
-  const out = {};
-  const keys = Object.keys(meta).sort();
-  for (const k of keys) {
-    out[k] = meta[k];
-  }
-  return JSON.stringify(out);
-};
-var equals = (a, b) => {
-  if (a === b) return true;
-  if (!a || !b) return false;
-  return stableStringify2(a) === stableStringify2(b);
-};
-var mergeCanonical = (current, incoming) => {
-  const existing = current.meta;
-  if (!existing) {
-    return {
-      meta: incoming.meta,
-      origin: incoming.origin,
-      conflicts: current.conflicts
-    };
-  }
-  if (equals(existing, incoming.meta)) {
-    return current;
-  }
-  const conflicts = [...current.conflicts ?? []];
-  const push = (conflict) => {
-    const exists = conflicts.some((c) => c.origin === conflict.origin && equals(c.meta, conflict.meta));
-    if (!exists) conflicts.push(conflict);
-  };
-  const existingCanonical = existing.canonical === true;
-  const incomingCanonical = incoming.meta.canonical === true;
-  if (!existingCanonical && incomingCanonical) {
-    push({
-      origin: current.origin ?? "unknown",
-      meta: existing
-    });
-    return {
-      meta: incoming.meta,
-      origin: incoming.origin,
-      conflicts
-    };
-  }
-  push({
-    origin: incoming.origin,
-    meta: incoming.meta
-  });
-  return {
-    meta: existing,
-    origin: current.origin ?? incoming.origin,
-    conflicts
-  };
-};
-
 // src/internal/state-trait/model.ts
 var normalizeSpec = (spec) => {
   const entries = [];
@@ -219,6 +84,14 @@ var normalizeSpec = (spec) => {
         meta: { ...meta, deps, _fieldPath: fieldPath }
       };
     }
+    if (entry.kind === "externalStore") {
+      const meta = entry.meta;
+      return {
+        ...entry,
+        fieldPath,
+        meta: { ...meta, _fieldPath: fieldPath }
+      };
+    }
     if (entry.kind === "link") {
       const meta = entry.meta;
       const from = prefixDeps([meta.from], depPrefix)[0] ?? meta.from;
@@ -256,6 +129,7 @@ var normalizeSpec = (spec) => {
     expandMaybeRecord(node.computed);
     expandMaybeRecord(node.source);
     expandMaybeRecord(node.link);
+    expandMaybeRecord(node.externalStore);
     if (node.check) {
       const rules = {};
       const checkDepsPrefix = options?.checkDepsPrefix ?? (joinPrefix.endsWith("[]") ? joinPrefix : "");
@@ -346,8 +220,56 @@ var collectNodeMeta = (spec) => {
   return out;
 };
 
+// src/internal/state-trait/converge-ir.ts
+var getConvergeStaticIrDigest = (ir) => {
+  if (typeof ir.staticIrDigest === "string" && ir.staticIrDigest.length > 0) {
+    return ir.staticIrDigest;
+  }
+  const hash = fnv1a32(
+    stableStringify({ writersKey: ir.writersKey, depsKey: ir.depsKey, fieldPathsKey: ir.fieldPathsKey })
+  );
+  return `converge_ir_v2:${hash}`;
+};
+var exportConvergeStaticIr = (options) => ({
+  staticIrDigest: getConvergeStaticIrDigest(options.ir),
+  moduleId: options.moduleId,
+  instanceId: options.instanceId,
+  generation: options.ir.generation,
+  fieldPaths: options.ir.fieldPaths,
+  stepOutFieldPathIdByStepId: Array.from(options.ir.stepOutFieldPathIdByStepId),
+  stepSchedulingByStepId: options.ir.stepSchedulingByStepId.slice(),
+  topoOrder: options.ir.topoOrder.slice(),
+  buildDurationMs: options.ir.buildDurationMs
+});
+
 // src/internal/state-trait/build.ts
 var nowPerf = () => typeof globalThis.performance !== "undefined" && typeof globalThis.performance.now === "function" ? globalThis.performance.now() : Date.now();
+var collectMultipleWritersError = (entries) => {
+  const kindsByFieldPath = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.kind !== "computed" && entry.kind !== "link" && entry.kind !== "source" && entry.kind !== "externalStore") {
+      continue;
+    }
+    const set = kindsByFieldPath.get(entry.fieldPath) ?? /* @__PURE__ */ new Set();
+    set.add(entry.kind);
+    kindsByFieldPath.set(entry.fieldPath, set);
+  }
+  const conflicts = [];
+  for (const [fieldPath, kinds] of kindsByFieldPath.entries()) {
+    if (kinds.size <= 1) continue;
+    conflicts.push({ fieldPath, kinds: Array.from(kinds).sort() });
+  }
+  if (conflicts.length === 0) return void 0;
+  conflicts.sort((a, b) => a.fieldPath < b.fieldPath ? -1 : a.fieldPath > b.fieldPath ? 1 : 0);
+  const fields = conflicts.map((c) => c.fieldPath);
+  const primary = conflicts[0];
+  const kindSummary = primary.kinds.join(" + ");
+  return {
+    code: "MULTIPLE_WRITERS",
+    message: `[StateTrait.build] Multiple writers for field "${primary.fieldPath}" (${kindSummary}). Only one of computed/link/source/externalStore can write a fieldPath.`,
+    fields
+  };
+};
 var getConvergeWriterDeps = (entry) => {
   if (entry.kind === "computed") {
     return entry.meta?.deps ?? [];
@@ -425,24 +347,11 @@ var collectSchemaFieldPaths = (schema) => {
     byKey.set(JSON.stringify(normalized), normalized);
   };
   const visit = (ast, prefix, seen) => {
-    let current = ast;
-    while (true) {
-      if (SchemaAST.isSuspend(current)) {
-        if (seen.has(current)) return;
-        seen.add(current);
-        current = current.f();
-        continue;
-      }
-      if (SchemaAST.isRefinement(current)) {
-        current = current.from;
-        continue;
-      }
-      break;
-    }
-    if (SchemaAST.isTransformation(current)) {
-      visit(current.to, prefix, seen);
-      visit(current.from, prefix, seen);
-      return;
+    let current = SchemaAST.toType(ast);
+    while (SchemaAST.isSuspend(current)) {
+      if (seen.has(current)) return;
+      seen.add(current);
+      current = SchemaAST.toType(current.thunk());
     }
     if (SchemaAST.isUnion(current)) {
       for (const t of current.types) {
@@ -450,16 +359,16 @@ var collectSchemaFieldPaths = (schema) => {
       }
       return;
     }
-    if (SchemaAST.isTupleType(current)) {
+    if (SchemaAST.isArrays(current)) {
       for (const e of current.elements) {
-        visit(e.type, prefix, seen);
+        visit(e, prefix, seen);
       }
       for (const r of current.rest) {
-        visit(r.type, prefix, seen);
+        visit(r, prefix, seen);
       }
       return;
     }
-    if (SchemaAST.isTypeLiteral(current)) {
+    if (SchemaAST.isObjects(current)) {
       for (const ps of current.propertySignatures) {
         const seg = String(ps.name);
         if (!seg) continue;
@@ -476,6 +385,7 @@ var collectSchemaFieldPaths = (schema) => {
 var buildConvergeIr = (stateSchema, entries) => {
   const startedAt = nowPerf();
   const generation = 0;
+  const multipleWritersError = collectMultipleWritersError(entries);
   const writers = entries.filter((e) => e.kind === "computed" || e.kind === "link");
   const writersKey = writers.map((entry) => `${entry.kind}:${entry.fieldPath}`).sort().join("|");
   const depsKey = writers.map((entry) => {
@@ -487,7 +397,7 @@ var buildConvergeIr = (stateSchema, entries) => {
   for (const entry of writers) {
     writerByPath.set(entry.fieldPath, entry);
   }
-  const topo = writers.length > 0 ? computeConvergeTopoOrder(writers) : { order: [] };
+  const topo = multipleWritersError ? { order: [] } : writers.length > 0 ? computeConvergeTopoOrder(writers) : { order: [] };
   const stepsById = topo.configError ? [] : topo.order.map((path) => writerByPath.get(path));
   const fieldPathTable = /* @__PURE__ */ new Map();
   const addPath = (path) => {
@@ -511,6 +421,11 @@ var buildConvergeIr = (stateSchema, entries) => {
   const fieldPaths = Array.from(fieldPathTable.values()).sort(compareFieldPath);
   const fieldPathIdRegistry = makeFieldPathIdRegistry(fieldPaths);
   const fieldPathsKey = fnv1a32(stableStringify(fieldPaths));
+  const staticIrDigest = getConvergeStaticIrDigest({
+    writersKey,
+    depsKey,
+    fieldPathsKey
+  });
   const stepOutFieldPathIdByStepId = [];
   const stepDepsFieldPathIdsByStepId = [];
   const stepSchedulingByStepId = [];
@@ -538,9 +453,10 @@ var buildConvergeIr = (stateSchema, entries) => {
     writersKey,
     depsKey,
     fieldPathsKey,
+    staticIrDigest,
     fieldPaths,
     fieldPathIdRegistry,
-    ...topo.configError ? { configError: topo.configError } : null,
+    ...multipleWritersError ? { configError: multipleWritersError } : topo.configError ? { configError: topo.configError } : null,
     stepsById,
     stepOutFieldPathIdByStepId,
     stepDepsFieldPathIdsByStepId,
@@ -696,6 +612,12 @@ var buildGraph = (entries, nodeMetaByFieldPath) => {
           });
         }
       }
+    } else if (entry.kind === "externalStore") {
+      planSteps.push({
+        id: `external-store:${fieldPath}`,
+        kind: "external-store-sync",
+        targetFieldPath: fieldPath
+      });
     } else if (entry.kind === "check") {
       planSteps.push({
         id: `check:${fieldPath}`,
@@ -836,7 +758,7 @@ var collectSchemaPaths = (entries) => {
       }
     }
   }
-  return Array.from(byKey.entries()).sort((a, b) => a[0].localeCompare(b[0])).map(([, v]) => v);
+  return Array.from(byKey.entries()).sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0).map(([, v]) => v);
 };
 var build = (stateSchema, spec) => {
   const entries = normalizeSpec(spec);
@@ -888,8 +810,8 @@ var build = (stateSchema, spec) => {
   };
 };
 
-// src/internal/state-trait/source.ts
-import { Effect, Fiber, FiberRef, Option } from "effect";
+// src/internal/state-trait/source.impl.ts
+import { Effect, Fiber, Option } from "effect";
 import { create } from "mutative";
 
 // src/internal/state-trait/deps-trace.ts
@@ -1037,7 +959,7 @@ var trace = (fn, state) => {
   };
 };
 
-// src/internal/state-trait/source.ts
+// src/internal/state-trait/source.impl.ts
 var onceInRunSession = (key) => Effect.serviceOption(RunSessionTag).pipe(
   Effect.map((maybe) => Option.isSome(maybe) ? maybe.value.local.once(key) : true)
 );
@@ -1061,7 +983,9 @@ var emitDepsMismatch = (params) => Effect.gen(function* () {
     kind: `deps_mismatch:${params.kind}`
   });
 });
-var getMiddlewareStack = () => Effect.serviceOption(EffectOpMiddlewareTag).pipe(
+var getMiddlewareStack = () => Effect.serviceOption(
+  EffectOpMiddlewareTag
+).pipe(
   Effect.map((maybe) => Option.isSome(maybe) ? maybe.value.stack : [])
 );
 var recordTraitPatch = (bound, path, reason, from, to, traitNodeId) => {
@@ -1313,7 +1237,7 @@ var installSourceRefresh = (bound, step, entry) => {
       }
       const io = Effect.gen(function* () {
         if (replayMode === "replay" && replayLog) {
-          yield* Effect.yieldNow();
+          yield* Effect.yieldNow;
           const consumePath = wroteLoadingPath ?? logFieldPath;
           if (!consumePath) return yield* Effect.void;
           const replayed = yield* replayLog.consumeNextResourceSnapshot({
@@ -1344,7 +1268,9 @@ var installSourceRefresh = (bound, step, entry) => {
           return yield* Effect.void;
         }
         const stack = yield* getMiddlewareStack();
-        const registryOpt = yield* Effect.serviceOption(internal.ResourceRegistryTag);
+        const registryOpt = yield* Effect.serviceOption(
+          internal.ResourceRegistryTag
+        );
         const registry = Option.isSome(registryOpt) ? registryOpt.value : void 0;
         const spec = registry?.specs.get(resourceId);
         if (!spec) {
@@ -1425,47 +1351,40 @@ var installSourceRefresh = (bound, step, entry) => {
             });
           }
         }
-      }).pipe(Effect.catchAllCause(() => Effect.void));
-      const fiber = yield* Effect.forkScoped(Effect.locally(inSyncTransactionFiber, false)(io));
+      }).pipe(Effect.catchCause(() => Effect.void));
+      const fiber = yield* Effect.forkScoped(Effect.provideService(io, inSyncTransactionFiber, false));
       const myGen = gen2 += 1;
       inFlight2.set(rowId, { gen: myGen, fiber, keyHash: keyHash2 });
       yield* Effect.forkScoped(
-        Effect.locally(
-          inSyncTransactionFiber,
-          false
-        )(
-          Fiber.await(fiber).pipe(
-            Effect.zipRight(
-              Effect.sync(() => {
-                const current = inFlight2.get(rowId);
-                if (current && current.gen === myGen) {
-                  inFlight2.delete(rowId);
-                }
-              })
-            ),
-            Effect.zipRight(
-              mode2 === "exhaust-trailing" ? Effect.gen(function* () {
-                const next = trailing2.get(rowId);
-                trailing2.delete(rowId);
-                if (next) {
-                  yield* startFetch2(rowId, next.key, next.keyHash, replayMode, replayLog);
-                }
-              }) : Effect.void
-            ),
-            Effect.catchAllCause(() => Effect.void)
-          )
-        )
+        Effect.provideService(Fiber.await(fiber).pipe(
+          Effect.flatMap(() => Effect.sync(() => {
+            const current = inFlight2.get(rowId);
+            if (current && current.gen === myGen) {
+              inFlight2.delete(rowId);
+            }
+          })),
+          Effect.flatMap(() => mode2 === "exhaust-trailing" ? Effect.gen(function* () {
+            const next = trailing2.get(rowId);
+            trailing2.delete(rowId);
+            if (next) {
+              yield* startFetch2(rowId, next.key, next.keyHash, replayMode, replayLog);
+            }
+          }) : Effect.void),
+          Effect.catchCause(() => Effect.void)
+        ), inSyncTransactionFiber, false)
       );
     });
     register(
       fieldPath,
       (state) => Effect.gen(function* () {
         const { moduleId, instanceId } = getBoundScope(bound);
-        const replayModeOpt = yield* Effect.serviceOption(ReplayModeConfigTag);
+        const replayModeOpt = yield* Effect.serviceOption(
+          ReplayModeConfigTag
+        );
         const replayMode = Option.isSome(replayModeOpt) ? replayModeOpt.value.mode : "live";
         const replayLogOpt = yield* Effect.serviceOption(ReplayLog);
         const replayLog = Option.isSome(replayLogOpt) ? replayLogOpt.value : void 0;
-        const force = yield* FiberRef.get(forceSourceRefresh);
+        const force = yield* Effect.service(forceSourceRefresh).pipe(Effect.orDie);
         const listValue = getAtPath(state, listPath);
         const items = Array.isArray(listValue) ? listValue : [];
         const ids = store.ensureList(listPath, items);
@@ -1623,7 +1542,7 @@ var installSourceRefresh = (bound, step, entry) => {
     }
     const io = Effect.gen(function* () {
       if (replayMode === "replay" && replayLog) {
-        yield* Effect.yieldNow();
+        yield* Effect.yieldNow;
         const replayed = yield* replayLog.consumeNextResourceSnapshot({
           resourceId,
           fieldPath,
@@ -1766,46 +1685,39 @@ var installSourceRefresh = (bound, step, entry) => {
           yield* recordSnapshot(replayMode, replayLog, event);
         }
       }
-    }).pipe(Effect.catchAllCause(() => Effect.void));
-    const fiber = yield* Effect.forkScoped(Effect.locally(inSyncTransactionFiber, false)(io));
+    }).pipe(Effect.catchCause(() => Effect.void));
+    const fiber = yield* Effect.forkScoped(Effect.provideService(io, inSyncTransactionFiber, false));
     const myGen = gen += 1;
     inFlight = { gen: myGen, fiber, keyHash: keyHash2 };
     yield* Effect.forkScoped(
-      Effect.locally(
-        inSyncTransactionFiber,
-        false
-      )(
-        Fiber.await(fiber).pipe(
-          Effect.zipRight(
-            Effect.sync(() => {
-              if (inFlight && inFlight.gen === myGen) {
-                inFlight = void 0;
-              }
-            })
-          ),
-          Effect.zipRight(
-            mode === "exhaust-trailing" ? Effect.gen(function* () {
-              const next = trailing;
-              trailing = void 0;
-              if (next) {
-                yield* startFetch(next.key, next.keyHash, replayMode, replayLog);
-              }
-            }) : Effect.void
-          ),
-          Effect.catchAllCause(() => Effect.void)
-        )
-      )
+      Effect.provideService(Fiber.await(fiber).pipe(
+        Effect.flatMap(() => Effect.sync(() => {
+          if (inFlight && inFlight.gen === myGen) {
+            inFlight = void 0;
+          }
+        })),
+        Effect.flatMap(() => mode === "exhaust-trailing" ? Effect.gen(function* () {
+          const next = trailing;
+          trailing = void 0;
+          if (next) {
+            yield* startFetch(next.key, next.keyHash, replayMode, replayLog);
+          }
+        }) : Effect.void),
+        Effect.catchCause(() => Effect.void)
+      ), inSyncTransactionFiber, false)
     );
   });
   register(
     fieldPath,
     (state) => Effect.gen(function* () {
       const { moduleId, instanceId } = getBoundScope(bound);
-      const replayModeOpt = yield* Effect.serviceOption(ReplayModeConfigTag);
+      const replayModeOpt = yield* Effect.serviceOption(
+        ReplayModeConfigTag
+      );
       const replayMode = Option.isSome(replayModeOpt) ? replayModeOpt.value.mode : "live";
       const replayLogOpt = yield* Effect.serviceOption(ReplayLog);
       const replayLog = Option.isSome(replayLogOpt) ? replayLogOpt.value : void 0;
-      const force = yield* FiberRef.get(forceSourceRefresh);
+      const force = yield* Effect.service(forceSourceRefresh).pipe(Effect.orDie);
       let key;
       try {
         key = entry.meta.key(state);
@@ -1831,7 +1743,7 @@ var installSourceRefresh = (bound, step, entry) => {
       }
       if (key === void 0) {
         if (inFlight) {
-          yield* Fiber.interruptFork(inFlight.fiber);
+          yield* Fiber.interrupt(inFlight.fiber);
           inFlight = void 0;
         }
         trailing = void 0;
@@ -1904,7 +1816,7 @@ var installSourceRefresh = (bound, step, entry) => {
         return;
       }
       if (mode === "switch" && inFlight) {
-        yield* Fiber.interruptFork(inFlight.fiber);
+        yield* Fiber.interrupt(inFlight.fiber);
         inFlight = void 0;
         trailing = void 0;
       }
@@ -1914,11 +1826,155 @@ var installSourceRefresh = (bound, step, entry) => {
   return Effect.void;
 };
 
+// src/internal/state-trait/converge-diagnostics.ts
+import { Effect as Effect2, Option as Option2 } from "effect";
+import * as SchemaAST2 from "effect/SchemaAST";
+var onceKeysFallback = /* @__PURE__ */ new Set();
+var onceInRunSession2 = (key) => Effect2.serviceOption(RunSessionTag).pipe(
+  Effect2.map((maybe) => {
+    if (Option2.isSome(maybe)) {
+      return maybe.value.local.once(key);
+    }
+    if (onceKeysFallback.has(key)) return false;
+    onceKeysFallback.add(key);
+    return true;
+  })
+);
+var formatList2 = (items, limit = 10) => {
+  if (items.length === 0) return "";
+  if (items.length <= limit) return items.join(", ");
+  return `${items.slice(0, limit).join(", ")}, \u2026(+${items.length - limit})`;
+};
+var emitDepsMismatch2 = (params) => {
+  return Effect2.gen(function* () {
+    const key = `${params.moduleId ?? "unknown"}::${params.instanceId ?? "unknown"}::${params.kind}::${params.fieldPath}`;
+    const shouldEmit = yield* onceInRunSession2(`deps_mismatch:${key}`);
+    if (!shouldEmit) return;
+    yield* record({
+      type: "diagnostic",
+      moduleId: params.moduleId,
+      instanceId: params.instanceId,
+      code: "state_trait::deps_mismatch",
+      severity: "warning",
+      message: `[deps] ${params.kind} "${params.fieldPath}" declared=[${formatList2(params.diff.declared)}] reads=[${formatList2(params.diff.reads)}] missing=[${formatList2(params.diff.missing)}] unused=[${formatList2(params.diff.unused)}]`,
+      hint: 'deps is the single source of truth for dependencies: incremental scheduling / reverse closures / performance optimizations rely on deps only. Keep deps consistent with actual reads; if you really depend on the whole object, declare a coarser-grained dep (e.g. "profile") to cover sub-field reads.',
+      kind: `deps_mismatch:${params.kind}`
+    });
+  });
+};
+var schemaHasPath = (ast, segments, seen = /* @__PURE__ */ new Set()) => {
+  if (segments.length === 0) return true;
+  let current = SchemaAST2.toType(ast);
+  while (SchemaAST2.isSuspend(current)) {
+    if (seen.has(current)) {
+      return true;
+    }
+    seen.add(current);
+    current = SchemaAST2.toType(current.thunk());
+  }
+  if (SchemaAST2.isUnion(current)) {
+    return current.types.some((t) => schemaHasPath(t, segments, seen));
+  }
+  if (SchemaAST2.isArrays(current)) {
+    const candidates = [];
+    for (const e of current.elements) candidates.push(e);
+    for (const r of current.rest) candidates.push(r);
+    if (candidates.length === 0) return true;
+    return candidates.some((t) => schemaHasPath(t, segments, seen));
+  }
+  if (SchemaAST2.isObjects(current)) {
+    const [head, ...tail] = segments;
+    for (const ps of current.propertySignatures) {
+      if (String(ps.name) !== head) continue;
+      return schemaHasPath(ps.type, tail, seen);
+    }
+    for (const sig of current.indexSignatures) {
+      const param = SchemaAST2.toType(sig.parameter);
+      const tag2 = param?._tag;
+      if (tag2 === "String" || tag2 === "TemplateLiteral") {
+        return schemaHasPath(sig.type, tail, seen);
+      }
+    }
+    return false;
+  }
+  const tag = current?._tag;
+  if (tag === "AnyKeyword" || tag === "UnknownKeyword" || tag === "ObjectKeyword" || tag === "Declaration") {
+    return true;
+  }
+  return false;
+};
+var schemaHasFieldPath = (stateSchemaAst, path) => {
+  if (!path) return true;
+  if (path === "$root") return true;
+  const normalized = normalizeFieldPath(path);
+  if (!normalized) return false;
+  const segs = normalized[0] === "$root" ? normalized.slice(1) : normalized;
+  return schemaHasPath(stateSchemaAst, segs);
+};
+var formatSchemaMismatchLine = (ref) => {
+  if (ref.kind === "fieldPath") {
+    return `- ${ref.entryKind} "${ref.entryFieldPath}" fieldPath="${ref.path}"`;
+  }
+  if (ref.kind === "dep") {
+    const rule = ref.ruleName ? ` rule="${ref.ruleName}"` : "";
+    return `- ${ref.entryKind} "${ref.entryFieldPath}" deps="${ref.path}"${rule}`;
+  }
+  if (ref.kind === "link_from") {
+    return `- link "${ref.entryFieldPath}" from="${ref.path}"`;
+  }
+  if (ref.kind === "check_writeback") {
+    return `- check "${ref.entryFieldPath}" writeback="${ref.path}"`;
+  }
+  return `- ${ref.entryKind} "${ref.entryFieldPath}" path="${ref.path}"`;
+};
+var emitSchemaMismatch = (program, ctx) => Effect2.gen(function* () {
+  if (!isDevEnv()) return;
+  const level = yield* Effect2.service(currentDiagnosticsLevel).pipe(Effect2.orDie);
+  if (level === "off") return;
+  const key = `${ctx.moduleId ?? "unknown"}::${ctx.instanceId}`;
+  const shouldEmit = yield* onceInRunSession2(`schema_mismatch:${key}`);
+  if (!shouldEmit) return;
+  const refs = program.schemaPaths ?? [];
+  if (refs.length === 0) return;
+  const stateSchemaAst = program.stateSchema.ast;
+  const mismatches = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const ref of refs) {
+    if (schemaHasFieldPath(stateSchemaAst, ref.path)) continue;
+    const k = `${ref.kind}|${ref.entryKind}|${ref.entryFieldPath}|${ref.ruleName ?? ""}|${ref.path}`;
+    if (seen.has(k)) continue;
+    seen.add(k);
+    mismatches.push(ref);
+  }
+  if (mismatches.length === 0) return;
+  const limit = level === "light" ? 8 : 24;
+  const lines = mismatches.slice(0, limit).map(formatSchemaMismatchLine);
+  if (mismatches.length > limit) {
+    lines.push(`- \u2026(+${mismatches.length - limit})`);
+  }
+  yield* record({
+    type: "diagnostic",
+    moduleId: ctx.moduleId,
+    instanceId: ctx.instanceId,
+    code: "state_trait::schema_mismatch",
+    severity: "warning",
+    message: `[schema] The following paths are not declared in stateSchema (total ${mismatches.length}):
+${lines.join("\n")}`,
+    hint: "StateTrait writeback will create missing objects/fields. Declare all fieldPath/deps/link.from and errors.* writeback paths in stateSchema, or fix typos in trait paths.",
+    kind: "schema_mismatch"
+  });
+});
+
 export {
+  getConvergeStaticIrDigest,
+  exportConvergeStaticIr,
+  onceInRunSession2 as onceInRunSession,
+  emitDepsMismatch2 as emitDepsMismatch,
+  emitSchemaMismatch,
   diffDeps,
   trace,
   syncIdleInTransaction,
   installSourceRefresh,
   build
 };
-//# sourceMappingURL=chunk-PYOE4VSI.js.map
+//# sourceMappingURL=chunk-IVXSVHO4.js.map