@graphrefly/graphrefly 0.43.0 → 0.45.0

package/dist/observable-BsBzUrcI.d.ts

@@ -1,36 +0,0 @@
-import { Observable } from 'rxjs';
-import { N as Node, M as Messages } from './node-ClS5yC-B.js';
-
-/** Options for {@link toObservable}. */
-type ToObservableOptions = {
-    /**
-     * When `true`, emit raw `Messages` batches instead of extracted `DATA` values.
-     * Terminal batches are still emitted as the final `next()` before the
-     * Observable signal (error/complete).
-     */
-    raw?: boolean;
-};
-/**
- * Bridge a `Node<T>` to an RxJS `Observable`.
- *
- * Default mode emits the node's value on each `DATA` message. Maps `ERROR` to
- * `subscriber.error()` and `COMPLETE` to `subscriber.complete()`.
- * Protocol-internal signals (DIRTY, RESOLVED, PAUSE, etc.) are skipped.
- *
- * With `{ raw: true }`, emits full `[[Type, Data?], ...]` message batches.
- * The Observable terminates on ERROR or COMPLETE (the terminal batch is still
- * emitted as the final `next()` before the Observable signal).
- *
- * For graph-level observation, use `toObservable(graph.resolve(path))` or
- * subscribe to `graph.observe()` directly.
- *
- * Unsubscribing the Observable unsubscribes the node.
- */
-declare function toObservable<T>(node: Node<T>, options?: ToObservableOptions & {
-    raw?: false;
-}): Observable<T>;
-declare function toObservable<T>(node: Node<T>, options: ToObservableOptions & {
-    raw: true;
-}): Observable<Messages>;
-
-export { type ToObservableOptions as T, toObservable as t };

package/dist/observable-DLGPPtb8.d.cts

@@ -1,36 +0,0 @@
-import { Observable } from 'rxjs';
-import { N as Node, M as Messages } from './node-ClS5yC-B.cjs';
-
-/** Options for {@link toObservable}. */
-type ToObservableOptions = {
-    /**
-     * When `true`, emit raw `Messages` batches instead of extracted `DATA` values.
-     * Terminal batches are still emitted as the final `next()` before the
-     * Observable signal (error/complete).
-     */
-    raw?: boolean;
-};
-/**
- * Bridge a `Node<T>` to an RxJS `Observable`.
- *
- * Default mode emits the node's value on each `DATA` message. Maps `ERROR` to
- * `subscriber.error()` and `COMPLETE` to `subscriber.complete()`.
- * Protocol-internal signals (DIRTY, RESOLVED, PAUSE, etc.) are skipped.
- *
- * With `{ raw: true }`, emits full `[[Type, Data?], ...]` message batches.
- * The Observable terminates on ERROR or COMPLETE (the terminal batch is still
- * emitted as the final `next()` before the Observable signal).
- *
- * For graph-level observation, use `toObservable(graph.resolve(path))` or
- * subscribe to `graph.observe()` directly.
- *
- * Unsubscribing the Observable unsubscribes the node.
- */
-declare function toObservable<T>(node: Node<T>, options?: ToObservableOptions & {
-    raw?: false;
-}): Observable<T>;
-declare function toObservable<T>(node: Node<T>, options: ToObservableOptions & {
-    raw: true;
-}): Observable<Messages>;
-
-export { type ToObservableOptions as T, toObservable as t };

package/dist/pipeline-graph-DPqKDk59.d.cts

