@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,1175 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  resolve
+} from "./chunk-XWHIN7CC.js";
+import {
+  create
+} from "./chunk-Y5I45PEB.js";
+import {
+  forceSourceRefresh,
+  inSyncTransactionFiber,
+  makeTaskRunner
+} from "./chunk-LYBBX6WM.js";
+import {
+  makeMatch,
+  makeMatchTag
+} from "./chunk-3U4CAKCX.js";
+import {
+  Tag
+} from "./chunk-ZWE3P6X2.js";
+import {
+  getRuntimeInternals,
+  setBoundInternals
+} from "./chunk-6FKWRVP4.js";
+import {
+  isDevEnv
+} from "./chunk-GP37MEGJ.js";
+import {
+  make
+} from "./chunk-ILFVY7H5.js";
+import {
+  currentDiagnosticsLevel,
+  record,
+  toSerializableErrorSummary
+} from "./chunk-4KIYG5E4.js";
+import {
+  RunSessionTag
+} from "./chunk-O57OZBDR.js";
+
+// ../logix-core/src/internal/runtime/core/mutativePatches.ts
+var toPatchPathString = (path) => {
+  if (typeof path === "string") {
+    const trimmed = path.trim();
+    return trimmed.length > 0 ? trimmed : void 0;
+  }
+  if (!Array.isArray(path)) return void 0;
+  const parts = [];
+  for (const seg of path) {
+    if (typeof seg === "string") {
+      if (seg.length > 0) parts.push(seg);
+      continue;
+    }
+    if (typeof seg === "number" && Number.isFinite(seg)) {
+      parts.push(String(Math.floor(seg)));
+      continue;
+    }
+  }
+  if (parts.length === 0) return "*";
+  return parts.join(".");
+};
+var mutateWithPatchPaths = (base, mutator) => {
+  const out = create(base, mutator, {
+    enablePatches: {
+      pathAsArray: true,
+      arrayLengthAssignment: false
+    }
+  });
+  if (!Array.isArray(out)) {
+    return { nextState: out, patchPaths: [] };
+  }
+  const nextState = out[0];
+  const patches = out[1] ?? [];
+  const set = /* @__PURE__ */ new Set();
+  for (const patch of patches) {
+    const p = toPatchPathString(patch?.path);
+    if (!p) continue;
+    set.add(p);
+  }
+  return {
+    nextState,
+    patchPaths: Array.from(set)
+  };
+};
+
+// ../logix-core/src/internal/runtime/core/BoundApiRuntime.ts
+import { Context as Context3, Effect as Effect3, FiberRef, Option, Schema, Stream } from "../effect.js";
+
+// ../logix-core/src/internal/runtime/core/Lifecycle.ts
+import { Cause, Context, Effect, Ref } from "../effect.js";
+var LifecycleContext = Context.GenericTag(
+  "@logix/LifecycleManager"
+);
+var safeRun = (label, eff) => eff.pipe(
+  Effect.matchCauseEffect({
+    onSuccess: () => Effect.void,
+    onFailure: (cause) => Effect.logError(`[${label}] failed: ${Cause.pretty(cause)}`)
+  })
+);
+var makeTaskId = (kind, order) => `${kind}:${order}`;
+var makeLifecycleManager = (identity) => Effect.gen(function* () {
+  const budgets = {
+    maxEventsPerInstance: 20,
+    maxEventBytes: 4 * 1024
+  };
+  const statusRef = yield* Ref.make({
+    identity,
+    status: "creating"
+  });
+  const initRequired = [];
+  const start = [];
+  const destroy = [];
+  const platformSuspend = [];
+  const platformResume = [];
+  const platformReset = [];
+  const onErrorHandlers = [];
+  const getStatus = Ref.get(statusRef);
+  const recordPhase = (phase, name, payload) => record({
+    type: "lifecycle:phase",
+    moduleId: identity.moduleId,
+    instanceId: identity.instanceId,
+    phase,
+    name,
+    payload
+  });
+  const setStatus = (status, patch) => Ref.update(statusRef, (prev) => ({
+    ...prev,
+    identity: {
+      ...prev.identity,
+      ...patch?.runtimeLabel ? { runtimeLabel: patch.runtimeLabel } : null
+    },
+    status,
+    ...patch?.initOutcome !== void 0 ? { initOutcome: patch.initOutcome } : null,
+    ...patch?.initProgress !== void 0 ? { initProgress: patch.initProgress } : null
+  }));
+  const registerInitRequired = (effect, options) => {
+    const order = initRequired.length;
+    initRequired.push({
+      taskId: makeTaskId("initRequired", order),
+      kind: "initRequired",
+      order,
+      name: options?.name,
+      effect
+    });
+  };
+  const registerStart = (effect, options) => {
+    const order = start.length;
+    start.push({
+      taskId: makeTaskId("start", order),
+      kind: "start",
+      order,
+      name: options?.name,
+      fatalOnFailure: options?.fatalOnFailure,
+      effect
+    });
+  };
+  const registerDestroy = (effect, options) => {
+    const order = destroy.length;
+    destroy.push({
+      taskId: makeTaskId("destroy", order),
+      kind: "destroy",
+      order,
+      name: options?.name,
+      effect
+    });
+  };
+  const registerOnError = (handler) => {
+    onErrorHandlers.push(handler);
+  };
+  const registerPlatformSuspend = (effect, options) => {
+    const order = platformSuspend.length;
+    platformSuspend.push({
+      taskId: makeTaskId("platformSuspend", order),
+      kind: "platformSuspend",
+      order,
+      name: options?.name,
+      effect
+    });
+  };
+  const registerPlatformResume = (effect, options) => {
+    const order = platformResume.length;
+    platformResume.push({
+      taskId: makeTaskId("platformResume", order),
+      kind: "platformResume",
+      order,
+      name: options?.name,
+      effect
+    });
+  };
+  const registerPlatformReset = (effect, options) => {
+    const order = platformReset.length;
+    platformReset.push({
+      taskId: makeTaskId("platformReset", order),
+      kind: "platformReset",
+      order,
+      name: options?.name,
+      effect
+    });
+  };
+  const notifyError = (cause, context) => {
+    if (Cause.isInterrupted(cause)) {
+      return Effect.void;
+    }
+    return record({
+      type: "lifecycle:error",
+      moduleId: context.moduleId,
+      instanceId: context.instanceId,
+      cause,
+      phase: context.phase,
+      hook: context.hook,
+      taskId: context.taskId,
+      txnSeq: context.txnSeq,
+      opSeq: context.opSeq,
+      origin: context.origin
+    }).pipe(
+      Effect.zipRight(
+        Effect.forEach(
+          onErrorHandlers,
+          (handler) => handler(cause, context).pipe(
+            Effect.catchAllCause(
+              (inner) => Effect.logError(
+                `[lifecycle.onError] failed: ${Cause.pretty(inner)}`
+              )
+            )
+          ),
+          { discard: true }
+        )
+      )
+    );
+  };
+  const runInitRequired = Effect.gen(function* () {
+    const total = initRequired.length;
+    if (total === 0) {
+      yield* setStatus("ready", {
+        initProgress: { total: 0, completed: 0 },
+        initOutcome: { status: "success" }
+      });
+      return;
+    }
+    const startedAt = Date.now();
+    yield* recordPhase("init", "initRequired:start", { total });
+    yield* setStatus("initializing", {
+      initProgress: { total, completed: 0, current: 0, startedAt }
+    });
+    let completed = 0;
+    for (let i = 0; i < initRequired.length; i++) {
+      yield* setStatus("initializing", {
+        initProgress: { total, completed, current: i, startedAt }
+      });
+      const task = initRequired[i];
+      const exit = yield* Effect.exit(task.effect);
+      if (exit._tag === "Success") {
+        completed += 1;
+        yield* setStatus("initializing", {
+          initProgress: { total, completed, current: i + 1, startedAt }
+        });
+        continue;
+      }
+      const summary = toSerializableErrorSummary(exit.cause);
+      yield* notifyError(exit.cause, {
+        phase: "init",
+        hook: "initRequired",
+        moduleId: identity.moduleId,
+        instanceId: identity.instanceId,
+        taskId: task.taskId,
+        origin: "initRequired"
+      });
+      yield* setStatus("failed", {
+        initProgress: { total, completed, current: i, startedAt },
+        initOutcome: { status: "failure", error: summary.errorSummary }
+      });
+      return yield* Effect.failCause(exit.cause);
+    }
+    yield* recordPhase("init", "initRequired:success", { total });
+    yield* setStatus("ready", {
+      initProgress: { total, completed, current: total, startedAt },
+      initOutcome: { status: "success" }
+    });
+  });
+  const runStart = recordPhase("run", "start:schedule", {
+    total: start.length
+  }).pipe(
+    Effect.zipRight(
+      Effect.forEach(
+        start,
+        (task) => Effect.forkScoped(
+          task.effect.pipe(
+            Effect.catchAllCause(
+              (cause) => notifyError(cause, {
+                phase: "run",
+                hook: "start",
+                moduleId: identity.moduleId,
+                instanceId: identity.instanceId,
+                taskId: task.taskId,
+                origin: "start"
+              })
+            )
+          )
+        ).pipe(Effect.asVoid),
+        { discard: true, concurrency: "unbounded" }
+      )
+    )
+  );
+  const runDestroy = Effect.gen(function* () {
+    yield* recordPhase("destroy", "destroy:start", { total: destroy.length });
+    yield* setStatus("terminating");
+    for (let i = destroy.length - 1; i >= 0; i--) {
+      const task = destroy[i];
+      yield* safeRun(
+        "lifecycle.onDestroy",
+        task.effect.pipe(
+          Effect.catchAllCause(
+            (cause) => notifyError(cause, {
+              phase: "destroy",
+              hook: "destroy",
+              moduleId: identity.moduleId,
+              instanceId: identity.instanceId,
+              taskId: task.taskId,
+              origin: "destroy"
+            })
+          )
+        )
+      );
+    }
+    yield* setStatus("terminated");
+    yield* recordPhase("destroy", "destroy:done", { total: destroy.length });
+  });
+  const runPlatformSuspend = Effect.gen(function* () {
+    if (platformSuspend.length === 0) return;
+    yield* recordPhase("platform", "signal:suspend", { total: platformSuspend.length });
+    for (const task of platformSuspend) {
+      yield* safeRun(
+        "lifecycle.onSuspend",
+        task.effect.pipe(
+          Effect.catchAllCause(
+            (cause) => notifyError(cause, {
+              phase: "platform",
+              hook: "suspend",
+              moduleId: identity.moduleId,
+              instanceId: identity.instanceId,
+              taskId: task.taskId,
+              origin: "platform.suspend"
+            })
+          )
+        )
+      );
+    }
+  });
+  const runPlatformResume = Effect.gen(function* () {
+    if (platformResume.length === 0) return;
+    yield* recordPhase("platform", "signal:resume", { total: platformResume.length });
+    for (const task of platformResume) {
+      yield* safeRun(
+        "lifecycle.onResume",
+        task.effect.pipe(
+          Effect.catchAllCause(
+            (cause) => notifyError(cause, {
+              phase: "platform",
+              hook: "resume",
+              moduleId: identity.moduleId,
+              instanceId: identity.instanceId,
+              taskId: task.taskId,
+              origin: "platform.resume"
+            })
+          )
+        )
+      );
+    }
+  });
+  const runPlatformReset = Effect.gen(function* () {
+    if (platformReset.length === 0) return;
+    yield* recordPhase("platform", "signal:reset", { total: platformReset.length });
+    for (const task of platformReset) {
+      yield* safeRun(
+        "lifecycle.onReset",
+        task.effect.pipe(
+          Effect.catchAllCause(
+            (cause) => notifyError(cause, {
+              phase: "platform",
+              hook: "reset",
+              moduleId: identity.moduleId,
+              instanceId: identity.instanceId,
+              taskId: task.taskId,
+              origin: "platform.reset"
+            })
+          )
+        )
+      );
+    }
+  });
+  const getTaskSnapshot = Effect.sync(() => ({
+    initRequired: initRequired.map(({ effect: _eff, ...rest }) => rest),
+    start: start.map(({ effect: _eff, ...rest }) => rest),
+    destroy: destroy.map(({ effect: _eff, ...rest }) => rest),
+    platformSuspend: platformSuspend.map(({ effect: _eff, ...rest }) => rest),
+    platformResume: platformResume.map(({ effect: _eff, ...rest }) => rest),
+    platformReset: platformReset.map(({ effect: _eff, ...rest }) => rest)
+  }));
+  const hasOnErrorHandlers = Effect.sync(() => onErrorHandlers.length > 0);
+  return {
+    identity,
+    budgets,
+    registerPlatformSuspend,
+    registerPlatformResume,
+    registerPlatformReset,
+    registerInitRequired,
+    registerStart,
+    registerDestroy,
+    registerOnError,
+    getStatus,
+    setStatus,
+    notifyError,
+    runPlatformSuspend,
+    runPlatformResume,
+    runPlatformReset,
+    runInitRequired,
+    runStart,
+    runDestroy,
+    hasOnErrorHandlers,
+    getTaskSnapshot
+  };
+});
+
+// ../logix-core/src/internal/runtime/core/LogicDiagnostics.ts
+import { Cause as Cause2, Context as Context2, Effect as Effect2 } from "../effect.js";
+var phaseDiagnosticsEnabled = () => isDevEnv();
+var SERVICE_NOT_FOUND_PREFIX = "Service not found:";
+var emitEnvServiceNotFoundDiagnosticIfNeeded = (cause, moduleId) => Effect2.gen(function* () {
+  let pretty;
+  try {
+    pretty = Cause2.pretty(cause, { renderErrorCause: true });
+  } catch {
+    return;
+  }
+  if (!pretty.includes(SERVICE_NOT_FOUND_PREFIX)) {
+    return;
+  }
+  yield* record({
+    type: "diagnostic",
+    moduleId,
+    code: "logic::env_service_not_found",
+    severity: "warning",
+    message: pretty,
+    hint: "Logic attempted to access an Env service before it was provided. This is a known initialization timing noise in Runtime/React integration. If it happens once during early startup and everything works afterward, it's likely harmless; if it persists or correlates with app issues, verify Runtime.make / RuntimeProvider.layer provides the service."
+  });
+  yield* record({
+    type: "diagnostic",
+    moduleId,
+    code: "logic::invalid_phase",
+    severity: "error",
+    message: "$.use is not allowed before Env is fully ready.",
+    hint: "Avoid reading services during setup or before Env is ready; move Env access to the Logic run section, or wrap init via $.lifecycle.onInitRequired.",
+    kind: "env_service_not_ready"
+  });
+});
+var LogicPhaseServiceTag = Context2.GenericTag(
+  "@logix/LogicPhaseService"
+);
+var LogicUnitServiceTag = class extends Context2.Tag("@logix/LogicUnitService")() {
+};
+var makeLogicPhaseError = (kind, api, phase, moduleId) => Object.assign(
+  new Error(
+    `[LogicPhaseError] ${api} is not allowed in ${phase} phase (kind=${kind}).`
+  ),
+  {
+    _tag: "LogicPhaseError",
+    kind,
+    api,
+    phase,
+    moduleId
+  }
+);
+var emitInvalidPhaseDiagnosticIfNeeded = (cause, moduleId) => Effect2.gen(function* () {
+  if (!phaseDiagnosticsEnabled()) {
+    return;
+  }
+  const allErrors = [
+    ...Cause2.failures(cause),
+    ...Cause2.defects(cause)
+  ];
+  for (const err of allErrors) {
+    const logicErr = err;
+    if (logicErr && logicErr._tag === "LogicPhaseError") {
+      const phaseErr = logicErr;
+      const hint = phaseErr.kind === "use_in_setup" || phaseErr.kind === "lifecycle_in_setup" ? "The setup phase must not read Env/services or run long-lived logic; move the relevant calls to the run phase." : phaseErr.kind === "lifecycle_in_run" ? "Do not register $.lifecycle.* in the run phase (setup-only). Move lifecycle registrations to the synchronous part of Module.logic builder (before return)." : phaseErr.kind === "traits_in_run" || phaseErr.kind === "traits_declare_in_run" ? "Traits are frozen after setup; move $.traits.declare to LogicPlan.setup or the setup registration phase of Module.logic builder." : "Move logic to the run phase; keep setup for registrations only.";
+      yield* record({
+        type: "diagnostic",
+        moduleId: phaseErr.moduleId ?? moduleId,
+        code: "logic::invalid_phase",
+        severity: "error",
+        message: `${phaseErr.api ?? phaseErr.kind} is not allowed in ${phaseErr.phase} phase.`,
+        hint,
+        kind: phaseErr.kind
+      });
+      return;
+    }
+  }
+});
+
+// ../logix-core/src/internal/runtime/core/BoundApiRuntime.ts
+var LogicBuilderFactory = (runtime, runtimeInternals) => {
+  const flowApi = make(runtime, runtimeInternals);
+  return (stream, triggerName) => {
+    const runWithStateTransaction = (origin, body) => runtimeInternals.txn.runWithStateTransaction(origin, body);
+    const taskRunnerRuntime = {
+      moduleId: runtime.moduleId,
+      instanceId: runtimeInternals.instanceId,
+      runWithStateTransaction,
+      resolveConcurrencyPolicy: runtimeInternals.concurrency.resolveConcurrencyPolicy
+    };
+    const builder = {
+      debounce: (ms) => LogicBuilderFactory(runtime, runtimeInternals)(
+        flowApi.debounce(ms)(stream),
+        triggerName
+      ),
+      throttle: (ms) => LogicBuilderFactory(runtime, runtimeInternals)(
+        flowApi.throttle(ms)(stream),
+        triggerName
+      ),
+      filter: (predicate) => LogicBuilderFactory(runtime, runtimeInternals)(
+        flowApi.filter(predicate)(stream),
+        triggerName
+      ),
+      map: (f) => LogicBuilderFactory(runtime, runtimeInternals)(
+        stream.pipe(Stream.map(f)),
+        triggerName
+      ),
+      run(eff, options) {
+        return flowApi.run(eff, options)(stream);
+      },
+      runLatest(eff, options) {
+        return flowApi.runLatest(eff, options)(stream);
+      },
+      runExhaust(eff, options) {
+        return flowApi.runExhaust(eff, options)(stream);
+      },
+      runParallel(eff, options) {
+        return flowApi.runParallel(eff, options)(stream);
+      },
+      runFork: (eff) => Effect3.forkScoped(flowApi.run(eff)(stream)).pipe(
+        Effect3.asVoid
+      ),
+      runParallelFork: (eff) => Effect3.forkScoped(
+        flowApi.runParallel(eff)(stream)
+      ).pipe(
+        Effect3.asVoid
+      ),
+      runTask: (config) => makeTaskRunner(
+        stream,
+        "task",
+        taskRunnerRuntime,
+        {
+          ...config,
+          triggerName: config.triggerName ?? triggerName
+        }
+      ),
+      runParallelTask: (config) => makeTaskRunner(
+        stream,
+        "parallel",
+        taskRunnerRuntime,
+        {
+          ...config,
+          triggerName: config.triggerName ?? triggerName
+        }
+      ),
+      runLatestTask: (config) => makeTaskRunner(
+        stream,
+        "latest",
+        taskRunnerRuntime,
+        {
+          ...config,
+          triggerName: config.triggerName ?? triggerName
+        }
+      ),
+      runExhaustTask: (config) => makeTaskRunner(
+        stream,
+        "exhaust",
+        taskRunnerRuntime,
+        {
+          ...config,
+          triggerName: config.triggerName ?? triggerName
+        }
+      ),
+      toStream: () => stream,
+      update: (reducer) => Stream.runForEach(
+        stream,
+        (payload) => taskRunnerRuntime.runWithStateTransaction(
+          {
+            kind: "watcher:update",
+            name: triggerName
+          },
+          () => Effect3.gen(function* () {
+            const prev = yield* runtime.getState;
+            const next = reducer(prev, payload);
+            if (Effect3.isEffect(next)) {
+              const exit = yield* Effect3.exit(
+                next
+              );
+              if (exit._tag === "Failure") {
+                yield* Effect3.logError("Flow error", exit.cause);
+                return;
+              }
+              yield* runtime.setState(exit.value);
+              return;
+            }
+            yield* runtime.setState(next);
+          })
+        )
+      ).pipe(
+        Effect3.catchAllCause(
+          (cause) => Effect3.logError("Flow error", cause)
+        )
+      ),
+      mutate: (reducer) => Stream.runForEach(
+        stream,
+        (payload) => taskRunnerRuntime.runWithStateTransaction(
+          {
+            kind: "watcher:mutate",
+            name: triggerName
+          },
+          () => Effect3.gen(function* () {
+            const prev = yield* runtime.getState;
+            const recordPatch = runtimeInternals?.txn.recordStatePatch;
+            const { nextState, patchPaths } = mutateWithPatchPaths(
+              prev,
+              (draft) => {
+                reducer(draft, payload);
+              }
+            );
+            for (const path of patchPaths) {
+              recordPatch?.({
+                path,
+                reason: "watcher:mutate"
+              });
+            }
+            yield* runtime.setState(nextState);
+          })
+        )
+      ).pipe(
+        Effect3.catchAllCause(
+          (cause) => Effect3.logError("Flow error", cause)
+        )
+      )
+    };
+    const andThen = (handlerOrEff) => {
+      if (typeof handlerOrEff === "function") {
+        if (handlerOrEff.length >= 2) {
+          return builder.update(handlerOrEff);
+        }
+        return builder.run(handlerOrEff);
+      }
+      return builder.run(handlerOrEff);
+    };
+    const pipe = function() {
+      const fns = arguments;
+      let acc = builder;
+      for (let i = 0; i < fns.length; i++) {
+        acc = fns[i](acc);
+      }
+      return acc;
+    };
+    return Object.assign(builder, { pipe, andThen });
+  };
+};
+function make2(shape, runtime, options) {
+  const runtimeInternals = getRuntimeInternals(runtime);
+  const getPhase = options?.getPhase ?? (() => "run");
+  const getCurrentPhase = () => {
+    const phaseService = options?.phaseService;
+    const phase = phaseService?.current ?? getPhase();
+    return phase === "setup" ? "setup" : "run";
+  };
+  const guardRunOnly = (kind, api2) => {
+    const phaseService = options?.phaseService;
+    const phase = phaseService?.current ?? getPhase();
+    if (phase === "setup") {
+      throw makeLogicPhaseError(
+        kind,
+        api2,
+        "setup",
+        options?.moduleId
+      );
+    }
+  };
+  const flowApi = make(runtime, runtimeInternals);
+  const makeIntentBuilder = (runtime_) => LogicBuilderFactory(runtime_, runtimeInternals);
+  const withLifecycle = (available, missing) => Effect3.serviceOption(LifecycleContext).pipe(
+    Effect3.flatMap(
+      (maybe) => Option.match(maybe, {
+        onSome: available,
+        onNone: missing
+      })
+    )
+  );
+  const withPlatform = (invoke) => Effect3.serviceOption(Tag).pipe(
+    Effect3.flatMap(
+      (maybe) => Option.match(maybe, {
+        onSome: invoke,
+        onNone: () => Effect3.void
+      })
+    )
+  );
+  const emitSetupOnlyViolation = (api2) => record({
+    type: "diagnostic",
+    moduleId: runtime.moduleId,
+    instanceId: runtime.instanceId,
+    code: "logic::invalid_phase",
+    severity: "error",
+    message: `${api2} is setup-only and is not allowed in run phase.`,
+    hint: "Move $.lifecycle.* calls to the synchronous part of Module.logic builder (before return) for registration; for dynamic resource cleanup in the run phase, use Effect.acquireRelease / Scope finalizer instead of registering onDestroy late.",
+    kind: "lifecycle_in_run"
+  });
+  const createIntentBuilder = (stream, triggerName) => makeIntentBuilder(runtime)(stream, triggerName);
+  const onceInRunSession = (key) => Effect3.serviceOption(RunSessionTag).pipe(
+    Effect3.map(
+      (maybe) => Option.isSome(maybe) ? maybe.value.local.once(key) : true
+    )
+  );
+  let cachedDiagnosticsLevel;
+  const isModuleLike = (value) => Boolean(
+    value && typeof value === "object" && ((value._kind === "ModuleDef" || value._kind === "Module") && "tag" in value) && Context3.isTag(value.tag)
+  );
+  const buildModuleHandle = (tag, rt) => {
+    const actionsProxy = new Proxy(
+      {},
+      {
+        get: (_target, prop) => (payload) => rt.dispatch({
+          _tag: prop,
+          payload
+        })
+      }
+    );
+    const handle = {
+      read: (selector) => Effect3.map(rt.getState, selector),
+      changes: rt.changes,
+      dispatch: rt.dispatch,
+      actions$: rt.actions$,
+      actions: actionsProxy
+    };
+    const EXTEND_HANDLE = /* @__PURE__ */ Symbol.for("logix.module.handle.extend");
+    const extend = tag?.[EXTEND_HANDLE];
+    return typeof extend === "function" ? extend(rt, handle) ?? handle : handle;
+  };
+  const emitModuleDescriptorOnce = (module, rt) => Effect3.gen(function* () {
+    if (cachedDiagnosticsLevel === "off") return;
+    const key = `module_descriptor:${String(rt.instanceId ?? "unknown")}`;
+    const shouldEmit = yield* onceInRunSession(key);
+    if (!shouldEmit) return;
+    const actionKeys = Object.keys(module.tag?.shape?.actionMap ?? {});
+    const internalSymbol = /* @__PURE__ */ Symbol.for("logix.module.internal");
+    const internal = module[internalSymbol];
+    const logicUnits = (internal?.mounted ?? []).map((u) => ({
+      kind: String(u?.kind ?? "user"),
+      id: String(u?.id ?? ""),
+      derived: u?.derived ? true : void 0,
+      name: typeof u?.name === "string" ? u.name : void 0
+    }));
+    const schemaKeys = module.schemas && typeof module.schemas === "object" ? Object.keys(module.schemas) : void 0;
+    const meta = module.meta && typeof module.meta === "object" ? module.meta : void 0;
+    const source = module.dev?.source;
+    const traitsSnapshot = runtimeInternals.traits.getModuleTraitsSnapshot();
+    const traits = traitsSnapshot ? {
+      digest: traitsSnapshot.digest,
+      count: traitsSnapshot.traits.length
+    } : void 0;
+    const data = {
+      id: module.id,
+      moduleId: String(rt.moduleId),
+      instanceId: String(rt.instanceId),
+      actionKeys,
+      logicUnits,
+      schemaKeys,
+      meta,
+      source,
+      traits
+    };
+    yield* record({
+      type: "trace:module:descriptor",
+      moduleId: rt.moduleId,
+      instanceId: rt.instanceId,
+      data
+    });
+  });
+  const resolveModuleRuntime = (tag) => Effect3.gen(function* () {
+    const requestedModuleId = typeof tag?.id === "string" ? tag.id : void 0;
+    const fromModuleId = typeof options?.moduleId === "string" ? options.moduleId : runtime.moduleId;
+    if (requestedModuleId && requestedModuleId === runtime.moduleId) {
+      return runtime;
+    }
+    const fromImports = runtimeInternals.imports.get(
+      tag
+    );
+    if (fromImports) {
+      return fromImports;
+    }
+    if (typeof options?.moduleId !== "string") {
+      const fromEnv = yield* Effect3.serviceOption(tag);
+      if (Option.isSome(fromEnv)) {
+        return fromEnv.value;
+      }
+    }
+    const tokenId = requestedModuleId ?? "<unknown module id>";
+    const fix = isDevEnv() ? [
+      "- Provide the child implementation in the same scope (imports).",
+      `  Example: ${fromModuleId ?? "ParentModule"}.implement({ imports: [${requestedModuleId ?? "ChildModule"}.impl], ... })`,
+      "- If you intentionally want a root singleton, provide it at app root (Runtime.make(...,{ layer }) / root imports),",
+      "  and use Root.resolve(ModuleTag) (instead of $.use) at the callsite."
+    ] : [];
+    const err = new Error(
+      isDevEnv() ? [
+        "[MissingModuleRuntimeError] Cannot resolve ModuleRuntime for ModuleTag.",
+        "",
+        `tokenId: ${tokenId}`,
+        "entrypoint: logic.$.use",
+        "mode: strict",
+        `from: ${fromModuleId ?? "<unknown module id>"}`,
+        `startScope: moduleId=${fromModuleId ?? "<unknown>"}, instanceId=${String(runtime.instanceId ?? "<unknown>")}`,
+        "",
+        "fix:",
+        ...fix
+      ].join("\n") : "[MissingModuleRuntimeError] module runtime not found"
+    );
+    err.tokenId = tokenId;
+    err.entrypoint = "logic.$.use";
+    err.mode = "strict";
+    err.from = fromModuleId;
+    err.startScope = {
+      moduleId: fromModuleId,
+      instanceId: String(runtime.instanceId ?? "<unknown>")
+    };
+    err.fix = fix;
+    err.name = "MissingModuleRuntimeError";
+    return yield* Effect3.die(err);
+  });
+  const stateApi = {
+    read: runtime.getState,
+    update: (f) => Effect3.gen(function* () {
+      const inTxn = yield* FiberRef.get(inSyncTransactionFiber);
+      if (inTxn) {
+        const prev = yield* runtime.getState;
+        return yield* runtime.setState(f(prev));
+      }
+      const body = () => Effect3.flatMap(runtime.getState, (prev) => runtime.setState(f(prev)));
+      return yield* runtimeInternals ? runtimeInternals.txn.runWithStateTransaction(
+        { kind: "state", name: "update" },
+        body
+      ) : body();
+    }),
+    mutate: (f) => Effect3.gen(function* () {
+      const recordPatch = runtimeInternals?.txn.recordStatePatch;
+      const inTxn = yield* FiberRef.get(inSyncTransactionFiber);
+      if (inTxn) {
+        const prev = yield* runtime.getState;
+        const { nextState, patchPaths } = mutateWithPatchPaths(
+          prev,
+          (draft) => {
+            f(draft);
+          }
+        );
+        for (const path of patchPaths) {
+          recordPatch?.({
+            path,
+            reason: "state:mutate"
+          });
+        }
+        return yield* runtime.setState(nextState);
+      }
+      const body = () => Effect3.flatMap(runtime.getState, (prev) => {
+        const { nextState, patchPaths } = mutateWithPatchPaths(
+          prev,
+          (draft) => {
+            f(draft);
+          }
+        );
+        for (const path of patchPaths) {
+          recordPatch?.({
+            path,
+            reason: "state:mutate"
+          });
+        }
+        return runtime.setState(nextState);
+      });
+      return yield* runtimeInternals ? runtimeInternals.txn.runWithStateTransaction(
+        { kind: "state", name: "mutate" },
+        body
+      ) : body();
+    }),
+    ref: runtime.ref
+  };
+  const actionsApi = new Proxy({}, {
+    get: (_target, prop) => {
+      if (prop === "dispatch") {
+        return (a) => runtime.dispatch(a);
+      }
+      if (prop === "actions$") {
+        return runtime.actions$;
+      }
+      return (payload) => runtime.dispatch({ _tag: prop, payload });
+    }
+  });
+  const matchApi = (value) => makeMatch(value);
+  const matchTagApi = (value) => makeMatchTag(value);
+  const reducer = (tag, fn) => {
+    return Effect3.sync(() => {
+      runtimeInternals.txn.registerReducer(String(tag), fn);
+    });
+  };
+  const api = {
+    root: {
+      resolve: (tag) => {
+        guardRunOnly("root_resolve_in_setup", "$.root.resolve");
+        return resolve(tag, {
+          entrypoint: "logic.$.root.resolve",
+          waitForReady: true
+        });
+      }
+    },
+    state: stateApi,
+    actions: actionsApi,
+    flow: flowApi,
+    match: matchApi,
+    matchTag: matchTagApi,
+    lifecycle: {
+      onInitRequired: (eff) => {
+        if (getCurrentPhase() === "run") {
+          return emitSetupOnlyViolation("$.lifecycle.onInitRequired");
+        }
+        runtimeInternals.lifecycle.registerInitRequired(eff);
+        return Effect3.void;
+      },
+      onStart: (eff) => {
+        if (getCurrentPhase() === "run") {
+          return emitSetupOnlyViolation("$.lifecycle.onStart");
+        }
+        runtimeInternals.lifecycle.registerStart(eff);
+        return Effect3.void;
+      },
+      onInit: (eff) => {
+        if (getCurrentPhase() === "run") {
+          return emitSetupOnlyViolation("$.lifecycle.onInit");
+        }
+        runtimeInternals.lifecycle.registerInitRequired(eff);
+        return Effect3.void;
+      },
+      onDestroy: (eff) => {
+        if (getCurrentPhase() === "run") {
+          return emitSetupOnlyViolation("$.lifecycle.onDestroy");
+        }
+        runtimeInternals.lifecycle.registerDestroy(eff);
+        return Effect3.void;
+      },
+      onError: (handler) => {
+        if (getCurrentPhase() === "run") {
+          return emitSetupOnlyViolation("$.lifecycle.onError");
+        }
+        runtimeInternals.lifecycle.registerOnError(handler);
+        return Effect3.void;
+      },
+      onSuspend: (eff) => {
+        if (getCurrentPhase() === "run") {
+          return emitSetupOnlyViolation("$.lifecycle.onSuspend");
+        }
+        runtimeInternals.lifecycle.registerPlatformSuspend(
+          Effect3.asVoid(eff)
+        );
+        return Effect3.void;
+      },
+      onResume: (eff) => {
+        if (getCurrentPhase() === "run") {
+          return emitSetupOnlyViolation("$.lifecycle.onResume");
+        }
+        runtimeInternals.lifecycle.registerPlatformResume(
+          Effect3.asVoid(eff)
+        );
+        return Effect3.void;
+      },
+      onReset: (eff) => {
+        if (getCurrentPhase() === "run") {
+          return emitSetupOnlyViolation("$.lifecycle.onReset");
+        }
+        runtimeInternals.lifecycle.registerPlatformReset(
+          Effect3.asVoid(eff)
+        );
+        return Effect3.void;
+      }
+    },
+    traits: {
+      declare: (traits) => {
+        if (getCurrentPhase() === "run") {
+          throw makeLogicPhaseError(
+            "traits_declare_in_run",
+            "$.traits.declare",
+            "run",
+            options?.moduleId
+          );
+        }
+        if (!traits || typeof traits !== "object") {
+          throw new Error(
+            "[InvalidTraitsDeclaration] $.traits.declare expects an object."
+          );
+        }
+        const logicUnit = options?.logicUnit ?? {
+          logicUnitId: "unknown",
+          logicUnitIdKind: "derived",
+          logicUnitLabel: "logicUnit:unknown",
+          path: void 0
+        };
+        runtimeInternals.traits.registerModuleTraitsContribution({
+          traits,
+          provenance: {
+            originType: "logicUnit",
+            originId: logicUnit.logicUnitId,
+            originIdKind: logicUnit.logicUnitIdKind,
+            originLabel: logicUnit.logicUnitLabel,
+            path: logicUnit.path
+          }
+        });
+      },
+      source: {
+        refresh: (fieldPath, options2) => Effect3.gen(function* () {
+          const handler = runtimeInternals.traits.getSourceRefreshHandler(
+            fieldPath
+          );
+          if (!handler) {
+            return yield* Effect3.void;
+          }
+          const force = options2?.force === true;
+          const runHandler = (state) => force ? Effect3.locally(forceSourceRefresh, true)(
+            handler(state)
+          ) : handler(state);
+          const inTxn = yield* FiberRef.get(inSyncTransactionFiber);
+          if (inTxn) {
+            const state = yield* runtime.getState;
+            return yield* runHandler(state);
+          }
+          return yield* runtimeInternals.txn.runWithStateTransaction(
+            {
+              kind: "source-refresh",
+              name: fieldPath
+            },
+            () => Effect3.gen(function* () {
+              const state = yield* runtime.getState;
+              return yield* runHandler(state);
+            })
+          );
+        })
+      }
+    },
+    reducer,
+    use: new Proxy(() => {
+    }, {
+      apply: (_target, _thisArg, [arg]) => {
+        guardRunOnly("use_in_setup", "$.use");
+        if (isModuleLike(arg)) {
+          const domain = arg;
+          const tag = domain.tag;
+          const resolveAndBuild = resolveModuleRuntime(tag).pipe(
+            Effect3.map((rt) => buildModuleHandle(tag, rt))
+          );
+          const resolveWithDescriptor = resolveModuleRuntime(tag).pipe(
+            Effect3.tap((rt) => emitModuleDescriptorOnce(domain, rt)),
+            Effect3.map((rt) => buildModuleHandle(tag, rt))
+          );
+          const detectAndSelect = FiberRef.get(currentDiagnosticsLevel).pipe(
+            Effect3.tap((level) => {
+              cachedDiagnosticsLevel = level;
+            }),
+            Effect3.flatMap(
+              (level) => level === "off" ? resolveAndBuild : resolveWithDescriptor
+            )
+          );
+          return Effect3.suspend(() => {
+            if (cachedDiagnosticsLevel === "off") {
+              return resolveAndBuild;
+            }
+            if (cachedDiagnosticsLevel !== void 0) {
+              return resolveWithDescriptor;
+            }
+            return detectAndSelect;
+          });
+        }
+        if (Context3.isTag(arg)) {
+          const candidate = arg;
+          if (candidate._kind === "ModuleTag") {
+            return resolveModuleRuntime(arg).pipe(
+              Effect3.map(
+                (rt) => buildModuleHandle(arg, rt)
+              )
+            );
+          }
+          return arg;
+        }
+        return Effect3.die("BoundApi.use: unsupported argument");
+      }
+    }),
+    onAction: new Proxy(() => {
+    }, {
+      apply: (_target, _thisArg, args) => {
+        guardRunOnly("use_in_setup", "$.onAction");
+        const arg = args[0];
+        if (typeof arg === "function") {
+          return createIntentBuilder(
+            runtime.actions$.pipe(Stream.filter(arg))
+          );
+        }
+        if (typeof arg === "string") {
+          return createIntentBuilder(
+            runtime.actions$.pipe(
+              Stream.filter((a) => a._tag === arg || a.type === arg)
+            ),
+            arg
+          );
+        }
+        if (typeof arg === "object" && arg !== null) {
+          if ("_tag" in arg) {
+            return createIntentBuilder(
+              runtime.actions$.pipe(
+                Stream.filter((a) => a._tag === arg._tag)
+              ),
+              String(arg._tag)
+            );
+          }
+          if (Schema.isSchema(arg)) {
+            return createIntentBuilder(
+              runtime.actions$.pipe(
+                Stream.filter((a) => {
+                  const result = Schema.decodeUnknownSync(
+                    arg
+                  )(a);
+                  return !!result;
+                })
+              )
+            );
+          }
+        }
+        return createIntentBuilder(runtime.actions$);
+      },
+      get: (_target, prop) => {
+        guardRunOnly("use_in_setup", "$.onAction");
+        if (typeof prop === "string") {
+          return createIntentBuilder(
+            runtime.actions$.pipe(
+              Stream.filter(
+                (a) => a._tag === prop || a.type === prop
+              )
+            ),
+            prop
+          );
+        }
+        return void 0;
+      }
+    }),
+    onState: (selector) => {
+      guardRunOnly("use_in_setup", "$.onState");
+      return createIntentBuilder(runtime.changes(selector));
+    },
+    on: (stream) => {
+      guardRunOnly("use_in_setup", "$.on");
+      return createIntentBuilder(stream);
+    }
+  };
+  setBoundInternals(api, runtimeInternals);
+  return api;
+}
+
+export {
+  mutateWithPatchPaths,
+  LifecycleContext,
+  makeLifecycleManager,
+  emitEnvServiceNotFoundDiagnosticIfNeeded,
+  LogicPhaseServiceTag,
+  LogicUnitServiceTag,
+  emitInvalidPhaseDiagnosticIfNeeded,
+  make2 as make
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/runtime/core/mutativePatches.ts", "../../../../logix-core/src/internal/runtime/core/BoundApiRuntime.ts", "../../../../logix-core/src/internal/runtime/core/Lifecycle.ts", "../../../../logix-core/src/internal/runtime/core/LogicDiagnostics.ts"],
  "sourcesContent": ["import { create, type Patches } from \"mutative\"\n\nexport type PatchPath = string\n\nconst toPatchPathString = (path: unknown): PatchPath | \"*\" | undefined => {\n  if (typeof path === \"string\") {\n    const trimmed = path.trim()\n    return trimmed.length > 0 ? trimmed : undefined\n  }\n\n  if (!Array.isArray(path)) return undefined\n\n  const parts: Array<string> = []\n  for (const seg of path) {\n    if (typeof seg === \"string\") {\n      if (seg.length > 0) parts.push(seg)\n      continue\n    }\n    if (typeof seg === \"number\" && Number.isFinite(seg)) {\n      parts.push(String(Math.floor(seg)))\n      continue\n    }\n  }\n\n  if (parts.length === 0) return \"*\"\n  return parts.join(\".\")\n}\n\nexport const mutateWithPatchPaths = <S>(\n  base: S,\n  mutator: (draft: S) => void,\n): { readonly nextState: S; readonly patchPaths: ReadonlyArray<PatchPath | \"*\"> } => {\n  const out = create(base, mutator as any, {\n    enablePatches: {\n      pathAsArray: true,\n      arrayLengthAssignment: false,\n    },\n  }) as unknown\n\n  if (!Array.isArray(out)) {\n    return { nextState: out as S, patchPaths: [] }\n  }\n\n  const nextState = out[0] as S\n  const patches = (out[1] ?? []) as Patches<{ pathAsArray: true; arrayLengthAssignment: false }>\n\n  const set = new Set<PatchPath | \"*\">()\n  for (const patch of patches) {\n    const p = toPatchPathString((patch as any)?.path)\n    if (!p) continue\n    set.add(p)\n  }\n\n  return {\n    nextState,\n    patchPaths: Array.from(set),\n  }\n}\n\n", "import { Context, Effect, FiberRef, Option, Schema, Stream, SubscriptionRef } from \"effect\"\nimport { create } from \"mutative\"\nimport type * as Logix from \"./module.js\"\nimport * as Logic from \"./LogicMiddleware.js\"\nimport * as TaskRunner from \"./TaskRunner.js\"\nimport { mutateWithPatchPaths } from \"./mutativePatches.js\"\nimport * as FlowRuntime from \"./FlowRuntime.js\"\nimport * as MatchBuilder from \"./MatchBuilder.js\"\nimport * as Platform from \"./Platform.js\"\nimport * as Lifecycle from \"./Lifecycle.js\"\nimport * as Debug from \"./DebugSink.js\"\nimport * as LogicDiagnostics from \"./LogicDiagnostics.js\"\nimport { isDevEnv } from \"./env.js\"\nimport { RunSessionTag } from \"../../observability/runSession.js\"\nimport * as Root from \"../../root.js\"\nimport type { RuntimeInternals } from \"./RuntimeInternals.js\"\nimport type * as ModuleTraits from \"./ModuleTraits.js\"\nimport {\n  getRuntimeInternals,\n  setBoundInternals,\n} from \"./runtimeInternalsAccessor.js\"\nimport type {\n  AnyModuleShape,\n  ModuleRuntime,\n  StateOf,\n  ActionOf,\n} from \"./module.js\"\n\n// \u672C\u5730\u6784\u9020 IntentBuilder \u5DE5\u5382\uFF0C\u7B49\u4EF7\u4E8E\u539F internal/dsl/LogicBuilder.makeIntentBuilderFactory\nconst LogicBuilderFactory = <Sh extends AnyModuleShape, R = never>(\n  runtime: ModuleRuntime<StateOf<Sh>, ActionOf<Sh>>,\n  runtimeInternals: RuntimeInternals,\n) => {\n  const flowApi = FlowRuntime.make<Sh, R>(runtime, runtimeInternals)\n\n  return <T>(\n    stream: Stream.Stream<T>,\n    triggerName?: string,\n  ): Logic.IntentBuilder<T, Sh, R> => {\n    const runWithStateTransaction: TaskRunner.TaskRunnerRuntime[\"runWithStateTransaction\"] =\n      (origin, body) => runtimeInternals.txn.runWithStateTransaction(origin as any, body)\n\n\t    const taskRunnerRuntime: TaskRunner.TaskRunnerRuntime = {\n\t      moduleId: runtime.moduleId,\n\t      instanceId: runtimeInternals.instanceId,\n\t      runWithStateTransaction,\n\t      resolveConcurrencyPolicy: runtimeInternals.concurrency.resolveConcurrencyPolicy,\n\t    }\n\n\t    const builder = {\n\t      debounce: (ms: number) =>\n\t        LogicBuilderFactory<Sh, R>(runtime, runtimeInternals)(\n\t          flowApi.debounce<T>(ms)(stream),\n\t          triggerName,\n\t        ),\n\t      throttle: (ms: number) =>\n\t        LogicBuilderFactory<Sh, R>(runtime, runtimeInternals)(\n\t          flowApi.throttle<T>(ms)(stream),\n\t          triggerName,\n\t        ),\n\t      filter: (predicate: (value: T) => boolean) =>\n\t        LogicBuilderFactory<Sh, R>(runtime, runtimeInternals)(\n\t          flowApi.filter(predicate)(stream),\n\t          triggerName,\n\t        ),\n\t      map: <U>(f: (value: T) => U) =>\n\t        LogicBuilderFactory<Sh, R>(runtime, runtimeInternals)(\n\t          stream.pipe(Stream.map(f)),\n\t          triggerName,\n\t        ),\n      run<A = void, E = never, R2 = unknown>(\n        eff:\n          | Logic.Of<Sh, R & R2, A, E>\n          | ((p: T) => Logic.Of<Sh, R & R2, A, E>),\n        options?: Logic.OperationOptions,\n      ): Logic.Of<Sh, R & R2, void, E> {\n        return flowApi.run<T, A, E, R2>(eff, options)(stream)\n      },\n      runLatest<A = void, E = never, R2 = unknown>(\n        eff:\n          | Logic.Of<Sh, R & R2, A, E>\n          | ((p: T) => Logic.Of<Sh, R & R2, A, E>),\n        options?: Logic.OperationOptions,\n      ): Logic.Of<Sh, R & R2, void, E> {\n        return flowApi.runLatest<T, A, E, R2>(eff, options)(stream)\n      },\n      runExhaust<A = void, E = never, R2 = unknown>(\n        eff:\n          | Logic.Of<Sh, R & R2, A, E>\n          | ((p: T) => Logic.Of<Sh, R & R2, A, E>),\n        options?: Logic.OperationOptions,\n      ): Logic.Of<Sh, R & R2, void, E> {\n        return flowApi.runExhaust<T, A, E, R2>(eff, options)(stream)\n      },\n      runParallel<A = void, E = never, R2 = unknown>(\n        eff:\n          | Logic.Of<Sh, R & R2, A, E>\n          | ((p: T) => Logic.Of<Sh, R & R2, A, E>),\n        options?: Logic.OperationOptions,\n      ): Logic.Of<Sh, R & R2, void, E> {\n        return flowApi.runParallel<T, A, E, R2>(eff, options)(stream)\n      },\n      runFork: <A = void, E = never, R2 = unknown>(\n        eff:\n          | Logic.Of<Sh, R & R2, A, E>\n          | ((p: T) => Logic.Of<Sh, R & R2, A, E>)\n      ): Logic.Of<Sh, R & R2, void, E> =>\n        Effect.forkScoped(flowApi.run<T, A, E, R2>(eff)(stream)).pipe(\n          Effect.asVoid,\n        ) as Logic.Of<Sh, R & R2, void, E>,\n      runParallelFork: <A = void, E = never, R2 = unknown>(\n        eff:\n          | Logic.Of<Sh, R & R2, A, E>\n          | ((p: T) => Logic.Of<Sh, R & R2, A, E>)\n      ): Logic.Of<Sh, R & R2, void, E> =>\n        Effect.forkScoped(\n          flowApi.runParallel<T, A, E, R2>(eff)(stream),\n        ).pipe(\n          Effect.asVoid,\n        ) as Logic.Of<Sh, R & R2, void, E>,\n      runTask: <A = void, E = never, R2 = unknown>(\n        config: TaskRunner.TaskRunnerConfig<T, Sh, R & R2, A, E>,\n      ): Logic.Of<Sh, R & R2, void, never> =>\n        TaskRunner.makeTaskRunner<T, Sh, R & R2, A, E>(\n          stream,\n          \"task\",\n          taskRunnerRuntime,\n          {\n            ...config,\n            triggerName: config.triggerName ?? triggerName,\n          },\n        ) as Logic.Of<Sh, R & R2, void, never>,\n      runParallelTask: <A = void, E = never, R2 = unknown>(\n        config: TaskRunner.TaskRunnerConfig<T, Sh, R & R2, A, E>,\n      ): Logic.Of<Sh, R & R2, void, never> =>\n        TaskRunner.makeTaskRunner<T, Sh, R & R2, A, E>(\n          stream,\n          \"parallel\",\n          taskRunnerRuntime,\n          {\n            ...config,\n            triggerName: config.triggerName ?? triggerName,\n          },\n        ) as Logic.Of<Sh, R & R2, void, never>,\n      runLatestTask: <A = void, E = never, R2 = unknown>(\n        config: TaskRunner.TaskRunnerConfig<T, Sh, R & R2, A, E>,\n      ): Logic.Of<Sh, R & R2, void, never> =>\n        TaskRunner.makeTaskRunner<T, Sh, R & R2, A, E>(\n          stream,\n          \"latest\",\n          taskRunnerRuntime,\n          {\n            ...config,\n            triggerName: config.triggerName ?? triggerName,\n          },\n        ) as Logic.Of<Sh, R & R2, void, never>,\n      runExhaustTask: <A = void, E = never, R2 = unknown>(\n        config: TaskRunner.TaskRunnerConfig<T, Sh, R & R2, A, E>,\n      ): Logic.Of<Sh, R & R2, void, never> =>\n        TaskRunner.makeTaskRunner<T, Sh, R & R2, A, E>(\n          stream,\n          \"exhaust\",\n          taskRunnerRuntime,\n          {\n            ...config,\n            triggerName: config.triggerName ?? triggerName,\n          },\n        ) as Logic.Of<Sh, R & R2, void, never>,\n      toStream: () => stream,\n      update: (\n        reducer: (\n          prev: StateOf<Sh>,\n          payload: T\n        ) =>\n          | StateOf<Sh>\n          | Effect.Effect<StateOf<Sh>, any, any>\n      ): Logic.Of<Sh, R, void, never> =>\n        Stream.runForEach(stream, (payload) =>\n          taskRunnerRuntime.runWithStateTransaction(\n            {\n              kind: \"watcher:update\",\n              name: triggerName,\n            },\n            () =>\n              Effect.gen(function* () {\n                const prev = (yield* runtime.getState) as StateOf<Sh>\n                const next = reducer(prev, payload)\n                if (Effect.isEffect(next)) {\n                  const exit = yield* Effect.exit(\n                    next as Effect.Effect<StateOf<Sh>, any, any>,\n                  )\n                  if (exit._tag === \"Failure\") {\n                    yield* Effect.logError(\"Flow error\", exit.cause)\n                    return\n                  }\n                  yield* runtime.setState(exit.value as StateOf<Sh>)\n                  return\n                }\n                yield* runtime.setState(next as StateOf<Sh>)\n              }),\n          )\n        ).pipe(\n          Effect.catchAllCause((cause) =>\n            Effect.logError(\"Flow error\", cause)\n          )\n        ) as Logic.Of<Sh, R, void, never>,\n      mutate: (\n        reducer: (draft: Logic.Draft<StateOf<Sh>>, payload: T) => void\n      ): Logic.Of<Sh, R, void, never> =>\n        Stream.runForEach(stream, (payload) =>\n          taskRunnerRuntime.runWithStateTransaction(\n            {\n              kind: \"watcher:mutate\",\n              name: triggerName,\n            },\n            () =>\n              Effect.gen(function* () {\n                const prev = (yield* runtime.getState) as StateOf<Sh>\n                const recordPatch = runtimeInternals?.txn.recordStatePatch\n\n                const { nextState, patchPaths } = mutateWithPatchPaths(\n                  prev as StateOf<Sh>,\n                  (draft) => {\n                    reducer(draft as Logic.Draft<StateOf<Sh>>, payload)\n                  },\n                )\n\n                for (const path of patchPaths) {\n                  recordPatch?.({\n                    path,\n                    reason: \"watcher:mutate\",\n                  })\n                }\n\n                yield* runtime.setState(nextState)\n              }),\n          )\n        ).pipe(\n          Effect.catchAllCause((cause) =>\n            Effect.logError(\"Flow error\", cause)\n          )\n        ) as Logic.Of<Sh, R, void, never>,\n    } as Omit<Logic.IntentBuilder<T, Sh, R>, \"pipe\" | \"andThen\">\n\n    const andThen: Logic.IntentBuilder<T, Sh, R>[\"andThen\"] = (\n      handlerOrEff: any,\n    ): any => {\n      if (typeof handlerOrEff === \"function\") {\n        if (handlerOrEff.length >= 2) {\n          return (builder as any).update(handlerOrEff)\n        }\n        return (builder as any).run(handlerOrEff)\n      }\n      return (builder as any).run(handlerOrEff)\n    }\n\n    const pipe: Logic.IntentBuilder<T, Sh, R>[\"pipe\"] = function (this: unknown) {\n      // eslint-disable-next-line prefer-rest-params\n      const fns = arguments as unknown as ReadonlyArray<\n        (self: Logic.IntentBuilder<T, Sh, R>) => Logic.IntentBuilder<T, Sh, R>\n      >\n      let acc: Logic.IntentBuilder<T, Sh, R> = builder as Logic.IntentBuilder<\n        T,\n        Sh,\n        R\n      >\n      for (let i = 0; i < fns.length; i++) {\n        acc = fns[i](acc)\n      }\n      return acc\n    }\n\n    return Object.assign(builder, { pipe, andThen }) as Logic.IntentBuilder<\n      T,\n      Sh,\n      R\n    >\n  }\n}\nimport type { BoundApi } from \"./module.js\"\n\n/**\n * BoundApi \u5B9E\u73B0\uFF1A\u4E3A\u67D0\u4E00\u7C7B Store Shape + Runtime \u521B\u5EFA\u9884\u7ED1\u5B9A\u7684 `$`\u3002\n *\n * \u8BF4\u660E\uFF1A\u7C7B\u578B\u4E0E\u5165\u53E3\u7B7E\u540D\u5728 api/BoundApi.ts \u4E2D\u58F0\u660E\uFF0C\u8FD9\u91CC\u53EA\u627F\u8F7D\u5177\u4F53\u5B9E\u73B0\u3002\n */\nexport function make<Sh extends Logix.AnyModuleShape, R = never>(\n  shape: Sh,\n  runtime: Logix.ModuleRuntime<Logix.StateOf<Sh>, Logix.ActionOf<Sh>>,\n  options?: {\n    readonly getPhase?: () => \"setup\" | \"run\"\n    readonly phaseService?: LogicDiagnostics.LogicPhaseService\n    readonly moduleId?: string\n    readonly logicUnit?: LogicDiagnostics.LogicUnitService\n  }\n  ): BoundApi<Sh, R> {\n  const runtimeInternals = getRuntimeInternals(runtime as any)\n\n  const getPhase = options?.getPhase ?? (() => \"run\")\n  const getCurrentPhase = (): \"setup\" | \"run\" => {\n    const phaseService = options?.phaseService\n    const phase = phaseService?.current ?? getPhase()\n    return phase === \"setup\" ? \"setup\" : \"run\"\n  }\n  const guardRunOnly = (kind: string, api: string) => {\n    const phaseService = options?.phaseService\n    const phase = phaseService?.current ?? getPhase()\n    if (phase === \"setup\") {\n      throw LogicDiagnostics.makeLogicPhaseError(\n        kind,\n        api,\n        \"setup\",\n        options?.moduleId\n      )\n    }\n  }\n  const flowApi = FlowRuntime.make<Sh, R>(runtime, runtimeInternals)\n\n  const makeIntentBuilder = (runtime_: Logix.ModuleRuntime<any, any>) =>\n    LogicBuilderFactory<Sh, R>(runtime_, runtimeInternals)\n  const withLifecycle = <A>(\n    available: (\n      manager: Lifecycle.LifecycleManager\n    ) => Effect.Effect<A, never, any>,\n    missing: () => Effect.Effect<A, never, any>\n  ) =>\n    Effect.serviceOption(Lifecycle.LifecycleContext).pipe(\n      Effect.flatMap((maybe) =>\n        Option.match(maybe, {\n          onSome: available,\n          onNone: missing,\n        })\n      )\n    )\n  const withPlatform = (\n    invoke: (platform: Platform.Service) => Effect.Effect<void, never, any>\n  ) =>\n    Effect.serviceOption(Platform.Tag).pipe(\n      Effect.flatMap((maybe) =>\n        Option.match(maybe, {\n          onSome: invoke,\n          onNone: () => Effect.void,\n        })\n      )\n    )\n\n  const emitSetupOnlyViolation = (api: string): Effect.Effect<void> =>\n    Debug.record({\n      type: \"diagnostic\",\n      moduleId: runtime.moduleId,\n      instanceId: runtime.instanceId,\n      code: \"logic::invalid_phase\",\n      severity: \"error\",\n      message: `${api} is setup-only and is not allowed in run phase.`,\n      hint:\n        \"Move $.lifecycle.* calls to the synchronous part of Module.logic builder (before return) for registration; \" +\n        \"for dynamic resource cleanup in the run phase, use Effect.acquireRelease / Scope finalizer instead of registering onDestroy late.\",\n      kind: \"lifecycle_in_run\",\n    })\n\n  const createIntentBuilder = <T>(\n    stream: Stream.Stream<T>,\n    triggerName?: string,\n  ) => makeIntentBuilder(runtime)(stream, triggerName)\n\n  const onceInRunSession = (key: string): Effect.Effect<boolean, never, any> =>\n    Effect.serviceOption(RunSessionTag).pipe(\n      Effect.map((maybe) =>\n        Option.isSome(maybe) ? maybe.value.local.once(key) : true,\n      ),\n    )\n\n  let cachedDiagnosticsLevel: Debug.DiagnosticsLevel | undefined\n\n  const isModuleLike = (\n    value: unknown,\n  ): value is {\n    readonly _kind: \"ModuleDef\" | \"Module\"\n    readonly id: string\n    readonly tag: Context.Tag<any, Logix.ModuleRuntime<any, any>>\n    readonly schemas?: Record<string, unknown>\n    readonly meta?: Record<string, unknown>\n    readonly dev?: { readonly source?: { readonly file: string; readonly line: number; readonly column: number } }\n  } =>\n    Boolean(\n      value &&\n        typeof value === \"object\" &&\n        (((value as any)._kind === \"ModuleDef\" || (value as any)._kind === \"Module\") &&\n          \"tag\" in (value as object)) &&\n        Context.isTag((value as any).tag),\n    )\n\n  const buildModuleHandle = (\n    tag: Context.Tag<any, Logix.ModuleRuntime<any, any>>,\n    rt: Logix.ModuleRuntime<any, any>,\n  ): unknown => {\n    const actionsProxy: Logix.ModuleHandle<any>[\"actions\"] =\n      new Proxy(\n        {},\n        {\n          get: (_target, prop) =>\n            (payload: unknown) =>\n              rt.dispatch({\n                _tag: prop as string,\n                payload,\n              }),\n        },\n      ) as Logix.ModuleHandle<any>[\"actions\"]\n\n    const handle: Logix.ModuleHandle<any> = {\n      read: (selector) => Effect.map(rt.getState, selector),\n      changes: rt.changes,\n      dispatch: rt.dispatch,\n      actions$: rt.actions$,\n      actions: actionsProxy,\n    }\n\n    const EXTEND_HANDLE = Symbol.for(\"logix.module.handle.extend\")\n    const extend =\n      (tag as any)?.[EXTEND_HANDLE] as\n        | ((\n            runtime: Logix.ModuleRuntime<any, any>,\n            base: Logix.ModuleHandle<any>,\n          ) => unknown)\n        | undefined\n\n    return typeof extend === \"function\" ? (extend(rt, handle) ?? handle) : handle\n  }\n\n  const emitModuleDescriptorOnce = (\n    module: {\n      readonly id: string\n      readonly tag: any\n      readonly schemas?: Record<string, unknown>\n      readonly meta?: Record<string, unknown>\n      readonly dev?: { readonly source?: { readonly file: string; readonly line: number; readonly column: number } }\n    },\n    rt: Logix.ModuleRuntime<any, any>,\n  ): Effect.Effect<void, never, any> =>\n    Effect.gen(function* () {\n      // \u4E3A hot-path \u515C\u5E95\uFF1A\u8BCA\u65AD\u7EA7\u522B\u4E3A off \u65F6\u6C38\u4E0D\u53D1\u4E8B\u4EF6\u3002\n      if (cachedDiagnosticsLevel === \"off\") return\n\n      const key = `module_descriptor:${String(rt.instanceId ?? \"unknown\")}`\n      const shouldEmit = yield* onceInRunSession(key)\n      if (!shouldEmit) return\n\n      const actionKeys = Object.keys((module.tag as any)?.shape?.actionMap ?? {})\n\n      const internalSymbol = Symbol.for(\"logix.module.internal\")\n      const internal = (module as any)[internalSymbol] as\n        | { readonly mounted?: ReadonlyArray<any> }\n        | undefined\n\n      const logicUnits = (internal?.mounted ?? []).map((u: any) => ({\n        kind: String(u?.kind ?? \"user\"),\n        id: String(u?.id ?? \"\"),\n        derived: u?.derived ? true : undefined,\n        name: typeof u?.name === \"string\" ? u.name : undefined,\n      }))\n\n      const schemaKeys =\n        module.schemas && typeof module.schemas === \"object\"\n          ? Object.keys(module.schemas)\n          : undefined\n\n      const meta =\n        module.meta && typeof module.meta === \"object\" ? module.meta : undefined\n\n      const source = module.dev?.source\n\n      const traitsSnapshot = runtimeInternals.traits.getModuleTraitsSnapshot()\n      const traits =\n        traitsSnapshot\n          ? {\n              digest: traitsSnapshot.digest,\n              count: traitsSnapshot.traits.length,\n            }\n          : undefined\n\n      const data = {\n        id: module.id,\n        moduleId: String(rt.moduleId),\n        instanceId: String(rt.instanceId),\n        actionKeys,\n        logicUnits,\n        schemaKeys,\n        meta,\n        source,\n        traits,\n      }\n\n      yield* Debug.record({\n        type: \"trace:module:descriptor\",\n        moduleId: rt.moduleId,\n        instanceId: rt.instanceId,\n        data,\n      } as any)\n    })\n\n  /**\n   * strict\uFF1A\u53EA\u4ECE\u201C\u5F53\u524D Effect Env\u201D\u89E3\u6790\u67D0\u4E2A Module \u7684 Runtime\u3002\n   *\n   * \u8BF4\u660E\uFF1A\n   * - \u591A root / \u591A\u5B9E\u4F8B\u573A\u666F\u4E0B\uFF0C\u4EFB\u4F55\u8FDB\u7A0B\u7EA7 registry \u90FD\u65E0\u6CD5\u8868\u8FBE\u6B63\u786E\u8BED\u4E49\uFF1B\n   * - \u7F3A\u5931\u63D0\u4F9B\u8005\u5C5E\u4E8E\u88C5\u914D\u9519\u8BEF\uFF1A\u5FC5\u987B\u7A33\u5B9A\u5931\u8D25\uFF0C\u5E76\u7ED9\u51FA\u53EF\u4FEE\u590D\u7684\u63D0\u793A\uFF08dev/test \u4E0B\u66F4\u8BE6\u7EC6\uFF09\u3002\n   */\n\t  const resolveModuleRuntime = (\n\t    tag: Context.Tag<any, Logix.ModuleRuntime<any, any>>\n\t  ): Effect.Effect<Logix.ModuleRuntime<any, any>, never, any> =>\n\t    Effect.gen(function* () {\n\t      const requestedModuleId =\n\t        typeof (tag as any)?.id === \"string\"\n\t          ? ((tag as any).id as string)\n\t          : undefined\n\t      const fromModuleId =\n\t        typeof options?.moduleId === \"string\" ? options.moduleId : runtime.moduleId\n\n\t      // self\uFF1A\u59CB\u7EC8\u5141\u8BB8\u89E3\u6790\u5230\u5F53\u524D ModuleRuntime\uFF08Bound.make / runtime \u6CE8\u5165\u4E24\u6761\u8DEF\u5F84\u90FD\u6210\u7ACB\uFF09\n\t      if (requestedModuleId && requestedModuleId === runtime.moduleId) {\n\t        return runtime as unknown as Logix.ModuleRuntime<any, any>\n\t      }\n\n\t      const fromImports = runtimeInternals.imports.get(\n\t        tag as unknown as Context.Tag<any, any>,\n\t      )\n\t      if (fromImports) {\n\t        return fromImports as unknown as Logix.ModuleRuntime<any, any>\n\t      }\n\n\t      // Bound.make\uFF08\u65E0 moduleId \u4E0A\u4E0B\u6587\uFF09\u573A\u666F\uFF1A\u5141\u8BB8\u4ECE\u5F53\u524D Effect Env \u89E3\u6790 module runtime\uFF08\u4FBF\u4E8E\u6D4B\u8BD5/\u811A\u624B\u67B6\uFF09\u3002\n\t      if (typeof options?.moduleId !== \"string\") {\n\t        const fromEnv = yield* Effect.serviceOption(tag as any)\n\t        if (Option.isSome(fromEnv)) {\n\t          return fromEnv.value as unknown as Logix.ModuleRuntime<any, any>\n\t        }\n\t      }\n\n\t      // 2) \u65E0\u6CD5\u627E\u5230\u65F6\u76F4\u63A5 die \u2014\u2014 \u8FD9\u662F\u914D\u7F6E\u9519\u8BEF\uFF0C\u63D0\u793A\u8C03\u7528\u65B9\u4FEE\u6B63\u88C5\u914D\u65B9\u5F0F\n\t      const tokenId = requestedModuleId ?? \"<unknown module id>\"\n      const fix: string[] = isDevEnv()\n        ? [\n            \"- Provide the child implementation in the same scope (imports).\",\n            `  Example: ${fromModuleId ?? \"ParentModule\"}.implement({ imports: [${requestedModuleId ?? \"ChildModule\"}.impl], ... })`,\n            \"- If you intentionally want a root singleton, provide it at app root (Runtime.make(...,{ layer }) / root imports),\",\n            \"  and use Root.resolve(ModuleTag) (instead of $.use) at the callsite.\",\n          ]\n        : []\n\n      const err = new Error(\n        isDevEnv()\n          ? [\n              \"[MissingModuleRuntimeError] Cannot resolve ModuleRuntime for ModuleTag.\",\n              \"\",\n              `tokenId: ${tokenId}`,\n              \"entrypoint: logic.$.use\",\n              \"mode: strict\",\n              `from: ${fromModuleId ?? \"<unknown module id>\"}`,\n              `startScope: moduleId=${fromModuleId ?? \"<unknown>\"}, instanceId=${String(runtime.instanceId ?? \"<unknown>\")}`,\n              \"\",\n              \"fix:\",\n              ...fix,\n            ].join(\"\\n\")\n          : \"[MissingModuleRuntimeError] module runtime not found\",\n      )\n\n      ;(err as any).tokenId = tokenId\n      ;(err as any).entrypoint = \"logic.$.use\"\n      ;(err as any).mode = \"strict\"\n      ;(err as any).from = fromModuleId\n      ;(err as any).startScope = {\n        moduleId: fromModuleId,\n        instanceId: String(runtime.instanceId ?? \"<unknown>\"),\n      }\n      ;(err as any).fix = fix\n\n      err.name = \"MissingModuleRuntimeError\"\n      return yield* Effect.die(err)\n    })\n\n  const stateApi: BoundApi<Sh, R>[\"state\"] = {\n    read: runtime.getState,\n    update: (f) =>\n      Effect.gen(function* () {\n        const inTxn = yield* FiberRef.get(TaskRunner.inSyncTransactionFiber)\n        if (inTxn) {\n          const prev = yield* runtime.getState\n          return yield* runtime.setState(f(prev))\n        }\n\n        const body = () =>\n          Effect.flatMap(runtime.getState, (prev) => runtime.setState(f(prev)))\n\n        return yield* (runtimeInternals\n          ? runtimeInternals.txn.runWithStateTransaction(\n              { kind: \"state\", name: \"update\" } as any,\n              body,\n            )\n          : body())\n      }),\n    mutate: (f) =>\n      Effect.gen(function* () {\n        const recordPatch = runtimeInternals?.txn.recordStatePatch\n\n        const inTxn = yield* FiberRef.get(TaskRunner.inSyncTransactionFiber)\n        if (inTxn) {\n          const prev = yield* runtime.getState\n          const { nextState, patchPaths } = mutateWithPatchPaths(\n            prev as Logix.StateOf<Sh>,\n            (draft) => {\n              f(draft as Logic.Draft<Logix.StateOf<Sh>>)\n            },\n          )\n\n          for (const path of patchPaths) {\n            recordPatch?.({\n              path,\n              reason: \"state:mutate\",\n            })\n          }\n\n          return yield* runtime.setState(nextState)\n        }\n\n        const body = () =>\n          Effect.flatMap(runtime.getState, (prev) => {\n            const { nextState, patchPaths } = mutateWithPatchPaths(\n              prev as Logix.StateOf<Sh>,\n              (draft) => {\n                f(draft as Logic.Draft<Logix.StateOf<Sh>>)\n              },\n            )\n\n            for (const path of patchPaths) {\n              recordPatch?.({\n                path,\n                reason: \"state:mutate\",\n              })\n            }\n\n            return runtime.setState(nextState)\n          })\n\n        return yield* (runtimeInternals\n          ? runtimeInternals.txn.runWithStateTransaction(\n              { kind: \"state\", name: \"mutate\" } as any,\n              body,\n            )\n          : body())\n      }),\n    ref: runtime.ref,\n  }\n\n  const actionsApi = new Proxy({} as BoundApi<Sh, R>[\"actions\"], {\n    get: (_target, prop) => {\n      if (prop === \"dispatch\") {\n        return (a: Logix.ActionOf<Sh>) => runtime.dispatch(a)\n      }\n      if (prop === \"actions$\") {\n        return runtime.actions$\n      }\n      return (payload: any) =>\n        runtime.dispatch({ _tag: prop as string, payload } as Logix.ActionOf<Sh>)\n    },\n  })\n\n  const matchApi = <V>(value: V): Logic.FluentMatch<V> =>\n    MatchBuilder.makeMatch(value)\n\n  const matchTagApi = <V extends { _tag: string }>(\n    value: V\n  ): Logic.FluentMatchTag<V> => MatchBuilder.makeMatchTag(value)\n\n  // Primary Reducer \u6CE8\u518C\uFF1A\u901A\u8FC7 runtime \u4E0A\u7684\u5185\u90E8\u6CE8\u518C\u51FD\u6570\uFF08\u82E5\u5B58\u5728\uFF09\u5199\u5165 reducer \u6620\u5C04\u3002\n  const reducer: BoundApi<Sh, R>[\"reducer\"] = (tag, fn) => {\n    return Effect.sync(() => {\n      runtimeInternals.txn.registerReducer(String(tag), fn as any)\n    }) as any\n  }\n\n  const api: BoundApi<Sh, R> = {\n    root: {\n      resolve: (tag: any) => {\n        guardRunOnly(\"root_resolve_in_setup\", \"$.root.resolve\")\n        return Root.resolve(tag, {\n          entrypoint: \"logic.$.root.resolve\",\n          waitForReady: true,\n        }) as any\n      },\n    },\n    state: stateApi,\n    actions: actionsApi,\n    flow: flowApi,\n    match: matchApi,\n    matchTag: matchTagApi,\n    lifecycle: {\n      onInitRequired: (eff: Logic.Of<Sh, R, void, never>) => {\n        if (getCurrentPhase() === \"run\") {\n          return emitSetupOnlyViolation(\"$.lifecycle.onInitRequired\") as any\n        }\n        runtimeInternals.lifecycle.registerInitRequired(eff as any)\n        return Effect.void as any\n      },\n      onStart: (eff: Logic.Of<Sh, R, void, never>) => {\n        if (getCurrentPhase() === \"run\") {\n          return emitSetupOnlyViolation(\"$.lifecycle.onStart\") as any\n        }\n        runtimeInternals.lifecycle.registerStart(eff as any)\n        return Effect.void as any\n      },\n      onInit: (eff: Logic.Of<Sh, R, void, never>) => {\n        // legacy alias\uFF1A\u8BED\u4E49\u7B49\u540C\u4E8E onInitRequired\uFF08\u4E3A\u4E86\u8FC1\u79FB\u671F\u51CF\u5C11\u6469\u64E6\uFF09\u3002\n        if (getCurrentPhase() === \"run\") {\n          return emitSetupOnlyViolation(\"$.lifecycle.onInit\") as any\n        }\n        runtimeInternals.lifecycle.registerInitRequired(eff as any)\n        return Effect.void as any\n      },\n      onDestroy: (eff: Logic.Of<Sh, R, void, never>) => {\n        if (getCurrentPhase() === \"run\") {\n          return emitSetupOnlyViolation(\"$.lifecycle.onDestroy\") as any\n        }\n        runtimeInternals.lifecycle.registerDestroy(eff as any)\n        return Effect.void as any\n      },\n      onError: (\n        handler: (\n          cause: import(\"effect\").Cause.Cause<unknown>,\n          context: Lifecycle.ErrorContext,\n        ) => Effect.Effect<void, never, R>,\n      ) => {\n        if (getCurrentPhase() === \"run\") {\n          return emitSetupOnlyViolation(\"$.lifecycle.onError\") as any\n        }\n        runtimeInternals.lifecycle.registerOnError(handler as any)\n        return Effect.void as any\n      },\n      onSuspend: (\n        eff: Logic.Of<Sh, R, void, never>,\n      ) => {\n        if (getCurrentPhase() === \"run\") {\n          return emitSetupOnlyViolation(\"$.lifecycle.onSuspend\") as any\n        }\n        runtimeInternals.lifecycle.registerPlatformSuspend(\n          Effect.asVoid(eff as Effect.Effect<void, never, any>),\n        )\n        return Effect.void as any\n      },\n      onResume: (\n        eff: Logic.Of<Sh, R, void, never>,\n      ) => {\n        if (getCurrentPhase() === \"run\") {\n          return emitSetupOnlyViolation(\"$.lifecycle.onResume\") as any\n        }\n        runtimeInternals.lifecycle.registerPlatformResume(\n          Effect.asVoid(eff as Effect.Effect<void, never, any>),\n        )\n        return Effect.void as any\n      },\n      onReset: (\n        eff: Logic.Of<Sh, R, void, never>,\n      ) => {\n        if (getCurrentPhase() === \"run\") {\n          return emitSetupOnlyViolation(\"$.lifecycle.onReset\") as any\n        }\n        runtimeInternals.lifecycle.registerPlatformReset(\n          Effect.asVoid(eff as Effect.Effect<void, never, any>),\n        )\n        return Effect.void as any\n      },\n    },\n    traits: {\n      declare: (traits: ModuleTraits.TraitSpec) => {\n        if (getCurrentPhase() === \"run\") {\n          throw LogicDiagnostics.makeLogicPhaseError(\n            \"traits_declare_in_run\",\n            \"$.traits.declare\",\n            \"run\",\n            options?.moduleId,\n          )\n        }\n\n        if (!traits || typeof traits !== \"object\") {\n          throw new Error(\n            \"[InvalidTraitsDeclaration] $.traits.declare expects an object.\",\n          )\n        }\n\n        const logicUnit = options?.logicUnit ?? {\n          logicUnitId: \"unknown\",\n          logicUnitIdKind: \"derived\" as const,\n          logicUnitLabel: \"logicUnit:unknown\",\n          path: undefined as string | undefined,\n        }\n\n        runtimeInternals.traits.registerModuleTraitsContribution({\n          traits,\n          provenance: {\n            originType: \"logicUnit\",\n            originId: logicUnit.logicUnitId,\n            originIdKind: logicUnit.logicUnitIdKind,\n            originLabel: logicUnit.logicUnitLabel,\n            path: logicUnit.path,\n          },\n        })\n      },\n      source: {\n        refresh: (\n          fieldPath: string,\n          options?: { readonly force?: boolean },\n        ) =>\n          Effect.gen(function* () {\n            const handler = (runtimeInternals.traits.getSourceRefreshHandler(\n              fieldPath,\n            ) as\n              | ((state: Logix.StateOf<Sh>) => Effect.Effect<void, never, any>)\n              | undefined)\n            if (!handler) {\n              // \u82E5\u672A\u6CE8\u518C\u5237\u65B0\u903B\u8F91\uFF0C\u5219\u89C6\u4E3A no-op\uFF0C\u907F\u514D\u5728\u672A\u6302 StateTraitProgram \u65F6\u629B\u9519\u3002\n              return yield* Effect.void\n            }\n\n            const force = options?.force === true\n            const runHandler = (state: Logix.StateOf<Sh>) =>\n              force\n                ? Effect.locally(TaskRunner.forceSourceRefresh, true)(\n                    handler(state),\n                  )\n                : handler(state)\n\n            // \u4E8B\u52A1\u7A97\u53E3\u5185\u7981\u6B62\u518D\u8D70 enqueueTransaction\uFF08\u4F1A\u5BFC\u81F4\u6B7B\u9501\uFF09\uFF1A\n            // - \u76F4\u63A5\u5728\u5F53\u524D\u4E8B\u52A1\u5185\u6267\u884C handler\uFF0C\u4F7F\u5176\u901A\u8FC7 bound.state.mutate \u5199\u5165 draft\uFF1B\n            // - \u7531\u5916\u5C42\u540C\u4E00\u4E8B\u52A1\u7A97\u53E3\u8D1F\u8D23 commit + debug \u805A\u5408\u3002\n            const inTxn = yield* FiberRef.get(TaskRunner.inSyncTransactionFiber)\n            if (inTxn) {\n              const state = (yield* runtime.getState) as Logix.StateOf<Sh>\n              return yield* runHandler(state)\n            }\n\n            // \u5C06\u4E00\u6B21 source-refresh \u89C6\u4E3A\u5355\u72EC\u7684\u4E8B\u52A1\u5165\u53E3\u3002\n            return yield* runtimeInternals.txn.runWithStateTransaction(\n              {\n                kind: \"source-refresh\",\n                name: fieldPath,\n              } as any,\n              () =>\n                Effect.gen(function* () {\n                  const state = (yield* runtime.getState) as Logix.StateOf<Sh>\n                  return yield* runHandler(state)\n                }),\n            )\n          }),\n      },\n    },\n    reducer,\n    use: new Proxy(() => {}, {\n      apply: (_target, _thisArg, [arg]) => {\n        guardRunOnly(\"use_in_setup\", \"$.use\")\n        if (isModuleLike(arg)) {\n          const domain = arg\n          const tag = domain.tag as unknown as Context.Tag<\n            any,\n            Logix.ModuleRuntime<any, any>\n          >\n\n          const resolveAndBuild = resolveModuleRuntime(tag).pipe(\n            Effect.map((rt) => buildModuleHandle(tag, rt)),\n          )\n\n          const resolveWithDescriptor = resolveModuleRuntime(tag).pipe(\n            Effect.tap((rt) => emitModuleDescriptorOnce(domain, rt)),\n            Effect.map((rt) => buildModuleHandle(tag, rt)),\n          )\n\n          const detectAndSelect = FiberRef.get(Debug.currentDiagnosticsLevel).pipe(\n            Effect.tap((level) => {\n              cachedDiagnosticsLevel = level\n            }),\n            Effect.flatMap((level) =>\n              level === \"off\" ? resolveAndBuild : resolveWithDescriptor,\n            ),\n          )\n\n          // 022 perf gate\uFF1Adiagnostics off \u65F6\uFF0C$.use(module) \u4E0E $.use(module.tag) \u5FC5\u987B\u7B49\u4EF7\u4E14\u96F6\u989D\u5916\u5F00\u9500\u3002\n          // \u7EA6\u675F\uFF1AEffect \u662F\u503C\uFF08\u53EF\u590D\u7528\uFF09\uFF1B\u56E0\u6B64\u5FC5\u987B\u5728\u6267\u884C\u671F\u505A\u4E00\u6B21\u6027\u7F13\u5B58\uFF0C\u800C\u4E0D\u80FD\u5728\u6784\u9020\u671F\u56FA\u5B9A\u5206\u652F\u3002\n\t          return Effect.suspend(() => {\n\t            if (cachedDiagnosticsLevel === \"off\") {\n\t              return resolveAndBuild\n\t            }\n\n\t            if (cachedDiagnosticsLevel !== undefined) {\n\t              return resolveWithDescriptor\n\t            }\n\n\t            return detectAndSelect\n\t          }) as unknown as Logic.Of<Sh, R, any, never>\n\t        }\n        if (Context.isTag(arg)) {\n          const candidate = arg as { _kind?: unknown }\n\n          // Module\uFF1A\u8FD4\u56DE\u53EA\u8BFB ModuleHandle \u89C6\u56FE\n          if (candidate._kind === \"ModuleTag\") {\n            return resolveModuleRuntime(arg as any).pipe(\n              Effect.map((rt: Logix.ModuleRuntime<any, any>) =>\n                buildModuleHandle(arg as any, rt),\n              ),\n            ) as unknown as Logic.Of<Sh, R, any, never>\n          }\n\n          // \u666E\u901A Service Tag\uFF1A\u76F4\u63A5\u4ECE Env \u83B7\u53D6 Service\n          return arg as unknown as Logic.Of<Sh, R, any, never>\n        }\n        return Effect.die(\"BoundApi.use: unsupported argument\") as unknown as Logic.Of<\n          Sh,\n          R,\n          any,\n          never\n        >\n      },\n    }) as unknown as BoundApi<Sh, R>[\"use\"],\n    onAction: new Proxy(() => {}, {\n      apply: (_target, _thisArg, args) => {\n        guardRunOnly(\"use_in_setup\", \"$.onAction\")\n        const arg = args[0]\n        if (typeof arg === \"function\") {\n          return createIntentBuilder(\n            runtime.actions$.pipe(Stream.filter(arg))\n          )\n        }\n        if (typeof arg === \"string\") {\n          return createIntentBuilder(\n            runtime.actions$.pipe(\n              Stream.filter((a: any) => a._tag === arg || a.type === arg)\n            ),\n            arg,\n          )\n        }\n        if (typeof arg === \"object\" && arg !== null) {\n          if (\"_tag\" in arg) {\n            return createIntentBuilder(\n              runtime.actions$.pipe(\n                Stream.filter((a: any) => a._tag === (arg as any)._tag)\n              ),\n              String((arg as any)._tag),\n            )\n          }\n          if (Schema.isSchema(arg)) {\n            return createIntentBuilder(\n              runtime.actions$.pipe(\n                Stream.filter((a: any) => {\n                  const result = Schema.decodeUnknownSync(\n                    arg as Schema.Schema<any, any, never>\n                  )(a)\n                  return !!result\n                })\n              )\n            )\n          }\n        }\n        return createIntentBuilder(runtime.actions$)\n      },\n      get: (_target, prop) => {\n        guardRunOnly(\"use_in_setup\", \"$.onAction\")\n        if (typeof prop === \"string\") {\n          return createIntentBuilder(\n            runtime.actions$.pipe(\n              Stream.filter(\n                (a: any) => a._tag === prop || a.type === prop\n              )\n            ),\n            prop,\n          )\n        }\n        return undefined\n      },\n    }) as unknown as BoundApi<Sh, R>[\"onAction\"],\n    onState: (\n      selector: (s: Logix.StateOf<Sh>) => any,\n    ) => {\n      guardRunOnly(\"use_in_setup\", \"$.onState\")\n      return createIntentBuilder(runtime.changes(selector))\n    },\n    on: (\n      stream: Stream.Stream<any>,\n    ) => {\n      guardRunOnly(\"use_in_setup\", \"$.on\")\n      return createIntentBuilder(stream)\n    },\n  } as any\n\n  setBoundInternals(api as any, runtimeInternals)\n\n  return api\n}\n", "import { Cause, Context, Effect, Ref } from \"effect\"\nimport { toSerializableErrorSummary } from \"./errorSummary.js\"\nimport * as Debug from \"./DebugSink.js\"\n\nexport type Phase = \"init\" | \"run\" | \"destroy\" | \"platform\"\n\nexport type Hook =\n  | \"initRequired\"\n  | \"start\"\n  | \"destroy\"\n  | \"suspend\"\n  | \"resume\"\n  | \"reset\"\n  | \"unknown\"\n\nexport type TaskKind =\n  | \"initRequired\"\n  | \"start\"\n  | \"destroy\"\n  | \"platformSuspend\"\n  | \"platformResume\"\n  | \"platformReset\"\n\nexport interface ErrorContext {\n  readonly phase: Phase\n  readonly hook: Hook\n  readonly moduleId: string\n  readonly instanceId: string\n  readonly taskId?: string\n  readonly txnSeq?: number\n  readonly opSeq?: number\n  /**\n   * \u4EC5\u7528\u4E8E\u8BCA\u65AD\u89E3\u91CA\uFF1A\u8BB0\u5F55\u201C\u9519\u8BEF\u4ECE\u54EA\u91CC\u5192\u51FA\u6765\u201D\u7684\u5B9E\u73B0\u4FA7\u6807\u8BC6\uFF0C\n   * \u4F8B\u5982 \"logic.fork\" / \"initRequired\" / \"start\"\u3002\n   *\n   * \u6CE8\u610F\uFF1A\u8BE5\u5B57\u6BB5\u5FC5\u987B\u53EF\u5E8F\u5217\u5316\uFF0C\u4E14\u4E0D\u5E94\u6210\u4E3A\u534F\u8BAE\u951A\u70B9\u3002\n   */\n  readonly origin?: string\n}\n\nexport interface ModuleRuntimeIdentity {\n  readonly moduleId: string\n  readonly instanceId: string\n  readonly runtimeLabel?: string\n}\n\nexport type InstanceStatus =\n  | \"creating\"\n  | \"initializing\"\n  | \"ready\"\n  | \"failed\"\n  | \"terminating\"\n  | \"terminated\"\n\nexport interface InitProgress {\n  readonly total: number\n  readonly completed: number\n  readonly current?: number\n  readonly startedAt?: number\n}\n\nexport type LifecycleOutcome =\n  | { readonly status: \"success\" }\n  | {\n      readonly status: \"failure\"\n      readonly error: import(\"./errorSummary.js\").SerializableErrorSummary\n    }\n\nexport interface LifecycleStatus {\n  readonly identity: ModuleRuntimeIdentity\n  readonly status: InstanceStatus\n  readonly initOutcome?: LifecycleOutcome\n  readonly initProgress?: InitProgress\n}\n\nexport interface TaskRef {\n  readonly taskId: string\n  readonly kind: TaskKind\n  readonly order: number\n  readonly name?: string\n  readonly fatalOnFailure?: boolean\n}\n\nexport interface LifecycleTask extends TaskRef {\n  readonly effect: Effect.Effect<void, never, any>\n}\n\nexport interface Budgets {\n  /** \u5355\u5B9E\u4F8B\u751F\u547D\u5468\u671F\u4E8B\u4EF6\u9884\u7B97\uFF1A\u5BF9\u9F50 specs/011 data-model\uFF08\u9ED8\u8BA4 \u226420\uFF09\u3002 */\n  readonly maxEventsPerInstance: number\n  /** \u5355\u4E8B\u4EF6\u4F53\u79EF\u9884\u7B97\uFF1A\u5BF9\u9F50 specs/011 data-model\uFF08\u9ED8\u8BA4 \u22644KB\uFF09\u3002 */\n  readonly maxEventBytes: number\n}\n\nexport interface LifecycleManager {\n  readonly identity: ModuleRuntimeIdentity\n  readonly budgets: Budgets\n\n  readonly registerPlatformSuspend: (\n    effect: Effect.Effect<void, never, any>,\n    options?: { readonly name?: string }\n  ) => void\n  readonly registerPlatformResume: (\n    effect: Effect.Effect<void, never, any>,\n    options?: { readonly name?: string }\n  ) => void\n  readonly registerPlatformReset: (\n    effect: Effect.Effect<void, never, any>,\n    options?: { readonly name?: string }\n  ) => void\n\n  readonly registerInitRequired: (\n    effect: Effect.Effect<void, never, any>,\n    options?: { readonly name?: string }\n  ) => void\n  readonly registerStart: (\n    effect: Effect.Effect<void, never, any>,\n    options?: { readonly name?: string; readonly fatalOnFailure?: boolean }\n  ) => void\n  readonly registerDestroy: (\n    effect: Effect.Effect<void, never, any>,\n    options?: { readonly name?: string }\n  ) => void\n  readonly registerOnError: (\n    handler: (\n      cause: Cause.Cause<unknown>,\n      context: ErrorContext\n    ) => Effect.Effect<void, never, any>\n  ) => void\n\n  readonly getStatus: Effect.Effect<LifecycleStatus>\n  readonly setStatus: (\n    status: InstanceStatus,\n    patch?: {\n      readonly initOutcome?: LifecycleOutcome | undefined\n      readonly initProgress?: InitProgress | undefined\n      readonly runtimeLabel?: string | undefined\n    }\n  ) => Effect.Effect<void>\n\n  readonly notifyError: (\n    cause: Cause.Cause<unknown>,\n    context: ErrorContext\n  ) => Effect.Effect<void, never, any>\n\n  readonly runPlatformSuspend: Effect.Effect<void, never, any>\n  readonly runPlatformResume: Effect.Effect<void, never, any>\n  readonly runPlatformReset: Effect.Effect<void, never, any>\n\n  readonly runInitRequired: Effect.Effect<void, unknown, any>\n  readonly runStart: Effect.Effect<void, never, any>\n  readonly runDestroy: Effect.Effect<void, never, any>\n\n  /** \u4EC5\u7528\u4E8E\u8BCA\u65AD\u76EE\u7684\uFF1A\u662F\u5426\u5DF2\u6CE8\u518C\u4EFB\u610F onError \u5904\u7406\u5668\u3002 */\n  readonly hasOnErrorHandlers: Effect.Effect<boolean>\n\n  /** \u4EC5\u7528\u4E8E\u6D4B\u8BD5/\u8BCA\u65AD\uFF1A\u8BFB\u53D6\u5DF2\u6CE8\u518C\u7684\u4EFB\u52A1\u5FEB\u7167\uFF08\u4E0D\u53EF\u53D8\u89C6\u56FE\uFF09\u3002 */\n  readonly getTaskSnapshot: Effect.Effect<\n    Readonly<{\n      readonly initRequired: ReadonlyArray<TaskRef>\n      readonly start: ReadonlyArray<TaskRef>\n      readonly destroy: ReadonlyArray<TaskRef>\n      readonly platformSuspend: ReadonlyArray<TaskRef>\n      readonly platformResume: ReadonlyArray<TaskRef>\n      readonly platformReset: ReadonlyArray<TaskRef>\n    }>,\n    never,\n    never\n  >\n}\n\nexport const LifecycleContext = Context.GenericTag<LifecycleManager>(\n  \"@logix/LifecycleManager\"\n)\n\nconst safeRun = (label: string, eff: Effect.Effect<void, any, any>) =>\n  eff.pipe(\n    Effect.matchCauseEffect({\n      onSuccess: () => Effect.void,\n      onFailure: (cause) =>\n        Effect.logError(`[${label}] failed: ${Cause.pretty(cause)}`),\n    })\n  )\n\nconst makeTaskId = (kind: TaskKind, order: number): string => `${kind}:${order}`\n\nexport const makeLifecycleManager = (\n  identity: ModuleRuntimeIdentity,\n): Effect.Effect<LifecycleManager> =>\n  Effect.gen(function* () {\n    const budgets: Budgets = {\n      maxEventsPerInstance: 20,\n      maxEventBytes: 4 * 1024,\n    }\n\n    const statusRef = yield* Ref.make<LifecycleStatus>({\n      identity,\n      status: \"creating\",\n    })\n\n    const initRequired: LifecycleTask[] = []\n    const start: LifecycleTask[] = []\n    const destroy: LifecycleTask[] = []\n    const platformSuspend: LifecycleTask[] = []\n    const platformResume: LifecycleTask[] = []\n    const platformReset: LifecycleTask[] = []\n    const onErrorHandlers: Array<\n      (\n        cause: Cause.Cause<unknown>,\n        context: ErrorContext\n      ) => Effect.Effect<void, never, any>\n    > = []\n\n    const getStatus: Effect.Effect<LifecycleStatus> = Ref.get(statusRef)\n\n    const recordPhase = (\n      phase: Phase,\n      name: string,\n      payload?: unknown,\n    ): Effect.Effect<void, never, any> =>\n      Debug.record({\n        type: \"lifecycle:phase\",\n        moduleId: identity.moduleId,\n        instanceId: identity.instanceId,\n        phase,\n        name,\n        payload,\n      })\n\n    const setStatus = (\n      status: InstanceStatus,\n      patch?: {\n        readonly initOutcome?: LifecycleOutcome | undefined\n        readonly initProgress?: InitProgress | undefined\n        readonly runtimeLabel?: string | undefined\n      }\n    ) =>\n      Ref.update(statusRef, (prev) => ({\n        ...prev,\n        identity: {\n          ...prev.identity,\n          ...(patch?.runtimeLabel ? { runtimeLabel: patch.runtimeLabel } : null),\n        },\n        status,\n        ...(patch?.initOutcome !== undefined ? { initOutcome: patch.initOutcome } : null),\n        ...(patch?.initProgress !== undefined ? { initProgress: patch.initProgress } : null),\n      }))\n\n    const registerInitRequired = (\n      effect: Effect.Effect<void, never, any>,\n      options?: { readonly name?: string }\n    ) => {\n      const order = initRequired.length\n      initRequired.push({\n        taskId: makeTaskId(\"initRequired\", order),\n        kind: \"initRequired\",\n        order,\n        name: options?.name,\n        effect,\n      })\n    }\n\n    const registerStart = (\n      effect: Effect.Effect<void, never, any>,\n      options?: { readonly name?: string; readonly fatalOnFailure?: boolean }\n    ) => {\n      const order = start.length\n      start.push({\n        taskId: makeTaskId(\"start\", order),\n        kind: \"start\",\n        order,\n        name: options?.name,\n        fatalOnFailure: options?.fatalOnFailure,\n        effect,\n      })\n    }\n\n    const registerDestroy = (\n      effect: Effect.Effect<void, never, any>,\n      options?: { readonly name?: string }\n    ) => {\n      const order = destroy.length\n      destroy.push({\n        taskId: makeTaskId(\"destroy\", order),\n        kind: \"destroy\",\n        order,\n        name: options?.name,\n        effect,\n      })\n    }\n\n    const registerOnError = (\n      handler: (\n        cause: Cause.Cause<unknown>,\n        context: ErrorContext\n      ) => Effect.Effect<void, never, any>\n    ) => {\n      onErrorHandlers.push(handler)\n    }\n\n    const registerPlatformSuspend = (\n      effect: Effect.Effect<void, never, any>,\n      options?: { readonly name?: string }\n    ) => {\n      const order = platformSuspend.length\n      platformSuspend.push({\n        taskId: makeTaskId(\"platformSuspend\", order),\n        kind: \"platformSuspend\",\n        order,\n        name: options?.name,\n        effect,\n      })\n    }\n\n    const registerPlatformResume = (\n      effect: Effect.Effect<void, never, any>,\n      options?: { readonly name?: string }\n    ) => {\n      const order = platformResume.length\n      platformResume.push({\n        taskId: makeTaskId(\"platformResume\", order),\n        kind: \"platformResume\",\n        order,\n        name: options?.name,\n        effect,\n      })\n    }\n\n    const registerPlatformReset = (\n      effect: Effect.Effect<void, never, any>,\n      options?: { readonly name?: string }\n    ) => {\n      const order = platformReset.length\n      platformReset.push({\n        taskId: makeTaskId(\"platformReset\", order),\n        kind: \"platformReset\",\n        order,\n        name: options?.name,\n        effect,\n      })\n    }\n\n    const notifyError = (cause: Cause.Cause<unknown>, context: ErrorContext) => {\n      // \u4E2D\u65AD/\u53D6\u6D88\u4E0D\u5E94\u88AB\u5F53\u4F5C\u9519\u8BEF\u4E0A\u62A5\u3002\n      if (Cause.isInterrupted(cause)) {\n        return Effect.void\n      }\n\n      return Debug.record({\n        type: \"lifecycle:error\",\n        moduleId: context.moduleId,\n        instanceId: context.instanceId,\n        cause,\n        phase: context.phase,\n        hook: context.hook,\n        taskId: context.taskId,\n        txnSeq: context.txnSeq,\n        opSeq: context.opSeq,\n        origin: context.origin,\n      }).pipe(\n        Effect.zipRight(\n          Effect.forEach(\n            onErrorHandlers,\n            (handler) =>\n              handler(cause, context).pipe(\n                Effect.catchAllCause((inner) =>\n                  Effect.logError(\n                    `[lifecycle.onError] failed: ${Cause.pretty(inner)}`\n                  )\n                )\n              ),\n            { discard: true }\n          )\n        )\n      )\n    }\n\n    const runInitRequired: Effect.Effect<void, unknown, any> = Effect.gen(function* () {\n      const total = initRequired.length\n      if (total === 0) {\n        yield* setStatus(\"ready\", {\n          initProgress: { total: 0, completed: 0 },\n          initOutcome: { status: \"success\" },\n        })\n        return\n      }\n\n      const startedAt = Date.now()\n      yield* recordPhase(\"init\", \"initRequired:start\", { total })\n      yield* setStatus(\"initializing\", {\n        initProgress: { total, completed: 0, current: 0, startedAt },\n      })\n\n      let completed = 0\n      for (let i = 0; i < initRequired.length; i++) {\n        yield* setStatus(\"initializing\", {\n          initProgress: { total, completed, current: i, startedAt },\n        })\n\n        const task = initRequired[i]\n        const exit = yield* Effect.exit(task.effect)\n\n        if (exit._tag === \"Success\") {\n          completed += 1\n          yield* setStatus(\"initializing\", {\n            initProgress: { total, completed, current: i + 1, startedAt },\n          })\n          continue\n        }\n\n        const summary = toSerializableErrorSummary(exit.cause)\n        yield* notifyError(exit.cause, {\n          phase: \"init\",\n          hook: \"initRequired\",\n          moduleId: identity.moduleId,\n          instanceId: identity.instanceId,\n          taskId: task.taskId,\n          origin: \"initRequired\",\n        })\n\n        yield* setStatus(\"failed\", {\n          initProgress: { total, completed, current: i, startedAt },\n          initOutcome: { status: \"failure\", error: summary.errorSummary },\n        })\n\n        return yield* Effect.failCause(exit.cause)\n      }\n\n      yield* recordPhase(\"init\", \"initRequired:success\", { total })\n      yield* setStatus(\"ready\", {\n        initProgress: { total, completed, current: total, startedAt },\n        initOutcome: { status: \"success\" },\n      })\n    })\n\n    const runStart: Effect.Effect<void, never, any> = recordPhase(\"run\", \"start:schedule\", {\n      total: start.length,\n    }).pipe(\n      Effect.zipRight(\n        Effect.forEach(\n          start,\n          (task) =>\n            Effect.forkScoped(\n              task.effect.pipe(\n                Effect.catchAllCause((cause) =>\n                  notifyError(cause, {\n                    phase: \"run\",\n                    hook: \"start\",\n                    moduleId: identity.moduleId,\n                    instanceId: identity.instanceId,\n                    taskId: task.taskId,\n                    origin: \"start\",\n                  })\n                )\n              )\n            ).pipe(Effect.asVoid),\n          { discard: true, concurrency: \"unbounded\" }\n        )\n      )\n    )\n\n    const runDestroy: Effect.Effect<void, never, any> = Effect.gen(function* () {\n      yield* recordPhase(\"destroy\", \"destroy:start\", { total: destroy.length })\n      yield* setStatus(\"terminating\")\n\n      // destroy\uFF1A\u540E\u6CE8\u518C\u5148\u6267\u884C\uFF08LIFO\uFF09\uFF0C\u4E14 best-effort\uFF08\u5355\u4E2A\u5931\u8D25\u4E0D\u963B\u585E\u540E\u7EED\uFF09\u3002\n      for (let i = destroy.length - 1; i >= 0; i--) {\n        const task = destroy[i]\n        yield* safeRun(\n          \"lifecycle.onDestroy\",\n          task.effect.pipe(\n            Effect.catchAllCause((cause) =>\n              notifyError(cause, {\n                phase: \"destroy\",\n                hook: \"destroy\",\n                moduleId: identity.moduleId,\n                instanceId: identity.instanceId,\n                taskId: task.taskId,\n                origin: \"destroy\",\n              })\n            )\n          )\n        )\n      }\n\n      yield* setStatus(\"terminated\")\n      yield* recordPhase(\"destroy\", \"destroy:done\", { total: destroy.length })\n    })\n\n    const runPlatformSuspend: Effect.Effect<void, never, any> = Effect.gen(function* () {\n      if (platformSuspend.length === 0) return\n\n      yield* recordPhase(\"platform\", \"signal:suspend\", { total: platformSuspend.length })\n      for (const task of platformSuspend) {\n        yield* safeRun(\n          \"lifecycle.onSuspend\",\n          task.effect.pipe(\n            Effect.catchAllCause((cause) =>\n              notifyError(cause, {\n                phase: \"platform\",\n                hook: \"suspend\",\n                moduleId: identity.moduleId,\n                instanceId: identity.instanceId,\n                taskId: task.taskId,\n                origin: \"platform.suspend\",\n              })\n            )\n          )\n        )\n      }\n    })\n\n    const runPlatformResume: Effect.Effect<void, never, any> = Effect.gen(function* () {\n      if (platformResume.length === 0) return\n\n      yield* recordPhase(\"platform\", \"signal:resume\", { total: platformResume.length })\n      for (const task of platformResume) {\n        yield* safeRun(\n          \"lifecycle.onResume\",\n          task.effect.pipe(\n            Effect.catchAllCause((cause) =>\n              notifyError(cause, {\n                phase: \"platform\",\n                hook: \"resume\",\n                moduleId: identity.moduleId,\n                instanceId: identity.instanceId,\n                taskId: task.taskId,\n                origin: \"platform.resume\",\n              })\n            )\n          )\n        )\n      }\n    })\n\n    const runPlatformReset: Effect.Effect<void, never, any> = Effect.gen(function* () {\n      if (platformReset.length === 0) return\n\n      yield* recordPhase(\"platform\", \"signal:reset\", { total: platformReset.length })\n      for (const task of platformReset) {\n        yield* safeRun(\n          \"lifecycle.onReset\",\n          task.effect.pipe(\n            Effect.catchAllCause((cause) =>\n              notifyError(cause, {\n                phase: \"platform\",\n                hook: \"reset\",\n                moduleId: identity.moduleId,\n                instanceId: identity.instanceId,\n                taskId: task.taskId,\n                origin: \"platform.reset\",\n              })\n            )\n          )\n        )\n      }\n    })\n\n    const getTaskSnapshot: LifecycleManager[\"getTaskSnapshot\"] = Effect.sync(() => ({\n      initRequired: initRequired.map(({ effect: _eff, ...rest }) => rest),\n      start: start.map(({ effect: _eff, ...rest }) => rest),\n      destroy: destroy.map(({ effect: _eff, ...rest }) => rest),\n      platformSuspend: platformSuspend.map(({ effect: _eff, ...rest }) => rest),\n      platformResume: platformResume.map(({ effect: _eff, ...rest }) => rest),\n      platformReset: platformReset.map(({ effect: _eff, ...rest }) => rest),\n    }))\n\n    const hasOnErrorHandlers: LifecycleManager[\"hasOnErrorHandlers\"] = Effect.sync(() => onErrorHandlers.length > 0)\n\n    return {\n      identity,\n      budgets,\n      registerPlatformSuspend,\n      registerPlatformResume,\n      registerPlatformReset,\n      registerInitRequired,\n      registerStart,\n      registerDestroy,\n      registerOnError,\n      getStatus,\n      setStatus,\n      notifyError,\n      runPlatformSuspend,\n      runPlatformResume,\n      runPlatformReset,\n      runInitRequired,\n      runStart,\n      runDestroy,\n      hasOnErrorHandlers,\n      getTaskSnapshot,\n    }\n  })\n", "import { Cause, Context, Effect } from \"effect\"\nimport * as Debug from \"./DebugSink.js\"\nimport { isDevEnv } from \"./env.js\"\n\nconst phaseDiagnosticsEnabled = (): boolean => isDevEnv()\n\n/**\n * Logic \u76F8\u5173\u8BCA\u65AD\uFF1A\n * - \u5F53\u524D\u805A\u7126\u4E8E Env Service \u7F3A\u5931\u5BFC\u81F4\u7684\u521D\u59CB\u5316\u566A\u97F3\uFF08Service not found\uFF09\u3002\n *\n * \u8BBE\u8BA1\u610F\u56FE\uFF1A\n * - \u5728\u63A8\u8350\u7528\u6CD5\u4E0B\uFF0CRuntime / React \u5C42\u4F1A\u6B63\u786E\u63D0\u4F9B Env\uFF1B\n * - \u4F46\u5728\u67D0\u4E9B\u521D\u59CB\u5316\u65F6\u5E8F\u4E0B\uFF0CLogic \u53EF\u80FD\u5728 Env \u94FA\u6EE1\u524D\u5C31\u5C1D\u8BD5\u8BFB\u53D6 Service\uFF1B\n * - \u8FD9\u7C7B\u9519\u8BEF\u901A\u5E38\u53EA\u51FA\u73B0\u4E00\u6B21\uFF0C\u4E0D\u6539\u53D8\u6700\u7EC8\u8BED\u4E49\uFF0C\u5374\u4F1A\u6C61\u67D3\u65E5\u5FD7\u3002\n *\n * \u56E0\u6B64\u8FD9\u91CC\u5728 Debug \u4FA7\u53D1\u51FA\u4E00\u6761 warning \u7EA7 diagnostic\uFF0C\u89E3\u91CA\u53EF\u80FD\u539F\u56E0\u4E0E\u6392\u67E5\u8DEF\u5F84\uFF0C\n * \u771F\u6B63\u7684\u9519\u8BEF\u8BED\u4E49\u4ECD\u7531 lifecycle.onError / AppRuntime.onError \u5904\u7406\u3002\n */\n\nconst SERVICE_NOT_FOUND_PREFIX = \"Service not found:\"\n\n/**\n * \u82E5 Cause \u4E2D\u5305\u542B `Service not found: ...` \u9519\u8BEF\uFF0C\u5219\u53D1\u51FA\u4E00\u6761 warning \u7EA7 diagnostic\uFF1A\n * - code: logic::env_service_not_found\n * - message: \u539F\u59CB\u9519\u8BEF message\uFF1B\n * - hint: \u8BF4\u660E\u8FD9\u662F\u5DF2\u77E5\u7684\u521D\u59CB\u5316\u65F6\u5E8F\u566A\u97F3\uFF0C\u5E76\u7ED9\u51FA\u6392\u67E5\u5EFA\u8BAE\u3002\n */\nexport const emitEnvServiceNotFoundDiagnosticIfNeeded = (\n  cause: Cause.Cause<unknown>,\n  moduleId?: string\n): Effect.Effect<void> =>\n  Effect.gen(function* () {\n    let pretty: string\n    try {\n      pretty = Cause.pretty(cause, { renderErrorCause: true })\n    } catch {\n      return\n    }\n\n    if (!pretty.includes(SERVICE_NOT_FOUND_PREFIX)) {\n      return\n    }\n\n    // 1) Env Service \u7F3A\u5931\u672C\u8EAB\u7684 warning \u8BCA\u65AD\n    yield* Debug.record({\n      type: \"diagnostic\",\n      moduleId,\n      code: \"logic::env_service_not_found\",\n      severity: \"warning\",\n      message: pretty,\n      hint:\n        \"Logic attempted to access an Env service before it was provided. This is a known initialization timing noise in Runtime/React integration. \" +\n        \"If it happens once during early startup and everything works afterward, it's likely harmless; \" +\n        \"if it persists or correlates with app issues, verify Runtime.make / RuntimeProvider.layer provides the service.\",\n    })\n\n    // 2) \u5728\u67D0\u4E9B\u573A\u666F\u4E0B\uFF08\u4F8B\u5982 Logic setup \u6BB5\u8FC7\u65E9\u8BBF\u95EE Env\uFF09\uFF0C\u6211\u4EEC\u4E5F\u5E0C\u671B\u901A\u8FC7\n    //    logic::invalid_phase \u63D0\u9192\u201C\u8BF7\u5C06 Env \u8BBF\u95EE\u79FB\u52A8\u5230 run \u6BB5\u201D\u3002\n    //\n    // \u7531\u4E8E\u5F53\u524D\u5B9E\u73B0\u65E0\u6CD5\u5728\u6B64\u5904\u53EF\u9760\u5224\u65AD\u8C03\u7528\u53D1\u751F\u7684 phase\uFF0C\u8FD9\u91CC\u53EA\u662F\u63D0\u4F9B\u4E00\u4E2A\u8865\u5145\u6027\u7684\n    // \u8BCA\u65AD\u4FE1\u53F7\uFF0C\u771F\u6B63\u7684 phase \u5B88\u536B\u4ECD\u7531 LogicPhaseError + emitInvalidPhaseDiagnosticIfNeeded \u627F\u62C5\u3002\n    yield* Debug.record({\n      type: \"diagnostic\",\n      moduleId,\n      code: \"logic::invalid_phase\",\n      severity: \"error\",\n      message: \"$.use is not allowed before Env is fully ready.\",\n      hint:\n        \"Avoid reading services during setup or before Env is ready; \" +\n        \"move Env access to the Logic run section, or wrap init via $.lifecycle.onInitRequired.\",\n      kind: \"env_service_not_ready\",\n    })\n  })\n\nexport interface LogicPhaseError extends Error {\n  readonly _tag: \"LogicPhaseError\"\n  readonly kind: string\n  readonly api?: string\n  readonly phase: \"setup\" | \"run\"\n  readonly moduleId?: string\n}\n\nexport interface LogicPhaseService {\n  readonly current: \"setup\" | \"run\"\n}\n\nexport const LogicPhaseServiceTag = Context.GenericTag<LogicPhaseService>(\n  \"@logix/LogicPhaseService\"\n)\n\n/**\n * LogicUnitService\uFF1A\n * - \u5728\u6267\u884C\u6BCF\u4E2A mounted logic \u65F6\u6CE8\u5165\uFF08scope = \u5355\u4E2A logic \u7684 setup/run fiber\uFF09\uFF1B\n * - \u7528\u4E8E traits provenance \u7B49\u201C\u4E0E\u5F53\u524D\u903B\u8F91\u5355\u5143\u7ED1\u5B9A\u201D\u7684\u4FE1\u606F\uFF08\u5BF9\u9F50 022-module \u7684 logicUnitId\uFF09\u3002\n *\n * \u7EA6\u675F\uFF1A\n * - \u7EAF\u53EA\u8BFB\uFF08\u4E0D\u5F97\u5199\u5165 runtime state\uFF09\uFF1B\u4EC5\u4F5C\u4E3A provenance/\u8BCA\u65AD\u951A\u70B9\u3002\n */\nexport interface LogicUnitService {\n  readonly logicUnitId: string\n  readonly logicUnitIdKind: \"explicit\" | \"derived\"\n  readonly logicUnitLabel: string\n  readonly path?: string\n}\n\nexport class LogicUnitServiceTag extends Context.Tag(\"@logix/LogicUnitService\")<\n  LogicUnitServiceTag,\n  LogicUnitService\n>() {}\n\nexport const makeLogicPhaseError = (\n  kind: string,\n  api: string,\n  phase: \"setup\" | \"run\",\n  moduleId?: string\n): LogicPhaseError =>\n  Object.assign(\n    new Error(\n      `[LogicPhaseError] ${api} is not allowed in ${phase} phase (kind=${kind}).`\n    ),\n    {\n      _tag: \"LogicPhaseError\",\n      kind,\n      api,\n      phase,\n      moduleId,\n    }\n  ) as LogicPhaseError\n\n/**\n * \u4ECE Cause \u4E2D\u63D0\u53D6 LogicPhaseError\uFF0C\u5E76\u4EE5 diagnostic \u5F62\u5F0F\u53D1\u51FA\uFF1A\n * - code: logic::invalid_phase\n * - kind: \u5177\u4F53\u8FDD\u89C4\u7C7B\u578B\uFF08\u5982 use_in_setup\uFF09\n */\nexport const emitInvalidPhaseDiagnosticIfNeeded = (\n  cause: Cause.Cause<unknown>,\n  moduleId?: string\n): Effect.Effect<void> =>\n  Effect.gen(function* () {\n    if (!phaseDiagnosticsEnabled()) {\n      return\n    }\n\n    const allErrors = [\n      ...Cause.failures(cause),\n      ...Cause.defects(cause),\n    ]\n\n    for (const err of allErrors) {\n      const logicErr = err as any\n      if (logicErr && logicErr._tag === \"LogicPhaseError\") {\n        const phaseErr = logicErr as LogicPhaseError\n        const hint =\n          phaseErr.kind === \"use_in_setup\" ||\n          phaseErr.kind === \"lifecycle_in_setup\"\n            ? \"The setup phase must not read Env/services or run long-lived logic; move the relevant calls to the run phase.\"\n            : phaseErr.kind === \"lifecycle_in_run\"\n              ? \"Do not register $.lifecycle.* in the run phase (setup-only). Move lifecycle registrations to the synchronous part of Module.logic builder (before return).\"\n            : phaseErr.kind === \"traits_in_run\" || phaseErr.kind === \"traits_declare_in_run\"\n              ? \"Traits are frozen after setup; move $.traits.declare to LogicPlan.setup or the setup registration phase of Module.logic builder.\"\n            : \"Move logic to the run phase; keep setup for registrations only.\"\n\n        yield* Debug.record({\n          type: \"diagnostic\",\n          moduleId: phaseErr.moduleId ?? moduleId,\n          code: \"logic::invalid_phase\",\n          severity: \"error\",\n          message: `${phaseErr.api ?? phaseErr.kind} is not allowed in ${phaseErr.phase} phase.`,\n          hint,\n          kind: phaseErr.kind,\n        })\n\n        // \u547D\u4E2D\u9996\u4E2A LogicPhaseError \u5373\u53EF\u8FD4\u56DE\n        return\n      }\n    }\n  })\n"],
  "mappings": "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",
  "names": ["Context", "Effect", "Cause", "Context", "Effect", "Effect", "Cause", "Context", "Effect", "make", "api", "Context", "options"]
}
