@logixjs/core 0.0.1

package/dist/Root.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/Root.ts","../src/internal/root.ts","../src/internal/runtime/core/env.ts","../src/internal/runtime/core/RootContext.ts"],"sourcesContent":["import type * as Internal from './internal/root.js'\nimport * as Impl from './internal/root.js'\n\nexport type RootResolveEntrypoint = Internal.RootResolveEntrypoint\nexport type RootResolveOptions = Internal.RootResolveOptions\n\nexport const resolve = Impl.resolve\nexport const layerFromContext = Impl.layerFromContext\n","import { Context, Deferred, Effect, Layer } from 'effect'\nimport { isDevEnv } from './runtime/core/env.js'\nimport { RootContextTag, type RootContext } from './runtime/core/RootContext.js'\n\nexport type RootResolveEntrypoint = 'logic.root.resolve' | 'logic.$.root.resolve'\n\nexport interface RootResolveOptions {\n  readonly entrypoint?: RootResolveEntrypoint\n  /**\n   * Whether to wait when RootContext is not ready yet:\n   * - Default false: avoid misuse during layer/setup which can deadlock.\n   * - `$.root.resolve` passes true in the run phase (run-only), allowing Env assembly to complete.\n   */\n  readonly waitForReady?: boolean\n}\n\nconst tagIdOf = (tag: Context.Tag<any, any>): string =>\n  typeof (tag as any)?.id === 'string'\n    ? String((tag as any).id)\n    : typeof (tag as any)?.key === 'string'\n      ? String((tag as any).key)\n      : '<unknown tag>'\n\nconst makeMissingRootProviderError = (\n  tag: Context.Tag<any, any>,\n  entrypoint: RootResolveEntrypoint,\n  extra?: string,\n): Error => {\n  const dev = isDevEnv()\n  const tokenId = tagIdOf(tag)\n  const fix: string[] = dev\n    ? [\n        '- Provide it when creating the runtime tree (Logix.Runtime.make(...,{ layer }) / ManagedRuntime.make(Layer.mergeAll(...))).',\n        \"- If you're in React and want the current runtime environment singleton, use useModule(ModuleTag).\",\n        '- Do not rely on nested RuntimeProvider.layer to mock Root.resolve.',\n      ]\n    : []\n\n  const message = dev\n    ? [\n        '[MissingRootProviderError] Cannot resolve Tag from root provider.',\n        extra ? `\\n${extra}` : '',\n        `tokenId: ${tokenId}`,\n        `entrypoint: ${entrypoint}`,\n        'mode: global',\n        'startScope: root',\n        '',\n        'fix:',\n        ...fix,\n      ]\n        .filter((s) => s.length > 0)\n        .join('\\n')\n    : '[MissingRootProviderError] tag not found in root provider'\n\n  const err = new Error(message)\n  err.name = 'MissingRootProviderError'\n  ;(err as any).tokenId = tokenId\n  ;(err as any).entrypoint = entrypoint\n  ;(err as any).mode = 'global'\n  ;(err as any).startScope = { kind: 'root' }\n  ;(err as any).fix = fix\n  return err\n}\n\n/**\n * resolve\n *\n * Resolve a Tag explicitly from the root provider of the current Runtime tree (ServiceTag / ModuleTag).\n *\n * Semantics:\n * - Always reads rootContext; unaffected by nearer-scope Layer/Context overrides.\n * - For ModuleTag: expresses root singleton semantics only (not used for multi-instance selection).\n */\nexport const resolve = <Id, Svc>(\n  tag: Context.Tag<Id, Svc>,\n  options?: RootResolveOptions,\n): Effect.Effect<Svc, never, any> =>\n  Effect.gen(function* () {\n    const entrypoint: RootResolveEntrypoint = options?.entrypoint ?? 'logic.root.resolve'\n\n    const root = yield* RootContextTag\n\n    const rootContext = root.context ?? (options?.waitForReady ? yield* root.ready : undefined)\n\n    if (!rootContext) {\n      return yield* Effect.die(\n        makeMissingRootProviderError(tag as Context.Tag<any, any>, entrypoint, 'reason: rootContextNotReady'),\n      )\n    }\n\n    try {\n      return Context.get(rootContext, tag as Context.Tag<any, any>) as Svc\n    } catch {\n      return yield* Effect.die(makeMissingRootProviderError(tag as Context.Tag<any, any>, entrypoint))\n    }\n  })\n\n/**\n * layerFromContext（tests/perf only）\n *\n * Provide a \"ready immediately\" RootContext for Root.resolve.\n * - `ready` is fulfilled immediately to avoid extra waits when waitForReady=true.\n */\nexport const layerFromContext = (context: Context.Context<any>): Layer.Layer<any, never, any> =>\n  Layer.scoped(\n    RootContextTag,\n    Effect.gen(function* () {\n      const ready = yield* Deferred.make<Context.Context<any>>()\n      yield* Deferred.succeed(ready, context)\n      const root: RootContext = { context, ready }\n      return root\n    }),\n  )\n","import { Context, Layer } from 'effect'\nimport type { TraitConvergeRequestedMode } from '../../state-trait/model.js'\nimport type { ReadQueryStrictGateConfig } from './ReadQuery.js'\n\n// Unified runtime env detection, avoiding bundlers inlining NODE_ENV at build time.\nexport const getNodeEnv = (): string | undefined => {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const env = (globalThis as any)?.process?.env\n    return typeof env?.NODE_ENV === 'string' ? env.NODE_ENV : undefined\n  } catch {\n    return undefined\n  }\n}\n\nexport const isDevEnv = (): boolean => getNodeEnv() !== 'production'\n\nexport type StateTransactionInstrumentation = 'full' | 'light'\n\n/**\n * getDefaultStateTxnInstrumentation：\n * - Currently chooses default instrumentation by NODE_ENV:\n *   - dev / test: full (keep patches and snapshots for debugging).\n *   - production: light (keep minimal semantics to reduce overhead).\n * - May evolve with finer-grained overrides in Runtime.make / Module.make.\n */\nexport const getDefaultStateTxnInstrumentation = (): StateTransactionInstrumentation => (isDevEnv() ? 'full' : 'light')\n\n/**\n * Runtime-level StateTransaction config Service:\n * - Provided at the app layer by Logix.Runtime.make / AppRuntime.makeApp.\n * - ModuleRuntime.make can read runtime-level defaults from Env.\n *\n * Notes:\n * - instrumentation is only a runtime-level default.\n * - Explicit instrumentation in ModuleImpl / ModuleRuntimeOptions has higher priority.\n */\nexport interface StateTransactionRuntimeConfig {\n  readonly instrumentation?: StateTransactionInstrumentation\n  /**\n   * StateTrait derived converge budget (ms):\n   * - Exceeding the budget triggers a soft degrade (freeze derived fields, preserve base writes and 0/1 commit semantics).\n   * - Default is 200ms (aligned with the 007 spec threshold).\n   */\n  readonly traitConvergeBudgetMs?: number\n  /**\n   * Auto-mode decision budget (ms):\n   * - Only used during the decision phase when requestedMode=\"auto\".\n   * - Exceeding the budget must immediately fall back to full (and record evidence).\n   */\n  readonly traitConvergeDecisionBudgetMs?: number\n  /**\n   * StateTrait converge scheduling strategy:\n   * - full: full topo execution (current default; safest).\n   * - dirty: minimal triggering based on dirtyPaths + deps in the txn window (requires accurate deps).\n   */\n  readonly traitConvergeMode?: TraitConvergeRequestedMode\n  /**\n   * 043: Trait converge time-slicing (explicit opt-in). Disabled by default.\n   */\n  readonly traitConvergeTimeSlicing?: TraitConvergeTimeSlicingPatch\n  /**\n   * 060: Txn Lanes (priority scheduling for transaction follow-up work). Enabled by default since 062.\n   */\n  readonly txnLanes?: TxnLanesPatch\n  /**\n   * Runtime-level per-module overrides (hotfix path):\n   * - Only affects converge behavior for the specified moduleId.\n   * - Lower priority than Provider overrides.\n   */\n  readonly traitConvergeOverridesByModuleId?: Readonly<Record<string, StateTransactionTraitConvergeOverrides>>\n  /**\n   * 060: Txn Lanes runtime_module overrides (hotfix / gradual tuning).\n   * - Only affects the specified moduleId.\n   * - Lower priority than Provider overrides.\n   */\n  readonly txnLanesOverridesByModuleId?: Readonly<Record<string, TxnLanesPatch>>\n}\n\nclass StateTransactionConfigTagImpl extends Context.Tag('@logixjs/core/StateTransactionRuntimeConfig')<\n  StateTransactionConfigTagImpl,\n  StateTransactionRuntimeConfig\n>() {}\n\nexport const StateTransactionConfigTag = StateTransactionConfigTagImpl\n\nexport type ReadQueryStrictGateRuntimeConfig = ReadQueryStrictGateConfig\n\nclass ReadQueryStrictGateConfigTagImpl extends Context.Tag('@logixjs/core/ReadQueryStrictGateRuntimeConfig')<\n  ReadQueryStrictGateConfigTagImpl,\n  ReadQueryStrictGateRuntimeConfig\n>() {}\n\nexport const ReadQueryStrictGateConfigTag = ReadQueryStrictGateConfigTagImpl\n\nexport type ReplayMode = 'live' | 'replay'\n\nexport interface ReplayModeConfig {\n  readonly mode: ReplayMode\n}\n\nclass ReplayModeConfigTagImpl extends Context.Tag('@logixjs/core/ReplayModeConfig')<\n  ReplayModeConfigTagImpl,\n  ReplayModeConfig\n>() {}\n\nexport const ReplayModeConfigTag = ReplayModeConfigTagImpl\n\nexport const replayModeLayer = (mode: ReplayMode): Layer.Layer<ReplayModeConfigTagImpl, never, never> =>\n  Layer.succeed(ReplayModeConfigTag, { mode })\n\nexport interface StateTransactionTraitConvergeOverrides {\n  readonly traitConvergeMode?: TraitConvergeRequestedMode\n  readonly traitConvergeBudgetMs?: number\n  readonly traitConvergeDecisionBudgetMs?: number\n  readonly traitConvergeTimeSlicing?: TraitConvergeTimeSlicingPatch\n}\n\nexport interface TxnLanesPatch {\n  /**\n   * enabled: whether Txn Lanes is enabled (default on since 062).\n   * - undefined: default enabled (when not explicitly configured)\n   * - false: disabled (returns to baseline behavior)\n   * - true: enabled (only affects scheduling of follow-up work outside the transaction; transactions remain synchronous)\n   */\n  readonly enabled?: boolean\n  /**\n   * overrideMode: runtime temporary override (for debugging/rollback/comparison).\n   * - forced_off: forcibly disables Txn Lanes (returns to baseline behavior).\n   * - forced_sync: forces fully synchronous execution (ignores non-urgent deferral and time-slicing; used for comparisons).\n   *\n   * Notes:\n   * - Override precedence follows StateTransactionOverrides: provider > runtime_module > runtime_default > builtin.\n   * - Overrides must be explainable by evidence (see 060 LaneEvidence reasons).\n   */\n  readonly overrideMode?: 'forced_off' | 'forced_sync'\n  /** non-urgent work loop slice budget (ms). */\n  readonly budgetMs?: number\n  /** Non-urgent backlog coalescing window (ms). */\n  readonly debounceMs?: number\n  /** Max lag upper bound (ms): exceeding it triggers an explainable starvation protection (forced catch-up). */\n  readonly maxLagMs?: number\n  /** Whether to allow coalescing/canceling intermediate non-urgent work (must preserve eventual consistency). */\n  readonly allowCoalesce?: boolean\n  /**\n   * Yield strategy for the non-urgent work loop (progressive enhancement).\n   * - baseline: uses only time budget + hard upper bound\n   * - inputPending: when supported by browsers, also consults `navigator.scheduling.isInputPending`\n   */\n  readonly yieldStrategy?: 'baseline' | 'inputPending'\n}\n\nexport interface TraitConvergeTimeSlicingPatch {\n  /**\n   * enabled：\n   * - false/undefined: disabled (default)\n   * - true: enables time-slicing (only affects computed/link explicitly marked as deferred)\n   */\n  readonly enabled?: boolean\n  /**\n   * debounceMs: coalescing interval (ms) for the deferral window; merges high-frequency inputs into one deferred flush.\n   */\n  readonly debounceMs?: number\n  /**\n   * maxLagMs: max lag upper bound (ms); exceeding it triggers an explainable forced flush (starvation protection).\n   */\n  readonly maxLagMs?: number\n}\n\n/**\n * Provider-scoped StateTransactionOverrides (delta overrides):\n * - Used to inject more local overrides into a Provider subtree on top of inherited global runtime config.\n * - Override precedence: provider > runtime_module > runtime_default > builtin.\n */\nexport interface StateTransactionOverrides {\n  readonly traitConvergeMode?: TraitConvergeRequestedMode\n  readonly traitConvergeBudgetMs?: number\n  readonly traitConvergeDecisionBudgetMs?: number\n  readonly traitConvergeTimeSlicing?: TraitConvergeTimeSlicingPatch\n  readonly traitConvergeOverridesByModuleId?: Readonly<Record<string, StateTransactionTraitConvergeOverrides>>\n  /** 060: Txn Lanes provider-level overrides (delta overrides). */\n  readonly txnLanes?: TxnLanesPatch\n  /** 060: Txn Lanes provider_module overrides (by moduleId). */\n  readonly txnLanesOverridesByModuleId?: Readonly<Record<string, TxnLanesPatch>>\n}\n\nclass StateTransactionOverridesTagImpl extends Context.Tag('@logixjs/core/StateTransactionOverrides')<\n  StateTransactionOverridesTagImpl,\n  StateTransactionOverrides\n>() {}\n\nexport const StateTransactionOverridesTag = StateTransactionOverridesTagImpl\n\nexport type ConcurrencyLimit = number | 'unbounded'\n\nexport interface ConcurrencyPolicyPatch {\n  readonly concurrencyLimit?: ConcurrencyLimit\n  readonly losslessBackpressureCapacity?: number\n  readonly allowUnbounded?: boolean\n  readonly pressureWarningThreshold?: {\n    readonly backlogCount?: number\n    readonly backlogDurationMs?: number\n  }\n  readonly warningCooldownMs?: number\n}\n\n/**\n * Runtime-level ConcurrencyPolicy:\n * - Provided at the app layer by Logix.Runtime.make / AppRuntime.makeApp.\n * - ModuleRuntime merges sources via a resolver (builtin/runtime_module/provider, etc.).\n *\n * Notes:\n * - overridesByModuleId is used for runtime_module hot-switching (hotfix / gradual tuning) and is lower priority than provider overrides.\n */\nexport interface ConcurrencyPolicy extends ConcurrencyPolicyPatch {\n  readonly overridesByModuleId?: Readonly<Record<string, ConcurrencyPolicyPatch>>\n}\n\nclass ConcurrencyPolicyTagImpl extends Context.Tag('@logixjs/core/ConcurrencyPolicy')<\n  ConcurrencyPolicyTagImpl,\n  ConcurrencyPolicy\n>() {}\n\nexport const ConcurrencyPolicyTag = ConcurrencyPolicyTagImpl\n\n/**\n * Provider-scoped ConcurrencyPolicyOverrides (delta overrides):\n * - Used to inject more local overrides into a Provider subtree on top of inherited global runtime config.\n * - Override precedence: provider > runtime_module > runtime_default > builtin.\n */\nexport interface ConcurrencyPolicyOverrides extends ConcurrencyPolicyPatch {\n  readonly overridesByModuleId?: Readonly<Record<string, ConcurrencyPolicyPatch>>\n}\n\nclass ConcurrencyPolicyOverridesTagImpl extends Context.Tag('@logixjs/core/ConcurrencyPolicyOverrides')<\n  ConcurrencyPolicyOverridesTagImpl,\n  ConcurrencyPolicyOverrides\n>() {}\n\nexport const ConcurrencyPolicyOverridesTag = ConcurrencyPolicyOverridesTagImpl\n","import { Context, Deferred } from 'effect'\n\nexport interface RootContext {\n  context: Context.Context<any> | undefined\n  readonly ready: Deferred.Deferred<Context.Context<any>, never>\n  readonly appId?: string\n  readonly appModuleIds?: ReadonlyArray<string>\n}\n\nclass RootContextTagImpl extends Context.Tag('@logixjs/core/RootContext')<RootContextTagImpl, RootContext>() {}\n\nexport const RootContextTag = RootContextTagImpl\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA,0BAAAA;AAAA,EAAA,eAAAC;AAAA;AAAA;;;ACAA,IAAAC,iBAAiD;;;ACAjD,oBAA+B;AAKxB,IAAM,aAAa,MAA0B;AAClD,MAAI;AAEF,UAAM,MAAO,YAAoB,SAAS;AAC1C,WAAO,OAAO,KAAK,aAAa,WAAW,IAAI,WAAW;AAAA,EAC5D,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAEO,IAAM,WAAW,MAAe,WAAW,MAAM;AAgExD,IAAM,gCAAN,cAA4C,sBAAQ,IAAI,6CAA6C,EAGnG,EAAE;AAAC;AAML,IAAM,mCAAN,cAA+C,sBAAQ,IAAI,gDAAgD,EAGzG,EAAE;AAAC;AAUL,IAAM,0BAAN,cAAsC,sBAAQ,IAAI,gCAAgC,EAGhF,EAAE;AAAC;AAkFL,IAAM,mCAAN,cAA+C,sBAAQ,IAAI,yCAAyC,EAGlG,EAAE;AAAC;AA6BL,IAAM,2BAAN,cAAuC,sBAAQ,IAAI,iCAAiC,EAGlF,EAAE;AAAC;AAaL,IAAM,oCAAN,cAAgD,sBAAQ,IAAI,0CAA0C,EAGpG,EAAE;AAAC;;;AC7OL,IAAAC,iBAAkC;AASlC,IAAM,qBAAN,cAAiC,uBAAQ,IAAI,2BAA2B,EAAmC,EAAE;AAAC;AAEvG,IAAM,iBAAiB;;;AFK9B,IAAM,UAAU,CAAC,QACf,OAAQ,KAAa,OAAO,WACxB,OAAQ,IAAY,EAAE,IACtB,OAAQ,KAAa,QAAQ,WAC3B,OAAQ,IAAY,GAAG,IACvB;AAER,IAAM,+BAA+B,CACnC,KACA,YACA,UACU;AACV,QAAM,MAAM,SAAS;AACrB,QAAM,UAAU,QAAQ,GAAG;AAC3B,QAAM,MAAgB,MAClB;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,EACF,IACA,CAAC;AAEL,QAAM,UAAU,MACZ;AAAA,IACE;AAAA,IACA,QAAQ;AAAA,EAAK,KAAK,KAAK;AAAA,IACvB,YAAY,OAAO;AAAA,IACnB,eAAe,UAAU;AAAA,IACzB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,GAAG;AAAA,EACL,EACG,OAAO,CAAC,MAAM,EAAE,SAAS,CAAC,EAC1B,KAAK,IAAI,IACZ;AAEJ,QAAM,MAAM,IAAI,MAAM,OAAO;AAC7B,MAAI,OAAO;AACV,EAAC,IAAY,UAAU;AACvB,EAAC,IAAY,aAAa;AAC1B,EAAC,IAAY,OAAO;AACpB,EAAC,IAAY,aAAa,EAAE,MAAM,OAAO;AACzC,EAAC,IAAY,MAAM;AACpB,SAAO;AACT;AAWO,IAAM,UAAU,CACrB,KACA,YAEA,sBAAO,IAAI,aAAa;AACtB,QAAM,aAAoC,SAAS,cAAc;AAEjE,QAAM,OAAO,OAAO;AAEpB,QAAM,cAAc,KAAK,YAAY,SAAS,eAAe,OAAO,KAAK,QAAQ;AAEjF,MAAI,CAAC,aAAa;AAChB,WAAO,OAAO,sBAAO;AAAA,MACnB,6BAA6B,KAA8B,YAAY,6BAA6B;AAAA,IACtG;AAAA,EACF;AAEA,MAAI;AACF,WAAO,uBAAQ,IAAI,aAAa,GAA4B;AAAA,EAC9D,QAAQ;AACN,WAAO,OAAO,sBAAO,IAAI,6BAA6B,KAA8B,UAAU,CAAC;AAAA,EACjG;AACF,CAAC;AAQI,IAAM,mBAAmB,CAAC,YAC/B,qBAAM;AAAA,EACJ;AAAA,EACA,sBAAO,IAAI,aAAa;AACtB,UAAM,QAAQ,OAAO,wBAAS,KAA2B;AACzD,WAAO,wBAAS,QAAQ,OAAO,OAAO;AACtC,UAAM,OAAoB,EAAE,SAAS,MAAM;AAC3C,WAAO;AAAA,EACT,CAAC;AACH;;;AD1GK,IAAMC,WAAe;AACrB,IAAMC,oBAAwB;","names":["layerFromContext","resolve","import_effect","import_effect","resolve","layerFromContext"]}

package/dist/Root.d.cts

@@ -0,0 +1,4 @@
+import 'effect/Layer';
+import 'effect/Effect';
+import 'effect/Context';
+export { a as RootResolveEntrypoint, b as RootResolveOptions, l as layerFromContext, r as resolve } from './Root-7ADUMk4t.cjs';

package/dist/Root.d.ts

@@ -0,0 +1,4 @@
+import 'effect/Layer';
+import 'effect/Effect';
+import 'effect/Context';
+export { a as RootResolveEntrypoint, b as RootResolveOptions, l as layerFromContext, r as resolve } from './Root-7ADUMk4t.js';

package/dist/Root.js

@@ -0,0 +1,12 @@
+import {
+  layerFromContext,
+  resolve
+} from "./chunk-G5ZBFPNU.js";
+import "./chunk-AUIR5O6W.js";
+import "./chunk-3QMIVH35.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  layerFromContext,
+  resolve
+};
+//# sourceMappingURL=Root.js.map

