@logixjs/core 0.0.1 → 0.0.2

package/dist/{chunk-JGIWG6SR.js → chunk-MS77U77X.js}

@@ -1,21 +1,28 @@
 import {
   build,
   diffDeps,
+  emitDepsMismatch,
+  emitSchemaMismatch,
+  onceInRunSession,
   syncIdleInTransaction,
   trace
-} from "./chunk-PYOE4VSI.js";
+} from "./chunk-JBKYRTCS.js";
 import {
   RowIdStore,
   collectListConfigs
-} from "./chunk-BABLDP24.js";
+} from "./chunk-KSZQYSEH.js";
 import {
-  RuntimeServiceBuiltinsTag,
-  evaluateFullCutoverGate
-} from "./chunk-KP7MUZNX.js";
+  currentTxnOriginOverride,
+  getLogicUnitMeta
+} from "./chunk-Y4VRBIS6.js";
 import {
   EvidenceCollectorTag,
   ProcessRuntimeTag
-} from "./chunk-PAYXCY6A.js";
+} from "./chunk-G7ESIQTI.js";
+import {
+  RuntimeServiceBuiltinsTag,
+  evaluateFullCutoverGate
+} from "./chunk-5W2V2NVJ.js";
 import {
   FullCutoverGateModeTag,
   RuntimeServicesRegistryTag,
@@ -25,7 +32,7 @@ import {
   selectRuntimeService,
   setKernelImplementationRef,
   setRuntimeServicesEvidence
-} from "./chunk-ZGDVUPTM.js";
+} from "./chunk-EB4RGQO3.js";
 import {
   LifecycleContext,
   LogicPhaseServiceTag,
@@ -33,44 +40,47 @@ import {
   emitEnvServiceNotFoundDiagnosticIfNeeded,
   emitInvalidPhaseDiagnosticIfNeeded,
   makeLifecycleManager
-} from "./chunk-BE3HW4FY.js";
-import {
-  enterSyncTransaction,
-  exitSyncTransaction,
-  inSyncTransactionFiber
-} from "./chunk-ZFLHVFUC.js";
+} from "./chunk-34CF6OGE.js";
 import {
   Tag
 } from "./chunk-KL5ACTCT.js";
 import {
   RootContextTag
-} from "./chunk-AUIR5O6W.js";
+} from "./chunk-3VZYDNXZ.js";
 import {
   currentConvergeStaticIrCollectors
 } from "./chunk-M3BFQ7HK.js";
 import {
+  compareFieldPath,
   dirtyPathsToRootIds,
   getFieldPathId,
   isPrefixOf,
   normalizeFieldPath,
   normalizePatchReason
-} from "./chunk-IHVBV5C2.js";
+} from "./chunk-ZTFTABXV.js";
 import {
   setRuntimeInternals
-} from "./chunk-3RMKLXHX.js";
+} from "./chunk-KLDVG3SY.js";
 import {
   ConcurrencyPolicyOverridesTag,
   ConcurrencyPolicyTag,
   ReadQueryStrictGateConfigTag,
+  RuntimeStoreTag,
   StateTransactionConfigTag,
   StateTransactionOverridesTag,
+  TickSchedulerTag,
+  enterSyncTransaction,
+  exitSyncTransaction,
   getDefaultStateTxnInstrumentation,
-  isDevEnv
-} from "./chunk-3QMIVH35.js";
+  inSyncTransactionFiber,
+  isDevEnv,
+  makeModuleInstanceKey
+} from "./chunk-AQ7L2QZ5.js";
 import {
-  compile,
-  evaluateStrictGate
-} from "./chunk-CW6T36TN.js";
+  RunSessionTag,
+  make,
+  run
+} from "./chunk-I4LCE5OY.js";
 import {
   currentDebugSinks,
   currentDiagnosticsLevel,
@@ -81,20 +91,19 @@ import {
   isErrorOnlyOnlySinks,
   record,
   toSerializableErrorSummary
-} from "./chunk-DMBALCE2.js";
-import {
-  fnv1a32,
-  stableStringify
-} from "./chunk-GMPEOUP2.js";
-import {
-  RunSessionTag,
-  make,
-  run
-} from "./chunk-OFADUJWJ.js";
+} from "./chunk-ZC7MSQ5U.js";
 import {
   EffectOpMiddlewareTag,
   currentLinkId
-} from "./chunk-JWOYLO27.js";
+} from "./chunk-WYJUJV4L.js";
+import {
+  compile,
+  evaluateStrictGate
+} from "./chunk-M3M7JFAH.js";
+import {
+  fnv1a32,
+  stableStringify
+} from "./chunk-4MZ7BT3R.js";
 
 // src/internal/runtime/core/ModuleRuntime.registry.ts
 var runtimeRegistry = /* @__PURE__ */ new WeakMap();
@@ -113,39 +122,15 @@ var unregisterRuntimeByInstanceKey = (instanceKey) => {
   runtimeByInstanceKey.delete(instanceKey);
 };
 
-// src/internal/runtime/core/LogicUnitMeta.ts
-var LOGIC_UNIT_META = /* @__PURE__ */ Symbol.for("logix.module.logic.meta");
-var getLogicUnitMeta = (logic) => {
-  if (!logic || typeof logic !== "object" && typeof logic !== "function") {
-    return void 0;
-  }
-  return logic[LOGIC_UNIT_META];
-};
-var attachLogicUnitMeta = (logic, meta) => {
-  try {
-    Object.defineProperty(logic, LOGIC_UNIT_META, {
-      value: meta,
-      enumerable: false,
-      configurable: true
-    });
-  } catch {
-  }
-  return logic;
-};
-var updateLogicUnitMeta = (logic, patch) => {
-  const prev = getLogicUnitMeta(logic);
-  return attachLogicUnitMeta(logic, { ...prev ?? {}, ...patch });
-};
-
-// src/internal/runtime/core/ModuleRuntime.ts
+// src/internal/runtime/core/ModuleRuntime.impl.ts
 import {
-  Effect as Effect21,
+  Effect as Effect20,
   Stream as Stream2,
   SubscriptionRef as SubscriptionRef3,
   PubSub as PubSub4,
   Context as Context2,
   FiberRef as FiberRef8,
-  Option as Option10,
+  Option as Option9,
   Queue as Queue3,
   Duration,
   Chunk as Chunk3
@@ -426,7 +411,7 @@ var makeRunOperation = (args) => {
 };
 
 // src/internal/runtime/core/ModuleRuntime.dispatch.ts
-import { Effect as Effect4, PubSub } from "effect";
+import { Effect as Effect4, FiberRef as FiberRef2, PubSub } from "effect";
 
 // src/internal/runtime/core/ReducerDiagnostics.ts
 import { Cause, Chunk, Effect as Effect3 } from "effect";
@@ -597,9 +582,9 @@ var makeDispatchOps = (args) => {
       )
     );
   };
