@logixjs/core 0.0.1 → 1.0.0

package/dist/index.d.ts

@@ -1,45 +1,172 @@
-export { A as AnyModule, D as DevSource, H as HandleExtendFn, L as LogicUnitOptions, g as MakeExtendDef, j as Manage, M as Module, d as ModuleDef, c as ModuleDescriptor, a as ModuleDev, b as MountedLogicUnitSummary, R as Reducer, S as Shape, f as descriptor, h as hasImpl, i as is, m as make, e as unwrapImpl, u as unwrapTag } from './Module-DnzluX2J.js';
-export { M as ModuleTag } from './ModuleTag-C8FHY_sY.js';
-import { C as ConcurrencyLimit, S as StateTransactionInstrumentation, a as StatePatchPath, P as PatchReason, D as DirtyAllReason, b as DirtySet, F as FieldPath, c as FieldPathId, n as normalizeFieldPath } from './module-k7m3txak.js';
-export { p as ActionOf, q as ActionsFromMap, h as AnyModuleShape, A as AnySchema, B as BoundApi, e as ConcurrencyPolicy, f as ConcurrencyPolicyOverrides, g as ConcurrencyPolicyPatch, m as ModuleHandle, k as ModuleImpl, j as ModuleLogic, l as ModuleRuntime, d as ModuleRuntimeTag, i as ModuleShape, M as ModuleTagType, r as MutatorsFromMap, R as ReducersFromMap, v as StateChangeWithMeta, u as StateCommitMeta, s as StateCommitMode, t as StateCommitPriority, o as StateOf } from './module-k7m3txak.js';
-export { S as State } from './State-CU50R26M.js';
-export { A as Actions } from './Actions-AsQ07yTP.js';
-export { A as Action } from './Action-mqVvtEHt.js';
-export { L as Logic } from './Logic-BRjEMr-W.js';
-export { B as Bound } from './Bound-BN1DQ_lM.js';
-export { L as Link } from './Link-Db7975nU.js';
-export { P as Process } from './Process-CM9xbMdP.js';
-export { H as Handle } from './Handle-D_cLW1Z3.js';
-import { R as RuntimeInternalsResolvedConcurrencyPolicy, I as ImportsScope } from './Flow-BhpjE22E.js';
-export { F as Flow } from './Flow-BhpjE22E.js';
-export { M as MatchBuilder } from './MatchBuilder-0QOc-nlU.js';
-export { R as ReadQuery } from './ReadQuery-BlMwhe-F.js';
-export { S as StateTrait } from './StateTrait-BGsZghTz.js';
-export { T as TraitLifecycle } from './TraitLifecycle-LdIWmKlg.js';
-export { R as Resource } from './Resource-Dy1xD_DG.js';
-export { R as Runtime } from './Runtime-CtyzZG4i.js';
-export { K as Kernel } from './Kernel-CnGE1Fyk.js';
-export { S as ScopeRegistry } from './ScopeRegistry-D1owDNSm.js';
-export { R as Root } from './Root-7ADUMk4t.js';
+export { n as ActionSchemaOf, l as ActionTokenMap, m as ActionUnionOf, A as AnyModule, D as DevSource, H as HandleExtendFn, L as LogicUnitOptions, k as MakeExtendDef, p as Manage, M as Module, f as ModuleDef, c as ModuleDescriptor, a as ModuleDev, e as ModuleLogicApi, d as ModuleSelfHandleEffect, b as MountedLogicUnitSummary, R as Reducer, S as Shape, j as descriptor, h as hasImpl, i as is, o as make, g as unwrapImpl, u as unwrapTag } from './Module-B_Cntyms.js';
+export { M as ModuleTag } from './ModuleTag-CGho_InD.js';
+import { S as StateCommitPriority, a as StateCommitMeta, b as SchedulingPolicyLimit, c as StateTransactionInstrumentation, d as StatePatchPath, P as PatchReason, D as DirtyAllReason, e as DirtySet, F as FieldPath, f as FieldPathId, n as normalizeFieldPath } from './module-Zd1Gn-Nj.js';
+export { E as ActionForTag, w as ActionOf, x as ActionsFromMap, o as AnyModuleShape, A as AnySchema, B as BoundApi, J as BoundApiDispatchApi, I as BoundApiDispatchersApi, K as BoundApiLifecycleApi, Q as BoundApiReducerApi, G as BoundApiRootApi, H as BoundApiStateApi, O as BoundApiTraitsApi, N as BoundApiUseApi, C as ConcurrencyLimit, k as ConcurrencyPolicy, l as ConcurrencyPolicyOverrides, m as ConcurrencyPolicyPatch, z as DispatchEffect, L as LogicEffect, u as ModuleHandle, r as ModuleImpl, q as ModuleLogic, s as ModuleRuntime, t as ModuleRuntimeOfShape, g as ModuleRuntimeTag, p as ModuleShape, M as ModuleTagType, y as MutatorsFromMap, V as ReadonlySubscriptionRef, R as ReducersFromMap, h as SchedulingPolicySurface, i as SchedulingPolicySurfaceOverrides, j as SchedulingPolicySurfacePatch, U as StateChangeWithMeta, T as StateCommitMode, v as StateOf } from './module-Zd1Gn-Nj.js';
+export { S as State } from './State-rNFsFPTl.js';
+export { A as Actions } from './Actions-Dicm7jdc.js';
+export { A as Action } from './Action-DYl88bwj.js';
+export { L as Logic } from './Logic-DKg7ghGy.js';
+export { B as Bound } from './Bound-1OJLzVIS.js';
+export { L as Link } from './Link-CUM0yUCH.js';
+export { P as Process } from './Process-Cyf6VNDR.js';
+export { H as Handle } from './Handle-Bo6cAFut.js';
+import { R as RuntimeInternalsResolvedConcurrencyPolicy, I as ImportsScope } from './Flow-DIVDxz7R.js';
+export { F as Flow } from './Flow-DIVDxz7R.js';
+export { W as Workflow } from './Workflow-C_OWr4dV.js';
+export { M as MatchBuilder } from './MatchBuilder-CsW5jgrL.js';
+export { R as ReadQuery } from './ReadQuery-C_or5nLC.js';
+export { E as ExternalStore } from './ExternalStore-DqJKKRJ4.js';
+export { S as StateTrait } from './StateTrait-CijdwNb6.js';
+export { T as TraitLifecycle } from './TraitLifecycle-Cvo94uDB.js';
+export { R as Resource } from './Resource-pKvQQ4x5.js';
+export { R as Runtime } from './Runtime-CRmvwK4I.js';
+export { K as Kernel } from './Kernel-D9guNwRL.js';
+export { S as ScopeRegistry } from './ScopeRegistry-BhYzqWri.js';
+export { R as Root } from './Root-CCVuFHB6.js';
 export { E as Env } from './Env-DuJ6JrU2.js';
