@raphy-js/raph 1.0.0-dev.2 → 1.0.1-dev.25

package/dist/debug/runtime/reactivity/disposal-sweep.utils.js

@@ -0,0 +1,42 @@
+function s(n, t, e) {
+  t._sweepDue = e, n.push(t), r(n, t, n.length - 1);
+}
+function w(n, t) {
+  const e = t._sweepSlot;
+  if (e < 0 || n[e] !== t)
+    return !1;
+  t._sweepSlot = -1;
+  const o = n.pop();
+  return o === t || (e !== 0 && o._sweepDue < n[e - 1 >> 1]._sweepDue ? r(n, o, e) : f(n, o, e)), !0;
+}
+function S(n, t) {
+  const e = n[0];
+  e._sweepDue = t, f(n, e, 0);
+}
+function r(n, t, e) {
+  const o = t._sweepDue;
+  for (; e !== 0; ) {
+    const i = e - 1 >> 1, p = n[i];
+    if (p._sweepDue <= o)
+      break;
+    n[e] = p, p._sweepSlot = e, e = i;
+  }
+  n[e] = t, t._sweepSlot = e;
+}
+function f(n, t, e) {
+  const o = n.length, i = t._sweepDue;
+  for (let p = e * 2 + 1; p < o; p = e * 2 + 1) {
+    const c = p + 1;
+    c < o && n[c]._sweepDue < n[p]._sweepDue && (p = c);
+    const _ = n[p];
+    if (_._sweepDue >= i)
+      break;
+    n[e] = _, _._sweepSlot = e, e = p;
+  }
+  n[e] = t, t._sweepSlot = e;
+}
+export {
+  w as dequeueSweeper,
+  s as enqueueSweeper,
+  S as postponeFirstSweeper
+};

package/dist/debug/runtime/reactivity/runtime-reactivity.types.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/debug/runtime/reactivity/runtime-reactivity.types.js

@@ -0,0 +1 @@
+

package/dist/entrypoints/machine-testing.d.ts

@@ -0,0 +1,2 @@
+export { createMachineCoverage, createManualMachineClock, enumerateMachinePaths, inspectMachine, } from '../machine/testing';
+export type { EnumeratedMachinePath, EnumerateMachinePathOptions, MachineCoverage, MachineCoverageReport, MachineInspection, ManualMachineClock, } from '../machine/testing';

package/dist/entrypoints/machine.d.ts

@@ -0,0 +1,5 @@
+export { defineMachine } from '../machine/compiler';
+export { getInitialSnapshot, transition } from '../machine/core';
+export { MachinePersistenceError, persistMachineSnapshot, restoreMachineSnapshot, } from '../machine/persistence';
+export { createMachine } from '../machine/runtime';
+export type { CreateMachineOptions, MachineActorRef, MachineBindings, MachineClock, MachineConfig, MachineEvent, MachineEventStatus, MachineGuard, MachineGuardArgs, MachineInstance, MachineInvokeConfig, MachineMigration, MachineModel, MachineOutput, MachineOutputArgs, MachineReducer, MachineReducerArgs, MachineResource, MachineResourceArgs, MachineSendResult, MachineSnapshot, MachineStateConfig, MachineStatus, MachineTask, MachineTaskArgs, MachineTransitionConfig, MachineTransitionDefinition, PersistedMachineSnapshot, } from '../machine/types';

package/dist/entrypoints/path.d.ts

@@ -0,0 +1,14 @@
+export type { DataPathParseOptions, PathScalar, PathSegment, PlainDataPath, } from '../path/data-path.types';
+export { DataPath } from '../path/DataPath';
+export type { DerivedCollectionByKeyStrategy, DerivedFilterByKeyStrategy, DerivedFullStrategy, DerivedStrategy, } from '../path/derived/derived-strategy.types';
+export { collectionByKey, filterByKey, full } from '../path/derived/derived-strategy.utils';
+export { RaphDerivedHandle } from '../path/derived/RaphDerivedHandle';
+export type { DerivedOptions } from '../path/derived/RaphDerivedHandle';
+export type { RaphMetaApi, RaphMetaEvents, RaphMetaMutationCause, RaphMetaMutationEvent, RaphMetaMutationKind, RaphMetaReadOptions, RaphMetaWatchCallback, RaphMetaWatchOptions, RaphMetaWriteOptions, } from '../path/meta/meta.types';
+export { RaphMeta } from '../path/meta/RaphMeta';
+export type { DataPathDef, PathApi, PathEvent, PathEvents, PathMutationKind, PathOptions, PathWatchCallback, } from '../path/path.types';
+export { RaphKernel } from '../path/RaphKernel';
+export type { RaphKernelOptions, RaphKernelRoot, RaphKernelRuntime, } from '../path/RaphKernel';
+export type { DataAdapter, DataObject, DefaultAdapterOptions, } from '../path/storage/data-adapter.types';
+export { DefaultDataAdapter } from '../path/storage/DefaultDataAdapter';
+export { PathStore } from '../path/storage/PathStore';

package/dist/entrypoints/reactivity.d.ts

@@ -0,0 +1 @@
+export * from '../reactivity/engine';

package/dist/entrypoints/runtime.d.ts

