@smeltjs/core 0.1.0

package/dist/lang/kotlin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kotlin.js","sourceRoot":"","sources":["../../src/lang/kotlin.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,MAAM,GAAoB;IACrC,EAAE,EAAE,QAAQ;IACZ,UAAU,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC;IACzB,IAAI,EAAE,yBAAyB;IAC/B,YAAY,EAAE,KAAK;IACnB,SAAS,EAAE;QACT,8DAA8D;QAC9D,YAAY,EAAE,IAAI,GAAG,CAAC,CAAC,cAAc,EAAE,mBAAmB,CAAC,CAAC;QAC5D,cAAc,EAAE,IAAI,GAAG,EAAE;QACzB,+EAA+E;QAC/E,WAAW,EAAE,IAAI,GAAG,CAAC,CAAC,cAAc,CAAC,CAAC;QACtC,0EAA0E;QAC1E,+EAA+E;QAC/E,+EAA+E;QAC/E,yBAAyB,EAAE,IAAI,GAAG,CAAC,CAAC,aAAa,CAAC,CAAC;QACnD,YAAY,EAAE,EAAE;QAChB,UAAU,EAAE;YACV,oBAAoB,EAAE,UAAU;YAChC,qEAAqE;YACrE,2EAA2E;YAC3E,iBAAiB,EAAE,kBAAkB;YACrC,kBAAkB,EAAE,QAAQ;YAC5B,oBAAoB,EAAE,UAAU;YAChC,UAAU,EAAE,YAAY;YACxB,cAAc,EAAE,gBAAgB;YAChC,WAAW,EAAE,aAAa;YAC1B,YAAY,EAAE,SAAS;SACxB;KACF;IACD,6EAA6E;IAC7E,kFAAkF;IAClF,OAAO,EAAE;QACP,QAAQ,EAAE,EAAE;QACZ,QAAQ,EAAE,CAAC,mBAAmB,EAAE,iBAAiB,CAAC;KACnD;CACF,CAAC"}

package/dist/lang/php.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageProfile } from './profile.ts';
+export declare const php: LanguageProfile;
+//# sourceMappingURL=php.d.ts.map

package/dist/lang/php.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"php.d.ts","sourceRoot":"","sources":["../../src/lang/php.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,eAAO,MAAM,GAAG,EAAE,eAmCjB,CAAC"}

package/dist/lang/php.js

@@ -0,0 +1,37 @@
+export const php = {
+    id: 'php',
+    extensions: ['php'],
+    wasm: 'tree-sitter-php.wasm',
+    markerLeader: '// ',
+    structure: {
+        // `//`, `#` and `/** … */` PHPDoc are all comment nodes.
+        commentTypes: new Set(['comment']),
+        attributeTypes: new Set(),
+        // `<?php` is what makes the rest of the file php at all.
+        pinnedTypes: new Set(['php_tag']),
+        wrapperTypes: {},
+        kindLabels: {
+            function_definition: 'function',
+            class_declaration: 'class',
+            interface_declaration: 'interface',
+            trait_declaration: 'trait',
+            enum_declaration: 'enum',
+            const_declaration: 'constant',
+            namespace_definition: 'namespace',
+            namespace_use_declaration: 'use declaration',
+            expression_statement: 'statement',
+            php_tag: 'php tag',
+            // Raw markup between `?>` and `<?php` — calling it a declaration would be the
+            // marker lying about the tree.
+            text: 'html section',
+            text_interpolation: 'html section',
+        },
+    },
+    // No def kinds: php names its definitions with `name` nodes, not identifiers, and
+    // an omitted kind means fewer symbols on the map, never wrong ones.
+    repomap: {
+        defKinds: {},
+        refTypes: ['name', 'variable_name'],
+    },
+};
+//# sourceMappingURL=php.js.map

package/dist/lang/php.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"php.js","sourceRoot":"","sources":["../../src/lang/php.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,GAAG,GAAoB;IAClC,EAAE,EAAE,KAAK;IACT,UAAU,EAAE,CAAC,KAAK,CAAC;IACnB,IAAI,EAAE,sBAAsB;IAC5B,YAAY,EAAE,KAAK;IACnB,SAAS,EAAE;QACT,yDAAyD;QACzD,YAAY,EAAE,IAAI,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC;QAClC,cAAc,EAAE,IAAI,GAAG,EAAE;QACzB,yDAAyD;QACzD,WAAW,EAAE,IAAI,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC;QACjC,YAAY,EAAE,EAAE;QAChB,UAAU,EAAE;YACV,mBAAmB,EAAE,UAAU;YAC/B,iBAAiB,EAAE,OAAO;YAC1B,qBAAqB,EAAE,WAAW;YAClC,iBAAiB,EAAE,OAAO;YAC1B,gBAAgB,EAAE,MAAM;YACxB,iBAAiB,EAAE,UAAU;YAC7B,oBAAoB,EAAE,WAAW;YACjC,yBAAyB,EAAE,iBAAiB;YAC5C,oBAAoB,EAAE,WAAW;YACjC,OAAO,EAAE,SAAS;YAClB,8EAA8E;YAC9E,+BAA+B;YAC/B,IAAI,EAAE,cAAc;YACpB,kBAAkB,EAAE,cAAc;SACnC;KACF;IACD,kFAAkF;IAClF,oEAAoE;IACpE,OAAO,EAAE;QACP,QAAQ,EAAE,EAAE;QACZ,QAAQ,EAAE,CAAC,MAAM,EAAE,eAAe,CAAC;KACpC;CACF,CAAC"}