package/dist/Root.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/Runtime-B-aL-f29.d.cts

@@ -0,0 +1,274 @@
+import * as effect from 'effect';
+import { Scope, ManagedRuntime, Layer, Effect } from 'effect';
+import { h as AnyModuleShape, l as ModuleRuntime, o as StateOf, p as ActionOf, B as BoundApi, S as StateTransactionInstrumentation, H as TraitConvergeTimeSlicingPatch, I as TxnLanesPatch, J as StateTransactionTraitConvergeOverrides, e as ConcurrencyPolicy, k as ModuleImpl, K as StateTransactionOverrides, f as ConcurrencyPolicyOverrides, g as ConcurrencyPolicyPatch } from './module-B8CBqIZ_.cjs';
+import { A as AnyModule } from './Module-B_0xRDMR.cjs';
+import { z as DebugLayerOptions, b as DiagnosticsLevel, T as TraitConvergeDiagnosticsSamplingConfig } from './Debug-Bq8Sqjcr.cjs';
+import { MiddlewareStack } from './EffectOp.cjs';
+import { g as ReadQueryFallbackReason$1 } from './ReadQuery-SinbStGF.cjs';
+import { DebugObserverConfig } from './Middleware.cjs';
+
+interface ProgramRunContext<Sh extends AnyModuleShape> {
+    readonly scope: Scope.CloseableScope;
+    readonly runtime: ManagedRuntime.ManagedRuntime<any, never>;
+    readonly module: ModuleRuntime<StateOf<Sh>, ActionOf<Sh>>;
+    readonly $: BoundApi<Sh, never>;
+}
+
+type ProgramRunnerErrorTag = 'BootError' | 'MainError' | 'DisposeError' | 'DisposeTimeout';
+interface ProgramIdentity {
+    moduleId: string;
+    instanceId: string;
+}
+declare abstract class ProgramRunnerErrorBase extends Error {
+    abstract readonly _tag: ProgramRunnerErrorTag;
+    readonly moduleId: string;
+    readonly instanceId: string;
+    readonly entrypoint: 'boot' | 'main' | 'dispose';
+    readonly hint?: string;
+    protected constructor(params: {
+        readonly message: string;
+        readonly identity: ProgramIdentity;
+        readonly entrypoint: 'boot' | 'main' | 'dispose';
+        readonly hint?: string;
+    });
+    toJSON(): Record<string, unknown>;
+}
+declare class BootError extends ProgramRunnerErrorBase {
+    readonly _tag: "BootError";
+    readonly cause?: {
+        name?: string;
+        message?: string;
+    };
+    constructor(identity: ProgramIdentity, cause: unknown);
+    toJSON(): Record<string, unknown>;
+}
+declare class MainError extends ProgramRunnerErrorBase {
+    readonly _tag: "MainError";
+    readonly cause?: {
+        name?: string;
+        message?: string;
+    };
+    constructor(identity: ProgramIdentity, cause: unknown);
+    toJSON(): Record<string, unknown>;
+}
+declare class DisposeError extends ProgramRunnerErrorBase {
+    readonly _tag: "DisposeError";
+    readonly cause?: {
+        name?: string;
+        message?: string;
+    };
+    constructor(identity: ProgramIdentity, cause: unknown);
+    toJSON(): Record<string, unknown>;
+}
+declare class DisposeTimeoutError extends ProgramRunnerErrorBase {
+    readonly _tag: "DisposeTimeout";
+    readonly timeoutMs: number;
+    readonly elapsedMs: number;
+    readonly suggestions: ReadonlyArray<string>;
+    constructor(identity: ProgramIdentity, params: {
+        readonly timeoutMs: number;
+        readonly elapsedMs: number;
+    });
+    toJSON(): Record<string, unknown>;
+}
+
+interface OpenProgramOptions extends RuntimeOptions {
+    readonly closeScopeTimeout?: number;
+    readonly handleSignals?: boolean;
+}
+interface RunProgramOptions<Args = unknown> extends OpenProgramOptions {
+    readonly args?: Args;
+    readonly exitCode?: boolean;
+    readonly reportError?: boolean;
+}
+/**
+ * Runtime-level StateTransaction defaults.
+ *
+ * Applied as the `runtime_default` baseline; modules and providers may override.
+ */
+interface RuntimeStateTransactionOptions {
+    readonly instrumentation?: StateTransactionInstrumentation;
+    readonly traitConvergeBudgetMs?: number;
+    readonly traitConvergeDecisionBudgetMs?: number;
+    readonly traitConvergeMode?: 'auto' | 'full' | 'dirty';
+    readonly traitConvergeTimeSlicing?: TraitConvergeTimeSlicingPatch;
+    /** Txn lanes configuration at the `runtime_default` baseline (enabled by default). */
+    readonly txnLanes?: TxnLanesPatch;
+    readonly traitConvergeOverridesByModuleId?: Readonly<Record<string, StateTransactionTraitConvergeOverrides>>;
+    /** Txn lanes overrides at the `runtime_module` layer. */
+    readonly txnLanesOverridesByModuleId?: Readonly<Record<string, TxnLanesPatch>>;
+}
+type ReadQueryFallbackReason = ReadQueryFallbackReason$1;
+interface RuntimeReadQueryStrictGateOptions {
+    /**
+     * Strict gate mode for ReadQuery fallbacks.
+     *
+     * - `off`: disabled (default).
+     * - `warn`: allow but emit structured diagnostics.
+     * - `error`: fail on forbidden fallbacks (CI/perf gate).
+     */
+    readonly mode?: 'off' | 'warn' | 'error';
+    /**
+     * Selectors that must stay on the static lane (keyed by selectorId).
+     *
+     * When undefined, the implementation decides the gate coverage (typically `all`).
+     */
+    readonly requireStatic?: {
+        readonly selectorIds?: ReadonlyArray<string>;
+        readonly modules?: ReadonlyArray<string>;
+    };
+    /**
+     * Fine-grained kill switch: deny specific fallback reasons (e.g. `unstableSelectorId`).
+     */
+    readonly denyFallbackReasons?: ReadonlyArray<ReadQueryFallbackReason>;
+}
+interface RuntimeReadQueryOptions {
+    readonly strictGate?: RuntimeReadQueryStrictGateOptions;
+}
+interface RuntimeOptions {
+    readonly layer?: Layer.Layer<any, never, never>;
+    readonly onError?: (cause: effect.Cause.Cause<unknown>) => Effect.Effect<void>;
+    /**
+     * Optional runtime label (e.g. `AppDemoRuntime`) for Debug / DevTools grouping.
+     */
+    readonly label?: string;
+    /**
+     * Optional Debug console output configuration.
+     *
+     * - `true`: enable `Debug.layer()` (auto mode).
+     * - `Debug.DebugLayerOptions`: forwarded to `Debug.layer(options)`.
+     *
+     * Advanced: for full control, omit this option and provide your own Debug layers via `options.layer`.
+     */
+    readonly debug?: true | DebugLayerOptions;
+    readonly middleware?: MiddlewareStack;
+    /**
+     * Enable Devtools (explicit override).
+     *
+     * - `true`: use default `DevtoolsRuntimeOptions`.
+     * - `DevtoolsRuntimeOptions`: customize hub buffer size, DebugObserver filters, etc.
+     */
+    readonly devtools?: true | DevtoolsRuntimeOptions;
+    /**
+     * Runtime-level StateTransaction defaults.
+     *
+     * When not provided, modules fall back to NODE_ENV-based defaults; modules may override via
+     * `ModuleDef.implement({ stateTransaction })`.
+     */
+    readonly stateTransaction?: RuntimeStateTransactionOptions;
+    /**
+     * Runtime-level concurrency control plane.
+     *
+     * Converges unbounded concurrency into bounded (default 16), with module/provider overrides.
+     */
+    readonly concurrencyPolicy?: ConcurrencyPolicy;
+    /**
+     * ReadQuery governance (e.g. strict gate policies).
+     */
+    readonly readQuery?: RuntimeReadQueryOptions;
+}
+interface DevtoolsRuntimeOptions {
+    /** Hub ring buffer capacity (events). Default: 500. */
+    readonly bufferSize?: number;
+    /**
+     * Diagnostics level for exportable Devtools events.
+     *
+     * Forwarded to `Debug.devtoolsHubLayer({ diagnosticsLevel })`.
+     * Default: `"light"`.
+     */
+    readonly diagnosticsLevel?: DiagnosticsLevel;
+    /**
+     * Trait converge diagnostics sampling config.
+     *
+     * Forwarded to `Debug.devtoolsHubLayer({ traitConvergeDiagnosticsSampling })`.
+     */
+    readonly traitConvergeDiagnosticsSampling?: TraitConvergeDiagnosticsSamplingConfig;
+    /** DebugObserver config for `trace:effectop`; undefined means full observation. */
+    readonly observer?: DebugObserverConfig | false;
+    /** Reserved: React render sampling / throttling config (consumed by `@logixjs/react`). */
+    readonly sampling?: {
+        readonly reactRenderSampleRate?: number;
+    };
+}
+/**
+ * Construct an application runtime from a root module.
+ *
+ * - Uses the root module + layer as the composition root.
+ * - Forks root processes within the runtime Scope.
+ * - Exposes a ManagedRuntime; the full Env is provided by `root.layer + options.layer`.
+ */
+declare const make: (root: ModuleImpl<any, AnyModuleShape, any> | AnyModule, options?: RuntimeOptions) => ManagedRuntime.ManagedRuntime<any, never>;
+/**
+ * Resourceful entry: returns a scope-bound ProgramRunContext (booted and ready).
+ */
+declare const openProgram: <Sh extends AnyModuleShape>(root: ModuleImpl<any, Sh, any> | AnyModule, options?: OpenProgramOptions) => Effect.Effect<ProgramRunContext<Sh>, unknown, Scope.Scope>;
+/**
+ * One-shot entry: boot → main(ctx,args) → dispose.
+ */
+declare const runProgram: <Sh extends AnyModuleShape, Args, A, E, R>(root: ModuleImpl<any, Sh, any> | AnyModule, main: (ctx: ProgramRunContext<Sh>, args: Args) => Effect.Effect<A, E, R>, options?: RunProgramOptions<Args>) => Promise<A>;
+/**
+ * Provider-scoped StateTransactionOverrides layer.
+ *
+ * Use it to apply local overrides on top of the `runtime_default` baseline.
+ */
+declare const stateTransactionOverridesLayer: (overrides: StateTransactionOverrides) => Layer.Layer<any, never, never>;
+/**
+ * Provider-scoped ConcurrencyPolicyOverrides layer.
+ *
+ * Use it to apply local overrides on top of the `runtime_default` baseline.
+ */
+declare const concurrencyPolicyOverridesLayer: (overrides: ConcurrencyPolicyOverrides) => Layer.Layer<any, never, never>;
+/**
+ * Hot-switch Trait converge overrides for a moduleId.
+ *
+ * This mutates the `runtime_module` patch map only; provider overrides still take precedence.
+ */
+declare const setTraitConvergeOverride: (runtime: ManagedRuntime.ManagedRuntime<any, never>, moduleId: string, overrides: StateTransactionTraitConvergeOverrides | undefined) => void;
+/**
+ * Hot-switch ConcurrencyPolicy patch for a moduleId.
+ *
+ * This mutates the `runtime_module` patch map only; provider overrides still take precedence.
+ */
+declare const setConcurrencyPolicyOverride: (runtime: ManagedRuntime.ManagedRuntime<any, never>, moduleId: string, patch: ConcurrencyPolicyPatch | undefined) => void;
+/**
+ * Apply a transaction snapshot for time-travel replay (dev/test).
+ *
+ * - `moduleId` / `instanceId` match Debug events.
+ * - `mode`: `before` replays pre-transaction; `after` replays post-commit.
+ *
+ * No-op if the runtime/instance cannot be resolved.
+ */
+declare const applyTransactionSnapshot: (moduleId: string, instanceId: string, txnId: string, mode: "before" | "after") => Effect.Effect<void, never, any>;
+
+type Runtime_BootError = BootError;
+declare const Runtime_BootError: typeof BootError;
+type Runtime_DevtoolsRuntimeOptions = DevtoolsRuntimeOptions;
+type Runtime_DisposeError = DisposeError;
+declare const Runtime_DisposeError: typeof DisposeError;
+type Runtime_DisposeTimeoutError = DisposeTimeoutError;
+declare const Runtime_DisposeTimeoutError: typeof DisposeTimeoutError;
+type Runtime_MainError = MainError;
+declare const Runtime_MainError: typeof MainError;
+type Runtime_OpenProgramOptions = OpenProgramOptions;
+type Runtime_ProgramIdentity = ProgramIdentity;
+type Runtime_ProgramRunContext<Sh extends AnyModuleShape> = ProgramRunContext<Sh>;
+type Runtime_ProgramRunnerErrorTag = ProgramRunnerErrorTag;
+type Runtime_ReadQueryFallbackReason = ReadQueryFallbackReason;
+type Runtime_RunProgramOptions<Args = unknown> = RunProgramOptions<Args>;
+type Runtime_RuntimeOptions = RuntimeOptions;
+type Runtime_RuntimeReadQueryOptions = RuntimeReadQueryOptions;
+type Runtime_RuntimeReadQueryStrictGateOptions = RuntimeReadQueryStrictGateOptions;
+type Runtime_RuntimeStateTransactionOptions = RuntimeStateTransactionOptions;
+declare const Runtime_applyTransactionSnapshot: typeof applyTransactionSnapshot;
+declare const Runtime_concurrencyPolicyOverridesLayer: typeof concurrencyPolicyOverridesLayer;
+declare const Runtime_make: typeof make;
+declare const Runtime_openProgram: typeof openProgram;
+declare const Runtime_runProgram: typeof runProgram;
+declare const Runtime_setConcurrencyPolicyOverride: typeof setConcurrencyPolicyOverride;
+declare const Runtime_setTraitConvergeOverride: typeof setTraitConvergeOverride;
+declare const Runtime_stateTransactionOverridesLayer: typeof stateTransactionOverridesLayer;
+declare namespace Runtime {
+  export { Runtime_BootError as BootError, type Runtime_DevtoolsRuntimeOptions as DevtoolsRuntimeOptions, Runtime_DisposeError as DisposeError, Runtime_DisposeTimeoutError as DisposeTimeoutError, Runtime_MainError as MainError, type Runtime_OpenProgramOptions as OpenProgramOptions, type Runtime_ProgramIdentity as ProgramIdentity, type Runtime_ProgramRunContext as ProgramRunContext, type Runtime_ProgramRunnerErrorTag as ProgramRunnerErrorTag, type Runtime_ReadQueryFallbackReason as ReadQueryFallbackReason, type Runtime_RunProgramOptions as RunProgramOptions, type Runtime_RuntimeOptions as RuntimeOptions, type Runtime_RuntimeReadQueryOptions as RuntimeReadQueryOptions, type Runtime_RuntimeReadQueryStrictGateOptions as RuntimeReadQueryStrictGateOptions, type Runtime_RuntimeStateTransactionOptions as RuntimeStateTransactionOptions, Runtime_applyTransactionSnapshot as applyTransactionSnapshot, Runtime_concurrencyPolicyOverridesLayer as concurrencyPolicyOverridesLayer, Runtime_make as make, Runtime_openProgram as openProgram, Runtime_runProgram as runProgram, Runtime_setConcurrencyPolicyOverride as setConcurrencyPolicyOverride, Runtime_setTraitConvergeOverride as setTraitConvergeOverride, Runtime_stateTransactionOverridesLayer as stateTransactionOverridesLayer };
+}
+
+export { BootError as B, type DevtoolsRuntimeOptions as D, MainError as M, type OpenProgramOptions as O, type ProgramRunContext as P, Runtime as R, type RunProgramOptions as a, type RuntimeStateTransactionOptions as b, type ReadQueryFallbackReason as c, type RuntimeReadQueryStrictGateOptions as d, type RuntimeReadQueryOptions as e, type RuntimeOptions as f, concurrencyPolicyOverridesLayer as g, setTraitConvergeOverride as h, setConcurrencyPolicyOverride as i, applyTransactionSnapshot as j, DisposeError as k, DisposeTimeoutError as l, make as m, type ProgramIdentity as n, openProgram as o, type ProgramRunnerErrorTag as p, runProgram as r, stateTransactionOverridesLayer as s };

