@gentbajko/slopify 0.6.1 → 0.8.0

package/dist/kernel/audio-preview.js

@@ -0,0 +1,188 @@
+import { randomUUID } from "node:crypto";
+const inactive = { append: () => { }, complete: () => { }, interrupt: () => { } };
+// A preview is a disposable copy of bytes from the paid call already in flight.
+// It never initiates synthesis, persists audio, or backpressures the provider.
+// Readers pull from shared bounded storage, so a slow browser cannot grow a queue.
+export function createAudioPreviewStore(limits = {}) {
+    const maxBytes = limits.maxBytes ?? 64 * 1024 * 1024;
+    const maxEntryBytes = limits.maxEntryBytes ?? 16 * 1024 * 1024;
+    const maxEntries = limits.maxEntries ?? 128;
+    const keepMs = limits.keepMs ?? 5 * 60_000;
+    const now = limits.now ?? Date.now;
+    const entries = new Map();
+    let retained = 0;
+    let closed = false;
+    const notify = (entry) => {
+        const listeners = [...entry.changed];
+        entry.changed.clear();
+        for (const listener of listeners)
+            listener();
+    };
+    const stop = (entry, state) => {
+        retained -= entry.bytes;
+        entry.bytes = 0;
+        entry.chunks.length = 0;
+        entry.state = state;
+        entry.endedAt = now();
+        notify(entry);
+    };
+    const remove = (entry) => {
+        stop(entry, "interrupted");
+        entries.delete(entry.id);
+    };
+    const prune = () => {
+        for (const entry of entries.values()) {
+            if (entry.endedAt !== undefined && now() - entry.endedAt >= keepMs)
+                remove(entry);
+        }
+    };
+    const expiry = setInterval(prune, Math.min(keepMs, 30_000));
+    expiry.unref();
+    const store = {
+        begin(projectId, key, label) {
+            if (closed)
+                return inactive;
+            prune();
+            for (const entry of entries.values()) {
+                if (entry.projectId === projectId && entry.key === key)
+                    remove(entry);
+            }
+            // At capacity, completed previews yield to current generation. Otherwise
+            // this request has no preview; the normal durable narration still succeeds.
+            if (entries.size >= maxEntries) {
+                const oldest = [...entries.values()].find((entry) => entry.state !== "streaming");
+                if (oldest !== undefined)
+                    remove(oldest);
+            }
+            if (entries.size >= maxEntries)
+                return inactive;
+            const entry = {
+                id: randomUUID(),
+                projectId,
+                key,
+                label,
+                chunks: [],
+                changed: new Set(),
+                state: "streaming",
+                bytes: 0,
+                endedAt: undefined,
+            };
+            entries.set(entry.id, entry);
+            const active = () => entries.get(entry.id) === entry && entry.state === "streaming";
+            return {
+                append(bytes) {
+                    if (!active() || bytes.byteLength === 0)
+                        return;
+                    if (retained + bytes.byteLength > maxBytes ||
+                        entry.bytes + bytes.byteLength > maxEntryBytes) {
+                        stop(entry, "unavailable");
+                        return;
+                    }
+                    // Own these bounded buffers. A provider may reuse its read buffer.
+                    for (let at = 0; at < bytes.byteLength; at += 64 * 1024) {
+                        entry.chunks.push(bytes.slice(at, at + 64 * 1024));
+                    }
+                    retained += bytes.byteLength;
+                    entry.bytes += bytes.byteLength;
+                    notify(entry);
+                },
+                complete() {
+                    if (!active())
+                        return;
+                    entry.state = "ready";
+                    entry.endedAt = now();
+                    notify(entry);
+                },
+                interrupt() {
+                    if (active())
+                        stop(entry, "interrupted");
+                },
+            };
+        },
+        list(projectId) {
+            prune();
+            return [...entries.values()]
+                .filter((entry) => entry.projectId === projectId)
+                .map(({ id, label, state, bytes }) => ({ id, label, state, bytes }));
+        },
+        stream(projectId, id, signal) {
+            prune();
+            const entry = entries.get(id);
+            if (entry === undefined ||
+                entry.projectId !== projectId ||
+                entry.state === "interrupted" ||
+                entry.state === "unavailable")
+                return undefined;
+            return follow(entry, signal);
+        },
+        clear(projectId) {
+            for (const entry of entries.values())
+                if (entry.projectId === projectId)
+                    remove(entry);
+        },
+        close() {
+            closed = true;
+            clearInterval(expiry);
+            for (const entry of entries.values())
+                remove(entry);
+        },
+    };
+    return store;
+}
+function follow(entry, signal) {
+    let index = 0;
+    let ended = false;
+    let wake;
+    let control;
+    const detach = () => {
+        ended = true;
+        signal.removeEventListener("abort", abort);
+        if (wake !== undefined) {
+            entry.changed.delete(wake);
+            wake();
+            wake = undefined;
+        }
+    };
+    const abort = () => {
+        if (ended)
+            return;
+        detach();
+        control?.error(new Error("Audio preview disconnected"));
+    };
+    return new ReadableStream({
+        start(controller) {
+            control = controller;
+            if (signal.aborted)
+                abort();
+            else
+                signal.addEventListener("abort", abort, { once: true });
+        },
+        async pull(controller) {
+            while (!ended) {
+                if (entry.state === "interrupted" || entry.state === "unavailable") {
+                    detach();
+                    controller.error(new Error("Audio preview was interrupted"));
+                    return;
+                }
+                const bytes = entry.chunks[index];
+                if (bytes !== undefined) {
+                    index += 1;
+                    controller.enqueue(bytes);
+                    return;
+                }
+                if (entry.state === "ready") {
+                    detach();
+                    controller.close();
+                    return;
+                }
+                await new Promise((resolve) => {
+                    wake = resolve;
+                    entry.changed.add(resolve);
+                });
+            }
+        },
+        cancel() {
+            detach();
+        },
+    }, { highWaterMark: 0 });
+}

