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

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const k=require("../../reactivity/engine.cjs"),O=require("../errors.cjs"),R=require("../phases/RaphPhaseTaskRecord.cjs"),S=require("./RaphSelector.cjs"),T=require("./RaphWorkGraph.cjs");let a,u;function A(n){return{schedule:n,dispose:g}}let v=0;function E(n){n.firstSub!==null&&++v}function N(n,e,t){n.firstSub===null&&t.delete(e)}const _=Object.freeze({}),m=Object.freeze({schedule:g,dispose:g}),b=64;class C{constructor(e){this.items=[e],this.shared=!1}detach(){const e=this.items.slice();return this.items=e,this.shared=!1,e}}class f extends T.RaphProducer{constructor(e,t,r,i){super(e,t,r),this._value=i,this._node=void 0,this._previousSource=void 0,this._writeTaps=void 0,this.source=this}get token(){return this}get dependencyOwner(){return this.owner}toJSON(){let e=0;for(let t=this._previousSource;t!==void 0&&e<b;t=t._previousSource)++e;return{kind:this.kind,owner:this.owner.id,index:e,revision:this.revision,disposed:this.disposed}}get(){const e=this.owner,t=e.runtime._getReactivity();w(t,e),e._assertAlive();const r=this._node;if(r!==void 0)return t._readSignalNode(r);const i=this._value,s=t._trackSignalNode(i,this);return s!==void 0&&(this._node=s,this._value=void 0),i}peek(){const e=this.owner,t=e.runtime._getReactivity();h(t._lifecycle),e._assertAlive();const r=this._node;return r===void 0?this._value:t._peekSignalNode(r)}set(e){const t=this.owner,r=t.runtime,i=r._getReactivity()._lifecycle,s=i.assertWriteAllowed;s===void 0?(h(i),t._assertAlive()):(t._assertAlive(),s()),r._enterWrite();try{this._write(e)}catch(o){throw r._failWrite(o)}r._exitWrite()}_writeInBoundary(e){const t=this.owner;h(t.runtime._getReactivity()._lifecycle),t._assertAlive(),this._write(e)}_addWriteTap(e){const t=this._writeTaps;if(t===void 0){e._tapSlot=0,this._writeTaps=new C(e);return}const r=t.shared?t.detach():t.items;e._tapSlot=r.length,r.push(e)}_removeWriteTap(e){const t=this._writeTaps;if(t===void 0)return;const r=e._tapSlot;if(r<0||t.items[r]!==e)return;if(e._tapSlot=-1,t.items.length===1){this._writeTaps=void 0;return}const i=t.shared?t.detach():t.items,s=i.pop();s!==e&&(i[r]=s,s._tapSlot=r)}onChange(e,t,r){this.owner.runtime._getWorkGraph()._notifyValueWrite(this,e,t,r)}onDispose(e){this.owner.runtime._getWorkGraph()._disposeProducer(this,e)}_findConsumerOwner(e,t){const r=this._writeTaps;if(r!==void 0){const s=r.items;for(let o=0;o<s.length;o++){const c=s[o]._tapOwner;if(e(c,t))return c}}const i=this._node;return i===void 0?void 0:this.owner.runtime._getReactivity()._findSubscriberOwner(i,e,t)}_finalizeSource(){if(this.disposed)return!0;this._value=void 0,this._writeTaps=void 0;const e=this._node,t=this.owner.runtime._getReactivity();let r;try{this.onDispose(e!==void 0&&t._signalNodeHasSubscribers(e))}catch(i){(r??=[]).push(i)}if(e!==void 0){this._node=void 0;try{t._releaseSignalNode(e)}catch(i){(r??=[]).push(i)}}if(r!==void 0)throw r.length===1?r[0]:new AggregateError(r,"Owned signal disposal failed.");return!0}_write(e){const t=this._writeTaps;if(t!==void 0){this._writeTapped(e,t);return}const r=this._node;if(r!==void 0){const s=this.owner.runtime,o=s._getReactivity(),c=o._visibleSignalValue(r);c!==e&&s._getWorkGraph()._notifyValueWrite(this,c,e,r.firstSub!==null),o._writeSignalNode(r,e);return}const i=this._value;i!==e&&(this.owner.runtime._getWorkGraph()._notifyValueWrite(this,i,e,!1),this._value=e)}_writeTapped(e,t){const r=this._node,i=this.owner.runtime._getReactivity(),s=r===void 0?this._value:i._visibleSignalValue(r);if(s===e)return;const o=t.items;t.shared=!0;let c=r!==void 0&&i._signalNodeHasSubscribers(r);for(let d=0;!c&&d<o.length;d++)c=o[d]._observesWrites();this.onChange(s,e,c);let l;if(r===void 0)this._value=e;else try{i._writeSignalNode(r,e)}catch(d){l=[d]}for(let d=0;d<o.length;d++)try{o[d]._afterSourceWrite(s,e)}catch(y){(l??=[]).push(y)}if(l!==void 0)throw l.length===1?l[0]:new AggregateError(l,"[Raph] Signal write and its observers failed.")}}class p extends k.RaphReactivity{constructor(e,t={}){super({...t.adaptiveDependencyIndex===void 0?{}:{adaptiveDependencyIndex:t.adaptiveDependencyIndex},effectScheduler:{bind:A}}),this._lifecycle=e,this._phaseBody=()=>{const r=this._activeEffectTask(),i=r.consumerOwner,s=a,o=u;a=e,u=i;let c;try{const l=r.effect;c=l(r.state&R.TASK_TASKLESS?r.group:r.task)}finally{a=s,u=o}return typeof c=="function"?I(this,c):c},p._releasedShapeAnchor??=W(this)}untrackedWithOwner(e){const t=a,r=u;a=void 0,u=void 0;try{return this.untracked(e)}finally{a=t,u=r}}_applyUntrackedWithOwner(e,t){const r=a,i=u;a=void 0,u=void 0;try{return this._isTracking()?this.untracked(()=>e(...t)):e(...t)}finally{a=r,u=i}}_runTaskEffectUntracked(e){const t=a,r=u;a=void 0,u=void 0;try{this._finishTaskEffectRun(e)}finally{a=t,u=r}}getActiveOwner(){return a===void 0?void 0:a.owner}getActiveConsumerOwner(){return u}hasActiveContext(){return a!==void 0||this._isTracking()}runWithOwner(e,t,r){const i=a,s=u;a=e,u=e===void 0?void 0:t;try{return r()}finally{a=i,u=s}}_findSignalConsumerOwner(e,t,r){for(let i=e._lastOwnedSource();i!==void 0;i=i._previousSource){if(!(i instanceof f)&&!(i instanceof S.RuntimeSelector))continue;const s=i._findConsumerOwner(t,r);if(s!==void 0)return s}}_assertTrackedRead(e){w(this,e)}_hasSingleSubscriber(e){const t=e.firstSub;return t!==null&&t===e.lastSub}_countObserved(e,t){let r=0;for(let i=0;i<e.length;i++){const s=e[i];s!==void 0&&s.firstSub!==null&&++r}return t!==void 0&&t.size!==0&&(v=0,t.forEach(E),r+=v),r}_dropUnobserved(e,t){let r=0;for(let i=0;i<e.length;i++){const s=e[i];s!==void 0&&(s.firstSub===null?e[i]=void 0:++r)}return t!==void 0&&t.size!==0&&t.forEach(N),r}selectorForOwner(e,t,r){if(!(e instanceof f))throw new TypeError("[Raph] selector() source must be a writable Runtime signal.");const i=r?.equals;if(i!==void 0&&typeof i!="function")throw new TypeError("[Raph] selector() equals must be a function.");const s=e.owner;if(s.runtime!==t.runtime)throw new O.RaphCrossRuntimeError("[Raph] selector() source belongs to another runtime.");s._assertAlive(),this._lifecycle.assertDependencyAllowed(s,t);const o=new S.RuntimeSelector(t,this,e,i);try{t._adoptSourceEntry(o)}catch(c){throw o._finalizeSource(),c}return o}signalForOwner(e,t,r="producer",i=!0){const s=new f(t,r,i,e);return t._adoptSourceEntry(s),s}computedForOwner(e,t,r){const i=this._lifecycle,s=t._adoptSource(this._ownedComputed(e,r));return{get:()=>{w(this,t),t._assertAlive();const o=s.get();return t._assertAlive(),o},peek(){h(i),t._assertAlive();const o=s.peek();return t._assertAlive(),o}}}}p._releasedShapeAnchor=void 0;function W(n){let e,t;const r=n._allocateTaskEffect(()=>{e=n._trackSignalNode(void 0,_),t=n._trackSignalNode(void 0,_)},m);n._requestTaskEffect(r,!1),n._beginTaskEffectRun(r),n._finishTaskEffectRun(r);const i=e.firstSub;n._disposeTaskEffect(r),n.batch(()=>n._writeSignalNode(t,0)),n._releaseSignalNode(e),n._releaseSignalNode(t);let s,o;const c=n._allocateTaskEffect(()=>{s=n._trackCounterNode(_),o=n._trackCounterNode(_)},m);return n._requestTaskEffect(c,!1),n._beginTaskEffectRun(c),n._finishTaskEffectRun(c),n.batch(()=>{n._bumpSignalNode(o)}),n._disposeTaskEffect(c),n._releaseSignalNode(s),n._releaseSignalNode(o),{source:e,written:t,edge:i,consumer:r,counter:s,bumped:o}}function I(n,e){return()=>n.untrackedWithOwner(e)}function h(n){n.owner===void 0&&n.throwDisposed()}function w(n,e){const t=n._lifecycle;h(t);const r=a;if(r!==void 0){r!==t&&t.throwCrossRuntime(r.owner);const s=u;s!==void 0&&s!==e&&t.assertDependencyAllowed(e,s);return}const i=n._activeSubscriberOwner();i!==void 0&&t.assertDependencyAllowed(e,i)}function g(){}exports.RuntimeReactivity=p;exports.RuntimeSignal=f;exports.SIGNAL_INDEX_LIMIT=b;

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

