@logixjs/core 0.0.1 → 0.0.2

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

@@ -4,186 +4,51 @@ import {
   parseListItemFieldPath,
   setAtPathMutating,
   toListItemValuePath
-} from "./chunk-BABLDP24.js";
+} from "./chunk-KSZQYSEH.js";
 import {
   Snapshot,
   internal,
   keyHash
-} from "./chunk-NZJKFF45.js";
+} from "./chunk-C2UZZQ76.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-ZTFTABXV.js";
 import {
   getBoundInternals
-} from "./chunk-3RMKLXHX.js";
+} from "./chunk-KLDVG3SY.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-AQ7L2QZ5.js";
 import {
   RunSessionTag,
   make,
   run
-} from "./chunk-OFADUJWJ.js";
+} from "./chunk-I4LCE5OY.js";
+import {
+  currentDiagnosticsLevel,
+  record
+} from "./chunk-ZC7MSQ5U.js";
 import {
   EffectOpMiddlewareTag
-} from "./chunk-JWOYLO27.js";
+} from "./chunk-WYJUJV4L.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 : "");
@@ -348,6 +222,32 @@ var collectNodeMeta = (spec) => {
 
 // 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 ?? [];
@@ -476,6 +376,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 +388,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) => {
@@ -540,7 +441,7 @@ var buildConvergeIr = (stateSchema, entries) => {
     fieldPathsKey,
     fieldPaths,
     fieldPathIdRegistry,
-    ...topo.configError ? { configError: topo.configError } : null,
+    ...multipleWritersError ? { configError: multipleWritersError } : topo.configError ? { configError: topo.configError } : null,
     stepsById,
     stepOutFieldPathIdByStepId,
     stepDepsFieldPathIdsByStepId,
@@ -696,6 +597,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 +743,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,7 +795,7 @@ var build = (stateSchema, spec) => {
   };
 };
 
-// src/internal/state-trait/source.ts
+// src/internal/state-trait/source.impl.ts
 import { Effect, Fiber, FiberRef, Option } from "effect";
 import { create } from "mutative";
 
@@ -1037,7 +944,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)
 );
@@ -1914,11 +1821,167 @@ var installSourceRefresh = (bound, step, entry) => {
   return Effect.void;
 };
 
+// src/internal/state-trait/converge-diagnostics.ts
+import { Effect as Effect2, FiberRef as FiberRef2, 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 = ast;
+  while (true) {
+    if (SchemaAST2.isSuspend(current)) {
+      if (seen.has(current)) {
+        return true;
+      }
+      seen.add(current);
+      current = current.f();
+      continue;
+    }
+    if (SchemaAST2.isRefinement(current)) {
+      current = current.from;
+      continue;
+    }
+    break;
+  }
+  if (SchemaAST2.isTransformation(current)) {
+    return schemaHasPath(current.to, segments, seen) || schemaHasPath(current.from, segments, seen);
+  }
+  if (SchemaAST2.isUnion(current)) {
+    return current.types.some((t) => schemaHasPath(t, segments, seen));
+  }
+  if (SchemaAST2.isTupleType(current)) {
+    const candidates = [];
+    for (const e of current.elements) candidates.push(e.type);
+    for (const r of current.rest) candidates.push(r.type);
+    if (candidates.length === 0) return true;
+    return candidates.some((t) => schemaHasPath(t, segments, seen));
+  }
+  if (SchemaAST2.isTypeLiteral(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) {
+      let param = sig.parameter;
+      while (SchemaAST2.isRefinement(param)) {
+        param = param.from;
+      }
+      const tag2 = param?._tag;
+      if (tag2 === "StringKeyword" || 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* FiberRef2.get(currentDiagnosticsLevel);
+  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 {
+  onceInRunSession2 as onceInRunSession,
+  emitDepsMismatch2 as emitDepsMismatch,
+  emitSchemaMismatch,
   diffDeps,
   trace,
   syncIdleInTransaction,
   installSourceRefresh,
   build
 };
-//# sourceMappingURL=chunk-PYOE4VSI.js.map
+//# sourceMappingURL=chunk-JBKYRTCS.js.map