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

package/dist/debug/runtime/reactivity/RuntimeReactivity.cjs

@@ -0,0 +1 @@
+"use strict";var f=Object.defineProperty;var p=(i,s,e)=>s in i?f(i,s,{enumerable:!0,configurable:!0,writable:!0,value:e}):i[s]=e;var a=(i,s,e)=>p(i,typeof s!="symbol"?s+"":s,e);Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const g=require("../../reactivity/engine.cjs");let n;class A{constructor(){a(this,"_active")}bind(s){const e=this._active;return e===void 0?{schedule:s,dispose:k}:e.binding(s)}runWith(s,e){const t=this._active;this._active=s===void 0?void 0:{binding:s};try{return e()}finally{this._active=t}}}class y extends g.RaphReactivity{constructor(e,t={}){const u=new A;super({...t.adaptiveDependencyIndex===void 0?{}:{adaptiveDependencyIndex:t.adaptiveDependencyIndex},effectScheduler:{bind:u.bind.bind(u)}});a(this,"_bindings");this._lifecycle=e,this._bindings=u}withEffectBinding(e,t){return this._bindings.runWith(e,t)}untrackedWithOwner(e){const t=n;n=void 0;try{return this.untracked(e)}finally{n=t}}getActiveOwner(){return n==null?void 0:n.lifecycle.owner}getActiveConsumerOwner(){return n==null?void 0:n.consumerOwner}hasActiveContext(){return n!==void 0||this._isTracking()}runWithOwner(e,t,u){const d=n;n=e===void 0?void 0:{consumerOwner:t,lifecycle:e};try{return u()}finally{n=d}}signalForOwner(e,t,u,d){const r=this._lifecycle,c=t._adoptSource(this._ownedSignal(e,u)),_=r.assertWriteAllowed,h=r.runWrite??b;return d==null||d(v=>{o(r),t._assertAlive(),c.set(v)}),_!==void 0?{get(){return l(r,t),t._assertAlive(),c.get()},peek(){return o(r),t._assertAlive(),c.peek()},set(v){t._assertAlive(),_(),h(()=>c.set(v))}}:{get(){return l(r,t),t._assertAlive(),c.get()},peek(){return o(r),t._assertAlive(),c.peek()},set(v){o(r),t._assertAlive(),h(()=>c.set(v))}}}computedForOwner(e,t,u){const d=this._lifecycle,r=t._adoptSource(this._ownedComputed(e,u));return{get(){l(d,t),t._assertAlive();const c=r.get();return t._assertAlive(),c},peek(){o(d),t._assertAlive();const c=r.peek();return t._assertAlive(),c}}}}function o(i){i.owner===void 0&&i.throwDisposed()}function l(i,s){o(i);const e=n;e!==void 0&&e.lifecycle!==i&&i.throwCrossRuntime(e.lifecycle.owner),(e==null?void 0:e.consumerOwner)!==void 0&&i.assertDependencyAllowed(s,e.consumerOwner)}function b(i){return i()}function k(){}exports.RuntimeReactivity=y;

package/dist/debug/runtime/reactivity/RuntimeReactivity.js

