@smeltjs/core 0.2.0 → 0.4.0

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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","sourcesContent":["/** Languages smelt can parse structurally. Everything else falls back to the lexical planner. */\nexport type LanguageId =\n  | 'typescript'\n  | 'tsx'\n  | 'javascript'\n  | 'rust'\n  | 'python'\n  | 'go'\n  | 'java'\n  | 'c'\n  | 'cpp'\n  | 'c_sharp'\n  | 'ruby'\n  | 'php'\n  | 'kotlin'\n  | 'swift'\n  | 'bash';\n\n/** `'unknown'` is a first-class outcome, not a failure: it selects the lexical planner. */\nexport type DetectedLanguage = LanguageId | 'unknown';\n\n/** A half-open byte range `[start, end)` into the UTF-8 bytes of the input. */\nexport interface ByteRange {\n  readonly start: number;\n  readonly end: number;\n}\n\n/**\n * Why a range was elided, in two registers: a stable id for counters, and a sentence\n * a human can read in a diff. Law 2 — every elision is explainable — lives here:\n * if you cannot write the sentence, the rule does not ship.\n */\nexport interface ElisionReason {\n  /** Stable machine id, e.g. `'sibling-collapse'`, `'line-window'`. */\n  readonly rule: string;\n  /** e.g. `'collapsed 3 sibling functions'`. Present tense, no trailing period. */\n  readonly explanation: string;\n}\n\n/** One range a planner proposes to remove. Plans are pure data — inspectable and testable. */\nexport interface PlannedElision {\n  readonly range: ByteRange;\n  readonly reason: ElisionReason;\n}\n\n/**\n * The complete output of a planner: the whole decision, before anything is mutated.\n * A plan can be logged, diffed, snapshot-tested, and rejected without touching the text.\n */\nexport interface ElisionPlan {\n  readonly planner: string;\n  readonly language: DetectedLanguage;\n  readonly elisions: readonly PlannedElision[];\n}\n\n/**\n * The seam through which a planner asks what a marker will cost, in UTF-8 bytes.\n *\n * Marker cost is `apply.ts`'s fact — the applier renders the marker, so only the\n * applier knows its price. Planners need that price for two decisions (profitability:\n * a marker that costs more than it removes grows the output; and budget prediction:\n * which ladder rung actually fits), and before this seam each planner rebuilt the\n * marker machinery privately to measure it — correct, but an inversion. Now\n * `markerPricing()` in `apply.ts` builds the one adapter from the exact builder\n * `applyPlan` will use, and planners ask it. They never guess, and they never render\n * a marker of their own.\n *\n * The price is exact, not an estimate: the cost of the marker this elision would\n * earn, comment leader and all, with a stand-in hash of the real hash's length —\n * marker cost depends on the hash's *length*, never its value.\n */\nexport interface MarkerPricing {\n  /** The exact UTF-8 byte cost of the marker an elision with this reason and size would earn. */\n  costBytes(reason: ElisionReason, elidedBytes: number): number;\n}\n\n/**\n * What the caller hands a planner.\n *\n * Constructed centrally: `createSmelter` (and through it, the CLI) builds the one\n * `PlanInput` per call, including its {@link MarkerPricing} — a caller invoking\n * `planLexical`/`planStructural` directly builds `pricing` with `markerPricing()`\n * from `apply.ts`. A JS caller who omits it gets {@link MissingMarkerPricingError}\n * at plan time, not a guessed cost.\n */\nexport interface PlanInput {\n  readonly text: string;\n  readonly language: DetectedLanguage;\n  /** Soft ceiling for the emitted output, in UTF-8 bytes. Planners aim under it. */\n  readonly budgetBytes: number;\n  /**\n   * What the caller was actually looking for — grep pattern, symbol name, error string.\n   * Planners keep matching regions and collapse around them.\n   */\n  readonly focus?: readonly string[];\n  /**\n   * What a marker costs. Required: a planner that guesses marker cost can plan an\n   * elision that grows the output. See {@link MarkerPricing}; built by\n   * `markerPricing()` in `apply.ts` from the exact builder `applyPlan` will use.\n   */\n  readonly pricing: MarkerPricing;\n}\n\n/**\n * A planner decides *what* to remove. It never removes anything itself; `applyPlan`\n * does that. Keeping the decision and the mutation apart is what makes the decision\n * testable in isolation.\n */\nexport interface Planner {\n  readonly id: string;\n  plan(input: PlanInput): Promise<ElisionPlan>;\n}\n\n/** One elision that actually happened, with the receipt needed to undo it. */\nexport interface AppliedElision {\n  /** Content hash of the removed bytes — the key `retrieve()` takes. */\n  readonly hash: string;\n  /** Where the removed bytes were in the *input*. */\n  readonly range: ByteRange;\n  /**\n   * Where the marker sits in the *output*. Law 3 — every elision is reversible — needs\n   * this: {@link Reconstructor} splices stored bytes back over these ranges. Without it,\n   * \"reversible\" would mean parsing markers back out of the text, which is a guess.\n   * This is a fact recorded at the moment of the cut.\n   */\n  readonly outputRange: ByteRange;\n  /** Size of the removed content, in UTF-8 bytes. */\n  readonly bytes: number;\n  readonly reason: ElisionReason;\n  /** The exact marker text substituted into the output. */\n  readonly marker: string;\n}\n\n/**\n * A consumer-supplied counter, so a caller who bills in tokens can *see* tokens.\n *\n * Budgets in smelt's core are UTF-8 bytes, permanently — bytes are the only unit that\n * is computable locally for every model, and they mean the same thing in five years.\n * See `docs/ARCHITECTURE.md` § \"Decision 1\". This hook does not change that: it adds a\n * second, labelled number to the result. The plan is still made in bytes.\n *\n * Both `id` and `unit` are required, and that is a Law 4 decision rather than\n * bookkeeping: a token count is meaningless without naming the tokenizer that produced\n * it. Anthropic's own docs record that Claude 4.7 and later use a newer tokenizer where\n * the same text yields roughly 30% more tokens than on earlier models — so `1,204\n * tokens` is not a fact, and `1,204 tokens (claude-4.7/count_tokens)` is.\n *\n * **This hook does not relax Law 1.** smelt imports no transport and the guard proves\n * that about smelt's own modules; it cannot prove it about a function you hand in. A\n * `count()` that calls an API makes *your* process call an API, from a line in *your*\n * source — exactly the arrangement {@link RerankStage} already describes. `count` is\n * synchronous on purpose: local tokenizers are synchronous, and network clients are not.\n */\nexport interface Measure {\n  /** Names the counter, e.g. `'tiktoken/o200k_base'` or `'claude-4.7/count_tokens'`. */\n  readonly id: string;\n  /** The unit `count()` returns, e.g. `'tokens'`. Printed next to the number. */\n  readonly unit: string;\n  /** Local, synchronous count over the whole string. */\n  count(text: string): number;\n}\n\n/** A second size for a result, in someone else's unit, with the counter named. */\nexport interface MeasuredSize {\n  /** {@link Measure.id} of the counter that produced these numbers. */\n  readonly measure: string;\n  /** {@link Measure.unit}. */\n  readonly unit: string;\n  readonly input: number;\n  readonly output: number;\n}\n\n/** The result of smelting one blob of text. */\nexport interface SmeltResult {\n  readonly text: string;\n  readonly inputBytes: number;\n  readonly outputBytes: number;\n  readonly planner: string;\n  readonly language: DetectedLanguage;\n  readonly elisions: readonly AppliedElision[];\n  /** Present only when the caller supplied a {@link Measure}. Never invented. */\n  readonly measured?: MeasuredSize;\n}\n\n/**\n * Reversibility, as a callable. Takes a {@link SmeltResult} and the store that holds its\n * elided bytes, and returns the original text — byte for byte.\n */\nexport type Reconstructor = (result: SmeltResult, store: ElisionStore) => string;\n\n// ---------------------------------------------------------------------------\n// The store, and the counters that make over-pruning visible\n// ---------------------------------------------------------------------------\n\n/**\n * The numbers that keep smelt honest about itself.\n *\n * Law 3 says elisions are reversible. That is cheap to satisfy and easy to abuse: a\n * compressor that cuts everything is \"reversible\" and useless. The *retrieve rate* is\n * the tell. If the model keeps calling `smelt_retrieve`, smelt cut material the task\n * needed, and the round trip cost more tokens than the elision saved.\n *\n * So: `expansionRate` is not telemetry. It is the metric a caller tunes budgets\n * against, and the only number smelt is willing to have an opinion about — because it\n * measures it locally, per session, on the caller's own traffic.\n */\nexport interface RetrieveStats {\n  /** Distinct blobs put into the store. */\n  readonly elisionsStored: number;\n  /** Total bytes held by the store. */\n  readonly bytesStored: number;\n  /** Every `retrieve()` call, including repeats and misses. */\n  readonly retrieveCalls: number;\n  /** Distinct hashes successfully retrieved at least once. */\n  readonly uniqueRetrieved: number;\n  /** Calls for a hash the store does not hold. Non-zero means a bug, not over-pruning. */\n  readonly misses: number;\n  /**\n   * `uniqueRetrieved / elisionsStored`, or `0` when nothing has been stored.\n   *\n   * Read it as: *what fraction of what smelt hid did the model have to ask for back?*\n   * There is no universally right value, and smelt does not ship a threshold it has\n   * not measured. Rising across a workload is the signal.\n   */\n  readonly expansionRate: number;\n  /**\n   * The one degenerate outcome smelt is willing to name: **every distinct blob it hid\n   * was asked for again.**\n   *\n   * smelt ships no expansion-rate threshold, because a threshold is a policy claim it\n   * has no basis for and the right rate depends on how aggressive a budget the caller\n   * chose — and a library printing warnings into someone else's process is bad manners.\n   * This is not a threshold. At `uniqueRetrieved === elisionsStored` the elision\n   * achieved nothing and cost a round trip: an arithmetic fact, not a preference. What\n   * to do about it is the caller's call.\n   *\n   * `false` for an empty store — nothing was hidden, so nothing was defeated.\n   */\n  readonly allElisionsRetrieved: boolean;\n}\n\n/**\n * Local, content-addressed storage for elided bytes. No network, no eviction in v1 —\n * evicting is how \"reversible\" quietly becomes \"reversible for a while\".\n */\nexport interface ElisionStore {\n  /** Store content, returning its hash. Idempotent for identical content. */\n  put(content: string): string;\n  /** The stored content, or `undefined` if this store never held that hash. */\n  peek(hash: string): string | undefined;\n  /**\n   * The stored content, *counted* as a retrieval. This is what the model's tool calls.\n   *\n   * @throws {UnknownHashError} when the hash is unknown.\n   * @throws {StoreCorruptionError} — {@link DirectoryElisionStore} only — when the\n   *   bytes on disk no longer hash to their own name. Distinct from\n   *   `UnknownHashError` on purpose: \"we hold damaged bytes\" and \"it never existed\"\n   *   are different answers, and a caller that conflates them will report the wrong\n   *   one to its user.\n   *\n   * A {@link DirectoryElisionStore} whose journal cannot be written (a read-only\n   * store directory, a full disk) still returns the bytes — verified bytes are never\n   * withheld over a bookkeeping failure — and surfaces the lost count as a\n   * `process.emitWarning` named `SmeltCounterWriteFailure` instead of throwing. Its\n   * stats go quiet from that point; the retrieval itself succeeded.\n   */\n  retrieve(hash: string): string;\n  /**\n   * Whether this hash can be retrieved — **not** merely whether a slot bearing it\n   * exists. `true` must mean the very next `retrieve(hash)` returns bytes, so a store\n   * that verifies content on read verifies here too and raises its corruption error\n   * rather than answering `true` for bytes it would then refuse. Uncounted: a check is\n   * not the model asking for material back.\n   */\n  has(hash: string): boolean;\n  /** A snapshot of the counters. See {@link RetrieveStats}. */\n  stats(): RetrieveStats;\n}\n\n/**\n * The retrieval tool a consumer exposes to its model. Deliberately not an MCP or\n * provider-specific shape — smelt does not know which SDK you use. The consumer adapts\n * this into its own tool schema; the contract is `hash in, exact bytes out`.\n */\nexport interface RetrieveTool {\n  /** `'smelt_retrieve'`. Stable — consumers hard-code it in prompts. */\n  readonly name: string;\n  /** Prose the consumer can put straight into a tool description. */\n  readonly description: string;\n  /**\n   * JSON-Schema-shaped parameter description, for consumers that want one.\n   *\n   * Strict-mode shaped: `additionalProperties: false` and a `required` naming every\n   * property, so a consumer registering this under OpenAI's structured-outputs strict\n   * mode is not refused at registration. See {@link createRetrieveTool}.\n   */\n  readonly inputSchema: {\n    readonly type: 'object';\n    readonly properties: {\n      readonly hash: { readonly type: 'string'; readonly description: string };\n    };\n    readonly required: readonly ['hash'];\n    readonly additionalProperties: false;\n  };\n  /**\n   * @throws {UnknownHashError} when the hash is unknown.\n   * @throws {StoreCorruptionError} when the backing store holds damaged bytes for\n   *   that hash — see {@link ElisionStore.retrieve}, whose contract this forwards\n   *   verbatim. Surface either to the model as a tool error, never as empty text.\n   */\n  invoke(input: { readonly hash: string }): string;\n}\n\n// ---------------------------------------------------------------------------\n// Pluggable stages — interfaces in v1, nothing more\n// ---------------------------------------------------------------------------\n\n/** A candidate handed to a {@link RerankStage}: an opaque id plus the text to judge. */\nexport interface RerankCandidate {\n  readonly id: string;\n  readonly text: string;\n}\n\n/** A reranked candidate, most relevant first. `score` is the stage's own scale. */\nexport interface RerankedCandidate extends RerankCandidate {\n  readonly score: number;\n}\n\n/**\n * Relevance reranking — a *seam*, not a feature.\n *\n * Hosted rerankers are good and smelt will never bundle one, because bundling would\n * break Law 1: the moment smelt ships a default reranker, `smelt()` can make a network\n * call that the caller did not ask for and cannot see. A consumer that wants one\n * implements this interface, wires its own key, and owns the fact that its context now\n * leaves the machine. That decision must be legible in the consumer's own source.\n */\nexport interface RerankStage {\n  readonly id: string;\n  /** May make network calls — that is the consumer's choice, made in the consumer's code. */\n  rerank(\n    candidates: readonly RerankCandidate[],\n    query: string,\n  ): Promise<readonly RerankedCandidate[]>;\n}\n\n/**\n * Learned distillation — rewriting content with a model instead of cutting it.\n *\n * Out of v1 for a reason beyond the network: a distilled paragraph cannot satisfy\n * Law 2. \"The model summarised this\" is not an explanation of what was removed, and\n * the removed material is no longer recoverable from the output. If this ever ships,\n * it ships as a stage that stores the original and explains itself in the same terms\n * every other rule does.\n */\nexport interface DistillStage {\n  readonly id: string;\n  distill(text: string, budgetBytes: number): Promise<string>;\n}\n"]}

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"","sourcesContent":["/** Languages smelt can parse structurally. Everything else falls back to the lexical planner. */\nexport type LanguageId =\n  | 'typescript'\n  | 'tsx'\n  | 'javascript'\n  | 'rust'\n  | 'python'\n  | 'go'\n  | 'java'\n  | 'c'\n  | 'cpp'\n  | 'c_sharp'\n  | 'ruby'\n  | 'php'\n  | 'kotlin'\n  | 'swift'\n  | 'bash';\n\n/** `'unknown'` is a first-class outcome, not a failure: it selects the lexical planner. */\nexport type DetectedLanguage = LanguageId | 'unknown';\n\n/** A half-open byte range `[start, end)` into the UTF-8 bytes of the input. */\nexport interface ByteRange {\n  readonly start: number;\n  readonly end: number;\n}\n\n/**\n * Why a range was elided, in two registers: a stable id for counters, and a sentence\n * a human can read in a diff. Law 2 — every elision is explainable — lives here:\n * if you cannot write the sentence, the rule does not ship.\n */\nexport interface ElisionReason {\n  /** Stable machine id, e.g. `'sibling-collapse'`, `'line-window'`. */\n  readonly rule: string;\n  /** e.g. `'collapsed 3 sibling functions'`. Present tense, no trailing period. */\n  readonly explanation: string;\n}\n\n/** One range a planner proposes to remove. Plans are pure data — inspectable and testable. */\nexport interface PlannedElision {\n  readonly range: ByteRange;\n  readonly reason: ElisionReason;\n}\n\n/**\n * The complete output of a planner: the whole decision, before anything is mutated.\n * A plan can be logged, diffed, snapshot-tested, and rejected without touching the text.\n */\nexport interface ElisionPlan {\n  readonly planner: string;\n  readonly language: DetectedLanguage;\n  readonly elisions: readonly PlannedElision[];\n}\n\n/**\n * The seam through which a planner asks what a marker will cost, in UTF-8 bytes.\n *\n * Marker cost is `apply.ts`'s fact — the applier renders the marker, so only the\n * applier knows its price. Planners need that price for two decisions (profitability:\n * a marker that costs more than it removes grows the output; and budget prediction:\n * which ladder rung actually fits), and before this seam each planner rebuilt the\n * marker machinery privately to measure it — correct, but an inversion. Now\n * `markerPricing()` in `apply.ts` builds the one adapter from the exact builder\n * `applyPlan` will use, and planners ask it. They never guess, and they never render\n * a marker of their own.\n *\n * The price is exact, not an estimate: the cost of the marker this elision would\n * earn, comment leader and all, with a stand-in hash of the real hash's length —\n * marker cost depends on the hash's *length*, never its value.\n */\nexport interface MarkerPricing {\n  /** The exact UTF-8 byte cost of the marker an elision with this reason and size would earn. */\n  costBytes(reason: ElisionReason, elidedBytes: number): number;\n}\n\n/**\n * What the caller hands a planner.\n *\n * Constructed centrally: `createSmelter` (and through it, the CLI) builds the one\n * `PlanInput` per call, including its {@link MarkerPricing} — a caller invoking\n * `planLexical`/`planStructural` directly builds `pricing` with `markerPricing()`\n * from `apply.ts`. A JS caller who omits it gets {@link MissingMarkerPricingError}\n * at plan time, not a guessed cost.\n */\nexport interface PlanInput {\n  readonly text: string;\n  readonly language: DetectedLanguage;\n  /** Soft ceiling for the emitted output, in UTF-8 bytes. Planners aim under it. */\n  readonly budgetBytes: number;\n  /**\n   * What the caller was actually looking for — grep pattern, symbol name, error string.\n   * Planners keep matching regions and collapse around them.\n   */\n  readonly focus?: readonly string[];\n  /**\n   * What a marker costs. Required: a planner that guesses marker cost can plan an\n   * elision that grows the output. See {@link MarkerPricing}; built by\n   * `markerPricing()` in `apply.ts` from the exact builder `applyPlan` will use.\n   */\n  readonly pricing: MarkerPricing;\n}\n\n/**\n * A planner decides *what* to remove. It never removes anything itself; `applyPlan`\n * does that. Keeping the decision and the mutation apart is what makes the decision\n * testable in isolation.\n */\nexport interface Planner {\n  readonly id: string;\n  plan(input: PlanInput): Promise<ElisionPlan>;\n}\n\n/** One elision that actually happened, with the receipt needed to undo it. */\nexport interface AppliedElision {\n  /** Content hash of the removed bytes — the key `retrieve()` takes. */\n  readonly hash: string;\n  /** Where the removed bytes were in the *input*. */\n  readonly range: ByteRange;\n  /**\n   * Where the marker sits in the *output*. Law 3 — every elision is reversible — needs\n   * this: {@link Reconstructor} splices stored bytes back over these ranges. Without it,\n   * \"reversible\" would mean parsing markers back out of the text, which is a guess.\n   * This is a fact recorded at the moment of the cut.\n   */\n  readonly outputRange: ByteRange;\n  /** Size of the removed content, in UTF-8 bytes. */\n  readonly bytes: number;\n  readonly reason: ElisionReason;\n  /** The exact marker text substituted into the output. */\n  readonly marker: string;\n}\n\n/**\n * A consumer-supplied counter, so a caller who bills in tokens can *see* tokens.\n *\n * Budgets in smelt's core are UTF-8 bytes, permanently — bytes are the only unit that\n * is computable locally for every model, and they mean the same thing in five years.\n * See `docs/ARCHITECTURE.md` § \"Decision 1\". This hook does not change that: it adds a\n * second, labelled number to the result. The plan is still made in bytes.\n *\n * Both `id` and `unit` are required, and that is a Law 4 decision rather than\n * bookkeeping: a token count is meaningless without naming the tokenizer that produced\n * it. Anthropic's own docs record that Claude 4.7 and later use a newer tokenizer where\n * the same text yields roughly 30% more tokens than on earlier models — so `1,204\n * tokens` is not a fact, and `1,204 tokens (claude-4.7/count_tokens)` is.\n *\n * **This hook does not relax Law 1.** smelt imports no transport and the guard proves\n * that about smelt's own modules; it cannot prove it about a function you hand in. A\n * `count()` that calls an API makes *your* process call an API, from a line in *your*\n * source — exactly the arrangement {@link RerankStage} already describes. `count` is\n * synchronous on purpose: local tokenizers are synchronous, and network clients are not.\n */\nexport interface Measure {\n  /** Names the counter, e.g. `'tiktoken/o200k_base'` or `'claude-4.7/count_tokens'`. */\n  readonly id: string;\n  /** The unit `count()` returns, e.g. `'tokens'`. Printed next to the number. */\n  readonly unit: string;\n  /** Local, synchronous count over the whole string. */\n  count(text: string): number;\n}\n\n/** A second size for a result, in someone else's unit, with the counter named. */\nexport interface MeasuredSize {\n  /** {@link Measure.id} of the counter that produced these numbers. */\n  readonly measure: string;\n  /** {@link Measure.unit}. */\n  readonly unit: string;\n  readonly input: number;\n  readonly output: number;\n}\n\n/** The result of smelting one blob of text. */\nexport interface SmeltResult {\n  readonly text: string;\n  readonly inputBytes: number;\n  readonly outputBytes: number;\n  readonly planner: string;\n  readonly language: DetectedLanguage;\n  readonly elisions: readonly AppliedElision[];\n  /** Present only when the caller supplied a {@link Measure}. Never invented. */\n  readonly measured?: MeasuredSize;\n}\n\n/**\n * Reversibility, as a callable. Takes a {@link SmeltResult} and the store that holds its\n * elided bytes, and returns the original text — byte for byte.\n */\nexport type Reconstructor = (result: SmeltResult, store: ElisionStore) => string;\n\n// ---------------------------------------------------------------------------\n// The store, and the counters that make over-pruning visible\n// ---------------------------------------------------------------------------\n\n/**\n * The numbers that keep smelt honest about itself.\n *\n * Law 3 says elisions are reversible. That is cheap to satisfy and easy to abuse: a\n * compressor that cuts everything is \"reversible\" and useless. The *retrieve rate* is\n * the tell. If the model keeps calling `smelt_retrieve`, smelt cut material the task\n * needed, and the round trip cost more tokens than the elision saved.\n *\n * So: `expansionRate` is not telemetry. It is the metric a caller tunes budgets\n * against, and the only number smelt is willing to have an opinion about — because it\n * measures it locally, per session, on the caller's own traffic.\n */\nexport interface RetrieveStats {\n  /** Distinct blobs put into the store. */\n  readonly elisionsStored: number;\n  /** Total bytes held by the store. */\n  readonly bytesStored: number;\n  /** Every `retrieve()` call, including repeats and misses. */\n  readonly retrieveCalls: number;\n  /** Distinct hashes successfully retrieved at least once. */\n  readonly uniqueRetrieved: number;\n  /** Calls for a hash the store does not hold. Non-zero means a bug, not over-pruning. */\n  readonly misses: number;\n  /**\n   * `uniqueRetrieved / elisionsStored`, or `0` when nothing has been stored.\n   *\n   * Read it as: *what fraction of what smelt hid did the model have to ask for back?*\n   * There is no universally right value, and smelt does not ship a threshold it has\n   * not measured. Rising across a workload is the signal.\n   */\n  readonly expansionRate: number;\n  /**\n   * The one degenerate outcome smelt is willing to name: **every distinct blob it hid\n   * was asked for again.**\n   *\n   * smelt ships no expansion-rate threshold, because a threshold is a policy claim it\n   * has no basis for and the right rate depends on how aggressive a budget the caller\n   * chose — and a library printing warnings into someone else's process is bad manners.\n   * This is not a threshold. At `uniqueRetrieved === elisionsStored` the elision\n   * achieved nothing and cost a round trip: an arithmetic fact, not a preference. What\n   * to do about it is the caller's call.\n   *\n   * `false` for an empty store — nothing was hidden, so nothing was defeated.\n   */\n  readonly allElisionsRetrieved: boolean;\n}\n\n/**\n * Local, content-addressed storage for elided bytes. No network, no eviction in v1 —\n * evicting is how \"reversible\" quietly becomes \"reversible for a while\".\n */\nexport interface ElisionStore {\n  /** Store content, returning its hash. Idempotent for identical content. */\n  put(content: string): string;\n  /** The stored content, or `undefined` if this store never held that hash. */\n  peek(hash: string): string | undefined;\n  /**\n   * The stored content, *counted* as a retrieval. This is what the model's tool calls.\n   *\n   * @throws {UnknownHashError} when the hash is unknown.\n   * @throws {StoreCorruptionError} — {@link DirectoryElisionStore} only — when the\n   *   bytes on disk no longer hash to their own name. Distinct from\n   *   `UnknownHashError` on purpose: \"we hold damaged bytes\" and \"it never existed\"\n   *   are different answers, and a caller that conflates them will report the wrong\n   *   one to its user.\n   *\n   * A {@link DirectoryElisionStore} whose journal cannot be written (a read-only\n   * store directory, a full disk) still returns the bytes — verified bytes are never\n   * withheld over a bookkeeping failure — and surfaces the lost count as a\n   * `process.emitWarning` named `SmeltCounterWriteFailure` instead of throwing. Its\n   * stats go quiet from that point; the retrieval itself succeeded.\n   */\n  retrieve(hash: string): string;\n  /**\n   * Whether this hash can be retrieved — **not** merely whether a slot bearing it\n   * exists. `true` must mean the very next `retrieve(hash)` returns bytes, so a store\n   * that verifies content on read verifies here too and raises its corruption error\n   * rather than answering `true` for bytes it would then refuse. Uncounted: a check is\n   * not the model asking for material back.\n   */\n  has(hash: string): boolean;\n  /** A snapshot of the counters. See {@link RetrieveStats}. */\n  stats(): RetrieveStats;\n}\n\n/**\n * The retrieval tool a consumer exposes to its model. Deliberately not an MCP or\n * provider-specific shape — smelt does not know which SDK you use. The consumer adapts\n * this into its own tool schema; the contract is `hash in, exact bytes out`.\n */\nexport interface RetrieveTool {\n  /** `'smelt_retrieve'`. Stable — consumers hard-code it in prompts. */\n  readonly name: string;\n  /** Prose the consumer can put straight into a tool description. */\n  readonly description: string;\n  /**\n   * JSON-Schema-shaped parameter description, for consumers that want one.\n   *\n   * Strict-mode shaped: `additionalProperties: false` and a `required` naming every\n   * property, so a consumer registering this under OpenAI's structured-outputs strict\n   * mode is not refused at registration. See {@link createRetrieveTool}.\n   */\n  readonly inputSchema: {\n    readonly type: 'object';\n    readonly properties: {\n      readonly hash: { readonly type: 'string'; readonly description: string };\n    };\n    readonly required: readonly ['hash'];\n    readonly additionalProperties: false;\n  };\n  /**\n   * @throws {UnknownHashError} when the hash is unknown.\n   * @throws {StoreCorruptionError} when the backing store holds damaged bytes for\n   *   that hash — see {@link ElisionStore.retrieve}, whose contract this forwards\n   *   verbatim. Surface either to the model as a tool error, never as empty text.\n   */\n  invoke(input: { readonly hash: string }): string;\n}\n\n// ---------------------------------------------------------------------------\n// Pluggable stages — interfaces in v1, nothing more\n// ---------------------------------------------------------------------------\n\n/** A candidate handed to a {@link RerankStage}: an opaque id plus the text to judge. */\nexport interface RerankCandidate {\n  readonly id: string;\n  readonly text: string;\n}\n\n/** A reranked candidate, most relevant first. `score` is the stage's own scale. */\nexport interface RerankedCandidate extends RerankCandidate {\n  readonly score: number;\n}\n\n/**\n * Relevance reranking — a *seam*, not a feature.\n *\n * Hosted rerankers are good and smelt will never bundle one, because bundling would\n * break Law 1: the moment smelt ships a default reranker, `smelt()` can make a network\n * call that the caller did not ask for and cannot see. A consumer that wants one\n * implements this interface, wires its own key, and owns the fact that its context now\n * leaves the machine. That decision must be legible in the consumer's own source.\n */\nexport interface RerankStage {\n  readonly id: string;\n  /** May make network calls — that is the consumer's choice, made in the consumer's code. */\n  rerank(\n    candidates: readonly RerankCandidate[],\n    query: string,\n  ): Promise<readonly RerankedCandidate[]>;\n}\n\n/**\n * Learned distillation — rewriting content with a model instead of cutting it.\n *\n * Out of v1 for a reason beyond the network: a distilled paragraph cannot satisfy\n * Law 2. \"The model summarised this\" is not an explanation of what was removed, and\n * the removed material is no longer recoverable from the output. If this ever ships,\n * it ships as a stage that stores the original and explains itself in the same terms\n * every other rule does.\n */\nexport interface DistillStage {\n  readonly id: string;\n  distill(text: string, budgetBytes: number): Promise<string>;\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smeltjs/core",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Structure-aware, reversible, offline context optimization for AI coding agents.",
   "license": "Apache-2.0",
   "author": "mong-x",
@@ -56,14 +56,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json && node ../../scripts/bundle-grammars.mjs",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "prepack": "pnpm run build && node ../../scripts/generate-third-party.mjs",
-    "bench": "node bench/run.mjs"
-  },
   "dependencies": {
     "web-tree-sitter": "~0.25.10"
   },
