@untangle-code/parser-registry 0.0.0-stage → 0.1.1

package/dist/languages/shared/table-profile.d.ts

@@ -0,0 +1,302 @@
+/**
+ * Das TABELLENGETRIEBENE Sprachprofil: eine Sprache kostet eine Tabelle,
+ * keinen Motor.
+ *
+ * Wofuer es da ist (WP-220): fuer jede Sprache, fuer die wir KEINE eigene
+ * Grammatik und keine handgeschriebenen Detektoren pflegen wollen. Der
+ * vereinheitlichte Walk (`engine.ts`) bleibt derselbe; nur die Bedeutung der
+ * Knotenarten kommt aus {@link LanguageKindTable} statt aus Fallunterscheidungen
+ * im Motor.
+ *
+ * WAS DIESE FASSUNG LEISTET — und was nicht. Sie deckt Symbole, Kommentare,
+ * Entscheidungen, Nesting, Halstead-Token, Importe und Aufrufe ab. Sie ist
+ * damit ausdruecklich SCHWAECHER als die handgeschriebene JS/TS-Fassung
+ * (`js-family-profile.ts`), und das steht hier, damit es niemand aus der
+ * Ausgabe erraten muss:
+ *
+ *   - Importbindungen (`RawImport.bindings`) liefert sie nur, wo die Tabelle
+ *     ein Aliasfeld nennt. Sonst FEHLT das Feld, statt eine Zuordnung zu
+ *     erfinden — der Vertrag in domain `analysis.ts` sagt ausdruecklich, dass
+ *     ein fehlendes Feld "unbekannt" heisst und Namensgleichheit kein Beweis ist.
+ *   - Der Aufrufqualifizierer kommt aus der Form des Aufrufziels, nicht aus
+ *     einer Namensaufloesung. `a.b.c()` liefert Qualifizierer `a.b`.
+ *   - `normalizedSignature` ist der Kopf bis zum Rumpf, mit den
+ *     Leerraumregeln aus `signature.ts`. Vorgabewerte werden NICHT entfernt
+ *     (das ist eine JS/TS-Regel und waere anderswo geraten).
+ *
+ * Wer eine dieser Grenzen fuer eine Sprache nicht hinnehmen will, schreibt fuer
+ * sie ein eigenes Profil — der Vertrag dafuer ist `profile.ts`, und der Motor
+ * merkt den Unterschied nicht.
+ */
+import type { SupportLevel } from "@untangle-code/domain";
+import type { LanguageProfile } from "./profile.js";
+import type { ScopeNode } from "./scope-model.js";
+import type { SyntaxNode } from "./syntax.js";
+/** Wie eine Knotenart zu einem Symbolscope wird. */
+export interface ScopeRule {
+    /** Knotenarten, die diesen Scope oeffnen. */
+    kinds: readonly string[];
+    scopeKind: ScopeNode["kind"];
+    /**
+     * Feld, das den Namen traegt (Vorgabe: `name`). Ein PUNKT trennt einen
+     * Feldpfad: Javas `field_declaration` fuehrt seinen Namen unter
+     * `declarator.name`, nicht unter `name`.
+     */
+    nameField?: string;
+    /**
+     * Feld mit dem TRAEGER, wenn die Sprache ihn nicht als Elternknoten fuehrt
+     * (WP-237). Gos `method_declaration` traegt `(a *A)` unter `receiver`; ohne
+     * diesen Zusatz heissen `(*A).Run` und `(*B).Run` beide `Run`.
+     */
+    qualifierField?: string;
+    /**
+     * Knotenarten, die im Traegerfeld den eigentlichen Namen tragen. Der erste
+     * Treffer in Quelltextreihenfolge gewinnt. Go nennt den Typ eines
+     * Empfaengers `type_identifier`; so bleibt auch `Pair[A, B]` strukturell
+     * `Pair`, ohne den Quelltext an Leerzeichen oder Klammern zu zerlegen.
+     */
+    qualifierNameKinds?: readonly string[];
+    /**
+     * Dem Namensfeld so lange weiter folgen, wie es weiterfuehrt. C schreibt
+     * `ring_t *ring_new(size_t)` als
+     * `function_definition.declarator -> pointer_declarator.declarator ->
+     * function_declarator.declarator -> identifier`; ohne diesen Abstieg hiesse
+     * jede zeigerwertige Funktion `*ring_new(...)`.
+     */
+    nameDescend?: boolean;
+    /**
+     * Kette von KINDKNOTENARTEN, die vor der Namenssuche abgestiegen wird.
+     * C# schreibt ein Feld als `field_declaration > variable_declaration >
+     * variable_declarator.name`, PHP als `property_declaration >
+     * property_element.name`. Ohne den Abstieg stuende der ganze Text im
+     * Namen (`"Dictionary<string, string> _items = new()"`).
+     */
+    nameKindPath?: readonly string[];
+    /** Ersatzweise: Kindknotenarten, deren Text der Name ist (erste Fundstelle). */
+    nameKinds?: readonly string[];
+    /**
+     * Nur dann ein Scope, wenn der ELTERNKNOTEN von dieser Art ist.
+     *
+     * WOFUER: Kotlin und Swift benutzen `property_declaration` sowohl fuer ein
+     * Klassenfeld als auch fuer eine LOKALE Variable in einem Funktionsrumpf.
+     * Ohne diese Schranke wuerde `var i = 0` mitten in einer Methode als Symbol
+     * gemeldet — eine falsche Aussage ueber die Datei, die in Hotspots,
+     * Ratsche und Risikobewertung einflosse.
+     */
+    parentKinds?: readonly string[];
+    /**
+     * Mindestens ein VORFAHRE muss von einer dieser Arten sein. Das grenzt
+     * syntaktisch identische Deklarationen nach ihrem Kontext ab: Rust verwendet
+     * `function_signature_item` sowohl in Traits als auch in `extern`-Bloecken,
+     * aber nur die Trait-Signatur ist eine Methode des analysierten Codes.
+     */
+    ancestorKinds?: readonly string[];
+    /**
+     * Namen, die diesen Scope zu einem Konstruktor machen (Java `<init>`,
+     * Rust `new`, ...). Leer heisst: nie ein Konstruktor.
+     */
+    constructorNames?: readonly string[];
+    /**
+     * Verfeinerung nach einem Kindknoten. Go kennt nur `type_spec`; ob daraus
+     * eine Klasse (`struct_type`), eine Schnittstelle (`interface_type`) oder ein
+     * Typalias wird, steht erst im Kind. Ohne diese Regel muesste die Tabelle
+     * luegen oder alles zu `type` einebnen.
+     */
+    refine?: readonly {
+        childKinds: readonly string[];
+        scopeKind: ScopeNode["kind"];
+    }[];
+}
+/** Entscheidungs- und Nesting-Regeln (spec.md §16.2–§16.4). */
+export interface DecisionRules {
+    ifKinds: readonly string[];
+    /**
+     * Elternknotenarten, die ein `if` zu einem `else if` machen (JS/Rust:
+     * `else_clause`, Go: `if_statement` selbst). Ohne Eintrag gibt es kein
+     * `else_if` — und die Zaehlung sagt das dann auch nicht.
+     */
+    elseIfParentKinds?: readonly string[];
+    /**
+     * Huellen, unter denen ein `if` nur dann eine Fortsetzung ist, wenn die
+     * Huelle unmittelbar auf ein anonymes `else`-Geschwister folgt. Kotlin
+     * bildet `else if` als `else > control_structure_body > if_expression` ab;
+     * ein `if` im Dann-Rumpf hat dieselbe Huelle, aber kein `else` davor.
+     */
+    elseIfWrapperKinds?: readonly string[];
+    /**
+     * Bereichssichere Korrektur fuer Grammatiken, die ein gueltiges
+     * `else /* Kommentar *\/ if` in Geschwister zerlegen und dabei das anonyme
+     * `else`-Token aus dem Baum verlieren. Aktiviert wird sie nur fuer die
+     * betroffene Sprache; erkannt wird ausschliesslich ein exaktes `else` im
+     * begrenzten Quelltextspalt zwischen zwei AST-Geschwistern.
+     */
+    recoverDetachedElseIfAfterComments?: boolean;
+    /**
+     * Knotenarten, die SELBST ein `else if` sind (Ruby `elsif`, PHP
+     * `else_if_clause`, Bash `elif_clause`). Anders als
+     * {@link DecisionRules.elseIfParentKinds} braucht es dafuer keinen Blick auf
+     * den Elternknoten — die Grammatik sagt es schon.
+     */
+    elseIfKinds?: readonly string[];
+    loopKinds: readonly string[];
+    catchKinds?: readonly string[];
+    /**
+     * Knotenarten, die eine vorzeitige Rueckkehr SIND (Swift `guard`). Die
+     * Guard-Erkennung ueber `consequenceField`/`jumpKinds` findet nur die
+     * `if`-Form; wo die Sprache ein eigenes Schluesselwort hat, steht es hier.
+     */
+    guardKinds?: readonly string[];
+    /**
+     * Musteralternativen (`Some(1) | Some(2)` in Rust) — `DecisionKind`
+     * `pattern_alternative`.
+     */
+    patternAlternativeKinds?: readonly string[];
+    /**
+     * Knotenarten, die einen KURZSCHLUSS darstellen, ohne ein Operatorfeld zu
+     * haben: Rusts `try_expression` (der `?`-Operator). Sie zaehlen wie ein
+     * logischer Operator NUR erweitert (spec.md §16.3), nie klassisch.
+     */
+    shortCircuitKinds?: readonly string[];
+    ternaryKinds?: readonly string[];
+    switchKinds?: readonly string[];
+    caseKinds?: readonly string[];
+    /**
+     * Ein `case`-Knoten mit einem DIREKTEN Kind dieser Art ist der
+     * Auffangzweig (`default:`) und zaehlt NICHT. Java und C fuehren `case X:`
+     * und `default:` unter DERSELBEN Knotenart; ohne diese Ausnahme bekaeme
+     * jeder `switch` eine Entscheidung zu viel.
+     */
+    caseExcludeChildKinds?: readonly string[];
+    /** Dasselbe ueber den Text des ersten Kindes (Bashs Auffangmuster `*)`). */
+    caseExcludeFirstChildText?: string;
+    /** Binaerausdruecke, deren Operator ueber `operatorField` erreichbar ist. */
+    binaryKinds?: readonly string[];
+    /**
+     * Knotenarten, deren Operator KEIN Feld ist, sondern das erste anonyme Kind.
+     * Kotlin (`conjunction_expression`), Swift (`disjunction_expression`) und
+     * Bash (`list` mit `&&`/`||`) vergeben dort keine Feldnamen.
+     */
+    anonymousOperatorKinds?: readonly string[];
+    operatorField?: string;
+    logicalAndOperators?: readonly string[];
+    logicalOrOperators?: readonly string[];
+    shortCircuitOperators?: readonly string[];
+    /** Sprunganweisungen fuer die Guard-Clause-Erkennung. */
+    jumpKinds?: readonly string[];
+    /** Rumpfhuellen, die fuer die Guard-Erkennung durchsichtig sind (Go: `block`+`statement_list`). */
+    blockKinds?: readonly string[];
+    consequenceField?: string;
+    alternativeField?: string;
+}
+/** Importregeln. */
+export interface ImportRules {
+    /** Anweisungsarten, die einen Import darstellen. */
+    kinds: readonly string[];
+    /** Untereintraege innerhalb der Anweisung (Go: `import_spec`). Leer: die Anweisung selbst. */
+    specKinds?: readonly string[];
+    /** Feld mit dem Pfad/Ziel (Go `path`, Rust `argument`). */
+    pathField?: string;
+    /** Ersatzweise: Knotenarten, deren Text der Pfad ist. */
+    pathKinds?: readonly string[];
+    /** Feld mit dem lokalen Namen (Alias), wenn die Sprache eines hat. */
+    aliasField?: string;
+    /**
+     * Auspacken zusammengesetzter Ziele. Rust schreibt
+     * `use a::b as c` (`use_as_clause`) und `use a::{b, c}` (`scoped_use_list`);
+     * ohne diese Regel stuende der ganze Ausdruck als "Pfad" im Ergebnis.
+     */
+    unwrap?: readonly {
+        kinds: readonly string[];
+        pathField: string;
+        aliasField?: string;
+        /** Feld mit der Namensliste; ihre BENANNTEN Kinder werden zu `importedNames`. */
+        namesField?: string;
+    }[];
+}
+/** Aufrufregeln. */
+export interface CallRules {
+    kinds: readonly string[];
+    /** Feld mit dem Aufrufziel (Vorgabe: `function`). */
+    functionField?: string;
+    /** Feld mit der Argumentliste (Vorgabe: `arguments`). */
+    argumentsField?: string;
+    /** Zugriffsformen `a.b` / `a::b`, aus denen Qualifizierer und Name entstehen. */
+    memberKinds?: readonly string[];
+    /**
+     * Feld mit dem EMPFAENGER, wenn die Sprache ihn getrennt fuehrt statt in
+     * einem Zugriffsknoten: Javas `method_invocation` hat `object` und `name`
+     * nebeneinander, Rubys `call` hat `receiver` und `method`. Ohne dieses Feld
+     * ginge der Qualifizierer dort verloren.
+     */
+    receiverField?: string;
+    /** Konstruktoraufrufe (`new X()`), falls die Sprache eine eigene Knotenart hat. */
+    constructionKinds?: readonly string[];
+    /** Feld mit dem Typ eines Konstruktoraufrufs. */
+    constructedTypeField?: string;
+    /**
+     * Zusaetzliche Bedingung, die ein Kandidat erfuellen muss.
+     *
+     * WOFUER: Swift benutzt `call_expression` AUCH fuer Indexzugriffe
+     * (`items["a"]`). Ohne Filter meldete der Adapter `items` als Aufrufziel —
+     * ein Aufruf, den es nicht gibt.
+     */
+    acceptCall?: (node: SyntaxNode) => boolean;
+}
+/** Die vollstaendige Tabelle einer Sprache. */
+export interface LanguageKindTable {
+    languageId: string;
+    extensions: readonly string[];
+    supportLevel: SupportLevel;
+    commentKinds: readonly string[];
+    /** Knoten, deren Teilbaum EIN Operand ist (Zeichenkettenliterale). */
+    stringContainerKinds: readonly string[];
+    identifierLeafKinds: readonly string[];
+    numberLeafKinds?: readonly string[];
+    booleanLeafKinds?: readonly string[];
+    nullLeafKinds?: readonly string[];
+    /** Satzzeichen, die weder Operator noch Operand sind (Vorgabe: {@link DEFAULT_PUNCTUATION}). */
+    punctuationKinds?: readonly string[];
+    scopes: readonly ScopeRule[];
+    decisions: DecisionRules;
+    imports: ImportRules;
+    calls: CallRules;
+    /** Elternknotenarten, in denen ein Bezeichner im Namensfeld eine Deklaration ist. */
+    declarationParentKinds: readonly string[];
+    /** Knotenarten, deren Text die Sichtbarkeit angibt (Rust `visibility_modifier`). */
+    visibilityKinds?: readonly string[];
+    /**
+     * Wenn der Sichtbarkeitsknoten ein SACK von Modifikatoren ist (Javas
+     * `modifiers` traegt `private final static` in EINEM Knoten): das erste
+     * Wort daraus, das in dieser Liste steht, ist die Sichtbarkeit. Ohne die
+     * Liste stuende `"private final"` im Ergebnis — eine Angabe, die kein
+     * Verbraucher vergleichen kann.
+     */
+    visibilityWords?: readonly string[];
+    /** Feld mit dem Rumpf — alles davor ist die Signatur (Vorgabe: `body`). */
+    bodyField?: string;
+    /**
+     * Ist dieser Name aus der Datei heraus sichtbar? Go entscheidet das am
+     * Grossbuchstaben, Rust am `pub`. Fehlt der Haken, meldet das Profil KEINE
+     * exportierten Namen — lieber nichts als eine erfundene Sichtbarkeit.
+     */
+    isExported?: (name: string, node: SyntaxNode) => boolean;
+    /**
+     * Feldnamen, die der ast-grep-Cursor am Elternknoten abfragen darf, um
+     * `currentFieldName` zu bestimmen (ast-grep kennt keine Umkehrrichtung,
+     * siehe `languages/astgrep-backend/syntax.ts`). Vorgabe: `["name"]`.
+     */
+    fieldNames?: readonly string[];
+}
+/** Satzzeichen, die in fast jeder Sprache reine Struktur sind. */
+export declare const DEFAULT_PUNCTUATION: readonly string[];
+/**
+ * Baut ein Profil aus vier kompilierten, unabhaengigen Verantwortungen.
+ *
+ * WP-239: Diese Funktion verdrahtet nur noch Tokens, Scopes, Entscheidungen
+ * und Modul-Fakten. Die jeweiligen Regeln leben in kleinen Resolvern mit
+ * eigener Zustandsmenge; der vorherige 500-Zeilen-Abschluss ist verschwunden.
+ */
+export declare function createTableProfile(table: LanguageKindTable): LanguageProfile;
+/** Die Feldnamen, die ein Backend ohne Feldnamen-Rueckrichtung abfragen muss. */
+export declare function fieldNamesOf(table: LanguageKindTable): readonly string[];
+//# sourceMappingURL=table-profile.d.ts.map