@@ -0,0 +1,156 @@
+var f = Object.defineProperty;
+var p = (s, i, e) => i in s ? f(s, i, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[i] = e;
+var l = (s, i, e) => p(s, typeof i != "symbol" ? i + "" : i, e);
+import { RaphReactivity as A } from "../../reactivity/engine.js";
+let n;
+class g {
+  constructor() {
+    // Хранит binding только на время синхронной регистрации effect.
+    l(this, "_active");
+  }
+  /**
+   * Связывает effect с owner и phase только на время регистрации.
+   */
+  bind(i) {
+    const e = this._active;
+    return e === void 0 ? { schedule: i, dispose: m } : e.binding(i);
+  }
+  /**
+   * Выполняет операцию с текущим effect binding.
+   */
+  runWith(i, e) {
+    const t = this._active;
+    this._active = i === void 0 ? void 0 : { binding: i };
+    try {
+      return e();
+    } finally {
+      this._active = t;
+    }
+  }
+}
+class O extends A {
+  /**
+   * Создаёт policy adapter реактивного графа для одного runtime.
+   */
+  constructor(e, t = {}) {
+    const o = new g();
+    super({
+      ...t.adaptiveDependencyIndex === void 0 ? {} : { adaptiveDependencyIndex: t.adaptiveDependencyIndex },
+      effectScheduler: {
+        bind: o.bind.bind(o)
+      }
+    });
+    // Изолирует registration binding от алгоритмов базового reactive graph.
+    l(this, "_bindings");
+    this._lifecycle = e, this._bindings = o;
+  }
+  /**
+   * Создаёт временную registration boundary для runtime effect.
+   */
+  withEffectBinding(e, t) {
+    return this._bindings.runWith(e, t);
+  }
+  /**
+   * Выполняет untracked-операцию, сохраняя runtime owner context.
+   */
+  untrackedWithOwner(e) {
+    const t = n;
+    n = void 0;
+    try {
+      return this.untracked(e);
+    } finally {
+      n = t;
+    }
+  }
+  /**
+   * Возвращает owner текущего синхронного реактивного контекста.
+   */
+  getActiveOwner() {
+    return n == null ? void 0 : n.lifecycle.owner;
+  }
+  /** Returns the Runtime resource owner whose implicit dependencies are being collected. */
+  getActiveConsumerOwner() {
+    return n == null ? void 0 : n.consumerOwner;
+  }
+  /**
+   * Сообщает, должен ли untracked work очищать graph consumer или Runtime owner context.
+   */
+  hasActiveContext() {
+    return n !== void 0 || this._isTracking();
+  }
+  /**
+   * Выполняет операцию с указанным active owner.
+   */
+  runWithOwner(e, t, o) {
+    const d = n;
+    n = e === void 0 ? void 0 : { consumerOwner: t, lifecycle: e };
+    try {
+      return o();
+    } finally {
+      n = d;
+    }
+  }
+  /**
+   * Создаёт owned signal с runtime lifecycle policy.
+   */
+  signalForOwner(e, t, o, d) {
+    const r = this._lifecycle, c = t._adoptSource(this._ownedSignal(e, o)), _ = r.assertWriteAllowed, h = r.runWrite ?? k;
+    return d == null || d((v) => {
+      u(r), t._assertAlive(), c.set(v);
+    }), _ !== void 0 ? {
+      get() {
+        return a(r, t), t._assertAlive(), c.get();
+      },
+      peek() {
+        return u(r), t._assertAlive(), c.peek();
+      },
+      set(v) {
+        t._assertAlive(), _(), h(() => c.set(v));
+      }
+    } : {
+      get() {
+        return a(r, t), t._assertAlive(), c.get();
+      },
+      peek() {
+        return u(r), t._assertAlive(), c.peek();
+      },
+      set(v) {
+        u(r), t._assertAlive(), h(() => c.set(v));
+      }
+    };
+  }
+  /**
+   * Создаёт owned computed с runtime lifecycle policy.
+   */
+  computedForOwner(e, t, o) {
+    const d = this._lifecycle, r = t._adoptSource(this._ownedComputed(e, o));
+    return {
+      get() {
+        a(d, t), t._assertAlive();
+        const c = r.get();
+        return t._assertAlive(), c;
+      },
+      peek() {
+        u(d), t._assertAlive();
+        const c = r.peek();
+        return t._assertAlive(), c;
+      }
+    };
+  }
+}
+function u(s) {
+  s.owner === void 0 && s.throwDisposed();
+}
+function a(s, i) {
+  u(s);
+  const e = n;
+  e !== void 0 && e.lifecycle !== s && s.throwCrossRuntime(e.lifecycle.owner), (e == null ? void 0 : e.consumerOwner) !== void 0 && s.assertDependencyAllowed(i, e.consumerOwner);
+}
+function k(s) {
+  return s();
+}
+function m() {
+}
+export {
+  O as RuntimeReactivity
+};

package/dist/debug/runtime/reactivity/RuntimeWatch.cjs

@@ -0,0 +1 @@
+"use strict";var p=Object.defineProperty;var c=(i,e,t)=>e in i?p(i,e,{enumerable:!0,configurable:!0,writable:!0,value:t}):i[e]=t;var r=(i,e,t)=>c(i,typeof e!="symbol"?e+"":e,t);Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class h{constructor(e,t){r(this,"_cleanup");r(this,"_stopped",!1);r(this,"deliver",()=>{if(this._stopped)return;const e=this._cleanup;if(e===void 0){const t=this._callback();if(typeof t!="function")return;this._stopped?this._runUntracked(t):this._cleanup=t;return}this._deliverWithCleanup(e)});this._runUntracked=e,this._callback=t}get stopped(){return this._stopped}_deliverWithCleanup(e){const t=[];if(this._cleanup=void 0,this._attempt(e,t),!this._stopped){let n=null;try{const s=this._runUntracked(this._callback);typeof s=="function"&&(n=s)}catch(s){t.push(s)}n!==null&&(this._stopped?this._attempt(n,t):this._cleanup=n)}a(t)}stop(e){if(this._stopped)return;this._stopped=!0;const t=[];if(e!==void 0)try{e()}catch(s){t.push(s)}const n=this._cleanup;this._cleanup=void 0,n!==void 0&&this._attempt(n,t),a(t)}_attempt(e,t){try{this._runUntracked(e)}catch(n){t.push(n)}}}function a(i){if(i.length===1)throw i[0];if(i.length>1)throw new AggregateError(i,"[Raph] Runtime watch delivery failed.")}exports.RuntimeWatch=h;

package/dist/debug/runtime/reactivity/RuntimeWatch.js

@@ -0,0 +1,88 @@
+var h = Object.defineProperty;
+var a = (i, e, t) => e in i ? h(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t;
+var r = (i, e, t) => a(i, typeof e != "symbol" ? e + "" : e, t);
+class l {
+  /**
+   * Создаёт runtime-owned watch с явным lifecycle остановки.
+   */
+  constructor(e, t) {
+    // Хранят cleanup последней доставки и окончательное состояние watcher.
+    r(this, "_cleanup");
+    r(this, "_stopped", !1);
+    /**
+     * Освобождает предыдущий результат callback и выполняет новую доставку.
+     * Ошибка cleanup не лишает живой watcher текущего события.
+     */
+    r(this, "deliver", () => {
+      if (this._stopped)
+        return;
+      const e = this._cleanup;
+      if (e === void 0) {
+        const t = this._callback();
+        if (typeof t != "function")
+          return;
+        this._stopped ? this._runUntracked(t) : this._cleanup = t;
+        return;
+      }
+      this._deliverWithCleanup(e);
+    });
+    this._runUntracked = e, this._callback = t;
+  }
+  /**
+   * Показывает, остановлен ли watch.
+   */
+  get stopped() {
+    return this._stopped;
+  }
+  /**
+   * Preserves cleanup/callback error aggregation and reentrant stop semantics
+   * for the less common resource-returning callback path.
+   */
+  _deliverWithCleanup(e) {
+    const t = [];
+    if (this._cleanup = void 0, this._attempt(e, t), !this._stopped) {
+      let n = null;
+      try {
+        const s = this._runUntracked(this._callback);
+        typeof s == "function" && (n = s);
+      } catch (s) {
+        t.push(s);
+      }
+      n !== null && (this._stopped ? this._attempt(n, t) : this._cleanup = n);
+    }
+    p(t);
+  }
+  /**
+   * Останавливает внешнюю регистрацию и cleanup callback, сохраняя обе ошибки.
+   */
+  stop(e) {
+    if (this._stopped)
+      return;
+    this._stopped = !0;
+    const t = [];
+    if (e !== void 0)
+      try {
+        e();
+      } catch (s) {
+        t.push(s);
+      }
+    const n = this._cleanup;
+    this._cleanup = void 0, n !== void 0 && this._attempt(n, t), p(t);
+  }
+  _attempt(e, t) {
+    try {
+      this._runUntracked(e);
+    } catch (n) {
+      t.push(n);
+    }
+  }
+}
+function p(i) {
+  if (i.length === 1)
+    throw i[0];
+  if (i.length > 1)
+    throw new AggregateError(i, "[Raph] Runtime watch delivery failed.");
+}
+export {
+  l as RuntimeWatch
+};

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,17 @@
+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, RaphEffectInitialMode, RaphEffectOptions, RaphFrameContext, RaphPhase, RaphPhaseBatch, 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 { 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;