package/dist/lang/profile.d.ts

@@ -0,0 +1,130 @@
+import type { LanguageId } from '../types.ts';
+/**
+ * Everything smelt knows about one language, in one place.
+ *
+ * Before this module existed, a language's facts lived in seven tables across five
+ * modules — the extension map in `detect.ts`, the grammar file in `plan/grammar.ts`,
+ * the marker leader in `apply.ts`, the structural node kinds and pins in
+ * `plan/structural.ts`, and the repo-map tag tables in `repomap/tags.ts`. Adding a
+ * language meant editing all five, and forgetting one produced a language that half
+ * works: detected but unparsable, parsable but with a syntax-breaking marker.
+ *
+ * A `LanguageProfile` is the single adapter carrying every per-language fact, and the
+ * registry (`registry.ts`) is `Record<LanguageId, LanguageProfile>` so totality stays
+ * a compile error: a new `LanguageId` without a profile does not build. Consumers
+ * *read* the registry — none of them owns a slice of it.
+ *
+ * The optional sections state capability, never invent it: a language is a
+ * **structural language** exactly when its profile carries a {@link structure}
+ * section, and it contributes repo-map symbols exactly when it carries a
+ * {@link repomap} section. What a profile does not claim, smelt does not do.
+ */
+export interface LanguageProfile {
+    readonly id: LanguageId;
+    /** File extensions (lowercase, no dot) that detect as this language. */
+    readonly extensions: readonly string[];
+    /** The bundled grammar file, e.g. `'tree-sitter-python.wasm'`. */
+    readonly wasm: string;
+    /**
+     * The line-comment leader the marker lands behind (`'// '`, `'# '`), so the
+     * survivor still parses in this language's own syntax. A bare `<<smelt…>>` line was
+     * measured to break the reparse non-locally in every grammar tested — see the doc
+     * on `MARKER_LINE_COMMENT_LEADERS` in `src/apply.ts` for the failure classes.
+     * Absent only for a language whose survivors have no syntax to break.
+     */
+    readonly markerLeader?: string;
+    /**
+     * What the structural planner needs to parse this language honestly. Present iff
+     * the language is claimed by `structural/v1`; the derived `STRUCTURAL_LANGUAGES`
+     * list is exactly the profiles that carry this section.
+     */
+    readonly structure?: LanguageStructure;
+    /** What the repo map's tag extraction reads. See {@link RepoMapFacts}. */
+    readonly repomap?: RepoMapFacts;
+}
+/**
+ * What the structural planner needs to know about a language, beyond its grammar:
+ * which node types are comments (so a doc comment travels with its declaration),
+ * which node types merely wrap the declaration that should be named
+ * (`export function f()` is a function, `@cached def f()` is a function), and the
+ * human word for each top-level node kind.
+ */
+export interface LanguageStructure {
+    /** Top-level node types that are comments, in this grammar's vocabulary. */
+    readonly commentTypes: ReadonlySet<string>;
+    /**
+     * Top-level node types that are outer attributes — parsed as siblings of the item
+     * they decorate, but attached forward to it unconditionally by the planner's
+     * `unitsOf`, because that is what the attribute means in the language.
+     */
+    readonly attributeTypes: ReadonlySet<string>;
+    /**
+     * Comments matching this pattern are pinned to the file — never attached, never
+     * collapsed. Go's `//go:build` governs which builds see the whole file, and the
+     * spec's mandatory blank line after it means it could never attach; bash and ruby
+     * shebang lines, and ruby's `# frozen_string_literal:` magic comment, govern how
+     * the file executes at all.
+     */
+    readonly pinnedCommentPattern?: RegExp;
+    /**
+     * Non-comment node types pinned to the file the same way — php's `<?php` open tag,
+     * a `#!` shebang line (javascript's `hash_bang_line`, kotlin and swift's
+     * `shebang_line`). Each is its own uncollapsible unit: a run that swallowed one
+     * would change what the survivor *is*, not just what it contains.
+     */
+    readonly pinnedTypes?: ReadonlySet<string>;
+    /**
+     * Per-node-type text patterns that pin a node the way {@link pinnedTypes} does —
+     * for kinds where only *some* nodes govern the file. C and C++ parse every
+     * `#pragma` as a `preproc_call`; only `#pragma once` changes what including the
+     * survivor *means*, so only it is pinned.
+     */
+    readonly pinnedPatternsByType?: Readonly<Record<string, RegExp>>;
+    /**
+     * Node types that belong to the *preceding* statement despite being parsed as
+     * top-level siblings — ruby's `heredoc_body`, which tree-sitter emits as a sibling
+     * of the statement holding the heredoc opener. Such a node extends the previous
+     * unit, so a collapse can never keep an opener while cutting its body (an
+     * unterminated heredoc the reparse cannot even see — tree-sitter-ruby reports no
+     * ERROR for a heredoc left open at EOF).
+     */
+    readonly ridesBackwardTypes?: ReadonlySet<string>;
+    /**
+     * Node types the grammar extends over trailing comments that belong to what
+     * *follows* — kotlin's `import_list` swallows a KDoc that directly follows the
+     * imports, which is the doc comment of the first declaration after them. The unit
+     * for such a node ends at its last non-comment token; the trailing comments ride
+     * forward and attach like any other comment block.
+     */
+    readonly trailingCommentSplitTypes?: ReadonlySet<string>;
+    /**
+     * Node types that wrap the declaration worth naming — the marker should say what is
+     * inside, not name the wrapper. The value is the label to fall back to when nothing
+     * nameable is found inside.
+     */
+    readonly wrapperTypes: Readonly<Record<string, string>>;
+    /**
+     * Human words per node type. What a language's map does not name, the planner
+     * still labels honestly: an `ERROR` node is an `'unparsed region'`, any other
+     * statement kind is a `'statement'`, and only what remains is called a
+     * `'declaration'` — a marker that calls a parse error or a log line a declaration
+     * would be lying about the tree.
+     */
+    readonly kindLabels: Readonly<Record<string, string>>;
+}
+/**
+ * What the repo map's tag extraction (`repomap/tags.ts`) knows about a language.
+ *
+ * `defKinds` lists only node kinds whose `name` field is an *identifier* node,
+ * because that is what the extraction walk reads — a kind whose name is spelled
+ * differently (php's `name` nodes, ruby's `constant` class names, bash's `word`
+ * function names, kotlin's field-less declarations) is *omitted*, not guessed at. An
+ * omitted kind means fewer symbols on the map, never wrong ones.
+ */
+export interface RepoMapFacts {
+    /** Declaration node type → human kind word. Absent from the map = not a definition. */
+    readonly defKinds: Readonly<Record<string, string>>;
+    /** Node types counted as references. */
+    readonly refTypes: readonly string[];
+}
+//# sourceMappingURL=profile.d.ts.map