package/dist/languages/shared/table-profile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-profile.d.ts","sourceRoot":"","sources":["../../../src/languages/shared/table-profile.ts"],"names":[],"mappings":"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"}

package/dist/languages/shared/table-profile.js

@@ -0,0 +1,125 @@
+import { TableDecisionDetector } from "./table-profile-decisions.js";
+import { TableModuleFactCollector } from "./table-profile-module-facts.js";
+import { setOf } from "./table-profile-queries.js";
+import { TableScopeResolver } from "./table-profile-scopes.js";
+/** Satzzeichen, die in fast jeder Sprache reine Struktur sind. */
+export const DEFAULT_PUNCTUATION = [
+    "(",
+    ")",
+    "{",
+    "}",
+    "[",
+    "]",
+    ",",
+    ";",
+    ".",
+    ":",
+];
+/**
+ * Die Blattklassifikation ist eine eigene Verantwortung: Sie kennt weder
+ * Scopes noch Kontrollfluss, Importe oder Aufrufe.
+ */
+class TableTokenClassifier {
+    commentKinds;
+    literalContainerKinds;
+    identifierLeafKinds;
+    simpleLiteralLeafKinds;
+    punctuationKinds;
+    numberKinds;
+    booleanKinds;
+    nullKinds;
+    declarationParentKinds;
+    constructor(table) {
+        this.commentKinds = setOf(table.commentKinds);
+        this.literalContainerKinds = setOf(table.stringContainerKinds);
+        this.identifierLeafKinds = setOf(table.identifierLeafKinds);
+        this.numberKinds = setOf(table.numberLeafKinds);
+        this.booleanKinds = setOf(table.booleanLeafKinds);
+        this.nullKinds = setOf(table.nullLeafKinds);
+        this.simpleLiteralLeafKinds = new Set([
+            ...this.numberKinds,
+            ...this.booleanKinds,
+            ...this.nullKinds,
+        ]);
+        this.punctuationKinds = setOf(table.punctuationKinds ?? DEFAULT_PUNCTUATION);
+        this.declarationParentKinds = setOf(table.declarationParentKinds);
+    }
+    literalKindOf(kind) {
+        if (this.numberKinds.has(kind))
+            return "number";
+        if (this.booleanKinds.has(kind))
+            return "boolean";
+        if (this.nullKinds.has(kind))
+            return "null";
+        return "other";
+    }
+    identifierRoleOf(fieldName, parentKind) {
+        return fieldName === "name" && this.declarationParentKinds.has(parentKind)
+            ? "declaration"
+            : "reference";
+    }
+}
+function stringLiteralKind() {
+    return "string";
+}
+function neverSuppressScope() {
+    return false;
+}
+function noMemberRegions() {
+    return [];
+}
+/**
+ * Baut ein Profil aus vier kompilierten, unabhaengigen Verantwortungen.
+ *
+ * WP-239: Diese Funktion verdrahtet nur noch Tokens, Scopes, Entscheidungen
+ * und Modul-Fakten. Die jeweiligen Regeln leben in kleinen Resolvern mit
+ * eigener Zustandsmenge; der vorherige 500-Zeilen-Abschluss ist verschwunden.
+ */
+export function createTableProfile(table) {
+    const tokens = new TableTokenClassifier(table);
+    const scopes = new TableScopeResolver(table, tokens.commentKinds);
+    const decisions = new TableDecisionDetector(table.decisions, tokens.commentKinds);
+    const moduleFacts = new TableModuleFactCollector(table.imports, table.calls);
+    const needsNodeKinds = new Set([
+        ...scopes.nodeKinds,
+        ...decisions.nodeKinds,
+        ...moduleFacts.nodeKinds,
+    ]);
+    return {
+        languageId: table.languageId,
+        extensions: table.extensions,
+        supportLevel: table.supportLevel,
+        commentKinds: tokens.commentKinds,
+        literalContainerKinds: tokens.literalContainerKinds,
+        identifierLeafKinds: tokens.identifierLeafKinds,
+        simpleLiteralLeafKinds: tokens.simpleLiteralLeafKinds,
+        templateTextLeafKinds: new Set(),
+        ignoredPunctuationKinds: tokens.punctuationKinds,
+        typeKeywordParentKinds: new Set(),
+        functionLikeKinds: scopes.functionLikeKinds,
+        exportWrapperKinds: new Set(),
+        containerLiteralKind: stringLiteralKind,
+        simpleLiteralKind: tokens.literalKindOf.bind(tokens),
+        identifierRole: tokens.identifierRoleOf.bind(tokens),
+        needsNode: needsNodeKinds.has.bind(needsNodeKinds),
+        scopeKindOf: scopes.kindOf.bind(scopes),
+        suppressesScope: neverSuppressScope,
+        scopeName: scopes.nameOf.bind(scopes),
+        scopeQualifier: scopes.qualifierOf.bind(scopes),
+        scopeSignature: scopes.signatureOf.bind(scopes),
+        docRange: scopes.docRangeOf.bind(scopes),
+        visibility: scopes.visibilityOf.bind(scopes),
+        exportedNames: scopes.exportedNamesOf.bind(scopes),
+        detectDecisionAndNesting: decisions.detect.bind(decisions),
+        collectModuleFacts: moduleFacts.collect.bind(moduleFacts),
+        memberRegions: noMemberRegions,
+    };
+}
+/** Die Feldnamen, die ein Backend ohne Feldnamen-Rueckrichtung abfragen muss. */
+export function fieldNamesOf(table) {
+    const names = new Set(table.fieldNames ?? ["name"]);
+    for (const rule of table.scopes)
+        names.add(rule.nameField ?? "name");
+    return [...names];
+}
+//# sourceMappingURL=table-profile.js.map

