@graphrefly/graphrefly 0.43.0 → 0.45.0

package/dist/index-CAC_rNzm.d.ts

@@ -1,189 +0,0 @@
-import { N as Node } from './node-ClS5yC-B.js';
-import { B as BaseAuditRecord } from './index-CZQXo5tH.js';
-import { a as ReactiveLogBundle } from './reactive-log-BezYsbA_.js';
-import { NodeInput } from './extra/sources.js';
-import { AppendLogStorageTier } from './extra/storage-tiers.js';
-import { G as Graph, a as GraphOptions } from './graph-7VguS7a4.js';
-
-/**
- * Job queue patterns (roadmap §4.2).
- *
- * Queue / flow primitives modeled as graph factories:
- * - `jobQueue()` — claim/ack/nack workflow with reactive depth.
- * - `jobFlow()` — multi-stage queue chain.
- *
- * Topic / subscription / hub primitives live in `patterns/messaging`.
- */
-
-type JobState = "queued" | "inflight";
-type JobEnvelope<T> = {
-    id: string;
-    payload: T;
-    attempts: number;
-    metadata: Readonly<Record<string, unknown>>;
-    state: JobState;
-};
-/** Audit record for a job-queue mutation (Audit 2 cross-cutting). */
-type JobEventAction = "enqueue" | "claim" | "ack" | "nack" | "remove";
-interface JobEvent<T = unknown> extends BaseAuditRecord {
-    readonly action: JobEventAction;
-    readonly id: string;
-    readonly attempts?: number;
-    readonly payload?: T;
-}
-/** Recommended `keyOf` for keyed-storage adapters (Audit 2 #7). */
-declare const jobEventKeyOf: <T>(e: JobEvent<T>) => string;
-type JobQueueOptions = {
-    graph?: GraphOptions;
-};
-declare class JobQueueGraph<T> extends Graph {
-    private readonly _pending;
-    private readonly _jobs;
-    private readonly _seqCursor;
-    readonly pending: Node<readonly string[]>;
-    readonly jobs: Node<ReadonlyMap<string, JobEnvelope<T>>>;
-    readonly depth: Node<number>;
-    /** Audit log of every queue mutation (Audit 2). */
-    readonly events: ReactiveLogBundle<JobEvent<T>>;
-    /** Alias for {@link JobQueueGraph.events} — Audit 2 `.audit` duplication. */
-    readonly audit: ReactiveLogBundle<JobEvent<T>>;
-    private readonly _enqueueImpl;
-    private readonly _ackImpl;
-    private readonly _nackImpl;
-    private readonly _removeByIdImpl;
-    constructor(name: string, opts?: JobQueueOptions);
-    /**
-     * Wire append-log storage tiers (Audit 4). Returns a disposer.
-     *
-     * Named `attachEventStorage` to avoid colliding with {@link Graph.attachSnapshotStorage}.
-     */
-    attachEventStorage(tiers: readonly AppendLogStorageTier<JobEvent<T>>[]): () => void;
-    enqueue(payload: T, opts?: {
-        id?: string;
-        metadata?: Record<string, unknown>;
-    }): string;
-    claim(limit?: number): readonly JobEnvelope<T>[];
-    ack(id: string): boolean;
-    nack(id: string, opts?: {
-        requeue?: boolean;
-    }): boolean;
-    /**
-     * Remove a job by id regardless of its current state. Returns `true` if
-     * the job existed and was removed, `false` if no job has this id.
-     *
-     * `ack` only works on inflight; `nack` only works on inflight.
-     * `removeById` is the state-agnostic escape hatch — useful for
-     * audit/observability layers that enqueue but never claim, and need to
-     * finalize a job when an external decision (e.g. harness verify
-     * outcome) resolves it. Distinct name from the inherited
-     * {@link Graph.remove}, which removes a mounted child subgraph by path.
-     *
-     * When the job is in `queued` state, its id is also pulled from the
-     * `pending` list — depth + pending snapshot stay consistent.
-     */
-    removeById(id: string): boolean;
-    /**
-     * Subscribe to a Node and enqueue each DATA payload into this queue.
-     * Returns a disposer that stops consuming when called.
-     *
-     * Used internally by {@link JobFlowGraph} for stage-to-stage wiring but
-     * also useful for users wiring an external source into a job queue.
-     *
-     * @param source - Node whose DATA values are enqueued.
-     * @param opts - Optional enqueue options (id generator, metadata prefix).
-     */
-    consumeFrom(source: Node<T>, opts?: {
-        metadata?: Record<string, unknown>;
-    }): () => void;
-}
-/**
- * Work function for a job flow stage. Receives the full job envelope,
- * returns a `NodeInput<T>` — raw value (sync), Promise (async), or Node
- * (composed pipeline). `fromAny` coerces any of these shapes.
- *
- * On error / rejection: the stage nacks the job (no requeue by default).
- */
-type WorkFn<T> = (job: JobEnvelope<T>) => NodeInput<T>;
-/**
- * Stage definition for {@link JobFlowGraph}. Either a bare name string
- * (no work hook, pure pass-through) or a full definition object.
- */
-type StageDef<T> = string | {
-    name: string;
-    work?: WorkFn<T>;
-    handlerVersion?: {
-        id: string;
-        version: string | number;
-    };
-    /**
-     * Per-stage cap on `claim → work → ack` cycles per pump tick.
-     * Overrides {@link JobFlowOptions.maxPerPump} for this stage. Useful
-     * when stages have asymmetric cost (e.g. an LLM-execute stage capped
-     * at 4 concurrent calls while a cheap verify stage runs unbounded).
-     *
-     * Falls back to the top-level `JobFlowOptions.maxPerPump`, which in
-     * turn falls back to `DEFAULT_MAX_PER_PUMP` (256).
-     */
-    maxPerPump?: number;
-};
-type JobFlowOptions<T = unknown> = {
-    graph?: GraphOptions;
-    /**
-     * Stage definitions. Each stage is either a bare name string (pure
-     * pass-through) or a `{ name, work?, handlerVersion?, maxPerPump? }` object.
-     *
-     * For back-compat, `string[]` values behave as stages with no work hook.
-     */
-    stages?: readonly StageDef<T>[];
-    /**
-     * Default cap on claims per pump tick across all stages. Per-stage
-     * overrides can be set on each {@link StageDef.maxPerPump}; if neither is
-     * set, falls back to `DEFAULT_MAX_PER_PUMP` (256).
-     */
-    maxPerPump?: number;
-};
-declare class JobFlowGraph<T> extends Graph {
-    private readonly _stageNames;
-    private readonly _stageWorkFns;
-    private readonly _queues;
-    private readonly _completed;
-    readonly completed: Node<readonly JobEnvelope<T>[]>;
-    readonly completedCount: Node<number>;
-    constructor(name: string, opts?: JobFlowOptions<T>);
-    stages(): readonly string[];
-    queue(stage: string): JobQueueGraph<T>;
-    enqueue(payload: T, opts?: {
-        id?: string;
-        metadata?: Record<string, unknown>;
-    }): string;
-    retainedCompleted(): readonly JobEnvelope<T>[];
-}
-/**
- * Creates a Pulsar-inspired job queue graph with claim/ack/nack workflow.
- */
-declare function jobQueue<T>(name: string, opts?: JobQueueOptions): JobQueueGraph<T>;
-/**
- * Creates an autonomous multi-stage queue chain graph.
- */
-declare function jobFlow<T>(name: string, opts?: JobFlowOptions<T>): JobFlowGraph<T>;
-
-type index_JobEnvelope<T> = JobEnvelope<T>;
-type index_JobEvent<T = unknown> = JobEvent<T>;
-type index_JobEventAction = JobEventAction;
-type index_JobFlowGraph<T> = JobFlowGraph<T>;
-declare const index_JobFlowGraph: typeof JobFlowGraph;
-type index_JobFlowOptions<T = unknown> = JobFlowOptions<T>;
-type index_JobQueueGraph<T> = JobQueueGraph<T>;
-declare const index_JobQueueGraph: typeof JobQueueGraph;
-type index_JobQueueOptions = JobQueueOptions;
-type index_JobState = JobState;
-type index_StageDef<T> = StageDef<T>;
-type index_WorkFn<T> = WorkFn<T>;
-declare const index_jobEventKeyOf: typeof jobEventKeyOf;
-declare const index_jobFlow: typeof jobFlow;
-declare const index_jobQueue: typeof jobQueue;
-declare namespace index {
-  export { type index_JobEnvelope as JobEnvelope, type index_JobEvent as JobEvent, type index_JobEventAction as JobEventAction, index_JobFlowGraph as JobFlowGraph, type index_JobFlowOptions as JobFlowOptions, index_JobQueueGraph as JobQueueGraph, type index_JobQueueOptions as JobQueueOptions, type index_JobState as JobState, type index_StageDef as StageDef, type index_WorkFn as WorkFn, index_jobEventKeyOf as jobEventKeyOf, index_jobFlow as jobFlow, index_jobQueue as jobQueue };
-}
-
-export { type JobEnvelope as J, type StageDef as S, type WorkFn as W, JobFlowGraph as a, JobQueueGraph as b, type JobEvent as c, type JobEventAction as d, type JobFlowOptions as e, type JobQueueOptions as f, type JobState as g, jobFlow as h, index as i, jobEventKeyOf as j, jobQueue as k };

