@graphrefly/graphrefly 0.45.0 → 0.46.0

package/dist/chunk-RGL53X5G.js

@@ -0,0 +1,574 @@
+import {
+  renderContextView,
+  taggedContextPool
+} from "./chunk-KIIXR252.js";
+import {
+  refineLoop
+} from "./chunk-GBCENOLN.js";
+import {
+  QUEUE_NAMES
+} from "./chunk-OIWU3NYV.js";
+import {
+  topic
+} from "./chunk-Q3EYOCZB.js";
+
+// src/presets/harness/actor-pool.ts
+import { node } from "@graphrefly/pure-ts/core";
+import { reactiveLog } from "@graphrefly/pure-ts/extra";
+import { Graph } from "@graphrefly/pure-ts/graph";
+var _actorPoolSeq = 0;
+function actorPool(parent, opts = {}) {
+  const name = opts.name ?? `actorPool-${++_actorPoolSeq}`;
+  const graph = new Graph(name);
+  parent.mount(name, graph);
+  const depthCap = opts.depthCap ?? Number.POSITIVE_INFINITY;
+  let autoActor = 0;
+  const liveHandles = /* @__PURE__ */ new Set();
+  const contextPool = taggedContextPool(graph, {
+    topic: opts.contextTopic ?? "context",
+    llmCompress: opts.llmCompress,
+    name: `${name}.ctx`
+  });
+  const todos = reactiveLog(void 0, { name: `${name}.todos` });
+  const stateMap = /* @__PURE__ */ new Map();
+  const active = node([], {
+    name: `${name}.active`,
+    initial: /* @__PURE__ */ new Map()
+  });
+  function pushActive() {
+    active.emit(new Map(stateMap));
+  }
+  function attachActor(spec) {
+    const depth = spec.depth ?? 0;
+    if (depth > depthCap) {
+      throw new RangeError(`actorPool: depth ${depth} exceeds depthCap ${depthCap}`);
+    }
+    const id = spec.id ?? `actor-${++autoActor}`;
+    const context = renderContextView(contextPool, spec.view);
+    const todoCursor = node(
+      [todos.entries],
+      (data, actions, ctx) => {
+        const all = data[0] != null && data[0].length > 0 ? data[0].at(-1) : ctx.prevData[0];
+        actions.emit((all ?? []).filter((t) => t.assignee === id || t.assignee === void 0));
+      },
+      { describeKind: "derived" }
+    );
+    const status = node([], { name: `${name}.${id}.status`, initial: "idle" });
+    stateMap.set(id, { id, depth, status: "idle" });
+    pushActive();
+    const subs = [
+      context.subscribe(() => {
+      }),
+      todoCursor.subscribe(() => {
+      }),
+      status.subscribe(() => {
+      })
+    ];
+    let released = false;
+    const handle = {
+      id,
+      context,
+      todoCursor,
+      status,
+      publish(entry) {
+        const tags = [...entry.tags ?? [], `actor:${id}`];
+        return contextPool.add({ ...entry, tags });
+      },
+      enqueueTodo(t) {
+        todos.append(t);
+      },
+      setStatus(s) {
+        status.emit(s);
+        const prev = stateMap.get(id);
+        if (prev) {
+          stateMap.set(id, { ...prev, status: s });
+          pushActive();
+        }
+      },
+      release() {
+        if (released) return;
+        released = true;
+        for (const u of subs) u();
+        stateMap.delete(id);
+        liveHandles.delete(handle);
+        pushActive();
+      }
+    };
+    liveHandles.add(handle);
+    return handle;
+  }
+  return {
+    attachActor,
+    contextPool,
+    todos,
+    active,
+    graph,
+    dispose() {
+      for (const h of [...liveHandles]) h.release();
+      contextPool.dispose();
+      todos.dispose();
+    }
+  };
+}
+
+// src/presets/harness/eval-verifier.ts
+import { batch, node as node3 } from "@graphrefly/pure-ts/core";
+import { filter as filter2 } from "@graphrefly/pure-ts/extra";
+import { Graph as Graph2 } from "@graphrefly/pure-ts/graph";
+
+// src/presets/harness/refine-executor.ts
+import { node as node2 } from "@graphrefly/pure-ts/core";
+import { filter } from "@graphrefly/pure-ts/extra";
+function defaultToOutput(result) {
+  const { best, score, status } = result;
+  const scoreStr = Number.isFinite(score) ? score.toFixed(3) : String(score);
+  const artifact = best ?? void 0;
+  if (status === "converged") {
+    return {
+      outcome: "success",
+      detail: `refineLoop converged at score ${scoreStr}`,
+      artifact
+    };
+  }
+  if (status === "budget") {
+    return {
+      outcome: "partial",
+      detail: `refineLoop hit budget at score ${scoreStr}`,
+      artifact
+    };
+  }
+  return {
+    outcome: "failure",
+    detail: `refineLoop errored (status=${status})`,
+    artifact
+  };
+}
+function refineExecutor(config) {
+  const name = config.name ?? "refine-executor";
+  const toOutput = config.toOutput ?? defaultToOutput;
+  return (job) => {
+    const item = job.payload.item;
+    const loop = refineLoop(config.seedFrom(item), config.evaluator, config.strategy, {
+      ...config.refine,
+      dataset: config.datasetFor(item),
+      name: `${name}/inner`
+    });
+    const raw = node2(
+      [loop.status, loop.best, loop._score],
+      (batchData, actions, ctx) => {
+        const data = batchData.map(
+          (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+        );
+        const s = data[0];
+        if (s !== "converged" && s !== "budget" && s !== "errored") {
+          actions.emit(null);
+          return;
+        }
+        const exec = toOutput({
+          best: data[1],
+          score: data[2],
+          status: s
+        });
+        actions.emit({
+          ...job.payload,
+          execution: { item, ...exec }
+        });
+      },
+      { name: `${name}/output`, describeKind: "derived" }
+    );
+    return filter(raw, (v) => v != null, { name: `${name}/gate-out` });
+  };
+}
+
+// src/presets/harness/eval-verifier.ts
+function meanScore(scores) {
+  if (scores.length === 0) return Number.NEGATIVE_INFINITY;
+  let sum = 0;
+  for (const s of scores) sum += s.score;
+  return sum / scores.length;
+}
+function defaultToOutput2(summary) {
+  const { passCount, total, meanScore: mean, threshold, missingArtifact } = summary;
+  const meanStr = Number.isFinite(mean) ? mean.toFixed(3) : String(mean);
+  const verified = !missingArtifact && total > 0 && mean >= threshold;
+  const findings = missingArtifact ? ["EXECUTE stage did not emit an artifact; cannot verify reactively"] : verified ? [`${passCount}/${total} eval tasks passed; mean score ${meanStr} \u2265 ${threshold}`] : total === 0 ? ["No eval tasks were selected for this item \u2014 cannot verify"] : [
+    `${passCount}/${total} eval tasks passed; mean score ${meanStr} < threshold ${threshold}`
+  ];
+  return verified ? { verified: true, findings } : { verified: false, findings, errorClass: "structural" };
+}
+function defaultExtractArtifact(exec) {
+  return exec.artifact ?? null;
+}
+function evalVerifier(config) {
+  const name = config.name ?? "eval-verifier";
+  const threshold = config.threshold ?? 0.5;
+  const toOutput = config.toOutput ?? defaultToOutput2;
+  const extract = config.extractArtifact ?? defaultExtractArtifact;
+  const parentGraph = config.graph;
+  const mountSeqByClaimId = /* @__PURE__ */ new Map();
+  return (job) => {
+    const { item, execution } = job.payload;
+    if (execution == null) {
+      return {
+        ...job.payload,
+        verify: {
+          verified: false,
+          findings: ["evalVerifier: prior execute stage produced no execution"],
+          errorClass: "structural"
+        }
+      };
+    }
+    const artifact = extract(execution, item);
+    if (artifact == null) {
+      return {
+        ...job.payload,
+        verify: toOutput({
+          scores: [],
+          meanScore: Number.NEGATIVE_INFINITY,
+          passCount: 0,
+          total: 0,
+          threshold,
+          missingArtifact: true
+        })
+      };
+    }
+    const claimId = job.id;
+    const seq = mountSeqByClaimId.get(claimId) ?? 0;
+    mountSeqByClaimId.set(claimId, seq + 1);
+    const segmentSuffix = seq === 0 ? "" : `_${seq}`;
+    const segmentPath = `eval/${claimId}${segmentSuffix}`;
+    const sub = parentGraph != null ? new Graph2(`eval_${claimId}${segmentSuffix}`) : null;
+    const candidatesName = sub != null ? "candidates" : `${name}/candidates`;
+    const datasetName = sub != null ? "dataset" : `${name}/dataset`;
+    const outputName = sub != null ? "output" : `${name}/output`;
+    const gateName = sub != null ? "gate-out" : `${name}/gate-out`;
+    const candidates = node3([], {
+      initial: [artifact],
+      name: candidatesName
+    });
+    const dataset = node3([], {
+      initial: config.datasetFor(item),
+      name: datasetName
+    });
+    if (sub != null) {
+      sub.add(candidates, { name: "candidates" });
+      sub.add(dataset, { name: "dataset" });
+    }
+    let scoresNode;
+    batch(() => {
+      scoresNode = config.evaluator(candidates, dataset);
+    });
+    const cleanup = parentGraph != null ? () => ({
+      onDeactivation: () => {
+        try {
+          parentGraph.remove(segmentPath);
+        } catch {
+        }
+      }
+    }) : () => void 0;
+    const raw = node3(
+      [scoresNode],
+      (batchData, actions, ctx) => {
+        const data = batchData.map(
+          (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+        );
+        const arr = data[0];
+        if (arr == null) {
+          actions.emit(null);
+          return cleanup();
+        }
+        const mean = meanScore(arr);
+        const passCount = arr.filter((s) => s.score >= threshold).length;
+        actions.emit({
+          ...job.payload,
+          verify: toOutput({
+            scores: arr,
+            meanScore: mean,
+            passCount,
+            total: arr.length,
+            threshold
+          })
+        });
+        return cleanup();
+      },
+      { name: outputName, describeKind: "derived" }
+    );
+    const gateOut = filter2(raw, (v) => v != null, { name: gateName });
+    if (sub != null) {
+      sub.add(raw, { name: "output" });
+      sub.add(gateOut, { name: "gate-out" });
+      parentGraph.mount(segmentPath, sub);
+    }
+    return gateOut;
+  };
+}
+function harnessEvalPair(config) {
+  const baseName = config.name ?? "harness-pair";
+  const executor = refineExecutor({
+    name: `${baseName}-exec`,
+    seedFrom: config.seedFrom,
+    evaluator: config.evaluator,
+    strategy: config.strategy,
+    datasetFor: config.datasetFor,
+    refine: config.refine
+  });
+  const verifier = evalVerifier({
+    name: `${baseName}-verify`,
+    evaluator: config.evaluator,
+    datasetFor: config.datasetFor,
+    threshold: config.threshold
+  });
+  return { executor, verifier };
+}
+
+// src/presets/harness/ownership-controller.ts
+import { policyAllowing, wallClockNs } from "@graphrefly/pure-ts/core";
+import { fromAny } from "@graphrefly/pure-ts/extra";
+import { Graph as Graph3 } from "@graphrefly/pure-ts/graph";
+var LEVEL_RANK = { L0: 0, L1: 1, L2: 2, L3: 3 };
+var EMPTY_STATE = {
+  owner: null,
+  level: null,
+  allowed: [],
+  signOfLifeNs: null
+};
+var OwnershipControllerGraph = class extends Graph3 {
+  topic;
+  current;
+  allowed;
+  guard;
+  _ttlNs;
+  _supervisor;
+  /**
+   * Whether a heartbeat `NodeInput` was supplied at construction (F14 —
+   * `claim()`'s `level` default is `"L2"` when wired, else `"L1"`). NOT a
+   * mutable accumulator — set once in the constructor, read-only after.
+   */
+  _hasHeartbeat;
+  constructor(name, opts) {
+    super(name);
+    this._ttlNs = Math.max(0, opts.ttl) * 1e6;
+    this._supervisor = opts.supervisor;
+    this._hasHeartbeat = opts.heartbeat != null;
+    this.topic = topic(`${name}__ownership`, {
+      retainedLimit: opts.retainedLimit ?? 256
+    });
+    this.addDisposer(() => {
+      this.topic.destroy();
+    });
+    const deps = [this.topic.events];
+    const heartbeatIdx = opts.heartbeat != null ? deps.push(fromAny(opts.heartbeat)) - 1 : -1;
+    if (opts.clock != null) deps.push(fromAny(opts.clock));
+    this.current = this.derived(
+      "currentOwner",
+      deps,
+      (batchData, ctx) => {
+        const nowNs = wallClockNs();
+        const beatThisWave = heartbeatIdx >= 0 && (() => {
+          const hb = batchData[heartbeatIdx];
+          return hb != null && hb.length > 0;
+        })();
+        const topoBatch = batchData[0];
+        const log = topoBatch != null && topoBatch.length > 0 ? topoBatch[topoBatch.length - 1] : ctx.prevData[0];
+        let active = null;
+        if (log != null) {
+          for (const ch of log) {
+            if (ch?.change == null) continue;
+            active = applyChange(active, ch, this._supervisor);
+          }
+        }
+        const prevState = ctx.cache ?? void 0;
+        let nextActive = active;
+        let signOfLifeNs = null;
+        if (active != null && this._ttlNs > 0) {
+          const carried = prevState?.signOfLifeNs != null && prevState.signOfLifeNs >= active.sinceNs ? prevState.signOfLifeNs : active.sinceNs;
+          const lapsed = nowNs - carried >= this._ttlNs;
+          if (lapsed) {
+            nextActive = null;
+            signOfLifeNs = null;
+          } else if (beatThisWave) {
+            signOfLifeNs = nowNs;
+          } else {
+            signOfLifeNs = carried;
+          }
+        } else if (active != null) {
+          const carried = prevState?.signOfLifeNs != null && prevState.signOfLifeNs >= active.sinceNs ? prevState.signOfLifeNs : active.sinceNs;
+          signOfLifeNs = beatThisWave ? nowNs : carried;
+        }
+        return [
+          nextActive == null ? EMPTY_STATE : {
+            owner: nextActive.owner,
+            level: nextActive.level,
+            allowed: [nextActive.owner],
+            signOfLifeNs
+          }
+        ];
+      },
+      { keepAlive: true }
+    );
+    this.allowed = this.derived(
+      "allowed",
+      [this.current],
+      (batchData, ctx) => {
+        const batch2 = batchData[0];
+        const s = batch2 != null && batch2.length > 0 ? batch2[batch2.length - 1] : ctx.prevData[0];
+        return [s?.allowed ?? []];
+      },
+      { keepAlive: true }
+    );
+    this.guard = policyAllowing(this.allowed);
+  }
+  /**
+   * Publish a `claim`. Thin reactive wrapper over `topic.publish` (message
+   * flow per §29 — NOT an imperative trigger). `level` defaults to `"L2"`
+   * when this controller has a heartbeat wired, else `"L1"`.
+   */
+  claim(actor, level) {
+    const lvl = level ?? (this._hasHeartbeat ? "L2" : "L1");
+    this.topic.publish(makeChange({ kind: "claim", subgraphId: this.name, actor, level: lvl }));
+  }
+  /** Publish a `release`. Clears ownership iff `actor` is the current owner. */
+  release(actor) {
+    this.topic.publish(makeChange({ kind: "release", subgraphId: this.name, actor }));
+  }
+  /**
+   * Publish a supervisor `override` (L3). Wins by `level` priority
+   * regardless of expiry (Q10). `actor` should be this controller's
+   * `supervisor` id for the override to take precedence.
+   */
+  override(actor, previousActor, reason) {
+    this.topic.publish(
+      makeChange({ kind: "override", subgraphId: this.name, actor, previousActor, reason })
+    );
+  }
+};
+function makeChange(payload) {
+  const t = wallClockNs();
+  return { structure: "ownership", version: t, t_ns: t, lifecycle: "ownership", change: payload };
+}
+function applyChange(active, ch, supervisor) {
+  const p = ch.change;
+  if (p.kind === "claim") {
+    if (active != null && LEVEL_RANK[active.level] > LEVEL_RANK[p.level]) return active;
+    return { owner: p.actor, level: p.level, sinceNs: ch.t_ns };
+  }
+  if (p.kind === "release") {
+    if (active != null && active.owner === p.actor) return null;
+    return active;
+  }
+  const isSupervisor = supervisor != null && p.actor === supervisor;
+  if (isSupervisor) {
+    return { owner: p.actor, level: "L3", sinceNs: ch.t_ns };
+  }
+  return active;
+}
+function ownershipController(name, opts) {
+  return new OwnershipControllerGraph(name, opts);
+}
+
+// src/presets/harness/profile.ts
+import {
+  graphProfile
+} from "@graphrefly/pure-ts/graph";
+function harnessProfile(harness, opts) {
+  const base = graphProfile(harness, opts);
+  const queueDepths = {};
+  for (const route of QUEUE_NAMES) {
+    const t = harness.queues.has(route) ? harness.queues.topic(route) : null;
+    queueDepths[route] = t?.retained().length ?? 0;
+  }
+  return {
+    ...base,
+    queueDepths,
+    strategyEntries: harness.strategy.entries.cache?.size ?? 0,
+    totalRetries: harness.totalRetries.cache ?? 0,
+    totalReingestions: harness.totalReingestions.cache ?? 0
+  };
+}
+
+// src/presets/harness/trace.ts
+import { monotonicNs } from "@graphrefly/pure-ts/core";
+function buildStageLabels(harness) {
+  const labels = {};
+  for (const { label, paths } of harness.stageNodes()) {
+    for (const p of paths) labels[p] = label;
+  }
+  return labels;
+}
+function harnessTrace(harness, opts) {
+  const logger = opts?.logger === null ? null : opts?.logger ?? console.log;
+  const detail = opts?.detail ?? "summary";
+  const startNs = monotonicNs();
+  const observations = [];
+  const events = [];
+  const stageLabels = buildStageLabels(harness);
+  function elapsedSecs() {
+    return (monotonicNs() - startNs) / 1e9;
+  }
+  function recordEvent(stage, type, rawData) {
+    const ev = { elapsed: elapsedSecs(), stage, type };
+    if (detail !== "summary") ev.summary = summarize(rawData);
+    if (detail === "full") ev.data = rawData;
+    events.push(ev);
+  }
+  for (const [path, stage] of Object.entries(stageLabels)) {
+    try {
+      const obs = harness.observe(path, {
+        format: "stage-log",
+        stageLabels,
+        logger: logger ? (line) => logger(line) : () => {
+        },
+        includeTypes: ["data", "error", "complete"]
+      });
+      obs.onEvent((event) => {
+        if (event.type === "data") recordEvent(stage, "data", event.data);
+        else if (event.type === "error")
+          recordEvent(stage, "error", event.data);
+        else if (event.type === "complete") recordEvent(stage, "complete", void 0);
+      });
+      observations.push(obs);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      recordEvent(stage, "error", `observe-unavailable: ${path} \u2014 ${msg}`);
+      if (logger) {
+        logger(`[${elapsedSecs().toFixed(3)}s] ${stage.padEnd(9)} \u2717 observe-unavailable: ${msg}`);
+      }
+    }
+  }
+  return {
+    get events() {
+      return events;
+    },
+    dispose() {
+      for (const obs of observations) obs.dispose();
+      observations.length = 0;
+    }
+  };
+}
+function summarize(value) {
+  if (value == null) return "null";
+  if (typeof value === "string") return truncate(value, 80);
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (typeof value === "bigint") return String(value);
+  try {
+    const json = JSON.stringify(value);
+    return truncate(json, 120);
+  } catch {
+    return String(value);
+  }
+}
+function truncate(s, max) {
+  return s.length > max ? `${s.slice(0, max - 1)}\u2026` : s;
+}
+
+export {
+  actorPool,
+  refineExecutor,
+  evalVerifier,
+  harnessEvalPair,
+  OwnershipControllerGraph,
+  ownershipController,
+  harnessProfile,
+  harnessTrace
+};
+//# sourceMappingURL=chunk-RGL53X5G.js.map