@smeltjs/core 0.1.0

package/dist/lang/typescript.js

@@ -0,0 +1,61 @@
+/**
+ * Human words for the tree-sitter node types the structural planner expects at the
+ * top level of a TypeScript or TSX file. What the map does not name, the planner
+ * still labels honestly — see {@link LanguageStructure.kindLabels}.
+ */
+export const TS_KIND_LABELS = {
+    function_declaration: 'function',
+    generator_function_declaration: 'function',
+    function_signature: 'function',
+    class_declaration: 'class',
+    abstract_class_declaration: 'class',
+    interface_declaration: 'interface',
+    type_alias_declaration: 'type alias',
+    enum_declaration: 'enum',
+    lexical_declaration: 'variable',
+    variable_declaration: 'variable',
+    import_statement: 'import statement',
+    internal_module: 'namespace',
+    module: 'namespace',
+    ambient_declaration: 'ambient declaration',
+    expression_statement: 'statement',
+    hash_bang_line: 'shebang',
+    comment: 'comment',
+};
+/** One grammar family, two ids: the tsx profile shares this structure verbatim. */
+export const TS_STRUCTURE = {
+    commentTypes: new Set(['comment']),
+    attributeTypes: new Set(),
+    // `#!/usr/bin/env -S npx tsx` parses as a hash_bang_line here too — same node, same
+    // law as javascript's: collapsing it changes which interpreter runs the file.
+    pinnedTypes: new Set(['hash_bang_line']),
+    wrapperTypes: { export_statement: 'export' },
+    kindLabels: TS_KIND_LABELS,
+};
+/**
+ * Repo-map definition kinds for the typescript grammar family — shared by the
+ * typescript, tsx and javascript profiles, exactly as the extraction treats them.
+ */
+export const TS_DEF_KINDS = {
+    function_declaration: 'function',
+    generator_function_declaration: 'function',
+    function_signature: 'function',
+    class_declaration: 'class',
+    abstract_class_declaration: 'class',
+    interface_declaration: 'interface',
+    type_alias_declaration: 'type alias',
+    enum_declaration: 'enum',
+    method_definition: 'method',
+    variable_declarator: 'variable',
+};
+/** Repo-map reference node types for the typescript grammar family. */
+export const TS_REF_TYPES = ['identifier', 'type_identifier'];
+export const typescript = {
+    id: 'typescript',
+    extensions: ['ts', 'mts', 'cts'],
+    wasm: 'tree-sitter-typescript.wasm',
+    markerLeader: '// ',
+    structure: TS_STRUCTURE,
+    repomap: { defKinds: TS_DEF_KINDS, refTypes: TS_REF_TYPES },
+};
+//# sourceMappingURL=typescript.js.map

package/dist/lang/typescript.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript.js","sourceRoot":"","sources":["../../src/lang/typescript.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,CAAC,MAAM,cAAc,GAAqC;IAC9D,oBAAoB,EAAE,UAAU;IAChC,8BAA8B,EAAE,UAAU;IAC1C,kBAAkB,EAAE,UAAU;IAC9B,iBAAiB,EAAE,OAAO;IAC1B,0BAA0B,EAAE,OAAO;IACnC,qBAAqB,EAAE,WAAW;IAClC,sBAAsB,EAAE,YAAY;IACpC,gBAAgB,EAAE,MAAM;IACxB,mBAAmB,EAAE,UAAU;IAC/B,oBAAoB,EAAE,UAAU;IAChC,gBAAgB,EAAE,kBAAkB;IACpC,eAAe,EAAE,WAAW;IAC5B,MAAM,EAAE,WAAW;IACnB,mBAAmB,EAAE,qBAAqB;IAC1C,oBAAoB,EAAE,WAAW;IACjC,cAAc,EAAE,SAAS;IACzB,OAAO,EAAE,SAAS;CACnB,CAAC;AAEF,mFAAmF;AACnF,MAAM,CAAC,MAAM,YAAY,GAAsB;IAC7C,YAAY,EAAE,IAAI,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC;IAClC,cAAc,EAAE,IAAI,GAAG,EAAE;IACzB,oFAAoF;IACpF,8EAA8E;IAC9E,WAAW,EAAE,IAAI,GAAG,CAAC,CAAC,gBAAgB,CAAC,CAAC;IACxC,YAAY,EAAE,EAAE,gBAAgB,EAAE,QAAQ,EAAE;IAC5C,UAAU,EAAE,cAAc;CAC3B,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,YAAY,GAAqC;IAC5D,oBAAoB,EAAE,UAAU;IAChC,8BAA8B,EAAE,UAAU;IAC1C,kBAAkB,EAAE,UAAU;IAC9B,iBAAiB,EAAE,OAAO;IAC1B,0BAA0B,EAAE,OAAO;IACnC,qBAAqB,EAAE,WAAW;IAClC,sBAAsB,EAAE,YAAY;IACpC,gBAAgB,EAAE,MAAM;IACxB,iBAAiB,EAAE,QAAQ;IAC3B,mBAAmB,EAAE,UAAU;CAChC,CAAC;AAEF,uEAAuE;AACvE,MAAM,CAAC,MAAM,YAAY,GAAsB,CAAC,YAAY,EAAE,iBAAiB,CAAC,CAAC;AAEjF,MAAM,CAAC,MAAM,UAAU,GAAoB;IACzC,EAAE,EAAE,YAAY;IAChB,UAAU,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC;IAChC,IAAI,EAAE,6BAA6B;IACnC,YAAY,EAAE,KAAK;IACnB,SAAS,EAAE,YAAY;IACvB,OAAO,EAAE,EAAE,QAAQ,EAAE,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE;CAC5D,CAAC"}