package/dist/Runtime-CtyzZG4i.d.ts

@@ -0,0 +1,274 @@
+import * as effect from 'effect';
+import { Scope, ManagedRuntime, Layer, Effect } from 'effect';
+import { h as AnyModuleShape, l as ModuleRuntime, o as StateOf, p as ActionOf, B as BoundApi, S as StateTransactionInstrumentation, H as TraitConvergeTimeSlicingPatch, I as TxnLanesPatch, J as StateTransactionTraitConvergeOverrides, e as ConcurrencyPolicy, k as ModuleImpl, K as StateTransactionOverrides, f as ConcurrencyPolicyOverrides, g as ConcurrencyPolicyPatch } from './module-k7m3txak.js';
+import { A as AnyModule } from './Module-DnzluX2J.js';
+import { z as DebugLayerOptions, b as DiagnosticsLevel, T as TraitConvergeDiagnosticsSamplingConfig } from './Debug-B5q5Bkzx.js';
+import { MiddlewareStack } from './EffectOp.js';
+import { g as ReadQueryFallbackReason$1 } from './ReadQuery-SinbStGF.js';
+import { DebugObserverConfig } from './Middleware.js';
+
+interface ProgramRunContext<Sh extends AnyModuleShape> {
+    readonly scope: Scope.CloseableScope;
+    readonly runtime: ManagedRuntime.ManagedRuntime<any, never>;
+    readonly module: ModuleRuntime<StateOf<Sh>, ActionOf<Sh>>;
+    readonly $: BoundApi<Sh, never>;
+}
+
+type ProgramRunnerErrorTag = 'BootError' | 'MainError' | 'DisposeError' | 'DisposeTimeout';
+interface ProgramIdentity {
+    moduleId: string;
+    instanceId: string;
+}
+declare abstract class ProgramRunnerErrorBase extends Error {
+    abstract readonly _tag: ProgramRunnerErrorTag;
+    readonly moduleId: string;
+    readonly instanceId: string;
+    readonly entrypoint: 'boot' | 'main' | 'dispose';
+    readonly hint?: string;
+    protected constructor(params: {
+        readonly message: string;
+        readonly identity: ProgramIdentity;
+        readonly entrypoint: 'boot' | 'main' | 'dispose';
+        readonly hint?: string;
+    });
+    toJSON(): Record<string, unknown>;
+}
+declare class BootError extends ProgramRunnerErrorBase {
+    readonly _tag: "BootError";
+    readonly cause?: {
+        name?: string;
+        message?: string;
+    };
+    constructor(identity: ProgramIdentity, cause: unknown);
+    toJSON(): Record<string, unknown>;
+}
+declare class MainError extends ProgramRunnerErrorBase {
+    readonly _tag: "MainError";
+    readonly cause?: {
+        name?: string;
+        message?: string;
+    };
+    constructor(identity: ProgramIdentity, cause: unknown);
+    toJSON(): Record<string, unknown>;
+}
+declare class DisposeError extends ProgramRunnerErrorBase {
+    readonly _tag: "DisposeError";
+    readonly cause?: {
+        name?: string;
+        message?: string;
+    };
+    constructor(identity: ProgramIdentity, cause: unknown);
+    toJSON(): Record<string, unknown>;
+}
+declare class DisposeTimeoutError extends ProgramRunnerErrorBase {
+    readonly _tag: "DisposeTimeout";
+    readonly timeoutMs: number;
+    readonly elapsedMs: number;
+    readonly suggestions: ReadonlyArray<string>;
+    constructor(identity: ProgramIdentity, params: {
+        readonly timeoutMs: number;
+        readonly elapsedMs: number;
+    });
+    toJSON(): Record<string, unknown>;
+}
+
+interface OpenProgramOptions extends RuntimeOptions {
+    readonly closeScopeTimeout?: number;
+    readonly handleSignals?: boolean;
+}
+interface RunProgramOptions<Args = unknown> extends OpenProgramOptions {
+    readonly args?: Args;
+    readonly exitCode?: boolean;
+    readonly reportError?: boolean;
+}
+/**
+ * Runtime-level StateTransaction defaults.
+ *
+ * Applied as the `runtime_default` baseline; modules and providers may override.
+ */
+interface RuntimeStateTransactionOptions {
+    readonly instrumentation?: StateTransactionInstrumentation;
+    readonly traitConvergeBudgetMs?: number;
+    readonly traitConvergeDecisionBudgetMs?: number;
+    readonly traitConvergeMode?: 'auto' | 'full' | 'dirty';
+    readonly traitConvergeTimeSlicing?: TraitConvergeTimeSlicingPatch;
+    /** Txn lanes configuration at the `runtime_default` baseline (enabled by default). */
+    readonly txnLanes?: TxnLanesPatch;
+    readonly traitConvergeOverridesByModuleId?: Readonly<Record<string, StateTransactionTraitConvergeOverrides>>;
+    /** Txn lanes overrides at the `runtime_module` layer. */
+    readonly txnLanesOverridesByModuleId?: Readonly<Record<string, TxnLanesPatch>>;
+}
+type ReadQueryFallbackReason = ReadQueryFallbackReason$1;
+interface RuntimeReadQueryStrictGateOptions {
+    /**
+     * Strict gate mode for ReadQuery fallbacks.
+     *
+     * - `off`: disabled (default).
+     * - `warn`: allow but emit structured diagnostics.
+     * - `error`: fail on forbidden fallbacks (CI/perf gate).
+     */
+    readonly mode?: 'off' | 'warn' | 'error';
+    /**
+     * Selectors that must stay on the static lane (keyed by selectorId).
+     *
+     * When undefined, the implementation decides the gate coverage (typically `all`).
+     */
+    readonly requireStatic?: {
+        readonly selectorIds?: ReadonlyArray<string>;
+        readonly modules?: ReadonlyArray<string>;
+    };
+    /**
+     * Fine-grained kill switch: deny specific fallback reasons (e.g. `unstableSelectorId`).
+     */
+    readonly denyFallbackReasons?: ReadonlyArray<ReadQueryFallbackReason>;
+}
+interface RuntimeReadQueryOptions {
+    readonly strictGate?: RuntimeReadQueryStrictGateOptions;
+}
+interface RuntimeOptions {
+    readonly layer?: Layer.Layer<any, never, never>;
+    readonly onError?: (cause: effect.Cause.Cause<unknown>) => Effect.Effect<void>;
+    /**
+     * Optional runtime label (e.g. `AppDemoRuntime`) for Debug / DevTools grouping.
+     */
+    readonly label?: string;
+    /**
+     * Optional Debug console output configuration.
+     *
+     * - `true`: enable `Debug.layer()` (auto mode).
+     * - `Debug.DebugLayerOptions`: forwarded to `Debug.layer(options)`.
+     *
+     * Advanced: for full control, omit this option and provide your own Debug layers via `options.layer`.
+     */
+    readonly debug?: true | DebugLayerOptions;
+    readonly middleware?: MiddlewareStack;
+    /**
+     * Enable Devtools (explicit override).
+     *
+     * - `true`: use default `DevtoolsRuntimeOptions`.
+     * - `DevtoolsRuntimeOptions`: customize hub buffer size, DebugObserver filters, etc.
+     */
+    readonly devtools?: true | DevtoolsRuntimeOptions;
+    /**
+     * Runtime-level StateTransaction defaults.
+     *
+     * When not provided, modules fall back to NODE_ENV-based defaults; modules may override via
+     * `ModuleDef.implement({ stateTransaction })`.
+     */
+    readonly stateTransaction?: RuntimeStateTransactionOptions;
+    /**
+     * Runtime-level concurrency control plane.
+     *
+     * Converges unbounded concurrency into bounded (default 16), with module/provider overrides.
+     */
+    readonly concurrencyPolicy?: ConcurrencyPolicy;
+    /**
+     * ReadQuery governance (e.g. strict gate policies).
+     */
+    readonly readQuery?: RuntimeReadQueryOptions;
+}
+interface DevtoolsRuntimeOptions {
+    /** Hub ring buffer capacity (events). Default: 500. */
+    readonly bufferSize?: number;
+    /**
+     * Diagnostics level for exportable Devtools events.
+     *
+     * Forwarded to `Debug.devtoolsHubLayer({ diagnosticsLevel })`.
+     * Default: `"light"`.
+     */
+    readonly diagnosticsLevel?: DiagnosticsLevel;
+    /**
+     * Trait converge diagnostics sampling config.
+     *
+     * Forwarded to `Debug.devtoolsHubLayer({ traitConvergeDiagnosticsSampling })`.
+     */
+    readonly traitConvergeDiagnosticsSampling?: TraitConvergeDiagnosticsSamplingConfig;
+    /** DebugObserver config for `trace:effectop`; undefined means full observation. */
+    readonly observer?: DebugObserverConfig | false;
+    /** Reserved: React render sampling / throttling config (consumed by `@logixjs/react`). */
+    readonly sampling?: {
+        readonly reactRenderSampleRate?: number;
+    };
+}
+/**
+ * Construct an application runtime from a root module.
+ *
+ * - Uses the root module + layer as the composition root.
+ * - Forks root processes within the runtime Scope.
+ * - Exposes a ManagedRuntime; the full Env is provided by `root.layer + options.layer`.
+ */
+declare const make: (root: ModuleImpl<any, AnyModuleShape, any> | AnyModule, options?: RuntimeOptions) => ManagedRuntime.ManagedRuntime<any, never>;
+/**
+ * Resourceful entry: returns a scope-bound ProgramRunContext (booted and ready).
+ */
+declare const openProgram: <Sh extends AnyModuleShape>(root: ModuleImpl<any, Sh, any> | AnyModule, options?: OpenProgramOptions) => Effect.Effect<ProgramRunContext<Sh>, unknown, Scope.Scope>;
+/**
+ * One-shot entry: boot → main(ctx,args) → dispose.
+ */
+declare const runProgram: <Sh extends AnyModuleShape, Args, A, E, R>(root: ModuleImpl<any, Sh, any> | AnyModule, main: (ctx: ProgramRunContext<Sh>, args: Args) => Effect.Effect<A, E, R>, options?: RunProgramOptions<Args>) => Promise<A>;
+/**
+ * Provider-scoped StateTransactionOverrides layer.
+ *
+ * Use it to apply local overrides on top of the `runtime_default` baseline.
+ */
+declare const stateTransactionOverridesLayer: (overrides: StateTransactionOverrides) => Layer.Layer<any, never, never>;
+/**
+ * Provider-scoped ConcurrencyPolicyOverrides layer.
+ *
+ * Use it to apply local overrides on top of the `runtime_default` baseline.
+ */
+declare const concurrencyPolicyOverridesLayer: (overrides: ConcurrencyPolicyOverrides) => Layer.Layer<any, never, never>;
+/**
+ * Hot-switch Trait converge overrides for a moduleId.
+ *
+ * This mutates the `runtime_module` patch map only; provider overrides still take precedence.
+ */
+declare const setTraitConvergeOverride: (runtime: ManagedRuntime.ManagedRuntime<any, never>, moduleId: string, overrides: StateTransactionTraitConvergeOverrides | undefined) => void;
+/**
+ * Hot-switch ConcurrencyPolicy patch for a moduleId.
+ *
+ * This mutates the `runtime_module` patch map only; provider overrides still take precedence.
+ */
+declare const setConcurrencyPolicyOverride: (runtime: ManagedRuntime.ManagedRuntime<any, never>, moduleId: string, patch: ConcurrencyPolicyPatch | undefined) => void;
+/**
+ * Apply a transaction snapshot for time-travel replay (dev/test).
+ *
+ * - `moduleId` / `instanceId` match Debug events.
+ * - `mode`: `before` replays pre-transaction; `after` replays post-commit.
+ *
+ * No-op if the runtime/instance cannot be resolved.
+ */
+declare const applyTransactionSnapshot: (moduleId: string, instanceId: string, txnId: string, mode: "before" | "after") => Effect.Effect<void, never, any>;
+
+type Runtime_BootError = BootError;
+declare const Runtime_BootError: typeof BootError;
+type Runtime_DevtoolsRuntimeOptions = DevtoolsRuntimeOptions;
+type Runtime_DisposeError = DisposeError;
+declare const Runtime_DisposeError: typeof DisposeError;
+type Runtime_DisposeTimeoutError = DisposeTimeoutError;
+declare const Runtime_DisposeTimeoutError: typeof DisposeTimeoutError;
+type Runtime_MainError = MainError;
+declare const Runtime_MainError: typeof MainError;
+type Runtime_OpenProgramOptions = OpenProgramOptions;
+type Runtime_ProgramIdentity = ProgramIdentity;
+type Runtime_ProgramRunContext<Sh extends AnyModuleShape> = ProgramRunContext<Sh>;
+type Runtime_ProgramRunnerErrorTag = ProgramRunnerErrorTag;
+type Runtime_ReadQueryFallbackReason = ReadQueryFallbackReason;
+type Runtime_RunProgramOptions<Args = unknown> = RunProgramOptions<Args>;
+type Runtime_RuntimeOptions = RuntimeOptions;
+type Runtime_RuntimeReadQueryOptions = RuntimeReadQueryOptions;
+type Runtime_RuntimeReadQueryStrictGateOptions = RuntimeReadQueryStrictGateOptions;
+type Runtime_RuntimeStateTransactionOptions = RuntimeStateTransactionOptions;
+declare const Runtime_applyTransactionSnapshot: typeof applyTransactionSnapshot;
+declare const Runtime_concurrencyPolicyOverridesLayer: typeof concurrencyPolicyOverridesLayer;
+declare const Runtime_make: typeof make;
+declare const Runtime_openProgram: typeof openProgram;
+declare const Runtime_runProgram: typeof runProgram;
+declare const Runtime_setConcurrencyPolicyOverride: typeof setConcurrencyPolicyOverride;
+declare const Runtime_setTraitConvergeOverride: typeof setTraitConvergeOverride;
+declare const Runtime_stateTransactionOverridesLayer: typeof stateTransactionOverridesLayer;
+declare namespace Runtime {
+  export { Runtime_BootError as BootError, type Runtime_DevtoolsRuntimeOptions as DevtoolsRuntimeOptions, Runtime_DisposeError as DisposeError, Runtime_DisposeTimeoutError as DisposeTimeoutError, Runtime_MainError as MainError, type Runtime_OpenProgramOptions as OpenProgramOptions, type Runtime_ProgramIdentity as ProgramIdentity, type Runtime_ProgramRunContext as ProgramRunContext, type Runtime_ProgramRunnerErrorTag as ProgramRunnerErrorTag, type Runtime_ReadQueryFallbackReason as ReadQueryFallbackReason, type Runtime_RunProgramOptions as RunProgramOptions, type Runtime_RuntimeOptions as RuntimeOptions, type Runtime_RuntimeReadQueryOptions as RuntimeReadQueryOptions, type Runtime_RuntimeReadQueryStrictGateOptions as RuntimeReadQueryStrictGateOptions, type Runtime_RuntimeStateTransactionOptions as RuntimeStateTransactionOptions, Runtime_applyTransactionSnapshot as applyTransactionSnapshot, Runtime_concurrencyPolicyOverridesLayer as concurrencyPolicyOverridesLayer, Runtime_make as make, Runtime_openProgram as openProgram, Runtime_runProgram as runProgram, Runtime_setConcurrencyPolicyOverride as setConcurrencyPolicyOverride, Runtime_setTraitConvergeOverride as setTraitConvergeOverride, Runtime_stateTransactionOverridesLayer as stateTransactionOverridesLayer };
+}
+
+export { BootError as B, type DevtoolsRuntimeOptions as D, MainError as M, type OpenProgramOptions as O, type ProgramRunContext as P, Runtime as R, type RunProgramOptions as a, type RuntimeStateTransactionOptions as b, type ReadQueryFallbackReason as c, type RuntimeReadQueryStrictGateOptions as d, type RuntimeReadQueryOptions as e, type RuntimeOptions as f, concurrencyPolicyOverridesLayer as g, setTraitConvergeOverride as h, setConcurrencyPolicyOverride as i, applyTransactionSnapshot as j, DisposeError as k, DisposeTimeoutError as l, make as m, type ProgramIdentity as n, openProgram as o, type ProgramRunnerErrorTag as p, runProgram as r, stateTransactionOverridesLayer as s };