-export { D as Debug, z as DebugLayerOptions, y as DebugMode, d as DevtoolsHubOptions, c as DevtoolsSnapshot, b as DiagnosticsLevel, E as Event, M as ModuleRuntimeCounter, I as ModuleTraitsDebug, J as ModuleTraitsFinalItem, P as PrettyLoggerOptions, r as RingBufferSink, R as RuntimeDebugEventRef, a as Sink, S as SnapshotToken, T as TraitConvergeDiagnosticsSamplingConfig, F as appendSinks, f as clearDevtoolsEvents, G as devtoolsHubLayer, o as diagnosticsLevel, n as exportEvidencePackage, h as getDevtoolsRunId, e as getDevtoolsSnapshot, g as getDevtoolsSnapshotToken, m as getInstanceLabel, O as getModuleFinalTraits, K as getModuleTraits, L as getModuleTraitsById, N as getModuleTraitsSnapshot, i as internal, q as isDevtoolsEnabled, A as layer, u as makeModuleRuntimeCounterSink, v as makeRingBufferSink, x as noopLayer, w as record, C as replace, H as runtimeLabel, j as setDevtoolsRunId, l as setInstanceLabel, k as startDevtoolsRun, s as subscribeDevtoolsSnapshot, t as toRuntimeDebugEventRef, Q as traceLayer, p as traitConvergeDiagnosticsSampling, B as withPrettyLogger } from './Debug-B5q5Bkzx.js';
-export { P as Platform } from './Platform-CHX8o-U4.js';
-import { T as TriggerRef, B as BuildEnv, C as ConstructionGuard, R as ReplayLog, a as RuntimeHost } from './Observability-cY4kLn0S.js';
-export { O as Observability } from './Observability-cY4kLn0S.js';
-export { R as Reflection } from './Reflection-CQnKwPXj.js';
-import { P as ProcessScope, a as ProcessInstallation, b as ProcessInstanceStatus, c as ProcessControlRequest, d as ProcessPlatformEvent, e as ProcessEvent } from './protocol-g_1897M2.js';
-import { Context, Effect, Stream, Scope, Layer } from 'effect';
-import './action-DiMDD_0v.js';
+export { D as Debug, G as DebugLayerOptions, F as DebugMode, f as DevtoolsHubOptions, e as DevtoolsSnapshot, b as DiagnosticsLevel, c as DiagnosticsMaterialization, E as Event, M as ModuleRuntimeCounter, O as ModuleTraitsDebug, Q as ModuleTraitsFinalItem, P as PrettyLoggerOptions, y as RingBufferSink, R as RuntimeDebugEventRef, a as Sink, S as SnapshotToken, T as TraceMode, d as TraitConvergeDiagnosticsSamplingConfig, K as appendSinks, k as clearDevtoolsEvents, L as devtoolsHubLayer, r as diagnosticsLevel, u as diagnosticsMaterialization, q as exportEvidencePackage, l as getDevtoolsRunId, h as getDevtoolsSnapshot, j as getDevtoolsSnapshotByRuntimeLabel, g as getDevtoolsSnapshotToken, p as getInstanceLabel, X as getModuleFinalTraits, U as getModuleTraits, V as getModuleTraitsById, W as getModuleTraitsSnapshot, i as internal, x as isDevtoolsEnabled, H as layer, z as makeModuleRuntimeCounterSink, A as makeRingBufferSink, C as noopLayer, B as record, J as replace, N as runtimeLabel, m as setDevtoolsRunId, o as setInstanceLabel, n as startDevtoolsRun, s as subscribeDevtoolsSnapshot, t as toRuntimeDebugEventRef, Y as traceLayer, v as traceMode, w as traitConvergeDiagnosticsSampling, I as withPrettyLogger } from './Debug-DKrWP5H1.js';
+export { M as Middleware } from './Middleware-DS7CbTTN.js';
+export { P as Platform } from './Platform-W0Mefy_e.js';
+import { B as BuildEnv, C as ConstructionGuard, R as RuntimeHost } from './Observability-Bdhnx2Dv.js';
+export { O as Observability } from './Observability-Bdhnx2Dv.js';
+export { R as Reflection } from './Reflection-B2Xi1e4Q.js';
+import { P as ProcessScope, a as ProcessInstallation, b as ProcessInstanceStatus, c as ProcessControlRequest, d as ProcessPlatformEvent, e as ProcessEvent, T as TriggerRef, R as ReplayLog } from './ReadQuery-DXLzCE0E.js';
+import { ServiceMap, Effect, Stream, Scope, ManagedRuntime, Layer } from 'effect';
+import './action-BQxjPFEw.js';
 import 'mutative';
