@logixjs/core 0.0.1

package/dist/chunk-BE3HW4FY.js

@@ -0,0 +1,1099 @@
+import {
+  forceSourceRefresh,
+  inSyncTransactionFiber,
+  makeTaskRunner
+} from "./chunk-ZFLHVFUC.js";
+import {
+  Tag
+} from "./chunk-KL5ACTCT.js";
+import {
+  resolve
+} from "./chunk-AUIR5O6W.js";
+import {
+  makeMatch,
+  makeMatchTag
+} from "./chunk-BZ2SHDN2.js";
+import {
+  isActionToken
+} from "./chunk-YS3AZQ2G.js";
+import {
+  isFieldPathSegment
+} from "./chunk-IHVBV5C2.js";
+import {
+  getRuntimeInternals,
+  setBoundInternals
+} from "./chunk-3RMKLXHX.js";
+import {
+  isDevEnv
+} from "./chunk-3QMIVH35.js";
+import {
+  make
+} from "./chunk-NQZ2OSGR.js";
+import {
+  currentDiagnosticsLevel,
+  record,
+  toSerializableErrorSummary
+} from "./chunk-DMBALCE2.js";
+import {
+  RunSessionTag
+} from "./chunk-OFADUJWJ.js";
+
+// src/internal/runtime/core/mutativePatches.ts
+import { create } from "mutative";
+var mutateWithoutPatches = (base, mutator) => {
+  return create(base, mutator);
+};
+var toPatchFieldPath = (path) => {
+  if (typeof path === "string") {
+    const trimmed = path.trim();
+    return trimmed.length > 0 ? "*" : void 0;
+  }
+  if (!Array.isArray(path)) return void 0;
+  const parts = [];
+  for (const seg of path) {
+    if (typeof seg === "string") {
+      if (isFieldPathSegment(seg)) parts.push(seg);
+      continue;
+    }
+  }
+  if (parts.length === 0) return "*";
+  return parts;
+};
+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 dedup = /* @__PURE__ */ new Map();
+  for (const patch of patches) {
+    const p = toPatchFieldPath(patch?.path);
+    if (!p) continue;
+    const key = p === "*" ? "*" : JSON.stringify(p);
+    if (!dedup.has(key)) dedup.set(key, p);
+  }
+  return {
+    nextState,
+    patchPaths: Array.from(dedup.values())
+  };
+};
+
+// src/internal/runtime/core/BoundApiRuntime.ts
+import { Context as Context3, Effect as Effect3, FiberRef, Option, Schema, Stream } from "effect";
+
+// src/internal/runtime/core/Lifecycle.ts
+import { Cause, Context, Effect, Ref } from "effect";
+var LifecycleContext = Context.GenericTag("@logixjs/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
+  };
+});
+
+// src/internal/runtime/core/LogicDiagnostics.ts
+import { Cause as Cause2, Context as Context2, Effect as Effect2 } from "effect";
+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("@logixjs/LogicPhaseService");
+var LogicUnitServiceTag = class extends Context2.Tag("@logixjs/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;
+    }
+  }
+});
+
+// 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 updateDraft = runtimeInternals.txn.updateDraft;
+            const { nextState, patchPaths } = mutateWithPatchPaths(prev, (draft) => {
+              reducer(draft, payload);
+            });
+            for (const path of patchPaths) {
+              recordPatch(path, "unknown");
+            }
+            updateDraft(nextState);
+          })
+        )
+      ).pipe(Effect3.catchAllCause((cause) => Effect3.logError("Flow error", cause)))
+    };
+    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 });
+  };
+};
+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 updateDraft = runtimeInternals?.txn.updateDraft;
+      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, "unknown");
+        }
+        updateDraft?.(nextState);
+        return;
+      }
+      const body = () => Effect3.gen(function* () {
+        const prev = yield* runtime.getState;
+        const { nextState, patchPaths } = mutateWithPatchPaths(prev, (draft) => {
+          f(draft);
+        });
+        for (const path of patchPaths) {
+          recordPatch?.(path, "unknown");
+        }
+        updateDraft?.(nextState);
+      });
+      return yield* runtimeInternals ? runtimeInternals.txn.runWithStateTransaction({ kind: "state", name: "mutate" }, body) : body();
+    }),
+    ref: runtime.ref
+  };
+  const actions = shape.actionMap;
+  const dispatcherCache = /* @__PURE__ */ new Map();
+  const hasAction = (key) => Object.prototype.hasOwnProperty.call(actions, key);
+  const dispatchers = new Proxy({}, {
+    get: (_target, prop) => {
+      if (typeof prop !== "string") return void 0;
+      if (!hasAction(prop)) return void 0;
+      const cached = dispatcherCache.get(prop);
+      if (cached) return cached;
+      const token = actions[prop];
+      const fn = (...args) => runtime.dispatch(token(...args));
+      dispatcherCache.set(prop, fn);
+      return fn;
+    },
+    has: (_target, prop) => typeof prop === "string" && hasAction(prop),
+    ownKeys: () => Object.keys(actions),
+    getOwnPropertyDescriptor: (_target, prop) => {
+      if (typeof prop !== "string") return void 0;
+      if (!hasAction(prop)) return void 0;
+      return { enumerable: true, configurable: true };
+    }
+  });
+  const dispatch = (...args) => {
+    const [first, second] = args;
+    if (typeof first === "string") {
+      return runtime.dispatch({ _tag: first, payload: second });
+    }
+    if (isActionToken(first)) {
+      return runtime.dispatch(first(second));
+    }
+    return runtime.dispatch(first);
+  };
+  const matchApi = (value) => makeMatch(value);
+  const matchTagApi = (value) => makeMatchTag(value);
+  const reducer = (tag, fn) => {
+    return Effect3.sync(() => {
+      runtimeInternals.txn.registerReducer(String(tag), fn);
+    });
+  };
+  const effect = (token, handler) => Effect3.gen(function* () {
+    if (!isActionToken(token)) {
+      return yield* Effect3.dieMessage("[BoundApi.effect] token must be an ActionToken");
+    }
+    const phase = getCurrentPhase();
+    const logicUnit = options?.logicUnit;
+    yield* runtimeInternals.effects.registerEffect({
+      actionTag: token.tag,
+      handler,
+      phase,
+      ...logicUnit ? {
+        logicUnit: {
+          logicUnitId: logicUnit.logicUnitId,
+          logicUnitLabel: logicUnit.logicUnitLabel,
+          path: logicUnit.path
+        }
+      } : {}
+    });
+  });
+  const api = {
+    root: {
+      resolve: (tag) => {
+        guardRunOnly("root_resolve_in_setup", "$.root.resolve");
+        return resolve(tag, {
+          entrypoint: "logic.$.root.resolve",
+          waitForReady: true
+        });
+      }
+    },
+    state: stateApi,
+    actions,
+    dispatchers,
+    dispatch,
+    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,
+    effect,
+    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 (isActionToken(arg)) {
+          const tag = arg.tag;
+          return createIntentBuilder(
+            runtime.actions$.pipe(
+              Stream.filter((a) => a._tag === tag || a.type === tag),
+              Stream.map((a) => a.payload)
+            ),
+            tag
+          );
+        }
+        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 {
+  mutateWithoutPatches,
+  mutateWithPatchPaths,
+  LifecycleContext,
+  makeLifecycleManager,
+  emitEnvServiceNotFoundDiagnosticIfNeeded,
+  LogicPhaseServiceTag,
+  LogicUnitServiceTag,
+  emitInvalidPhaseDiagnosticIfNeeded,
+  make2 as make
+};
+//# sourceMappingURL=chunk-BE3HW4FY.js.map