package/dist/index-CCq87F7t.d.ts

@@ -1,127 +0,0 @@
-import { N as Node } from './node-ClS5yC-B.js';
-
-/**
- * A Nanostores-compatible atom.
- *
- * @category compat
- */
-interface NanoAtom<T> {
-    /** Get current value. */
-    get(): T;
-    /** Set a new value (writable atoms only). */
-    set(value: T): void;
-    /** Subscribe to value changes. Callback receives the new value.
-     * Returns unsubscribe function. Called immediately with current value. */
-    subscribe(cb: (value: T) => void): () => void;
-    /** Listen to value changes (no immediate call). Returns unsubscribe. */
-    listen(cb: (value: T) => void): () => void;
-    /** The underlying GraphReFly node. */
-    readonly _node: Node<T>;
-}
-/**
- * A Nanostores-compatible computed store.
- *
- * @category compat
- */
-interface NanoComputed<T> {
-    /** Get current value. */
-    get(): T;
-    /** Subscribe to value changes. Called immediately with current value.
-     * Returns unsubscribe function. */
-    subscribe(cb: (value: T) => void): () => void;
-    /** Listen to value changes (no immediate call). Returns unsubscribe. */
-    listen(cb: (value: T) => void): () => void;
-    /** The underlying GraphReFly node. */
-    readonly _node: Node<T>;
-}
-/**
- * A Nanostores-compatible map.
- *
- * @category compat
- */
-interface NanoMap<T extends Record<string, unknown>> extends NanoAtom<T> {
-    /** Set a single key. */
-    setKey<K extends keyof T>(key: K, value: T[K]): void;
-}
-/**
- * Creates a nanostores-compatible atom.
- *
- * @param initial - Initial value.
- * @returns `NanoAtom<T>`
- *
- * @category compat
- */
-declare function atom<T>(initial: T): NanoAtom<T>;
-/**
- * Creates a nanostores-compatible computed store.
- *
- * @param stores - One or more atoms/computed stores.
- * @param fn - Compute function.
- * @returns `NanoComputed<T>`
- *
- * @category compat
- */
-declare function computed<T, A>(storeA: NanoAtom<A> | NanoComputed<A>, fn: (a: A) => T): NanoComputed<T>;
-declare function computed<T, A, B>(stores: [NanoAtom<A> | NanoComputed<A>, NanoAtom<B> | NanoComputed<B>], fn: (a: A, b: B) => T): NanoComputed<T>;
-declare function computed<T, A, B, C>(stores: [
-    NanoAtom<A> | NanoComputed<A>,
-    NanoAtom<B> | NanoComputed<B>,
-    NanoAtom<C> | NanoComputed<C>
-], fn: (a: A, b: B, c: C) => T): NanoComputed<T>;
-/**
- * Creates a nanostores-compatible map.
- *
- * @param initial - Initial object value.
- * @returns `NanoMap<T>`
- *
- * @category compat
- */
-declare function map<T extends Record<string, unknown>>(initial: T): NanoMap<T>;
-/**
- * Returns the current value of the store.
- *
- * @category compat
- */
-declare function getValue<T>(store: NanoAtom<T> | NanoComputed<T>): T;
-/**
- * Adds a listener for the store start (first listener connected).
- *
- * @category compat
- */
-declare function onStart(store: NanoAtom<any> | NanoComputed<any>, cb: () => void): void;
-/**
- * Adds a listener for the store stop (last listener disconnected).
- *
- * @category compat
- */
-declare function onStop(store: NanoAtom<any> | NanoComputed<any>, cb: () => void): void;
-/**
- * Adds a listener for the store mount (first listener connected).
- *
- * @returns A cleanup function called when the last listener is removed.
- * @category compat
- */
-declare function onMount(store: NanoAtom<any> | NanoComputed<any>, cb: () => (() => void) | undefined): void;
-/**
- * Batches multiple store updates.
- *
- * @category compat
- */
-declare function action<Args extends any[], Return>(_store: NanoAtom<any> | NanoComputed<any>, _name: string, fn: (...args: Args) => Return): (...args: Args) => Return;
-
-type index_NanoAtom<T> = NanoAtom<T>;
-type index_NanoComputed<T> = NanoComputed<T>;
-type index_NanoMap<T extends Record<string, unknown>> = NanoMap<T>;
-declare const index_action: typeof action;
-declare const index_atom: typeof atom;
-declare const index_computed: typeof computed;
-declare const index_getValue: typeof getValue;
-declare const index_map: typeof map;
-declare const index_onMount: typeof onMount;
-declare const index_onStart: typeof onStart;
-declare const index_onStop: typeof onStop;
-declare namespace index {
-  export { type index_NanoAtom as NanoAtom, type index_NanoComputed as NanoComputed, type index_NanoMap as NanoMap, index_action as action, index_atom as atom, index_computed as computed, index_getValue as getValue, index_map as map, index_onMount as onMount, index_onStart as onStart, index_onStop as onStop };
-}
-
-export { type NanoAtom as N, type NanoComputed as a, type NanoMap as b, action as c, atom as d, computed as e, onStart as f, getValue as g, onStop as h, index as i, map as m, onMount as o };