package/dist/net/policy.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Law 1 — zero network in v1 — written down once, in one place, so that the guard
+ * test and the runtime check cannot drift apart. `test/guards/no-network.test.ts`
+ * imports these lists and fails if any module reachable from the public entrypoint
+ * imports one of them.
+ *
+ * This is a *partition of a discovered set*, not an allowlist over an assumed one:
+ * the guard walks the real import graph and classifies every edge it finds. A new
+ * transport nobody thought of still gets classified — as an unknown bare import,
+ * which the guard reports rather than ignores.
+ */
+export declare const FORBIDDEN_NODE_MODULES: readonly string[];
+/** Third-party transports. A dependency that pulls one in is a Law 1 violation too. */
+export declare const FORBIDDEN_PACKAGES: readonly string[];
+/**
+ * Globals that reach the network without an import. Grepped for by the guard — both
+ * bare (`fetch(…)`) and qualified through a global object (`globalThis.fetch(…)`),
+ * which is why `globalThis` and `global` are themselves on the list: an access
+ * routed through the global object is the escape hatch around a bare-name grep.
+ */
+export declare const FORBIDDEN_GLOBALS: readonly string[];
+/**
+ * The other half of the partition.
+ *
+ * A forbidden-list alone is an allowlist over an assumed set: it can only catch
+ * transports somebody already thought of. So the guard classifies *every* import edge
+ * it discovers, and an edge that matches neither the forbidden lists nor these
+ * permitted ones **fails the build**. Adding a dependency therefore requires adding it
+ * here, in a diff, next to the reason — which is the point.
+ */
+export declare const ALLOWED_NODE_BUILTINS: readonly string[];
+/** Third-party packages any smelt module may import. Keep this list boring and short. */
+export declare const ALLOWED_PACKAGES: readonly string[];
+/**
+ * The only URL schemes any smelt code path may resolve.
+ *
+ * This is not paranoia about our own code. `web-tree-sitter`'s `Language.load()`
+ * accepts a `string | URL`, and an `https:` URL there would fetch a grammar over the
+ * wire — a real network call inside the elision path, from a dependency's happy path.
+ * Every resource smelt hands to a loader goes through {@link assertLocalResource} first.
+ */
+export declare const ALLOWED_URL_SCHEMES: readonly string[];
+/**
+ * Reject anything that is not a local file, and return the resolved `file:` URL.
+ *
+ * @throws {NetworkPolicyError} if the input names a remote scheme.
+ */
+export declare function assertLocalResource(input: string | URL): URL;
+//# sourceMappingURL=policy.d.ts.map

package/dist/net/policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../../src/net/policy.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,EAAE,SAAS,MAAM,EAenD,CAAC;AAEF,uFAAuF;AACvF,eAAO,MAAM,kBAAkB,EAAE,SAAS,MAAM,EAU/C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,EAAE,SAAS,MAAM,EAQ9C,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EAYlD,CAAC;AAEF,yFAAyF;AACzF,eAAO,MAAM,gBAAgB,EAAE,SAAS,MAAM,EAG7C,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,MAAM,EAAc,CAAC;AAEhE;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,GAAG,CAS5D"}

package/dist/net/policy.js

