appostle-installer 0.0.2 → 0.0.3

package/dist/worker.js

@@ -4,7 +4,7 @@ const require = __ac_createRequire(import.meta.url);
 // ../server/src/server/bootstrap.ts
 import express from "express";
 import { createServer as createHTTPServer } from "http";
-import { createReadStream, unlinkSync, existsSync as existsSync19 } from "fs";
+import { createReadStream, unlinkSync, existsSync as existsSync18 } from "fs";
 import { stat as stat9 } from "fs/promises";
 import { randomUUID as randomUUID14 } from "node:crypto";
 import { hostname as getHostname2 } from "node:os";
@@ -16179,12 +16179,12 @@ function extractPlanNameFromFrontmatter(content) {
   return null;
 }
 function resolvePlanFilename(options) {
-  const { originalPath, newSlug, existsSync: existsSync22 } = options;
+  const { originalPath, newSlug, existsSync: existsSync21 } = options;
   const dir = path5.dirname(originalPath);
   const base = `${newSlug}.md`;
   let candidate = path5.join(dir, base);
   let counter = 2;
-  while (candidate !== originalPath && existsSync22(candidate)) {
+  while (candidate !== originalPath && existsSync21(candidate)) {
     candidate = path5.join(dir, `${newSlug}-${counter}.md`);
     counter += 1;
   }
@@ -43281,52 +43281,11 @@ var SHERPA_ONNX_MODEL_CATALOG = {
     description: "Kokoro TTS (higher quality; larger).",
     aliases: ["kokoro"],
     defaultFor: "tts"
-  },
-  "pocket-tts-onnx-int8": {
-    kind: "tts",
-    extractedDir: "pocket-tts-onnx-int8",
-    downloadFiles: [
-      {
-        url: "https://huggingface.co/KevinAHM/pocket-tts-onnx/resolve/main/onnx/mimi_encoder.onnx",
-        relPath: "onnx/mimi_encoder.onnx"
-      },
-      {
-        url: "https://huggingface.co/KevinAHM/pocket-tts-onnx/resolve/main/onnx/text_conditioner.onnx",
-        relPath: "onnx/text_conditioner.onnx"
-      },
-      {
-        url: "https://huggingface.co/KevinAHM/pocket-tts-onnx/resolve/main/onnx/flow_lm_main_int8.onnx",
-        relPath: "onnx/flow_lm_main_int8.onnx"
-      },
-      {
-        url: "https://huggingface.co/KevinAHM/pocket-tts-onnx/resolve/main/onnx/flow_lm_flow_int8.onnx",
-        relPath: "onnx/flow_lm_flow_int8.onnx"
-      },
-      {
-        url: "https://huggingface.co/KevinAHM/pocket-tts-onnx/resolve/main/onnx/mimi_decoder_int8.onnx",
-        relPath: "onnx/mimi_decoder_int8.onnx"
-      },
-      {
-        url: "https://huggingface.co/KevinAHM/pocket-tts-onnx/resolve/main/tokenizer.model",
-        relPath: "tokenizer.model"
-      },
-      {
-        url: "https://huggingface.co/KevinAHM/pocket-tts-onnx/resolve/main/reference_sample.wav",
-        relPath: "reference_sample.wav"
-      }
-    ],
-    requiredFiles: [
-      "onnx/mimi_encoder.onnx",
-      "onnx/text_conditioner.onnx",
-      "onnx/flow_lm_main_int8.onnx",
-      "onnx/flow_lm_flow_int8.onnx",
-      "onnx/mimi_decoder_int8.onnx",
-      "tokenizer.model",
-      "reference_sample.wav"
-    ],
-    description: "Pocket TTS ONNX (INT8) with streaming decode support (via onnxruntime).",
-    aliases: ["pocket", "pocket-tts"]
   }
+  // pocket-tts-onnx-int8 was previously listed here. Removed on
+  // 2026-05-02: source was a single individual HuggingFace account
+  // (KevinAHM/pocket-tts-onnx) with no provenance/integrity guarantees.
+  // Re-add only if we host a verified mirror with pinned hashes.
 };
 var ALL_MODEL_IDS = Object.keys(SHERPA_ONNX_MODEL_CATALOG);
 var LOCAL_STT_MODEL_IDS = ALL_MODEL_IDS.filter(
@@ -43575,426 +43534,13 @@ async function ensureLocalSpeechModels(options) {
   });
 }
 
