@raphy-js/raph 1.0.0-dev.2

package/dist/runtime/RaphPhasePipeline.d.ts

@@ -0,0 +1,133 @@
+import { DataPathDef } from '../path/path.types';
+import { RaphKernel } from '../path/RaphKernel';
+import { Disposer, EffectTask } from '../reactivity/types';
+import { RaphFrameContext, RaphObserveDataOptions, RaphPhase, RaphPhaseMode, RaphSchedulerMode, RaphTrackOptions } from './phase.types';
+import { RaphNode } from './RaphNode';
+/**
+ * Ленивый Runtime-owned pipeline поверх Kernel path batches.
+ */
+export declare class RaphPhasePipeline {
+    private readonly _kernel;
+    private readonly _root;
+    private readonly _scheduler;
+    private readonly _runUntracked;
+    private readonly _deferSync;
+    private _observerRouter;
+    private _phaseRouter;
+    private _observers;
+    private _stopKernel;
+    private _phases;
+    private _phaseByName;
+    private _pending;
+    private _tasks;
+    private _phaseBindings;
+    private _taskSequence;
+    private _scheduled;
+    private _scheduleToken;
+    private _frameHandle;
+    private _frameHandleKind;
+    private _configurationLocked;
+    private _running;
+    private _disposed;
+    private _firstFrameAt;
+    private _lastFrameAt;
+    private _frameNumber;
+    private _frame;
+    /**
+     * Создаёт phase pipeline для runtime и его root node.
+     */
+    constructor(_kernel: RaphKernel, _root: RaphNode, _scheduler: RaphSchedulerMode, _runUntracked: <T>(operation: () => T) => T, _deferSync?: () => boolean);
+    /**
+     * Возвращает последний frame context pipeline.
+     */
+    get frame(): RaphFrameContext;
+    /**
+     * Возвращает текущее упорядоченное определение phases.
+     */
+    get phases(): readonly RaphPhase[];
+    /**
+     * Заменяет полное определение phase pipeline до его первого выполнения.
+     */
+    definePhases(phases: readonly RaphPhase[]): void;
+    /**
+     * Добавляет phase до первого выполнения pipeline.
+     */
+    addPhase(phase: RaphPhase): void;
+    /**
+     * Удаляет пользовательские phases до первого выполнения pipeline.
+     */
+    clearPhases(): void;
+    /**
+     * Возвращает phase либо отклоняет неизвестное имя.
+     */
+    requirePhase(name: string): void;
+    /**
+     * Фиксирует phase definitions перед синхронным выполнением вне flush.
+     */
+    lockConfiguration(): void;
+    /**
+     * Удерживает определение фазы для idle registrations вне data observer/effect.
+     */
+    retainPhase(name: string): Disposer;
+    /**
+     * Возвращает scheduler mode указанной phase.
+     */
+    phaseMode(name: string): RaphPhaseMode;
+    /**
+     * Связывает реактивный effect с phase scheduler.
+     */
+    registerEffect(name: string): Disposer;
+    /**
+     * Один раз связывает watcher с task и callback.
+     * Повторные invalidations используют ту же task без hot-path поиска node и phase.
+     */
+    bindEffect(phase: string, priority: number, run: () => void, node?: RaphNode): EffectTask;
+    /**
+     * Ставит уже зарегистрированный effect в очередь его phase.
+     */
+    queueEffect(phase: string, priority: number, run: () => void, schedule?: boolean): Disposer;
+    /**
+     * Запрашивает выполнение pipeline согласно scheduler mode.
+     */
+    request(): void;
+    /**
+     * Ставит frame-driven обход всего дерева в очередь даже без reactive effect.
+     */
+    requestAlwaysPhases(): void;
+    /**
+     * Регистрирует path observer в phase pipeline.
+     */
+    observeData(node: RaphNode, masks: DataPathDef | readonly DataPathDef[], options: RaphObserveDataOptions): Disposer;
+    /**
+     * Регистрирует tracked executor указанной phase.
+     */
+    track(node: RaphNode, masks: DataPathDef | readonly DataPathDef[], options: RaphTrackOptions): Disposer;
+    /**
+     * Помечает node и зависимых владельцев как требующих выполнения.
+     */
+    invalidate(node: RaphNode, phase: string): void;
+    /**
+     * Синхронно выполняет все готовые очереди pipeline.
+     */
+    flush(): void;
+    /**
+     * Останавливает scheduler и удаляет observers, tasks и phase definitions.
+     */
+    dispose(): void;
+    /**
+     * Показывает наличие запланированной или выполняемой работы pipeline.
+     * @internal
+     */
+    _debugPending(): boolean;
+    private _addObserver;
+    private _ensureKernelWatch;
+    private _assertRetainedPhases;
+    private _receive;
+    private _queue;
+    private _schedule;
+    private _cancelScheduled;
+    private _nextFrame;
+    private _hasPending;
+    private _expandContexts;
+    private _assertAlive;
+}

