@ersbeth/picoflow 2.3.2 → 3.0.0

package/dist/shared.js

@@ -0,0 +1,1496 @@
+//#region src/core/base/dependenciesRegistry.ts
+/**
+* Shared bookkeeping for the "set of sources this observer reads" half of the
+* dependency graph (A2-ARCH-5). `Observer` and `Node` both hold one instead of
+* each carrying their own `Set<IObservable<unknown>>` and reimplementing
+* register/unregister/clear.
+* @internal
+*/
+var DependenciesRegistry = class {
+	_dependencies = /* @__PURE__ */ new Set();
+	register(dependency, dependent) {
+		this._dependencies.add(dependency);
+		dependency.registerDependent(dependent);
+	}
+	unregister(dependency, dependent) {
+		this._dependencies.delete(dependency);
+		dependency.unregisterDependent(dependent);
+	}
+	clear(dependent) {
+		this._dependencies.forEach((dependency) => {
+			dependency.unregisterDependent(dependent);
+		});
+		this._dependencies.clear();
+	}
+	forEach(fn) {
+		Array.from(this._dependencies).forEach(fn);
+	}
+};
+
+//#endregion
+//#region src/core/base/dependentsRegistry.ts
+/**
+* Shared bookkeeping for the "set of watchers" half of the dependency graph
+* (A2-ARCH-5). `Observable` and `Node` both hold one instead of each carrying
+* their own `Set<IObserver>` and reimplementing register/unregister/notify.
+* @internal
+*/
+var DependentsRegistry = class {
+	_dependents = /* @__PURE__ */ new Set();
+	register(dependent) {
+		this._dependents.add(dependent);
+	}
+	unregister(dependent) {
+		this._dependents.delete(dependent);
+	}
+	notifyAll() {
+		this._dependents.forEach((dependent) => {
+			dependent.notify();
+		});
+	}
+	forEach(fn) {
+		Array.from(this._dependents).forEach(fn);
+	}
+};
+
+//#endregion
+//#region src/core/base/errors.ts
+/**
+* Base class for picoflow's typed errors, so a consumer can `catch` one with a single
+* `instanceof PicoFlowError` check instead of matching on message text. Every throw the library
+* raises is one of its subclasses, and every message carries the `[PicoFlow]` prefix.
+*
+* It is never thrown directly: catch it to handle any picoflow failure, and narrow to a subclass to
+* tell one kind from another.
+* @public
+*/
+var PicoFlowError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "PicoFlowError";
+	}
+};
+/**
+* Thrown when a disposed primitive (or its underlying scheduler) is read, written, or otherwise
+* used after `dispose()`.
+* @public
+*/
+var PicoFlowDisposedError = class extends PicoFlowError {
+	constructor(message) {
+		super(message);
+		this.name = "PicoFlowDisposedError";
+	}
+};
+/**
+* Thrown when the reactive flush detects a feedback loop that exceeds the maximum step guard.
+* @public
+*/
+var PicoFlowCycleError = class extends PicoFlowError {
+	constructor(message) {
+		super(message);
+		this.name = "PicoFlowCycleError";
+	}
+};
+/**
+* Thrown when a node reaches a state its own implementation considers unreachable. Reaching this
+* indicates a picoflow bug rather than a misuse of the public API.
+* @public
+*/
+var PicoFlowInternalError = class extends PicoFlowError {
+	constructor(message) {
+		super(message);
+		this.name = "PicoFlowInternalError";
+	}
+};
+/**
+* Thrown when a documented precondition of a public method is violated by the caller: a collection
+* operation naming an entry that does not exist (or, for `add`, one that already does), and
+* `from()`'s check on the value it was handed. Reaching this indicates a misuse of the API rather
+* than a picoflow bug, and the call had no effect (#123).
+* @public
+*/
+var PicoFlowPreconditionError = class extends PicoFlowError {
+	constructor(message) {
+		super(message);
+		this.name = "PicoFlowPreconditionError";
+	}
+};
+/**
+* Normalises a thrown value to an `Error`, so that every read path — `pick()`, `get()`, `value`,
+* and `subscribe`'s `onError` — surfaces the same type whatever the computation threw (A2-SEC-3,
+* #67). A genuine `Error` passes through by identity; anything else is wrapped, with its string
+* form as the message and the original value as `cause`.
+* @internal
+*/
+function toError(thrown) {
+	return thrown instanceof Error ? thrown : new Error(String(thrown), { cause: thrown });
+}
+
+//#endregion
+//#region src/core/base/liveNodeRegistry.ts
+/**
+* Census of every graph participant ever created, held weakly (#50, A2-DX-2).
+*
+* It is what an inspection dump reads. The graph has no roots of its own, and the nodes a census
+* exists to reveal — the ones leaked because nothing disposed them — are precisely the ones no
+* handle points at any more, so a traversal from caller-supplied roots could never reach them.
+*
+* Tracking is unconditional: an opt-in census misses everything built before it was switched on,
+* which is the confusing half-graph an introspection tool must never show. That puts its cost on
+* every node's construction, a path picoflow is already slow on, so it is pared to one
+* {@link WeakRef} and one array push. Two things it deliberately does not do: register with a
+* `FinalizationRegistry` (whose `register` measured four times the cost of the reference it was
+* there to clean up), and keep a `Set` (whose hashing measured half again the cost of the push).
+*
+* Entries are **not** removed on disposal: a disposed node something still references is forensic
+* evidence, and a dump filters it out by status instead. What removes an entry is the garbage
+* collector taking its target, after which the compaction below drops the empty reference — on
+* every read, and while writing whenever the census has doubled since it was last compacted.
+* @internal
+*/
+var LiveNodeRegistry = class LiveNodeRegistry {
+	static _refs = [];
+	/** Length the census has to reach before compacting is worth the walk. */
+	static _compactAt = 64;
+	/** Records a node. Called from the {@link Disposable} constructor, so nothing escapes the census. */
+	static track(node) {
+		if (LiveNodeRegistry._refs.length >= LiveNodeRegistry._compactAt) LiveNodeRegistry._compact();
+		LiveNodeRegistry._refs.push(new WeakRef(node));
+	}
+	/** Visits the nodes still alive, in creation order. Reads no status and touches no registry. */
+	static forEach(fn) {
+		LiveNodeRegistry._compact();
+		for (const ref of [...LiveNodeRegistry._refs]) {
+			const node = ref.deref();
+			if (node !== void 0) fn(node);
+		}
+	}
+	/**
+	* Empties the census.
+	*
+	* Test support, deliberately not part of the public `reset()`: that one returns the *scheduler*
+	* to its just-started state and documents that primitives created before it stay usable, so
+	* dropping them from the census there would hide live nodes. A suite asserting on the census
+	* needs the clean slate all the same, the census being process-global like the scheduler.
+	*/
+	static clear() {
+		LiveNodeRegistry._refs = [];
+		LiveNodeRegistry._compactAt = 64;
+	}
+	/**
+	* Drops the references whose target has been collected and sets the next compaction a doubling
+	* away, so the walk is amortised to a constant per node. In place, keeping creation order: a
+	* fresh array would allocate one slot per live node every time.
+	*/
+	static _compact() {
+		const refs = LiveNodeRegistry._refs;
+		let kept = 0;
+		for (let i = 0; i < refs.length; i++) {
+			const ref = refs[i];
+			if (ref.deref() !== void 0) refs[kept++] = ref;
+		}
+		refs.length = kept;
+		LiveNodeRegistry._compactAt = Math.max(64, kept * 2);
+	}
+};
+
+//#endregion
+//#region src/core/base/disposable.ts
+/**
+* Base implementation of the disposable pattern for reactive primitives.
+* Concrete subclasses implement `dispose()`, which is idempotent: a second call is a no-op.
+*/
+var Disposable = class Disposable {
+	static _nextId = 0;
+	_disposed = false;
+	_name;
+	/**
+	* Identity for introspection (#50): monotonic per process, assigned at construction and never
+	* reused, so the same node is recognisable across successive dumps — and so an unnamed one can
+	* still be labelled `kind#id` rather than being indistinguishable from its siblings.
+	* @internal
+	*/
+	_id = ++Disposable._nextId;
+	/**
+	* Which primitive this node belongs to, for introspection (#50).
+	*
+	* A plain field written once at construction rather than something an inspector works out
+	* afterwards: deriving it would mean keeping a map from every engine back to the facade that
+	* names it, and a `WeakMap.set` per node costs about as much as building the node did.
+	* @internal
+	*/
+	_kind = "unknown";
+	constructor(name) {
+		this._name = name;
+		LiveNodeRegistry.track(this);
+	}
+	/**
+	* The `name` given at creation, for introspection. A getter rather than making `_name` itself
+	* public: the field stays protected, as the error builders below are its only other readers.
+	* @internal
+	*/
+	get _inspectName() {
+		return this._name;
+	}
+	/** Builds the disposed-primitive error, naming the primitive when a `name` was given at creation. */
+	_disposedError() {
+		return new PicoFlowDisposedError(this._name ? `[PicoFlow] Primitive "${this._name}" is disposed` : "[PicoFlow] Primitive is disposed");
+	}
+	/**
+	* Releases the primitive when it leaves a `using` block, by delegating to {@link dispose}.
+	*
+	* Declared once here rather than per subclass: the standard `Disposable` protocol keys off this
+	* symbol, and every primitive reaches it through this base (A2-ARCH-2).
+	*/
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+};
+
+//#endregion
+//#region src/core/base/traceHub.ts
+/**
+* Where the engine reports what it is doing, for a trace to pick up (#50, A2-DX-2).
+*
+* The engine knows nothing about traces: it calls {@link emit} at the handful of points where
+* something happens, and the first thing `emit` does is return unless someone is listening. That
+* one boolean is the entire cost of tracing being available, which is what lets the hooks sit on
+* the flush path at all.
+*
+* What a listener does with an event — turning a node into a readable reference, keeping a bounded
+* history of them — belongs to the inspection layer, so that this stays free of any notion of how
+* a node is described.
+* @internal
+*/
+var TraceHub = class TraceHub {
+	/** Read before anything else on every hot path; kept in step with `_listeners` below. */
+	static enabled = false;
+	static _listeners = /* @__PURE__ */ new Set();
+	static emit(type, node) {
+		if (!TraceHub.enabled) return;
+		for (const listener of TraceHub._listeners) listener(type, node);
+	}
+	static listen(listener) {
+		TraceHub._listeners.add(listener);
+		TraceHub.enabled = true;
+	}
+	static unlisten(listener) {
+		TraceHub._listeners.delete(listener);
+		TraceHub.enabled = TraceHub._listeners.size > 0;
+	}
+};
+
+//#endregion
+//#region src/core/base/executionStack.ts
+/**
+* Global scheduler that batches and executes reactive computations asynchronously.
+*
+* Flush order: pending value nodes first, then effects, both in the next task.
+* That task is posted on a MessageChannel port, not setTimeout(0): the HTML spec clamps nested
+* timers to >= 4 ms (~5-6 ms per reactive round measured on Chromium/Firefox, A2-PERF-1), while
+* message tasks are never clamped — and fake timers cannot freeze them either (A2-RT-2).
+* Queues are index-drained so items appended mid-flush are not lost (see _drain).
+*/
+var ExecutionStack = class ExecutionStack {
+	static _MAX_FLUSH_STEPS = 1e4;
+	static _pendingQueue = [];
+	static _effectQueue = [];
+	static _executionScheduled;
+	/** Resolver of _executionScheduled, invoked by the flush task once the queues have drained. */
+	static _executionResolve;
+	/**
+	* Bumped by reset(). A posted flush carries the generation it was scheduled under; a message
+	* arriving with a stale generation is a flush reset() cancelled, and is dropped on delivery —
+	* MessageChannel has no clearTimeout equivalent.
+	*/
+	static _flushGeneration = 0;
+	/** Lazily created channel carrying flush tasks; post schedules, receive drains. */
+	static _flushChannel;
+	/** Handle of the fallback timer backing _executionScheduled where MessageChannel is missing. */
+	static _executionTimer;
+	static _coalesceResetScheduled = false;
+	/** Per-effect resets accumulated for the microtask scheduled below, so notifying more than one
+	* effect in the same sync turn doesn't discard every reset after the first (A2-SEM-5). */
+	static _coalesceResets = /* @__PURE__ */ new Set();
+	/** Routes any error escaping the flush loop; defaults to logging rather than crashing (A2-SEM-2, A2-SEC-1). */
+	static _onFlushError = (error) => console.error(error);
+	/**
+	* True once the current synchronous call stack has finished and microtasks have started.
+	* EffectNode uses this to treat microtask notifications (e.g. async resolve) differently
+	* from coalesced sync-batch notifications.
+	*/
+	static _pastSyncTurn = false;
+	/** @internal Used by EffectNode to distinguish sync-batch from microtask notifications. */
+	static get pastSyncTurn() {
+		return ExecutionStack._pastSyncTurn;
+	}
+	/**
+	* @internal Runs after the current sync turn ends (queueMicrotask).
+	* Marks pastSyncTurn so the next coalesced effect notify can bump its epoch,
+	* and resets per-effect coalesce flags via onReset.
+	*/
+	static scheduleCoalesceReset(onReset) {
+		ExecutionStack._coalesceResets.add(onReset);
+		if (ExecutionStack._coalesceResetScheduled) return;
+		ExecutionStack._coalesceResetScheduled = true;
+		queueMicrotask(() => {
+			ExecutionStack._pastSyncTurn = true;
+			ExecutionStack._coalesceResetScheduled = false;
+			const resets = ExecutionStack._coalesceResets;
+			ExecutionStack._coalesceResets = /* @__PURE__ */ new Set();
+			resets.forEach((reset) => {
+				reset();
+			});
+		});
+	}
+	/** @internal Wired to the public `onFlushError()` API in `src/api/base/flowConfig.ts`. */
+	static setFlushErrorHandler(handler) {
+		ExecutionStack._onFlushError = handler;
+	}
+	/**
+	* @internal Wired to the public `reset()` API in `src/core/api/base/flowConfig.ts`.
+	*
+	* Discards every queue and flag, returning the scheduler to its just-started state (A2-ARCH-1).
+	* Queued work is dropped, not run: nodes left in the queues stay `dirty` and only recompute if
+	* something notifies them again.
+	*/
+	static reset() {
+		ExecutionStack._pendingQueue.length = 0;
+		ExecutionStack._effectQueue.length = 0;
+		ExecutionStack._flushGeneration++;
+		ExecutionStack._flushChannel?.receive.unref?.();
+		clearTimeout(ExecutionStack._executionTimer);
+		ExecutionStack._executionTimer = void 0;
+		ExecutionStack._executionScheduled = void 0;
+		ExecutionStack._executionResolve = void 0;
+		ExecutionStack._coalesceResets = /* @__PURE__ */ new Set();
+		ExecutionStack._coalesceResetScheduled = false;
+		ExecutionStack._pastSyncTurn = false;
+		ExecutionStack._onFlushError = (error) => console.error(error);
+	}
+	static pushPending(node) {
+		TraceHub.emit("queue-pending", node);
+		ExecutionStack._beginSyncTurn();
+		ExecutionStack._scheduleExecution();
+		ExecutionStack._pendingQueue.push(node);
+	}
+	static pushEffect(effect) {
+		TraceHub.emit("queue-effect", effect);
+		ExecutionStack._beginSyncTurn();
+		ExecutionStack._scheduleExecution();
+		ExecutionStack._effectQueue.push(effect);
+	}
+	static _beginSyncTurn() {
+		ExecutionStack._pastSyncTurn = false;
+	}
+	/** Lazily builds the channel carrying flush tasks and installs the drain handler. */
+	static _channel() {
+		if (!ExecutionStack._flushChannel) {
+			const { port1, port2 } = new MessageChannel();
+			const receive = port1;
+			receive.onmessage = (event) => {
+				if (event.data !== ExecutionStack._flushGeneration) return;
+				const resolve = ExecutionStack._executionResolve;
+				ExecutionStack._executionScheduled = void 0;
+				ExecutionStack._executionResolve = void 0;
+				receive.unref?.();
+				ExecutionStack._execute();
+				resolve?.();
+			};
+			receive.unref?.();
+			ExecutionStack._flushChannel = {
+				post: port2,
+				receive
+			};
+		}
+		return ExecutionStack._flushChannel;
+	}
+	static _scheduleExecution() {
+		if (ExecutionStack._executionScheduled) return;
+		if (typeof MessageChannel === "undefined") {
+			ExecutionStack._executionScheduled = new Promise((resolve) => {
+				ExecutionStack._executionTimer = setTimeout(() => {
+					ExecutionStack._executionScheduled = void 0;
+					ExecutionStack._executionTimer = void 0;
+					ExecutionStack._execute();
+					resolve();
+				}, 0);
+			});
+			return;
+		}
+		const channel = ExecutionStack._channel();
+		ExecutionStack._executionScheduled = new Promise((resolve) => {
+			ExecutionStack._executionResolve = resolve;
+		});
+		channel.receive.ref?.();
+		channel.post.postMessage(ExecutionStack._flushGeneration);
+	}
+	static _drain(queue) {
+		for (let i = 0; i < queue.length; i++) {
+			if (i >= ExecutionStack._MAX_FLUSH_STEPS) {
+				const looping = queue[i];
+				if (looping) TraceHub.emit("cycle-error", looping);
+				ExecutionStack._pendingQueue.length = 0;
+				ExecutionStack._effectQueue.length = 0;
+				ExecutionStack._reportFlushError(new PicoFlowCycleError("[PicoFlow] Reactive update cycle exceeded maximum depth"));
+				return;
+			}
+			const node = queue[i];
+			try {
+				node?.execute();
+			} catch (error) {
+				ExecutionStack._reportFlushError(error);
+			}
+		}
+		queue.length = 0;
+	}
+	/** Invokes the flush-error hook under a guard of its own (A4-CORR-1). The hook exists so an
+	* error escaping the flush cannot become an uncaught exception; a hook that throws must not
+	* reintroduce one, nor abandon the effects queued behind it. Reported to console.error — the
+	* documented default, and the only reporter that cannot itself be the broken one. */
+	static _reportFlushError(error) {
+		try {
+			ExecutionStack._onFlushError(error);
+		} catch (handlerError) {
+			console.error("[PicoFlow] the onFlushError handler threw", handlerError);
+			console.error(error);
+		}
+	}
+	static _execute() {
+		ExecutionStack._drain(ExecutionStack._pendingQueue);
+		ExecutionStack._drain(ExecutionStack._effectQueue);
+	}
+};
+
+//#endregion
+//#region src/core/base/observer.ts
+/**
+* Narrows the public tracker type to the internal observer it always is.
+*
+* The one place this conversion happens, and the only cast left in the graph-wiring path. It is safe
+* by construction rather than by inspection: {@link FlowTracker} is branded (A2-TYPE-3), the brand is
+* declared only on {@link Observer} and {@link Node}, and both implement {@link IObserver} — so no
+* value can reach here typed as a tracker without being one. A duck-typed object can still reach it
+* at runtime through a double cast on the caller's side, which is exactly the A2-RT-3 behaviour left
+* deliberately untouched.
+*/
+function asObserver(t) {
+	return t;
+}
+/**
+* Base implementation managing dependency tracking for reactive observers.
+*/
+var Observer = class extends Disposable {
+	_dependenciesRegistry = new DependenciesRegistry();
+	/** Set when a dependency disposed while this observer was queued; consumed by the next execute(). */
+	_dependencyDisposed = false;
+	/** Set while this observer awaits a flush; cleared at the start of execute(). */
+	_queued = false;
+	/**
+	* Reports this observer's lifecycle. Never throws, so a debugger or a `console.log` can inspect
+	* a released effect — the same reasoning as the observable `status` getter (A2-ARCH-2).
+	*/
+	get status() {
+		if (this._disposed) return "disposed";
+		return this._queued ? "queued" : "idle";
+	}
+	/** Visits the sources this observer currently reads, for introspection — see {@link Observable._forEachDependent}. @internal */
+	_forEachDependency(fn) {
+		this._dependenciesRegistry.forEach(fn);
+	}
+	markDependencyDisposed() {
+		this._dependencyDisposed = true;
+	}
+	registerDependency(dependency) {
+		if (this._disposed) throw this._disposedError();
+		this._dependenciesRegistry.register(dependency, this);
+	}
+	unregisterDependency(dependency) {
+		if (this._disposed) throw this._disposedError();
+		this._dependenciesRegistry.unregister(dependency, this);
+	}
+	clearDependencies() {
+		if (this._disposed) throw this._disposedError();
+		this._dependenciesRegistry.clear(this);
+	}
+	dispose() {
+		if (this._disposed) return;
+		this._dependenciesRegistry.clear(this);
+		this._disposed = true;
+	}
+};
+
+//#endregion
+//#region src/core/base/observable.ts
+/**
+* Base implementation managing the dependency graph for reactive observables.
+*/
+var Observable = class extends Disposable {
+	_dependentsRegistry = new DependentsRegistry();
+	_status = "resolved";
+	get status() {
+		if (this._disposed) return "disposed";
+		return this._status;
+	}
+	set status(status) {
+		if (this._disposed) throw this._disposedError();
+		this._status = status;
+	}
+	registerDependent(dependent) {
+		if (this._disposed) throw this._disposedError();
+		this._dependentsRegistry.register(dependent);
+	}
+	unregisterDependent(dependent) {
+		if (this._disposed) throw this._disposedError();
+		this._dependentsRegistry.unregister(dependent);
+	}
+	notifyDependents() {
+		if (this._disposed) return;
+		this._dependentsRegistry.notifyAll();
+	}
+	/**
+	* Visits the observers currently registered on this node, for introspection (#50).
+	*
+	* No disposal guard, unlike every mutating method here: an inspector must be able to describe a
+	* released node, and disposal has already emptied the registry, so a disposed node simply
+	* reports no dependent. Reading the edges registers nothing and computes nothing.
+	* @internal
+	*/
+	_forEachDependent(fn) {
+		this._dependentsRegistry.forEach(fn);
+	}
+	watch(tracker) {
+		if (this._disposed) throw this._disposedError();
+		asObserver(tracker).registerDependency(this);
+	}
+	trigger() {
+		if (this._disposed) throw this._disposedError();
+		this.notifyDependents();
+	}
+	/**
+	* Hook for subclasses that also hold dependencies ({@link Node}): runs inside {@link dispose}
+	* after the dependents are detached and before the disposal flag is set, so the override can
+	* still call the guarded unregister methods (A2-ARCH-5, #111).
+	*/
+	_disposeDependencies() {}
+	dispose() {
+		if (this._disposed) return;
+		this._dependentsRegistry.forEach((dependant) => {
+			dependant.markDependencyDisposed();
+			dependant.unregisterDependency(this);
+			this.unregisterDependent(dependant);
+		});
+		this._disposeDependencies();
+		this._disposed = true;
+	}
+};
+
+//#endregion
+//#region src/core/base/node.ts
+/**
+* Base implementation for reactive nodes that propagate changes through the dependency graph.
+*
+* A node is both observed and observing. The observed half — dependents registry, `status`,
+* `watch`, `trigger`, `notifyDependents`, `dispose` — is inherited from {@link Observable} rather
+* than copied (A2-ARCH-5, #34, #111); this class adds only the observing half, as guarded
+* delegations to {@link DependenciesRegistry}, the same shape {@link Observer} has.
+*/
+var Node = class extends Observable {
+	_dependenciesRegistry = new DependenciesRegistry();
+	/** Set when a dependency disposed while this node was dirty; consumed by the next execute(). */
+	_dependencyDisposed = false;
+	registerDependency(dependency) {
+		if (this._disposed) throw this._disposedError();
+		this._dependenciesRegistry.register(dependency, this);
+	}
+	unregisterDependency(dependency) {
+		if (this._disposed) throw this._disposedError();
+		this._dependenciesRegistry.unregister(dependency, this);
+	}
+	clearDependencies() {
+		if (this._disposed) throw this._disposedError();
+		this._dependenciesRegistry.clear(this);
+	}
+	/** Visits the sources this node currently reads, for introspection — see {@link Observable._forEachDependent}. @internal */
+	_forEachDependency(fn) {
+		this._dependenciesRegistry.forEach(fn);
+	}
+	markDependencyDisposed() {
+		this._dependencyDisposed = true;
+	}
+	/** Runs inside Observable.dispose(), before the disposal flag is set. */
+	_disposeDependencies() {
+		this._dependenciesRegistry.forEach((dependency) => {
+			this.unregisterDependency(dependency);
+		});
+	}
+};
+
+//#endregion
+//#region src/core/schedulers/pendingError.ts
+/**
+* Error thrown when an async computation is pending, encapsulating its promise for cascading dependencies.
+* @internal
+*/
+var PendingError = class extends Error {
+	pendingPromise;
+	constructor(promise) {
+		super("[PicoFlow] Computation is pending");
+		this.name = "PendingError";
+		this.pendingPromise = promise;
+	}
+};
+
+//#endregion
+//#region src/core/schedulers/asyncResolver.ts
+/**
+* Manages asynchronous computation lifecycle with iteration tracking to prevent race conditions.
+* @internal
+*/
+var AsyncResolver = class {
+	_compute;
+	_computed = Promise.withResolvers();
+	_iteration = 0;
+	_aborted = false;
+	_finished = false;
+	/** Set when the computation rejected with `PendingError`: it waits on a dependency (#113). */
+	_blocked = false;
+	constructor(compute) {
+		this._compute = compute;
+		this._computed.promise.catch(() => {});
+	}
+	get computed() {
+		return this._computed.promise;
+	}
+	get aborted() {
+		return this._aborted;
+	}
+	get finished() {
+		return this._finished;
+	}
+	get blocked() {
+		return this._blocked;
+	}
+	compute() {
+		if (this._finished) throw new PicoFlowInternalError("[PicoFlow] AsyncResolver: Can't restart a settled resolver");
+		if (this._aborted) throw new PicoFlowInternalError("[PicoFlow] AsyncResolver: Can't restart an aborted resolver");
+		this._iteration++;
+		this._blocked = false;
+		const currentIteration = this._iteration;
+		this._compute().then((value) => {
+			if (this._iteration === currentIteration && !this._aborted) this._resolve(value);
+		}).catch((error) => {
+			if (this._iteration === currentIteration && !this._aborted) {
+				if (error instanceof PendingError) this._blocked = true;
+				else this._reject(error);
+			}
+		});
+	}
+	overwrite(promise) {
+		if (this._finished) throw new PicoFlowInternalError("[PicoFlow] AsyncResolver: Can't overwrite a settled resolver");
+		if (this._aborted) throw new PicoFlowInternalError("[PicoFlow] AsyncResolver: Can't overwrite an aborted resolver");
+		this._iteration++;
+		this._blocked = false;
+		const currentIteration = this._iteration;
+		promise.then((value) => {
+			if (this._iteration === currentIteration && !this._aborted) this._resolve(value);
+		}).catch((error) => {
+			if (this._iteration === currentIteration && !this._aborted) this._reject(error);
+		});
+	}
+	_resolve(value) {
+		this._finished = true;
+		this._computed.resolve(value);
+	}
+	_reject(error) {
+		this._finished = true;
+		this._computed.reject(error);
+	}
+	abort() {
+		this._aborted = true;
+	}
+};
+
+//#endregion
+//#region src/core/schedulers/asyncScheduler.ts
+/**
+* Scheduler that manages asynchronous computation lifecycle with resolver instances.
+* @internal
+*/
+var AsyncScheduler = class {
+	inline = false;
+	_compute;
+	_resolver;
+	_onResolve;
+	_onReject;
+	_settled = Promise.withResolvers();
+	_disposed = false;
+	constructor(compute, onResolve, onReject) {
+		this._compute = compute;
+		this._onResolve = onResolve;
+		this._onReject = onReject;
+		this._resolver = new AsyncResolver(compute);
+		this._attachHandlers(this._resolver);
+	}
+	get settled() {
+		if (this._disposed) throw new PicoFlowDisposedError("[PicoFlow] ComputationScheduler is disposed");
+		return this._settled.promise;
+	}
+	get disposed() {
+		return this._disposed;
+	}
+	get blocked() {
+		return this._resolver.blocked;
+	}
+	wrap(value) {
+		return Promise.resolve(value);
+	}
+	chain(input, fn) {
+		return input.then((value) => fn(value));
+	}
+	overwrite(promise) {
+		if (this._disposed) throw new PicoFlowDisposedError("[PicoFlow] ComputationScheduler is disposed");
+		if (this._resolver.finished) {
+			this._resolver = new AsyncResolver(this._compute);
+			this._settled = Promise.withResolvers();
+			this._attachHandlers(this._resolver);
+		}
+		this._resolver.overwrite(promise);
+	}
+	compute() {
+		if (this._disposed) throw new PicoFlowDisposedError("[PicoFlow] ComputationScheduler is disposed");
+		if (this._resolver.finished) {
+			this._resolver = new AsyncResolver(this._compute);
+			this._settled = Promise.withResolvers();
+			this._attachHandlers(this._resolver);
+		}
+		this._resolver.compute();
+	}
+	_attachHandlers(resolver) {
+		const settled = this._settled;
+		resolver.computed.then((value) => {
+			if (this._disposed) return;
+			this._onResolve(value);
+		}).catch((error) => {
+			if (this._disposed) return;
+			this._onReject(error);
+		}).finally(() => settled.resolve());
+	}
+	dispose() {
+		this._resolver.abort();
+		this._disposed = true;
+		this._settled.resolve();
+	}
+};
+
+//#endregion
+//#region src/core/schedulers/syncResolver.ts
+/**
+* Manages synchronous computation lifecycle with abort and settled-state guards.
+* @internal
+*/
+var SyncResolver = class {
+	_compute;
+	_aborted = false;
+	_finished = false;
+	/** Set when the computation threw `PendingError`: it waits on a dependency (#113). */
+	_blocked = false;
+	_onValue;
+	_onError;
+	constructor(compute, onValue, onError) {
+		this._compute = compute;
+		this._onValue = onValue;
+		this._onError = onError;
+	}
+	get aborted() {
+		return this._aborted;
+	}
+	get finished() {
+		return this._finished;
+	}
+	get blocked() {
+		return this._blocked;
+	}
+	compute() {
+		if (this._finished) throw new PicoFlowInternalError("[PicoFlow] SyncResolver: Can't restart a settled resolver");
+		if (this._aborted) throw new PicoFlowInternalError("[PicoFlow] SyncResolver: Can't restart an aborted resolver");
+		this._blocked = false;
+		try {
+			const value = this._compute();
+			if (!this._finished && !this._aborted) {
+				this._finished = true;
+				this._onValue(value);
+			}
+		} catch (error) {
+			if (!this._finished && !this._aborted) {
+				if (error instanceof PendingError) this._blocked = true;
+				else {
+					this._finished = true;
+					this._onError(error);
+				}
+			}
+		}
+	}
+	overwrite(value) {
+		if (this._finished) throw new PicoFlowInternalError("[PicoFlow] SyncResolver: Can't overwrite a settled resolver");
+		if (this._aborted) throw new PicoFlowInternalError("[PicoFlow] SyncResolver: Can't overwrite an aborted resolver");
+		this._blocked = false;
+		this._finished = true;
+		this._onValue(value);
+	}
+	abort() {
+		this._aborted = true;
+	}
+};
+
+//#endregion
+//#region src/core/schedulers/syncScheduler.ts
+/**
+* Scheduler that manages synchronous computation lifecycle with resolver instances.
+* @internal
+*/
+var SyncScheduler = class {
+	inline = true;
+	_compute;
+	_resolver;
+	_onResolve;
+	_onReject;
+	_settled = Promise.withResolvers();
+	_disposed = false;
+	constructor(compute, onResolve, onReject) {
+		this._compute = compute;
+		this._onResolve = onResolve;
+		this._onReject = onReject;
+		this._resolver = this._newResolver();
+	}
+	get settled() {
+		return this._settled.promise;
+	}
+	get blocked() {
+		return this._resolver.blocked;
+	}
+	wrap(value) {
+		return value;
+	}
+	chain(input, fn) {
+		return fn(input);
+	}
+	/**
+	* Each resolver settles the deferred that was current when it was created — captured, not read
+	* at settlement time: the node's resolution handler may re-enter `overwrite()` with a queued
+	* write (#43, #113), which swaps `_settled` for a fresh deferred; the `pick()` awaiting the old
+	* one must still be released. Same shape as AsyncScheduler._attachHandlers.
+	*/
+	_newResolver() {
+		const settled = this._settled;
+		return new SyncResolver(this._compute, (value) => {
+			this._onResolve(value);
+			settled.resolve();
+		}, (error) => {
+			this._onReject(error);
+			settled.resolve();
+		});
+	}
+	overwrite(value) {
+		if (this._disposed) throw new PicoFlowDisposedError("[PicoFlow] ComputationScheduler is disposed");
+		if (this._resolver.finished) {
+			this._settled = Promise.withResolvers();
+			this._resolver = this._newResolver();
+		}
+		this._resolver.overwrite(value);
+	}
+	compute() {
+		if (this._disposed) throw new PicoFlowDisposedError("[PicoFlow] ComputationScheduler is disposed");
+		if (this._resolver.finished) {
+			this._settled = Promise.withResolvers();
+			this._resolver = this._newResolver();
+		}
+		this._resolver.compute();
+	}
+	dispose() {
+		this._resolver.abort();
+		this._disposed = true;
+		this._settled.resolve();
+	}
+};
+
+//#endregion
+//#region src/core/nodes/effectNode.ts
+/**
+* Reactive effect that automatically re-executes when its dependencies change.
+*
+* Scheduling uses epoch-based coalescing:
+* - Multiple dependency changes in the same synchronous turn produce one queue entry
+*   but may still require multiple runs when notifications arrive in later microtasks
+*   (e.g. async pending → resolved).
+* - Re-notifications during execute() (cascading effects) enqueue a fresh run because
+*   _queued is cleared at the start of execute().
+*
+* @internal
+*/
+var EffectNode = class extends Observer {
+	_kind = "effect";
+	_data;
+	_onData;
+	_onError;
+	_onPending;
+	/** True while this effect is already waiting in the effect queue for the next flush. */
+	/** Guards the single coalesced bump of _notifyEpoch while _queued during one sync turn. */
+	_coalescedWhileQueued = false;
+	/** Monotonic count of notifications that must eventually be executed. */
+	_notifyEpoch = 0;
+	/** How many notification epochs have been executed so far. */
+	_executedEpoch = 0;
+	/** Callbacks registered via {@link onDispose}, run once after dispose() tears down the graph edges. */
+	_disposeListeners = [];
+	constructor(data, onData, onError, onPending, name) {
+		super(name);
+		this._data = data;
+		this._onData = onData;
+		this._onError = onError;
+		this._onPending = onPending;
+		this._notifyEpoch = 1;
+		this.execute();
+	}
+	/**
+	* Registers a callback to run once this effect is disposed, after the graph edges are torn
+	* down. Lets a caller that wraps an effect (e.g. {@link ActionNode.subscribe}) attach its own
+	* teardown without patching `dispose` on the returned instance (A2-ARCH-8).
+	* @internal
+	*/
+	onDispose(fn) {
+		this._disposeListeners.push(fn);
+	}
+	dispose() {
+		if (this._disposed) return;
+		super.dispose();
+		this._disposeListeners.forEach((fn) => {
+			fn();
+		});
+	}
+	notify() {
+		if (this._disposed) throw this._disposedError();
+		if (this._queued) {
+			if (!this._coalescedWhileQueued) {
+				this._coalescedWhileQueued = true;
+				if (ExecutionStack.pastSyncTurn) this._notifyEpoch++;
+			}
+			return;
+		}
+		this._notifyEpoch++;
+		this._queued = true;
+		ExecutionStack.scheduleCoalesceReset(() => {
+			this._coalescedWhileQueued = false;
+		});
+		ExecutionStack.pushEffect(this);
+	}
+	execute() {
+		this._queued = false;
+		if (this._disposed) {
+			this._executedEpoch = this._notifyEpoch;
+			return;
+		}
+		if (this._dependencyDisposed) {
+			this._dependencyDisposed = false;
+			this._executedEpoch = this._notifyEpoch;
+			return;
+		}
+		const targetEpoch = this._notifyEpoch;
+		while (this._executedEpoch < targetEpoch) {
+			this._executedEpoch++;
+			if (this._disposed) {
+				this._executedEpoch = this._notifyEpoch;
+				return;
+			}
+			if (this._dependencyDisposed) {
+				this._dependencyDisposed = false;
+				this._executedEpoch = this._notifyEpoch;
+				return;
+			}
+			TraceHub.emit("effect-run", this);
+			try {
+				this.clearDependencies();
+				const data = this._data(this);
+				this._onData(data);
+			} catch (error) {
+				if (error instanceof PendingError) this._onPending?.();
+				else if (this._onError) this._onError(toError(error));
+				else throw error;
+			}
+		}
+	}
+};
+
+//#endregion
+//#region src/core/nodes/readableNode.ts
+/**
+* Global-registry symbol branding a {@link ReadableNode} instance, so `from()` can recognize a node
+* built by a different copy of the library — where its class objects, and thus `instanceof`, differ.
+* @internal
+*/
+const PICOFLOW_VALUE_NODE = Symbol.for("picoflow.node");
+/**
+* Public face of a reactive value: owns a {@link ValueCore} and implements `FlowValue` by delegating
+* to it. It has no graph membership of its own — the core is what other nodes depend on, what the
+* execution stack queues, and the tracker compute functions receive (A2-GOV-5, #71, #112 — step 2
+* of #110).
+*
+* This class carries the readers only. Each public primitive has a subclass that adds exactly the
+* mutators its interface declares — {@link ConstantNode}, {@link DerivationNode}, {@link StateNode},
+* {@link WritableDerivationNode}, {@link ArrayNode}, {@link MapNode} — so a method absent from a
+* primitive's type is absent from its prototype chain too (#114, step 4 of #110; closes #26, #32,
+* #108). `trigger()` is among those mutators: it stayed here one round longer, which let a constant
+* force its whole subtree to re-run, and moved down with the others in #132 (A3-ARCH-1). Sync and async are not classes: they differ by the core a facade is given, built with
+* {@link syncCore} or {@link asyncCore}.
+*
+* The core is a `#private` field, not an underscore-prefixed property: an ordinary property is
+* enumerable, so `JSON.stringify`, `Object.keys` or a spread of a primitive walked the whole engine —
+* current value included — into logs and persisted state (A2-SEC-5, #69). Subclasses reach it
+* through the protected `_core` accessor, a prototype getter nothing structural walks.
+* @internal
+*/
+var ReadableNode = class {
+	[PICOFLOW_VALUE_NODE] = true;
+	#core;
+	constructor(core, kind = "unknown") {
+		this.#core = core;
+		core._kind = kind;
+	}
+	/** The engine this facade delegates to. Subclasses narrow the input type by overriding it. */
+	get _core() {
+		return this.#core;
+	}
+	get status() {
+		return this._core.status;
+	}
+	get(tracker) {
+		return this._core.read(tracker, () => this._core.current, () => {
+			this._core.markPendingRead();
+			throw new PendingError(this._core.settled);
+		});
+	}
+	watch(tracker) {
+		this._core.read(tracker, () => void 0, () => {
+			this._core.markPendingRead();
+			throw new PendingError(this._core.settled);
+		});
+	}
+	async pick() {
+		return await this._core.read(void 0, () => this._core.current, () => this._core.settle());
+	}
+	/** Passive snapshot (A2-ARCH-10, #80) — see {@link ValueCore.snapshot}. */
+	get value() {
+		return this._core.snapshot();
+	}
+	/** Passive read of the cached value (A2-ARCH-10, #80); it survives disposal, so this does too. */
+	get latest() {
+		return this._core.current;
+	}
+	subscribe(onValue, onError, onPending, options) {
+		this._core.assertAlive();
+		return new EffectNode((t) => this.get(t), onValue, onError, onPending, options?.name);
+	}
+	dispose() {
+		this._core.dispose();
+	}
+	/** Releases the primitive when it leaves a `using` block, by delegating to {@link dispose}. */
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+};
+
+//#endregion
+//#region src/core/nodes/valueCore.ts
+/**
+* Engine behind every reactive value: the state (`status`, value, error), the scheduler, the graph
+* membership inherited from {@link Node}, the write queue, and the one status machine every read
+* goes through.
+*
+* A core has no public face of its own — {@link ReadableNode} owns one and implements `FlowValue` by
+* delegation (A2-GOV-5, #71, #112 — step 2 of #110). The core is what the registries hold, what the
+* `ExecutionStack` queues, and the `FlowTracker` handed to compute functions.
+*
+* One class serves sync and async values (#113 — step 3 of #110): `I` is the scheduler's input
+* type (the value itself, or a promise of it), and everything that used to tell the two apart is
+* asked of the {@link Scheduler} — `inline`, `blocked`, `wrap`, `chain`.
+* @internal
+*/
+var ValueCore = class extends Node {
+	_scheduler;
+	_value;
+	_error;
+	/** Set by {@link markPendingRead} when a dependent registers while this node is mid-flight. */
+	_hasPendingReader = false;
+	/**
+	* True only while the in-flight computation was started by a write, which already ran its own
+	* eager `notifyDependents()` cascade before this resolution. `refresh()` and a recompute pulled
+	* lazily after an upstream `notify()` have no such pre-cascade — for them, `_onResolve`'s own
+	* `notifyDependents()` call is the only notification, so it must never be skipped (A2-PERF-4).
+	*/
+	_pendingFromSet = false;
+	/** True once a value has resolved at least once, so `_value` is a real value and not the initial gap. */
+	_hasResolved = false;
+	/**
+	* Writes that arrived while the node was mid-flight, applied in call order on the settled value
+	* (A2-TYPE-1, #43). A `set` discards everything queued before it, so the queue is at most one
+	* `set` followed by `update`s.
+	*/
+	_ops = [];
+	/**
+	* Change detection for this node. Defaults to `===` rather than `Object.is`, which is what
+	* semantics guarantees 3 and 4 describe; a consumer opts out per primitive via the `equals`
+	* option (A2-SEM-4, A2-ARCH-6).
+	*/
+	_equals;
+	/**
+	* Built from a compute function that tracks dependencies, as opposed to a value or a lazy
+	* initializer. Decides whether a replacing write on a never-computed node must run the
+	* computation first so the dependency edges exist — see {@link overwrite} (#109).
+	*/
+	_derivation;
+	/**
+	* Recompute on dirty instead of on read (#118): `notify()` enqueues this node in the flush, so
+	* it computes without waiting for a reader. Only meaningful on a dependency-tracking compute
+	* function, so the option is gated on `_derivation` — `state`, `constant`, the collections and
+	* `signal` ignore it, as documented on {@link FlowPrimitiveOptions.eager}.
+	*/
+	_eager;
+	constructor(input, options, makeScheduler, derivation = false) {
+		super(options?.name);
+		this._derivation = derivation;
+		this._eager = derivation && (options?.eager ?? false);
+		this._equals = options?.equals ?? ((previous, next) => previous === next);
+		const builtFromValue = typeof input !== "function";
+		const compute = builtFromValue ? () => input : () => input(this, this._value);
+		this.status = "dirty";
+		this._scheduler = makeScheduler(compute, (value) => this._onResolve(value), (error) => this._onReject(error));
+		if (builtFromValue && this._scheduler.inline) this._scheduler.compute();
+		if (this._eager) ExecutionStack.pushPending(this);
+	}
+	/** Throws the disposed-primitive error when the core has been released; the guard every facade method starts with. */
+	assertAlive() {
+		if (this._disposed) throw this._disposedError();
+	}
+	/** Builds the "unreachable state" error, naming the primitive when a `name` was given at creation. */
+	internalError() {
+		return new PicoFlowInternalError(this._name ? `[PicoFlow] Internal error (${this._name})` : "[PicoFlow] Internal error");
+	}
+	/**
+	* Called just before a tracked read throws `PendingError`, i.e. a dependent registered while
+	* this node is mid-flight and has no other way to learn the computation later settled — so the
+	* post-resolve `notifyDependents()` cannot be skipped even if the value is unchanged (A2-PERF-4).
+	*/
+	markPendingRead() {
+		this._hasPendingReader = true;
+	}
+	/** Whether the in-flight computation waits on a pending dependency — see {@link Scheduler.blocked}. */
+	get blocked() {
+		return this._scheduler.blocked;
+	}
+	/** Whether this core recomputes on dirty rather than on read (#118), for introspection (#50). @internal */
+	get _isEager() {
+		return this._eager;
+	}
+	/** The promise the scheduler settles on; what a pending tracked read hands to `PendingError`. */
+	get settled() {
+		return this._scheduler.settled;
+	}
+	/**
+	* The one status machine behind `get()`, `watch()` and `pick()` (A2-GOV-5). `track` registers the
+	* caller as a dependent first; a `dirty` core computes, then the settled status is dispatched
+	* once: `resolved` → `onResolved`, `pending` → `onPending`, `error` → the error is thrown, and
+	* `disposed` — reachable only when the computation just run disposed its own node — throws the
+	* disposed error whichever way the node was being read (A2-ARCH-2).
+	*/
+	read(track, onResolved, onPending) {
+		this.assertAlive();
+		if (track) this.watch(track);
+		if (this.status === "dirty") this.execute();
+		switch (this.status) {
+			case "resolved": return onResolved();
+			case "error": throw this._error;
+			case "pending": return onPending();
+			case "disposed": throw this._disposedError();
+			/* v8 ignore next 2 */
+			case "dirty": throw this.internalError();
+		}
+	}
+	/** The raw cached value — what collections mutate in place, and what `latest` reports. */
+	get current() {
+		return this._value;
+	}
+	set current(value) {
+		this._value = value;
+	}
+	/**
+	* Passive snapshot (A2-ARCH-10, #80). No disposal guard on purpose: `status` already reports
+	* `"disposed"` instead of throwing, and an inspector must be able to read a released node.
+	*/
+	snapshot() {
+		const status = this.status;
+		switch (status) {
+			case "resolved": return {
+				status,
+				data: this._value
+			};
+			case "error": return {
+				status,
+				error: this._error
+			};
+			default: return { status };
+		}
+	}
+	/**
+	* Waits until the node leaves "pending". One settlement may not be enough: writes queued while
+	* the node was mid-flight are applied on the settled value by re-overwriting the scheduler,
+	* which hands out a fresh `settled` promise (A2-TYPE-1, #43).
+	*/
+	async settle() {
+		while (this.status === "pending") {
+			const settled = this._scheduler.settled;
+			await settled;
+			if (this.status === "disposed") throw this._disposedError();
+			/* v8 ignore next 3 */
+			if (this.status === "pending" && this._scheduler.settled === settled) throw this.internalError();
+		}
+		if (this.status === "resolved") return this._value;
+		if (this.status === "error") throw this._error;
+		throw this.internalError();
+	}
+	notify() {
+		if (this._disposed) throw this._disposedError();
+		if (this.status === "dirty") return;
+		TraceHub.emit("notify", this);
+		if (this.status === "pending" || this._eager) ExecutionStack.pushPending(this);
+		this.status = "dirty";
+		this.notifyDependents();
+	}
+	execute() {
+		if (this._disposed) return;
+		if (this.status !== "dirty") return;
+		if (this._dependencyDisposed && this._hasResolved && this._error === void 0) {
+			this._dependencyDisposed = false;
+			this.status = "resolved";
+			return;
+		}
+		this.run();
+	}
+	/** Unconditional computation: clears the dependencies and runs the scheduler. */
+	run() {
+		TraceHub.emit("execute", this);
+		this.clearDependencies();
+		this.status = "pending";
+		this._scheduler.compute();
+	}
+	dispose() {
+		this._ops = [];
+		super.dispose();
+		this._scheduler.dispose();
+	}
+	/**
+	* The `equals` comparator, guarded. `undefined` means it threw, in which case the node has
+	* already been failed with that error and the caller must abandon what it was doing: the write
+	* is not applied, the settlement is dropped (A3-SEM-2-b, #127).
+	*
+	* The two routes differ only in who notifies. At settlement `_onReject` is the node's own
+	* failure handler and its notification rules already apply; a write call has no settlement to
+	* notify for it, which is what `fail()` exists to cover (A3-SEM-2-a). `from` is a string rather
+	* than a callback so a comparison allocates nothing — it runs on every settlement.
+	*/
+	_compare(previous, next, from) {
+		try {
+			return this._equals(previous, next);
+		} catch (error) {
+			if (from === "settlement") this._onReject(error);
+			else this.fail(error);
+			return;
+		}
+	}
+	_onResolve(value) {
+		if (this._disposed) return;
+		TraceHub.emit("resolve", this);
+		if (this._ops.length > 0) {
+			this._applyOps(this._scheduler.wrap(value));
+			return;
+		}
+		let changed = true;
+		if (this._hasResolved) {
+			const same = this._compare(this._value, value, "settlement");
+			if (same === void 0) return;
+			changed = !same;
+		}
+		const hadPendingReader = this._hasPendingReader;
+		const pendingFromSet = this._pendingFromSet;
+		this._hasPendingReader = false;
+		this._pendingFromSet = false;
+		this.status = "resolved";
+		this._value = value;
+		this._hasResolved = true;
+		this._error = void 0;
+		if (this._scheduler.inline) return;
+		if (changed || hadPendingReader || !pendingFromSet) this.notifyDependents();
+	}
+	_onReject(error) {
+		if (this._disposed) return;
+		TraceHub.emit("reject", this);
+		const first = this._ops[0];
+		if (first?.kind === "set") {
+			this._applyOps(first.input, 1);
+			return;
+		}
+		this._ops = [];
+		this.status = "error";
+		this._error = toError(error);
+		if (this._scheduler.inline) return;
+		this.notifyDependents();
+	}
+	/**
+	* Fails the node from a write-path callback that threw, the way a failing computation fails it:
+	* the error is recorded and normalised through `toError`, `_value` is left on the last resolved
+	* value, and a `set()` recovers the node (A3-SEM-2-a, #126).
+	*
+	* The notification is the one thing that does not simply delegate. Inline, `_onReject` returns
+	* before notifying because an inline settlement always happens inside the call that will notify
+	* — `_overwrite`, `refresh()`. A callback that threw before any of those ran has no such caller,
+	* so the notification is issued here. A deferred scheduler is the opposite case: `_onReject`
+	* notifies for itself, and a second call here would notify twice.
+	*/
+	fail(error) {
+		this._onReject(error);
+		if (this._scheduler.inline) this.notifyDependents();
+	}
+	/**
+	* Chains the queued writes from `from` on `base` and hands the chain to the scheduler as a new
+	* input: the node stays pending and dependents never observe the intermediate value. Called
+	* from the settlement handlers, where the resolver is already marked finished, so `overwrite`
+	* starts a fresh resolver with its own `settled`. Inline, the chain is folded on the spot and a
+	* throwing updater fails the node like a computation would.
+	*/
+	_applyOps(base, from = 0) {
+		const ops = this._ops;
+		this._ops = [];
+		let chain = base;
+		try {
+			for (let i = from; i < ops.length; i++) {
+				const op = ops[i];
+				chain = op.kind === "set" ? op.input : this._scheduler.chain(chain, op.updater);
+			}
+		} catch (error) {
+			this._onReject(error);
+			return;
+		}
+		this.status = "pending";
+		this._pendingFromSet = true;
+		this._scheduler.overwrite(chain);
+	}
+	/**
+	* The replacing write behind `set()`. Returns whether the write is going to land: `false` only
+	* when the comparator dropped it as unchanged, `true` when it applied now or was queued to apply
+	* at settlement. Collections read that answer to keep `$lastAction` in step with the value view —
+	* a dropped write must not emit a `set` action (A3-SEC-1, #129).
+	*/
+	overwrite(input) {
+		this.assertAlive();
+		if (this.status === "dirty" && this._derivation) this.execute();
+		if (this.status === "pending" && this._scheduler.blocked) {
+			this._ops = [{
+				kind: "set",
+				input
+			}];
+			return true;
+		}
+		if (this.status === "resolved" && this._scheduler.inline) {
+			const same = this._compare(this._value, input, "write");
+			if (same === void 0 || same) return false;
+		}
+		this._ops = [];
+		this._overwrite(input);
+		return true;
+	}
+	/** The deriving write behind `update()`. */
+	update(updater) {
+		this.assertAlive();
+		if (this.status === "dirty") this.execute();
+		switch (this.status) {
+			case "resolved": {
+				let next;
+				try {
+					next = updater(this._value);
+				} catch (error) {
+					this.fail(error);
+					return;
+				}
+				if (this._scheduler.inline) {
+					const same = this._compare(this._value, next, "write");
+					if (same === void 0 || same) return;
+				}
+				this._overwrite(next);
+				return;
+			}
+			case "pending":
+				this._ops.push({
+					kind: "update",
+					updater
+				});
+				return;
+			case "error": return;
+			/* v8 ignore next 2 */
+			case "disposed": throw this._disposedError();
+			/* v8 ignore next 2 */
+			case "dirty": throw this.internalError();
+		}
+	}
+	_overwrite(input) {
+		this._ops = [];
+		this.status = "pending";
+		this._pendingFromSet = true;
+		this._scheduler.overwrite(input);
+		this.notifyDependents();
+	}
+	refresh() {
+		this.assertAlive();
+		const currentValue = this._value;
+		const currentStatus = this.status;
+		this.run();
+		if (this.status === "pending" && !this._scheduler.blocked) return;
+		switch (this.status) {
+			case "resolved": {
+				if (currentStatus !== "resolved") {
+					this.notifyDependents();
+					return;
+				}
+				const same = this._compare(currentValue, this._value, "write");
+				if (same === void 0 || same) return;
+				this.notifyDependents();
+				return;
+			}
+			case "error":
+			case "pending":
+			case "dirty":
+				this.notifyDependents();
+				return;
+			case "disposed": return;
+		}
+	}
+};
+/**
+* Builds the engine of a synchronous primitive: the input is the value itself and settlement is
+* inline. The facades take a built core, so which scheduler drives a primitive is decided here and
+* in {@link asyncCore} alone (#114, step 4 of #110). `derivation` marks a core built from a
+* dependency-tracking compute function rather than a lazy initializer (#109).
+* @internal
+*/
+function syncCore(input, options, derivation = false) {
+	return new ValueCore(input, options, (compute, onResolve, onReject) => new SyncScheduler(compute, onResolve, onReject), derivation);
+}
+/**
+* Builds the engine of an asynchronous primitive: the input is a promise of the value and settlement
+* is deferred — see {@link syncCore}.
+* @internal
+*/
+function asyncCore(input, options, derivation = false) {
+	return new ValueCore(input, options, (compute, onResolve, onReject) => new AsyncScheduler(compute, onResolve, onReject), derivation);
+}
+
+//#endregion
+export { PicoFlowPreconditionError as _, ReadableNode as a, Observable as c, TraceHub as d, LiveNodeRegistry as f, PicoFlowInternalError as g, PicoFlowError as h, PICOFLOW_VALUE_NODE as i, Observer as l, PicoFlowDisposedError as m, asyncCore as n, EffectNode as o, PicoFlowCycleError as p, syncCore as r, Node as s, ValueCore as t, ExecutionStack as u };