@@ -0,0 +1,18 @@
+export type { RaphDebugFrameLoopSnapshot, RaphDebugMachinesApi, RaphDebugOptions, RaphDebugOwnerSnapshot, RaphDebugSnapshot, RaphDebugStats, RaphDebugTraceApi, RaphDebugTreeNode, RaphMachineDebugSnapshot, RaphMachineDebugSummary, RaphRuntimeDebug, RaphTraceContextMode, RaphTraceEvent, RaphTraceGuardMode, RaphTraceKind, RaphTraceOptions, RaphTraceReadOptions, RaphTraceStatus, } from '../runtime/diagnostics/RaphDebug';
+export { RaphActionError, RaphCrossRuntimeError, RaphDisposedError, RaphPhaseProcessError, } from '../runtime/errors';
+export type { DepGraph } from '../runtime/ownership/parent-graph.types';
+export { parentGraph } from '../runtime/ownership/parentGraph';
+export { RaphEffectScope } from '../runtime/ownership/RaphEffectScope';
+export { RaphNode } from '../runtime/ownership/RaphNode';
+export type { NodeOptions } from '../runtime/ownership/RaphNode';
+export { RaphScope } from '../runtime/ownership/RaphScope';
+export { orderPhaseTasks } from '../runtime/phases/orderPhaseTasks';
+export { RaphSchedulerType } from '../runtime/phases/phase.types';
+export type { FrameLoopLease, RaphAggregateSource, RaphEffectGroup, RaphEffectGroupOptions, RaphEffectGroupRun, RaphEffectGroupSlot, RaphEffectInitialMode, RaphEffectOptions, RaphFrameContext, RaphPhase, RaphPhaseBatch, RaphPhaseBody, RaphPhaseEffect, RaphPhaseTask, RaphSchedulerMode, RaphStructureCause, RaphTaskOrderOptions, RaphWatchInclude, RaphWatchInitialMode, RaphWatchOptions, RaphWatchSource, RaphWorkCause, RaphWorkCauseKind, } from '../runtime/phases/phase.types';
+export { RaphRuntime } from '../runtime/RaphRuntime';
+export type { RaphRuntimeConfiguration, RaphRuntimeMeta, RaphRuntimeOptions, } from '../runtime/RaphRuntime';
+export { PathHandle } from '../runtime/reactivity/PathHandle';
+export type { RaphMetaSource } from '../runtime/reactivity/RaphMetaSource';
+export type { RaphMetaSourceOptions } from '../runtime/reactivity/RaphMetaSource';
+export type { RaphSelector, RaphSelectorOptions } from '../runtime/reactivity/RaphSelector';
+export type { RaphAggregate } from '../runtime/reactivity/RaphWorkGraph';

package/dist/index.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const p=require("./debug/path/data-adapter.cjs"),o=require("./debug/path/data-path.cjs"),r=require("./debug/path/derived-strategies.cjs"),t=require("./debug/path/RaphDerivedHandle.cjs"),h=require("./debug/path/RaphKernel.cjs"),u=require("./debug/path/RaphMeta.cjs"),a=require("./debug/runtime/errors.cjs"),i=require("./debug/runtime/parent-graph.cjs"),n=require("./debug/runtime/PathHandle.cjs"),R=require("./debug/runtime/phase.types.cjs"),d=require("./debug/runtime/RaphNode.cjs"),_=require("./debug/runtime/RaphRuntime.cjs"),s=require("./debug/runtime/RaphScope.cjs"),e=require("./debug/api/errors.cjs"),c=require("./debug/api/Raph.cjs");exports.DefaultDataAdapter=p.DefaultDataAdapter;exports.DataPath=o.DataPath;exports.collectionByKey=r.collectionByKey;exports.filterByKey=r.filterByKey;exports.full=r.full;exports.RaphDerivedHandle=t.RaphDerivedHandle;exports.RaphDerivedTargetWriteError=t.RaphDerivedTargetWriteError;exports.RaphKernel=h.RaphKernel;exports.RaphMeta=u.RaphMeta;exports.RaphActionError=a.RaphActionError;exports.RaphCrossRuntimeError=a.RaphCrossRuntimeError;exports.RaphDisposedError=a.RaphDisposedError;exports.parentGraph=i.parentGraph;exports.PathHandle=n.PathHandle;exports.RaphSchedulerType=R.RaphSchedulerType;exports.RaphNode=d.RaphNode;exports.RaphRuntime=_.RaphRuntime;exports.RaphScope=s.RaphScope;exports.RaphConfigurationError=e.RaphConfigurationError;exports.RaphDefaultRuntimeError=e.RaphDefaultRuntimeError;exports.RaphError=e.RaphError;exports.RaphModeError=e.RaphModeError;exports.Raph=c.Raph;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./debug/api/errors.cjs"),p=require("./debug/api/Raph.cjs"),i=require("./debug/api/RaphReactivityInstance.cjs"),r=require("./debug/runtime/errors.cjs"),o=require("./debug/runtime/ownership/parentGraph.cjs"),h=require("./debug/runtime/ownership/RaphEffectScope.cjs"),n=require("./debug/runtime/ownership/RaphNode.cjs"),s=require("./debug/runtime/ownership/RaphScope.cjs"),u=require("./debug/runtime/phases/orderPhaseTasks.cjs"),R=require("./debug/runtime/phases/phase.types.cjs"),d=require("./debug/runtime/RaphRuntime.cjs"),c=require("./debug/runtime/reactivity/PathHandle.cjs"),_=require("./debug/path/DataPath.cjs"),a=require("./debug/path/derived/derived-strategy.utils.cjs"),t=require("./debug/path/derived/RaphDerivedHandle.cjs"),l=require("./debug/path/meta/RaphMeta.cjs"),g=require("./debug/path/RaphKernel.cjs"),E=require("./debug/path/storage/DefaultDataAdapter.cjs");exports.RaphCapabilityError=e.RaphCapabilityError;exports.RaphConfigurationError=e.RaphConfigurationError;exports.RaphDefaultInstanceError=e.RaphDefaultInstanceError;exports.RaphError=e.RaphError;exports.RaphFacadeDisposedError=e.RaphFacadeDisposedError;exports.Raph=p.Raph;exports.RaphReactivityInstance=i.RaphReactivityInstance;exports.RaphActionError=r.RaphActionError;exports.RaphCrossRuntimeError=r.RaphCrossRuntimeError;exports.RaphDisposedError=r.RaphDisposedError;exports.RaphPhaseProcessError=r.RaphPhaseProcessError;exports.parentGraph=o.parentGraph;exports.RaphEffectScope=h.RaphEffectScope;exports.RaphNode=n.RaphNode;exports.RaphScope=s.RaphScope;exports.orderPhaseTasks=u.orderPhaseTasks;exports.RaphSchedulerType=R.RaphSchedulerType;exports.RaphRuntime=d.RaphRuntime;exports.PathHandle=c.PathHandle;exports.DataPath=_.DataPath;exports.collectionByKey=a.collectionByKey;exports.filterByKey=a.filterByKey;exports.full=a.full;exports.RaphDerivedHandle=t.RaphDerivedHandle;exports.RaphDerivedTargetWriteError=t.RaphDerivedTargetWriteError;exports.RaphMeta=l.RaphMeta;exports.RaphKernel=g.RaphKernel;exports.DefaultDataAdapter=E.DefaultDataAdapter;

