@qorejs/qore 0.7.1 → 0.7.2

package/README.md

@@ -1,18 +1,55 @@
 # Qore
 
+[![npm version](https://img.shields.io/npm/v/%40qorejs%2Fqore?color=0f766e&label=npm)](https://www.npmjs.com/package/@qorejs/qore)
+[![ci](https://github.com/qorejs/qore/actions/workflows/ci.yml/badge.svg)](https://github.com/qorejs/qore/actions/workflows/ci.yml)
+[![browser smoke](https://img.shields.io/badge/browser-smoke-playwright-45ba63)](#browser-regression)
+[![release checks](https://github.com/qorejs/qore/actions/workflows/release-check.yml/badge.svg)](https://github.com/qorejs/qore/actions/workflows/release-check.yml)
+[![publish github packages](https://github.com/qorejs/qore/actions/workflows/publish-github-packages.yml/badge.svg)](https://github.com/qorejs/qore/actions/workflows/publish-github-packages.yml)
+[![GitHub Packages](https://img.shields.io/badge/GitHub-Packages-181717?logo=github)](https://github.com/qorejs/qore/packages)
+[![node >= 18](https://img.shields.io/badge/node-%3E%3D18-1f6feb)](https://nodejs.org/)
+[![license: MIT](https://img.shields.io/badge/license-MIT-0f766e)](https://github.com/qorejs/qore/blob/main/LICENSE)
+
 Qore is a streaming-response framework where `stream = signal`.
 
 Instead of treating data as a snapshot, Qore treats it like a river. Tokens arrive piece by piece, and the UI should respond piece by piece too. No manual string accumulation. No scattered loading state. No partial rendering workaround layered on top of a snapshot-first mental model.
 
+Quick links:
+
+- [npm package](https://www.npmjs.com/package/@qorejs/qore)
+- [GitHub Packages](https://github.com/qorejs/qore/packages)
+- [landing page source](https://github.com/qorejs/qore/blob/main/index.html)
+- [streaming demo source](https://github.com/qorejs/qore/blob/main/examples/streaming-response.html)
+- [benchmark page](https://github.com/qorejs/qore/blob/main/examples/benchmark.html)
+- [continuous integration](https://github.com/qorejs/qore/actions/workflows/ci.yml)
+- [release workflow](https://github.com/qorejs/qore/actions/workflows/release-check.yml)
+- [contributing guide](https://github.com/qorejs/qore/blob/main/CONTRIBUTING.md)
+- [security policy](https://github.com/qorejs/qore/blob/main/SECURITY.md)
+
 ## Installation
 
+From npm:
+
+```bash
+npm i @qorejs/qore
+```
+
+From GitHub Packages:
+
 ```bash
+echo "@qorejs:registry=https://npm.pkg.github.com" >> .npmrc
 npm i @qorejs/qore
 ```
 
+GitHub Packages installs require an authenticated session against `https://npm.pkg.github.com`.
+
 - Package name: `@qorejs/qore`
 - Module format: `ESM`
 - Supported runtime: `Node >= 18`
+- CI coverage: `Node 18`, `20`, and `22`
+- Browser regression: Playwright desktop + mobile smoke coverage for the homepage, focused demo, and benchmark page
+- Registries:
+  - npm: [npmjs.com/package/@qorejs/qore](https://www.npmjs.com/package/@qorejs/qore)
+  - GitHub Packages: [github.com/qorejs/qore/packages](https://github.com/qorejs/qore/packages)
 
 ## Core Idea
 
@@ -182,22 +219,102 @@ If your goal is to pipe a stream directly into the UI, prefer `stream(...)`.
 The repository includes a landing page and a focused streaming demo:
 
 - [Landing Page Source](https://github.com/qorejs/qore/blob/main/index.html)
-- [Homepage Logic](https://github.com/qorejs/qore/blob/main/examples/showcase.js)
+- [Homepage Logic](https://github.com/qorejs/qore/blob/main/examples/showcase.ts)
 - [Homepage Styles](https://github.com/qorejs/qore/blob/main/examples/showcase.css)
+- [Benchmark Page](https://github.com/qorejs/qore/blob/main/examples/benchmark.html)
+- [Benchmark Logic](https://github.com/qorejs/qore/blob/main/examples/benchmark-page.ts)
+- [Benchmark Core](https://github.com/qorejs/qore/blob/main/examples/benchmark-core.ts)
 - [Focused Demo](https://github.com/qorejs/qore/blob/main/examples/streaming-response.html)
-- [Focused Chat Logic](https://github.com/qorejs/qore/blob/main/examples/qore-chat.js)
-- [React Compare](https://github.com/qorejs/qore/blob/main/examples/react-chat.jsx)
+- [Focused Chat Logic](https://github.com/qorejs/qore/blob/main/examples/qore-chat.ts)
+- [React Compare](https://github.com/qorejs/qore/blob/main/examples/react-chat.ts)
+
+## Project Layout
+
+```text
+src/
+  core/       stream, signal, response, iterable
+  dom/        app mounting and DOM bindings
+  providers/  OpenAI, Anthropic, generic SSE adapters
+  shared/     runtime utilities
+  index.ts    public entrypoint
+
+dist/
+  src/        compiled package output
+  examples/   built showcase scripts for local preview
+  test/       compiled test output
+```
 
 For a local preview:
 
 ```bash
 git clone git@github.com:qorejs/qore.git
 cd qore
+npm install
+npm run build
 python3 -m http.server 4173
 ```
 
 Then open [http://127.0.0.1:4173/](http://127.0.0.1:4173/).
 
+## Browser Regression
+
+Install the browser binary once:
+
+```bash
+npm run browsers:install
+```
+
+Then run the browser smoke suite:
+
+```bash
+npm run test:browser
+```
+
+It validates:
+
+- the homepage stream demo
+- the focused streaming chat demo
+- the dedicated benchmark page
+
+The suite checks desktop and mobile layouts, watches for runtime console errors, exercises the primary interactions, and runs inside `release:check`.
+
+CI also uploads the browser regression evidence as workflow artifacts. The bundle includes viewport screenshots, focused page-surface screenshots, the Playwright HTML report, and a `benchmark-suite.json` attachment from the dedicated benchmark page.
+
+If a locked-down local shell cannot launch a supported headless browser, the script will defer to CI unless you force a hard local failure with `QORE_BROWSER_SMOKE_REQUIRED=1`.
+
+## Benchmark Methodology
+
+Qore now includes a reproducible browser benchmark that compares two rendering paths against the same workload:
+
+- `Qore stream = signal`: mount the transcript shell once and advance the same live text node as chunks arrive
+- `Snapshot rerender baseline`: rebuild the transcript shell from a snapshot string on every chunk
+
+Both paths use the same transcript history, the same chunk list, and the same final answer text. The benchmark reports first paint time, mutation records, node churn, and regenerated markup so the difference is visible instead of rhetorical.
+
+## GitHub Packages
+
+The repository includes GitHub Actions workflows for both release validation and GitHub Packages publishing.
+
+- Release validation: `.github/workflows/release-check.yml`
+- GitHub Packages publish: `.github/workflows/publish-github-packages.yml`
+- Both workflows can be triggered manually from the Actions tab
+- Publishing a GitHub Release triggers both the release check and the GitHub Packages publish flow
+- The publish workflow validates the release tag, changelog, test suite, and tarball before it pushes the package
+- The publish workflow uses the repository `GITHUB_TOKEN`, which GitHub documents as the recommended way to publish packages from the workflow repository
+- GitHub Packages starts new packages as private by default, so you may want to switch the package visibility to public after the first publish
+
+Because the package already includes the correct `repository` field in `package.json`, GitHub Packages can link the package back to `qorejs/qore` when the workflow publishes it.
+
+## Project Hygiene
+
+The repository also includes:
+
+- `CONTRIBUTING.md` for contributor expectations and release flow
+- `SECURITY.md` for responsible disclosure
+- issue templates for bugs and feature requests
+- a pull request template
+- `.github/release.yml` to keep GitHub release notes structured
+
 ## Package Boundary
 
 Qore does not ship a built-in catalog of buttons, dialogs, tabs, or other UI primitives.

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

@@ -0,0 +1 @@
+export declare function toAsyncIterable<T>(source: T | Iterable<T> | AsyncIterable<T> | null | undefined): AsyncIterable<T>;

package/dist/src/core/iterable.js

@@ -0,0 +1,17 @@
+// Normalize values, iterables, and async iterables into one async iterable shape.
+export function toAsyncIterable(source) {
+    if (source == null) {
+        return (async function* empty() { })();
+    }
+    if (typeof source[Symbol.asyncIterator] === 'function') {
+        return source;
+    }
+    if (typeof source[Symbol.iterator] === 'function') {
+        return (async function* fromIterable() {
+            yield* source;
+        })();
+    }
+    return (async function* fromValue() {
+        yield source;
+    })();
+}

package/dist/src/core/response-runtime.d.ts

@@ -0,0 +1,2 @@
+import type { CreateResponseOptions, ResponseState } from './response-types.js';
+export declare function createResponse<TChunk, TValue>(options: CreateResponseOptions<TChunk, TValue>): ResponseState<TChunk, TValue>;

package/dist/src/core/response-runtime.js

@@ -0,0 +1,233 @@
+import { batch } from './signal.js';
+import { toAsyncIterable } from './iterable.js';
+import { createResponseState, isTerminalStatus } from './response-state.js';
+import { normalizeError } from '../shared/utils.js';
+function isResponseSourceFactory(source) {
+    const callableSource = source;
+    return typeof source === 'function'
+        && typeof callableSource[Symbol.asyncIterator] !== 'function'
+        && typeof callableSource.peek !== 'function';
+}
+// Build a response state machine that accumulates chunks into a reactive value.
+export function createResponse(options) {
+    const { seed, reduce } = options;
+    const state = createResponseState(seed);
+    const { status, value, error, chunks, startedAt, finishedAt, pending, streaming, completed, failed, aborted, chunkCount } = state;
+    let activeController = null;
+    let runId = 0;
+    let api;
+    // Abort the active executor when a new run supersedes it.
+    function supersedeActiveRun(reason = 'Response superseded by a new run') {
+        if (!activeController) {
+            return;
+        }
+        activeController.abort(reason);
+        activeController = null;
+    }
+    // Reset the response to its initial seed and clear all lifecycle markers.
+    function reset(nextSeed = seed) {
+        supersedeActiveRun('Response reset');
+        batch(() => {
+            status('idle');
+            value(nextSeed);
+            error(null);
+            chunks([]);
+            startedAt(null);
+            finishedAt(null);
+        });
+        return nextSeed;
+    }
+    // Push a chunk through the reducer and advance the response into streaming state.
+    function push(chunk) {
+        const currentStatus = status.peek();
+        if (isTerminalStatus(currentStatus)) {
+            return value.peek();
+        }
+        const index = chunks.peek().length;
+        const nextValue = reduce(value.peek(), chunk, index);
+        batch(() => {
+            if (status.peek() === 'idle' || status.peek() === 'pending') {
+                status('streaming');
+            }
+            chunks([...chunks.peek(), chunk]);
+            value(nextValue);
+        });
+        return nextValue;
+    }
+    // Mark the response as completed and freeze the current accumulated value.
+    function complete() {
+        const currentStatus = status.peek();
+        if (isTerminalStatus(currentStatus)) {
+            return value.peek();
+        }
+        activeController = null;
+        batch(() => {
+            status('completed');
+            finishedAt(Date.now());
+        });
+        return value.peek();
+    }
+    // Capture an error unless the response is already closed.
+    function fail(reason) {
+        const currentStatus = status.peek();
+        const normalizedError = normalizeError(reason);
+        if (isTerminalStatus(currentStatus)) {
+            return currentStatus === 'error'
+                ? error.peek() ?? normalizedError
+                : value.peek();
+        }
+        activeController = null;
+        batch(() => {
+            status('error');
+            error(normalizedError);
+            finishedAt(Date.now());
+        });
+        return normalizedError;
+    }
+    // Abort an in-flight response while keeping the value accumulated so far.
+    function abort(reason = 'Response aborted') {
+        const currentStatus = status.peek();
+        if (currentStatus !== 'pending' && currentStatus !== 'streaming') {
+            return value.peek();
+        }
+        activeController?.abort(reason);
+        activeController = null;
+        batch(() => {
+            status('aborted');
+            finishedAt(Date.now());
+        });
+        return value.peek();
+    }
+    // Run an async executor and guard every lifecycle method to the active run only.
+    async function run(executor, options = {}) {
+        const { resetValue = true, nextSeed = seed } = options;
+        supersedeActiveRun();
+        runId += 1;
+        const currentRunId = runId;
+        const controller = new AbortController();
+        activeController = controller;
+        // A response may outlive older executors, so every write must prove it still owns the run.
+        const isCurrentRun = () => (currentRunId === runId
+            && activeController === controller
+            && !controller.signal.aborted);
+        const settleExitedRun = () => {
+            if (currentRunId !== runId) {
+                return value.peek();
+            }
+            if (status.peek() === 'error') {
+                throw error.peek() ?? new Error('Response failed');
+            }
+            return value.peek();
+        };
+        batch(() => {
+            if (resetValue) {
+                value(nextSeed);
+                chunks([]);
+            }
+            error(null);
+            status('pending');
+            startedAt(Date.now());
+            finishedAt(null);
+        });
+        // Expose guarded lifecycle helpers so stale executors cannot leak writes into the latest run.
+        const context = {
+            get signal() {
+                return controller.signal;
+            },
+            response: api,
+            push(chunk) {
+                if (!isCurrentRun()) {
+                    return value.peek();
+                }
+                return push(chunk);
+            },
+            complete() {
+                if (!isCurrentRun()) {
+                    return value.peek();
+                }
+                return complete();
+            },
+            fail(reason) {
+                if (!isCurrentRun()) {
+                    return status.peek() === 'error'
+                        ? error.peek() ?? normalizeError(reason)
+                        : value.peek();
+                }
+                return fail(reason);
+            },
+            abort(reason) {
+                if (!isCurrentRun()) {
+                    return value.peek();
+                }
+                return abort(reason);
+            }
+        };
+        try {
+            await executor(context);
+            if (!isCurrentRun()) {
+                return settleExitedRun();
+            }
+            return complete();
+        }
+        catch (reason) {
+            if (!isCurrentRun()) {
+                return settleExitedRun();
+            }
+            throw fail(reason);
+        }
+        finally {
+            if (currentRunId === runId && activeController === controller) {
+                activeController = null;
+            }
+        }
+    }
+    // Consume any async iterable-like source and route each chunk through the guarded writer.
+    async function consume(source, options = {}) {
+        return run(async ({ signal: abortSignal, push: write }) => {
+            const resolvedSource = isResponseSourceFactory(source)
+                ? await source({ signal: abortSignal, response: api })
+                : await source;
+            for await (const chunk of toAsyncIterable(resolvedSource)) {
+                if (abortSignal.aborted) {
+                    break;
+                }
+                write(chunk);
+            }
+        }, options);
+    }
+    // Return a plain snapshot suitable for inspection without exposing mutable internals.
+    function snapshot() {
+        return {
+            status: status.peek(),
+            value: value.peek(),
+            error: error.peek(),
+            chunks: [...chunks.peek()],
+            startedAt: startedAt.peek(),
+            finishedAt: finishedAt.peek(),
+            chunkCount: chunks.peek().length
+        };
+    }
+    api = {
+        status,
+        value,
+        error,
+        chunks,
+        startedAt,
+        finishedAt,
+        pending,
+        streaming,
+        completed,
+        failed,
+        aborted,
+        chunkCount,
+        reset,
+        push,
+        complete,
+        fail,
+        abort,
+        run,
+        consume,
+        snapshot
+    };
+    return api;
+}

package/dist/src/core/response-state.d.ts

@@ -0,0 +1,3 @@
+import type { ResponseReactiveState, ResponseStatus } from './response-types.js';
+export declare function isTerminalStatus(currentStatus: ResponseStatus): boolean;
+export declare function createResponseState<TChunk, TValue>(seed: TValue): ResponseReactiveState<TChunk, TValue>;

package/dist/src/core/response-state.js

@@ -0,0 +1,37 @@
+import { computed, signal } from './signal.js';
+// Treat these states as closed so late writes cannot mutate a finished response.
+export function isTerminalStatus(currentStatus) {
+    return currentStatus === 'completed' || currentStatus === 'error' || currentStatus === 'aborted';
+}
+// Create the reactive state bundle that powers a response lifecycle.
+export function createResponseState(seed) {
+    const status = signal('idle');
+    const value = signal(seed);
+    const error = signal(null);
+    const chunks = signal([]);
+    const startedAt = signal(null);
+    const finishedAt = signal(null);
+    const pending = computed(() => {
+        const currentStatus = status();
+        return currentStatus === 'pending' || currentStatus === 'streaming';
+    });
+    const streaming = computed(() => status() === 'streaming');
+    const completed = computed(() => status() === 'completed');
+    const failed = computed(() => status() === 'error');
+    const aborted = computed(() => status() === 'aborted');
+    const chunkCount = computed(() => chunks().length);
+    return {
+        status,
+        value,
+        error,
+        chunks,
+        startedAt,
+        finishedAt,
+        pending,
+        streaming,
+        completed,
+        failed,
+        aborted,
+        chunkCount
+    };
+}

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

@@ -0,0 +1,73 @@
+import type { ComputedSignal, Signal } from './signal.js';
+export type MaybePromise<T> = T | Promise<T>;
+export type ResponseStatus = 'idle' | 'pending' | 'streaming' | 'completed' | 'error' | 'aborted';
+export type GlobalAbortSignal = typeof globalThis extends {
+    AbortSignal: infer T;
+} ? T extends {
+    prototype: infer P;
+} ? P : unknown : {
+    aborted: boolean;
+    reason?: unknown;
+};
+export interface ResponseSnapshot<TChunk = unknown, TValue = unknown> {
+    status: ResponseStatus;
+    value: TValue;
+    error: Error | null;
+    chunks: TChunk[];
+    startedAt: number | null;
+    finishedAt: number | null;
+    chunkCount: number;
+}
+export interface ResponseRunOptions<TValue> {
+    resetValue?: boolean;
+    nextSeed?: TValue;
+}
+export type SourceLike<T> = T | Iterable<T> | AsyncIterable<T> | null | undefined;
+export interface ResponseReactiveState<TChunk, TValue> {
+    status: Signal<ResponseStatus>;
+    value: Signal<TValue>;
+    error: Signal<Error | null>;
+    chunks: Signal<TChunk[]>;
+    startedAt: Signal<number | null>;
+    finishedAt: Signal<number | null>;
+    pending: ComputedSignal<boolean>;
+    streaming: ComputedSignal<boolean>;
+    completed: ComputedSignal<boolean>;
+    failed: ComputedSignal<boolean>;
+    aborted: ComputedSignal<boolean>;
+    chunkCount: ComputedSignal<number>;
+}
+export interface ResponseConsumeContext<TChunk, TValue> {
+    signal: GlobalAbortSignal;
+    response: ResponseState<TChunk, TValue>;
+}
+export interface ResponseExecutorContext<TChunk, TValue> {
+    readonly signal: GlobalAbortSignal;
+    response: ResponseState<TChunk, TValue>;
+    push(chunk: TChunk): TValue;
+    complete(): TValue;
+    fail(reason?: unknown): Error | TValue;
+    abort(reason?: unknown): TValue;
+}
+export type ResponseSourceFactory<TChunk, TValue> = (context: ResponseConsumeContext<TChunk, TValue>) => MaybePromise<SourceLike<TChunk>>;
+export type ResponseSource<TChunk, TValue> = SourceLike<TChunk> | ResponseSourceFactory<TChunk, TValue>;
+export interface CreateResponseOptions<TChunk, TValue> {
+    seed: TValue;
+    reduce: (currentValue: TValue, chunk: TChunk, index: number) => TValue;
+}
+export interface ResponseState<TChunk = unknown, TValue = unknown> extends ResponseReactiveState<TChunk, TValue> {
+    reset(nextSeed?: TValue): TValue;
+    push(chunk: TChunk): TValue;
+    complete(): TValue;
+    fail(reason?: unknown): Error | TValue;
+    abort(reason?: unknown): TValue;
+    run(executor: (context: ResponseExecutorContext<TChunk, TValue>) => MaybePromise<unknown>, options?: ResponseRunOptions<TValue>): Promise<TValue>;
+    consume(source: ResponseSource<TChunk, TValue>, options?: ResponseRunOptions<TValue>): Promise<TValue>;
+    snapshot(): ResponseSnapshot<TChunk, TValue>;
+}
+export interface ResponseFactory {
+    create<TChunk, TValue>(options: CreateResponseOptions<TChunk, TValue>): ResponseState<TChunk, TValue>;
+    text<TChunk = string>(seed?: string): ResponseState<TChunk, string>;
+    list<TChunk>(seed?: TChunk[]): ResponseState<TChunk, TChunk[]>;
+    latest<TChunk>(seed?: TChunk | null): ResponseState<TChunk, TChunk | null>;
+}

package/dist/src/core/response-types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,4 @@
+import type { ResponseFactory } from './response-types.js';
+export { createResponse } from './response-runtime.js';
+export type { CreateResponseOptions, GlobalAbortSignal, MaybePromise, ResponseConsumeContext, ResponseExecutorContext, ResponseFactory, ResponseReactiveState, ResponseRunOptions, ResponseSnapshot, ResponseSource, ResponseSourceFactory, ResponseState, ResponseStatus, SourceLike } from './response-types.js';
+export declare const response: ResponseFactory;

package/dist/src/core/response.js

@@ -0,0 +1,26 @@
+import { createResponse } from './response-runtime.js';
+// Ship a few common reducers as convenience constructors on top of createResponse.
+export { createResponse } from './response-runtime.js';
+export const response = {
+    create(options) {
+        return createResponse(options);
+    },
+    text(seed = '') {
+        return createResponse({
+            seed,
+            reduce: (currentValue, chunk) => currentValue + String(chunk)
+        });
+    },
+    list(seed = []) {
+        return createResponse({
+            seed,
+            reduce: (currentValue, chunk) => [...currentValue, chunk]
+        });
+    },
+    latest(seed = null) {
+        return createResponse({
+            seed,
+            reduce: (_, chunk) => chunk
+        });
+    }
+};

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

@@ -0,0 +1,10 @@
+import type { ReactiveObserver } from './signal-types.js';
+export declare const READ: unique symbol;
+export declare function getActiveObserver(): ReactiveObserver | null;
+export declare function setActiveObserver(observer: ReactiveObserver | null): void;
+export declare function withActiveObserver<T>(observer: ReactiveObserver | null, fn: () => T): T;
+export declare function cleanupObserver(observer: ReactiveObserver): void;
+export declare function scheduleObserver(observer: ReactiveObserver): void;
+export declare function removePendingObserver(observer: ReactiveObserver): void;
+export declare function batch<T>(fn: () => T): T;
+export declare function untrack<T>(fn: () => T): T;

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

@@ -0,0 +1,69 @@
+// Use a sentinel so signals can still store undefined as a real value.
+export const READ = Symbol('qore.signal.read');
+let activeObserver = null;
+let batchDepth = 0;
+const pendingObservers = new Set();
+export function getActiveObserver() {
+    return activeObserver;
+}
+export function setActiveObserver(observer) {
+    activeObserver = observer;
+}
+export function withActiveObserver(observer, fn) {
+    const previousObserver = activeObserver;
+    activeObserver = observer;
+    try {
+        return fn();
+    }
+    finally {
+        activeObserver = previousObserver;
+    }
+}
+// Remove this observer from every dependency it tracked during the last run.
+export function cleanupObserver(observer) {
+    for (const dep of observer.deps) {
+        dep.subscribers.delete(observer);
+    }
+    observer.deps.clear();
+}
+// Queue observer work during batching, otherwise notify immediately.
+export function scheduleObserver(observer) {
+    if (!observer.active) {
+        return;
+    }
+    if (batchDepth > 0) {
+        pendingObservers.add(observer);
+        return;
+    }
+    observer.schedule();
+}
+export function removePendingObserver(observer) {
+    pendingObservers.delete(observer);
+}
+// Flush batched observer work in FIFO-like waves until the queue is empty.
+function flushObservers() {
+    while (pendingObservers.size > 0) {
+        const queue = Array.from(pendingObservers);
+        pendingObservers.clear();
+        for (const observer of queue) {
+            observer.schedule();
+        }
+    }
+}
+// Batch synchronous updates so dependent observers only re-run once afterward.
+export function batch(fn) {
+    batchDepth += 1;
+    try {
+        return fn();
+    }
+    finally {
+        batchDepth -= 1;
+        if (batchDepth === 0) {
+            flushObservers();
+        }
+    }
+}
+// Read signals without subscribing the current observer to them.
+export function untrack(fn) {
+    return withActiveObserver(null, fn);
+}