@logixjs/core 0.0.1 → 1.0.0

package/dist/chunk-GWSM4KLB.js

@@ -0,0 +1,763 @@
+import {
+  build,
+  installSourceRefresh,
+  onceInRunSession
+} from "./chunk-IVXSVHO4.js";
+import {
+  getAtPath,
+  setAtPathMutating
+} from "./chunk-EPQFNJU3.js";
+import {
+  exportStaticIr
+} from "./chunk-HJM5Y5NU.js";
+import {
+  sanitizeWithReport
+} from "./chunk-J3CWXIPV.js";
+import {
+  normalizeFieldPath
+} from "./chunk-SOOBFXRR.js";
+import {
+  getBoundInternals
+} from "./chunk-63ZQ5RIN.js";
+import {
+  DeclarativeLinkRuntimeTag,
+  inSyncTransactionFiber,
+  isDevEnv
+} from "./chunk-S4S5N4BJ.js";
+import {
+  getExternalStoreDescriptor
+} from "./chunk-NZMWWDAY.js";
+import {
+  currentDiagnosticsLevel,
+  record
+} from "./chunk-V2SBGVDO.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/StateTrait.ts
+var StateTrait_exports = {};
+__export(StateTrait_exports, {
+  $root: () => $root,
+  build: () => build2,
+  computed: () => computed,
+  exportStaticIr: () => exportStaticIr2,
+  externalStore: () => externalStore,
+  from: () => from,
+  install: () => install2,
+  link: () => link,
+  list: () => list,
+  node: () => node,
+  source: () => source
+});
+
+// src/internal/state-trait/install.ts
+import { Effect as Effect3 } from "effect";
+
+// src/internal/state-trait/external-store.ts
+import { Effect, Fiber, Option, ServiceMap, Stream } from "effect";
+import { create } from "mutative";
+var isFn = (value) => typeof value === "function";
+var writebackCoordinatorByInternals = /* @__PURE__ */ new WeakMap();
+var getOrCreateExternalStoreWritebackCoordinator = (args) => Effect.gen(function* () {
+  const cached = writebackCoordinatorByInternals.get(args.internals);
+  if (cached) return cached;
+  let closed = false;
+  let inFlight = false;
+  let pendingWrites = /* @__PURE__ */ new Map();
+  const drainPendingWrites = () => {
+    if (pendingWrites.size === 0) return [];
+    const drained = pendingWrites;
+    pendingWrites = /* @__PURE__ */ new Map();
+    return Array.from(drained.values());
+  };
+  const applyWritebackBatch = (batch) => Effect.gen(function* () {
+    if (batch.length === 0) return;
+    if (batch.length === 1) {
+      const req = batch[0];
+      const prevState2 = yield* args.bound.state.read;
+      const prevValue = getAtPath(prevState2, req.fieldPath);
+      if (req.isEqual(prevValue, req.nextValue)) return;
+      const nextDraft2 = create(prevState2, (draft) => {
+        setAtPathMutating(draft, req.fieldPath, req.nextValue);
+      });
+      args.internals.txn.recordStatePatch(
+        req.normalizedPatchPath,
+        "trait-external-store",
+        prevValue,
+        req.nextValue,
+        req.traitNodeId
+      );
+      args.internals.txn.updateDraft(nextDraft2);
+      return;
+    }
+    const prevState = yield* args.bound.state.read;
+    const changes = [];
+    for (let i = 0; i < batch.length; i++) {
+      const req = batch[i];
+      const prevValue = getAtPath(prevState, req.fieldPath);
+      if (req.isEqual(prevValue, req.nextValue)) continue;
+      changes.push({ request: req, prevValue });
+    }
+    if (changes.length === 0) return;
+    const nextDraft = create(prevState, (draft) => {
+      for (let i = 0; i < changes.length; i++) {
+        const { request } = changes[i];
+        setAtPathMutating(draft, request.fieldPath, request.nextValue);
+      }
+    });
+    for (let i = 0; i < changes.length; i++) {
+      const { request, prevValue } = changes[i];
+      args.internals.txn.recordStatePatch(
+        request.normalizedPatchPath,
+        "trait-external-store",
+        prevValue,
+        request.nextValue,
+        request.traitNodeId
+      );
+    }
+    args.internals.txn.updateDraft(nextDraft);
+  });
+  const coordinator = {
+    enqueue: (request) => Effect.gen(function* () {
+      if (closed) return;
+      pendingWrites.set(request.fieldPath, request);
+      if (inFlight) return;
+      inFlight = true;
+      try {
+        while (true) {
+          const batch = drainPendingWrites();
+          if (batch.length === 0) return;
+          const commitPriority = batch.some((x) => x.commitPriority === "normal") ? "normal" : "low";
+          const originName = batch.length === 1 ? batch[0].fieldPath : "externalStore:batched";
+          yield* args.internals.txn.runWithStateTransaction(
+            {
+              kind: "trait-external-store",
+              name: originName,
+              details: {
+                stateCommit: {
+                  priority: commitPriority
+                }
+              }
+            },
+            () => applyWritebackBatch(batch).pipe(Effect.asVoid)
+          ).pipe(Effect.provide(args.env));
+        }
+      } finally {
+        inFlight = false;
+      }
+    })
+  };
+  writebackCoordinatorByInternals.set(args.internals, coordinator);
+  yield* Effect.addFinalizer(
+    () => Effect.sync(() => {
+      closed = true;
+      pendingWrites.clear();
+    })
+  );
+  return coordinator;
+});
+var resolveStore = (entry) => Effect.gen(function* () {
+  const store = entry.meta?.store;
+  const descriptor = getExternalStoreDescriptor(store);
+  if (descriptor?.kind === "service") {
+    const service = yield* Effect.service(descriptor.tag).pipe(Effect.orDie);
+    return descriptor.map(service);
+  }
+  return store;
+});
+var installExternalStoreSync = (bound, step, entry) => Effect.gen(function* () {
+  const fieldPath = step.targetFieldPath;
+  if (!fieldPath) return;
+  const env = yield* Effect.services();
+  let internals;
+  try {
+    internals = getBoundInternals(bound);
+  } catch {
+    return;
+  }
+  const select = entry.meta?.select;
+  const equals = entry.meta?.equals;
+  const computeValue = (snapshot) => isFn(select) ? select(snapshot) : snapshot;
+  const isEqual = (a, b) => isFn(equals) ? equals(a, b) : Object.is(a, b);
+  const traitLane = entry.meta?.priority;
+  const rawStore = entry.meta?.store;
+  const rawDescriptor = getExternalStoreDescriptor(rawStore);
+  const makeScopedDescriptorStore = () => Effect.gen(function* () {
+    if (rawDescriptor?.kind === "subscriptionRef") {
+      let current = yield* Effect.provideService(rawDescriptor.ref.get, inSyncTransactionFiber, false);
+      const listeners = /* @__PURE__ */ new Set();
+      const notify = () => {
+        for (const listener of listeners) {
+          listener();
+        }
+      };
+      const fiber2 = yield* Effect.forkDetach(
+        Effect.provideService(Stream.runForEach(
+          rawDescriptor.ref.changes,
+          (value) => Effect.sync(() => {
+            current = value;
+            notify();
+          })
+        ).pipe(Effect.catchCause(() => Effect.void)), inSyncTransactionFiber, false),
+        { startImmediately: true }
+      );
+      internals.lifecycle.registerDestroy(Fiber.interrupt(fiber2).pipe(Effect.asVoid), { name: `externalStore:${fieldPath}:subscriptionRef` });
+      return {
+        getSnapshot: () => current,
+        subscribe: (listener) => {
+          listeners.add(listener);
+          return () => {
+            listeners.delete(listener);
+          };
+        }
+      };
+    }
+    if (rawDescriptor?.kind === "stream") {
+      let current = rawDescriptor.initial;
+      const listeners = /* @__PURE__ */ new Set();
+      const notify = () => {
+        for (const listener of listeners) {
+          listener();
+        }
+      };
+      const fiber2 = yield* Effect.forkDetach(
+        Effect.provideService(Stream.runForEach(
+          rawDescriptor.stream,
+          (value) => Effect.sync(() => {
+            current = value;
+            notify();
+          })
+        ).pipe(Effect.catchCause(() => Effect.void)), inSyncTransactionFiber, false),
+        { startImmediately: true }
+      );
+      internals.lifecycle.registerDestroy(Fiber.interrupt(fiber2).pipe(Effect.asVoid), { name: `externalStore:${fieldPath}:stream` });
+      return {
+        getSnapshot: () => current,
+        subscribe: (listener) => {
+          listeners.add(listener);
+          return () => {
+            listeners.delete(listener);
+          };
+        }
+      };
+    }
+    return void 0;
+  });
+  if (rawDescriptor?.kind === "module") {
+    const linkRuntimeOpt = yield* Effect.serviceOption(
+      DeclarativeLinkRuntimeTag
+    );
+    if (Option.isNone(linkRuntimeOpt)) {
+      return yield* Effect.die(new Error("[StateTrait.externalStore] Missing DeclarativeLinkRuntime service (073)."));
+    }
+    const module = rawDescriptor.module;
+    const sourceRuntime = (() => {
+      if (module && typeof module === "object") {
+        const moduleId = module.moduleId;
+        const instanceId = module.instanceId;
+        const getState = module.getState;
+        if (typeof moduleId === "string" && moduleId.length > 0 && typeof instanceId === "string" && instanceId.length > 0 && getState) {
+          return module;
+        }
+        const tag = module.tag;
+        if (tag && ServiceMap.isKey(tag)) {
+          return internals.imports.get(tag);
+        }
+        if (ServiceMap.isKey(module)) {
+          return internals.imports.get(module);
+        }
+      }
+      return void 0;
+    })();
+    if (!sourceRuntime) {
+      return yield* Effect.die(new Error(`[StateTrait.externalStore] Module-as-Source store is unresolved for "${fieldPath}". Fix: include the source ModuleTag in module imports (moduleId=${rawDescriptor.moduleId}).`));
+    }
+    if (rawDescriptor.instanceId && rawDescriptor.instanceId !== sourceRuntime.instanceId) {
+      return yield* Effect.die(new Error(`[StateTrait.externalStore] Module-as-Source instanceId mismatch for "${fieldPath}". descriptor.instanceId=${rawDescriptor.instanceId}, resolved.instanceId=${sourceRuntime.instanceId}`));
+    }
+    if (sourceRuntime.moduleId !== rawDescriptor.moduleId) {
+      return yield* Effect.die(new Error(`[StateTrait.externalStore] Module-as-Source moduleId mismatch for "${fieldPath}". descriptor.moduleId=${rawDescriptor.moduleId}, resolved.moduleId=${sourceRuntime.moduleId}`));
+    }
+    const staticIr = rawDescriptor.readQuery.staticIr;
+    const isRecognizableStatic = staticIr.lane === "static" && staticIr.readsDigest != null && staticIr.fallbackReason == null;
+    if (!isRecognizableStatic) {
+      yield* record({
+        type: "diagnostic",
+        moduleId: internals.moduleId,
+        instanceId: internals.instanceId,
+        code: "external_store::module_source_degraded",
+        severity: "warning",
+        message: "[StateTrait.externalStore] Module-as-Source selector is not fully IR-recognizable; falling back to module-topic edge (may reduce perf).",
+        hint: "Fix: provide a static ReadQuery (ReadQuery.make) or annotate selector.fieldPaths to get a stable readsDigest; avoid dynamic lane.",
+        kind: "module_as_source_degraded",
+        trigger: {
+          kind: "trait",
+          name: "externalStore.moduleSource",
+          details: {
+            sourceModuleId: rawDescriptor.moduleId,
+            selectorId: staticIr.selectorId,
+            lane: staticIr.lane,
+            fallbackReason: staticIr.fallbackReason,
+            readsDigest: staticIr.readsDigest
+          }
+        }
+      });
+    }
+    const moduleInstanceKey = `${sourceRuntime.moduleId}::${sourceRuntime.instanceId}`;
+    const writeValue = (nextValue) => Effect.gen(function* () {
+      const inTxn = yield* Effect.service(inSyncTransactionFiber).pipe(Effect.orDie);
+      const body = Effect.gen(function* () {
+        const prevState = yield* bound.state.read;
+        const prevValue = getAtPath(prevState, fieldPath);
+        if (isEqual(prevValue, nextValue)) {
+          return;
+        }
+        const nextDraft = create(prevState, (draft) => {
+          setAtPathMutating(draft, fieldPath, nextValue);
+        });
+        const normalized = normalizeFieldPath(fieldPath) ?? [];
+        internals.txn.recordStatePatch(normalized, "trait-external-store", prevValue, nextValue, step.id);
+        internals.txn.updateDraft(nextDraft);
+      });
+      if (inTxn) {
+        return yield* body;
+      }
+      const stateCommitPriority = traitLane === "nonUrgent" ? "low" : "normal";
+      return yield* internals.txn.runWithStateTransaction(
+        {
+          kind: "trait-external-store",
+          name: fieldPath,
+          details: {
+            stateCommit: {
+              priority: stateCommitPriority
+            }
+          }
+        },
+        () => body.pipe(Effect.asVoid)
+      );
+    }).pipe(Effect.provideServices(env));
+    const unregister = linkRuntimeOpt.value.registerModuleAsSourceLink({
+      id: `${internals.instanceId}::externalStore:${step.id}`,
+      sourceModuleInstanceKey: moduleInstanceKey,
+      readQuery: rawDescriptor.readQuery,
+      computeValue,
+      equalsValue: isEqual,
+      applyValue: writeValue
+    });
+    yield* Effect.addFinalizer(
+      () => Effect.sync(() => {
+        unregister();
+      })
+    );
+    const initialState = yield* sourceRuntime.getState;
+    const initialSelected = rawDescriptor.readQuery.select(initialState);
+    yield* writeValue(computeValue(initialSelected));
+    return;
+  }
+  const scopedDescriptorStore = yield* makeScopedDescriptorStore();
+  const store = scopedDescriptorStore ?? (rawDescriptor?.kind === "service" ? yield* resolveStore(entry) : rawStore);
+  if (!store || typeof store !== "object") {
+    return yield* Effect.die(new Error(`[StateTrait.externalStore] Invalid store for "${fieldPath}". Expected { getSnapshot, subscribe }.`));
+  }
+  if (!isFn(store.getSnapshot) || !isFn(store.subscribe)) {
+    return yield* Effect.die(new Error(`[StateTrait.externalStore] Invalid store for "${fieldPath}". Expected { getSnapshot, subscribe }.`));
+  }
+  let fused = false;
+  let fuseCause;
+  let fuseRecorded = false;
+  let pending = false;
+  let resume;
+  const recordFuseDiagnostic = Effect.gen(function* () {
+    if (fuseRecorded) return;
+    fuseRecorded = true;
+    const errorMessage = (() => {
+      if (fuseCause instanceof Error) return fuseCause.message;
+      if (typeof fuseCause === "string") return fuseCause;
+      return "unknown";
+    })();
+    yield* record({
+      type: "diagnostic",
+      moduleId: internals.moduleId,
+      instanceId: internals.instanceId,
+      code: "external_store::snapshot_threw",
+      severity: "warning",
+      message: `[StateTrait.externalStore] store.getSnapshot() threw; trait is fused and will stop syncing for "${fieldPath}".`,
+      hint: "Fix: ensure getSnapshot is synchronous and non-throwing; async resources should use StateTrait.source or ExternalStore.fromStream({ current/initial }).",
+      kind: "external_store_fused:get_snapshot",
+      trigger: {
+        kind: "trait",
+        name: "externalStore.getSnapshot",
+        details: {
+          fieldPath,
+          traitId: step.id,
+          storeKind: rawDescriptor?.kind ?? "raw",
+          error: errorMessage
+        }
+      }
+    });
+  });
+  const signal = () => {
+    if (fused) return;
+    if (resume) {
+      const r = resume;
+      pending = false;
+      r();
+      return;
+    }
+    pending = true;
+  };
+  const awaitSignal = () => {
+    if (pending) {
+      pending = false;
+      return Effect.void;
+    }
+    return Effect.promise(
+      (signal2) => new Promise((resolve) => {
+        let done = false;
+        const r = () => {
+          if (done) return;
+          done = true;
+          resume = void 0;
+          resolve();
+        };
+        resume = r;
+        signal2.addEventListener(
+          "abort",
+          () => {
+            if (resume === r) {
+              resume = void 0;
+            }
+          },
+          { once: true }
+        );
+      })
+    );
+  };
+  const getSnapshotOrFuse = () => {
+    try {
+      return store.getSnapshot();
+    } catch (err) {
+      fused = true;
+      fuseCause = err;
+      return void 0;
+    }
+  };
+  const readSnapshotOrFuse = Effect.provideService(Effect.sync(getSnapshotOrFuse), inSyncTransactionFiber, false);
+  const before = yield* readSnapshotOrFuse;
+  if (fused) {
+    yield* recordFuseDiagnostic;
+    return;
+  }
+  const unsubscribe = store.subscribe(signal);
+  yield* Effect.addFinalizer(
+    () => Effect.sync(() => {
+      try {
+        unsubscribe?.();
+      } catch {
+      }
+    })
+  );
+  const after = yield* readSnapshotOrFuse;
+  if (fused) {
+    yield* recordFuseDiagnostic;
+    return;
+  }
+  const coordinator = yield* getOrCreateExternalStoreWritebackCoordinator({ internals, bound, env });
+  const normalizedPatchPath = normalizeFieldPath(fieldPath) ?? [];
+  const commitPriority = traitLane === "nonUrgent" ? "low" : "normal";
+  const writeValueSync = (nextValue) => Effect.gen(function* () {
+    const inTxn = yield* Effect.service(inSyncTransactionFiber).pipe(Effect.orDie);
+    const body = Effect.gen(function* () {
+      const prevState = yield* bound.state.read;
+      const prevValue = getAtPath(prevState, fieldPath);
+      if (isEqual(prevValue, nextValue)) {
+        return;
+      }
+      const nextDraft = create(prevState, (draft) => {
+        setAtPathMutating(draft, fieldPath, nextValue);
+      });
+      internals.txn.recordStatePatch(normalizedPatchPath, "trait-external-store", prevValue, nextValue, step.id);
+      internals.txn.updateDraft(nextDraft);
+    });
+    if (inTxn) {
+      return yield* body;
+    }
+    return yield* internals.txn.runWithStateTransaction(
+      {
+        kind: "trait-external-store",
+        name: fieldPath,
+        details: {
+          stateCommit: {
+            priority: commitPriority
+          }
+        }
+      },
+      () => body.pipe(Effect.asVoid)
+    );
+  }).pipe(Effect.provideServices(env));
+  const enqueueWriteValue = (nextValue) => coordinator.enqueue({
+    fieldPath,
+    traitNodeId: step.id,
+    normalizedPatchPath,
+    nextValue,
+    isEqual,
+    commitPriority
+  });
+  yield* writeValueSync(computeValue(after));
+  if (!isEqual(before, after)) {
+    signal();
+  }
+  const fiber = yield* Effect.forkDetach(
+    Effect.provideService(Effect.gen(function* () {
+      while (true) {
+        yield* awaitSignal();
+        if (fused) return;
+        const snapshot = yield* readSnapshotOrFuse;
+        if (fused) {
+          yield* recordFuseDiagnostic;
+          return;
+        }
+        yield* enqueueWriteValue(computeValue(snapshot));
+      }
+    }), inSyncTransactionFiber, false),
+    { startImmediately: true }
+  );
+  internals.lifecycle.registerDestroy(Fiber.interrupt(fiber).pipe(Effect.asVoid), { name: `externalStore:${fieldPath}:writeback` });
+});
+
+// src/internal/state-trait/meta-diagnostics.ts
+import { Effect as Effect2 } from "effect";
+var formatList = (items, limit = 6) => {
+  if (!items || items.length === 0) return void 0;
+  if (items.length <= limit) return items.join(", ");
+  return `${items.slice(0, limit).join(", ")}, \u2026(+${items.length - limit})`;
+};
+var formatPart = (label, value) => {
+  if (value === void 0) return void 0;
+  return `${label}=${value}`;
+};
+var formatIssue = (issue) => {
+  const r = issue.report;
+  const parts = [];
+  if (r.invalidInput) parts.push("invalidInput=true");
+  const unknownKeys = formatList(r.unknownKeys, 6);
+  if (unknownKeys) {
+    parts.push(
+      `unknownKeys=[${unknownKeys}]${typeof r.unknownKeyCount === "number" && r.unknownKeyCount > r.unknownKeys.length ? ` total=${r.unknownKeyCount}` : ""}`
+    );
+  }
+  const droppedKeys = formatList(r.droppedKeys, 6);
+  if (droppedKeys) parts.push(`droppedKeys=[${droppedKeys}]`);
+  if (typeof r.droppedTagItems === "number" && r.droppedTagItems > 0) {
+    parts.push(`droppedTagItems=${r.droppedTagItems}`);
+  }
+  const ignoredAnnotationKeys = formatList(r.ignoredAnnotationKeys, 6);
+  if (ignoredAnnotationKeys) {
+    parts.push(
+      `ignoredAnnotationKeys=[${ignoredAnnotationKeys}]${typeof r.ignoredAnnotationKeyCount === "number" && r.ignoredAnnotationKeyCount > r.ignoredAnnotationKeys.length ? ` total=${r.ignoredAnnotationKeyCount}` : ""}`
+    );
+  }
+  const droppedAnnotationKeys = formatList(r.droppedAnnotationKeys, 6);
+  if (droppedAnnotationKeys) {
+    parts.push(
+      `droppedAnnotationKeys=[${droppedAnnotationKeys}]${typeof r.droppedAnnotationKeyCount === "number" && r.droppedAnnotationKeyCount > r.droppedAnnotationKeys.length ? ` total=${r.droppedAnnotationKeyCount}` : ""}`
+    );
+  }
+  const droppedValues = formatPart("droppedAnnotationValues", r.droppedAnnotationValues);
+  if (droppedValues) parts.push(droppedValues);
+  const nonSerializable = formatPart("nonSerializable", r.droppedAnnotationNonSerializable);
+  const depthExceeded = formatPart("depthExceeded", r.droppedAnnotationDepthExceeded);
+  const nonFiniteNumber = formatPart("nonFiniteNumber", r.droppedAnnotationNonFiniteNumber);
+  const reasons = [nonSerializable, depthExceeded, nonFiniteNumber].filter((x) => x !== void 0);
+  if (reasons.length > 0) parts.push(`reasons={${reasons.join(", ")}}`);
+  return `[${issue.origin}] ${parts.join(" ")}`;
+};
+var collectNodeMetaIssues = (program) => {
+  const spec = program.spec;
+  if (!spec || typeof spec !== "object") return [];
+  const isNode = (value) => typeof value === "object" && value !== null && value._tag === "StateTraitNode";
+  const isList = (value) => typeof value === "object" && value !== null && value._tag === "StateTraitList";
+  const issues = [];
+  const add = (origin, meta) => {
+    const { report } = sanitizeWithReport(meta);
+    if (report) issues.push({ origin, report });
+  };
+  for (const key of Object.keys(spec)) {
+    const raw = spec[key];
+    if (!raw) continue;
+    if (isList(raw)) {
+      if (raw.item && isNode(raw.item) && raw.item.meta !== void 0) {
+        add(`node:${key}[]`, raw.item.meta);
+      }
+      if (raw.list && isNode(raw.list) && raw.list.meta !== void 0) {
+        add(`node:${key}`, raw.list.meta);
+      }
+      continue;
+    }
+    if (isNode(raw)) {
+      if (raw.meta === void 0) continue;
+      add(`node:${key === "$root" ? "$root" : key}`, raw.meta);
+      continue;
+    }
+  }
+  return issues;
+};
+var collectEntryMetaIssues = (program) => {
+  const issues = [];
+  for (const entry of program.entries) {
+    if (entry.kind !== "source" && entry.kind !== "externalStore") continue;
+    const rawMeta = entry.meta?.meta;
+    if (rawMeta === void 0) continue;
+    const origin = entry.kind === "source" ? `source:${entry.fieldPath}` : `externalStore:${entry.fieldPath}`;
+    const { report } = sanitizeWithReport(rawMeta);
+    if (report) issues.push({ origin, report });
+  }
+  return issues;
+};
+var emitMetaSanitizeDiagnostics = (program, ctx) => Effect2.gen(function* () {
+  if (!isDevEnv()) return;
+  const level = yield* Effect2.service(currentDiagnosticsLevel).pipe(Effect2.orDie);
+  if (level === "off") return;
+  const moduleId = ctx.moduleId ?? "unknown";
+  const shouldEmit = yield* onceInRunSession(`meta_sanitize:${moduleId}`);
+  if (!shouldEmit) return;
+  const issues = [...collectNodeMetaIssues(program), ...collectEntryMetaIssues(program)];
+  if (issues.length === 0) return;
+  const limit = level === "light" || level === "sampled" ? 8 : 24;
+  const lines = issues.slice(0, limit).map(formatIssue);
+  if (issues.length > limit) {
+    lines.push(`\u2026(+${issues.length - limit})`);
+  }
+  yield* record({
+    type: "diagnostic",
+    moduleId: ctx.moduleId,
+    instanceId: ctx.instanceId,
+    code: "state_trait::meta_sanitized",
+    severity: "warning",
+    message: `[meta] TraitMeta contains non-exportable fields/values and will be sanitized (total ${issues.length}):
+${lines.join("\n")}`,
+    hint: "TraitMeta is export-only (Devtools/Static IR) and MUST be JsonValue. Use `annotations` with `x-*` keys for extension hints; avoid closures/functions/Effect/Fiber/Tag/DOM/BigInt/circular refs. See specs/016 and docs/ssot/platform/contracts/03-control-surface-manifest.md.",
+    kind: "meta_sanitized"
+  });
+});
+
+// src/internal/state-trait/install.ts
+var buildEntryIndex = (entries) => {
+  const index = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const list2 = index.get(entry.fieldPath) ?? [];
+    list2.push(entry);
+    index.set(entry.fieldPath, list2);
+  }
+  return index;
+};
+var install = (bound, program) => {
+  return Effect3.gen(function* () {
+    let internals;
+    try {
+      internals = getBoundInternals(bound);
+      internals.traits.registerStateTraitProgram(program, {
+        bumpReason: "logic_installed"
+      });
+    } catch {
+    }
+    if (internals) {
+      yield* emitMetaSanitizeDiagnostics(program, {
+        moduleId: internals.moduleId,
+        instanceId: internals.instanceId
+      });
+    }
+    const entryIndex = buildEntryIndex(program.entries);
+    const installStep = (step) => {
+      if (!step.targetFieldPath) {
+        return Effect3.void;
+      }
+      if (step.kind !== "source-refresh" && step.kind !== "external-store-sync") {
+        return Effect3.void;
+      }
+      const candidates = entryIndex.get(step.targetFieldPath);
+      if (!candidates || candidates.length === 0) {
+        return Effect3.void;
+      }
+      const entry = step.kind === "source-refresh" ? candidates.find((e) => e.kind === "source") : candidates.find((e) => e.kind === "externalStore");
+      if (!entry) {
+        return Effect3.void;
+      }
+      return step.kind === "source-refresh" ? installSourceRefresh(bound, step, entry) : installExternalStoreSync(bound, step, entry);
+    };
+    yield* Effect3.forEach(program.plan.steps, (step) => installStep(step)).pipe(Effect3.asVoid);
+  }).pipe(Effect3.asVoid);
+};
+
+// src/StateTrait.ts
+var $root = "$root";
+var from = (_schema) => (spec) => spec;
+var node = (spec) => ({
+  _tag: "StateTraitNode",
+  ...spec
+});
+var list = (spec) => ({
+  _tag: "StateTraitList",
+  ...spec
+});
+var computed = (input) => {
+  const derive = (state) => {
+    const args = input.deps.map((dep) => getAtPath(state, dep));
+    return input.get(...args);
+  };
+  return {
+    fieldPath: void 0,
+    kind: "computed",
+    meta: {
+      deps: input.deps,
+      derive,
+      equals: input.equals,
+      ...input.scheduling ? { scheduling: input.scheduling } : {}
+    }
+  };
+};
+var source = (input) => {
+  const key = (state) => {
+    const args = input.deps.map((dep) => getAtPath(state, dep));
+    return input.key(...args);
+  };
+  return {
+    fieldPath: void 0,
+    kind: "source",
+    meta: { ...input, key }
+  };
+};
+var externalStore = (input) => ({
+  fieldPath: void 0,
+  kind: "externalStore",
+  meta: input
+});
+var link = (meta) => ({
+  fieldPath: void 0,
+  kind: "link",
+  meta: { ...meta, ...meta.scheduling ? { scheduling: meta.scheduling } : {} }
+});
+var build2 = (stateSchema, spec) => build(stateSchema, spec);
+var install2 = (bound, program) => install(bound, program);
+var exportStaticIr2 = (program, moduleId, options) => exportStaticIr({
+  program,
+  moduleId,
+  version: options?.version
+});
+
+export {
+  $root,
+  from,
+  node,
+  list,
+  computed,
+  source,
+  externalStore,
+  link,
+  build2 as build,
+  install2 as install,
+  exportStaticIr2 as exportStaticIr,
+  StateTrait_exports
+};
+//# sourceMappingURL=chunk-GWSM4KLB.js.map