@graphrefly/graphrefly 0.45.0 → 0.47.0

package/dist/guarded-execution-BcdtxeBk.d.ts

@@ -0,0 +1,207 @@
+import { Node, Actor, PolicyRuleData } from '@graphrefly/pure-ts/core';
+import { Graph, GraphDescribeOutput, GraphOptions, GraphDescribeOptions } from '@graphrefly/pure-ts/graph';
+import { P as PolicyGateGraph, e as PolicyViolation } from './audit-BAXb3VOg.js';
+import { TopicGraph } from './utils/messaging/index.js';
+
+/**
+ * Composable safety layer (roadmap §9.0b — Tier 5.1 Wave-B rebuild).
+ *
+ * {@link guardedExecution} wraps any {@link Graph} with:
+ *
+ * - {@link policyGate} — reactive ABAC (Tier 2.3 rename of `policyEnforcer`),
+ *   policies stored as a `Node` so LLMs / humans can update them at runtime.
+ *   Full transitive dynamic coverage via `watchTopologyTree`.
+ * - Reactive {@link GuardedExecutionGraph.scopedDescribeNode} — a thin
+ *   delegate over `target.describe({ reactive: true, actor })` that re-derives
+ *   on every settle (topology change, error transition, actor swap).
+ * - The enforcer's `violations` topic is republished as `violations` on
+ *   the wrapper, composable with {@link graphLens}'s `health`.
+ * - The wrapper-level `lints` topic surfaces non-policy diagnostic warnings
+ *   (`empty-policies` / `audit-no-effect` / `no-actor`) so misconfigurations
+ *   are caught reactively rather than via thrown errors at scattered call sites.
+ * - The `scope` derived publishes the current configuration tuple
+ *   (`{actor, mode, policiesCount}`) for dashboards.
+ *
+ * V1 scope: policies + actor + reactive scoped describe + lints + scope.
+ * Budget-as-option is NOT in V1 — it requires a cost-tracking design that
+ * hasn't landed yet. Callers who need a budget limit today append a
+ * budget-aware {@link PolicyRuleData} to the policies list (check current
+ * cost and `deny` when exhausted).
+ *
+ * @module
+ */
+
+/** Diagnostic warning published on {@link GuardedExecutionGraph.lints}. */
+interface GuardedExecutionLint {
+    /**
+     * - `"empty-policies"` — `policies` Node emitted an empty array in
+     *   `mode: "enforce"`. Static empty arrays throw at construction; this
+     *   covers the reactive case.
+     * - `"audit-no-effect"` — `mode: "audit"` plus the target has no per-node
+     *   guards, so `scopedDescribeNode` filters by per-node guards only and
+     *   policies will never gate visibility (they still populate `violations`
+     *   on writes).
+     * - `"no-actor"` — neither a wrapper-configured nor per-call actor was
+     *   supplied. `scopedDescribeNode` falls back to "describe everything"
+     *   for the corresponding subscription.
+     */
+    kind: "empty-policies" | "audit-no-effect" | "no-actor";
+    message: string;
+    timestamp_ns: number;
+}
+/** Configuration tuple published on {@link GuardedExecutionGraph.scope}. */
+interface GuardedScope {
+    /** The wrapper-configured default actor, or `null` when none configured. */
+    actor: Actor | null;
+    mode: "audit" | "enforce";
+    /** Current policy count (reactive — re-emits on `policies` Node updates). */
+    policiesCount: number;
+}
+/** Options for {@link guardedExecution}. */
+interface GuardedExecutionOptions {
+    /**
+     * Policies enforced against every guarded write. Static list or a live
+     * `Node<readonly PolicyRuleData[]>` (LLM-updatable).
+     *
+     * **Empty-policies handling:**
+     * - Static empty array + `mode: "enforce"` throws `RangeError` at
+     *   construction (deny-by-default is almost certainly a misconfiguration).
+     * - Node-supplied empty array + `mode: "enforce"` emits a one-time
+     *   `"empty-policies"` lint on first such emission (the wrapper can't
+     *   throw mid-run — surface the warning reactively).
+     * - `mode: "audit"` tolerates empty policies (no guards stacked; policies
+     *   only feed the `violations` channel on writes).
+     */
+    policies: readonly PolicyRuleData[] | Node<readonly PolicyRuleData[]>;
+    /**
+     * Default actor used when the caller invokes
+     * {@link GuardedExecutionGraph.scopedDescribeNode} without an override.
+     * Accepts a static {@link Actor} or a `Node<Actor>` — when a Node is
+     * supplied, the reactive describe re-derives on every actor emission so
+     * harnesses binding a per-turn actor get a single live describe Node
+     * instead of re-creating one per turn.
+     *
+     * Omit to scope per-call only. A `"no-actor"` lint fires once per instance
+     * if neither a configured nor per-call actor is ever supplied (the
+     * resulting describe is unscoped — full visibility).
+     */
+    actor?: Actor | Node<Actor>;
+    /**
+     * `"enforce"` (default) — push guards onto target nodes so disallowed
+     * writes throw {@link GuardDenied}.
+     * `"audit"` — record would-be denials to the `violations` topic without
+     * blocking writes.
+     */
+    mode?: "audit" | "enforce";
+    /** Ring-buffer cap for the `violations` topic. Default 1000 (inherited from policyGate). */
+    violationsLimit?: number;
+    /** Ring-buffer cap for the `lints` topic. Default 64 — each lint kind fires at most once per instance. */
+    lintsLimit?: number;
+    /** Wrapper graph name. Default `${target.name}_guarded`. */
+    name?: string;
+    /** Wrapper graph options. */
+    graph?: GraphOptions;
+}
+/**
+ * Wrapper over a target {@link Graph} providing reactive ABAC + reactive
+ * scoped describe + diagnostic lints. Mounts a {@link PolicyGateGraph} under
+ * `enforcer`, a {@link TopicGraph} of {@link GuardedExecutionLint} under
+ * `lints`, and a `scope` derived publishing `{actor, mode, policiesCount}`.
+ *
+ * @category patterns
+ */
+declare class GuardedExecutionGraph extends Graph {
+    readonly enforcer: PolicyGateGraph;
+    readonly violations: TopicGraph<PolicyViolation>;
+    readonly lints: TopicGraph<GuardedExecutionLint>;
+    readonly scope: Node<GuardedScope>;
+    /**
+     * Canonical reactive describe scoped to the wrapper's configured `actor`.
+     * Subscribes ONCE at construction; lifecycle owned by the wrapper (disposed
+     * on `wrapper.destroy()`). Use this property for the common case
+     * (long-lived consumer wanting "describe scoped to my actor"); use
+     * {@link scopedDescribeNode} only when a per-call actor override or
+     * different `detail`/`fields` is required.
+     *
+     * Re-derives on every settle of the target graph: structural changes,
+     * status transitions (errors flip nodes into `"errored"`), and actor
+     * emissions (when a `Node<Actor>` is bound, including the SENTINEL bridge
+     * applied internally — see qa G1B).
+     */
+    readonly scopedDescribe: Node<GraphDescribeOutput>;
+    private readonly _target;
+    private readonly _actorNode;
+    private readonly _mode;
+    private readonly _firedLintKinds;
+    constructor(target: Graph, opts: GuardedExecutionOptions);
+    private _fireLint;
+    /**
+     * **Per-call escape hatch.** Prefer {@link scopedDescribe} (the mounted
+     * property) for the common case of "describe scoped to my actor." Use
+     * this method ONLY when you need a per-call actor override or different
+     * `detail`/`fields`/`filter`.
+     *
+     * Returns a live `Node<GraphDescribeOutput>` scoped to the supplied (or
+     * configured) actor, plus an explicit `dispose` for caller-controlled
+     * lifecycle. Re-derives on every settle of the target graph: structural
+     * changes, status transitions, and actor emissions (when a `Node<Actor>`
+     * is bound).
+     *
+     * **Lifecycle (qa G1A — EC1 fix).** Each call instantiates a fresh
+     * `target.describe({reactive: true})` handle (with its own version state,
+     * observe handle, transitive topology subscriptions, derived + keepalive).
+     * The caller MUST invoke the returned `dispose()` when finished to release
+     * these resources. Disposers ARE also tracked on the wrapper graph so
+     * `wrapper.destroy()` cleans up any handles the caller forgot — but a
+     * long-lived wrapper with heavy per-call usage will leak until destroy
+     * unless `dispose()` is called explicitly.
+     *
+     * @param actorOverride - Optional per-call override. Static {@link Actor}
+     *   or `Node<Actor>`. Omit to use the wrapper-configured default.
+     * @param opts - Standard {@link GraphDescribeOptions} fields (`detail`,
+     *   `fields`, `filter`). `actor` / `reactive` / `reactiveName` are
+     *   controlled by the wrapper.
+     * @returns `{node, dispose}` — `node` is the live describe Node; `dispose`
+     *   tears down the underlying reactive describe subscription idempotently.
+     */
+    scopedDescribeNode(actorOverride?: Actor | Node<Actor>, opts?: Omit<GraphDescribeOptions, "actor" | "reactive" | "reactiveName">): {
+        node: Node<GraphDescribeOutput>;
+        dispose: () => void;
+    };
+    /** The wrapped graph (escape hatch for tooling). */
+    get target(): Graph;
+}
+/**
+ * Wrap a {@link Graph} with {@link policyGate} plus a reactive scoped describe
+ * lens. Returns a {@link GuardedExecutionGraph} that can be mounted, diffed,
+ * or composed with {@link graphLens}.
+ *
+ * @param target - The graph to guard.
+ * @param opts - See {@link GuardedExecutionOptions}.
+ *
+ * @example
+ * ```ts
+ * const guarded = guardedExecution(app, {
+ *   actor: node<Actor>([], { initial: { type: "human", id: "alice" } }), // reactive — re-derive on swap
+ *   policies: [
+ *     { effect: "allow", action: "read", actorType: "human" },
+ *     { effect: "deny", action: "write", pathPattern: "system::*" },
+ *   ],
+ *   mode: "enforce",
+ * });
+ *
+ * // Canonical: subscribe to the mounted reactive describe (no per-call leak).
+ * guarded.scopedDescribe.subscribe((msgs) => { /* live describe per actor / topology change *\/ });
+ * // Per-call escape hatch (different actor / detail) — caller manages dispose.
+ * const detailed = guarded.scopedDescribeNode(undefined, { detail: "standard" });
+ * try { detailed.node.subscribe(/* … *\/); } finally { detailed.dispose(); }
+ * guarded.violations.events.subscribe(msgs => console.log("violations:", msgs));
+ * guarded.lints.events.subscribe(msgs => console.warn("lints:", msgs));
+ * guarded.scope.subscribe(msgs => console.log("scope:", msgs));
+ * ```
+ *
+ * @category patterns
+ */
+declare function guardedExecution(target: Graph, opts: GuardedExecutionOptions): GuardedExecutionGraph;
+
+export { GuardedExecutionGraph as G, type GuardedExecutionLint as a, type GuardedExecutionOptions as b, type GuardedScope as c, guardedExecution as g };