package/dist/languages/shared/table-profile.js.map

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

package/dist/languages/shared/tree-sitter-types.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Thin type-only surface over the `tree-sitter` native binding.
+ *
+ * We import only types here (`import type`) — the actual native module is
+ * loaded lazily and dynamically at runtime via `grammar-loader.ts` using
+ * `createRequire`, never through a static `import` statement. That is what
+ * makes grammar loading lazy: requiring this file costs nothing at the
+ * native-addon level, only `loadGrammar()` does, and only for languages
+ * actually used.
+ */
+import type Parser from "tree-sitter";
+import type { SyntaxCursor, SyntaxNode } from "./syntax.js";
+export type TsSyntaxNode = Parser.SyntaxNode;
+/** Eine Parserinstanz mit gesetzter Grammatik (siehe `parse-limits.ts#parseWithBuffer`). */
+export type TsParser = Parser;
+export type TsTree = Parser.Tree;
+/**
+ * Der native Baumcursor (`tree.walk()` / `node.walk()`). Er haelt die
+ * Position IN der nativen Bibliothek; `gotoFirstChild`/`gotoNextSibling`/
+ * `gotoParent` verschieben sie, ohne je einen JS-Knotenwrapper zu bauen.
+ * Genau darum ist er der Traversierungsweg dieses Pakets (WP-95) — `.children`
+ * materialisiert je Knoten ein Array aus Wrappern.
+ */
+export type TsTreeCursor = Parser.TreeCursor;
+export type TsPoint = Parser.Point;
+export type TsParserCtor = typeof Parser;
+/** Opaque tree-sitter `Language` handle, as accepted by `Parser#setLanguage`. */
+export type TsLanguage = unknown;
+/**
+ * Die Zusage aus `syntax.ts`, hier festgenagelt: die NATIVEN tree-sitter-Formen
+ * erfuellen den backend-neutralen Baumvertrag STRUKTURELL. Kein Wrapper, kein
+ * Adapterobjekt, keine zusaetzliche Grenzueberquerung je Knoten — der Weg, den
+ * WP-95 saniert hat, bleibt genau so teuer wie vorher.
+ *
+ * Diese beiden Zuweisungen sind reine Typaussagen (`never` zur Laufzeit
+ * unbenutzt). Bricht eine kuenftige Aenderung an `syntax.ts` die Vertraglichkeit,
+ * scheitert der Typcheck HIER — und nicht erst an der Aufrufstelle, an der
+ * jemand versucht waere, sie mit einer Umtypung zu erschlagen.
+ */
+type AssertAssignable<Target, Source extends Target> = [Target, Source];
+export type TreeSitterSatisfiesSyntaxNode = AssertAssignable<SyntaxNode, TsSyntaxNode>;
+export type TreeSitterSatisfiesSyntaxCursor = AssertAssignable<SyntaxCursor, TsTreeCursor>;
+export {};
+//# sourceMappingURL=tree-sitter-types.d.ts.map

