@vibgrate/cli 2026.722.1 → 2026.727.1

package/dist/chunk-K7REHDQS.js

@@ -0,0 +1,776 @@
+import { trieHas, trieHasPrefix, maskAllowedNextChars, trieEnumerateWords, extractIdentifiers, SessionPrefixCursor, KvBlockRegistry, annotateUnknownIdentifiers, scanIdentifiersAgainstTrie, contentHash, longestWarmPrefix } from './chunk-JIBOJTGS.js';
+
+// src/runtime/llm-host/binding-capabilities.ts
+function probeBindingCapabilities(lib, model, sequence, options = {}) {
+  const l = lib;
+  const m = model;
+  const seq = sequence;
+  const env = options.env ?? process.env;
+  const tokenBias = !!(l && typeof l.TokenBias === "function");
+  const llamaGrammar = !!(l && typeof l.LlamaGrammar === "function");
+  const vocabIterate = !!(m && typeof m.iterateAllTokens === "function" && typeof m.detokenize === "function");
+  const tokenize = !!(m && typeof m.tokenize === "function");
+  const evaluateWithoutGenerate = !!(seq && typeof seq.evaluateWithoutGeneratingNewTokens === "function");
+  const envOnToken = /^(1|true|yes)$/i.test(String(env.VG_LLM_ON_TOKEN ?? env.VIBGRATE_LLM_ON_TOKEN ?? ""));
+  const envCustom = /^(1|true|yes)$/i.test(String(env.VG_LLM_CUSTOM_SAMPLER ?? ""));
+  const onTokenCallback = !!(options.assumeOnToken || envOnToken);
+  const customSampler = !!(options.assumeCustomSampler || envCustom);
+  const summary = [];
+  if (tokenBias) summary.push("TokenBias");
+  if (llamaGrammar) summary.push("LlamaGrammar");
+  if (vocabIterate) summary.push("vocabIterate");
+  if (tokenize) summary.push("tokenize");
+  if (evaluateWithoutGenerate) summary.push("evaluateWithoutGenerate");
+  if (onTokenCallback) summary.push("onToken");
+  if (customSampler) summary.push("customSampler");
+  if (summary.length === 0) summary.push("none");
+  return {
+    tokenBias,
+    llamaGrammar,
+    vocabIterate,
+    tokenize,
+    evaluateWithoutGenerate,
+    onTokenCallback,
+    customSampler,
+    summary
+  };
+}
+function supportsDynamicIdentSampler(caps) {
+  return caps.onTokenCallback || caps.customSampler;
+}
+function supportsKvPrefixEvaluate(caps) {
+  return caps.tokenize && caps.evaluateWithoutGenerate;
+}
+
+// src/runtime/llm-host/compose-constraints.ts
+function composePromptConstraints(input) {
+  const promptOpts = { ...input.base ?? {} };
+  if (input.grammar != null) promptOpts.grammar = input.grammar;
+  if (input.tokenBias != null) promptOpts.tokenBias = input.tokenBias;
+  if (input.dynamic) {
+    for (const [k, v] of Object.entries(input.dynamic)) {
+      if (v !== void 0) promptOpts[k] = v;
+    }
+  }
+  return {
+    promptOpts,
+    layers: {
+      grammar: input.grammar != null,
+      tokenBias: input.tokenBias != null,
+      dynamic: !!(input.dynamic && Object.keys(input.dynamic).length > 0)
+    }
+  };
+}
+
+// src/runtime/llm-host/grammar.ts
+async function attachGrammar(lib, gbnf) {
+  if (!gbnf?.trim()) {
+    return { value: null, method: "none", applied: false, reason: "no GBNF provided" };
+  }
+  const l = lib;
+  if (!l) {
+    return { value: null, method: "none", applied: false, reason: "no llama binding loaded" };
+  }
+  if (l.LlamaGrammar) {
+    try {
+      if (typeof l.LlamaGrammar === "function") {
+        let llama;
+        try {
+          llama = typeof l.getLlama === "function" ? await l.getLlama() : void 0;
+        } catch {
+          llama = void 0;
+        }
+        const attempts = [
+          () => new l.LlamaGrammar(llama, { grammar: gbnf }),
+          () => new l.LlamaGrammar({ grammar: gbnf }),
+          () => new l.LlamaGrammar(gbnf)
+        ];
+        for (const attempt of attempts) {
+          try {
+            const g = attempt();
+            if (g) return { value: g, method: "LlamaGrammar", applied: true };
+          } catch {
+          }
+        }
+      }
+      if (typeof l.LlamaGrammar.fromString === "function") {
+        const g = await l.LlamaGrammar.fromString(gbnf);
+        if (g) return { value: g, method: "LlamaGrammar", applied: true };
+      }
+    } catch (e) {
+      return {
+        value: null,
+        method: "none",
+        applied: false,
+        reason: `LlamaGrammar failed: ${e instanceof Error ? e.message : String(e)}`
+      };
+    }
+  }
+  if (typeof l.createGrammar === "function") {
+    try {
+      const g = await l.createGrammar(gbnf);
+      if (g) return { value: g, method: "createGrammar", applied: true };
+    } catch (e) {
+      return {
+        value: null,
+        method: "none",
+        applied: false,
+        reason: `createGrammar failed: ${e instanceof Error ? e.message : String(e)}`
+      };
+    }
+  }
+  return {
+    value: gbnf,
+    method: "string-fallback",
+    applied: false,
+    reason: "binding has no LlamaGrammar/createGrammar; raw GBNF string is available but not verified as constrained"
+  };
+}
+function assertGrammarOrThrow(result, opts = {}) {
+  if (!opts.requireGrammar) return;
+  if (result.applied) return;
+  if (opts.allowStringFallback && result.method === "string-fallback" && result.value) {
+    return;
+  }
+  throw new Error(
+    `constrained decoding required but grammar could not be attached (${result.method}${result.reason ? `: ${result.reason}` : ""}). Use a node-llama-cpp build with LlamaGrammar, or choose a Code Mode without constrainedDecoding (e.g. Flow), or set VG_ALLOW_GRAMMAR_STRING_FALLBACK=1 only if your binding documents raw GBNF support.`
+  );
+}
+function allowGrammarStringFallback(env = process.env) {
+  return env.VG_ALLOW_GRAMMAR_STRING_FALLBACK === "1" || env.VIBGRATE_ALLOW_GRAMMAR_STRING_FALLBACK === "1";
+}
+
+// src/runtime/llm-host/identifier-sampler.ts
+var IDENT_START = /[A-Za-z_]/;
+var IDENT_CONT = /[A-Za-z0-9_]/;
+var COMPLETE_IDENT = /^[A-Za-z_][A-Za-z0-9_]{2,}$/;
+var STOP = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "var",
+  "let",
+  "const",
+  "function",
+  "class",
+  "return",
+  "import",
+  "export",
+  "from",
+  "async",
+  "await",
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "this",
+  "new",
+  "typeof",
+  "interface",
+  "type",
+  "string",
+  "number",
+  "boolean",
+  "void",
+  "any",
+  "unknown",
+  "Promise",
+  "Array",
+  "Object",
+  "Error",
+  "console",
+  "process",
+  "require",
+  "module",
+  "exports",
+  "default",
+  "extends",
+  "implements",
+  "public",
+  "private",
+  "protected",
+  "static",
+  "readonly",
+  "if",
+  "else",
+  "while",
+  "switch",
+  "case",
+  "break",
+  "continue",
+  "try",
+  "catch",
+  "finally",
+  "throw",
+  "with",
+  "yield",
+  "of",
+  "in",
+  "as",
+  "is",
+  "get",
+  "set",
+  "super",
+  "delete",
+  "void",
+  "enum",
+  "package"
+]);
+function createIdentStreamState() {
+  return { mode: "free", prefix: "" };
+}
+function isStop(s) {
+  return STOP.has(s) || STOP.has(s.toLowerCase());
+}
+function stepIdentStream(state, tokenText, trie) {
+  if (!tokenText) {
+    return { next: state, allowed: true, allowedNextChars: allowedChars(state, trie) };
+  }
+  if (!trie) {
+    return { next: trackOnly(state, tokenText), allowed: true, allowedNextChars: null };
+  }
+  if (state.mode === "in_ident") {
+    const joined = state.prefix + tokenText;
+    const m = joined.match(/^[A-Za-z_][A-Za-z0-9_]*/);
+    const head = m?.[0] ?? "";
+    if (head.length >= 3 && !isStop(head) && !trieHas(trie, head) && !trieHasPrefix(trie, head)) {
+      return {
+        next: state,
+        allowed: false,
+        reason: `identifier '${head}' not in graph trie`,
+        allowedNextChars: maskAllowedNextChars(trie, state.prefix)
+      };
+    }
+  } else if (COMPLETE_IDENT.test(tokenText) && !isStop(tokenText)) {
+    if (!trieHas(trie, tokenText) && !trieHasPrefix(trie, tokenText)) {
+      return {
+        next: state,
+        allowed: false,
+        reason: `identifier '${tokenText}' not in graph trie`,
+        allowedNextChars: null
+      };
+    }
+  }
+  const next = trackOnly(state, tokenText);
+  return {
+    next,
+    allowed: true,
+    allowedNextChars: allowedChars(next, trie)
+  };
+}
+function trackOnly(state, tokenText) {
+  let mode = state.mode;
+  let prefix = state.prefix;
+  for (const ch of tokenText) {
+    if (mode === "free") {
+      if (IDENT_START.test(ch)) {
+        mode = "in_ident";
+        prefix = ch;
+      }
+    } else if (IDENT_CONT.test(ch)) {
+      prefix += ch;
+    } else {
+      mode = "free";
+      prefix = "";
+    }
+  }
+  return { mode, prefix };
+}
+function allowedChars(state, trie) {
+  if (!trie || state.mode !== "in_ident") return null;
+  return maskAllowedNextChars(trie, state.prefix);
+}
+function filterTokenTexts(state, candidates, trie) {
+  return candidates.filter((t) => stepIdentStream(state, t, trie).allowed);
+}
+function dynamicAllowedNextChars(state, trie) {
+  return allowedChars(state, trie);
+}
+function attachDynamicIdentFilter(promptOpts, trie, capabilities) {
+  const state = createIdentStreamState();
+  if (!trie) return { attached: false, method: "none", state };
+  if (capabilities.onTokenCallback) {
+    let stream = createIdentStreamState();
+    promptOpts.onToken = (tokenText) => {
+      const step = stepIdentStream(stream, tokenText, trie);
+      if (!step.allowed) return false;
+      stream = step.next;
+      return true;
+    };
+    return { attached: true, method: "onToken", state: stream };
+  }
+  if (capabilities.customSampler) {
+    let stream = createIdentStreamState();
+    promptOpts.customSampler = {
+      accept: (tokenText) => {
+        const step = stepIdentStream(stream, tokenText, trie);
+        if (!step.allowed) return false;
+        stream = step.next;
+        return true;
+      }
+    };
+    return { attached: true, method: "customSampler", state: stream };
+  }
+  return { attached: false, method: "none", state };
+}
+
+// src/runtime/llm-host/logit-mask.ts
+var COMPLETE_IDENT2 = /^[A-Za-z_][A-Za-z0-9_]{2,}$/;
+function buildIdentifierTokenBias(lib, model, trie, options = {}) {
+  if (!trie) {
+    return { applied: false, method: "none", tokenBias: null, boostedTokens: 0, suppressedTokens: 0, reason: "no trie" };
+  }
+  const l = lib;
+  const m = model;
+  if (!l || typeof l.TokenBias !== "function") {
+    if (m && typeof m.iterateAllTokens === "function") {
+      return {
+        applied: false,
+        method: "capability",
+        tokenBias: null,
+        boostedTokens: 0,
+        suppressedTokens: 0,
+        reason: "TokenBias class missing (binding can iterate tokens)"
+      };
+    }
+    return {
+      applied: false,
+      method: "none",
+      tokenBias: null,
+      boostedTokens: 0,
+      suppressedTokens: 0,
+      reason: "TokenBias unavailable"
+    };
+  }
+  const tokenizer = m?.tokenizer ?? m;
+  if (!tokenizer) {
+    return {
+      applied: false,
+      method: "none",
+      tokenBias: null,
+      boostedTokens: 0,
+      suppressedTokens: 0,
+      reason: "model.tokenizer missing"
+    };
+  }
+  let bias;
+  try {
+    bias = new l.TokenBias(tokenizer);
+  } catch (e) {
+    return {
+      applied: false,
+      method: "none",
+      tokenBias: null,
+      boostedTokens: 0,
+      suppressedTokens: 0,
+      reason: e instanceof Error ? e.message : "TokenBias construct failed"
+    };
+  }
+  const boost = options.boost ?? 0.35;
+  const maxBoostIds = options.maxBoostIds ?? 2048;
+  const words = trieEnumerateWords(trie, maxBoostIds);
+  let boostedTokens = 0;
+  for (const word of words) {
+    if (word.length < 3) continue;
+    const tokens = tokenizeBestEffort(m, word);
+    for (const tok of tokens) {
+      try {
+        if (typeof bias.set === "function") {
+          try {
+            bias.set(tok, boost);
+          } catch {
+            bias.set(tok, { logit: boost });
+          }
+          boostedTokens++;
+        }
+      } catch {
+      }
+    }
+  }
+  let suppressedTokens = 0;
+  if (options.suppressUnknown !== false && typeof m.iterateAllTokens === "function" && typeof m.detokenize === "function") {
+    const maxScan = options.maxVocabScan ?? 5e4;
+    let scanned = 0;
+    try {
+      for (const token of m.iterateAllTokens()) {
+        if (scanned++ >= maxScan) break;
+        let text = "";
+        try {
+          text = m.detokenize([token]);
+        } catch {
+          continue;
+        }
+        if (!text || !COMPLETE_IDENT2.test(text)) continue;
+        if (trieHas(trie, text) || trieHasPrefix(trie, text)) continue;
+        try {
+          bias.set(token, "never");
+          suppressedTokens++;
+        } catch {
+          try {
+            bias.set(token, -0.95);
+            suppressedTokens++;
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const method = boostedTokens > 0 || suppressedTokens > 0 ? suppressedTokens > 0 ? "TokenBias" : "TokenBias-boost" : "none";
+  return {
+    applied: method !== "none",
+    method: method === "none" ? "none" : method,
+    tokenBias: method === "none" ? null : bias,
+    boostedTokens,
+    suppressedTokens,
+    reason: method === "none" ? "no tokens adjusted" : void 0
+  };
+}
+function tokenizeBestEffort(model, text) {
+  try {
+    if (typeof model.tokenize === "function") {
+      const t = model.tokenize(text);
+      if (Array.isArray(t)) return t;
+      if (t && typeof t[Symbol.iterator] === "function") return [...t];
+    }
+  } catch {
+  }
+  try {
+    if (model.tokenizer && typeof model.tokenizer.encode === "function") {
+      const t = model.tokenizer.encode(text);
+      if (Array.isArray(t)) return t;
+    }
+  } catch {
+  }
+  return [];
+}
+function planNextCharMask(trie, partialIdent) {
+  return maskAllowedNextChars(trie, partialIdent);
+}
+function tokenCompatibleWithTrie(tokenText, trie, openPrefix = "") {
+  const joined = openPrefix + tokenText;
+  if (trieHas(trie, joined) || trieHasPrefix(trie, joined)) return true;
+  const ids = extractIdentifiers(joined);
+  if (ids.length === 0) return true;
+  return ids.every((id) => trieHas(trie, id) || trieHasPrefix(trie, id));
+}
+function trieFingerprint(trie, limit = 256) {
+  const words = trieEnumerateWords(trie, limit);
+  return `${words.length}:${words.slice(0, 32).join("|")}`;
+}
+
+// src/runtime/llm-host/speculative.ts
+function rankDraftCandidates(candidates, messages, max = 3) {
+  if (!candidates?.length) return [];
+  const last = messages[messages.length - 1]?.content?.toLowerCase() ?? "";
+  const ranked = [];
+  for (const raw of candidates) {
+    const d = raw.trim();
+    if (d.length < 8) continue;
+    let score = 0;
+    const reasons = [];
+    const head = d.slice(0, 48).toLowerCase().replace(/\s+/g, " ");
+    const tokens = head.split(/[^a-z0-9_]+/).filter((t) => t.length > 3);
+    for (const t of tokens) {
+      if (last.includes(t)) {
+        score += 3;
+        reasons.push(`token:${t}`);
+      }
+    }
+    if (/\b(signature|import|export function|export class|implements|extends)\b/i.test(last)) {
+      score += 2;
+      reasons.push("quotational-ask");
+    }
+    if (/^export\s+(async\s+)?(function|class|const|type|interface)\b/.test(d)) {
+      score += 1;
+      reasons.push("export-shape");
+    }
+    if (score > 0) {
+      ranked.push({ text: d, score, reason: reasons.join(",") || "match" });
+    }
+  }
+  if (ranked.length === 0 && /\b(signature|import|export function|export class)\b/i.test(last)) {
+    for (const d of candidates.slice(0, max)) {
+      if (d.trim().length >= 8) ranked.push({ text: d.trim(), score: 1, reason: "fallback-quotational" });
+    }
+  }
+  return ranked.sort((a, b) => b.score - a.score || b.text.length - a.text.length).slice(0, max);
+}
+function pickBestDraft(candidates, messages) {
+  return rankDraftCandidates(candidates, messages, 1)[0]?.text ?? null;
+}
+
+// src/runtime/llm-host/session.ts
+var globalPool = /* @__PURE__ */ new Map();
+function sessionKey(modelPath) {
+  return `embedded:${modelPath}`;
+}
+function clearHostSessionPool() {
+  globalPool.clear();
+}
+function hostSessionPoolSize() {
+  return globalPool.size;
+}
+function listHostSessions() {
+  return [...globalPool.values()].map((s) => ({
+    key: s.key,
+    modelPath: s.modelPath,
+    loads: s.loads,
+    lastUsed: s.lastUsed,
+    kvBlocks: s.kv.size(),
+    cursorBlocks: s.cursor.evaluatedHashes.length,
+    bindingCaps: s.caps?.summary ?? null
+  })).sort((a, b) => b.lastUsed - a.lastUsed);
+}
+function dropHostSession(modelPathOrKey) {
+  const key = modelPathOrKey.startsWith("embedded:") ? modelPathOrKey : sessionKey(modelPathOrKey);
+  return globalPool.delete(key);
+}
+async function acquireHostSession(lib, modelPath) {
+  const key = sessionKey(modelPath);
+  const existing = globalPool.get(key);
+  if (existing) {
+    existing.lastUsed = Date.now();
+    return existing;
+  }
+  const l = lib;
+  if (!l || typeof l.getLlama !== "function") {
+    throw new Error("llm-host session: invalid node-llama-cpp module (getLlama missing)");
+  }
+  const llama = await l.getLlama();
+  const model = await llama.loadModel({ modelPath });
+  const context = await model.createContext();
+  const sequence = context.getSequence();
+  const { LlamaChatSession } = l;
+  if (typeof LlamaChatSession !== "function") {
+    throw new Error("llm-host session: LlamaChatSession missing");
+  }
+  const chat = new LlamaChatSession({ contextSequence: sequence });
+  const sess = {
+    key,
+    lib: l,
+    modelPath,
+    model,
+    context,
+    sequence,
+    chat,
+    kv: new KvBlockRegistry(),
+    cursor: new SessionPrefixCursor(),
+    lastUsed: Date.now(),
+    loads: 1,
+    logitMaskCache: /* @__PURE__ */ new Map(),
+    caps: null
+  };
+  globalPool.set(key, sess);
+  return sess;
+}
+function evictIdleSessions(maxSessions = 2, maxIdleMs = 30 * 6e4, now = Date.now()) {
+  if (globalPool.size <= maxSessions) {
+    let dropped2 = 0;
+    for (const [k, s] of globalPool) {
+      if (now - s.lastUsed > maxIdleMs) {
+        globalPool.delete(k);
+        dropped2++;
+      }
+    }
+    return dropped2;
+  }
+  const ordered = [...globalPool.entries()].sort((a, b) => a[1].lastUsed - b[1].lastUsed);
+  let dropped = 0;
+  while (globalPool.size > maxSessions && ordered.length) {
+    const [k] = ordered.shift();
+    globalPool.delete(k);
+    dropped++;
+  }
+  return dropped;
+}
+async function generateOnSession(session, messages, extras = {}) {
+  const t0 = Date.now();
+  const warmStart = session.loads > 0 && session.lastUsed > 0;
+  session.loads++;
+  session.lastUsed = Date.now();
+  const env = extras.env ?? process.env;
+  const caps = session.caps ?? probeBindingCapabilities(session.lib, session.model, session.sequence, {
+    assumeOnToken: extras.assumeOnToken,
+    assumeCustomSampler: extras.assumeCustomSampler,
+    env
+  });
+  session.caps = caps;
+  const segments = extras.promptSegments ?? messages.map((m, i) => ({
+    kind: m.role === "system" ? "system" : i === messages.length - 1 ? "user" : "context",
+    text: m.content
+  }));
+  const kvPlan = session.kv.plan(segments, session.cursor);
+  const prefixReuse = await tryReuseWarmPrefix(session, segments, kvPlan, caps);
+  const ranked = rankDraftCandidates(extras.draftCandidates, messages, 3);
+  let draftAcceptedChars = 0;
+  let draftCandidatesTried = 0;
+  let text = "";
+  const stringOk = allowGrammarStringFallback(env);
+  const grammar = await attachGrammar(session.lib, extras.grammar);
+  assertGrammarOrThrow(grammar, {
+    requireGrammar: extras.requireGrammar,
+    allowStringFallback: stringOk
+  });
+  let promptGrammar = null;
+  if (grammar.applied) promptGrammar = grammar.value;
+  else if (grammar.method === "string-fallback" && grammar.value && (stringOk || !extras.requireGrammar)) {
+    promptGrammar = grammar.value;
+  }
+  const mask = resolveLogitMask(session, extras.identifierTrie, extras.suppressUnknownLogits !== false);
+  const baseOpts = {
+    temperature: extras.temperature ?? 0
+  };
+  if (typeof extras.maxTokens === "number") baseOpts.maxTokens = extras.maxTokens;
+  const dynBag = {};
+  let dynamicAttached = false;
+  let dynMethod = "none";
+  if (extras.identifierTrie && supportsDynamicIdentSampler(caps)) {
+    const dyn = attachDynamicIdentFilter(dynBag, extras.identifierTrie, {
+      onTokenCallback: caps.onTokenCallback,
+      customSampler: caps.customSampler
+    });
+    dynamicAttached = dyn.attached;
+    dynMethod = dyn.method;
+  }
+  const composed = composePromptConstraints({
+    base: baseOpts,
+    grammar: promptGrammar,
+    tokenBias: mask.tokenBias,
+    dynamic: dynamicAttached ? dynBag : null
+  });
+  const samplerMethod = resolveSamplerMethod(mask, dynamicAttached, dynMethod);
+  if (ranked.length) {
+    let accepted = null;
+    for (const d of ranked) {
+      draftCandidatesTried++;
+      if (await tryAcceptDraft(session, d.text, caps)) {
+        accepted = d.text;
+        break;
+      }
+    }
+    if (accepted) {
+      draftAcceptedChars = accepted.length;
+      text = accepted;
+      const continueMsgs = [
+        ...messages,
+        { role: "assistant", content: accepted },
+        { role: "user", content: "Continue from the draft above without repeating it." }
+      ];
+      const cont = await sessionPrompt(session, continueMsgs, composed.promptOpts);
+      text = accepted + (cont.startsWith(accepted) ? cont.slice(accepted.length) : cont);
+    } else {
+      text = await sessionPrompt(session, messages, composed.promptOpts);
+    }
+  } else {
+    text = await sessionPrompt(session, messages, composed.promptOpts);
+  }
+  session.kv.commit(segments);
+  session.cursor.commit(kvPlan.order);
+  let unknownIdentifiers;
+  if (extras.identifierTrie) {
+    if (extras.annotateUnknownIdentifiers !== false) {
+      const ann = annotateUnknownIdentifiers(text, extras.identifierTrie);
+      text = ann.text;
+      unknownIdentifiers = ann.unknown.length ? ann.unknown : void 0;
+    } else {
+      const scan = scanIdentifiersAgainstTrie(text, extras.identifierTrie);
+      unknownIdentifiers = scan.unknown.length ? scan.unknown : void 0;
+    }
+  }
+  return {
+    text,
+    model: session.modelPath,
+    isolation: "embedded",
+    constrained: grammar.applied || !!promptGrammar && stringOk || dynamicAttached,
+    unknownIdentifiers,
+    draftAcceptedChars,
+    draftCandidatesTried,
+    kvPlan,
+    grammarApplied: grammar.applied || !!promptGrammar && stringOk && grammar.method === "string-fallback",
+    grammarMethod: grammar.method,
+    samplerHook: mask.applied || dynamicAttached,
+    samplerMethod,
+    samplerBoostedTokens: mask.boostedTokens,
+    samplerSuppressedTokens: mask.suppressedTokens,
+    dynamicSampler: dynamicAttached,
+    kvPrefixReusedTokens: prefixReuse.tokens,
+    kvDeltaTokens: kvPlan.deltaTokens,
+    bindingCaps: caps.summary,
+    constraintLayers: composed.layers,
+    warmStart,
+    latencyMs: Date.now() - t0
+  };
+}
+function resolveSamplerMethod(mask, dynamicAttached, dynMethod) {
+  if (mask.applied && dynamicAttached) return "TokenBias+dynamic";
+  if (dynamicAttached && dynMethod === "onToken") return "dynamic-onToken";
+  if (dynamicAttached && dynMethod === "customSampler") return "dynamic-customSampler";
+  return mask.method;
+}
+function resolveLogitMask(session, trie, suppressUnknown) {
+  if (!trie) {
+    return { applied: false, method: "none", tokenBias: null, boostedTokens: 0, suppressedTokens: 0 };
+  }
+  const fp = `${trieFingerprint(trie)}|sup=${suppressUnknown ? 1 : 0}`;
+  const cached = session.logitMaskCache.get(fp);
+  if (cached) return cached;
+  const built = buildIdentifierTokenBias(session.lib, session.model, trie, {
+    suppressUnknown
+  });
+  if (session.logitMaskCache.size > 8) session.logitMaskCache.clear();
+  session.logitMaskCache.set(fp, built);
+  return built;
+}
+async function sessionPrompt(session, messages, promptOpts) {
+  const prompt = messages.map((m) => `${m.role}: ${m.content}`).join("\n\n");
+  const text = await session.chat.prompt(prompt, promptOpts);
+  return typeof text === "string" ? text : String(text ?? "");
+}
+async function tryAcceptDraft(session, draft, caps) {
+  try {
+    const seq = session.sequence;
+    if (caps.evaluateWithoutGenerate && caps.tokenize && seq && typeof seq.evaluateWithoutGeneratingNewTokens === "function") {
+      const model = session.model;
+      if (model && typeof model.tokenize === "function") {
+        const tokens = model.tokenize(draft);
+        await seq.evaluateWithoutGeneratingNewTokens(tokens);
+        return true;
+      }
+    }
+  } catch {
+  }
+  return session.kv.isWarm(contentHash(draft));
+}
+async function tryReuseWarmPrefix(session, segments, plan, caps) {
+  const prefix = longestWarmPrefix(session.kv, segments);
+  if (prefix.count === 0 && (plan.cursorSkipBlocks ?? 0) === 0) {
+    return { tokens: 0, method: "none" };
+  }
+  const canEval = caps.tokenize && caps.evaluateWithoutGenerate;
+  try {
+    const seq = session.sequence;
+    const model = session.model;
+    if (canEval && seq && typeof seq.evaluateWithoutGeneratingNewTokens === "function" && model && typeof model.tokenize === "function") {
+      const delta = session.cursor.delta(plan.order, segments);
+      if (delta.skipBlocks > 0 && delta.evaluateText) {
+        const tokens2 = model.tokenize(delta.evaluateText);
+        await seq.evaluateWithoutGeneratingNewTokens(tokens2);
+        return { tokens: plan.hitTokens, method: "evaluate-delta" };
+      }
+      if (prefix.text) {
+        const tokens2 = model.tokenize(prefix.text);
+        await seq.evaluateWithoutGeneratingNewTokens(tokens2);
+        return { tokens: prefix.tokens, method: "evaluate-prefix" };
+      }
+    }
+  } catch {
+  }
+  const tokens = prefix.tokens || plan.hitTokens;
+  if (tokens > 0) return { tokens, method: "plan-only" };
+  return { tokens: 0, method: "none" };
+}
+
+export { acquireHostSession, allowGrammarStringFallback, assertGrammarOrThrow, attachDynamicIdentFilter, attachGrammar, buildIdentifierTokenBias, clearHostSessionPool, composePromptConstraints, createIdentStreamState, dropHostSession, dynamicAllowedNextChars, evictIdleSessions, filterTokenTexts, generateOnSession, hostSessionPoolSize, listHostSessions, pickBestDraft, planNextCharMask, probeBindingCapabilities, rankDraftCandidates, sessionKey, stepIdentStream, supportsDynamicIdentSampler, supportsKvPrefixEvaluate, tokenCompatibleWithTrie, trieFingerprint };
+//# sourceMappingURL=chunk-K7REHDQS.js.map
+//# sourceMappingURL=chunk-K7REHDQS.js.map