@graphrefly/graphrefly 0.42.0 → 0.44.0

package/dist/chunk-XLQPNNIC.js

@@ -1 +0,0 @@
-import{a as I,b as P,c as V,d as j,f as _,g as w}from"./chunk-3G5U5QNE.js";import{a as C,b as D,c as $,d as R,g as A,h as S,i as N,j as h,k as T,l as F}from"./chunk-ACMJ2ZPS.js";import{a as m,b as g,c as k,d as v,e as O,f as E,g as G,h as x}from"./chunk-LYCLF26R.js";import{b as u}from"./chunk-CK2E7BTU.js";import{b as H}from"./chunk-QYADASLV.js";var q={};H(q,{ENVELOPE_VERSION:()=>v,GRAPH_META_SEGMENT:()=>S,Graph:()=>h,JsonCodec:()=>m,SIZEOF_OVERHEAD:()=>C,SIZEOF_SYMBOL:()=>D,SNAPSHOT_VERSION:()=>N,createDagCborCodec:()=>g,createDagCborZstdCodec:()=>k,decodeEnvelope:()=>E,diffForWAL:()=>T,encodeEnvelope:()=>O,explainPath:()=>R,graphProfile:()=>A,reachable:()=>F,registerBuiltinCodecs:()=>G,replayWAL:()=>x,sizeof:()=>$,validateGraphObservability:()=>W,validateNoIslands:()=>M,watchTopologyTree:()=>L});function L(n,p){let o=new Map,c=(s,a)=>{if(o.has(s))return;let i={off:()=>{},prefix:a};o.set(s,i);let f=s.topology.subscribe(l=>{for(let t of l){if(t[0]!==u)continue;let e=t[1];if(p(e,s,a),e.kind==="added"&&e.nodeKind==="mount"){let r=s._mounts.get(e.name);if(r instanceof h){let d=`${a}${e.name}::`;c(r,d)}}else if(e.kind==="removed"&&e.nodeKind==="mount"){let r=`${a}${e.name}::`;for(let[d,y]of Array.from(o.entries()))d!==n&&y.prefix.startsWith(r)&&(y.off(),o.delete(d))}}});i.off=f;for(let[l,t]of s._mounts)if(t instanceof h){let e=`${a}${l}::`;c(t,e)}};return c(n,""),()=>{for(let s of o.values())s.off();o.clear()}}function M(n){let p=n.describe({detail:"minimal"}),o=Object.keys(p.nodes),c=new Set;for(let a of o){let i=p.nodes[a];if(!i)continue;let f=i.deps??[];for(let l of f)c.add(l)}let s=[];for(let a of o){let i=p.nodes[a];if(!i)continue;let l=(i.deps??[]).length,t=c.has(a);if(l===0&&!t){let e=i.type??"unknown";s.push({path:a,kind:e})}}return s.sort((a,i)=>a.path<i.path?-1:a.path>i.path?1:0),{ok:s.length===0,orphans:s,summary(){if(s.length===0)return"validateNoIslands: ok (no islands)";let a=s.slice(0,3).map(i=>`${i.path} (${i.kind})`).join(", ");return`validateNoIslands: ${s.length} island node(s) \u2014 ${a}${s.length>3?", \u2026":""}`}}}var K={json:n=>V(n),pretty:n=>w(n),mermaid:n=>j(n),"mermaid-url":n=>_(n),d2:n=>P(n),ascii:n=>I(n)};function W(n,p={}){let o=[],c=p.requireFound??!0;if(p.skipDescribe!==!0)try{let t=n.describe(),e=new Set(Object.keys(t.nodes)),r=[];for(let[d,y]of Object.entries(t.nodes))for(let b of y.deps)b!==""&&!e.has(b)&&r.push(`${d} \u2192 ${b}`);for(let d of t.edges)e.has(d.from)||r.push(`edge.from: ${d.from}`),e.has(d.to)||r.push(`edge.to: ${d.to}`);r.length>0?o.push({kind:"describe",ok:!1,reason:`describe() has ${r.length} dangling pointer(s); nodes \u2289 deps`,danglingDeps:r}):o.push({kind:"describe",ok:!0,nodeCount:e.size,edgeCount:t.edges.length})}catch(t){o.push({kind:"describe",ok:!1,reason:`describe() threw: ${t instanceof Error?t.message:String(t)}`})}if((p.formats?.length??0)>0){let t=n.describe();for(let e of p.formats)try{let r=K[e](t);typeof r!="string"||r.length===0?o.push({kind:"describe-format",ok:!1,format:e,reason:`${e} renderer returned empty or non-string output`}):o.push({kind:"describe-format",ok:!0,format:e,length:r.length})}catch(r){o.push({kind:"describe-format",ok:!1,format:e,reason:r instanceof Error?r.message:String(r)})}}for(let t of p.paths??[])try{n.resolve(t),o.push({kind:"observe",ok:!0,path:t})}catch(e){o.push({kind:"observe",ok:!1,path:t,reason:e instanceof Error?e.message:String(e)})}for(let[t,e]of p.pairs??[])try{let r=n.explain(t,e);c&&r.found===!1?o.push({kind:"explain",ok:!1,from:t,to:e,reason:`explain(${t} \u2192 ${e}) found no path${r.reason?`: ${r.reason}`:""}`}):o.push({kind:"explain",ok:!0,from:t,to:e,found:r.found,steps:r.steps.length})}catch(r){o.push({kind:"explain",ok:!1,from:t,to:e,reason:r instanceof Error?r.message:String(r)})}let s=o.filter(t=>!t.ok),a=s.length===0,i=p.paths?.length??0,f=p.pairs?.length??0,l=p.formats?.length??0;return{ok:a,checks:o,failures:s,summary(){let t=[p.skipDescribe===!0?null:"describe",l>0?`${l} format${l===1?"":"s"}`:null,i>0?`${i} observe path${i===1?"":"s"}`:null,f>0?`${f} explain pair${f===1?"":"s"}`:null].filter(r=>r!=null),e=t.length>0?t.join(", "):"describe-only";return a?`validateGraphObservability: OK (${e})`:`validateGraphObservability: ${s.length} failure(s) across ${e}`}}}export{L as a,M as b,W as c,q as d};