package/dist/lang/profile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../src/lang/profile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAC;IACxB,wEAAwE;IACxE,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,kEAAkE;IAClE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,iBAAiB,CAAC;IACvC,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC;CACjC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC,4EAA4E;IAC5E,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC3C;;;;OAIG;IACH,QAAQ,CAAC,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC7C;;;;;;OAMG;IACH,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IACvC;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC3C;;;;;OAKG;IACH,QAAQ,CAAC,oBAAoB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACjE;;;;;;;OAOG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAClD;;;;;;OAMG;IACH,QAAQ,CAAC,yBAAyB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACzD;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACxD;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACvD;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,YAAY;IAC3B,uFAAuF;IACvF,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACpD,wCAAwC;IACxC,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC"}

package/dist/lang/profile.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=profile.js.map

package/dist/lang/profile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile.js","sourceRoot":"","sources":["../../src/lang/profile.ts"],"names":[],"mappings":""}

package/dist/lang/python.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageProfile } from './profile.ts';
+export declare const python: LanguageProfile;
+//# sourceMappingURL=python.d.ts.map

package/dist/lang/python.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"python.d.ts","sourceRoot":"","sources":["../../src/lang/python.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,eAAO,MAAM,MAAM,EAAE,eA+BpB,CAAC"}

package/dist/lang/python.js

