@smeltjs/core 0.2.0 → 0.3.0

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

@@ -1 +1 @@
-{"version":3,"file":"java.d.ts","sourceRoot":"","sources":["../../src/lang/java.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,eAAO,MAAM,IAAI,EAAE,eAgClB,CAAC"}
+{"version":3,"file":"java.d.ts","sourceRoot":"","sources":["../../src/lang/java.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,eAAO,MAAM,IAAI,EAAE,eAgClB,CAAC","sourcesContent":["import type { LanguageProfile } from './profile.ts';\n\nexport const java: LanguageProfile = {\n  id: 'java',\n  extensions: ['java'],\n  wasm: 'tree-sitter-java.wasm',\n  markerLeader: '// ',\n  structure: {\n    // `//` is line_comment, `/** … */` javadoc is block_comment — both attach.\n    commentTypes: new Set(['line_comment', 'block_comment']),\n    attributeTypes: new Set(),\n    wrapperTypes: {},\n    kindLabels: {\n      class_declaration: 'class',\n      interface_declaration: 'interface',\n      enum_declaration: 'enum',\n      record_declaration: 'record',\n      annotation_type_declaration: 'annotation type',\n      package_declaration: 'package declaration',\n      import_declaration: 'import declaration',\n      module_declaration: 'module declaration',\n    },\n  },\n  repomap: {\n    defKinds: {\n      class_declaration: 'class',\n      interface_declaration: 'interface',\n      enum_declaration: 'enum',\n      record_declaration: 'record',\n      annotation_type_declaration: 'annotation type',\n      method_declaration: 'method',\n    },\n    refTypes: ['identifier', 'type_identifier'],\n  },\n};\n"]}

package/dist/lang/java.js.map

@@ -1 +1 @@
-{"version":3,"file":"java.js","sourceRoot":"","sources":["../../src/lang/java.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,IAAI,GAAoB;IACnC,EAAE,EAAE,MAAM;IACV,UAAU,EAAE,CAAC,MAAM,CAAC;IACpB,IAAI,EAAE,uBAAuB;IAC7B,YAAY,EAAE,KAAK;IACnB,SAAS,EAAE;QACT,2EAA2E;QAC3E,YAAY,EAAE,IAAI,GAAG,CAAC,CAAC,cAAc,EAAE,eAAe,CAAC,CAAC;QACxD,cAAc,EAAE,IAAI,GAAG,EAAE;QACzB,YAAY,EAAE,EAAE;QAChB,UAAU,EAAE;YACV,iBAAiB,EAAE,OAAO;YAC1B,qBAAqB,EAAE,WAAW;YAClC,gBAAgB,EAAE,MAAM;YACxB,kBAAkB,EAAE,QAAQ;YAC5B,2BAA2B,EAAE,iBAAiB;YAC9C,mBAAmB,EAAE,qBAAqB;YAC1C,kBAAkB,EAAE,oBAAoB;YACxC,kBAAkB,EAAE,oBAAoB;SACzC;KACF;IACD,OAAO,EAAE;QACP,QAAQ,EAAE;YACR,iBAAiB,EAAE,OAAO;YAC1B,qBAAqB,EAAE,WAAW;YAClC,gBAAgB,EAAE,MAAM;YACxB,kBAAkB,EAAE,QAAQ;YAC5B,2BAA2B,EAAE,iBAAiB;YAC9C,kBAAkB,EAAE,QAAQ;SAC7B;QACD,QAAQ,EAAE,CAAC,YAAY,EAAE,iBAAiB,CAAC;KAC5C;CACF,CAAC"}
+{"version":3,"file":"java.js","sourceRoot":"","sources":["../../src/lang/java.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,IAAI,GAAoB;IACnC,EAAE,EAAE,MAAM;IACV,UAAU,EAAE,CAAC,MAAM,CAAC;IACpB,IAAI,EAAE,uBAAuB;IAC7B,YAAY,EAAE,KAAK;IACnB,SAAS,EAAE;QACT,2EAA2E;QAC3E,YAAY,EAAE,IAAI,GAAG,CAAC,CAAC,cAAc,EAAE,eAAe,CAAC,CAAC;QACxD,cAAc,EAAE,IAAI,GAAG,EAAE;QACzB,YAAY,EAAE,EAAE;QAChB,UAAU,EAAE;YACV,iBAAiB,EAAE,OAAO;YAC1B,qBAAqB,EAAE,WAAW;YAClC,gBAAgB,EAAE,MAAM;YACxB,kBAAkB,EAAE,QAAQ;YAC5B,2BAA2B,EAAE,iBAAiB;YAC9C,mBAAmB,EAAE,qBAAqB;YAC1C,kBAAkB,EAAE,oBAAoB;YACxC,kBAAkB,EAAE,oBAAoB;SACzC;KACF;IACD,OAAO,EAAE;QACP,QAAQ,EAAE;YACR,iBAAiB,EAAE,OAAO;YAC1B,qBAAqB,EAAE,WAAW;YAClC,gBAAgB,EAAE,MAAM;YACxB,kBAAkB,EAAE,QAAQ;YAC5B,2BAA2B,EAAE,iBAAiB;YAC9C,kBAAkB,EAAE,QAAQ;SAC7B;QACD,QAAQ,EAAE,CAAC,YAAY,EAAE,iBAAiB,CAAC;KAC5C;CACF,CAAC","sourcesContent":["import type { LanguageProfile } from './profile.ts';\n\nexport const java: LanguageProfile = {\n  id: 'java',\n  extensions: ['java'],\n  wasm: 'tree-sitter-java.wasm',\n  markerLeader: '// ',\n  structure: {\n    // `//` is line_comment, `/** … */` javadoc is block_comment — both attach.\n    commentTypes: new Set(['line_comment', 'block_comment']),\n    attributeTypes: new Set(),\n    wrapperTypes: {},\n    kindLabels: {\n      class_declaration: 'class',\n      interface_declaration: 'interface',\n      enum_declaration: 'enum',\n      record_declaration: 'record',\n      annotation_type_declaration: 'annotation type',\n      package_declaration: 'package declaration',\n      import_declaration: 'import declaration',\n      module_declaration: 'module declaration',\n    },\n  },\n  repomap: {\n    defKinds: {\n      class_declaration: 'class',\n      interface_declaration: 'interface',\n      enum_declaration: 'enum',\n      record_declaration: 'record',\n      annotation_type_declaration: 'annotation type',\n      method_declaration: 'method',\n    },\n    refTypes: ['identifier', 'type_identifier'],\n  },\n};\n"]}

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

@@ -1 +1 @@
-{"version":3,"file":"javascript.d.ts","sourceRoot":"","sources":["../../src/lang/javascript.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAGpD,eAAO,MAAM,UAAU,EAAE,eAyBxB,CAAC"}
+{"version":3,"file":"javascript.d.ts","sourceRoot":"","sources":["../../src/lang/javascript.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAGpD,eAAO,MAAM,UAAU,EAAE,eAyBxB,CAAC","sourcesContent":["import type { LanguageProfile } from './profile.ts';\nimport { TS_DEF_KINDS, TS_REF_TYPES } from './typescript.ts';\n\nexport const javascript: LanguageProfile = {\n  id: 'javascript',\n  extensions: ['js', 'mjs', 'cjs', 'jsx'],\n  wasm: 'tree-sitter-javascript.wasm',\n  markerLeader: '// ',\n  structure: {\n    commentTypes: new Set(['comment']),\n    attributeTypes: new Set(),\n    // `#!/usr/bin/env node` parses as a hash_bang_line node, and it decides how the\n    // file executes — a collapse that swallowed it would break every direct invocation.\n    pinnedTypes: new Set(['hash_bang_line']),\n    wrapperTypes: { export_statement: 'export' },\n    kindLabels: {\n      function_declaration: 'function',\n      generator_function_declaration: 'function',\n      class_declaration: 'class',\n      lexical_declaration: 'variable',\n      variable_declaration: 'variable',\n      import_statement: 'import statement',\n      expression_statement: 'statement',\n      hash_bang_line: 'shebang',\n      comment: 'comment',\n    },\n  },\n  repomap: { defKinds: TS_DEF_KINDS, refTypes: TS_REF_TYPES },\n};\n"]}

package/dist/lang/javascript.js.map

@@ -1 +1 @@
-{"version":3,"file":"javascript.js","sourceRoot":"","sources":["../../src/lang/javascript.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE7D,MAAM,CAAC,MAAM,UAAU,GAAoB;IACzC,EAAE,EAAE,YAAY;IAChB,UAAU,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC;IACvC,IAAI,EAAE,6BAA6B;IACnC,YAAY,EAAE,KAAK;IACnB,SAAS,EAAE;QACT,YAAY,EAAE,IAAI,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC;QAClC,cAAc,EAAE,IAAI,GAAG,EAAE;QACzB,gFAAgF;QAChF,oFAAoF;QACpF,WAAW,EAAE,IAAI,GAAG,CAAC,CAAC,gBAAgB,CAAC,CAAC;QACxC,YAAY,EAAE,EAAE,gBAAgB,EAAE,QAAQ,EAAE;QAC5C,UAAU,EAAE;YACV,oBAAoB,EAAE,UAAU;YAChC,8BAA8B,EAAE,UAAU;YAC1C,iBAAiB,EAAE,OAAO;YAC1B,mBAAmB,EAAE,UAAU;YAC/B,oBAAoB,EAAE,UAAU;YAChC,gBAAgB,EAAE,kBAAkB;YACpC,oBAAoB,EAAE,WAAW;YACjC,cAAc,EAAE,SAAS;YACzB,OAAO,EAAE,SAAS;SACnB;KACF;IACD,OAAO,EAAE,EAAE,QAAQ,EAAE,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE;CAC5D,CAAC"}
+{"version":3,"file":"javascript.js","sourceRoot":"","sources":["../../src/lang/javascript.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE7D,MAAM,CAAC,MAAM,UAAU,GAAoB;IACzC,EAAE,EAAE,YAAY;IAChB,UAAU,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC;IACvC,IAAI,EAAE,6BAA6B;IACnC,YAAY,EAAE,KAAK;IACnB,SAAS,EAAE;QACT,YAAY,EAAE,IAAI,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC;QAClC,cAAc,EAAE,IAAI,GAAG,EAAE;QACzB,gFAAgF;QAChF,oFAAoF;QACpF,WAAW,EAAE,IAAI,GAAG,CAAC,CAAC,gBAAgB,CAAC,CAAC;QACxC,YAAY,EAAE,EAAE,gBAAgB,EAAE,QAAQ,EAAE;QAC5C,UAAU,EAAE;YACV,oBAAoB,EAAE,UAAU;YAChC,8BAA8B,EAAE,UAAU;YAC1C,iBAAiB,EAAE,OAAO;YAC1B,mBAAmB,EAAE,UAAU;YAC/B,oBAAoB,EAAE,UAAU;YAChC,gBAAgB,EAAE,kBAAkB;YACpC,oBAAoB,EAAE,WAAW;YACjC,cAAc,EAAE,SAAS;YACzB,OAAO,EAAE,SAAS;SACnB;KACF;IACD,OAAO,EAAE,EAAE,QAAQ,EAAE,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE;CAC5D,CAAC","sourcesContent":["import type { LanguageProfile } from './profile.ts';\nimport { TS_DEF_KINDS, TS_REF_TYPES } from './typescript.ts';\n\nexport const javascript: LanguageProfile = {\n  id: 'javascript',\n  extensions: ['js', 'mjs', 'cjs', 'jsx'],\n  wasm: 'tree-sitter-javascript.wasm',\n  markerLeader: '// ',\n  structure: {\n    commentTypes: new Set(['comment']),\n    attributeTypes: new Set(),\n    // `#!/usr/bin/env node` parses as a hash_bang_line node, and it decides how the\n    // file executes — a collapse that swallowed it would break every direct invocation.\n    pinnedTypes: new Set(['hash_bang_line']),\n    wrapperTypes: { export_statement: 'export' },\n    kindLabels: {\n      function_declaration: 'function',\n      generator_function_declaration: 'function',\n      class_declaration: 'class',\n      lexical_declaration: 'variable',\n      variable_declaration: 'variable',\n      import_statement: 'import statement',\n      expression_statement: 'statement',\n      hash_bang_line: 'shebang',\n      comment: 'comment',\n    },\n  },\n  repomap: { defKinds: TS_DEF_KINDS, refTypes: TS_REF_TYPES },\n};\n"]}

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

@@ -1 +1 @@
-{"version":3,"file":"kotlin.d.ts","sourceRoot":"","sources":["../../src/lang/kotlin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,eAAO,MAAM,MAAM,EAAE,eAmCpB,CAAC"}
+{"version":3,"file":"kotlin.d.ts","sourceRoot":"","sources":["../../src/lang/kotlin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,eAAO,MAAM,MAAM,EAAE,eAmCpB,CAAC","sourcesContent":["import type { LanguageProfile } from './profile.ts';\n\nexport const kotlin: LanguageProfile = {\n  id: 'kotlin',\n  extensions: ['kt', 'kts'],\n  wasm: 'tree-sitter-kotlin.wasm',\n  markerLeader: '// ',\n  structure: {\n    // `//` is line_comment; `/** … */` KDoc is multiline_comment.\n    commentTypes: new Set(['line_comment', 'multiline_comment']),\n    attributeTypes: new Set(),\n    // `#!/usr/bin/env kotlin` parses as a shebang_line node; same law as the rest.\n    pinnedTypes: new Set(['shebang_line']),\n    // tree-sitter-kotlin extends import_list over a doc comment that directly\n    // follows it — the KDoc of the first documented declaration after the imports.\n    // Split it back out, or that declaration loses its doc to the import collapse.\n    trailingCommentSplitTypes: new Set(['import_list']),\n    wrapperTypes: {},\n    kindLabels: {\n      function_declaration: 'function',\n      // tree-sitter-kotlin parses class, interface and enum headers all as\n      // class_declaration — \"type declaration\" is the honest word for the union.\n      class_declaration: 'type declaration',\n      object_declaration: 'object',\n      property_declaration: 'property',\n      type_alias: 'type alias',\n      package_header: 'package header',\n      import_list: 'import list',\n      shebang_line: 'shebang',\n    },\n  },\n  // No def kinds: tree-sitter-kotlin's declarations carry no identifier `name`\n  // field the extraction walk can read, so kotlin symbols are omitted, not guessed.\n  repomap: {\n    defKinds: {},\n    refTypes: ['simple_identifier', 'type_identifier'],\n  },\n};\n"]}

package/dist/lang/kotlin.js.map

@@ -1 +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"}
+{"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","sourcesContent":["import type { LanguageProfile } from './profile.ts';\n\nexport const kotlin: LanguageProfile = {\n  id: 'kotlin',\n  extensions: ['kt', 'kts'],\n  wasm: 'tree-sitter-kotlin.wasm',\n  markerLeader: '// ',\n  structure: {\n    // `//` is line_comment; `/** … */` KDoc is multiline_comment.\n    commentTypes: new Set(['line_comment', 'multiline_comment']),\n    attributeTypes: new Set(),\n    // `#!/usr/bin/env kotlin` parses as a shebang_line node; same law as the rest.\n    pinnedTypes: new Set(['shebang_line']),\n    // tree-sitter-kotlin extends import_list over a doc comment that directly\n    // follows it — the KDoc of the first documented declaration after the imports.\n    // Split it back out, or that declaration loses its doc to the import collapse.\n    trailingCommentSplitTypes: new Set(['import_list']),\n    wrapperTypes: {},\n    kindLabels: {\n      function_declaration: 'function',\n      // tree-sitter-kotlin parses class, interface and enum headers all as\n      // class_declaration — \"type declaration\" is the honest word for the union.\n      class_declaration: 'type declaration',\n      object_declaration: 'object',\n      property_declaration: 'property',\n      type_alias: 'type alias',\n      package_header: 'package header',\n      import_list: 'import list',\n      shebang_line: 'shebang',\n    },\n  },\n  // No def kinds: tree-sitter-kotlin's declarations carry no identifier `name`\n  // field the extraction walk can read, so kotlin symbols are omitted, not guessed.\n  repomap: {\n    defKinds: {},\n    refTypes: ['simple_identifier', 'type_identifier'],\n  },\n};\n"]}

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

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

package/dist/lang/php.js.map

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

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

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

package/dist/lang/profile.js.map

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

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

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

package/dist/lang/python.js.map

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

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

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

package/dist/lang/registry.js.map

@@ -1 +1 @@
-{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/lang/registry.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAC7B,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAkD;IAC9E,UAAU;IACV,GAAG;IACH,UAAU;IACV,IAAI;IACJ,MAAM;IACN,EAAE;IACF,IAAI;IACJ,CAAC;IACD,GAAG;IACH,OAAO;IACP,IAAI;IACJ,GAAG;IACH,MAAM;IACN,KAAK;IACL,IAAI;CACL,CAAC;AAEF,oFAAoF;AACpF,MAAM,UAAU,UAAU,CAAC,EAAc;IACvC,OAAO,iBAAiB,CAAC,EAAE,CAAC,CAAC;AAC/B,CAAC;AAED,oFAAoF;AACpF,MAAM,YAAY,GAAyC,CAAC,GAAG,EAAE;IAC/D,MAAM,KAAK,GAAG,IAAI,GAAG,EAA2B,CAAC;IACjD,KAAK,MAAM,OAAO,IAAI,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,EAAE,CAAC;QACvD,KAAK,MAAM,SAAS,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;YAC3C,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YACpC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;gBACzB,MAAM,IAAI,KAAK,CACb,sBAAsB,SAAS,yBAAyB,MAAM,CAAC,EAAE,QAAQ;oBACvE,IAAI,OAAO,CAAC,EAAE,mDAAmD,CACpE,CAAC;YACJ,CAAC;YACD,KAAK,CAAC,GAAG,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QAChC,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC,CAAC,EAAE,CAAC;AAEL;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,IAAwB;IACrD,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IACzC,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC;IAC7D,MAAM,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IAClC,IAAI,GAAG,IAAI,CAAC;QAAE,OAAO,SAAS,CAAC;IAC/B,OAAO,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC;AAC7D,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,mBAAmB;IACjC,OAAO,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC;SACpC,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,SAAS,KAAK,SAAS,CAAC;SACpD,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;AAClC,CAAC"}
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/lang/registry.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAC7B,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAkD;IAC9E,UAAU;IACV,GAAG;IACH,UAAU;IACV,IAAI;IACJ,MAAM;IACN,EAAE;IACF,IAAI;IACJ,CAAC;IACD,GAAG;IACH,OAAO;IACP,IAAI;IACJ,GAAG;IACH,MAAM;IACN,KAAK;IACL,IAAI;CACL,CAAC;AAEF,oFAAoF;AACpF,MAAM,UAAU,UAAU,CAAC,EAAc;IACvC,OAAO,iBAAiB,CAAC,EAAE,CAAC,CAAC;AAC/B,CAAC;AAED,oFAAoF;AACpF,MAAM,YAAY,GAAyC,CAAC,GAAG,EAAE;IAC/D,MAAM,KAAK,GAAG,IAAI,GAAG,EAA2B,CAAC;IACjD,KAAK,MAAM,OAAO,IAAI,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,EAAE,CAAC;QACvD,KAAK,MAAM,SAAS,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;YAC3C,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YACpC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;gBACzB,MAAM,IAAI,KAAK,CACb,sBAAsB,SAAS,yBAAyB,MAAM,CAAC,EAAE,QAAQ;oBACvE,IAAI,OAAO,CAAC,EAAE,mDAAmD,CACpE,CAAC;YACJ,CAAC;YACD,KAAK,CAAC,GAAG,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QAChC,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC,CAAC,EAAE,CAAC;AAEL;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,IAAwB;IACrD,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IACzC,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC;IAC7D,MAAM,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IAClC,IAAI,GAAG,IAAI,CAAC;QAAE,OAAO,SAAS,CAAC;IAC/B,OAAO,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC;AAC7D,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,mBAAmB;IACjC,OAAO,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC;SACpC,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,SAAS,KAAK,SAAS,CAAC;SACpD,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;AAClC,CAAC","sourcesContent":["import type { LanguageId } from '../types.ts';\n\nimport type { LanguageProfile } from './profile.ts';\nimport { bash } from './bash.ts';\nimport { c } from './c.ts';\nimport { c_sharp } from './c_sharp.ts';\nimport { cpp } from './cpp.ts';\nimport { go } from './go.ts';\nimport { java } from './java.ts';\nimport { javascript } from './javascript.ts';\nimport { kotlin } from './kotlin.ts';\nimport { php } from './php.ts';\nimport { python } from './python.ts';\nimport { ruby } from './ruby.ts';\nimport { rust } from './rust.ts';\nimport { swift } from './swift.ts';\nimport { tsx } from './tsx.ts';\nimport { typescript } from './typescript.ts';\n\n/**\n * The registry — every language smelt knows, one {@link LanguageProfile} each.\n *\n * `Record<LanguageId, LanguageProfile>` on purpose: adding a `LanguageId` in\n * `types.ts` without writing its profile is a compile error, so the id list and the\n * facts cannot drift. Every derived view — `SUPPORTED_LANGUAGES`,\n * `WASM_BY_LANGUAGE`, `STRUCTURAL_LANGUAGES`, the extension map, the marker leaders,\n * the repo-map tag tables — is computed from this object, never written twice.\n *\n * Key order is meaningful: it is the order every rendered language list uses (the\n * `--language`/`--strategy` help, the init wizard, error messages), so keep it stable\n * and append new languages at the end.\n */\nexport const LANGUAGE_PROFILES: Readonly<Record<LanguageId, LanguageProfile>> = {\n  typescript,\n  tsx,\n  javascript,\n  rust,\n  python,\n  go,\n  java,\n  c,\n  cpp,\n  c_sharp,\n  ruby,\n  php,\n  kotlin,\n  swift,\n  bash,\n};\n\n/** The profile for a language id. Total by construction — see the registry type. */\nexport function profileFor(id: LanguageId): LanguageProfile {\n  return LANGUAGE_PROFILES[id];\n}\n\n/** Extension → profile, derived once. A duplicate claim would be a registry bug. */\nconst BY_EXTENSION: ReadonlyMap<string, LanguageProfile> = (() => {\n  const index = new Map<string, LanguageProfile>();\n  for (const profile of Object.values(LANGUAGE_PROFILES)) {\n    for (const extension of profile.extensions) {\n      const holder = index.get(extension);\n      if (holder !== undefined) {\n        throw new Error(\n          `smelt: extension \".${extension}\" is claimed by both \"${holder.id}\" and ` +\n            `\"${profile.id}\" — a path would detect as whichever loaded last.`,\n        );\n      }\n      index.set(extension, profile);\n    }\n  }\n  return index;\n})();\n\n/**\n * The profile a path's extension selects, or `undefined` for anything unmapped.\n * Deliberately not a content sniffer: guessing from bytes gets things wrong silently,\n * and `undefined` costs nothing here — `detectLanguage` turns it into `'unknown'`,\n * which selects the lexical planner, and that works on anything.\n */\nexport function profileForPath(path: string | undefined): LanguageProfile | undefined {\n  if (path === undefined) return undefined;\n  const base = path.replace(/\\\\/g, '/').split('/').pop() ?? '';\n  const dot = base.lastIndexOf('.');\n  if (dot <= 0) return undefined;\n  return BY_EXTENSION.get(base.slice(dot + 1).toLowerCase());\n}\n\n/**\n * The languages the structural planner claims: exactly the profiles that carry a\n * `structure` section. In registry order, so every rendered list agrees.\n */\nexport function structuralLanguages(): readonly LanguageId[] {\n  return Object.values(LANGUAGE_PROFILES)\n    .filter((profile) => profile.structure !== undefined)\n    .map((profile) => profile.id);\n}\n"]}

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

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

package/dist/lang/ruby.js.map

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

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

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

package/dist/lang/rust.js.map

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

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

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

package/dist/lang/swift.js.map

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

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

@@ -1 +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"}
+{"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","sourcesContent":["import type { LanguageProfile } from './profile.ts';\nimport { TS_DEF_KINDS, TS_REF_TYPES, TS_STRUCTURE } from './typescript.ts';\n\n/** TSX is the typescript grammar family's second id — same structure, same facts. */\nexport const tsx: LanguageProfile = {\n  id: 'tsx',\n  extensions: ['tsx'],\n  wasm: 'tree-sitter-tsx.wasm',\n  markerLeader: '// ',\n  structure: TS_STRUCTURE,\n  repomap: { defKinds: TS_DEF_KINDS, refTypes: TS_REF_TYPES },\n};\n"]}

package/dist/lang/tsx.js.map

@@ -1 +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"}
+{"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","sourcesContent":["import type { LanguageProfile } from './profile.ts';\nimport { TS_DEF_KINDS, TS_REF_TYPES, TS_STRUCTURE } from './typescript.ts';\n\n/** TSX is the typescript grammar family's second id — same structure, same facts. */\nexport const tsx: LanguageProfile = {\n  id: 'tsx',\n  extensions: ['tsx'],\n  wasm: 'tree-sitter-tsx.wasm',\n  markerLeader: '// ',\n  structure: TS_STRUCTURE,\n  repomap: { defKinds: TS_DEF_KINDS, refTypes: TS_REF_TYPES },\n};\n"]}

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

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

package/dist/lang/typescript.js.map

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

package/dist/net/policy.d.ts

@@ -40,10 +40,27 @@ export declare const ALLOWED_PACKAGES: readonly string[];
  * Every resource smelt hands to a loader goes through {@link assertLocalResource} first.
  */
 export declare const ALLOWED_URL_SCHEMES: readonly string[];
+/**
+ * The parsed resource {@link assertLocalResource} takes and hands back.
+ *
+ * A WHATWG `URL` satisfies it, and one is what comes back at runtime — but `URL` is
+ * *stated* structurally here, for the reason `AnswerStream` is not
+ * `NodeJS.ReadableStream` and `RepoReader.read` returns `Uint8Array`: `URL` is a
+ * global that only a compilation which pulled in `@types/node` (or the DOM lib) has,
+ * so naming it in an exported signature put two errors into the shipped `.d.ts` for
+ * every consumer building with `skipLibCheck: false` and no such types of their own.
+ * These are the two members the policy reads and the two its callers use.
+ */
+export interface LocalResource {
+    /** The scheme, with its colon — `'file:'`. */
+    readonly protocol: string;
+    /** The whole URL, as a string. `fileURLToPath` takes it directly. */
+    readonly href: 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;
+export declare function assertLocalResource(input: string | LocalResource): LocalResource;
 //# sourceMappingURL=policy.d.ts.map

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

@@ -1 +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,EAalD,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"}
+{"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;;;;;;;;;;GAUG;AACH,MAAM,WAAW,aAAa;IAC5B,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,qEAAqE;IACrE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,GAAG,aAAa,CAShF","sourcesContent":["import { NetworkPolicyError } from '../errors.ts';\n\n/**\n * Law 1 — zero network in v1 — written down once, in one place, so that the guard\n * test and the runtime check cannot drift apart. `test/guards/no-network.test.ts`\n * imports these lists and fails if any module reachable from the public entrypoint\n * imports one of them.\n *\n * This is a *partition of a discovered set*, not an allowlist over an assumed one:\n * the guard walks the real import graph and classifies every edge it finds. A new\n * transport nobody thought of still gets classified — as an unknown bare import,\n * which the guard reports rather than ignores.\n */\nexport const FORBIDDEN_NODE_MODULES: readonly string[] = [\n  'http',\n  'https',\n  'http2',\n  'net',\n  'tls',\n  'dgram',\n  'dns',\n  'node:http',\n  'node:https',\n  'node:http2',\n  'node:net',\n  'node:tls',\n  'node:dgram',\n  'node:dns',\n];\n\n/** Third-party transports. A dependency that pulls one in is a Law 1 violation too. */\nexport const FORBIDDEN_PACKAGES: readonly string[] = [\n  'undici',\n  'axios',\n  'node-fetch',\n  'got',\n  'ky',\n  'superagent',\n  'ws',\n  'socket.io-client',\n  'eventsource',\n];\n\n/**\n * Globals that reach the network without an import. Grepped for by the guard — both\n * bare (`fetch(…)`) and qualified through a global object (`globalThis.fetch(…)`),\n * which is why `globalThis` and `global` are themselves on the list: an access\n * routed through the global object is the escape hatch around a bare-name grep.\n */\nexport const FORBIDDEN_GLOBALS: readonly string[] = [\n  'fetch',\n  'XMLHttpRequest',\n  'WebSocket',\n  'EventSource',\n  'navigator',\n  'globalThis',\n  'global',\n];\n\n/**\n * The other half of the partition.\n *\n * A forbidden-list alone is an allowlist over an assumed set: it can only catch\n * transports somebody already thought of. So the guard classifies *every* import edge\n * it discovers, and an edge that matches neither the forbidden lists nor these\n * permitted ones **fails the build**. Adding a dependency therefore requires adding it\n * here, in a diff, next to the reason — which is the point.\n */\nexport const ALLOWED_NODE_BUILTINS: readonly string[] = [\n  'node:crypto', // content hashing for the elision store\n  'node:fs', // reading grammar .wasm files off disk\n  'node:fs/promises',\n  'node:path',\n  'node:url',\n  'node:buffer',\n  'node:module', // web-tree-sitter's own loader shim needs createRequire\n  'node:util', // parseArgs, for the CLI. Argument parsing with zero dependencies.\n  'node:process', // argv, stdin/stdout/stderr and the exit code, for the CLI\n  'node:os', // homedir(), for `smelt hooks install` harness detection — reads a path, opens nothing\n  'node:tty', // isatty(0) for the CLI's TTY check — a plain syscall, no stream, no socket\n];\n\n/** Third-party packages any smelt module may import. Keep this list boring and short. */\nexport const ALLOWED_PACKAGES: readonly string[] = [\n  'web-tree-sitter', // WASM parsers. No native build step, no download at runtime.\n  'tree-sitter-wasms', // prebuilt grammar .wasm blobs, resolved to local file paths\n];\n\n/**\n * The only URL schemes any smelt code path may resolve.\n *\n * This is not paranoia about our own code. `web-tree-sitter`'s `Language.load()`\n * accepts a `string | URL`, and an `https:` URL there would fetch a grammar over the\n * wire — a real network call inside the elision path, from a dependency's happy path.\n * Every resource smelt hands to a loader goes through {@link assertLocalResource} first.\n */\nexport const ALLOWED_URL_SCHEMES: readonly string[] = ['file:'];\n\n/**\n * The parsed resource {@link assertLocalResource} takes and hands back.\n *\n * A WHATWG `URL` satisfies it, and one is what comes back at runtime — but `URL` is\n * *stated* structurally here, for the reason `AnswerStream` is not\n * `NodeJS.ReadableStream` and `RepoReader.read` returns `Uint8Array`: `URL` is a\n * global that only a compilation which pulled in `@types/node` (or the DOM lib) has,\n * so naming it in an exported signature put two errors into the shipped `.d.ts` for\n * every consumer building with `skipLibCheck: false` and no such types of their own.\n * These are the two members the policy reads and the two its callers use.\n */\nexport interface LocalResource {\n  /** The scheme, with its colon — `'file:'`. */\n  readonly protocol: string;\n  /** The whole URL, as a string. `fileURLToPath` takes it directly. */\n  readonly href: string;\n}\n\n/**\n * Reject anything that is not a local file, and return the resolved `file:` URL.\n *\n * @throws {NetworkPolicyError} if the input names a remote scheme.\n */\nexport function assertLocalResource(input: string | LocalResource): LocalResource {\n  const url = toUrl(input);\n  if (!ALLOWED_URL_SCHEMES.includes(url.protocol)) {\n    throw new NetworkPolicyError(\n      `refusing to load \"${resourceLabel(input)}\": scheme \"${url.protocol}\" is not local. ` +\n        `v1 makes zero network calls; only ${ALLOWED_URL_SCHEMES.join(', ')} is allowed.`,\n    );\n  }\n  return url;\n}\n\nconst resourceLabel = (input: string | LocalResource): string =>\n  typeof input === 'string' ? input : input.href;\n\nfunction toUrl(input: string | LocalResource): URL {\n  // Structural in, structural out: anything carrying an `href` is re-parsed from it,\n  // which covers a real `URL` and a `URL` from another realm identically.\n  if (typeof input !== 'string') return new URL(input.href);\n  // A bare path is a local path. Anything with a scheme is parsed as-is so that\n  // \"https://evil/grammar.wasm\" is caught rather than treated as a relative path.\n  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(input)) {\n    try {\n      return new URL(input);\n    } catch {\n      throw new NetworkPolicyError(`refusing to load \"${input}\": not a parseable URL or path.`);\n    }\n  }\n  return new URL(`file://${input.startsWith('/') ? '' : '/'}${input}`);\n}\n"]}

package/dist/net/policy.js

@@ -73,7 +73,6 @@ export const ALLOWED_NODE_BUILTINS = [
     '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:os', // homedir(), for `smelt hooks install` harness detection — reads a path, opens nothing
-    '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. */
@@ -98,14 +97,17 @@ export const ALLOWED_URL_SCHEMES = ['file:'];
 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. ` +
+        throw new NetworkPolicyError(`refusing to load "${resourceLabel(input)}": scheme "${url.protocol}" is not local. ` +
             `v1 makes zero network calls; only ${ALLOWED_URL_SCHEMES.join(', ')} is allowed.`);
     }
     return url;
 }
+const resourceLabel = (input) => typeof input === 'string' ? input : input.href;
 function toUrl(input) {
-    if (input instanceof URL)
-        return input;
+    // Structural in, structural out: anything carrying an `href` is re-parsed from it,
+    // which covers a real `URL` and a `URL` from another realm identically.
+    if (typeof input !== 'string')
+        return new URL(input.href);
     // 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)) {

package/dist/net/policy.js.map

@@ -1 +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,SAAS,EAAE,uFAAuF;IAClG,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"}
+{"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,SAAS,EAAE,uFAAuF;IAClG,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;AAoBhE;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAA6B;IAC/D,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,aAAa,CAAC,KAAK,CAAC,cAAc,GAAG,CAAC,QAAQ,kBAAkB;YACnF,qCAAqC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CACpF,CAAC;IACJ,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,MAAM,aAAa,GAAG,CAAC,KAA6B,EAAU,EAAE,CAC9D,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC;AAEjD,SAAS,KAAK,CAAC,KAA6B;IAC1C,mFAAmF;IACnF,wEAAwE;IACxE,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,IAAI,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC1D,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","sourcesContent":["import { NetworkPolicyError } from '../errors.ts';\n\n/**\n * Law 1 — zero network in v1 — written down once, in one place, so that the guard\n * test and the runtime check cannot drift apart. `test/guards/no-network.test.ts`\n * imports these lists and fails if any module reachable from the public entrypoint\n * imports one of them.\n *\n * This is a *partition of a discovered set*, not an allowlist over an assumed one:\n * the guard walks the real import graph and classifies every edge it finds. A new\n * transport nobody thought of still gets classified — as an unknown bare import,\n * which the guard reports rather than ignores.\n */\nexport const FORBIDDEN_NODE_MODULES: readonly string[] = [\n  'http',\n  'https',\n  'http2',\n  'net',\n  'tls',\n  'dgram',\n  'dns',\n  'node:http',\n  'node:https',\n  'node:http2',\n  'node:net',\n  'node:tls',\n  'node:dgram',\n  'node:dns',\n];\n\n/** Third-party transports. A dependency that pulls one in is a Law 1 violation too. */\nexport const FORBIDDEN_PACKAGES: readonly string[] = [\n  'undici',\n  'axios',\n  'node-fetch',\n  'got',\n  'ky',\n  'superagent',\n  'ws',\n  'socket.io-client',\n  'eventsource',\n];\n\n/**\n * Globals that reach the network without an import. Grepped for by the guard — both\n * bare (`fetch(…)`) and qualified through a global object (`globalThis.fetch(…)`),\n * which is why `globalThis` and `global` are themselves on the list: an access\n * routed through the global object is the escape hatch around a bare-name grep.\n */\nexport const FORBIDDEN_GLOBALS: readonly string[] = [\n  'fetch',\n  'XMLHttpRequest',\n  'WebSocket',\n  'EventSource',\n  'navigator',\n  'globalThis',\n  'global',\n];\n\n/**\n * The other half of the partition.\n *\n * A forbidden-list alone is an allowlist over an assumed set: it can only catch\n * transports somebody already thought of. So the guard classifies *every* import edge\n * it discovers, and an edge that matches neither the forbidden lists nor these\n * permitted ones **fails the build**. Adding a dependency therefore requires adding it\n * here, in a diff, next to the reason — which is the point.\n */\nexport const ALLOWED_NODE_BUILTINS: readonly string[] = [\n  'node:crypto', // content hashing for the elision store\n  'node:fs', // reading grammar .wasm files off disk\n  'node:fs/promises',\n  'node:path',\n  'node:url',\n  'node:buffer',\n  'node:module', // web-tree-sitter's own loader shim needs createRequire\n  'node:util', // parseArgs, for the CLI. Argument parsing with zero dependencies.\n  'node:process', // argv, stdin/stdout/stderr and the exit code, for the CLI\n  'node:os', // homedir(), for `smelt hooks install` harness detection — reads a path, opens nothing\n  'node:tty', // isatty(0) for the CLI's TTY check — a plain syscall, no stream, no socket\n];\n\n/** Third-party packages any smelt module may import. Keep this list boring and short. */\nexport const ALLOWED_PACKAGES: readonly string[] = [\n  'web-tree-sitter', // WASM parsers. No native build step, no download at runtime.\n  'tree-sitter-wasms', // prebuilt grammar .wasm blobs, resolved to local file paths\n];\n\n/**\n * The only URL schemes any smelt code path may resolve.\n *\n * This is not paranoia about our own code. `web-tree-sitter`'s `Language.load()`\n * accepts a `string | URL`, and an `https:` URL there would fetch a grammar over the\n * wire — a real network call inside the elision path, from a dependency's happy path.\n * Every resource smelt hands to a loader goes through {@link assertLocalResource} first.\n */\nexport const ALLOWED_URL_SCHEMES: readonly string[] = ['file:'];\n\n/**\n * The parsed resource {@link assertLocalResource} takes and hands back.\n *\n * A WHATWG `URL` satisfies it, and one is what comes back at runtime — but `URL` is\n * *stated* structurally here, for the reason `AnswerStream` is not\n * `NodeJS.ReadableStream` and `RepoReader.read` returns `Uint8Array`: `URL` is a\n * global that only a compilation which pulled in `@types/node` (or the DOM lib) has,\n * so naming it in an exported signature put two errors into the shipped `.d.ts` for\n * every consumer building with `skipLibCheck: false` and no such types of their own.\n * These are the two members the policy reads and the two its callers use.\n */\nexport interface LocalResource {\n  /** The scheme, with its colon — `'file:'`. */\n  readonly protocol: string;\n  /** The whole URL, as a string. `fileURLToPath` takes it directly. */\n  readonly href: string;\n}\n\n/**\n * Reject anything that is not a local file, and return the resolved `file:` URL.\n *\n * @throws {NetworkPolicyError} if the input names a remote scheme.\n */\nexport function assertLocalResource(input: string | LocalResource): LocalResource {\n  const url = toUrl(input);\n  if (!ALLOWED_URL_SCHEMES.includes(url.protocol)) {\n    throw new NetworkPolicyError(\n      `refusing to load \"${resourceLabel(input)}\": scheme \"${url.protocol}\" is not local. ` +\n        `v1 makes zero network calls; only ${ALLOWED_URL_SCHEMES.join(', ')} is allowed.`,\n    );\n  }\n  return url;\n}\n\nconst resourceLabel = (input: string | LocalResource): string =>\n  typeof input === 'string' ? input : input.href;\n\nfunction toUrl(input: string | LocalResource): URL {\n  // Structural in, structural out: anything carrying an `href` is re-parsed from it,\n  // which covers a real `URL` and a `URL` from another realm identically.\n  if (typeof input !== 'string') return new URL(input.href);\n  // A bare path is a local path. Anything with a scheme is parsed as-is so that\n  // \"https://evil/grammar.wasm\" is caught rather than treated as a relative path.\n  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(input)) {\n    try {\n      return new URL(input);\n    } catch {\n      throw new NetworkPolicyError(`refusing to load \"${input}\": not a parseable URL or path.`);\n    }\n  }\n  return new URL(`file://${input.startsWith('/') ? '' : '/'}${input}`);\n}\n"]}

package/dist/ops/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The operations seam: what `smelt` *does*, under every door that asks it to.
+ *
+ * smelt has two front doors — the `smelt` binary in this package and the
+ * `@smeltjs/mcp` server next to it — and they are not two products. They are two
+ * conventions for saying the same four things: cut this blob, map this tree, give
+ * those bytes back, read the counters. The difference between them is entirely at the
+ * edges: one reads argv and writes to two streams and returns an exit code, the other
+ * validates a JSON Schema and returns a `CallToolResult`.
+ *
+ * The middle was duplicated anyway. Both packages had their own copy of *the budget is
+ * a positive integer with no default*, *an explicit strategy beats a configured one
+ * and `lexical` fills last*, *a tree reader refuses a file*, *read a path or fail
+ * naming it*, and *a config decides a store*. Five laws, ten implementations — and the
+ * mechanical cause is visible in one line of history: `resolveStoreRun` was never
+ * exported, so the package that needed the store law could not import it and wrote its
+ * own. A restatement leaked across a package boundary because the seam it needed sat
+ * on the wrong side of a barrel.
+ *
+ * So this module is the seam, below both doors:
+ *
+ * - **`ops/verbs.ts`** — {@link smeltBlob}, {@link mapTree}, {@link retrieveBytes},
+ *   {@link readCounters}. The verbs over already-resolved inputs, returning data.
+ * - **`ops/inputs.ts`** — the laws an input must satisfy to *be* resolved, each
+ *   stating its rule once and taking the caller's naming as an argument.
+ *
+ * A front door is now an adapter: **parse and resolve, call an op, render.** The CLI
+ * subcommand bodies do that with flags, a config file and an exit code; the MCP tools
+ * do it with a JSON Schema and a result envelope. What each may still keep is what is
+ * genuinely its own — its error type, its exit code, its wording, and any policy it
+ * deliberately does not share. (`smelt retrieve` refuses a memory store; the MCP
+ * server accepts one and says so when it bites. That divergence is intentional, it is
+ * documented on both sides, and it lives in the adapters — never here.)
+ */
+export { budgetFault, budgetMalformed, budgetRequired, openStore, readBlob, readTree, resolveStrategy, } from './inputs.ts';
+export type { BudgetFault, BudgetNaming, ResolvedStrategy, Ruling, StrategySource, TreeNaming, } from './inputs.ts';
+export { mapTree, readCounters, retrieveBytes, smeltBlob } from './verbs.ts';
+export type { MapTreeOp, ReadCountersOp, RetrieveBytesOp, SmeltBlobOp, SmeltBlobOutcome, } from './verbs.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/ops/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ops/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EACL,WAAW,EACX,eAAe,EACf,cAAc,EACd,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,eAAe,GAChB,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,MAAM,EACN,cAAc,EACd,UAAU,GACX,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC7E,YAAY,EACV,SAAS,EACT,cAAc,EACd,eAAe,EACf,WAAW,EACX,gBAAgB,GACjB,MAAM,YAAY,CAAC","sourcesContent":["/**\n * The operations seam: what `smelt` *does*, under every door that asks it to.\n *\n * smelt has two front doors — the `smelt` binary in this package and the\n * `@smeltjs/mcp` server next to it — and they are not two products. They are two\n * conventions for saying the same four things: cut this blob, map this tree, give\n * those bytes back, read the counters. The difference between them is entirely at the\n * edges: one reads argv and writes to two streams and returns an exit code, the other\n * validates a JSON Schema and returns a `CallToolResult`.\n *\n * The middle was duplicated anyway. Both packages had their own copy of *the budget is\n * a positive integer with no default*, *an explicit strategy beats a configured one\n * and `lexical` fills last*, *a tree reader refuses a file*, *read a path or fail\n * naming it*, and *a config decides a store*. Five laws, ten implementations — and the\n * mechanical cause is visible in one line of history: `resolveStoreRun` was never\n * exported, so the package that needed the store law could not import it and wrote its\n * own. A restatement leaked across a package boundary because the seam it needed sat\n * on the wrong side of a barrel.\n *\n * So this module is the seam, below both doors:\n *\n * - **`ops/verbs.ts`** — {@link smeltBlob}, {@link mapTree}, {@link retrieveBytes},\n *   {@link readCounters}. The verbs over already-resolved inputs, returning data.\n * - **`ops/inputs.ts`** — the laws an input must satisfy to *be* resolved, each\n *   stating its rule once and taking the caller's naming as an argument.\n *\n * A front door is now an adapter: **parse and resolve, call an op, render.** The CLI\n * subcommand bodies do that with flags, a config file and an exit code; the MCP tools\n * do it with a JSON Schema and a result envelope. What each may still keep is what is\n * genuinely its own — its error type, its exit code, its wording, and any policy it\n * deliberately does not share. (`smelt retrieve` refuses a memory store; the MCP\n * server accepts one and says so when it bites. That divergence is intentional, it is\n * documented on both sides, and it lives in the adapters — never here.)\n */\n\nexport {\n  budgetFault,\n  budgetMalformed,\n  budgetRequired,\n  openStore,\n  readBlob,\n  readTree,\n  resolveStrategy,\n} from './inputs.ts';\nexport type {\n  BudgetFault,\n  BudgetNaming,\n  ResolvedStrategy,\n  Ruling,\n  StrategySource,\n  TreeNaming,\n} from './inputs.ts';\nexport { mapTree, readCounters, retrieveBytes, smeltBlob } from './verbs.ts';\nexport type {\n  MapTreeOp,\n  ReadCountersOp,\n  RetrieveBytesOp,\n  SmeltBlobOp,\n  SmeltBlobOutcome,\n} from './verbs.ts';\n"]}

package/dist/ops/index.js

@@ -0,0 +1,37 @@
+/**
+ * The operations seam: what `smelt` *does*, under every door that asks it to.
+ *
+ * smelt has two front doors — the `smelt` binary in this package and the
+ * `@smeltjs/mcp` server next to it — and they are not two products. They are two
+ * conventions for saying the same four things: cut this blob, map this tree, give
+ * those bytes back, read the counters. The difference between them is entirely at the
+ * edges: one reads argv and writes to two streams and returns an exit code, the other
+ * validates a JSON Schema and returns a `CallToolResult`.
+ *
+ * The middle was duplicated anyway. Both packages had their own copy of *the budget is
+ * a positive integer with no default*, *an explicit strategy beats a configured one
+ * and `lexical` fills last*, *a tree reader refuses a file*, *read a path or fail
+ * naming it*, and *a config decides a store*. Five laws, ten implementations — and the
+ * mechanical cause is visible in one line of history: `resolveStoreRun` was never
+ * exported, so the package that needed the store law could not import it and wrote its
+ * own. A restatement leaked across a package boundary because the seam it needed sat
+ * on the wrong side of a barrel.
+ *
+ * So this module is the seam, below both doors:
+ *
+ * - **`ops/verbs.ts`** — {@link smeltBlob}, {@link mapTree}, {@link retrieveBytes},
+ *   {@link readCounters}. The verbs over already-resolved inputs, returning data.
+ * - **`ops/inputs.ts`** — the laws an input must satisfy to *be* resolved, each
+ *   stating its rule once and taking the caller's naming as an argument.
+ *
+ * A front door is now an adapter: **parse and resolve, call an op, render.** The CLI
+ * subcommand bodies do that with flags, a config file and an exit code; the MCP tools
+ * do it with a JSON Schema and a result envelope. What each may still keep is what is
+ * genuinely its own — its error type, its exit code, its wording, and any policy it
+ * deliberately does not share. (`smelt retrieve` refuses a memory store; the MCP
+ * server accepts one and says so when it bites. That divergence is intentional, it is
+ * documented on both sides, and it lives in the adapters — never here.)
+ */
+export { budgetFault, budgetMalformed, budgetRequired, openStore, readBlob, readTree, resolveStrategy, } from './inputs.js';
+export { mapTree, readCounters, retrieveBytes, smeltBlob } from './verbs.js';
+//# sourceMappingURL=index.js.map

package/dist/ops/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/ops/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EACL,WAAW,EACX,eAAe,EACf,cAAc,EACd,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,eAAe,GAChB,MAAM,aAAa,CAAC;AASrB,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC","sourcesContent":["/**\n * The operations seam: what `smelt` *does*, under every door that asks it to.\n *\n * smelt has two front doors — the `smelt` binary in this package and the\n * `@smeltjs/mcp` server next to it — and they are not two products. They are two\n * conventions for saying the same four things: cut this blob, map this tree, give\n * those bytes back, read the counters. The difference between them is entirely at the\n * edges: one reads argv and writes to two streams and returns an exit code, the other\n * validates a JSON Schema and returns a `CallToolResult`.\n *\n * The middle was duplicated anyway. Both packages had their own copy of *the budget is\n * a positive integer with no default*, *an explicit strategy beats a configured one\n * and `lexical` fills last*, *a tree reader refuses a file*, *read a path or fail\n * naming it*, and *a config decides a store*. Five laws, ten implementations — and the\n * mechanical cause is visible in one line of history: `resolveStoreRun` was never\n * exported, so the package that needed the store law could not import it and wrote its\n * own. A restatement leaked across a package boundary because the seam it needed sat\n * on the wrong side of a barrel.\n *\n * So this module is the seam, below both doors:\n *\n * - **`ops/verbs.ts`** — {@link smeltBlob}, {@link mapTree}, {@link retrieveBytes},\n *   {@link readCounters}. The verbs over already-resolved inputs, returning data.\n * - **`ops/inputs.ts`** — the laws an input must satisfy to *be* resolved, each\n *   stating its rule once and taking the caller's naming as an argument.\n *\n * A front door is now an adapter: **parse and resolve, call an op, render.** The CLI\n * subcommand bodies do that with flags, a config file and an exit code; the MCP tools\n * do it with a JSON Schema and a result envelope. What each may still keep is what is\n * genuinely its own — its error type, its exit code, its wording, and any policy it\n * deliberately does not share. (`smelt retrieve` refuses a memory store; the MCP\n * server accepts one and says so when it bites. That divergence is intentional, it is\n * documented on both sides, and it lives in the adapters — never here.)\n */\n\nexport {\n  budgetFault,\n  budgetMalformed,\n  budgetRequired,\n  openStore,\n  readBlob,\n  readTree,\n  resolveStrategy,\n} from './inputs.ts';\nexport type {\n  BudgetFault,\n  BudgetNaming,\n  ResolvedStrategy,\n  Ruling,\n  StrategySource,\n  TreeNaming,\n} from './inputs.ts';\nexport { mapTree, readCounters, retrieveBytes, smeltBlob } from './verbs.ts';\nexport type {\n  MapTreeOp,\n  ReadCountersOp,\n  RetrieveBytesOp,\n  SmeltBlobOp,\n  SmeltBlobOutcome,\n} from './verbs.ts';\n"]}