@@ -1,137 +0,0 @@
-import { N as Node, c as NodeActions } from './node-ClS5yC-B.cjs';
-import { D as DerivedFn } from './sugar-DyVGtczU.cjs';
-import { B as BaseAuditRecord } from './index-C9pjcz3l.cjs';
-import { a as ReactiveLogBundle } from './reactive-log-B00laMSQ.cjs';
-import { G as Graph, a as GraphOptions } from './graph-C4SHb3Ly.cjs';
-
-/**
- * PipelineGraph subclass (Wave A.1 Unit 1 — locked 2026-04-24).
- *
- * Specialized {@link Graph} that hosts workflow-DAG sugar methods:
- * `task` / `classify` / `combine` / `approval` / `approvalGate` / `catch`.
- * The legacy `pipeline` / `task` / `branch` / `join` / `subPipeline` /
- * `approval` / `loop` / `onFailure` factories from {@link ./index} continue
- * to work for migration ease; new code should prefer methods on this class.
- *
- * **Tier 2.3 rename:** the prior `gate(...)` method is now `approvalGate(...)`,
- * disambiguating it from the other gate-family primitives (`budgetGate` for
- * numeric constraints, `valve` for boolean switching, `policyGate` for ABAC
- * rules). The "gating dimension" here is **human judgment**.
- *
- * Construction: `pipelineGraph(name, opts?)` or `new PipelineGraph(name, opts)`.
- */
-
-type StepRef = string | Node<unknown>;
-type DecisionAction = "approve" | "reject" | "modify" | "drop" | "open" | "close" | "teardown";
-interface Decision<T = unknown> extends BaseAuditRecord {
-    readonly action: DecisionAction;
-    readonly count?: number;
-    readonly items?: readonly T[];
-    readonly unflushed?: number;
-}
-/** Recommended `keyOf` for keyed-storage adapters (Audit 2 #7). */
-declare const decisionKeyOf: <T>(d: Decision<T>) => string;
-interface GateOptions<T = unknown> {
-    /** Bounded default 1000 (Audit 2 cross-cutting). `Infinity` is opt-in. */
-    maxPending?: number;
-    startOpen?: boolean;
-    /**
-     * Reactive auto-approve: gate's `latestIsOpen` mirrors this node's truthy
-     * value. False→true transition drains the pending queue.
-     *
-     * **`COMPLETE` / `ERROR` on the approver are silently ignored** — the gate
-     * stays in its current state. For permanent-open latching, use
-     * `onceOnly: true` (the first truthy approval latches; subsequent falsy
-     * values are ignored). The gate has no graceful terminal-state behavior
-     * for the approver itself.
-     */
-    approver?: Node<unknown>;
-    /** Latch — first truthy approval opens permanently; `close()` becomes no-op. */
-    onceOnly?: boolean;
-    meta?: Record<string, unknown>;
-    handlerVersion?: {
-        id: string;
-        version: string | number;
-    };
-}
-interface GateController<T> {
-    readonly node: Node<T>;
-    readonly pending: Node<readonly T[]>;
-    readonly count: Node<number>;
-    readonly isOpen: Node<boolean>;
-    readonly droppedCount: Node<number>;
-    readonly decisions: ReactiveLogBundle<Decision<T>>;
-    readonly audit: ReactiveLogBundle<Decision<T>>;
-    approve(count?: number): void;
-    reject(count?: number): void;
-    modify(fn: (value: T, index: number, pending: readonly T[]) => T, count?: number): void;
-    open(): void;
-    close(): void;
-}
-/**
- * Terminal-cause discriminator for the {@link PipelineGraph.catch} recovery
- * handler. Tier 1.6.3 status-enum migration: was `{ kind: "complete" | "error" }`
- * pre-1.0; aligned with the canonical lifecycle enum
- * (`status: "running" | "completed" | "errored" | "cancelled"`). The variant
- * structure is preserved — `errored` still carries `error: unknown` and
- * `completed` carries no payload.
- */
-type TerminalCause = {
-    kind: "errored";
-    error: unknown;
-} | {
-    kind: "completed";
-};
-interface CatchOptions<T> {
-    /**
-     * Which terminal cause to recover. Default `"errored"` (Tier 1.6.3 rename
-     * of `"error"`). `"completed"` recovers COMPLETE; `"terminal"` recovers
-     * either. Aligns with the canonical lifecycle enum that
-     * {@link TerminalCause.kind} now uses.
-     */
-    on?: "errored" | "completed" | "terminal";
-    completeWhenDepsComplete?: boolean;
-    meta?: Record<string, unknown>;
-    handlerVersion?: {
-        id: string;
-        version: string | number;
-    };
-}
-interface ClassifyResult<TTag extends string, T> {
-    readonly tag: TTag | "error";
-    readonly value: T;
-    readonly error?: unknown;
-}
-declare class PipelineGraph extends Graph {
-    constructor(name: string, opts?: GraphOptions);
-    /**
-     * Register a workflow task (`derived` + auto-add). String deps resolve via
-     * `this.resolve(path)`; Node deps via {@link Graph.nameOf} O(1) lookup.
-     */
-    task<T>(name: string, run: DerivedFn<T>, opts?: {
-        deps?: ReadonlyArray<StepRef>;
-        meta?: Record<string, unknown>;
-    }): Node<T>;
-    classify<TTag extends string, T>(name: string, source: StepRef, tagger: (value: T) => TTag, opts?: {
-        meta?: Record<string, unknown>;
-    }): Node<ClassifyResult<TTag, T>>;
-    combine<R extends Record<string, StepRef>>(name: string, deps: R, opts?: {
-        meta?: Record<string, unknown>;
-    }): Node<{
-        [K in keyof R]: unknown;
-    }>;
-    approvalGate<T>(name: string, source: StepRef, opts?: GateOptions<T>): GateController<T>;
-    /**
-     * Reactive approval step: passes items through when `approver` is truthy;
-     * holds at most one pending item (maxPending: 1) when falsy. A thin alias
-     * over `approvalGate({ approver, maxPending: 1 })` — use `approvalGate()`
-     * directly for finer control (maxPending, onceOnly, manual approve/reject).
-     */
-    approval<T>(name: string, source: StepRef, approver: Node<unknown>, opts?: Omit<GateOptions<T>, "approver" | "maxPending">): GateController<T>;
-    catch<T>(name: string, source: StepRef, recover: (cause: TerminalCause, actions: NodeActions) => T, opts?: CatchOptions<T>): Node<T>;
-    private _resolveStep;
-}
-/** Factory wrapper — `pipelineGraph(name, opts?)`. Equivalent to `new PipelineGraph(name, opts)`. */
-declare function pipelineGraph(name: string, opts?: GraphOptions): PipelineGraph;
-
-export { type CatchOptions as C, type Decision as D, type GateController as G, PipelineGraph as P, type StepRef as S, type TerminalCause as T, type ClassifyResult as a, type DecisionAction as b, type GateOptions as c, decisionKeyOf as d, pipelineGraph as p };