package/dist/meta-BgVAsg9j.d.ts

@@ -1,102 +0,0 @@
-import { e as NodeDescribeKind, N as Node, A as Actor } from './node-ClS5yC-B.js';
-
-/**
- * JSON-shaped slice of a node for `Graph.describe()`
- * (GRAPHREFLY-SPEC §3.6, Appendix B).
- */
-type DescribeNodeOutput = {
-    type: NodeDescribeKind;
-    status?: Node["status"];
-    deps: string[];
-    meta?: Record<string, unknown>;
-    name?: string;
-    value?: unknown;
-    /** True when the node is in `"sentinel"` state (no value ever). */
-    sentinel?: boolean;
-    v?: {
-        id: string;
-        version: number;
-        cid?: string;
-        prev?: string | null;
-    };
-    guard?: string;
-    lastMutation?: Readonly<{
-        actor: Actor;
-        timestamp_ns: number;
-    }>;
-    /**
-     * Latest annotation attached via `graph.trace(path, annotation)` or via
-     * `graph.add(node, { name: path, annotation })`, when present. Populated by
-     * `Graph.describe` only — `describeNode` has no graph context.
-     */
-    annotation?: string;
-};
-/**
- * Detail level for progressive disclosure (Phase 3.3b).
- *
- * - `"minimal"` — `type`, `deps` only.
- * - `"standard"` — minimal + `status`, `value`, `meta`, `v`.
- * - `"full"` — every field.
- * - `"spec"` — Tier 1.5.3 (Session A.1 lock + Phase 3 path (b)). Projects
- *   spec-relevant fields (`type`, `deps`, `meta` — including
- *   `meta.factory` / `meta.factoryArgs`) and strips runtime fields
- *   (`status`, `lastMutation`, `guard`, `sentinel`, `v`). **Retains
- *   `value` for state nodes only** so the seed initial value round-trips
- *   through `decompileSpec` → `compileSpec` without forcing every state
- *   constructor to spawn `meta.factory`/`factoryArgs` companion nodes.
- *   The output is structurally identical to the `GraphSpec` shape so
- *   `decompileSpec(g) === describe(g, { detail: "spec" })`.
- */
-type DescribeDetail = "minimal" | "standard" | "full" | "spec";
-/** Valid field names for `describe({ fields: [...] })`. */
-type DescribeField = "type" | "status" | "value" | "deps" | "meta" | "v" | "guard" | "lastMutation" | `meta.${string}`;
-/** Resolve which fields to include based on detail level or explicit field list. */
-declare function resolveDescribeFields(detail?: DescribeDetail, fields?: readonly DescribeField[]): Set<string> | null;
-/**
- * Walk an arbitrary value, replacing non-JSON-serializable fields with
- * descriptive string placeholders (Tier 1.5.3 Phase 2.5 — DG2=ii). Useful for
- * `Graph.prototype.tagFactory(name, args)` when the factory's options include
- * `LLMAdapter` instances, callbacks, or `Node`s that don't survive
- * serialization. Output preserves structure for documentation / audit value;
- * recipients of the spec see "<Node>" / "<function>" / etc. in place of the
- * unserializable bits.
- *
- * Heuristics:
- * - `null` / `undefined` / boolean / number / string — kept as-is.
- * - `function` — `"<function>"`.
- * - Object with `subscribe` method — `"<Node>"` (matches Node-shape duck check).
- * - Array — recursed.
- * - Plain object — recursed.
- * - Anything else — `"<unserializable>"`.
- */
-declare function placeholderArgs(opts: Record<string, unknown>): Record<string, unknown>;
-/**
- * Build a `meta` fragment that stamps a factory identifier and its construction
- * arguments onto a node, so `describe({ detail: "spec" })` exposes enough
- * information for `compileSpec` to recreate the node from the snapshot.
- *
- * Use inside node-producing factories at construction time:
- *
- * ```ts
- * import { factoryTag } from "@graphrefly/graphrefly";
- *
- * export function rateLimiter<T>(source: NodeInput<T>, opts: RateLimiterOptions): Node<T> {
- *   return derived([fromAny(source)], fn, {
- *     name: "rate-limiter",
- *     meta: { ...factoryTag("rateLimiter", opts), domain: "resilience" },
- *   });
- * }
- * ```
- *
- * `factoryArgs` should be JSON-serializable so the spec round-trips through
- * `decompileSpec → compileSpec`. Function-typed args break determinism — use
- * the {@link COMPOSITION-GUIDE} §39 `meta.fnId` pattern for those.
- *
- * Tier 1.5.3 (Session A.1 lock).
- */
-declare function factoryTag(factory: string, factoryArgs?: unknown): {
-    factory: string;
-    factoryArgs?: unknown;
-};
-
-export { type DescribeNodeOutput as D, type DescribeDetail as a, type DescribeField as b, factoryTag as f, placeholderArgs as p, resolveDescribeFields as r };