package/dist/guarded-execution-C-3hnP6A.d.cts

@@ -0,0 +1,207 @@
+import { Node, Actor, PolicyRuleData } from '@graphrefly/pure-ts/core';
+import { Graph, GraphDescribeOutput, GraphOptions, GraphDescribeOptions } from '@graphrefly/pure-ts/graph';
+import { P as PolicyGateGraph, e as PolicyViolation } from './audit-C_bPfkqS.cjs';
+import { TopicGraph } from './utils/messaging/index.cjs';
+
+/**
+ * Composable safety layer (roadmap §9.0b — Tier 5.1 Wave-B rebuild).
+ *
+ * {@link guardedExecution} wraps any {@link Graph} with:
+ *
+ * - {@link policyGate} — reactive ABAC (Tier 2.3 rename of `policyEnforcer`),
+ *   policies stored as a `Node` so LLMs / humans can update them at runtime.
+ *   Full transitive dynamic coverage via `watchTopologyTree`.
+ * - Reactive {@link GuardedExecutionGraph.scopedDescribeNode} — a thin
+ *   delegate over `target.describe({ reactive: true, actor })` that re-derives
+ *   on every settle (topology change, error transition, actor swap).
+ * - The enforcer's `violations` topic is republished as `violations` on
+ *   the wrapper, composable with {@link graphLens}'s `health`.
+ * - The wrapper-level `lints` topic surfaces non-policy diagnostic warnings
+ *   (`empty-policies` / `audit-no-effect` / `no-actor`) so misconfigurations
+ *   are caught reactively rather than via thrown errors at scattered call sites.
+ * - The `scope` derived publishes the current configuration tuple
+ *   (`{actor, mode, policiesCount}`) for dashboards.
+ *
+ * V1 scope: policies + actor + reactive scoped describe + lints + scope.
+ * Budget-as-option is NOT in V1 — it requires a cost-tracking design that
+ * hasn't landed yet. Callers who need a budget limit today append a
+ * budget-aware {@link PolicyRuleData} to the policies list (check current
+ * cost and `deny` when exhausted).
+ *
+ * @module
+ */
+
+/** Diagnostic warning published on {@link GuardedExecutionGraph.lints}. */
+interface GuardedExecutionLint {
+    /**
+     * - `"empty-policies"` — `policies` Node emitted an empty array in
+     *   `mode: "enforce"`. Static empty arrays throw at construction; this
+     *   covers the reactive case.
+     * - `"audit-no-effect"` — `mode: "audit"` plus the target has no per-node
+     *   guards, so `scopedDescribeNode` filters by per-node guards only and
+     *   policies will never gate visibility (they still populate `violations`
+     *   on writes).
+     * - `"no-actor"` — neither a wrapper-configured nor per-call actor was
+     *   supplied. `scopedDescribeNode` falls back to "describe everything"
+     *   for the corresponding subscription.
+     */
+    kind: "empty-policies" | "audit-no-effect" | "no-actor";
+    message: string;
+    timestamp_ns: number;
+}
+/** Configuration tuple published on {@link GuardedExecutionGraph.scope}. */
+interface GuardedScope {
+    /** The wrapper-configured default actor, or `null` when none configured. */
+    actor: Actor | null;
+    mode: "audit" | "enforce";
+    /** Current policy count (reactive — re-emits on `policies` Node updates). */
+    policiesCount: number;
+}
+/** Options for {@link guardedExecution}. */
+interface GuardedExecutionOptions {
+    /**
+     * Policies enforced against every guarded write. Static list or a live
+     * `Node<readonly PolicyRuleData[]>` (LLM-updatable).
+     *
+     * **Empty-policies handling:**
+     * - Static empty array + `mode: "enforce"` throws `RangeError` at
+     *   construction (deny-by-default is almost certainly a misconfiguration).
+     * - Node-supplied empty array + `mode: "enforce"` emits a one-time
+     *   `"empty-policies"` lint on first such emission (the wrapper can't
+     *   throw mid-run — surface the warning reactively).
+     * - `mode: "audit"` tolerates empty policies (no guards stacked; policies
+     *   only feed the `violations` channel on writes).
+     */
+    policies: readonly PolicyRuleData[] | Node<readonly PolicyRuleData[]>;
+    /**
+     * Default actor used when the caller invokes
+     * {@link GuardedExecutionGraph.scopedDescribeNode} without an override.
+     * Accepts a static {@link Actor} or a `Node<Actor>` — when a Node is
+     * supplied, the reactive describe re-derives on every actor emission so
+     * harnesses binding a per-turn actor get a single live describe Node
+     * instead of re-creating one per turn.
+     *
+     * Omit to scope per-call only. A `"no-actor"` lint fires once per instance
+     * if neither a configured nor per-call actor is ever supplied (the
+     * resulting describe is unscoped — full visibility).
+     */
+    actor?: Actor | Node<Actor>;
+    /**
+     * `"enforce"` (default) — push guards onto target nodes so disallowed
+     * writes throw {@link GuardDenied}.
+     * `"audit"` — record would-be denials to the `violations` topic without
+     * blocking writes.
+     */
+    mode?: "audit" | "enforce";
+    /** Ring-buffer cap for the `violations` topic. Default 1000 (inherited from policyGate). */
+    violationsLimit?: number;
+    /** Ring-buffer cap for the `lints` topic. Default 64 — each lint kind fires at most once per instance. */
+    lintsLimit?: number;
+    /** Wrapper graph name. Default `${target.name}_guarded`. */
+    name?: string;
+    /** Wrapper graph options. */
+    graph?: GraphOptions;
+}
+/**
+ * Wrapper over a target {@link Graph} providing reactive ABAC + reactive
+ * scoped describe + diagnostic lints. Mounts a {@link PolicyGateGraph} under
+ * `enforcer`, a {@link TopicGraph} of {@link GuardedExecutionLint} under
+ * `lints`, and a `scope` derived publishing `{actor, mode, policiesCount}`.
+ *
+ * @category patterns
+ */
+declare class GuardedExecutionGraph extends Graph {
+    readonly enforcer: PolicyGateGraph;
+    readonly violations: TopicGraph<PolicyViolation>;
+    readonly lints: TopicGraph<GuardedExecutionLint>;
+    readonly scope: Node<GuardedScope>;
+    /**
+     * Canonical reactive describe scoped to the wrapper's configured `actor`.
+     * Subscribes ONCE at construction; lifecycle owned by the wrapper (disposed
+     * on `wrapper.destroy()`). Use this property for the common case
+     * (long-lived consumer wanting "describe scoped to my actor"); use
+     * {@link scopedDescribeNode} only when a per-call actor override or
+     * different `detail`/`fields` is required.
+     *
+     * Re-derives on every settle of the target graph: structural changes,
+     * status transitions (errors flip nodes into `"errored"`), and actor
+     * emissions (when a `Node<Actor>` is bound, including the SENTINEL bridge
+     * applied internally — see qa G1B).
+     */
+    readonly scopedDescribe: Node<GraphDescribeOutput>;
+    private readonly _target;
+    private readonly _actorNode;
+    private readonly _mode;
+    private readonly _firedLintKinds;
+    constructor(target: Graph, opts: GuardedExecutionOptions);
+    private _fireLint;
+    /**
+     * **Per-call escape hatch.** Prefer {@link scopedDescribe} (the mounted
+     * property) for the common case of "describe scoped to my actor." Use
+     * this method ONLY when you need a per-call actor override or different
+     * `detail`/`fields`/`filter`.
+     *
+     * Returns a live `Node<GraphDescribeOutput>` scoped to the supplied (or
+     * configured) actor, plus an explicit `dispose` for caller-controlled
+     * lifecycle. Re-derives on every settle of the target graph: structural
+     * changes, status transitions, and actor emissions (when a `Node<Actor>`
+     * is bound).
+     *
+     * **Lifecycle (qa G1A — EC1 fix).** Each call instantiates a fresh
+     * `target.describe({reactive: true})` handle (with its own version state,
+     * observe handle, transitive topology subscriptions, derived + keepalive).
+     * The caller MUST invoke the returned `dispose()` when finished to release
+     * these resources. Disposers ARE also tracked on the wrapper graph so
+     * `wrapper.destroy()` cleans up any handles the caller forgot — but a
+     * long-lived wrapper with heavy per-call usage will leak until destroy
+     * unless `dispose()` is called explicitly.
+     *
+     * @param actorOverride - Optional per-call override. Static {@link Actor}
+     *   or `Node<Actor>`. Omit to use the wrapper-configured default.
+     * @param opts - Standard {@link GraphDescribeOptions} fields (`detail`,
+     *   `fields`, `filter`). `actor` / `reactive` / `reactiveName` are
+     *   controlled by the wrapper.
+     * @returns `{node, dispose}` — `node` is the live describe Node; `dispose`
+     *   tears down the underlying reactive describe subscription idempotently.
+     */
+    scopedDescribeNode(actorOverride?: Actor | Node<Actor>, opts?: Omit<GraphDescribeOptions, "actor" | "reactive" | "reactiveName">): {
+        node: Node<GraphDescribeOutput>;
+        dispose: () => void;
+    };
+    /** The wrapped graph (escape hatch for tooling). */
+    get target(): Graph;
+}
+/**
+ * Wrap a {@link Graph} with {@link policyGate} plus a reactive scoped describe
+ * lens. Returns a {@link GuardedExecutionGraph} that can be mounted, diffed,
+ * or composed with {@link graphLens}.
+ *
+ * @param target - The graph to guard.
+ * @param opts - See {@link GuardedExecutionOptions}.
+ *
+ * @example
+ * ```ts
+ * const guarded = guardedExecution(app, {
+ *   actor: node<Actor>([], { initial: { type: "human", id: "alice" } }), // reactive — re-derive on swap
+ *   policies: [
+ *     { effect: "allow", action: "read", actorType: "human" },
+ *     { effect: "deny", action: "write", pathPattern: "system::*" },
+ *   ],
+ *   mode: "enforce",
+ * });
+ *
+ * // Canonical: subscribe to the mounted reactive describe (no per-call leak).
+ * guarded.scopedDescribe.subscribe((msgs) => { /* live describe per actor / topology change *\/ });
+ * // Per-call escape hatch (different actor / detail) — caller manages dispose.
+ * const detailed = guarded.scopedDescribeNode(undefined, { detail: "standard" });
+ * try { detailed.node.subscribe(/* … *\/); } finally { detailed.dispose(); }
+ * guarded.violations.events.subscribe(msgs => console.log("violations:", msgs));
+ * guarded.lints.events.subscribe(msgs => console.warn("lints:", msgs));
+ * guarded.scope.subscribe(msgs => console.log("scope:", msgs));
+ * ```
+ *
+ * @category patterns
+ */
+declare function guardedExecution(target: Graph, opts: GuardedExecutionOptions): GuardedExecutionGraph;
+
+export { GuardedExecutionGraph as G, type GuardedExecutionLint as a, type GuardedExecutionOptions as b, type GuardedScope as c, guardedExecution as g };