package/dist/index.js

@@ -1,40 +1,48 @@
-import { DefaultDataAdapter as e } from "./debug/path/data-adapter.js";
-import { DataPath as t } from "./debug/path/data-path.js";
-import { collectionByKey as f, filterByKey as h, full as R } from "./debug/path/derived-strategies.js";
-import { RaphDerivedHandle as x, RaphDerivedTargetWriteError as i } from "./debug/path/RaphDerivedHandle.js";
-import { RaphKernel as n } from "./debug/path/RaphKernel.js";
-import { RaphMeta as u } from "./debug/path/RaphMeta.js";
-import { RaphActionError as D, RaphCrossRuntimeError as c, RaphDisposedError as y } from "./debug/runtime/errors.js";
-import { parentGraph as K } from "./debug/runtime/parent-graph.js";
-import { PathHandle as v } from "./debug/runtime/PathHandle.js";
-import { RaphSchedulerType as B } from "./debug/runtime/phase.types.js";
-import { RaphNode as H } from "./debug/runtime/RaphNode.js";
-import { RaphRuntime as P } from "./debug/runtime/RaphRuntime.js";
-import { RaphScope as T } from "./debug/runtime/RaphScope.js";
-import { RaphConfigurationError as N, RaphDefaultRuntimeError as W, RaphError as b, RaphModeError as j } from "./debug/api/errors.js";
-import { Raph as q } from "./debug/api/Raph.js";
+import { RaphCapabilityError as e, RaphConfigurationError as p, RaphDefaultInstanceError as a, RaphError as t, RaphFacadeDisposedError as h } from "./debug/api/errors.js";
+import { Raph as R } from "./debug/api/Raph.js";
+import { RaphReactivityInstance as x } from "./debug/api/RaphReactivityInstance.js";
+import { RaphActionError as n, RaphCrossRuntimeError as s, RaphDisposedError as c, RaphPhaseProcessError as l } from "./debug/runtime/errors.js";
+import { parentGraph as E } from "./debug/runtime/ownership/parentGraph.js";
+import { RaphEffectScope as u } from "./debug/runtime/ownership/RaphEffectScope.js";
+import { RaphNode as P } from "./debug/runtime/ownership/RaphNode.js";
+import { RaphScope as C } from "./debug/runtime/ownership/RaphScope.js";
+import { orderPhaseTasks as S } from "./debug/runtime/phases/orderPhaseTasks.js";
+import { RaphSchedulerType as g } from "./debug/runtime/phases/phase.types.js";
+import { RaphRuntime as B } from "./debug/runtime/RaphRuntime.js";
+import { PathHandle as I } from "./debug/runtime/reactivity/PathHandle.js";
+import { DataPath as k } from "./debug/path/DataPath.js";
+import { collectionByKey as G, filterByKey as M, full as N } from "./debug/path/derived/derived-strategy.utils.js";
+import { RaphDerivedHandle as j, RaphDerivedTargetWriteError as q } from "./debug/path/derived/RaphDerivedHandle.js";
+import { RaphMeta as z } from "./debug/path/meta/RaphMeta.js";
+import { RaphKernel as L } from "./debug/path/RaphKernel.js";
+import { DefaultDataAdapter as Q } from "./debug/path/storage/DefaultDataAdapter.js";
 export {
-  t as DataPath,
-  e as DefaultDataAdapter,
-  v as PathHandle,
-  q as Raph,
-  D as RaphActionError,
-  N as RaphConfigurationError,
-  c as RaphCrossRuntimeError,
-  W as RaphDefaultRuntimeError,
-  x as RaphDerivedHandle,
-  i as RaphDerivedTargetWriteError,
-  y as RaphDisposedError,
-  b as RaphError,
-  n as RaphKernel,
-  u as RaphMeta,
-  j as RaphModeError,
-  H as RaphNode,
-  P as RaphRuntime,
-  B as RaphSchedulerType,
-  T as RaphScope,
-  f as collectionByKey,
-  h as filterByKey,
-  R as full,
-  K as parentGraph
+  k as DataPath,
+  Q as DefaultDataAdapter,
+  I as PathHandle,
+  R as Raph,
+  n as RaphActionError,
+  e as RaphCapabilityError,
+  p as RaphConfigurationError,
+  s as RaphCrossRuntimeError,
+  a as RaphDefaultInstanceError,
+  j as RaphDerivedHandle,
+  q as RaphDerivedTargetWriteError,
+  c as RaphDisposedError,
+  u as RaphEffectScope,
+  t as RaphError,
+  h as RaphFacadeDisposedError,
+  L as RaphKernel,
+  z as RaphMeta,
+  P as RaphNode,
+  l as RaphPhaseProcessError,
+  x as RaphReactivityInstance,
+  B as RaphRuntime,
+  g as RaphSchedulerType,
+  C as RaphScope,
+  G as collectionByKey,
+  M as filterByKey,
+  N as full,
+  S as orderPhaseTasks,
+  E as parentGraph
 };