@@ -0,0 +1,120 @@
+import { NetworkPolicyError } from '../errors.js';
+/**
+ * Law 1 — zero network in v1 — written down once, in one place, so that the guard
+ * test and the runtime check cannot drift apart. `test/guards/no-network.test.ts`
+ * imports these lists and fails if any module reachable from the public entrypoint
+ * imports one of them.
+ *
+ * This is a *partition of a discovered set*, not an allowlist over an assumed one:
+ * the guard walks the real import graph and classifies every edge it finds. A new
+ * transport nobody thought of still gets classified — as an unknown bare import,
+ * which the guard reports rather than ignores.
+ */
+export const FORBIDDEN_NODE_MODULES = [
+    'http',
+    'https',
+    'http2',
+    'net',
+    'tls',
+    'dgram',
+    'dns',
+    'node:http',
+    'node:https',
+    'node:http2',
+    'node:net',
+    'node:tls',
+    'node:dgram',
+    'node:dns',
+];
+/** Third-party transports. A dependency that pulls one in is a Law 1 violation too. */
+export const FORBIDDEN_PACKAGES = [
+    'undici',
+    'axios',
+    'node-fetch',
+    'got',
+    'ky',
+    'superagent',
+    'ws',
+    'socket.io-client',
+    'eventsource',
+];
+/**
+ * Globals that reach the network without an import. Grepped for by the guard — both
+ * bare (`fetch(…)`) and qualified through a global object (`globalThis.fetch(…)`),
+ * which is why `globalThis` and `global` are themselves on the list: an access
+ * routed through the global object is the escape hatch around a bare-name grep.
+ */
+export const FORBIDDEN_GLOBALS = [
+    'fetch',
+    'XMLHttpRequest',
+    'WebSocket',
+    'EventSource',
+    'navigator',
+    'globalThis',
+    'global',
+];
+/**
+ * The other half of the partition.
+ *
+ * A forbidden-list alone is an allowlist over an assumed set: it can only catch
+ * transports somebody already thought of. So the guard classifies *every* import edge
+ * it discovers, and an edge that matches neither the forbidden lists nor these
+ * permitted ones **fails the build**. Adding a dependency therefore requires adding it
+ * here, in a diff, next to the reason — which is the point.
+ */
+export const ALLOWED_NODE_BUILTINS = [
+    'node:crypto', // content hashing for the elision store
+    'node:fs', // reading grammar .wasm files off disk
+    'node:fs/promises',
+    'node:path',
+    'node:url',
+    'node:buffer',
+    'node:module', // web-tree-sitter's own loader shim needs createRequire
+    'node:util', // parseArgs, for the CLI. Argument parsing with zero dependencies.
+    'node:process', // argv, stdin/stdout/stderr and the exit code, for the CLI
+    'node:readline/promises', // line-by-line answers for `smelt init` — reads streams it is handed, opens nothing
+    'node:tty', // isatty(0) for the CLI's TTY check — a plain syscall, no stream, no socket
+];
+/** Third-party packages any smelt module may import. Keep this list boring and short. */
+export const ALLOWED_PACKAGES = [
+    'web-tree-sitter', // WASM parsers. No native build step, no download at runtime.
+    'tree-sitter-wasms', // prebuilt grammar .wasm blobs, resolved to local file paths
+];
+/**
+ * The only URL schemes any smelt code path may resolve.
+ *
+ * This is not paranoia about our own code. `web-tree-sitter`'s `Language.load()`
+ * accepts a `string | URL`, and an `https:` URL there would fetch a grammar over the
+ * wire — a real network call inside the elision path, from a dependency's happy path.
+ * Every resource smelt hands to a loader goes through {@link assertLocalResource} first.
+ */
+export const ALLOWED_URL_SCHEMES = ['file:'];
+/**
+ * Reject anything that is not a local file, and return the resolved `file:` URL.
+ *
+ * @throws {NetworkPolicyError} if the input names a remote scheme.
+ */
+export function assertLocalResource(input) {
+    const url = toUrl(input);
+    if (!ALLOWED_URL_SCHEMES.includes(url.protocol)) {
+        throw new NetworkPolicyError(`refusing to load "${String(input)}": scheme "${url.protocol}" is not local. ` +
+            `v1 makes zero network calls; only ${ALLOWED_URL_SCHEMES.join(', ')} is allowed.`);
+    }
+    return url;
+}
+function toUrl(input) {
+    if (input instanceof URL)
+        return input;
+    // A bare path is a local path. Anything with a scheme is parsed as-is so that
+    // "https://evil/grammar.wasm" is caught rather than treated as a relative path.
+    if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(input)) {
+        try {
+            return new URL(input);
+        }
+        catch {
+            throw new NetworkPolicyError(`refusing to load "${input}": not a parseable URL or path.`);
+        }
+    }
+    return new URL(`file://${input.startsWith('/') ? '' : '/'}${input}`);
+}
+//# sourceMappingURL=policy.js.map