package/dist/meta-vE8bxW1E.d.cts

@@ -1,102 +0,0 @@
-import { e as NodeDescribeKind, N as Node, A as Actor } from './node-ClS5yC-B.cjs';
-
-/**
- * JSON-shaped slice of a node for `Graph.describe()`
- * (GRAPHREFLY-SPEC §3.6, Appendix B).
- */
-type DescribeNodeOutput = {
-    type: NodeDescribeKind;
-    status?: Node["status"];
-    deps: string[];
-    meta?: Record<string, unknown>;
-    name?: string;
-    value?: unknown;
-    /** True when the node is in `"sentinel"` state (no value ever). */
-    sentinel?: boolean;
-    v?: {
-        id: string;
-        version: number;
-        cid?: string;
-        prev?: string | null;
-    };
-    guard?: string;
-    lastMutation?: Readonly<{
-        actor: Actor;
-        timestamp_ns: number;
-    }>;
-    /**
-     * Latest annotation attached via `graph.trace(path, annotation)` or via
-     * `graph.add(node, { name: path, annotation })`, when present. Populated by
-     * `Graph.describe` only — `describeNode` has no graph context.
-     */
-    annotation?: string;
-};
-/**
- * Detail level for progressive disclosure (Phase 3.3b).
- *
- * - `"minimal"` — `type`, `deps` only.
- * - `"standard"` — minimal + `status`, `value`, `meta`, `v`.
- * - `"full"` — every field.
- * - `"spec"` — Tier 1.5.3 (Session A.1 lock + Phase 3 path (b)). Projects
- *   spec-relevant fields (`type`, `deps`, `meta` — including
- *   `meta.factory` / `meta.factoryArgs`) and strips runtime fields
- *   (`status`, `lastMutation`, `guard`, `sentinel`, `v`). **Retains
- *   `value` for state nodes only** so the seed initial value round-trips
- *   through `decompileSpec` → `compileSpec` without forcing every state
- *   constructor to spawn `meta.factory`/`factoryArgs` companion nodes.
- *   The output is structurally identical to the `GraphSpec` shape so
- *   `decompileSpec(g) === describe(g, { detail: "spec" })`.
- */
-type DescribeDetail = "minimal" | "standard" | "full" | "spec";
-/** Valid field names for `describe({ fields: [...] })`. */
-type DescribeField = "type" | "status" | "value" | "deps" | "meta" | "v" | "guard" | "lastMutation" | `meta.${string}`;
-/** Resolve which fields to include based on detail level or explicit field list. */
-declare function resolveDescribeFields(detail?: DescribeDetail, fields?: readonly DescribeField[]): Set<string> | null;
-/**
- * Walk an arbitrary value, replacing non-JSON-serializable fields with
- * descriptive string placeholders (Tier 1.5.3 Phase 2.5 — DG2=ii). Useful for
- * `Graph.prototype.tagFactory(name, args)` when the factory's options include
- * `LLMAdapter` instances, callbacks, or `Node`s that don't survive
- * serialization. Output preserves structure for documentation / audit value;
- * recipients of the spec see "<Node>" / "<function>" / etc. in place of the
- * unserializable bits.
- *
- * Heuristics:
- * - `null` / `undefined` / boolean / number / string — kept as-is.
- * - `function` — `"<function>"`.
- * - Object with `subscribe` method — `"<Node>"` (matches Node-shape duck check).
- * - Array — recursed.
- * - Plain object — recursed.
- * - Anything else — `"<unserializable>"`.
- */
-declare function placeholderArgs(opts: Record<string, unknown>): Record<string, unknown>;
-/**
- * Build a `meta` fragment that stamps a factory identifier and its construction
- * arguments onto a node, so `describe({ detail: "spec" })` exposes enough
- * information for `compileSpec` to recreate the node from the snapshot.
- *
- * Use inside node-producing factories at construction time:
- *
- * ```ts
- * import { factoryTag } from "@graphrefly/graphrefly";
- *
- * export function rateLimiter<T>(source: NodeInput<T>, opts: RateLimiterOptions): Node<T> {
- *   return derived([fromAny(source)], fn, {
- *     name: "rate-limiter",
- *     meta: { ...factoryTag("rateLimiter", opts), domain: "resilience" },
- *   });
- * }
- * ```
- *
- * `factoryArgs` should be JSON-serializable so the spec round-trips through
- * `decompileSpec → compileSpec`. Function-typed args break determinism — use
- * the {@link COMPOSITION-GUIDE} §39 `meta.fnId` pattern for those.
- *
- * Tier 1.5.3 (Session A.1 lock).
- */
-declare function factoryTag(factory: string, factoryArgs?: unknown): {
-    factory: string;
-    factoryArgs?: unknown;
-};
-
-export { type DescribeNodeOutput as D, type DescribeDetail as a, type DescribeField as b, factoryTag as f, placeholderArgs as p, resolveDescribeFields as r };