package/dist/index-B6pxYJzO.d.cts

@@ -0,0 +1,36 @@
+import { Node } from '@graphrefly/pure-ts/core';
+
+/** Solid accessor function — returns current value when called. */
+type Accessor<T> = () => T;
+/**
+ * Subscribe to a `Node<T>` as a Solid signal. Auto-cleans up with the owning scope.
+ * Subscription lifecycle is tied to Solid scope cleanup (not node terminal messages).
+ */
+declare function useSubscribe<T>(node: Node<T>): Accessor<T | undefined | null>;
+/**
+ * Bind a writable `Node<T>` as a Solid resource tuple `[accessor, setter]`.
+ * Setter always forwards `[[DIRTY], [DATA, value]]`, including `value === undefined`.
+ * Subscription lifecycle is tied to Solid scope cleanup (not node terminal messages).
+ */
+declare function useStore<T>(node: Node<T>): [Accessor<T | undefined | null>, (v: T) => void];
+/** Maps a key to an object of nodes. Used by `useSubscribeRecord`. */
+type NodeFactory<K, R extends Record<string, any>> = (key: K) => {
+    [P in keyof R]: Node<R[P]>;
+};
+/**
+ * Subscribe to a dynamic set of keyed node records as a Solid accessor.
+ * Re-subscribes all per-key fields whenever `keys` changes.
+ * Key re-sync is gated to settled batches (`messageTier >= 3`) to avoid DIRTY-phase churn.
+ */
+declare function useSubscribeRecord<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory<K, R>): Accessor<Record<K, R>>;
+
+type index_Accessor<T> = Accessor<T>;
+type index_NodeFactory<K, R extends Record<string, any>> = NodeFactory<K, R>;
+declare const index_useStore: typeof useStore;
+declare const index_useSubscribe: typeof useSubscribe;
+declare const index_useSubscribeRecord: typeof useSubscribeRecord;
+declare namespace index {
+  export { type index_Accessor as Accessor, type index_NodeFactory as NodeFactory, index_useStore as useStore, index_useSubscribe as useSubscribe, index_useSubscribeRecord as useSubscribeRecord };
+}
+
+export { type Accessor as A, type NodeFactory as N, useSubscribe as a, useSubscribeRecord as b, index as i, useStore as u };

