@graphrefly/graphrefly 0.43.0 → 0.45.0

package/dist/index-CZjOhcBy.d.cts

@@ -1,113 +0,0 @@
-import { N as Node, a as NodeOptions } from './node-ClS5yC-B.cjs';
-import { a as GraphOptions, G as Graph } from './graph-C4SHb3Ly.cjs';
-
-/**
- * Reduction primitives (roadmap §8.1).
- *
- * Composable building blocks for taking heterogeneous massive inputs and producing
- * prioritized, auditable, human-actionable output. Each primitive is either a Graph
- * factory or a Node factory, built on top of core + extra primitives.
- *
- * @module
- */
-
-type StepRef = string | Node<unknown>;
-/** A named stage for {@link funnel}. */
-type FunnelStage = {
-    /** Stage name (mounted as subgraph). */
-    name: string;
-    /** Builder: receives a sub-graph, should add an `"input"` and `"output"` node. */
-    build: (sub: Graph) => void;
-};
-/** Options for {@link funnel}. */
-type FunnelOptions = GraphOptions & {
-    meta?: Record<string, unknown>;
-};
-/**
- * Multi-source merge with sequential reduction stages.
- *
- * Sources are merged into a single stream. Each stage is a named subgraph
- * (mounted via `graph.mount()`). Stages connect linearly:
- * `merged → stage[0].input → stage[0].output → stage[1].input → ...`
- *
- * @param name - Graph name.
- * @param sources - Input nodes to merge.
- * @param stages - Sequential reduction stages.
- * @param opts - Optional graph/meta options.
- * @returns Graph with `"merged"` and mounted stage subgraphs.
- *
- * @category patterns
- */
-declare function funnel<T>(name: string, sources: ReadonlyArray<Node<T>>, stages: ReadonlyArray<FunnelStage>, opts?: FunnelOptions): Graph;
-/** Options for {@link feedback}. */
-type FeedbackOptions = {
-    /** Maximum feedback iterations before stopping (default: 10). */
-    maxIterations?: number;
-    /** Optional budget gate node path for cost-bounded iteration. */
-    budgetNode?: StepRef;
-    meta?: Record<string, unknown>;
-};
-/**
- * Introduce a bounded reactive cycle into an existing graph.
- *
- * When `condition` emits a non-null DATA value, the feedback effect routes it
- * back to the `reentry` state node — creating a cycle. Bounded by
- * `maxIterations` (default 10). The counter node (`__feedback_<condition>`)
- * is the source of truth — reset it to 0 to allow more iterations.
- *
- * To remove the feedback cycle, call `graph.remove("__feedback_<condition>")`.
- *
- * @param graph - Existing graph to augment with a feedback cycle.
- * @param condition - Path to a node whose DATA triggers feedback.
- * @param reentry - Path to a state node that receives the feedback value.
- * @param opts - Iteration bounds and metadata.
- * @returns The same graph (mutated with feedback nodes added).
- *
- * @category patterns
- */
-declare function feedback(graph: Graph, condition: string, reentry: string, opts?: FeedbackOptions): Graph;
-/** A scored item with full breakdown. */
-type ScoredItem<T = unknown> = {
-    /** Original value. */
-    value: T;
-    /** Final weighted score. */
-    score: number;
-    /** Per-signal breakdown: signal index → weighted contribution. */
-    breakdown: number[];
-};
-/** Options for {@link scorer}. */
-type ScorerOptions = Omit<NodeOptions<unknown>, "describeKind" | "name" | "meta"> & {
-    meta?: Record<string, unknown>;
-    /** Custom scoring function per signal. Default: identity (signal value IS the score). */
-    scoreFns?: ReadonlyArray<(value: unknown) => number>;
-};
-/**
- * Reactive multi-signal scoring with live weights.
- *
- * Each source emits items to score. Weights are reactive state nodes that
- * LLM or human can adjust live. Output is sorted scored items with full
- * breakdown.
- *
- * @param sources - Signal nodes (each emits a numeric score dimension).
- * @param weights - Reactive weight nodes (one per source).
- * @param opts - Optional node/meta options.
- * @returns Node emitting scored output.
- *
- * @category patterns
- */
-declare function scorer(sources: ReadonlyArray<Node<number>>, weights: ReadonlyArray<Node<number>>, opts?: ScorerOptions): Node<ScoredItem<number[]>>;
-
-type index_FeedbackOptions = FeedbackOptions;
-type index_FunnelOptions = FunnelOptions;
-type index_FunnelStage = FunnelStage;
-type index_ScoredItem<T = unknown> = ScoredItem<T>;
-type index_ScorerOptions = ScorerOptions;
-type index_StepRef = StepRef;
-declare const index_feedback: typeof feedback;
-declare const index_funnel: typeof funnel;
-declare const index_scorer: typeof scorer;
-declare namespace index {
-  export { type index_FeedbackOptions as FeedbackOptions, type index_FunnelOptions as FunnelOptions, type index_FunnelStage as FunnelStage, type index_ScoredItem as ScoredItem, type index_ScorerOptions as ScorerOptions, type index_StepRef as StepRef, index_feedback as feedback, index_funnel as funnel, index_scorer as scorer };
-}
-
-export { type FeedbackOptions as F, type ScoredItem as S, type FunnelOptions as a, type FunnelStage as b, type ScorerOptions as c, type StepRef as d, funnel as e, feedback as f, index as i, scorer as s };