package/dist/resilience-445VFFXQ.js

@@ -1 +0,0 @@
-import{a,b,c,d,e,f,g,h,i,j,k,l,m,n}from"./chunk-AS3TV2TV.js";import"./chunk-L6NSJVJZ.js";import"./chunk-XLQPNNIC.js";import"./chunk-3G5U5QNE.js";import"./chunk-C72GO4IZ.js";import"./chunk-ACMJ2ZPS.js";import"./chunk-ESMPEKEV.js";import"./chunk-6YFZMUMR.js";import"./chunk-4VVTGLXJ.js";import"./chunk-2K5RXLAH.js";import"./chunk-35JTVPOX.js";import"./chunk-LYCLF26R.js";import"./chunk-CK2E7BTU.js";import"./chunk-QYADASLV.js";export{e as CircuitOpenError,i as RateLimiterOverflowError,b as ResilientPipelineGraph,l as TimeoutError,a as budgetGate,f as circuitBreaker,m as fallback,j as rateLimiter,c as resilientPipeline,d as retry,n as timeout,h as tokenBucket,g as withBreaker,k as withStatus};

package/dist/sugar-CH-2ZY90.d.ts

@@ -1,203 +0,0 @@
-import { a as NodeOptions, F as FnCtx, N as Node, c as NodeActions, d as NodeFnCleanup } from './node-ClS5yC-B.js';
-
-/**
- * Sugar constructors over the raw `node()` primitive.
- *
- * Each factory wraps a user-friendly function into the canonical
- * `NodeFn = (data, actions, ctx) => cleanup | void` shape, then calls
- * `node(...)`. This is the only place `actions.emit(...)` is invoked
- * on behalf of the user — if you need finer control (multi-emission,
- * raw `actions.down` / `actions.up`, cleanup return), use the raw
- * `node()` factory from `./node.js` directly.
- *
- * See SESSION-foundation-redesign.md §8.5 + §10.6 for the rewrite.
- */
-
-/**
- * Creates a manual source node. Drive it with `state.emit(v)` (framed,
- * diamond-safe) or `state.down([[DATA, v]])` (raw compat path).
- *
- * @param initial - Starting cached value. Pass `undefined` or `null`
- *   explicitly to cache that value; omit to leave the node in `"sentinel"`.
- * @param opts - Optional {@link NodeOptions} (excluding `initial`).
- */
-declare function state<T>(initial: T, opts?: Omit<NodeOptions<T>, "initial">): Node<T>;
-/**
- * User-level producer compute: runs once on first-subscriber activation.
- * Receives `actions` for imperative emission and `ctx` for FnCtx (typically
- * only `store` is useful on a producer — no deps means `prevData` and
- * `terminalDeps` are empty).
- */
-type ProducerFn = (actions: NodeActions, ctx: FnCtx) => NodeFnCleanup | void;
-/**
- * Creates a producer node with no deps; `fn` runs once when the first
- * subscriber connects. Return a cleanup function (`() => void` — fires on
- * every transition) or an object with granular hooks
- * (`{ beforeRun?, deactivate?, invalidate? }` — each hook fires on its named
- * transition only) to register teardown. See {@link NodeFnCleanup}.
- *
- * @example
- * ```ts
- * const ticker = producer((actions) => {
- *   const id = setInterval(() => actions.emit(Date.now()), 1000);
- *   return () => clearInterval(id);
- * });
- * ```
- */
-declare function producer<T = unknown>(fn: ProducerFn, opts?: NodeOptions<T>): Node<T>;
-/**
- * User-level derived compute: receives the latest DATA from each dep and
- * returns the new value. The sugar wraps it with `actions.emit(fn(...))`
- * so the return value flows through the framed emit pipeline.
- *
- * For derived nodes that need to inspect `ctx.prevData` / `ctx.terminalDeps`
- * / `ctx.store`, accept the optional second parameter.
- */
-type DerivedFn<T> = (data: readonly unknown[], ctx: FnCtx) => T | undefined | null;
-/**
- * Creates a derived node that computes **one output per wave** from the latest
- * value of each dependency — **snapshot / combine semantics**.
- *
- * `fn` receives one scalar per dep (the last DATA value seen this wave, or the
- * prior-wave value as fallback). It is called once per settled wave and emits
- * a single value via `actions.emit`. The equals check then suppresses the
- * emission as `RESOLVED` if the output has not changed.
- *
- * **Not for streaming one-to-one transforms.** If each DATA value in a batch
- * must produce a corresponding output (e.g. transforming every item emitted by
- * `fromIter` individually), use {@link map} or raw `node()` with full batch
- * iteration instead. `derived` only sees the *last* value per dep when a batch
- * carries multiple DATAs.
- *
- * @example
- * ```ts
- * const a = state(1);
- * const b = derived([a], ([x]) => (x as number) * 2);
- * ```
- */
-declare function derived<T = unknown>(deps: readonly Node[], fn: DerivedFn<T>, opts?: NodeOptions<T>): Node<T>;
-/**
- * User-level effect compute: fires when deps settle. Return value is NOT
- * auto-emitted — use `actions.emit(v)` / `actions.down(msgs)` explicitly if
- * the effect also wants to produce downstream messages. Return a cleanup
- * function (`() => void`) or an object with granular hooks
- * (`{ beforeRun?, deactivate?, invalidate? }`) to register teardown.
- * See {@link NodeFnCleanup}.
- */
-type EffectFn = (data: readonly unknown[], actions: NodeActions, ctx: FnCtx) => NodeFnCleanup | void;
-/**
- * Runs a side-effect when deps settle. Return value is not auto-emitted.
- *
- * @example
- * ```ts
- * effect([source], ([v]) => {
- *   console.log(v);
- * });
- * ```
- */
-declare function effect(deps: readonly Node[], fn: EffectFn, opts?: NodeOptions<unknown>): Node<unknown>;
-/**
- * Proxy handed to a {@link DynamicFn}. `track(dep)` returns the dep's
- * latest DATA payload, as delivered through the protocol. Reading from
- * `track` does NOT bypass the message protocol — it reads the internal
- * `DepRecord.prevData` (the stable end-of-previous-wave value) that
- * `_onDepMessage` already populated. If a dep has not yet sent DATA,
- * `track` returns `undefined`.
- */
-type TrackFn = (dep: Node) => unknown;
-/** User-level dynamicNode compute. */
-type DynamicFn<T> = (track: TrackFn, ctx: FnCtx) => T | undefined | null;
-/**
- * Sugar over `derived(...)` that exposes dep values via a `track(dep)`
- * proxy instead of positional `data[i]`. All declared `allDeps` participate
- * in wave tracking, so the first fn run waits for every dep to settle.
- * Unused deps that update just re-run fn; `equals` absorbs unchanged
- * outputs as RESOLVED.
- *
- * P3-compliant: `track(dep)` reads from the framework-managed
- * `DepRecord.prevData` populated by the protocol, never from
- * `dep.cache`.
- *
- * @example
- * ```ts
- * const a = state(1);
- * const b = state(10);
- * const sum = dynamicNode([a, b], (track) => (track(a) as number) + (track(b) as number));
- * ```
- */
-declare function dynamicNode<T = unknown>(allDeps: readonly Node[], fn: DynamicFn<T>, opts?: NodeOptions<T> & {
-    partial?: boolean;
-}): Node<T>;
-/**
- * Like {@link dynamicNode} but deps are discovered at runtime via `track()`
- * calls — no upfront `allDeps` array needed. Designed for pull-based compat
- * layers (Jotai atoms, TC39 Signals) where deps are unknown until fn runs.
- *
- * **Two-phase discovery:**
- * 1. fn runs. Each `track(dep)` for an unknown dep: subscribes immediately
- *    via `_addDep`, returns `dep.cache` as a stub (P3 boundary exception).
- *    Result is discarded (discovery run).
- * 2. New deps settle (DATA from subscribe handshake). Wave machinery
- *    re-triggers fn. `track(dep)` now returns protocol-delivered `data[i]`.
- *    If MORE unknown deps appear, repeat step 1.
- * 3. Converges when no new deps found → real run → `actions.emit(result)`.
- *
- * P3 violation is limited to discovery runs. Once all deps are known,
- * subsequent waves use protocol-delivered values exclusively.
- *
- * Re-entrance safety: `_addDep` subscribes immediately. If the dep delivers
- * DATA synchronously during fn execution, `_execFn`'s re-entrance guard
- * defers the re-run to after the current fn returns.
- *
- * @param opts - Optional {@link AutoTrackOptions}. Pass `{ partial: true }` to
- *   allow fn to run before all known deps have delivered their first value
- *   (useful for optional/secondary deps).
- *
- * @example
- * ```ts
- * const a = state(1), b = state(2);
- * const sum = autoTrackNode((track) => track(a) + track(b));
- * // deps [a, b] discovered automatically on first run
- * ```
- */
-/**
- * Options for {@link autoTrackNode}.
- */
-interface AutoTrackOptions<T> extends NodeOptions<T> {
-    /**
-     * When `true`, fn may run before all known deps have delivered their first
-     * DATA. Unknown deps return `undefined` via `track()`, which the fn must
-     * handle explicitly. Useful when some deps are "nice-to-have" — e.g. a
-     * primary computation should continue while a secondary dep is still
-     * initialising.
-     *
-     * When `false` (default), fn is held until every declared dep has delivered
-     * at least one DATA value — core's first-run gate (spec §2.7) handles this.
-     * Delegates to {@link NodeOptions.partial}; both semantics are aligned: the
-     * gate is first-run-only (`_hasCalledFnOnce`), so INVALIDATE on a dep does
-     * NOT re-gate after fn has fired once. Pull-based compat layers (Signals,
-     * Jotai) that rely on "consistent compute across INVALIDATE" should
-     * explicitly wrap their dep reads with null/undefined handling in fn.
-     *
-     * @default false
-     */
-    partial?: boolean;
-}
-declare function autoTrackNode<T = unknown>(fn: (track: TrackFn, ctx: FnCtx) => T | undefined | null, opts?: AutoTrackOptions<T>): Node<T>;
-/** Unary operator used by {@link pipe}. */
-type PipeOperator = (n: Node) => Node;
-/**
- * Composes unary operators left-to-right; returns the final node.
- *
- * @example
- * ```ts
- * const out = pipe(
- *   source,
- *   (n) => map(n, (x) => x + 1),
- *   (n) => filter(n, (x) => x > 0),
- * );
- * ```
- */
-declare function pipe(source: Node, ...ops: PipeOperator[]): Node;
-
-export { type AutoTrackOptions as A, type DerivedFn as D, type EffectFn as E, type PipeOperator as P, type TrackFn as T, type DynamicFn as a, type ProducerFn as b, autoTrackNode as c, derived as d, dynamicNode as e, effect as f, producer as g, pipe as p, state as s };