package/dist/index-B6pxYJzO.d.ts

@@ -0,0 +1,36 @@
+import { Node } from '@graphrefly/pure-ts/core';
+
+/** Solid accessor function — returns current value when called. */
+type Accessor<T> = () => T;
+/**
+ * Subscribe to a `Node<T>` as a Solid signal. Auto-cleans up with the owning scope.
+ * Subscription lifecycle is tied to Solid scope cleanup (not node terminal messages).
+ */
+declare function useSubscribe<T>(node: Node<T>): Accessor<T | undefined | null>;
+/**
+ * Bind a writable `Node<T>` as a Solid resource tuple `[accessor, setter]`.
+ * Setter always forwards `[[DIRTY], [DATA, value]]`, including `value === undefined`.
+ * Subscription lifecycle is tied to Solid scope cleanup (not node terminal messages).
+ */
+declare function useStore<T>(node: Node<T>): [Accessor<T | undefined | null>, (v: T) => void];
+/** Maps a key to an object of nodes. Used by `useSubscribeRecord`. */
+type NodeFactory<K, R extends Record<string, any>> = (key: K) => {
+    [P in keyof R]: Node<R[P]>;
+};
+/**
+ * Subscribe to a dynamic set of keyed node records as a Solid accessor.
+ * Re-subscribes all per-key fields whenever `keys` changes.
+ * Key re-sync is gated to settled batches (`messageTier >= 3`) to avoid DIRTY-phase churn.
+ */
+declare function useSubscribeRecord<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory<K, R>): Accessor<Record<K, R>>;
+
+type index_Accessor<T> = Accessor<T>;
+type index_NodeFactory<K, R extends Record<string, any>> = NodeFactory<K, R>;
+declare const index_useStore: typeof useStore;
+declare const index_useSubscribe: typeof useSubscribe;
+declare const index_useSubscribeRecord: typeof useSubscribeRecord;
+declare namespace index {
+  export { type index_Accessor as Accessor, type index_NodeFactory as NodeFactory, index_useStore as useStore, index_useSubscribe as useSubscribe, index_useSubscribeRecord as useSubscribeRecord };
+}
+
+export { type Accessor as A, type NodeFactory as N, useSubscribe as a, useSubscribeRecord as b, index as i, useStore as u };