-  const makeActionOrigin = (originName, action) => ({
-    kind: "action",
-    name: originName,
+  const makeActionOrigin = (originName, action, override) => ({
+    kind: override?.kind ?? "action",
+    name: override?.name ?? originName,
     details: {
       _tag: resolveActionTag2(action) ?? "unknown",
       path: typeof action?.payload?.path === "string" ? action.payload.path : void 0,
@@ -642,16 +627,16 @@ var makeDispatchOps = (args) => {
       yield* PubSub.publish(actionCommitHub, { value: action, meta });
     }
   });
-  const runDispatch = (action) => runOperation(
+  const runDispatch = (action, override) => runOperation(
     "action",
     "action:dispatch",
     {
       payload: action,
       meta: { moduleId: optionsModuleId, instanceId }
     },
-    runWithStateTransaction(makeActionOrigin("dispatch", action), () => dispatchInTransaction(action))
+    runWithStateTransaction(makeActionOrigin("dispatch", action, override), () => dispatchInTransaction(action))
   ).pipe(Effect4.asVoid);
-  const runDispatchLowPriority = (action) => runOperation(
+  const runDispatchLowPriority = (action, override) => runOperation(
     "action",
     "action:dispatchLowPriority",
     {
@@ -659,7 +644,7 @@ var makeDispatchOps = (args) => {
       meta: { moduleId: optionsModuleId, instanceId }
     },
     runWithStateTransaction(
-      makeActionOrigin("dispatchLowPriority", action),
+      makeActionOrigin("dispatchLowPriority", action, override),
       () => Effect4.gen(function* () {
         if (txnContext.current) {
           ;
@@ -670,7 +655,7 @@ var makeDispatchOps = (args) => {
       })
     )
   ).pipe(Effect4.asVoid);
-  const runDispatchBatch = (actions) => {
+  const runDispatchBatch = (actions, override) => {
     if (actions.length === 0) return Effect4.void;
     return runOperation(
       "action",
@@ -680,7 +665,7 @@ var makeDispatchOps = (args) => {
         meta: { moduleId: optionsModuleId, instanceId }
       },
       runWithStateTransaction(
-        { kind: "action", name: "dispatchBatch", details: { count: actions.length } },
+        { kind: override?.kind ?? "action", name: override?.name ?? "dispatchBatch", details: { count: actions.length } },
         () => Effect4.gen(function* () {
           if (txnContext.current) {
             ;
@@ -712,14 +697,26 @@ var makeDispatchOps = (args) => {
     registerReducer,
     // Note: publish is a lossless/backpressure channel and may wait.
     // Must run outside the transaction window (FR-012) and must not block the txnQueue consumer fiber (avoid deadlock).
-    dispatch: (action) => enqueueTransaction(runDispatch(action)).pipe(
-      Effect4.zipRight(publishWithPressureDiagnostics("publish", PubSub.publish(actionHub, action)))
+    dispatch: (action) => FiberRef2.get(currentTxnOriginOverride).pipe(
+      Effect4.flatMap(
+        (override) => enqueueTransaction(runDispatch(action, override)).pipe(
+          Effect4.zipRight(publishWithPressureDiagnostics("publish", PubSub.publish(actionHub, action)))
+        )
+      )
     ),
-    dispatchBatch: (actions) => enqueueTransaction(runDispatchBatch(actions)).pipe(
-      Effect4.zipRight(publishWithPressureDiagnostics("publishAll", PubSub.publishAll(actionHub, actions)))
+    dispatchBatch: (actions) => FiberRef2.get(currentTxnOriginOverride).pipe(
+      Effect4.flatMap(
+        (override) => enqueueTransaction(runDispatchBatch(actions, override)).pipe(
+          Effect4.zipRight(publishWithPressureDiagnostics("publishAll", PubSub.publishAll(actionHub, actions)))
+        )
+      )
     ),
-    dispatchLowPriority: (action) => enqueueTransaction(runDispatchLowPriority(action)).pipe(
-      Effect4.zipRight(publishWithPressureDiagnostics("publish", PubSub.publish(actionHub, action)))
+    dispatchLowPriority: (action) => FiberRef2.get(currentTxnOriginOverride).pipe(
+      Effect4.flatMap(
+        (override) => enqueueTransaction(runDispatchLowPriority(action, override)).pipe(
+          Effect4.zipRight(publishWithPressureDiagnostics("publish", PubSub.publish(actionHub, action)))
+        )
+      )
     )
   };
 };
@@ -895,7 +892,7 @@ var makeEffectsRegistry = (args) => {
 };
 
 // src/internal/runtime/core/ModuleRuntime.transaction.ts
-import { Cause as Cause2, Effect as Effect11, Exit, Fiber, FiberRef as FiberRef6, Option as Option4, PubSub as PubSub2, Queue, SubscriptionRef as SubscriptionRef2 } from "effect";
+import { Cause as Cause2, Effect as Effect10, Exit, Fiber, FiberRef as FiberRef6, Option as Option3, PubSub as PubSub2, Queue, SubscriptionRef as SubscriptionRef2 } from "effect";
 
 // src/internal/state-trait/plan-cache.ts
 var rootIdsEquals = (a, b) => {
@@ -1062,8 +1059,8 @@ var StateTraitConfigError = class extends Error {
   }
 };
 
-// src/internal/state-trait/converge-in-transaction.ts
-import { Effect as Effect9, FiberRef as FiberRef4 } from "effect";
+// src/internal/state-trait/converge-in-transaction.impl.ts
+import { Effect as Effect8, FiberRef as FiberRef4 } from "effect";
 
 // src/internal/state-trait/converge-ir.ts
 var getConvergeStaticIrDigest = (ir) => {
@@ -1204,161 +1201,8 @@ var ShallowInPlaceDraft = class {
   }
 };
 
-// src/internal/state-trait/converge-diagnostics.ts
-import { Effect as Effect6, FiberRef as FiberRef2, Option as Option2 } from "effect";
-import * as SchemaAST from "effect/SchemaAST";
-var onceKeysFallback = /* @__PURE__ */ new Set();
-var onceInRunSession = (key) => Effect6.serviceOption(RunSessionTag).pipe(
-  Effect6.map((maybe) => {
-    if (Option2.isSome(maybe)) {
-      return maybe.value.local.once(key);
-    }
-    if (onceKeysFallback.has(key)) return false;
-    onceKeysFallback.add(key);
-    return true;
-  })
-);
-var formatList = (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 emitDepsMismatch = (params) => {
-  return Effect6.gen(function* () {
-    const key = `${params.moduleId ?? "unknown"}::${params.instanceId ?? "unknown"}::${params.kind}::${params.fieldPath}`;
-    const shouldEmit = yield* onceInRunSession(`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=[${formatList(params.diff.declared)}] reads=[${formatList(params.diff.reads)}] missing=[${formatList(params.diff.missing)}] unused=[${formatList(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 (SchemaAST.isSuspend(current)) {
-      if (seen.has(current)) {
-        return true;
-      }
-      seen.add(current);
-      current = current.f();
-      continue;
-    }
-    if (SchemaAST.isRefinement(current)) {
-      current = current.from;
-      continue;
-    }
-    break;
-  }
-  if (SchemaAST.isTransformation(current)) {
-    return schemaHasPath(current.to, segments, seen) || schemaHasPath(current.from, segments, seen);
-  }
-  if (SchemaAST.isUnion(current)) {
-    return current.types.some((t) => schemaHasPath(t, segments, seen));
-  }
-  if (SchemaAST.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 (SchemaAST.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 (SchemaAST.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) => Effect6.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* onceInRunSession(`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"
-  });
-});
-
 // src/internal/state-trait/exec-vm-mode.ts
-import { Effect as Effect7, FiberRef as FiberRef3, Layer } from "effect";
+import { Effect as Effect6, FiberRef as FiberRef3, Layer } from "effect";
 var currentExecVmMode = FiberRef3.unsafeMake(false);
 var execVmModeLayer = (enabled) => Layer.fiberRefLocallyScopedWith(currentExecVmMode, () => enabled);
 
@@ -1594,9 +1438,9 @@ var makeConvergeExecIr = (ir) => {
 };
 
 // src/internal/state-trait/converge-step.ts
-import { Effect as Effect8, Option as Option3 } from "effect";
-var getMiddlewareStack2 = () => Effect8.serviceOption(EffectOpMiddlewareTag).pipe(
-  Effect8.map((maybe) => Option3.isSome(maybe) ? maybe.value.stack : [])
+import { Effect as Effect7, Option as Option2 } from "effect";
+var getMiddlewareStack2 = () => Effect7.serviceOption(EffectOpMiddlewareTag).pipe(
+  Effect7.map((maybe) => Option2.isSome(maybe) ? maybe.value.stack : [])
 );
 var getWriterKind = (entry) => entry.kind === "computed" ? "computed" : entry.kind === "link" ? "link" : void 0;
 var getWriterDeps = (entry) => {
@@ -1648,7 +1492,7 @@ var runWriterStep = (ctx, execIr, draft, stepId, entry, shouldCollectDecision, d
   const instanceId = ctx.instanceId;
   const fieldPath = entry.fieldPath;
   const kind = getWriterKind(entry);
-  if (!kind) return Effect8.succeed(false);
+  if (!kind) return Effect7.succeed(false);
   const reason = kind === "computed" ? "trait-computed" : "trait-link";
   const opKind = kind === "computed" ? "trait-computed" : "trait-link";
   const opName = kind === "computed" ? "computed:update" : "link:propagate";
@@ -1658,14 +1502,14 @@ var runWriterStep = (ctx, execIr, draft, stepId, entry, shouldCollectDecision, d
   const outPath = execIr.fieldPathsById[outPathId];
   const fromPathId = execIr.stepFromFieldPathIdByStepId[stepId];
   const fromPath = fromPathId >= 0 ? execIr.fieldPathsById[fromPathId] : void 0;
-  return Effect8.gen(function* () {
+  return Effect7.gen(function* () {
     const stepLabel = diagnosticsLevel === "off" ? void 0 : execIr.stepLabelByStepId[stepId] ?? String(stepId);
     let shouldTraceDeps = false;
     if (kind === "computed" && shouldCollectDecision && isDevEnv()) {
       const traceKey = `${moduleId ?? "unknown"}::${instanceId ?? "unknown"}::computed::${fieldPath}`;
       shouldTraceDeps = yield* onceInRunSession(`deps_trace:settled:${traceKey}`);
     }
-    const body = Effect8.sync(() => {
+    const body = Effect7.sync(() => {
       const current = draft.getRoot();
       const prev = draft.getAt(outPath);
       let next;
@@ -1694,14 +1538,14 @@ var runWriterStep = (ctx, execIr, draft, stepId, entry, shouldCollectDecision, d
       ctx.recordPatch(outPathId, reason, prev, next, void 0, stepId);
       return { changed: true, depsDiff };
     }).pipe(
-      Effect8.flatMap(
+      Effect7.flatMap(
         ({ changed, depsDiff }) => depsDiff && kind === "computed" ? emitDepsMismatch({
           moduleId,
           instanceId,
           kind: "computed",
           fieldPath,
           diff: depsDiff
-        }).pipe(Effect8.as(changed)) : Effect8.succeed(changed)
+        }).pipe(Effect7.as(changed)) : Effect7.succeed(changed)
       )
     );
     const meta = {
@@ -1718,8 +1562,8 @@ var runWriterStep = (ctx, execIr, draft, stepId, entry, shouldCollectDecision, d
       ...stepLabel ? { stepId: stepLabel } : null
     };
     if (!(typeof meta.opSeq === "number" && Number.isFinite(meta.opSeq))) {
-      const sessionOpt = yield* Effect8.serviceOption(RunSessionTag);
-      if (Option3.isSome(sessionOpt)) {
+      const sessionOpt = yield* Effect7.serviceOption(RunSessionTag);
+      if (Option2.isSome(sessionOpt)) {
         const key = instanceId ?? "global";
         meta.opSeq = sessionOpt.value.local.nextSeq("opSeq", key);
       }
@@ -1737,7 +1581,7 @@ var runWriterStep = (ctx, execIr, draft, stepId, entry, shouldCollectDecision, d
   });
 };
 
-// src/internal/state-trait/converge-in-transaction.ts
+// src/internal/state-trait/converge-in-transaction.impl.ts
 var pickTop3Steps = (steps) => {
   let first;
   let second;
@@ -1784,7 +1628,7 @@ var insertTopKHotspot = (args) => {
     hotspots.length = topK;
   }
 };
-var convergeInTransaction = (program, ctx) => Effect9.gen(function* () {
+var convergeInTransaction = (program, ctx) => Effect8.gen(function* () {
   yield* emitSchemaMismatch(program, ctx);
   const decisionStartedAt = ctx.now();
   let decisionDurationMs;
@@ -1851,7 +1695,7 @@ var convergeInTransaction = (program, ctx) => Effect9.gen(function* () {
       reasons.push("time_slicing_deferred");
     }
   }
-  const emitTraitConvergeTraceEvent = (decision2) => !shouldCollectDecision ? Effect9.void : record({
+  const emitTraitConvergeTraceEvent = (decision2) => !shouldCollectDecision ? Effect8.void : record({
     type: "trace:trait:converge",
     moduleId: ctx.moduleId,
     instanceId: ctx.instanceId,
@@ -1861,25 +1705,12 @@ var convergeInTransaction = (program, ctx) => Effect9.gen(function* () {
   });
   const registry = ir.fieldPathIdRegistry;
   const dirtyPaths = ctx.dirtyPaths == null ? [] : Array.isArray(ctx.dirtyPaths) ? ctx.dirtyPaths : ctx.dirtyPaths;
-  const dirtyRootIds = dirtyPathsToRootIds({
-    dirtyPaths,
-    registry,
-    dirtyAllReason: ctx.dirtyAllReason
-  });
+  const dirtyPathCountHint = Array.isArray(dirtyPaths) ? dirtyPaths.length : typeof dirtyPaths?.size === "number" ? dirtyPaths.size : void 0;
+  let dirtyRootIds;
   const DIRTY_ROOT_IDS_TOP_K = 3;
   const AUTO_FLOOR_RATIO = 1.05;
-  const dirtySummary = !shouldCollectDecisionDetails ? void 0 : dirtyRootIds.dirtyAll ? {
-    dirtyAll: true,
-    reason: dirtyRootIds.reason ?? "unknownWrite",
-    rootCount: 0,
-    rootIds: [],
-    rootIdsTruncated: false
-  } : {
-    dirtyAll: false,
-    rootCount: dirtyRootIds.rootCount,
-    rootIds: dirtyRootIds.rootIds.slice(0, DIRTY_ROOT_IDS_TOP_K),
-    rootIdsTruncated: dirtyRootIds.rootIds.length > DIRTY_ROOT_IDS_TOP_K
-  };
+  const MAX_CACHEABLE_ROOT_IDS = 128;
+  const MAX_CACHEABLE_ROOT_RATIO = 0.5;
   const configScope = ctx.configScope ?? "builtin";
   const generationEvidence = ctx.generation ?? {
     generation: ir.generation
@@ -2034,9 +1865,23 @@ var convergeInTransaction = (program, ctx) => Effect9.gen(function* () {
   if (cacheMissReasonHint === "generation_bumped" && typeof generationEvidence.generationBumpCount === "number" && generationEvidence.generationBumpCount >= 3 && cache && !cache.isDisabled()) {
     cache.disable("generation_thrash");
   }
-  const canUseCache = !!cache && !cache.isDisabled() && ctx.schedulingScopeStepIds == null && !dirtyRootIds.dirtyAll && dirtyRootIds.rootIds.length > 0;
-  const planKeyHash = dirtyRootIds.keyHash ^ (schedulingScope === "all" ? 0 : schedulingScope === "immediate" ? 1 : 2);
-  const rootIdsKey = canUseCache ? dirtyRootIds.rootIds : void 0;
+  let canUseCache = false;
+  let planKeyHash = 0;
+  let rootIdsKey = void 0;
+  const ensureDirtyRootIds = () => {
+    if (dirtyRootIds) return dirtyRootIds;
+    dirtyRootIds = dirtyPathsToRootIds({
+      dirtyPaths,
+      registry,
+      dirtyAllReason: ctx.dirtyAllReason
+    });
+    const rootRatioForCache = !dirtyRootIds.dirtyAll && scopeStepCount > 0 ? dirtyRootIds.rootCount / scopeStepCount : void 0;
+    const cacheableBySize = !dirtyRootIds.dirtyAll && dirtyRootIds.rootIds.length > 0 && dirtyRootIds.rootIds.length <= MAX_CACHEABLE_ROOT_IDS && (rootRatioForCache == null || rootRatioForCache <= MAX_CACHEABLE_ROOT_RATIO);
+    canUseCache = !!cache && !cache.isDisabled() && ctx.schedulingScopeStepIds == null && cacheableBySize;
+    planKeyHash = dirtyRootIds.keyHash ^ (schedulingScope === "all" ? 0 : schedulingScope === "immediate" ? 1 : 2);
+    rootIdsKey = canUseCache ? dirtyRootIds.rootIds : void 0;
+    return dirtyRootIds;
+  };
   let cacheEvidence = shouldCollectDecisionHeavyDetails ? {
     capacity: 0,
     size: 0,
@@ -2048,11 +1893,12 @@ var convergeInTransaction = (program, ctx) => Effect9.gen(function* () {
   let affectedSteps;
   let planStepIds;
   const getOrComputePlan = (options) => {
-    if (dirtyRootIds.dirtyAll) {
+    const dirty = ensureDirtyRootIds();
+    if (dirty.dirtyAll) {
       if (cacheEvidence && cache) {
         cacheEvidence = cache.evidence({
           hit: false,
-          keySize: dirtyRootIds.keySize,
+          keySize: dirty.keySize,
           missReason: options?.missReason ?? "unknown"
         });
       }
@@ -2066,7 +1912,7 @@ var convergeInTransaction = (program, ctx) => Effect9.gen(function* () {
         if (cacheEvidence) {
           cacheEvidence = cache.evidence({
             hit: true,
-            keySize: dirtyRootIds.keySize
+            keySize: dirty.keySize
           });
         }
         affectedSteps = cached.length;
@@ -2077,24 +1923,34 @@ var convergeInTransaction = (program, ctx) => Effect9.gen(function* () {
       if (cacheEvidence && cache) {
         cacheEvidence = cache.evidence({
           hit: false,
-          keySize: dirtyRootIds.keySize,
+          keySize: dirty.keySize,
           missReason: options?.missReason ?? "unknown"
         });
       }
-      return { hit: false, budgetCutoff: true };
+      const fullPlan = scopeStepIds;
+      affectedSteps = fullPlan.length;
+      if (canUseCache && cache && rootIdsKey) {
+        cache.set(planKeyHash, rootIdsKey, fullPlan);
+      }
+      return { plan: fullPlan, hit: false, budgetCutoff: true };
     }
-    const computed = computePlanStepIds(dirtyRootIds.rootIds, {
+    const computed = computePlanStepIds(dirty.rootIds, {
       stopOnDecisionBudget: options?.stopOnDecisionBudget
     });
     if (computed.budgetCutoff) {
       if (cacheEvidence && cache) {
         cacheEvidence = cache.evidence({
           hit: false,
-          keySize: dirtyRootIds.keySize,
+          keySize: dirty.keySize,
           missReason: options?.missReason ?? "unknown"
         });
       }
-      return { hit: false, budgetCutoff: true };
+      const fullPlan = scopeStepIds;
+      affectedSteps = fullPlan.length;
+      if (canUseCache && cache && rootIdsKey) {
+        cache.set(planKeyHash, rootIdsKey, fullPlan);
+      }
+      return { plan: fullPlan, hit: false, budgetCutoff: true };
     }
     const plan = computed.plan ?? new Int32Array(0);
     if (canUseCache && cache && rootIdsKey) {
@@ -2103,60 +1959,82 @@ var convergeInTransaction = (program, ctx) => Effect9.gen(function* () {
     if (cacheEvidence && cache) {
       cacheEvidence = cache.evidence({
         hit: false,
-        keySize: dirtyRootIds.keySize,
+        keySize: dirty.keySize,
         missReason: options?.missReason ?? "not_cached"
       });
     }
     affectedSteps = plan.length;
     return { plan, hit: false };
   };
-  const NEAR_FULL_ROOT_RATIO_THRESHOLD = 0.75;
+  const getNearFullRootRatioThreshold = (stepCount) => {
+    if (stepCount >= 1536) return 0.65;
+    if (stepCount >= 1024) return 0.7;
+    if (stepCount >= 512) return 0.75;
+    return 0.9;
+  };
   const NEAR_FULL_PLAN_RATIO_THRESHOLD = 0.9;
   if (requestedMode === "auto") {
     if (ctx.txnSeq === 1) {
       mode = "full";
       reasons.push("cold_start");
-    } else if (dirtyRootIds.dirtyAll) {
+    } else if (ctx.dirtyAllReason) {
       mode = "full";
       reasons.push("dirty_all");
       reasons.push("unknown_write");
-    } else if (dirtyRootIds.rootIds.length === 0) {
+    } else if (dirtyPathCountHint === 0) {
       mode = "full";
       reasons.push("unknown_write");
     } else {
-      const rootRatio = scopeStepCount > 0 ? dirtyRootIds.rootCount / scopeStepCount : 1;
-      if (rootRatio >= NEAR_FULL_ROOT_RATIO_THRESHOLD) {
+      const nearFullRootRatioThreshold = getNearFullRootRatioThreshold(scopeStepCount);
+      const rootRatio = typeof dirtyPathCountHint === "number" && Number.isFinite(dirtyPathCountHint) && dirtyPathCountHint >= 0 ? scopeStepCount > 0 ? dirtyPathCountHint / scopeStepCount : 1 : void 0;
+      if (rootRatio != null && rootRatio >= nearFullRootRatioThreshold) {
         mode = "full";
         reasons.push("near_full");
       } else {
-        const { plan, hit, budgetCutoff } = getOrComputePlan({
-          missReason: cacheMissReasonHint ?? "not_cached",
-          stopOnDecisionBudget: decisionBudgetMs != null
-        });
-        if (budgetCutoff || !plan) {
+        const dirty = ensureDirtyRootIds();
+        if (dirty.dirtyAll) {
+          mode = "full";
+          reasons.push("dirty_all");
+          reasons.push("unknown_write");
+        } else if (dirty.rootIds.length === 0) {
           mode = "full";
-          markDecisionBudgetCutoff();
+          reasons.push("unknown_write");
+        } else if ((scopeStepCount > 0 ? dirty.rootCount / scopeStepCount : 1) >= nearFullRootRatioThreshold) {
+          mode = "full";
+          reasons.push("near_full");
         } else {
-          planStepIds = plan;
-          reasons.push(hit ? "cache_hit" : "cache_miss");
-          const ratio = scopeStepCount > 0 ? plan.length / scopeStepCount : 1;
-          if (ratio >= NEAR_FULL_PLAN_RATIO_THRESHOLD) {
-            mode = "full";
-            reasons.push("near_full");
-          } else {
+          const { plan, hit, budgetCutoff } = getOrComputePlan({
+            missReason: cacheMissReasonHint ?? "not_cached",
+            stopOnDecisionBudget: decisionBudgetMs != null
+          });
+          if (budgetCutoff) {
+            markDecisionBudgetCutoff();
+          }
+          if (!plan) {
             mode = "dirty";
+          } else {
+            planStepIds = plan;
+            reasons.push(hit ? "cache_hit" : "cache_miss");
+            const ratio = scopeStepCount > 0 ? plan.length / scopeStepCount : 1;
+            if (ratio >= NEAR_FULL_PLAN_RATIO_THRESHOLD) {
+              mode = "full";
+              reasons.push("near_full");
+            } else {
+              mode = "dirty";
+            }
           }
         }
       }
     }
   } else {
     reasons.push("module_override");
+    const dirty = ensureDirtyRootIds();
     if (mode === "dirty") {
       const { plan, hit } = getOrComputePlan({ missReason: cacheMissReasonHint ?? "not_cached" });
       planStepIds = plan;
-      if (dirtyRootIds.dirtyAll) {
+      if (dirty.dirtyAll) {
         reasons.push("dirty_all");
-      } else if (cache && dirtyRootIds.rootIds.length > 0) {
+      } else if (cache && dirty.rootIds.length > 0) {
         reasons.push(hit ? "cache_hit" : "cache_miss");
       }
     }
@@ -2164,6 +2042,48 @@ var convergeInTransaction = (program, ctx) => Effect9.gen(function* () {
   if (cacheEvidence?.disabled && cacheEvidence.disableReason === "low_hit_rate" && !reasons.includes("low_hit_rate_protection")) {
     reasons.push("low_hit_rate_protection");
   }
+  const getDirtySummary = () => {
+    if (!shouldCollectDecisionDetails) return void 0;
+    const requiresRootIds = diagnosticsLevel === "light" || diagnosticsLevel === "full" || requestedMode === "dirty" || mode === "dirty" || dirtyRootIds != null;
+    const dirty = requiresRootIds && dirtyRootIds == null && (diagnosticsLevel === "light" || diagnosticsLevel === "full") ? ensureDirtyRootIds() : dirtyRootIds;
+    if (dirty?.dirtyAll) {
+      return {
+        dirtyAll: true,
+        reason: dirty.reason ?? "unknownWrite",
+        rootCount: 0,
+        ...requiresRootIds ? { rootIds: [], rootIdsTruncated: false } : null
+      };
+    }
+    if (dirty) {
+      return {
+        dirtyAll: false,
+        rootCount: dirty.rootCount,
+        ...requiresRootIds ? {
+          rootIds: dirty.rootIds.slice(0, DIRTY_ROOT_IDS_TOP_K),
+          rootIdsTruncated: dirty.rootIds.length > DIRTY_ROOT_IDS_TOP_K
+        } : null
+      };
+    }
+    if (typeof dirtyPathCountHint === "number" && dirtyPathCountHint === 0) {
+      return {
+        dirtyAll: true,
+        reason: "unknownWrite",
+        rootCount: 0
+      };
+    }
+    if (typeof dirtyPathCountHint === "number") {
+      return {
+        dirtyAll: false,
+        rootCount: dirtyPathCountHint
+      };
+    }
+    return {
+      dirtyAll: true,
+      reason: "unknownWrite",
+      rootCount: 0,
+      ...requiresRootIds ? { rootIds: [], rootIdsTruncated: false } : null
+    };
+  };
   executionStartedAt = ctx.now();
   if (requestedMode === "auto") {
     decisionDurationMs = Math.max(0, executionStartedAt - decisionStartedAt);
@@ -2185,8 +2105,8 @@ var convergeInTransaction = (program, ctx) => Effect9.gen(function* () {
       staticIrDigest,
       executionBudgetMs: ctx.budgetMs,
       executionDurationMs: params.executionDurationMs,
-      ...requestedMode === "auto" && ctx.decisionBudgetMs != null ? { decisionBudgetMs: ctx.decisionBudgetMs } : null,
-      ...requestedMode === "auto" && decisionDurationMs != null ? { decisionDurationMs } : null,
+      decisionBudgetMs: requestedMode === "auto" ? ctx.decisionBudgetMs : void 0,
+      decisionDurationMs: requestedMode === "auto" ? decisionDurationMs : void 0,
       reasons,
       stepStats
     };
@@ -2194,11 +2114,13 @@ var convergeInTransaction = (program, ctx) => Effect9.gen(function* () {
       return base2;
     }
     if (!shouldCollectDecisionHeavyDetails) {
+      const dirtySummary2 = getDirtySummary();
       return {
         ...base2,
-        dirty: dirtySummary
+        dirty: dirtySummary2
       };
     }
+    const dirtySummary = getDirtySummary();
     return {
       ...base2,
       thresholds: { floorRatio: AUTO_FLOOR_RATIO },
@@ -2220,6 +2142,7 @@ var convergeInTransaction = (program, ctx) => Effect9.gen(function* () {
   const canUseInPlaceDraft = ctx.allowInPlaceDraft === true && execIr.allOutPathsShallow;
   const draft = canUseInPlaceDraft ? new ShallowInPlaceDraft(base) : new CowDraft(base);
   let budgetChecks = 0;
+  const dirtyRootIdsForExecution = mode === "dirty" ? ensureDirtyRootIds() : void 0;
   const rollbackDraft = () => {
     if (draft instanceof ShallowInPlaceDraft) {
       draft.rollback();
@@ -2227,14 +2150,10 @@ var convergeInTransaction = (program, ctx) => Effect9.gen(function* () {
     ctx.setDraft(base);
   };
   try {
-    if (mode === "dirty" && !planStepIds) {
-      const { plan } = getOrComputePlan({ missReason: cacheMissReasonHint ?? "not_cached" });
-      planStepIds = plan;
-    }
     let dirtyPrefixSet;
-    if (mode === "dirty" && !dirtyRootIds.dirtyAll) {
+    if (mode === "dirty" && !planStepIds && dirtyRootIdsForExecution && !dirtyRootIdsForExecution.dirtyAll) {
       dirtyPrefixBitSet.clear();
-      const roots = dirtyRootIds.rootIds;
+      const roots = dirtyRootIdsForExecution.rootIds;
       for (let i = 0; i < roots.length; i++) {
         addPathPrefixes(roots[i]);
       }
@@ -2308,7 +2227,7 @@ var convergeInTransaction = (program, ctx) => Effect9.gen(function* () {
       executedSteps += 1;
       if (steps) {
         const stepStartedAt = ctx.now();
-        const exit2 = yield* Effect9.exit(
+        const exit2 = yield* Effect8.exit(
           runWriterStep(ctx, execIr, draft, stepId, entry, shouldCollectDecision, diagnosticsLevel, stack)
         );
         const stepEndedAt = ctx.now();
@@ -2378,7 +2297,7 @@ var convergeInTransaction = (program, ctx) => Effect9.gen(function* () {
       }
       if (hotspots) {
         const stepStartedAt = ctx.now();
-        const exit2 = yield* Effect9.exit(
+        const exit2 = yield* Effect8.exit(
           runWriterStep(ctx, execIr, draft, stepId, entry, shouldCollectDecision, diagnosticsLevel, stack)
         );
         const stepEndedAt = ctx.now();
@@ -2452,7 +2371,7 @@ var convergeInTransaction = (program, ctx) => Effect9.gen(function* () {
         }
         continue;
       }
-      const exit = yield* Effect9.exit(
+      const exit = yield* Effect8.exit(
         runWriterStep(ctx, execIr, draft, stepId, entry, shouldCollectDecision, diagnosticsLevel, stack)
       );
       if (exit._tag === "Failure") {
@@ -2554,8 +2473,8 @@ var convergeInTransaction = (program, ctx) => Effect9.gen(function* () {
   };
 });
 
-// src/internal/state-trait/validate.ts
-import { Effect as Effect10, FiberRef as FiberRef5 } from "effect";
+// src/internal/state-trait/validate.impl.ts
+import { Effect as Effect9, FiberRef as FiberRef5 } from "effect";
 import { create } from "mutative";
 
 // src/internal/state-trait/graph.ts
@@ -2589,7 +2508,7 @@ var reverseClosure = (graph, target) => {
   return visited;
 };
 
-// src/internal/state-trait/validate.ts
+// src/internal/state-trait/validate.impl.ts
 var RULE_SKIP = /* @__PURE__ */ Symbol.for("logix.state-trait.validate.skip");
 var parseSegments = (path) => {
   if (!path) return [];
@@ -2996,11 +2915,11 @@ var evalCheck = (entry, input, ctx) => {
   if (!ran) return RULE_SKIP;
   return mergeRuleErrors(results);
 };
-var validateInTransaction = (program, ctx, requests) => Effect10.gen(function* () {
+var validateInTransaction = (program, ctx, requests) => Effect9.gen(function* () {
   const diagnosticsLevel = yield* FiberRef5.get(currentDiagnosticsLevel);
   const enableTrace = diagnosticsLevel !== "off";
   const traceEvents = enableTrace ? [] : void 0;
-  yield* Effect10.sync(() => {
+  yield* Effect9.sync(() => {
     if (requests.length === 0) return;
     const checks = program.entries.filter(
       (e) => e.kind === "check"
@@ -3504,7 +3423,7 @@ var validateInTransaction = (program, ctx, requests) => Effect10.gen(function* (
     }
   });
   if (traceEvents && traceEvents.length > 0) {
-    yield* Effect10.forEach(traceEvents, (event) => record(event), {
+    yield* Effect9.forEach(traceEvents, (event) => record(event), {
       discard: true
     });
   }
@@ -3545,44 +3464,48 @@ var makeTransactionOps = (args) => {
     txnHistory,
     txnById
   } = args;
-  const readState = Effect11.gen(function* () {
+  const readState = Effect10.gen(function* () {
     const inTxn = yield* FiberRef6.get(inSyncTransactionFiber);
     const current = txnContext.current;
     if (inTxn && current) return current.draft;
     return yield* SubscriptionRef2.get(stateRef);
   });
-  const runWithStateTransaction = (origin, body) => Effect11.locally(
+  const runWithStateTransaction = (origin, body) => Effect10.locally(
     inSyncTransactionFiber,
     true
   )(
-    Effect11.gen(function* () {
+    Effect10.gen(function* () {
       const baseState = yield* SubscriptionRef2.get(stateRef);
       beginTransaction(txnContext, origin, baseState);
       const txnCurrent = txnContext.current;
       txnCurrent.stateTraitValidateRequests = [];
       txnCurrent.commitMode = "normal";
       txnCurrent.priority = "normal";
+      const stateCommitPriority = origin?.details?.stateCommit?.priority;
+      if (stateCommitPriority === "low" || stateCommitPriority === "normal") {
+        txnCurrent.priority = stateCommitPriority;
+      }
       const txnId = txnContext.current?.txnId;
       const txnSeq = txnContext.current?.txnSeq;
       enterSyncTransaction();
       let exit;
       try {
-        exit = yield* Effect11.exit(
-          Effect11.locally(
+        exit = yield* Effect10.exit(
+          Effect10.locally(
             currentTxnId,
             txnId
           )(
-            Effect11.gen(function* () {
+            Effect10.gen(function* () {
               let traitSummary;
               if (isDevEnv2()) {
-                const bodyFiber = yield* Effect11.fork(body());
+                const bodyFiber = yield* Effect10.fork(body());
                 const YIELD_BUDGET = 5;
                 let polled = yield* Fiber.poll(bodyFiber);
-                for (let i = 0; i < YIELD_BUDGET && Option4.isNone(polled); i++) {
-                  yield* Effect11.yieldNow();
+                for (let i = 0; i < YIELD_BUDGET && Option3.isNone(polled); i++) {
+                  yield* Effect10.yieldNow();
                   polled = yield* Fiber.poll(bodyFiber);
                 }
-                if (Option4.isNone(polled)) {
+                if (Option3.isNone(polled)) {
                   yield* record({
                     type: "diagnostic",
                     moduleId: optionsModuleId,
@@ -3599,8 +3522,8 @@ var makeTransactionOps = (args) => {
                 }
                 const bodyExit = yield* Fiber.await(bodyFiber);
                 yield* Exit.match(bodyExit, {
-                  onFailure: (cause) => Effect11.failCause(cause),
-                  onSuccess: () => Effect11.void
+                  onFailure: (cause) => Effect10.failCause(cause),
+                  onSuccess: () => Effect10.void
                 });
               } else {
                 yield* body();
@@ -3619,7 +3542,7 @@ var makeTransactionOps = (args) => {
                   deferredSlice.start,
                   deferredSlice.end
                 ) : void 0;
-                const convergeExit = yield* Effect11.exit(
+                const convergeExit = yield* Effect10.exit(
                   convergeInTransaction(
                     stateTraitProgram,
                     {
@@ -3672,7 +3595,7 @@ var makeTransactionOps = (args) => {
                       kind: `state_trait_config_error:${configError.code}`
                     });
                   }
-                  return yield* Effect11.failCause(convergeExit.cause);
+                  return yield* Effect10.failCause(convergeExit.cause);
                 }
                 const outcome = convergeExit.value;
                 const dirtyAllReasonForDeferred = txnContext.current?.dirtyAllReason;
@@ -3692,8 +3615,8 @@ var makeTransactionOps = (args) => {
                   const runtimeLabel = yield* FiberRef6.get(currentRuntimeLabel);
                   const diagnosticsLevel = yield* FiberRef6.get(currentDiagnosticsLevel);
                   const debugSinks = yield* FiberRef6.get(currentDebugSinks);
-                  const overridesOpt = yield* Effect11.serviceOption(StateTransactionOverridesTag);
-                  const overrides = Option4.isSome(overridesOpt) ? overridesOpt.value : void 0;
+                  const overridesOpt = yield* Effect10.serviceOption(StateTransactionOverridesTag);
+                  const overrides = Option3.isSome(overridesOpt) ? overridesOpt.value : void 0;
                   traitConvergeTimeSlicing.capturedContext = {
                     runtimeLabel,
                     diagnosticsLevel,
@@ -3811,7 +3734,7 @@ var makeTransactionOps = (args) => {
                 "state",
                 "state:update",
                 { meta: { moduleId: optionsModuleId, instanceId } },
-                Effect11.gen(function* () {
+                Effect10.gen(function* () {
                   const replayEvent = txnContext.current?.lastReplayEvent;
                   const commitMode = txnContext.current?.commitMode ?? "normal";
                   const priority = txnContext.current?.priority ?? "normal";
@@ -3945,11 +3868,11 @@ var makeTransactionOps = (args) => {
       }
       if (exit._tag === "Failure") {
         abort(txnContext);
-        return yield* Effect11.failCause(exit.cause);
+        return yield* Effect10.failCause(exit.cause);
       }
     })
   );
-  const setStateInternal = (next, path, reason, from, to, traitNodeId, stepId) => Effect11.gen(function* () {
+  const setStateInternal = (next, path, reason, from, to, traitNodeId, stepId) => Effect10.gen(function* () {
     const inTxn = yield* FiberRef6.get(inSyncTransactionFiber);
     if (inTxn && txnContext.current) {
       const current = txnContext.current;
@@ -3973,7 +3896,7 @@ var makeTransactionOps = (args) => {
             kind: "state",
             name: "setState"
           },
-          () => Effect11.sync(() => {
+          () => Effect10.sync(() => {
             updateDraft(txnContext, next);
             recordStatePatch(path, reason, from, to, traitNodeId, stepId);
           })
@@ -4000,7 +3923,7 @@ var makeTransactionOps = (args) => {
 };
 
 // src/internal/runtime/core/ModuleRuntime.concurrencyPolicy.ts
-import { Effect as Effect12, Option as Option5 } from "effect";
+import { Effect as Effect11, Option as Option4 } from "effect";
 var normalizeConcurrencyLimit = (v) => v === "unbounded" ? "unbounded" : normalizePositiveInt(v);
 var makeResolveConcurrencyPolicy = (args) => {
   const builtinConcurrencyLimit = 16;
@@ -4009,11 +3932,11 @@ var makeResolveConcurrencyPolicy = (args) => {
   const builtinThresholdBacklogCount = 1e3;
   const builtinThresholdBacklogDurationMs = 5e3;
   const builtinWarningCooldownMs = 3e4;
-  return () => Effect12.gen(function* () {
-    const runtimeConfigOpt = yield* Effect12.serviceOption(ConcurrencyPolicyTag);
-    const overridesOpt = yield* Effect12.serviceOption(ConcurrencyPolicyOverridesTag);
-    const runtimeConfig = Option5.isSome(runtimeConfigOpt) ? runtimeConfigOpt.value : void 0;
-    const providerOverrides = Option5.isSome(overridesOpt) ? overridesOpt.value : void 0;
+  return () => Effect11.gen(function* () {
+    const runtimeConfigOpt = yield* Effect11.serviceOption(ConcurrencyPolicyTag);
+    const overridesOpt = yield* Effect11.serviceOption(ConcurrencyPolicyOverridesTag);
+    const runtimeConfig = Option4.isSome(runtimeConfigOpt) ? runtimeConfigOpt.value : void 0;
+    const providerOverrides = Option4.isSome(overridesOpt) ? overridesOpt.value : void 0;
     let concurrencyLimit = builtinConcurrencyLimit;
     let concurrencyLimitScope = "builtin";
     let lastBoundedConcurrencyLimit = builtinConcurrencyLimit;
@@ -4110,7 +4033,7 @@ var makeResolveConcurrencyPolicy = (args) => {
 };
 
 // src/internal/runtime/core/ModuleRuntime.txnLanePolicy.ts
-import { Effect as Effect13, Option as Option6 } from "effect";
+import { Effect as Effect12, Option as Option5 } from "effect";
 var normalizeMs = normalizeNonNegativeNumber;
 var normalizeBool = normalizeBoolean;
 var makeResolveTxnLanePolicy = (args) => {
@@ -4120,11 +4043,11 @@ var makeResolveTxnLanePolicy = (args) => {
   const builtinMaxLagMs = normalizeMs(args.stateTransaction?.txnLanes?.maxLagMs) ?? 50;
   const builtinAllowCoalesce = normalizeBool(args.stateTransaction?.txnLanes?.allowCoalesce) ?? true;
   const builtinYieldStrategy = args.stateTransaction?.txnLanes?.yieldStrategy === "inputPending" ? "inputPending" : "baseline";
-  return () => Effect13.gen(function* () {
-    const runtimeConfigOpt = yield* Effect13.serviceOption(StateTransactionConfigTag);
-    const overridesOpt = yield* Effect13.serviceOption(StateTransactionOverridesTag);
-    const runtimeConfig = Option6.isSome(runtimeConfigOpt) ? runtimeConfigOpt.value : void 0;
-    const providerOverrides = Option6.isSome(overridesOpt) ? overridesOpt.value : void 0;
+  return () => Effect12.gen(function* () {
+    const runtimeConfigOpt = yield* Effect12.serviceOption(StateTransactionConfigTag);
+    const overridesOpt = yield* Effect12.serviceOption(StateTransactionOverridesTag);
+    const runtimeConfig = Option5.isSome(runtimeConfigOpt) ? runtimeConfigOpt.value : void 0;
+    const providerOverrides = Option5.isSome(overridesOpt) ? overridesOpt.value : void 0;
     let enabled = builtinEnabled;
     let budgetMs = builtinBudgetMs;
     let debounceMs = builtinDebounceMs;
@@ -4201,7 +4124,7 @@ var makeResolveTxnLanePolicy = (args) => {
 };
 
 // src/internal/runtime/core/ModuleRuntime.traitConvergeConfig.ts
-import { Effect as Effect14, Option as Option7 } from "effect";
+import { Effect as Effect13, Option as Option6 } from "effect";
 var normalizePositiveMs = normalizePositiveNumber;
 var normalizeRequestedMode = (mode) => mode === "auto" || mode === "full" || mode === "dirty" ? mode : void 0;
 var normalizeBool2 = (value) => typeof value === "boolean" ? value : void 0;
@@ -4212,11 +4135,11 @@ var makeResolveTraitConvergeConfig = (args) => {
   const builtinTimeSlicingEnabled = normalizeBool2(args.stateTransaction?.traitConvergeTimeSlicing?.enabled) ?? false;
   const builtinTimeSlicingDebounceMs = normalizePositiveMs(args.stateTransaction?.traitConvergeTimeSlicing?.debounceMs) ?? 16;
   const builtinTimeSlicingMaxLagMs = normalizePositiveMs(args.stateTransaction?.traitConvergeTimeSlicing?.maxLagMs) ?? 200;
-  return () => Effect14.gen(function* () {
-    const runtimeConfigOpt = yield* Effect14.serviceOption(StateTransactionConfigTag);
-    const overridesOpt = yield* Effect14.serviceOption(StateTransactionOverridesTag);
-    const runtimeConfig = Option7.isSome(runtimeConfigOpt) ? runtimeConfigOpt.value : void 0;
-    const providerOverrides = Option7.isSome(overridesOpt) ? overridesOpt.value : void 0;
+  return () => Effect13.gen(function* () {
+    const runtimeConfigOpt = yield* Effect13.serviceOption(StateTransactionConfigTag);
+    const overridesOpt = yield* Effect13.serviceOption(StateTransactionOverridesTag);
+    const runtimeConfig = Option6.isSome(runtimeConfigOpt) ? runtimeConfigOpt.value : void 0;
+    const providerOverrides = Option6.isSome(overridesOpt) ? overridesOpt.value : void 0;
     let traitConvergeMode = builtinTraitConvergeMode;
     let traitConvergeBudgetMs = builtinTraitConvergeBudgetMs;
     let traitConvergeDecisionBudgetMs = builtinTraitConvergeDecisionBudgetMs;
@@ -4286,14 +4209,14 @@ var makeResolveTraitConvergeConfig = (args) => {
 };
 
 // src/internal/runtime/core/ModuleRuntime.internalHooks.ts
-import { Effect as Effect15 } from "effect";
-var installInternalHooks = (args) => Effect15.sync(() => {
+import { Effect as Effect14 } from "effect";
+var installInternalHooks = (args) => Effect14.sync(() => {
   const { runtime, runtimeInternals } = args;
   setRuntimeInternals(runtime, runtimeInternals);
 });
 
 // src/internal/runtime/core/SelectorGraph.ts
-import { Effect as Effect16, PubSub as PubSub3 } from "effect";
+import { Effect as Effect15, PubSub as PubSub3 } from "effect";
 var getReadRootKeyFromPath = (path) => path[0] ?? "";
 var overlaps = (a, b) => isPrefixOf(a, b) || isPrefixOf(b, a);
 var equalsShallowStruct = (a, b) => {
@@ -4335,9 +4258,9 @@ var make2 = (args) => {
   const ensureEntry = (readQuery) => {
     const existing = selectorsById.get(readQuery.selectorId);
     if (existing) {
-      return Effect16.succeed(existing);
+      return Effect15.succeed(existing);
     }
-    return Effect16.gen(function* () {
+    return Effect15.gen(function* () {
       const hub = yield* PubSub3.unbounded();
       const reads = readQuery.reads.filter((x) => typeof x === "string").map((raw) => normalizeFieldPath(raw)).filter((x) => x != null);
       const readRootKeys = Array.from(new Set(reads.map(getReadRootKeyFromPath)));
@@ -4379,7 +4302,7 @@ var make2 = (args) => {
       }
     }
   };
-  const onCommit = (state, meta, dirtySet, diagnosticsLevel) => Effect16.gen(function* () {
+  const onCommit = (state, meta, dirtySet, diagnosticsLevel, onSelectorChanged) => Effect15.gen(function* () {
     if (selectorsById.size === 0) return;
     const emitEvalEvent = diagnosticsLevel === "light" || diagnosticsLevel === "full" || diagnosticsLevel === "sampled";
     const registry = dirtySet.dirtyAll || dirtySet.rootIds.length === 0 ? void 0 : getFieldPathIdRegistry?.();
@@ -4445,6 +4368,7 @@ var make2 = (args) => {
         entry.cachedValue = next;
         entry.hasValue = true;
         entry.cachedAtTxnSeq = meta.txnSeq;
+        onSelectorChanged?.(entry.selectorId);
         yield* PubSub3.publish(entry.hub, {
           value: entry.cachedValue,
           meta
@@ -4546,6 +4470,7 @@ var make2 = (args) => {
         entry.cachedValue = next;
         entry.hasValue = true;
         entry.cachedAtTxnSeq = meta.txnSeq;
+        onSelectorChanged?.(selectorId);
         yield* PubSub3.publish(entry.hub, {
           value: entry.cachedValue,
           meta
@@ -4576,9 +4501,11 @@ var make2 = (args) => {
 };
 
 // src/internal/runtime/core/ModuleRuntime.txnQueue.ts
-import { Deferred, Effect as Effect17, Exit as Exit2, FiberRef as FiberRef7, Option as Option8, Queue as Queue2, Ref } from "effect";
-var captureDiagnosticContext = (args) => Effect17.gen(function* () {
-  const overridesOpt = yield* Effect17.serviceOption(StateTransactionOverridesTag);
+import { Deferred, Effect as Effect16, Exit as Exit2, FiberRef as FiberRef7, Option as Option7, Queue as Queue2, Ref } from "effect";
+var captureDiagnosticContext = (args) => Effect16.gen(function* () {
+  const overridesOpt = yield* Effect16.serviceOption(StateTransactionOverridesTag);
+  const runtimeStoreOpt = yield* Effect16.serviceOption(RuntimeStoreTag);
+  const tickSchedulerOpt = yield* Effect16.serviceOption(TickSchedulerTag);
   const diagnosticsLevel = yield* FiberRef7.get(currentDiagnosticsLevel);
   const runtimeLabel = yield* FiberRef7.get(currentRuntimeLabel);
   const debugSinks = yield* FiberRef7.get(currentDebugSinks);
@@ -4589,19 +4516,23 @@ var captureDiagnosticContext = (args) => Effect17.gen(function* () {
     runtimeLabel,
     diagnosticsLevel,
     debugSinks,
-    overridesOpt
+    overridesOpt,
+    runtimeStoreOpt,
+    tickSchedulerOpt
   };
 });
 var withDiagnosticContext = (context, eff) => {
-  const effWithOverrides = Option8.isSome(context.overridesOpt) ? Effect17.provideService(eff, StateTransactionOverridesTag, context.overridesOpt.value) : eff;
-  return effWithOverrides.pipe(
-    Effect17.locally(currentLinkId, context.linkId),
-    Effect17.locally(currentRuntimeLabel, context.runtimeLabel),
-    Effect17.locally(currentDiagnosticsLevel, context.diagnosticsLevel),
-    Effect17.locally(currentDebugSinks, context.debugSinks)
+  const effWithOverrides = Option7.isSome(context.overridesOpt) ? Effect16.provideService(eff, StateTransactionOverridesTag, context.overridesOpt.value) : eff;
+  const effWithRuntimeStore = Option7.isSome(context.runtimeStoreOpt) ? Effect16.provideService(effWithOverrides, RuntimeStoreTag, context.runtimeStoreOpt.value) : effWithOverrides;
+  const effWithTickScheduler = Option7.isSome(context.tickSchedulerOpt) ? Effect16.provideService(effWithRuntimeStore, TickSchedulerTag, context.tickSchedulerOpt.value) : effWithRuntimeStore;
+  return effWithTickScheduler.pipe(
+    Effect16.locally(currentLinkId, context.linkId),
+    Effect16.locally(currentRuntimeLabel, context.runtimeLabel),
+    Effect16.locally(currentDiagnosticsLevel, context.diagnosticsLevel),
+    Effect16.locally(currentDebugSinks, context.debugSinks)
   );
 };
-var makeEnqueueTransaction = (args) => Effect17.gen(function* () {
+var makeEnqueueTransaction = (args) => Effect16.gen(function* () {
   const urgentQueue = yield* Queue2.unbounded();
   const nonUrgentQueue = yield* Queue2.unbounded();
   const wakeQueue = yield* Queue2.unbounded();
@@ -4623,7 +4554,7 @@ var makeEnqueueTransaction = (args) => Effect17.gen(function* () {
     waiters: 0,
     signal: initialNonUrgentSignal
   });
-  const release = (stateRef) => Effect17.gen(function* () {
+  const release = (stateRef) => Effect16.gen(function* () {
     let prevSignal;
     const nextSignal = yield* Deferred.make();
     yield* Ref.update(stateRef, (s) => {
@@ -4646,7 +4577,7 @@ var makeEnqueueTransaction = (args) => Effect17.gen(function* () {
       yield* Deferred.succeed(prevSignal, void 0);
     }
   });
-  const acquireBacklogSlot = (lane, capacity) => Effect17.gen(function* () {
+  const acquireBacklogSlot = (lane, capacity) => Effect16.gen(function* () {
     const inTxn = yield* FiberRef7.get(inSyncTransactionFiber);
     if (inTxn) {
       yield* record({
@@ -4659,7 +4590,7 @@ var makeEnqueueTransaction = (args) => Effect17.gen(function* () {
         hint: "Move dispatch/setState calls outside the transaction window, or use a multi-entry pattern (pending \u2192 IO \u2192 writeback).",
         kind: "enqueue_in_transaction"
       });
-      yield* Effect17.dieMessage("enqueueTransaction is not allowed inside a synchronous StateTransaction body");
+      yield* Effect16.dieMessage("enqueueTransaction is not allowed inside a synchronous StateTransaction body");
     }
     const stateRef = lane === "urgent" ? urgentStateRef : nonUrgentStateRef;
     let waitedFromMs;
@@ -4692,12 +4623,12 @@ var makeEnqueueTransaction = (args) => Effect17.gen(function* () {
         backlogCount: attempt.backlogCount,
         saturatedDurationMs
       });
-      yield* Effect17.acquireUseRelease(
+      yield* Effect16.acquireUseRelease(
         Ref.update(stateRef, (s) => ({
           backlogCount: s.backlogCount,
           waiters: s.waiters + 1,
           signal: s.signal
-        })).pipe(Effect17.as(attempt.signal)),
+        })).pipe(Effect16.as(attempt.signal)),
         (signal) => Deferred.await(signal),
         () => Ref.update(stateRef, (s) => ({
           backlogCount: s.backlogCount,
@@ -4707,27 +4638,26 @@ var makeEnqueueTransaction = (args) => Effect17.gen(function* () {
       );
     }
   });
-  yield* Effect17.forkScoped(
-    Effect17.forever(
-      Effect17.gen(function* () {
-        yield* Queue2.take(wakeQueue);
-        while (true) {
-          const urgent = yield* Queue2.poll(urgentQueue);
-          if (Option8.isSome(urgent)) {
-            yield* urgent.value;
-            continue;
-          }
-          const nonUrgent = yield* Queue2.poll(nonUrgentQueue);
-          if (Option8.isSome(nonUrgent)) {
-            yield* nonUrgent.value;
-            continue;
-          }
-          break;
+  const consumerLoop = Effect16.forever(
+    Effect16.gen(function* () {
+      yield* Queue2.take(wakeQueue);
+      while (true) {
+        const urgent = yield* Queue2.poll(urgentQueue);
+        if (Option7.isSome(urgent)) {
+          yield* urgent.value;
+          continue;
         }
-      })
-    )
+        const nonUrgent = yield* Queue2.poll(nonUrgentQueue);
+        if (Option7.isSome(nonUrgent)) {
+          yield* nonUrgent.value;
+          continue;
+        }
+        break;
+      }
+    })
   );
-  const enqueueTransaction = (a0, a1) => Effect17.gen(function* () {
+  yield* Effect16.forkScoped(consumerLoop);
+  const enqueueTransaction = (a0, a1) => Effect16.gen(function* () {
     const lane = a1 ? a0 : "urgent";
     const eff = a1 ? a1 : a0;
     const stateRef = lane === "urgent" ? urgentStateRef : nonUrgentStateRef;
@@ -4738,30 +4668,30 @@ var makeEnqueueTransaction = (args) => Effect17.gen(function* () {
     const capturedContext = yield* captureDiagnosticContext({ nextLinkId });
     const effWithContext = withDiagnosticContext(capturedContext, eff);
     const task = effWithContext.pipe(
-      Effect17.exit,
-      Effect17.flatMap((exit2) => Deferred.succeed(done, exit2)),
-      Effect17.asVoid,
-      Effect17.ensuring(release(stateRef))
+      Effect16.exit,
+      Effect16.flatMap((exit2) => Deferred.succeed(done, exit2)),
+      Effect16.asVoid,
+      Effect16.ensuring(release(stateRef))
     );
     const targetQueue = lane === "urgent" ? urgentQueue : nonUrgentQueue;
-    yield* Effect17.uninterruptible(Effect17.all([Queue2.offer(targetQueue, task), Queue2.offer(wakeQueue, void 0)]));
+    yield* Effect16.uninterruptible(Effect16.all([Queue2.offer(targetQueue, task), Queue2.offer(wakeQueue, void 0)]));
     const exit = yield* Deferred.await(done);
     return yield* Exit2.match(exit, {
-      onFailure: (cause) => Effect17.failCause(cause),
-      onSuccess: (value) => Effect17.succeed(value)
+      onFailure: (cause) => Effect16.failCause(cause),
+      onSuccess: (value) => Effect16.succeed(value)
     });
   });
   return enqueueTransaction;
 });
 
 // src/internal/runtime/core/ModuleRuntime.logics.ts
-import { Cause as Cause4, Effect as Effect19, Exit as Exit3, Fiber as Fiber2, Option as Option9 } from "effect";
+import { Cause as Cause4, Context, Deferred as Deferred2, Effect as Effect18, Exit as Exit3, Fiber as Fiber2, Option as Option8 } from "effect";
 
 // src/internal/runtime/core/LifecycleDiagnostics.ts
-import { Cause as Cause3, Chunk as Chunk2, Effect as Effect18 } from "effect";
+import { Cause as Cause3, Chunk as Chunk2, Effect as Effect17 } from "effect";
 var emitMissingOnErrorDiagnosticIfNeeded = (lifecycle, moduleId) => lifecycle.hasOnErrorHandlers.pipe(
-  Effect18.flatMap(
-    (has) => has || !moduleId ? Effect18.void : record({
+  Effect17.flatMap(
+    (has) => has || !moduleId ? Effect17.void : record({
       type: "diagnostic",
       moduleId,
       code: "lifecycle::missing_on_error",
@@ -4771,13 +4701,13 @@ var emitMissingOnErrorDiagnosticIfNeeded = (lifecycle, moduleId) => lifecycle.ha
     })
   )
 );
-var emitAssemblyFailureDiagnosticIfNeeded = (cause, moduleId) => Effect18.sync(() => {
+var emitAssemblyFailureDiagnosticIfNeeded = (cause, moduleId) => Effect17.sync(() => {
   const defects = Chunk2.toReadonlyArray(Cause3.defects(cause));
   const missing = defects.find(
     (e) => e && typeof e === "object" && e.name === "MissingModuleRuntimeError"
   );
   if (!missing) {
-    return Effect18.void;
+    return Effect17.void;
   }
   const tokenId = typeof missing.tokenId === "string" ? missing.tokenId : "<unknown module id>";
   const fix = Array.isArray(missing.fix) && missing.fix.every((l) => typeof l === "string") ? missing.fix.join("\n") : void 0;
@@ -4790,7 +4720,7 @@ var emitAssemblyFailureDiagnosticIfNeeded = (cause, moduleId) => Effect18.sync((
     hint: fix ?? "Provide the child implementation in the same scope (imports), or provide a root singleton at app root.",
     kind: "assembly_failure"
   });
-}).pipe(Effect18.flatten);
+}).pipe(Effect17.flatten);
 
 // src/internal/runtime/core/LogicPlanMarker.ts
 var LOGIC_PLAN_EFFECT = /* @__PURE__ */ Symbol.for("@logixjs/core/logicPlanEffect");
@@ -4828,17 +4758,17 @@ var createPhaseRef = () => ({ current: "run" });
 var runModuleLogics = (args) => {
   const { tag, logics, runtime, lifecycle, moduleId, instanceId } = args;
   const moduleIdForLogs = moduleId;
-  return Effect19.gen(function* () {
+  return Effect18.gen(function* () {
     const withRuntimeAndLifecycle = (eff, phaseRef, logicUnit) => {
-      const withServices = Effect19.provideService(
-        Effect19.provideService(eff, LifecycleContext, lifecycle),
+      const withServices = Effect18.provideService(
+        Effect18.provideService(eff, LifecycleContext, lifecycle),
         tag,
         runtime
       );
-      const annotated = Effect19.annotateLogs({
+      const annotated = Effect18.annotateLogs({
         "logix.moduleId": moduleIdForLogs
       })(withServices);
-      const withLogicUnit = logicUnit ? Effect19.provideService(annotated, LogicUnitServiceTag, logicUnit) : annotated;
+      const withLogicUnit = logicUnit ? Effect18.provideService(annotated, LogicUnitServiceTag, logicUnit) : annotated;
       if (!phaseRef) {
         return withLogicUnit;
       }
@@ -4847,8 +4777,19 @@ var runModuleLogics = (args) => {
           return phaseRef.current;
         }
       };
-      return Effect19.provideService(withLogicUnit, LogicPhaseServiceTag, phaseService);
+      return Effect18.provideService(withLogicUnit, LogicPhaseServiceTag, phaseService);
     };
+    const withRootEnvIfAvailable = (eff) => Effect18.gen(function* () {
+      const rootOpt = yield* Effect18.serviceOption(RootContextTag);
+      if (Option8.isNone(rootOpt)) {
+        return yield* eff;
+      }
+      const root = rootOpt.value;
+      const rootEnv = root.context ?? (yield* Deferred2.await(root.ready));
+      const currentEnv = yield* Effect18.context();
+      const mergedEnv = Context.merge(rootEnv, currentEnv);
+      return yield* Effect18.provide(eff, mergedEnv);
+    });
     const formatSource = (source) => source ? `${source.file}:${source.line}:${source.column}` : void 0;
     const resolveLogicUnitService = (rawLogic, index) => {
       const meta = getLogicUnitMeta(rawLogic);
@@ -4867,7 +4808,7 @@ var runModuleLogics = (args) => {
     };
     const handleLogicFailure = (cause) => {
       if (Cause4.isInterrupted(cause)) {
-        return Effect19.failCause(cause);
+        return Effect18.failCause(cause);
       }
       const phaseErrorMarker = [...Cause4.failures(cause), ...Cause4.defects(cause)].some(
         (err) => err?._tag === "LogicPhaseError"
@@ -4879,24 +4820,24 @@ var runModuleLogics = (args) => {
         instanceId,
         origin: "logic.fork"
       }).pipe(
-        Effect19.tap(() => emitMissingOnErrorDiagnosticIfNeeded(lifecycle, moduleId)),
-        Effect19.tap(() => emitAssemblyFailureDiagnosticIfNeeded(cause, moduleId)),
-        Effect19.tap(() => emitDiagnosticsFromCause(cause, moduleId)),
-        Effect19.tap(() => emitEnvServiceNotFoundDiagnosticIfNeeded(cause, moduleId)),
-        Effect19.tap(() => emitInvalidPhaseDiagnosticIfNeeded(cause, moduleId))
+        Effect18.tap(() => emitMissingOnErrorDiagnosticIfNeeded(lifecycle, moduleId)),
+        Effect18.tap(() => emitAssemblyFailureDiagnosticIfNeeded(cause, moduleId)),
+        Effect18.tap(() => emitDiagnosticsFromCause(cause, moduleId)),
+        Effect18.tap(() => emitEnvServiceNotFoundDiagnosticIfNeeded(cause, moduleId)),
+        Effect18.tap(() => emitInvalidPhaseDiagnosticIfNeeded(cause, moduleId))
       );
       if (phaseErrorMarker) {
         return base;
       }
-      return base.pipe(Effect19.flatMap(() => Effect19.failCause(cause)));
+      return base.pipe(Effect18.flatMap(() => Effect18.failCause(cause)));
     };
-    const handleInitFailure = (cause) => Cause4.isInterrupted(cause) ? Effect19.failCause(cause) : Effect19.void.pipe(
-      Effect19.tap(() => emitMissingOnErrorDiagnosticIfNeeded(lifecycle, moduleId)),
-      Effect19.tap(() => emitAssemblyFailureDiagnosticIfNeeded(cause, moduleId)),
-      Effect19.tap(() => emitDiagnosticsFromCause(cause, moduleId)),
-      Effect19.tap(() => emitEnvServiceNotFoundDiagnosticIfNeeded(cause, moduleId)),
-      Effect19.tap(() => emitInvalidPhaseDiagnosticIfNeeded(cause, moduleId)),
-      Effect19.zipRight(Effect19.failCause(cause))
+    const handleInitFailure = (cause) => Cause4.isInterrupted(cause) ? Effect18.failCause(cause) : Effect18.void.pipe(
+      Effect18.tap(() => emitMissingOnErrorDiagnosticIfNeeded(lifecycle, moduleId)),
+      Effect18.tap(() => emitAssemblyFailureDiagnosticIfNeeded(cause, moduleId)),
+      Effect18.tap(() => emitDiagnosticsFromCause(cause, moduleId)),
+      Effect18.tap(() => emitEnvServiceNotFoundDiagnosticIfNeeded(cause, moduleId)),
+      Effect18.tap(() => emitInvalidPhaseDiagnosticIfNeeded(cause, moduleId)),
+      Effect18.zipRight(Effect18.failCause(cause))
     );
     const isLogicPlan = (value) => Boolean(value && typeof value === "object" && "run" in value && "setup" in value);
     const normalizeToPlan = (value, defaultPhaseRef) => {
@@ -4909,7 +4850,7 @@ var runModuleLogics = (args) => {
         return plan2;
       }
       const plan = {
-        setup: Effect19.void,
+        setup: Effect18.void,
         run: value
       };
       attachPhaseRef(plan, phaseRef);
@@ -4925,13 +4866,13 @@ var runModuleLogics = (args) => {
         const setupPhase = withRuntimeAndLifecycle(rawLogic.setup, phaseRef, logicUnit);
         const runPhase2 = withRuntimeAndLifecycle(rawLogic.run, phaseRef, logicUnit);
         phaseRef.current = "setup";
-        yield* setupPhase.pipe(Effect19.catchAllCause(handleLogicFailure));
+        yield* setupPhase.pipe(Effect18.catchAllCause(handleLogicFailure));
         pendingRunForks.push(
-          Effect19.sync(() => {
+          Effect18.sync(() => {
             phaseRef.current = "run";
           }).pipe(
-            Effect19.zipRight(Effect19.forkScoped(runPhase2.pipe(Effect19.catchAllCause(handleLogicFailure)))),
-            Effect19.asVoid
+            Effect18.zipRight(Effect18.forkScoped(runPhase2.pipe(Effect18.catchAllCause(handleLogicFailure)))),
+            Effect18.asVoid
           )
         );
         continue;
@@ -4940,8 +4881,8 @@ var runModuleLogics = (args) => {
         const phaseRef = getPhaseRef(rawLogic) ?? createPhaseRef();
         const makeNoopPlan = () => (() => {
           const plan = {
-            setup: Effect19.void,
-            run: Effect19.void
+            setup: Effect18.void,
+            run: Effect18.void
           };
           attachPhaseRef(plan, phaseRef);
           markSkipRun(plan);
@@ -4953,21 +4894,21 @@ var runModuleLogics = (args) => {
           phaseRef,
           logicUnit
         ).pipe(
-          Effect19.matchCauseEffect({
-            onSuccess: (value) => Effect19.succeed(normalizeToPlan(value, phaseRef)),
+          Effect18.matchCauseEffect({
+            onSuccess: (value) => Effect18.succeed(normalizeToPlan(value, phaseRef)),
             onFailure: (cause) => {
               const isLogicPhaseError = [...Cause4.failures(cause), ...Cause4.defects(cause)].some(
                 (err) => err?._tag === "LogicPhaseError"
               );
               if (isLogicPhaseError) {
                 return emitInvalidPhaseDiagnosticIfNeeded(cause, moduleId).pipe(
-                  Effect19.zipRight(handleLogicFailure(cause)),
-                  Effect19.as(makeNoopPlan())
+                  Effect18.zipRight(handleLogicFailure(cause)),
+                  Effect18.as(makeNoopPlan())
                 );
               }
               return emitEnvServiceNotFoundDiagnosticIfNeeded(cause, moduleId).pipe(
-                Effect19.zipRight(handleLogicFailure(cause)),
-                Effect19.zipRight(Effect19.failCause(cause))
+                Effect18.zipRight(handleLogicFailure(cause)),
+                Effect18.zipRight(Effect18.failCause(cause))
               );
             }
           })
@@ -4981,14 +4922,14 @@ var runModuleLogics = (args) => {
         const runPhase2 = withRuntimeAndLifecycle(resolvedPlan.run, planPhaseRef, logicUnit);
         const skipRun = isSkipRun(resolvedPlan);
         planPhaseRef.current = "setup";
-        yield* setupPhase.pipe(Effect19.catchAllCause(handleLogicFailure));
+        yield* setupPhase.pipe(Effect18.catchAllCause(handleLogicFailure));
         if (!skipRun) {
           pendingRunForks.push(
-            Effect19.sync(() => {
+            Effect18.sync(() => {
               planPhaseRef.current = "run";
             }).pipe(
-              Effect19.zipRight(Effect19.forkScoped(runPhase2.pipe(Effect19.catchAllCause(handleLogicFailure)))),
-              Effect19.asVoid
+              Effect18.zipRight(Effect18.forkScoped(withRootEnvIfAvailable(runPhase2).pipe(Effect18.catchAllCause(handleLogicFailure)))),
+              Effect18.asVoid
             )
           );
         }
@@ -4996,16 +4937,16 @@ var runModuleLogics = (args) => {
       }
       const basePhaseRef = getPhaseRef(rawLogic);
       const runPhase = withRuntimeAndLifecycle(rawLogic, basePhaseRef, logicUnit).pipe(
-        Effect19.catchAllCause(handleLogicFailure)
+        Effect18.catchAllCause(handleLogicFailure)
       );
       pendingRunForks.push(
-        Effect19.gen(function* () {
-          const runFiber = yield* Effect19.forkScoped(runPhase);
-          yield* Effect19.forkScoped(
+        Effect18.gen(function* () {
+          const runFiber = yield* Effect18.forkScoped(withRootEnvIfAvailable(runPhase));
+          yield* Effect18.forkScoped(
             Fiber2.await(runFiber).pipe(
-              Effect19.flatMap(
+              Effect18.flatMap(
                 (exit) => Exit3.match(exit, {
-                  onFailure: () => Effect19.void,
+                  onFailure: () => Effect18.void,
                   onSuccess: (value) => {
                     const executePlan = (plan) => {
                       const phaseRef = getPhaseRef(plan) ?? createPhaseRef();
@@ -5013,13 +4954,17 @@ var runModuleLogics = (args) => {
                       const runPlanPhase = withRuntimeAndLifecycle(plan.run, phaseRef, logicUnit);
                       phaseRef.current = "setup";
                       return setupPhase.pipe(
-                        Effect19.catchAllCause(handleLogicFailure),
-                        Effect19.zipRight(
-                          Effect19.sync(() => {
+                        Effect18.catchAllCause(handleLogicFailure),
+                        Effect18.zipRight(
+                          Effect18.sync(() => {
                             phaseRef.current = "run";
                           }).pipe(
-                            Effect19.zipRight(Effect19.forkScoped(runPlanPhase.pipe(Effect19.catchAllCause(handleLogicFailure)))),
-                            Effect19.asVoid
+                            Effect18.zipRight(
+                              Effect18.forkScoped(
+                                withRootEnvIfAvailable(runPlanPhase).pipe(Effect18.catchAllCause(handleLogicFailure))
+                              )
+                            ),
+                            Effect18.asVoid
                           )
                         )
                       );
@@ -5033,14 +4978,14 @@ var runModuleLogics = (args) => {
                         basePhaseRef,
                         logicUnit
                       ).pipe(
-                        Effect19.map((value2) => normalizeToPlan(value2, basePhaseRef)),
-                        Effect19.matchCauseEffect({
+                        Effect18.map((value2) => normalizeToPlan(value2, basePhaseRef)),
+                        Effect18.matchCauseEffect({
                           onFailure: (cause) => handleLogicFailure(cause),
                           onSuccess: (plan) => executePlan(plan)
                         })
                       );
                     }
-                    return Effect19.void;
+                    return Effect18.void;
                   }
                 })
               )
@@ -5050,9 +4995,9 @@ var runModuleLogics = (args) => {
       );
       continue;
     }
-    yield* lifecycle.runInitRequired.pipe(Effect19.catchAllCause(handleInitFailure));
-    const platformOpt = yield* Effect19.serviceOption(Tag);
-    if (Option9.isSome(platformOpt)) {
+    yield* lifecycle.runInitRequired.pipe(Effect18.catchAllCause(handleInitFailure));
+    const platformOpt = yield* Effect18.serviceOption(Tag);
+    if (Option8.isSome(platformOpt)) {
       const platform = platformOpt.value;
       const snapshot = yield* lifecycle.getTaskSnapshot;
       const platformPhaseRef = { current: "run" };
@@ -5061,10 +5006,10 @@ var runModuleLogics = (args) => {
           return platformPhaseRef.current;
         }
       };
-      const providePlatformEnv = (eff) => Effect19.provideService(
-        Effect19.provideService(
-          Effect19.provideService(
-            Effect19.provideService(eff, Tag, platform),
+      const providePlatformEnv = (eff) => Effect18.provideService(
+        Effect18.provideService(
+          Effect18.provideService(
+            Effect18.provideService(eff, Tag, platform),
             LifecycleContext,
             lifecycle
           ),
@@ -5074,13 +5019,13 @@ var runModuleLogics = (args) => {
         LogicPhaseServiceTag,
         phaseService
       );
-      const register = (label, subscribe) => Effect19.forkScoped(
+      const register = (label, subscribe) => Effect18.forkScoped(
         subscribe(
           providePlatformEnv(
             label === "suspend" ? lifecycle.runPlatformSuspend : label === "resume" ? lifecycle.runPlatformResume : lifecycle.runPlatformReset
-          ).pipe(Effect19.asVoid)
+          ).pipe(Effect18.asVoid)
         ).pipe(
-          Effect19.catchAllCause(
+          Effect18.catchAllCause(
             (cause) => lifecycle.notifyError(cause, {
               phase: "platform",
               hook: label,
@@ -5090,7 +5035,7 @@ var runModuleLogics = (args) => {
             })
           )
         )
-      ).pipe(Effect19.asVoid);
+      ).pipe(Effect18.asVoid);
       if (snapshot.platformSuspend.length > 0) {
         yield* register("suspend", platform.lifecycle.onSuspend);
       }
@@ -5101,21 +5046,21 @@ var runModuleLogics = (args) => {
         yield* register("reset", platform.lifecycle.onReset);
       }
     }
-    yield* Effect19.forEach(pendingRunForks, (eff) => eff, { discard: true });
+    yield* Effect18.forEach(pendingRunForks, (eff) => eff, { discard: true });
     yield* lifecycle.runStart;
-    yield* Effect19.yieldNow();
+    yield* Effect18.yieldNow();
   });
 };
 
 // src/internal/runtime/core/ConcurrencyDiagnostics.ts
-import { Effect as Effect20, Ref as Ref2 } from "effect";
+import { Effect as Effect19, Ref as Ref2 } from "effect";
 var keyOf = (trigger) => `${trigger.kind}::${typeof trigger.name === "string" ? trigger.name : ""}`;
-var nowMs3 = Effect20.clockWith((clock) => clock.currentTimeMillis);
-var make3 = (args) => Effect20.gen(function* () {
+var nowMs3 = Effect19.clockWith((clock) => clock.currentTimeMillis);
+var make3 = (args) => Effect19.gen(function* () {
   const pressureCooldownByKeyRef = yield* Ref2.make({});
   const unboundedEnabledEmittedRef = yield* Ref2.make(false);
   const unboundedBlockedEmittedRef = yield* Ref2.make(false);
-  const emitPressureIfNeeded = (inArgs) => Effect20.gen(function* () {
+  const emitPressureIfNeeded = (inArgs) => Effect19.gen(function* () {
     const policy = inArgs.policy;
     const backlogCount = inArgs.backlogCount ?? 0;
     const saturatedDurationMs = inArgs.saturatedDurationMs ?? 0;
@@ -5193,7 +5138,7 @@ var make3 = (args) => Effect20.gen(function* () {
       }
     });
   });
-  const emitUnboundedPolicyIfNeeded = (inArgs) => Effect20.gen(function* () {
+  const emitUnboundedPolicyIfNeeded = (inArgs) => Effect19.gen(function* () {
     const policy = inArgs.policy;
     if (policy.concurrencyLimit === "unbounded" && policy.allowUnbounded === true) {
       const shouldEmit2 = yield* Ref2.modify(
@@ -5258,23 +5203,23 @@ var make3 = (args) => Effect20.gen(function* () {
   return { emitPressureIfNeeded, emitUnboundedPolicyIfNeeded };
 });
 
-// src/internal/runtime/core/ModuleRuntime.ts
+// src/internal/runtime/core/ModuleRuntime.impl.ts
 var nextInstanceSeq = 0;
 var makeDefaultInstanceId = () => {
   nextInstanceSeq += 1;
   return `i${nextInstanceSeq}`;
 };
 var make4 = (initialState, options = {}) => {
-  const program = Effect21.gen(function* () {
+  const program = Effect20.gen(function* () {
     const stateRef = options.createState ? yield* options.createState : yield* SubscriptionRef3.make(initialState);
     const commitHub = yield* PubSub4.unbounded();
     const actionCommitHub = yield* PubSub4.unbounded();
     let commitHubSubscriberCount = 0;
     const fromCommitHub = Stream2.unwrapScoped(
-      Effect21.gen(function* () {
+      Effect20.gen(function* () {
         commitHubSubscriberCount += 1;
-        yield* Effect21.addFinalizer(
-          () => Effect21.sync(() => {
+        yield* Effect20.addFinalizer(
+          () => Effect20.sync(() => {
             commitHubSubscriberCount = Math.max(0, commitHubSubscriberCount - 1);
           })
         );
@@ -5283,6 +5228,7 @@ var make4 = (initialState, options = {}) => {
     );
     const moduleId = options.moduleId ?? "unknown";
     const instanceId = normalizeNonEmptyString(options.instanceId) ?? makeDefaultInstanceId();
+    const moduleInstanceKey = makeModuleInstanceKey(moduleId, instanceId);
     const runtimeLabel = yield* FiberRef8.get(currentRuntimeLabel);
     const lifecycle = yield* makeLifecycleManager({
       moduleId,
@@ -5293,8 +5239,8 @@ var make4 = (initialState, options = {}) => {
       moduleId: options.moduleId,
       instanceId
     });
-    const runtimeConfigOpt = yield* Effect21.serviceOption(StateTransactionConfigTag);
-    const runtimeInstrumentation = Option10.isSome(runtimeConfigOpt) ? runtimeConfigOpt.value.instrumentation : void 0;
+    const runtimeConfigOpt = yield* Effect20.serviceOption(StateTransactionConfigTag);
+    const runtimeInstrumentation = Option9.isSome(runtimeConfigOpt) ? runtimeConfigOpt.value.instrumentation : void 0;
     const instrumentation = options.stateTransaction?.instrumentation ?? runtimeInstrumentation ?? getDefaultStateTxnInstrumentation();
     const resolveTraitConvergeConfig = makeResolveTraitConvergeConfig({
       moduleId: options.moduleId,
@@ -5308,7 +5254,7 @@ var make4 = (initialState, options = {}) => {
       moduleId: options.moduleId,
       stateTransaction: options.stateTransaction
     });
-    const actionHub = options.createActionHub ? yield* options.createActionHub : yield* Effect21.gen(function* () {
+    const actionHub = options.createActionHub ? yield* options.createActionHub : yield* Effect20.gen(function* () {
       const policy = yield* resolveConcurrencyPolicy();
       return yield* PubSub4.bounded(policy.losslessBackpressureCapacity);
     });
@@ -5324,6 +5270,8 @@ var make4 = (initialState, options = {}) => {
       lastConvergeIrKeys: void 0,
       listConfigs: []
     };
+    let externalOwnedFieldPaths = [];
+    let externalOwnedFieldPathKeys = /* @__PURE__ */ new Set();
     const rowIdStore = new RowIdStore(instanceId);
     const selectorGraph = make2({
       moduleId,
@@ -5345,6 +5293,72 @@ var make4 = (initialState, options = {}) => {
       }
     });
     const recordStatePatch = (path, reason, from, to, traitNodeId, stepId) => {
+      if (externalOwnedFieldPaths.length > 0) {
+        const registry = txnContext.current?.fieldPathIdRegistry;
+        const toFieldPathOrStar = (input) => {
+          if (input === void 0) return void 0;
+          if (input === "*") return "*";
+          if (typeof input === "number") {
+            if (!registry) return "*";
+            if (!Number.isFinite(input)) return "*";
+            const idx = Math.floor(input);
+            if (idx < 0) return "*";
+            const resolved2 = registry.fieldPaths[idx];
+            return resolved2 && Array.isArray(resolved2) ? resolved2 : "*";
+          }
+          if (typeof input === "string") {
+            if (!registry) return "*";
+            const id = registry.pathStringToId?.get(input);
+            if (id == null) return "*";
+            const resolved2 = registry.fieldPaths[id];
+            return resolved2 && Array.isArray(resolved2) ? resolved2 : "*";
+          }
+          const normalized = normalizeFieldPath(input);
+          return normalized ?? "*";
+        };
+        const resolved = toFieldPathOrStar(path);
+        const throwViolation = (details) => {
+          const owned = details.owned ?? externalOwnedFieldPaths[0];
+          const ownedPath = owned ? owned.join(".") : "<unknown>";
+          const resolvedPath = details.resolvedPath === void 0 ? "<unknown>" : details.resolvedPath === "*" ? "*" : details.resolvedPath.join(".");
+          const err = new Error(
+            `[ExternalOwnedWriteError] State write overlaps an external-owned field.
+moduleId=${options.moduleId ?? "unknown"}
+instanceId=${instanceId}
+owned=${ownedPath}
+path=${resolvedPath}
+reason=${String(reason)}
+Fix: do not write external-owned fields via reducers/$.state.*; use StateTrait.externalStore to own the field, and avoid setState/state.update (root writes) on modules with external-owned fields.`
+          );
+          err.name = "ExternalOwnedWriteError";
+          err._tag = "ExternalOwnedWriteError";
+          err.moduleId = options.moduleId;
+          err.instanceId = instanceId;
+          err.reason = reason;
+          err.path = path;
+          throw err;
+        };
+        const ensureFieldPath = (input) => {
+          if (input === void 0 || input === "*") {
+            return throwViolation({ resolvedPath: input });
+          }
+          return input;
+        };
+        if (reason === "trait-external-store") {
+          const resolvedFieldPath = ensureFieldPath(resolved);
+          const key = JSON.stringify(resolvedFieldPath);
+          if (!externalOwnedFieldPathKeys.has(key)) {
+            throwViolation({ resolvedPath: resolvedFieldPath });
+          }
+        } else {
+          const resolvedFieldPath = ensureFieldPath(resolved);
+          for (const owned of externalOwnedFieldPaths) {
+            if (isPrefixOf(owned, resolvedFieldPath) || isPrefixOf(resolvedFieldPath, owned)) {
+              throwViolation({ resolvedPath: resolvedFieldPath, owned });
+            }
+          }
+        }
+      }
       recordPatch(txnContext, path, reason, from, to, traitNodeId, stepId);
     };
     const updateDraft2 = (nextState) => {
@@ -5373,8 +5387,8 @@ var make4 = (initialState, options = {}) => {
     const runtimeServicesOverrides = yield* resolveRuntimeServicesOverrides({
       moduleId: options.moduleId
     });
-    const runtimeServicesRegistryOpt = yield* Effect21.serviceOption(RuntimeServicesRegistryTag);
-    const runtimeServicesRegistry = Option10.isSome(runtimeServicesRegistryOpt) ? runtimeServicesRegistryOpt.value : void 0;
+    const runtimeServicesRegistryOpt = yield* Effect20.serviceOption(RuntimeServicesRegistryTag);
+    const runtimeServicesRegistry = Option9.isSome(runtimeServicesRegistryOpt) ? runtimeServicesRegistryOpt.value : void 0;
     const resolveRuntimeServiceImpls = (serviceId, builtin) => {
       const extraRaw = runtimeServicesRegistry?.implsByServiceId[serviceId];
       if (!extraRaw || extraRaw.length === 0) return builtin;
@@ -5416,12 +5430,12 @@ var make4 = (initialState, options = {}) => {
       ]),
       runtimeServicesOverrides
     );
-    const enqueueTransaction = yield* enqueueTxnSel.impl.make.pipe(
-      Effect21.provideService(RuntimeServiceBuiltinsTag, {
-        getBuiltinMake: (serviceId) => serviceId === "txnQueue" ? makeTxnQueueBuiltin : Effect21.dieMessage(`[Logix] builtin make not available: ${serviceId}`)
+    const enqueueTransactionBase = yield* enqueueTxnSel.impl.make.pipe(
+      Effect20.provideService(RuntimeServiceBuiltinsTag, {
+        getBuiltinMake: (serviceId) => serviceId === "txnQueue" ? makeTxnQueueBuiltin : Effect20.dieMessage(`[Logix] builtin make not available: ${serviceId}`)
       })
     );
-    const makeOperationRunnerBuiltin = Effect21.succeed(
+    const makeOperationRunnerBuiltin = Effect20.succeed(
       makeRunOperation({
         optionsModuleId: options.moduleId,
         instanceId,
@@ -5440,8 +5454,8 @@ var make4 = (initialState, options = {}) => {
       runtimeServicesOverrides
     );
     const runOperation = yield* runOperationSel.impl.make.pipe(
-      Effect21.provideService(RuntimeServiceBuiltinsTag, {
-        getBuiltinMake: (serviceId) => serviceId === "operationRunner" ? makeOperationRunnerBuiltin : Effect21.dieMessage(`[Logix] builtin make not available: ${serviceId}`)
+      Effect20.provideService(RuntimeServiceBuiltinsTag, {
+        getBuiltinMake: (serviceId) => serviceId === "operationRunner" ? makeOperationRunnerBuiltin : Effect20.dieMessage(`[Logix] builtin make not available: ${serviceId}`)
       })
     );
     yield* runOperation(
@@ -5467,7 +5481,34 @@ var make4 = (initialState, options = {}) => {
         txnSeq: 0
       })
     );
-    const makeTransactionBuiltin = Effect21.sync(
+    const runtimeStoreOpt = yield* Effect20.serviceOption(RuntimeStoreTag);
+    if (Option9.isSome(runtimeStoreOpt)) {
+      runtimeStoreOpt.value.registerModuleInstance({
+        moduleId,
+        instanceId,
+        moduleInstanceKey,
+        initialState: initialSnapshot
+      });
+    }
+    const rootContextSvcOpt = yield* Effect20.serviceOption(RootContextTag);
+    const rootContext = Option9.isSome(rootContextSvcOpt) ? rootContextSvcOpt.value : void 0;
+    const tickSchedulerOpt = yield* Effect20.serviceOption(TickSchedulerTag);
+    let tickSchedulerCached = Option9.isSome(tickSchedulerOpt) ? tickSchedulerOpt.value : void 0;
+    const enqueueTransaction = ((a0, a1) => Effect20.gen(function* () {
+      if (!tickSchedulerCached) {
+        const refreshed = yield* Effect20.serviceOption(TickSchedulerTag);
+        if (Option9.isSome(refreshed)) {
+          tickSchedulerCached = refreshed.value;
+        } else if (rootContext?.context) {
+          const fromRoot = Context2.getOption(rootContext.context, TickSchedulerTag);
+          if (Option9.isSome(fromRoot)) {
+            tickSchedulerCached = fromRoot.value;
+          }
+        }
+      }
+      return yield* a1 !== void 0 ? enqueueTransactionBase(a0, a1) : enqueueTransactionBase(a0);
+    }));
+    const makeTransactionBuiltin = Effect20.sync(
       () => makeTransactionOps({
         moduleId,
         optionsModuleId: options.moduleId,
@@ -5476,7 +5517,73 @@ var make4 = (initialState, options = {}) => {
         commitHub,
         shouldPublishCommitHub: () => commitHubSubscriberCount > 0,
         recordStatePatch,
-        onCommit: ({ state, meta, dirtySet, diagnosticsLevel }) => selectorGraph.onCommit(state, meta, dirtySet, diagnosticsLevel),
+        onCommit: ({ state, meta, dirtySet, diagnosticsLevel }) => Effect20.gen(function* () {
+          let scheduler = tickSchedulerCached;
+          if (!scheduler) {
+            const refreshed = yield* Effect20.serviceOption(TickSchedulerTag);
+            if (Option9.isSome(refreshed)) {
+              scheduler = refreshed.value;
+              tickSchedulerCached = refreshed.value;
+            }
+          }
+          let root = rootContext;
+          if (!root) {
+            const rootOpt = yield* Effect20.serviceOption(RootContextTag);
+            if (Option9.isSome(rootOpt)) {
+              root = rootOpt.value;
+            }
+          }
+          if (!scheduler && root?.context) {
+            const fromRoot = Context2.getOption(root.context, TickSchedulerTag);
+            if (Option9.isSome(fromRoot)) {
+              scheduler = fromRoot.value;
+              tickSchedulerCached = fromRoot.value;
+            }
+          }
+          if (!scheduler && diagnosticsLevel !== "off" && isDevEnv()) {
+            yield* record({
+              type: "diagnostic",
+              moduleId,
+              instanceId,
+              txnSeq: meta.txnSeq,
+              txnId: meta.txnId,
+              trigger: {
+                kind: meta.originKind ?? "unknown",
+                name: meta.originName ?? meta.originKind ?? "unknown"
+              },
+              code: "tick_scheduler::missing_service",
+              severity: "error",
+              message: "TickScheduler service is not visible in ModuleRuntime.onCommit; tickSeq will not advance and RuntimeStore subscribers will not flush.",
+              hint: "Ensure TickSchedulerTag is available in the fiber Env for logic/task/txnQueue execution (AppRuntime baseLayer + RootContext wiring).",
+              kind: "missing_tick_scheduler"
+            });
+          }
+          yield* selectorGraph.onCommit(
+            state,
+            meta,
+            dirtySet,
+            diagnosticsLevel,
+            scheduler ? (selectorId) => {
+              scheduler.onSelectorChanged({
+                moduleInstanceKey,
+                selectorId,
+                priority: meta.priority
+              });
+            } : void 0
+          );
+          if (scheduler) {
+            const opSeqRaw = yield* FiberRef8.get(currentOpSeq);
+            const opSeq = typeof opSeqRaw === "number" && Number.isFinite(opSeqRaw) && opSeqRaw >= 0 ? Math.floor(opSeqRaw) : void 0;
+            yield* scheduler.onModuleCommit({
+              moduleId,
+              instanceId,
+              moduleInstanceKey,
+              state,
+              meta,
+              opSeq
+            });
+          }
+        }),
         enqueueTransaction,
         runOperation,
         txnContext,
@@ -5511,8 +5618,8 @@ var make4 = (initialState, options = {}) => {
       runtimeServicesOverrides
     );
     const { readState, setStateInternal, runWithStateTransaction } = yield* transactionSel.impl.make.pipe(
-      Effect21.provideService(RuntimeServiceBuiltinsTag, {
-        getBuiltinMake: (serviceId) => serviceId === "transaction" ? makeTransactionBuiltin : Effect21.dieMessage(`[Logix] builtin make not available: ${serviceId}`)
+      Effect20.provideService(RuntimeServiceBuiltinsTag, {
+        getBuiltinMake: (serviceId) => serviceId === "transaction" ? makeTransactionBuiltin : Effect20.dieMessage(`[Logix] builtin make not available: ${serviceId}`)
       })
     );
     let deferredFlushCoalescedCount = 0;
@@ -5545,7 +5652,7 @@ var make4 = (initialState, options = {}) => {
               name: "trait:deferredConvergeFlush",
               details
             },
-            () => Effect21.gen(function* () {
+            () => Effect20.gen(function* () {
               const current = txnContext.current;
               if (current) {
                 capturedTxnSeq = current.txnSeq;
@@ -5570,16 +5677,16 @@ var make4 = (initialState, options = {}) => {
           )
         )
       ).pipe(
-        Effect21.as({
+        Effect20.as({
           txnSeq: capturedTxnSeq,
           txnId: capturedTxnId,
           opSeq: capturedOpSeq
         })
       );
     };
-    yield* Effect21.forkScoped(
-      Effect21.forever(
-        Effect21.gen(function* () {
+    yield* Effect20.forkScoped(
+      Effect20.forever(
+        Effect20.gen(function* () {
           yield* Queue3.take(traitConvergeTimeSlicingState.signal);
           while (true) {
             const config = traitConvergeTimeSlicingState.latestConvergeConfig?.traitConvergeTimeSlicing;
@@ -5594,7 +5701,7 @@ var make4 = (initialState, options = {}) => {
             const firstPendingAtMs2 = traitConvergeTimeSlicingState.firstPendingAtMs ?? now;
             traitConvergeTimeSlicingState.firstPendingAtMs = firstPendingAtMs2;
             const captured2 = traitConvergeTimeSlicingState.capturedContext;
-            const txnLanePolicy2 = yield* captured2?.overrides ? Effect21.provideService(resolveTxnLanePolicy(), StateTransactionOverridesTag, captured2.overrides) : resolveTxnLanePolicy();
+            const txnLanePolicy2 = yield* captured2?.overrides ? Effect20.provideService(resolveTxnLanePolicy(), StateTransactionOverridesTag, captured2.overrides) : resolveTxnLanePolicy();
             const debounceMs = txnLanePolicy2.enabled ? txnLanePolicy2.debounceMs : config.debounceMs;
             const maxLagMs = txnLanePolicy2.enabled ? txnLanePolicy2.maxLagMs : config.maxLagMs;
             const elapsedMs = Math.max(0, now - firstPendingAtMs2);
@@ -5604,9 +5711,9 @@ var make4 = (initialState, options = {}) => {
             }
             const sleepMs = Math.max(0, Math.min(debounceMs, remainingLagMs));
             if (sleepMs > 0) {
-              yield* Effect21.sleep(Duration.millis(sleepMs));
+              yield* Effect20.sleep(Duration.millis(sleepMs));
             } else {
-              yield* Effect21.yieldNow();
+              yield* Effect20.yieldNow();
             }
             const drained = yield* Queue3.takeAll(traitConvergeTimeSlicingState.signal);
             if (Chunk3.isEmpty(drained)) {
@@ -5628,19 +5735,19 @@ var make4 = (initialState, options = {}) => {
             return;
           }
           const captured = traitConvergeTimeSlicingState.capturedContext;
-          const txnLanePolicy = yield* captured?.overrides ? Effect21.provideService(resolveTxnLanePolicy(), StateTransactionOverridesTag, captured.overrides) : resolveTxnLanePolicy();
+          const txnLanePolicy = yield* captured?.overrides ? Effect20.provideService(resolveTxnLanePolicy(), StateTransactionOverridesTag, captured.overrides) : resolveTxnLanePolicy();
           const shouldEmitLaneEvidence = captured != null && captured.diagnosticsLevel !== "off";
           const shouldEmitLaneEvidenceForPolicy = shouldEmitLaneEvidence && (txnLanePolicy.enabled || txnLanePolicy.overrideMode != null);
           const withCapturedContext = (eff) => {
             let next = eff;
             if (captured?.overrides) {
-              next = Effect21.provideService(next, StateTransactionOverridesTag, captured.overrides);
+              next = Effect20.provideService(next, StateTransactionOverridesTag, captured.overrides);
             }
             if (captured) {
               next = next.pipe(
-                Effect21.locally(currentRuntimeLabel, captured.runtimeLabel),
-                Effect21.locally(currentDiagnosticsLevel, captured.diagnosticsLevel),
-                Effect21.locally(currentDebugSinks, captured.debugSinks)
+                Effect20.locally(currentRuntimeLabel, captured.runtimeLabel),
+                Effect20.locally(currentDiagnosticsLevel, captured.diagnosticsLevel),
+                Effect20.locally(currentDebugSinks, captured.debugSinks)
               );
             }
             return next;
@@ -5712,7 +5819,7 @@ var make4 = (initialState, options = {}) => {
             const sliceStart = cursor;
             const sliceEnd = Math.min(totalSteps, cursor + chunkSize);
             const { sliceDurationMs, anchor } = yield* withCapturedContext(
-              Effect21.gen(function* () {
+              Effect20.gen(function* () {
                 const sliceStartedAtMs = Date.now();
                 const anchor2 = yield* runDeferredConvergeFlush({
                   dirtyPathsSnapshot,
@@ -5737,7 +5844,7 @@ var make4 = (initialState, options = {}) => {
             const yieldReason = !shouldYield ? "none" : inputPending ? "input_pending" : budgetExceeded ? "budget_exceeded" : "forced_frame_yield";
             if (shouldEmitLaneEvidence) {
               yield* withCapturedContext(
-                Effect21.gen(function* () {
+                Effect20.gen(function* () {
                   const reasons = ["queued_non_urgent"];
                   if (lagExceeded) reasons.push("max_lag_forced", "starvation_protection");
                   if (yieldReason === "budget_exceeded") reasons.push("budget_yield");
@@ -5833,7 +5940,7 @@ var make4 = (initialState, options = {}) => {
             if (shouldYield) {
               yieldCount += 1;
               lastYieldAtMs = Date.now();
-              yield* Effect21.yieldNow();
+              yield* Effect20.yieldNow();
             }
           }
           if (traitConvergeTimeSlicingState.backlogDirtyPaths.size > 0 || traitConvergeTimeSlicingState.backlogDirtyAllReason != null) {
@@ -5849,7 +5956,7 @@ var make4 = (initialState, options = {}) => {
       }
       return new Set(Object.keys(actionMap));
     })();
-    const makeDispatchBuiltin = Effect21.sync(
+    const makeDispatchBuiltin = Effect20.sync(
       () => makeDispatchOps({
         optionsModuleId: options.moduleId,
         instanceId,
@@ -5881,8 +5988,8 @@ var make4 = (initialState, options = {}) => {
       runtimeServicesOverrides
     );
     const dispatchOps = yield* dispatchSel.impl.make.pipe(
-      Effect21.provideService(RuntimeServiceBuiltinsTag, {
-        getBuiltinMake: (serviceId) => serviceId === "dispatch" ? makeDispatchBuiltin : Effect21.dieMessage(`[Logix] builtin make not available: ${serviceId}`)
+      Effect20.provideService(RuntimeServiceBuiltinsTag, {
+        getBuiltinMake: (serviceId) => serviceId === "dispatch" ? makeDispatchBuiltin : Effect20.dieMessage(`[Logix] builtin make not available: ${serviceId}`)
       })
     );
     const runtimeServicesEvidence = makeRuntimeServicesEvidence({
@@ -5897,8 +6004,8 @@ var make4 = (initialState, options = {}) => {
       ]
     });
     if (kernelImplementationRef.kernelId !== "core") {
-      const modeOpt = yield* Effect21.serviceOption(FullCutoverGateModeTag);
-      const mode = Option10.isSome(modeOpt) ? modeOpt.value : "trial";
+      const modeOpt = yield* Effect20.serviceOption(FullCutoverGateModeTag);
+      const mode = Option9.isSome(modeOpt) ? modeOpt.value : "trial";
       if (mode === "fullCutover") {
         const gate = evaluateFullCutoverGate({
           mode: "fullCutover",
@@ -5947,9 +6054,9 @@ var make4 = (initialState, options = {}) => {
         const compiled = input?.staticIr != null && typeof input?.lane === "string" && typeof input?.producer === "string" ? input : compile(input);
         if (compiled.lane !== "static") {
           return Stream2.unwrapScoped(
-            Effect21.gen(function* () {
-              const strictGateOpt = yield* Effect21.serviceOption(ReadQueryStrictGateConfigTag);
-              if (Option10.isSome(strictGateOpt)) {
+            Effect20.gen(function* () {
+              const strictGateOpt = yield* Effect20.serviceOption(ReadQueryStrictGateConfigTag);
+              if (Option9.isSome(strictGateOpt)) {
                 const decision = evaluateStrictGate({
                   config: strictGateOpt.value,
                   moduleId,
@@ -5961,7 +6068,7 @@ var make4 = (initialState, options = {}) => {
                   yield* record(decision.diagnostic);
                 } else if (decision.verdict === "FAIL") {
                   yield* record(decision.diagnostic);
-                  yield* Effect21.die(decision.error);
+                  yield* Effect20.die(decision.error);
                 }
               }
               return Stream2.map(fromCommitHub, ({ value, meta }) => ({
@@ -5972,11 +6079,11 @@ var make4 = (initialState, options = {}) => {
           );
         }
         return Stream2.unwrapScoped(
-          Effect21.gen(function* () {
+          Effect20.gen(function* () {
             const entry = yield* selectorGraph.ensureEntry(compiled);
             entry.subscriberCount += 1;
-            yield* Effect21.addFinalizer(
-              () => Effect21.sync(() => {
+            yield* Effect20.addFinalizer(
+              () => Effect20.sync(() => {
                 selectorGraph.releaseEntry(compiled.selectorId);
               })
             );
@@ -5998,14 +6105,14 @@ var make4 = (initialState, options = {}) => {
           return stateRef;
         }
         const readonlyRef = {
-          get: Effect21.map(SubscriptionRef3.get(stateRef), selector),
-          modify: () => Effect21.dieMessage("Cannot write to a derived ref")
+          get: Effect20.map(SubscriptionRef3.get(stateRef), selector),
+          modify: () => Effect20.dieMessage("Cannot write to a derived ref")
         };
         const derived = {
           // SubscriptionRef internals access self.ref / self.pubsub / self.semaphore.
           ref: readonlyRef,
           pubsub: {
-            publish: () => Effect21.succeed(true)
+            publish: () => Effect20.succeed(true)
           },
           semaphore: {
             withPermits: () => (self) => self
@@ -6020,8 +6127,8 @@ var make4 = (initialState, options = {}) => {
     };
     setKernelImplementationRef(runtime, kernelImplementationRef);
     setRuntimeServicesEvidence(runtime, runtimeServicesEvidence);
-    const collectorOpt = yield* Effect21.serviceOption(EvidenceCollectorTag);
-    if (Option10.isSome(collectorOpt)) {
+    const collectorOpt = yield* Effect20.serviceOption(EvidenceCollectorTag);
+    if (Option9.isSome(collectorOpt)) {
       collectorOpt.value.setKernelImplementationRef(kernelImplementationRef);
       const level = yield* FiberRef8.get(currentDiagnosticsLevel);
       if (level !== "off") {
@@ -6036,15 +6143,15 @@ var make4 = (initialState, options = {}) => {
       }
     };
     const sourceRefreshRegistry = /* @__PURE__ */ new Map();
-    yield* Effect21.addFinalizer(
-      () => Effect21.sync(() => {
+    yield* Effect20.addFinalizer(
+      () => Effect20.sync(() => {
         sourceRefreshRegistry.clear();
       })
     );
     const importsMap = /* @__PURE__ */ new Map();
     for (const imported of options.imports ?? []) {
-      const maybe = yield* Effect21.serviceOption(imported);
-      if (Option10.isSome(maybe)) {
+      const maybe = yield* Effect20.serviceOption(imported);
+      if (Option9.isSome(maybe)) {
         importsMap.set(imported, maybe.value);
       }
     }
@@ -6098,6 +6205,9 @@ var make4 = (initialState, options = {}) => {
         convergeExecIr
       };
       traitState.listConfigs = collectListConfigs(program2.spec);
+      const owned = (program2?.entries ?? []).filter((e) => e && e.kind === "externalStore" && typeof e.fieldPath === "string").map((e) => normalizeFieldPath(e.fieldPath)).filter((p) => p != null).sort(compareFieldPath);
+      externalOwnedFieldPaths = owned;
+      externalOwnedFieldPathKeys = new Set(owned.map((p) => JSON.stringify(p)));
       if (!traitState.convergePlanCache) {
         traitState.convergePlanCache = new ConvergePlanCache(convergePlanCacheCapacity);
       }
@@ -6148,7 +6258,7 @@ var make4 = (initialState, options = {}) => {
       )
     );
     const applyTransactionSnapshot = (txnId, mode) => enqueueTransaction(
-      Effect21.gen(function* () {
+      Effect20.gen(function* () {
         if (!isDevEnv()) {
           return;
         }
@@ -6169,7 +6279,7 @@ var make4 = (initialState, options = {}) => {
               mode
             }
           },
-          () => Effect21.sync(() => {
+          () => Effect20.sync(() => {
             updateDraft(txnContext, targetState);
             recordPatch(txnContext, "*", "devtools");
           })
@@ -6257,17 +6367,24 @@ var make4 = (initialState, options = {}) => {
       }
     };
     yield* installInternalHooks({ runtime, runtimeInternals });
-    yield* Effect21.addFinalizer(
-      () => Effect21.sync(() => {
+    yield* Effect20.addFinalizer(
+      () => Effect20.sync(() => {
         importsMap.clear();
       })
     );
+    yield* Effect20.addFinalizer(
+      () => Effect20.sync(() => {
+        if (Option9.isSome(runtimeStoreOpt)) {
+          runtimeStoreOpt.value.unregisterModuleInstance(moduleInstanceKey);
+        }
+      })
+    );
     if (options.tag) {
       registerRuntime(options.tag, runtime);
     }
-    yield* Effect21.addFinalizer(
+    yield* Effect20.addFinalizer(
       () => lifecycle.runDestroy.pipe(
-        Effect21.flatMap(
+        Effect20.flatMap(
           () => runOperation(
             "lifecycle",
             "module:destroy",
@@ -6279,8 +6396,8 @@ var make4 = (initialState, options = {}) => {
             })
           )
         ),
-        Effect21.tap(
-          () => Effect21.sync(() => {
+        Effect20.tap(
+          () => Effect20.sync(() => {
             if (options.tag) {
               unregisterRuntime(options.tag);
             }
@@ -6302,20 +6419,20 @@ var make4 = (initialState, options = {}) => {
       });
     }
     if (options.processes && options.processes.length > 0) {
-      const env = yield* Effect21.context();
+      const env = yield* Effect20.context();
       const rootContextOpt = Context2.getOption(env, RootContextTag);
-      const isAppModule = Option10.isSome(rootContextOpt) && Array.isArray(rootContextOpt.value.appModuleIds) && rootContextOpt.value.appModuleIds.includes(moduleId);
+      const isAppModule = Option9.isSome(rootContextOpt) && Array.isArray(rootContextOpt.value.appModuleIds) && rootContextOpt.value.appModuleIds.includes(moduleId);
       if (!isAppModule) {
         const processRuntimeOpt = Context2.getOption(env, ProcessRuntimeTag);
-        const processRuntime = Option10.isSome(processRuntimeOpt) ? processRuntimeOpt.value : void 0;
+        const processRuntime = Option9.isSome(processRuntimeOpt) ? processRuntimeOpt.value : void 0;
         const scope = {
           type: "moduleInstance",
           moduleId,
           instanceId
         };
-        yield* Effect21.forEach(
+        yield* Effect20.forEach(
           options.processes,
-          (process) => Effect21.gen(function* () {
+          (process) => Effect20.gen(function* () {
             if (processRuntime) {
               const installEffect = processRuntime.install(process, {
                 scope,
@@ -6323,13 +6440,13 @@ var make4 = (initialState, options = {}) => {
                 installedAt: "moduleRuntime"
               });
               const installation = options.tag ? yield* installEffect.pipe(
-                Effect21.provideService(options.tag, runtime)
+                Effect20.provideService(options.tag, runtime)
               ) : yield* installEffect;
               if (installation !== void 0) {
                 return;
               }
             }
-            yield* Effect21.forkScoped(process);
+            yield* Effect20.forkScoped(process);
           }),
           { discard: true }
         );
@@ -6349,11 +6466,8 @@ export {
   execVmModeLayer,
   getRuntimeByModuleAndInstance,
   makeEnqueueTransaction,
-  getLogicUnitMeta,
-  attachLogicUnitMeta,
-  updateLogicUnitMeta,
   markAsLogicPlanEffect,
   isLogicPlanEffect,
   make4 as make
 };
-//# sourceMappingURL=chunk-JGIWG6SR.js.map
+//# sourceMappingURL=chunk-MS77U77X.js.map