package/dist/machine/compiler.d.ts

@@ -0,0 +1,71 @@
+import { MachineConfig, MachineEvent, MachineGuardRef, MachineInvokeConfig, MachineMigration, MachineModel, MachineOutputRef, MachineReducerRef } from './types';
+export type CompiledStateKind = 'atomic' | 'compound' | 'final' | 'history' | 'parallel';
+export interface CompiledTransition {
+    readonly emit: readonly MachineOutputRef<unknown, MachineEvent, unknown>[];
+    readonly guard?: MachineGuardRef<unknown, MachineEvent, unknown>;
+    readonly index: number;
+    readonly raise?: MachineEvent | ((args: {
+        readonly context: Readonly<unknown>;
+        readonly event: MachineEvent;
+        readonly input: unknown;
+    }) => MachineEvent);
+    readonly reason?: string;
+    readonly reduce: readonly MachineReducerRef<unknown, MachineEvent, unknown>[];
+    readonly reenter: boolean;
+    readonly source: number;
+    readonly target?: number;
+}
+export interface CompiledInvoke {
+    readonly id: string;
+    readonly input?: MachineInvokeConfig<unknown, MachineEvent, unknown>['input'];
+    readonly onDone: readonly CompiledTransition[];
+    readonly onError: readonly CompiledTransition[];
+    readonly src: MachineInvokeConfig<unknown, MachineEvent, unknown>['src'];
+    readonly type: 'machine' | 'task';
+}
+export interface CompiledState {
+    readonly after: ReadonlyMap<string, readonly CompiledTransition[]>;
+    readonly always: readonly CompiledTransition[];
+    readonly children: readonly number[];
+    readonly depth: number;
+    readonly entry: readonly MachineOutputRef<unknown, MachineEvent, unknown>[];
+    readonly exit: readonly MachineOutputRef<unknown, MachineEvent, unknown>[];
+    readonly history: 'deep' | 'shallow';
+    readonly historyFallback?: number;
+    readonly id: number;
+    readonly initial?: number;
+    readonly invokes: readonly CompiledInvoke[];
+    readonly key: string;
+    readonly kind: CompiledStateKind;
+    readonly meta?: Readonly<Record<string, unknown>>;
+    readonly on: ReadonlyMap<string, readonly CompiledTransition[]>;
+    readonly onDone: readonly CompiledTransition[];
+    readonly output?: unknown | ((args: {
+        readonly context: Readonly<unknown>;
+        readonly event: MachineEvent;
+        readonly input: unknown;
+    }) => unknown);
+    readonly parent?: number;
+    readonly path: string;
+    readonly resources: readonly string[];
+    readonly tags: readonly string[];
+}
+export interface CompiledMachine {
+    readonly ancestry: readonly (readonly number[])[];
+    readonly context: MachineConfig<unknown, MachineEvent, unknown, unknown>['context'];
+    readonly eventIndexes: ReadonlyMap<string, number>;
+    readonly eventTypes: readonly string[];
+    readonly flat: boolean;
+    readonly flatDispatch?: readonly (readonly CompiledTransition[] | undefined)[];
+    readonly id: string;
+    readonly initial: number;
+    readonly migrations: ReadonlyMap<number, MachineMigration>;
+    readonly output?: MachineConfig<unknown, MachineEvent, unknown, unknown>['output'];
+    readonly pathToState: ReadonlyMap<string, number>;
+    readonly rootChildren: readonly number[];
+    readonly states: readonly CompiledState[];
+    readonly version: number;
+}
+export declare function defineMachine<Context, Event extends MachineEvent, Input = void, Output = unknown>(config: MachineConfig<Context, Event, Input, Output>): MachineModel<Context, Event, Input, Output>;
+/** @internal */
+export declare function getCompiledMachine(model: MachineModel<unknown, MachineEvent, unknown, unknown>): CompiledMachine;

package/dist/machine/core.d.ts