package/dist/runtime/RaphRuntime.d.ts

@@ -0,0 +1,285 @@
+import { DataPathDef, PathEvents, PathOptions } from '../path/path.types';
+import { DerivedOptions, RaphDerivedHandle } from '../path/RaphDerivedHandle';
+import { RaphKernelRoot, RaphKernel } from '../path/RaphKernel';
+import { Disposer, ReadonlySignal, Signal, WatchOptions, WatchSource, WatchValue, WritableComputedOptions } from '../reactivity/types';
+import { DepGraph } from './parent-graph';
+import { FrameLoopLease, RaphEffectOptions, RaphObserveDataOptions, RaphPhase, RaphSchedulerMode, RaphTrackOptions } from './phase.types';
+import { RaphRuntimeDebug } from './RaphDebug';
+import { NodeOptions, RaphNode } from './RaphNode';
+import { RaphMeta } from '../path/RaphMeta';
+import { PathHandle } from './PathHandle';
+import { RaphScope } from './RaphScope';
+import { RuntimeReactivity } from './RuntimeReactivity';
+export interface RaphRuntimeOptions {
+    readonly id?: string;
+    readonly kernel?: RaphKernel;
+    readonly enforceActions?: boolean;
+    readonly scheduler?: RaphSchedulerMode;
+}
+export interface RaphRuntimeConfiguration {
+    readonly id: string;
+    readonly kernel: RaphKernel;
+    readonly enforceActions: boolean;
+    readonly scheduler: RaphSchedulerMode;
+}
+/**
+ * Один изолированный signal execution-plane поверх собственного или shared Kernel.
+ */
+export declare class RaphRuntime {
+    private static _runtimeCounter;
+    readonly configuration: RaphRuntimeConfiguration;
+    readonly rootScope: RaphScope;
+    readonly root: RaphNode;
+    private readonly _reactivity;
+    private readonly _signalLifecycle;
+    private _pathHandles;
+    private _meta;
+    private _phases;
+    private _frameLoop;
+    private _frameRevision;
+    private _frameRevisionValue;
+    private _debug;
+    private _parentGraph;
+    private readonly _owners;
+    private _transactionDepth;
+    private _mutationDepth;
+    private _kernelTransactionDepth;
+    private _actionDepth;
+    private _executionRequested;
+    private _disposed;
+    private readonly _disposedListeners;
+    /**
+     * Создаёт изолированный execution graph поверх собственного или shared Kernel.
+     */
+    constructor(options?: RaphRuntimeOptions);
+    /**
+     * Возвращает внутренний runtime reactivity adapter.
+     * @internal
+     */
+    _getReactivity(): RuntimeReactivity;
+    /**
+     * Возвращает стабильный идентификатор runtime.
+     */
+    get id(): string;
+    /**
+     * Возвращает data/meta Kernel этого runtime.
+     */
+    get kernel(): RaphKernel;
+    /**
+     * Возвращает лениво созданный runtime-owned metadata facade.
+     */
+    get meta(): RaphMeta;
+    /**
+     * Показывает, освобождён ли runtime.
+     */
+    get disposed(): boolean;
+    /**
+     * Возвращает лениво созданное read-only представление ownership graph.
+     */
+    get graph(): DepGraph;
+    /**
+     * Показывает, удерживается ли автоматический frame-loop.
+     */
+    get loopEnabled(): boolean;
+    /**
+     * Возвращает последний frame context runtime pipeline.
+     */
+    get frame(): Readonly<{
+        now: number;
+        delta: number;
+        elapsed: number;
+        frame: number;
+    }>;
+    /**
+     * Возвращает текущее определение runtime phases.
+     */
+    get phases(): readonly RaphPhase[];
+    /**
+     * Формирует диагностический снимок materialized derived registry.
+     */
+    getDerivedSnapshot(): ReturnType<RaphKernel['getDerivedSnapshot']>;
+    /**
+     * Возвращает лениво созданную read-only диагностику runtime и ownership tree.
+     */
+    get debug(): RaphRuntimeDebug;
+    /**
+     * Создаёт writable signal, принадлежащий указанному owner.
+     */
+    signal<T>(value: T, owner?: RaphScope): Signal<T>;
+    /**
+     * Создаёт computed, принадлежащий указанному owner.
+     */
+    computed<T>(getter: () => T, owner?: RaphScope): ReadonlySignal<T>;
+    computed<T>(options: WritableComputedOptions<T>, owner?: RaphScope): Signal<T>;
+    /**
+     * Создаёт реактивный effect и регистрирует его lifecycle у owner.
+     */
+    effect(callback: () => void | Disposer, owner?: RaphScope): Disposer;
+    effect(phase: string, callback: () => void | Disposer, options?: RaphEffectOptions, owner?: RaphScope): Disposer;
+    /**
+     * Подписывает runtime owner на path- либо signal-изменения.
+     */
+    watch(masks: DataPathDef | readonly DataPathDef[], callback: (payload: PathEvents) => void | Disposer, options?: WatchOptions, owner?: RaphScope): Disposer;
+    watch<S extends WatchSource | readonly WatchSource[]>(source: S, callback: (value: WatchValue<S>, previous: WatchValue<S> | undefined) => void | Disposer, options?: WatchOptions, owner?: RaphScope): Disposer;
+    /**
+     * Возвращает кешируемый runtime-owned handle canonical path.
+     */
+    path<T>(path: DataPathDef, options?: PathOptions): PathHandle<T>;
+    /**
+     * Возвращает весь path-root Kernel с обычным tracking чтения.
+     */
+    get<T = RaphKernelRoot>(): T | undefined;
+    /**
+     * Возвращает значение Kernel по пути с runtime lifecycle checks.
+     */
+    get<T = unknown>(path: DataPathDef, options?: PathOptions): T | undefined;
+    /**
+     * Читает весь path-root Kernel без регистрации реактивной зависимости.
+     */
+    peek<T = RaphKernelRoot>(): T | undefined;
+    /**
+     * Читает значение Kernel без регистрации реактивной зависимости.
+     */
+    peek<T = unknown>(path: DataPathDef, options?: PathOptions): T | undefined;
+    /**
+     * Проверяет наличие значения Kernel по пути.
+     */
+    has(path: DataPathDef, options?: PathOptions): boolean;
+    /**
+     * Записывает значение Kernel внутри runtime write policy.
+     */
+    set<T>(path: DataPathDef, value: T, options?: PathOptions): void;
+    /**
+     * Объединяет значение Kernel внутри runtime write policy.
+     */
+    merge(path: DataPathDef, value: unknown, options?: PathOptions): void;
+    /**
+     * Удаляет значение Kernel внутри runtime write policy.
+     */
+    delete(path: DataPathDef, options?: PathOptions): void;
+    /**
+     * Выполняет операцию в общей синхронной transaction boundary.
+     */
+    transaction<T>(operation: () => T): T;
+    /**
+     * Создаёт именованную action boundary для разрешённых записей.
+     */
+    action<Args extends unknown[], Result>(name: string, operation: (...args: Args) => Result, owner?: RaphScope): (...args: Args) => Result;
+    /**
+     * Выполняет операцию внутри action boundary.
+     */
+    runInAction<T>(_name: string, operation: () => T): T;
+    /**
+     * Выполняет операцию без регистрации реактивных зависимостей.
+     */
+    untracked<T>(operation: () => T): T;
+    /**
+     * Создаёт дочерний lifecycle scope.
+     */
+    scope(id: string): RaphScope;
+    /**
+     * Создаёт дочерний execution node.
+     */
+    node<TApi>(options: NodeOptions, setup: (node: RaphNode) => TApi): RaphNode<TApi>;
+    /**
+     * Находит принадлежащий runtime node по id для диагностики.
+     */
+    getNode(id: string): RaphNode | undefined;
+    /**
+     * Заменяет полное определение phase pipeline до его первого выполнения.
+     */
+    definePhases(phases: readonly RaphPhase[]): void;
+    /**
+     * Добавляет phase до первого выполнения pipeline.
+     */
+    addPhase(phase: RaphPhase): void;
+    /**
+     * Удаляет пользовательские phases до первого выполнения pipeline.
+     */
+    clearPhases(): void;
+    /**
+     * Регистрирует path observer в phase pipeline.
+     */
+    observeData(node: RaphNode, masks: DataPathDef | readonly DataPathDef[], options: RaphObserveDataOptions): Disposer;
+    /**
+     * Регистрирует tracked executor указанной phase.
+     */
+    track(node: RaphNode, masks: DataPathDef | readonly DataPathDef[], options?: RaphTrackOptions): Disposer;
+    /**
+     * Помечает node для выполнения в pipeline.
+     */
+    invalidateNode(node: RaphNode, phase: string): void;
+    /**
+     * Синхронно выполняет все готовые очереди pipeline.
+     */
+    flush(): void;
+    /**
+     * Получает lease автоматического frame-loop.
+     */
+    acquireLoop(owner: string): FrameLoopLease;
+    /**
+     * Запускает manual lease автоматического frame-loop.
+     */
+    startLoop(): void;
+    /**
+     * Останавливает manual lease автоматического frame-loop.
+     */
+    stopLoop(): void;
+    /**
+     * Создаёт управляемое derived-представление source path в target path.
+     */
+    derive<TSource, TTarget>(options: DerivedOptions<TSource, TTarget>): RaphDerivedHandle<TSource, TTarget>;
+    /**
+     * Освобождает execution graph и отсоединяет runtime от shared Kernel.
+     */
+    dispose(): void;
+    /**
+     * Регистрирует listener освобождения runtime.
+     * @internal
+     */
+    _onDisposed(listener: () => void): Disposer;
+    private _watchPath;
+    private _createDebugSnapshot;
+    private _watchMeta;
+    private _watchMetaInPhase;
+    private _releasePathHandle;
+    private get _execution();
+    private get _clock();
+    private _tickFrameLoop;
+    private _attachWritableComputed;
+    private _own;
+    /**
+     * Регистрирует lifecycle owner в runtime registry.
+     * @internal
+     */
+    _registerOwner(owner: RaphScope): void;
+    /**
+     * Удаляет lifecycle owner из runtime registry.
+     * @internal
+     */
+    _unregisterOwner(owner: RaphScope): void;
+    /**
+     * Проверяет, что owner принадлежит этому живому runtime.
+     * @internal
+     */
+    _assertOwnerRuntime(owner: RaphScope): void;
+    private _runTracked;
+    private _runUntracked;
+    private _runWrite;
+    private _requestExecution;
+    /**
+     * Открывает shared Kernel transaction для runtime.
+     * @internal
+     */
+    _beginKernelTransaction(): void;
+    /**
+     * Закрывает shared Kernel transaction и запускает отложенное выполнение.
+     * @internal
+     */
+    _endKernelTransaction(): void;
+    private _assertTrackedRead;
+    private _assertWriteAllowed;
+    private _throwCrossRuntime;
+    private _throwDisposed;
+    private _assertAlive;
+}