-// ../server/src/server/speech/providers/local/pocket/pocket-tts-onnx.ts
-import { existsSync as existsSync12 } from "node:fs";
-import { readFile as readFile3 } from "node:fs/promises";
-import { Readable as Readable3 } from "node:stream";
-function assertFileExists(filePath, label) {
-  if (!existsSync12(filePath)) {
-    throw new Error(`Missing ${label}: ${filePath}`);
-  }
-}
-function product(dims) {
-  let out = 1;
-  for (const d of dims) out *= d;
-  return out;
-}
-function normalizeDims(dims) {
-  return dims.map((d) => {
-    if (typeof d === "number" && Number.isFinite(d)) {
-      if (d === 0) return 0;
-      if (d > 0) return d;
-      return 1;
-    }
-    return 1;
-  });
-}
-function getSessionInputMeta(session, inputName) {
-  const metaAny = session.inputMetadata;
-  if (Array.isArray(metaAny)) {
-    const entry = metaAny.find(
-      (m) => m && typeof m === "object" && m.name === inputName
-    );
-    if (!entry) return void 0;
-    return { type: entry.type, dims: entry.shape };
-  }
-  if (metaAny && typeof metaAny === "object" && inputName in metaAny) {
-    const entry = metaAny[inputName];
-    return { type: entry?.type, dims: entry?.dimensions ?? entry?.shape };
-  }
-  return void 0;
-}
-function toBigInt64(values) {
-  const out = new BigInt64Array(values.length);
-  for (let i = 0; i < values.length; i += 1) {
-    out[i] = BigInt(values[i]);
-  }
-  return out;
-}
-function randn() {
-  let u = 0;
-  let v = 0;
-  while (u === 0) u = Math.random();
-  while (v === 0) v = Math.random();
-  return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
-}
-function normalizeTextForPocket(text) {
-  const trimmed = text.trim();
-  if (!trimmed) {
-    throw new Error("Cannot synthesize empty text");
-  }
-  let out = trimmed;
-  if (out.length > 0 && /[A-Za-z0-9]$/.test(out)) {
-    out = `${out}.`;
-  }
-  if (out.length > 0 && /[a-z]/.test(out[0])) {
-    out = out[0].toUpperCase() + out.slice(1);
-  }
-  return out;
-}
-async function loadOrt() {
-  return await import("onnxruntime-node");
-}
-async function loadSentencePiece(tokenizerModelPath) {
-  const mod = await import("@sctg/sentencepiece-js");
-  const Processor = mod.SentencePieceProcessor ?? mod.default?.SentencePieceProcessor ?? mod.default;
-  if (!Processor) {
-    throw new Error("Failed to load SentencePiece processor from @sctg/sentencepiece-js");
-  }
-  const sp = new Processor();
-  if (typeof sp.load === "function") {
-    await sp.load(tokenizerModelPath);
-  } else if (typeof sp.Load === "function") {
-    sp.Load(tokenizerModelPath);
-  } else {
-    throw new Error("SentencePiece processor does not expose load()/Load()");
-  }
-  return sp;
-}
-function getOrtProviders(ort, device) {
-  if (device === "cpu") return ["cpu"];
-  if (device === "cuda") return ["cuda", "cpu"];
-  void ort;
-  return ["cpu"];
-}
-function createZeroTensorForInput(ort, session, inputName) {
-  const meta = getSessionInputMeta(session, inputName);
-  const dims = normalizeDims(meta?.dims ?? []);
-  if (dims.length === 0) {
-    throw new Error(`Missing input metadata shape for ${inputName}`);
-  }
-  const type = (meta?.type ?? "float32").toLowerCase();
-  const size = product(dims);
-  if (type.includes("int64")) {
-    return new ort.Tensor("int64", new BigInt64Array(size), dims);
-  }
-  if (type.includes("bool")) {
-    return new ort.Tensor("bool", new Uint8Array(size), dims);
-  }
-  return new ort.Tensor("float32", new Float32Array(size), dims);
-}
-function initState(session, ort) {
-  const out = {};
-  for (const name of session.inputNames) {
-    if (name.startsWith("state_")) {
-      out[name] = createZeroTensorForInput(ort, session, name);
-    }
-  }
-  return out;
-}
-function updateStateFromOutputs(state, outputs) {
-  for (const [name, tensor] of Object.entries(outputs)) {
-    if (!name.startsWith("out_state_")) continue;
-    const idx = Number.parseInt(name.replace("out_state_", ""), 10);
-    if (Number.isFinite(idx)) {
-      state[`state_${idx}`] = tensor;
-    }
-  }
-}
-function tensorDataFloat32(t) {
-  const data = t.data;
-  if (data instanceof Float32Array) return data;
-  if (Array.isArray(data)) return Float32Array.from(data);
-  throw new Error("Unexpected tensor data type (expected Float32Array)");
-}
-var PocketTtsOnnxEngine = class _PocketTtsOnnxEngine {
-  static {
-    this.SAMPLE_RATE = 24e3;
-  }
-  static {
-    this.SAMPLES_PER_FRAME = 1920;
-  }
-  constructor(args) {
-    this.ort = args.ort;
-    this.temperature = args.temperature;
-    this.lsdSteps = args.lsdSteps;
-    this.maxFrames = args.maxFrames;
-    this.framesAfterEos = args.framesAfterEos;
-    this.firstChunkFrames = args.firstChunkFrames;
-    this.maxChunkFrames = args.maxChunkFrames;
-    this.tokenizer = args.tokenizer;
-    this.textConditioner = args.textConditioner;
-    this.flowLmMain = args.flowLmMain;
-    this.flowLmFlow = args.flowLmFlow;
-    this.mimiDecoder = args.mimiDecoder;
-    this.stBuffers = args.stBuffers;
-    this.voiceEmbeddings = args.voiceEmbeddings;
-  }
-  static async create(config, logger) {
-    const log = logger.child({
-      module: "speech",
-      provider: "pocket-tts",
-      component: "onnx-engine"
-    });
-    const modelDir = config.modelDir;
-    const onnxDir = `${modelDir}/onnx`;
-    const precision = config.precision ?? "int8";
-    const device = config.device ?? "auto";
-    const temperature = config.temperature ?? 0.7;
-    const lsdSteps = config.lsdSteps ?? 10;
-    const maxFrames = config.maxFrames ?? 500;
-    const framesAfterEos = config.framesAfterEos ?? 3;
-    const firstChunkFrames = config.firstChunkFrames ?? 2;
-    const maxChunkFrames = config.maxChunkFrames ?? 15;
-    const tokenizerPath = `${modelDir}/tokenizer.model`;
-    const referenceAudioFile = config.referenceAudioFile ?? `${modelDir}/reference_sample.wav`;
-    const flowMainFile = precision === "int8" ? "flow_lm_main_int8.onnx" : "flow_lm_main.onnx";
-    const flowFlowFile = precision === "int8" ? "flow_lm_flow_int8.onnx" : "flow_lm_flow.onnx";
-    const decoderFile = precision === "int8" ? "mimi_decoder_int8.onnx" : "mimi_decoder.onnx";
-    assertFileExists(`${onnxDir}/mimi_encoder.onnx`, "PocketTTS mimi_encoder");
-    assertFileExists(`${onnxDir}/text_conditioner.onnx`, "PocketTTS text_conditioner");
-    assertFileExists(`${onnxDir}/${flowMainFile}`, "PocketTTS flow_lm_main");
-    assertFileExists(`${onnxDir}/${flowFlowFile}`, "PocketTTS flow_lm_flow");
-    assertFileExists(`${onnxDir}/${decoderFile}`, "PocketTTS mimi_decoder");
-    assertFileExists(tokenizerPath, "PocketTTS tokenizer.model");
-    assertFileExists(referenceAudioFile, "PocketTTS reference_sample.wav");
-    const ort = await loadOrt();
-    const providers = getOrtProviders(ort, device);
-    const [tokenizer, mimiEncoder, textConditioner, flowLmMain, flowLmFlow, mimiDecoder] = await Promise.all([
-      loadSentencePiece(tokenizerPath),
-      ort.InferenceSession.create(`${onnxDir}/mimi_encoder.onnx`, {
-        executionProviders: providers
-      }),
-      ort.InferenceSession.create(`${onnxDir}/text_conditioner.onnx`, {
-        executionProviders: providers
-      }),
-      ort.InferenceSession.create(`${onnxDir}/${flowMainFile}`, {
-        executionProviders: providers
-      }),
-      ort.InferenceSession.create(`${onnxDir}/${flowFlowFile}`, {
-        executionProviders: providers
-      }),
-      ort.InferenceSession.create(`${onnxDir}/${decoderFile}`, { executionProviders: providers })
-    ]);
-    const stBuffers = [];
-    for (let j = 0; j < lsdSteps; j += 1) {
-      const s = j / lsdSteps;
-      const t = s + 1 / lsdSteps;
-      stBuffers.push({
-        s: new ort.Tensor("float32", new Float32Array([s]), [1, 1]),
-        t: new ort.Tensor("float32", new Float32Array([t]), [1, 1])
-      });
-    }
-    const refWav = await readFile3(referenceAudioFile);
-    const parsed = parsePcm16MonoWav(refWav);
-    let pcm16 = parsed.pcm16;
-    if (parsed.sampleRate !== _PocketTtsOnnxEngine.SAMPLE_RATE) {
-      const resampler = new Pcm16MonoResampler({
-        inputRate: parsed.sampleRate,
-        outputRate: _PocketTtsOnnxEngine.SAMPLE_RATE
-      });
-      pcm16 = resampler.processChunk(pcm16);
-    }
-    const floatAudio = pcm16leToFloat32(pcm16);
-    const audioTensor = new ort.Tensor("float32", floatAudio, [1, 1, floatAudio.length]);
-    const encoded = await mimiEncoder.run({ audio: audioTensor });
-    const firstOutName = mimiEncoder.outputNames?.[0];
-    const voiceEmb = firstOutName ? encoded[firstOutName] : Object.values(encoded)[0];
-    if (!voiceEmb) {
-      throw new Error("PocketTTS mimi_encoder: missing output");
-    }
-    log.info({ precision, device, providers, lsdSteps, temperature }, "PocketTTS ONNX initialized");
-    return new _PocketTtsOnnxEngine({
-      ort,
-      temperature,
-      lsdSteps,
-      maxFrames,
-      framesAfterEos,
-      firstChunkFrames,
-      maxChunkFrames,
-      tokenizer,
-      textConditioner,
-      flowLmMain,
-      flowLmFlow,
-      mimiDecoder,
-      stBuffers,
-      voiceEmbeddings: voiceEmb
-    });
-  }
-  tokenize(text) {
-    const normalized = normalizeTextForPocket(text);
-    const ids = this.tokenizer.encodeIds(normalized);
-    const data = toBigInt64(ids ?? []);
-    return new this.ort.Tensor("int64", data, [1, data.length]);
-  }
-  async runTextConditioner(tokenIds) {
-    const out = await this.textConditioner.run({ token_ids: tokenIds });
-    const firstOutName = this.textConditioner.outputNames?.[0];
-    const t = firstOutName ? out[firstOutName] : Object.values(out)[0];
-    if (!t) throw new Error("PocketTTS text_conditioner: missing output");
-    return t;
-  }
-  async *runFlowLm(textEmbeddings) {
-    const ort = this.ort;
-    const state = initState(this.flowLmMain, ort);
-    const emptySeq = new ort.Tensor("float32", new Float32Array(0), [1, 0, 32]);
-    const emptyText = new ort.Tensor("float32", new Float32Array(0), [1, 0, 1024]);
-    const resVoice = await this.flowLmMain.run({
-      sequence: emptySeq,
-      text_embeddings: this.voiceEmbeddings,
-      ...state
-    });
-    updateStateFromOutputs(state, resVoice);
-    const resText = await this.flowLmMain.run({
-      sequence: emptySeq,
-      text_embeddings: textEmbeddings,
-      ...state
-    });
-    updateStateFromOutputs(state, resText);
-    const curr = new Float32Array(32);
-    curr.fill(Number.NaN);
-    let currTensor = new ort.Tensor("float32", curr, [1, 1, 32]);
-    const dt = 1 / this.lsdSteps;
-    let eosStep = null;
-    for (let step = 0; step < this.maxFrames; step += 1) {
-      const resStep = await this.flowLmMain.run({
-        sequence: currTensor,
-        text_embeddings: emptyText,
-        ...state
-      });
-      const outputNames = this.flowLmMain.outputNames;
-      const conditioningName = outputNames?.[0] ?? Object.keys(resStep)[0];
-      const eosName = outputNames?.[1] ?? Object.keys(resStep)[1];
-      const conditioning = resStep[conditioningName];
-      const eos = resStep[eosName];
-      if (!conditioning || !eos) {
-        throw new Error("PocketTTS flow_lm_main: missing conditioning/EOS outputs");
-      }
-      updateStateFromOutputs(state, resStep);
-      const eosData = tensorDataFloat32(eos);
-      if (eosData[0] > -4 && eosStep === null) {
-        eosStep = step;
-      }
-      if (eosStep !== null && step >= eosStep + this.framesAfterEos) {
-        break;
-      }
-      const std = this.temperature > 0 ? Math.sqrt(this.temperature) : 0;
-      const x = new Float32Array(32);
-      if (std > 0) {
-        for (let i = 0; i < x.length; i += 1) {
-          x[i] = randn() * std;
-        }
-      }
-      for (const st of this.stBuffers) {
-        const xTensor = new ort.Tensor("float32", x, [1, 32]);
-        const flowOut = await this.flowLmFlow.run({
-          c: conditioning,
-          s: st.s,
-          t: st.t,
-          x: xTensor
-        });
-        const first = this.flowLmFlow.outputNames?.[0];
-        const flowTensor = first ? flowOut[first] : Object.values(flowOut)[0];
-        if (!flowTensor) throw new Error("PocketTTS flow_lm_flow: missing output");
-        const delta = tensorDataFloat32(flowTensor);
-        for (let i = 0; i < x.length; i += 1) {
-          x[i] = x[i] + delta[i] * dt;
-        }
-      }
-      yield x;
-      currTensor = new ort.Tensor("float32", x, [1, 1, 32]);
-    }
-  }
-  async decodeLatentsChunk(frames, state) {
-    const ort = this.ort;
-    const frameCount = frames.length;
-    const flattened = new Float32Array(frameCount * 32);
-    for (let i = 0; i < frameCount; i += 1) {
-      flattened.set(frames[i], i * 32);
-    }
-    const latent = new ort.Tensor("float32", flattened, [1, frameCount, 32]);
-    const out = await this.mimiDecoder.run({ latent, ...state });
-    updateStateFromOutputs(state, out);
-    const firstOutName = this.mimiDecoder.outputNames?.[0];
-    const audioTensor = firstOutName ? out[firstOutName] : Object.values(out)[0];
-    if (!audioTensor) {
-      throw new Error("PocketTTS mimi_decoder: missing audio output");
-    }
-    return tensorDataFloat32(audioTensor);
-  }
-  async *streamAudio(text) {
-    const tokenIds = this.tokenize(text);
-    const textEmb = await this.runTextConditioner(tokenIds);
-    const decoderState = initState(this.mimiDecoder, this.ort);
-    const generated = [];
-    let decodedFrames = 0;
-    for await (const latent of this.runFlowLm(textEmb)) {
-      generated.push(latent);
-      const pending = generated.length - decodedFrames;
-      let chunkSize = 0;
-      if (decodedFrames === 0) {
-        if (pending >= this.firstChunkFrames) {
-          chunkSize = this.firstChunkFrames;
-        }
-      } else if (pending >= this.maxChunkFrames) {
-        chunkSize = this.maxChunkFrames;
-      }
-      if (chunkSize > 0) {
-        const audio = await this.decodeLatentsChunk(
-          generated.slice(decodedFrames, decodedFrames + chunkSize),
-          decoderState
-        );
-        decodedFrames += chunkSize;
-        yield audio;
-      }
-    }
-    if (decodedFrames < generated.length) {
-      const audio = await this.decodeLatentsChunk(generated.slice(decodedFrames), decoderState);
-      yield audio;
-    }
-  }
-};
-var PocketTtsOnnxTTS = class _PocketTtsOnnxTTS {
-  constructor(engine, logger, chunkMs) {
-    this.engine = engine;
-    this.chunkMs = chunkMs;
-    this.logger = logger.child({ module: "speech", provider: "pocket-tts", component: "tts" });
-  }
-  static async create(config, logger) {
-    const engine = await PocketTtsOnnxEngine.create(config, logger);
-    const chunkMs = config.targetChunkMs ?? 50;
-    return new _PocketTtsOnnxTTS(engine, logger, chunkMs);
-  }
-  async synthesizeSpeech(text) {
-    const start = Date.now();
-    const sampleRate = PocketTtsOnnxEngine.SAMPLE_RATE;
-    const pcmChunkBytes = Math.max(2, Math.round(sampleRate * this.chunkMs / 1e3) * 2);
-    const iterable = (async function* (engine) {
-      for await (const floatChunk of engine.streamAudio(text)) {
-        const pcm = float32ToPcm16le(floatChunk);
-        for (const chunk of chunkBuffer(pcm, pcmChunkBytes)) {
-          yield chunk;
-        }
-      }
-    })(this.engine);
-    this.logger.debug(
-      { ms: Date.now() - start, textLength: text.length },
-      "PocketTTS stream ready"
-    );
-    return {
-      stream: Readable3.from(iterable),
-      format: `pcm;rate=${sampleRate}`
-    };
-  }
-};
-
 // ../server/src/server/speech/providers/local/sherpa/sherpa-offline-recognizer.ts