@@ -0,0 +1,50 @@
+import { CompiledMachine, CompiledTransition } from './compiler';
+import { MachineBindings, MachineEvent, MachineModel, MachineOutputRef, MachineSnapshot, PersistedMachineSnapshot } from './types';
+export interface MachineEvaluationHooks {
+    readonly guard?: (name: string, passed: boolean, context: Readonly<Record<string, unknown>> | undefined) => void;
+    readonly transition?: (details: {
+        readonly reason?: string;
+        readonly source: string;
+        readonly target?: string;
+    }) => void;
+}
+export interface MachineEffectPlan {
+    readonly entered: readonly number[];
+    readonly entryOutputs: readonly PlannedOutput[];
+    readonly event: MachineEvent;
+    readonly exited: readonly number[];
+    readonly exitOutputs: readonly PlannedOutput[];
+    readonly transitionOutputRefs?: readonly MachineOutputRef<unknown, MachineEvent, unknown>[];
+    readonly transitionOutputs: readonly PlannedOutput[];
+}
+export interface PlannedOutput {
+    readonly event: MachineEvent;
+    readonly ref: MachineOutputRef<unknown, MachineEvent, unknown>;
+}
+export interface MachineMacrostepResult<Context, Output> {
+    readonly changed: boolean;
+    readonly plan: MachineEffectPlan;
+    readonly snapshot: MachineSnapshot<Context, Output>;
+}
+export declare function getInitialSnapshot<Context, Event extends MachineEvent, Input, Output>(model: MachineModel<Context, Event, Input, Output>, input?: Input): MachineSnapshot<Context, Output>;
+export declare function transition<Context, Event extends MachineEvent, Input, Output>(model: MachineModel<Context, Event, Input, Output>, snapshot: MachineSnapshot<Context, Output>, event: Event, bindings?: MachineBindings<Context, Event, Input>, hooks?: MachineEvaluationHooks): MachineSnapshot<Context, Output>;
+/** @internal */
+export declare function assertMachineSnapshot(model: MachineModel<unknown, MachineEvent, unknown, unknown>, snapshot: MachineSnapshot<unknown>): void;
+/** Creates a terminal snapshot while retaining model/input provenance. @internal */
+export declare function stopMachineSnapshot<Context, Event extends MachineEvent, Input, Output>(model: MachineModel<Context, Event, Input, Output>, snapshot: MachineSnapshot<Context, Output>): MachineSnapshot<Context, Output>;
+/** @internal */
+export declare function createInitialSnapshot<Context, Event extends MachineEvent, Input, Output>(model: MachineModel<Context, Event, Input, Output>, input: Input, bindings: MachineBindings<Context, Event, Input> | undefined, hooks?: MachineEvaluationHooks): MachineMacrostepResult<Context, Output>;
+/** @internal */
+export declare function runMacrostep<Context, Event extends MachineEvent, Input, Output>(model: MachineModel<Context, Event, Input, Output>, snapshot: MachineSnapshot<Context, Output>, event: Event, bindings: MachineBindings<Context, Event, Input> | undefined, input: Input, hooks?: MachineEvaluationHooks, compiledInput?: CompiledMachine, stabilizeOnly?: boolean, initialRaised?: readonly MachineEvent[]): MachineMacrostepResult<Context, Output>;
+/**
+ * Выполняет macrostep после проверки события владеющим Runtime.
+ *
+ * @internal
+ */
+export declare function runValidatedMacrostep<Context, Event extends MachineEvent, Input, Output>(model: MachineModel<Context, Event, Input, Output>, snapshot: MachineSnapshot<Context, Output>, event: Event, bindings: MachineBindings<Context, Event, Input> | undefined, input: Input, hooks?: MachineEvaluationHooks, compiledInput?: CompiledMachine, flatEventId?: number, stabilizeOnly?: boolean, initialRaised?: readonly MachineEvent[]): MachineMacrostepResult<Context, Output>;
+/** @internal */
+export declare function runExplicitTransitions<Context, Event extends MachineEvent, Input, Output>(model: MachineModel<Context, Event, Input, Output>, snapshot: MachineSnapshot<Context, Output>, event: Event, transitions: readonly CompiledTransition[], bindings: MachineBindings<Context, Event, Input> | undefined, input: Input, hooks?: MachineEvaluationHooks): MachineMacrostepResult<Context, Output>;
+/** Создаёт validated immutable live snapshot без повторения entry outputs. @internal */
+export declare function hydrateSnapshot<Context, Event extends MachineEvent, Input, Output>(model: MachineModel<Context, Event, Input, Output>, persisted: PersistedMachineSnapshot<Context, Output>, input: Input): MachineSnapshot<Context, Output>;
+/** @internal */
+export declare function canHandleEvent(compiled: CompiledMachine, active: readonly string[], eventType: string): boolean;

package/dist/machine/persistence.d.ts

@@ -0,0 +1,5 @@
+import { MachineEvent, MachineModel, MachineSnapshot, PersistedMachineSnapshot } from './types';
+export declare class MachinePersistenceError extends Error {
+}
+export declare function persistMachineSnapshot<Context, Event extends MachineEvent, Input, Output>(model: MachineModel<Context, Event, Input, Output>, snapshot: MachineSnapshot<Context, Output>): PersistedMachineSnapshot<Context, Output>;
+export declare function restoreMachineSnapshot<Context, Event extends MachineEvent, Input, Output>(model: MachineModel<Context, Event, Input, Output>, persisted: PersistedMachineSnapshot<unknown, unknown>, input?: Input): MachineSnapshot<Context, Output>;

package/dist/machine/runtime.d.ts

@@ -0,0 +1,4 @@
+import { RaphNode } from '../runtime/ownership/RaphNode';
+import { CreateMachineOptions, MachineBindings, MachineEvent, MachineInstance, MachineModel } from './types';
+import { RaphScope } from '../runtime/ownership/RaphScope';
+export declare function createMachine<Context, Event extends MachineEvent, Input = void, Output = unknown>(owner: RaphNode | RaphScope, model: MachineModel<Context, Event, Input, Output>, bindings?: MachineBindings<Context, Event, Input>, options?: CreateMachineOptions<Context, Input, Output>): MachineInstance<Context, Event, Input, Output>;

package/dist/machine/testing.d.ts