package/dist/runtime/RaphScope.d.ts

@@ -0,0 +1,50 @@
+import { Disposer, ReadonlySignal, Signal, WatchOptions, WatchSource, WatchValue, WritableComputedOptions } from '../reactivity/types';
+import { RaphEffectOptions } from './phase.types';
+import { RaphRuntime } from './RaphRuntime';
+import { ScopeNode } from '../reactivity/scope';
+/**
+ * Владеет группой runtime-ресурсов без участия в дереве исполнения.
+ */
+export declare class RaphScope extends ScopeNode {
+    readonly id: string;
+    readonly runtime: RaphRuntime;
+    /**
+     * Создаёт lifecycle scope внутри указанного runtime.
+     */
+    constructor(id: string, runtime: RaphRuntime);
+    /**
+     * Создаёт writable signal, принадлежащий указанному owner.
+     */
+    signal<T>(value: T): Signal<T>;
+    /**
+     * Создаёт computed, принадлежащий указанному owner.
+     */
+    computed<T>(getter: () => T): ReadonlySignal<T>;
+    computed<T>(options: WritableComputedOptions<T>): Signal<T>;
+    /**
+     * Создаёт реактивный effect и регистрирует его lifecycle у owner.
+     */
+    effect(callback: () => void | Disposer): Disposer;
+    effect(phase: string, callback: () => void | Disposer, options?: RaphEffectOptions): Disposer;
+    /**
+     * Подписывает callback и привязывает disposer к lifecycle scope.
+     */
+    watch<S extends WatchSource | readonly WatchSource[]>(source: S, callback: (value: WatchValue<S>, previous: WatchValue<S> | undefined) => void | Disposer, options?: WatchOptions): Disposer;
+    /**
+     * Создаёт action, выполнение которой привязано к lifecycle scope.
+     */
+    action<Args extends unknown[], Result>(name: string, operation: (...args: Args) => Result): (...args: Args) => Result;
+    /**
+     * Выполняет runtime cleanup после освобождения scope.
+     */
+    protected _afterDispose(): void;
+    /**
+     * Возвращает диагностическое сообщение для освобождённого scope.
+     */
+    protected _disposalMessage(): string;
+    /**
+     * Запрещает операции после начала освобождения scope.
+     * @internal
+     */
+    _assertAlive(): void;
+}

