@wrtnlabs/evidence 0.0.0 → 0.1.0

package/lib/parsers/EvidenceParseSession.js

@@ -3,24 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EvidenceParseSession = void 0;
 const web_tree_sitter_1 = require("web-tree-sitter");
 const EvidenceParserError_1 = require("./EvidenceParserError");
-const TreeSitterRange_1 = require("../internal/TreeSitterRange");
+const EvidenceTreeSitterRange_1 = require("../internal/EvidenceTreeSitterRange");
 /**
- * Borrows one syntax tree and owns its query cache during an extraction callback.
+ * Borrows one syntax tree and owns its query cache during an extraction
+ * callback.
  *
- * `EvidenceParser.parse` creates the session after verifying syntax completeness
- * and disposes it before releasing the tree. Adapters can traverse `root`, query
- * captures or matches, and convert nodes into serializable ranges. Nodes and
- * query results remain borrowed; only copied names, ranges, and relationships
- * may survive the callback.
+ * `EvidenceParser.parse` creates the session after verifying syntax
+ * completeness and disposes it before releasing the tree. Adapters can traverse
+ * `root`, query captures or matches, and convert nodes into serializable
+ * ranges. Nodes and query results remain borrowed; only copied names, ranges,
+ * and relationships may survive the callback.
  *
  * Every operation checks lifetime and node ownership. A query that cannot be
  * compiled, needs unsupported external predicates, or exceeds its match limit
  * rejects extraction rather than supplying an apparently complete subset.
  *
  * @example
- * // Inside EvidenceParser.parse's callback:
- * const range: IEvidenceSourceRange = session.range(session.root);
- * // Return range, not session.root: the range is data, while the node is borrowed.
+ *   // Inside EvidenceParser.parse's callback:
+ *   const range: IEvidenceSourceRange = session.range(session.root);
+ *   // Return range, not session.root: the range is data, while the node is borrowed.
  */
 class EvidenceParseSession {
     tree;
@@ -35,8 +36,9 @@ class EvidenceParseSession {
     /**
      * Compiled queries owned by this session, keyed by exact query source.
      *
-     * Repeated extraction queries reuse their compiled form. The cache is released
-     * before the runtime deletes the tree and cannot be shared across sessions.
+     * Repeated extraction queries reuse their compiled form. The cache is
+     * released before the runtime deletes the tree and cannot be shared across
+     * sessions.
      */
     queries = new Map();
     /**
@@ -69,7 +71,8 @@ class EvidenceParseSession {
      * Returns the borrowed root node while the session remains open.
      *
      * Traversal is valid only within the parse callback. Access after disposal
-     * throws a session-closed error instead of exposing an already released tree.
+     * throws a session-closed error instead of exposing an already released
+     * tree.
      */
     get root() {
         this.assertOpen();
@@ -78,19 +81,21 @@ class EvidenceParseSession {
     /**
      * Copies a session-owned node's source coordinates into a serializable range.
      *
-     * The range can safely escape the callback. Foreign-tree nodes and calls after
-     * disposal reject before coordinate conversion, preserving source ownership.
+     * The range can safely escape the callback. Foreign-tree nodes and calls
+     * after disposal reject before coordinate conversion, preserving source
+     * ownership.
      */
     range(node) {
         this.assertNode(node);
-        return TreeSitterRange_1.TreeSitterRange.from(node);
+        return EvidenceTreeSitterRange_1.EvidenceTreeSitterRange.from(node);
     }
     /**
      * Runs a query and returns its flattened borrowed captures.
      *
-     * Omit `node` to query the full root. A supplied node must belong to this tree.
-     * Compilation failures, unsupported predicates, and match-limit truncation
-     * throw, since incomplete captures cannot establish a public population.
+     * Omit `node` to query the full root. A supplied node must belong to this
+     * tree. Compilation failures, unsupported predicates, and match-limit
+     * truncation throw, since incomplete captures cannot establish a public
+     * population.
      */
     captures(source, node) {
         const target = node ?? this.root;
@@ -104,8 +109,9 @@ class EvidenceParseSession {
      * Runs a query while retaining captures grouped by their matching pattern.
      *
      * Use matches when ownership depends on captures belonging to the same syntax
-     * occurrence. The default target is the root; ownership and completeness checks
-     * are the same as for `captures`, and returned nodes remain callback-scoped.
+     * occurrence. The default target is the root; ownership and completeness
+     * checks are the same as for `captures`, and returned nodes remain
+     * callback-scoped.
      */
     matches(source, node) {
         const target = node ?? this.root;
@@ -118,8 +124,9 @@ class EvidenceParseSession {
     /**
      * Closes the session and releases its compiled queries once.
      *
-     * The runtime calls this before deleting the separately owned tree. Marking the
-     * session closed first prevents later API calls from accessing borrowed nodes.
+     * The runtime calls this before deleting the separately owned tree. Marking
+     * the session closed first prevents later API calls from accessing borrowed
+     * nodes.
      *
      * @internal
      */
@@ -135,8 +142,9 @@ class EvidenceParseSession {
      * Compiles or reuses a query whose semantics the binding can fully evaluate.
      *
      * External and property predicates are refused before caching. Treating them
-     * as ignored filters would return incorrect captures while claiming a complete
-     * inventory; failed queries are deleted and reported against the source file.
+     * as ignored filters would return incorrect captures while claiming a
+     * complete inventory; failed queries are deleted and reported against the
+     * source file.
      */
     query(source) {
         let query = this.queries.get(source);

package/lib/parsers/EvidenceParser.d.ts

@@ -4,12 +4,13 @@ import type { IEvidenceParserInput } from "../structures/IEvidenceParserInput";
 import type { IEvidenceParserOptions } from "../structures/IEvidenceParserOptions";
 import type { IEvidenceParserState } from "../structures/IEvidenceParserState";
 /**
- * Owns bounded Tree-sitter parse sessions with lazy, verified grammar acquisition.
+ * Owns bounded Tree-sitter parse sessions with lazy, verified grammar
+ * acquisition.
  *
- * Create a parser for a group of source extractions, call `parse` for each file,
- * then await `close`. Grammar selection uses the configured artifact and filename;
- * acquisition starts only when that grammar is needed. Construction and metadata
- * inspection do not initialize a language or parse source.
+ * Create a parser for a group of source extractions, call `parse` for each
+ * file, then await `close`. Grammar selection uses the configured artifact and
+ * filename; acquisition starts only when that grammar is needed. Construction
+ * and metadata inspection do not initialize a language or parse source.
  *
  * Each request owns a native parser and tree. Its callback receives a borrowed
  * session only after syntax completeness is established, and must return data
@@ -17,21 +18,25 @@ import type { IEvidenceParserState } from "../structures/IEvidenceParserState";
  * during asynchronous callback work, so a callback must not await another parse
  * or close on the same pool: that work can wait for the callback's own slot.
  *
- * Cleanup runs for successful extraction and every failure path. Closing rejects
- * new requests and waits for accepted callbacks; immutable process-wide grammar
- * data can remain cached for later runtimes.
+ * Cleanup runs for successful extraction and every failure path. Closing
+ * rejects new requests and waits for accepted callbacks; immutable process-wide
+ * grammar data can remain cached for later runtimes.
  *
  * @example
- * const parser: EvidenceParser = new EvidenceParser({ concurrency: 2 });
- * try {
- *   const range: IEvidenceSourceRange = await parser.parse(
- *     { type: "typescript", file: "api.ts", content: "export const value = 1;" },
- *     (session: EvidenceParseSession): IEvidenceSourceRange =>
- *       session.range(session.root),
- *   );
- * } finally {
- *   await parser.close();
- * }
+ *   const parser: EvidenceParser = new EvidenceParser({ concurrency: 2 });
+ *   try {
+ *     const range: IEvidenceSourceRange = await parser.parse(
+ *       {
+ *         type: "typescript",
+ *         file: "api.ts",
+ *         content: "export const value = 1;",
+ *       },
+ *       (session: EvidenceParseSession): IEvidenceSourceRange =>
+ *         session.range(session.root),
+ *     );
+ *   } finally {
+ *     await parser.close();
+ *   }
  */
 export declare class EvidenceParser {
     /**
@@ -44,8 +49,9 @@ export declare class EvidenceParser {
     /**
      * Admission queue and lifecycle boundary for parse callbacks.
      *
-     * A slot covers acquisition, parsing, and the callback's asynchronous lifetime.
-     * Closing this queue prevents new work before native resources are discarded.
+     * A slot covers acquisition, parsing, and the callback's asynchronous
+     * lifetime. Closing this queue prevents new work before native resources are
+     * discarded.
      */
     private readonly slots;
     /**
@@ -65,8 +71,9 @@ export declare class EvidenceParser {
     /**
      * Creates a lazy parser pool with a bounded callback count.
      *
-     * The default permits four active requests. Options are validated immediately,
-     * but grammar acquisition and native parser allocation wait for `parse`.
+     * The default permits four active requests. Options are validated
+     * immediately, but grammar acquisition and native parser allocation wait for
+     * `parse`.
      */
     constructor(options?: IEvidenceParserOptions);
     /**
@@ -80,12 +87,14 @@ export declare class EvidenceParser {
     /**
      * Reports admission state and successfully loaded grammar IDs.
      *
-     * Reading state does not acquire assets or wait for pending parses. The returned
-     * counts describe this pool; the language list records its successful loads.
+     * Reading state does not acquire assets or wait for pending parses. The
+     * returned counts describe this pool; the language list records its
+     * successful loads.
      */
     state(): IEvidenceParserState;
     /**
-     * Extracts data from a complete syntax tree within a borrowed callback session.
+     * Extracts data from a complete syntax tree within a borrowed callback
+     * session.
      *
      * Syntax errors, missing nodes, and incompatible grammars reject before the
      * callback can treat a partial tree as a complete declaration inventory.
@@ -93,7 +102,8 @@ export declare class EvidenceParser {
      *
      * Callbacks may await work, but must not await another parse or close on this
      * same pool. Copy names, ranges, and relationships into serializable values;
-     * returning a node, tree, or session would retain already released resources.
+     * returning a node, tree, or session would retain already released
+     * resources.
      */
     parse<T>(input: IEvidenceParserInput, closure: (session: EvidenceParseSession) => T | Promise<T>): Promise<T>;
     /**

package/lib/parsers/EvidenceParser.js

@@ -44,17 +44,18 @@ const web_tree_sitter_1 = require("web-tree-sitter");
 const EvidenceLanguageRegistry_1 = require("./EvidenceLanguageRegistry");
 const EvidenceParseSession_1 = require("./EvidenceParseSession");
 const EvidenceParserError_1 = require("./EvidenceParserError");
-const ParserSlots_1 = require("../internal/ParserSlots");
-const TreeSitterAssets_1 = require("../internal/TreeSitterAssets");
-const TreeSitterRange_1 = require("../internal/TreeSitterRange");
-const TreeSitterRuntime_1 = require("../internal/TreeSitterRuntime");
+const EvidenceParserSlots_1 = require("../internal/EvidenceParserSlots");
+const EvidenceTreeSitterAssets_1 = require("../internal/EvidenceTreeSitterAssets");
+const EvidenceTreeSitterRange_1 = require("../internal/EvidenceTreeSitterRange");
+const EvidenceTreeSitterRuntime_1 = require("../internal/EvidenceTreeSitterRuntime");
 /**
- * Owns bounded Tree-sitter parse sessions with lazy, verified grammar acquisition.
+ * Owns bounded Tree-sitter parse sessions with lazy, verified grammar
+ * acquisition.
  *
- * Create a parser for a group of source extractions, call `parse` for each file,
- * then await `close`. Grammar selection uses the configured artifact and filename;
- * acquisition starts only when that grammar is needed. Construction and metadata
- * inspection do not initialize a language or parse source.
+ * Create a parser for a group of source extractions, call `parse` for each
+ * file, then await `close`. Grammar selection uses the configured artifact and
+ * filename; acquisition starts only when that grammar is needed. Construction
+ * and metadata inspection do not initialize a language or parse source.
  *
  * Each request owns a native parser and tree. Its callback receives a borrowed
  * session only after syntax completeness is established, and must return data
@@ -62,21 +63,25 @@ const TreeSitterRuntime_1 = require("../internal/TreeSitterRuntime");
  * during asynchronous callback work, so a callback must not await another parse
  * or close on the same pool: that work can wait for the callback's own slot.
  *
- * Cleanup runs for successful extraction and every failure path. Closing rejects
- * new requests and waits for accepted callbacks; immutable process-wide grammar
- * data can remain cached for later runtimes.
+ * Cleanup runs for successful extraction and every failure path. Closing
+ * rejects new requests and waits for accepted callbacks; immutable process-wide
+ * grammar data can remain cached for later runtimes.
  *
  * @example
- * const parser: EvidenceParser = new EvidenceParser({ concurrency: 2 });
- * try {
- *   const range: IEvidenceSourceRange = await parser.parse(
- *     { type: "typescript", file: "api.ts", content: "export const value = 1;" },
- *     (session: EvidenceParseSession): IEvidenceSourceRange =>
- *       session.range(session.root),
- *   );
- * } finally {
- *   await parser.close();
- * }
+ *   const parser: EvidenceParser = new EvidenceParser({ concurrency: 2 });
+ *   try {
+ *     const range: IEvidenceSourceRange = await parser.parse(
+ *       {
+ *         type: "typescript",
+ *         file: "api.ts",
+ *         content: "export const value = 1;",
+ *       },
+ *       (session: EvidenceParseSession): IEvidenceSourceRange =>
+ *         session.range(session.root),
+ *     );
+ *   } finally {
+ *     await parser.close();
+ *   }
  */
 class EvidenceParser {
     /**
@@ -85,12 +90,13 @@ class EvidenceParser {
      * Keeping one provider per runtime shares acquisition work without loading
      * every registered grammar when the parser is constructed.
      */
-    assets = new TreeSitterAssets_1.TreeSitterAssets();
+    assets = new EvidenceTreeSitterAssets_1.EvidenceTreeSitterAssets();
     /**
      * Admission queue and lifecycle boundary for parse callbacks.
      *
-     * A slot covers acquisition, parsing, and the callback's asynchronous lifetime.
-     * Closing this queue prevents new work before native resources are discarded.
+     * A slot covers acquisition, parsing, and the callback's asynchronous
+     * lifetime. Closing this queue prevents new work before native resources are
+     * discarded.
      */
     slots;
     /**
@@ -110,11 +116,12 @@ class EvidenceParser {
     /**
      * Creates a lazy parser pool with a bounded callback count.
      *
-     * The default permits four active requests. Options are validated immediately,
-     * but grammar acquisition and native parser allocation wait for `parse`.
+     * The default permits four active requests. Options are validated
+     * immediately, but grammar acquisition and native parser allocation wait for
+     * `parse`.
      */
     constructor(options = {}) {
-        this.slots = new ParserSlots_1.ParserSlots((() => {
+        this.slots = new EvidenceParserSlots_1.EvidenceParserSlots((() => {
             const _ao0 = (input, _path, _exceptionable = true) => undefined === input.concurrency || "number" === typeof input.concurrency && (_isTypeUint32_1._isTypeUint32(input.concurrency) || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
                 path: _path + ".concurrency",
@@ -166,8 +173,9 @@ class EvidenceParser {
     /**
      * Reports admission state and successfully loaded grammar IDs.
      *
-     * Reading state does not acquire assets or wait for pending parses. The returned
-     * counts describe this pool; the language list records its successful loads.
+     * Reading state does not acquire assets or wait for pending parses. The
+     * returned counts describe this pool; the language list records its
+     * successful loads.
      */
     state() {
         return {
@@ -178,7 +186,8 @@ class EvidenceParser {
         };
     }
     /**
-     * Extracts data from a complete syntax tree within a borrowed callback session.
+     * Extracts data from a complete syntax tree within a borrowed callback
+     * session.
      *
      * Syntax errors, missing nodes, and incompatible grammars reject before the
      * callback can treat a partial tree as a complete declaration inventory.
@@ -186,7 +195,8 @@ class EvidenceParser {
      *
      * Callbacks may await work, but must not await another parse or close on this
      * same pool. Copy names, ranges, and relationships into serializable values;
-     * returning a node, tree, or session would retain already released resources.
+     * returning a node, tree, or session would retain already released
+     * resources.
      */
     async parse(input, closure) {
         // Capture the string-valued request before queueing. Later caller mutation
@@ -234,7 +244,7 @@ class EvidenceParser {
                         }
                         node = cursor.currentNode;
                     }
-                    throw new EvidenceParserError_1.EvidenceParserError("parse-incomplete", input.file, "The grammar found an ERROR or MISSING node. Correct the source or add support for its syntax before checking coverage.", TreeSitterRange_1.TreeSitterRange.from(node));
+                    throw new EvidenceParserError_1.EvidenceParserError("parse-incomplete", input.file, "The grammar found an ERROR or MISSING node. Correct the source or add support for its syntax before checking coverage.", EvidenceTreeSitterRange_1.EvidenceTreeSitterRange.from(node));
                 }
                 finally {
                     cursor.delete();
@@ -271,8 +281,8 @@ class EvidenceParser {
      *
      * Sharing the pending promise prevents concurrent parses from downloading and
      * initializing the same language repeatedly. A failed promise is removed only
-     * when it is still current, allowing a later request to retry without deleting
-     * a newer load that has replaced it.
+     * when it is still current, allowing a later request to retry without
+     * deleting a newer load that has replaced it.
      */
     async language(id) {
         let pending = this.languages.get(id);
@@ -299,7 +309,7 @@ class EvidenceParser {
     async load(id) {
         const grammar = await this.assets.grammar(id);
         const bytes = await this.assets.bytes(grammar);
-        const language = await TreeSitterRuntime_1.TreeSitterRuntime.language(grammar, bytes);
+        const language = await EvidenceTreeSitterRuntime_1.EvidenceTreeSitterRuntime.language(grammar, bytes);
         this.loaded.add(id);
         return language;
     }

package/lib/parsers/EvidenceParserError.d.ts

@@ -1,71 +1,80 @@
 import type { IEvidenceSourceRange } from "../structures/IEvidenceSourceRange";
 import type { EvidenceParserErrorCode } from "../typings/EvidenceParserErrorCode";
 /**
- * Parser failure preserving its category, affected source, and underlying cause.
+ * Parser failure preserving its category, affected source, and underlying
+ * cause.
  *
- * Adapters translate these fields into incomplete-inventory diagnostics, and watch
- * uses acquisition categories to decide whether timed recovery is appropriate.
- * A range is available for syntax failures but may be absent before source parsing
- * begins, such as when grammar acquisition cannot complete.
+ * Adapters translate these fields into incomplete-inventory diagnostics, and
+ * watch uses acquisition categories to decide whether timed recovery is
+ * appropriate. A range is available for syntax failures but may be absent
+ * before source parsing begins, such as when grammar acquisition cannot
+ * complete.
  */
 export declare class EvidenceParserError extends Error {
     /**
      * Stable parser or acquisition failure category.
      *
-     * Adapters use it in diagnostic codes and watch uses it to classify retryable
-     * preparation failures.
+     * Adapters use it in diagnostic codes and watch uses it to classify
+     * retryable preparation failures.
      */
     readonly code: EvidenceParserErrorCode;
     /**
      * Source or asset identifier affected by the failed operation.
      *
-     * This remains useful even when no syntax tree exists to provide a source span.
+     * This remains useful even when no syntax tree exists to provide a source
+     * span.
      */
     readonly file: string;
     /**
      * Precise source span when the failure can be attributed to parsed syntax.
      *
-     * Omission denotes a file- or acquisition-level failure without invented coordinates.
+     * Omission denotes a file- or acquisition-level failure without invented
+     * coordinates.
      */
     readonly range?: IEvidenceSourceRange | undefined;
     /**
-     * Creates a source-qualified error without discarding the original failure cause.
+     * Creates a source-qualified error without discarding the original failure
+     * cause.
      *
-     * The message includes the file for ordinary Error consumers; structured callers
-     * can inspect the category and optional span without parsing that message.
+     * The message includes the file for ordinary Error consumers; structured
+     * callers can inspect the category and optional span without parsing that
+     * message.
      */
     constructor(
     /**
      * Stable parser or acquisition failure category.
      *
-     * Adapters use it in diagnostic codes and watch uses it to classify retryable
-     * preparation failures.
+     * Adapters use it in diagnostic codes and watch uses it to classify
+     * retryable preparation failures.
      */
     code: EvidenceParserErrorCode, 
     /**
      * Source or asset identifier affected by the failed operation.
      *
-     * This remains useful even when no syntax tree exists to provide a source span.
+     * This remains useful even when no syntax tree exists to provide a source
+     * span.
      */
     file: string, 
     /**
      * Human-readable explanation of the failed parser operation.
      *
-     * The constructor prefixes this text with `file` for ordinary Error consumers;
-     * structured consumers should use `code`, `file`, and `range` for classification.
+     * The constructor prefixes this text with `file` for ordinary Error
+     * consumers; structured consumers should use `code`, `file`, and `range`
+     * for classification.
      */
     message: string, 
     /**
      * Precise source span when the failure can be attributed to parsed syntax.
      *
-     * Omission denotes a file- or acquisition-level failure without invented coordinates.
+     * Omission denotes a file- or acquisition-level failure without invented
+     * coordinates.
      */
     range?: IEvidenceSourceRange | undefined, 
     /**
      * Native error metadata retained as this Error's optional cause.
      *
-     * Omission means the parser has no lower-level exception to preserve, such as a
-     * detected incomplete syntax tree.
+     * Omission means the parser has no lower-level exception to preserve, such
+     * as a detected incomplete syntax tree.
      */
     options?: ErrorOptions);
 }

package/lib/parsers/EvidenceParserError.js

@@ -2,55 +2,62 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EvidenceParserError = void 0;
 /**
- * Parser failure preserving its category, affected source, and underlying cause.
+ * Parser failure preserving its category, affected source, and underlying
+ * cause.
  *
- * Adapters translate these fields into incomplete-inventory diagnostics, and watch
- * uses acquisition categories to decide whether timed recovery is appropriate.
- * A range is available for syntax failures but may be absent before source parsing
- * begins, such as when grammar acquisition cannot complete.
+ * Adapters translate these fields into incomplete-inventory diagnostics, and
+ * watch uses acquisition categories to decide whether timed recovery is
+ * appropriate. A range is available for syntax failures but may be absent
+ * before source parsing begins, such as when grammar acquisition cannot
+ * complete.
  */
 class EvidenceParserError extends Error {
     code;
     file;
     range;
     /**
-     * Creates a source-qualified error without discarding the original failure cause.
+     * Creates a source-qualified error without discarding the original failure
+     * cause.
      *
-     * The message includes the file for ordinary Error consumers; structured callers
-     * can inspect the category and optional span without parsing that message.
+     * The message includes the file for ordinary Error consumers; structured
+     * callers can inspect the category and optional span without parsing that
+     * message.
      */
     constructor(
     /**
      * Stable parser or acquisition failure category.
      *
-     * Adapters use it in diagnostic codes and watch uses it to classify retryable
-     * preparation failures.
+     * Adapters use it in diagnostic codes and watch uses it to classify
+     * retryable preparation failures.
      */
     code, 
     /**
      * Source or asset identifier affected by the failed operation.
      *
-     * This remains useful even when no syntax tree exists to provide a source span.
+     * This remains useful even when no syntax tree exists to provide a source
+     * span.
      */
     file, 
     /**
      * Human-readable explanation of the failed parser operation.
      *
-     * The constructor prefixes this text with `file` for ordinary Error consumers;
-     * structured consumers should use `code`, `file`, and `range` for classification.
+     * The constructor prefixes this text with `file` for ordinary Error
+     * consumers; structured consumers should use `code`, `file`, and `range`
+     * for classification.
      */
     message, 
     /**
      * Precise source span when the failure can be attributed to parsed syntax.
      *
-     * Omission denotes a file- or acquisition-level failure without invented coordinates.
+     * Omission denotes a file- or acquisition-level failure without invented
+     * coordinates.
      */
     range, 
     /**
      * Native error metadata retained as this Error's optional cause.
      *
-     * Omission means the parser has no lower-level exception to preserve, such as a
-     * detected incomplete syntax tree.
+     * Omission means the parser has no lower-level exception to preserve, such
+     * as a detected incomplete syntax tree.
      */
     options) {
         super(`${file}: ${message}`, options);

package/lib/parsers/EvidenceTagParser.d.ts

@@ -4,53 +4,61 @@ import type { IEvidenceTagParseResult } from "../structures/IEvidenceTagParseRes
 /**
  * Coordinates annotation parsing for one documented host.
  *
- * Every parse creates fresh continuation, fence, and diagnostic state. The adapter
- * establishes host attachment and documentation mapping before construction; this
- * controller preserves those inputs while delegating the grammar to the tag programmer.
+ * Every parse creates fresh continuation, fence, and diagnostic state. The
+ * adapter establishes host attachment and documentation mapping before
+ * construction; this controller preserves those inputs while delegating the
+ * grammar to the tag programmer.
  */
 export declare class EvidenceTagParser {
     /**
      * Original source content used to restore annotation positions.
      *
-     * Documentation stores normalized text, while diagnostics must point into this
-     * complete host source through the documentation's retained offset mapping.
+     * Documentation stores normalized text, while diagnostics must point into
+     * this complete host source through the documentation's retained offset
+     * mapping.
      */
     private readonly content;
     /**
-     * Adapter-established attachment and semantic identity of the documented host.
+     * Adapter-established attachment and semantic identity of the documented
+     * host.
      *
-     * The tag programmer uses this host for statements and diagnostics. It is copied
-     * at construction so a caller cannot redirect parsed annotations by later mutation.
+     * The tag programmer uses this host for statements and diagnostics. It is
+     * copied at construction so a caller cannot redirect parsed annotations by
+     * later mutation.
      */
     private readonly host;
     /**
      * Mapped documentation accepted for this host by its adapter.
      *
-     * Its tag boundaries and withdrawal policy define what annotation syntax is valid;
-     * the copy keeps a parse operation tied to the attachment it was created for.
+     * Its tag boundaries and withdrawal policy define what annotation syntax is
+     * valid; the copy keeps a parse operation tied to the attachment it was
+     * created for.
      */
     private readonly documentation;
     /**
      * Captures one adapter-established host and its mapped documentation.
      *
      * Callers supply the full source solely for source-coordinate conversion. The
-     * constructor does not parse tags, allowing adapters to build all host records
-     * before the independent parsing phase begins.
+     * constructor does not parse tags, allowing adapters to build all host
+     * records before the independent parsing phase begins.
      */
     constructor(content: string, host: IEvidenceHost, documentation: IEvidenceDocumentation);
     /**
-     * Parses the captured documentation into statements, withdrawals, and diagnostics.
+     * Parses the captured documentation into statements, withdrawals, and
+     * diagnostics.
      *
-     * Mutable continuation and code-fence state is allocated per call. Repeated calls
-     * therefore produce independent results and cannot carry an unfinished tag from
-     * one extraction cycle into another.
+     * Mutable continuation and code-fence state is allocated per call. Repeated
+     * calls therefore produce independent results and cannot carry an unfinished
+     * tag from one extraction cycle into another.
      */
     parse(): IEvidenceTagParseResult;
     /**
-     * Parses one adapter-mapped documentation attachment without retaining a controller.
+     * Parses one adapter-mapped documentation attachment without retaining a
+     * controller.
      *
-     * This convenience entry point has the same snapshot and isolation guarantees as
-     * constructing a parser and calling `parse`, and is suitable for one-off adapter work.
+     * This convenience entry point has the same snapshot and isolation guarantees
+     * as constructing a parser and calling `parse`, and is suitable for one-off
+     * adapter work.
      */
     static parse(content: string, host: IEvidenceHost, documentation: IEvidenceDocumentation): IEvidenceTagParseResult;
 }