@@ -0,0 +1,43 @@
+import { MachineBindings, MachineClock, MachineEvent, MachineModel, MachineSnapshot } from './types';
+export interface MachineInspection {
+    readonly deadEnds: readonly string[];
+    readonly inconsistencies: readonly string[];
+    readonly reachable: readonly string[];
+    readonly unreachable: readonly string[];
+    readonly valid: boolean;
+}
+export interface EnumeratedMachinePath<Context, Output> {
+    readonly events: readonly MachineEvent[];
+    readonly snapshot: MachineSnapshot<Context, Output>;
+}
+export interface EnumerateMachinePathOptions<Context, Event extends MachineEvent, Input> {
+    readonly bindings?: MachineBindings<Context, Event, Input>;
+    readonly events?: readonly Event[];
+    readonly input?: Input;
+    readonly maxDepth?: number;
+    readonly maxPaths?: number;
+}
+export interface MachineCoverageReport {
+    readonly guards: Readonly<Record<string, Readonly<{
+        failed: number;
+        passed: number;
+    }>>>;
+    readonly states: Readonly<Record<string, number>>;
+    readonly transitions: Readonly<Record<string, number>>;
+}
+export interface MachineCoverage {
+    guard: (name: string, passed: boolean) => void;
+    record: <Context, Output>(before: MachineSnapshot<Context, Output>, event: MachineEvent, after: MachineSnapshot<Context, Output>) => void;
+    report: () => MachineCoverageReport;
+    reset: () => void;
+    transition: <Context, Event extends MachineEvent, Input, Output>(model: MachineModel<Context, Event, Input, Output>, before: MachineSnapshot<Context, Output>, event: Event, bindings?: MachineBindings<Context, Event, Input>) => MachineSnapshot<Context, Output>;
+}
+export interface ManualMachineClock extends MachineClock {
+    readonly pending: number;
+    advance: (duration: number) => void;
+    runAll: () => void;
+}
+export declare function inspectMachine<Context, Event extends MachineEvent, Input, Output>(model: MachineModel<Context, Event, Input, Output>): MachineInspection;
+export declare function enumerateMachinePaths<Context, Event extends MachineEvent, Input, Output>(model: MachineModel<Context, Event, Input, Output>, options?: EnumerateMachinePathOptions<Context, Event, Input>): readonly EnumeratedMachinePath<Context, Output>[];
+export declare function createMachineCoverage(): MachineCoverage;
+export declare function createManualMachineClock(initialNow?: number): ManualMachineClock;

package/dist/machine/types.d.ts

