@logixjs/sandbox 0.0.1 → 0.0.2

package/public/sandbox/chunks/chunk-NE447XAF.js

@@ -0,0 +1,597 @@
+// @logixjs/core subpath bundles for @logixjs/sandbox
+
+import {
+  build,
+  installSourceRefresh,
+  onceInRunSession
+} from "./chunk-FQRUTYAD.js";
+import {
+  getAtPath,
+  setAtPathMutating
+} from "./chunk-C2MYMMO4.js";
+import {
+  create
+} from "./chunk-KE2H62D6.js";
+import {
+  exportStaticIr
+} from "./chunk-4MY35XR3.js";
+import {
+  sanitizeWithReport
+} from "./chunk-X2Z5VYG3.js";
+import {
+  normalizeFieldPath
+} from "./chunk-ASVMK364.js";
+import {
+  getBoundInternals
+} from "./chunk-7GPAF2UK.js";
+import {
+  DeclarativeLinkRuntimeTag,
+  HostSchedulerTag,
+  inSyncTransactionFiber,
+  isDevEnv
+} from "./chunk-YMVMZA3U.js";
+import {
+  getExternalStoreDescriptor
+} from "./chunk-NMGFJZ4I.js";
+import {
+  getGlobalHostScheduler
+} from "./chunk-UJGVDFZN.js";
+import {
+  currentDiagnosticsLevel,
+  record
+} from "./chunk-SH7TP5CJ.js";
+
+// ../logix-core/src/internal/state-trait/install.ts
+import { Effect as Effect3 } from "../effect.js";
+
+// ../logix-core/src/internal/state-trait/external-store.ts
+import { Context, Effect, FiberRef, Option } from "../effect.js";
+var isFn = (value) => typeof value === "function";
+var resolveStore = (entry) => Effect.gen(function* () {
+  const store = entry.meta?.store;
+  const descriptor = getExternalStoreDescriptor(store);
+  if (descriptor?.kind === "service") {
+    const service = yield* descriptor.tag;
+    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.context();
+  const hostSchedulerOpt = yield* Effect.serviceOption(HostSchedulerTag);
+  const hostScheduler = Option.isSome(hostSchedulerOpt) ? hostSchedulerOpt.value : getGlobalHostScheduler();
+  const microtask = Effect.async((resume2) => {
+    hostScheduler.scheduleMicrotask(() => resume2(Effect.void));
+  });
+  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);
+  if (rawDescriptor?.kind === "module") {
+    const linkRuntimeOpt = yield* Effect.serviceOption(DeclarativeLinkRuntimeTag);
+    if (Option.isNone(linkRuntimeOpt)) {
+      return yield* Effect.dieMessage("[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 && Context.isTag(tag)) {
+          return internals.imports.get(tag);
+        }
+        if (Context.isTag(module)) {
+          return internals.imports.get(module);
+        }
+      }
+      return void 0;
+    })();
+    if (!sourceRuntime) {
+      return yield* Effect.dieMessage(
+        `[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.dieMessage(
+        `[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.dieMessage(
+        `[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 writeValue2 = (nextValue) => Effect.gen(function* () {
+      const inTxn = yield* FiberRef.get(inSyncTransactionFiber);
+      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.provide(env));
+    const unregister = linkRuntimeOpt.value.registerModuleAsSourceLink({
+      id: `${internals.instanceId}::externalStore:${step.id}`,
+      sourceModuleInstanceKey: moduleInstanceKey,
+      readQuery: rawDescriptor.readQuery,
+      computeValue,
+      equalsValue: isEqual,
+      applyValue: writeValue2
+    });
+    yield* Effect.addFinalizer(
+      () => Effect.sync(() => {
+        unregister();
+      })
+    );
+    const initialState = yield* sourceRuntime.getState;
+    const initialSelected = rawDescriptor.readQuery.select(initialState);
+    yield* writeValue2(computeValue(initialSelected));
+    return;
+  }
+  const store = rawDescriptor?.kind === "service" ? yield* resolveStore(entry) : rawStore;
+  if (!store || typeof store !== "object") {
+    return yield* Effect.dieMessage(
+      `[StateTrait.externalStore] Invalid store for "${fieldPath}". Expected { getSnapshot, subscribe }.`
+    );
+  }
+  if (!isFn(store.getSnapshot) || !isFn(store.subscribe)) {
+    return yield* Effect.dieMessage(
+      `[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.async((resumeEffect, signal2) => {
+      let done = false;
+      const r = () => {
+        if (done) return;
+        done = true;
+        resume = void 0;
+        resumeEffect(Effect.void);
+      };
+      resume = r;
+      try {
+        signal2.addEventListener(
+          "abort",
+          () => {
+            if (resume === r) {
+              resume = void 0;
+            }
+          },
+          { once: true }
+        );
+      } catch {
+      }
+    });
+  };
+  const getSnapshotOrFuse = () => {
+    try {
+      return store.getSnapshot();
+    } catch (err) {
+      fused = true;
+      fuseCause = err;
+      return void 0;
+    }
+  };
+  const readSnapshotOrFuse = Effect.locally(inSyncTransactionFiber, false)(Effect.sync(getSnapshotOrFuse));
+  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 writeValue = (nextValue) => Effect.gen(function* () {
+    const inTxn = yield* FiberRef.get(inSyncTransactionFiber);
+    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)
+    );
+  });
+  yield* writeValue(computeValue(after));
+  if (!isEqual(before, after)) {
+    signal();
+  }
+  yield* Effect.forkScoped(
+    Effect.locally(inSyncTransactionFiber, false)(
+      Effect.gen(function* () {
+        while (true) {
+          yield* awaitSignal();
+          if (fused) return;
+          yield* microtask;
+          if (fused) return;
+          const snapshot = yield* readSnapshotOrFuse;
+          if (fused) {
+            yield* recordFuseDiagnostic;
+            return;
+          }
+          yield* writeValue(computeValue(snapshot));
+        }
+      })
+    )
+  );
+});
+
+// ../logix-core/src/internal/state-trait/meta-diagnostics.ts
+import { Effect as Effect2, FiberRef as FiberRef2 } from "../effect.js";
+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* FiberRef2.get(currentDiagnosticsLevel);
+  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"
+  });
+});
+
+// ../logix-core/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);
+};
+
+// ../logix-core/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
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/state-trait/install.ts", "../../../../logix-core/src/internal/state-trait/external-store.ts", "../../../../logix-core/src/internal/state-trait/meta-diagnostics.ts", "../../../../logix-core/src/StateTrait.ts"],
  "sourcesContent": ["import { Effect } from 'effect'\nimport type { BoundApi } from '../runtime/core/module.js'\nimport { getBoundInternals } from '../runtime/core/runtimeInternalsAccessor.js'\nimport * as SourceRuntime from './source.js'\nimport * as ExternalStoreRuntime from './external-store.js'\nimport * as MetaDiagnostics from './meta-diagnostics.js'\nimport type {\n  StateTraitProgram,\n  StateTraitPlanStep,\n  StateTraitEntry,\n  TraitConvergeGenerationBumpReason,\n} from './model.js'\n\nconst buildEntryIndex = <S>(\n  entries: ReadonlyArray<StateTraitEntry<S, string>>,\n): Map<string, Array<StateTraitEntry<S, string>>> => {\n  const index = new Map<string, Array<StateTraitEntry<S, string>>>()\n  for (const entry of entries) {\n    const list = index.get(entry.fieldPath) ?? []\n    list.push(entry)\n    index.set(entry.fieldPath, list)\n  }\n  return index\n}\n\n/**\n * Install behaviors described by StateTraitProgram onto the given Bound API.\n *\n * - Phase 2 minimal implementation:\n *   - Register watchers for computed fields: recompute target fields when State changes.\n *   - Register watchers for link fields: sync target fields when source fields change.\n *   - Reserve refresh entrypoints for source fields (no external calls yet).\n *\n * Notes:\n * - All watchers are installed via Bound API `$`, without directly depending on ModuleRuntime.\n * - Each PlanStep corresponds to a long-lived Effect and is mounted into the Runtime Scope via forkScoped.\n */\nexport const install = <S>(\n  bound: BoundApi<any, any>,\n  program: StateTraitProgram<S>,\n): Effect.Effect<void, never, any> => {\n  return Effect.gen(function* () {\n    // Register the program to Runtime first (the converge engine runs computed/link/check before txn commit).\n    let internals: any | undefined\n    try {\n      internals = getBoundInternals(bound as any)\n      ;(internals.traits.registerStateTraitProgram as any)(program, {\n        bumpReason: 'logic_installed' as TraitConvergeGenerationBumpReason,\n      })\n    } catch {\n      // no-op for legacy/mocked bound\n    }\n\n    if (internals) {\n      yield* MetaDiagnostics.emitMetaSanitizeDiagnostics(program as any, {\n        moduleId: internals.moduleId,\n        instanceId: internals.instanceId,\n      })\n    }\n\n    const entryIndex = buildEntryIndex(program.entries as any)\n\n    const installStep = (step: StateTraitPlanStep): Effect.Effect<void, never, any> => {\n      if (!step.targetFieldPath) {\n        return Effect.void\n      }\n\n      if (step.kind !== 'source-refresh' && step.kind !== 'external-store-sync') {\n        // computed/link/check are handled by the runtime core within the transaction window; install keeps only source.refresh/externalStore sync entrypoints.\n        return Effect.void\n      }\n\n      const candidates = entryIndex.get(step.targetFieldPath)\n      if (!candidates || candidates.length === 0) {\n        // The plan references a missing spec: treat it as a build-time bug and ignore the step here.\n        return Effect.void\n      }\n\n      const entry =\n        step.kind === 'source-refresh'\n          ? candidates.find((e) => e.kind === 'source')\n          : candidates.find((e) => e.kind === 'externalStore')\n\n      if (!entry) {\n        return Effect.void\n      }\n\n      return step.kind === 'source-refresh'\n        ? SourceRuntime.installSourceRefresh(bound, step, entry as any)\n        : ExternalStoreRuntime.installExternalStoreSync(bound, step, entry as any)\n    }\n\n    yield* Effect.forEach(program.plan.steps, (step) => installStep(step)).pipe(Effect.asVoid)\n  }).pipe(Effect.asVoid)\n}\n", "import { Context, Effect, FiberRef, Option } from 'effect'\nimport { create } from 'mutative'\nimport type { BoundApi } from '../runtime/core/module.js'\nimport { getBoundInternals } from '../runtime/core/runtimeInternalsAccessor.js'\nimport * as TaskRunner from '../runtime/core/TaskRunner.js'\nimport * as Debug from '../runtime/core/DebugSink.js'\nimport { getExternalStoreDescriptor } from '../external-store-descriptor.js'\nimport { normalizeFieldPath } from '../field-path.js'\nimport { DeclarativeLinkRuntimeTag, HostSchedulerTag } from '../runtime/core/env.js'\nimport { getGlobalHostScheduler } from '../runtime/core/HostScheduler.js'\nimport * as RowId from './rowid.js'\nimport type { StateTraitEntry, StateTraitPlanStep } from './model.js'\n\nconst isFn = (value: unknown): value is (...args: ReadonlyArray<any>) => unknown => typeof value === 'function'\n\ntype ExternalStoreEntry<S> = Extract<StateTraitEntry<S, string>, { readonly kind: 'externalStore' }>\n\nconst resolveStore = (entry: ExternalStoreEntry<any>): Effect.Effect<any, never, any> =>\n  Effect.gen(function* () {\n    const store = (entry.meta as any)?.store\n    const descriptor = getExternalStoreDescriptor(store)\n\n    if (descriptor?.kind === 'service') {\n      const service = yield* descriptor.tag\n      return descriptor.map(service)\n    }\n\n    return store\n  })\n\nexport const installExternalStoreSync = <S>(\n  bound: BoundApi<any, any>,\n  step: StateTraitPlanStep,\n  entry: ExternalStoreEntry<S>,\n): Effect.Effect<void, never, any> =>\n  Effect.gen(function* () {\n    const fieldPath = step.targetFieldPath\n    if (!fieldPath) return\n\n    const env = yield* Effect.context<any>()\n    const hostSchedulerOpt = yield* Effect.serviceOption(HostSchedulerTag)\n    const hostScheduler = Option.isSome(hostSchedulerOpt) ? hostSchedulerOpt.value : getGlobalHostScheduler()\n    const microtask = Effect.async<void, never>((resume) => {\n      hostScheduler.scheduleMicrotask(() => resume(Effect.void))\n    })\n\n    let internals: ReturnType<typeof getBoundInternals>\n    try {\n      internals = getBoundInternals(bound as any)\n    } catch {\n      return\n    }\n\n    const select = (entry.meta as any)?.select as ((snapshot: unknown) => unknown) | undefined\n    const equals = (entry.meta as any)?.equals as ((a: unknown, b: unknown) => boolean) | undefined\n\n    const computeValue = (snapshot: unknown): unknown => (isFn(select) ? select(snapshot) : snapshot)\n    const isEqual = (a: unknown, b: unknown): boolean => (isFn(equals) ? equals(a, b) : Object.is(a, b))\n\n    const traitLane = (entry.meta as any)?.priority as 'urgent' | 'nonUrgent' | undefined\n\n    const rawStore = (entry.meta as any)?.store\n    const rawDescriptor = getExternalStoreDescriptor(rawStore)\n\n    if (rawDescriptor?.kind === 'module') {\n      const linkRuntimeOpt = yield* Effect.serviceOption(DeclarativeLinkRuntimeTag)\n      if (Option.isNone(linkRuntimeOpt)) {\n        return yield* Effect.dieMessage('[StateTrait.externalStore] Missing DeclarativeLinkRuntime service (073).')\n      }\n\n      const module = rawDescriptor.module\n\n      const sourceRuntime = (() => {\n        if (module && typeof module === 'object') {\n          const moduleId = (module as any).moduleId\n          const instanceId = (module as any).instanceId\n          const getState = (module as any).getState\n          if (typeof moduleId === 'string' && moduleId.length > 0 && typeof instanceId === 'string' && instanceId.length > 0 && getState) {\n            return module as any\n          }\n\n          const tag = (module as any).tag\n          if (tag && Context.isTag(tag)) {\n            return internals.imports.get(tag as any)\n          }\n\n          if (Context.isTag(module as any)) {\n            return internals.imports.get(module as any)\n          }\n        }\n        return undefined\n      })()\n\n      if (!sourceRuntime) {\n        return yield* Effect.dieMessage(\n          `[StateTrait.externalStore] Module-as-Source store is unresolved for \"${fieldPath}\". ` +\n            `Fix: include the source ModuleTag in module imports (moduleId=${rawDescriptor.moduleId}).`,\n        )\n      }\n\n      if (rawDescriptor.instanceId && rawDescriptor.instanceId !== sourceRuntime.instanceId) {\n        return yield* Effect.dieMessage(\n          `[StateTrait.externalStore] Module-as-Source instanceId mismatch for \"${fieldPath}\". ` +\n            `descriptor.instanceId=${rawDescriptor.instanceId}, resolved.instanceId=${sourceRuntime.instanceId}`,\n        )\n      }\n\n      if (sourceRuntime.moduleId !== rawDescriptor.moduleId) {\n        return yield* Effect.dieMessage(\n          `[StateTrait.externalStore] Module-as-Source moduleId mismatch for \"${fieldPath}\". ` +\n            `descriptor.moduleId=${rawDescriptor.moduleId}, resolved.moduleId=${sourceRuntime.moduleId}`,\n        )\n      }\n\n      const staticIr = rawDescriptor.readQuery.staticIr\n      const isRecognizableStatic =\n        staticIr.lane === 'static' && staticIr.readsDigest != null && staticIr.fallbackReason == null\n\n      if (!isRecognizableStatic) {\n        yield* Debug.record({\n          type: 'diagnostic',\n          moduleId: internals.moduleId,\n          instanceId: internals.instanceId,\n          code: 'external_store::module_source_degraded',\n          severity: 'warning',\n          message:\n            '[StateTrait.externalStore] Module-as-Source selector is not fully IR-recognizable; falling back to module-topic edge (may reduce perf).',\n          hint:\n            'Fix: provide a static ReadQuery (ReadQuery.make) or annotate selector.fieldPaths to get a stable readsDigest; avoid dynamic lane.',\n          kind: 'module_as_source_degraded',\n          trigger: {\n            kind: 'trait',\n            name: 'externalStore.moduleSource',\n            details: {\n              sourceModuleId: rawDescriptor.moduleId,\n              selectorId: staticIr.selectorId,\n              lane: staticIr.lane,\n              fallbackReason: staticIr.fallbackReason,\n              readsDigest: staticIr.readsDigest,\n            },\n          },\n        })\n      }\n\n      const moduleInstanceKey = `${sourceRuntime.moduleId}::${sourceRuntime.instanceId}` as any\n\n      const writeValue = (nextValue: unknown): Effect.Effect<void, never, never> =>\n        Effect.gen(function* () {\n          const inTxn = yield* FiberRef.get(TaskRunner.inSyncTransactionFiber)\n\n          const body = Effect.gen(function* () {\n            const prevState = (yield* bound.state.read) as any\n            const prevValue = RowId.getAtPath(prevState as any, fieldPath)\n\n            if (isEqual(prevValue, nextValue)) {\n              return\n            }\n\n            const nextDraft = create(prevState, (draft) => {\n              RowId.setAtPathMutating(draft as any, fieldPath, nextValue)\n            })\n\n            const normalized = normalizeFieldPath(fieldPath) ?? []\n            internals.txn.recordStatePatch(normalized, 'trait-external-store', prevValue, nextValue, step.id)\n            internals.txn.updateDraft(nextDraft)\n          })\n\n          if (inTxn) {\n            return yield* body\n          }\n\n          const stateCommitPriority = traitLane === 'nonUrgent' ? 'low' : 'normal'\n          return yield* internals.txn.runWithStateTransaction(\n            {\n              kind: 'trait-external-store',\n              name: fieldPath,\n              details: {\n                stateCommit: {\n                  priority: stateCommitPriority,\n                },\n              },\n            },\n            () => body.pipe(Effect.asVoid),\n          )\n        }).pipe(Effect.provide(env))\n\n      const unregister = linkRuntimeOpt.value.registerModuleAsSourceLink({\n        id: `${internals.instanceId}::externalStore:${step.id}`,\n        sourceModuleInstanceKey: moduleInstanceKey,\n        readQuery: rawDescriptor.readQuery as any,\n        computeValue,\n        equalsValue: isEqual,\n        applyValue: writeValue,\n      })\n\n      yield* Effect.addFinalizer(() =>\n        Effect.sync(() => {\n          unregister()\n        }),\n      )\n\n      // Initial sync: read the current source snapshot and write it back immediately.\n      const initialState = yield* (sourceRuntime.getState as Effect.Effect<unknown, never, never>)\n      const initialSelected = rawDescriptor.readQuery.select(initialState as any)\n      yield* writeValue(computeValue(initialSelected))\n\n      return\n    }\n\n    const store = rawDescriptor?.kind === 'service' ? yield* resolveStore(entry) : rawStore\n\n    if (!store || typeof store !== 'object') {\n      return yield* Effect.dieMessage(\n        `[StateTrait.externalStore] Invalid store for \"${fieldPath}\". Expected { getSnapshot, subscribe }.`,\n      )\n    }\n    if (!isFn((store as any).getSnapshot) || !isFn((store as any).subscribe)) {\n      return yield* Effect.dieMessage(\n        `[StateTrait.externalStore] Invalid store for \"${fieldPath}\". Expected { getSnapshot, subscribe }.`,\n      )\n    }\n\n    let fused = false\n    let fuseCause: unknown | undefined\n    let fuseRecorded = false\n    let pending = false\n    let resume: (() => void) | undefined\n\n    const recordFuseDiagnostic = Effect.gen(function* () {\n      if (fuseRecorded) return\n      fuseRecorded = true\n\n      const errorMessage = (() => {\n        if (fuseCause instanceof Error) return fuseCause.message\n        if (typeof fuseCause === 'string') return fuseCause\n        return 'unknown'\n      })()\n\n      yield* Debug.record({\n        type: 'diagnostic',\n        moduleId: internals.moduleId,\n        instanceId: internals.instanceId,\n        code: 'external_store::snapshot_threw',\n        severity: 'warning',\n        message:\n          `[StateTrait.externalStore] store.getSnapshot() threw; trait is fused and will stop syncing for \"${fieldPath}\".`,\n        hint: 'Fix: ensure getSnapshot is synchronous and non-throwing; async resources should use StateTrait.source or ExternalStore.fromStream({ current/initial }).',\n        kind: 'external_store_fused:get_snapshot',\n        trigger: {\n          kind: 'trait',\n          name: 'externalStore.getSnapshot',\n          details: {\n            fieldPath,\n            traitId: step.id,\n            storeKind: rawDescriptor?.kind ?? 'raw',\n            error: errorMessage,\n          },\n        },\n      })\n    })\n\n    const signal = (): void => {\n      if (fused) return\n      if (resume) {\n        const r = resume\n        pending = false\n        r()\n        return\n      }\n      pending = true\n    }\n\n    const awaitSignal = (): Effect.Effect<void, never, never> => {\n      if (pending) {\n        pending = false\n        return Effect.void\n      }\n\n      return Effect.async<void, never>((resumeEffect, signal) => {\n        let done = false\n        const r = () => {\n          if (done) return\n          done = true\n          resume = undefined\n          resumeEffect(Effect.void)\n        }\n\n        resume = r\n\n        try {\n          signal.addEventListener(\n            'abort',\n            () => {\n              if (resume === r) {\n                resume = undefined\n              }\n            },\n            { once: true },\n          )\n        } catch {\n          // best-effort\n        }\n      })\n    }\n\n    const getSnapshotOrFuse = (): unknown => {\n      try {\n        return (store as any).getSnapshot()\n      } catch (err) {\n        fused = true\n        fuseCause = err\n        return undefined\n      }\n    }\n\n    const readSnapshotOrFuse = Effect.locally(TaskRunner.inSyncTransactionFiber, false)(Effect.sync(getSnapshotOrFuse))\n\n    // T016: atomic init semantics (no missed updates between getSnapshot() and subscribe()).\n    const before = yield* readSnapshotOrFuse\n    if (fused) {\n      yield* recordFuseDiagnostic\n      return\n    }\n\n    const unsubscribe = (store as any).subscribe(signal) as (() => void) | undefined\n    yield* Effect.addFinalizer(() =>\n      Effect.sync(() => {\n        try {\n          unsubscribe?.()\n        } catch {\n          // best-effort\n        }\n      }),\n    )\n\n    const after = yield* readSnapshotOrFuse\n    if (fused) {\n      yield* recordFuseDiagnostic\n      return\n    }\n\n    const writeValue = (nextValue: unknown): Effect.Effect<void, never, any> =>\n      Effect.gen(function* () {\n        const inTxn = yield* FiberRef.get(TaskRunner.inSyncTransactionFiber)\n\n        const body = Effect.gen(function* () {\n          const prevState = (yield* bound.state.read) as any\n          const prevValue = RowId.getAtPath(prevState as any, fieldPath)\n\n          if (isEqual(prevValue, nextValue)) {\n            return\n          }\n\n          const nextDraft = create(prevState, (draft) => {\n            RowId.setAtPathMutating(draft as any, fieldPath, nextValue)\n          })\n\n          const normalized = normalizeFieldPath(fieldPath) ?? []\n          internals.txn.recordStatePatch(normalized, 'trait-external-store', prevValue, nextValue, step.id)\n          internals.txn.updateDraft(nextDraft)\n        })\n\n          if (inTxn) {\n            return yield* body\n          }\n\n          const stateCommitPriority = traitLane === 'nonUrgent' ? 'low' : 'normal'\n          return yield* internals.txn.runWithStateTransaction(\n            {\n              kind: 'trait-external-store',\n              name: fieldPath,\n              details: {\n                stateCommit: {\n                  priority: stateCommitPriority,\n                },\n              },\n            },\n            () => body.pipe(Effect.asVoid),\n          )\n        })\n\n    // Use the post-subscribe snapshot as the initial committed value to avoid missing an update between getSnapshot and subscribe.\n    yield* writeValue(computeValue(after))\n\n    if (!isEqual(before, after)) {\n      signal()\n    }\n\n    // Long-lived sync loop: coalesce changes, pull latest snapshot, and write back in a txn.\n    yield* Effect.forkScoped(\n      Effect.locally(TaskRunner.inSyncTransactionFiber, false)(\n        Effect.gen(function* () {\n          while (true) {\n            yield* awaitSignal()\n            if (fused) return\n            yield* microtask\n            if (fused) return\n\n            const snapshot = yield* readSnapshotOrFuse\n            if (fused) {\n              yield* recordFuseDiagnostic\n              return\n            }\n\n            yield* writeValue(computeValue(snapshot))\n          }\n        }),\n      ),\n    )\n  })\n", "import { Effect, FiberRef } from 'effect'\nimport * as Debug from '../runtime/core/DebugSink.js'\nimport { isDevEnv } from '../runtime/core/env.js'\nimport { onceInRunSession } from './converge-diagnostics.js'\nimport type { StateTraitProgram } from './model.js'\nimport * as Meta from './meta.js'\n\ntype MetaIssue = Readonly<{\n  readonly origin: string\n  readonly report: Meta.TraitMetaSanitizeReport\n}>\n\nconst formatList = (items: ReadonlyArray<string> | undefined, limit = 6): string | undefined => {\n  if (!items || items.length === 0) return undefined\n  if (items.length <= limit) return items.join(', ')\n  return `${items.slice(0, limit).join(', ')}, \u2026(+${items.length - limit})`\n}\n\nconst formatPart = (label: string, value: string | number | undefined): string | undefined => {\n  if (value === undefined) return undefined\n  return `${label}=${value}`\n}\n\nconst formatIssue = (issue: MetaIssue): string => {\n  const r = issue.report\n\n  const parts: Array<string> = []\n\n  if (r.invalidInput) parts.push('invalidInput=true')\n\n  const unknownKeys = formatList(r.unknownKeys, 6)\n  if (unknownKeys) {\n    parts.push(\n      `unknownKeys=[${unknownKeys}]${typeof r.unknownKeyCount === 'number' && r.unknownKeyCount > r.unknownKeys!.length ? ` total=${r.unknownKeyCount}` : ''}`,\n    )\n  }\n\n  const droppedKeys = formatList(r.droppedKeys, 6)\n  if (droppedKeys) parts.push(`droppedKeys=[${droppedKeys}]`)\n\n  if (typeof r.droppedTagItems === 'number' && r.droppedTagItems > 0) {\n    parts.push(`droppedTagItems=${r.droppedTagItems}`)\n  }\n\n  const ignoredAnnotationKeys = formatList(r.ignoredAnnotationKeys, 6)\n  if (ignoredAnnotationKeys) {\n    parts.push(\n      `ignoredAnnotationKeys=[${ignoredAnnotationKeys}]${\n        typeof r.ignoredAnnotationKeyCount === 'number' && r.ignoredAnnotationKeyCount > r.ignoredAnnotationKeys!.length\n          ? ` total=${r.ignoredAnnotationKeyCount}`\n          : ''\n      }`,\n    )\n  }\n\n  const droppedAnnotationKeys = formatList(r.droppedAnnotationKeys, 6)\n  if (droppedAnnotationKeys) {\n    parts.push(\n      `droppedAnnotationKeys=[${droppedAnnotationKeys}]${\n        typeof r.droppedAnnotationKeyCount === 'number' && r.droppedAnnotationKeyCount > r.droppedAnnotationKeys!.length\n          ? ` total=${r.droppedAnnotationKeyCount}`\n          : ''\n      }`,\n    )\n  }\n\n  const droppedValues = formatPart('droppedAnnotationValues', r.droppedAnnotationValues)\n  if (droppedValues) parts.push(droppedValues)\n\n  const nonSerializable = formatPart('nonSerializable', r.droppedAnnotationNonSerializable)\n  const depthExceeded = formatPart('depthExceeded', r.droppedAnnotationDepthExceeded)\n  const nonFiniteNumber = formatPart('nonFiniteNumber', r.droppedAnnotationNonFiniteNumber)\n  const reasons = [nonSerializable, depthExceeded, nonFiniteNumber].filter((x): x is string => x !== undefined)\n  if (reasons.length > 0) parts.push(`reasons={${reasons.join(', ')}}`)\n\n  return `[${issue.origin}] ${parts.join(' ')}`\n}\n\nconst collectNodeMetaIssues = (program: StateTraitProgram<any>): Array<MetaIssue> => {\n  const spec: any = program.spec as any\n  if (!spec || typeof spec !== 'object') return []\n\n  const isNode = (value: unknown): value is { readonly _tag: 'StateTraitNode'; readonly meta?: unknown } =>\n    typeof value === 'object' && value !== null && (value as any)._tag === 'StateTraitNode'\n\n  const isList = (value: unknown): value is { readonly _tag: 'StateTraitList'; readonly item?: unknown; readonly list?: unknown } =>\n    typeof value === 'object' && value !== null && (value as any)._tag === 'StateTraitList'\n\n  const issues: Array<MetaIssue> = []\n\n  const add = (origin: string, meta: unknown): void => {\n    const { report } = Meta.sanitizeWithReport(meta)\n    if (report) issues.push({ origin, report })\n  }\n\n  for (const key of Object.keys(spec)) {\n    const raw = spec[key]\n    if (!raw) continue\n\n    if (isList(raw)) {\n      if (raw.item && isNode(raw.item) && (raw.item as any).meta !== undefined) {\n        add(`node:${key}[]`, (raw.item as any).meta)\n      }\n      if (raw.list && isNode(raw.list) && (raw.list as any).meta !== undefined) {\n        add(`node:${key}`, (raw.list as any).meta)\n      }\n      continue\n    }\n\n    if (isNode(raw)) {\n      if ((raw as any).meta === undefined) continue\n      add(`node:${key === '$root' ? '$root' : key}`, (raw as any).meta)\n      continue\n    }\n  }\n\n  return issues\n}\n\nconst collectEntryMetaIssues = (program: StateTraitProgram<any>): Array<MetaIssue> => {\n  const issues: Array<MetaIssue> = []\n\n  for (const entry of program.entries) {\n    if (entry.kind !== 'source' && entry.kind !== 'externalStore') continue\n    const rawMeta = (entry.meta as any)?.meta\n    if (rawMeta === undefined) continue\n\n    const origin = entry.kind === 'source' ? `source:${entry.fieldPath}` : `externalStore:${entry.fieldPath}`\n    const { report } = Meta.sanitizeWithReport(rawMeta)\n    if (report) issues.push({ origin, report })\n  }\n\n  return issues\n}\n\nexport const emitMetaSanitizeDiagnostics = (\n  program: StateTraitProgram<any>,\n  ctx: Readonly<{ readonly moduleId?: string; readonly instanceId?: string }>,\n): Effect.Effect<void> =>\n  Effect.gen(function* () {\n    if (!isDevEnv()) return\n\n    const level = yield* FiberRef.get(Debug.currentDiagnosticsLevel)\n    if (level === 'off') return\n\n    const moduleId = ctx.moduleId ?? 'unknown'\n    const shouldEmit = yield* onceInRunSession(`meta_sanitize:${moduleId}`)\n    if (!shouldEmit) return\n\n    const issues = [...collectNodeMetaIssues(program), ...collectEntryMetaIssues(program)]\n    if (issues.length === 0) return\n\n    const limit = level === 'light' || level === 'sampled' ? 8 : 24\n    const lines = issues.slice(0, limit).map(formatIssue)\n    if (issues.length > limit) {\n      lines.push(`\u2026(+${issues.length - limit})`)\n    }\n\n    yield* Debug.record({\n      type: 'diagnostic',\n      moduleId: ctx.moduleId,\n      instanceId: ctx.instanceId,\n      code: 'state_trait::meta_sanitized',\n      severity: 'warning',\n      message: `[meta] TraitMeta contains non-exportable fields/values and will be sanitized (total ${issues.length}):\\n${lines.join('\\n')}`,\n      hint:\n        'TraitMeta is export-only (Devtools/Static IR) and MUST be JsonValue. ' +\n        'Use `annotations` with `x-*` keys for extension hints; avoid closures/functions/Effect/Fiber/Tag/DOM/BigInt/circular refs. ' +\n        'See specs/016 and docs/ssot/platform/contracts/03-control-surface-manifest.md.',\n      kind: 'meta_sanitized',\n    })\n  })\n\n", "// StateTrait namespace module (@logixjs/core/StateTrait):\n// - Provides a DSL for trait specs (from/node/list/computed/source/link).\n// - build: normalizes the spec and produces Program/Graph/Plan.\n// - install: installs a Program into the runtime (registers source.refresh, runs converge/validate in txn windows).\n\nimport type { Schema } from 'effect'\nimport { Effect } from 'effect'\nimport type { BoundApi } from './Bound.js'\nimport type { ExternalStore as ExternalStoreType } from './ExternalStore.js'\nimport * as Model from './internal/state-trait/model.js'\nimport type { TraitMeta as TraitMetaInternal } from './internal/state-trait/meta.js'\nimport * as FieldPath from './internal/state-trait/field-path.js'\nimport * as RowId from './internal/state-trait/rowid.js'\nimport * as InternalBuild from './internal/state-trait/build.js'\nimport * as InternalInstall from './internal/state-trait/install.js'\nimport * as InternalIr from './internal/state-trait/ir.js'\n\n// Public type aliases.\nexport type StateTraitSpec<S> = Model.StateTraitSpec<S>\nexport type StateTraitEntry<S = unknown, P extends string = string> = Model.StateTraitEntry<S, P>\nexport type StateTraitProgram<S> = Model.StateTraitProgram<S>\nexport type StateTraitGraph = Model.StateTraitGraph\nexport type StateTraitPlan = Model.StateTraitPlan\nexport type StateTraitNode<Input = unknown, Ctx = unknown> = Model.StateTraitNode<Input, Ctx>\nexport type StateTraitList<Item = unknown> = Model.StateTraitList<Item>\nexport type CheckRule<Input = unknown, Ctx = unknown> = Model.CheckRule<Input, Ctx>\nexport type TraitMeta = TraitMetaInternal\n\nexport type StateFieldPath<S> = FieldPath.StateFieldPath<S>\nexport type StateAtPath<S, P> = FieldPath.StateAtPath<S, P>\n\nexport const $root = '$root' as const\n\ntype DepsArgs<S extends object, Deps extends ReadonlyArray<StateFieldPath<S>>> = {\n  readonly [K in keyof Deps]: StateAtPath<S, Deps[K]>\n}\n\n/**\n * StateTrait.from:\n * - Narrows available field paths based on the state Schema, adding type constraints to trait specs.\n * - At runtime this returns the raw spec object; normalization is handled by internal layers.\n */\nexport const from =\n  <S extends object, I>(_schema: Schema.Schema<S, I>) =>\n  (spec: StateTraitSpec<S>): StateTraitSpec<S> =>\n    spec\n\nexport const node = <Input = unknown, Ctx = unknown>(\n  spec: Omit<Model.StateTraitNode<Input, Ctx>, '_tag'>,\n): Model.StateTraitNode<Input, Ctx> => ({\n  _tag: 'StateTraitNode',\n  ...spec,\n})\n\nexport const list = <Item = unknown>(spec: Omit<Model.StateTraitList<Item>, '_tag'>): Model.StateTraitList<Item> => ({\n  _tag: 'StateTraitList',\n  ...spec,\n})\n\n/**\n * StateTrait.computed:\n * - Declares computed semantics for a field.\n * - Uses explicit deps as the single source of truth for dependencies (diagnostics / reverse-closure / incremental sched).\n */\nexport const computed = <\n  S extends object,\n  P extends StateFieldPath<S>,\n  const Deps extends ReadonlyArray<StateFieldPath<S>>,\n>(input: {\n  readonly deps: Deps\n  readonly get: (...depsValues: DepsArgs<S, Deps>) => StateAtPath<S, P>\n  readonly equals?: (prev: StateAtPath<S, P>, next: StateAtPath<S, P>) => boolean\n  /**\n   * 043: explicit converge time-slicing scheduling.\n   * - unset: immediate (default behavior unchanged)\n   * - deferred: can be postponed and merged into later windows (requires runtime time-slicing enabled)\n   */\n  readonly scheduling?: Model.TraitConvergeScheduling\n}): StateTraitEntry<S, P> => {\n  const derive = (state: Readonly<S>): StateAtPath<S, P> => {\n    const args = (input.deps as ReadonlyArray<string>).map((dep) => RowId.getAtPath(state as any, dep))\n    return (input.get as any)(...args)\n  }\n  return {\n    fieldPath: undefined as unknown as P,\n    kind: 'computed',\n    meta: {\n      deps: input.deps,\n      derive,\n      equals: input.equals,\n      ...(input.scheduling ? { scheduling: input.scheduling } : {}),\n    },\n  } as StateTraitEntry<S, P>\n}\n\n/**\n * StateTrait.source:\n * - Declares an external resource source for a field (Resource / Query integration is implemented in later phases).\n * - The kernel owns keyHash gating / concurrency / ReplayMode behavior.\n */\nexport const source = <\n  S extends object,\n  P extends StateFieldPath<S>,\n  const Deps extends ReadonlyArray<StateFieldPath<S>>,\n>(input: {\n  readonly resource: string\n  readonly deps: Deps\n  readonly key: (...depsValues: DepsArgs<S, Deps>) => unknown\n  readonly triggers?: ReadonlyArray<'onMount' | 'onKeyChange' | 'manual'>\n  readonly debounceMs?: number\n  readonly concurrency?: 'switch' | 'exhaust-trailing'\n  /**\n   * Serializable metadata for Devtools/docs (whitelisted fields are extracted during build).\n   */\n  readonly meta?: TraitMeta\n}): StateTraitEntry<S, P> => {\n  const key = (state: Readonly<S>): unknown => {\n    const args = (input.deps as ReadonlyArray<string>).map((dep) => RowId.getAtPath(state as any, dep))\n    return (input.key as any)(...args)\n  }\n  return {\n    fieldPath: undefined as unknown as P,\n    kind: 'source',\n    meta: { ...input, key },\n  } as StateTraitEntry<S, P>\n}\n\n/**\n * StateTrait.externalStore:\n * - Declares that a field is written back from an ExternalStore (external input or Module-as-Source).\n * - The field is treated as external-owned: do not write to it from reducers/computed/link/source; use separate fields + derived traits.\n */\nexport const externalStore = <S extends object, P extends StateFieldPath<S>, T = StateAtPath<S, P>>(input: {\n  readonly store: ExternalStoreType<T>\n  readonly select?: (snapshot: T) => StateAtPath<S, P>\n  readonly equals?: (prev: StateAtPath<S, P>, next: StateAtPath<S, P>) => boolean\n  readonly coalesceWindowMs?: number\n  readonly priority?: Model.TraitLane\n  readonly meta?: TraitMeta\n}): StateTraitEntry<S, P> =>\n  ({\n    fieldPath: undefined as unknown as P,\n    kind: 'externalStore',\n    meta: input as any,\n  }) as StateTraitEntry<S, P>\n\n/**\n * StateTrait.link:\n * - Declares a linkage from another field into the target field.\n * - `meta.from` is also constrained by `StateFieldPath<S>`.\n */\nexport const link = <S extends object, P extends StateFieldPath<S>>(meta: {\n  from: StateFieldPath<S>\n  /**\n   * 043: explicit converge time-slicing scheduling.\n   * - unset: immediate (default behavior unchanged)\n   * - deferred: can be postponed and merged into later windows (requires runtime time-slicing enabled)\n   */\n  scheduling?: Model.TraitConvergeScheduling\n}): StateTraitEntry<S, P> =>\n  ({\n    fieldPath: undefined as unknown as P,\n    kind: 'link',\n    meta: { ...meta, ...(meta.scheduling ? { scheduling: meta.scheduling } : {}) },\n  }) as StateTraitEntry<S, P>\n\n/**\n * StateTrait.build:\n * - Normalizes the spec into an executable Program (including Graph/Plan).\n * - When DSL and build constraints differ, build is the final authority (e.g. requiring explicit deps).\n */\nexport const build = <S extends object>(\n  stateSchema: Schema.Schema<S, any>,\n  spec: StateTraitSpec<S>,\n): StateTraitProgram<S> => InternalBuild.build(stateSchema, spec)\n\n/**\n * StateTrait.install:\n * - Installs Program-defined behavior (computed/link/source/check, etc.) on top of a Bound API.\n * - Each PlanStep corresponds to a long-lived Effect mounted into the runtime Scope.\n */\nexport const install = <S extends object>(\n  bound: BoundApi<any, any>,\n  program: StateTraitProgram<S>,\n): Effect.Effect<void, never, any> => InternalInstall.install(bound, program)\n\n/**\n * StateTrait.exportStaticIr:\n * - Exports minimal Static IR (aligned with 009 canonical FieldPath constraints) for Devtools / Alignment Lab.\n * - The return value must be JSON-stringifiable (evidence packages / replay pipeline).\n */\nexport type StaticIr = InternalIr.StaticIr\n\nexport const exportStaticIr = (\n  program: StateTraitProgram<any>,\n  moduleId: string,\n  options?: {\n    readonly version?: string\n  },\n): StaticIr =>\n  InternalIr.exportStaticIr({\n    program,\n    moduleId,\n    version: options?.version,\n  })\n"],
  "mappings": "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",
  "names": ["Effect", "resume", "writeValue", "signal", "Effect", "FiberRef", "Effect", "FiberRef", "list", "Effect", "build", "install", "exportStaticIr"]
}
