@graphrefly/ts 0.0.0

package/dist/composition/index.d.cts

@@ -0,0 +1,95 @@
+import { N as Node, n as NodeOptions } from '../types-bNMSWKqF.cjs';
+import { a as DescribeNode, c as DescribeSnapshot } from '../describe-Ciu8SUnN.cjs';
+import { L as Operator, Q as StateNode, T as SugarOpts, d as Graph } from '../graph-s23RbbFO.cjs';
+import '../messages-BZqrGGm1.cjs';
+import '../core/index.cjs';
+import '../codec-BB7p8fJc.cjs';
+
+/**
+ * CSP-2.8 composition helpers (D56).
+ *
+ * These are graph-layer, per-language helpers (D6/D24), not protocol primitives. The first cut is
+ * intentionally static: branch nodes are declared at construction time, with real dep edges
+ * `[source, rules]` that `describe()` can show. Dynamic rule add/remove is deferred by D56.
+ */
+
+/** One unary operator step accepted by {@link pipe}. */
+type PipeOperator<TIn, TOut> = Operator<TIn, TOut>;
+type DescribeEvent = {
+    readonly type: "node-added";
+    readonly id: string;
+    readonly node: DescribeNode;
+} | {
+    readonly type: "node-removed";
+    readonly id: string;
+} | {
+    readonly type: "node-meta-changed";
+    readonly id: string;
+    readonly prevMeta: Record<string, unknown>;
+    readonly nextMeta: Record<string, unknown>;
+} | {
+    readonly type: "edge-added";
+    readonly from: string;
+    readonly to: string;
+} | {
+    readonly type: "edge-removed";
+    readonly from: string;
+    readonly to: string;
+} | {
+    readonly type: "subgraph-mounted";
+    readonly path: string;
+} | {
+    readonly type: "subgraph-unmounted";
+    readonly path: string;
+};
+interface DescribeChangeset {
+    readonly events: readonly DescribeEvent[];
+}
+/**
+ * Pure topology delta from one D39 `describe()` snapshot to another. No node refs, no clocks, no
+ * old-core deps (D56). Values/status changes are not topology events; use `observe()` for data.
+ */
+declare function topologyDiff(prev: DescribeSnapshot, next: DescribeSnapshot): DescribeChangeset;
+/**
+ * Compose unary operator factories into a graph-registered chain.
+ *
+ * Each step is instantiated through `g.initNode`, so `describe()` still shows the real
+ * per-operator factory names and declared edges (D6/D39/D45). This is graph-layer sugar, not a
+ * new verb or protocol primitive.
+ */
+declare function pipe<S>(g: Graph, source: Node<S>): Node<S>;
+declare function pipe<S, A>(g: Graph, source: Node<S>, op1: PipeOperator<S, A>): Node<A>;
+declare function pipe<S, A, B>(g: Graph, source: Node<S>, op1: PipeOperator<S, A>, op2: PipeOperator<A, B>): Node<B>;
+declare function pipe<S, A, B, C>(g: Graph, source: Node<S>, op1: PipeOperator<S, A>, op2: PipeOperator<A, B>, op3: PipeOperator<B, C>): Node<C>;
+declare function pipe<S, A, B, C, D>(g: Graph, source: Node<S>, op1: PipeOperator<S, A>, op2: PipeOperator<A, B>, op3: PipeOperator<B, C>, op4: PipeOperator<C, D>): Node<D>;
+declare function pipe<S, A, B, C, D, E>(g: Graph, source: Node<S>, op1: PipeOperator<S, A>, op2: PipeOperator<A, B>, op3: PipeOperator<B, C>, op4: PipeOperator<C, D>, op5: PipeOperator<D, E>): Node<E>;
+declare function pipe<S, A, B, C, D, E, F>(g: Graph, source: Node<S>, op1: PipeOperator<S, A>, op2: PipeOperator<A, B>, op3: PipeOperator<B, C>, op4: PipeOperator<C, D>, op5: PipeOperator<D, E>, op6: PipeOperator<E, F>): Node<F>;
+declare function pipe<S>(g: Graph, source: Node<S>, ...ops: readonly PipeOperator<unknown, unknown>[]): Node<unknown>;
+interface StratifyRule<R> {
+    readonly name: string;
+    readonly rule: R;
+    readonly meta?: Record<string, unknown>;
+}
+interface StratifyBranchOptions<T> extends Omit<NodeOptions<T>, "dispatcher"> {
+}
+/** D56 branch node body: declared deps `[source, rules]`, no internal subscribe island. */
+declare function stratifyBranch<T, R>(source: Node<T>, rules: Node<R>, classifier: (rules: R, value: T) => boolean, opts?: StratifyBranchOptions<T>): Node<T>;
+interface StratifyOptions<R = unknown> {
+    /** Branch id prefix. Default `branch`, yielding ids like `branch/even`. */
+    prefix?: string;
+    /** Optional graph sugar opts for the rules state node. */
+    rules?: SugarOpts<readonly StratifyRule<R>[]>;
+    /** Optional graph sugar opts for each branch node, keyed by rule name. */
+    branches?: Record<string, SugarOpts<unknown>>;
+}
+interface Stratified<T, R> {
+    readonly rules: StateNode<readonly StratifyRule<R>[]>;
+    readonly branches: Record<string, Node<T>>;
+}
+/**
+ * Build static stratification branches in `g` (D56 first cut). Rules are a state node so future
+ * classifier data changes affect future source items, but branch count is fixed at construction.
+ */
+declare function stratify<T, R>(g: Graph, source: Node<T>, rules: readonly StratifyRule<R>[], classifier: (rule: R, value: T) => boolean, opts?: StratifyOptions<R>): Stratified<T, R>;
+
+export { type DescribeChangeset, type DescribeEvent, type PipeOperator, type Stratified, type StratifyOptions, type StratifyRule, pipe, stratify, stratifyBranch, topologyDiff };