@@ -0,0 +1,33 @@
+export const python = {
+    id: 'python',
+    extensions: ['py', 'pyi'],
+    wasm: 'tree-sitter-python.wasm',
+    markerLeader: '# ',
+    structure: {
+        // Docstrings are not comments — they live inside the definition's body, so a kept
+        // definition keeps its docstring because units are kept whole. `#` comments above
+        // a definition attach the same way `/** … */` does in TypeScript.
+        commentTypes: new Set(['comment']),
+        attributeTypes: new Set(),
+        // `#!/usr/bin/env python3` parses as a plain comment node, but it decides which
+        // interpreter runs the file — pinned the way the bash and ruby shebangs are.
+        pinnedCommentPattern: /^#!/,
+        wrapperTypes: { decorated_definition: 'declaration' },
+        kindLabels: {
+            function_definition: 'function',
+            class_definition: 'class',
+            import_statement: 'import statement',
+            import_from_statement: 'import statement',
+            future_import_statement: 'import statement',
+            expression_statement: 'statement',
+        },
+    },
+    repomap: {
+        defKinds: {
+            function_definition: 'function',
+            class_definition: 'class',
+        },
+        refTypes: ['identifier'],
+    },
+};
+//# sourceMappingURL=python.js.map

package/dist/lang/python.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"python.js","sourceRoot":"","sources":["../../src/lang/python.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,MAAM,GAAoB;IACrC,EAAE,EAAE,QAAQ;IACZ,UAAU,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC;IACzB,IAAI,EAAE,yBAAyB;IAC/B,YAAY,EAAE,IAAI;IAClB,SAAS,EAAE;QACT,kFAAkF;QAClF,kFAAkF;QAClF,kEAAkE;QAClE,YAAY,EAAE,IAAI,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC;QAClC,cAAc,EAAE,IAAI,GAAG,EAAE;QACzB,gFAAgF;QAChF,6EAA6E;QAC7E,oBAAoB,EAAE,KAAK;QAC3B,YAAY,EAAE,EAAE,oBAAoB,EAAE,aAAa,EAAE;QACrD,UAAU,EAAE;YACV,mBAAmB,EAAE,UAAU;YAC/B,gBAAgB,EAAE,OAAO;YACzB,gBAAgB,EAAE,kBAAkB;YACpC,qBAAqB,EAAE,kBAAkB;YACzC,uBAAuB,EAAE,kBAAkB;YAC3C,oBAAoB,EAAE,WAAW;SAClC;KACF;IACD,OAAO,EAAE;QACP,QAAQ,EAAE;YACR,mBAAmB,EAAE,UAAU;YAC/B,gBAAgB,EAAE,OAAO;SAC1B;QACD,QAAQ,EAAE,CAAC,YAAY,CAAC;KACzB;CACF,CAAC"}

package/dist/lang/registry.d.ts

@@ -0,0 +1,31 @@
+import type { LanguageId } from '../types.ts';
+import type { LanguageProfile } from './profile.ts';
+/**
+ * The registry — every language smelt knows, one {@link LanguageProfile} each.
+ *
+ * `Record<LanguageId, LanguageProfile>` on purpose: adding a `LanguageId` in
+ * `types.ts` without writing its profile is a compile error, so the id list and the
+ * facts cannot drift. Every derived view — `SUPPORTED_LANGUAGES`,
+ * `WASM_BY_LANGUAGE`, `STRUCTURAL_LANGUAGES`, the extension map, the marker leaders,
+ * the repo-map tag tables — is computed from this object, never written twice.
+ *
+ * Key order is meaningful: it is the order every rendered language list uses (the
+ * `--language`/`--strategy` help, the init wizard, error messages), so keep it stable
+ * and append new languages at the end.
+ */
+export declare const LANGUAGE_PROFILES: Readonly<Record<LanguageId, LanguageProfile>>;
+/** The profile for a language id. Total by construction — see the registry type. */
+export declare function profileFor(id: LanguageId): LanguageProfile;
+/**
+ * The profile a path's extension selects, or `undefined` for anything unmapped.
+ * Deliberately not a content sniffer: guessing from bytes gets things wrong silently,
+ * and `undefined` costs nothing here — `detectLanguage` turns it into `'unknown'`,
+ * which selects the lexical planner, and that works on anything.
+ */
+export declare function profileForPath(path: string | undefined): LanguageProfile | undefined;
+/**
+ * The languages the structural planner claims: exactly the profiles that carry a
+ * `structure` section. In registry order, so every rendered list agrees.
+ */
+export declare function structuralLanguages(): readonly LanguageId[];
+//# sourceMappingURL=registry.d.ts.map

package/dist/lang/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/lang/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAiBpD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,UAAU,EAAE,eAAe,CAAC,CAgB3E,CAAC;AAEF,oFAAoF;AACpF,wBAAgB,UAAU,CAAC,EAAE,EAAE,UAAU,GAAG,eAAe,CAE1D;AAoBD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,eAAe,GAAG,SAAS,CAMpF;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,SAAS,UAAU,EAAE,CAI3D"}

package/dist/lang/registry.js