package/dist/pipeline-graph-loP57TBA.d.ts

@@ -1,137 +0,0 @@
-import { N as Node, c as NodeActions } from './node-ClS5yC-B.js';
-import { D as DerivedFn } from './sugar-DLwvMr3F.js';
-import { B as BaseAuditRecord } from './index-CZQXo5tH.js';
-import { a as ReactiveLogBundle } from './reactive-log-BezYsbA_.js';
-import { G as Graph, a as GraphOptions } from './graph-7VguS7a4.js';
-
-/**
- * PipelineGraph subclass (Wave A.1 Unit 1 — locked 2026-04-24).
- *
- * Specialized {@link Graph} that hosts workflow-DAG sugar methods:
- * `task` / `classify` / `combine` / `approval` / `approvalGate` / `catch`.
- * The legacy `pipeline` / `task` / `branch` / `join` / `subPipeline` /
- * `approval` / `loop` / `onFailure` factories from {@link ./index} continue
- * to work for migration ease; new code should prefer methods on this class.
- *
- * **Tier 2.3 rename:** the prior `gate(...)` method is now `approvalGate(...)`,
- * disambiguating it from the other gate-family primitives (`budgetGate` for
- * numeric constraints, `valve` for boolean switching, `policyGate` for ABAC
- * rules). The "gating dimension" here is **human judgment**.
- *
- * Construction: `pipelineGraph(name, opts?)` or `new PipelineGraph(name, opts)`.
- */
-
-type StepRef = string | Node<unknown>;
-type DecisionAction = "approve" | "reject" | "modify" | "drop" | "open" | "close" | "teardown";
-interface Decision<T = unknown> extends BaseAuditRecord {
-    readonly action: DecisionAction;
-    readonly count?: number;
-    readonly items?: readonly T[];
-    readonly unflushed?: number;
-}
-/** Recommended `keyOf` for keyed-storage adapters (Audit 2 #7). */
-declare const decisionKeyOf: <T>(d: Decision<T>) => string;
-interface GateOptions<T = unknown> {
-    /** Bounded default 1000 (Audit 2 cross-cutting). `Infinity` is opt-in. */
-    maxPending?: number;
-    startOpen?: boolean;
-    /**
-     * Reactive auto-approve: gate's `latestIsOpen` mirrors this node's truthy
-     * value. False→true transition drains the pending queue.
-     *
-     * **`COMPLETE` / `ERROR` on the approver are silently ignored** — the gate
-     * stays in its current state. For permanent-open latching, use
-     * `onceOnly: true` (the first truthy approval latches; subsequent falsy
-     * values are ignored). The gate has no graceful terminal-state behavior
-     * for the approver itself.
-     */
-    approver?: Node<unknown>;
-    /** Latch — first truthy approval opens permanently; `close()` becomes no-op. */
-    onceOnly?: boolean;
-    meta?: Record<string, unknown>;
-    handlerVersion?: {
-        id: string;
-        version: string | number;
-    };
-}
-interface GateController<T> {
-    readonly node: Node<T>;
-    readonly pending: Node<readonly T[]>;
-    readonly count: Node<number>;
-    readonly isOpen: Node<boolean>;
-    readonly droppedCount: Node<number>;
-    readonly decisions: ReactiveLogBundle<Decision<T>>;
-    readonly audit: ReactiveLogBundle<Decision<T>>;
-    approve(count?: number): void;
-    reject(count?: number): void;
-    modify(fn: (value: T, index: number, pending: readonly T[]) => T, count?: number): void;
-    open(): void;
-    close(): void;
-}
-/**
- * Terminal-cause discriminator for the {@link PipelineGraph.catch} recovery
- * handler. Tier 1.6.3 status-enum migration: was `{ kind: "complete" | "error" }`
- * pre-1.0; aligned with the canonical lifecycle enum
- * (`status: "running" | "completed" | "errored" | "cancelled"`). The variant
- * structure is preserved — `errored` still carries `error: unknown` and
- * `completed` carries no payload.
- */
-type TerminalCause = {
-    kind: "errored";
-    error: unknown;
-} | {
-    kind: "completed";
-};
-interface CatchOptions<T> {
-    /**
-     * Which terminal cause to recover. Default `"errored"` (Tier 1.6.3 rename
-     * of `"error"`). `"completed"` recovers COMPLETE; `"terminal"` recovers
-     * either. Aligns with the canonical lifecycle enum that
-     * {@link TerminalCause.kind} now uses.
-     */
-    on?: "errored" | "completed" | "terminal";
-    completeWhenDepsComplete?: boolean;
-    meta?: Record<string, unknown>;
-    handlerVersion?: {
-        id: string;
-        version: string | number;
-    };
-}
-interface ClassifyResult<TTag extends string, T> {
-    readonly tag: TTag | "error";
-    readonly value: T;
-    readonly error?: unknown;
-}
-declare class PipelineGraph extends Graph {
-    constructor(name: string, opts?: GraphOptions);
-    /**
-     * Register a workflow task (`derived` + auto-add). String deps resolve via
-     * `this.resolve(path)`; Node deps via {@link Graph.nameOf} O(1) lookup.
-     */
-    task<T>(name: string, run: DerivedFn<T>, opts?: {
-        deps?: ReadonlyArray<StepRef>;
-        meta?: Record<string, unknown>;
-    }): Node<T>;
-    classify<TTag extends string, T>(name: string, source: StepRef, tagger: (value: T) => TTag, opts?: {
-        meta?: Record<string, unknown>;
-    }): Node<ClassifyResult<TTag, T>>;
-    combine<R extends Record<string, StepRef>>(name: string, deps: R, opts?: {
-        meta?: Record<string, unknown>;
-    }): Node<{
-        [K in keyof R]: unknown;
-    }>;
-    approvalGate<T>(name: string, source: StepRef, opts?: GateOptions<T>): GateController<T>;
-    /**
-     * Reactive approval step: passes items through when `approver` is truthy;
-     * holds at most one pending item (maxPending: 1) when falsy. A thin alias
-     * over `approvalGate({ approver, maxPending: 1 })` — use `approvalGate()`
-     * directly for finer control (maxPending, onceOnly, manual approve/reject).
-     */
-    approval<T>(name: string, source: StepRef, approver: Node<unknown>, opts?: Omit<GateOptions<T>, "approver" | "maxPending">): GateController<T>;
-    catch<T>(name: string, source: StepRef, recover: (cause: TerminalCause, actions: NodeActions) => T, opts?: CatchOptions<T>): Node<T>;
-    private _resolveStep;
-}
-/** Factory wrapper — `pipelineGraph(name, opts?)`. Equivalent to `new PipelineGraph(name, opts)`. */
-declare function pipelineGraph(name: string, opts?: GraphOptions): PipelineGraph;
-
-export { type CatchOptions as C, type Decision as D, type GateController as G, PipelineGraph as P, type StepRef as S, type TerminalCause as T, type ClassifyResult as a, type DecisionAction as b, type GateOptions as c, decisionKeyOf as d, pipelineGraph as p };