package/dist/net/policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.js","sourceRoot":"","sources":["../../src/net/policy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAElD;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAsB;IACvD,MAAM;IACN,OAAO;IACP,OAAO;IACP,KAAK;IACL,KAAK;IACL,OAAO;IACP,KAAK;IACL,WAAW;IACX,YAAY;IACZ,YAAY;IACZ,UAAU;IACV,UAAU;IACV,YAAY;IACZ,UAAU;CACX,CAAC;AAEF,uFAAuF;AACvF,MAAM,CAAC,MAAM,kBAAkB,GAAsB;IACnD,QAAQ;IACR,OAAO;IACP,YAAY;IACZ,KAAK;IACL,IAAI;IACJ,YAAY;IACZ,IAAI;IACJ,kBAAkB;IAClB,aAAa;CACd,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAsB;IAClD,OAAO;IACP,gBAAgB;IAChB,WAAW;IACX,aAAa;IACb,WAAW;IACX,YAAY;IACZ,QAAQ;CACT,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAsB;IACtD,aAAa,EAAE,wCAAwC;IACvD,SAAS,EAAE,uCAAuC;IAClD,kBAAkB;IAClB,WAAW;IACX,UAAU;IACV,aAAa;IACb,aAAa,EAAE,wDAAwD;IACvE,WAAW,EAAE,mEAAmE;IAChF,cAAc,EAAE,2DAA2D;IAC3E,wBAAwB,EAAE,oFAAoF;IAC9G,UAAU,EAAE,4EAA4E;CACzF,CAAC;AAEF,yFAAyF;AACzF,MAAM,CAAC,MAAM,gBAAgB,GAAsB;IACjD,iBAAiB,EAAE,8DAA8D;IACjF,mBAAmB,EAAE,6DAA6D;CACnF,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAsB,CAAC,OAAO,CAAC,CAAC;AAEhE;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAmB;IACrD,MAAM,GAAG,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;IACzB,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;QAChD,MAAM,IAAI,kBAAkB,CAC1B,qBAAqB,MAAM,CAAC,KAAK,CAAC,cAAc,GAAG,CAAC,QAAQ,kBAAkB;YAC5E,qCAAqC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CACpF,CAAC;IACJ,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,KAAK,CAAC,KAAmB;IAChC,IAAI,KAAK,YAAY,GAAG;QAAE,OAAO,KAAK,CAAC;IACvC,8EAA8E;IAC9E,gFAAgF;IAChF,IAAI,2BAA2B,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5C,IAAI,CAAC;YACH,OAAO,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC;QACxB,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,IAAI,kBAAkB,CAAC,qBAAqB,KAAK,iCAAiC,CAAC,CAAC;QAC5F,CAAC;IACH,CAAC;IACD,OAAO,IAAI,GAAG,CAAC,UAAU,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,KAAK,EAAE,CAAC,CAAC;AACvE,CAAC"}

package/dist/plan/grammar.d.ts

@@ -0,0 +1,38 @@
+import { Language } from 'web-tree-sitter';
+import type { LanguageId } from '../types.ts';
+/**
+ * Grammar file for each language smelt claims to parse — the registry's `wasm`
+ * facts, as a map. Derived from `LANGUAGE_PROFILES` (which is
+ * `Record<LanguageId, LanguageProfile>`, so adding a `LanguageId` without a profile —
+ * and its grammar — is a type error and the two cannot drift). It stays exported
+ * because `scripts/bundle-grammars.mjs` and the attribution generator both read it —
+ * a hand-written second list of grammar filenames would be exactly the drift the
+ * registry exists to prevent.
+ */
+export declare const WASM_BY_LANGUAGE: Readonly<Record<LanguageId, string>>;
+/**
+ * Resolve a grammar to a path on this machine.
+ *
+ * The copy bundled in this package wins; `tree-sitter-wasms` is the fallback, for a
+ * source checkout that has not run `pnpm build` yet. Note what this function does *not*
+ * do: it never constructs a URL from a version string, a CDN base, or anything else.
+ * Grammars come off disk — either the ones shipped here or the ones a package manager
+ * already installed. A "fetch the grammar on first use" cache is the most natural way
+ * to break Law 1 without noticing, because it works perfectly on the machine that
+ * wrote it.
+ */
+export declare function grammarPath(language: LanguageId): string;
+/**
+ * Load a grammar, from disk, once.
+ *
+ * The bytes are read here and handed to tree-sitter as a `Uint8Array` rather than
+ * passing it a path. `Language.load()` accepts `string | URL`, and a `URL` with an
+ * `https:` scheme would make it fetch — inside the elision path, from a dependency's
+ * ordinary happy path. Reading the file ourselves removes that capability instead of
+ * documenting it, and {@link assertLocalResource} rejects a remote path before we get
+ * that far.
+ */
+export declare function loadGrammar(language: LanguageId): Promise<Language>;
+/** Reset the grammar cache. Tests use it; production has no reason to. */
+export declare function clearGrammarCache(): void;
+//# sourceMappingURL=grammar.d.ts.map

package/dist/plan/grammar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grammar.d.ts","sourceRoot":"","sources":["../../src/plan/grammar.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,QAAQ,EAAU,MAAM,iBAAiB,CAAC;AAKnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAEnC,CAAC;AAkBhC;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,CAexD;AAED;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAAC,QAAQ,EAAE,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,CAYzE;AAED,0EAA0E;AAC1E,wBAAgB,iBAAiB,IAAI,IAAI,CAGxC"}

package/dist/plan/grammar.js