@@ -0,0 +1,89 @@
+import { bash } from './bash.js';
+import { c } from './c.js';
+import { c_sharp } from './c_sharp.js';
+import { cpp } from './cpp.js';
+import { go } from './go.js';
+import { java } from './java.js';
+import { javascript } from './javascript.js';
+import { kotlin } from './kotlin.js';
+import { php } from './php.js';
+import { python } from './python.js';
+import { ruby } from './ruby.js';
+import { rust } from './rust.js';
+import { swift } from './swift.js';
+import { tsx } from './tsx.js';
+import { typescript } from './typescript.js';
+/**
+ * The registry — every language smelt knows, one {@link LanguageProfile} each.
+ *
+ * `Record<LanguageId, LanguageProfile>` on purpose: adding a `LanguageId` in
+ * `types.ts` without writing its profile is a compile error, so the id list and the
+ * facts cannot drift. Every derived view — `SUPPORTED_LANGUAGES`,
+ * `WASM_BY_LANGUAGE`, `STRUCTURAL_LANGUAGES`, the extension map, the marker leaders,
+ * the repo-map tag tables — is computed from this object, never written twice.
+ *
+ * Key order is meaningful: it is the order every rendered language list uses (the
+ * `--language`/`--strategy` help, the init wizard, error messages), so keep it stable
+ * and append new languages at the end.
+ */
+export const LANGUAGE_PROFILES = {
+    typescript,
+    tsx,
+    javascript,
+    rust,
+    python,
+    go,
+    java,
+    c,
+    cpp,
+    c_sharp,
+    ruby,
+    php,
+    kotlin,
+    swift,
+    bash,
+};
+/** The profile for a language id. Total by construction — see the registry type. */
+export function profileFor(id) {
+    return LANGUAGE_PROFILES[id];
+}
+/** Extension → profile, derived once. A duplicate claim would be a registry bug. */
+const BY_EXTENSION = (() => {
+    const index = new Map();
+    for (const profile of Object.values(LANGUAGE_PROFILES)) {
+        for (const extension of profile.extensions) {
+            const holder = index.get(extension);
+            if (holder !== undefined) {
+                throw new Error(`smelt: extension ".${extension}" is claimed by both "${holder.id}" and ` +
+                    `"${profile.id}" — a path would detect as whichever loaded last.`);
+            }
+            index.set(extension, profile);
+        }
+    }
+    return index;
+})();
+/**
+ * The profile a path's extension selects, or `undefined` for anything unmapped.
+ * Deliberately not a content sniffer: guessing from bytes gets things wrong silently,
+ * and `undefined` costs nothing here — `detectLanguage` turns it into `'unknown'`,
+ * which selects the lexical planner, and that works on anything.
+ */
+export function profileForPath(path) {
+    if (path === undefined)
+        return undefined;
+    const base = path.replace(/\\/g, '/').split('/').pop() ?? '';
+    const dot = base.lastIndexOf('.');
+    if (dot <= 0)
+        return undefined;
+    return BY_EXTENSION.get(base.slice(dot + 1).toLowerCase());
+}
+/**
+ * The languages the structural planner claims: exactly the profiles that carry a
+ * `structure` section. In registry order, so every rendered list agrees.
+ */
+export function structuralLanguages() {
+    return Object.values(LANGUAGE_PROFILES)
+        .filter((profile) => profile.structure !== undefined)
+        .map((profile) => profile.id);
+}
+//# sourceMappingURL=registry.js.map

package/dist/lang/registry.js.map

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

package/dist/lang/ruby.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageProfile } from './profile.ts';
+export declare const ruby: LanguageProfile;
+//# sourceMappingURL=ruby.d.ts.map

package/dist/lang/ruby.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ruby.d.ts","sourceRoot":"","sources":["../../src/lang/ruby.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,eAAO,MAAM,IAAI,EAAE,eA6ClB,CAAC"}

package/dist/lang/ruby.js

