@smeltjs/core 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,55 @@
+# @smeltjs/core
+
+Structure-aware, reversible context optimization for coding agents. Zero network calls.
+
+This is the library package. The project README, the four laws and their reasoning, the
+build plan and the consumer contract all live in the repository root:
+**https://github.com/mong-x/smelt**
+
+```ts
+import { createSmelter } from '@smeltjs/core';
+
+const smelter = createSmelter({ defaultBudgetBytes: 8_000 });
+
+const result = await smelter.smelt(toolOutput, {
+  path: 'src/server.ts',
+  focus: ['handleRequest'],
+  budgetBytes: 4_000,
+});
+
+result.text; // send this to the model
+smelter.tool; // the `smelt_retrieve` tool that gives it the rest back
+smelter.stats().expansionRate; // whether you cut too much
+```
+
+There is also a CLI, installed as `smelt` (or run via `npx @smeltjs/core`):
+
+```sh
+smelt src/server.ts --budget 4000 --focus handleRequest   # text on stdout, report on stderr
+smelt --budget 4000 --focus TypeError < build.log
+smelt --strategy structural src/api.ts --budget 4000       # parse-tree collapse for code
+smelt --reconstruct result.json                            # the round trip, from a shell
+smelt init                                                 # the setup wizard: defaults, back-navigation, smelt.config.json
+```
+
+**Budgets are UTF-8 bytes, permanently** — the only unit computable locally for every
+model, which is what makes the zero-network guarantee possible. Pass a `measure` if you
+want a token count in the result as well; the budget stays bytes.
+
+**Two stability promises.** The marker format (`<<smelt/v1: … >>`) and the
+`smelt_retrieve` tool name are stable from 0.1 and treated as 1.0, because markers go into
+prompts and a silent change to one shows up as worse model output with no error anywhere.
+The TypeScript API is `0.x` and may move.
+
+The parsers ship inside this tarball — no native build step, no post-install download.
+That makes smelt a redistributor, so [`THIRD-PARTY.md`](./THIRD-PARTY.md) carries the
+licences, generated from package metadata rather than written by hand.
+
+**0.x.** The full v1 slice plan has shipped: structural planning (tree-sitter, with
+signatures and doc comments always kept), the lexical planner, a persistent
+content-addressed store, cache-prefix hygiene (detect, never rewrite), a repo-map
+planner modelled on Aider's, the `smelt init` wizard, and a committed measurement
+harness. An unsupported language under `strategy: 'structural'` is refused, never
+approximated. See [`docs/HANDOFF.md`](https://github.com/mong-x/smelt/blob/main/docs/HANDOFF.md).
+
+Apache-2.0.

package/THIRD-PARTY.md

@@ -0,0 +1,140 @@
+# Third-party notices
+
+<!-- GENERATED FILE — do not edit by hand.
+     Produced by scripts/generate-third-party.mjs from installed package metadata,
+     the bundled grammar files, and packages/core/grammar-provenance.json.
+     Regenerate with `pnpm generate:third-party`; a stale copy fails
+     packages/core/test/guards/third-party.test.ts. -->
+
+`@smeltjs/core` redistributes the files listed below inside its npm tarball. Everything here is someone else's work, under someone else's licence.
+
+Attribution is required rather than courteous, because the parsers are **shipped**, not merely depended on: that is what makes "no native compilation, works offline" true. If you redistribute smelt, this file travels with it.
+
+## Runtime dependencies
+
+### web-tree-sitter 0.25.10 — MIT
+
+- Repository: https://github.com/tree-sitter/tree-sitter
+- Declared range: `~0.25.10`
+
+```text
+The MIT License (MIT)
+
+Copyright (c) 2018-2024 Max Brunsfeld
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
+## Bundled tree-sitter grammars
+
+The `.wasm` parsers in `grammars/` were taken from **tree-sitter-wasms 0.1.13** (Unlicense), which prebuilds them. The packaging licence covers the packaging; each grammar carries its own, listed after the table.
+
+| file                          | from                   | version range | licence | bytes   | sha256             |
+| ----------------------------- | ---------------------- | ------------- | ------- | ------- | ------------------ |
+| `tree-sitter-bash.wasm`       | tree-sitter-bash       | `^0.20.5`     | MIT     | 1400214 | `807dcdb1380a59be` |
+| `tree-sitter-c.wasm`          | tree-sitter-c          | `^0.20.7`     | MIT     | 792959  | `056b25072382f72d` |
+| `tree-sitter-c_sharp.wasm`    | tree-sitter-c-sharp    | `^0.20.0`     | MIT     | 3978594 | `6266a7e32d68a345` |
+| `tree-sitter-cpp.wasm`        | tree-sitter-cpp        | `^0.20.4`     | MIT     | 4662978 | `f6afdf53bfd6de76` |
+| `tree-sitter-go.wasm`         | tree-sitter-go         | `^0.20.0`     | MIT     | 235957  | `9963ca89b616eaf0` |
+| `tree-sitter-java.wasm`       | tree-sitter-java       | `^0.20.2`     | MIT     | 430239  | `637aac4415fb39a2` |
+| `tree-sitter-javascript.wasm` | tree-sitter-javascript | `^0.20.3`     | MIT     | 647334  | `63812b9e275d2685` |
+| `tree-sitter-kotlin.wasm`     | tree-sitter-kotlin     | `^0.3.1`      | MIT     | 4052705 | `b5cb00c8d06ed0f1` |
+| `tree-sitter-php.wasm`        | tree-sitter-php        | `^0.22.0`     | MIT     | 812594  | `55bb617b6f01e14b` |
+| `tree-sitter-python.wasm`     | tree-sitter-python     | `^0.21.0`     | MIT     | 476105  | `9056d0fb0c337810` |
+| `tree-sitter-ruby.wasm`       | tree-sitter-ruby       | `^0.20.1`     | MIT     | 2106447 | `93a5022855314cdb` |
+| `tree-sitter-rust.wasm`       | tree-sitter-rust       | `^0.20.4`     | MIT     | 818756  | `4409921a70d0aa5b` |
+| `tree-sitter-swift.wasm`      | tree-sitter-swift      | `^0.4.0`      | MIT     | 3147876 | `41c4fdb2249a3aa6` |
+| `tree-sitter-tsx.wasm`        | tree-sitter-typescript | `^0.20.5`     | MIT     | 2411272 | `6aa3b2c70e76f5d4` |
+| `tree-sitter-typescript.wasm` | tree-sitter-typescript | `^0.20.5`     | MIT     | 2342690 | `8515404dceed38e1` |
+
+### Copyright notices
+
+Licence identifiers and copyright lines below were verified on **2026-09-02** against the npm registry and each repository's `LICENSE` file, and are recorded in `grammar-provenance.json`. They are not derivable on this machine: a `.wasm` blob carries no metadata, and the grammar packages are tree-sitter-wasms's own devDependencies, so they are never installed here.
+
+- **tree-sitter-bash** — MIT — Copyright (c) 2017 Max Brunsfeld — https://github.com/tree-sitter/tree-sitter-bash
+- **tree-sitter-c** — MIT — Copyright (c) 2014 Max Brunsfeld — https://github.com/tree-sitter/tree-sitter-c
+- **tree-sitter-c-sharp** — MIT — Copyright (c) 2014-2023 Max Brunsfeld, Damien Guard, Amaan Qureshi, and contributors. — https://github.com/tree-sitter/tree-sitter-c-sharp
+- **tree-sitter-cpp** — MIT — Copyright (c) 2014 Max Brunsfeld — https://github.com/tree-sitter/tree-sitter-cpp
+- **tree-sitter-go** — MIT — Copyright (c) 2014 Max Brunsfeld — https://github.com/tree-sitter/tree-sitter-go
+- **tree-sitter-java** — MIT — Copyright (c) 2017 Ayman Nadeem — https://github.com/tree-sitter/tree-sitter-java
+- **tree-sitter-javascript** — MIT — Copyright (c) 2014 Max Brunsfeld — https://github.com/tree-sitter/tree-sitter-javascript
+- **tree-sitter-kotlin** — MIT — Copyright (c) 2019 fwcd — https://github.com/fwcd/tree-sitter-kotlin
+- **tree-sitter-php** — MIT — Copyright (c) 2017 Josh Vera, GitHub — https://github.com/tree-sitter/tree-sitter-php
+- **tree-sitter-python** — MIT — Copyright (c) 2016 Max Brunsfeld — https://github.com/tree-sitter/tree-sitter-python
+- **tree-sitter-ruby** — MIT — Copyright (c) 2016 Rob Rix — https://github.com/tree-sitter/tree-sitter-ruby
+- **tree-sitter-rust** — MIT — Copyright (c) 2017 Maxim Sokolov — https://github.com/tree-sitter/tree-sitter-rust
+- **tree-sitter-swift** — MIT — Copyright (c) 2021 alex-pinkus — https://github.com/alex-pinkus/tree-sitter-swift
+- **tree-sitter-typescript** — MIT — Copyright (c) 2017 Max Brunsfeld — https://github.com/tree-sitter/tree-sitter-typescript
+
+### Packaging licence
+
+```text
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org>
+```
+
+### The MIT licence
+
+Every grammar above is MIT. The body is reproduced once, quoted from the installed `web-tree-sitter` `LICENSE` — each grammar's own copy differs only in the copyright line listed above.
+
+```text
+The MIT License (MIT)
+
+Copyright (c) 2018-2024 Max Brunsfeld
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```

package/dist/apply.d.ts

@@ -0,0 +1,145 @@
+import type { DetectedLanguage, ElisionPlan, ElisionStore, MarkerPricing, Measure, SmeltResult } from './types.ts';
+/** Everything the marker text is allowed to depend on. */
+export interface MarkerInfo {
+    readonly hash: string;
+    readonly bytes: number;
+    readonly rule: string;
+    readonly explanation: string;
+}
+export type MarkerBuilder = (info: MarkerInfo) => string;
+/**
+ * The version of the marker format itself, carried **in band** in every marker.
+ *
+ * The marker is the one part of smelt a *model* sees, and it goes into prompts.
+ * Changing its shape changes model behaviour downstream and shows up as worse output
+ * with no error anywhere — this project's signature failure mode, shipped as a patch
+ * release. So the wire surface is frozen from 0.1 and treated as 1.0
+ * (`CONTRIBUTING.md` § "Two promises, not one"), and a future format is *additive and
+ * identifiable*: `smelt/v2` markers can coexist with `smelt/v1` ones, and a consumer
+ * parsing markers can tell which it is holding. A format that changed silently would
+ * be a substitution; this makes it a declaration.
+ *
+ * `test/guards/marker-format.test.ts` pins the rendered marker per version and fails if
+ * the format moves without the version moving.
+ */
+export declare const MARKER_FORMAT_VERSION = "v1";
+/**
+ * The default marker.
+ *
+ * Its shape is the user-facing form of Laws 2 and 3, in one line the model reads:
+ * *which format this is* (the version), *what was removed* (the explanation), *how
+ * much* (the byte count), and *how to get it back* (the hash). Anything that cannot
+ * fill in all of those is not allowed to be an elision.
+ *
+ * `<<…>>` rather than a Unicode bracket because it survives every tokenizer, terminal,
+ * and diff tool without becoming three tokens of nothing.
+ */
+export declare const defaultMarker: MarkerBuilder;
+/**
+ * Line-comment leaders per language: the marker always lands as a comment in the
+ * survivor's own syntax, because a bare marker line breaks the syntax of what remains
+ * around it — in **every** grammar this was tested against, not just the indented ones.
+ *
+ * The failure classes, each verified by reparsing a bare-marker survivor:
+ *
+ *   - **python** — significant indentation means a parse error does not stay local.
+ *     The ERROR node swallows the *neighbouring definitions too* — the survivor stops
+ *     being Python at all, not just at the marker line.
+ *   - **ruby** and **bash** — the marker *begins with* `<<`, which both languages read
+ *     as a heredoc operator. A bare marker line opens a heredoc whose terminator never
+ *     arrives, and everything after it — every kept declaration — is swallowed into a
+ *     string literal.
+ *   - **php** — `<<` is an operator here too: the kept function after a bare marker is
+ *     re-typed into an anonymous-function operand inside the marker's binary
+ *     expression. The kept declaration is no longer a declaration in the survivor.
+ *   - **kotlin**, **swift**, and the rest of the brace-delimited set (typescript, tsx,
+ *     javascript, rust, go, java, c, cpp, c_sharp) — the folk claim that braces keep a
+ *     parse error local is **empirically false**: reparsing each language's fixture
+ *     survivor with its own bundled grammar shows ERROR nodes spanning the kept
+ *     declarations (a C function's signature absorbed into an ERROR, fifteen cascading
+ *     ERRORs in swift, and so on). The survivor-reparse guard in
+ *     `test/guards/structural.test.ts` now asserts the opposite property for every
+ *     structural language: the survivor reparses with no new issues.
+ *
+ * Only `'unknown'` keeps the bare marker — lexical text has no syntax to break.
+ *
+ * This does **not** move the frozen wire surface. The `<<smelt/v1: … >>` core is
+ * rendered by {@link defaultMarker}, byte-identical and still versioned in band; the
+ * leader is part of the substituted marker text, so `outputRange` covers it and
+ * reconstruction stays byte-exact. A comment leader in the survivor's own syntax is
+ * the one wrapping that cannot change what a model reads out of the marker.
+ *
+ * A derived view: each leader is the `markerLeader` fact on the language's
+ * {@link LanguageProfile} (`src/lang/`), collected here so marker construction keeps
+ * one lookup table.
+ */
+export declare const MARKER_LINE_COMMENT_LEADERS: Readonly<Partial<Record<DetectedLanguage, string>>>;
+/**
+ * The marker builder for a language: {@link defaultMarker}, wrapped in the language's
+ * line-comment leader when {@link MARKER_LINE_COMMENT_LEADERS} names one — so a Python
+ * survivor still parses as Python. Everything else gets `base` unchanged.
+ */
+export declare function markerForLanguage(language: DetectedLanguage, base?: MarkerBuilder): MarkerBuilder;
+/**
+ * The one adapter behind the {@link MarkerPricing} seam.
+ *
+ * Marker cost is this module's fact: `applyPlan` renders the marker, so only this
+ * module can price it without guessing. The pricing is built from the **exact builder
+ * `applyPlan` will use** — the same resolution, in the same order: a caller-supplied
+ * builder (`SmelterConfig.marker` / `ApplyOptions.marker`) wins wholesale, otherwise
+ * the language's leader-wrapped default via {@link markerForLanguage}.
+ *
+ * The custom-builder leg is load-bearing, not a convenience: a caller who installs a
+ * longer `MarkerBuilder` changes what every elision costs, and a planner still pricing
+ * the *default* marker would keep planning elisions the real marker makes
+ * unprofitable — cuts that grow the output, silently. Pricing with the builder's own
+ * rendering closes that hole: `costBytes` measures the marker *that builder* would
+ * emit, byte for byte.
+ *
+ * `createSmelter` (and through it, the CLI) calls this centrally, once per smelt call;
+ * a caller driving `planLexical`/`planStructural` directly builds its own and puts it
+ * on the {@link PlanInput}.
+ */
+export declare function markerPricing(language?: DetectedLanguage, markerBuilder?: MarkerBuilder): MarkerPricing;
+export interface ApplyOptions {
+    /**
+     * Overrides the marker builder. The default follows the *plan's* language —
+     * {@link markerForLanguage} — so the documented composition
+     * `planStructural → applyPlan` lands a `# `-led marker in python without the caller
+     * wiring it, the same as `createSmelter` does. A bare {@link defaultMarker} in a
+     * python survivor is exactly the parse-breaking failure the leader exists to prevent.
+     */
+    readonly marker?: MarkerBuilder;
+    /** A consumer-supplied counter. See {@link Measure}; the budget stays in bytes. */
+    readonly measure?: Measure;
+}
+/**
+ * Turn a plan into text.
+ *
+ * This is the only function in smelt that removes anything, and it contains no
+ * judgement at all: it validates the plan, stores every removed run, substitutes
+ * markers, and records where each marker landed. All the deciding happens in a
+ * {@link Planner}, which is why a plan can be reviewed before a byte moves.
+ *
+ * @throws {RangeOutOfBoundsError} if a range falls outside the input's UTF-8 bytes.
+ * @throws {OverlappingElisionError} if two ranges overlap — applying both would
+ *   corrupt the output, and picking a winner would be a silent guess.
+ */
+export declare function applyPlan(text: string, plan: ElisionPlan, store: ElisionStore, options?: ApplyOptions): SmeltResult;
+/**
+ * Put it all back. `reconstruct(smelt(x), store) === x`, byte for byte — this is Law 3
+ * expressed as an executable equation, and `test/guards/reversibility.test.ts` asserts
+ * it on every input the suite knows about.
+ *
+ * Reads through `peek`, **not** `retrieve`: `retrieveCalls` and the expansion rate
+ * exist to count *the model asking for hidden material back* — the honest signal this
+ * whole project sells. A caller reassembling the original (to diff it, to verify a
+ * round trip, to write it to disk) is not that, and counting it would inflate the one
+ * number that must never flatter. The guard in
+ * `test/guards/expansion-counter.test.ts` pins this: reconstruction leaves every
+ * counter exactly where it was.
+ *
+ * @throws {UnknownHashError} if the store no longer holds an elision's bytes.
+ */
+export declare function reconstruct(result: SmeltResult, store: ElisionStore): string;
+//# sourceMappingURL=apply.d.ts.map

package/dist/apply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../src/apply.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAGV,gBAAgB,EAChB,WAAW,EACX,YAAY,EACZ,aAAa,EACb,OAAO,EACP,WAAW,EACZ,MAAM,YAAY,CAAC;AAEpB,0DAA0D;AAC1D,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,MAAM,aAAa,GAAG,CAAC,IAAI,EAAE,UAAU,KAAK,MAAM,CAAC;AAEzD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,qBAAqB,OAAO,CAAC;AAE1C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,EAAE,aACoE,CAAC;AAEjG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,gBAAgB,EAAE,MAAM,CAAC,CAAC,CAKzF,CAAC;AAEJ;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,GAAE,aAA6B,GAClC,aAAa,CAIf;AAQD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,GAAE,gBAA4B,EACtC,aAAa,CAAC,EAAE,aAAa,GAC5B,aAAa,CAef;AAED,MAAM,WAAW,YAAY;IAC3B;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,CAAC;IAChC,mFAAmF;IACnF,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,YAAY,EACnB,OAAO,GAAE,YAAiB,GACzB,WAAW,CA6Eb;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,YAAY,GAAG,MAAM,CAiB5E"}