-import './Platform-C49Pv956.js';
-import './ReadQuery-SinbStGF.js';
-import './ir-DUOz6H-5.js';
+import './Platform-BV_0MW7g.js';
+import './ir-D-uqwL_4.js';
 import 'effect/Layer';
 import './EffectOp.js';
 import 'effect/Effect';
-import './Middleware.js';
-import 'effect/Context';
-import 'effect/FiberRef';
+import 'effect/ServiceMap';
+
+type Cancel = () => void;
+type HostScheduler = {
+    readonly nowMs: () => number;
+    readonly scheduleMicrotask: (cb: () => void) => void;
+    readonly scheduleMacrotask: (cb: () => void) => Cancel;
+    readonly scheduleAnimationFrame: (cb: () => void) => Cancel;
+    readonly scheduleTimeout: (ms: number, cb: () => void) => Cancel;
+};
+type DeterministicHostScheduler = HostScheduler & {
+    readonly flushMicrotasks: (options?: {
+        readonly max?: number;
+    }) => number;
+    readonly flushOneMacrotask: () => boolean;
+    readonly flushAll: (options?: {
+        readonly maxTurns?: number;
+    }) => {
+        readonly turns: number;
+        readonly ran: number;
+    };
+    readonly getQueueSize: () => {
+        readonly microtasks: number;
+        readonly macrotasks: number;
+    };
+};
+
+type ModuleInstanceKey = `${string}::${string}`;
+type TopicKey = string;
+interface RuntimeStoreModuleCommit {
+    readonly moduleId: string;
+    readonly instanceId: string;
+    readonly moduleInstanceKey: ModuleInstanceKey;
+    readonly state: unknown;
+    readonly meta: StateCommitMeta;
+    readonly opSeq?: number;
+    readonly schedulingPolicy?: {
+        readonly configScope: 'builtin' | 'runtime_default' | 'runtime_module' | 'provider';
+        readonly concurrencyLimit: number | 'unbounded';
+        readonly allowUnbounded: boolean;
+        readonly losslessBackpressureCapacity: number;
+        readonly pressureWarningThreshold: {
+            readonly backlogCount: number;
+            readonly backlogDurationMs: number;
+        };
+        readonly warningCooldownMs: number;
+        readonly resolvedAtTxnSeq: number;
+    };
+}
+interface RuntimeStorePendingDrain {
+    readonly modules: ReadonlyMap<ModuleInstanceKey, RuntimeStoreModuleCommit>;
+    readonly dirtyTopics: ReadonlyMap<TopicKey, StateCommitPriority>;
+}
+interface RuntimeStoreCommitResult {
+    readonly changedTopicListeners: ReadonlyArray<() => void>;
+}
+type RuntimeStoreListenerCallback = (listener: () => void) => void;
+interface RuntimeStore {
+    readonly getTickSeq: () => number;
+    readonly getModuleState: (moduleInstanceKey: ModuleInstanceKey) => unknown;
+    readonly getTopicVersion: (topicKey: TopicKey) => number;
+    readonly getTopicPriority: (topicKey: TopicKey) => StateCommitPriority;
+    readonly subscribeTopic: (topicKey: TopicKey, listener: () => void) => () => void;
+    readonly getTopicSubscriberCount: (topicKey: TopicKey) => number;
+    readonly getModuleSubscriberCount: (moduleInstanceKey: ModuleInstanceKey) => number;
+    readonly registerModuleInstance: (args: {
+        readonly moduleId: string;
+        readonly instanceId: string;
+        readonly moduleInstanceKey: ModuleInstanceKey;
+        readonly initialState: unknown;
+    }) => void;
+    readonly unregisterModuleInstance: (moduleInstanceKey: ModuleInstanceKey) => void;
+    readonly commitTick: (args: {
+        readonly tickSeq: number;
+        readonly accepted: RuntimeStorePendingDrain;
+        readonly onListener?: RuntimeStoreListenerCallback;
+    }) => RuntimeStoreCommitResult;
+    readonly dispose: () => void;
+}
+
+type TickDegradeReason = 'budget_steps' | 'cycle_detected' | 'unknown';
+interface TickSchedulerConfig {
+    /**
+     * Fixpoint step cap:
+     * - Steps count "work acceptance units" within a single tick, not time.
+     * - Exceeding the budget triggers a soft degrade (stable=false), deferring nonUrgent backlog to the next tick.
+     */
+    readonly maxSteps?: number;
+    /**
+     * Urgent safety cap:
+     * - Even urgent work may be cut when the system appears to be in a cycle (avoid freezing).
+     */
+    readonly urgentStepCap?: number;
+    /**
+     * Drain-round cap:
+     * - Bounds the number of drain rounds while capturing concurrent commits before committing the tick snapshot.
+     * - Exceeding the cap is treated as a cycle (stable=false, degradeReason=cycle_detected).
+     */
+    readonly maxDrainRounds?: number;
+    /**
+     * Microtask starvation protection threshold:
+     * - Counts consecutive ticks scheduled on microtask boundaries without yielding to host (best-effort).
+     * - Exceeding the limit forces the next tick to start on a macrotask boundary.
+     */
+    readonly microtaskChainDepthLimit?: number;
+    /**
+     * Optional degraded-tick telemetry (opt-in, sampled):
+     * - Runs even when diagnostics=off (Devtools disabled).
+     * - Intended for production health signals (frequency of stable=false / forced yield).
+     */
+    readonly telemetry?: TickSchedulerTelemetryConfig;
+}
+interface TickSchedulerTelemetryEvent {
+    readonly tickSeq: number;
+    readonly stable: boolean;
+    readonly degradeReason?: TickDegradeReason;
+    readonly forcedMacrotask?: boolean;
+    readonly scheduleReason?: TickScheduleReason;
+    readonly microtaskChainDepth?: number;
+    readonly deferredWorkCount?: number;
+}
+interface TickSchedulerTelemetryConfig {
+    /** Sample rate in [0, 1]. Default: 0 (disabled). */
+    readonly sampleRate?: number;
+    /** Called for ticks that are degraded (stable=false) and/or started on a forced macrotask boundary. */
+    readonly onTickDegraded?: (event: TickSchedulerTelemetryEvent) => void;
+}
+type TickScheduleReason = 'budget' | 'cycle_detected' | 'microtask_starvation' | 'unknown';
 
 type ProcessInstallMode = 'switch' | 'exhaust';
 interface ProcessRuntime {
@@ -59,7 +186,7 @@ interface ProcessRuntime {
     readonly events: Stream.Stream<ProcessEvent>;
     readonly getEventsSnapshot: () => Effect.Effect<ReadonlyArray<ProcessEvent>>;
 }
-declare const ProcessRuntimeTag_base: Context.TagClass<ProcessRuntimeTag, "@logixjs/core/ProcessRuntime", ProcessRuntime>;
+declare const ProcessRuntimeTag_base: ServiceMap.ServiceClass<ProcessRuntimeTag, "@logixjs/core/ProcessRuntime", ProcessRuntime>;
 declare class ProcessRuntimeTag extends ProcessRuntimeTag_base {
 }
 
@@ -77,9 +204,9 @@ interface ConcurrencyDiagnostics {
     }) => Effect.Effect<void>;
 }
 
