@textui/core 0.1.0

package/dist/util/markdown.js

@@ -0,0 +1,220 @@
+import { graphemes, stringWidth, wrapText } from './text.js';
+/**
+ * Markdown, laid out.
+ *
+ * Not a parser - a formatter for the subset that appears in READMEs, notes and
+ * anything an agent or a service writes for a person: headings, lists, rules,
+ * fences, block quotes, and inline emphasis, code and links.
+ *
+ * Pure, and measured in cells. It takes the glyphs it needs rather than
+ * reading a theme, so it can be called from a test, from a viewer that windows
+ * the rows, and from a component that draws all of them.
+ */
+/**
+ * The delimiters, guarded.
+ *
+ * The guards are the whole difficulty. A single `*` beside a double one is not
+ * an opener - `2 * 3 and **half a bold` italicised " 3 and " and ate a
+ * character, because the lone asterisk paired with the first half of the
+ * unclosed pair. A delimiter with a space just inside it is arithmetic or a
+ * footnote, not emphasis. And an underscore needs a word boundary as well, or
+ * `snake_case_name` goes italic in the middle.
+ */
+const PATTERNS = [
+    String.raw `\*\*(?!\s)[^*]+(?<!\s)\*\*`,
+    String.raw `(?<![\w_])__(?!\s)[^_]+(?<!\s)__(?![\w_])`,
+    String.raw `\x60[^\x60]+\x60`,
+    String.raw `(?<!\*)\*(?!\s)[^*]+(?<!\s)\*(?!\*)`,
+    String.raw `(?<![\w_])_(?!\s)[^_]+(?<!\s)_(?![\w_])`,
+    String.raw `\[[^\]]+\]\([^)]+\)`,
+];
+/** One capturing group, so `split` keeps the delimited pieces. */
+const INLINE = new RegExp(`(${PATTERNS.join('|')})`);
+/**
+ * Emphasis, code and links, as styled runs.
+ *
+ * Unmatched markers stay literal: a lone asterisk in prose is an asterisk, and
+ * a document that reformats itself as the closing one arrives is worse than
+ * one that never tried.
+ */
+export function inlineRuns(text) {
+    const runs = [];
+    for (const piece of text.split(INLINE)) {
+        if (piece === '')
+            continue;
+        if (/^\*\*[^*]+\*\*$/.test(piece) || /^__[^_]+__$/.test(piece)) {
+            runs.push({ text: piece.slice(2, -2), bold: true });
+        }
+        else if (/^`[^`]+`$/.test(piece)) {
+            runs.push({ text: piece.slice(1, -1), code: true });
+        }
+        else if (/^\*[^*]+\*$/.test(piece) || /^_[^_]+_$/.test(piece)) {
+            runs.push({ text: piece.slice(1, -1), italic: true });
+        }
+        else {
+            const link = /^\[([^\]]+)\]\(([^)]+)\)$/.exec(piece);
+            if (link)
+                runs.push({ text: link[1] ?? '', link: link[2] ?? '' });
+            else
+                runs.push({ text: piece });
+        }
+    }
+    return runs.length > 0 ? runs : [{ text: '' }];
+}
+/**
+ * Fold styled runs into lines that fit.
+ *
+ * `wrapText` wraps a string, and a string cannot carry which half of it was
+ * bold - so the wrap happens over runs, on cell widths rather than character
+ * counts. A word longer than the whole width is broken rather than allowed to
+ * decide the width of the pane it is in.
+ */
+export function wrapRuns(runs, width) {
+    if (width <= 0)
+        return [runs];
+    const lines = [];
+    let line = [];
+    let used = 0;
+    const push = (run, text) => {
+        const last = line[line.length - 1];
+        if (last && sameStyle(last, run))
+            last.text += text;
+        else
+            line.push({ ...run, text });
+        used += stringWidth(text);
+    };
+    for (const run of runs) {
+        for (const word of run.text.split(/(\s+)/)) {
+            if (word === '')
+                continue;
+            const w = stringWidth(word);
+            if (/^\s+$/.test(word)) {
+                // A space at the start of a line is a space nobody typed.
+                if (used > 0 && used + w <= width)
+                    push(run, word);
+                continue;
+            }
+            if (used + w > width && used > 0) {
+                lines.push(line);
+                line = [];
+                used = 0;
+            }
+            if (w > width) {
+                let rest = graphemes(word);
+                while (rest.length > 0) {
+                    const room = Math.max(1, width - used);
+                    push(run, rest.slice(0, room).join(''));
+                    rest = rest.slice(room);
+                    if (rest.length > 0) {
+                        lines.push(line);
+                        line = [];
+                        used = 0;
+                    }
+                }
+                continue;
+            }
+            push(run, word);
+        }
+    }
+    if (line.length > 0)
+        lines.push(line);
+    return lines.length > 0 ? lines : [[{ text: '' }]];
+}
+function sameStyle(a, b) {
+    return !!a.bold === !!b.bold && !!a.italic === !!b.italic
+        && !!a.code === !!b.code && a.link === b.link;
+}
+/** Wrapped rows behind a gutter: the marker on the first, its width on the rest. */
+function withPrefix(runs, width, prefix, options = {}) {
+    const gutter = stringWidth(prefix);
+    const rest = options.continued ?? ' '.repeat(gutter);
+    return wrapRuns(runs, width <= 0 ? 0 : Math.max(1, width - gutter - 1)).map((line, index) => ({
+        kind: 'text',
+        runs: line,
+        prefix: index === 0 ? prefix : rest,
+        ...(options.prefixFg ? { prefixFg: options.prefixFg } : {}),
+    }));
+}
+export function layoutMarkdown(source, options) {
+    const { width, bullet = '-', quoteBar = '|', ruled = true } = options;
+    const lines = Array.isArray(source) ? source : source.replace(/\r\n/g, '\n').split('\n');
+    const rows = [];
+    let fence = 0;
+    let inFence = false;
+    let language = '';
+    for (const line of lines) {
+        const marker = /^\s*```(\S*)\s*$/.exec(line);
+        if (marker) {
+            // An open fence is laid out as a fence from the moment it opens. A turn
+            // is streamed, so the closing marker may simply not have been said yet -
+            // and a block that flickers between prose and code as the words land is
+            // worse than one shown open.
+            if (!inFence)
+                language = marker[1] ?? '';
+            if (ruled)
+                rows.push({ kind: 'fence', fence, part: inFence ? 'close' : 'open', ...(language ? { language } : {}) });
+            if (inFence)
+                fence++;
+            inFence = !inFence;
+            continue;
+        }
+        if (inFence) {
+            rows.push({ kind: 'fence', fence, part: 'code', text: line, ...(language ? { language } : {}) });
+            continue;
+        }
+        const heading = /^(#{1,6})\s+(.*)$/.exec(line);
+        if (heading) {
+            const level = heading[1].length;
+            for (const runs of wrapRuns(inlineRuns(heading[2] ?? ''), width)) {
+                rows.push({ kind: 'heading', runs, level });
+            }
+            continue;
+        }
+        if (/^\s*([-*_])\1{2,}\s*$/.test(line)) {
+            rows.push({ kind: 'rule' });
+            continue;
+        }
+        const item = /^(\s*)[-*+]\s+(.*)$/.exec(line);
+        if (item) {
+            rows.push(...withPrefix(inlineRuns(item[2] ?? ''), width, `${item[1]}${bullet}`));
+            continue;
+        }
+        const ordered = /^(\s*)(\d+)[.)]\s+(.*)$/.exec(line);
+        if (ordered) {
+            rows.push(...withPrefix(inlineRuns(ordered[3] ?? ''), width, `${ordered[1]}${ordered[2]}.`));
+            continue;
+        }
+        const quote = /^\s*>\s?(.*)$/.exec(line);
+        if (quote) {
+            // The bar repeats down every row of the quote: a rule that stopped after
+            // the first wrapped row would read as one quoted line and some prose.
+            rows.push(...withPrefix(inlineRuns(quote[1] ?? ''), width, quoteBar, {
+                continued: quoteBar,
+                prefixFg: 'borderSubtle',
+            }));
+            continue;
+        }
+        if (line.trim() === '') {
+            rows.push({ kind: 'text', runs: [{ text: '' }] });
+            continue;
+        }
+        for (const runs of wrapRuns(inlineRuns(line), width))
+            rows.push({ kind: 'text', runs });
+    }
+    // An unterminated fence still gets its closing rule, so the box reads as a
+    // box rather than as something the renderer forgot to finish.
+    if (inFence && ruled)
+        rows.push({ kind: 'fence', fence, part: 'close' });
+    return rows;
+}
+/** Every run's text, for a measurement or a test that does not care how it looks. */
+export function runsToText(runs) {
+    return runs.map((run) => run.text).join('');
+}
+/** Wrap plain text the way a row does, for callers that have no runs. */
+export function wrapAt(text, width) {
+    if (width <= 0)
+        return [text];
+    const wrapped = wrapText(text, width);
+    return wrapped.length > 0 ? wrapped : [''];
+}

