stitchkit 0.95.0 → 0.95.2

package/dist/entrypoints/server.js

@@ -21,6 +21,9 @@ import {
   webSocketLane
 } from "../index-p3vsv1fb.js";
 import"../index-y91ry9h2.js";
+import {
+  createFileStateStore
+} from "../index-tm88avnj.js";
 import {
   withDeadline
 } from "../index-b9aefrqd.js";
@@ -113,222 +116,6 @@ import {
 import {
   isRecord
 } from "../index-hffjpmq9.js";
-
-// src/application/file-state-store.ts
-import { mkdir, open, readdir, readFile, rename, stat, unlink } from "node:fs/promises";
-import { basename, dirname, join } from "node:path";
-var ABANDONED_LOCK_MULTIPLIER = 10;
-var ABANDONED_HEARTBEATS = 30;
-var MIN_HEARTBEAT_MS = 10;
-var delay = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
-async function missing(error) {
-  return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
-function existing(error) {
-  return error instanceof Error && "code" in error && error.code === "EEXIST";
-}
-async function ownerState(lockPath) {
-  let owner;
-  try {
-    owner = JSON.parse(await readFile(lockPath, "utf8"));
-  } catch {
-    return "unknown";
-  }
-  if (typeof owner !== "object" || owner === null || !("pid" in owner) || typeof owner.pid !== "number" || !Number.isSafeInteger(owner.pid) || owner.pid <= 0) {
-    return "unknown";
-  }
-  try {
-    process.kill(owner.pid, 0);
-    return "alive";
-  } catch (error) {
-    return error instanceof Error && "code" in error && error.code === "ESRCH" ? "gone" : "unknown";
-  }
-}
-async function sweepTemporaries(path, staleLockMs) {
-  const prefix = `${basename(path)}.tmp.`;
-  const directory = dirname(path);
-  let entries;
-  try {
-    entries = await readdir(directory);
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (!entry.startsWith(prefix))
-      continue;
-    const candidate = join(directory, entry);
-    const info = await stat(candidate).catch(() => null);
-    if (info && Date.now() - info.mtimeMs > staleLockMs) {
-      await unlink(candidate).catch(() => {
-        return;
-      });
-    }
-  }
-}
-async function reclaim(lockPath, observed, staleLockMs, abandonedAfterMs) {
-  const guardPath = `${lockPath}.reclaim`;
-  let guard;
-  try {
-    guard = await open(guardPath, "wx");
-  } catch (error) {
-    if (!existing(error))
-      throw error;
-    const orphan = await stat(guardPath).catch(() => null);
-    if (orphan && Date.now() - orphan.mtimeMs > staleLockMs) {
-      await unlink(guardPath).catch(() => {
-        return;
-      });
-    }
-    return false;
-  }
-  try {
-    const current = await stat(lockPath).catch(() => null);
-    if (!current || current.dev !== observed.dev || current.ino !== observed.ino || current.mtimeMs !== observed.mtimeMs) {
-      return false;
-    }
-    const owner = await ownerState(lockPath);
-    const age = Date.now() - current.mtimeMs;
-    if (owner !== "gone" && age < abandonedAfterMs)
-      return false;
-    await unlink(lockPath);
-    return true;
-  } finally {
-    await guard.close().catch(() => {
-      return;
-    });
-    await unlink(guardPath).catch(() => {
-      return;
-    });
-  }
-}
-function createFileStateStore(path, options) {
-  const lockPath = `${path}.lock`;
-  const lockTimeoutMs = options.lockTimeoutMs ?? 1e4;
-  const staleLockMs = options.staleLockMs ?? 3000;
-  const retryMs = options.retryMs ?? 10;
-  const heartbeatMs = Math.max(MIN_HEARTBEAT_MS, Math.floor(staleLockMs / 3));
-  const abandonedAfterMs = Math.max(staleLockMs * ABANDONED_LOCK_MULTIPLIER, heartbeatMs * ABANDONED_HEARTBEATS);
-  if (staleLockMs >= lockTimeoutMs) {
-    throw new Error(`[stitchkit] createFileStateStore: staleLockMs (${staleLockMs}) must be below lockTimeoutMs (${lockTimeoutMs}), or a crashed holder blocks every update until the timeout`);
-  }
-  let sweptTemporaries = false;
-  const parseFile = async () => {
-    let source;
-    try {
-      source = await readFile(path, "utf8");
-    } catch (error) {
-      if (await missing(error))
-        return null;
-      throw error;
-    }
-    try {
-      return options.schema.parse(JSON.parse(source));
-    } catch (error) {
-      await options.onCorrupt?.({ path, error });
-      if ((options.corrupt ?? "throw") === "empty")
-        return null;
-      throw error;
-    }
-  };
-  const acquire = async () => {
-    await mkdir(dirname(path), { recursive: true });
-    if (!sweptTemporaries) {
-      sweptTemporaries = true;
-      await sweepTemporaries(path, staleLockMs);
-    }
-    const deadline = Date.now() + lockTimeoutMs;
-    while (true) {
-      try {
-        const handle = await open(lockPath, "wx");
-        const token = crypto.randomUUID();
-        try {
-          await handle.writeFile(JSON.stringify({ token, pid: process.pid, acquiredAt: Date.now() }));
-          await handle.sync();
-        } catch (error) {
-          await handle.close().catch(() => {
-            return;
-          });
-          await unlink(lockPath).catch(() => {
-            return;
-          });
-          throw error;
-        }
-        return {
-          refresh: async () => {
-            const now = new Date;
-            await handle.utimes(now, now);
-          },
-          release: async () => {
-            await handle.close();
-            try {
-              const owner = JSON.parse(await readFile(lockPath, "utf8"));
-              if (isRecord(owner) && owner.token === token)
-                await unlink(lockPath);
-            } catch (error) {
-              if (!await missing(error))
-                throw error;
-            }
-          }
-        };
-      } catch (error) {
-        if (!existing(error))
-          throw error;
-        try {
-          const lock = await stat(lockPath);
-          if (Date.now() - lock.mtimeMs > staleLockMs) {
-            if (await reclaim(lockPath, lock, staleLockMs, abandonedAfterMs))
-              continue;
-          }
-        } catch (statError) {
-          if (await missing(statError))
-            continue;
-          throw statError;
-        }
-        if (Date.now() >= deadline) {
-          throw new Error(`[stitchkit] timed out acquiring state lock for ${path}`);
-        }
-        await delay(retryMs);
-      }
-    }
-  };
-  const write = async (state) => {
-    const validated = options.schema.parse(state);
-    const temporary = `${path}.tmp.${process.pid}.${crypto.randomUUID()}`;
-    const handle = await open(temporary, "wx");
-    try {
-      try {
-        await handle.writeFile(`${JSON.stringify(validated)}
-`);
-        await handle.sync();
-      } finally {
-        await handle.close();
-      }
-      await rename(temporary, path);
-    } catch (error) {
-      await unlink(temporary).catch(() => {
-        return;
-      });
-      throw error;
-    }
-  };
-  return {
-    read: parseFile,
-    async update(transition) {
-      const lock = await acquire();
-      const heartbeat = setInterval(() => void lock.refresh().catch(() => {
-        return;
-      }), heartbeatMs);
-      try {
-        const next = await transition(await parseFile());
-        await write(next.state);
-        return next.result;
-      } finally {
-        clearInterval(heartbeat);
-        await lock.release();
-      }
-    }
-  };
-}
 // src/realtime/registry.ts
 var authorizedRoom = Symbol("stitchkit.authorized-room");
 function freezeRoom(name) {
@@ -1001,7 +788,7 @@ function createEventBus(options = {}) {
   };
 }
 // src/server/file.ts
-import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
+import { readFile, stat } from "node:fs/promises";
 import { resolve } from "node:path";
 
 // src/server/mime.ts
@@ -1061,10 +848,10 @@ function staticRoute(prefix, dir) {
       const realTarget = await realPathWithinDir(root, target);
       if (realTarget === null)
         return new Response("Not found", { status: 404 });
-      const info = await stat2(realTarget).catch(() => null);
+      const info = await stat(realTarget).catch(() => null);
       if (!info?.isFile())
         return new Response("Not found", { status: 404 });
-      return new Response(await readFile2(realTarget), {
+      return new Response(await readFile(realTarget), {
         headers: {
           "Content-Type": mimeForPath(realTarget),
           "X-Content-Type-Options": "nosniff"

package/dist/entrypoints/voice.d.ts

@@ -0,0 +1,6 @@
+/** Isomorphic primitives of a live voice conversation: sentences, speakable text, speech queue. */
+export { LIVE_VOICE_PHASES, type LiveVoicePhase } from '../voice/phases.js';
+export { SentenceCutter } from '../voice/sentences.js';
+export { speakableText } from '../voice/speakable.js';
+export { SpeechQueue, type SpeechQueueOptions } from '../voice/speech-queue.js';
+//# sourceMappingURL=voice.d.ts.map

package/dist/entrypoints/voice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"voice.d.ts","sourceRoot":"","sources":["../../src/entrypoints/voice.ts"],"names":[],"mappings":"AAAA,mGAAmG;AACnG,OAAO,EAAE,iBAAiB,EAAE,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACzE,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/entrypoints/voice.js

@@ -0,0 +1,221 @@
+// src/voice/phases.ts
+var LIVE_VOICE_PHASES = [
+  "opening",
+  "idle",
+  "hearing",
+  "thinking",
+  "speaking"
+];
+// src/voice/sentences.ts
+var TERMINAL = /[.!?…]/;
+var CLOSING = /["»”)]/;
+var ENDS_SENTENCE = /[.!?…]+["»”)]*$/;
+var OPENER = /^[\p{Lu}\p{N}"«“(—–-]/u;
+var NEXT_WORD = /^\s+(\S)/u;
+
+class SentenceCutter {
+  said = 0;
+  next(text, final) {
+    const sentences = [];
+    let start = this.said;
+    let fence = fenceFrom(text, this.said);
+    for (let index = this.said;index < text.length; index += 1) {
+      if (index >= fence.end)
+        fence = fenceFrom(text, index);
+      if (index >= fence.start && index < fence.end)
+        continue;
+      if (!isBoundary(text, index, start))
+        continue;
+      const sentence = text.slice(start, index + 1).trim();
+      if (sentence !== "")
+        sentences.push(sentence);
+      start = index + 1;
+    }
+    this.said = start;
+    if (final) {
+      const rest = text.slice(start).trim();
+      if (rest !== "")
+        sentences.push(rest);
+      this.said = text.length;
+    }
+    return sentences;
+  }
+  reset() {
+    this.said = 0;
+  }
+}
+function isBoundary(text, index, start) {
+  const char = text[index] ?? "";
+  if (char === `
+` && text[index + 1] === `
+`)
+    return true;
+  if (!TERMINAL.test(char) && !CLOSING.test(char))
+    return false;
+  const following = text[index + 1] ?? "";
+  if (TERMINAL.test(following) || CLOSING.test(following))
+    return false;
+  if (!ENDS_SENTENCE.test(text.slice(start, index + 1)))
+    return false;
+  const next = text.slice(index + 1, index + 64).match(NEXT_WORD);
+  return next !== null && OPENER.test(next[1] ?? "");
+}
+function fenceFrom(text, from) {
+  const open = text.indexOf("```", from);
+  if (open === -1)
+    return { start: text.length, end: text.length };
+  const close = text.indexOf("```", open + 3);
+  return { start: open, end: close === -1 ? text.length : close + 3 };
+}
+// src/voice/speakable.ts
+var FENCED_BLOCK = /^[ \t]*(```|~~~)[^\n]*\n[\s\S]*?(?:^[ \t]*\1[^\n]*$|(?![\s\S]))/gm;
+var TABLE_ROW = /^[ \t]*\|.*$/gm;
+var THEMATIC_BREAK = /^[ \t]*([-*_])(?:[ \t]*\1){2,}[ \t]*$/gm;
+var IMAGE = /!\[[^\]]*\]\((?:<[^>]*>|[^)])*\)/g;
+var LINK = /\[([^\]]+)\]\((?:<[^>]*>|[^)])*\)/g;
+var REFERENCE_LINK = /\[([^\]]+)\]\[[^\]]*\]/g;
+var LINK_DEFINITION = /^[ \t]{0,3}\[[^\]]+\]:[ \t]*\S+.*$/gm;
+var AUTOLINK = /<(?:https?|mailto):[^>\s]*>/g;
+var BARE_URL = /\bhttps?:\/\/[^\s<>()]+/g;
+var HTML_TAG = /<\/?[A-Za-z][^>]*>/g;
+var LINE_MARKER = /^[ \t]{0,3}(?:#{1,6}[ \t]+|>[ \t]?|[-*+][ \t]+(?:\[[ xX]\][ \t]+)?)/gm;
+function speakableText(markdown) {
+  return markdown.replace(FENCED_BLOCK, " ").replace(TABLE_ROW, " ").replace(THEMATIC_BREAK, " ").replace(LINK_DEFINITION, " ").replace(IMAGE, "").replace(LINK, "$1").replace(REFERENCE_LINK, "$1").replace(AUTOLINK, "").replace(BARE_URL, "").replace(HTML_TAG, "").replace(LINE_MARKER, "").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/__([^_]+)__/g, "$1").replace(/~~([^~]+)~~/g, "$1").replace(/(^|[^\p{L}\p{N}*])\*([^*\s][^*]*?)\*(?![\p{L}\p{N}*])/gu, "$1$2").replace(/(^|[^\p{L}\p{N}_])_([^_\s][^_]*?)_(?![\p{L}\p{N}_])/gu, "$1$2").replace(/`([^`]+)`/g, "$1").replace(/\s+/g, " ").replace(/ ([.,!?;:…])/g, "$1").trim();
+}
+// src/voice/speech-queue.ts
+var CANCELLED = Symbol("cancelled");
+function settle(run) {
+  return Promise.resolve().then(run).then((value) => ({ ok: true, value }), (error) => ({ ok: false, error }));
+}
+
+class SpeechQueue {
+  options;
+  done;
+  lookahead;
+  pending = [];
+  ahead = [];
+  current = null;
+  playing = false;
+  closed = false;
+  cancelled = false;
+  wake = null;
+  stop;
+  stopped = new Promise((resolve) => {
+    this.stop = resolve;
+  });
+  constructor(options) {
+    this.options = options;
+    const lookahead = options.lookahead ?? 1;
+    if (!Number.isInteger(lookahead) || lookahead < 0) {
+      throw new RangeError(`lookahead must be a non-negative integer, got ${lookahead}`);
+    }
+    this.lookahead = lookahead;
+    this.done = this.run();
+  }
+  get isCancelled() {
+    return this.cancelled;
+  }
+  get isSpeaking() {
+    return this.playing;
+  }
+  push(text) {
+    if (this.closed || this.cancelled || text.trim() === "")
+      return;
+    this.pending.push(text);
+    this.fill();
+    this.notify();
+  }
+  close() {
+    this.closed = true;
+    this.notify();
+  }
+  cancel() {
+    if (this.cancelled)
+      return;
+    this.cancelled = true;
+    this.closed = true;
+    this.pending.length = 0;
+    const unplayed = this.ahead.splice(0);
+    if (this.current && !this.playing)
+      unplayed.push(this.current);
+    this.current?.controller.abort();
+    for (const slot of unplayed) {
+      slot.controller.abort();
+      slot.result.then((outcome) => {
+        if (outcome.ok)
+          this.release(outcome.value);
+      });
+    }
+    this.stop(CANCELLED);
+    this.notify();
+  }
+  notify() {
+    this.wake?.();
+  }
+  fill() {
+    const capacity = this.lookahead + 1 - (this.current ? 1 : 0);
+    while (!this.cancelled && this.ahead.length < capacity && this.pending.length > 0) {
+      const text = this.pending.shift();
+      const controller = new AbortController;
+      this.ahead.push({
+        text,
+        controller,
+        result: settle(() => this.options.prepare(text, controller.signal))
+      });
+    }
+  }
+  async run() {
+    while (!this.cancelled) {
+      this.fill();
+      const slot = this.ahead.shift();
+      if (!slot) {
+        if (this.closed)
+          return;
+        await new Promise((resolve) => {
+          this.wake = resolve;
+        });
+        this.wake = null;
+        continue;
+      }
+      this.current = slot;
+      try {
+        const prepared = await Promise.race([slot.result, this.stopped]);
+        if (prepared === CANCELLED)
+          return;
+        if (!prepared.ok) {
+          this.report(prepared.error, slot.text);
+          continue;
+        }
+        this.playing = true;
+        this.fill();
+        const played = await Promise.race([
+          settle(() => this.options.play(prepared.value, slot.controller.signal)),
+          this.stopped
+        ]);
+        if (played === CANCELLED)
+          return;
+        if (!played.ok)
+          this.report(played.error, slot.text);
+      } finally {
+        this.playing = false;
+        this.current = null;
+      }
+    }
+  }
+  report(error, text) {
+    try {
+      this.options.onError?.(error, text);
+    } catch {}
+  }
+  release(prepared) {
+    try {
+      this.options.discard?.(prepared);
+    } catch {}
+  }
+}
+export {
+  speakableText,
+  SpeechQueue,
+  SentenceCutter,
+  LIVE_VOICE_PHASES
+};

package/dist/index-5jrd0yng.js

@@ -0,0 +1,114 @@
+// src/application/directory-inbox-contract.ts
+import { z } from "zod";
+var timestamp = z.string().datetime({ offset: true });
+var key = z.string().min(1).max(255);
+var DirectoryInboxRejectionReasonSchema = z.enum([
+  "invalid",
+  "too-large",
+  "attempt-limit"
+]);
+var DirectoryInboxStateSchema = z.object({
+  schemaVersion: z.literal(1),
+  claims: z.array(z.object({
+    key,
+    attempts: z.number().int().positive(),
+    nextAttemptAt: timestamp,
+    leaseId: z.string().min(1).max(128).nullable(),
+    leaseUntil: timestamp.nullable()
+  }).strict()),
+  receipts: z.array(z.object({ key, completedAt: timestamp }).strict()),
+  rejected: z.array(z.object({
+    key,
+    reason: DirectoryInboxRejectionReasonSchema,
+    detail: z.string().max(1000),
+    rejectedAt: timestamp
+  }).strict())
+}).strict();
+var emptyDirectoryInboxState = () => ({
+  schemaVersion: 1,
+  claims: [],
+  receipts: [],
+  rejected: []
+});
+var iso = (milliseconds) => new Date(milliseconds).toISOString();
+function withRejection(state, rejection, retain) {
+  return {
+    ...state,
+    claims: state.claims.filter((claim) => claim.key !== rejection.key),
+    rejected: [
+      rejection,
+      ...state.rejected.filter((item) => item.key !== rejection.key)
+    ].slice(0, retain)
+  };
+}
+function claimEntry(state, input) {
+  if (state.receipts.some((receipt) => receipt.key === input.key)) {
+    return { state, step: { kind: "remove" } };
+  }
+  if (state.rejected.some((rejection) => rejection.key === input.key)) {
+    return { state, step: { kind: "set-aside" } };
+  }
+  const now = input.now.getTime();
+  const claim = state.claims.find((candidate) => candidate.key === input.key);
+  if (claim) {
+    const leased = claim.leaseUntil !== null && Date.parse(claim.leaseUntil) > now;
+    if (leased || Date.parse(claim.nextAttemptAt) > now)
+      return { state, step: { kind: "skip" } };
+    if (claim.attempts >= input.maxAttempts) {
+      const rejection = {
+        key: input.key,
+        reason: "attempt-limit",
+        detail: `taken ${claim.attempts} times without completing`,
+        rejectedAt: iso(now)
+      };
+      return {
+        state: withRejection(state, rejection, input.retain),
+        step: { kind: "reject", rejection }
+      };
+    }
+  }
+  const taken = {
+    key: input.key,
+    attempts: (claim?.attempts ?? 0) + 1,
+    nextAttemptAt: iso(now),
+    leaseId: crypto.randomUUID(),
+    leaseUntil: iso(now + input.leaseMs)
+  };
+  return {
+    state: {
+      ...state,
+      claims: [...state.claims.filter((candidate) => candidate.key !== input.key), taken]
+    },
+    step: { kind: "deliver", claim: taken }
+  };
+}
+function completeEntry(state, entryKey, now, retain) {
+  return {
+    ...state,
+    claims: state.claims.filter((claim) => claim.key !== entryKey),
+    receipts: [
+      { key: entryKey, completedAt: now.toISOString() },
+      ...state.receipts.filter((receipt) => receipt.key !== entryKey)
+    ].slice(0, retain)
+  };
+}
+function releaseEntry(state, claim, retryAt) {
+  return {
+    ...state,
+    claims: state.claims.map((candidate) => candidate.key === claim.key && candidate.leaseId === claim.leaseId ? {
+      ...candidate,
+      nextAttemptAt: retryAt.toISOString(),
+      leaseId: null,
+      leaseUntil: null
+    } : candidate)
+  };
+}
+function forgetMissing(state, present, now) {
+  const live = (claim) => claim.leaseUntil !== null && Date.parse(claim.leaseUntil) > now.getTime();
+  return {
+    ...state,
+    claims: state.claims.filter((claim) => present.has(claim.key) || live(claim))
+  };
+}
+
+export { DirectoryInboxRejectionReasonSchema, DirectoryInboxStateSchema, emptyDirectoryInboxState, withRejection, claimEntry, completeEntry, releaseEntry, forgetMissing };