@@ -0,0 +1,47 @@
+export const ruby = {
+    id: 'ruby',
+    extensions: ['rb'],
+    wasm: 'tree-sitter-ruby.wasm',
+    markerLeader: '# ',
+    structure: {
+        commentTypes: new Set(['comment']),
+        attributeTypes: new Set(),
+        // The shebang and the `# frozen_string_literal:` magic comment both govern how
+        // the whole file executes; neither may collapse into a run.
+        pinnedCommentPattern: /^#(?:!|\s*frozen_string_literal:)/,
+        // A heredoc's body is a top-level sibling of the statement holding its opener —
+        // it extends that statement's unit, or a collapse could keep the opener and cut
+        // the body, leaving an unterminated heredoc that swallows every declaration
+        // after it (and tree-sitter-ruby reports no ERROR for it at EOF).
+        ridesBackwardTypes: new Set(['heredoc_body']),
+        wrapperTypes: {},
+        kindLabels: {
+            method: 'method',
+            singleton_method: 'method',
+            class: 'class',
+            module: 'module',
+            // Top-level `require "json"` and `CONSTANT = 1` are expression nodes in
+            // tree-sitter-ruby; "statement" is the honest generic word for both — and for
+            // top-level control-flow blocks, which are expressions here too.
+            call: 'statement',
+            assignment: 'statement',
+            if: 'statement',
+            unless: 'statement',
+            case: 'statement',
+            while: 'statement',
+            until: 'statement',
+            for: 'statement',
+            begin: 'statement',
+            heredoc_body: 'heredoc body',
+            comment: 'comment',
+        },
+    },
+    repomap: {
+        defKinds: {
+            method: 'method',
+            singleton_method: 'method',
+        },
+        refTypes: ['identifier', 'constant'],
+    },
+};
+//# sourceMappingURL=ruby.js.map

package/dist/lang/ruby.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ruby.js","sourceRoot":"","sources":["../../src/lang/ruby.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,IAAI,GAAoB;IACnC,EAAE,EAAE,MAAM;IACV,UAAU,EAAE,CAAC,IAAI,CAAC;IAClB,IAAI,EAAE,uBAAuB;IAC7B,YAAY,EAAE,IAAI;IAClB,SAAS,EAAE;QACT,YAAY,EAAE,IAAI,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC;QAClC,cAAc,EAAE,IAAI,GAAG,EAAE;QACzB,+EAA+E;QAC/E,4DAA4D;QAC5D,oBAAoB,EAAE,mCAAmC;QACzD,gFAAgF;QAChF,gFAAgF;QAChF,4EAA4E;QAC5E,kEAAkE;QAClE,kBAAkB,EAAE,IAAI,GAAG,CAAC,CAAC,cAAc,CAAC,CAAC;QAC7C,YAAY,EAAE,EAAE;QAChB,UAAU,EAAE;YACV,MAAM,EAAE,QAAQ;YAChB,gBAAgB,EAAE,QAAQ;YAC1B,KAAK,EAAE,OAAO;YACd,MAAM,EAAE,QAAQ;YAChB,wEAAwE;YACxE,8EAA8E;YAC9E,iEAAiE;YACjE,IAAI,EAAE,WAAW;YACjB,UAAU,EAAE,WAAW;YACvB,EAAE,EAAE,WAAW;YACf,MAAM,EAAE,WAAW;YACnB,IAAI,EAAE,WAAW;YACjB,KAAK,EAAE,WAAW;YAClB,KAAK,EAAE,WAAW;YAClB,GAAG,EAAE,WAAW;YAChB,KAAK,EAAE,WAAW;YAClB,YAAY,EAAE,cAAc;YAC5B,OAAO,EAAE,SAAS;SACnB;KACF;IACD,OAAO,EAAE;QACP,QAAQ,EAAE;YACR,MAAM,EAAE,QAAQ;YAChB,gBAAgB,EAAE,QAAQ;SAC3B;QACD,QAAQ,EAAE,CAAC,YAAY,EAAE,UAAU,CAAC;KACrC;CACF,CAAC"}

package/dist/lang/rust.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageProfile } from './profile.ts';
+export declare const rust: LanguageProfile;
+//# sourceMappingURL=rust.d.ts.map

package/dist/lang/rust.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rust.d.ts","sourceRoot":"","sources":["../../src/lang/rust.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,eAAO,MAAM,IAAI,EAAE,eA2ClB,CAAC"}

package/dist/lang/rust.js

@@ -0,0 +1,45 @@
+export const rust = {
+    id: 'rust',
+    extensions: ['rs'],
+    wasm: 'tree-sitter-rust.wasm',
+    markerLeader: '// ',
+    structure: {
+        // `///` and `//!` doc comments are line_comment nodes; `/** … */` is block_comment.
+        commentTypes: new Set(['line_comment', 'block_comment']),
+        // `#[…]` is a top-level sibling in tree-sitter-rust; it rides forward to its item.
+        attributeTypes: new Set(['attribute_item']),
+        wrapperTypes: {},
+        kindLabels: {
+            function_item: 'function',
+            struct_item: 'struct',
+            enum_item: 'enum',
+            union_item: 'union',
+            trait_item: 'trait',
+            impl_item: 'impl block',
+            mod_item: 'module',
+            macro_definition: 'macro',
+            type_item: 'type alias',
+            const_item: 'constant',
+            static_item: 'static item',
+            use_declaration: 'use declaration',
+            extern_crate_declaration: 'extern crate declaration',
+            attribute_item: 'attribute',
+            foreign_mod_item: 'extern block',
+        },
+    },
+    repomap: {
+        defKinds: {
+            function_item: 'function',
+            struct_item: 'struct',
+            enum_item: 'enum',
+            trait_item: 'trait',
+            mod_item: 'module',
+            const_item: 'constant',
+            static_item: 'static',
+            type_item: 'type alias',
+            union_item: 'union',
+        },
+        refTypes: ['identifier', 'type_identifier'],
+    },
+};
+//# sourceMappingURL=rust.js.map

