@qorejs/qore 0.7.2 → 0.7.3

package/README.md

@@ -1,6 +1,7 @@
 # Qore
 
 [![npm version](https://img.shields.io/npm/v/%40qorejs%2Fqore?color=0f766e&label=npm)](https://www.npmjs.com/package/@qorejs/qore)
+[![latest release](https://img.shields.io/github/v/release/qorejs/qore?color=0f766e&label=release)](https://github.com/qorejs/qore/releases/latest)
 [![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)
@@ -16,6 +17,7 @@ Instead of treating data as a snapshot, Qore treats it like a river. Tokens arri
 Quick links:
 
 - [npm package](https://www.npmjs.com/package/@qorejs/qore)
+- [latest release](https://github.com/qorejs/qore/releases/latest)
 - [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)
@@ -73,6 +75,17 @@ Here, `answer` is all of the following at once:
 - An `AsyncIterable`, so you can still use `for await...of`
 - A lifecycle-aware streaming state, with `status()`, `streaming()`, `error()`, and `chunks()`
 
+## Performance Model
+
+Qore keeps the streaming hot path narrow:
+
+- chunk commits append into an internal log instead of cloning the full history on every token
+- public `chunks()` reads still return defensive copies, so consumers cannot corrupt runtime state
+- `chunkCount()` tracks the internal log version directly, so status UIs can stay cheap during long generations
+- DOM bindings update only the nodes that read the stream signal
+
+That means a long AI answer can keep flowing through one signal and one text node without turning every token into a full transcript rewrite.
+
 ## Why Qore
 
 - React treats streaming as a special case that needs extra machinery
@@ -282,6 +295,12 @@ CI also uploads the browser regression evidence as workflow artifacts. The bundl
 
 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`.
 
+Local preview ports can also be pinned when another process is already using the default range:
+
+```bash
+QORE_STATIC_PORT=4300 QORE_STATIC_PORT_END=4400 npm run test:browser
+```
+
 ## Benchmark Methodology
 
 Qore now includes a reproducible browser benchmark that compares two rendering paths against the same workload:

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

@@ -1,6 +1,6 @@
 import { batch } from './signal.js';
 import { toAsyncIterable } from './iterable.js';
-import { createResponseState, isTerminalStatus } from './response-state.js';
+import { appendResponseChunk, createResponseState, getResponseChunkCount, isTerminalStatus, snapshotResponseChunks } from './response-state.js';
 import { normalizeError } from '../shared/utils.js';
 function isResponseSourceFactory(source) {
     const callableSource = source;
@@ -43,13 +43,13 @@ export function createResponse(options) {
         if (isTerminalStatus(currentStatus)) {
             return value.peek();
         }
-        const index = chunks.peek().length;
+        const index = getResponseChunkCount(chunks);
         const nextValue = reduce(value.peek(), chunk, index);
         batch(() => {
             if (status.peek() === 'idle' || status.peek() === 'pending') {
                 status('streaming');
             }
-            chunks([...chunks.peek(), chunk]);
+            appendResponseChunk(chunks, chunk);
             value(nextValue);
         });
         return nextValue;
@@ -201,10 +201,10 @@ export function createResponse(options) {
             status: status.peek(),
             value: value.peek(),
             error: error.peek(),
-            chunks: [...chunks.peek()],
+            chunks: snapshotResponseChunks(chunks),
             startedAt: startedAt.peek(),
             finishedAt: finishedAt.peek(),
-            chunkCount: chunks.peek().length
+            chunkCount: getResponseChunkCount(chunks)
         };
     }
     api = {

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

@@ -1,3 +1,7 @@
+import { type Signal } from './signal.js';
 import type { ResponseReactiveState, ResponseStatus } from './response-types.js';
 export declare function isTerminalStatus(currentStatus: ResponseStatus): boolean;
+export declare function appendResponseChunk<T>(chunks: Signal<T[]>, chunk: T): number;
+export declare function getResponseChunkCount<T>(chunks: Signal<T[]>): number;
+export declare function snapshotResponseChunks<T>(chunks: Signal<T[]>): T[];
 export declare function createResponseState<TChunk, TValue>(seed: TValue): ResponseReactiveState<TChunk, TValue>;

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

@@ -1,14 +1,79 @@
+import { READ } from './signal-context.js';
 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';
 }
+function isChunkSignal(value) {
+    return typeof value.append === 'function'
+        && typeof value.count === 'function'
+        && typeof value.peekCount === 'function'
+        && typeof value.snapshot === 'function';
+}
+// Store the live chunk log behind a version signal so token commits do not copy
+// the full history on every push. Public reads still receive defensive copies.
+function createChunkSignal() {
+    let items = [];
+    const version = signal(0);
+    const notify = () => version(version.peek() + 1);
+    const chunks = ((nextValue = READ) => {
+        if (nextValue === READ) {
+            version();
+            return [...items];
+        }
+        items = [...nextValue];
+        notify();
+        return [...items];
+    });
+    chunks.set = (nextValue) => {
+        items = [...nextValue];
+        notify();
+        return [...items];
+    };
+    chunks.update = (updater) => chunks.set(updater([...items]));
+    chunks.peek = () => [...items];
+    chunks.subscribe = (listener, options = {}) => {
+        const { immediate = true } = options;
+        if (immediate) {
+            listener([...items]);
+        }
+        return version.subscribe(() => listener([...items]), { immediate: false });
+    };
+    chunks.append = (chunk) => {
+        const index = items.length;
+        items.push(chunk);
+        notify();
+        return index;
+    };
+    chunks.count = () => {
+        version();
+        return items.length;
+    };
+    chunks.peekCount = () => items.length;
+    chunks.snapshot = () => [...items];
+    return chunks;
+}
+export function appendResponseChunk(chunks, chunk) {
+    if (isChunkSignal(chunks)) {
+        return chunks.append(chunk);
+    }
+    const currentChunks = chunks.peek();
+    const index = currentChunks.length;
+    chunks([...currentChunks, chunk]);
+    return index;
+}
+export function getResponseChunkCount(chunks) {
+    return isChunkSignal(chunks) ? chunks.peekCount() : chunks.peek().length;
+}
+export function snapshotResponseChunks(chunks) {
+    return isChunkSignal(chunks) ? chunks.snapshot() : [...chunks.peek()];
+}
 // 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 chunks = createChunkSignal();
     const startedAt = signal(null);
     const finishedAt = signal(null);
     const pending = computed(() => {
@@ -19,7 +84,7 @@ export function createResponseState(seed) {
     const completed = computed(() => status() === 'completed');
     const failed = computed(() => status() === 'error');
     const aborted = computed(() => status() === 'aborted');
-    const chunkCount = computed(() => chunks().length);
+    const chunkCount = computed(() => chunks.count());
     return {
         status,
         value,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qorejs/qore",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "description": "Qore is a streaming-response framework where stream becomes signal.",
   "type": "module",
   "main": "./dist/src/index.js",