@@ -0,0 +1,155 @@
+import { Disposer, ReadonlySignal } from '../reactivity/types';
+import { RaphNode } from '../runtime/ownership/RaphNode';
+import { RaphScope } from '../runtime/ownership/RaphScope';
+export interface MachineEvent {
+    readonly type: string;
+}
+export type MachineStatus = 'active' | 'done' | 'stopped';
+export type MachineEventStatus = 'ignored' | 'queued' | 'transitioned';
+export interface MachineSnapshot<Context, Output = unknown> {
+    readonly active: readonly string[];
+    readonly context: Readonly<Context>;
+    readonly history: Readonly<Record<string, readonly string[]>>;
+    readonly output?: Output;
+    readonly revision: number;
+    readonly status: MachineStatus;
+}
+export interface MachineGuardArgs<Context, Event extends MachineEvent, Input> {
+    readonly context: Readonly<Context>;
+    readonly event: Event;
+    readonly input: Input;
+}
+export interface MachineReducerArgs<Context, Event extends MachineEvent, Input> extends MachineGuardArgs<Context, Event, Input> {
+}
+export interface MachineOutputArgs<Context, Event extends MachineEvent, Input> extends MachineGuardArgs<Context, Event, Input> {
+    readonly snapshot: MachineSnapshot<Context>;
+}
+export type MachineGuard<Context, Event extends MachineEvent, Input> = (args: MachineGuardArgs<Context, Event, Input>) => boolean;
+export type MachineReducer<Context, Event extends MachineEvent, Input> = (args: MachineReducerArgs<Context, Event, Input>) => Context;
+export type MachineOutput<Context, Event extends MachineEvent, Input> = (args: MachineOutputArgs<Context, Event, Input>) => void;
+export type MachineGuardRef<Context, Event extends MachineEvent, Input> = MachineGuard<Context, Event, Input> | string;
+export type MachineReducerRef<Context, Event extends MachineEvent, Input> = MachineReducer<Context, Event, Input> | string;
+export type MachineOutputRef<Context, Event extends MachineEvent, Input> = MachineOutput<Context, Event, Input> | string;
+export interface MachineTransitionConfig<Context, Event extends MachineEvent, Input> {
+    readonly emit?: MachineOutputRef<Context, Event, Input> | readonly MachineOutputRef<Context, Event, Input>[];
+    readonly guard?: MachineGuardRef<Context, Event, Input>;
+    readonly raise?: Event | ((args: MachineReducerArgs<Context, Event, Input>) => Event);
+    readonly reason?: string;
+    readonly reduce?: MachineReducerRef<Context, Event, Input> | readonly MachineReducerRef<Context, Event, Input>[];
+    readonly reenter?: boolean;
+    readonly target?: string;
+}
+export type MachineTransitionDefinition<Context, Event extends MachineEvent, Input> = MachineTransitionConfig<Context, Event, Input> | readonly MachineTransitionConfig<Context, Event, Input>[] | string;
+export interface MachineInvokeConfig<Context, Event extends MachineEvent, Input> {
+    readonly id?: string;
+    readonly input?: unknown | ((args: MachineGuardArgs<Context, Event, Input>) => unknown);
+    readonly onDone?: MachineTransitionDefinition<Context, Event, Input>;
+    readonly onError?: MachineTransitionDefinition<Context, Event, Input>;
+    readonly src: string | MachineModel<unknown, MachineEvent, unknown, unknown>;
+    readonly type?: 'machine' | 'task';
+}
+export interface MachineStateConfig<Context, Event extends MachineEvent, Input, Output> {
+    readonly after?: Readonly<Record<string, MachineTransitionDefinition<Context, Event, Input>>>;
+    readonly always?: MachineTransitionDefinition<Context, Event, Input>;
+    readonly entry?: MachineOutputRef<Context, Event, Input> | readonly MachineOutputRef<Context, Event, Input>[];
+    readonly exit?: MachineOutputRef<Context, Event, Input> | readonly MachineOutputRef<Context, Event, Input>[];
+    readonly history?: 'deep' | 'shallow';
+    readonly initial?: string;
+    readonly invoke?: MachineInvokeConfig<Context, Event, Input> | readonly MachineInvokeConfig<Context, Event, Input>[];
+    readonly meta?: Readonly<Record<string, unknown>>;
+    readonly on?: Readonly<Partial<Record<Event['type'], MachineTransitionDefinition<Context, Event, Input>>>> | Readonly<Record<string, MachineTransitionDefinition<Context, Event, Input>>>;
+    readonly onDone?: MachineTransitionDefinition<Context, Event, Input>;
+    readonly output?: Output | ((args: MachineGuardArgs<Context, Event, Input>) => Output);
+    readonly resources?: string | readonly string[];
+    readonly states?: Readonly<Record<string, MachineStateConfig<Context, Event, Input, Output>>>;
+    readonly tags?: string | readonly string[];
+    readonly target?: string;
+    readonly type?: 'atomic' | 'compound' | 'final' | 'history' | 'parallel';
+}
+export interface PersistedMachineSnapshot<Context = unknown, Output = unknown> {
+    readonly active: readonly string[];
+    readonly context: Context;
+    readonly history: Readonly<Record<string, readonly string[]>>;
+    readonly modelId: string;
+    readonly output?: Output;
+    readonly revision: number;
+    readonly status: MachineStatus;
+    readonly version: number;
+}
+export type MachineMigration = (snapshot: PersistedMachineSnapshot) => PersistedMachineSnapshot;
+export interface MachineConfig<Context, Event extends MachineEvent, Input, Output> {
+    readonly context: Context | ((input: Input) => Context);
+    readonly id: string;
+    readonly initial: string;
+    readonly migrations?: Readonly<Record<number, MachineMigration>>;
+    readonly output?: Output | ((args: MachineGuardArgs<Context, Event, Input>) => Output);
+    readonly states: Readonly<Record<string, MachineStateConfig<Context, Event, Input, Output>>>;
+    readonly version?: number;
+}
+declare const MACHINE_MODEL_TYPES: unique symbol;
+export interface MachineModel<Context, Event extends MachineEvent, Input, Output> {
+    readonly id: string;
+    readonly version: number;
+    readonly [MACHINE_MODEL_TYPES]?: {
+        readonly context: Context;
+        readonly event: Event;
+        readonly input: Input;
+        readonly output: Output;
+    };
+}
+export interface MachineClock {
+    clearTimeout: (handle: unknown) => void;
+    now: () => number;
+    setTimeout: (callback: () => void, delay: number) => unknown;
+}
+export interface MachineTaskArgs<Context, Event extends MachineEvent, Input> extends MachineGuardArgs<Context, Event, Input> {
+    readonly send: (event: Event) => void;
+    readonly signal: AbortSignal;
+}
+export type MachineTask<Context, Event extends MachineEvent, Input> = (args: MachineTaskArgs<Context, Event, Input>) => unknown | Promise<unknown>;
+export interface MachineResourceArgs<Context, Event extends MachineEvent, Input> extends MachineOutputArgs<Context, Event, Input> {
+    readonly owner: RaphNode | RaphScope;
+    readonly signal: AbortSignal;
+}
+export type MachineResource<Context, Event extends MachineEvent, Input> = (args: MachineResourceArgs<Context, Event, Input>) => void | Disposer;
+export interface MachineBindings<Context, Event extends MachineEvent, Input> {
+    readonly actors?: Readonly<Record<string, MachineModel<unknown, MachineEvent, unknown, unknown>>>;
+    readonly delays?: Readonly<Record<string, number | ((args: MachineGuardArgs<Context, Event, Input>) => number)>>;
+    readonly guards?: Readonly<Record<string, MachineGuard<Context, Event, Input>>>;
+    readonly outputs?: Readonly<Record<string, MachineOutput<Context, Event, Input>>>;
+    readonly reducers?: Readonly<Record<string, MachineReducer<Context, Event, Input>>>;
+    readonly resources?: Readonly<Record<string, MachineResource<Context, Event, Input>>>;
+    readonly tasks?: Readonly<Record<string, MachineTask<Context, Event, Input>>>;
+}
+export interface CreateMachineOptions<Context, Input, Output> {
+    readonly clock?: MachineClock;
+    readonly errorPolicy?: 'ignore' | 'stop' | 'throw';
+    readonly id?: string;
+    readonly input?: Input;
+    readonly parentId?: string;
+    readonly persisted?: PersistedMachineSnapshot<Context, Output>;
+}
+export interface MachineSendResult<Context, Output> {
+    readonly snapshot: MachineSnapshot<Context, Output>;
+    readonly status: MachineEventStatus;
+}
+export interface MachineActorRef<Event extends MachineEvent = MachineEvent> {
+    readonly id: string;
+    send: (event: Event) => MachineSendResult<unknown, unknown>;
+    stop: () => void;
+}
+export interface MachineInstance<Context, Event extends MachineEvent, Input, Output> {
+    readonly id: string;
+    readonly model: MachineModel<Context, Event, Input, Output>;
+    readonly snapshot: ReadonlySignal<MachineSnapshot<Context, Output>>;
+    readonly started: boolean;
+    hasTag: (tag: string) => boolean;
+    matches: (path: string) => boolean;
+    persist: () => PersistedMachineSnapshot<Context, Output>;
+    send: (event: Event) => MachineSendResult<Context, Output>;
+    sendTo: (actorId: string, event: MachineEvent) => MachineSendResult<unknown, unknown>;
+    start: () => MachineInstance<Context, Event, Input, Output>;
+    stop: () => void;
+    subscribe: (listener: (snapshot: MachineSnapshot<Context, Output>) => void) => Disposer;
+}
+export {};