package/dist/runtime/RuntimeReactivity.d.ts

@@ -0,0 +1,40 @@
+import { ScopeNode } from '../reactivity/scope';
+import { ReadonlySignal, Signal } from '../reactivity/types';
+import { RaphEffectInitialMode } from './phase.types';
+import { RuntimeEffectBinding, RuntimeSignalLifecycle } from './runtime-reactivity.types';
+import { RaphReactivity } from '../reactivity/engine';
+/**
+ * Внутренний policy adapter, наследующий реактивные алгоритмы без дублирования.
+ */
+export declare class RuntimeReactivity extends RaphReactivity {
+    private readonly _lifecycle;
+    private readonly _bindings;
+    /**
+     * Создаёт policy adapter реактивного графа для одного runtime.
+     */
+    constructor(_lifecycle: RuntimeSignalLifecycle);
+    /**
+     * Создаёт временную registration boundary для runtime effect.
+     */
+    withEffectBinding<T>(binding: RuntimeEffectBinding | undefined, initial: RaphEffectInitialMode, operation: () => T): T;
+    /**
+     * Выполняет untracked-операцию, сохраняя runtime owner context.
+     */
+    untrackedWithOwner<T>(operation: () => T): T;
+    /**
+     * Возвращает owner текущего синхронного реактивного контекста.
+     */
+    getActiveOwner(): object | undefined;
+    /**
+     * Выполняет операцию с указанным active owner.
+     */
+    runWithOwner<T>(lifecycle: RuntimeSignalLifecycle | undefined, operation: () => T): T;
+    /**
+     * Создаёт owned signal с runtime lifecycle policy.
+     */
+    signalForOwner<T>(initialValue: T, owner?: ScopeNode): Signal<T>;
+    /**
+     * Создаёт owned computed с runtime lifecycle policy.
+     */
+    computedForOwner<T>(getter: () => T, owner?: ScopeNode): ReadonlySignal<T>;
+}