@@ -0,0 +1,85 @@
+import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { Language, Parser } from 'web-tree-sitter';
+import { GrammarUnavailableError } from '../errors.js';
+import { LANGUAGE_PROFILES } from '../lang/registry.js';
+import { assertLocalResource } from '../net/policy.js';
+/**
+ * Grammar file for each language smelt claims to parse — the registry's `wasm`
+ * facts, as a map. Derived from `LANGUAGE_PROFILES` (which is
+ * `Record<LanguageId, LanguageProfile>`, so adding a `LanguageId` without a profile —
+ * and its grammar — is a type error and the two cannot drift). It stays exported
+ * because `scripts/bundle-grammars.mjs` and the attribution generator both read it —
+ * a hand-written second list of grammar filenames would be exactly the drift the
+ * registry exists to prevent.
+ */
+export const WASM_BY_LANGUAGE = Object.fromEntries(Object.values(LANGUAGE_PROFILES).map((profile) => [profile.id, profile.wasm]));
+/**
+ * Where the bundled grammars live, relative to this module.
+ *
+ * From `dist/plan/grammar.js` and from `src/plan/grammar.ts` alike, `../../grammars/`
+ * is this package's own `grammars/` directory — filled by `pnpm build` and shipped
+ * inside the npm tarball. That is what makes "zero native compilation, works offline"
+ * true rather than aspirational: whoever installs the package has the parsers, with no
+ * post-install download and no optional peer dependency to remember. It is also
+ * redistribution, which is why `THIRD-PARTY.md` exists and is generated.
+ */
+const BUNDLED_GRAMMAR_DIR = new URL('../../grammars/', import.meta.url);
+const require = createRequire(import.meta.url);
+const cache = new Map();
+let runtimeReady;
+/**
+ * Resolve a grammar to a path on this machine.
+ *
+ * The copy bundled in this package wins; `tree-sitter-wasms` is the fallback, for a
+ * source checkout that has not run `pnpm build` yet. Note what this function does *not*
+ * do: it never constructs a URL from a version string, a CDN base, or anything else.
+ * Grammars come off disk — either the ones shipped here or the ones a package manager
+ * already installed. A "fetch the grammar on first use" cache is the most natural way
+ * to break Law 1 without noticing, because it works perfectly on the machine that
+ * wrote it.
+ */
+export function grammarPath(language) {
+    const file = WASM_BY_LANGUAGE[language];
+    const bundled = fileURLToPath(new URL(file, BUNDLED_GRAMMAR_DIR));
+    if (existsSync(bundled))
+        return bundled;
+    try {
+        return require.resolve(`tree-sitter-wasms/out/${file}`);
+    }
+    catch {
+        throw new GrammarUnavailableError(`smelt: no grammar for "${language}". The bundled copy is missing (run ` +
+            `\`pnpm build\` in a source checkout) and \`tree-sitter-wasms\` is not installed ` +
+            `either. Pass \`language: 'unknown'\` to use the lexical planner.`);
+    }
+}
+/**
+ * Load a grammar, from disk, once.
+ *
+ * The bytes are read here and handed to tree-sitter as a `Uint8Array` rather than
+ * passing it a path. `Language.load()` accepts `string | URL`, and a `URL` with an
+ * `https:` scheme would make it fetch — inside the elision path, from a dependency's
+ * ordinary happy path. Reading the file ourselves removes that capability instead of
+ * documenting it, and {@link assertLocalResource} rejects a remote path before we get
+ * that far.
+ */
+export async function loadGrammar(language) {
+    const cached = cache.get(language);
+    if (cached !== undefined)
+        return cached;
+    runtimeReady ??= Parser.init();
+    await runtimeReady;
+    const resolved = assertLocalResource(grammarPath(language));
+    const bytes = await readFile(fileURLToPath(resolved));
+    const grammar = await Language.load(new Uint8Array(bytes));
+    cache.set(language, grammar);
+    return grammar;
+}
+/** Reset the grammar cache. Tests use it; production has no reason to. */
+export function clearGrammarCache() {
+    cache.clear();
+    runtimeReady = undefined;
+}
+//# sourceMappingURL=grammar.js.map