package/dist/kernel/db/migrations/0003-batch-queue.sql

@@ -0,0 +1,11 @@
+CREATE TABLE batches (
+  id TEXT PRIMARY KEY,
+  created_at TEXT NOT NULL
+);
+CREATE TABLE project_queue (
+  position INTEGER PRIMARY KEY AUTOINCREMENT,
+  project_id TEXT NOT NULL UNIQUE REFERENCES projects(id) ON DELETE CASCADE,
+  batch_id TEXT NOT NULL REFERENCES batches(id),
+  state TEXT NOT NULL DEFAULT 'queued' CHECK(state IN ('queued','active','finished'))
+);
+CREATE INDEX project_queue_state ON project_queue(state, position);

package/dist/kernel/ports/llm.js

@@ -1 +1,2 @@
 export const messageRoles = ["system", "user", "assistant"];
+export const thinkingModes = ["off", "low", "medium", "high", "xhigh"];

package/dist/kernel/ports/text.js

@@ -0,0 +1,26 @@
+// Bounded UTF-16 length is conservative for providers counting Unicode characters.
+// Every character survives; the split never cuts a surrogate pair.
+export function splitText(text, limit) {
+    if (!Number.isInteger(limit) || limit < 2)
+        throw new Error("Text limit must be at least two characters");
+    const parts = [];
+    let rest = text;
+    while (rest.length > limit) {
+        const window = rest.slice(0, limit);
+        const sentences = [...window.matchAll(/[.!?]\s+|\n/g)];
+        const last = sentences.at(-1);
+        let cut = last && last.index > limit / 2
+            ? last.index + last[0].length
+            : Math.max(window.lastIndexOf(" "), window.lastIndexOf("\n"), window.lastIndexOf("\t")) + 1;
+        if (cut < limit / 2)
+            cut = limit;
+        const code = rest.charCodeAt(cut - 1);
+        if (code >= 0xd800 && code <= 0xdbff)
+            cut--;
+        parts.push(rest.slice(0, cut));
+        rest = rest.slice(cut);
+    }
+    if (rest)
+        parts.push(rest);
+    return parts;
+}