@@ -71,6 +63,14 @@
     "@types/node": "^26.4.0",
     "tree-sitter-wasms": "^0.1.13",
     "typescript": "^7.0.2",
-    "vitest": "^4.1.11"
+    "vitest": "^4.1.11",
+    "@smelt/guard-kit": "0.0.0"
+  },
+  "scripts": {
+    "build": "node ../../scripts/clean-dist.mjs && tsc -p tsconfig.build.json && node ../../scripts/inline-declaration-map-sources.mjs && node ../../scripts/bundle-grammars.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "bench": "node bench/run.mjs"
   }
-}
+}

package/dist/cli/resolve.d.ts

@@ -1,103 +0,0 @@
-import type { Strategy } from '../plan/planners.ts';
-import type { DetectedLanguage } from '../types.ts';
-import type { MapInvocation, SmeltInvocation } from './args.ts';
-import type { LoadedConfig } from './config.ts';
-/**
- * Everything one smelt run needs, fully merged — with a receipt for where each
- * merged value came from.
- *
- * This is the CLI's single merge of flags + config + built-ins. Precedence lives
- * here and nowhere else: `resolveRun` is the only code that may look at a flag and a
- * config default side by side, so a precedence question is always answered by one
- * function instead of by reading two files. `runSmelt` executes this object
- * straight-line, without a `??` of its own.
- */
-export interface ResolvedRun {
-    readonly budgetBytes: number;
-    /** Where the budget came from. A missing budget never gets here — it throws. */
-    readonly budgetSource: 'flag' | 'config';
-    readonly strategy: Strategy;
-    readonly strategySource: 'flag' | 'config' | 'builtin';
-    /**
-     * The store decision, with `path` already resolved against the config file's
-     * directory. `'memory'` is the built-in default — a fresh in-memory store per run.
-     */
-    readonly store: {
-        readonly kind: 'memory';
-    } | {
-        readonly kind: 'directory';
-        readonly path: string;
-    };
-    /** Path to read. `undefined` means stdin. Flags only; the config has no say. */
-    readonly file?: string;
-    readonly focus: readonly string[];
-    readonly language?: DetectedLanguage;
-    readonly json: boolean;
-}
-/**
- * Merge one `'smelt'`-mode invocation with the loaded config (or `undefined` when no
- * `smelt.config.json` exists) and the built-in defaults.
- *
- * The precedence is strict and one-directional: an explicit flag always wins over the
- * config, and the config only fills what the flags left unsaid. Built-ins fill last,
- * and only where a built-in exists at all — the budget deliberately has none, so a run
- * with no budget from either source is refused here, in the one module that owns that
- * error.
- *
- * @throws {CliUsageError} when neither `--budget` nor the config names a budget.
- */
-export declare function resolveRun(invocation: SmeltInvocation, config: LoadedConfig | undefined): ResolvedRun;
-/**
- * Everything one `smelt map` run needs, fully merged — {@link ResolvedRun}'s sibling,
- * not a contortion of it. The two commands share exactly one merged value (the
- * budget), so they share the *module* that owns precedence and the budget-required
- * refusal, not a struct whose fields would mostly be lies for one of them: a map has
- * no store, no strategy, no stdin, and its ignore/cache legs mean nothing to a
- * single-blob run.
- */
-export interface ResolvedMapRun {
-    readonly budgetBytes: number;
-    /** Where the budget came from. A missing budget never gets here — it throws. */
-    readonly budgetSource: 'flag' | 'config';
-    readonly dir: string;
-    readonly focus: readonly string[];
-    /** `undefined` means "use the library's default ignore list". Flags only. */
-    readonly ignore?: readonly string[];
-    /** Only when present does the map write to disk. Flags only; the config has no say. */
-    readonly cacheDir?: string;
-    readonly json: boolean;
-}
-/**
- * Merge one `'map'`-mode invocation with the loaded config and the built-ins. The
- * config contributes exactly what it contributes to a smelt run — `defaultBudgetBytes`,
- * a default the user chose explicitly — and nothing else: the store and strategy legs
- * are single-blob concerns, and the map ignores them rather than reinterpreting them.
- *
- * @throws {CliUsageError} when neither `--budget` nor the config names a budget.
- */
-export declare function resolveMapRun(invocation: MapInvocation, config: LoadedConfig | undefined): ResolvedMapRun;
-/**
- * Everything `smelt retrieve` and `smelt stats` need, fully merged: the persistent
- * store's directory, already resolved against the config file. A third sibling in
- * this module for the same reason {@link ResolvedMapRun} is one — these commands
- * share the *module* that owns precedence, not a struct: they have no budget, no
- * strategy, no file leg at all, only the store leg, which is config-only.
- */
-export interface ResolvedStoreRun {
-    /** Absolute path of the directory store, resolved against the config file. */
-    readonly storePath: string;
-}
-/**
- * The store leg alone, for the two commands whose entire job is the store between
- * runs. The refusal is the point: `retrieve` exists so the marker's
- * `retrieve("hash")` works from a later shell — cross-run retrieval — and a memory
- * store dies with the process that filled it, so with a memory store (or no config
- * at all) there is nothing those commands could honestly read. Answering with
- * `UnknownHashError` or all-zero stats instead would be the quiet wrong answer this
- * project refuses everywhere: the hash *was* elided, the counters *did* move — in a
- * store that no longer exists.
- *
- * @throws {CliUsageError} when no config exists, or the configured store is memory.
- */
-export declare function resolveStoreRun(command: 'retrieve' | 'stats', config: LoadedConfig | undefined): ResolvedStoreRun;
-//# sourceMappingURL=resolve.d.ts.map