package/dist/index-BFsng6v1.d.cts

@@ -0,0 +1,44 @@
+import { Node } from '@graphrefly/pure-ts/core';
+
+/**
+ * Subscribe to a read-only `Node<T>` as a React value. Re-renders on node value settlement.
+ * Subscription lifecycle is tied to React mount/unmount (not node terminal messages).
+ *
+ * @param node - Any `Node<T>`.
+ * @returns `T | undefined` — the current node value, kept in sync via `useSyncExternalStore`.
+ */
+declare function useSubscribe<T>(node: Node<T>): T | undefined | null;
+/**
+ * Bind a writable `Node<T>` as a React `[value, setter]` tuple.
+ * Setting the value always pushes `[[DIRTY], [DATA, value]]`, including `value === undefined`.
+ * Subscription lifecycle is tied to React mount/unmount (not node terminal messages).
+ *
+ * @param node - A `Node<T>` (e.g. state node).
+ * @returns `[T | undefined, (value: T) => void]` — current value and setter function.
+ */
+declare function useStore<T>(node: Node<T>): [T | undefined | null, (value: T) => void];
+/** Maps a key to an object of nodes. Used by `useSubscribeRecord`. */
+type NodeFactory<K, R extends Record<string, any>> = (key: K) => {
+    [P in keyof R]: Node<R[P]>;
+};
+/**
+ * Subscribe to a dynamic set of keyed node records.
+ * Re-subscribes all per-key fields whenever `keysNode` changes.
+ * Key re-sync is gated to settled batches (`messageTier >= 3`) to avoid DIRTY-phase churn.
+ * Guaranteed to clean up strictly with React hook lifecycle, utilizing no global mappings.
+ *
+ * @param keysNode - Node of current keys (e.g. node IDs)
+ * @param factory - Function returning `{ [field]: Node<V> }` for each key.
+ * @returns `Record<K, R>` — snapshot of resolved values for all keys.
+ */
+declare function useSubscribeRecord<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory<K, R>): Record<K, R>;
+
+type index_NodeFactory<K, R extends Record<string, any>> = NodeFactory<K, R>;
+declare const index_useStore: typeof useStore;
+declare const index_useSubscribe: typeof useSubscribe;
+declare const index_useSubscribeRecord: typeof useSubscribeRecord;
+declare namespace index {
+  export { type index_NodeFactory as NodeFactory, index_useStore as useStore, index_useSubscribe as useSubscribe, index_useSubscribeRecord as useSubscribeRecord };
+}
+
+export { type NodeFactory as N, useSubscribe as a, useSubscribeRecord as b, index as i, useStore as u };