package/dist/util/paths.d.ts

@@ -0,0 +1,47 @@
+import type { BindingPath } from '../types/graph.js';
+/**
+ * Store paths are JSON-Pointer-shaped.
+ *
+ *   `$/scope/a/b`  absolute; the first segment is the scope
+ *   `/a/b`         relative to the surrounding data context
+ *   `..`           forbidden - escape to the root with `$/` instead, so a
+ *                  node's meaning never depends on where it was pasted
+ *   `*`            wildcard segment; legal in subscriptions, never in writes
+ *
+ * Internally a path is its segment list. The canonical key is the segments
+ * joined by `/` with no sigil, which is what every map here is keyed by.
+ */
+export declare class PathError extends Error {
+    readonly path: string;
+    constructor(message: string, path: string);
+}
+export declare function escapeSegment(seg: string): string;
+export declare function isAbsolute(path: string): path is `$/${string}`;
+export declare function isRelative(path: string): boolean;
+/** Split into segments. Does not resolve relatives - use `resolvePath`. */
+export declare function segments(path: string): string[];
+/**
+ * Canonical map key for a path: segments joined, no sigil.
+ *
+ * The segments are re-escaped on the way out. Everything downstream - the
+ * store's own walk, `ancestorKeys`, `matchKey` - splits a key on `/`, so a
+ * segment that legitimately contains one (a URI used as a key, a filename with
+ * a slash) has to stay escaped or it silently becomes several segments and the
+ * value lands somewhere nobody looks.
+ */
+export declare function pathKey(path: string): string;
+export declare function joinPath(...parts: (string | number)[]): BindingPath;
+/**
+ * Resolve a possibly-relative path against a data context.
+ * A relative path with no context is an error a caller should never reach.
+ */
+export declare function resolvePath(path: string, dataContext?: string): BindingPath;
+export declare function scopeOf(path: string): string;
+export declare function parentKey(key: string): string | null;
+/** Every ancestor key of `key`, closest first, including `''` for the root. */
+export declare function ancestorKeys(key: string): string[];
+export declare function isDescendantKey(key: string, ancestor: string): boolean;
+export declare function hasWildcard(path: string): boolean;
+/** Match a concrete key against a pattern key that may contain `*`. */
+export declare function matchKey(key: string, pattern: string, subtree?: boolean): boolean;
+//# sourceMappingURL=paths.d.ts.map