package/dist/lang/rust.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rust.js","sourceRoot":"","sources":["../../src/lang/rust.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,IAAI,GAAoB;IACnC,EAAE,EAAE,MAAM;IACV,UAAU,EAAE,CAAC,IAAI,CAAC;IAClB,IAAI,EAAE,uBAAuB;IAC7B,YAAY,EAAE,KAAK;IACnB,SAAS,EAAE;QACT,oFAAoF;QACpF,YAAY,EAAE,IAAI,GAAG,CAAC,CAAC,cAAc,EAAE,eAAe,CAAC,CAAC;QACxD,mFAAmF;QACnF,cAAc,EAAE,IAAI,GAAG,CAAC,CAAC,gBAAgB,CAAC,CAAC;QAC3C,YAAY,EAAE,EAAE;QAChB,UAAU,EAAE;YACV,aAAa,EAAE,UAAU;YACzB,WAAW,EAAE,QAAQ;YACrB,SAAS,EAAE,MAAM;YACjB,UAAU,EAAE,OAAO;YACnB,UAAU,EAAE,OAAO;YACnB,SAAS,EAAE,YAAY;YACvB,QAAQ,EAAE,QAAQ;YAClB,gBAAgB,EAAE,OAAO;YACzB,SAAS,EAAE,YAAY;YACvB,UAAU,EAAE,UAAU;YACtB,WAAW,EAAE,aAAa;YAC1B,eAAe,EAAE,iBAAiB;YAClC,wBAAwB,EAAE,0BAA0B;YACpD,cAAc,EAAE,WAAW;YAC3B,gBAAgB,EAAE,cAAc;SACjC;KACF;IACD,OAAO,EAAE;QACP,QAAQ,EAAE;YACR,aAAa,EAAE,UAAU;YACzB,WAAW,EAAE,QAAQ;YACrB,SAAS,EAAE,MAAM;YACjB,UAAU,EAAE,OAAO;YACnB,QAAQ,EAAE,QAAQ;YAClB,UAAU,EAAE,UAAU;YACtB,WAAW,EAAE,QAAQ;YACrB,SAAS,EAAE,YAAY;YACvB,UAAU,EAAE,OAAO;SACpB;QACD,QAAQ,EAAE,CAAC,YAAY,EAAE,iBAAiB,CAAC;KAC5C;CACF,CAAC"}

package/dist/lang/swift.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageProfile } from './profile.ts';
+export declare const swift: LanguageProfile;
+//# sourceMappingURL=swift.d.ts.map

package/dist/lang/swift.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swift.d.ts","sourceRoot":"","sources":["../../src/lang/swift.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,eAAO,MAAM,KAAK,EAAE,eAgCnB,CAAC"}

package/dist/lang/swift.js

@@ -0,0 +1,34 @@
+export const swift = {
+    id: 'swift',
+    extensions: ['swift'],
+    wasm: 'tree-sitter-swift.wasm',
+    markerLeader: '// ',
+    structure: {
+        // `//` and `///` are comment nodes; `/* … */` is multiline_comment.
+        commentTypes: new Set(['comment', 'multiline_comment']),
+        attributeTypes: new Set(),
+        // `#!/usr/bin/env swift` parses as a shebang_line node; same law as the rest.
+        pinnedTypes: new Set(['shebang_line']),
+        wrapperTypes: {},
+        kindLabels: {
+            function_declaration: 'function',
+            // tree-sitter-swift parses struct, class, enum and extension declarations all
+            // as class_declaration — "type declaration" is the honest word for the union.
+            class_declaration: 'type declaration',
+            protocol_declaration: 'protocol',
+            property_declaration: 'property',
+            typealias_declaration: 'type alias',
+            import_declaration: 'import declaration',
+            shebang_line: 'shebang',
+        },
+    },
+    repomap: {
+        defKinds: {
+            class_declaration: 'type',
+            protocol_declaration: 'protocol',
+            function_declaration: 'function',
+        },
+        refTypes: ['simple_identifier', 'type_identifier'],
+    },
+};
+//# sourceMappingURL=swift.js.map