package/dist/cli/resolve.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../src/cli/resolve.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGpD,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEhE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD;;;;;;;;;GASG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,gFAAgF;IAChF,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,QAAQ,CAAC;IACzC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;IACvD;;;OAGG;IACH,QAAQ,CAAC,KAAK,EACZ;QAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;KAAE,GAAG;QAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACtF,gFAAgF;IAChF,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IACrC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;CACxB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CACxB,UAAU,EAAE,eAAe,EAC3B,MAAM,EAAE,YAAY,GAAG,SAAS,GAC/B,WAAW,CA8Bb;AAcD;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,gFAAgF;IAChF,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,QAAQ,CAAC;IACzC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,6EAA6E;IAC7E,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,uFAAuF;IACvF,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;CACxB;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,UAAU,EAAE,aAAa,EACzB,MAAM,EAAE,YAAY,GAAG,SAAS,GAC/B,cAAc,CAqBhB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,8EAA8E;IAC9E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,UAAU,GAAG,OAAO,EAC7B,MAAM,EAAE,YAAY,GAAG,SAAS,GAC/B,gBAAgB,CAgBlB"}

package/dist/cli/resolve.js

@@ -1,106 +0,0 @@
-import { CliUsageError } from '../errors.js';
-import { CLI_NAME } from './args.js';
-import { CONFIG_FILE_NAME, resolveStorePath } from './config.js';
-/**
- * Merge one `'smelt'`-mode invocation with the loaded config (or `undefined` when no
- * `smelt.config.json` exists) and the built-in defaults.
- *
- * The precedence is strict and one-directional: an explicit flag always wins over the
- * config, and the config only fills what the flags left unsaid. Built-ins fill last,
- * and only where a built-in exists at all — the budget deliberately has none, so a run
- * with no budget from either source is refused here, in the one module that owns that
- * error.
- *
- * @throws {CliUsageError} when neither `--budget` nor the config names a budget.
- */
-export function resolveRun(invocation, config) {
-    const budgetBytes = invocation.budgetBytes ?? config?.config.defaultBudgetBytes;
-    if (budgetBytes === undefined) {
-        throw new CliUsageError(`${CLI_NAME}: --budget is required, in UTF-8 bytes. There is no default, because ` +
-            `a budget smelt invented would silently decide how much of your context to ` +
-            `throw away. Pass --budget, or set defaultBudgetBytes in ${CONFIG_FILE_NAME} ` +
-            `(\`${CLI_NAME} init\` writes one).\n` +
-            `  ${CLI_NAME} src/server.ts --budget 4000 --focus handleRequest`);
-    }
-    const strategy = invocation.strategy ?? config?.config.strategy ?? 'lexical';
-    return {
-        budgetBytes,
-        budgetSource: invocation.budgetBytes !== undefined ? 'flag' : 'config',
-        strategy,
-        strategySource: invocation.strategy !== undefined
-            ? 'flag'
-            : config?.config.strategy !== undefined
-                ? 'config'
-                : 'builtin',
-        store: resolveStore(config),
-        ...(invocation.file === undefined ? {} : { file: invocation.file }),
-        focus: invocation.focus,
-        ...(invocation.language === undefined ? {} : { language: invocation.language }),
-        json: invocation.json,
-    };
-}
-/**
- * The store the config asks for, with `path` resolved relative to the config file —
- * one config serves every subdirectory it covers without scattering store roots.
- * There is no store flag, so this leg of the merge is config-or-built-in only.
- */
-function resolveStore(config) {
-    if (config?.config.store === undefined || config.config.store.kind === 'memory') {
-        return { kind: 'memory' };
-    }
-    return { kind: 'directory', path: resolveStorePath(config, config.config.store.path) };
-}
-/**
- * Merge one `'map'`-mode invocation with the loaded config and the built-ins. The
- * config contributes exactly what it contributes to a smelt run — `defaultBudgetBytes`,
- * a default the user chose explicitly — and nothing else: the store and strategy legs
- * are single-blob concerns, and the map ignores them rather than reinterpreting them.
- *
- * @throws {CliUsageError} when neither `--budget` nor the config names a budget.
- */
-export function resolveMapRun(invocation, config) {
-    const budgetBytes = invocation.budgetBytes ?? config?.config.defaultBudgetBytes;
-    if (budgetBytes === undefined) {
-        throw new CliUsageError(`${CLI_NAME}: --budget is required, in UTF-8 bytes. There is no default, because ` +
-            `a budget ${CLI_NAME} invented would silently decide how much of the map to ` +
-            `leave out. Pass --budget, or set defaultBudgetBytes in ${CONFIG_FILE_NAME} ` +
-            `(\`${CLI_NAME} init\` writes one).\n` +
-            `  ${CLI_NAME} map src --budget 4000 --focus handleRequest`);
-    }
-    return {
-        budgetBytes,
-        budgetSource: invocation.budgetBytes !== undefined ? 'flag' : 'config',
-        dir: invocation.dir,
-        focus: invocation.focus,
-        ...(invocation.ignore.length === 0 ? {} : { ignore: invocation.ignore }),
-        ...(invocation.cacheDir === undefined ? {} : { cacheDir: invocation.cacheDir }),
-        json: invocation.json,
-    };
-}
-/**
- * The store leg alone, for the two commands whose entire job is the store between
- * runs. The refusal is the point: `retrieve` exists so the marker's
- * `retrieve("hash")` works from a later shell — cross-run retrieval — and a memory
- * store dies with the process that filled it, so with a memory store (or no config
- * at all) there is nothing those commands could honestly read. Answering with
- * `UnknownHashError` or all-zero stats instead would be the quiet wrong answer this
- * project refuses everywhere: the hash *was* elided, the counters *did* move — in a
- * store that no longer exists.
- *
- * @throws {CliUsageError} when no config exists, or the configured store is memory.
- */
-export function resolveStoreRun(command, config) {
-    const store = resolveStore(config);
-    if (store.kind !== 'directory') {
-        const state = config === undefined
-            ? `there is no ${CONFIG_FILE_NAME} here`
-            : `the ${CONFIG_FILE_NAME} at ${config.path} uses a memory store`;
-        throw new CliUsageError(`${CLI_NAME}: ${command} needs a persistent store, and ${state}. Cross-run ` +
-            `retrieval is the point of the store: a memory store dies with the process ` +
-            `that made it, so a marker's hash from an earlier run names bytes this run ` +
-            `never held. Configure {"store": {"kind": "directory", "path": …}} in ` +
-            `${CONFIG_FILE_NAME} — \`${CLI_NAME} init\` writes one.`);
-    }
-    return { storePath: store.path };
-}
-//# sourceMappingURL=resolve.js.map

package/dist/cli/resolve.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve.js","sourceRoot":"","sources":["../../src/cli/resolve.ts"],"names":[],"mappings":"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"}