-import { existsSync as existsSync14 } from "node:fs";
+import { existsSync as existsSync13 } from "node:fs";
 
 // ../server/src/server/speech/providers/local/sherpa/sherpa-onnx-node-loader.ts
 import { createRequire as createRequire4 } from "node:module";
 import path18 from "node:path";
-import { existsSync as existsSync13 } from "node:fs";
+import { existsSync as existsSync12 } from "node:fs";
 import { spawnSync } from "node:child_process";
 
 // ../server/src/server/speech/providers/local/sherpa/sherpa-runtime-env.ts
@@ -44147,7 +43693,7 @@ function loadSherpaOnnxNode() {
   if (platformPkgDir) {
     applySherpaLoaderEnv(process.env);
     const addonPath = path18.join(platformPkgDir, "sherpa-onnx.node");
-    if (existsSync13(addonPath)) {
+    if (existsSync12(addonPath)) {
       const byPath = loadWithRequire(require4, addonPath, attempts);
       if (byPath) {
         cached = byPath;
@@ -44165,8 +43711,8 @@ function loadSherpaOnnxNode() {
 }
 
 // ../server/src/server/speech/providers/local/sherpa/sherpa-offline-recognizer.ts
-function assertFileExists2(filePath, label) {
-  if (!existsSync14(filePath)) {
+function assertFileExists(filePath, label) {
+  if (!existsSync13(filePath)) {
     throw new Error(`Missing ${label}: ${filePath}`);
   }
 }
@@ -44177,10 +43723,10 @@ var SherpaOfflineRecognizerEngine = class {
       provider: "local",
       component: "offline-recognizer"
     });
-    assertFileExists2(config.model.encoder, "offline encoder");
-    assertFileExists2(config.model.decoder, "offline decoder");
-    assertFileExists2(config.model.joiner, "offline joiner");
-    assertFileExists2(config.model.tokens, "tokens");
+    assertFileExists(config.model.encoder, "offline encoder");
+    assertFileExists(config.model.decoder, "offline decoder");
+    assertFileExists(config.model.joiner, "offline joiner");
+    assertFileExists(config.model.tokens, "tokens");
     const sherpa = loadSherpaOnnxNode();
     const recognizerConfig = {
       featConfig: {
@@ -44233,7 +43779,7 @@ var SherpaOfflineRecognizerEngine = class {
 };
 
 // ../server/src/server/speech/providers/local/sherpa/sherpa-online-recognizer.ts
-import { existsSync as existsSync15 } from "node:fs";
+import { existsSync as existsSync14 } from "node:fs";
 
 // ../server/src/server/speech/providers/local/sherpa/sherpa-onnx-loader.ts
 import { createRequire as createRequire5 } from "node:module";
@@ -44248,8 +43794,8 @@ function loadSherpaOnnx() {
 }
 
 // ../server/src/server/speech/providers/local/sherpa/sherpa-online-recognizer.ts
-function assertFileExists3(filePath, label) {
-  if (!existsSync15(filePath)) {
+function assertFileExists2(filePath, label) {
+  if (!existsSync14(filePath)) {
     throw new Error(`Missing ${label}: ${filePath}`);
   }
 }
@@ -44262,14 +43808,14 @@ var SherpaOnlineRecognizerEngine = class {
     });
     const { model } = config;
     if (model.kind === "transducer") {
-      assertFileExists3(model.encoder, "transducer encoder");
-      assertFileExists3(model.decoder, "transducer decoder");
-      assertFileExists3(model.joiner, "transducer joiner");
-      assertFileExists3(model.tokens, "tokens");
+      assertFileExists2(model.encoder, "transducer encoder");
+      assertFileExists2(model.decoder, "transducer decoder");
+      assertFileExists2(model.joiner, "transducer joiner");
+      assertFileExists2(model.tokens, "tokens");
     } else {
-      assertFileExists3(model.encoder, "paraformer encoder");
-      assertFileExists3(model.decoder, "paraformer decoder");
-      assertFileExists3(model.tokens, "tokens");
+      assertFileExists2(model.encoder, "paraformer encoder");
+      assertFileExists2(model.decoder, "paraformer decoder");
+      assertFileExists2(model.tokens, "tokens");
     }
     const sherpa = loadSherpaOnnx();
     const modelConfig = model.kind === "transducer" ? {
@@ -44824,10 +44370,10 @@ var SherpaOnnxSTT = class {
 };
 
 // ../server/src/server/speech/providers/local/sherpa/sherpa-tts.ts
-import { Readable as Readable4 } from "node:stream";
-import { existsSync as existsSync16 } from "node:fs";
-function assertFileExists4(filePath, label) {
-  if (!existsSync16(filePath)) {
+import { Readable as Readable3 } from "node:stream";
+import { existsSync as existsSync15 } from "node:fs";
+function assertFileExists3(filePath, label) {
+  if (!existsSync15(filePath)) {
     throw new Error(`Missing ${label}: ${filePath}`);
   }
 }
@@ -44848,10 +44394,10 @@ var SherpaOnnxTTS = class {
     const voicesPath = `${config.modelDir}/voices.bin`;
     const tokensPath = `${config.modelDir}/tokens.txt`;
     const dataDir = `${config.modelDir}/espeak-ng-data`;
-    assertFileExists4(modelPath, "TTS model");
-    assertFileExists4(voicesPath, "TTS voices");
-    assertFileExists4(tokensPath, "TTS tokens");
-    assertFileExists4(dataDir, "TTS espeak-ng dataDir");
+    assertFileExists3(modelPath, "TTS model");
+    assertFileExists3(voicesPath, "TTS voices");
+    assertFileExists3(tokensPath, "TTS tokens");
+    assertFileExists3(dataDir, "TTS espeak-ng dataDir");
     const modelConfig = config.preset === "kokoro-en-v0_19" ? {
       kokoro: {
         model: modelPath,
@@ -44904,7 +44450,7 @@ var SherpaOnnxTTS = class {
     const chunkBytes = Math.max(2, Math.round(sampleRate * 0.05) * 2);
     const chunks = chunkBuffer(pcm16, chunkBytes);
     return {
-      stream: Readable4.from(chunks),
+      stream: Readable3.from(chunks),
       format: `pcm;rate=${sampleRate}`
     };
   }
@@ -45350,20 +44896,7 @@ async function initializeLocalSpeechServices(params) {
       );
     } else {
       try {
-        if (localModels.voiceLocalTtsModel === "pocket-tts-onnx-int8") {
-          const modelDir = getLocalSpeechModelDir(
-            localConfig.modelsDir,
-            localModels.voiceLocalTtsModel
-          );
-          localVoiceTtsProvider = await PocketTtsOnnxTTS.create(
-            {
-              modelDir,
-              precision: "int8",
-              targetChunkMs: 50
-            },
-            logger
-          );
-        } else {
+        {
           const modelDir = getLocalSpeechModelDir(
             localConfig.modelsDir,
             localModels.voiceLocalTtsModel
@@ -46548,7 +46081,7 @@ import { z as z33 } from "zod";
 import { getSessionMessages } from "@anthropic-ai/claude-agent-sdk";
 
 // ../server/src/server/agent/session-fork.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync7, readdirSync, existsSync as existsSync17 } from "node:fs";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync7, readdirSync, existsSync as existsSync16 } from "node:fs";
 import { dirname as dirname6, join as join12 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 var ForkPointInvalidError = class extends Error {
@@ -46570,11 +46103,11 @@ function jsonLineIsToolResultUser(json) {
 function findClaudeSessionFile(params) {
   const home = params.claudeHomeDir ?? join12(homedir5(), ".claude");
   const projectsDir = join12(home, "projects");
-  if (!existsSync17(projectsDir)) return null;
+  if (!existsSync16(projectsDir)) return null;
   for (const entry of readdirSync(projectsDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
     const candidate = join12(projectsDir, entry.name, `${params.sessionId}.jsonl`);
-    if (existsSync17(candidate)) return candidate;
+    if (existsSync16(candidate)) return candidate;
   }
   return null;
 }
@@ -46626,7 +46159,7 @@ function forkSession(input) {
   const lastCopiedIndex = nextUserLineIndex === -1 ? lines.length - 1 : nextUserLineIndex - 1;
   const copied = lines.slice(0, lastCopiedIndex + 1).filter((l) => l.length > 0);
   const targetDir = dirname6(input.targetSessionPath);
-  if (!existsSync17(targetDir)) {
+  if (!existsSync16(targetDir)) {
     throw new Error(`Target directory does not exist: ${targetDir}`);
   }
   writeFileSync7(input.targetSessionPath, copied.join("\n") + "\n", "utf-8");
@@ -52008,7 +51541,7 @@ import { join as join15 } from "node:path";
 
 // ../server/src/server/schedule/store.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { mkdir as mkdir6, readFile as readFile4, readdir as readdir4, rm as rm3, writeFile as writeFile5 } from "node:fs/promises";
+import { mkdir as mkdir6, readFile as readFile3, readdir as readdir4, rm as rm3, writeFile as writeFile5 } from "node:fs/promises";
 import { join as join14 } from "node:path";
 function generateScheduleId() {
   return randomBytes2(4).toString("hex");
@@ -52028,7 +51561,7 @@ var ScheduleStore = class {
     const entries = await readdir4(this.dir, { withFileTypes: true });
     const schedules = await Promise.all(
       entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map(async (entry) => {
-        const content = await readFile4(join14(this.dir, entry.name), "utf-8");
+        const content = await readFile3(join14(this.dir, entry.name), "utf-8");
         return StoredScheduleSchema.parse(JSON.parse(content));
       })
     );
@@ -52037,7 +51570,7 @@ var ScheduleStore = class {
   async get(id) {
     await this.ensureDir();
     try {
-      const content = await readFile4(this.filePath(id), "utf-8");
+      const content = await readFile3(this.filePath(id), "utf-8");
       return StoredScheduleSchema.parse(JSON.parse(content));
     } catch (error) {
       if (error.code === "ENOENT") {
@@ -52647,7 +52180,7 @@ function mergeMutableConfigIntoPersistedConfig(params) {
 
 // ../server/src/server/workspace-git-service.ts
 import { watch } from "node:fs";
-import { readFile as readFile5, readdir as readdir5 } from "node:fs/promises";
+import { readFile as readFile4, readdir as readdir5 } from "node:fs/promises";
 import { join as join16, resolve as resolve12 } from "node:path";
 var WORKSPACE_GIT_WATCH_DEBOUNCE_MS = 500;
 var BACKGROUND_GIT_FETCH_INTERVAL_MS = 18e4;
@@ -52877,7 +52410,7 @@ var WorkspaceGitServiceImpl = class {
   }
   async resolveWorkspaceGitRefsRoot(gitDir) {
     try {
-      const commonDir = (await readFile5(join16(gitDir, "commondir"), "utf8")).trim();
+      const commonDir = (await readFile4(join16(gitDir, "commondir"), "utf8")).trim();
       if (commonDir.length > 0) {
         return resolve12(gitDir, commonDir);
       }
@@ -54103,7 +53636,7 @@ function createAuthServerClient(options) {
 }
 
 // ../server/src/server/package-version.ts
-import { existsSync as existsSync18, readFileSync as readFileSync9 } from "node:fs";
+import { existsSync as existsSync17, readFileSync as readFileSync9 } from "node:fs";
 import path23 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var PackageVersionResolutionError = class extends Error {
@@ -54117,7 +53650,7 @@ function resolvePackageVersion(params) {
   let currentDir = path23.dirname(fileURLToPath3(moduleUrl));
   while (true) {
     const packageJsonPath = path23.join(currentDir, "package.json");
-    if (existsSync18(packageJsonPath)) {
+    if (existsSync17(packageJsonPath)) {
       try {
         const packageJson = JSON.parse(readFileSync9(packageJsonPath, "utf8"));
         if (packageJson.name === params.packageName) {
@@ -54974,7 +54507,7 @@ async function createAppostleDaemon(config, rootLogger) {
         if (listenTarget.type === "tcp") {
           httpServer.listen(listenTarget.port, listenTarget.host);
         } else {
-          if (listenTarget.type === "socket" && existsSync19(listenTarget.path)) {
+          if (listenTarget.type === "socket" && existsSync18(listenTarget.path)) {
             unlinkSync(listenTarget.path);
           }
           httpServer.listen(listenTarget.path);
@@ -55004,7 +54537,7 @@ async function createAppostleDaemon(config, rootLogger) {
       await new Promise((resolve14) => {
         httpServer.close(() => resolve14());
       });
-      if (listenTarget.type === "socket" && existsSync19(listenTarget.path)) {
+      if (listenTarget.type === "socket" && existsSync18(listenTarget.path)) {
         unlinkSync(listenTarget.path);
       }
     };
@@ -55343,7 +54876,7 @@ function loadConfig(appostleHome, options) {
 }
 
 // ../server/src/server/logger.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync7, readdirSync as readdirSync2, renameSync as renameSync3, unlinkSync as unlinkSync2 } from "node:fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync7, readdirSync as readdirSync2, renameSync as renameSync3, unlinkSync as unlinkSync2 } from "node:fs";
 import path27 from "node:path";
 import pino from "pino";
 import pretty from "pino-pretty";
@@ -55430,7 +54963,7 @@ function normalizeLoggerConfigInput(config) {
   return config;
 }
 function rotateOnRestart(filePath, maxFiles) {
-  if (!existsSync20(filePath)) return;
+  if (!existsSync19(filePath)) return;
   const dir = path27.dirname(filePath);
   const base = path27.basename(filePath);
   const now = /* @__PURE__ */ new Date();
@@ -55515,8 +55048,8 @@ function createRootLogger(configInput, options) {
 }
 
 // ../server/src/server/pid-lock.ts
-import { open, readFile as readFile6, unlink as unlink2, mkdir as mkdir7 } from "node:fs/promises";
-import { existsSync as existsSync21 } from "node:fs";
+import { open, readFile as readFile5, unlink as unlink2, mkdir as mkdir7 } from "node:fs/promises";
+import { existsSync as existsSync20 } from "node:fs";
 import { join as join17 } from "node:path";
 import { hostname } from "node:os";
 var PidLockError = class extends Error {
@@ -55545,12 +55078,12 @@ function resolveOwnerPid(ownerPid) {
 }
 async function acquirePidLock(appostleHome, listen, options) {
   const pidPath = getPidFilePath(appostleHome);
-  if (!existsSync21(appostleHome)) {
+  if (!existsSync20(appostleHome)) {
     await mkdir7(appostleHome, { recursive: true });
   }
   let existingLock = null;
   try {
-    const content = await readFile6(pidPath, "utf-8");
+    const content = await readFile5(pidPath, "utf-8");
     existingLock = JSON.parse(content);
   } catch {
   }
@@ -55583,7 +55116,7 @@ async function acquirePidLock(appostleHome, listen, options) {
   } catch (err) {
     if (err.code === "EEXIST") {
       try {
-        const content = await readFile6(pidPath, "utf-8");
+        const content = await readFile5(pidPath, "utf-8");
         const raceLock = JSON.parse(content);
         throw new PidLockError(
           `Another Appostle daemon is already running (PID ${raceLock.pid})`,
@@ -55602,7 +55135,7 @@ async function acquirePidLock(appostleHome, listen, options) {
 async function updatePidLock(appostleHome, patch, options) {
   const pidPath = getPidFilePath(appostleHome);
   const lockOwnerPid = resolveOwnerPid(options?.ownerPid);
-  const content = await readFile6(pidPath, "utf-8");
+  const content = await readFile5(pidPath, "utf-8");
   const existingLock = JSON.parse(content);
   if (existingLock.pid !== lockOwnerPid) {
     throw new PidLockError(`Cannot update PID lock owned by PID ${existingLock.pid}`, existingLock);
@@ -55623,7 +55156,7 @@ async function releasePidLock(appostleHome, options) {
   const pidPath = getPidFilePath(appostleHome);
   const lockOwnerPid = resolveOwnerPid(options?.ownerPid);
   try {
-    const content = await readFile6(pidPath, "utf-8");
+    const content = await readFile5(pidPath, "utf-8");
     const lock = JSON.parse(content);
     if (lock.pid === lockOwnerPid) {
       await unlink2(pidPath);