package/dist/index-CDXc9zKM.d.cts

@@ -1,26 +0,0 @@
-import { C as CatchOptions, a as ClassifyResult, D as Decision, b as DecisionAction, G as GateController, c as GateOptions, P as PipelineGraph, S as StepRef, T as TerminalCause, d as decisionKeyOf, p as pipelineGraph } from './pipeline-graph-DPqKDk59.cjs';
-
-/**
- * Orchestration patterns (roadmap §4.1).
- *
- * Domain-layer helpers that build workflow shapes on top of core + extra primitives.
- * Exported under the `patterns.orchestration` namespace to avoid collisions with
- * Phase 2 operator names (for example `gate`, `forEach`).
- */
-
-declare const index_CatchOptions: typeof CatchOptions;
-declare const index_ClassifyResult: typeof ClassifyResult;
-declare const index_Decision: typeof Decision;
-declare const index_DecisionAction: typeof DecisionAction;
-declare const index_GateController: typeof GateController;
-declare const index_GateOptions: typeof GateOptions;
-declare const index_PipelineGraph: typeof PipelineGraph;
-declare const index_StepRef: typeof StepRef;
-declare const index_TerminalCause: typeof TerminalCause;
-declare const index_decisionKeyOf: typeof decisionKeyOf;
-declare const index_pipelineGraph: typeof pipelineGraph;
-declare namespace index {
-  export { index_CatchOptions as CatchOptions, index_ClassifyResult as ClassifyResult, index_Decision as Decision, index_DecisionAction as DecisionAction, index_GateController as GateController, index_GateOptions as GateOptions, index_PipelineGraph as PipelineGraph, index_StepRef as StepRef, index_TerminalCause as TerminalCause, index_decisionKeyOf as decisionKeyOf, index_pipelineGraph as pipelineGraph };
-}
-
-export { index as i };

package/dist/index-CJK1JkYy.d.ts

@@ -1,36 +0,0 @@
-import { N as Node } from './node-ClS5yC-B.js';
-
-/** 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 };