agentar 0.1.0

package/dist/agentar.js

@@ -0,0 +1,1967 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// packages/core/src/visemes.ts
+function isViseme(value) {
+  return VISEMES.includes(value);
+}
+var VISEMES;
+var init_visemes = __esm({
+  "packages/core/src/visemes.ts"() {
+    "use strict";
+    VISEMES = [
+      "sil",
+      // silence / neutral
+      "PP",
+      // p, b, m
+      "FF",
+      // f, v
+      "TH",
+      // th
+      "DD",
+      // t, d
+      "kk",
+      // k, g
+      "CH",
+      // ch, j, sh
+      "SS",
+      // s, z
+      "nn",
+      // n, l
+      "RR",
+      // r
+      "aa",
+      // a (father)
+      "E",
+      // e (bed)
+      "I",
+      // i (tip, see)
+      "O",
+      // o (toe)
+      "U"
+      // u (book, boot)
+    ];
+  }
+});
+
+// packages/core/src/moods.ts
+function isMood(v) {
+  return typeof v === "string" && MOODS.includes(v);
+}
+var MOODS;
+var init_moods = __esm({
+  "packages/core/src/moods.ts"() {
+    "use strict";
+    MOODS = ["neutral", "happy", "thinking", "surprised", "concerned", "amused"];
+  }
+});
+
+// packages/core/src/config.ts
+function color(v, fallback) {
+  return typeof v === "string" && HEX_RE.test(v) ? v.toLowerCase() : fallback;
+}
+function colorOverride(v, fallback) {
+  if (v === null) return null;
+  return typeof v === "string" && HEX_RE.test(v) ? v.toLowerCase() : fallback;
+}
+function oneOf(v, allowed, fallback) {
+  return typeof v === "string" && allowed.includes(v) ? v : fallback;
+}
+function num(v, min, max, fallback) {
+  return typeof v === "number" && Number.isFinite(v) ? Math.min(max, Math.max(min, v)) : fallback;
+}
+function str(v, maxLen, fallback) {
+  return typeof v === "string" ? v.slice(0, maxLen) : fallback;
+}
+function bool(v, fallback) {
+  return typeof v === "boolean" ? v : fallback;
+}
+function model(v, fallback) {
+  if (!isDict(v)) return fallback;
+  if (v.source === "builtin" && typeof v.id === "string" && BUILTIN_MODELS.some((m) => m.id === v.id)) {
+    return { source: "builtin", id: v.id };
+  }
+  if (v.source === "url" && typeof v.url === "string" && isAllowedModelUrl(v.url)) {
+    const format = v.format === "vrm" || v.format === "glb" ? v.format : void 0;
+    return format ? { source: "url", url: v.url, format } : { source: "url", url: v.url };
+  }
+  return fallback;
+}
+function isAllowedModelUrl(url) {
+  if (url.startsWith("/models/")) return !url.includes("..");
+  return /^https?:\/\/[^\s/?#]+[^\s]*$/i.test(url);
+}
+function mergeConfig(base, patch) {
+  const p = isDict(patch) ? patch : {};
+  const a = isDict(p.appearance) ? p.appearance : {};
+  const v = isDict(p.voice) ? p.voice : {};
+  const b = isDict(p.behavior) ? p.behavior : {};
+  const s = isDict(p.scene) ? p.scene : {};
+  const A = base.appearance;
+  const V = base.voice;
+  const B = base.behavior;
+  const S = base.scene;
+  return {
+    version: 1,
+    name: str(p.name, 64, base.name).trim() || base.name,
+    model: model(p.model, base.model),
+    appearance: {
+      skin: "skin" in a ? colorOverride(a.skin, A.skin) : A.skin,
+      hair: "hair" in a ? colorOverride(a.hair, A.hair) : A.hair,
+      eyes: "eyes" in a ? colorOverride(a.eyes, A.eyes) : A.eyes,
+      top: "top" in a ? colorOverride(a.top, A.top) : A.top,
+      bottom: "bottom" in a ? colorOverride(a.bottom, A.bottom) : A.bottom,
+      shoes: "shoes" in a ? colorOverride(a.shoes, A.shoes) : A.shoes,
+      glasses: oneOf(a.glasses, GLASSES, A.glasses),
+      hat: oneOf(a.hat, HATS, A.hat),
+      accessoryColor: color(a.accessoryColor, A.accessoryColor),
+      height: num(a.height, 0.85, 1.15, A.height)
+    },
+    voice: {
+      provider: oneOf(v.provider, VOICE_PROVIDERS, V.provider),
+      voice: str(v.voice, 128, V.voice),
+      rate: num(v.rate, 0.5, 2, V.rate),
+      pitch: num(v.pitch, 0.5, 2, V.pitch),
+      volume: num(v.volume, 0, 1, V.volume)
+    },
+    behavior: {
+      mood: oneOf(b.mood, MOODS, B.mood),
+      expressiveness: num(b.expressiveness, 0, 1, B.expressiveness),
+      idleMotion: num(b.idleMotion, 0, 1, B.idleMotion),
+      eyeContact: num(b.eyeContact, 0, 1, B.eyeContact)
+    },
+    scene: {
+      background: color(s.background, S.background),
+      framing: oneOf(s.framing, FRAMINGS, S.framing),
+      lighting: oneOf(s.lighting, LIGHTINGS, S.lighting),
+      showFloor: bool(s.showFloor, S.showFloor)
+    }
+  };
+}
+function resolveConfig(input) {
+  return mergeConfig(DEFAULT_CONFIG, input);
+}
+var GLASSES, HATS, VOICE_PROVIDERS, FRAMINGS, LIGHTINGS, BUILTIN_MODELS, DEFAULT_CONFIG, isDict, HEX_RE;
+var init_config = __esm({
+  "packages/core/src/config.ts"() {
+    "use strict";
+    init_moods();
+    GLASSES = ["none", "model", "round", "square"];
+    HATS = ["none", "beanie", "cap"];
+    VOICE_PROVIDERS = ["system", "browser", "edge", "openai", "elevenlabs", "xai"];
+    FRAMINGS = ["head", "bust", "full"];
+    LIGHTINGS = ["studio", "warm", "cool", "dramatic"];
+    BUILTIN_MODELS = [
+      {
+        id: "mpfb",
+        label: "Alex (MPFB, CC0)",
+        file: "mpfb.glb",
+        license: "CC0-1.0",
+        attribution: "Created with Blender + MPFB (MakeHuman). Distributed with TalkingHead.",
+        slots: {
+          "Human.body": "skin",
+          "Human.female_casualsuit01": "top",
+          "Human.ponytail01": "hair",
+          "Human.mindfront_eyebrows_02": "hair",
+          "Human.high-poly": "eyes"
+        }
+      },
+      {
+        id: "avaturn",
+        label: "Avaturn sample (non-commercial)",
+        file: "avaturn.glb",
+        license: "Non-commercial use",
+        attribution: "Created at avaturn.me. Distributed with TalkingHead.",
+        slots: {
+          Body: "skin",
+          Head: "skin",
+          Eyes: "eyes",
+          avaturn_hair_0_material: "hair",
+          avaturn_hair_1_material: "hair",
+          avaturn_look_0_material: "top",
+          avaturn_shoes_0_material: "shoes"
+        }
+      },
+      {
+        id: "brunette",
+        label: "Brunette (Ready Player Me, CC BY-NC 4.0)",
+        file: "brunette.glb",
+        license: "CC-BY-NC-4.0",
+        attribution: "Created at Ready Player Me. Distributed with TalkingHead.",
+        slots: {
+          Wolf3D_Skin: "skin",
+          Wolf3D_Body: "skin",
+          Wolf3D_Hair: "hair",
+          Wolf3D_Eye: "eyes",
+          Wolf3D_Outfit_Top: "top",
+          Wolf3D_Outfit_Bottom: "bottom",
+          Wolf3D_Outfit_Footwear: "shoes",
+          Wolf3D_Glasses: "eyewear"
+        }
+      },
+      {
+        id: "avatarsdk",
+        label: "AvatarSDK sample (non-commercial)",
+        file: "avatarsdk.glb",
+        license: "Non-commercial use",
+        attribution: "Created at avatarsdk.com. Distributed with TalkingHead."
+      }
+    ];
+    DEFAULT_CONFIG = {
+      version: 1,
+      name: "Agentar",
+      model: { source: "builtin", id: "mpfb" },
+      appearance: {
+        skin: null,
+        hair: null,
+        eyes: null,
+        top: null,
+        bottom: null,
+        shoes: null,
+        glasses: "none",
+        hat: "none",
+        accessoryColor: "#222222",
+        height: 1
+      },
+      voice: { provider: "system", voice: "", rate: 1, pitch: 1, volume: 1 },
+      behavior: { mood: "neutral", expressiveness: 0.7, idleMotion: 0.6, eyeContact: 0.8 },
+      scene: { background: "#1b1f27", framing: "bust", lighting: "studio", showFloor: false }
+    };
+    isDict = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+    HEX_RE = /^#[0-9a-fA-F]{6}$/;
+  }
+});
+
+// packages/core/src/protocol.ts
+var DEFAULT_PORT, PROTOCOL_VERSION, GESTURES;
+var init_protocol = __esm({
+  "packages/core/src/protocol.ts"() {
+    "use strict";
+    DEFAULT_PORT = 7777;
+    PROTOCOL_VERSION = 1;
+    GESTURES = [
+      "nod",
+      "shake",
+      "tilt",
+      "wave",
+      "high-five",
+      "thumbs-up",
+      "thumbs-down",
+      "idea",
+      "shrug",
+      "namaste",
+      "wink",
+      "laugh",
+      "surprised",
+      "bow"
+    ];
+  }
+});
+
+// packages/core/src/speakable.ts
+function toSpeakable(markdown, opts = {}) {
+  const maxChars = opts.maxChars ?? 600;
+  let s = markdown.replace(/\r\n/g, "\n");
+  let codeBlocks = 0;
+  s = s.replace(/```[\s\S]*?(```|$)/g, () => {
+    codeBlocks++;
+    return "\n";
+  });
+  s = s.replace(/^\s*\|?\s*:?-{3,}.*$/gm, "").replace(/\|/g, ", ").replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/\[([^\]]+)\]\([^)]*\)/g, "$1").replace(/<?https?:\/\/[^\s>)]+>?/g, "a link").replace(/`([^`]+)`/g, "$1").replace(/^\s{0,3}#{1,6}\s+(.*)$/gm, "$1.").replace(/^\s*>\s?/gm, "").replace(/^\s*(?:[-*+]|\d+[.)])\s+(.*)$/gm, "$1.").replace(/(\*\*|__)(.*?)\1/g, "$2").replace(/(^|\W)[*_](\S[^*_]*)[*_](?=\W|$)/g, "$1$2").replace(/<[^>]+>/g, "").replace(/(?:[\w.-]+\/)+([\w.-]+\.\w+)(?::\d+)?/g, "$1").replace(/\.{2,}\s*$/gm, ".").replace(/([.!?])\.+/g, "$1").replace(/[ \t]+/g, " ").replace(/\n{2,}/g, "\n").split("\n").map((l) => l.trim()).filter(Boolean).join(" ").trim();
+  if (codeBlocks > 0) {
+    const note = codeBlocks === 1 ? "I've included a code snippet." : `I've included ${codeBlocks} code snippets.`;
+    s = s ? `${s} ${note}` : note;
+  }
+  if (s.length > maxChars) {
+    const cut = s.slice(0, maxChars);
+    const lastStop = Math.max(cut.lastIndexOf(". "), cut.lastIndexOf("! "), cut.lastIndexOf("? "));
+    s = (lastStop > maxChars * 0.4 ? cut.slice(0, lastStop + 1) : cut.replace(/\s+\S*$/, "") + "\u2026").trim();
+    s += " The full details are in the chat.";
+  }
+  return s;
+}
+var init_speakable = __esm({
+  "packages/core/src/speakable.ts"() {
+    "use strict";
+  }
+});
+
+// packages/core/src/lipsync/english.ts
+function compile(rule) {
+  const posL = rule.indexOf("[");
+  const posR = rule.indexOf("]");
+  const posE = rule.indexOf("=");
+  const left = rule.substring(0, posL);
+  const letters = [...rule.substring(posL + 1, posR)];
+  const right = rule.substring(posR + 1, posE);
+  const out = rule.substring(posE + 1);
+  letters[0] = letters[0].toLowerCase();
+  const exp = [...left].map((c) => OPS[c] ?? c).join("") + letters.join("") + [...right].map((c) => OPS[c] ?? c).join("");
+  return {
+    regex: new RegExp(exp),
+    move: letters.length,
+    visemes: out.length ? out.split(" ").filter(isViseme) : []
+  };
+}
+var RULES, OPS, COMPILED;
+var init_english = __esm({
+  "packages/core/src/lipsync/english.ts"() {
+    "use strict";
+    init_visemes();
+    RULES = {
+      A: [
+        "[A] =aa",
+        " [ARE] =aa RR",
+        " [AR]O=aa RR",
+        "[AR]#=E RR",
+        " ^[AS]#=E SS",
+        "[A]WA=aa",
+        "[AW]=aa",
+        " :[ANY]=E nn I",
+        "[A]^+#=E",
+        "#:[ALLY]=aa nn I",
+        " [AL]#=aa nn",
+        "[AGAIN]=aa kk E nn",
+        "#:[AG]E=I kk",
+        "[A]^+:#=aa",
+        ":[A]^+ =E",
+        "[A]^%=E",
+        " [ARR]=aa RR",
+        "[ARR]=aa RR",
+        " :[AR] =aa RR",
+        "[AR] =E",
+        "[AR]=aa RR",
+        "[AIR]=E RR",
+        "[AI]=E",
+        "[AY]=E",
+        "[AU]=aa",
+        "#:[AL] =aa nn",
+        "#:[ALS] =aa nn SS",
+        "[ALK]=aa kk",
+        "[AL]^=aa nn",
+        " :[ABLE]=E PP aa nn",
+        "[ABLE]=aa PP aa nn",
+        "[ANG]+=E nn kk",
+        "[A]=aa"
+      ],
+      B: [" [BE]^#=PP I", "[BEING]=PP I I nn", " [BOTH] =PP O TH", " [BUS]#=PP I SS", "[BUIL]=PP I nn", "[B]=PP"],
+      C: [
+        " [CH]^=kk",
+        "^E[CH]=kk",
+        "[CH]=CH",
+        " S[CI]#=SS aa",
+        "[CI]A=SS",
+        "[CI]O=SS",
+        "[CI]EN=SS",
+        "[C]+=SS",
+        "[CK]=kk",
+        "[COM]%=kk aa PP",
+        "[C]=kk"
+      ],
+      D: [
+        "#:[DED] =DD I DD",
+        ".E[D] =DD",
+        "#^:E[D] =DD",
+        " [DE]^#=DD I",
+        " [DO] =DD U",
+        " [DOES]=DD aa SS",
+        " [DOING]=DD U I nn",
+        " [DOW]=DD aa",
+        "[DU]A=kk U",
+        "[D]=DD"
+      ],
+      E: [
+        "#:[E] =",
+        "'^:[E] =",
+        " :[E] =I",
+        "#[ED] =DD",
+        "#:[E]D =",
+        "[EV]ER=E FF",
+        "[E]^%=I",
+        "[ERI]#=I RR I",
+        "[ERI]=E RR I",
+        "#:[ER]#=E",
+        "[ER]#=E RR",
+        "[ER]=E",
+        " [EVEN]=I FF E nn",
+        "#:[E]W=",
+        "@[EW]=U",
+        "[EW]=I U",
+        "[E]O=I",
+        "#:&[ES] =I SS",
+        "#:[E]S =",
+        "#:[ELY] =nn I",
+        "#:[EMENT]=PP E nn DD",
+        "[EFUL]=FF U nn",
+        "[EE]=I",
+        "[EARN]=E nn",
+        " [EAR]^=E",
+        "[EAD]=E DD",
+        "#:[EA] =I aa",
+        "[EA]SU=E",
+        "[EA]=I",
+        "[EIGH]=E",
+        "[EI]=I",
+        " [EYE]=aa",
+        "[EY]=I",
+        "[EU]=I U",
+        "[E]=E"
+      ],
+      F: ["[FUL]=FF U nn", "[F]=FF"],
+      G: [
+        "[GIV]=kk I FF",
+        " [G]I^=kk",
+        "[GE]T=kk E",
+        "SU[GGES]=kk kk E SS",
+        "[GG]=kk",
+        " B#[G]=kk",
+        "[G]+=kk",
+        "[GREAT]=kk RR E DD",
+        "#[GH]=",
+        "[G]=kk"
+      ],
+      H: [" [HAV]=I aa FF", " [HERE]=I I RR", " [HOUR]=aa E", "[HOW]=I aa", "[H]#=I", "[H]="],
+      I: [
+        " [IN]=I nn",
+        " [I] =aa",
+        "[IN]D=aa nn",
+        "[IER]=I E",
+        "#:R[IED] =I DD",
+        "[IED] =aa DD",
+        "[IEN]=I E nn",
+        "[IE]T=aa E",
+        " :[I]%=aa",
+        "[I]%=I",
+        "[IE]=I",
+        "[I]^+:#=I",
+        "[IR]#=aa RR",
+        "[IZ]%=aa SS",
+        "[IS]%=aa SS",
+        "[I]D%=aa",
+        "+^[I]^+=I",
+        "[I]T%=aa",
+        "#^:[I]^+=I",
+        "[I]^+=aa",
+        "[IR]=E",
+        "[IGH]=aa",
+        "[ILD]=aa nn DD",
+        "[IGN] =aa nn",
+        "[IGN]^=aa nn",
+        "[IGN]%=aa nn",
+        "[IQUE]=I kk",
+        "[I]=I"
+      ],
+      J: ["[J]=kk"],
+      K: [" [K]N=", "[K]=kk"],
+      L: ["[LO]C#=nn O", "L[L]=", "#^:[L]%=aa nn", "[LEAD]=nn I DD", "[L]=nn"],
+      M: ["[MOV]=PP U FF", "[M]=PP"],
+      N: [
+        "E[NG]+=nn kk",
+        "[NG]R=nn kk",
+        "[NG]#=nn kk",
+        "[NGL]%=nn kk aa nn",
+        "[NG]=nn",
+        "[NK]=nn kk",
+        " [NOW] =nn aa",
+        "[N]=nn"
+      ],
+      O: [
+        "[OF] =aa FF",
+        "[OROUGH]=E O",
+        "#:[OR] =E",
+        "#:[ORS] =E SS",
+        "[OR]=aa RR",
+        " [ONE]=FF aa nn",
+        "[OW]=O",
+        " [OVER]=O FF E",
+        "[OV]=aa FF",
+        "[O]^%=O",
+        "[O]^EN=O",
+        "[O]^I#=O",
+        "[OL]D=O nn",
+        "[OUGHT]=aa DD",
+        "[OUGH]=aa FF",
+        " [OU]=aa",
+        "H[OU]S#=aa",
+        "[OUS]=aa SS",
+        "[OUR]=aa RR",
+        "[OULD]=U DD",
+        "^[OU]^L=aa",
+        "[OUP]=U PP",
+        "[OU]=aa",
+        "[OY]=O",
+        "[OING]=O I nn",
+        "[OI]=O",
+        "[OOR]=aa RR",
+        "[OOK]=U kk",
+        "[OOD]=U DD",
+        "[OO]=U",
+        "[O]E=O",
+        "[O] =O",
+        "[OA]=O",
+        " [ONLY]=O nn nn I",
+        " [ONCE]=FF aa nn SS",
+        "[ON'T]=O nn DD",
+        "C[O]N=aa",
+        "[O]NG=aa",
+        " ^:[O]N=aa",
+        "I[ON]=aa nn",
+        "#:[ON] =aa nn",
+        "#^[ON]=aa nn",
+        "[O]ST =O",
+        "[OF]^=aa FF",
+        "[OTHER]=aa TH E",
+        "[OSS] =aa SS",
+        "#^:[OM]=aa PP",
+        "[O]=aa"
+      ],
+      P: ["[PH]=FF", "[PEOP]=PP I PP", "[POW]=PP aa", "[PUT] =PP U DD", "[P]=PP"],
+      Q: ["[QUAR]=kk FF aa RR", "[QU]=kk FF", "[Q]=kk"],
+      R: [" [RE]^#=RR I", "[R]=RR"],
+      S: [
+        "[SH]=SS",
+        "#[SION]=SS aa nn",
+        "[SOME]=SS aa PP",
+        "#[SUR]#=SS E",
+        "[SUR]#=SS E",
+        "#[SU]#=SS U",
+        "#[SSU]#=SS U",
+        "#[SED] =SS DD",
+        "#[S]#=SS",
+        "[SAID]=SS E DD",
+        "^[SION]=SS aa nn",
+        "[S]S=",
+        ".[S] =SS",
+        "#:.E[S] =SS",
+        "#^:##[S] =SS",
+        "#^:#[S] =SS",
+        "U[S] =SS",
+        " :#[S] =SS",
+        " [SCH]=SS kk",
+        "[S]C+=",
+        "#[SM]=SS PP",
+        "#[SN]'=SS aa nn",
+        "[S]=SS"
+      ],
+      T: [
+        " [THE] =TH aa",
+        "[TO] =DD U",
+        "[THAT] =TH aa DD",
+        " [THIS] =TH I SS",
+        " [THEY]=TH E",
+        " [THERE]=TH E RR",
+        "[THER]=TH E",
+        "[THEIR]=TH E RR",
+        " [THAN] =TH aa nn",
+        " [THEM] =TH E PP",
+        "[THESE] =TH I SS",
+        " [THEN]=TH E nn",
+        "[THROUGH]=TH RR U",
+        "[THOSE]=TH O SS",
+        "[THOUGH] =TH O",
+        " [THUS]=TH aa SS",
+        "[TH]=TH",
+        "#:[TED] =DD I DD",
+        "S[TI]#N=CH",
+        "[TI]O=SS",
+        "[TI]A=SS",
+        "[TIEN]=SS aa nn",
+        "[TUR]#=CH E",
+        "[TU]A=CH U",
+        " [TWO]=DD U",
+        "[T]=DD"
+      ],
+      U: [
+        " [UN]I=I U nn",
+        " [UN]=aa nn",
+        " [UPON]=aa PP aa nn",
+        "@[UR]#=U RR",
+        "[UR]#=I U RR",
+        "[UR]=E",
+        "[U]^ =aa",
+        "[U]^^=aa",
+        "[UY]=aa",
+        " G[U]#=",
+        "G[U]%=",
+        "G[U]#=FF",
+        "#N[U]=I U",
+        "@[U]=I",
+        "[U]=I U"
+      ],
+      V: ["[VIEW]=FF I U", "[V]=FF"],
+      W: [
+        " [WERE]=FF E",
+        "[WA]S=FF aa",
+        "[WA]T=FF aa",
+        "[WHERE]=FF E RR",
+        "[WHAT]=FF aa DD",
+        "[WHOL]=I O nn",
+        "[WHO]=I U",
+        "[WH]=FF",
+        "[WAR]=FF aa RR",
+        "[WOR]^=FF E",
+        "[WR]=RR",
+        "[W]=FF"
+      ],
+      X: [" [X]=SS", "[X]=kk SS"],
+      Y: [
+        "[YOUNG]=I aa nn",
+        " [YOU]=I U",
+        " [YES]=I E SS",
+        " [Y]=I",
+        "#^:[Y] =I",
+        "#^:[Y]I=I",
+        " :[Y] =aa",
+        " :[Y]#=aa",
+        " :[Y]^+:#=I",
+        " :[Y]^#=I",
+        "[Y]=I"
+      ],
+      Z: ["[Z]=SS"]
+    };
+    OPS = {
+      "#": "[AEIOUY]+",
+      // one or more vowels
+      ".": "[BDVGJLMNRWZ]",
+      // one voiced consonant
+      "%": "(?:ER|E|ES|ED|ING|ELY)",
+      // common suffixes
+      "&": "(?:[SCGZXJ]|CH|SH)",
+      "@": "(?:[TSRDLZNJ]|TH|CH|SH)",
+      "^": "[BCDFGHJKLMNPQRSTVWXZ]",
+      // one consonant
+      "+": "[EIY]",
+      ":": "[BCDFGHJKLMNPQRSTVWXZ]*",
+      // zero or more consonants
+      " ": "\\b"
+      // word boundary
+    };
+    COMPILED = Object.fromEntries(
+      Object.entries(RULES).map(([k, rules]) => [k, rules.map(compile)])
+    );
+  }
+});
+
+// packages/core/src/lipsync/timeline.ts
+var init_timeline = __esm({
+  "packages/core/src/lipsync/timeline.ts"() {
+    "use strict";
+    init_english();
+  }
+});
+
+// packages/core/src/lipsync/audio.ts
+var init_audio = __esm({
+  "packages/core/src/lipsync/audio.ts"() {
+    "use strict";
+  }
+});
+
+// packages/core/src/index.ts
+var init_src = __esm({
+  "packages/core/src/index.ts"() {
+    "use strict";
+    init_visemes();
+    init_moods();
+    init_config();
+    init_protocol();
+    init_speakable();
+    init_english();
+    init_timeline();
+    init_audio();
+  }
+});
+
+// apps/bridge/src/store.ts
+import { mkdir as mkdir2, readFile as readFile3, rename, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname2, join as join2 } from "node:path";
+function agentarHome() {
+  return process.env.AGENTAR_HOME ?? join2(homedir2(), ".agentar");
+}
+var ConfigStore;
+var init_store = __esm({
+  "apps/bridge/src/store.ts"() {
+    "use strict";
+    init_src();
+    ConfigStore = class _ConfigStore {
+      constructor(file, initial) {
+        this.file = file;
+        this.config = initial;
+      }
+      file;
+      config;
+      static async open(file = join2(agentarHome(), "config.json")) {
+        let raw;
+        try {
+          raw = JSON.parse(await readFile3(file, "utf8"));
+        } catch {
+          raw = void 0;
+        }
+        return new _ConfigStore(file, resolveConfig(raw));
+      }
+      get() {
+        return this.config;
+      }
+      async update(patch) {
+        this.config = mergeConfig(this.config, patch);
+        await mkdir2(dirname2(this.file), { recursive: true });
+        const tmp = `${this.file}.tmp`;
+        await writeFile2(tmp, JSON.stringify(this.config, null, 2) + "\n", "utf8");
+        await rename(tmp, this.file);
+        return this.config;
+      }
+    };
+  }
+});
+
+// apps/bridge/src/models.ts
+import { createWriteStream, existsSync } from "node:fs";
+import { mkdir as mkdir3, rename as rename2, rm, stat } from "node:fs/promises";
+import { dirname as dirname3, join as join3, resolve } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { fileURLToPath } from "node:url";
+function defaultWebDir() {
+  const candidates = [join3(REPO_ROOT, "apps/web/dist"), resolve(HERE, "../web")];
+  return candidates.find((d) => existsSync(join3(d, "index.html"))) ?? candidates[0];
+}
+function defaultModelsDir(home = agentarHome()) {
+  const repo = join3(REPO_ROOT, "assets/models");
+  return existsSync(join3(repo, "README.md")) ? repo : join3(home, "builtin-models");
+}
+function defaultCliPath() {
+  return join3(REPO_ROOT, "packages/cli/dist/index.js");
+}
+async function fetchModels(dir, opts = {}) {
+  const log = opts.log ?? ((m) => console.log(m));
+  const defaultId = DEFAULT_CONFIG.model.source === "builtin" ? DEFAULT_CONFIG.model.id : "";
+  await mkdir3(dir, { recursive: true });
+  let ok = true;
+  for (const m of BUILTIN_MODELS) {
+    if (!opts.all && m.id !== defaultId) continue;
+    const dest = join3(dir, m.file);
+    try {
+      if ((await stat(dest)).size > 1e3) {
+        if (!opts.quiet) log(`\u2713 ${m.file} already present`);
+        continue;
+      }
+    } catch {
+    }
+    log(`\u2193 ${m.file} (${m.license}) \u2026`);
+    try {
+      const res = await fetch(`${MODELS_URL}/${m.file}`);
+      if (!res.ok || !res.body) throw new Error(`HTTP ${res.status}`);
+      await pipeline(Readable.fromWeb(res.body), createWriteStream(`${dest}.part`));
+      await rename2(`${dest}.part`, dest);
+      log(`\u2713 ${m.file} downloaded`);
+    } catch (err) {
+      await rm(`${dest}.part`, { force: true });
+      log(`\u2717 ${m.file} failed: ${err.message}`);
+      ok = false;
+    }
+  }
+  return ok;
+}
+var MODELS_URL, HERE, REPO_ROOT;
+var init_models = __esm({
+  "apps/bridge/src/models.ts"() {
+    "use strict";
+    init_src();
+    init_store();
+    MODELS_URL = "https://raw.githubusercontent.com/met4citizen/TalkingHead/main/avatars";
+    HERE = dirname3(fileURLToPath(import.meta.url));
+    REPO_ROOT = resolve(HERE, "../../..");
+  }
+});
+
+// apps/bridge/src/speech-queue.ts
+import { randomUUID } from "node:crypto";
+function deferred() {
+  let resolve2;
+  const promise = new Promise((r) => resolve2 = r);
+  return { promise, resolve: resolve2 };
+}
+var SpeechQueue;
+var init_speech_queue = __esm({
+  "apps/bridge/src/speech-queue.ts"() {
+    "use strict";
+    SpeechQueue = class {
+      constructor(deps) {
+        this.deps = deps;
+      }
+      deps;
+      queue = [];
+      current = null;
+      get busy() {
+        return this.current !== null || this.queue.length > 0;
+      }
+      async say(req) {
+        const id = randomUUID();
+        if (this.deps.clientCount() === 0) {
+          return { id, status: "no-clients", error: "No avatar is connected. Open the agentar page in a browser first." };
+        }
+        if (req.interrupt ?? true) this.stop();
+        const abort = new AbortController();
+        const item = {
+          id,
+          text: req.text,
+          mood: req.mood,
+          abort,
+          audio: this.deps.render(id, req.text, abort.signal),
+          dispatched: deferred(),
+          finished: deferred(),
+          audience: 0,
+          failures: 0
+        };
+        item.audio.catch(() => void 0);
+        const isNext = this.current === null && this.queue.length === 0;
+        this.queue.push(item);
+        void this.pump();
+        if (req.wait) return item.finished.promise;
+        return isNext ? item.dispatched.promise : { id, status: "queued" };
+      }
+      /** Stop the current utterance and drop everything queued. */
+      stop() {
+        const dropped = [...this.queue.splice(0), ...this.current ? [this.current] : []];
+        const hadCurrent = this.current !== null;
+        this.current = null;
+        for (const item of dropped) this.settle(item, { id: item.id, status: "interrupted" });
+        if (hadCurrent) this.deps.broadcast({ type: "stop" });
+      }
+      /** Called when an avatar client reports that it finished an utterance. */
+      speechEnded(id, interrupted, error) {
+        const item = this.current;
+        if (!item || item.id !== id) return;
+        if (error && ++item.failures < item.audience) return;
+        this.current = null;
+        this.settle(item, error ? { id, status: "error", error } : { id, status: interrupted ? "interrupted" : "spoken" });
+        void this.pump();
+      }
+      async pump() {
+        if (this.current || this.queue.length === 0) return;
+        const item = this.queue.shift();
+        this.current = item;
+        let audio;
+        try {
+          audio = await item.audio;
+        } catch (err) {
+          if (this.current === item) this.current = null;
+          this.settle(item, { id: item.id, status: "error", error: err.message });
+          void this.pump();
+          return;
+        }
+        if (this.current !== item) return;
+        const utterance = { id: item.id, text: item.text };
+        if (item.mood) utterance.mood = item.mood;
+        if (audio) utterance.audio = audio;
+        this.deps.broadcast({ type: "speak", utterance });
+        item.dispatched.resolve({ id: item.id, status: "queued" });
+        const words = item.text.split(/\s+/).length;
+        const rate = Math.max(0.25, this.deps.speechRate?.() ?? 1);
+        item.audience = this.deps.clientCount();
+        item.timer = setTimeout(() => this.speechEnded(item.id, false), (words / (2.5 * rate) + 15) * 1e3);
+      }
+      settle(item, res) {
+        if (item.timer) clearTimeout(item.timer);
+        item.abort.abort();
+        item.dispatched.resolve(res);
+        item.finished.resolve(res);
+      }
+    };
+  }
+});
+
+// apps/bridge/src/tts/types.ts
+var TtsError;
+var init_types = __esm({
+  "apps/bridge/src/tts/types.ts"() {
+    "use strict";
+    TtsError = class extends Error {
+    };
+  }
+});
+
+// apps/bridge/src/tts/cloud.ts
+var OPENAI_VOICES, OpenAiTts, ElevenLabsTts, XaiTts;
+var init_cloud = __esm({
+  "apps/bridge/src/tts/cloud.ts"() {
+    "use strict";
+    init_types();
+    OPENAI_VOICES = ["alloy", "ash", "ballad", "coral", "echo", "fable", "nova", "onyx", "sage", "shimmer", "verse"];
+    OpenAiTts = class {
+      constructor(apiKey = process.env.OPENAI_API_KEY, model2 = process.env.AGENTAR_OPENAI_TTS_MODEL ?? "gpt-4o-mini-tts", baseUrl = process.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1") {
+        this.apiKey = apiKey;
+        this.model = model2;
+        this.baseUrl = baseUrl;
+      }
+      apiKey;
+      model;
+      baseUrl;
+      id = "openai";
+      async unavailableReason() {
+        return this.apiKey ? null : "Set OPENAI_API_KEY in the environment that runs `agentar start`.";
+      }
+      async listVoices() {
+        return OPENAI_VOICES.map((v) => ({ id: v, name: v[0].toUpperCase() + v.slice(1) }));
+      }
+      async synthesize(text2, voice, signal) {
+        if (!this.apiKey) throw new TtsError("OPENAI_API_KEY is not set");
+        const res = await fetch(`${this.baseUrl}/audio/speech`, {
+          method: "POST",
+          signal,
+          headers: { Authorization: `Bearer ${this.apiKey}`, "Content-Type": "application/json" },
+          body: JSON.stringify({
+            model: this.model,
+            voice: voice.voice || "coral",
+            input: text2,
+            response_format: "mp3",
+            speed: voice.rate
+          })
+        });
+        if (!res.ok) throw new TtsError(`OpenAI TTS failed (${res.status}): ${(await res.text()).slice(0, 300)}`);
+        return { data: Buffer.from(await res.arrayBuffer()), mime: "audio/mpeg" };
+      }
+    };
+    ElevenLabsTts = class {
+      constructor(apiKey = process.env.ELEVENLABS_API_KEY, model2 = process.env.AGENTAR_ELEVENLABS_MODEL ?? "eleven_flash_v2_5") {
+        this.apiKey = apiKey;
+        this.model = model2;
+      }
+      apiKey;
+      model;
+      id = "elevenlabs";
+      async unavailableReason() {
+        return this.apiKey ? null : "Set ELEVENLABS_API_KEY in the environment that runs `agentar start`.";
+      }
+      async listVoices() {
+        if (!this.apiKey) return [];
+        const res = await fetch("https://api.elevenlabs.io/v1/voices", { headers: { "xi-api-key": this.apiKey } });
+        if (!res.ok) throw new TtsError(`ElevenLabs voices failed (${res.status})`);
+        const body = await res.json();
+        return (body.voices ?? []).map((v) => ({ id: v.voice_id, name: v.name, language: v.labels?.accent }));
+      }
+      async synthesize(text2, voice, signal) {
+        if (!this.apiKey) throw new TtsError("ELEVENLABS_API_KEY is not set");
+        const voiceId = encodeURIComponent(voice.voice || "21m00Tcm4TlvDq8ikWAM");
+        const res = await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${voiceId}?output_format=mp3_44100_128`, {
+          method: "POST",
+          signal,
+          headers: { "xi-api-key": this.apiKey, "Content-Type": "application/json", Accept: "audio/mpeg" },
+          body: JSON.stringify({
+            text: text2,
+            model_id: this.model,
+            voice_settings: { stability: 0.5, similarity_boost: 0.75, speed: Math.min(1.2, Math.max(0.7, voice.rate)) }
+          })
+        });
+        if (!res.ok) throw new TtsError(`ElevenLabs TTS failed (${res.status}): ${(await res.text()).slice(0, 300)}`);
+        return { data: Buffer.from(await res.arrayBuffer()), mime: "audio/mpeg" };
+      }
+    };
+    XaiTts = class {
+      constructor(apiKey = process.env.XAI_API_KEY, baseUrl = process.env.XAI_BASE_URL ?? "https://api.x.ai/v1") {
+        this.apiKey = apiKey;
+        this.baseUrl = baseUrl;
+      }
+      apiKey;
+      baseUrl;
+      id = "xai";
+      async unavailableReason() {
+        return this.apiKey ? null : "Set XAI_API_KEY in the environment that runs `agentar start`.";
+      }
+      async listVoices() {
+        if (!this.apiKey) return [];
+        const res = await fetch(`${this.baseUrl}/tts/voices`, { headers: { Authorization: `Bearer ${this.apiKey}` } });
+        if (!res.ok) throw new TtsError(`xAI voices failed (${res.status})`);
+        const body = await res.json();
+        return (body.voices ?? []).map((v) => ({ id: v.voice_id, name: v.name, language: v.language ?? void 0 }));
+      }
+      async synthesize(text2, voice, signal) {
+        if (!this.apiKey) throw new TtsError("XAI_API_KEY is not set");
+        const res = await fetch(`${this.baseUrl}/tts`, {
+          method: "POST",
+          signal,
+          headers: { Authorization: `Bearer ${this.apiKey}`, "Content-Type": "application/json" },
+          body: JSON.stringify({
+            text: text2,
+            voice_id: voice.voice || "eve",
+            language: "auto",
+            output_format: { codec: "mp3" },
+            speed: Math.min(1.5, Math.max(0.7, voice.rate))
+          })
+        });
+        if (!res.ok) throw new TtsError(`xAI TTS failed (${res.status}): ${(await res.text()).slice(0, 300)}`);
+        return { data: Buffer.from(await res.arrayBuffer()), mime: "audio/mpeg" };
+      }
+    };
+  }
+});
+
+// apps/bridge/src/tts/edge.ts
+import { execFile } from "node:child_process";
+import { access, mkdtemp, readFile as readFile4, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
+import { homedir as homedir3, tmpdir } from "node:os";
+import { join as join4 } from "node:path";
+import { promisify } from "node:util";
+async function isExecutable(path) {
+  try {
+    await access(
+      path,
+      1
+      /* X_OK */
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+function edgeRate(rate) {
+  const pct = Math.round((rate - 1) * 100);
+  return `${pct < 0 ? "-" : "+"}${Math.abs(pct)}%`;
+}
+function parseEdgeVoices(stdout) {
+  const voices = [];
+  for (const line of stdout.split("\n")) {
+    const m = /^((?:[a-z]{2,3}-)(?:[A-Za-z]+-)+)([A-Za-z]+?)(Multilingual)?Neural\s+(\S+)/.exec(line.trim());
+    if (!m) continue;
+    const [, locale = "", short = "", multi, gender = ""] = m;
+    const id = line.trim().split(/\s+/)[0];
+    const label = multi ? `${short} Multilingual` : short;
+    voices.push({ id, name: `${label}, ${gender.toLowerCase()}`, language: locale.slice(0, -1) });
+  }
+  return voices;
+}
+var run, EdgeTts;
+var init_edge = __esm({
+  "apps/bridge/src/tts/edge.ts"() {
+    "use strict";
+    init_types();
+    run = promisify(execFile);
+    EdgeTts = class {
+      constructor(binary = process.env.AGENTAR_EDGE_TTS) {
+        this.binary = binary;
+      }
+      binary;
+      id = "edge";
+      voicesCache = null;
+      async unavailableReason() {
+        return await this.findBinary() ? null : "Install edge-tts (`pipx install edge-tts` or `uv tool install edge-tts`).";
+      }
+      async listVoices() {
+        if (this.voicesCache) return this.voicesCache;
+        const { stdout } = await run(await this.requireBinary(), ["--list-voices"], { timeout: 3e4 });
+        this.voicesCache = parseEdgeVoices(stdout);
+        return this.voicesCache;
+      }
+      async synthesize(text2, voice, signal) {
+        const bin = await this.requireBinary();
+        const dir = await mkdtemp(join4(tmpdir(), "agentar-edge-"));
+        const input = join4(dir, "input.txt");
+        const out = join4(dir, "speech.mp3");
+        try {
+          await writeFile3(input, text2, "utf8");
+          const args = [`--file=${input}`, `--write-media=${out}`, `--rate=${edgeRate(voice.rate)}`];
+          if (voice.voice) args.push(`--voice=${voice.voice}`);
+          await run(bin, args, { timeout: 6e4, signal });
+          return { data: await readFile4(out), mime: "audio/mpeg" };
+        } catch (err) {
+          throw new TtsError(`Edge TTS failed: ${err.message}`);
+        } finally {
+          await rm2(dir, { recursive: true, force: true });
+        }
+      }
+      async requireBinary() {
+        const bin = await this.findBinary();
+        if (!bin) throw new TtsError("edge-tts not found");
+        return bin;
+      }
+      /**
+       * The bridge may be started from a hook or app with a short PATH, so also
+       * look where pipx, uv, and Homebrew put their binaries.
+       */
+      async findBinary() {
+        if (this.binary) return await isExecutable(this.binary) ? this.binary : null;
+        try {
+          const { stdout } = await run("which", ["edge-tts"]);
+          if (stdout.trim()) return stdout.trim();
+        } catch {
+        }
+        for (const dir of [join4(homedir3(), ".local/bin"), "/opt/homebrew/bin", "/usr/local/bin"]) {
+          const bin = join4(dir, "edge-tts");
+          if (await isExecutable(bin)) return bin;
+        }
+        return null;
+      }
+    };
+  }
+});
+
+// apps/bridge/src/tts/system.ts
+import { execFile as execFile2 } from "node:child_process";
+import { mkdtemp as mkdtemp2, readFile as readFile5, rm as rm3, writeFile as writeFile4 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join5 } from "node:path";
+import { promisify as promisify2 } from "node:util";
+function parseSayVoices(stdout) {
+  const voices = [];
+  for (const line of stdout.split("\n")) {
+    const m = /^(.+?)\s+([a-z]{2,3}[_-][A-Za-z0-9]+)\s+#/.exec(line);
+    if (m) voices.push({ id: m[1].trim(), name: m[1].trim(), language: m[2].replace("_", "-") });
+  }
+  return voices;
+}
+var run2, SystemTts;
+var init_system = __esm({
+  "apps/bridge/src/tts/system.ts"() {
+    "use strict";
+    init_types();
+    run2 = promisify2(execFile2);
+    SystemTts = class {
+      constructor(platform = process.platform) {
+        this.platform = platform;
+      }
+      platform;
+      id = "system";
+      voicesCache = null;
+      async unavailableReason() {
+        try {
+          if (this.platform === "darwin") await run2("which", ["say"]);
+          else if (this.platform === "win32") await run2("powershell", ["-NoProfile", "-Command", "Add-Type -AssemblyName System.Speech"]);
+          else await this.linuxBinary();
+          return null;
+        } catch {
+          return this.platform === "linux" ? "Install espeak-ng (e.g. `sudo apt install espeak-ng`) or choose another voice provider." : "The system speech engine is not available.";
+        }
+      }
+      async listVoices() {
+        if (this.voicesCache) return this.voicesCache;
+        let voices = [];
+        if (this.platform === "darwin") {
+          const { stdout } = await run2("say", ["-v", "?"]);
+          voices = parseSayVoices(stdout);
+        } else if (this.platform === "win32") {
+          const { stdout } = await run2("powershell", [
+            "-NoProfile",
+            "-Command",
+            "Add-Type -AssemblyName System.Speech; (New-Object System.Speech.Synthesis.SpeechSynthesizer).GetInstalledVoices() | % { $_.VoiceInfo.Name + '|' + $_.VoiceInfo.Culture }"
+          ]);
+          voices = stdout.split(/\r?\n/).filter(Boolean).map((l) => {
+            const [name = "", language] = l.split("|");
+            return { id: name, name, language };
+          });
+        } else {
+          const bin = await this.linuxBinary();
+          const { stdout } = await run2(bin, ["--voices"]);
+          voices = stdout.split("\n").slice(1).map((l) => l.trim().split(/\s+/)).filter((p) => p.length >= 4).map((p) => ({ id: p[3], name: p[3], language: p[1] }));
+        }
+        this.voicesCache = voices;
+        return voices;
+      }
+      async synthesize(text2, voice) {
+        const dir = await mkdtemp2(join5(tmpdir2(), "agentar-tts-"));
+        const input = join5(dir, "input.txt");
+        const out = join5(dir, "speech.wav");
+        try {
+          await writeFile4(input, text2, "utf8");
+          if (this.platform === "darwin") {
+            const args = ["-f", input, "-o", out, "--file-format=WAVE", "--data-format=LEI16@22050", "-r", String(Math.round(185 * voice.rate))];
+            if (voice.voice) args.unshift("-v", voice.voice);
+            await run2("say", args, { timeout: 6e4 });
+          } else if (this.platform === "win32") {
+            const script = [
+              "Add-Type -AssemblyName System.Speech",
+              "$s = New-Object System.Speech.Synthesis.SpeechSynthesizer",
+              voice.voice ? `$s.SelectVoice($env:AGENTAR_VOICE)` : "",
+              `$s.Rate = ${Math.max(-10, Math.min(10, Math.round((voice.rate - 1) * 10)))}`,
+              "$s.SetOutputToWaveFile($env:AGENTAR_OUT)",
+              "$s.Speak([IO.File]::ReadAllText($env:AGENTAR_IN))",
+              "$s.Dispose()"
+            ].join("; ");
+            await run2("powershell", ["-NoProfile", "-Command", script], {
+              timeout: 6e4,
+              env: { ...process.env, AGENTAR_VOICE: voice.voice, AGENTAR_OUT: out, AGENTAR_IN: input }
+            });
+          } else {
+            const bin = await this.linuxBinary();
+            const args = ["-w", out, "-s", String(Math.round(170 * voice.rate)), "-f", input];
+            if (voice.voice) args.unshift("-v", voice.voice);
+            await run2(bin, args, { timeout: 6e4 });
+          }
+          return { data: await readFile5(out), mime: "audio/wav" };
+        } catch (err) {
+          throw new TtsError(`System TTS failed: ${err.message}`);
+        } finally {
+          await rm3(dir, { recursive: true, force: true });
+        }
+      }
+      async linuxBinary() {
+        for (const bin of ["espeak-ng", "espeak"]) {
+          try {
+            await run2("which", [bin]);
+            return bin;
+          } catch {
+          }
+        }
+        throw new TtsError("espeak-ng not found");
+      }
+    };
+  }
+});
+
+// apps/bridge/src/server.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { mkdir as mkdir4, readdir, stat as stat2, writeFile as writeFile5 } from "node:fs/promises";
+import { createServer } from "node:http";
+import { extname, join as join6, normalize, sep } from "node:path";
+import { WebSocketServer } from "ws";
+async function startBridge(opts = {}) {
+  const port = opts.port ?? Number(process.env.AGENTAR_PORT ?? DEFAULT_PORT);
+  const host = opts.host ?? process.env.AGENTAR_HOST ?? "127.0.0.1";
+  const home = opts.homeDir ?? agentarHome();
+  const webDir = opts.webDir ?? process.env.AGENTAR_WEB_DIR ?? defaultWebDir();
+  const modelsDir = opts.modelsDir ?? process.env.AGENTAR_MODELS_DIR ?? defaultModelsDir(home);
+  const cliPath = opts.cliPath ?? defaultCliPath();
+  const userModelsDir = join6(home, "models");
+  const log = opts.log ?? ((m) => console.log(`[agentar] ${m}`));
+  const store = await ConfigStore.open(join6(home, "config.json"));
+  const providers = {
+    system: opts.providers?.system ?? new SystemTts(),
+    edge: opts.providers?.edge ?? new EdgeTts(),
+    openai: opts.providers?.openai ?? new OpenAiTts(),
+    elevenlabs: opts.providers?.elevenlabs ?? new ElevenLabsTts(),
+    xai: opts.providers?.xai ?? new XaiTts()
+  };
+  let publicUrl = "";
+  const audio = /* @__PURE__ */ new Map();
+  const clients = /* @__PURE__ */ new Map();
+  const broadcast = (msg) => {
+    const data = JSON.stringify(msg);
+    for (const ws of clients.keys()) if (ws.readyState === ws.OPEN) ws.send(data);
+  };
+  const queue = new SpeechQueue({
+    clientCount: () => clients.size,
+    speechRate: () => store.get().voice.rate,
+    broadcast,
+    render: async (id, text2, signal) => {
+      const voice = store.get().voice;
+      if (voice.provider === "browser") return null;
+      const { data, mime } = await providers[voice.provider].synthesize(text2, voice, signal);
+      const now = Date.now();
+      for (const [k, v] of audio) if (v.expires < now) audio.delete(k);
+      audio.set(id, { data, mime, expires: now + AUDIO_TTL_MS });
+      return { url: `/api/audio/${id}`, mime };
+    }
+  });
+  const server = createServer((req, res) => {
+    handle(req, res).catch((err) => {
+      const status = err.status;
+      if (!status) log(`error: ${err.stack ?? String(err)}`);
+      if (!res.headersSent) sendJson(res, status ?? 500, { error: status ? err.message : "Internal error" });
+      else res.end();
+    });
+  });
+  async function handle(req, res) {
+    const url2 = new URL(req.url ?? "/", "http://localhost");
+    const path = url2.pathname;
+    const method = req.method ?? "GET";
+    if (!originAllowed(req)) return sendJson(res, 403, { error: "Cross-origin requests are not allowed" });
+    if (path === "/api/health" && method === "GET") {
+      const body = { ok: true, name: "agentar", version: VERSION, clients: clients.size };
+      return sendJson(res, 200, body);
+    }
+    if (path === "/api/info" && method === "GET") {
+      return sendJson(res, 200, { version: VERSION, url: publicUrl, cliPath });
+    }
+    if (path === "/api/config") {
+      if (method === "GET") return sendJson(res, 200, store.get());
+      if (method === "PUT" || method === "PATCH") {
+        const patch = await readJson(req);
+        const config = await store.update(patch);
+        broadcast({ type: "config", config });
+        return sendJson(res, 200, config);
+      }
+    }
+    if (path === "/api/say" && method === "POST") {
+      const body = await readSayBody(req);
+      if (!body) return sendJson(res, 400, { error: "Provide non-empty `text` (max 5000 chars)." });
+      const result = await queue.say(body);
+      const status = result.status === "error" ? 502 : result.status === "no-clients" ? 409 : 200;
+      return sendJson(res, status, result);
+    }
+    if (path === "/api/stop" && method === "POST") {
+      queue.stop();
+      return sendJson(res, 200, { ok: true });
+    }
+    if (path === "/api/mood" && method === "POST") {
+      const body = await readJson(req);
+      if (!isMood(body.mood)) return sendJson(res, 400, { error: "Unknown mood" });
+      if (body.persist) {
+        broadcast({ type: "config", config: await store.update({ behavior: { mood: body.mood } }) });
+      } else {
+        broadcast({ type: "mood", mood: body.mood });
+      }
+      return sendJson(res, 200, { ok: true });
+    }
+    if (path === "/api/gesture" && method === "POST") {
+      const body = await readJson(req);
+      if (typeof body.gesture !== "string" || !GESTURES.includes(body.gesture)) {
+        return sendJson(res, 400, { error: `gesture must be one of ${GESTURES.join(", ")}` });
+      }
+      broadcast({ type: "gesture", gesture: body.gesture });
+      return sendJson(res, 200, { ok: true });
+    }
+    if (path === "/api/voices" && method === "GET") {
+      const p = url2.searchParams.get("provider") ?? store.get().voice.provider;
+      if (!VOICE_PROVIDERS.includes(p)) return sendJson(res, 400, { error: "Unknown provider" });
+      if (p === "browser") return sendJson(res, 200, { provider: p, available: true, voices: [] });
+      const provider = providers[p];
+      const reason = await provider.unavailableReason();
+      if (reason) return sendJson(res, 200, { provider: p, available: false, reason, voices: [] });
+      try {
+        return sendJson(res, 200, { provider: p, available: true, voices: await provider.listVoices() });
+      } catch (err) {
+        return sendJson(res, 200, { provider: p, available: false, reason: err.message, voices: [] });
+      }
+    }
+    const audioMatch = /^\/api\/audio\/([\w-]+)$/.exec(path);
+    if (audioMatch && method === "GET") {
+      const clip = audio.get(audioMatch[1]);
+      if (!clip) return sendJson(res, 404, { error: "Audio expired" });
+      res.writeHead(200, { "Content-Type": clip.mime, "Content-Length": clip.data.length, "Cache-Control": "no-store" });
+      res.end(clip.data);
+      return;
+    }
+    if (path === "/api/models" && method === "GET") {
+      const builtin = await Promise.all(
+        BUILTIN_MODELS.map(async (m) => ({
+          id: m.id,
+          label: m.label,
+          license: m.license,
+          url: `/models/${m.file}`,
+          available: await exists(join6(modelsDir, m.file))
+        }))
+      );
+      let user = [];
+      try {
+        user = (await readdir(userModelsDir)).filter((f) => /\.(glb|vrm)$/i.test(f)).map((f) => ({ name: f, url: `/models/user/${encodeURIComponent(f)}` }));
+      } catch {
+      }
+      return sendJson(res, 200, { builtin, user });
+    }
+    if (path === "/api/models" && method === "POST") {
+      const name = sanitizeFileName(url2.searchParams.get("name") ?? "");
+      if (!name) return sendJson(res, 400, { error: "Pass ?name=<file>.glb or .vrm" });
+      const data = await readBody(req, MAX_MODEL);
+      if (data.subarray(0, 4).toString("latin1") !== "glTF") return sendJson(res, 400, { error: "Not a binary glTF (.glb/.vrm) file" });
+      await mkdir4(userModelsDir, { recursive: true });
+      await writeFile5(join6(userModelsDir, name), data);
+      log(`saved custom model ${name} (${(data.length / 1e6).toFixed(1)} MB)`);
+      return sendJson(res, 201, { name, url: `/models/user/${encodeURIComponent(name)}` });
+    }
+    if (path.startsWith("/models/user/")) {
+      await serveFile(res, userModelsDir, decodeURIComponent(path.slice("/models/user/".length)));
+      return;
+    }
+    if (path.startsWith("/models/")) {
+      await serveFile(res, modelsDir, decodeURIComponent(path.slice("/models/".length)));
+      return;
+    }
+    if (path.startsWith("/api/")) return sendJson(res, 404, { error: "Not found" });
+    if (method === "GET") {
+      const rel = path === "/" ? "index.html" : decodeURIComponent(path.slice(1));
+      if (await serveFile(res, webDir, rel, true)) return;
+      if (await serveFile(res, webDir, "index.html", true)) return;
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(
+        `<!doctype html><title>agentar</title><body style="font-family:system-ui;background:#111;color:#eee;padding:2rem"><h1>agentar bridge is running</h1><p>The web UI is not built yet. Run <code>npm run build</code>, or use <code>npm run dev</code> and open <a style="color:#8cf" href="http://localhost:5173">http://localhost:5173</a>.</p>`
+      );
+      return;
+    }
+    sendJson(res, 405, { error: "Method not allowed" });
+  }
+  async function serveFile(res, root, rel, quiet = false) {
+    const full = normalize(join6(root, rel));
+    if (!full.startsWith(normalize(root) + sep)) {
+      if (!quiet) sendJson(res, 403, { error: "Forbidden" });
+      return false;
+    }
+    let info;
+    try {
+      info = await stat2(full);
+    } catch {
+      if (!quiet) {
+        sendJson(res, 404, {
+          error: rel.endsWith(".glb") ? "Model not found. Run `agentar fetch-models` to download the built-in avatars." : "Not found"
+        });
+      }
+      return false;
+    }
+    if (!info.isFile()) {
+      if (!quiet) sendJson(res, 404, { error: "Not found" });
+      return false;
+    }
+    const type = MIME[extname(full).toLowerCase()] ?? "application/octet-stream";
+    const immutable = full.includes(`${sep}assets${sep}`) && full.startsWith(normalize(webDir));
+    res.writeHead(200, {
+      "Content-Type": type,
+      "Content-Length": info.size,
+      "Cache-Control": immutable ? "public, max-age=31536000, immutable" : "no-cache"
+    });
+    createReadStream(full).pipe(res);
+    return true;
+  }
+  const wss = new WebSocketServer({ noServer: true, maxPayload: 64 * 1024 });
+  server.on("upgrade", (req, socket, head) => {
+    const { pathname } = new URL(req.url ?? "/", "http://localhost");
+    if (pathname !== "/ws" || !originAllowed(req)) {
+      socket.destroy();
+      return;
+    }
+    wss.handleUpgrade(req, socket, head, (ws) => wss.emit("connection", ws, req));
+  });
+  wss.on("connection", (ws) => {
+    const clientId = randomUUID2();
+    clients.set(ws, { id: clientId });
+    log(`avatar connected (${clients.size} total)`);
+    ws.send(JSON.stringify({ type: "hello", protocol: PROTOCOL_VERSION, config: store.get(), clientId }));
+    ws.on("message", (raw) => {
+      let msg;
+      try {
+        msg = JSON.parse(String(raw));
+      } catch {
+        return;
+      }
+      if (typeof msg !== "object" || msg === null) return;
+      if (msg.type === "speech-end" && typeof msg.id === "string") {
+        queue.speechEnded(msg.id, Boolean(msg.interrupted), typeof msg.error === "string" ? msg.error : void 0);
+      }
+    });
+    ws.on("close", () => {
+      clients.delete(ws);
+      log(`avatar disconnected (${clients.size} left)`);
+    });
+  });
+  await new Promise((resolvePromise, reject) => {
+    server.once("error", reject);
+    server.listen(port, host, () => {
+      server.off("error", reject);
+      resolvePromise();
+    });
+  });
+  const actualPort = server.address().port;
+  const url = publicUrl = `http://${host === "0.0.0.0" || host === "127.0.0.1" ? "localhost" : host}:${actualPort}`;
+  log(`bridge listening on ${url}`);
+  return {
+    server,
+    url,
+    port: actualPort,
+    store,
+    queue,
+    close: () => new Promise((r) => {
+      queue.stop();
+      for (const ws of clients.keys()) ws.terminate();
+      wss.close();
+      server.close(() => r());
+    })
+  };
+}
+function originAllowed(req) {
+  const origin = req.headers.origin;
+  if (!origin || origin === "null") return !origin;
+  try {
+    const { hostname } = new URL(origin);
+    return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+  } catch {
+    return false;
+  }
+}
+function sendJson(res, status, body) {
+  const data = JSON.stringify(body);
+  res.writeHead(status, { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(data) });
+  res.end(data);
+}
+async function readBody(req, limit) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    size += chunk.length;
+    if (size > limit) throw Object.assign(new Error("Body too large"), { status: 413 });
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks);
+}
+async function readJson(req) {
+  const raw = (await readBody(req, MAX_JSON)).toString("utf8");
+  if (!raw.trim()) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function readSayBody(req) {
+  const type = req.headers["content-type"] ?? "";
+  let body;
+  if (type.startsWith("text/plain")) {
+    body = { text: (await readBody(req, MAX_JSON)).toString("utf8") };
+  } else {
+    const parsed = await readJson(req);
+    body = typeof parsed === "object" && parsed ? parsed : {};
+  }
+  const text2 = typeof body.text === "string" ? body.text.trim() : "";
+  if (!text2 || text2.length > MAX_TEXT) return null;
+  const out = { text: text2 };
+  if (isMood(body.mood)) out.mood = body.mood;
+  if (typeof body.wait === "boolean") out.wait = body.wait;
+  if (typeof body.interrupt === "boolean") out.interrupt = body.interrupt;
+  return out;
+}
+function sanitizeFileName(name) {
+  const base = name.split(/[\\/]/).pop() ?? "";
+  const clean = base.replace(/[^\w.\- ]/g, "_").slice(0, 100);
+  return /\.(glb|vrm)$/i.test(clean) && !clean.startsWith(".") ? clean : null;
+}
+async function exists(file) {
+  try {
+    return (await stat2(file)).isFile();
+  } catch {
+    return false;
+  }
+}
+var VERSION, MIME, MAX_JSON, MAX_MODEL, MAX_TEXT, AUDIO_TTL_MS;
+var init_server = __esm({
+  "apps/bridge/src/server.ts"() {
+    "use strict";
+    init_src();
+    init_models();
+    init_speech_queue();
+    init_store();
+    init_cloud();
+    init_edge();
+    init_system();
+    VERSION = "0.1.0";
+    MIME = {
+      ".html": "text/html; charset=utf-8",
+      ".js": "text/javascript; charset=utf-8",
+      ".css": "text/css; charset=utf-8",
+      ".json": "application/json",
+      ".svg": "image/svg+xml",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".ico": "image/x-icon",
+      ".glb": "model/gltf-binary",
+      ".vrm": "model/gltf-binary",
+      ".wasm": "application/wasm",
+      ".wav": "audio/wav",
+      ".mp3": "audio/mpeg"
+    };
+    MAX_JSON = 256 * 1024;
+    MAX_MODEL = 150 * 1024 * 1024;
+    MAX_TEXT = 5e3;
+    AUDIO_TTL_MS = 10 * 60 * 1e3;
+  }
+});
+
+// apps/bridge/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ConfigStore: () => ConfigStore,
+  EdgeTts: () => EdgeTts,
+  ElevenLabsTts: () => ElevenLabsTts,
+  OpenAiTts: () => OpenAiTts,
+  SpeechQueue: () => SpeechQueue,
+  SystemTts: () => SystemTts,
+  VERSION: () => VERSION,
+  XaiTts: () => XaiTts,
+  agentarHome: () => agentarHome,
+  defaultModelsDir: () => defaultModelsDir,
+  defaultWebDir: () => defaultWebDir,
+  edgeRate: () => edgeRate,
+  fetchModels: () => fetchModels,
+  parseEdgeVoices: () => parseEdgeVoices,
+  parseSayVoices: () => parseSayVoices,
+  startBridge: () => startBridge
+});
+var init_src2 = __esm({
+  "apps/bridge/src/index.ts"() {
+    "use strict";
+    init_server();
+    init_speech_queue();
+    init_models();
+    init_store();
+    init_system();
+    init_cloud();
+    init_edge();
+  }
+});
+
+// packages/mcp/src/index.ts
+var src_exports2 = {};
+__export(src_exports2, {
+  bridgeUrl: () => bridgeUrl,
+  createMcpServer: () => createMcpServer,
+  runMcpServer: () => runMcpServer
+});
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+function bridgeUrl() {
+  return process.env.AGENTAR_URL ?? `http://localhost:${process.env.AGENTAR_PORT ?? DEFAULT_PORT}`;
+}
+async function post(path, body) {
+  try {
+    const res = await fetch(`${bridgeUrl()}${path}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    return { status: res.status, json: await res.json() };
+  } catch {
+    throw new Error(`agentar bridge is not running at ${bridgeUrl()}. Start it with \`agentar start\`.`);
+  }
+}
+function createMcpServer() {
+  const server = new McpServer(
+    { name: "agentar", version: "0.1.0" },
+    {
+      instructions: "agentar gives you a 3D talking body that the user can see and hear. Use `speak` for short, conversational spoken summaries (one to three sentences) \u2014 not for code, file paths or long lists, which belong in the chat. Use `set_mood` and `gesture` sparingly to match the tone."
+    }
+  );
+  server.registerTool(
+    "speak",
+    {
+      title: "Speak aloud",
+      description: "Say something out loud through the user's agentar avatar (text-to-speech with a lip-synced 3D face). Keep it short and conversational; markdown is stripped automatically.",
+      inputSchema: {
+        text: z.string().min(1).max(5e3).describe("What to say, in plain conversational language."),
+        mood: z.enum(MOODS).optional().describe("Facial expression while speaking."),
+        wait: z.boolean().optional().describe("Wait until the avatar finishes speaking before returning. Default false.")
+      }
+    },
+    async ({ text: raw, mood, wait }) => {
+      const spoken = toSpeakable(raw, { maxChars: 1200 });
+      const { json } = await post("/api/say", { text: spoken, mood, wait: wait ?? false });
+      const res = json;
+      if (res.status === "no-clients") return { ...text(`Not spoken: ${res.error}`), isError: true };
+      if (res.status === "error") return { ...text(`Speech failed: ${res.error}`), isError: true };
+      return text(res.status === "spoken" ? "Spoken." : "Speaking.");
+    }
+  );
+  server.registerTool(
+    "set_mood",
+    {
+      title: "Set facial mood",
+      description: "Change the avatar's resting facial expression.",
+      inputSchema: { mood: z.enum(MOODS) }
+    },
+    async ({ mood }) => {
+      await post("/api/mood", { mood });
+      return text(`Mood set to ${mood}.`);
+    }
+  );
+  server.registerTool(
+    "gesture",
+    {
+      title: "Gesture",
+      description: "Play a short gesture. Head: nod (yes/agree), shake (no), tilt (curious). Hands: wave (hello/bye), high-five (celebrate a win), thumbs-up (approve), thumbs-down (disapprove), idea (one finger up), shrug (not sure), namaste (thanks). Face and body: wink, laugh, surprised, bow.",
+      inputSchema: { gesture: z.enum(GESTURES) }
+    },
+    async ({ gesture }) => {
+      await post("/api/gesture", { gesture });
+      return text(`Played ${gesture}.`);
+    }
+  );
+  server.registerTool(
+    "stop_speaking",
+    { title: "Stop speaking", description: "Stop the avatar mid-sentence and clear queued speech.", inputSchema: {} },
+    async () => {
+      await post("/api/stop", {});
+      return text("Stopped.");
+    }
+  );
+  return server;
+}
+async function runMcpServer() {
+  await createMcpServer().connect(new StdioServerTransport());
+}
+var text;
+var init_src3 = __esm({
+  "packages/mcp/src/index.ts"() {
+    "use strict";
+    init_src();
+    text = (t) => ({ content: [{ type: "text", text: t }] });
+  }
+});
+
+// packages/cli/src/index.ts
+init_src();
+import { execFile as execFile3 } from "node:child_process";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// packages/cli/src/hooks.ts
+import { readFile } from "node:fs/promises";
+async function claudeCodeReply(stdinJson) {
+  let input;
+  try {
+    input = JSON.parse(stdinJson);
+  } catch {
+    return null;
+  }
+  if (input.stop_hook_active === true) return null;
+  if (typeof input.last_assistant_message === "string" && input.last_assistant_message.trim()) {
+    return input.last_assistant_message;
+  }
+  if (typeof input.transcript_path !== "string") return null;
+  try {
+    return lastAssistantText(await readFile(input.transcript_path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function lastAssistantText(jsonl) {
+  const lines = jsonl.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (!line) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (entry.type !== "assistant" && entry.message?.role !== "assistant") continue;
+    const content = entry.message?.content;
+    const text2 = typeof content === "string" ? content : Array.isArray(content) ? content.filter((b) => b?.type === "text" && typeof b.text === "string").map((b) => b.text).join("\n") : "";
+    if (text2.trim()) return text2;
+  }
+  return null;
+}
+function codexReply(arg) {
+  if (!arg) return null;
+  try {
+    const payload = JSON.parse(arg);
+    if (payload.type !== "agent-turn-complete") return null;
+    const msg = payload["last-assistant-message"];
+    return typeof msg === "string" && msg.trim() ? msg : null;
+  } catch {
+    return null;
+  }
+}
+
+// packages/cli/src/install.ts
+import { copyFile, mkdir, readFile as readFile2, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+async function installClaudeCode(cliPath, file = join(homedir(), ".claude", "settings.json")) {
+  const command = `node ${JSON.stringify(cliPath)} hook claude-code`;
+  let settings = {};
+  try {
+    settings = JSON.parse(await readFile2(file, "utf8"));
+    await copyFile(file, `${file}.bak`);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw new Error(`Could not read ${file}: ${err.message}`);
+  }
+  const hooks = settings.hooks ??= {};
+  const stop = hooks.Stop ??= [];
+  if (JSON.stringify(stop).includes("hook claude-code")) return `Already installed in ${file}`;
+  stop.push({ hooks: [{ type: "command", command }] });
+  await mkdir(dirname(file), { recursive: true });
+  await writeFile(file, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  return `Added a Stop hook to ${file}`;
+}
+async function installCodex(cliPath, file = join(homedir(), ".codex", "config.toml")) {
+  let toml = "";
+  try {
+    toml = await readFile2(file, "utf8");
+    await copyFile(file, `${file}.bak`);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  const notes = [];
+  const q = (s) => JSON.stringify(s);
+  if (/^\s*notify\s*=/m.test(toml)) {
+    notes.push(`${file} already has a notify setting. Add agentar manually: notify = ["node", ${q(cliPath)}, "hook", "codex"]`);
+  } else {
+    toml = `notify = ["node", ${q(cliPath)}, "hook", "codex"]
+` + toml;
+    notes.push("Added notify hook (speaks each finished turn).");
+  }
+  if (/^\s*\[mcp_servers\.agentar\]/m.test(toml)) {
+    notes.push("MCP server already configured.");
+  } else {
+    toml += `${toml.endsWith("\n") || !toml ? "" : "\n"}
+[mcp_servers.agentar]
+command = "node"
+args = [${q(cliPath)}, "mcp"]
+`;
+    notes.push("Added [mcp_servers.agentar] (speak / set_mood / gesture tools).");
+  }
+  await mkdir(dirname(file), { recursive: true });
+  await writeFile(file, toml, "utf8");
+  return notes;
+}
+
+// packages/cli/src/index.ts
+var CLI_PATH = fileURLToPath2(import.meta.url);
+var BRIDGE = process.env.AGENTAR_URL ?? `http://localhost:${process.env.AGENTAR_PORT ?? DEFAULT_PORT}`;
+var HELP = `agentar (agent + avatar) \u2014 give your AI agent a body
+
+Usage:
+  agentar start [--port N] [--no-open]   Start the bridge and open the avatar in your browser
+  agentar say <text> [--mood M] [--wait] Make the avatar speak
+  agentar stop                           Stop speaking
+  agentar fetch-models [--all]           Download the built-in avatars (--all adds non-commercial samples)
+  agentar mcp                            Run the MCP server (stdio) for Claude Code / Codex
+  agentar hook claude-code               Claude Code Stop hook (reads JSON on stdin)
+  agentar hook codex <json>              Codex notify hook
+  agentar install claude-code            Speak every Claude Code reply (adds a Stop hook)
+  agentar install codex                  Configure Codex notify + MCP server
+
+Environment:
+  AGENTAR_PORT (default ${DEFAULT_PORT}), AGENTAR_URL, AGENTAR_HOME (default ~/.agentar),
+  OPENAI_API_KEY, ELEVENLABS_API_KEY, XAI_API_KEY for cloud voices,
+  AGENTAR_EDGE_TTS (path to edge-tts, if it is not on PATH).`;
+async function main(argv) {
+  const [cmd, ...rest] = argv;
+  switch (cmd) {
+    case "start":
+      return start(rest);
+    case "say":
+      return say(rest);
+    case "stop":
+      await fetch(`${BRIDGE}/api/stop`, { method: "POST" });
+      return 0;
+    case "fetch-models": {
+      const { defaultModelsDir: defaultModelsDir2, fetchModels: fetchModels2 } = await Promise.resolve().then(() => (init_src2(), src_exports));
+      return await fetchModels2(process.env.AGENTAR_MODELS_DIR ?? defaultModelsDir2(), { all: rest.includes("--all") }) ? 0 : 1;
+    }
+    case "mcp": {
+      const { runMcpServer: runMcpServer2 } = await Promise.resolve().then(() => (init_src3(), src_exports2));
+      await runMcpServer2();
+      return -1;
+    }
+    case "hook":
+      return hook(rest);
+    case "install":
+      return install(rest);
+    case void 0:
+    case "help":
+    case "--help":
+    case "-h":
+      console.log(HELP);
+      return 0;
+    default:
+      console.error(`Unknown command: ${cmd}
+
+${HELP}`);
+      return 1;
+  }
+}
+async function start(args) {
+  const portIdx = args.indexOf("--port");
+  const port = portIdx >= 0 ? Number(args[portIdx + 1]) : void 0;
+  const { defaultModelsDir: defaultModelsDir2, fetchModels: fetchModels2, startBridge: startBridge2 } = await Promise.resolve().then(() => (init_src2(), src_exports));
+  const modelsDir = process.env.AGENTAR_MODELS_DIR ?? defaultModelsDir2();
+  await fetchModels2(modelsDir, { quiet: true });
+  const bridge = await startBridge2({ ...port ? { port } : {}, modelsDir, cliPath: CLI_PATH });
+  console.log(`
+  agentar is running \u2192 ${bridge.url}
+  OBS / virtual camera view \u2192 ${bridge.url}/?stage=1
+`);
+  if (!args.includes("--no-open")) openBrowser(bridge.url);
+  const shutdown = () => void bridge.close().then(() => process.exit(0));
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  return -1;
+}
+async function say(args) {
+  const words = [];
+  let mood;
+  let wait = false;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--mood") mood = args[++i];
+    else if (args[i] === "--wait") wait = true;
+    else words.push(args[i]);
+  }
+  const text2 = words.join(" ").trim();
+  if (!text2) {
+    console.error("Usage: agentar say <text> [--mood happy] [--wait]");
+    return 1;
+  }
+  const res = await speak(text2, isMood(mood) ? mood : void 0, wait);
+  if (!res.ok) console.error(res.error);
+  return res.ok ? 0 : 1;
+}
+async function speak(text2, mood, wait = false) {
+  try {
+    const res = await fetch(`${BRIDGE}/api/say`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ text: text2, mood, wait })
+    });
+    const body = await res.json();
+    return res.ok ? { ok: true } : { ok: false, error: body.error ?? body.status };
+  } catch {
+    return { ok: false, error: `agentar is not running at ${BRIDGE}. Start it with: agentar start` };
+  }
+}
+async function hook(args) {
+  const [kind, payload] = args;
+  let reply = null;
+  if (kind === "claude-code") reply = await claudeCodeReply(await readStdin());
+  else if (kind === "codex") reply = codexReply(payload ?? args[args.length - 1]);
+  if (reply) await speak(toSpeakable(reply));
+  return 0;
+}
+async function install(args) {
+  const [target] = args;
+  if (target === "claude-code") {
+    console.log(await installClaudeCode(CLI_PATH));
+    console.log(`
+For tools Claude can call itself (speak, set_mood, gesture), also run:
+  claude mcp add agentar -- node ${JSON.stringify(CLI_PATH)} mcp`);
+    return 0;
+  }
+  if (target === "codex") {
+    for (const note of await installCodex(CLI_PATH)) console.log(note);
+    return 0;
+  }
+  console.error("Usage: agentar install <claude-code|codex>");
+  return 1;
+}
+function readStdin() {
+  if (process.stdin.isTTY) return Promise.resolve("");
+  return new Promise((resolve2) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (c) => data += c);
+    process.stdin.on("end", () => resolve2(data));
+  });
+}
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "explorer" : "xdg-open";
+  execFile3(cmd, [url], () => void 0);
+}
+main(process.argv.slice(2)).then(
+  (code) => {
+    if (code >= 0) process.exit(code);
+  },
+  (err) => {
+    console.error(err.message);
+    process.exit(1);
+  }
+);