@wrtnlabs/evidence 0.0.0

package/lib/parsers/EvidenceLanguageRegistry.js

@@ -0,0 +1,652 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceLanguageRegistry = void 0;
+const EvidenceParserError_1 = require("./EvidenceParserError");
+/**
+ * Provides the pinned grammar catalog used to validate parser requests.
+ *
+ * The registry separates certified programming and database languages from
+ * researched candidates. Selecting a grammar validates both the configured type
+ * and the logical filename before any asset acquisition, so an overlapping
+ * extension cannot silently select another language's parser.
+ */
+var EvidenceLanguageRegistry;
+(function (EvidenceLanguageRegistry) {
+    /**
+     * Returns a copy of the certified programming-language catalog.
+     *
+     * Callers may present this metadata or inspect its grammar provenance without
+     * mutating the registry. A listed grammar has an Evidence adapter, but its
+     * presence does not mean its WASM asset has been acquired by a parser runtime.
+     */
+    function list() {
+        return structuredClone(LANGUAGES);
+    }
+    EvidenceLanguageRegistry.list = list;
+    /**
+     * Returns a copy of the certified database-language catalog.
+     *
+     * Database types remain separate from programming types because their adapters
+     * expose model, column, and relation semantics rather than lexical declarations.
+     * The copy preserves the registry as the authoritative certification boundary.
+     */
+    function databases() {
+        return structuredClone(DATABASES);
+    }
+    EvidenceLanguageRegistry.databases = databases;
+    /**
+     * Returns investigated language candidates that are not yet supported.
+     *
+     * Candidate records communicate grammar and adapter blockers to maintainers.
+     * They intentionally cannot be selected: publishing an unimplemented candidate
+     * as a language would imply an extraction boundary Evidence cannot enforce.
+     */
+    function candidates() {
+        return structuredClone(CANDIDATES);
+    }
+    EvidenceLanguageRegistry.candidates = candidates;
+    /**
+     * Selects the grammar registered for one configured type and logical filename.
+     *
+     * Filenames are matched after separator normalization and basename extraction;
+     * a grammar is returned as a copy so parser acquisition cannot alter catalog
+     * metadata. Unsupported types and extensions throw typed parser errors instead
+     * of guessing from a shared extension such as `.sql` or `.h`.
+     */
+    function select(type, file) {
+        const language = [...LANGUAGES, ...DATABASES].find((entry) => entry.type === type);
+        if (language === undefined)
+            throw new EvidenceParserError_1.EvidenceParserError("unsupported-language", file, `No registered grammar for ${type}. Add its grammar and Evidence adapter before selecting it.`);
+        const basename = file.replaceAll("\\", "/").split("/").pop() ?? "";
+        const grammar = language.grammars.find((entry) => entry.filenames.includes(basename) ||
+            entry.extensions.some((extension) => basename.endsWith(extension)));
+        if (grammar === undefined)
+            throw new EvidenceParserError_1.EvidenceParserError("unsupported-extension", file, `The selected file is not a recognized ${language.name} source. Correct its population type or file selection.`);
+        return structuredClone(grammar);
+    }
+    EvidenceLanguageRegistry.select = select;
+    const DATABASES = [
+        {
+            type: "sqlite",
+            name: "SQLite",
+            grammars: [
+                { id: "sqlite", extensions: [".sql", ".sqlite"], filenames: [] },
+            ],
+            adapter: {
+                entry: "EvidenceSqliteAdapter",
+                symbols: ["model", "column", "relation"],
+                publicSurface: "Explicit SQLite CREATE TABLE declarations, columns, and foreign keys across selected schema files.",
+                addressing: "File-qualified decoded source names with literal schema and table segments; case-insensitive schema identities are independent of files.",
+                comments: ["adjacent leading SQLite line and block comments"],
+                unsupported: [
+                    "runtime database inspection",
+                    "schema mutations",
+                    "virtual tables",
+                    "CREATE TABLE AS",
+                    "ATTACH and PRAGMA execution",
+                    "views and triggers",
+                ],
+            },
+        },
+        {
+            type: "postgresql",
+            name: "PostgreSQL",
+            grammars: [{ id: "sql", extensions: [".sql"], filenames: [] }],
+            adapter: {
+                entry: "EvidencePostgresqlAdapter",
+                symbols: ["model", "column", "relation"],
+                publicSurface: "Explicit schema-qualified PostgreSQL table declarations, columns, foreign keys, and additive ALTER declarations within the selected snapshot.",
+                addressing: "File-qualified schema and table segments; unquoted ASCII names fold to lowercase and quoted names remain literal.",
+                comments: ["adjacent SQL comments", "COMMENT ON TABLE or COLUMN"],
+                unsupported: [
+                    "search_path evaluation",
+                    "conditional DDL",
+                    "inheritance and partitioning",
+                    "LIKE, OF, and AS-derived schemas",
+                    "destructive ALTER",
+                    "executed migrations",
+                ],
+            },
+        },
+        {
+            type: "mysql",
+            name: "MySQL",
+            grammars: [{ id: "mysql", extensions: [".sql"], filenames: [] }],
+            adapter: {
+                entry: "EvidenceMysqlAdapter",
+                symbols: ["model", "column", "relation"],
+                publicSurface: "Explicit MySQL CREATE TABLE source declarations with column and table foreign-key ownership.",
+                addressing: "File-qualified, source-case database and table segments; endpoint-derived foreign-key segments.",
+                comments: ["adjacent SQL comments", "table and column COMMENT strings"],
+                unsupported: [
+                    "schema migrations",
+                    "dynamic SQL",
+                    "stored routines",
+                    "session modes",
+                    "generated columns",
+                    "views",
+                    "temporary tables",
+                    "named CONSTRAINT foreign keys",
+                ],
+            },
+        },
+        {
+            type: "bigquery",
+            name: "BigQuery GoogleSQL",
+            grammars: [
+                { id: "bigquery", extensions: [".sql", ".bqsql"], filenames: [] },
+            ],
+            adapter: {
+                entry: "EvidenceBigQueryAdapter",
+                symbols: ["model", "column", "relation"],
+                publicSurface: "Explicit GoogleSQL CREATE TABLE declarations, nested STRUCT and ARRAY fields, and declared NOT ENFORCED foreign keys.",
+                addressing: "File-qualified project.dataset.table paths with nested field segments and named or endpoint-derived foreign-key segments.",
+                comments: [
+                    "adjacent --, #, or block comments",
+                    "static OPTIONS description strings",
+                ],
+                unsupported: [
+                    "query-derived and external schemas",
+                    "conditional or replacing table definitions",
+                    "ALTER migrations",
+                    "runtime database state",
+                    "unsupported string escapes",
+                ],
+            },
+        },
+        {
+            type: "sql",
+            name: "Portable SQL",
+            grammars: [{ id: "sql", extensions: [".sql"], filenames: [] }],
+            adapter: {
+                entry: "EvidenceSqlAdapter",
+                symbols: ["model", "column", "relation"],
+                publicSurface: "Explicit CREATE TABLE declarations in the documented portable DDL subset.",
+                addressing: "Qualified table and column accessors; foreign keys use a literal endpoint-derived member segment.",
+                comments: ["adjacent -- or block documentation"],
+                unsupported: [
+                    "schema mutations",
+                    "query-derived tables",
+                    "dialect extensions",
+                    "runtime database discovery",
+                ],
+            },
+        },
+        {
+            type: "dbml",
+            name: "DBML",
+            grammars: [{ id: "dbml", extensions: [".dbml"], filenames: [] }],
+            adapter: {
+                entry: "EvidenceDbmlAdapter",
+                symbols: ["model", "column", "relation"],
+                publicSurface: "Selected DBML tables, scalar columns and inline/short/long named or composite relationships.",
+                addressing: "File-qualified schema/table/member addresses; public-schema shorthand and explicit table aliases retain one identity.",
+                comments: [
+                    "adjacent standalone // or block comments",
+                    "table and column notes",
+                ],
+                unsupported: [
+                    "reusable partials",
+                    "table groups",
+                    "module imports",
+                    "optional cardinality modifiers",
+                    "runtime schema discovery",
+                ],
+            },
+        },
+    ];
+    const LANGUAGES = [
+        {
+            type: "objc",
+            name: "Objective-C",
+            grammars: [{ id: "objc", extensions: [".m", ".h"], filenames: [] }],
+            adapter: {
+                entry: "EvidenceObjcAdapter",
+                symbols: ["type", "function", "property"],
+                publicSurface: "Explicit interfaces, protocols, named categories, public ivars, properties and external C functions in the selected Objective-C snapshot.",
+                addressing: "File-qualified nominal owners; protocols and categories use quoted names, and method selectors retain their + or - prefix and all colons.",
+                comments: ["attached Doxygen"],
+                unsupported: [
+                    "Objective-C++",
+                    "conditional compilation",
+                    "macro expansion",
+                    "include traversal",
+                    "external C data and aggregate types",
+                    "compatibility aliases",
+                    "inherited and synthesized declarations",
+                ],
+            },
+        },
+        {
+            type: "lua",
+            name: "Lua",
+            grammars: [{ id: "lua", extensions: [".lua"], filenames: [] }],
+            adapter: {
+                entry: "EvidenceLuaAdapter",
+                symbols: ["function", "property"],
+                publicSurface: "Explicit globals and statically returned module tables with literal fields and resolved local aliases.",
+                addressing: "File-qualified globals and module fields; tables are properties and dot/colon methods share literal field accessors.",
+                comments: ["adjacent --- LuaDoc", "adjacent long Lua comments"],
+                unsupported: [
+                    "dynamic table mutation",
+                    "shared values with distinct table owners",
+                    "metatables",
+                    "require loader evaluation",
+                    "computed and numeric keys",
+                    "conditional initialization",
+                    "escaped field names",
+                ],
+            },
+        },
+        {
+            type: "dart",
+            name: "Dart",
+            grammars: [{ id: "dart", extensions: [".dart"], filenames: [] }],
+            adapter: {
+                entry: "EvidenceDartAdapter",
+                symbols: ["type", "function", "property"],
+                publicSurface: "Explicit public Dart declarations across selected defining libraries, reciprocal parts, and static relative exports.",
+                addressing: "File-qualified library names and lexical members, with part and show/hide export aliases sharing semantic identity.",
+                comments: ["attached /// or /** */ Dart documentation"],
+                unsupported: [
+                    "package and SDK export URIs",
+                    "conditional exports",
+                    "augmentation",
+                    "inherited or generated members absent from selected source",
+                ],
+            },
+        },
+        {
+            type: "zig",
+            name: "Zig",
+            grammars: [{ id: "zig", extensions: [".zig"], filenames: [] }],
+            adapter: {
+                entry: "EvidenceZigAdapter",
+                symbols: ["type", "function", "property"],
+                publicSurface: "Explicit pub declarations and fields of public containers recognized by tree-sitter-zig v1.1.2 (Zig 0.14 syntax).",
+                addressing: "File-qualified lexical container paths; bounded same-container aliases share canonical source identities.",
+                comments: ["attached /// documentation"],
+                unsupported: [
+                    "namespace imports and usingnamespace",
+                    "namespace comptime execution",
+                    "type-producing and dependent generic return types",
+                    "inferred conditional and call-produced public surfaces",
+                    "anonymous aggregate values and computed declaration types",
+                    "Zig-specific quoted identifier escapes",
+                    "empty container grammar forms",
+                    "build and generated-source execution",
+                ],
+            },
+        },
+        {
+            type: "php",
+            name: "PHP",
+            grammars: [{ id: "php", extensions: [".php"], filenames: [] }],
+            adapter: {
+                entry: "EvidencePhpAdapter",
+                symbols: ["type", "function", "property"],
+                publicSurface: "Explicit namespace declarations and public members in tagged PHP source recognized by tree-sitter-php v0.24.2.",
+                addressing: "File-qualified namespace and owner segments; properties retain their leading dollar sign; constants and methods do not.",
+                comments: ["attached PHPDoc"],
+                unsupported: [
+                    "tagless PHP-only input",
+                    "trait composition",
+                    "conditional declarations",
+                    "runtime includes and autoload discovery",
+                    "dynamic declaration generation",
+                    "inherited and generated members",
+                ],
+            },
+        },
+        {
+            type: "scala",
+            name: "Scala",
+            grammars: [{ id: "scala", extensions: [".scala"], filenames: [] }],
+            adapter: {
+                entry: "EvidenceScalaAdapter",
+                symbols: ["type", "function", "property"],
+                publicSurface: "Explicit unrestricted Scala 2/3 declarations recognized by tree-sitter-scala v0.26.2 within the selected source snapshot.",
+                addressing: "File-qualified package and lexical owner paths; singleton objects and package objects have explicit quoted owner segments.",
+                comments: ["attached Scaladoc"],
+                unsupported: [
+                    "anonymous givens",
+                    "wildcard and unresolved exports",
+                    "inherited and synthesized members",
+                    "macro expansion",
+                    "derives and uses clauses",
+                    "extractor binding patterns",
+                ],
+            },
+        },
+        {
+            type: "matlab",
+            name: "MATLAB",
+            grammars: [{ id: "matlab", extensions: [".m"], filenames: [] }],
+            adapter: {
+                entry: "EvidenceMatlabAdapter",
+                symbols: ["type", "function", "property"],
+                publicSurface: "Explicit textual MATLAB classdef and primary function declarations with class-folder ownership.",
+                addressing: "File-qualified package and class segments; accessors merge with declared properties and external methods with class ownership.",
+                comments: ["attached percent-line help comments"],
+                unsupported: [
+                    "runtime path mutation",
+                    "dynamic properties",
+                    "legacy classes",
+                    "inherited or generated declarations",
+                    "Octave extensions",
+                    "binary and live scripts",
+                ],
+            },
+        },
+        {
+            type: "swift",
+            name: "Swift",
+            grammars: [{ id: "swift", extensions: [".swift"], filenames: [] }],
+            adapter: {
+                entry: "EvidenceSwiftAdapter",
+                symbols: ["type", "function", "property"],
+                publicSurface: "Explicit public/open declarations in one selected Swift module, including local nominal extensions and protocol requirements.",
+                addressing: "File-qualified lexical owners; overloads group by base name and static members add a static segment.",
+                comments: ["attached DocC /// and /** */"],
+                unsupported: [
+                    "external extension ownership",
+                    "constrained extensions",
+                    "macro and custom attribute expansion",
+                    "conditional compilation",
+                    "compiler-generated and inherited members",
+                ],
+            },
+        },
+        {
+            type: "kotlin",
+            name: "Kotlin",
+            grammars: [{ id: "kotlin", extensions: [".kt"], filenames: [] }],
+            adapter: {
+                entry: "EvidenceKotlinAdapter",
+                symbols: ["type", "function", "property"],
+                publicSurface: "Explicit public Kotlin source declarations recognized by tree-sitter-kotlin v1.1.0 within the selected snapshot.",
+                addressing: "File-qualified lexical owners, explicit companions, and receiver-qualified extension segments.",
+                comments: ["attached KDoc"],
+                unsupported: [
+                    "scripts",
+                    "multiplatform expect/actual",
+                    "delegated members",
+                    "implicit override visibility",
+                    "generic and unresolved extension receivers",
+                    "compiler-generated and inherited members",
+                ],
+            },
+        },
+        {
+            type: "typescript",
+            name: "TypeScript",
+            grammars: [
+                {
+                    id: "typescript",
+                    extensions: [".ts", ".cts", ".mts"],
+                    filenames: [],
+                },
+                { id: "tsx", extensions: [".tsx"], filenames: [] },
+            ],
+            adapter: {
+                entry: "EvidenceTypeScriptAdapter",
+                symbols: ["type", "function", "property"],
+                publicSurface: "Static TypeScript module exports and declaration files within the selected snapshot.",
+                addressing: "File-qualified export accessors; instance members include prototype while static members do not.",
+                comments: ["JSDoc"],
+                unsupported: [
+                    "package exports",
+                    "path aliases",
+                    "ambient modules",
+                    "global augmentations",
+                    "CommonJS export assignment",
+                ],
+            },
+        },
+        {
+            type: "javascript",
+            name: "JavaScript",
+            grammars: [
+                {
+                    id: "javascript",
+                    extensions: [".js", ".jsx", ".cjs", ".mjs"],
+                    filenames: [],
+                },
+            ],
+            adapter: {
+                entry: "EvidenceJavaScriptAdapter",
+                symbols: ["type", "function", "property"],
+                publicSurface: "Static ESM exports and bounded CommonJS initialization.",
+                addressing: "File-qualified export accessors; instance members include prototype while static members do not.",
+                comments: ["JSDoc"],
+                unsupported: [
+                    "dynamic CommonJS exports",
+                    "computed CommonJS keys",
+                    "unsafe CommonJS aliases",
+                ],
+            },
+        },
+        {
+            type: "python",
+            name: "Python",
+            grammars: [{ id: "python", extensions: [".py", ".pyi"], filenames: [] }],
+            adapter: {
+                entry: "EvidencePythonAdapter",
+                symbols: ["type", "function", "property"],
+                publicSurface: "Statically declared Python module exports with bounded local import and __all__ resolution.",
+                addressing: "File-qualified module accessors; instance members include prototype while class members do not.",
+                comments: ["docstring", "adjacent # comment"],
+                unsupported: [
+                    "executed module discovery",
+                    "dynamic __all__ mutation",
+                    "decorator-generated members",
+                    "metaclass-generated members",
+                ],
+            },
+        },
+        {
+            type: "go",
+            name: "Go",
+            grammars: [{ id: "go", extensions: [".go"], filenames: [] }],
+            adapter: {
+                entry: "EvidenceGoAdapter",
+                symbols: ["type", "function", "property"],
+                publicSurface: "Selected exported Go package declarations with package-wide receiver ownership.",
+                addressing: "File-qualified package declarations with receiver and interface members under their owner type.",
+                comments: ["adjacent // or block documentation comment"],
+                unsupported: [
+                    "GOOS and GOARCH evaluation",
+                    "promoted members",
+                    "dependency-derived members",
+                    "generated declarations absent from selected source",
+                ],
+            },
+        },
+        {
+            type: "rust",
+            name: "Rust",
+            grammars: [{ id: "rust", extensions: [".rs"], filenames: [] }],
+            adapter: {
+                entry: "EvidenceRustAdapter",
+                symbols: ["type", "function", "property"],
+                publicSurface: "Selected Rust crate modules, public reexports, and local nominal impl members.",
+                addressing: "File-qualified public paths; trait implementations add an explicit quoted impl segment.",
+                comments: ["outer or inner documentation", "static doc attribute"],
+                unsupported: [
+                    "Cargo feature evaluation",
+                    "macro expansion",
+                    "custom module paths",
+                    "external type ownership",
+                    "generated declarations absent from selected source",
+                ],
+            },
+        },
+        {
+            type: "java",
+            name: "Java",
+            grammars: [{ id: "java", extensions: [".java"], filenames: [] }],
+            adapter: {
+                entry: "EvidenceJavaAdapter",
+                symbols: ["type", "function", "property"],
+                publicSurface: "Java source-public declarations recognized by tree-sitter-java v0.23.5, independent of JPMS exports.",
+                addressing: "File-qualified top-level and nested type accessors with methods grouped by owner and name.",
+                comments: ["attached Javadoc"],
+                unsupported: [
+                    "JPMS package export enforcement",
+                    "annotation processor execution",
+                    "compiler-generated record and enum methods",
+                    "inherited members",
+                    "generated declarations absent from selected source",
+                ],
+            },
+        },
+        {
+            type: "csharp",
+            name: "C#",
+            grammars: [{ id: "c-sharp", extensions: [".cs"], filenames: [] }],
+            adapter: {
+                entry: "EvidenceCSharpAdapter",
+                symbols: ["type", "function", "property"],
+                publicSurface: "C# source-public declarations recognized by tree-sitter-c-sharp v0.23.5 within one configured source snapshot.",
+                addressing: "File-qualified namespace and owner accessors with quoted segments for generic arity, indexers, and operators.",
+                comments: ["attached /// or /** */ XML documentation"],
+                unsupported: [
+                    "conditional-compilation evaluation",
+                    "explicit interface implementation units",
+                    "source-generator execution",
+                    "compiler-generated record members",
+                    "inherited members",
+                ],
+            },
+        },
+        {
+            type: "c",
+            name: "C",
+            grammars: [{ id: "c", extensions: [".c", ".h"], filenames: [] }],
+            adapter: {
+                entry: "EvidenceCAdapter",
+                symbols: ["type", "function", "property"],
+                publicSurface: "Explicit external declarations, tags, typedefs, aggregate fields, and enumerators recognized by tree-sitter-c v0.24.2 within each selected physical file.",
+                addressing: "File-qualified declarations with exact quoted tag names and unambiguous typedef or source-name aliases.",
+                comments: ["attached Doxygen"],
+                unsupported: [
+                    "preprocessor branch evaluation",
+                    "macro expansion",
+                    "include traversal",
+                    "linker export policy",
+                    "generated declarations absent from selected source",
+                ],
+            },
+        },
+        {
+            type: "cpp",
+            name: "C++",
+            grammars: [
+                {
+                    id: "cpp",
+                    extensions: [
+                        ".cpp",
+                        ".cc",
+                        ".cxx",
+                        ".c++",
+                        ".C",
+                        ".h",
+                        ".hpp",
+                        ".hh",
+                        ".hxx",
+                        ".h++",
+                        ".H",
+                        ".ipp",
+                        ".tpp",
+                        ".ixx",
+                        ".cppm",
+                        ".ccm",
+                        ".cxxm",
+                        ".c++m",
+                    ],
+                    filenames: [],
+                },
+            ],
+            adapter: {
+                entry: "EvidenceCppAdapter",
+                symbols: ["type", "function", "property"],
+                publicSurface: "Explicit namespaces, public types and members, external declarations, templates, and bounded aliases recognized by tree-sitter-cpp v0.23.4 across the selected snapshot.",
+                addressing: "File-qualified namespace and owner accessors with quoted segments for template arity and operators.",
+                comments: ["attached Doxygen"],
+                unsupported: [
+                    "preprocessor branch evaluation",
+                    "macro expansion",
+                    "include traversal",
+                    "template specialization and instantiation",
+                    "inheritance and friend lookup",
+                    "modules and linker visibility",
+                ],
+            },
+        },
+        {
+            type: "ruby",
+            name: "Ruby",
+            grammars: [
+                {
+                    id: "ruby",
+                    extensions: [".rb", ".rake", ".gemspec"],
+                    filenames: ["Gemfile", "Rakefile"],
+                },
+            ],
+            adapter: {
+                entry: "EvidenceRubyAdapter",
+                symbols: ["type", "function", "property"],
+                publicSurface: "Explicit classes and modules, public instance and singleton methods, constants, literal attributes, bounded aliases, and reopenings recognized by tree-sitter-ruby v0.23.1 across the selected snapshot.",
+                addressing: "File-qualified constant paths; instance members use their owner directly and singleton members add self.",
+                comments: ["adjacent Ruby line or embedded RDoc comments"],
+                unsupported: [
+                    "runtime load order",
+                    "dynamic method and constant generation",
+                    "mixin and refinement expansion",
+                    "eval-created declarations",
+                    "inherited members",
+                ],
+            },
+        },
+    ];
+    const CANDIDATES = [
+        {
+            id: "vue",
+            name: "Vue single-file component",
+            kind: "embedded-format",
+            dialects: ["Vue SFC"],
+            grammarRepository: "https://github.com/tree-sitter-grammars/tree-sitter-vue",
+            grammarLicense: "MIT",
+            wasm: "source-build",
+            wasmNotes: "No upstream release is published; build WASM from a pinned source commit with the Tree-sitter CLI.",
+            languageReference: "https://vuejs.org/api/sfc-spec.html",
+            visibility: "component contracts combine script/module exports, script setup macros, template bindings, styles, and custom blocks",
+            declarations: "embedded JavaScript/TypeScript regions, component options, defineProps/defineEmits macros, templates, styles, and custom blocks",
+            blockers: [
+                "embedded regions require offset-preserving extraction",
+                "script setup macros need Vue semantics",
+                "template and style grammars do not share a programming-symbol model",
+            ],
+            next: "Implement source-region extraction and mapped host coordinates before delegating script blocks to JavaScript or TypeScript adapters.",
+        },
+        {
+            id: "svelte",
+            name: "Svelte component",
+            kind: "embedded-format",
+            dialects: ["Svelte component"],
+            grammarRepository: "https://github.com/sveltejs/tree-sitter-svelte",
+            grammarLicense: "MIT",
+            wasm: "source-build",
+            wasmNotes: "No upstream release is published; build WASM from a pinned source commit with the Tree-sitter CLI.",
+            languageReference: "https://svelte.dev/docs/svelte/svelte-files",
+            visibility: "component contracts combine module/instance scripts, exported props or runes, markup, styles, and compiler-generated bindings",
+            declarations: "embedded JavaScript/TypeScript regions, component props, module exports, markup, styles, and compiler directives",
+            blockers: [
+                "embedded regions require offset-preserving extraction",
+                "Svelte version semantics change component exports",
+                "compiler-generated bindings are not explicit syntax declarations",
+            ],
+            next: "Implement source-region extraction and mapped host coordinates before delegating script blocks to JavaScript or TypeScript adapters.",
+        },
+    ];
+})(EvidenceLanguageRegistry || (exports.EvidenceLanguageRegistry = EvidenceLanguageRegistry = {}));