package/dist/composition/index.d.ts

@@ -0,0 +1,95 @@
+import { N as Node, n as NodeOptions } from '../types-h12mNYbq.js';
+import { a as DescribeNode, c as DescribeSnapshot } from '../describe-BZb7AS2y.js';
+import { L as Operator, Q as StateNode, T as SugarOpts, d as Graph } from '../graph-DfdF9zy4.js';
+import '../messages-BZqrGGm1.js';
+import '../core/index.js';
+import '../codec-BB7p8fJc.js';
+
+/**
+ * CSP-2.8 composition helpers (D56).
+ *
+ * These are graph-layer, per-language helpers (D6/D24), not protocol primitives. The first cut is
+ * intentionally static: branch nodes are declared at construction time, with real dep edges
+ * `[source, rules]` that `describe()` can show. Dynamic rule add/remove is deferred by D56.
+ */
+
+/** One unary operator step accepted by {@link pipe}. */
+type PipeOperator<TIn, TOut> = Operator<TIn, TOut>;
+type DescribeEvent = {
+    readonly type: "node-added";
+    readonly id: string;
+    readonly node: DescribeNode;
+} | {
+    readonly type: "node-removed";
+    readonly id: string;
+} | {
+    readonly type: "node-meta-changed";
+    readonly id: string;
+    readonly prevMeta: Record<string, unknown>;
+    readonly nextMeta: Record<string, unknown>;
+} | {
+    readonly type: "edge-added";
+    readonly from: string;
+    readonly to: string;
+} | {
+    readonly type: "edge-removed";
+    readonly from: string;
+    readonly to: string;
+} | {
+    readonly type: "subgraph-mounted";
+    readonly path: string;
+} | {
+    readonly type: "subgraph-unmounted";
+    readonly path: string;
+};
+interface DescribeChangeset {
+    readonly events: readonly DescribeEvent[];
+}
+/**
+ * Pure topology delta from one D39 `describe()` snapshot to another. No node refs, no clocks, no
+ * old-core deps (D56). Values/status changes are not topology events; use `observe()` for data.
+ */
+declare function topologyDiff(prev: DescribeSnapshot, next: DescribeSnapshot): DescribeChangeset;
+/**
+ * Compose unary operator factories into a graph-registered chain.
+ *
+ * Each step is instantiated through `g.initNode`, so `describe()` still shows the real
+ * per-operator factory names and declared edges (D6/D39/D45). This is graph-layer sugar, not a
+ * new verb or protocol primitive.
+ */
+declare function pipe<S>(g: Graph, source: Node<S>): Node<S>;
+declare function pipe<S, A>(g: Graph, source: Node<S>, op1: PipeOperator<S, A>): Node<A>;
+declare function pipe<S, A, B>(g: Graph, source: Node<S>, op1: PipeOperator<S, A>, op2: PipeOperator<A, B>): Node<B>;
+declare function pipe<S, A, B, C>(g: Graph, source: Node<S>, op1: PipeOperator<S, A>, op2: PipeOperator<A, B>, op3: PipeOperator<B, C>): Node<C>;
+declare function pipe<S, A, B, C, D>(g: Graph, source: Node<S>, op1: PipeOperator<S, A>, op2: PipeOperator<A, B>, op3: PipeOperator<B, C>, op4: PipeOperator<C, D>): Node<D>;
+declare function pipe<S, A, B, C, D, E>(g: Graph, source: Node<S>, op1: PipeOperator<S, A>, op2: PipeOperator<A, B>, op3: PipeOperator<B, C>, op4: PipeOperator<C, D>, op5: PipeOperator<D, E>): Node<E>;
+declare function pipe<S, A, B, C, D, E, F>(g: Graph, source: Node<S>, op1: PipeOperator<S, A>, op2: PipeOperator<A, B>, op3: PipeOperator<B, C>, op4: PipeOperator<C, D>, op5: PipeOperator<D, E>, op6: PipeOperator<E, F>): Node<F>;
+declare function pipe<S>(g: Graph, source: Node<S>, ...ops: readonly PipeOperator<unknown, unknown>[]): Node<unknown>;
+interface StratifyRule<R> {
+    readonly name: string;
+    readonly rule: R;
+    readonly meta?: Record<string, unknown>;
+}
+interface StratifyBranchOptions<T> extends Omit<NodeOptions<T>, "dispatcher"> {
+}
+/** D56 branch node body: declared deps `[source, rules]`, no internal subscribe island. */
+declare function stratifyBranch<T, R>(source: Node<T>, rules: Node<R>, classifier: (rules: R, value: T) => boolean, opts?: StratifyBranchOptions<T>): Node<T>;
+interface StratifyOptions<R = unknown> {
+    /** Branch id prefix. Default `branch`, yielding ids like `branch/even`. */
+    prefix?: string;
+    /** Optional graph sugar opts for the rules state node. */
+    rules?: SugarOpts<readonly StratifyRule<R>[]>;
+    /** Optional graph sugar opts for each branch node, keyed by rule name. */
+    branches?: Record<string, SugarOpts<unknown>>;
+}
+interface Stratified<T, R> {
+    readonly rules: StateNode<readonly StratifyRule<R>[]>;
+    readonly branches: Record<string, Node<T>>;
+}
+/**
+ * Build static stratification branches in `g` (D56 first cut). Rules are a state node so future
+ * classifier data changes affect future source items, but branch count is fixed at construction.
+ */
+declare function stratify<T, R>(g: Graph, source: Node<T>, rules: readonly StratifyRule<R>[], classifier: (rule: R, value: T) => boolean, opts?: StratifyOptions<R>): Stratified<T, R>;
+
+export { type DescribeChangeset, type DescribeEvent, type PipeOperator, type Stratified, type StratifyOptions, type StratifyRule, pipe, stratify, stratifyBranch, topologyDiff };

package/dist/composition/index.js

@@ -0,0 +1,19 @@
+import "../chunk-H2HTHFVN.js";
+import {
+  pipe,
+  stratify,
+  stratifyBranch,
+  topologyDiff
+} from "../chunk-D6BG7U6A.js";
+import "../chunk-PKVBHGBM.js";
+import "../chunk-I3IHOHCJ.js";
+import "../chunk-4VLAQHZI.js";
+import "../chunk-SWTLEQL6.js";
+import "../chunk-DK554R7P.js";
+export {
+  pipe,
+  stratify,
+  stratifyBranch,
+  topologyDiff
+};
+//# sourceMappingURL=index.js.map

package/dist/composition/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}