-type ConcurrencyPolicyConfigScope = 'builtin' | 'runtime_default' | 'runtime_module' | 'provider';
-type ResolvedConcurrencyPolicy = {
-    readonly concurrencyLimit: ConcurrencyLimit;
+type SchedulingPolicySurfaceConfigScope = 'builtin' | 'runtime_default' | 'runtime_module' | 'provider';
+type ResolvedSchedulingPolicySurface = {
+    readonly concurrencyLimit: SchedulingPolicyLimit;
     readonly losslessBackpressureCapacity: number;
     readonly allowUnbounded: boolean;
     readonly pressureWarningThreshold: {
@@ -87,16 +214,17 @@ type ResolvedConcurrencyPolicy = {
         readonly backlogDurationMs: number;
     };
     readonly warningCooldownMs: number;
-    readonly configScope: ConcurrencyPolicyConfigScope;
+    readonly configScope: SchedulingPolicySurfaceConfigScope;
     /** Field-level scope for the effective concurrency limit. */
-    readonly concurrencyLimitScope: ConcurrencyPolicyConfigScope;
+    readonly concurrencyLimitScope: SchedulingPolicySurfaceConfigScope;
     /** The originally requested concurrency limit (for explaining the unbounded gate). */
-    readonly requestedConcurrencyLimit: ConcurrencyLimit;
+    readonly requestedConcurrencyLimit: SchedulingPolicyLimit;
     /** Field-level scope for the originally requested concurrency limit. */
-    readonly requestedConcurrencyLimitScope: ConcurrencyPolicyConfigScope;
+    readonly requestedConcurrencyLimitScope: SchedulingPolicySurfaceConfigScope;
     /** Field-level scope for allowUnbounded. */
-    readonly allowUnboundedScope: ConcurrencyPolicyConfigScope;
+    readonly allowUnboundedScope: SchedulingPolicySurfaceConfigScope;
 };
+type ResolvedConcurrencyPolicy = ResolvedSchedulingPolicySurface;
 
 type TxnLane = 'urgent' | 'nonUrgent';
 interface EnqueueTransaction {
@@ -128,6 +256,14 @@ declare const makeEnqueueTransaction: (args: {
  * - Exposes only minimal capabilities (ISP) to avoid leaking RuntimeInternals as a public dependency.
  */
 declare const getImportsScope: (runtime: object) => ImportsScope;
+declare const getRuntimeStore: (runtime: ManagedRuntime.ManagedRuntime<any, any>) => RuntimeStore;
+declare const getHostScheduler: (runtime: ManagedRuntime.ManagedRuntime<any, any>) => HostScheduler;
+
+declare const makeDeterministicHostScheduler: () => DeterministicHostScheduler;
+declare const hostSchedulerTestLayer: (scheduler: HostScheduler) => Layer.Layer<any, never, never>;
+declare const tickSchedulerTestLayer: (config?: TickSchedulerConfig) => Layer.Layer<any, never, never>;
+declare const __unsafeSetGlobalHostScheduler: (next: HostScheduler | undefined) => void;
+declare const tickServicesLayer: Layer.Layer<any, never, never>;
 declare const getStateTransactionInstrumentation: (runtime: object) => StateTransactionInstrumentation;
 declare const getRowIdStore: (runtime: object) => unknown;
 declare const getStateTraitListConfigs: (runtime: object) => ReadonlyArray<unknown>;
@@ -141,7 +277,7 @@ declare const runWithStateTransaction: <E, R>(runtime: object, origin: {
     readonly details?: unknown;
 }, body: () => Effect.Effect<void, E, R>) => Effect.Effect<void, E, R>;
 declare const applyTransactionSnapshot: (runtime: object, txnId: string, mode: "before" | "after") => Effect.Effect<void, never, any>;
-declare const withCurrentLinkId: (linkId: string) => <B, E, R>(use: Effect.Effect<B, E, R>) => Effect.Effect<B, E, R>;
+declare const withCurrentLinkId: <A, E, R>(effect: Effect.Effect<A, E, R>, linkId: string) => Effect.Effect<A, E, R>;
 /** 049: Exec VM (core-ng) switch: enable the Exec VM hot path within the current Effect scope. */
 declare const withExecVmMode: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
 /** 049: Exec VM (core-ng) switch: enable/disable the Exec VM hot path within the current runtime scope. */
@@ -163,33 +299,43 @@ declare const installProcess: <E, R>(process: Effect.Effect<void, E, R>, options
 
 declare const InternalContracts_BuildEnv: typeof BuildEnv;
 declare const InternalContracts_ConstructionGuard: typeof ConstructionGuard;
+type InternalContracts_DeterministicHostScheduler = DeterministicHostScheduler;
 declare const InternalContracts_DirtyAllReason: typeof DirtyAllReason;
 declare const InternalContracts_DirtySet: typeof DirtySet;
 declare const InternalContracts_FieldPath: typeof FieldPath;
 declare const InternalContracts_FieldPathId: typeof FieldPathId;
+type InternalContracts_HostScheduler = HostScheduler;
 declare const InternalContracts_ReplayLog: typeof ReplayLog;
 declare const InternalContracts_RuntimeHost: typeof RuntimeHost;
+type InternalContracts_TickSchedulerConfig = TickSchedulerConfig;
+declare const InternalContracts___unsafeSetGlobalHostScheduler: typeof __unsafeSetGlobalHostScheduler;
 declare const InternalContracts_applyTransactionSnapshot: typeof applyTransactionSnapshot;
 declare const InternalContracts_controlProcessInstance: typeof controlProcessInstance;
 declare const InternalContracts_deliverProcessPlatformEvent: typeof deliverProcessPlatformEvent;
 declare const InternalContracts_execVmModeLayer: typeof execVmModeLayer;
+declare const InternalContracts_getHostScheduler: typeof getHostScheduler;
 declare const InternalContracts_getImportsScope: typeof getImportsScope;
 declare const InternalContracts_getProcessEvents: typeof getProcessEvents;
 declare const InternalContracts_getProcessInstallations: typeof getProcessInstallations;
 declare const InternalContracts_getProcessInstanceStatus: typeof getProcessInstanceStatus;
 declare const InternalContracts_getRowIdStore: typeof getRowIdStore;
+declare const InternalContracts_getRuntimeStore: typeof getRuntimeStore;
 declare const InternalContracts_getStateTraitListConfigs: typeof getStateTraitListConfigs;
 declare const InternalContracts_getStateTransactionInstrumentation: typeof getStateTransactionInstrumentation;
+declare const InternalContracts_hostSchedulerTestLayer: typeof hostSchedulerTestLayer;
 declare const InternalContracts_installProcess: typeof installProcess;
+declare const InternalContracts_makeDeterministicHostScheduler: typeof makeDeterministicHostScheduler;
 declare const InternalContracts_makeEnqueueTransaction: typeof makeEnqueueTransaction;
 declare const InternalContracts_normalizeFieldPath: typeof normalizeFieldPath;
 declare const InternalContracts_recordStatePatch: typeof recordStatePatch;
 declare const InternalContracts_registerStateTraitProgram: typeof registerStateTraitProgram;
 declare const InternalContracts_runWithStateTransaction: typeof runWithStateTransaction;
+declare const InternalContracts_tickSchedulerTestLayer: typeof tickSchedulerTestLayer;
+declare const InternalContracts_tickServicesLayer: typeof tickServicesLayer;
 declare const InternalContracts_withCurrentLinkId: typeof withCurrentLinkId;
 declare const InternalContracts_withExecVmMode: typeof withExecVmMode;
 declare namespace InternalContracts {
-  export { InternalContracts_BuildEnv as BuildEnv, InternalContracts_ConstructionGuard as ConstructionGuard, InternalContracts_DirtyAllReason as DirtyAllReason, InternalContracts_DirtySet as DirtySet, InternalContracts_FieldPath as FieldPath, InternalContracts_FieldPathId as FieldPathId, InternalContracts_ReplayLog as ReplayLog, InternalContracts_RuntimeHost as RuntimeHost, InternalContracts_applyTransactionSnapshot as applyTransactionSnapshot, InternalContracts_controlProcessInstance as controlProcessInstance, InternalContracts_deliverProcessPlatformEvent as deliverProcessPlatformEvent, InternalContracts_execVmModeLayer as execVmModeLayer, InternalContracts_getImportsScope as getImportsScope, InternalContracts_getProcessEvents as getProcessEvents, InternalContracts_getProcessInstallations as getProcessInstallations, InternalContracts_getProcessInstanceStatus as getProcessInstanceStatus, InternalContracts_getRowIdStore as getRowIdStore, InternalContracts_getStateTraitListConfigs as getStateTraitListConfigs, InternalContracts_getStateTransactionInstrumentation as getStateTransactionInstrumentation, InternalContracts_installProcess as installProcess, InternalContracts_makeEnqueueTransaction as makeEnqueueTransaction, InternalContracts_normalizeFieldPath as normalizeFieldPath, InternalContracts_recordStatePatch as recordStatePatch, InternalContracts_registerStateTraitProgram as registerStateTraitProgram, InternalContracts_runWithStateTransaction as runWithStateTransaction, InternalContracts_withCurrentLinkId as withCurrentLinkId, InternalContracts_withExecVmMode as withExecVmMode };
+  export { InternalContracts_BuildEnv as BuildEnv, InternalContracts_ConstructionGuard as ConstructionGuard, type InternalContracts_DeterministicHostScheduler as DeterministicHostScheduler, InternalContracts_DirtyAllReason as DirtyAllReason, InternalContracts_DirtySet as DirtySet, InternalContracts_FieldPath as FieldPath, InternalContracts_FieldPathId as FieldPathId, type InternalContracts_HostScheduler as HostScheduler, InternalContracts_ReplayLog as ReplayLog, InternalContracts_RuntimeHost as RuntimeHost, type InternalContracts_TickSchedulerConfig as TickSchedulerConfig, InternalContracts___unsafeSetGlobalHostScheduler as __unsafeSetGlobalHostScheduler, InternalContracts_applyTransactionSnapshot as applyTransactionSnapshot, InternalContracts_controlProcessInstance as controlProcessInstance, InternalContracts_deliverProcessPlatformEvent as deliverProcessPlatformEvent, InternalContracts_execVmModeLayer as execVmModeLayer, InternalContracts_getHostScheduler as getHostScheduler, InternalContracts_getImportsScope as getImportsScope, InternalContracts_getProcessEvents as getProcessEvents, InternalContracts_getProcessInstallations as getProcessInstallations, InternalContracts_getProcessInstanceStatus as getProcessInstanceStatus, InternalContracts_getRowIdStore as getRowIdStore, InternalContracts_getRuntimeStore as getRuntimeStore, InternalContracts_getStateTraitListConfigs as getStateTraitListConfigs, InternalContracts_getStateTransactionInstrumentation as getStateTransactionInstrumentation, InternalContracts_hostSchedulerTestLayer as hostSchedulerTestLayer, InternalContracts_installProcess as installProcess, InternalContracts_makeDeterministicHostScheduler as makeDeterministicHostScheduler, InternalContracts_makeEnqueueTransaction as makeEnqueueTransaction, InternalContracts_normalizeFieldPath as normalizeFieldPath, InternalContracts_recordStatePatch as recordStatePatch, InternalContracts_registerStateTraitProgram as registerStateTraitProgram, InternalContracts_runWithStateTransaction as runWithStateTransaction, InternalContracts_tickSchedulerTestLayer as tickSchedulerTestLayer, InternalContracts_tickServicesLayer as tickServicesLayer, InternalContracts_withCurrentLinkId as withCurrentLinkId, InternalContracts_withExecVmMode as withExecVmMode };
 }
 
-export { ConcurrencyLimit, InternalContracts };
+export { InternalContracts, SchedulingPolicyLimit, StateCommitMeta, StateCommitPriority };