package/dist/sugar-DStZfUEK.d.cts

@@ -1,203 +0,0 @@
-import { a as NodeOptions, F as FnCtx, N as Node, c as NodeActions, d as NodeFnCleanup } from './node-ClS5yC-B.cjs';
-
-/**
- * Sugar constructors over the raw `node()` primitive.
- *
- * Each factory wraps a user-friendly function into the canonical
- * `NodeFn = (data, actions, ctx) => cleanup | void` shape, then calls
- * `node(...)`. This is the only place `actions.emit(...)` is invoked
- * on behalf of the user — if you need finer control (multi-emission,
- * raw `actions.down` / `actions.up`, cleanup return), use the raw
- * `node()` factory from `./node.js` directly.
- *
- * See SESSION-foundation-redesign.md §8.5 + §10.6 for the rewrite.
- */
-
-/**
- * Creates a manual source node. Drive it with `state.emit(v)` (framed,
- * diamond-safe) or `state.down([[DATA, v]])` (raw compat path).
- *
- * @param initial - Starting cached value. Pass `undefined` or `null`
- *   explicitly to cache that value; omit to leave the node in `"sentinel"`.
- * @param opts - Optional {@link NodeOptions} (excluding `initial`).
- */
-declare function state<T>(initial: T, opts?: Omit<NodeOptions<T>, "initial">): Node<T>;
-/**
- * User-level producer compute: runs once on first-subscriber activation.
- * Receives `actions` for imperative emission and `ctx` for FnCtx (typically
- * only `store` is useful on a producer — no deps means `prevData` and
- * `terminalDeps` are empty).
- */
-type ProducerFn = (actions: NodeActions, ctx: FnCtx) => NodeFnCleanup | void;
-/**
- * Creates a producer node with no deps; `fn` runs once when the first
- * subscriber connects. Return a cleanup function (`() => void` — fires on
- * every transition) or an object with granular hooks
- * (`{ beforeRun?, deactivate?, invalidate? }` — each hook fires on its named
- * transition only) to register teardown. See {@link NodeFnCleanup}.
- *
- * @example
- * ```ts
- * const ticker = producer((actions) => {
- *   const id = setInterval(() => actions.emit(Date.now()), 1000);
- *   return () => clearInterval(id);
- * });
- * ```
- */
-declare function producer<T = unknown>(fn: ProducerFn, opts?: NodeOptions<T>): Node<T>;
-/**
- * User-level derived compute: receives the latest DATA from each dep and
- * returns the new value. The sugar wraps it with `actions.emit(fn(...))`
- * so the return value flows through the framed emit pipeline.
- *
- * For derived nodes that need to inspect `ctx.prevData` / `ctx.terminalDeps`
- * / `ctx.store`, accept the optional second parameter.
- */
-type DerivedFn<T> = (data: readonly unknown[], ctx: FnCtx) => T | undefined | null;
-/**
- * Creates a derived node that computes **one output per wave** from the latest
- * value of each dependency — **snapshot / combine semantics**.
- *
- * `fn` receives one scalar per dep (the last DATA value seen this wave, or the
- * prior-wave value as fallback). It is called once per settled wave and emits
- * a single value via `actions.emit`. The equals check then suppresses the
- * emission as `RESOLVED` if the output has not changed.
- *
- * **Not for streaming one-to-one transforms.** If each DATA value in a batch
- * must produce a corresponding output (e.g. transforming every item emitted by
- * `fromIter` individually), use {@link map} or raw `node()` with full batch
- * iteration instead. `derived` only sees the *last* value per dep when a batch
- * carries multiple DATAs.
- *
- * @example
- * ```ts
- * const a = state(1);
- * const b = derived([a], ([x]) => (x as number) * 2);
- * ```
- */
-declare function derived<T = unknown>(deps: readonly Node[], fn: DerivedFn<T>, opts?: NodeOptions<T>): Node<T>;
-/**
- * User-level effect compute: fires when deps settle. Return value is NOT
- * auto-emitted — use `actions.emit(v)` / `actions.down(msgs)` explicitly if
- * the effect also wants to produce downstream messages. Return a cleanup
- * function (`() => void`) or an object with granular hooks
- * (`{ beforeRun?, deactivate?, invalidate? }`) to register teardown.
- * See {@link NodeFnCleanup}.
- */
-type EffectFn = (data: readonly unknown[], actions: NodeActions, ctx: FnCtx) => NodeFnCleanup | void;
-/**
- * Runs a side-effect when deps settle. Return value is not auto-emitted.
- *
- * @example
- * ```ts
- * effect([source], ([v]) => {
- *   console.log(v);
- * });
- * ```
- */
-declare function effect(deps: readonly Node[], fn: EffectFn, opts?: NodeOptions<unknown>): Node<unknown>;
-/**
- * Proxy handed to a {@link DynamicFn}. `track(dep)` returns the dep's
- * latest DATA payload, as delivered through the protocol. Reading from
- * `track` does NOT bypass the message protocol — it reads the internal
- * `DepRecord.prevData` (the stable end-of-previous-wave value) that
- * `_onDepMessage` already populated. If a dep has not yet sent DATA,
- * `track` returns `undefined`.
- */
-type TrackFn = (dep: Node) => unknown;
-/** User-level dynamicNode compute. */
-type DynamicFn<T> = (track: TrackFn, ctx: FnCtx) => T | undefined | null;
-/**
- * Sugar over `derived(...)` that exposes dep values via a `track(dep)`
- * proxy instead of positional `data[i]`. All declared `allDeps` participate
- * in wave tracking, so the first fn run waits for every dep to settle.
- * Unused deps that update just re-run fn; `equals` absorbs unchanged
- * outputs as RESOLVED.
- *
- * P3-compliant: `track(dep)` reads from the framework-managed
- * `DepRecord.prevData` populated by the protocol, never from
- * `dep.cache`.
- *
- * @example
- * ```ts
- * const a = state(1);
- * const b = state(10);
- * const sum = dynamicNode([a, b], (track) => (track(a) as number) + (track(b) as number));
- * ```
- */
-declare function dynamicNode<T = unknown>(allDeps: readonly Node[], fn: DynamicFn<T>, opts?: NodeOptions<T> & {
-    partial?: boolean;
-}): Node<T>;
-/**
- * Like {@link dynamicNode} but deps are discovered at runtime via `track()`
- * calls — no upfront `allDeps` array needed. Designed for pull-based compat
- * layers (Jotai atoms, TC39 Signals) where deps are unknown until fn runs.
- *
- * **Two-phase discovery:**
- * 1. fn runs. Each `track(dep)` for an unknown dep: subscribes immediately
- *    via `_addDep`, returns `dep.cache` as a stub (P3 boundary exception).
- *    Result is discarded (discovery run).
- * 2. New deps settle (DATA from subscribe handshake). Wave machinery
- *    re-triggers fn. `track(dep)` now returns protocol-delivered `data[i]`.
- *    If MORE unknown deps appear, repeat step 1.
- * 3. Converges when no new deps found → real run → `actions.emit(result)`.
- *
- * P3 violation is limited to discovery runs. Once all deps are known,
- * subsequent waves use protocol-delivered values exclusively.
- *
- * Re-entrance safety: `_addDep` subscribes immediately. If the dep delivers
- * DATA synchronously during fn execution, `_execFn`'s re-entrance guard
- * defers the re-run to after the current fn returns.
- *
- * @param opts - Optional {@link AutoTrackOptions}. Pass `{ partial: true }` to
- *   allow fn to run before all known deps have delivered their first value
- *   (useful for optional/secondary deps).
- *
- * @example
- * ```ts
- * const a = state(1), b = state(2);
- * const sum = autoTrackNode((track) => track(a) + track(b));
- * // deps [a, b] discovered automatically on first run
- * ```
- */
-/**
- * Options for {@link autoTrackNode}.
- */
-interface AutoTrackOptions<T> extends NodeOptions<T> {
-    /**
-     * When `true`, fn may run before all known deps have delivered their first
-     * DATA. Unknown deps return `undefined` via `track()`, which the fn must
-     * handle explicitly. Useful when some deps are "nice-to-have" — e.g. a
-     * primary computation should continue while a secondary dep is still
-     * initialising.
-     *
-     * When `false` (default), fn is held until every declared dep has delivered
-     * at least one DATA value — core's first-run gate (spec §2.7) handles this.
-     * Delegates to {@link NodeOptions.partial}; both semantics are aligned: the
-     * gate is first-run-only (`_hasCalledFnOnce`), so INVALIDATE on a dep does
-     * NOT re-gate after fn has fired once. Pull-based compat layers (Signals,
-     * Jotai) that rely on "consistent compute across INVALIDATE" should
-     * explicitly wrap their dep reads with null/undefined handling in fn.
-     *
-     * @default false
-     */
-    partial?: boolean;
-}
-declare function autoTrackNode<T = unknown>(fn: (track: TrackFn, ctx: FnCtx) => T | undefined | null, opts?: AutoTrackOptions<T>): Node<T>;
-/** Unary operator used by {@link pipe}. */
-type PipeOperator = (n: Node) => Node;
-/**
- * Composes unary operators left-to-right; returns the final node.
- *
- * @example
- * ```ts
- * const out = pipe(
- *   source,
- *   (n) => map(n, (x) => x + 1),
- *   (n) => filter(n, (x) => x > 0),
- * );
- * ```
- */
-declare function pipe(source: Node, ...ops: PipeOperator[]): Node;
-
-export { type AutoTrackOptions as A, type DerivedFn as D, type EffectFn as E, type PipeOperator as P, type TrackFn as T, type DynamicFn as a, type ProducerFn as b, autoTrackNode as c, derived as d, dynamicNode as e, effect as f, producer as g, pipe as p, state as s };