@@ -0,0 +1,550 @@
+import { RaphReactivity as y } from "../../reactivity/engine.js";
+import { RaphCrossRuntimeError as k } from "../errors.js";
+import { TASK_TASKLESS as O } from "../phases/RaphPhaseTaskRecord.js";
+import { RuntimeSelector as m } from "./RaphSelector.js";
+import { RaphProducer as T } from "./RaphWorkGraph.js";
+let a, d;
+function A(n) {
+  return { schedule: n, dispose: w };
+}
+let p = 0;
+function R(n) {
+  n.firstSub !== null && ++p;
+}
+function E(n, e, t) {
+  n.firstSub === null && t.delete(e);
+}
+const f = Object.freeze({}), S = Object.freeze({ schedule: w, dispose: w }), N = 64;
+class C {
+  constructor(e) {
+    this.items = [e], this.shared = !1;
+  }
+  /**
+   * Заменяет список его копией, которую ещё не обходит ни одна запись, и
+   * возвращает её. Места наблюдателей в копии те же.
+   */
+  detach() {
+    const e = this.items.slice();
+    return this.items = e, this.shared = !1, e;
+  }
+}
+class _ extends T {
+  /**
+   * Создаёт signal своим собственным handle. Регистрацию у владельца
+   * выполняет вызывающий код.
+   */
+  constructor(e, t, r, s) {
+    super(e, t, r), this._value = s, this._node = void 0, this._previousSource = void 0, this._writeTaps = void 0, this.source = this;
+  }
+  /**
+   * Identity producer для задач implicit effects: сам signal.
+   * @internal
+   */
+  get token() {
+    return this;
+  }
+  /**
+   * Владелец signal. Engine читает это поле только у потребителей, а signal
+   * потребителем не бывает; getter сохраняет полный контракт source hooks.
+   * @internal
+   */
+  get dependencyOwner() {
+    return this.owner;
+  }
+  /**
+   * Возвращает компактное описание signal для JSON.stringify, логов и diff
+   * неуспешной проверки. К описанию producer добавлен номер signal среди
+   * источников его владельца в порядке регистрации: один и тот же signal
+   * описывается одинаково, сколько бы раз и через какую копию его ни
+   * печатали, а разные живые signals одного владельца различаются номером,
+   * пока он меньше SIGNAL_INDEX_LIMIT. Номер считается проходом по списку
+   * источников только при сериализации и не дальше этой границы: у каждого
+   * источника, зарегистрированного после первых SIGNAL_INDEX_LIMIT, он равен
+   * границе. У освобождённого signal номер равен нулю. Значение в описание не
+   * входит: оно может быть сколь угодно большим и само содержать циклы.
+   */
+  toJSON() {
+    let e = 0;
+    for (let t = this._previousSource; t !== void 0 && e < N; t = t._previousSource)
+      ++e;
+    return {
+      kind: this.kind,
+      owner: this.owner.id,
+      index: e,
+      revision: this.revision,
+      disposed: this.disposed
+    };
+  }
+  /**
+   * Читает значение и регистрирует зависимость активного потребителя.
+   */
+  get() {
+    const e = this.owner, t = e.runtime._getReactivity();
+    v(t, e), e._assertAlive();
+    const r = this._node;
+    if (r !== void 0)
+      return t._readSignalNode(r);
+    const s = this._value, i = t._trackSignalNode(s, this);
+    return i !== void 0 && (this._node = i, this._value = void 0), s;
+  }
+  /**
+   * Читает значение без подписки текущего потребителя.
+   */
+  peek() {
+    const e = this.owner, t = e.runtime._getReactivity();
+    h(t._lifecycle), e._assertAlive();
+    const r = this._node;
+    return r === void 0 ? this._value : t._peekSignalNode(r);
+  }
+  /**
+   * Записывает значение в собственной границе записи Runtime. Граница
+   * открывается и закрывается явными вызовами, без closure.
+   */
+  set(e) {
+    const t = this.owner, r = t.runtime, s = r._getReactivity()._lifecycle, i = s.assertWriteAllowed;
+    i === void 0 ? (h(s), t._assertAlive()) : (t._assertAlive(), i()), r._enterWrite();
+    try {
+      this._write(e);
+    } catch (o) {
+      throw r._failWrite(o);
+    }
+    r._exitWrite();
+  }
+  /**
+   * Записывает значение внутри уже открытой границы записи, минуя политику
+   * actions: так Runtime продвигает собственный frame signal.
+   * @internal
+   */
+  _writeInBoundary(e) {
+    const t = this.owner;
+    h(t.runtime._getReactivity()._lifecycle), t._assertAlive(), this._write(e);
+  }
+  /**
+   * Подключает наблюдателя фактических записей этого signal. Наблюдатель
+   * вызывается синхронно внутри границы записи, после того как новое значение
+   * стало видимым для чтения, и до выхода из записи. Запись, которая уже идёт,
+   * нового наблюдателя не вызывает. Цена подключения не зависит от числа
+   * наблюдателей.
+   * @internal
+   */
+  _addWriteTap(e) {
+    const t = this._writeTaps;
+    if (t === void 0) {
+      e._tapSlot = 0, this._writeTaps = new C(e);
+      return;
+    }
+    const r = t.shared ? t.detach() : t.items;
+    e._tapSlot = r.length, r.push(e);
+  }
+  /**
+   * Отключает наблюдателя записей: его место занимает последний наблюдатель
+   * списка. Запись, которая уже идёт, ещё вызовет отключённого наблюдателя.
+   * Отключение неизвестного наблюдателя и отключение у освобождённого signal
+   * безопасны. Цена отключения не зависит от числа наблюдателей.
+   * @internal
+   */
+  _removeWriteTap(e) {
+    const t = this._writeTaps;
+    if (t === void 0)
+      return;
+    const r = e._tapSlot;
+    if (r < 0 || t.items[r] !== e)
+      return;
+    if (e._tapSlot = -1, t.items.length === 1) {
+      this._writeTaps = void 0;
+      return;
+    }
+    const s = t.shared ? t.detach() : t.items, i = s.pop();
+    i !== e && (s[r] = i, i._tapSlot = r);
+  }
+  /**
+   * Сообщает WorkGraph о фактической записи до распространения по графу.
+   * @internal
+   */
+  onChange(e, t, r) {
+    this.owner.runtime._getWorkGraph()._notifyValueWrite(
+      this,
+      e,
+      t,
+      r
+    );
+  }
+  /**
+   * Освобождает producer-сторону signal в WorkGraph.
+   * @internal
+   */
+  onDispose(e) {
+    this.owner.runtime._getWorkGraph()._disposeProducer(this, e);
+  }
+  /**
+   * Ищет среди текущих потребителей signal в графе первого, чьего владельца
+   * принимает accept, и возвращает этого владельца. Signal не ведёт учёта
+   * своих implicit-рёбер и не имеет hook onDependency: рёбра читаются из
+   * записи графа только по запросу. У signal без записи графа потребителей
+   * нет: его ещё не читал ни один потребитель либо он уже освобождён.
+   * Владельцы наблюдателей записи считаются потребителями наравне с ними.
+   * @internal
+   */
+  _findConsumerOwner(e, t) {
+    const r = this._writeTaps;
+    if (r !== void 0) {
+      const i = r.items;
+      for (let o = 0; o < i.length; o++) {
+        const c = i[o]._tapOwner;
+        if (e(c, t))
+          return c;
+      }
+    }
+    const s = this._node;
+    return s === void 0 ? void 0 : this.owner.runtime._getReactivity()._findSubscriberOwner(s, e, t);
+  }
+  /**
+   * Освобождает signal как источник владельца: публикует финальную причину,
+   * отсоединяет запись графа и отпускает значение. Сбой одного шага не
+   * отменяет остальные. Повторный вызов безопасен.
+   * @internal
+   */
+  _finalizeSource() {
+    if (this.disposed)
+      return !0;
+    this._value = void 0, this._writeTaps = void 0;
+    const e = this._node, t = this.owner.runtime._getReactivity();
+    let r;
+    try {
+      this.onDispose(e !== void 0 && t._signalNodeHasSubscribers(e));
+    } catch (s) {
+      (r ??= []).push(s);
+    }
+    if (e !== void 0) {
+      this._node = void 0;
+      try {
+        t._releaseSignalNode(e);
+      } catch (s) {
+        (r ??= []).push(s);
+      }
+    }
+    if (r !== void 0)
+      throw r.length === 1 ? r[0] : new AggregateError(r, "Owned signal disposal failed.");
+    return !0;
+  }
+  /**
+   * Записывает значение без проверок lifetime и без границы записи.
+   * Критерий изменения — ===, как у записи графа.
+   */
+  _write(e) {
+    const t = this._writeTaps;
+    if (t !== void 0) {
+      this._writeTapped(e, t);
+      return;
+    }
+    const r = this._node;
+    if (r !== void 0) {
+      const i = this.owner.runtime, o = i._getReactivity(), c = o._visibleSignalValue(r);
+      c !== e && i._getWorkGraph()._notifyValueWrite(this, c, e, r.firstSub !== null), o._writeSignalNode(r, e);
+      return;
+    }
+    const s = this._value;
+    s !== e && (this.owner.runtime._getWorkGraph()._notifyValueWrite(this, s, e, !1), this._value = e);
+  }
+  /**
+   * Запись signal с наблюдателями. Отличается от `_write()` двумя вещами.
+   * Причина записи публикуется и тогда, когда потребители есть только у
+   * наблюдателя: их будит эта же запись. После того как новое значение стало
+   * видимым, каждый наблюдатель получает прежнее и новое значение. Сбой
+   * распространения по графу или одного наблюдателя не отменяет остальных.
+   *
+   * Запись обходит тот список наблюдателей, который застала: подключение и
+   * отключение во время обхода меняют его копию.
+   */
+  _writeTapped(e, t) {
+    const r = this._node, s = this.owner.runtime._getReactivity(), i = r === void 0 ? this._value : s._visibleSignalValue(r);
+    if (i === e)
+      return;
+    const o = t.items;
+    t.shared = !0;
+    let c = r !== void 0 && s._signalNodeHasSubscribers(r);
+    for (let u = 0; !c && u < o.length; u++)
+      c = o[u]._observesWrites();
+    this.onChange(i, e, c);
+    let l;
+    if (r === void 0)
+      this._value = e;
+    else
+      try {
+        s._writeSignalNode(r, e);
+      } catch (u) {
+        l = [u];
+      }
+    for (let u = 0; u < o.length; u++)
+      try {
+        o[u]._afterSourceWrite(i, e);
+      } catch (b) {
+        (l ??= []).push(b);
+      }
+    if (l !== void 0)
+      throw l.length === 1 ? l[0] : new AggregateError(l, "[Raph] Signal write and its observers failed.");
+  }
+}
+class g extends y {
+  /**
+   * Создаёт policy adapter реактивного графа для одного runtime.
+   * @param _lifecycle Политика lifetime и записи Runtime; её читают handles
+   * этого графа, поэтому поле доступно внутри пакета.
+   */
+  constructor(e, t = {}) {
+    super({
+      ...t.adaptiveDependencyIndex === void 0 ? {} : { adaptiveDependencyIndex: t.adaptiveDependencyIndex },
+      effectScheduler: { bind: A }
+    }), this._lifecycle = e, this._phaseBody = () => {
+      const r = this._activeEffectTask(), s = r.consumerOwner, i = a, o = d;
+      a = e, d = s;
+      let c;
+      try {
+        const l = r.effect;
+        c = l(r.state & O ? r.group : r.task);
+      } finally {
+        a = i, d = o;
+      }
+      return typeof c == "function" ? D(this, c) : c;
+    }, g._releasedShapeAnchor ??= W(this);
+  }
+  /**
+   * Выполняет untracked-операцию, сохраняя runtime owner context.
+   */
+  untrackedWithOwner(e) {
+    const t = a, r = d;
+    a = void 0, d = void 0;
+    try {
+      return this.untracked(e);
+    } finally {
+      a = t, d = r;
+    }
+  }
+  /**
+   * Вызывает операцию с её аргументами вне Runtime owner context и вне graph
+   * consumer: форма `untrackedWithOwner(() => operation(...args))` без closure.
+   * Closure создаётся, только когда вызов пришёл изнутри отслеживаемого
+   * вычисления и graph consumer нужно снять.
+   *
+   * @internal
+   */
+  _applyUntrackedWithOwner(e, t) {
+    const r = a, s = d;
+    a = void 0, d = void 0;
+    try {
+      return this._isTracking() ? this.untracked(() => e(...t)) : e(...t);
+    } finally {
+      a = r, d = s;
+    }
+  }
+  /**
+   * Выполняет одну открытую доставку phase effect вне Runtime owner context и
+   * вне graph consumer: форма untrackedWithOwner() без closure для записи,
+   * подготовленной через _beginTaskEffectRun().
+   *
+   * @internal
+   */
+  _runTaskEffectUntracked(e) {
+    const t = a, r = d;
+    a = void 0, d = void 0;
+    try {
+      this._finishTaskEffectRun(e);
+    } finally {
+      a = t, d = r;
+    }
+  }
+  /**
+   * Возвращает owner текущего синхронного реактивного контекста.
+   */
+  getActiveOwner() {
+    return a === void 0 ? void 0 : a.owner;
+  }
+  /** Returns the Runtime resource owner whose implicit dependencies are being collected. */
+  getActiveConsumerOwner() {
+    return d;
+  }
+  /**
+   * Сообщает, должен ли untracked work очищать graph consumer или Runtime owner context.
+   */
+  hasActiveContext() {
+    return a !== void 0 || this._isTracking();
+  }
+  /**
+   * Выполняет операцию с указанным active owner.
+   */
+  runWithOwner(e, t, r) {
+    const s = a, i = d;
+    a = e, d = e === void 0 ? void 0 : t;
+    try {
+      return r();
+    } finally {
+      a = s, d = i;
+    }
+  }
+  /**
+   * Ищет среди текущих потребителей Runtime signals владельца `sourceOwner`
+   * первого, чьего владельца принимает accept, и возвращает этого владельца.
+   * Signals обходятся от нового к старому по списку источников владельца;
+   * остальные источники списка пропускаются: их рёбра учитывает сам WorkGraph.
+   * Обход ничего не выделяет. Его цена — длина списка источников владельца
+   * плюс потребители каждого его signal с записью графа до первого принятого.
+   *
+   * @internal
+   */
+  _findSignalConsumerOwner(e, t, r) {
+    for (let s = e._lastOwnedSource(); s !== void 0; s = s._previousSource) {
+      if (!(s instanceof _) && !(s instanceof m))
+        continue;
+      const i = s._findConsumerOwner(t, r);
+      if (i !== void 0)
+        return i;
+    }
+  }
+  /**
+   * Проверяет отслеживаемое чтение источника владельца `sourceOwner` теми же
+   * правилами, что и чтение его Runtime signal: Runtime жив, активный
+   * потребитель принадлежит этому Runtime и вправе неявно зависеть от
+   * владельца. Lifetime самого владельца проверяет вызывающий код.
+   *
+   * @internal
+   */
+  _assertTrackedRead(e) {
+    v(this, e);
+  }
+  /**
+   * Сообщает, что у записи ровно один потребитель. Внутри cleanup связи,
+   * который engine вызывает до снятия этой связи со списка, ответ `true`
+   * означает, что снимается последняя связь записи.
+   *
+   * @internal
+   */
+  _hasSingleSubscriber(e) {
+    const t = e.firstSub;
+    return t !== null && t === e.lastSub;
+  }
+  /**
+   * Считает записи, у которых есть потребители, в двух частях одного индекса:
+   * в ряду, где пустое место хранит undefined, и в индексе по ключам, если он
+   * есть. Ряд обходится циклом без вызовов. Обход ничего не выделяет и не
+   * меняет граф.
+   *
+   * @internal
+   */
+  _countObserved(e, t) {
+    let r = 0;
+    for (let s = 0; s < e.length; s++) {
+      const i = e[s];
+      i !== void 0 && i.firstSub !== null && ++r;
+    }
+    return t !== void 0 && t.size !== 0 && (p = 0, t.forEach(R), r += p), r;
+  }
+  /**
+   * Убирает записи без потребителей из обеих частей индекса: место ряда
+   * становится пустым, запись индекса по ключам удаляется. Возвращает число
+   * мест ряда, оставшихся занятыми. Сами записи не освобождаются: без
+   * потребителей и без ссылки из индекса они недостижимы.
+   *
+   * @internal
+   */
+  _dropUnobserved(e, t) {
+    let r = 0;
+    for (let s = 0; s < e.length; s++) {
+      const i = e[s];
+      i !== void 0 && (i.firstSub === null ? e[s] = void 0 : ++r);
+    }
+    return t !== void 0 && t.size !== 0 && t.forEach(E), r;
+  }
+  /**
+   * Создаёт selector над записываемым Runtime signal и ставит его в список
+   * источников владельца. Source должен быть доступен владельцу для implicit
+   * чтения: принадлежать ему самому, его предку или root scope. Тогда source
+   * переживает selector, а потребители selector могли бы читать source сами.
+   */
+  selectorForOwner(e, t, r) {
+    if (!(e instanceof _))
+      throw new TypeError("[Raph] selector() source must be a writable Runtime signal.");
+    const s = r?.equals;
+    if (s !== void 0 && typeof s != "function")
+      throw new TypeError("[Raph] selector() equals must be a function.");
+    const i = e.owner;
+    if (i.runtime !== t.runtime)
+      throw new k("[Raph] selector() source belongs to another runtime.");
+    i._assertAlive(), this._lifecycle.assertDependencyAllowed(i, t);
+    const o = new m(t, this, e, s);
+    try {
+      t._adoptSourceEntry(o);
+    } catch (c) {
+      throw o._finalizeSource(), c;
+    }
+    return o;
+  }
+  /**
+   * Создаёт Runtime signal и ставит его в список источников владельца. Signal
+   * одним объектом является handle, producer WorkGraph и записью источника.
+   */
+  signalForOwner(e, t, r = "producer", s = !0) {
+    const i = new _(t, r, s, e);
+    return t._adoptSourceEntry(i), i;
+  }
+  /**
+   * Создаёт owned computed с runtime lifecycle policy.
+   */
+  computedForOwner(e, t, r) {
+    const s = this._lifecycle, i = t._adoptSource(this._ownedComputed(e, r));
+    return {
+      get: () => {
+        v(this, t), t._assertAlive();
+        const o = i.get();
+        return t._assertAlive(), o;
+      },
+      peek() {
+        h(s), t._assertAlive();
+        const o = i.peek();
+        return t._assertAlive(), o;
+      }
+    };
+  }
+}
+g._releasedShapeAnchor = void 0;
+function W(n) {
+  let e, t;
+  const r = n._allocateTaskEffect(() => {
+    e = n._trackSignalNode(void 0, f), t = n._trackSignalNode(void 0, f);
+  }, S);
+  n._requestTaskEffect(r, !1), n._beginTaskEffectRun(r), n._finishTaskEffectRun(r);
+  const s = e.firstSub;
+  n._disposeTaskEffect(r), n.batch(() => n._writeSignalNode(t, 0)), n._releaseSignalNode(e), n._releaseSignalNode(t);
+  let i, o;
+  const c = n._allocateTaskEffect(() => {
+    i = n._trackCounterNode(f), o = n._trackCounterNode(f);
+  }, S);
+  return n._requestTaskEffect(c, !1), n._beginTaskEffectRun(c), n._finishTaskEffectRun(c), n.batch(() => {
+    n._bumpSignalNode(o);
+  }), n._disposeTaskEffect(c), n._releaseSignalNode(i), n._releaseSignalNode(o), { source: e, written: t, edge: s, consumer: r, counter: i, bumped: o };
+}
+function D(n, e) {
+  return () => n.untrackedWithOwner(e);
+}
+function h(n) {
+  n.owner === void 0 && n.throwDisposed();
+}
+function v(n, e) {
+  const t = n._lifecycle;
+  h(t);
+  const r = a;
+  if (r !== void 0) {
+    r !== t && t.throwCrossRuntime(r.owner);
+    const i = d;
+    i !== void 0 && i !== e && t.assertDependencyAllowed(e, i);
+    return;
+  }
+  const s = n._activeSubscriberOwner();
+  s !== void 0 && t.assertDependencyAllowed(e, s);
+}
+function w() {
+}
+export {
+  g as RuntimeReactivity,
+  _ as RuntimeSignal,
+  N as SIGNAL_INDEX_LIMIT
+};

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

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

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

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

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

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