@graphrefly/graphrefly 0.23.0 → 0.25.0

package/dist/index.cjs

@@ -200,6 +200,7 @@ __export(index_exports, {
   fromPromise: () => fromPromise,
   fromPulsar: () => fromPulsar,
   fromRabbitMQ: () => fromRabbitMQ,
+  fromRaf: () => fromRaf,
   fromRedisStream: () => fromRedisStream,
   fromSSE: () => fromSSE,
   fromSqlite: () => fromSqlite,
@@ -2132,37 +2133,35 @@ var NodeImpl = class _NodeImpl {
   // --- Emit pipeline ---
   /**
    * @internal The unified dispatch waist — one call = one wave.
+   * See `GRAPHREFLY-SPEC.md` §1.3.1 for protocol context — the stages
+   * below are the implementation order.
    *
    * Pipeline stages, in order:
    *
-   *   1. Early-return on empty batch.
-   *   2. Terminal filter — post-COMPLETE/ERROR only TEARDOWN/INVALIDATE
+   *   1. Terminal filter — post-COMPLETE/ERROR only TEARDOWN/INVALIDATE
    *      still propagate so graph teardown and cache-clear still work.
-   *   3. Tier sort (stable) — the batch can be in any order when it
+   *   2. Tier sort (stable) — the batch can be in any order when it
    *      arrives; the walker downstream (`downWithBatch`) assumes
    *      ascending tier monotone, and so does `_updateState`'s tier-3
    *      slice walk. This is the single source of truth for ordering.
-   *   4. Synthetic DIRTY prefix — if a tier-3 payload is present, no
+   *   3. Synthetic DIRTY prefix — if a tier-3 payload is present, no
    *      DIRTY is already in the batch, and the node isn't already in
    *      `"dirty"` status, prepend `[DIRTY]` after any tier-0 START
    *      entries. Guarantees spec §1.3.1 (DIRTY precedes DATA within
    *      the same batch) uniformly across every entry point.
-   *   5. PAUSE/RESUME lock bookkeeping (C0) — update `_pauseLocks`,
+   *   4. PAUSE/RESUME lock bookkeeping (C0) — update `_pauseLocks`,
    *      derive `_paused`, filter unknown-lockId RESUME, replay
    *      bufferAll buffer on final lock release.
-   *   6. Meta TEARDOWN fan-out — notify meta children before
+   *   5. Meta TEARDOWN fan-out — notify meta children before
    *      `_updateState`'s TEARDOWN branch calls `_deactivate`. Hoisted
    *      out of the walk to keep `_updateState` re-entrance-free.
-   *   7. `_updateState` — walk the batch in tier order, advancing
+   *   6. `_updateState` — walk the batch in tier order, advancing
    *      `_cached` / `_status` / `_versioning` and running equals
    *      substitution on tier-3 DATA (§3.5.1). Returns
    *      `{finalMessages, equalsError?}`.
-   *   8. `downWithBatch` dispatch (or bufferAll capture if paused with
+   *   7. `downWithBatch` dispatch (or bufferAll capture if paused with
    *      `pausable: "resumeAll"`).
-   *   9. Recursive ERROR emission if equals threw mid-walk.
-   *
-   * `node.down` / `node.emit` / `actions.down` / `actions.emit` all
-   * converge here — the unified `_emit` waist (spec §1.3.1).
+   *   8. Recursive ERROR emission if equals threw mid-walk.
    */
   _emit(messages) {
     if (messages.length === 0) return;
@@ -3188,6 +3187,72 @@ function fromTimer(ms, opts) {
     return cleanup;
   }, sourceOpts(rest));
 }
+function fromRaf(opts) {
+  const { signal, ...rest } = opts ?? {};
+  return producer((a) => {
+    let done = false;
+    let rafId;
+    let fallbackTimer;
+    let abortListenerAdded = false;
+    let visibilityListenerAdded = false;
+    const raf = typeof requestAnimationFrame === "function" ? requestAnimationFrame : void 0;
+    const caf = typeof cancelAnimationFrame === "function" ? cancelAnimationFrame : void 0;
+    const doc = typeof document !== "undefined" ? document : void 0;
+    const clearPending = () => {
+      if (rafId !== void 0 && caf) caf(rafId);
+      if (fallbackTimer !== void 0) clearTimeout(fallbackTimer);
+      rafId = void 0;
+      fallbackTimer = void 0;
+    };
+    const cleanup = () => {
+      done = true;
+      clearPending();
+      if (abortListenerAdded) {
+        signal?.removeEventListener("abort", onAbort);
+        abortListenerAdded = false;
+      }
+      if (visibilityListenerAdded && doc) {
+        doc.removeEventListener("visibilitychange", onVisibilityChange);
+        visibilityListenerAdded = false;
+      }
+    };
+    const onAbort = () => {
+      if (done) return;
+      cleanup();
+      a.down([[ERROR, signal.reason]]);
+    };
+    const tick = (now) => {
+      if (done) return;
+      a.emit(now);
+      scheduleNext();
+    };
+    const scheduleNext = () => {
+      if (done) return;
+      if (raf && (!doc || doc.visibilityState !== "hidden")) {
+        rafId = raf(tick);
+      } else {
+        fallbackTimer = setTimeout(() => tick(performance.now()), 16);
+      }
+    };
+    const onVisibilityChange = () => {
+      if (done) return;
+      clearPending();
+      scheduleNext();
+    };
+    if (signal?.aborted) {
+      onAbort();
+      return cleanup;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+    abortListenerAdded = signal !== void 0;
+    if (doc && raf) {
+      doc.addEventListener("visibilitychange", onVisibilityChange);
+      visibilityListenerAdded = true;
+    }
+    scheduleNext();
+    return cleanup;
+  }, sourceOpts(rest));
+}
 function fromCron(expr, opts) {
   const schedule = parseCron(expr);
   const { tickMs: tickOpt, output, ...rest } = opts ?? {};
@@ -8187,20 +8252,12 @@ function useStore4(node2) {
 function useSubscribeRecord4(keys, factory) {
   const result = (0, import_vue.shallowRef)({});
   const activeSubs = /* @__PURE__ */ new Map();
-  let disposed = false;
-  let batchPending = false;
-  function scheduleBatch() {
-    if (batchPending) return;
-    batchPending = true;
-    queueMicrotask(() => {
-      if (disposed) return;
-      batchPending = false;
-      const snap = {};
-      for (const [key, entry] of activeSubs) {
-        snap[key] = { ...entry.values };
-      }
-      result.value = snap;
-    });
+  function flushResult() {
+    const snap = {};
+    for (const [key, entry] of activeSubs) {
+      snap[key] = { ...entry.values };
+    }
+    result.value = snap;
   }
   function sync(newKeys) {
     for (const entry of activeSubs.values()) {
@@ -8217,7 +8274,7 @@ function useSubscribeRecord4(keys, factory) {
         values[field] = node2.cache;
         const unsub = node2.subscribe(() => {
           values[field] = node2.cache;
-          scheduleBatch();
+          flushResult();
         });
         subs.push(unsub);
       }
@@ -8236,7 +8293,6 @@ function useSubscribeRecord4(keys, factory) {
   (0, import_vue.watch)(readKeys, (newKeys) => sync(newKeys ?? []), { immediate: true });
   if ((0, import_vue.getCurrentScope)()) {
     (0, import_vue.onScopeDispose)(() => {
-      disposed = true;
       for (const entry of activeSubs.values()) {
         for (const unsub of entry.subs) unsub();
       }
@@ -8265,18 +8321,17 @@ function create(initializer) {
   g.add("state", s);
   const getState = () => s.cache;
   const setState = (partial, replace) => {
-    const prev = getState();
+    const prev = s.cache;
     const next = typeof partial === "function" ? partial(prev) : partial;
-    const nextState = replace ? next : { ...prev, ...next };
-    s.emit(nextState);
+    s.emit(replace ? next : { ...prev, ...next });
   };
   const api = {
     getState,
     setState,
     getInitialState: () => initialValue,
     subscribe: (listener) => {
-      let prev = getState();
       let initial = true;
+      let prev = s.cache;
       return s.subscribe((msgs) => {
         for (const [t, v] of msgs) {
           if (t === DATA) {
@@ -8380,6 +8435,7 @@ __export(extra_exports, {
   fromPromise: () => fromPromise,
   fromPulsar: () => fromPulsar,
   fromRabbitMQ: () => fromRabbitMQ,
+  fromRaf: () => fromRaf,
   fromRedisStream: () => fromRedisStream,
   fromSSE: () => fromSSE,
   fromSqlite: () => fromSqlite,
@@ -18066,7 +18122,7 @@ function analyzeAndMeasure(text, font, adapter, cache, stats) {
   const normalized = normalizeWhitespace(text);
   if (normalized.length === 0) return [];
   const pieces = segmentText(normalized);
-  const graphemeSegmenter = new Intl.Segmenter(void 0, {
+  const graphemeSegmenter2 = new Intl.Segmenter(void 0, {
     granularity: "grapheme"
   });
   const rawTexts = [];
@@ -18110,7 +18166,8 @@ function analyzeAndMeasure(text, font, adapter, cache, stats) {
     let w = fontCache.get(seg);
     if (w === void 0) {
       if (stats) stats.misses += 1;
-      w = adapter.measureSegment(seg, font).width;
+      const raw = adapter.measureSegment(seg, font).width;
+      w = Number.isFinite(raw) && raw >= 0 ? raw : 0;
       fontCache.set(seg, w);
     } else if (stats) {
       stats.hits += 1;
@@ -18132,7 +18189,7 @@ function analyzeAndMeasure(text, font, adapter, cache, stats) {
     }
     if (isCJK(t)) {
       let unitText = "";
-      for (const gs of graphemeSegmenter.segment(t)) {
+      for (const gs of graphemeSegmenter2.segment(t)) {
         const grapheme = gs.segment;
         if (unitText.length > 0 && kinsokuStart.has(grapheme)) {
           unitText += grapheme;
@@ -18164,7 +18221,7 @@ function analyzeAndMeasure(text, font, adapter, cache, stats) {
     let graphemeWidths = null;
     if (mergedWordLike[i] && t.length > 1) {
       const gWidths = [];
-      for (const gs of graphemeSegmenter.segment(t)) {
+      for (const gs of graphemeSegmenter2.segment(t)) {
         gWidths.push(measureCached(gs.segment));
       }
       if (gWidths.length > 1) {
@@ -18204,10 +18261,10 @@ function computeLineBreaks(segments, maxWidth, adapter, font, cache) {
       const seg = segments[i];
       if (seg.kind === "soft-hyphen" || seg.kind === "hard-break") continue;
       if (i === lineStartSeg && lineStartGrapheme > 0 && seg.graphemeWidths) {
-        const graphemeSegmenter = new Intl.Segmenter(void 0, {
+        const graphemeSegmenter2 = new Intl.Segmenter(void 0, {
           granularity: "grapheme"
         });
-        const graphemes = [...graphemeSegmenter.segment(seg.text)].map((g) => g.segment);
+        const graphemes = [...graphemeSegmenter2.segment(seg.text)].map((g) => g.segment);
         text += graphemes.slice(lineStartGrapheme).join("");
       } else {
         text += seg.text;
@@ -18215,10 +18272,10 @@ function computeLineBreaks(segments, maxWidth, adapter, font, cache) {
     }
     if (endGrapheme > 0 && endSeg < segments.length) {
       const seg = segments[endSeg];
-      const graphemeSegmenter = new Intl.Segmenter(void 0, {
+      const graphemeSegmenter2 = new Intl.Segmenter(void 0, {
         granularity: "grapheme"
       });
-      const graphemes = [...graphemeSegmenter.segment(seg.text)].map((g) => g.segment);
+      const graphemes = [...graphemeSegmenter2.segment(seg.text)].map((g) => g.segment);
       const startG = lineStartSeg === endSeg ? lineStartGrapheme : 0;
       text += graphemes.slice(startG, endGrapheme).join("");
     }
@@ -18238,7 +18295,7 @@ function computeLineBreaks(segments, maxWidth, adapter, font, cache) {
     pendingBreakSeg = -1;
     pendingBreakWidth = 0;
   }
-  function canBreakAfter(kind) {
+  function canBreakAfter2(kind) {
     return kind === "space" || kind === "zero-width-break" || kind === "soft-hyphen";
   }
   function startLine(segIdx, graphemeIdx, width) {
@@ -18283,7 +18340,7 @@ function computeLineBreaks(segments, maxWidth, adapter, font, cache) {
       } else {
         startLine(i, 0, w);
       }
-      if (canBreakAfter(seg.kind)) {
+      if (canBreakAfter2(seg.kind)) {
         pendingBreakSeg = i + 1;
         pendingBreakWidth = seg.kind === "space" ? lineW - w : lineW;
       }
@@ -18291,7 +18348,7 @@ function computeLineBreaks(segments, maxWidth, adapter, font, cache) {
     }
     const newW = lineW + w;
     if (newW > maxWidth + 5e-3) {
-      if (canBreakAfter(seg.kind)) {
+      if (canBreakAfter2(seg.kind)) {
         lineW += w;
         lineEndSeg = i + 1;
         lineEndGrapheme = 0;
@@ -18315,7 +18372,7 @@ function computeLineBreaks(segments, maxWidth, adapter, font, cache) {
     lineW = newW;
     lineEndSeg = i + 1;
     lineEndGrapheme = 0;
-    if (canBreakAfter(seg.kind)) {
+    if (canBreakAfter2(seg.kind)) {
       pendingBreakSeg = i + 1;
       pendingBreakWidth = seg.kind === "space" ? lineW - w : lineW;
     }
@@ -18346,9 +18403,289 @@ function computeLineBreaks(segments, maxWidth, adapter, font, cache) {
     }
   }
 }
+function canBreakAfter(kind) {
+  return kind === "space" || kind === "zero-width-break" || kind === "soft-hyphen";
+}
+var _graphemeSegmenter = null;
+function graphemeSegmenter() {
+  if (_graphemeSegmenter === null) {
+    _graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+  }
+  return _graphemeSegmenter;
+}
+function sliceSegmentText(seg, startG, endG) {
+  if (startG === 0 && endG < 0) return seg.text;
+  const graphemes = [...graphemeSegmenter().segment(seg.text)].map((g) => g.segment);
+  const stop = endG < 0 ? graphemes.length : endG;
+  return graphemes.slice(startG, stop).join("");
+}
+function buildLineText(segments, startSeg, startG, endSeg, endG, appendHyphen) {
+  let text = "";
+  for (let i = startSeg; i < endSeg; i++) {
+    const seg = segments[i];
+    if (seg.kind === "soft-hyphen" || seg.kind === "hard-break") continue;
+    if (i === startSeg && startG > 0) {
+      text += sliceSegmentText(seg, startG, -1);
+    } else {
+      text += seg.text;
+    }
+  }
+  if (endG > 0 && endSeg < segments.length) {
+    const seg = segments[endSeg];
+    const from = startSeg === endSeg ? startG : 0;
+    text += sliceSegmentText(seg, from, endG);
+  }
+  if (appendHyphen) text += "-";
+  return text;
+}
+function resolveHyphenWidth(ctx) {
+  if (!ctx || !ctx.adapter || !ctx.font) return 0;
+  const cache = ctx.cache;
+  if (cache) {
+    let fc = cache.get(ctx.font);
+    if (!fc) {
+      fc = /* @__PURE__ */ new Map();
+      cache.set(ctx.font, fc);
+    }
+    let hw = fc.get("-");
+    if (hw === void 0) {
+      hw = ctx.adapter.measureSegment("-", ctx.font).width;
+      fc.set("-", hw);
+    }
+    return hw;
+  }
+  return ctx.adapter.measureSegment("-", ctx.font).width;
+}
+function layoutNextLine(segments, cursor, slotWidth, ctx) {
+  let i = cursor.segmentIndex;
+  const initialG = cursor.graphemeIndex;
+  if (i >= segments.length) return null;
+  if (initialG === 0) {
+    while (i < segments.length) {
+      const seg = segments[i];
+      if (seg.kind === "hard-break") {
+        return {
+          text: "",
+          width: 0,
+          start: { segmentIndex: cursor.segmentIndex, graphemeIndex: 0 },
+          end: { segmentIndex: i + 1, graphemeIndex: 0 }
+        };
+      }
+      if (seg.kind === "space" || seg.kind === "zero-width-break" || seg.kind === "soft-hyphen") {
+        i += 1;
+        continue;
+      }
+      break;
+    }
+    if (i >= segments.length) return null;
+  }
+  const hyphenWidth = resolveHyphenWidth(ctx);
+  const startSeg = i;
+  const startG = i === cursor.segmentIndex ? initialG : 0;
+  let lineW = 0;
+  let lineEndSeg = startSeg;
+  let lineEndG = 0;
+  let hasContent = false;
+  let pendingBreakSeg = -1;
+  let pendingBreakG = 0;
+  let pendingBreakWidth = 0;
+  let pendingBreakSoftHyphen = false;
+  const recordPending = (sIdx, gIdx, widthAtBreak, kind) => {
+    pendingBreakSeg = sIdx;
+    pendingBreakG = gIdx;
+    pendingBreakWidth = widthAtBreak;
+    pendingBreakSoftHyphen = kind === "soft-hyphen";
+  };
+  const consumeBreakable = (segIdx, gStart, gWidths) => {
+    for (let g = gStart; g < gWidths.length; g++) {
+      const gw = gWidths[g];
+      if (!hasContent) {
+        lineW = gw;
+        lineEndSeg = segIdx;
+        lineEndG = g + 1;
+        hasContent = true;
+        continue;
+      }
+      if (lineW + gw > slotWidth + 5e-3) {
+        return true;
+      }
+      lineW += gw;
+      lineEndSeg = segIdx;
+      lineEndG = g + 1;
+    }
+    if (lineEndSeg === segIdx && lineEndG === gWidths.length) {
+      lineEndSeg = segIdx + 1;
+      lineEndG = 0;
+    }
+    return false;
+  };
+  if (startG > 0 && startSeg < segments.length) {
+    const seg = segments[startSeg];
+    if (seg.graphemeWidths) {
+      const overflowed = consumeBreakable(startSeg, startG, seg.graphemeWidths);
+      if (overflowed) {
+        const text2 = buildLineText(segments, startSeg, startG, lineEndSeg, lineEndG, false);
+        return {
+          text: text2,
+          width: lineW,
+          start: { segmentIndex: startSeg, graphemeIndex: startG },
+          end: { segmentIndex: lineEndSeg, graphemeIndex: lineEndG }
+        };
+      }
+      i = lineEndSeg;
+    } else {
+    }
+  }
+  for (; i < segments.length; ) {
+    const seg = segments[i];
+    if (seg.kind === "hard-break") {
+      if (hasContent) {
+        const endsAtSoftHyphen2 = lineEndSeg > 0 && segments[lineEndSeg - 1]?.kind === "soft-hyphen";
+        const text2 = buildLineText(
+          segments,
+          startSeg,
+          startG,
+          lineEndSeg,
+          lineEndG,
+          endsAtSoftHyphen2
+        );
+        return {
+          text: text2,
+          width: lineW + (endsAtSoftHyphen2 ? hyphenWidth : 0),
+          start: { segmentIndex: startSeg, graphemeIndex: startG },
+          end: { segmentIndex: lineEndSeg, graphemeIndex: lineEndG }
+        };
+      }
+      return {
+        text: "",
+        width: 0,
+        start: { segmentIndex: startSeg, graphemeIndex: startG },
+        end: { segmentIndex: i + 1, graphemeIndex: 0 }
+      };
+    }
+    const w = seg.width;
+    if (!hasContent) {
+      if (w > slotWidth && seg.graphemeWidths) {
+        const overflowed = consumeBreakable(i, 0, seg.graphemeWidths);
+        if (overflowed) {
+          const text2 = buildLineText(segments, startSeg, startG, lineEndSeg, lineEndG, false);
+          return {
+            text: text2,
+            width: lineW,
+            start: { segmentIndex: startSeg, graphemeIndex: startG },
+            end: { segmentIndex: lineEndSeg, graphemeIndex: lineEndG }
+          };
+        }
+        i = lineEndSeg;
+        continue;
+      }
+      lineW = w;
+      lineEndSeg = i + 1;
+      lineEndG = 0;
+      hasContent = true;
+      if (canBreakAfter(seg.kind)) {
+        recordPending(i + 1, 0, seg.kind === "space" ? lineW - w : lineW, seg.kind);
+      }
+      i += 1;
+      continue;
+    }
+    const newW = lineW + w;
+    if (newW > slotWidth + 5e-3) {
+      if (canBreakAfter(seg.kind)) {
+        lineEndSeg = i + 1;
+        lineEndG = 0;
+        const endsAtSoftHyphen2 = seg.kind === "soft-hyphen";
+        const finalWidth = seg.kind === "space" ? lineW : lineW + (endsAtSoftHyphen2 ? hyphenWidth : 0);
+        const text3 = buildLineText(
+          segments,
+          startSeg,
+          startG,
+          lineEndSeg,
+          lineEndG,
+          endsAtSoftHyphen2
+        );
+        return {
+          text: text3,
+          width: finalWidth,
+          start: { segmentIndex: startSeg, graphemeIndex: startG },
+          end: { segmentIndex: lineEndSeg, graphemeIndex: lineEndG }
+        };
+      }
+      if (pendingBreakSeg >= 0) {
+        const text3 = buildLineText(
+          segments,
+          startSeg,
+          startG,
+          pendingBreakSeg,
+          pendingBreakG,
+          pendingBreakSoftHyphen
+        );
+        return {
+          text: text3,
+          width: pendingBreakWidth + (pendingBreakSoftHyphen ? hyphenWidth : 0),
+          start: { segmentIndex: startSeg, graphemeIndex: startG },
+          end: { segmentIndex: pendingBreakSeg, graphemeIndex: pendingBreakG }
+        };
+      }
+      if (w > slotWidth && seg.graphemeWidths) {
+        const text3 = buildLineText(segments, startSeg, startG, lineEndSeg, lineEndG, false);
+        return {
+          text: text3,
+          width: lineW,
+          start: { segmentIndex: startSeg, graphemeIndex: startG },
+          end: { segmentIndex: lineEndSeg, graphemeIndex: lineEndG }
+        };
+      }
+      const text2 = buildLineText(segments, startSeg, startG, lineEndSeg, lineEndG, false);
+      return {
+        text: text2,
+        width: lineW,
+        start: { segmentIndex: startSeg, graphemeIndex: startG },
+        end: { segmentIndex: lineEndSeg, graphemeIndex: lineEndG }
+      };
+    }
+    lineW = newW;
+    lineEndSeg = i + 1;
+    lineEndG = 0;
+    if (canBreakAfter(seg.kind)) {
+      recordPending(i + 1, 0, seg.kind === "space" ? lineW - w : lineW, seg.kind);
+    }
+    i += 1;
+  }
+  if (!hasContent) return null;
+  const endsAtSoftHyphen = lineEndSeg > 0 && segments[lineEndSeg - 1]?.kind === "soft-hyphen";
+  const text = buildLineText(segments, startSeg, startG, lineEndSeg, lineEndG, endsAtSoftHyphen);
+  return {
+    text,
+    width: lineW + (endsAtSoftHyphen ? hyphenWidth : 0),
+    start: { segmentIndex: startSeg, graphemeIndex: startG },
+    end: { segmentIndex: lineEndSeg, graphemeIndex: lineEndG }
+  };
+}
+function carveTextLineSlots(base, blocked, minSlotWidth = 0) {
+  let slots = [base];
+  for (let bi = 0; bi < blocked.length; bi++) {
+    const block = blocked[bi];
+    const next = [];
+    for (let si = 0; si < slots.length; si++) {
+      const slot = slots[si];
+      if (block.right <= slot.left || block.left >= slot.right) {
+        next.push(slot);
+        continue;
+      }
+      if (block.left > slot.left) next.push({ left: slot.left, right: block.left });
+      if (block.right < slot.right) next.push({ left: block.right, right: slot.right });
+    }
+    slots = next;
+  }
+  if (minSlotWidth > 0) {
+    return slots.filter((s) => s.right - s.left >= minSlotWidth);
+  }
+  return slots;
+}
 function computeCharPositions(lineBreaks, segments, lineHeight) {
   const positions = [];
-  const graphemeSegmenter = new Intl.Segmenter(void 0, {
+  const graphemeSegmenter2 = new Intl.Segmenter(void 0, {
     granularity: "grapheme"
   });
   for (let lineIdx = 0; lineIdx < lineBreaks.lines.length; lineIdx++) {
@@ -18361,7 +18698,7 @@ function computeCharPositions(lineBreaks, segments, lineHeight) {
         if (si >= line.endSegment && line.endGrapheme === 0) break;
         continue;
       }
-      const graphemes = [...graphemeSegmenter.segment(seg.text)].map((g) => g.segment);
+      const graphemes = [...graphemeSegmenter2.segment(seg.text)].map((g) => g.segment);
       if (graphemes.length === 0) continue;
       const startG = si === line.startSegment ? line.startGrapheme : 0;
       let endG;
@@ -21352,14 +21689,20 @@ __export(reactive_layout_exports, {
   PrecomputedAdapter: () => PrecomputedAdapter,
   SvgBoundsAdapter: () => SvgBoundsAdapter,
   analyzeAndMeasure: () => analyzeAndMeasure,
+  carveTextLineSlots: () => carveTextLineSlots,
+  circleIntervalForBand: () => circleIntervalForBand,
   computeBlockFlow: () => computeBlockFlow,
   computeCharPositions: () => computeCharPositions,
+  computeFlowLines: () => computeFlowLines,
   computeLineBreaks: () => computeLineBreaks,
   computeTotalHeight: () => computeTotalHeight,
+  layoutNextLine: () => layoutNextLine,
   measureBlock: () => measureBlock,
   measureBlocks: () => measureBlocks,
   reactiveBlockLayout: () => reactiveBlockLayout,
-  reactiveLayout: () => reactiveLayout
+  reactiveFlowLayout: () => reactiveFlowLayout,
+  reactiveLayout: () => reactiveLayout,
+  rectIntervalForBand: () => rectIntervalForBand
 });
 
 // src/patterns/reactive-layout/measurement-adapters.ts
@@ -21827,6 +22170,185 @@ function reactiveBlockLayout(opts) {
   };
 }
 
+// src/patterns/reactive-layout/reactive-flow-layout.ts
+function circleIntervalForBand(o, bandTop, bandBottom) {
+  const hPad = o.hPad ?? 0;
+  const vPad = o.vPad ?? 0;
+  const top = bandTop - vPad;
+  const bottom = bandBottom + vPad;
+  if (top >= o.cy + o.r || bottom <= o.cy - o.r) return null;
+  const minDy = o.cy >= top && o.cy <= bottom ? 0 : o.cy < top ? top - o.cy : o.cy - bottom;
+  if (minDy >= o.r) return null;
+  const maxDx = Math.sqrt(o.r * o.r - minDy * minDy);
+  return { left: o.cx - maxDx - hPad, right: o.cx + maxDx + hPad };
+}
+function rectIntervalForBand(o, bandTop, bandBottom) {
+  const hPad = o.hPad ?? 0;
+  const vPad = o.vPad ?? 0;
+  if (bandBottom <= o.y - vPad) return null;
+  if (bandTop >= o.y + o.h + vPad) return null;
+  return { left: o.x - hPad, right: o.x + o.w + hPad };
+}
+function obstacleIntervalForBand(o, bandTop, bandBottom) {
+  return o.kind === "circle" ? circleIntervalForBand(o, bandTop, bandBottom) : rectIntervalForBand(o, bandTop, bandBottom);
+}
+function computeFlowLines(segments, container, columns, obstacles, lineHeight, minSlotWidth) {
+  const lines = [];
+  let cursor = { segmentIndex: 0, graphemeIndex: 0 };
+  if (segments.length === 0 || columns.count <= 0 || lineHeight <= 0) {
+    return { lines, cursor };
+  }
+  const padX = container.paddingX ?? 0;
+  const padY = container.paddingY ?? 0;
+  const availWidth = Math.max(0, container.width - padX * 2);
+  const availHeight = Math.max(0, container.height - padY * 2);
+  const gapTotal = columns.gap * Math.max(0, columns.count - 1);
+  const colWidth = Math.max(0, (availWidth - gapTotal) / columns.count);
+  if (colWidth <= 0) return { lines, cursor };
+  outerCol: for (let col = 0; col < columns.count; col++) {
+    const colLeft = padX + col * (colWidth + columns.gap);
+    const colRight = colLeft + colWidth;
+    let bandTop = padY;
+    while (bandTop + lineHeight <= padY + availHeight) {
+      const bandBottom = bandTop + lineHeight;
+      const blocked = [];
+      for (let oi = 0; oi < obstacles.length; oi++) {
+        const iv = obstacleIntervalForBand(obstacles[oi], bandTop, bandBottom);
+        if (iv !== null) blocked.push(iv);
+      }
+      const slots = carveTextLineSlots({ left: colLeft, right: colRight }, blocked, minSlotWidth);
+      if (slots.length === 0) {
+        bandTop += lineHeight;
+        continue;
+      }
+      let hardBreakThisBand = false;
+      for (let si = 0; si < slots.length; si++) {
+        const slot = slots[si];
+        const slotW = slot.right - slot.left;
+        const line = layoutNextLine(segments, cursor, slotW);
+        if (line === null) {
+          return { lines, cursor };
+        }
+        if (line.text.length === 0 && line.width === 0) {
+          cursor = line.end;
+          hardBreakThisBand = true;
+          break;
+        }
+        lines.push({
+          x: slot.left,
+          y: bandTop,
+          width: line.width,
+          slotWidth: slotW,
+          text: line.text,
+          columnIndex: col,
+          flushToRight: slot.right < colRight - 0.5
+        });
+        cursor = line.end;
+      }
+      bandTop += lineHeight;
+      if (hardBreakThisBand) continue;
+      if (cursor.segmentIndex >= segments.length) break outerCol;
+    }
+    if (cursor.segmentIndex >= segments.length) break;
+  }
+  return { lines, cursor };
+}
+function reactiveFlowLayout(opts) {
+  const { adapter, name = "reactive-flow-layout", minSlotWidth = 20 } = opts;
+  const g = new Graph(name);
+  const measureCache = /* @__PURE__ */ new Map();
+  const textNode = state(opts.text ?? "", { name: "text" });
+  const fontNode = state(opts.font ?? "16px sans-serif", { name: "font" });
+  const lineHeightNode = state(opts.lineHeight ?? 20, { name: "line-height" });
+  const containerNode = state(
+    opts.container ?? { width: 800, height: 600, paddingX: 0, paddingY: 0 },
+    { name: "container" }
+  );
+  const columnsNode = state(opts.columns ?? { count: 1, gap: 0 }, {
+    name: "columns"
+  });
+  const obstaclesNode = state(opts.obstacles ?? [], { name: "obstacles" });
+  const segmentsNode = node(
+    [textNode, fontNode],
+    (data, actions, ctx) => {
+      const b0 = data[0];
+      const textVal = b0 != null && b0.length > 0 ? b0.at(-1) : ctx.prevData[0];
+      const b1 = data[1];
+      const fontVal = b1 != null && b1.length > 0 ? b1.at(-1) : ctx.prevData[1];
+      const result = analyzeAndMeasure(textVal, fontVal, adapter, measureCache);
+      actions.emit(result);
+      return () => {
+        measureCache.clear();
+        adapter.clearCache?.();
+      };
+    },
+    { name: "segments", describeKind: "derived" }
+  );
+  const flowLinesNode = derived(
+    [segmentsNode, containerNode, columnsNode, obstaclesNode, lineHeightNode],
+    ([segs, cont, cols, obs, lh]) => {
+      const segments = segs;
+      const t0 = monotonicNs();
+      const { lines: result, cursor } = computeFlowLines(
+        segments,
+        cont,
+        cols,
+        obs,
+        lh,
+        minSlotWidth
+      );
+      const elapsed = monotonicNs() - t0;
+      const overflow = Math.max(0, segments.length - cursor.segmentIndex);
+      const meta = flowLinesNode.meta;
+      if (meta) {
+        emitToMeta(meta["line-count"], result.length);
+        emitToMeta(meta["layout-time-ns"], elapsed);
+        emitToMeta(meta["overflow-segments"], overflow);
+      }
+      return result;
+    },
+    {
+      name: "flow-lines",
+      meta: {
+        "line-count": 0,
+        "layout-time-ns": 0,
+        "overflow-segments": 0
+      },
+      equals: (a, b) => {
+        const la = a;
+        const lb = b;
+        if (la.length !== lb.length) return false;
+        for (let i = 0; i < la.length; i++) {
+          const pa = la[i];
+          const pb = lb[i];
+          if (pa.x !== pb.x || pa.y !== pb.y || pa.width !== pb.width || pa.slotWidth !== pb.slotWidth || pa.text !== pb.text || pa.columnIndex !== pb.columnIndex || pa.flushToRight !== pb.flushToRight)
+            return false;
+        }
+        return true;
+      }
+    }
+  );
+  g.add("text", textNode);
+  g.add("font", fontNode);
+  g.add("line-height", lineHeightNode);
+  g.add("container", containerNode);
+  g.add("columns", columnsNode);
+  g.add("obstacles", obstaclesNode);
+  g.add("segments", segmentsNode);
+  g.add("flow-lines", flowLinesNode);
+  return {
+    graph: g,
+    setText: (t) => g.set("text", t),
+    setFont: (f) => g.set("font", f),
+    setLineHeight: (lh) => g.set("line-height", lh),
+    setContainer: (c) => g.set("container", c),
+    setColumns: (c) => g.set("columns", c),
+    setObstacles: (o) => g.set("obstacles", o),
+    segments: segmentsNode,
+    flowLines: flowLinesNode
+  };
+}
+
 // src/index.ts
 var version = "0.0.0";
 // Annotate the CommonJS export names for ESM import in node:
@@ -21966,6 +22488,7 @@ var version = "0.0.0";
   fromPromise,
   fromPulsar,
   fromRabbitMQ,
+  fromRaf,
   fromRedisStream,
   fromSSE,
   fromSqlite,