package/dist/plan/grammar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grammar.js","sourceRoot":"","sources":["../../src/plan/grammar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAGvD;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAyC,MAAM,CAAC,WAAW,CACtF,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAChD,CAAC;AAEhC;;;;;;;;;GASG;AACH,MAAM,mBAAmB,GAAG,IAAI,GAAG,CAAC,iBAAiB,EAAE,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC;AAExE,MAAM,OAAO,GAAG,aAAa,CAAC,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC;AAC/C,MAAM,KAAK,GAAG,IAAI,GAAG,EAAwB,CAAC;AAC9C,IAAI,YAAuC,CAAC;AAE5C;;;;;;;;;;GAUG;AACH,MAAM,UAAU,WAAW,CAAC,QAAoB;IAC9C,MAAM,IAAI,GAAG,gBAAgB,CAAC,QAAQ,CAAC,CAAC;IAExC,MAAM,OAAO,GAAG,aAAa,CAAC,IAAI,GAAG,CAAC,IAAI,EAAE,mBAAmB,CAAC,CAAC,CAAC;IAClE,IAAI,UAAU,CAAC,OAAO,CAAC;QAAE,OAAO,OAAO,CAAC;IAExC,IAAI,CAAC;QACH,OAAO,OAAO,CAAC,OAAO,CAAC,yBAAyB,IAAI,EAAE,CAAC,CAAC;IAC1D,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,IAAI,uBAAuB,CAC/B,0BAA0B,QAAQ,sCAAsC;YACtE,kFAAkF;YAClF,kEAAkE,CACrE,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAAC,QAAoB;IACpD,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACnC,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,MAAM,CAAC;IAExC,YAAY,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC;IAC/B,MAAM,YAAY,CAAC;IAEnB,MAAM,QAAQ,GAAG,mBAAmB,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC5D,MAAM,KAAK,GAAG,MAAM,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC;IACtD,MAAM,OAAO,GAAG,MAAM,QAAQ,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC;IAC3D,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC7B,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,0EAA0E;AAC1E,MAAM,UAAU,iBAAiB;IAC/B,KAAK,CAAC,KAAK,EAAE,CAAC;IACd,YAAY,GAAG,SAAS,CAAC;AAC3B,CAAC"}

package/dist/plan/lexical.d.ts

@@ -0,0 +1,51 @@
+import type { ElisionPlan, PlanInput, Planner } from '../types.ts';
+export declare const LEXICAL_PLANNER_ID = "lexical/v1";
+export interface LexicalPlannerOptions {
+    /** Lines of context kept either side of a focus match. Shrinks under budget pressure. */
+    readonly contextLines?: number;
+    /** Never collapse a run shorter than this, however tempting. */
+    readonly minRunLines?: number;
+    /** With no focus terms: lines kept at the top. */
+    readonly headLines?: number;
+    /** With no focus terms: lines kept at the bottom. */
+    readonly tailLines?: number;
+    /** Focus matching is substring, case-insensitive by default. */
+    readonly caseSensitive?: boolean;
+}
+/**
+ * The fallback planner, and the reference implementation of the whole pipeline.
+ *
+ * It knows nothing about syntax: it keeps the lines you were looking for plus a window
+ * of context, and collapses the runs in between. That is a weak strategy on code and a
+ * perfectly good one on log files, stack traces, JSON dumps and every other thing a
+ * coding agent shovels into a prompt — which is why it is the fallback rather than an
+ * embarrassment. It also runs on languages smelt has no grammar for, so
+ * `language: 'unknown'` is never a dead end.
+ *
+ * Everything here is deterministic and rule-named. Same input, same plan, and every
+ * elision can say which rule produced it.
+ */
+export declare class LexicalPlanner implements Planner {
+    #private;
+    readonly id = "lexical/v1";
+    constructor(options?: LexicalPlannerOptions);
+    plan(input: PlanInput): Promise<ElisionPlan>;
+}
+/**
+ * The synchronous core, exported because it is worth testing and reusing directly.
+ *
+ * `budgetBytes` is a target, not a guarantee. If the smallest context window still
+ * exceeds it, the plan comes back over budget rather than eliding the matches the
+ * caller asked to keep — an optimizer that silently drops the thing you searched for is
+ * the exact failure this design is built to prevent. Callers who need a hard ceiling
+ * check `outputBytes` and decide; smelt will not decide for them.
+ *
+ * Profitability and budget prediction are **measured, not estimated**: every candidate
+ * elision is priced through the input's {@link MarkerPricing} — the seam `apply.ts`
+ * builds from the exact builder `applyPlan` will use, comment leader and custom
+ * builder included. A guessed constant here once under-counted real ~105-byte markers
+ * as 64, so a plan could be "chosen as fitting" and then come back over budget after
+ * the markers landed.
+ */
+export declare function planLexical(input: PlanInput, options?: LexicalPlannerOptions): ElisionPlan;
+//# sourceMappingURL=lexical.d.ts.map

package/dist/plan/lexical.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lexical.d.ts","sourceRoot":"","sources":["../../src/plan/lexical.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAiB,SAAS,EAAkB,OAAO,EAAE,MAAM,aAAa,CAAC;AAElG,eAAO,MAAM,kBAAkB,eAAe,CAAC;AAK/C,MAAM,WAAW,qBAAqB;IACpC,yFAAyF;IACzF,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,gEAAgE;IAChE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,kDAAkD;IAClD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,qDAAqD;IACrD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,gEAAgE;IAChE,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CAClC;AAUD;;;;;;;;;;;;GAYG;AACH,qBAAa,cAAe,YAAW,OAAO;;IAC5C,QAAQ,CAAC,EAAE,gBAAsB;IAGjC,YAAY,OAAO,GAAE,qBAA0B,EAE9C;IAED,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC,CAE3C;CACF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,GAAE,qBAA0B,GAAG,WAAW,CAsC9F"}