package/dist/lang/swift.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"swift.js","sourceRoot":"","sources":["../../src/lang/swift.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,KAAK,GAAoB;IACpC,EAAE,EAAE,OAAO;IACX,UAAU,EAAE,CAAC,OAAO,CAAC;IACrB,IAAI,EAAE,wBAAwB;IAC9B,YAAY,EAAE,KAAK;IACnB,SAAS,EAAE;QACT,oEAAoE;QACpE,YAAY,EAAE,IAAI,GAAG,CAAC,CAAC,SAAS,EAAE,mBAAmB,CAAC,CAAC;QACvD,cAAc,EAAE,IAAI,GAAG,EAAE;QACzB,8EAA8E;QAC9E,WAAW,EAAE,IAAI,GAAG,CAAC,CAAC,cAAc,CAAC,CAAC;QACtC,YAAY,EAAE,EAAE;QAChB,UAAU,EAAE;YACV,oBAAoB,EAAE,UAAU;YAChC,8EAA8E;YAC9E,8EAA8E;YAC9E,iBAAiB,EAAE,kBAAkB;YACrC,oBAAoB,EAAE,UAAU;YAChC,oBAAoB,EAAE,UAAU;YAChC,qBAAqB,EAAE,YAAY;YACnC,kBAAkB,EAAE,oBAAoB;YACxC,YAAY,EAAE,SAAS;SACxB;KACF;IACD,OAAO,EAAE;QACP,QAAQ,EAAE;YACR,iBAAiB,EAAE,MAAM;YACzB,oBAAoB,EAAE,UAAU;YAChC,oBAAoB,EAAE,UAAU;SACjC;QACD,QAAQ,EAAE,CAAC,mBAAmB,EAAE,iBAAiB,CAAC;KACnD;CACF,CAAC"}

package/dist/lang/tsx.d.ts

@@ -0,0 +1,4 @@
+import type { LanguageProfile } from './profile.ts';
+/** TSX is the typescript grammar family's second id — same structure, same facts. */
+export declare const tsx: LanguageProfile;
+//# sourceMappingURL=tsx.d.ts.map

package/dist/lang/tsx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsx.d.ts","sourceRoot":"","sources":["../../src/lang/tsx.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAGpD,qFAAqF;AACrF,eAAO,MAAM,GAAG,EAAE,eAOjB,CAAC"}

package/dist/lang/tsx.js

@@ -0,0 +1,11 @@
+import { TS_DEF_KINDS, TS_REF_TYPES, TS_STRUCTURE } from './typescript.js';
+/** TSX is the typescript grammar family's second id — same structure, same facts. */
+export const tsx = {
+    id: 'tsx',
+    extensions: ['tsx'],
+    wasm: 'tree-sitter-tsx.wasm',
+    markerLeader: '// ',
+    structure: TS_STRUCTURE,
+    repomap: { defKinds: TS_DEF_KINDS, refTypes: TS_REF_TYPES },
+};
+//# sourceMappingURL=tsx.js.map

package/dist/lang/tsx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsx.js","sourceRoot":"","sources":["../../src/lang/tsx.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE3E,qFAAqF;AACrF,MAAM,CAAC,MAAM,GAAG,GAAoB;IAClC,EAAE,EAAE,KAAK;IACT,UAAU,EAAE,CAAC,KAAK,CAAC;IACnB,IAAI,EAAE,sBAAsB;IAC5B,YAAY,EAAE,KAAK;IACnB,SAAS,EAAE,YAAY;IACvB,OAAO,EAAE,EAAE,QAAQ,EAAE,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE;CAC5D,CAAC"}

package/dist/lang/typescript.d.ts

@@ -0,0 +1,18 @@
+import type { LanguageProfile, LanguageStructure } from './profile.ts';
+/**
+ * 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 declare const TS_KIND_LABELS: Readonly<Record<string, string>>;
+/** One grammar family, two ids: the tsx profile shares this structure verbatim. */
+export declare const TS_STRUCTURE: LanguageStructure;
+/**
+ * Repo-map definition kinds for the typescript grammar family — shared by the
+ * typescript, tsx and javascript profiles, exactly as the extraction treats them.
+ */
+export declare const TS_DEF_KINDS: Readonly<Record<string, string>>;
+/** Repo-map reference node types for the typescript grammar family. */
+export declare const TS_REF_TYPES: readonly string[];
+export declare const typescript: LanguageProfile;
+//# sourceMappingURL=typescript.d.ts.map

package/dist/lang/typescript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../src/lang/typescript.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEvE;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAkB3D,CAAC;AAEF,mFAAmF;AACnF,eAAO,MAAM,YAAY,EAAE,iBAQ1B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAWzD,CAAC;AAEF,uEAAuE;AACvE,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EAAsC,CAAC;AAEjF,eAAO,MAAM,UAAU,EAAE,eAOxB,CAAC"}