@logixjs/core 0.0.1

package/dist/Bound.cjs

@@ -0,0 +1,1532 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Bound.ts
+var Bound_exports = {};
+__export(Bound_exports, {
+  make: () => make4
+});
+module.exports = __toCommonJS(Bound_exports);
+
+// src/internal/runtime/core/BoundApiRuntime.ts
+var import_effect16 = require("effect");
+
+// src/internal/action.ts
+var import_effect = require("effect");
+var isActionToken = (value) => typeof value === "function" && value._kind === "ActionToken" && typeof value.tag === "string" && import_effect.Schema.isSchema(value.schema);
+
+// src/internal/runtime/core/TaskRunner.ts
+var import_effect6 = require("effect");
+
+// src/internal/runtime/core/DebugSink.ts
+var import_effect4 = require("effect");
+
+// src/internal/observability/jsonValue.ts
+var defaultOptions = {
+  maxDepth: 6,
+  maxObjectKeys: 32,
+  maxArrayLength: 32,
+  maxStringLength: 256,
+  maxJsonBytes: 4 * 1024,
+  oversizedPreviewBytes: 256
+};
+
+// src/internal/runtime/core/errorSummary.ts
+var import_effect2 = require("effect");
+
+// src/internal/runtime/core/EffectOpCore.ts
+var import_effect3 = require("effect");
+var currentLinkId = import_effect3.FiberRef.unsafeMake(void 0);
+var EffectOpMiddlewareTag = class extends import_effect3.Context.Tag("Logix/EffectOpMiddleware")() {
+};
+var composeMiddleware = (stack) => {
+  return (op) => stack.reduceRight(
+    (eff, mw) => mw({ ...op, effect: eff }),
+    op.effect
+  );
+};
+var runWithMiddleware = (op, stack) => {
+  return import_effect3.Effect.gen(function* () {
+    const existing = yield* import_effect3.FiberRef.get(currentLinkId);
+    const metaLinkId = op.meta?.linkId;
+    const linkId = typeof metaLinkId === "string" && metaLinkId.length > 0 ? metaLinkId : existing ?? op.id;
+    const nextOp = {
+      ...op,
+      meta: {
+        ...op.meta ?? {},
+        linkId
+      }
+    };
+    const program = stack.length ? composeMiddleware(stack)(nextOp) : nextOp.effect;
+    return yield* import_effect3.Effect.locally(currentLinkId, linkId)(program);
+  });
+};
+
+// src/internal/runtime/core/DebugSink.ts
+var currentDebugSinks = import_effect4.FiberRef.unsafeMake([]);
+var currentRuntimeLabel = import_effect4.FiberRef.unsafeMake(void 0);
+var currentTxnId = import_effect4.FiberRef.unsafeMake(void 0);
+var currentOpSeq = import_effect4.FiberRef.unsafeMake(void 0);
+var currentDiagnosticsLevel = import_effect4.FiberRef.unsafeMake("off");
+var currentTraitConvergeDiagnosticsSampling = import_effect4.FiberRef.unsafeMake({
+  sampleEveryN: 32,
+  topK: 3
+});
+var browserLifecycleSeen = /* @__PURE__ */ new Set();
+var browserDiagnosticSeen = /* @__PURE__ */ new Set();
+var lifecycleErrorLog = (event) => {
+  const moduleId = event.moduleId ?? "unknown";
+  const causePretty = (() => {
+    try {
+      return import_effect4.Cause.pretty(event.cause, {
+        renderErrorCause: true
+      });
+    } catch {
+      try {
+        return JSON.stringify(event.cause, null, 2);
+      } catch {
+        return String(event.cause);
+      }
+    }
+  })();
+  const message = `[Logix][module=${moduleId}] lifecycle:error
+${causePretty}`;
+  return import_effect4.Effect.logError(message).pipe(
+    import_effect4.Effect.annotateLogs({
+      "logix.moduleId": moduleId,
+      "logix.event": "lifecycle:error",
+      "logix.cause": causePretty
+    })
+  );
+};
+var diagnosticLog = (event) => {
+  const moduleId = event.moduleId ?? "unknown";
+  const header = `[Logix][module=${moduleId}] diagnostic(${event.severity})`;
+  const detail = `code=${event.code} message=${event.message}${event.actionTag ? ` action=${event.actionTag}` : ""}${event.hint ? `
+hint: ${event.hint}` : ""}`;
+  const msg = `${header}
+${detail}`;
+  const base = event.severity === "warning" ? import_effect4.Effect.logWarning(msg) : event.severity === "info" ? import_effect4.Effect.logInfo(msg) : import_effect4.Effect.logError(msg);
+  const annotations = {
+    "logix.moduleId": moduleId,
+    "logix.event": `diagnostic(${event.severity})`,
+    "logix.diagnostic.code": event.code,
+    "logix.diagnostic.message": event.message
+  };
+  if (event.hint) {
+    annotations["logix.diagnostic.hint"] = event.hint;
+  }
+  if (event.actionTag) {
+    annotations["logix.diagnostic.actionTag"] = event.actionTag;
+  }
+  return base.pipe(import_effect4.Effect.annotateLogs(annotations));
+};
+var noopLayer = import_effect4.Layer.locallyScoped(currentDebugSinks, []);
+var errorOnlySink = {
+  record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" && event.severity !== "info" ? diagnosticLog(event) : import_effect4.Effect.void
+};
+var errorOnlyLayer = import_effect4.Layer.locallyScoped(currentDebugSinks, [errorOnlySink]);
+var isErrorOnlyOnlySinks = (sinks) => sinks.length === 1 && sinks[0] === errorOnlySink;
+var consoleSink = {
+  record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" ? diagnosticLog(event) : import_effect4.Effect.logDebug({ debugEvent: event })
+};
+var consoleLayer = import_effect4.Layer.locallyScoped(currentDebugSinks, [consoleSink]);
+var isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+var renderBrowserConsoleEvent = (event) => {
+  if (typeof event.type === "string" && event.type.startsWith("trace:")) {
+    const moduleId = event.moduleId ?? "unknown";
+    const type = event.type;
+    return import_effect4.Effect.sync(() => {
+      console.groupCollapsed(
+        "%c[Logix]%c trace %c" + moduleId + "%c " + String(type),
+        "color:#6b7280;font-weight:bold",
+        // tag
+        "color:#3b82f6",
+        // label
+        "color:#9ca3af",
+        // module id
+        "color:#6b7280"
+        // type
+      );
+      console.log(event);
+      console.groupEnd();
+    });
+  }
+  if (event.type === "lifecycle:error") {
+    const moduleId = event.moduleId ?? "unknown";
+    const causePretty = (() => {
+      try {
+        return import_effect4.Cause.pretty(event.cause, { renderErrorCause: true });
+      } catch {
+        try {
+          return JSON.stringify(event.cause, null, 2);
+        } catch {
+          return String(event.cause);
+        }
+      }
+    })();
+    const key = `${moduleId}|${causePretty}`;
+    if (browserLifecycleSeen.has(key)) {
+      return import_effect4.Effect.void;
+    }
+    browserLifecycleSeen.add(key);
+    return import_effect4.Effect.sync(() => {
+      console.groupCollapsed(
+        "%c[Logix]%c lifecycle:error %c" + moduleId,
+        "color:#ef4444;font-weight:bold",
+        // tag
+        "color:#ef4444",
+        // label
+        "color:#9ca3af"
+        // module id
+      );
+      console.error(causePretty);
+      console.groupEnd();
+    });
+  }
+  if (event.type === "diagnostic") {
+    const moduleId = event.moduleId ?? "unknown";
+    const detail = `code=${event.code} message=${event.message}${event.actionTag ? ` action=${event.actionTag}` : ""}${event.hint ? `
+hint: ${event.hint}` : ""}`;
+    const color = event.severity === "warning" ? "color:#d97706" : event.severity === "info" ? "color:#3b82f6" : "color:#ef4444";
+    const label = event.severity === "warning" ? "diagnostic(warning)" : event.severity === "info" ? "diagnostic(info)" : "diagnostic(error)";
+    const key = `${moduleId}|${event.code}|${event.message}`;
+    if (browserDiagnosticSeen.has(key)) {
+      return import_effect4.Effect.void;
+    }
+    browserDiagnosticSeen.add(key);
+    return import_effect4.Effect.sync(() => {
+      console.groupCollapsed(
+        "%c[Logix]%c " + label + "%c module=" + moduleId,
+        "color:#6b7280;font-weight:bold",
+        color,
+        "color:#9ca3af"
+      );
+      if (event.severity === "warning") {
+        console.warn(detail);
+      } else if (event.severity === "info") {
+        console.info(detail);
+      } else {
+        console.error(detail);
+      }
+      console.groupEnd();
+    });
+  }
+  return import_effect4.Effect.void;
+};
+var browserConsoleSink = {
+  record: (event) => {
+    if (!isBrowser) {
+      return event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" ? diagnosticLog(event) : import_effect4.Effect.logDebug({ debugEvent: event });
+    }
+    return renderBrowserConsoleEvent(event);
+  }
+};
+var browserConsoleLayer = import_effect4.Layer.locallyScoped(currentDebugSinks, [browserConsoleSink]);
+var browserDiagnosticConsoleSink = {
+  record: (event) => {
+    if (!isBrowser) {
+      return event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" && event.severity !== "info" ? diagnosticLog(event) : import_effect4.Effect.void;
+    }
+    return event.type === "lifecycle:error" || event.type === "diagnostic" && event.severity !== "info" ? renderBrowserConsoleEvent(event) : import_effect4.Effect.void;
+  }
+};
+var browserDiagnosticConsoleLayer = import_effect4.Layer.locallyScoped(currentDebugSinks, [browserDiagnosticConsoleSink]);
+var browserPrettyLoggerLayer = import_effect4.Logger.replace(
+  import_effect4.Logger.defaultLogger,
+  import_effect4.Logger.prettyLogger({ mode: "browser", colors: true })
+);
+var record = (event) => import_effect4.Effect.gen(function* () {
+  const sinks = yield* import_effect4.FiberRef.get(currentDebugSinks);
+  if (isErrorOnlyOnlySinks(sinks)) {
+    if (event.type === "lifecycle:error") {
+      yield* lifecycleErrorLog(event);
+      return;
+    }
+    if (event.type === "diagnostic") {
+      if (event.severity !== "info") {
+        yield* diagnosticLog(event);
+      } else {
+        yield* import_effect4.Effect.void;
+      }
+      return;
+    }
+    yield* import_effect4.Effect.void;
+    return;
+  }
+  if (sinks.length === 0) {
+    if (isBrowser) {
+      if (event.type === "lifecycle:error" || event.type === "diagnostic") {
+        yield* renderBrowserConsoleEvent(event);
+        return;
+      }
+      yield* import_effect4.Effect.void;
+      return;
+    }
+    if (event.type === "lifecycle:error") {
+      yield* lifecycleErrorLog(event);
+      return;
+    }
+    if (event.type === "diagnostic") {
+      yield* diagnosticLog(event);
+      return;
+    }
+    yield* import_effect4.Effect.void;
+    return;
+  }
+  const enriched = event;
+  const diagnosticsLevel = yield* import_effect4.FiberRef.get(currentDiagnosticsLevel);
+  let now;
+  const getNow = () => {
+    if (now === void 0) now = Date.now();
+    return now;
+  };
+  if (enriched.timestamp === void 0 && (diagnosticsLevel !== "off" || enriched.type === "lifecycle:error" || enriched.type === "diagnostic")) {
+    ;
+    enriched.timestamp = getNow();
+  }
+  if (diagnosticsLevel !== "off" && enriched.runtimeLabel === void 0) {
+    const runtimeLabel = yield* import_effect4.FiberRef.get(currentRuntimeLabel);
+    if (runtimeLabel) {
+      ;
+      enriched.runtimeLabel = runtimeLabel;
+    }
+  }
+  if (enriched.type === "diagnostic" && enriched.txnId === void 0) {
+    const txnId = yield* import_effect4.FiberRef.get(currentTxnId);
+    if (txnId) {
+      ;
+      enriched.txnId = txnId;
+    }
+  }
+  if (diagnosticsLevel !== "off" && enriched.type === "trace:effectop" && enriched.linkId === void 0) {
+    const linkId = yield* import_effect4.FiberRef.get(currentLinkId);
+    if (linkId) {
+      ;
+      enriched.linkId = linkId;
+    }
+  }
+  if (sinks.length === 1) {
+    yield* sinks[0].record(enriched);
+    return;
+  }
+  yield* import_effect4.Effect.forEach(sinks, (sink) => sink.record(enriched), { discard: true });
+});
+
+// src/internal/runtime/core/env.ts
+var import_effect5 = require("effect");
+var getNodeEnv = () => {
+  try {
+    const env = globalThis?.process?.env;
+    return typeof env?.NODE_ENV === "string" ? env.NODE_ENV : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var isDevEnv = () => getNodeEnv() !== "production";
+var StateTransactionConfigTagImpl = class extends import_effect5.Context.Tag("@logixjs/core/StateTransactionRuntimeConfig")() {
+};
+var ReadQueryStrictGateConfigTagImpl = class extends import_effect5.Context.Tag("@logixjs/core/ReadQueryStrictGateRuntimeConfig")() {
+};
+var ReplayModeConfigTagImpl = class extends import_effect5.Context.Tag("@logixjs/core/ReplayModeConfig")() {
+};
+var StateTransactionOverridesTagImpl = class extends import_effect5.Context.Tag("@logixjs/core/StateTransactionOverrides")() {
+};
+var ConcurrencyPolicyTagImpl = class extends import_effect5.Context.Tag("@logixjs/core/ConcurrencyPolicy")() {
+};
+var ConcurrencyPolicyOverridesTagImpl = class extends import_effect5.Context.Tag("@logixjs/core/ConcurrencyPolicyOverrides")() {
+};
+
+// src/internal/runtime/core/TaskRunner.ts
+var inSyncTransactionFiber = import_effect6.FiberRef.unsafeMake(false);
+var forceSourceRefresh = import_effect6.FiberRef.unsafeMake(false);
+var resolve = (eff, payload) => typeof eff === "function" ? eff(payload) : eff;
+var defaultOrigins = (triggerName) => ({
+  pending: {
+    kind: "task:pending",
+    name: triggerName
+  },
+  success: {
+    kind: "service-callback",
+    name: "task:success"
+  },
+  failure: {
+    kind: "service-callback",
+    name: "task:failure"
+  }
+});
+var shouldNoopInSyncTransactionFiber = (options) => import_effect6.Effect.gen(function* () {
+  const inTxn = yield* import_effect6.FiberRef.get(inSyncTransactionFiber);
+  if (!inTxn) {
+    return false;
+  }
+  if (isDevEnv()) {
+    yield* record({
+      type: "diagnostic",
+      moduleId: options.moduleId,
+      instanceId: options.instanceId,
+      code: options.code,
+      severity: options.severity,
+      message: options.message,
+      hint: options.hint,
+      actionTag: options.actionTag,
+      kind: options.kind
+    });
+  }
+  return true;
+});
+var resolveConcurrencyLimit = (runtime) => runtime.resolveConcurrencyPolicy ? runtime.resolveConcurrencyPolicy().pipe(import_effect6.Effect.map((p) => p.concurrencyLimit)) : import_effect6.Effect.succeed(16);
+var runTaskLifecycle = (payload, runtime, config, getCanWriteBack) => import_effect6.Effect.gen(function* () {
+  const noop = yield* shouldNoopInSyncTransactionFiber({
+    moduleId: runtime.moduleId,
+    instanceId: runtime.instanceId,
+    code: "logic::invalid_usage",
+    severity: "error",
+    message: "run*Task is not allowed inside a synchronous StateTransaction body (it may deadlock the txnQueue).",
+    hint: "Call run*Task from the run section of a watcher (e.g. $.onAction/$.onState/$.on); do not call it directly inside a reducer / trait.run / synchronous transaction body. For long-lived flows, use a multi-entry pattern (pending \u2192 IO \u2192 writeback).",
+    kind: "run_task_in_transaction"
+  });
+  if (noop) {
+    return;
+  }
+  const defaults = defaultOrigins(config.triggerName);
+  const origins = {
+    pending: config.origin?.pending ?? defaults.pending,
+    success: config.origin?.success ?? defaults.success,
+    failure: config.origin?.failure ?? defaults.failure
+  };
+  const pending = config.pending;
+  if (pending) {
+    yield* import_effect6.Effect.uninterruptible(
+      runtime.runWithStateTransaction(origins.pending, () => import_effect6.Effect.asVoid(resolve(pending, payload)))
+    );
+  }
+  const io = resolve(config.effect, payload);
+  const exit = yield* import_effect6.Effect.exit(io);
+  if (getCanWriteBack) {
+    const ok = yield* getCanWriteBack;
+    if (!ok) {
+      return;
+    }
+  }
+  if (exit._tag === "Success") {
+    const success = config.success;
+    if (success) {
+      yield* runtime.runWithStateTransaction(origins.success, () => import_effect6.Effect.asVoid(success(exit.value, payload)));
+    }
+    return;
+  }
+  const cause = exit.cause;
+  if (import_effect6.Cause.isInterrupted(cause)) {
+    return;
+  }
+  const failure = config.failure;
+  if (failure) {
+    yield* runtime.runWithStateTransaction(origins.failure, () => import_effect6.Effect.asVoid(failure(cause, payload)));
+  }
+}).pipe(
+  // Watchers must not crash as a whole due to a single task failure: swallow errors, but keep them diagnosable.
+  import_effect6.Effect.catchAllCause(
+    (cause) => record({
+      type: "diagnostic",
+      moduleId: runtime.moduleId,
+      instanceId: runtime.instanceId,
+      code: "task_runner::unhandled_failure",
+      severity: "error",
+      message: "TaskRunner encountered an unhandled failure (pending/IO/writeback).",
+      hint: "Add a failure writeback for this task or handle errors explicitly upstream; avoid fire-and-forget swallowing errors.",
+      actionTag: config.triggerName,
+      kind: "task_runner_unhandled_failure",
+      trigger: {
+        kind: "task",
+        name: config.triggerName
+      }
+    }).pipe(import_effect6.Effect.zipRight(import_effect6.Effect.logError("TaskRunner error", cause)))
+  )
+);
+var makeTaskRunner = (stream, mode, runtime, config) => {
+  if (mode === "latest") {
+    return import_effect6.Effect.gen(function* () {
+      const taskIdRef = yield* import_effect6.Ref.make(0);
+      const currentFiberRef = yield* import_effect6.Ref.make(void 0);
+      const start = (payload) => import_effect6.Effect.gen(function* () {
+        const taskId = yield* import_effect6.Ref.updateAndGet(taskIdRef, (n) => n + 1);
+        const prev = yield* import_effect6.Ref.get(currentFiberRef);
+        if (prev) {
+          yield* import_effect6.Fiber.interruptFork(prev);
+        }
+        const canWriteBack = import_effect6.Ref.get(taskIdRef).pipe(import_effect6.Effect.map((current) => current === taskId));
+        const fiber = yield* import_effect6.Effect.fork(
+          runTaskLifecycle(payload, runtime, config, canWriteBack)
+        );
+        yield* import_effect6.Ref.set(currentFiberRef, fiber);
+      });
+      return yield* import_effect6.Stream.runForEach(stream, start);
+    });
+  }
+  if (mode === "exhaust") {
+    return import_effect6.Effect.gen(function* () {
+      const concurrency = yield* resolveConcurrencyLimit(runtime);
+      const busyRef = yield* import_effect6.Ref.make(false);
+      const mapper = (payload) => import_effect6.Effect.gen(function* () {
+        const acquired = yield* import_effect6.Ref.modify(
+          busyRef,
+          (busy) => busy ? [false, busy] : [true, true]
+        );
+        if (!acquired) {
+          return;
+        }
+        try {
+          yield* runTaskLifecycle(payload, runtime, config);
+        } finally {
+          yield* import_effect6.Ref.set(busyRef, false);
+        }
+      });
+      return yield* import_effect6.Stream.runDrain(stream.pipe(import_effect6.Stream.mapEffect(mapper, { concurrency })));
+    });
+  }
+  if (mode === "parallel") {
+    return import_effect6.Effect.gen(function* () {
+      const concurrency = yield* resolveConcurrencyLimit(runtime);
+      return yield* import_effect6.Stream.runDrain(
+        stream.pipe(
+          import_effect6.Stream.mapEffect((payload) => runTaskLifecycle(payload, runtime, config), {
+            concurrency
+          })
+        )
+      );
+    });
+  }
+  return import_effect6.Stream.runForEach(
+    stream,
+    (payload) => runTaskLifecycle(payload, runtime, config)
+  );
+};
+
+// src/internal/runtime/core/mutativePatches.ts
+var import_mutative = require("mutative");
+
+// src/internal/field-path.ts
+var isFieldPathSegment = (seg) => {
+  if (!seg) return false;
+  if (seg === "*") return false;
+  if (/^\d+$/.test(seg)) return false;
+  if (seg.includes("[") || seg.includes("]")) return false;
+  return true;
+};
+
+// src/internal/runtime/core/mutativePatches.ts
+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 = (0, import_mutative.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/FlowRuntime.ts
+var import_effect9 = require("effect");
+
+// src/internal/effect-op.ts
+var import_effect8 = require("effect");
+
+// src/internal/observability/runSession.ts
+var import_effect7 = require("effect");
+var RunSessionTagImpl = class extends import_effect7.Context.Tag("@logixjs/core/RunSession")() {
+};
+var RunSessionTag = RunSessionTagImpl;
+
+// src/internal/effect-op.ts
+var nextGlobalOpSeq = 0;
+var nextOpSeq = () => {
+  nextGlobalOpSeq += 1;
+  return nextGlobalOpSeq;
+};
+var makeId = (instanceId, opSeq) => instanceId ? `${instanceId}::o${opSeq}` : `o${opSeq}`;
+var make = (params) => ({
+  ...params.id ? { id: params.id, meta: params.meta } : (() => {
+    const meta = params.meta ?? {};
+    const instanceId = meta.instanceId;
+    const opSeq = typeof meta.opSeq === "number" && Number.isFinite(meta.opSeq) ? Math.floor(meta.opSeq) : nextOpSeq();
+    return {
+      id: makeId(instanceId, opSeq),
+      meta: meta.opSeq === opSeq ? meta : { ...meta, opSeq }
+    };
+  })(),
+  kind: params.kind,
+  name: params.name,
+  payload: params.payload,
+  effect: params.effect
+});
+var run = (op, stack) => runWithMiddleware(op, stack);
+
+// src/internal/runtime/core/ReadQuery.ts
+function isReadQuery(input) {
+  if (!input || typeof input !== "object" && typeof input !== "function") return false;
+  const maybe = input;
+  return typeof maybe.selectorId === "string" && typeof maybe.select === "function" && Array.isArray(maybe.reads);
+}
+
+// src/internal/runtime/core/FlowRuntime.ts
+var getMiddlewareStack = () => import_effect9.Effect.serviceOption(EffectOpMiddlewareTag).pipe(
+  import_effect9.Effect.map((maybe) => import_effect9.Option.isSome(maybe) ? maybe.value.stack : [])
+);
+var getRuntimeScope = (runtime) => {
+  if (!runtime) return {};
+  if (typeof runtime !== "object" && typeof runtime !== "function") return {};
+  const scope = runtime;
+  return {
+    moduleId: typeof scope.moduleId === "string" ? scope.moduleId : void 0,
+    instanceId: typeof scope.instanceId === "string" ? scope.instanceId : void 0
+  };
+};
+var resolveEffect = (eff, payload) => typeof eff === "function" ? eff(payload) : eff;
+var make2 = (runtime, runtimeInternals) => {
+  const scope = getRuntimeScope(runtime);
+  const resolveConcurrencyLimit2 = () => runtimeInternals ? runtimeInternals.concurrency.resolveConcurrencyPolicy().pipe(import_effect9.Effect.map((p) => p.concurrencyLimit)) : import_effect9.Effect.succeed(16);
+  const runAsFlowOp = (name, payload, eff, options) => import_effect9.Effect.gen(function* () {
+    const stack = yield* getMiddlewareStack();
+    const meta = {
+      ...options?.meta ?? {},
+      policy: options?.policy,
+      tags: options?.tags,
+      trace: options?.trace,
+      moduleId: scope.moduleId,
+      instanceId: scope.instanceId
+    };
+    if (!(typeof meta.opSeq === "number" && Number.isFinite(meta.opSeq))) {
+      const sessionOpt = yield* import_effect9.Effect.serviceOption(RunSessionTag);
+      if (import_effect9.Option.isSome(sessionOpt)) {
+        const key = meta.instanceId ?? "global";
+        meta.opSeq = sessionOpt.value.local.nextSeq("opSeq", key);
+      }
+    }
+    const op = make({
+      kind: "flow",
+      name,
+      payload,
+      effect: eff,
+      meta
+    });
+    return yield* run(op, stack);
+  });
+  const runEffect = (eff) => (payload) => resolveEffect(eff, payload);
+  const runStreamSequential = (eff, options) => (stream) => import_effect9.Stream.runForEach(
+    stream,
+    (payload) => runAsFlowOp("flow.run", payload, runEffect(eff)(payload), options)
+  );
+  const runStreamParallel = (eff, options) => (stream) => import_effect9.Effect.gen(function* () {
+    const concurrency = yield* resolveConcurrencyLimit2();
+    return yield* import_effect9.Stream.runDrain(
+      stream.pipe(
+        import_effect9.Stream.mapEffect(
+          (payload) => runAsFlowOp("flow.runParallel", payload, runEffect(eff)(payload), options),
+          { concurrency }
+        )
+      )
+    ).pipe(
+      import_effect9.Effect.catchAllCause(
+        (cause) => record({
+          type: "diagnostic",
+          moduleId: scope.moduleId,
+          instanceId: scope.instanceId,
+          code: "flow::unhandled_failure",
+          severity: "error",
+          message: "Flow watcher (runParallel) failed with an unhandled error.",
+          hint: "Handle errors explicitly inside the watcher (catch/catchAll) or write back via TaskRunner failure; avoid silent failures.",
+          kind: "flow_unhandled_failure",
+          trigger: {
+            kind: "flow",
+            name: "runParallel"
+          }
+        }).pipe(import_effect9.Effect.zipRight(import_effect9.Effect.failCause(cause)))
+      )
+    );
+  });
+  return {
+    fromAction: (predicate) => runtime.actions$.pipe(import_effect9.Stream.filter(predicate)),
+    fromState: (selectorOrQuery) => runtime.changes(isReadQuery(selectorOrQuery) ? selectorOrQuery.select : selectorOrQuery),
+    debounce: (ms) => (stream) => import_effect9.Stream.debounce(stream, ms),
+    throttle: (ms) => (stream) => import_effect9.Stream.throttle(stream, {
+      cost: () => 1,
+      units: 1,
+      duration: ms,
+      strategy: "enforce"
+    }),
+    filter: (predicate) => (stream) => import_effect9.Stream.filter(stream, predicate),
+    run: (eff, options) => (stream) => runStreamSequential(eff, options)(stream),
+    runParallel: (eff, options) => (stream) => runStreamParallel(eff, options)(stream),
+    runLatest: (eff, options) => (stream) => import_effect9.Stream.runDrain(
+      import_effect9.Stream.map(
+        stream,
+        (payload) => runAsFlowOp(
+          "flow.runLatest",
+          payload,
+          runEffect(eff)(payload),
+          options
+        )
+      ).pipe(
+        import_effect9.Stream.flatMap((effect) => import_effect9.Stream.fromEffect(effect), {
+          switch: true
+        })
+      )
+    ),
+    runExhaust: (eff, options) => (stream) => import_effect9.Effect.gen(function* () {
+      const concurrency = yield* resolveConcurrencyLimit2();
+      const busyRef = yield* import_effect9.Ref.make(false);
+      const mapper = (payload) => import_effect9.Effect.gen(function* () {
+        const acquired = yield* import_effect9.Ref.modify(
+          busyRef,
+          (busy) => busy ? [false, busy] : [true, true]
+        );
+        if (!acquired) {
+          return;
+        }
+        try {
+          yield* runAsFlowOp(
+            "flow.runExhaust",
+            payload,
+            runEffect(eff)(payload),
+            options
+          );
+        } finally {
+          yield* import_effect9.Ref.set(busyRef, false);
+        }
+      });
+      return yield* import_effect9.Stream.runDrain(stream.pipe(import_effect9.Stream.mapEffect(mapper, { concurrency })));
+    })
+  };
+};
+
+// src/internal/runtime/core/MatchBuilder.ts
+var import_effect10 = require("effect");
+var makeMatch = (value) => {
+  let result;
+  const chain = {
+    with: (predicate, handler) => {
+      if (result) return chain;
+      if (predicate(value)) {
+        result = handler(value);
+      }
+      return chain;
+    },
+    otherwise: (handler) => {
+      if (result) return result;
+      return handler(value);
+    },
+    exhaustive: () => {
+      if (result) {
+        return result;
+      }
+      return import_effect10.Effect.dieMessage("[FluentMatch] Non-exhaustive match: no pattern matched value");
+    }
+  };
+  return chain;
+};
+var makeMatchTag = (value) => {
+  let result;
+  const chain = {
+    with: (t, handler) => {
+      if (result) return chain;
+      if (value._tag === t) {
+        result = handler(value);
+      }
+      return chain;
+    },
+    otherwise: (handler) => {
+      if (result) return result;
+      return handler(value);
+    },
+    exhaustive: () => {
+      if (result) {
+        return result;
+      }
+      return import_effect10.Effect.dieMessage("[FluentMatchTag] Non-exhaustive match: no tag handler matched value");
+    }
+  };
+  return chain;
+};
+
+// src/internal/runtime/core/Platform.ts
+var import_effect11 = require("effect");
+var Tag = import_effect11.Context.GenericTag("@logixjs/Platform");
+
+// src/internal/runtime/core/Lifecycle.ts
+var import_effect12 = require("effect");
+var LifecycleContext = import_effect12.Context.GenericTag("@logixjs/LifecycleManager");
+
+// src/internal/runtime/core/LogicDiagnostics.ts
+var import_effect13 = require("effect");
+var LogicPhaseServiceTag = import_effect13.Context.GenericTag("@logixjs/LogicPhaseService");
+var LogicUnitServiceTag = class extends import_effect13.Context.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
+});
+
+// src/internal/root.ts
+var import_effect15 = require("effect");
+
+// src/internal/runtime/core/RootContext.ts
+var import_effect14 = require("effect");
+var RootContextTagImpl = class extends import_effect14.Context.Tag("@logixjs/core/RootContext")() {
+};
+var RootContextTag = RootContextTagImpl;
+
+// src/internal/root.ts
+var tagIdOf = (tag) => typeof tag?.id === "string" ? String(tag.id) : typeof tag?.key === "string" ? String(tag.key) : "<unknown tag>";
+var makeMissingRootProviderError = (tag, entrypoint, extra) => {
+  const dev = isDevEnv();
+  const tokenId = tagIdOf(tag);
+  const fix = dev ? [
+    "- Provide it when creating the runtime tree (Logix.Runtime.make(...,{ layer }) / ManagedRuntime.make(Layer.mergeAll(...))).",
+    "- If you're in React and want the current runtime environment singleton, use useModule(ModuleTag).",
+    "- Do not rely on nested RuntimeProvider.layer to mock Root.resolve."
+  ] : [];
+  const message = dev ? [
+    "[MissingRootProviderError] Cannot resolve Tag from root provider.",
+    extra ? `
+${extra}` : "",
+    `tokenId: ${tokenId}`,
+    `entrypoint: ${entrypoint}`,
+    "mode: global",
+    "startScope: root",
+    "",
+    "fix:",
+    ...fix
+  ].filter((s) => s.length > 0).join("\n") : "[MissingRootProviderError] tag not found in root provider";
+  const err = new Error(message);
+  err.name = "MissingRootProviderError";
+  err.tokenId = tokenId;
+  err.entrypoint = entrypoint;
+  err.mode = "global";
+  err.startScope = { kind: "root" };
+  err.fix = fix;
+  return err;
+};
+var resolve2 = (tag, options) => import_effect15.Effect.gen(function* () {
+  const entrypoint = options?.entrypoint ?? "logic.root.resolve";
+  const root = yield* RootContextTag;
+  const rootContext = root.context ?? (options?.waitForReady ? yield* root.ready : void 0);
+  if (!rootContext) {
+    return yield* import_effect15.Effect.die(
+      makeMissingRootProviderError(tag, entrypoint, "reason: rootContextNotReady")
+    );
+  }
+  try {
+    return import_effect15.Context.get(rootContext, tag);
+  } catch {
+    return yield* import_effect15.Effect.die(makeMissingRootProviderError(tag, entrypoint));
+  }
+});
+
+// src/internal/runtime/core/runtimeInternalsAccessor.ts
+var RUNTIME_INTERNALS = /* @__PURE__ */ Symbol.for("@logixjs/core/runtimeInternals");
+var BOUND_INTERNALS = /* @__PURE__ */ Symbol.for("@logixjs/core/boundInternals");
+var defineHidden = (target, key, value) => {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+};
+var setBoundInternals = (bound, internals) => {
+  defineHidden(bound, BOUND_INTERNALS, internals);
+};
+var formatScope = (moduleId, instanceId) => {
+  const m = typeof moduleId === "string" && moduleId.length > 0 ? moduleId : "unknown";
+  const i = typeof instanceId === "string" && instanceId.length > 0 ? instanceId : "unknown";
+  return `moduleId=${m}, instanceId=${i}`;
+};
+var getRuntimeInternals = (runtime) => {
+  const scope = runtime;
+  const internals = runtime[RUNTIME_INTERNALS];
+  if (!internals) {
+    const msg = isDevEnv() ? [
+      "[MissingRuntimeInternals] Runtime internals not installed on ModuleRuntime instance.",
+      `scope: ${formatScope(scope.moduleId, scope.instanceId)}`,
+      "fix:",
+      "- Ensure ModuleRuntime.make calls internalHooks.installInternalHooks (020 foundation).",
+      "- If you created a mock runtime for tests, attach internals or avoid calling internal-only APIs."
+    ].join("\n") : "Runtime internals not installed";
+    throw new Error(msg);
+  }
+  const runtimeInstanceId = scope.instanceId;
+  if (typeof runtimeInstanceId === "string" && runtimeInstanceId.length > 0 && runtimeInstanceId !== internals.instanceId) {
+    throw new Error(
+      isDevEnv() ? [
+        "[InconsistentRuntimeInternals] Runtime internals instanceId mismatch.",
+        `runtime: ${formatScope(scope.moduleId, runtimeInstanceId)}`,
+        `internals: ${formatScope(internals.moduleId, internals.instanceId)}`
+      ].join("\n") : "Runtime internals mismatch"
+    );
+  }
+  return internals;
+};
+
+// src/internal/runtime/core/BoundApiRuntime.ts
+var LogicBuilderFactory = (runtime, runtimeInternals) => {
+  const flowApi = make2(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(import_effect16.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) => import_effect16.Effect.forkScoped(flowApi.run(eff)(stream)).pipe(import_effect16.Effect.asVoid),
+      runParallelFork: (eff) => import_effect16.Effect.forkScoped(flowApi.runParallel(eff)(stream)).pipe(import_effect16.Effect.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) => import_effect16.Stream.runForEach(
+        stream,
+        (payload) => taskRunnerRuntime.runWithStateTransaction(
+          {
+            kind: "watcher:update",
+            name: triggerName
+          },
+          () => import_effect16.Effect.gen(function* () {
+            const prev = yield* runtime.getState;
+            const next = reducer(prev, payload);
+            if (import_effect16.Effect.isEffect(next)) {
+              const exit = yield* import_effect16.Effect.exit(next);
+              if (exit._tag === "Failure") {
+                yield* import_effect16.Effect.logError("Flow error", exit.cause);
+                return;
+              }
+              yield* runtime.setState(exit.value);
+              return;
+            }
+            yield* runtime.setState(next);
+          })
+        )
+      ).pipe(import_effect16.Effect.catchAllCause((cause) => import_effect16.Effect.logError("Flow error", cause))),
+      mutate: (reducer) => import_effect16.Stream.runForEach(
+        stream,
+        (payload) => taskRunnerRuntime.runWithStateTransaction(
+          {
+            kind: "watcher:mutate",
+            name: triggerName
+          },
+          () => import_effect16.Effect.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(import_effect16.Effect.catchAllCause((cause) => import_effect16.Effect.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 make3(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 = make2(runtime, runtimeInternals);
+  const makeIntentBuilder = (runtime_) => LogicBuilderFactory(runtime_, runtimeInternals);
+  const withLifecycle = (available, missing) => import_effect16.Effect.serviceOption(LifecycleContext).pipe(
+    import_effect16.Effect.flatMap(
+      (maybe) => import_effect16.Option.match(maybe, {
+        onSome: available,
+        onNone: missing
+      })
+    )
+  );
+  const withPlatform = (invoke) => import_effect16.Effect.serviceOption(Tag).pipe(
+    import_effect16.Effect.flatMap(
+      (maybe) => import_effect16.Option.match(maybe, {
+        onSome: invoke,
+        onNone: () => import_effect16.Effect.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) => import_effect16.Effect.serviceOption(RunSessionTag).pipe(
+    import_effect16.Effect.map((maybe) => import_effect16.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 && import_effect16.Context.isTag(value.tag)
+  );
+  const buildModuleHandle = (tag, rt) => {
+    const actionsProxy = new Proxy(
+      {},
+      {
+        get: (_target, prop) => (payload) => rt.dispatch({
+          _tag: prop,
+          payload
+        })
+      }
+    );
+    const handle = {
+      read: (selector) => import_effect16.Effect.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 = (module2, rt) => import_effect16.Effect.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(module2.tag?.shape?.actionMap ?? {});
+    const internalSymbol = /* @__PURE__ */ Symbol.for("logix.module.internal");
+    const internal = module2[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 = module2.schemas && typeof module2.schemas === "object" ? Object.keys(module2.schemas) : void 0;
+    const meta = module2.meta && typeof module2.meta === "object" ? module2.meta : void 0;
+    const source = module2.dev?.source;
+    const traitsSnapshot = runtimeInternals.traits.getModuleTraitsSnapshot();
+    const traits = traitsSnapshot ? {
+      digest: traitsSnapshot.digest,
+      count: traitsSnapshot.traits.length
+    } : void 0;
+    const data = {
+      id: module2.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) => import_effect16.Effect.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* import_effect16.Effect.serviceOption(tag);
+      if (import_effect16.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* import_effect16.Effect.die(err);
+  });
+  const stateApi = {
+    read: runtime.getState,
+    update: (f) => import_effect16.Effect.gen(function* () {
+      const inTxn = yield* import_effect16.FiberRef.get(inSyncTransactionFiber);
+      if (inTxn) {
+        const prev = yield* runtime.getState;
+        return yield* runtime.setState(f(prev));
+      }
+      const body = () => import_effect16.Effect.flatMap(runtime.getState, (prev) => runtime.setState(f(prev)));
+      return yield* runtimeInternals ? runtimeInternals.txn.runWithStateTransaction({ kind: "state", name: "update" }, body) : body();
+    }),
+    mutate: (f) => import_effect16.Effect.gen(function* () {
+      const recordPatch = runtimeInternals?.txn.recordStatePatch;
+      const updateDraft = runtimeInternals?.txn.updateDraft;
+      const inTxn = yield* import_effect16.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 = () => import_effect16.Effect.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 import_effect16.Effect.sync(() => {
+      runtimeInternals.txn.registerReducer(String(tag), fn);
+    });
+  };
+  const effect = (token, handler) => import_effect16.Effect.gen(function* () {
+    if (!isActionToken(token)) {
+      return yield* import_effect16.Effect.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 resolve2(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 import_effect16.Effect.void;
+      },
+      onStart: (eff) => {
+        if (getCurrentPhase() === "run") {
+          return emitSetupOnlyViolation("$.lifecycle.onStart");
+        }
+        runtimeInternals.lifecycle.registerStart(eff);
+        return import_effect16.Effect.void;
+      },
+      onInit: (eff) => {
+        if (getCurrentPhase() === "run") {
+          return emitSetupOnlyViolation("$.lifecycle.onInit");
+        }
+        runtimeInternals.lifecycle.registerInitRequired(eff);
+        return import_effect16.Effect.void;
+      },
+      onDestroy: (eff) => {
+        if (getCurrentPhase() === "run") {
+          return emitSetupOnlyViolation("$.lifecycle.onDestroy");
+        }
+        runtimeInternals.lifecycle.registerDestroy(eff);
+        return import_effect16.Effect.void;
+      },
+      onError: (handler) => {
+        if (getCurrentPhase() === "run") {
+          return emitSetupOnlyViolation("$.lifecycle.onError");
+        }
+        runtimeInternals.lifecycle.registerOnError(handler);
+        return import_effect16.Effect.void;
+      },
+      onSuspend: (eff) => {
+        if (getCurrentPhase() === "run") {
+          return emitSetupOnlyViolation("$.lifecycle.onSuspend");
+        }
+        runtimeInternals.lifecycle.registerPlatformSuspend(import_effect16.Effect.asVoid(eff));
+        return import_effect16.Effect.void;
+      },
+      onResume: (eff) => {
+        if (getCurrentPhase() === "run") {
+          return emitSetupOnlyViolation("$.lifecycle.onResume");
+        }
+        runtimeInternals.lifecycle.registerPlatformResume(import_effect16.Effect.asVoid(eff));
+        return import_effect16.Effect.void;
+      },
+      onReset: (eff) => {
+        if (getCurrentPhase() === "run") {
+          return emitSetupOnlyViolation("$.lifecycle.onReset");
+        }
+        runtimeInternals.lifecycle.registerPlatformReset(import_effect16.Effect.asVoid(eff));
+        return import_effect16.Effect.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) => import_effect16.Effect.gen(function* () {
+          const handler = runtimeInternals.traits.getSourceRefreshHandler(fieldPath);
+          if (!handler) {
+            return yield* import_effect16.Effect.void;
+          }
+          const force = options2?.force === true;
+          const runHandler = (state) => force ? import_effect16.Effect.locally(forceSourceRefresh, true)(handler(state)) : handler(state);
+          const inTxn = yield* import_effect16.FiberRef.get(inSyncTransactionFiber);
+          if (inTxn) {
+            const state = yield* runtime.getState;
+            return yield* runHandler(state);
+          }
+          return yield* runtimeInternals.txn.runWithStateTransaction(
+            {
+              kind: "source-refresh",
+              name: fieldPath
+            },
+            () => import_effect16.Effect.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(import_effect16.Effect.map((rt) => buildModuleHandle(tag, rt)));
+          const resolveWithDescriptor = resolveModuleRuntime(tag).pipe(
+            import_effect16.Effect.tap((rt) => emitModuleDescriptorOnce(domain, rt)),
+            import_effect16.Effect.map((rt) => buildModuleHandle(tag, rt))
+          );
+          const detectAndSelect = import_effect16.FiberRef.get(currentDiagnosticsLevel).pipe(
+            import_effect16.Effect.tap((level) => {
+              cachedDiagnosticsLevel = level;
+            }),
+            import_effect16.Effect.flatMap((level) => level === "off" ? resolveAndBuild : resolveWithDescriptor)
+          );
+          return import_effect16.Effect.suspend(() => {
+            if (cachedDiagnosticsLevel === "off") {
+              return resolveAndBuild;
+            }
+            if (cachedDiagnosticsLevel !== void 0) {
+              return resolveWithDescriptor;
+            }
+            return detectAndSelect;
+          });
+        }
+        if (import_effect16.Context.isTag(arg)) {
+          const candidate = arg;
+          if (candidate._kind === "ModuleTag") {
+            return resolveModuleRuntime(arg).pipe(
+              import_effect16.Effect.map((rt) => buildModuleHandle(arg, rt))
+            );
+          }
+          return arg;
+        }
+        return import_effect16.Effect.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(
+              import_effect16.Stream.filter((a) => a._tag === tag || a.type === tag),
+              import_effect16.Stream.map((a) => a.payload)
+            ),
+            tag
+          );
+        }
+        if (typeof arg === "function") {
+          return createIntentBuilder(runtime.actions$.pipe(import_effect16.Stream.filter(arg)));
+        }
+        if (typeof arg === "string") {
+          return createIntentBuilder(
+            runtime.actions$.pipe(import_effect16.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(import_effect16.Stream.filter((a) => a._tag === arg._tag)),
+              String(arg._tag)
+            );
+          }
+          if (import_effect16.Schema.isSchema(arg)) {
+            return createIntentBuilder(
+              runtime.actions$.pipe(
+                import_effect16.Stream.filter((a) => {
+                  const result = import_effect16.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(import_effect16.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;
+}
+
+// src/Bound.ts
+function make4(shape, runtime) {
+  return make3(shape, runtime);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  make
+});
+//# sourceMappingURL=Bound.cjs.map