package/dist/kernel/runner/providers.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { attempt } from "./attempt.js";
 export function stageProviders(deps, context, pieceId) {
     const ctx = {
@@ -10,25 +11,40 @@ export function stageProviders(deps, context, pieceId) {
         ...(pieceId === undefined ? {} : { pieceId }),
         signal: context.signal,
     };
+    const schedule = (provider, work) => deps.queue ? deps.queue.run(provider, context.signal, work) : work();
     return {
         llm: (call, onEvent) => {
             // Resolved once; the adapter reads the stored key per request, so a key replaced
             // mid-run still reaches the next attempt.
             const port = deps.registry.llm(call.provider);
-            return attempt(ctx, async (signal, progress) => {
+            const callId = randomUUID();
+            const preview = (text, reset) => context.emit({
+                type: "llm.preview",
+                projectId: context.stage.projectId,
+                stage: context.stage.kind,
+                callId,
+                label: call.previewLabel ?? context.stage.kind,
+                text,
+                ...(reset === undefined ? {} : { reset }),
+            });
+            return schedule(call.provider, () => attempt(ctx, async (signal, progress) => {
+                preview("", true);
                 let text = "";
                 let usage = null;
                 let finishReason = null;
                 for await (const event of port.complete({
                     model: call.model,
+                    ...(call.thinking === undefined ? {} : { thinking: call.thinking }),
                     messages: call.messages,
                     ...(call.webSearch === undefined ? {} : { webSearch: call.webSearch }),
                     signal,
                 })) {
+                    signal.throwIfAborted();
                     // Every event is a sign of life, so the idle clock restarts here.
                     progress();
                     if (event.type === "delta") {
                         text += event.text;
+                        preview(event.text);
                     }
                     else if (event.type === "done") {
                         usage = event.usage;
@@ -44,47 +60,83 @@ export function stageProviders(deps, context, pieceId) {
                     throw new Error(unusable);
                 }
                 return answer;
-            }, { kind: "llm", streaming: port.capabilities.streams });
+            }, { kind: "llm", streaming: port.capabilities.streams }));
         },
-        tts: (call) => {
+        tts: (call, observe) => {
             const port = deps.registry.tts(call.provider);
-            return attempt(ctx, async (signal, progress) => {
-                const spoken = await port.synthesize({
-                    voiceId: call.voiceId,
-                    text: call.text,
-                    signal,
-                });
-                const reader = spoken.audio.getReader();
-                const chunks = [];
-                let total = 0;
-                for (;;) {
-                    const { done, value } = await reader.read();
-                    if (done || value === undefined) {
-                        break;
+            let continuation;
+            const notify = (event) => {
+                try {
+                    observe?.(event);
+                }
+                catch {
+                    // A preview is optional. A broken observer must never repeat a paid call.
+                    deps.log.write("warn", "audio.preview", {
+                        projectId: context.stage.projectId,
+                        stage: "audio",
+                        detail: "Could not update the live audio preview",
+                    });
+                }
+            };
+            return schedule(call.provider, () => attempt(ctx, async (signal, progress) => {
+                notify({ type: "start" });
+                try {
+                    const spoken = await port.synthesize({
+                        model: call.model,
+                        voiceId: call.voiceId,
+                        text: call.text,
+                        signal,
+                        onActivity: progress,
+                        continuation: {
+                            read: () => continuation,
+                            write: (token) => {
+                                continuation = token;
+                            },
+                        },
+                    });
+                    const reader = spoken.audio.getReader();
+                    const chunks = [];
+                    let total = 0;
+                    try {
+                        for (;;) {
+                            const { done, value } = await reader.read();
+                            signal.throwIfAborted();
+                            if (done || value === undefined)
+                                break;
+                            progress();
+                            chunks.push(value);
+                            total += value.length;
+                            notify({ type: "chunk", bytes: value });
+                        }
                     }
-                    progress();
-                    chunks.push(value);
-                    total += value.length;
+                    finally {
+                        reader.releaseLock();
+                    }
+                    const bytes = new Uint8Array(total);
+                    let at = 0;
+                    for (const chunk of chunks) {
+                        bytes.set(chunk, at);
+                        at += chunk.length;
+                    }
+                    notify({ type: "complete" });
+                    return { bytes, container: spoken.container };
                 }
-                const bytes = new Uint8Array(total);
-                let at = 0;
-                for (const chunk of chunks) {
-                    bytes.set(chunk, at);
-                    at += chunk.length;
+                catch (error) {
+                    notify({ type: "interrupted" });
+                    throw error;
                 }
-                return { bytes, container: spoken.container };
-            }, { kind: "tts", streaming: port.capabilities.streams });
+            }, { kind: "tts", streaming: port.capabilities.streams }));
         },
         image: (call) => {
             const port = deps.registry.image(call.provider);
-            return attempt(ctx, (signal) => port.generate({
+            return schedule(call.provider, () => attempt(ctx, (signal) => port.generate({
                 model: call.model,
                 prompt: call.prompt,
                 aspect: call.aspect,
                 signal,
             }), 
             // One request, one answer: the 300 s runs over the whole call.
-            { kind: "image" });
+            { kind: "image" }));
         },
         forPiece: (piece) => stageProviders(deps, context, piece),
     };

package/dist/kernel/runner/queue.js

@@ -0,0 +1,65 @@
+// One app-wide queue: no more than five calls, with lower provider limits.
+// Waiting does not start an attempt or its idle timer. FIFO among eligible calls.
+export function createProviderQueue(limitFor) {
+    const active = new Map();
+    const waiting = [];
+    let total = 0;
+    function drain() {
+        while (total < 5) {
+            const at = waiting.findIndex((w) => (active.get(w.provider) ?? 0) <
+                Math.max(1, Math.min(5, Math.floor(limitFor(w.provider)) || 1)));
+            if (at < 0)
+                return;
+            const next = waiting.splice(at, 1)[0];
+            if (!next)
+                return;
+            next.signal.removeEventListener("abort", next.cancel);
+            if (next.signal.aborted) {
+                next.cancel();
+                continue;
+            }
+            total++;
+            active.set(next.provider, (active.get(next.provider) ?? 0) + 1);
+            next.start();
+        }
+    }
+    return {
+        run: (provider, signal, work) => {
+            if (signal.aborted)
+                return Promise.reject(signal.reason);
+            return new Promise((resolve, reject) => {
+                const waiter = {
+                    provider,
+                    signal,
+                    cancel: () => {
+                        const at = waiting.indexOf(waiter);
+                        if (at >= 0)
+                            waiting.splice(at, 1);
+                        signal.removeEventListener("abort", waiter.cancel);
+                        reject(signal.reason);
+                    },
+                    start: () => {
+                        void Promise.resolve()
+                            .then(() => {
+                            signal.throwIfAborted();
+                            return work();
+                        })
+                            .then(resolve, reject)
+                            .finally(() => {
+                            total--;
+                            const left = (active.get(provider) ?? 1) - 1;
+                            if (left)
+                                active.set(provider, left);
+                            else
+                                active.delete(provider);
+                            drain();
+                        });
+                    },
+                };
+                waiting.push(waiter);
+                signal.addEventListener("abort", waiter.cancel, { once: true });
+                drain();
+            });
+        },
+    };
+}