package/dist/plan/lexical.js

@@ -0,0 +1,167 @@
+import { MissingMarkerPricingError } from '../errors.js';
+export const LEXICAL_PLANNER_ID = 'lexical/v1';
+/** How hard the head/tail strategy squeezes, in order, when the budget is not met. */
+const HEAD_TAIL_LADDER = [1, 0.5, 0.25, 0.1, 0.05];
+/**
+ * The fallback planner, and the reference implementation of the whole pipeline.
+ *
+ * It knows nothing about syntax: it keeps the lines you were looking for plus a window
+ * of context, and collapses the runs in between. That is a weak strategy on code and a
+ * perfectly good one on log files, stack traces, JSON dumps and every other thing a
+ * coding agent shovels into a prompt — which is why it is the fallback rather than an
+ * embarrassment. It also runs on languages smelt has no grammar for, so
+ * `language: 'unknown'` is never a dead end.
+ *
+ * Everything here is deterministic and rule-named. Same input, same plan, and every
+ * elision can say which rule produced it.
+ */
+export class LexicalPlanner {
+    id = LEXICAL_PLANNER_ID;
+    #options;
+    constructor(options = {}) {
+        this.#options = options;
+    }
+    plan(input) {
+        return Promise.resolve(planLexical(input, this.#options));
+    }
+}
+/**
+ * The synchronous core, exported because it is worth testing and reusing directly.
+ *
+ * `budgetBytes` is a target, not a guarantee. If the smallest context window still
+ * exceeds it, the plan comes back over budget rather than eliding the matches the
+ * caller asked to keep — an optimizer that silently drops the thing you searched for is
+ * the exact failure this design is built to prevent. Callers who need a hard ceiling
+ * check `outputBytes` and decide; smelt will not decide for them.
+ *
+ * Profitability and budget prediction are **measured, not estimated**: every candidate
+ * elision is priced through the input's {@link MarkerPricing} — the seam `apply.ts`
+ * builds from the exact builder `applyPlan` will use, comment leader and custom
+ * builder included. A guessed constant here once under-counted real ~105-byte markers
+ * as 64, so a plan could be "chosen as fitting" and then come back over budget after
+ * the markers landed.
+ */
+export function planLexical(input, options = {}) {
+    const pricing = requirePricing(input);
+    const lines = splitLines(input.text);
+    const focus = (input.focus ?? []).filter((term) => term.length > 0);
+    const minRunLines = options.minRunLines ?? 3;
+    const attempts = focus.length > 0
+        ? ladder(options.contextLines ?? 4).map((context) => collapse(lines, keepByFocus(lines, focus, context, options.caseSensitive ?? false), {
+            minRunLines,
+            rule: 'focus-window',
+            pricing,
+        }))
+        : HEAD_TAIL_LADDER.map((shrink) => collapse(lines, keepByHeadTail(lines, Math.max(3, Math.round((options.headLines ?? 40) * shrink)), Math.max(3, Math.round((options.tailLines ?? 20) * shrink))), { minRunLines, rule: 'head-tail', pricing }));
+    const inputBytes = Buffer.byteLength(input.text, 'utf8');
+    const chosen = attempts.find((elisions) => predictOutputBytes(inputBytes, elisions, pricing) <= input.budgetBytes) ?? attempts[attempts.length - 1];
+    return {
+        planner: LEXICAL_PLANNER_ID,
+        language: input.language,
+        elisions: chosen,
+    };
+}
+/** Context-window sizes to try, largest first. */
+function ladder(start) {
+    const sizes = [];
+    for (let n = start; n >= 0; n -= 1)
+        sizes.push(n);
+    if (sizes.length === 0)
+        sizes.push(0);
+    return sizes;
+}
+/**
+ * The runtime backstop for JS callers: TypeScript makes `pricing` required, but a JS
+ * caller can omit it, and the honest answer is a named refusal rather than a planner
+ * quietly pricing markers itself — the inversion the seam removed.
+ */
+function requirePricing(input) {
+    const pricing = input.pricing;
+    if (pricing === undefined)
+        throw new MissingMarkerPricingError(LEXICAL_PLANNER_ID);
+    return pricing;
+}
+/** The exact UTF-8 cost of the marker this elision would earn. Asked, not guessed. */
+function markerBytes(elision, pricing) {
+    return pricing.costBytes(elision.reason, elision.range.end - elision.range.start);
+}
+function predictOutputBytes(inputBytes, elisions, pricing) {
+    return elisions.reduce((bytes, elision) => bytes - (elision.range.end - elision.range.start) + markerBytes(elision, pricing), inputBytes);
+}
+function splitLines(text) {
+    const lines = [];
+    let start = 0;
+    let byte = 0;
+    const raw = text.split('\n');
+    for (let i = 0; i < raw.length; i += 1) {
+        const content = raw[i];
+        const contentBytes = Buffer.byteLength(content, 'utf8');
+        byte = start + contentBytes;
+        lines.push({ start, end: byte, text: content });
+        // +1 for the '\n' we split on; the final fragment has none.
+        start = byte + 1;
+    }
+    return lines;
+}
+function keepByFocus(lines, focus, contextLines, caseSensitive) {
+    const needles = caseSensitive ? focus : focus.map((t) => t.toLowerCase());
+    const keep = Array.from({ length: lines.length }, () => false);
+    for (let i = 0; i < lines.length; i += 1) {
+        const haystack = caseSensitive ? lines[i].text : lines[i].text.toLowerCase();
+        if (!needles.some((needle) => haystack.includes(needle)))
+            continue;
+        const from = Math.max(0, i - contextLines);
+        const to = Math.min(lines.length - 1, i + contextLines);
+        for (let j = from; j <= to; j += 1)
+            keep[j] = true;
+    }
+    return keep;
+}
+function keepByHeadTail(lines, head, tail) {
+    const keep = Array.from({ length: lines.length }, () => false);
+    for (let i = 0; i < Math.min(head, lines.length); i += 1)
+        keep[i] = true;
+    for (let i = Math.max(0, lines.length - tail); i < lines.length; i += 1)
+        keep[i] = true;
+    return keep;
+}
+function collapse(lines, keep, config) {
+    const elisions = [];
+    let runStart = -1;
+    const flush = (endExclusive) => {
+        if (runStart < 0)
+            return;
+        const count = endExclusive - runStart;
+        const range = { start: lines[runStart].start, end: lines[endExclusive - 1].end };
+        runStart = -1;
+        if (count < config.minRunLines)
+            return;
+        const candidate = {
+            range,
+            reason: {
+                rule: config.rule,
+                explanation: `collapsed ${String(count)} ${count === 1 ? 'line' : 'lines'}${describe(config.rule)}`,
+            },
+        };
+        // Profitability, measured rather than estimated: a marker that costs at least as
+        // many bytes as it removes grows the output — same rule, same seam, as the
+        // structural planner.
+        if (range.end - range.start <= markerBytes(candidate, config.pricing))
+            return;
+        elisions.push(candidate);
+    };
+    for (let i = 0; i < lines.length; i += 1) {
+        if (keep[i] === true) {
+            flush(i);
+        }
+        else if (runStart < 0) {
+            runStart = i;
+        }
+    }
+    flush(lines.length);
+    return elisions;
+}
+function describe(rule) {
+    return rule === 'focus-window' ? ' with no match for the focus terms' : ' from the middle';
+}
+//# sourceMappingURL=lexical.js.map

package/dist/plan/lexical.js.map

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

package/dist/plan/planners.d.ts

@@ -0,0 +1,35 @@
+import type { Planner } from '../types.ts';
+import type { LexicalPlannerOptions } from './lexical.ts';
+import type { StructuralPlannerOptions } from './structural.ts';
+/**
+ * The option bags a strategy factory may draw from — the same fields
+ * `SmelterConfig` carries, so the config object itself can be handed to a factory.
+ */
+export interface PlannerFactoryOptions {
+    readonly lexical?: LexicalPlannerOptions;
+    readonly structural?: StructuralPlannerOptions;
+}
+/**
+ * The one registry of planner strategies — string in, constructed {@link Planner} out.
+ *
+ * This object is the single place the strategy names live. `createSmelter` builds from
+ * it, `--strategy` and `smelt.config.json` validation accept exactly its keys, and the
+ * `--help` text renders its keys — so a strategy cannot exist in one of those faces and
+ * be missing from another. Before this registry the pair was restated in three places,
+ * which is how help text rots.
+ *
+ * `'structural'` parses every language named in {@link STRUCTURAL_LANGUAGES} with a
+ * bundled grammar and throws {@link GrammarUnavailableError} for anything else — never
+ * a silent lexical fallback. See {@link StructuralPlanner}.
+ */
+export declare const PLANNERS: {
+    readonly lexical: (options: PlannerFactoryOptions) => Planner;
+    readonly structural: (options: PlannerFactoryOptions) => Planner;
+};
+/** Which planner a smelter uses, named by string. Exactly the keys of {@link PLANNERS}. */
+export type Strategy = keyof typeof PLANNERS;
+/** The registry's keys, in declaration order, for help text and error messages. */
+export declare const STRATEGIES: readonly Strategy[];
+/** The one membership test `--strategy` and config validation both use. */
+export declare function isStrategy(value: string): value is Strategy;
+//# sourceMappingURL=planners.d.ts.map