package/dist/machine-testing.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const h=require("./core-cPQWYD4K.cjs");function y(n){const i=h.getCompiledMachine(n),c=M(i),a=i.states.filter(t=>t.kind!=="history"&&!c.has(t.id)).map(t=>t.path),o=i.states.filter(t=>t.kind==="atomic"&&t.on.size===0&&t.always.length===0&&t.after.size===0&&t.invokes.length===0).map(t=>t.path),r=[];for(const t of i.states)t.kind==="parallel"&&t.children.length===0&&r.push(`Parallel state "${t.path}" has no regions.`),t.kind==="compound"&&t.initial===void 0&&r.push(`Compound state "${t.path}" has no initial child.`);return Object.freeze({deadEnds:Object.freeze(o),inconsistencies:Object.freeze(r),reachable:Object.freeze([...c].map(t=>i.states[t].path)),unreachable:Object.freeze(a),valid:r.length===0})}function k(n,i={}){const c=h.getCompiledMachine(n),a=i.maxDepth??12,o=i.maxPaths??1e3;j(a,"maxDepth"),j(o,"maxPaths");const r=i.events??c.eventTypes.map(l=>({type:l})),t=h.getInitialSnapshot(n,i.input),s=[{events:Object.freeze([]),snapshot:t}],e=[s[0]],f=new Set([b(t)]);let u=0;for(;u<e.length&&s.length<o;){const l=e[u++];if(!(l.events.length>=a||l.snapshot.status!=="active"))for(const m of r){const p=h.transition(n,l.snapshot,m,i.bindings);if(p===l.snapshot)continue;const g=b(p);if(f.has(g))continue;f.add(g);const v=Object.freeze({events:Object.freeze([...l.events,m]),snapshot:p});if(s.push(v),e.push(v),s.length>=o)break}}return Object.freeze(s)}function w(){const n=new Map,i=new Map,c=new Map;return{guard:(a,o)=>{const r=c.get(a)??{failed:0,passed:0};o?r.passed++:r.failed++,c.set(a,r)},record:(a,o,r)=>{for(const t of r.active)n.set(t,(n.get(t)??0)+1);if(a!==r){const t=`${a.active.join("|")} --${o.type}--> ${r.active.join("|")}`;i.set(t,(i.get(t)??0)+1)}},report:()=>Object.freeze({guards:Object.freeze(Object.fromEntries([...c].map(([a,o])=>[a,Object.freeze({...o})]))),states:Object.freeze(Object.fromEntries(n)),transitions:Object.freeze(Object.fromEntries(i))}),reset:()=>{n.clear(),i.clear(),c.clear()},transition:(a,o,r,t)=>{const s=h.transition(a,o,r,t,{guard:(e,f)=>{const u=c.get(e)??{failed:0,passed:0};f?u.passed++:u.failed++,c.set(e,u)}});for(const e of s.active)n.set(e,(n.get(e)??0)+1);if(o!==s){const e=`${o.active.join("|")} --${r.type}--> ${s.active.join("|")}`;i.set(e,(i.get(e)??0)+1)}return s}}}function O(n=0){if(!Number.isFinite(n))throw new TypeError("[Raph machine] Manual clock initial time must be finite.");let i=n,c=1;const a=new Map;return{advance:s=>{if(!Number.isFinite(s)||s<0)throw new TypeError("[Raph machine] Clock advance duration must be non-negative and finite.");const e=i+s;r(e),i=e},clearTimeout:s=>{const e=a.get(s);e!==void 0&&(e.active=!1,a.delete(e.id))},now:()=>i,get pending(){return a.size},runAll:()=>{let s=0;for(;a.size!==0;){if(++s>1e5)throw new Error("[Raph machine] Manual clock exceeded 100000 timer turns.");const e=t();if(e===void 0)break;r(e.at),i=e.at}},setTimeout:(s,e)=>{if(!Number.isFinite(e)||e<0)throw new TypeError("[Raph machine] Timer delay must be non-negative and finite.");const f={active:!0,at:i+e,callback:s,id:c++};return a.set(f.id,f),f.id}};function r(s){for(;;){const e=t();if(e===void 0||e.at>s)return;i=e.at,a.delete(e.id),e.active&&(e.active=!1,e.callback())}}function t(){let s;for(const e of a.values())e.active&&(s===void 0||e.at<s.at||e.at===s.at&&e.id<s.id)&&(s=e);return s}}function M(n){const i=new Set,c=new Set,a=[n.initial];let o=0;for(;o<a.length;){const r=a[o++];if(c.has(r))continue;c.add(r);for(const e of n.ancestry[r])c.has(e)||a.push(e),i.add(e);const t=n.states[r];if(t.kind==="history"){if(t.historyFallback!==void 0)a.push(t.historyFallback);else if(t.parent!==void 0){const e=n.states[t.parent];e.initial!==void 0&&a.push(e.initial)}}t.initial!==void 0&&a.push(t.initial),t.kind==="parallel"&&a.push(...t.children.filter(e=>n.states[e].kind!=="history"));const s=[t.always,t.onDone,...t.on.values(),...t.after.values()];for(const e of t.invokes)s.push(e.onDone,e.onError);for(const e of s)for(const f of e)f.target!==void 0&&a.push(f.target)}return i}function b(n){return[n.status,n.active.join("|"),d(n.context),d(n.history),d(n.output)].join(":")}function d(n){return n===null||typeof n!="object"?JSON.stringify(n):Array.isArray(n)?`[${n.map(d).join(",")}]`:`{${Object.keys(n).sort().map(i=>`${JSON.stringify(i)}:${d(n[i])}`).join(",")}}`}function j(n,i){if(!Number.isSafeInteger(n)||n<=0)throw new TypeError(`[Raph machine] ${i} must be a positive safe integer.`)}exports.createMachineCoverage=w;exports.createManualMachineClock=O;exports.enumerateMachinePaths=k;exports.inspectMachine=y;