package/dist/runtime/RuntimeWatch.d.ts

@@ -0,0 +1,28 @@
+import { Disposer } from '../reactivity/types';
+/**
+ * Хранит общий callback/cleanup lifecycle Runtime-watch без знания источника
+ * событий. Регистрация в Kernel и фазовая доставка остаются у Runtime.
+ */
+export declare class RuntimeWatch {
+    private readonly _runUntracked;
+    private _cleanup;
+    private _stopped;
+    /**
+     * Создаёт runtime-owned watch с явным lifecycle остановки.
+     */
+    constructor(_runUntracked: <T>(operation: () => T) => T);
+    /**
+     * Показывает, остановлен ли watch.
+     */
+    get stopped(): boolean;
+    /**
+     * Освобождает предыдущий результат callback и выполняет новую доставку.
+     * Ошибка cleanup не лишает живой watcher текущего события.
+     */
+    deliver(callback: () => void | Disposer): void;
+    /**
+     * Останавливает внешнюю регистрацию и cleanup callback, сохраняя обе ошибки.
+     */
+    stop(stopSource?: Disposer): void;
+    private _attempt;
+}

package/dist/runtime/disposal.d.ts

@@ -0,0 +1 @@
+export declare function throwDisposalErrors(errors: unknown[], message?: string): void;

