promptopskit 0.7.1 → 0.8.1

package/dist/chunk-RVAFVWR2.js

@@ -0,0 +1,1760 @@
+import {
+  loadPromptFile,
+  parsePrompt
+} from "./chunk-E4GEKWVP.js";
+
+// src/renderer/interpolate.ts
+var VARIABLE_RE = /\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*)(?:\s*\|\s*(compress|toon|compact|code))?\s*\}\}/g;
+var ESCAPED_OPEN = /\\\{\\\{/g;
+var ESCAPE_PLACEHOLDER = "\0ESCAPED_OPEN\0";
+function interpolate(template, variables, options = {}) {
+  const { strict = false } = options;
+  const optionalVariables = new Set(options.optionalVariables ?? []);
+  let result = template.replace(ESCAPED_OPEN, ESCAPE_PLACEHOLDER);
+  result = result.replace(VARIABLE_RE, (match, name, modifier) => {
+    if (name in variables) {
+      const value = variables[name];
+      return options.transformVariable ? options.transformVariable({ name, value, modifier, match }) : value;
+    }
+    if (strict && !optionalVariables.has(name)) {
+      throw new Error(`Missing required variable: "${name}"`);
+    }
+    return match;
+  });
+  result = result.replaceAll(ESCAPE_PLACEHOLDER, "{{");
+  return result;
+}
+function extractVariables(template) {
+  const vars = /* @__PURE__ */ new Set();
+  let match;
+  const re = new RegExp(VARIABLE_RE.source, "g");
+  while ((match = re.exec(template)) !== null) {
+    vars.add(match[1]);
+  }
+  return [...vars];
+}
+
+// src/context.ts
+var textEncoder = new TextEncoder();
+var REJECT_SECRETS_PATTERN = "(secret|api[_-]?key|password)";
+var REJECT_SECRETS_FLAGS = "i";
+function getContextInputs(asset) {
+  return (asset.context?.inputs ?? []).map(normalizeContextInput);
+}
+function normalizeContextInput(input) {
+  if (typeof input === "string") {
+    return { name: input };
+  }
+  return {
+    name: input.name,
+    optional: input.optional,
+    warnings: input.warnings,
+    max_size: input.max_size,
+    trim: input.trim,
+    compression: normalizeContextInputCompression(input.compression),
+    allow_regex: normalizeContextRegex(input.allow_regex),
+    deny_regex: normalizeContextRegex(input.deny_regex),
+    non_empty: normalizeBuiltInValidator(input.non_empty),
+    reject_secrets: normalizeBuiltInValidator(input.reject_secrets)
+  };
+}
+function normalizeContextInputCompression(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value === "heuristic") {
+    return { heuristic: { enabled: true } };
+  }
+  if (value === "code") {
+    return { code: { enabled: true } };
+  }
+  if (value.heuristic === void 0) {
+    return normalizeCodeCompression(value.code);
+  }
+  const normalized = {
+    heuristic: {
+      enabled: value.heuristic.enabled ?? true,
+      min_tokens: value.heuristic.min_tokens,
+      max_sentences: value.heuristic.max_sentences,
+      target_reduction: value.heuristic.target_reduction,
+      query: value.heuristic.query,
+      query_variable: value.heuristic.query_variable,
+      json_to_toon: value.heuristic.json_to_toon
+    }
+  };
+  const code = normalizeCodeCompression(value.code);
+  if (code?.code) {
+    normalized.code = code.code;
+  }
+  return normalized;
+}
+function normalizeCodeCompression(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return {
+    code: {
+      enabled: value.enabled ?? true,
+      remove_comments: value.remove_comments,
+      trim_indentation: value.trim_indentation,
+      collapse_blank_lines: value.collapse_blank_lines
+    }
+  };
+}
+function areContextInputWarningsEnabled(input) {
+  return input.warnings !== false;
+}
+function normalizeContextRegex(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    const literal = parseRegexLiteral(value);
+    if (value.startsWith("/") && !literal) {
+      return {
+        pattern: value,
+        flags: "",
+        raw: value,
+        invalidLiteral: true
+      };
+    }
+    return {
+      pattern: literal?.pattern ?? value,
+      flags: literal?.flags ?? "",
+      raw: value
+    };
+  }
+  return {
+    pattern: value.pattern,
+    flags: value.flags ?? "",
+    raw: JSON.stringify(value),
+    returnMessage: value.return_message
+  };
+}
+function normalizeBuiltInValidator(value) {
+  if (value === void 0 || value === false) {
+    return void 0;
+  }
+  if (value === true) {
+    return {};
+  }
+  return {
+    returnMessage: value.return_message
+  };
+}
+function parseRegexLiteral(value) {
+  if (!value.startsWith("/")) {
+    return void 0;
+  }
+  for (let index = value.length - 1; index > 0; index -= 1) {
+    if (value[index] !== "/") {
+      continue;
+    }
+    let backslashCount = 0;
+    for (let cursor = index - 1; cursor >= 0 && value[cursor] === "\\"; cursor -= 1) {
+      backslashCount += 1;
+    }
+    if (backslashCount % 2 === 1) {
+      continue;
+    }
+    return {
+      pattern: value.slice(1, index),
+      flags: value.slice(index + 1)
+    };
+  }
+  return void 0;
+}
+function formatInvalidContextRegexMessage(details) {
+  return [
+    `Invalid context regex for prompt "${details.promptId}"`,
+    `variable "${details.variable}"`,
+    `field "${details.field}"`,
+    `value ${JSON.stringify(details.raw)}: ${details.reason}`
+  ].join(", ");
+}
+function compileContextRegex(regex, details) {
+  if (regex.invalidLiteral) {
+    throw new Error(
+      `POK013: ${formatInvalidContextRegexMessage({
+        ...details,
+        raw: regex.raw,
+        reason: "Malformed regex literal. Use /pattern/flags or { pattern, flags }."
+      })}`
+    );
+  }
+  try {
+    return new RegExp(regex.pattern, regex.flags);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(`POK013: ${formatInvalidContextRegexMessage({ ...details, raw: regex.raw, reason })}`);
+  }
+}
+function getRejectSecretsRegex() {
+  return {
+    pattern: REJECT_SECRETS_PATTERN,
+    flags: REJECT_SECRETS_FLAGS,
+    raw: JSON.stringify({ pattern: REJECT_SECRETS_PATTERN, flags: REJECT_SECRETS_FLAGS })
+  };
+}
+function isTrimEnabled(mode) {
+  return mode === true || mode === "start" || mode === "end" || mode === "both";
+}
+function normalizeTrimMode(mode) {
+  if (mode === "start") {
+    return "start";
+  }
+  return "end";
+}
+function trimToMaxSize(value, maxSize, mode) {
+  const measured = measureContextValueSize(value);
+  if (measured <= maxSize) {
+    return value;
+  }
+  const characters = Array.from(value);
+  const normalizedMode = normalizeTrimMode(mode);
+  if (normalizedMode === "start") {
+    let collected2 = "";
+    let size2 = 0;
+    for (let i = characters.length - 1; i >= 0; i -= 1) {
+      const next = characters[i];
+      const charSize = measureContextValueSize(next);
+      if (size2 + charSize > maxSize) {
+        break;
+      }
+      collected2 = next + collected2;
+      size2 += charSize;
+    }
+    return collected2;
+  }
+  let collected = "";
+  let size = 0;
+  for (const char of characters) {
+    const charSize = measureContextValueSize(char);
+    if (size + charSize > maxSize) {
+      break;
+    }
+    collected += char;
+    size += charSize;
+  }
+  return collected;
+}
+function sanitizeContextVariables(asset, variables = {}, options = {}) {
+  const { onContextOverflow } = options;
+  const sanitized = { ...variables };
+  for (const input of getContextInputs(asset)) {
+    const value = sanitized[input.name];
+    if (value === void 0) {
+      continue;
+    }
+    let candidate = value;
+    if (input.max_size !== void 0) {
+      const actualSize = measureContextValueSize(candidate);
+      if (actualSize > input.max_size && onContextOverflow) {
+        candidate = onContextOverflow({
+          promptId: asset.id,
+          variable: input.name,
+          value: candidate,
+          maxSize: input.max_size,
+          actualSize
+        });
+      }
+    }
+    if (isTrimEnabled(input.trim) && input.max_size !== void 0) {
+      candidate = trimToMaxSize(candidate, input.max_size, input.trim);
+    }
+    sanitized[input.name] = candidate;
+    if (input.allow_regex) {
+      const candidate2 = sanitized[input.name];
+      const matcher = compileContextRegex(input.allow_regex, {
+        promptId: asset.id,
+        variable: input.name,
+        field: "allow_regex"
+      });
+      if (!matcher.test(candidate2)) {
+        if (input.allow_regex.returnMessage) {
+          return {
+            variables: sanitized,
+            shortCircuit: {
+              returnMessage: input.allow_regex.returnMessage,
+              code: "POK031",
+              variable: input.name,
+              field: "allow_regex"
+            }
+          };
+        }
+        throw new Error(
+          `POK031: Context variable "${input.name}" failed allow_regex validation for prompt "${asset.id}".`
+        );
+      }
+    }
+    if (input.deny_regex) {
+      const candidate2 = sanitized[input.name];
+      const matcher = compileContextRegex(input.deny_regex, {
+        promptId: asset.id,
+        variable: input.name,
+        field: "deny_regex"
+      });
+      if (matcher.test(candidate2)) {
+        if (input.deny_regex.returnMessage) {
+          return {
+            variables: sanitized,
+            shortCircuit: {
+              returnMessage: input.deny_regex.returnMessage,
+              code: "POK032",
+              variable: input.name,
+              field: "deny_regex"
+            }
+          };
+        }
+        throw new Error(
+          `POK032: Context variable "${input.name}" matched deny_regex for prompt "${asset.id}".`
+        );
+      }
+    }
+    if (input.non_empty && candidate.trim().length === 0) {
+      if (input.non_empty.returnMessage) {
+        return {
+          variables: sanitized,
+          shortCircuit: {
+            returnMessage: input.non_empty.returnMessage,
+            code: "POK033",
+            variable: input.name,
+            field: "non_empty"
+          }
+        };
+      }
+      throw new Error(
+        `POK033: Context variable "${input.name}" failed non_empty validation for prompt "${asset.id}".`
+      );
+    }
+    if (input.reject_secrets) {
+      const matcher = compileContextRegex(getRejectSecretsRegex(), {
+        promptId: asset.id,
+        variable: input.name,
+        field: "reject_secrets"
+      });
+      if (matcher.test(candidate)) {
+        if (input.reject_secrets.returnMessage) {
+          return {
+            variables: sanitized,
+            shortCircuit: {
+              returnMessage: input.reject_secrets.returnMessage,
+              code: "POK034",
+              variable: input.name,
+              field: "reject_secrets"
+            }
+          };
+        }
+        throw new Error(
+          `POK034: Context variable "${input.name}" matched reject_secrets validation for prompt "${asset.id}".`
+        );
+      }
+    }
+  }
+  return { variables: sanitized };
+}
+function measureContextValueSize(value) {
+  return textEncoder.encode(value).length;
+}
+function collectContextSizeWarnings(asset, variables = {}) {
+  const warnings = [];
+  for (const input of getContextInputs(asset)) {
+    if (!areContextInputWarningsEnabled(input)) {
+      continue;
+    }
+    if (input.max_size === void 0) {
+      continue;
+    }
+    const value = variables[input.name];
+    if (value === void 0) {
+      continue;
+    }
+    const actualSize = measureContextValueSize(value);
+    if (actualSize > input.max_size) {
+      warnings.push({
+        variable: input.name,
+        maxSize: input.max_size,
+        actualSize
+      });
+    }
+  }
+  return warnings;
+}
+
+// src/toon-encoding.ts
+var DEFAULT_INDENT = 2;
+var DEFAULT_DELIMITER = ",";
+function tryJsonToToon(text, options = {}) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return void 0;
+  }
+  const value = normalizeJsonValue(parsed);
+  if (value === void 0) {
+    return void 0;
+  }
+  return {
+    output: encodeToon(value, options),
+    value
+  };
+}
+function encodeToon(value, options = {}) {
+  const resolved = {
+    indent: options.indent ?? DEFAULT_INDENT,
+    delimiter: options.delimiter ?? DEFAULT_DELIMITER
+  };
+  return encodeValue(value, void 0, 0, resolved).join("\n");
+}
+function normalizeJsonValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => normalizeJsonValue(item) ?? null);
+  }
+  if (isPlainObject(value)) {
+    const normalized = {};
+    for (const [key, child] of Object.entries(value)) {
+      normalized[key] = normalizeJsonValue(child) ?? null;
+    }
+    return normalized;
+  }
+  return void 0;
+}
+function encodeValue(value, key, depth, options) {
+  if (isPrimitive(value)) {
+    return [line(depth, key === void 0 ? encodePrimitive(value, options.delimiter) : `${encodeKey(key)}: ${encodePrimitive(value, options.delimiter)}`, options.indent)];
+  }
+  if (Array.isArray(value)) {
+    return encodeArray(value, key, depth, options);
+  }
+  return encodeObject(value, key, depth, options);
+}
+function encodeObject(value, key, depth, options) {
+  const entries = Object.entries(value);
+  const lines = [];
+  if (key !== void 0) {
+    lines.push(line(depth, `${encodeKey(key)}:`, options.indent));
+  }
+  const childDepth = key === void 0 ? depth : depth + 1;
+  for (const [childKey, childValue] of entries) {
+    lines.push(...encodeValue(childValue, childKey, childDepth, options));
+  }
+  return lines;
+}
+function encodeArray(value, key, depth, options) {
+  const prefix = key === void 0 ? "" : encodeKey(key);
+  if (value.length === 0) {
+    return [line(depth, key === void 0 ? "[]" : `${prefix}: []`, options.indent)];
+  }
+  if (value.every(isPrimitive)) {
+    const joined = value.map((item) => encodePrimitive(item, options.delimiter)).join(options.delimiter);
+    return [line(depth, `${prefix}[${value.length}]: ${joined}`, options.indent)];
+  }
+  const tabularFields = getTabularFields(value);
+  if (tabularFields) {
+    const lines2 = [
+      line(depth, `${prefix}[${value.length}]{${tabularFields.map(encodeKey).join(options.delimiter)}}:`, options.indent)
+    ];
+    for (const row of value) {
+      lines2.push(line(depth + 1, tabularFields.map((field) => encodePrimitive(row[field], options.delimiter)).join(options.delimiter), options.indent));
+    }
+    return lines2;
+  }
+  const lines = [line(depth, `${prefix}[${value.length}]:`, options.indent)];
+  for (const item of value) {
+    lines.push(...encodeListItem(item, depth + 1, options));
+  }
+  return lines;
+}
+function encodeListItem(value, depth, options) {
+  if (isPrimitive(value)) {
+    return [line(depth, `- ${encodePrimitive(value, options.delimiter)}`, options.indent)];
+  }
+  if (Array.isArray(value)) {
+    const encoded = encodeArray(value, void 0, depth, options);
+    return encoded.map((item, index) => {
+      if (index === 0) {
+        return line(depth, `- ${item.trimStart()}`, options.indent);
+      }
+      return item;
+    });
+  }
+  const entries = Object.entries(value);
+  if (entries.length === 0) {
+    return [line(depth, "-", options.indent)];
+  }
+  const [firstKey, firstValue] = entries[0];
+  const rest = Object.fromEntries(entries.slice(1));
+  const firstLines = encodeValue(firstValue, firstKey, depth, options);
+  const lines = [line(depth, `- ${firstLines[0].trimStart()}`, options.indent)];
+  for (const continuation of firstLines.slice(1)) {
+    lines.push(continuation);
+  }
+  if (Object.keys(rest).length > 0) {
+    lines.push(...encodeObject(rest, void 0, depth + 1, options));
+  }
+  return lines;
+}
+function getTabularFields(value) {
+  if (value.length === 0 || !value.every(isObjectRecord)) {
+    return void 0;
+  }
+  const first = value[0];
+  const fields = Object.keys(first);
+  if (fields.length === 0) {
+    return void 0;
+  }
+  for (const row of value) {
+    const keys = Object.keys(row);
+    if (keys.length !== fields.length) {
+      return void 0;
+    }
+    for (const field of fields) {
+      if (!(field in row) || !isPrimitive(row[field])) {
+        return void 0;
+      }
+    }
+  }
+  return fields;
+}
+function encodePrimitive(value, delimiter) {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return encodeString(value, delimiter);
+}
+function encodeString(value, delimiter) {
+  if (isSafeUnquotedString(value, delimiter)) {
+    return value;
+  }
+  return JSON.stringify(value);
+}
+function encodeKey(key) {
+  if (/^[A-Z_][\w.]*$/i.test(key)) {
+    return key;
+  }
+  return JSON.stringify(key);
+}
+function isSafeUnquotedString(value, delimiter) {
+  if (value.length === 0 || value !== value.trim()) {
+    return false;
+  }
+  if (/^(?:true|false|null)$/i.test(value) || /^-?\d+(?:\.\d+)?(?:e[+-]?\d+)?$/i.test(value) || /^0\d+$/.test(value)) {
+    return false;
+  }
+  if (value.includes(":") || value.includes('"') || value.includes("\\") || value.includes(delimiter)) {
+    return false;
+  }
+  if (/[[\]{}]|[\u0000-\u001F]/.test(value) || value.startsWith("-")) {
+    return false;
+  }
+  return true;
+}
+function isPrimitive(value) {
+  return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function isObjectRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === null || prototype === Object.prototype;
+}
+function line(depth, content, indent) {
+  return `${" ".repeat(depth * indent)}${content}`;
+}
+
+// src/token-compression.ts
+var TOKEN_REGEX = /[\p{L}\p{N}]+|[^\s]/gu;
+var TOKEN_NORMALIZE_REGEX = /[^\p{L}\p{N}]/gu;
+var DEDUPE_NORMALIZE_REGEX = /[^\p{L}\p{N}\s]/gu;
+var BOILERPLATE_REGEX = /copyright|all rights reserved|disclaimer|confidential/i;
+var MAX_SEGMENT_TOKENS = 120;
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "by",
+  "for",
+  "from",
+  "how",
+  "in",
+  "is",
+  "it",
+  "of",
+  "on",
+  "or",
+  "that",
+  "the",
+  "this",
+  "to",
+  "was",
+  "we",
+  "with",
+  "you",
+  "your",
+  "our"
+]);
+var DEFAULT_OPTIONS = {
+  min_tokens: 80,
+  max_sentences: 10,
+  target_reduction: 0.45
+};
+function tokenizeForHeuristicCompression(text) {
+  if (!text) {
+    return [];
+  }
+  return text.match(TOKEN_REGEX) ?? [];
+}
+function estimateHeuristicTokens(text) {
+  return tokenizeForHeuristicCompression(text).length;
+}
+function compressHeuristicText(input, options = {}) {
+  const inputText = input ?? "";
+  const inputTokens = estimateHeuristicTokens(inputText);
+  if (options.json_to_toon === true) {
+    const toonResult = tryJsonToToon(inputText);
+    if (toonResult) {
+      const toonOutputTokens = estimateHeuristicTokens(toonResult.output);
+      if (toonOutputTokens <= inputTokens) {
+        return {
+          ...toCompressionOutput(toonResult.output, inputTokens),
+          outputFormat: "toon"
+        };
+      }
+      return {
+        ...toCompressionOutput(inputText, inputTokens),
+        warnings: ["JSON-to-TOON skipped because TOON was not smaller than the original JSON."]
+      };
+    }
+    return {
+      ...toCompressionOutput(inputText, inputTokens),
+      warnings: ["JSON-to-TOON skipped because the input is not a complete valid JSON object or array."]
+    };
+  }
+  const analysis = preprocessContext(inputText);
+  if (inputTokens === 0) {
+    return toCompressionOutput(inputText, inputTokens);
+  }
+  const minTokens = options.min_tokens ?? DEFAULT_OPTIONS.min_tokens;
+  if (inputTokens <= minTokens) {
+    return toCompressionOutput(inputText, inputTokens);
+  }
+  const targetReduction = options.target_reduction ?? DEFAULT_OPTIONS.target_reduction;
+  const targetTokens = Math.max(1, Math.max(minTokens, Math.floor(inputTokens * (1 - targetReduction))));
+  const maxSentences = options.max_sentences ?? DEFAULT_OPTIONS.max_sentences;
+  const query = options.query ?? "";
+  const terms = queryTerms(query);
+  const scoredSentences = analysis.candidates.map((candidate) => ({
+    sentence: candidate.sentence,
+    index: candidate.index,
+    ...scoreSentenceCandidate(candidate, terms),
+    tokens: candidate.tokenCount
+  }));
+  const selected = [];
+  const selectedIndices = /* @__PURE__ */ new Set();
+  const coveredTerms = /* @__PURE__ */ new Set();
+  let selectedTokens = 0;
+  while (selected.length < maxSentences) {
+    let bestCandidate;
+    let bestAdjustedScore = Number.NEGATIVE_INFINITY;
+    for (const candidate of scoredSentences) {
+      if (selectedIndices.has(candidate.index)) {
+        continue;
+      }
+      const underBudget = selectedTokens + candidate.tokens <= targetTokens;
+      const forceTopCandidate = selected.length === 0;
+      const forceRelevantSecond = selected.length === 1 && candidate.overlapCount > 0;
+      if (!underBudget && !forceTopCandidate && !forceRelevantSecond) {
+        continue;
+      }
+      let uncoveredOverlapCount = 0;
+      for (const term of candidate.overlapTerms) {
+        if (!coveredTerms.has(term)) {
+          uncoveredOverlapCount += 1;
+        }
+      }
+      const adjustedScore = candidate.score + uncoveredOverlapCount * 1.2;
+      if (adjustedScore > bestAdjustedScore || adjustedScore === bestAdjustedScore && bestCandidate && isBetterTieBreak(candidate, bestCandidate)) {
+        bestAdjustedScore = adjustedScore;
+        bestCandidate = candidate;
+      }
+    }
+    if (!bestCandidate) {
+      break;
+    }
+    selected.push(bestCandidate);
+    selectedIndices.add(bestCandidate.index);
+    selectedTokens += bestCandidate.tokens;
+    for (const term of bestCandidate.overlapTerms) {
+      coveredTerms.add(term);
+    }
+  }
+  selected.sort((left, right) => left.index - right.index);
+  let output = selected.map((item) => item.sentence).join(" ");
+  if (!output) {
+    output = tokenizeForHeuristicCompression(inputText).slice(0, targetTokens).join(" ");
+  } else {
+    const outputTokens = tokenizeForHeuristicCompression(output);
+    if (outputTokens.length > targetTokens) {
+      output = outputTokens.slice(0, targetTokens).join(" ");
+    }
+  }
+  return toCompressionOutput(output, inputTokens);
+}
+function toCompressionOutput(output, inputTokens) {
+  const outputTokens = estimateHeuristicTokens(output);
+  const tokensSaved = Math.max(0, inputTokens - outputTokens);
+  return {
+    output,
+    inputTokens,
+    outputTokens,
+    tokensSaved,
+    compressionRatio: outputTokens === 0 ? 0 : inputTokens / outputTokens
+  };
+}
+function isBetterTieBreak(candidate, bestCandidate) {
+  if (candidate.overlapCount !== bestCandidate.overlapCount) {
+    return candidate.overlapCount > bestCandidate.overlapCount;
+  }
+  if (candidate.tokens !== bestCandidate.tokens) {
+    return candidate.tokens < bestCandidate.tokens;
+  }
+  return candidate.index < bestCandidate.index;
+}
+function normalizeForDeduping(sentence) {
+  return sentence.toLowerCase().replace(DEDUPE_NORMALIZE_REGEX, " ").replace(/\s+/g, " ").trim();
+}
+function splitIntoSentences(text) {
+  return text.split(/(?<=[.!?])\s+|\n+/g).map((sentence) => sentence.trim()).filter(Boolean);
+}
+function chunkTokens(tokens, chunkSize) {
+  const chunks = [];
+  for (let index = 0; index < tokens.length; index += chunkSize) {
+    chunks.push(tokens.slice(index, index + chunkSize));
+  }
+  return chunks;
+}
+function splitOversizedSentence(sentence, maxTokens = MAX_SEGMENT_TOKENS) {
+  const rawTokens = tokenizeForHeuristicCompression(sentence);
+  if (rawTokens.length <= maxTokens) {
+    return [sentence];
+  }
+  const commaSplit = sentence.split(/(?<=[,;:])\s+|\s+-\s+/g).map((segment) => segment.trim()).filter(Boolean);
+  if (commaSplit.length > 1) {
+    return commaSplit.flatMap((segment) => {
+      if (estimateHeuristicTokens(segment) <= maxTokens) {
+        return [segment];
+      }
+      return chunkTokens(tokenizeForHeuristicCompression(segment), maxTokens).map((chunk) => chunk.join(" "));
+    });
+  }
+  return chunkTokens(rawTokens, maxTokens).map((chunk) => chunk.join(" "));
+}
+function normalizeToken(token) {
+  return token.replace(TOKEN_NORMALIZE_REGEX, "").trim();
+}
+function tokenizeNormalized(text) {
+  return tokenizeForHeuristicCompression(text.toLowerCase()).map(normalizeToken).filter(Boolean);
+}
+function queryTerms(query) {
+  return new Set(tokenizeNormalized(query).filter((term) => term.length >= 3 && !STOP_WORDS.has(term)));
+}
+function preprocessContext(context) {
+  const originalTokens = estimateHeuristicTokens(context);
+  const dedupeSet = /* @__PURE__ */ new Set();
+  const candidates = [];
+  for (const sentence of splitIntoSentences(context)) {
+    for (const segment of splitOversizedSentence(sentence)) {
+      const normalized = normalizeForDeduping(segment);
+      if (!normalized || dedupeSet.has(normalized)) {
+        continue;
+      }
+      dedupeSet.add(normalized);
+      const rawTokens = tokenizeForHeuristicCompression(segment);
+      const normalizedTerms = rawTokens.map((token) => normalizeToken(token.toLowerCase())).filter(Boolean);
+      const lowered = segment.toLowerCase();
+      candidates.push({
+        sentence: segment,
+        index: candidates.length,
+        tokenCount: rawTokens.length,
+        uniqueTerms: new Set(normalizedTerms),
+        isBoilerplate: BOILERPLATE_REGEX.test(lowered)
+      });
+    }
+  }
+  return { originalTokens, candidates };
+}
+function scoreSentenceCandidate(candidate, terms) {
+  if (candidate.tokenCount === 0) {
+    return {
+      score: 0,
+      overlapCount: 0,
+      overlapTerms: []
+    };
+  }
+  const overlapTerms = [];
+  let overlap = 0;
+  for (const term of terms) {
+    if (candidate.uniqueTerms.has(term)) {
+      overlap += 1;
+      overlapTerms.push(term);
+    }
+  }
+  const overlapScore = overlap * 2;
+  const densityScore = terms.size > 0 ? overlap / terms.size : 0;
+  const lengthScore = Math.min(candidate.tokenCount, 40) / 40;
+  const boilerplatePenalty = candidate.isBoilerplate ? 0.5 : 0;
+  return {
+    score: overlapScore + densityScore + lengthScore - boilerplatePenalty,
+    overlapCount: overlap,
+    overlapTerms
+  };
+}
+
+// src/code-compaction.ts
+function compactCode(input, options = {}) {
+  const inputText = input ?? "";
+  const removeComments = options.remove_comments ?? true;
+  const trimIndentation = options.trim_indentation ?? true;
+  const collapseBlankLines = options.collapse_blank_lines ?? true;
+  let output = inputText.replace(/\r\n?/g, "\n");
+  if (removeComments) {
+    output = stripCodeComments(output);
+  }
+  output = output.split("\n").map((line2) => line2.replace(/[ \t]+$/g, "")).join("\n");
+  if (trimIndentation) {
+    output = stripCommonIndent(output);
+  }
+  if (collapseBlankLines) {
+    output = output.split("\n").filter((line2) => line2.trim().length > 0).join("\n");
+  }
+  output = output.trim();
+  const inputTokens = estimateHeuristicTokens(inputText);
+  const outputTokens = estimateHeuristicTokens(output);
+  return {
+    output,
+    inputTokens,
+    outputTokens,
+    tokensSaved: Math.max(0, inputTokens - outputTokens),
+    compressionRatio: outputTokens === 0 ? 0 : inputTokens / outputTokens
+  };
+}
+function stripCommonIndent(input) {
+  const lines = input.split("\n");
+  const nonEmptyLines = lines.filter((line2) => line2.trim().length > 0);
+  if (nonEmptyLines.length === 0) {
+    return "";
+  }
+  const commonIndent = Math.min(
+    ...nonEmptyLines.map((line2) => {
+      const match = line2.match(/^[ \t]*/);
+      return match?.[0].length ?? 0;
+    })
+  );
+  if (commonIndent === 0) {
+    return input;
+  }
+  return lines.map((line2) => line2.slice(commonIndent)).join("\n");
+}
+function stripCodeComments(input) {
+  let output = "";
+  let index = 0;
+  let quote;
+  let escaped = false;
+  let atLineStart = true;
+  while (index < input.length) {
+    const char = input[index];
+    const next = input[index + 1];
+    if (quote) {
+      output += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === quote) {
+        quote = void 0;
+      }
+      atLineStart = char === "\n";
+      index += 1;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      output += char;
+      atLineStart = false;
+      index += 1;
+      continue;
+    }
+    if (atLineStart && char === "#" && next === "!") {
+      while (index < input.length && input[index] !== "\n") {
+        output += input[index];
+        index += 1;
+      }
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      index += 2;
+      while (index < input.length && input[index] !== "\n") {
+        index += 1;
+      }
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      index += 2;
+      while (index < input.length && !(input[index] === "*" && input[index + 1] === "/")) {
+        if (input[index] === "\n") {
+          output += "\n";
+        }
+        index += 1;
+      }
+      index += input[index] === "*" ? 2 : 0;
+      continue;
+    }
+    if (char === "#" && (next === " " || next === "	")) {
+      index += 1;
+      while (index < input.length && input[index] !== "\n") {
+        index += 1;
+      }
+      continue;
+    }
+    output += char;
+    atLineStart = char === "\n" || atLineStart && (char === " " || char === "	");
+    index += 1;
+  }
+  return output;
+}
+
+// src/renderer/renderer.ts
+function renderSections(asset, options = {}) {
+  const { variables = {}, strict = false } = options;
+  const contextInputs = getContextInputs(asset);
+  const optionalVariables = contextInputs.filter((input) => input.optional === true).map((input) => input.name);
+  const contextInputsByName = new Map(contextInputs.map((input) => [input.name, input]));
+  const compressionCache = /* @__PURE__ */ new Map();
+  const createTransformVariable = (template) => {
+    return ({ name, value, modifier, match }) => {
+      const input = contextInputsByName.get(name);
+      const configuredHeuristic = input?.compression?.heuristic;
+      const configuredCode = input?.compression?.code;
+      const shouldCompactCode = modifier === "compact" || modifier === "code" || configuredCode?.enabled === true;
+      const shouldCompress = modifier === "compress" || configuredHeuristic?.enabled === true;
+      if (modifier === "toon") {
+        const result3 = toToonPlaceholder(value);
+        if (!result3) {
+          options.compression?.onCompressionWarning?.(
+            `POK031: JSON-to-TOON skipped for placeholder "${name}" because the value is not a complete valid JSON object or array.`
+          );
+          return value;
+        }
+        if (result3.tokensSaved > 0 || result3.output !== value) {
+          options.compression?.onHeuristicCompression?.({
+            scope: "placeholder",
+            variable: name,
+            ...result3
+          });
+        }
+        return result3.output;
+      }
+      if (shouldCompactCode) {
+        const result3 = compactCode(value, toCodeCompactionOptions(configuredCode));
+        if (result3.tokensSaved > 0 || result3.output !== value) {
+          options.compression?.onCodeCompaction?.({
+            scope: "placeholder",
+            variable: name,
+            ...result3
+          });
+        }
+        return result3.output;
+      }
+      if (!shouldCompress) {
+        return value;
+      }
+      const query = resolveHeuristicQuery(configuredHeuristic, variables, template, match);
+      const compressionOptions = {
+        min_tokens: configuredHeuristic?.min_tokens,
+        max_sentences: configuredHeuristic?.max_sentences,
+        target_reduction: configuredHeuristic?.target_reduction,
+        query,
+        json_to_toon: configuredHeuristic?.json_to_toon
+      };
+      const cacheKey = JSON.stringify([name, value, compressionOptions]);
+      const cached = compressionCache.get(cacheKey);
+      if (cached !== void 0) {
+        return cached;
+      }
+      const result2 = compressHeuristicText(value, compressionOptions);
+      compressionCache.set(cacheKey, result2.output);
+      reportHeuristicCompressionWarnings(options, result2, `placeholder "${name}"`);
+      if (result2.tokensSaved > 0 || result2.output !== value) {
+        options.compression?.onHeuristicCompression?.({
+          scope: "placeholder",
+          variable: name,
+          ...result2
+        });
+      }
+      return result2.output;
+    };
+  };
+  const result = {};
+  if (asset.sections.system_instructions) {
+    result.system_instructions = interpolate(
+      asset.sections.system_instructions,
+      variables,
+      {
+        strict,
+        optionalVariables,
+        transformVariable: createTransformVariable(asset.sections.system_instructions)
+      }
+    );
+  }
+  if (asset.sections.prompt_template) {
+    result.prompt_template = interpolate(
+      asset.sections.prompt_template,
+      variables,
+      {
+        strict,
+        optionalVariables,
+        transformVariable: createTransformVariable(asset.sections.prompt_template)
+      }
+    );
+  }
+  return result;
+}
+function resolveHeuristicQuery(options, variables, template, match) {
+  if (options?.query !== void 0) {
+    return options.query;
+  }
+  if (options?.query_variable && variables[options.query_variable] !== void 0) {
+    return variables[options.query_variable];
+  }
+  return template.replace(match, " ");
+}
+function toToonPlaceholder(value) {
+  const toon = tryJsonToToon(value);
+  if (!toon) {
+    return void 0;
+  }
+  const inputTokens = estimateHeuristicTokens(value);
+  const outputTokens = estimateHeuristicTokens(toon.output);
+  return {
+    output: toon.output,
+    inputTokens,
+    outputTokens,
+    tokensSaved: Math.max(0, inputTokens - outputTokens),
+    compressionRatio: outputTokens === 0 ? 0 : inputTokens / outputTokens,
+    outputFormat: "toon"
+  };
+}
+function toCodeCompactionOptions(options) {
+  return {
+    remove_comments: options?.remove_comments,
+    trim_indentation: options?.trim_indentation,
+    collapse_blank_lines: options?.collapse_blank_lines
+  };
+}
+function reportHeuristicCompressionWarnings(options, result, scope) {
+  for (const warning of result.warnings ?? []) {
+    options.compression?.onCompressionWarning?.(`POK031: ${warning} Scope: ${scope}.`);
+  }
+}
+
+// src/overrides/apply-overrides.ts
+function applyOverrides(asset, options = {}) {
+  let result = { ...asset };
+  if (options.environment && result.environments?.[options.environment]) {
+    result = mergeOverride(result, result.environments[options.environment]);
+  }
+  if (options.tier && result.tiers?.[options.tier]) {
+    result = mergeOverride(result, result.tiers[options.tier]);
+  }
+  if (options.runtime) {
+    result = mergeOverride(result, options.runtime);
+  }
+  return result;
+}
+function mergeOverride(base, override) {
+  const result = { ...base };
+  if (override.model !== void 0) result.model = override.model;
+  if (override.fallback_models !== void 0) result.fallback_models = override.fallback_models;
+  if (override.tools !== void 0) result.tools = override.tools;
+  if (override.reasoning !== void 0) {
+    result.reasoning = { ...result.reasoning, ...override.reasoning };
+  }
+  if (override.sampling !== void 0) {
+    result.sampling = { ...result.sampling, ...override.sampling };
+  }
+  if (override.response !== void 0) {
+    result.response = { ...result.response, ...override.response };
+  }
+  if (override.compression !== void 0) {
+    result.compression = {
+      ...result.compression,
+      ...override.compression,
+      thetokencompany: mergeRecordBlock(
+        result.compression?.thetokencompany,
+        override.compression.thetokencompany
+      ),
+      heuristic: mergeRecordBlock(
+        result.compression?.heuristic,
+        override.compression.heuristic
+      ),
+      code: mergeRecordBlock(
+        result.compression?.code,
+        override.compression.code
+      )
+    };
+  }
+  if (override.cache !== void 0) {
+    result.cache = {
+      ...result.cache,
+      ...override.cache,
+      openai: mergeRecordBlock(result.cache?.openai, override.cache.openai),
+      anthropic: mergeRecordBlock(result.cache?.anthropic, override.cache.anthropic),
+      gemini: mergeRecordBlock(result.cache?.gemini, override.cache.gemini),
+      google: mergeRecordBlock(result.cache?.google, override.cache.google)
+    };
+  }
+  if (override.raw !== void 0) {
+    result.raw = {
+      ...result.raw,
+      ...override.raw,
+      openai: mergeRecordBlock(result.raw?.openai, override.raw.openai),
+      "openai-responses": mergeRecordBlock(result.raw?.["openai-responses"], override.raw["openai-responses"]),
+      openai_responses: mergeRecordBlock(result.raw?.openai_responses, override.raw.openai_responses),
+      anthropic: mergeRecordBlock(result.raw?.anthropic, override.raw.anthropic),
+      gemini: mergeRecordBlock(result.raw?.gemini, override.raw.gemini),
+      google: mergeRecordBlock(result.raw?.google, override.raw.google),
+      openrouter: mergeRecordBlock(result.raw?.openrouter, override.raw.openrouter),
+      llmasaservice: mergeRecordBlock(result.raw?.llmasaservice, override.raw.llmasaservice)
+    };
+  }
+  if (override.provider_options !== void 0) {
+    result.provider_options = {
+      ...result.provider_options,
+      ...override.provider_options,
+      anthropic: {
+        ...result.provider_options?.anthropic,
+        ...override.provider_options.anthropic
+      },
+      gemini: {
+        ...result.provider_options?.gemini,
+        ...override.provider_options.gemini
+      },
+      openrouter: {
+        ...result.provider_options?.openrouter,
+        ...override.provider_options.openrouter
+      },
+      llmasaservice: {
+        ...result.provider_options?.llmasaservice,
+        ...override.provider_options.llmasaservice
+      }
+    };
+  }
+  return result;
+}
+function mergeRecordBlock(base, override) {
+  if (override === void 0) return base;
+  return { ...base, ...override };
+}
+
+// src/providers/resolve-asset.ts
+function resolveAssetForProvider(asset, runtime = {}) {
+  if (!runtime.environment && !runtime.tier && !runtime.runtime) {
+    return asset;
+  }
+  return applyOverrides(asset, {
+    environment: runtime.environment,
+    tier: runtime.tier,
+    runtime: runtime.runtime
+  });
+}
+
+// src/cache.ts
+import { statSync } from "fs";
+var PromptCache = class {
+  cache = /* @__PURE__ */ new Map();
+  maxSize;
+  constructor(maxSize = 100) {
+    this.maxSize = maxSize;
+  }
+  get(filePath) {
+    const entry = this.cache.get(filePath);
+    if (!entry) return void 0;
+    try {
+      const stat = statSync(filePath);
+      if (stat.mtimeMs !== entry.mtime) {
+        this.cache.delete(filePath);
+        return void 0;
+      }
+    } catch {
+      this.cache.delete(filePath);
+      return void 0;
+    }
+    this.cache.delete(filePath);
+    this.cache.set(filePath, entry);
+    return entry.value;
+  }
+  set(filePath, value) {
+    try {
+      const stat = statSync(filePath);
+      if (this.cache.has(filePath)) {
+        this.cache.delete(filePath);
+      } else if (this.cache.size >= this.maxSize) {
+        const oldest = this.cache.keys().next().value;
+        if (oldest) this.cache.delete(oldest);
+      }
+      this.cache.set(filePath, { value, mtime: stat.mtimeMs });
+    } catch {
+    }
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+};
+
+// src/composition/resolve-includes.ts
+import { readFile } from "fs/promises";
+import { resolve, dirname } from "path";
+async function resolveIncludes(asset, basePath, visited = /* @__PURE__ */ new Set()) {
+  if (!asset.includes || asset.includes.length === 0) {
+    return asset;
+  }
+  const baseDir = dirname(basePath);
+  const resolvedPath = resolve(basePath);
+  if (visited.has(resolvedPath)) {
+    throw new Error(`Circular include detected: ${resolvedPath}`);
+  }
+  visited.add(resolvedPath);
+  let mergedSystemInstructions = "";
+  for (const includePath of asset.includes) {
+    const fullPath = resolve(baseDir, includePath);
+    if (visited.has(fullPath)) {
+      throw new Error(`Circular include detected: ${fullPath} (included from ${basePath})`);
+    }
+    const content = await readFile(fullPath, "utf-8");
+    const { asset: includedAsset } = parsePrompt(content, fullPath);
+    const resolved = await resolveIncludes(includedAsset, fullPath, new Set(visited));
+    if (resolved.sections?.system_instructions) {
+      mergedSystemInstructions += resolved.sections.system_instructions + "\n\n";
+    }
+  }
+  const localSystem = asset.sections?.system_instructions ?? "";
+  const combinedSystem = (mergedSystemInstructions + localSystem).trim() || void 0;
+  return {
+    ...asset,
+    sections: {
+      ...asset.sections,
+      system_instructions: combinedSystem
+    },
+    // Drop includes from the resolved asset — they've been inlined
+    includes: void 0
+  };
+}
+
+// src/prompt-resolution.ts
+import { readFile as readFile2 } from "fs/promises";
+import { existsSync, statSync as statSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+var DEFAULT_PROMPTS_DIR = "./prompts";
+var DEFAULT_COMPILED_JSON_DIR = "./.generated-prompts/json";
+function withPromptResolutionDefaults(config) {
+  return {
+    ...config,
+    sourceDir: config.sourceDir ?? DEFAULT_PROMPTS_DIR,
+    compiledDir: config.compiledDir ?? DEFAULT_COMPILED_JSON_DIR
+  };
+}
+var sharedPromptCache = new PromptCache();
+async function loadPromptAsset(promptPath, config, promptCache = sharedPromptCache) {
+  const resolvedConfig = withPromptResolutionDefaults(config);
+  const mode = resolvedConfig.mode ?? "auto";
+  if (mode !== "source-only" && resolvedConfig.compiledDir) {
+    const compiledFile = resolve2(resolvedConfig.compiledDir, promptPath + ".json");
+    if (existsSync(compiledFile)) {
+      if (mode === "auto") {
+        const sourceFile = resolve2(resolvedConfig.sourceDir, promptPath + ".md");
+        if (existsSync(sourceFile)) {
+          const compiledMtime = statSync2(compiledFile).mtimeMs;
+          const sourceMtime = statSync2(sourceFile).mtimeMs;
+          if (sourceMtime > compiledMtime) {
+            console.warn(
+              `[promptopskit] Warning: compiled artifact for "${promptPath}" is older than source .md file.
+               Run "promptopskit compile" or switch to source-only mode.`
+            );
+          }
+        }
+      }
+      const content = await readFile2(compiledFile, "utf-8");
+      return JSON.parse(content);
+    }
+    if (mode === "compiled-only") {
+      throw new Error(
+        `Compiled artifact not found: ${compiledFile}
+Run "promptopskit compile" to generate it.`
+      );
+    }
+  }
+  if (mode !== "compiled-only") {
+    const sourceFile = resolve2(resolvedConfig.sourceDir, promptPath + ".md");
+    if (resolvedConfig.cache !== false) {
+      const cached = promptCache.get(sourceFile);
+      if (cached) {
+        return cached;
+      }
+    }
+    if (!existsSync(sourceFile)) {
+      const paths = [sourceFile];
+      if (resolvedConfig.compiledDir) {
+        paths.unshift(resolve2(resolvedConfig.compiledDir, promptPath + ".json"));
+      }
+      throw new Error(
+        `Prompt not found: "${promptPath}"
+Searched:
+${paths.map((candidate) => `  - ${candidate}`).join("\n")}`
+      );
+    }
+    const { asset } = await loadPromptFile(sourceFile, { defaultsRoot: resolvedConfig.sourceDir });
+    if (resolvedConfig.cache !== false) {
+      promptCache.set(sourceFile, asset);
+    }
+    return asset;
+  }
+  throw new Error(`Prompt not found: "${promptPath}"`);
+}
+async function resolvePromptAsset(promptPath, config, options = {}, promptCache = sharedPromptCache) {
+  const resolvedConfig = withPromptResolutionDefaults(config);
+  let asset = await loadPromptAsset(promptPath, resolvedConfig, promptCache);
+  const sourceFile = resolve2(resolvedConfig.sourceDir, promptPath + ".md");
+  if (asset.includes && asset.includes.length > 0 && existsSync(sourceFile)) {
+    asset = await resolveIncludes(asset, sourceFile);
+  }
+  asset = applyOverrides(asset, {
+    environment: options.environment,
+    tier: options.tier,
+    runtime: options.runtime
+  });
+  return asset;
+}
+function resolveInlinePromptSource(source, options = {}) {
+  const { asset } = parsePrompt(source);
+  return applyOverrides(asset, {
+    environment: options.environment,
+    tier: options.tier,
+    runtime: options.runtime
+  });
+}
+
+// src/history.ts
+function defaultCompactHistory(info) {
+  const content = info.overflow.map((message) => `${message.role}: ${message.content}`).join("\n\n");
+  return {
+    role: "user",
+    content: `Earlier conversation compacted to preserve history:
+
+${content}`
+  };
+}
+function normalizeCompactionResult(result) {
+  if (typeof result === "string") {
+    return {
+      role: "user",
+      content: result
+    };
+  }
+  return result;
+}
+function compactHistoryForPrompt(asset, runtime) {
+  const history = runtime.history;
+  const maxItems = asset.context?.history?.max_items;
+  if (!history || maxItems === void 0 || history.length <= maxItems) {
+    return history;
+  }
+  if (maxItems === 1) {
+    const info2 = {
+      promptId: asset.id,
+      maxItems,
+      overflow: history,
+      preserved: [],
+      history
+    };
+    const compacted2 = runtime.onHistoryCompaction ? normalizeCompactionResult(runtime.onHistoryCompaction(info2)) : defaultCompactHistory(info2);
+    return [compacted2];
+  }
+  const preservedCount = maxItems - 1;
+  const overflow = history.slice(0, history.length - preservedCount);
+  const preserved = history.slice(-preservedCount);
+  const info = {
+    promptId: asset.id,
+    maxItems,
+    overflow,
+    preserved,
+    history
+  };
+  const compacted = runtime.onHistoryCompaction ? normalizeCompactionResult(runtime.onHistoryCompaction(info)) : defaultCompactHistory(info);
+  return [compacted, ...preserved];
+}
+
+// src/compression.ts
+var THETOKENCOMPANY_DEFAULT_MODEL = "bear-2";
+var THETOKENCOMPANY_DEFAULT_BASE_URL = "https://api.thetokencompany.com";
+var HEURISTIC_COMPRESSION_MODEL = "local-heuristic-v1";
+var CODE_COMPACTION_MODEL = "local-code-compactor-v1";
+function summarizePromptCompression(compression = []) {
+  const totals = compression.reduce(
+    (accumulator, result) => {
+      accumulator.inputTokens += result.inputTokens;
+      accumulator.outputTokens += result.outputTokens;
+      accumulator.tokensSaved += result.tokensSaved;
+      return accumulator;
+    },
+    {
+      inputTokens: 0,
+      outputTokens: 0,
+      tokensSaved: 0
+    }
+  );
+  return {
+    steps: compression.length,
+    inputTokens: totals.inputTokens,
+    outputTokens: totals.outputTokens,
+    tokensSaved: totals.tokensSaved,
+    reductionRatio: totals.inputTokens === 0 ? 0 : totals.tokensSaved / totals.inputTokens
+  };
+}
+async function applyPromptCompressionForRender(asset, runtime) {
+  const theTokenCompanyConfig = asset.compression?.thetokencompany;
+  const heuristicConfig = asset.compression?.heuristic;
+  const codeConfig = asset.compression?.code;
+  const hasTheTokenCompanyCompression = theTokenCompanyConfig?.enabled === true && Boolean(asset.sections.prompt_template);
+  const hasHeuristicPromptCompression = heuristicConfig?.enabled === true && Boolean(asset.sections.prompt_template);
+  const hasCodePromptCompaction = codeConfig?.enabled === true && Boolean(asset.sections.prompt_template);
+  const hasPlaceholderCompression = usesPlaceholderCompression(asset);
+  if (!hasTheTokenCompanyCompression && !hasHeuristicPromptCompression && !hasCodePromptCompaction && !hasPlaceholderCompression) {
+    return { asset, runtime, compression: [], warnings: [] };
+  }
+  const compression = [];
+  const warnings = [];
+  const sections = renderSections(asset, {
+    variables: runtime.variables,
+    strict: runtime.strict,
+    compression: {
+      onHeuristicCompression: (event) => {
+        compression.push({
+          provider: "heuristic",
+          model: HEURISTIC_COMPRESSION_MODEL,
+          inputTokens: event.inputTokens,
+          outputTokens: event.outputTokens,
+          tokensSaved: event.tokensSaved,
+          compressionRatio: event.compressionRatio,
+          scope: event.scope,
+          variable: event.variable,
+          outputFormat: event.outputFormat
+        });
+      },
+      onCodeCompaction: (event) => {
+        compression.push({
+          provider: "code",
+          model: CODE_COMPACTION_MODEL,
+          inputTokens: event.inputTokens,
+          outputTokens: event.outputTokens,
+          tokensSaved: event.tokensSaved,
+          compressionRatio: event.compressionRatio,
+          scope: event.scope,
+          variable: event.variable,
+          outputFormat: "code"
+        });
+      },
+      onCompressionWarning: (warning) => {
+        warnings.push(warning);
+      }
+    }
+  });
+  let promptTemplate = sections.prompt_template;
+  if (hasCodePromptCompaction && promptTemplate) {
+    if (hasHeuristicPromptCompression) {
+      warnings.push(
+        "POK032: Local heuristic prompt compression skipped because compression.code is enabled for the prompt template."
+      );
+    }
+    const result = compactCode(promptTemplate, toCodeCompactionOptions2(codeConfig));
+    promptTemplate = result.output;
+    if (result.tokensSaved > 0 || result.output !== sections.prompt_template) {
+      compression.push({
+        provider: "code",
+        model: CODE_COMPACTION_MODEL,
+        inputTokens: result.inputTokens,
+        outputTokens: result.outputTokens,
+        tokensSaved: result.tokensSaved,
+        compressionRatio: result.compressionRatio,
+        scope: "prompt_template",
+        outputFormat: "code"
+      });
+    }
+  } else if (hasHeuristicPromptCompression && promptTemplate) {
+    const result = compressHeuristicText(promptTemplate, {
+      min_tokens: heuristicConfig?.min_tokens,
+      max_sentences: heuristicConfig?.max_sentences,
+      target_reduction: heuristicConfig?.target_reduction,
+      query: resolveHeuristicPromptQuery(heuristicConfig, runtime.variables, sections.system_instructions),
+      json_to_toon: heuristicConfig?.json_to_toon
+    });
+    promptTemplate = result.output;
+    reportHeuristicCompressionWarnings2(warnings, result.warnings, "prompt template");
+    if (result.tokensSaved > 0 || result.output !== sections.prompt_template) {
+      compression.push({
+        provider: "heuristic",
+        model: HEURISTIC_COMPRESSION_MODEL,
+        inputTokens: result.inputTokens,
+        outputTokens: result.outputTokens,
+        tokensSaved: result.tokensSaved,
+        compressionRatio: result.compressionRatio,
+        scope: "prompt_template",
+        outputFormat: result.outputFormat
+      });
+    }
+  }
+  if (hasTheTokenCompanyCompression && hasCodePromptCompaction && promptTemplate) {
+    warnings.push(
+      "POK033: TheTokenCompany compression skipped because compression.code is enabled; code is compacted locally and not text-compressed."
+    );
+  } else if (hasTheTokenCompanyCompression && promptTemplate) {
+    const model = theTokenCompanyConfig?.model ?? THETOKENCOMPANY_DEFAULT_MODEL;
+    const result = await compressWithTheTokenCompany(promptTemplate, {
+      apiKey: runtime.theTokenCompany?.apiKey,
+      baseURL: runtime.theTokenCompany?.baseURL,
+      fetch: runtime.theTokenCompany?.fetch,
+      model,
+      aggressiveness: theTokenCompanyConfig?.aggressiveness
+    });
+    promptTemplate = result.output;
+    compression.push({
+      provider: "thetokencompany",
+      model,
+      inputTokens: result.input_tokens,
+      outputTokens: result.output_tokens,
+      tokensSaved: result.tokens_saved,
+      compressionRatio: result.compression_ratio
+    });
+  }
+  return {
+    asset: {
+      ...asset,
+      sections: {
+        ...asset.sections,
+        ...sections,
+        ...promptTemplate !== void 0 ? { prompt_template: promptTemplate } : {}
+      }
+    },
+    runtime: {
+      ...runtime,
+      variables: {},
+      strict: false
+    },
+    compression,
+    warnings
+  };
+}
+function usesPlaceholderCompression(asset) {
+  const hasContextInputCompression = getContextInputs(asset).some(
+    (input) => input.compression?.heuristic?.enabled === true || input.compression?.code?.enabled === true
+  );
+  if (hasContextInputCompression) {
+    return true;
+  }
+  return Boolean(
+    asset.sections.system_instructions && hasCompressionModifier(asset.sections.system_instructions) || asset.sections.prompt_template && hasCompressionModifier(asset.sections.prompt_template)
+  );
+}
+function hasCompressionModifier(template) {
+  return /\{\{\s*[a-zA-Z_][a-zA-Z0-9_]*\s*\|\s*(?:compress|toon|compact|code)\s*\}\}/.test(template);
+}
+function resolveHeuristicPromptQuery(options, variables, systemInstructions) {
+  if (options?.query !== void 0) {
+    return options.query;
+  }
+  if (options?.query_variable && variables?.[options.query_variable] !== void 0) {
+    return variables[options.query_variable];
+  }
+  return systemInstructions;
+}
+function toCodeCompactionOptions2(options) {
+  return {
+    remove_comments: options?.remove_comments,
+    trim_indentation: options?.trim_indentation,
+    collapse_blank_lines: options?.collapse_blank_lines
+  };
+}
+function reportHeuristicCompressionWarnings2(warnings, compressionWarnings, scope) {
+  for (const warning of compressionWarnings ?? []) {
+    warnings.push(`POK031: ${warning} Scope: ${scope}.`);
+  }
+}
+async function compressWithTheTokenCompany(input, options) {
+  const apiKey = options.apiKey ?? getEnv("THETOKENCOMPANY_API_KEY") ?? getEnv("TTC_API_KEY");
+  if (!apiKey) {
+    throw new Error(
+      "TheTokenCompany compression is enabled, but no API key was provided. Pass theTokenCompany.apiKey to renderPrompt() or set THETOKENCOMPANY_API_KEY."
+    );
+  }
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  if (!fetchImpl) {
+    throw new Error("TheTokenCompany compression requires a runtime with fetch support.");
+  }
+  const baseURL = (options.baseURL ?? THETOKENCOMPANY_DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const compressionSettings = options.aggressiveness === void 0 ? void 0 : { aggressiveness: options.aggressiveness };
+  const response = await fetchImpl(`${baseURL}/v1/compress`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      model: options.model,
+      input,
+      ...compressionSettings ? { compression_settings: compressionSettings } : {}
+    })
+  });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(
+      `TheTokenCompany compression failed with HTTP ${response.status}` + (body ? `: ${body}` : ".")
+    );
+  }
+  const data = await response.json();
+  if (typeof data.output !== "string" || typeof data.output_tokens !== "number" || typeof data.input_tokens !== "number" || typeof data.tokens_saved !== "number" || typeof data.compression_ratio !== "number") {
+    throw new Error("TheTokenCompany compression returned an invalid response payload.");
+  }
+  return data;
+}
+function getEnv(name) {
+  if (typeof process === "undefined") {
+    return void 0;
+  }
+  return process.env[name];
+}
+
+// src/providers/prompt-input.ts
+function isPromptLookup(input) {
+  return "path" in input && typeof input.path === "string";
+}
+function isInlinePromptSource(input) {
+  return "source" in input && typeof input.source === "string";
+}
+async function resolveProviderPromptInput(input, runtime) {
+  if (isPromptLookup(input)) {
+    return resolvePromptAsset(input.path, input, runtime);
+  }
+  if (isInlinePromptSource(input)) {
+    return resolveInlinePromptSource(input.source, runtime);
+  }
+  return input;
+}
+function withPromptInputSupport(adapter) {
+  const validatePrompt = async (input, runtime) => {
+    const resolved = await resolveProviderPromptInput(input, runtime);
+    return adapter.validate(resolved, runtime);
+  };
+  const renderPrompt = async (input, runtime) => {
+    const resolved = await resolveProviderPromptInput(input, runtime);
+    const resolvedForRender = resolveAssetForProvider(resolved, runtime);
+    const sanitization = sanitizeContextVariables(resolvedForRender, runtime.variables, {
+      onContextOverflow: runtime.onContextOverflow
+    });
+    if (sanitization.shortCircuit) {
+      return {
+        provider: adapter.name,
+        model: resolvedForRender.model ?? "",
+        returnMessage: sanitization.shortCircuit.returnMessage
+      };
+    }
+    const prepared = await applyPromptCompressionForRender(resolvedForRender, {
+      ...runtime,
+      environment: void 0,
+      tier: void 0,
+      runtime: void 0,
+      variables: sanitization.variables,
+      history: compactHistoryForPrompt(resolvedForRender, runtime)
+    });
+    const request = adapter.render(prepared.asset, prepared.runtime);
+    return prepared.compression.length > 0 || prepared.warnings.length > 0 ? {
+      ...request,
+      ...prepared.compression.length > 0 ? {
+        compression: prepared.compression,
+        compressionSummary: summarizePromptCompression(prepared.compression)
+      } : {},
+      ...prepared.warnings.length > 0 ? { warnings: prepared.warnings } : {}
+    } : request;
+  };
+  return {
+    ...adapter,
+    validatePrompt,
+    renderPrompt
+  };
+}
+
+// src/providers/raw.ts
+function applyRawProviderBody(body, asset, provider) {
+  const raw = getRawProviderBody(asset, provider);
+  return raw ? { ...body, ...raw } : body;
+}
+function getRawProviderBody(asset, provider) {
+  if (provider === "openai-responses") {
+    return asset.raw?.["openai-responses"] ?? asset.raw?.openai_responses;
+  }
+  if (provider === "gemini") {
+    return asset.raw?.gemini ?? asset.raw?.google;
+  }
+  return asset.raw?.[provider];
+}
+
+export {
+  interpolate,
+  extractVariables,
+  getContextInputs,
+  areContextInputWarningsEnabled,
+  compileContextRegex,
+  sanitizeContextVariables,
+  collectContextSizeWarnings,
+  renderSections,
+  applyOverrides,
+  resolveAssetForProvider,
+  PromptCache,
+  resolveIncludes,
+  DEFAULT_PROMPTS_DIR,
+  withPromptResolutionDefaults,
+  loadPromptAsset,
+  resolvePromptAsset,
+  resolveInlinePromptSource,
+  compactHistoryForPrompt,
+  THETOKENCOMPANY_DEFAULT_MODEL,
+  THETOKENCOMPANY_DEFAULT_BASE_URL,
+  summarizePromptCompression,
+  applyPromptCompressionForRender,
+  withPromptInputSupport,
+  applyRawProviderBody
+};
+//# sourceMappingURL=chunk-RVAFVWR2.js.map