package/dist/index-BFsng6v1.d.ts

@@ -0,0 +1,44 @@
+import { Node } from '@graphrefly/pure-ts/core';
+
+/**
+ * Subscribe to a read-only `Node<T>` as a React value. Re-renders on node value settlement.
+ * Subscription lifecycle is tied to React mount/unmount (not node terminal messages).
+ *
+ * @param node - Any `Node<T>`.
+ * @returns `T | undefined` — the current node value, kept in sync via `useSyncExternalStore`.
+ */
+declare function useSubscribe<T>(node: Node<T>): T | undefined | null;
+/**
+ * Bind a writable `Node<T>` as a React `[value, setter]` tuple.
+ * Setting the value always pushes `[[DIRTY], [DATA, value]]`, including `value === undefined`.
+ * Subscription lifecycle is tied to React mount/unmount (not node terminal messages).
+ *
+ * @param node - A `Node<T>` (e.g. state node).
+ * @returns `[T | undefined, (value: T) => void]` — current value and setter function.
+ */
+declare function useStore<T>(node: Node<T>): [T | undefined | null, (value: T) => void];
+/** Maps a key to an object of nodes. Used by `useSubscribeRecord`. */
+type NodeFactory<K, R extends Record<string, any>> = (key: K) => {
+    [P in keyof R]: Node<R[P]>;
+};
+/**
+ * Subscribe to a dynamic set of keyed node records.
+ * Re-subscribes all per-key fields whenever `keysNode` changes.
+ * Key re-sync is gated to settled batches (`messageTier >= 3`) to avoid DIRTY-phase churn.
+ * Guaranteed to clean up strictly with React hook lifecycle, utilizing no global mappings.
+ *
+ * @param keysNode - Node of current keys (e.g. node IDs)
+ * @param factory - Function returning `{ [field]: Node<V> }` for each key.
+ * @returns `Record<K, R>` — snapshot of resolved values for all keys.
+ */
+declare function useSubscribeRecord<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory<K, R>): Record<K, R>;
+
+type index_NodeFactory<K, R extends Record<string, any>> = NodeFactory<K, R>;
+declare const index_useStore: typeof useStore;
+declare const index_useSubscribe: typeof useSubscribe;
+declare const index_useSubscribeRecord: typeof useSubscribeRecord;
+declare namespace index {
+  export { type index_NodeFactory as NodeFactory, index_useStore as useStore, index_useSubscribe as useSubscribe, index_useSubscribeRecord as useSubscribeRecord };
+}
+
+export { type NodeFactory as N, useSubscribe as a, useSubscribeRecord as b, index as i, useStore as u };