package/dist/runtime/errors.d.ts

@@ -0,0 +1,16 @@
+import { RaphError } from '../api/errors';
+/**
+ * Сообщает о записи вне action при включённом enforceActions.
+ */
+export declare class RaphActionError extends RaphError {
+}
+/**
+ * Сообщает об обращении к уже освобождённому runtime-owner.
+ */
+export declare class RaphDisposedError extends RaphError {
+}
+/**
+ * Сообщает о попытке связать owners из разных runtimes.
+ */
+export declare class RaphCrossRuntimeError extends RaphError {
+}

package/dist/runtime/parent-graph.d.ts

@@ -0,0 +1,5 @@
+import { RaphNode } from './RaphNode';
+export interface DepGraph<T extends RaphNode = RaphNode> {
+    parentsOf: (node: T) => ReadonlySet<T>;
+}
+export declare function parentGraph<T extends RaphNode>(): DepGraph<T>;

package/dist/runtime/phase.types.d.ts

@@ -0,0 +1,49 @@
+import { DataPathDef, PathEvent } from '../path/path.types';
+import { RaphNode } from './RaphNode';
+export declare const RaphSchedulerType: Readonly<{
+    readonly AnimationFrame: "animationFrame";
+    readonly Microtask: "microtask";
+    readonly Sync: "sync";
+}>;
+export type RaphSchedulerMode = typeof RaphSchedulerType[keyof typeof RaphSchedulerType];
+export type RaphPhaseTraversal = 'dirty-only' | 'dirty-and-down' | 'dirty-and-up' | 'all';
+export type RaphPhaseMode = 'dirty' | 'always';
+export type RaphEffectInitialMode = 'scheduled' | 'sync';
+export interface FrameLoopLease {
+    readonly owner: string;
+    release: () => void;
+}
+export interface RaphFrameContext {
+    readonly now: number;
+    readonly delta: number;
+    readonly elapsed: number;
+    readonly frame: number;
+}
+export interface RaphPhaseContext {
+    readonly phase: string;
+    readonly node: RaphNode<any>;
+    readonly frame: RaphFrameContext;
+    readonly events: readonly PathEvent[];
+}
+export interface RaphPhase {
+    readonly name: string;
+    readonly traversal: RaphPhaseTraversal;
+    readonly mode?: RaphPhaseMode;
+    readonly routes?: readonly DataPathDef[];
+    readonly nodes?: (node: RaphNode<any>) => boolean;
+    readonly each?: (context: RaphPhaseContext) => void;
+    readonly all?: (contexts: readonly RaphPhaseContext[]) => void;
+}
+export interface RaphEffectOptions {
+    readonly initial?: RaphEffectInitialMode;
+    readonly priority?: number;
+}
+export interface RaphObserveDataOptions {
+    readonly phase: string;
+    readonly vars?: Readonly<Record<string, unknown>>;
+    readonly wildcardDynamic?: boolean;
+}
+export interface RaphTrackOptions {
+    readonly vars?: Readonly<Record<string, unknown>>;
+    readonly wildcardDynamic?: boolean;
+}