package/dist/languages/shared/tree-sitter-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-sitter-types.d.ts","sourceRoot":"","sources":["../../../src/languages/shared/tree-sitter-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AAEtC,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE5D,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,UAAU,CAAC;AAC7C,4FAA4F;AAC5F,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC;AAC9B,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC;AACjC;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,UAAU,CAAC;AAC7C,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC;AACnC,MAAM,MAAM,YAAY,GAAG,OAAO,MAAM,CAAC;AAEzC,iFAAiF;AACjF,MAAM,MAAM,UAAU,GAAG,OAAO,CAAC;AAEjC;;;;;;;;;;GAUG;AACH,KAAK,gBAAgB,CAAC,MAAM,EAAE,MAAM,SAAS,MAAM,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AACxE,MAAM,MAAM,6BAA6B,GAAG,gBAAgB,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;AACvF,MAAM,MAAM,+BAA+B,GAAG,gBAAgB,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC"}

package/dist/languages/shared/tree-sitter-types.js

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

package/dist/languages/shared/tree-sitter-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-sitter-types.js","sourceRoot":"","sources":["../../../src/languages/shared/tree-sitter-types.ts"],"names":[],"mappings":""}

package/dist/languages/structured-text/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * `LanguageAdapter` fuer strukturierte, verfasste Daten — JSON, YAML, TOML,
+ * XML (vision.md §1c, spec.md §7.1/§7.2, WP-217).
+ *
+ * DIE ENTSCHEIDUNG, DIE HIER GETROFFEN IST
+ *
+ * Bei der Selbstanalyse fielen 80 JSON-, 6 TOML-, 4 YAML- und 2 XML-Dateien
+ * unter `unsupported_language`. Dieser Grund war falsch: die Formate SIND
+ * unterstuetzt, sie haben nur keinen Graphen und keinen Kontrollfluss. Nach
+ * spec.md §7.2 gehoeren sie ausdruecklich in die Stufe `text`.
+ *
+ * Sie bekommen deshalb hier `text` — mit voller Suche und sicheren
+ * Textchunks. Eine `package.json`, eine `untangle.toml`, ein Manifest
+ * beantworten echte Fragen; sie aus dem Index zu halten waere ein Verlust.
+ *
+ * WAS SIE NICHT BEKOMMEN, UND WARUM DAS KEINE ABSTUFUNG IST
+ *
+ * - Keine Symbole und keine `symbolScopes`: ein Schluessel in einer
+ *   `package.json` ist kein Symbol mit Signatur, Callern und Callees. Ein
+ *   erfundenes Symbol waere schlimmer als keins.
+ * - Keine Komplexitaetszahlen: es gibt keine Entscheidungspunkte. Wer diese
+ *   Dateien in einer Metrikauswertung uebergeht, benennt das mit dem Grund
+ *   `no_metric_defined` (domain `skip-ledger.ts`) — nicht mit
+ *   `unsupported_language`, denn verstanden sind sie.
+ * - Auch KEINE Prosa-Metriken: eine YAML-Datei hat keine Abschnittstiefe im
+ *   Sinne von Ueberschriften und keine Verweisdichte im Sinne von
+ *   Querverweisen. Die Prosa-Familie ist fuer Prosa.
+ *
+ * WIE GESCHNITTEN WIRD
+ *
+ * Nur an Grenzen, die im Format EXAKT und ohne Parser bestimmbar sind:
+ *
+ * - TOML: eine Zeile, die (nach Leerraum) mit `[` beginnt, eroeffnet eine
+ *   neue Tabelle — das ist die Gliederung des Formats.
+ * - YAML: `---` trennt Dokumente in einem Strom.
+ *
+ * Fuer JSON und XML gibt es keine solche Grenze ohne echten Parser. Sie
+ * bekommen EINEN Bereich ueber die ganze Datei, den der Chunker bei Bedarf
+ * am Tokenbudget teilt. Das ist die ehrliche Antwort und ausdruecklich
+ * KEINE ueberschriftenbewusste Gliederung, wie Markdown sie bekommt — sie
+ * zu behaupten, wo das Format sie nicht hergibt, waere die Sorte
+ * Beschoenigung, die E4 verbietet.
+ */
+import type { LanguageAdapter } from "@untangle-code/domain";
+/** Sprachkennung dieses Adapters. Bewusst formatuebergreifend: die Behandlung ist dieselbe. */
+export declare const STRUCTURED_TEXT_LANGUAGE_ID = "structured-text";
+export declare function createStructuredTextAdapter(): LanguageAdapter;
+//# sourceMappingURL=index.d.ts.map

package/dist/languages/structured-text/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/languages/structured-text/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,OAAO,KAAK,EAKV,eAAe,EAOhB,MAAM,uBAAuB,CAAC;AAK/B,+FAA+F;AAC/F,eAAO,MAAM,2BAA2B,oBAAoB,CAAC;AAyC7D,wBAAgB,2BAA2B,IAAI,eAAe,CAyF7D"}