package/dist/util/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../src/util/paths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD;;;;;;;;;;;GAWG;AAEH,qBAAa,SAAU,SAAQ,KAAK;IACL,QAAQ,CAAC,IAAI,EAAE,MAAM;gBAAtC,OAAO,EAAE,MAAM,EAAW,IAAI,EAAE,MAAM;CAInD;AAMD,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,KAAK,MAAM,EAAE,CAE9D;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED,2EAA2E;AAC3E,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAQ/C;AAED;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE5C;AAED,wBAAgB,QAAQ,CAAC,GAAG,KAAK,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,GAAG,WAAW,CASnE;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,WAAW,CAW3E;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAG5C;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGpD;AAED,+EAA+E;AAC/E,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAWlD;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAGtE;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEjD;AAED,uEAAuE;AACvE,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,UAAQ,GAAG,OAAO,CAa/E"}

package/dist/util/paths.js

@@ -0,0 +1,134 @@
+/**
+ * Store paths are JSON-Pointer-shaped.
+ *
+ *   `$/scope/a/b`  absolute; the first segment is the scope
+ *   `/a/b`         relative to the surrounding data context
+ *   `..`           forbidden - escape to the root with `$/` instead, so a
+ *                  node's meaning never depends on where it was pasted
+ *   `*`            wildcard segment; legal in subscriptions, never in writes
+ *
+ * Internally a path is its segment list. The canonical key is the segments
+ * joined by `/` with no sigil, which is what every map here is keyed by.
+ */
+export class PathError extends Error {
+    path;
+    constructor(message, path) {
+        super(`${message}: ${path}`);
+        this.path = path;
+        this.name = 'PathError';
+    }
+}
+function unescapeSegment(seg) {
+    return seg.includes('~') ? seg.replace(/~1/g, '/').replace(/~0/g, '~') : seg;
+}
+export function escapeSegment(seg) {
+    return seg.replace(/~/g, '~0').replace(/\//g, '~1');
+}
+export function isAbsolute(path) {
+    return path.startsWith('$/');
+}
+export function isRelative(path) {
+    return path.startsWith('/');
+}
+/** Split into segments. Does not resolve relatives - use `resolvePath`. */
+export function segments(path) {
+    const body = isAbsolute(path) ? path.slice(2) : path.startsWith('/') ? path.slice(1) : path;
+    if (body === '')
+        return [];
+    const parts = body.split('/');
+    for (const p of parts) {
+        if (p === '..')
+            throw new PathError('".." is forbidden in a store path', path);
+    }
+    return parts.map(unescapeSegment);
+}
+/**
+ * Canonical map key for a path: segments joined, no sigil.
+ *
+ * The segments are re-escaped on the way out. Everything downstream - the
+ * store's own walk, `ancestorKeys`, `matchKey` - splits a key on `/`, so a
+ * segment that legitimately contains one (a URI used as a key, a filename with
+ * a slash) has to stay escaped or it silently becomes several segments and the
+ * value lands somewhere nobody looks.
+ */
+export function pathKey(path) {
+    return segments(path).map(escapeSegment).join('/');
+}
+export function joinPath(...parts) {
+    const segs = [];
+    for (const p of parts) {
+        const s = String(p);
+        for (const seg of s.replace(/^\$\//, '').replace(/^\//, '').split('/')) {
+            if (seg !== '')
+                segs.push(seg);
+        }
+    }
+    return `$/${segs.join('/')}`;
+}
+/**
+ * Resolve a possibly-relative path against a data context.
+ * A relative path with no context is an error a caller should never reach.
+ */
+export function resolvePath(path, dataContext) {
+    if (isAbsolute(path))
+        return path;
+    if (!path.startsWith('/')) {
+        throw new PathError('a path must start with "$/" or "/"', path);
+    }
+    if (!dataContext) {
+        throw new PathError('relative path used with no data context', path);
+    }
+    const base = segments(dataContext);
+    const rest = segments(path);
+    return `$/${[...base, ...rest].join('/')}`;
+}
+export function scopeOf(path) {
+    const segs = segments(path);
+    return segs[0] ?? '';
+}
+export function parentKey(key) {
+    const i = key.lastIndexOf('/');
+    return i === -1 ? (key === '' ? null : '') : key.slice(0, i);
+}
+/** Every ancestor key of `key`, closest first, including `''` for the root. */
+export function ancestorKeys(key) {
+    const out = [];
+    let cur = key;
+    for (;;) {
+        const p = parentKey(cur);
+        if (p === null)
+            break;
+        out.push(p);
+        cur = p;
+        if (p === '')
+            break;
+    }
+    return out;
+}
+export function isDescendantKey(key, ancestor) {
+    if (ancestor === '')
+        return key !== '';
+    return key.startsWith(ancestor + '/');
+}
+export function hasWildcard(path) {
+    return path.includes('*');
+}
+/** Match a concrete key against a pattern key that may contain `*`. */
+export function matchKey(key, pattern, subtree = false) {
+    if (!pattern.includes('*')) {
+        return key === pattern || (subtree && isDescendantKey(key, pattern));
+    }
+    const p = pattern.split('/');
+    const k = key.split('/');
+    if (!subtree && p.length !== k.length)
+        return false;
+    if (subtree && k.length < p.length)
+        return false;
+    for (let i = 0; i < p.length; i++) {
+        if (p[i] === '*')
+            continue;
+        if (p[i] !== k[i])
+            return false;
+    }
+    return true;
+}

package/dist/util/stream.d.ts

@@ -0,0 +1,32 @@
+import type { Stream, StreamObserver, StreamSource } from '../types/stream.js';
+import type { ReactiveStore } from '../types/store.js';
+import type { BindingPath } from '../types/graph.js';
+/**
+ * The smallest useful stream, plus adapters.
+ *
+ * A LogViewer should not care whether its lines come from a child process, an
+ * async iterable or a store path - so everything is adapted to one shape here,
+ * and nowhere else has to know the difference.
+ */
+export declare function createStream<T>(start: (observer: StreamObserver<T>) => (() => void) | void): Stream<T>;
+export declare function fromAsyncIterable<T>(iterable: AsyncIterable<T>): Stream<T>;
+export declare function fromIterable<T>(iterable: Iterable<T>): Stream<T>;
+/** Emit the value at a store path each time it changes. */
+export declare function fromStorePath<T>(store: ReactiveStore, path: BindingPath): Stream<T>;
+/** Emit each item appended to a store collection, and nothing already there. */
+export declare function fromStoreCollection<T>(store: ReactiveStore, path: BindingPath): Stream<T>;
+/** A source that pushes from the outside. Adapters and tests use this. */
+export interface Subject<T> extends Stream<T> {
+    next(value: T): void;
+    error(err: unknown): void;
+    complete(): void;
+}
+export declare function createSubject<T>(): Subject<T>;
+export declare function toStream<T>(source: StreamSource<T>): Stream<T>;
+export declare function mapStream<T, U>(source: Stream<T>, fn: (value: T) => U): Stream<U>;
+export declare function filterStream<T>(source: Stream<T>, pred: (value: T) => boolean): Stream<T>;
+/** Split incoming chunks on newlines. What a log stream almost always wants. */
+export declare function lines(source: Stream<string>): Stream<string>;
+/** Emit at most one value per `ms`, keeping the latest. */
+export declare function throttleStream<T>(source: Stream<T>, ms: number): Stream<T>;
+//# sourceMappingURL=stream.d.ts.map

package/dist/util/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../src/util/stream.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC/E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD;;;;;;GAMG;AAEH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,KAAK,EAAE,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,GAC1D,MAAM,CAAC,CAAC,CAAC,CAgBX;AAED,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAgB1E;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAKhE;AAED,2DAA2D;AAC3D,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,WAAW,GAAG,MAAM,CAAC,CAAC,CAAC,CAKnF;AAED,gFAAgF;AAChF,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,WAAW,GAAG,MAAM,CAAC,CAAC,CAAC,CAWzF;AAED,0EAA0E;AAC1E,MAAM,WAAW,OAAO,CAAC,CAAC,CAAE,SAAQ,MAAM,CAAC,CAAC,CAAC;IAC3C,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IACrB,KAAK,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1B,QAAQ,IAAI,IAAI,CAAC;CAClB;AAED,wBAAgB,aAAa,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CA8B7C;AAMD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAO9D;AAID,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CASjF;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,MAAM,CAAC,CAAC,CAAC,CASzF;AAED,gFAAgF;AAChF,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAkB5D;AAED,2DAA2D;AAC3D,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAiC1E"}

package/dist/util/stream.js

@@ -0,0 +1,206 @@
+import { toDisposable } from './disposable.js';
+/**
+ * The smallest useful stream, plus adapters.
+ *
+ * A LogViewer should not care whether its lines come from a child process, an
+ * async iterable or a store path - so everything is adapted to one shape here,
+ * and nowhere else has to know the difference.
+ */
+export function createStream(start) {
+    return {
+        subscribe(observer) {
+            let closed = false;
+            const guard = {
+                next: (v) => { if (!closed)
+                    observer.next(v); },
+                error: (e) => { if (!closed)
+                    observer.error?.(e); },
+                complete: () => { if (!closed)
+                    observer.complete?.(); },
+            };
+            const stop = start(guard);
+            return toDisposable(() => {
+                closed = true;
+                stop?.();
+            });
+        },
+    };
+}
+export function fromAsyncIterable(iterable) {
+    return createStream((observer) => {
+        let cancelled = false;
+        void (async () => {
+            try {
+                for await (const value of iterable) {
+                    if (cancelled)
+                        return;
+                    observer.next(value);
+                }
+                observer.complete?.();
+            }
+            catch (err) {
+                if (!cancelled)
+                    observer.error?.(err);
+            }
+        })();
+        return () => { cancelled = true; };
+    });
+}
+export function fromIterable(iterable) {
+    return createStream((observer) => {
+        for (const value of iterable)
+            observer.next(value);
+        observer.complete?.();
+    });
+}
+/** Emit the value at a store path each time it changes. */
+export function fromStorePath(store, path) {
+    return createStream((observer) => {
+        const sub = store.subscribe(path, (value) => observer.next(value), { immediate: true });
+        return () => sub.dispose();
+    });
+}
+/** Emit each item appended to a store collection, and nothing already there. */
+export function fromStoreCollection(store, path) {
+    return createStream((observer) => {
+        let seen = (store.get(path) ?? []).length;
+        const sub = store.subscribe(path, (value) => {
+            const list = Array.isArray(value) ? value : [];
+            if (list.length < seen)
+                seen = 0;
+            for (let i = seen; i < list.length; i++)
+                observer.next(list[i]);
+            seen = list.length;
+        });
+        return () => sub.dispose();
+    });
+}
+export function createSubject() {
+    const observers = new Set();
+    let done = false;
+    return {
+        subscribe(observer) {
+            if (done) {
+                observer.complete?.();
+                return toDisposable(() => { });
+            }
+            observers.add(observer);
+            return toDisposable(() => observers.delete(observer));
+        },
+        next(value) {
+            if (done)
+                return;
+            for (const o of [...observers])
+                o.next(value);
+        },
+        error(err) {
+            if (done)
+                return;
+            done = true;
+            for (const o of [...observers])
+                o.error?.(err);
+            observers.clear();
+        },
+        complete() {
+            if (done)
+                return;
+            done = true;
+            for (const o of [...observers])
+                o.complete?.();
+            observers.clear();
+        },
+    };
+}
+function isStream(value) {
+    return typeof value === 'object' && value !== null && 'subscribe' in value;
+}
+export function toStream(source) {
+    if (typeof source === 'function')
+        return fromAsyncIterable(source());
+    if (isStream(source))
+        return source;
+    if (Symbol.asyncIterator in source) {
+        return fromAsyncIterable(source);
+    }
+    return fromIterable(source);
+}
+// ------------------------------------------------------------- operators
+export function mapStream(source, fn) {
+    return createStream((observer) => {
+        const sub = source.subscribe({
+            next: (v) => observer.next(fn(v)),
+            error: (e) => observer.error?.(e),
+            complete: () => observer.complete?.(),
+        });
+        return () => sub.dispose();
+    });
+}
+export function filterStream(source, pred) {
+    return createStream((observer) => {
+        const sub = source.subscribe({
+            next: (v) => { if (pred(v))
+                observer.next(v); },
+            error: (e) => observer.error?.(e),
+            complete: () => observer.complete?.(),
+        });
+        return () => sub.dispose();
+    });
+}
+/** Split incoming chunks on newlines. What a log stream almost always wants. */
+export function lines(source) {
+    return createStream((observer) => {
+        let carry = '';
+        const sub = source.subscribe({
+            next(chunk) {
+                carry += chunk;
+                const parts = carry.split('\n');
+                carry = parts.pop() ?? '';
+                for (const line of parts)
+                    observer.next(line);
+            },
+            error: (e) => observer.error?.(e),
+            complete() {
+                if (carry !== '')
+                    observer.next(carry);
+                observer.complete?.();
+            },
+        });
+        return () => sub.dispose();
+    });
+}
+/** Emit at most one value per `ms`, keeping the latest. */
+export function throttleStream(source, ms) {
+    return createStream((observer) => {
+        let pending;
+        let has = false;
+        let timer = null;
+        const sub = source.subscribe({
+            next(value) {
+                pending = value;
+                has = true;
+                if (timer)
+                    return;
+                timer = setInterval(() => {
+                    if (has) {
+                        observer.next(pending);
+                        has = false;
+                        return;
+                    }
+                    if (timer)
+                        clearInterval(timer);
+                    timer = null;
+                }, ms);
+                timer.unref?.();
+                observer.next(pending);
+                has = false;
+            },
+            error: (e) => observer.error?.(e),
+            complete: () => observer.complete?.(),
+        });
+        return () => {
+            if (timer)
+                clearInterval(timer);
+            sub.dispose();
+        };
+    });
+}