package/dist/runtime/public.d.ts

@@ -0,0 +1,13 @@
+export { RaphActionError, RaphCrossRuntimeError, RaphDisposedError, } from './errors';
+export { parentGraph } from './parent-graph';
+export type { DepGraph } from './parent-graph';
+export { PathHandle } from './PathHandle';
+export { RaphSchedulerType } from './phase.types';
+export type { RaphPhaseContext as PhaseExecutorContext } from './phase.types';
+export type { FrameLoopLease, RaphEffectInitialMode, RaphEffectOptions, RaphFrameContext, RaphObserveDataOptions, RaphPhase, RaphPhaseContext, RaphPhaseMode, RaphPhaseTraversal, RaphSchedulerMode, RaphTrackOptions, } from './phase.types';
+export type { RaphDebugFrameLoopSnapshot, RaphDebugOwnerSnapshot, RaphDebugSnapshot, RaphRuntimeDebug, } from './RaphDebug';
+export { RaphNode } from './RaphNode';
+export type { NodeOptions } from './RaphNode';
+export { RaphRuntime } from './RaphRuntime';
+export type { RaphRuntimeConfiguration, RaphRuntimeOptions, } from './RaphRuntime';
+export { RaphScope } from './RaphScope';

package/dist/runtime/runtime-reactivity.types.d.ts

@@ -0,0 +1,9 @@
+import { EffectTask } from '../reactivity/types';
+export interface RuntimeSignalLifecycle {
+    owner: object | undefined;
+    assertWriteAllowed?: () => void;
+    runWrite?: <T>(operation: () => T) => T;
+    throwDisposed: () => never;
+    throwCrossRuntime: (owner: object) => never;
+}
+export type RuntimeEffectBinding = (run: () => void) => EffectTask;

package/dist/runtime.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./debug/runtime/errors.cjs"),r=require("./debug/runtime/parent-graph.cjs"),t=require("./debug/runtime/PathHandle.cjs"),p=require("./debug/runtime/phase.types.cjs"),a=require("./debug/runtime/RaphNode.cjs"),u=require("./debug/runtime/RaphRuntime.cjs"),o=require("./debug/runtime/RaphScope.cjs");exports.RaphActionError=e.RaphActionError;exports.RaphCrossRuntimeError=e.RaphCrossRuntimeError;exports.RaphDisposedError=e.RaphDisposedError;exports.parentGraph=r.parentGraph;exports.PathHandle=t.PathHandle;exports.RaphSchedulerType=p.RaphSchedulerType;exports.RaphNode=a.RaphNode;exports.RaphRuntime=u.RaphRuntime;exports.RaphScope=o.RaphScope;

package/dist/runtime.js

@@ -0,0 +1,18 @@
+import { RaphActionError as p, RaphCrossRuntimeError as e, RaphDisposedError as t } from "./debug/runtime/errors.js";
+import { parentGraph as h } from "./debug/runtime/parent-graph.js";
+import { PathHandle as R } from "./debug/runtime/PathHandle.js";
+import { RaphSchedulerType as x } from "./debug/runtime/phase.types.js";
+import { RaphNode as d } from "./debug/runtime/RaphNode.js";
+import { RaphRuntime as s } from "./debug/runtime/RaphRuntime.js";
+import { RaphScope as u } from "./debug/runtime/RaphScope.js";
+export {
+  R as PathHandle,
+  p as RaphActionError,
+  e as RaphCrossRuntimeError,
+  t as RaphDisposedError,
+  d as RaphNode,
+  s as RaphRuntime,
+  x as RaphSchedulerType,
+  u as RaphScope,
+  h as parentGraph
+};