@qorejs/qore 0.7.2 → 0.9.0

package/dist/src/core/signal-nodes.d.ts

@@ -1,6 +1,7 @@
 import type { Cleanup, EffectCallback, EffectOptions, ObserverDependency, ReactiveObserver, SignalListener, SubscribeOptions } from './signal-types.js';
 export declare class SignalNode<T> implements ObserverDependency {
     value: T;
+    level: number;
     subscribers: Set<ReactiveObserver>;
     listeners: Set<SignalListener<T>>;
     constructor(initialValue: T);
@@ -13,6 +14,8 @@ export declare class SignalNode<T> implements ObserverDependency {
 }
 export declare class ComputedNode<T> implements ObserverDependency, ReactiveObserver {
     getter: () => T;
+    private owner;
+    level: number;
     subscribers: Set<ReactiveObserver>;
     listeners: Set<SignalListener<T>>;
     deps: Set<ObserverDependency>;
@@ -31,6 +34,8 @@ export declare class ComputedNode<T> implements ObserverDependency, ReactiveObse
 export declare class EffectNode implements ReactiveObserver {
     fn: EffectCallback;
     scheduler: EffectOptions['scheduler'];
+    private owner;
+    level: number;
     deps: Set<ObserverDependency>;
     active: boolean;
     scheduled: boolean;

package/dist/src/core/signal-nodes.js

@@ -1,8 +1,10 @@
-import { cleanupObserver, getActiveObserver, removePendingObserver, scheduleObserver, withActiveObserver } from './signal-context.js';
+import { batch, cleanupObserver, getActiveObserver, removePendingObserver, scheduleObserver, withActiveObserver } from './signal-context.js';
+import { createOwnedScope, disposeOwner, onCleanup, resetOwner, withOwner } from './owner.js';
 import { scheduleEffectRun } from './signal-scheduler.js';
 // A mutable signal node stores a value and fan-outs updates to listeners and observers.
 export class SignalNode {
     value;
+    level = 0;
     subscribers = new Set();
     listeners = new Set();
     constructor(initialValue) {
@@ -45,14 +47,18 @@ export class SignalNode {
         for (const listener of Array.from(this.listeners)) {
             listener(this.value);
         }
-        for (const observer of Array.from(this.subscribers)) {
-            scheduleObserver(observer);
-        }
+        batch(() => {
+            for (const observer of Array.from(this.subscribers)) {
+                scheduleObserver(observer);
+            }
+        });
     }
 }
 // A computed node re-runs its getter whenever one of its dependencies changes.
 export class ComputedNode {
     getter;
+    owner = createOwnedScope();
+    level = 1;
     subscribers = new Set();
     listeners = new Set();
     deps = new Set();
@@ -61,6 +67,7 @@ export class ComputedNode {
     value;
     constructor(getter) {
         this.getter = getter;
+        onCleanup(() => this.stop());
         this.recompute();
     }
     get() {
@@ -96,11 +103,16 @@ export class ComputedNode {
             return;
         }
         const previousValue = this.value;
+        resetOwner(this.owner);
         cleanupObserver(this);
-        withActiveObserver(this, () => {
+        withOwner(this.owner, () => withActiveObserver(this, () => {
             const nextValue = this.getter();
             const changed = !this.initialized || !Object.is(previousValue, nextValue);
+            const nextLevel = this.deps.size > 0
+                ? Math.max(...Array.from(this.deps, (dependency) => dependency.level)) + 1
+                : 1;
             this.value = nextValue;
+            this.level = nextLevel;
             this.initialized = true;
             if (!changed) {
                 return;
@@ -108,10 +120,12 @@ export class ComputedNode {
             for (const listener of Array.from(this.listeners)) {
                 listener(this.value);
             }
-            for (const observer of Array.from(this.subscribers)) {
-                scheduleObserver(observer);
-            }
-        });
+            batch(() => {
+                for (const observer of Array.from(this.subscribers)) {
+                    scheduleObserver(observer);
+                }
+            });
+        }));
     }
     stop() {
         if (!this.active) {
@@ -120,6 +134,7 @@ export class ComputedNode {
         this.active = false;
         cleanupObserver(this);
         removePendingObserver(this);
+        disposeOwner(this.owner);
         this.subscribers.clear();
         this.listeners.clear();
     }
@@ -128,6 +143,8 @@ export class ComputedNode {
 export class EffectNode {
     fn;
     scheduler;
+    owner = createOwnedScope();
+    level = 1;
     deps = new Set();
     active = true;
     scheduled = false;
@@ -137,6 +154,7 @@ export class EffectNode {
     constructor(fn, options = {}) {
         this.fn = fn;
         this.scheduler = options.scheduler ?? 'sync';
+        onCleanup(() => this.stop());
         this.run();
     }
     schedule() {
@@ -166,18 +184,29 @@ export class EffectNode {
         }
         this.running = true;
         this.needsRun = false;
-        cleanupObserver(this);
-        if (typeof this.cleanup === 'function') {
-            this.cleanup();
-            this.cleanup = null;
-        }
-        withActiveObserver(this, () => {
-            const maybeCleanup = this.fn();
-            this.cleanup = typeof maybeCleanup === 'function' ? maybeCleanup : null;
-        });
-        this.running = false;
-        if (this.needsRun && this.active) {
-            this.schedule();
+        const previousCleanup = this.cleanup;
+        this.cleanup = null;
+        try {
+            // Run the previous cleanup before dropping old dependencies so a thrown cleanup
+            // does not silently unsubscribe the effect from future source updates.
+            if (typeof previousCleanup === 'function') {
+                previousCleanup();
+            }
+            resetOwner(this.owner);
+            cleanupObserver(this);
+            withOwner(this.owner, () => withActiveObserver(this, () => {
+                const maybeCleanup = this.fn();
+                this.cleanup = typeof maybeCleanup === 'function' ? maybeCleanup : null;
+            }));
+            this.level = this.deps.size > 0
+                ? Math.max(...Array.from(this.deps, (dependency) => dependency.level)) + 1
+                : 1;
+        }
+        finally {
+            this.running = false;
+            if (this.needsRun && this.active) {
+                this.schedule();
+            }
         }
     }
     stop() {
@@ -189,6 +218,7 @@ export class EffectNode {
         this.needsRun = false;
         cleanupObserver(this);
         removePendingObserver(this);
+        disposeOwner(this.owner);
         if (typeof this.cleanup === 'function') {
             this.cleanup();
             this.cleanup = null;

package/dist/src/core/signal-types.d.ts

@@ -9,11 +9,13 @@ export interface EffectOptions {
     scheduler?: EffectScheduler;
 }
 export interface ObserverDependency {
+    level: number;
     subscribers: Set<ReactiveObserver>;
 }
 export interface ReactiveObserver {
     deps: Set<ObserverDependency>;
     active: boolean;
+    level: number;
     schedule(): void;
     notify(): void;
 }

package/dist/src/core/signal.d.ts

@@ -16,4 +16,5 @@ export declare function signal<T>(initialValue: T): Signal<T>;
 export declare function computed<T>(getter: () => T): ComputedSignal<T>;
 export declare function effect(fn: EffectCallback, options?: EffectOptions): Cleanup;
 export { batch, untrack } from './signal-context.js';
+export { createRoot, onCleanup } from './owner.js';
 export declare function isSignal<T = unknown>(value: unknown): value is ReadonlySignal<T>;

package/dist/src/core/signal.js

@@ -1,3 +1,4 @@
+import { createRoot, onCleanup } from './owner.js';
 import { batch, READ, untrack } from './signal-context.js';
 import { ComputedNode, EffectNode, SignalNode } from './signal-nodes.js';
 // Create a mutable signal function with helper methods attached to it.
@@ -35,6 +36,7 @@ export function effect(fn, options = {}) {
     return () => node.stop();
 }
 export { batch, untrack } from './signal-context.js';
+export { createRoot, onCleanup } from './owner.js';
 // Detect Qore signal-like values by their callable shape plus peek helper.
 export function isSignal(value) {
     return typeof value === 'function' && typeof value.peek === 'function';

package/dist/src/core/stream-types.d.ts

@@ -6,6 +6,7 @@ export interface BackpressureOptions {
     buffer?: number;
     overflow?: OverflowStrategy;
 }
+export type RetryBackoff = number | number[] | 'exponential' | ((retry: number, error: unknown) => MaybePromise<number>);
 export interface NormalizedBackpressure {
     interval: number;
     buffer: number;
@@ -21,6 +22,11 @@ export interface StreamOptions<TChunk = unknown, TValue = string> {
     reduce?: (currentValue: TValue, chunk: TChunk, index: number) => TValue;
     backpressure?: number | BackpressureOptions | null;
 }
+export interface RetryableStreamOptions<TChunk = unknown, TValue = string> extends StreamOptions<TChunk, TValue> {
+    maxRetries?: number;
+    backoff?: RetryBackoff;
+}
+export type StreamPipeStage<TChunk = unknown, TValue = string> = (value: TValue, index: number) => MaybePromise<StreamInput<TChunk, TValue>>;
 export interface StreamController<TChunk = unknown, TValue = string> {
     readonly signal: GlobalAbortSignal;
     push(chunk: TChunk): Promise<TValue>;
@@ -57,5 +63,11 @@ export interface StreamFactory {
     latest<TChunk>(sourceOrSetup: StreamInput<TChunk, TChunk | null>, options?: StreamOptions<TChunk, TChunk | null>): QoreStream<TChunk, TChunk | null>;
     withBackpressure<TChunk = unknown, TValue = string>(sourceOrSetup: StreamInput<TChunk, TValue>, backpressure: number | BackpressureOptions, options?: StreamOptions<TChunk, TValue>): QoreStream<TChunk, TValue>;
     paced<TChunk = unknown, TValue = string>(sourceOrSetup: StreamInput<TChunk, TValue>, interval: number, options?: StreamOptions<TChunk, TValue>): QoreStream<TChunk, TValue>;
+    merge<TChunk = unknown, TValue = string>(sources: Array<SourceLike<TChunk>>, options?: StreamOptions<TChunk, TValue>): QoreStream<TChunk, TValue>;
+    concat<TChunk = unknown, TValue = string>(sources: Array<SourceLike<TChunk>>, options?: StreamOptions<TChunk, TValue>): QoreStream<TChunk, TValue>;
+    pipe<TChunk = unknown, TValue = string>(sourceOrSetup: StreamInput<TChunk, TValue>, stages: Array<StreamPipeStage<TChunk, TValue>>, options?: StreamOptions<TChunk, TValue>): QoreStream<TChunk, TValue>;
+    race<TChunk = unknown, TValue = string>(sources: Array<SourceLike<TChunk>>, options?: StreamOptions<TChunk, TValue>): QoreStream<TChunk, TValue>;
+    retryable<TChunk = unknown, TValue = string>(sourceFactory: (attempt: number) => StreamInput<TChunk, TValue>, options?: RetryableStreamOptions<TChunk, TValue>): QoreStream<TChunk, TValue>;
+    switchMap<TInput, TChunk = unknown, TValue = string>(source: SourceLike<TInput>, mapper: (value: TInput, index: number) => MaybePromise<SourceLike<TChunk>>, options?: StreamOptions<TChunk, TValue>): QoreStream<TChunk, TValue>;
 }
 export type StreamResponseState<TChunk, TValue> = ResponseState<TChunk, TValue>;

package/dist/src/core/stream.d.ts

@@ -7,5 +7,5 @@ export declare function from<TChunk, TValue = string>(source: SourceLike<TChunk>
 export declare function mapStream<TInput, TOutput, TValue = string>(source: SourceLike<TInput>, mapper: (chunk: TInput, index: number) => MaybePromise<TOutput>, options?: StreamOptions<TOutput, TValue>): QoreStream<TOutput, TValue>;
 export declare function scanStream<TInput, TOutput>(source: SourceLike<TInput>, reducer: (currentValue: TOutput, chunk: TInput, index: number) => MaybePromise<TOutput>, seed: TOutput, options?: Omit<StreamOptions<TOutput, TOutput>, 'seed' | 'reduce'>): QoreStream<TOutput, TOutput>;
 export { createStream } from './stream-runtime.js';
-export type { BackpressureOptions, QoreStream, StreamController, StreamFactory, StreamInput, StreamOptions, StreamSetup } from './stream-types.js';
+export type { BackpressureOptions, QoreStream, RetryBackoff, RetryableStreamOptions, StreamController, StreamFactory, StreamInput, StreamOptions, StreamSetup } from './stream-types.js';
 export { toAsyncIterable } from './iterable.js';

package/dist/src/core/stream.js

@@ -1,5 +1,6 @@
 import { toAsyncIterable } from './iterable.js';
 import { createStream } from './stream-runtime.js';
+import { startSource } from './stream-source.js';
 import { reduceText } from './stream-state.js';
 import { sleep } from '../shared/utils.js';
 const streamFactory = ((sourceOrSetup, options = {}) => createStream(sourceOrSetup, {
@@ -36,8 +37,151 @@ streamFactory.withBackpressure = (sourceOrSetup, backpressure, options = {}) =>
 });
 // Shorthand for the first backpressure primitive: minimum interval between chunks.
 streamFactory.paced = (sourceOrSetup, interval, options = {}) => streamFactory.withBackpressure(sourceOrSetup, { interval }, options);
+streamFactory.merge = (sources, options = {}) => createStream(async (controller) => {
+    await Promise.all(sources.map(async (source) => {
+        await startSource(source, controller);
+    }));
+}, options);
+streamFactory.concat = (sources, options = {}) => createStream(async (controller) => {
+    for (const source of sources) {
+        if (controller.signal.aborted) {
+            break;
+        }
+        await startSource(source, controller);
+    }
+}, options);
+streamFactory.pipe = (sourceOrSetup, stages, options = {}) => createStream(async (controller) => {
+    const consumeSource = async (currentSource) => {
+        const currentStream = createStream(currentSource, options);
+        for await (const chunk of currentStream) {
+            if (controller.signal.aborted) {
+                break;
+            }
+            await controller.push(chunk);
+        }
+        return currentStream.ready;
+    };
+    let currentValue = await consumeSource(sourceOrSetup);
+    for (const [index, stage] of stages.entries()) {
+        if (controller.signal.aborted) {
+            break;
+        }
+        const nextSource = await stage(currentValue, index);
+        currentValue = await consumeSource(nextSource);
+    }
+}, options);
+streamFactory.race = (sources, options = {}) => createStream(async (controller) => {
+    const activeIterators = sources.map((source, index) => ({
+        index,
+        iterator: toAsyncIterable(source)[Symbol.asyncIterator]()
+    }));
+    let winner = null;
+    try {
+        while (!controller.signal.aborted && winner === null && activeIterators.length > 0) {
+            const nextResult = await Promise.race(activeIterators.map(async ({ index, iterator }) => ({
+                index,
+                result: await iterator.next()
+            })));
+            if (nextResult.result.done) {
+                const exhaustedIndex = activeIterators.findIndex(({ index }) => index === nextResult.index);
+                if (exhaustedIndex >= 0) {
+                    activeIterators.splice(exhaustedIndex, 1);
+                }
+                continue;
+            }
+            winner = activeIterators.find(({ index }) => index === nextResult.index)?.iterator ?? null;
+            await controller.push(nextResult.result.value);
+        }
+        if (!winner || controller.signal.aborted) {
+            return;
+        }
+        for (const candidate of activeIterators) {
+            if (candidate.iterator !== winner) {
+                await candidate.iterator.return?.();
+            }
+        }
+        while (!controller.signal.aborted) {
+            const nextChunk = await winner.next();
+            if (nextChunk.done) {
+                break;
+            }
+            await controller.push(nextChunk.value);
+        }
+    }
+    finally {
+        for (const { iterator } of activeIterators) {
+            if (iterator !== winner) {
+                await iterator.return?.();
+            }
+        }
+    }
+}, options);
+streamFactory.retryable = (sourceFactory, options = {}) => {
+    const { maxRetries = 0, backoff = 'exponential', ...streamOptions } = options;
+    return createStream(async (controller) => {
+        let retries = 0;
+        while (!controller.signal.aborted) {
+            try {
+                await startSource(sourceFactory(retries), controller);
+                return;
+            }
+            catch (error) {
+                if (retries >= maxRetries || controller.signal.aborted) {
+                    throw error;
+                }
+                retries += 1;
+                const delay = await resolveRetryDelay(backoff, retries, error);
+                if (delay > 0) {
+                    await sleep(delay, controller.signal);
+                }
+            }
+        }
+    }, streamOptions);
+};
+streamFactory.switchMap = (source, mapper, options = {}) => createStream(async (controller) => {
+    let index = 0;
+    let activeToken = 0;
+    let activeTask = null;
+    const startInner = (token, innerSource) => (async () => {
+        for await (const chunk of toAsyncIterable(innerSource)) {
+            if (controller.signal.aborted || token !== activeToken) {
+                break;
+            }
+            await controller.push(chunk);
+        }
+    })().catch((error) => {
+        if (token !== activeToken || controller.signal.aborted) {
+            return;
+        }
+        throw error;
+    });
+    for await (const value of toAsyncIterable(source)) {
+        if (controller.signal.aborted) {
+            break;
+        }
+        activeToken += 1;
+        const token = activeToken;
+        const innerSource = await mapper(value, index);
+        activeTask = startInner(token, innerSource);
+        index += 1;
+    }
+    await activeTask;
+}, options);
 // Create a text-accumulating stream by default.
 export const stream = streamFactory;
+async function resolveRetryDelay(backoff, retry, error) {
+    if (typeof backoff === 'function') {
+        return Math.max(0, await backoff(retry, error));
+    }
+    if (Array.isArray(backoff)) {
+        const nextDelay = backoff[Math.min(retry - 1, backoff.length - 1)] ?? 0;
+        return Math.max(0, nextDelay);
+    }
+    if (backoff === 'exponential') {
+        return 250 * 2 ** (retry - 1);
+    }
+    return Math.max(0, backoff);
+}
 // Turn any iterable or async iterable into a stream, optionally adding source delay.
 export function from(source, options = {}) {
     const { delay = 0, ...streamOptions } = options;

package/dist/src/dom/app.js

@@ -2,11 +2,10 @@ import { dynamic, fragment, h, list, mount, renderResponse, show, text } from '.
 import { batch, computed, effect, signal, untrack } from '../core/signal.js';
 import { response } from '../core/response.js';
 import { from, mapStream, scanStream, stream } from '../core/stream.js';
+import { assertDocument } from './scope.js';
 // Resolve a CSS selector or direct node into the root mount target.
 function resolveTarget(target) {
-    if (typeof document === 'undefined') {
-        throw new Error('Qore app mounting requires a browser-like environment');
-    }
+    assertDocument('createApp(...).mount(...)');
     if (typeof target === 'string') {
         const element = document.querySelector(target);
         if (!element) {

package/dist/src/dom/dom.d.ts

@@ -5,6 +5,7 @@ export declare function dynamic<T>(source: ReactiveValue<T>, render?: (value: T)
 export declare function show<T>(source: ReactiveValue<T>, render?: (value: T) => QoreChild, fallback?: QoreChild | ((value: T) => QoreChild)): QoreDocumentFragment;
 export declare function list<T>(source: ReactiveValue<Iterable<T> | ArrayLike<T> | null | undefined>, render: (item: T, index: number) => QoreChild, options?: {
     fallback?: QoreChild | ((items: T[]) => QoreChild);
+    key?: (item: T, index: number) => unknown;
 }): QoreDocumentFragment;
 export declare function renderResponse<TChunk, TValue>(responseState: ResponseState<TChunk, TValue>, views?: ResponseViews<TChunk, TValue>): QoreDocumentFragment;
 export declare function h(tag: string, props?: Record<string, unknown> | null, ...children: QoreChild[]): QoreElement;

package/dist/src/dom/dom.js

@@ -63,6 +63,27 @@ function replaceRange(start, end, nextValue) {
         parent.insertBefore(node, end);
     }
 }
+function insertBefore(parent, reference, value) {
+    for (const node of materialize(value)) {
+        parent.insertBefore(node, reference);
+    }
+}
+function destroyKeyedEntry(entry) {
+    disposeScope(entry.scope);
+    clearRange(entry.start, entry.end);
+    entry.start.remove();
+    entry.end.remove();
+}
+function renderKeyedEntry(parent, reference, item, index, render) {
+    const start = document.createComment('qore-list-item-start');
+    const end = document.createComment('qore-list-item-end');
+    const scope = createScope();
+    parent.insertBefore(start, reference);
+    const content = withScope(scope, () => render(item, index));
+    insertBefore(parent, reference, content);
+    parent.insertBefore(end, reference);
+    return { key: null, value: item, index, start, end, scope };
+}
 // Allow mount targets to be passed as selectors or direct nodes.
 function resolveRoot(root) {
     if (typeof root === 'string') {
@@ -76,7 +97,7 @@ function resolveRoot(root) {
 }
 // Build a fragment from a variadic list of children.
 export function fragment(...children) {
-    assertDocument();
+    assertDocument('fragment()');
     const node = document.createDocumentFragment();
     for (const child of children) {
         appendChild(node, child);
@@ -85,7 +106,7 @@ export function fragment(...children) {
 }
 // Render a live region between comment markers and refresh it when the source changes.
 export function dynamic(source, render = (value) => value) {
-    assertDocument();
+    assertDocument('dynamic()');
     const start = document.createComment('qore-dynamic-start');
     const end = document.createComment('qore-dynamic-end');
     const node = document.createDocumentFragment();
@@ -115,18 +136,84 @@ export function show(source, render, fallback = null) {
 }
 // Render a list reactively, or a fallback when the collection is empty.
 export function list(source, render, options = {}) {
-    const { fallback = null } = options;
-    return dynamic(source, (value) => {
+    const { fallback = null, key } = options;
+    if (!key) {
+        return dynamic(source, (value) => {
+            const items = value == null
+                ? []
+                : Array.isArray(value)
+                    ? value
+                    : Array.from(value);
+            if (items.length === 0) {
+                return resolveTemplate(fallback, items);
+            }
+            return items.map((item, index) => render(item, index));
+        });
+    }
+    assertDocument('list()');
+    const start = document.createComment('qore-list-start');
+    const end = document.createComment('qore-list-end');
+    const node = document.createDocumentFragment();
+    node.append(start, end);
+    let entries = [];
+    let fallbackScope = null;
+    const stop = effect(() => {
+        const value = resolveAccessor(source);
         const items = value == null
             ? []
             : Array.isArray(value)
                 ? value
                 : Array.from(value);
+        const parent = end.parentNode;
+        if (!parent) {
+            return;
+        }
         if (items.length === 0) {
-            return resolveTemplate(fallback, items);
+            for (const entry of entries) {
+                destroyKeyedEntry(entry);
+            }
+            entries = [];
+            disposeScope(fallbackScope);
+            fallbackScope = createScope();
+            const renderedFallback = withScope(fallbackScope, () => resolveTemplate(fallback, items));
+            replaceRange(start, end, renderedFallback);
+            return;
+        }
+        disposeScope(fallbackScope);
+        fallbackScope = null;
+        const nextKeys = items.map((item, index) => key(item, index));
+        const canAppend = entries.length <= items.length
+            && entries.every((entry, index) => Object.is(entry.key, nextKeys[index]));
+        if (!canAppend) {
+            for (const entry of entries) {
+                destroyKeyedEntry(entry);
+            }
+            clearRange(start, end);
+            entries = [];
+        }
+        if (!canAppend) {
+            for (let index = 0; index < items.length; index += 1) {
+                const entry = renderKeyedEntry(parent, end, items[index], index, render);
+                entry.key = nextKeys[index];
+                entries.push(entry);
+            }
+            return;
+        }
+        for (let index = entries.length; index < items.length; index += 1) {
+            const entry = renderKeyedEntry(parent, end, items[index], index, render);
+            entry.key = nextKeys[index];
+            entries.push(entry);
         }
-        return items.map((item, index) => render(item, index));
     });
+    registerCleanup(() => {
+        stop();
+        disposeScope(fallbackScope);
+        for (const entry of entries) {
+            destroyKeyedEntry(entry);
+        }
+        entries = [];
+    });
+    return node;
 }
 // Render response state through status-aware template overrides.
 export function renderResponse(responseState, views = {}) {
@@ -142,7 +229,7 @@ export function renderResponse(responseState, views = {}) {
     });
 }
 export function h(tag, props = null, ...children) {
-    assertDocument();
+    assertDocument('h()');
     if (typeof tag === 'function') {
         return tag({
             ...(props ?? {}),
@@ -162,7 +249,7 @@ export function h(tag, props = null, ...children) {
 }
 // Create a text node and keep it in sync with a reactive getter when necessary.
 export function text(valueOrGetter) {
-    assertDocument();
+    assertDocument('text()');
     const node = document.createTextNode('');
     if (isReactiveValue(valueOrGetter)) {
         const stop = effect(() => {
@@ -177,7 +264,7 @@ export function text(valueOrGetter) {
 }
 // Mount a view into a root element and return a disposer for its reactive scope.
 export function mount(root, view) {
-    assertDocument();
+    assertDocument('mount()');
     const target = resolveRoot(root);
     target[ROOT_CLEANUP]?.();
     const scope = createScope();

package/dist/src/dom/scope.d.ts

@@ -3,7 +3,9 @@ export declare const ROOT_CLEANUP: unique symbol;
 export interface Scope {
     cleanups: Cleanup[];
 }
-export declare function assertDocument(): void;
+export declare function canUseDOM(): boolean;
+export declare function assertCanUseDOM(apiName?: string): void;
+export declare function assertDocument(apiName?: string): void;
 export declare function createScope(): Scope;
 export declare function withScope<T>(scope: Scope, fn: () => T): T;
 export declare function registerCleanup<T extends Cleanup | null | undefined>(cleanup: T): T;

package/dist/src/dom/scope.js

@@ -1,12 +1,19 @@
 // Store mount cleanup directly on the root node so remounts can tear down old scopes.
 export const ROOT_CLEANUP = Symbol('qore.dom.cleanup');
 let activeScope = null;
+// Detect whether the current runtime can create and mutate real DOM nodes.
+export function canUseDOM() {
+    return typeof document !== 'undefined';
+}
 // Guard DOM helpers so they only run in browser-like environments.
-export function assertDocument() {
-    if (typeof document === 'undefined') {
-        throw new Error('Qore DOM APIs require a browser-like environment');
+export function assertCanUseDOM(apiName = 'Qore DOM APIs') {
+    if (!canUseDOM()) {
+        throw new Error(`${apiName} requires a browser-like environment`);
     }
 }
+export function assertDocument(apiName = 'Qore DOM APIs') {
+    assertCanUseDOM(apiName);
+}
 // A scope collects effect disposers created while rendering a subtree.
 export function createScope() {
     return { cleanups: [] };

package/dist/src/index.d.ts

@@ -1,16 +1,22 @@
-export { signal, computed, effect, batch, untrack, isSignal } from './core/signal.js';
+export { signal, computed, createRoot, effect, onCleanup, batch, untrack, isSignal } from './core/signal.js';
 export type { ComputedSignal, ReadonlySignal, Signal } from './core/signal.js';
 export type { EffectOptions, EffectScheduler, SubscribeOptions } from './core/signal-types.js';
 export { stream, createStream, from, mapStream, scanStream, toAsyncIterable } from './core/stream.js';
-export type { BackpressureOptions, QoreStream, StreamController, StreamFactory, StreamInput, StreamOptions, StreamSetup } from './core/stream.js';
+export type { BackpressureOptions, QoreStream, RetryBackoff, RetryableStreamOptions, StreamController, StreamFactory, StreamInput, StreamOptions, StreamSetup } from './core/stream.js';
 export { createResponse, response } from './core/response.js';
 export type { CreateResponseOptions, GlobalAbortSignal, MaybePromise, ResponseConsumeContext, ResponseExecutorContext, ResponseFactory, ResponseReactiveState, ResponseRunOptions, ResponseSnapshot, ResponseSource, ResponseSourceFactory, ResponseState, ResponseStatus, SourceLike } from './core/response.js';
 export { createApp } from './dom/app.js';
 export type { AppContext, AppSetupResult, QoreApp } from './dom/app.js';
 export { dynamic, fragment, h, list, mount, renderResponse, show, text } from './dom/dom.js';
+export { assertCanUseDOM, canUseDOM } from './dom/scope.js';
+export { createSSEResponse } from './server/sse-response.js';
+export type { CreateSSEResponseOptions, SSEFrame } from './server/sse-response.js';
 export type { GlobalDocumentFragment, GlobalElement, GlobalNode, GlobalText, MountTarget, MountView, QoreChild, QoreComponent, QoreDocumentFragment, QoreElement, QoreNode, QoreTemplate, QoreText, ReactiveValue, ResponseRenderState, ResponseViews } from './dom/types.js';
 export { createAnthropic } from './providers/anthropic.js';
+export { createDeepSeek } from './providers/deepseek.js';
+export { createOllama } from './providers/ollama.js';
 export { createOpenAI } from './providers/openai.js';
-export { createSSEAdapter } from './providers/sse.js';
-export type { AnthropicAdapter, AnthropicChatInput, AnthropicEvent, AnthropicMessage, AnthropicOptions, AnthropicRequest, FetchLike, OpenAIAdapter, OpenAIChatInput, OpenAIEvent, OpenAIMessage, OpenAIOptions, OpenAIRequest, ProviderHeaders, ProviderRequestOptions, SSEAdapter, SSEAdapterOptions, SSEEvent, SSERequestConfig } from './providers/sse.js';
+export { createOpenRouter } from './providers/openrouter.js';
+export { collectProviderMetadata, createLineAdapter, createSSEAdapter, extractAnthropicMetadata, extractDeepSeekMetadata, extractOllamaMetadata, extractOpenAIMetadata, extractOpenRouterMetadata, mergeProviderMetadata } from './providers/sse.js';
+export type { AnthropicAdapter, AnthropicChatInput, AnthropicEvent, AnthropicMessage, AnthropicOptions, AnthropicRequest, DeepSeekAdapter, DeepSeekChatInput, DeepSeekEvent, DeepSeekMessage, DeepSeekOptions, DeepSeekRequest, FetchLike, LineAdapter, LineAdapterOptions, LineEvent, LineRequestConfig, OpenAIAdapter, OpenAIChatInput, OpenAIEvent, OpenAIMessage, OpenAIOptions, OpenAIRequest, OllamaAdapter, OllamaChatInput, OllamaEvent, OllamaMessage, OllamaOptions, OllamaRequest, OpenRouterAdapter, OpenRouterChatInput, OpenRouterEvent, OpenRouterMessage, OpenRouterOptions, OpenRouterRequest, ProviderHeaders, ProviderMetadataUpdate, ProviderRetryBackoff, ProviderRetryOptions, ProviderRequestOptions, ProviderStreamMetadata, ProviderUsage, SSEAdapter, SSEAdapterOptions, SSEEvent, SSERequestConfig } from './providers/sse.js';
 export { normalizeError, sleep } from './shared/utils.js';