package/dist/index-ChOyVLKm.d.cts

@@ -1,86 +0,0 @@
-import { N as Node } from './node-ClS5yC-B.cjs';
-
-/**
- * Options for creating an atom.
- *
- * @category compat
- */
-interface AtomOptions {
-    /** Optional identifier for the underlying node. */
-    name?: string;
-    /** Optional companion meta nodes. */
-    meta?: Record<string, unknown>;
-}
-/**
- * A read-only Jotai-compatible atom.
- *
- * @category compat
- */
-interface ReadableAtom<T> {
-    /** Returns the current cached value. */
-    get(): T;
-    /** Subscribes to value changes. Returns an unsubscribe function. */
-    subscribe(callback: (value: T) => void): () => void;
-    /** Access to companion meta nodes. */
-    readonly meta: Record<string, Node>;
-    /** @internal The underlying GraphReFly node. */
-    _node: Node<T>;
-}
-/**
- * A writable Jotai-compatible atom.
- *
- * @category compat
- */
-interface WritableAtom<T> extends ReadableAtom<T> {
-    /** Sets a new value. */
-    set(value: T): void;
-    /** Updates the value using a transformation function. */
-    update(fn: (current: T) => T): void;
-}
-/** Function type for reading other atoms inside a derived atom. */
-type GetFn = <V>(a: ReadableAtom<V>) => V;
-/** Function type for writing to other atoms inside a writable derived atom. */
-type SetFn = <V>(a: WritableAtom<V>, value: V) => void;
-/** Function that computes the atom's value. */
-type ReadFn<T> = (get: GetFn) => T;
-/** Function that handles writes to the atom. */
-type WriteFn<T> = (get: GetFn, set: SetFn, value: T) => void;
-/**
- * Creates a Jotai-compatible atom built on GraphReFly primitives.
- *
- * Supports three overloads:
- * 1. `atom(initial)` — Writable primitive atom (wraps `state()`).
- * 2. `atom(read)` — Read-only derived atom (wraps `dynamicNode()`).
- * 3. `atom(read, write)` — Writable derived atom.
- *
- * @param initialOrRead - Initial value or a read function.
- * @param writeOrOptions - Write function or options object.
- * @param options - Optional configuration.
- * @returns WritableAtom or ReadableAtom.
- *
- * @example
- * ```ts
- * const count = atom(0);
- * count.set(1);
- * const doubled = atom((get) => get(count)! * 2);
- * ```
- *
- * @category compat
- */
-declare function atom<T>(initial: T, options?: AtomOptions): WritableAtom<T>;
-declare function atom<T>(read: ReadFn<T>, options?: AtomOptions): ReadableAtom<T>;
-declare function atom<T>(read: ReadFn<T>, write: WriteFn<T>, options?: AtomOptions): WritableAtom<T>;
-
-type index_AtomOptions = AtomOptions;
-type index_GetFn = GetFn;
-type index_ReadFn<T> = ReadFn<T>;
-type index_ReadableAtom<T> = ReadableAtom<T>;
-type index_SetFn = SetFn;
-type index_WritableAtom<T> = WritableAtom<T>;
-type index_WriteFn<T> = WriteFn<T>;
-declare const index_atom: typeof atom;
-declare namespace index {
-  export { type index_AtomOptions as AtomOptions, type index_GetFn as GetFn, type index_ReadFn as ReadFn, type index_ReadableAtom as ReadableAtom, type index_SetFn as SetFn, type index_WritableAtom as WritableAtom, type index_WriteFn as WriteFn, index_atom as atom };
-}
-
-export { type AtomOptions as A, type GetFn as G, type ReadFn as R, type SetFn as S, type WritableAtom as W, type ReadableAtom as a, type WriteFn as b, atom as c, index as i };

package/dist/index-CvrqGfNS.d.ts

@@ -1,34 +0,0 @@
-import { Ref, WatchSource } from 'vue';
-import { N as Node } from './node-ClS5yC-B.js';
-
-/**
- * Subscribe to a read-only `Node<T>` as a Vue `Ref<T>`. Auto-unsubscribes on scope disposal.
- * Subscription lifecycle is tied to Vue scope disposal (not node terminal messages).
- */
-declare function useSubscribe<T>(node: Node<T>): Readonly<Ref<T | undefined | null>>;
-/**
- * Bind a writable `Node<T>` as a Vue `Ref<T>`. Reads and writes are bidirectional.
- * Value sets always dispatch `[[DIRTY], [DATA, value]]`, including `value === undefined`.
- * Subscription lifecycle is tied to Vue scope disposal (not node terminal messages).
- */
-declare function useStore<T>(node: Node<T>): Ref<T | undefined | null>;
-/** Maps a key to an object of nodes. Used by `useSubscribeRecord` factory. */
-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. When keys change,
- * old subscriptions are torn down and new ones created automatically.
- * Must be called during Vue `setup()`.
- */
-declare function useSubscribeRecord<K extends string, R extends Record<string, any>>(keys: WatchSource<K[] | undefined>, factory: NodeFactory<K, R>): Readonly<Ref<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 };