package/dist/reactive-layout-Dsvob4zD.d.cts

@@ -1,183 +0,0 @@
-import { N as Node } from './node-ClS5yC-B.cjs';
-import { G as Graph } from './graph-C4SHb3Ly.cjs';
-
-/** Pluggable measurement backend. */
-interface MeasurementAdapter {
-    measureSegment(text: string, font: string): {
-        width: number;
-    };
-    /** Optional; adapters may omit for read-only / stateless measurement. */
-    clearCache?(): void;
-}
-/** Mutable counters for `analyzeAndMeasure` cache hit ratio (hits / (hits + misses)). */
-type SegmentMeasureStats = {
-    hits: number;
-    misses: number;
-};
-/** Break kind for each segment (ported from Pretext analysis.ts). */
-type SegmentBreakKind = "text" | "space" | "zero-width-break" | "soft-hyphen" | "hard-break";
-/** A measured text segment ready for line breaking. */
-type PreparedSegment = {
-    text: string;
-    width: number;
-    kind: SegmentBreakKind;
-    /** Grapheme widths for overflow-wrap: break-word (null if single grapheme). */
-    graphemeWidths: number[] | null;
-};
-/** A laid-out line with start/end cursors. */
-type LayoutLine = {
-    text: string;
-    width: number;
-    startSegment: number;
-    startGrapheme: number;
-    endSegment: number;
-    endGrapheme: number;
-};
-/** Per-character position for hit testing. */
-type CharPosition = {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    line: number;
-};
-/** Full layout result from the line-breaks derived node. */
-type LineBreaksResult = {
-    lines: LayoutLine[];
-    lineCount: number;
-};
-/**
- * A position within `PreparedSegment[]` — segment + grapheme offset.
- * `graphemeIndex: 0` at segment boundaries.
- *
- * Used by {@link layoutNextLine} for cursor-based line walking; needed when
- * lines have varying widths (multi-column flow, text wrapping around obstacles).
- */
-type LayoutCursor = {
-    segmentIndex: number;
-    graphemeIndex: number;
-};
-/** A horizontal span `[left, right]` in pixels — used by flow-layout slot carving. */
-type Interval = {
-    left: number;
-    right: number;
-};
-/** Result of a single `layoutNextLine` call. */
-type LayoutNextLineResult = {
-    text: string;
-    width: number;
-    start: LayoutCursor;
-    end: LayoutCursor;
-};
-/** Optional context for `layoutNextLine` — enables soft-hyphen visible-hyphen rendering. */
-type LayoutNextLineContext = {
-    adapter?: MeasurementAdapter;
-    font?: string;
-    cache?: Map<string, Map<string, number>>;
-};
-/** Result of the reactive layout graph's describe-accessible state. */
-type ReactiveLayoutBundle = {
-    graph: Graph;
-    /** Set input text. */
-    setText: (text: string) => void;
-    /** Set CSS font string. */
-    setFont: (font: string) => void;
-    /** Set line height (px). */
-    setLineHeight: (lineHeight: number) => void;
-    /** Set max width constraint (px). */
-    setMaxWidth: (maxWidth: number) => void;
-    /** Segments node. */
-    segments: Node<PreparedSegment[]>;
-    /** Line breaks node. */
-    lineBreaks: Node<LineBreaksResult>;
-    /** Total height node. */
-    height: Node<number>;
-    /** Per-character positions node. */
-    charPositions: Node<CharPosition[]>;
-};
-/**
- * Merge segmentation pieces: sticky punctuation, CJK per-grapheme splitting,
- * and produce the final measured segment list.
- */
-declare function analyzeAndMeasure(text: string, font: string, adapter: MeasurementAdapter, cache: Map<string, Map<string, number>>, stats?: SegmentMeasureStats): PreparedSegment[];
-/**
- * Greedy line-breaking algorithm.
- *
- * Walks segments left to right, accumulating width. Breaks when a segment would
- * overflow maxWidth. Supports:
- * - Trailing space hang (spaces don't trigger breaks)
- * - overflow-wrap: break-word via grapheme widths
- * - Soft hyphens (break opportunity, adds visible hyphen width)
- * - Hard breaks (forced newline)
- */
-declare function computeLineBreaks(segments: PreparedSegment[], maxWidth: number, adapter: MeasurementAdapter, font: string, cache: Map<string, Map<string, number>>): LineBreaksResult;
-/**
- * Lay out the next single line starting from `cursor`, fitting into `slotWidth`.
- *
- * Unlike `computeLineBreaks`, which consumes whole text with one `maxWidth`,
- * this is the cursor-based primitive needed when successive lines have different
- * widths (multi-column flow, text wrapping around shape obstacles, mixed
- * column+pullquote layouts).
- *
- * Returns `null` when the cursor is past all segments (text exhausted).
- * At a hard-break with no preceding content, returns an empty line and advances
- * the cursor past the break so the caller can continue.
- *
- * ```ts
- * let cursor: LayoutCursor = { segmentIndex: 0, graphemeIndex: 0 };
- * while (true) {
- *   const line = layoutNextLine(segments, cursor, availableWidth);
- *   if (line === null) break;
- *   render(line);
- *   cursor = line.end;
- * }
- * ```
- */
-declare function layoutNextLine(segments: PreparedSegment[], cursor: LayoutCursor, slotWidth: number, ctx?: LayoutNextLineContext): LayoutNextLineResult | null;
-/**
- * Subtract blocked horizontal intervals from a base interval, producing
- * remaining ordered, non-overlapping slots wide enough to fit text.
- *
- * Pure geometry — no text dependency. Used by flow-layout to turn obstacle
- * intersections into per-line layout slots.
- *
- * ```ts
- * carveTextLineSlots({left: 0, right: 600}, [{left: 200, right: 280}])
- * // → [{left: 0, right: 200}, {left: 280, right: 600}]
- * ```
- */
-declare function carveTextLineSlots(base: Interval, blocked: Interval[], minSlotWidth?: number): Interval[];
-/** Compute per-character x,y positions from line breaks and segments. */
-declare function computeCharPositions(lineBreaks: LineBreaksResult, segments: PreparedSegment[], lineHeight: number): CharPosition[];
-type ReactiveLayoutOptions = {
-    /** Measurement backend (required). */
-    adapter: MeasurementAdapter;
-    /** Graph name (default: "reactive-layout"). */
-    name?: string;
-    /** Initial text. */
-    text?: string;
-    /** Initial CSS font string. */
-    font?: string;
-    /** Initial line height in px. */
-    lineHeight?: number;
-    /** Initial max width in px (clamped to ≥ 0). */
-    maxWidth?: number;
-};
-/**
- * Create a reactive text layout graph.
- *
- * ```
- * Graph("reactive-layout")
- * ├── state("text")
- * ├── state("font")
- * ├── state("line-height")
- * ├── state("max-width")
- * ├── derived("segments")      — text + font → PreparedSegment[]
- * ├── derived("line-breaks")   — segments + max-width → LineBreaksResult
- * ├── derived("height")        — line-breaks → number
- * └── derived("char-positions") — line-breaks + segments → CharPosition[]
- * ```
- */
-declare function reactiveLayout(opts: ReactiveLayoutOptions): ReactiveLayoutBundle;
-
-export { type CharPosition as C, type Interval as I, type LineBreaksResult as L, type MeasurementAdapter as M, type PreparedSegment as P, type ReactiveLayoutBundle as R, type SegmentBreakKind as S, type LayoutCursor as a, type LayoutLine as b, type LayoutNextLineContext as c, type LayoutNextLineResult as d, type ReactiveLayoutOptions as e, type SegmentMeasureStats as f, analyzeAndMeasure as g, carveTextLineSlots as h, computeCharPositions as i, computeLineBreaks as j, layoutNextLine as l, reactiveLayout as r };