@smeltjs/core 0.2.0 → 0.4.0

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

package/dist/ops/inputs.d.ts

@@ -0,0 +1,170 @@
+import type { ConfiguredStore } from '../cli/config.ts';
+import type { Strategy } from '../plan/planners.ts';
+import type { ElisionStore } from '../types.ts';
+/**
+ * The laws an operation's input must satisfy — stated once, for every front door.
+ *
+ * Each rule here was, until this seam existed, written twice: once in a
+ * `cli/subcommands/*` verb and once in the MCP server's tool handlers. Two copies of a
+ * law is two laws, and the copies had already begun to differ — the `smelt` CLI and
+ * the `smelt_file` tool refuse a missing budget with the same reasoning in two
+ * separately-maintained sentences, and only one of them was ever edited at a time.
+ *
+ * **What is shared and what is not.** A law has two halves, and only one of them can
+ * be shared honestly:
+ *
+ *   - the **rule and its reasoning** — that a budget is a whole number of bytes
+ *     greater than zero, that there is no default and why, that a tree-reader refuses
+ *     a file, that a strategy falls back to `lexical` last. That half lives here.
+ *   - the **naming** — a CLI spells its budget `--budget` and points at
+ *     `smelt.config.json`; a tool spells it `"budgetBytes"` and points at nothing.
+ *     That half is the front door's own, and every function here takes it as an
+ *     argument rather than guessing.
+ *
+ * Nothing here throws. The two front doors refuse in different currencies — the CLI
+ * with a {@link CliUsageError} that exits 2, the MCP server with a tool-level error
+ * carrying `isError: true` — and a shared law that threw would force one of them to
+ * catch and re-wrap the other's error type, which is how an exit code changes by
+ * accident. So a law that can refuse returns a {@link Ruling}: the value, or the one
+ * sentence that refuses it, for the caller to throw in its own currency.
+ *
+ * Nothing here *finds* a `smelt.config.json` either. Config discovery is a CLI
+ * concern by design (see `cli/config.ts`); {@link openStore} takes a decision that
+ * has already been made and opens it, so no library call's behaviour depends on the
+ * directory it was invoked from.
+ */
+/**
+ * The answer to a law that can refuse: the value, or the one sentence refusing it.
+ *
+ * Deliberately not an exception — see the module comment. The refusal is the
+ * complete sentence *minus* whatever prefix the front door puts on its own errors
+ * (`smelt: ` for the CLI, the tool name for MCP), because that prefix is naming, and
+ * naming belongs to the caller.
+ */
+export type Ruling<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly refusal: string;
+};
+/** How one front door spells the budget it is refusing, and what it points at next. */
+export interface BudgetNaming {
+    /** The knob, as this surface spells it: `--budget`, `"budgetBytes"`. */
+    readonly knob: string;
+    /**
+     * What a budget smelt invented would silently decide — the back half of the
+     * no-default sentence. `'your context to throw away'` for a blob run, `'the map to
+     * leave out'` for a tree.
+     */
+    readonly stake: string;
+    /**
+     * Anything this surface adds after the law: where else the value can come from, and
+     * an example. Appended after a single space. The CLI names `defaultBudgetBytes` and
+     * `smelt init` here; a tool whose schema already says `required` adds nothing.
+     */
+    readonly advice?: string;
+}
+/**
+ * Law: **a budget is required, and there is no default.**
+ *
+ * The reasoning is the whole point of the sentence, so it is stated once here rather
+ * than paraphrased per surface: a budget smelt invented would silently decide how much
+ * of the caller's context to throw away, which is a number nobody measured making a
+ * decision nobody made.
+ */
+export declare function budgetRequired(naming: BudgetNaming): string;
+/** The two ways a budget that *was* given can still be wrong. See {@link budgetFault}. */
+export type BudgetFault = 'not-an-integer' | 'not-positive';
+/**
+ * Law: **a budget is a whole number of UTF-8 bytes greater than zero.**
+ *
+ * The numeric half only. Getting a candidate *number* out of a surface is that
+ * surface's own lexing and stays there: argv carries strings (`--budget 4kb` is a
+ * malformed number, and `-1` never reaches here because a leading `-` is not a
+ * budget at all), while a JSON tool argument carries whatever type the model sent.
+ * Both then ask this function the same question about the same rule.
+ */
+export declare function budgetFault(value: number): BudgetFault | undefined;
+/**
+ * The sentence for a {@link BudgetFault}, naming the value it rejected.
+ *
+ * `got` is rendered with `JSON.stringify`, which is what both front doors already
+ * printed: a CLI passes the raw argv word and gets it back quoted (`"4kb"`), a tool
+ * passes the raw JSON value and gets numbers bare (`0`) and strings quoted. One
+ * renderer, because a value echoed back in a different shape than it was written is a
+ * value the author has to translate before they can see their own typo.
+ */
+export declare function budgetMalformed(fault: BudgetFault, knob: string, got: unknown): string;
+/**
+ * The strategy a run falls back to when neither the caller nor a config names one.
+ *
+ * Re-exported rather than restated: {@link DEFAULT_STRATEGY} is the planner registry's
+ * own fact, and a second spelling here would be the fork this seam exists to close.
+ */
+export { DEFAULT_STRATEGY } from '../plan/planners.ts';
+/** Where a resolved strategy came from — the receipt {@link resolveStrategy} returns. */
+export type StrategySource = 'flag' | 'config' | 'builtin';
+/** A strategy, with the provenance that explains it. */
+export interface ResolvedStrategy {
+    readonly strategy: Strategy;
+    readonly source: StrategySource;
+}
+/**
+ * Law: **an explicit strategy wins over a configured one, and `lexical` fills last.**
+ *
+ * Both front doors had this precedence written out, and both spelled the built-in
+ * `'lexical'` inline — so a sixth planner promoted to the default would have been a
+ * two-package edit with no compiler and no test to notice half of it. `chosen` is
+ * whatever the caller said explicitly (a `--strategy` flag, a `"strategy"` argument);
+ * `configured` is what the nearest `smelt.config.json` says. Validating the name is
+ * *not* part of this law — membership in the `PLANNERS` registry (`isStrategy`) is
+ * that, already shared, and the sentence each surface refuses an unknown name with is
+ * its own register: a flag and a JSON argument do not read alike.
+ */
+export declare function resolveStrategy(chosen: Strategy | undefined, configured: Strategy | undefined): ResolvedStrategy;
+/**
+ * Law: **read a path, or fail naming it.**
+ *
+ * `shownAs` is the path as its author wrote it, which is not always the path opened:
+ * a tool resolves a relative argument against the server's working directory, and
+ * echoing back the absolute result would answer a question nobody asked. The cause is
+ * carried through verbatim — an `EACCES` and an `ENOENT` call for different
+ * responses, and flattening them to "could not read" throws that away.
+ */
+export declare function readBlob(fullPath: string, shownAs: string): Ruling<string>;
+/** How one front door names the tree verb and its single-file sibling. */
+export interface TreeNaming {
+    /** The whole-tree reader, as this surface spells it: `map`, `repo_map`. */
+    readonly tree: string;
+    /** Where to go for one file instead: `` `smelt <file>` ``, `smelt_file`. */
+    readonly file: string;
+}
+/**
+ * Law: **a tree reader reads a directory, and says so when handed a file.**
+ *
+ * Two distinct refusals, kept distinct: a path that cannot be statted at all
+ * (misspelled, unreadable) and a path that is a perfectly good *file*. The second is
+ * the interesting one — it is a caller who wanted the other verb, so the refusal
+ * names the other verb instead of leaving them to guess which of their two options
+ * was wrong.
+ */
+export declare function readTree(fullPath: string, shownAs: string, naming: TreeNaming): Ruling<string>;
+/**
+ * Law: **a store decision, opened.**
+ *
+ * The *decision* — which kind, and where — is `configuredStore()` in `cli/config.ts`,
+ * one reading of one config key. This is the other half: turning that decision into a
+ * live {@link ElisionStore}. It was the missing half. The MCP package needed exactly
+ * this and could not import it, so it re-derived the decision *and* the construction
+ * from the config keys directly, and a second reading of `store.kind` came into
+ * existence in another package.
+ *
+ * What each front door does with a memory store stays the front door's: `smelt
+ * retrieve` and `smelt stats` refuse one (a marker's hash from an earlier run names
+ * bytes no memory store ever held), while the MCP server accepts one and says so at
+ * the moment it bites. That divergence is deliberate and documented; it is a policy
+ * about a store, not a fact about opening one.
+ */
+export declare function openStore(decision: ConfiguredStore): ElisionStore;
+//# sourceMappingURL=inputs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inputs.d.ts","sourceRoot":"","sources":["../../src/ops/inputs.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAGpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH;;;;;;;GAOG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,IAClB;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9F,uFAAuF;AACvF,MAAM,WAAW,YAAY;IAC3B,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAM3D;AAED,0FAA0F;AAC1F,MAAM,MAAM,WAAW,GAAG,gBAAgB,GAAG,cAAc,CAAC;AAE5D;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAIlE;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,GAAG,MAAM,CAItF;AAED;;;;;GAKG;AACH,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvD,yFAAyF;AACzF,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE3D,wDAAwD;AACxD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;CACjC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,QAAQ,GAAG,SAAS,EAC5B,UAAU,EAAE,QAAQ,GAAG,SAAS,GAC/B,gBAAgB,CAIlB;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAM1E;AAED,0EAA0E;AAC1E,MAAM,WAAW,UAAU;IACzB,2EAA2E;IAC3E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,4EAA4E;IAC5E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,CAgB9F;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,eAAe,GAAG,YAAY,CAIjE","sourcesContent":["import { readFileSync, statSync } from 'node:fs';\n\nimport type { ConfiguredStore } from '../cli/config.ts';\nimport { DEFAULT_STRATEGY } from '../plan/planners.ts';\nimport type { Strategy } from '../plan/planners.ts';\nimport { MemoryElisionStore } from '../store.ts';\nimport { DirectoryElisionStore } from '../store-dir.ts';\nimport type { ElisionStore } from '../types.ts';\n\n/**\n * The laws an operation's input must satisfy — stated once, for every front door.\n *\n * Each rule here was, until this seam existed, written twice: once in a\n * `cli/subcommands/*` verb and once in the MCP server's tool handlers. Two copies of a\n * law is two laws, and the copies had already begun to differ — the `smelt` CLI and\n * the `smelt_file` tool refuse a missing budget with the same reasoning in two\n * separately-maintained sentences, and only one of them was ever edited at a time.\n *\n * **What is shared and what is not.** A law has two halves, and only one of them can\n * be shared honestly:\n *\n *   - the **rule and its reasoning** — that a budget is a whole number of bytes\n *     greater than zero, that there is no default and why, that a tree-reader refuses\n *     a file, that a strategy falls back to `lexical` last. That half lives here.\n *   - the **naming** — a CLI spells its budget `--budget` and points at\n *     `smelt.config.json`; a tool spells it `\"budgetBytes\"` and points at nothing.\n *     That half is the front door's own, and every function here takes it as an\n *     argument rather than guessing.\n *\n * Nothing here throws. The two front doors refuse in different currencies — the CLI\n * with a {@link CliUsageError} that exits 2, the MCP server with a tool-level error\n * carrying `isError: true` — and a shared law that threw would force one of them to\n * catch and re-wrap the other's error type, which is how an exit code changes by\n * accident. So a law that can refuse returns a {@link Ruling}: the value, or the one\n * sentence that refuses it, for the caller to throw in its own currency.\n *\n * Nothing here *finds* a `smelt.config.json` either. Config discovery is a CLI\n * concern by design (see `cli/config.ts`); {@link openStore} takes a decision that\n * has already been made and opens it, so no library call's behaviour depends on the\n * directory it was invoked from.\n */\n\n/**\n * The answer to a law that can refuse: the value, or the one sentence refusing it.\n *\n * Deliberately not an exception — see the module comment. The refusal is the\n * complete sentence *minus* whatever prefix the front door puts on its own errors\n * (`smelt: ` for the CLI, the tool name for MCP), because that prefix is naming, and\n * naming belongs to the caller.\n */\nexport type Ruling<T> =\n  { readonly ok: true; readonly value: T } | { readonly ok: false; readonly refusal: string };\n\n/** How one front door spells the budget it is refusing, and what it points at next. */\nexport interface BudgetNaming {\n  /** The knob, as this surface spells it: `--budget`, `\"budgetBytes\"`. */\n  readonly knob: string;\n  /**\n   * What a budget smelt invented would silently decide — the back half of the\n   * no-default sentence. `'your context to throw away'` for a blob run, `'the map to\n   * leave out'` for a tree.\n   */\n  readonly stake: string;\n  /**\n   * Anything this surface adds after the law: where else the value can come from, and\n   * an example. Appended after a single space. The CLI names `defaultBudgetBytes` and\n   * `smelt init` here; a tool whose schema already says `required` adds nothing.\n   */\n  readonly advice?: string;\n}\n\n/**\n * Law: **a budget is required, and there is no default.**\n *\n * The reasoning is the whole point of the sentence, so it is stated once here rather\n * than paraphrased per surface: a budget smelt invented would silently decide how much\n * of the caller's context to throw away, which is a number nobody measured making a\n * decision nobody made.\n */\nexport function budgetRequired(naming: BudgetNaming): string {\n  return (\n    `${naming.knob} is required, in UTF-8 bytes. There is no default, because a budget ` +\n    `smelt invented would silently decide how much of ${naming.stake}.` +\n    (naming.advice === undefined ? '' : ` ${naming.advice}`)\n  );\n}\n\n/** The two ways a budget that *was* given can still be wrong. See {@link budgetFault}. */\nexport type BudgetFault = 'not-an-integer' | 'not-positive';\n\n/**\n * Law: **a budget is a whole number of UTF-8 bytes greater than zero.**\n *\n * The numeric half only. Getting a candidate *number* out of a surface is that\n * surface's own lexing and stays there: argv carries strings (`--budget 4kb` is a\n * malformed number, and `-1` never reaches here because a leading `-` is not a\n * budget at all), while a JSON tool argument carries whatever type the model sent.\n * Both then ask this function the same question about the same rule.\n */\nexport function budgetFault(value: number): BudgetFault | undefined {\n  if (!Number.isInteger(value)) return 'not-an-integer';\n  if (value <= 0) return 'not-positive';\n  return undefined;\n}\n\n/**\n * The sentence for a {@link BudgetFault}, naming the value it rejected.\n *\n * `got` is rendered with `JSON.stringify`, which is what both front doors already\n * printed: a CLI passes the raw argv word and gets it back quoted (`\"4kb\"`), a tool\n * passes the raw JSON value and gets numbers bare (`0`) and strings quoted. One\n * renderer, because a value echoed back in a different shape than it was written is a\n * value the author has to translate before they can see their own typo.\n */\nexport function budgetMalformed(fault: BudgetFault, knob: string, got: unknown): string {\n  return fault === 'not-an-integer'\n    ? `${knob} must be a whole number of bytes, got ${JSON.stringify(got)}.`\n    : `${knob} must be greater than zero, got ${JSON.stringify(got)}.`;\n}\n\n/**\n * The strategy a run falls back to when neither the caller nor a config names one.\n *\n * Re-exported rather than restated: {@link DEFAULT_STRATEGY} is the planner registry's\n * own fact, and a second spelling here would be the fork this seam exists to close.\n */\nexport { DEFAULT_STRATEGY } from '../plan/planners.ts';\n\n/** Where a resolved strategy came from — the receipt {@link resolveStrategy} returns. */\nexport type StrategySource = 'flag' | 'config' | 'builtin';\n\n/** A strategy, with the provenance that explains it. */\nexport interface ResolvedStrategy {\n  readonly strategy: Strategy;\n  readonly source: StrategySource;\n}\n\n/**\n * Law: **an explicit strategy wins over a configured one, and `lexical` fills last.**\n *\n * Both front doors had this precedence written out, and both spelled the built-in\n * `'lexical'` inline — so a sixth planner promoted to the default would have been a\n * two-package edit with no compiler and no test to notice half of it. `chosen` is\n * whatever the caller said explicitly (a `--strategy` flag, a `\"strategy\"` argument);\n * `configured` is what the nearest `smelt.config.json` says. Validating the name is\n * *not* part of this law — membership in the `PLANNERS` registry (`isStrategy`) is\n * that, already shared, and the sentence each surface refuses an unknown name with is\n * its own register: a flag and a JSON argument do not read alike.\n */\nexport function resolveStrategy(\n  chosen: Strategy | undefined,\n  configured: Strategy | undefined,\n): ResolvedStrategy {\n  if (chosen !== undefined) return { strategy: chosen, source: 'flag' };\n  if (configured !== undefined) return { strategy: configured, source: 'config' };\n  return { strategy: DEFAULT_STRATEGY, source: 'builtin' };\n}\n\n/**\n * Law: **read a path, or fail naming it.**\n *\n * `shownAs` is the path as its author wrote it, which is not always the path opened:\n * a tool resolves a relative argument against the server's working directory, and\n * echoing back the absolute result would answer a question nobody asked. The cause is\n * carried through verbatim — an `EACCES` and an `ENOENT` call for different\n * responses, and flattening them to \"could not read\" throws that away.\n */\nexport function readBlob(fullPath: string, shownAs: string): Ruling<string> {\n  try {\n    return { ok: true, value: readFileSync(fullPath, 'utf8') };\n  } catch (cause) {\n    return { ok: false, refusal: `cannot read \"${shownAs}\": ${describe(cause)}` };\n  }\n}\n\n/** How one front door names the tree verb and its single-file sibling. */\nexport interface TreeNaming {\n  /** The whole-tree reader, as this surface spells it: `map`, `repo_map`. */\n  readonly tree: string;\n  /** Where to go for one file instead: `` `smelt <file>` ``, `smelt_file`. */\n  readonly file: string;\n}\n\n/**\n * Law: **a tree reader reads a directory, and says so when handed a file.**\n *\n * Two distinct refusals, kept distinct: a path that cannot be statted at all\n * (misspelled, unreadable) and a path that is a perfectly good *file*. The second is\n * the interesting one — it is a caller who wanted the other verb, so the refusal\n * names the other verb instead of leaving them to guess which of their two options\n * was wrong.\n */\nexport function readTree(fullPath: string, shownAs: string, naming: TreeNaming): Ruling<string> {\n  let isDirectory: boolean;\n  try {\n    isDirectory = statSync(fullPath).isDirectory();\n  } catch (cause) {\n    return { ok: false, refusal: `cannot read directory \"${shownAs}\": ${describe(cause)}` };\n  }\n  if (!isDirectory) {\n    return {\n      ok: false,\n      refusal:\n        `\"${shownAs}\" is not a directory. ${naming.tree} reads a whole tree; for one ` +\n        `file, use ${naming.file}.`,\n    };\n  }\n  return { ok: true, value: fullPath };\n}\n\n/**\n * Law: **a store decision, opened.**\n *\n * The *decision* — which kind, and where — is `configuredStore()` in `cli/config.ts`,\n * one reading of one config key. This is the other half: turning that decision into a\n * live {@link ElisionStore}. It was the missing half. The MCP package needed exactly\n * this and could not import it, so it re-derived the decision *and* the construction\n * from the config keys directly, and a second reading of `store.kind` came into\n * existence in another package.\n *\n * What each front door does with a memory store stays the front door's: `smelt\n * retrieve` and `smelt stats` refuse one (a marker's hash from an earlier run names\n * bytes no memory store ever held), while the MCP server accepts one and says so at\n * the moment it bites. That divergence is deliberate and documented; it is a policy\n * about a store, not a fact about opening one.\n */\nexport function openStore(decision: ConfiguredStore): ElisionStore {\n  return decision.kind === 'memory'\n    ? new MemoryElisionStore()\n    : new DirectoryElisionStore(decision.path);\n}\n\n/** A thrown cause as one line, without pretending an unknown throw was an Error. */\nfunction describe(cause: unknown): string {\n  return cause instanceof Error ? cause.message : String(cause);\n}\n"]}