@qorejs/qore 0.7.2 → 0.9.0

package/dist/src/server/sse-response.js

@@ -0,0 +1,102 @@
+import { toAsyncIterable } from '../core/iterable.js';
+import { normalizeAbortReason, normalizeError } from '../shared/utils.js';
+const encoder = new TextEncoder();
+function normalizeFrame(chunk, index, options) {
+    if (typeof options.encode === 'function') {
+        return Promise.resolve(options.encode(chunk, index));
+    }
+    return Promise.resolve({
+        ...(options.event ? { event: options.event } : {}),
+        data: typeof chunk === 'string' ? chunk : JSON.stringify(chunk)
+    });
+}
+function formatSSEFrame(frame) {
+    if (typeof frame === 'string') {
+        return frame.endsWith('\n\n') ? frame : `${frame}\n\n`;
+    }
+    const lines = [];
+    if (frame.event) {
+        lines.push(`event: ${frame.event}`);
+    }
+    if (frame.id) {
+        lines.push(`id: ${frame.id}`);
+    }
+    if (typeof frame.retry === 'number') {
+        lines.push(`retry: ${frame.retry}`);
+    }
+    const payloadLines = String(frame.data).split('\n');
+    for (const line of payloadLines) {
+        lines.push(`data: ${line}`);
+    }
+    return `${lines.join('\n')}\n\n`;
+}
+function mergeResponseHeaders(headers = {}) {
+    const merged = new Headers({
+        'cache-control': 'no-cache, no-transform',
+        connection: 'keep-alive',
+        'content-type': 'text/event-stream; charset=utf-8',
+        ...headers
+    });
+    return merged;
+}
+export function createSSEResponse(source, options = {}) {
+    const { signal, headers, doneFrame = 'data: [DONE]\n\n', onError = (error) => ({
+        event: 'error',
+        data: error.message
+    }) } = options;
+    const body = new ReadableStream({
+        async start(controller) {
+            let index = 0;
+            const close = () => {
+                if (doneFrame) {
+                    controller.enqueue(encoder.encode(typeof doneFrame === 'string' ? doneFrame : 'data: [DONE]\n\n'));
+                }
+                controller.close();
+            };
+            if (signal?.aborted) {
+                controller.error(normalizeAbortReason(signal.reason, 'SSE response aborted'));
+                return;
+            }
+            const abortHandler = () => {
+                try {
+                    controller.close();
+                }
+                catch {
+                    // Ignore close races after the stream has already settled.
+                }
+            };
+            signal?.addEventListener('abort', abortHandler, { once: true });
+            try {
+                for await (const chunk of toAsyncIterable(source)) {
+                    if (signal?.aborted) {
+                        close();
+                        return;
+                    }
+                    const frame = await normalizeFrame(chunk, index, options);
+                    controller.enqueue(encoder.encode(formatSSEFrame(frame)));
+                    index += 1;
+                }
+                close();
+            }
+            catch (error) {
+                if (signal?.aborted) {
+                    abortHandler();
+                    return;
+                }
+                const normalizedError = normalizeError(error);
+                const errorFrame = await onError(normalizedError);
+                if (errorFrame !== false) {
+                    controller.enqueue(encoder.encode(formatSSEFrame(errorFrame)));
+                }
+                controller.close();
+            }
+            finally {
+                signal?.removeEventListener('abort', abortHandler);
+            }
+        }
+    });
+    return new Response(body, {
+        status: 200,
+        headers: mergeResponseHeaders(headers)
+    });
+}

package/dist/src/shared/utils.d.ts

@@ -1,2 +1,3 @@
 export declare function normalizeError(error: unknown): Error;
+export declare function normalizeAbortReason(reason: unknown, fallbackMessage?: string): Error;
 export declare function sleep(ms: number, signal?: AbortSignal | null): Promise<void>;

package/dist/src/shared/utils.js

@@ -8,6 +8,13 @@ export function normalizeError(error) {
     }
     return new Error('Unknown Qore error');
 }
+// Convert abort reasons into stable Error instances for transport and runtime code.
+export function normalizeAbortReason(reason, fallbackMessage = 'Operation aborted') {
+    if (reason == null) {
+        return new Error(fallbackMessage);
+    }
+    return normalizeError(reason);
+}
 // Sleep for a fixed time and reject early if the surrounding operation is aborted.
 export function sleep(ms, signal) {
     return new Promise((resolve, reject) => {
@@ -17,7 +24,7 @@ export function sleep(ms, signal) {
         }, ms);
         const onAbort = () => {
             cleanup();
-            reject(normalizeError(signal?.reason ?? 'Operation aborted'));
+            reject(normalizeAbortReason(signal?.reason, 'Operation aborted'));
         };
         const cleanup = () => {
             clearTimeout(timer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qorejs/qore",
-  "version": "0.7.2",
+  "version": "0.9.0",
   "description": "Qore is a streaming-response framework where stream becomes signal.",
   "type": "module",
   "main": "./dist/src/index.js",
@@ -23,13 +23,17 @@
     "browsers:install": "playwright install chromium",
     "typecheck": "node ./scripts/typecheck.mjs",
     "check:dist": "node ./scripts/check-dist-sync.mjs",
+    "check:api-surface": "node ./scripts/check-public-api.mjs",
+    "check:release-docs": "node ./scripts/check-release-docs.mjs",
     "test:browser": "node ./scripts/browser-smoke.mjs",
+    "test:benchmark": "node ./scripts/benchmark-gate.mjs",
     "smoke:package-types": "node ./scripts/package-type-smoke.mjs",
     "smoke:package-runtime": "node ./scripts/package-runtime-smoke.mjs",
     "test": "node ./scripts/test.mjs",
     "release:check": "node ./scripts/release-check.mjs",
+    "publish:preflight": "node ./scripts/publish-preflight.mjs",
     "publish:github": "npm publish --registry=https://npm.pkg.github.com",
-    "publish:npm": "npm publish --access public",
+    "publish:npm": "node ./scripts/publish-npm.mjs",
     "prepublishOnly": "node ./scripts/release-check.mjs"
   },
   "engines": {
@@ -42,9 +46,12 @@
     "signal",
     "reactive",
     "sse",
+    "ndjson",
     "ai",
     "openai",
     "anthropic",
+    "deepseek",
+    "ollama",
     "framework",
     "async-iterable"
   ],