@miliastry/quasar 1.0.6 → 1.1.0

package/dist/types/Model/DocumentModel.d.ts

@@ -0,0 +1,318 @@
+/**
+ * DocumentEngine — DocumentModel
+ *
+ * THE CORE of the Language Platform.
+ *
+ * The DocumentModel is the single source of truth for the document.
+ * BBCode is just ONE representation of this model.
+ * The model is language-agnostic and format-agnostic.
+ *
+ * Responsibilities:
+ * - Hold the current Red Tree
+ * - Manage incremental parsing
+ * - Coordinate transactions (undo/redo)
+ * - Emit change events
+ * - Provide query/find capabilities
+ * - Manage diagnostics
+ *
+ * Inspired by ProseMirror's EditorState and Roslyn's Document.
+ */
+import { RedNode } from '../Syntax/RedNode';
+import { GreenNode } from '../Syntax/GreenNode';
+import { NodeMatcher } from '../Syntax/NodeMatcher';
+import { IncrementalParser, type ReparseParseOptions, type FallbackReason, type SourceSpan } from '../Incremental/IncrementalParser';
+import { ChangeTracker } from '../Incremental/ChangeTracker';
+import type { TextChange, TextChangeRange } from '../Incremental/ChangeTracker';
+import { SemanticAnalyzer } from '../Semantic/SemanticAnalyzer';
+import type { AnalyzeResult, Validator } from '../Semantic/SemanticAnalyzer';
+import type { Operation } from '../Types/operations';
+import { UndoManager } from '../Transactions/UndoManager';
+import { TreeBuilder } from '../Syntax/TreeBuilder';
+import { QueryEngine } from '../Queries/QueryEngine';
+import type { Query, QueryResult } from '../Types/queries';
+import type { DocumentNode, NodeId } from '../Types/core';
+import type { DiagnosticCollection } from '../Types/diagnostics';
+import { DocumentEventBus } from '../Events/EventBus';
+import { NodeFactory } from './NodeFactory';
+import { TagRegistry } from './TagRegistry';
+export interface DocumentModelOptions {
+    /** Initial source text */
+    source?: string;
+    /** Language identifier */
+    language?: string;
+    /** Maximum undo stack size */
+    maxUndo?: number;
+    /** Whether to auto-analyze on change */
+    autoAnalyze?: boolean;
+    /**
+     * Attempt incremental reparse on `applyChange`. Default `true`.
+     *
+     * Setting this to `false` makes every change a full rebuild. The result is
+     * identical either way — that is the incremental parser's contract, checked
+     * differentially over 22.100 edits — so this is a performance switch and a
+     * debugging aid, not a correctness one.
+     */
+    incremental?: boolean;
+    /**
+     * Reuse red subtrees across incremental reparses. Default `true`.
+     *
+     * When the splice shares a green subtree by reference, the old red subtree
+     * is adopted into the new tree instead of being rebuilt — building red was
+     * the largest phase of a keystroke. The trade is a contract: the previous
+     * `redRoot` is consumed by the adoption and must not be walked afterwards.
+     * No engine or app code does; this switch exists for any future consumer
+     * that needs the superseded tree to stay intact.
+     */
+    reuseRed?: boolean;
+}
+export declare class DocumentModel {
+    private _source;
+    private _language;
+    private _redRoot;
+    private _greenRoot;
+    private _version;
+    readonly tagRegistry: TagRegistry;
+    readonly nodeFactory: NodeFactory;
+    readonly treeBuilder: TreeBuilder;
+    readonly nodeMatcher: NodeMatcher;
+    readonly semanticAnalyzer: SemanticAnalyzer;
+    readonly incrementalParser: IncrementalParser;
+    readonly changeTracker: ChangeTracker;
+    readonly undoManager: UndoManager;
+    readonly queryEngine: QueryEngine;
+    readonly events: DocumentEventBus;
+    private _diagnostics;
+    private _lastAnalyzeResult;
+    /**
+     * Source range of the last applied edit — see {@link TextChangeRange}.
+     * `null` after a full rebuild, which is not an edit.
+     */
+    private _lastChangeRange;
+    private _options;
+    private _analyzeTimeout;
+    /** The debounced post-edit work, kept so `ensureAnalyzed` can run it early. */
+    private _pendingAnalyze;
+    /** Last reparse timings breakdown (exposed for debugging) */
+    lastReparsePath: string;
+    /** Why the last reparse fell back to a full rebuild, if it did. */
+    lastReparseFallbackReason: FallbackReason | null;
+    lastReparseTimings: {
+        findAffected: number;
+        safeBoundary: number;
+        parse: number;
+        buildRed: number;
+        mutate: number;
+        other: number;
+    } | null;
+    /**
+     * The span of the current source the last reparse actually re-parsed, in
+     * CURRENT coordinates — `null` after a full rebuild, where the answer is
+     * "all of it". See {@link ReparseResult.window}.
+     */
+    lastReparseWindow: SourceSpan | null;
+    /**
+     * The union of every reparse window since the last analysis, in CURRENT
+     * coordinates — `null` when nothing is pending. A bounding span rather than
+     * a list: over-covering only means re-validating a few more nodes, and the
+     * arithmetic to keep several spans current across later edits costs more
+     * than the nodes do.
+     */
+    private _analysisWindow;
+    /** Set by anything a window pass cannot be built on: a rebuild, a reparse that fell back. */
+    private _analysisWindowBroken;
+    constructor(options?: DocumentModelOptions);
+    get source(): string;
+    get language(): string;
+    get version(): number;
+    get redRoot(): RedNode | null;
+    get greenRoot(): GreenNode | null;
+    get diagnostics(): DiagnosticCollection | null;
+    /**
+     * What the last analysis cost and how it was obtained — its `scope` says
+     * whether it walked the document or only the edit's window, and `window`
+     * carries that span when it did. The diagnostics themselves are on
+     * {@link diagnostics}, and are the whole document's on either route.
+     */
+    get lastAnalyze(): AnalyzeResult | null;
+    /**
+     * The source range of the last applied edit, in new-source coordinates.
+     *
+     * `null` after a `rebuild` (there is no incremental edit to point at). The
+     * BlockPatcher reads this to reconcile only the blocks around the edit
+     * instead of walking the whole document. The same range is also attached to
+     * the current `redRoot` (`__changeRange`), so a consumer that only holds the
+     * AST — like the live preview — can find it without plumbing the model.
+     */
+    get lastChangeRange(): TextChangeRange | null;
+    /**
+     * Full rebuild from source text.
+     * Used for initial load or when incremental parsing isn't possible.
+     */
+    rebuild(source: string): void;
+    /**
+     * Install `nodeMatch` on an event as an accessor, so the match is only
+     * computed if a subscriber actually reads it.
+     *
+     * Matching two 1736-node trees costs ~3.5 ms and allocates a result entry per
+     * node plus five Maps/Sets — and it ran on *every* keystroke to populate a
+     * field that no subscriber in this codebase reads. The capability is real
+     * (preserving selection and scroll across re-parses is what it is for), so it
+     * stays available; it just stops running speculatively.
+     *
+     * Callers still write `event.nodeMatch` and see a `NodeMatch | null`. Note the
+     * closure keeps `oldRoot` alive for as long as the event object is retained.
+     */
+    private defineLazyNodeMatch;
+    /**
+     * Attach the last change range to a root node.
+     *
+     * The range travels with the AST so the preview can read it from the root it
+     * is about to patch — no prop drilling through workspace → window → preview.
+     * `__changeRange` is deliberately not part of RedNode's API; it is a runtime
+     * marker owned by the model (the BlockPatcher reads it with a cast).
+     */
+    private _attachChangeRange;
+    /**
+     * Apply one exact source change — THE edit path, and the one an editor
+     * should use.
+     *
+     * An editor already knows what the user did: Monaco's
+     * `onDidChangeModelContent` hands over `rangeOffset`, `rangeLength` and
+     * `text`, which is exactly a {@link TextChange}. Handing that over instead
+     * of the new document text skips the only part of the pipeline that is
+     * unavoidably proportional to the whole document — the prefix/suffix diff
+     * in {@link applyTextUpdate} — and the difference is not marginal. Typing
+     * 120 characters into the middle of the 500 KB fixture, per keystroke:
+     *
+     *     applyTextUpdate   p50 7.35 ms   p95 28.79 ms
+     *     applyChange       p50 1.85 ms   p95  8.18 ms
+     *
+     * Everything downstream is already windowed, so what is left after the diff
+     * goes is work proportional to the edit.
+     *
+     * `origin` tags where the change came from — `'local'` (default) for the
+     * user's own editing, anything else for programmatic or synced sources
+     * (`'remote'`, `'sync'`, a peer id…). It travels on the emitted events, so
+     * a collaboration layer can tell its own echo apart from user edits — the
+     * classic infinite-loop bug when wiring a CRDT. See `QuasarCollab.MD`.
+     */
+    applyChange(change: TextChange, origin?: string): void;
+    /**
+     * Flush the debounced post-edit analysis, so `diagnostics` describes the
+     * *current* tree.
+     *
+     * `applyChange` defers analysis by a few milliseconds to keep the keystroke
+     * path lean. A caller that reads `diagnostics` synchronously right after an
+     * edit would otherwise be looking at the previous document's errors — which
+     * is exactly what the editor's error panel did.
+     */
+    ensureAnalyzed(): void;
+    /**
+     * Recover the edit from the new document text, then apply it.
+     *
+     * The FALLBACK, for a caller that only has the text: a textarea's `value`,
+     * a CRDT that hands over a materialised document, a paste normaliser. It is
+     * a shared-prefix/shared-suffix diff, so it costs one pass over the
+     * unchanged part of the document before any of the incremental machinery
+     * gets to run — which is precisely the term {@link applyChange} does not
+     * pay. Anything that knows the edit should say so and use that instead.
+     */
+    applyTextUpdate(newSource: string, origin?: string): void;
+    /**
+     * Execute operations within a transaction (undoable).
+     *
+     * Coherence contract: after a `transact` the model's `source`, green tree
+     * and red tree all describe the same document. The transaction mutates the
+     * red tree, the result is serialized back to text via `exportSource`, and
+     * the model rebuilds from that text — parse stays the single source of
+     * truth, exactly as in `applyChange`. (The previous implementation swapped
+     * `_redRoot` and left `_source`/`_greenRoot` describing the old document,
+     * so the next text edit diffed against a source the tree no longer matched.)
+     *
+     * Returns `true` if the document changed.
+     */
+    transact(operations: Operation[], label?: string): boolean;
+    /**
+     * Undo the last transaction.
+     *
+     * Undo/redo replay *source snapshots*, not stored tree mutations: a rebuild
+     * replaces every node id, so a retained `Transaction` could never be
+     * re-applied against the current tree — and its `invert()` was only defined
+     * for one of the six operation kinds anyway. Text is always replayable.
+     */
+    undo(): boolean;
+    /**
+     * Redo the last undone transaction. See `undo` for why this replays text.
+     */
+    redo(): boolean;
+    /**
+     * Run semantic analysis on the current tree.
+     *
+     * Incremental when it can be: if every edit since the last analysis was an
+     * incremental reparse that adopted subtrees, only the nodes inside those
+     * reparse windows — plus the ones whose document-wide facts the edits moved
+     * — are re-validated, and every other node keeps the verdict it already
+     * had. The DIAGNOSTICS ARE THE SAME EITHER WAY; the difference is how long
+     * it took to arrive at them, and {@link AnalyzeResult.scope} says which
+     * route was taken. The differential in `Chars500kAnalysis.test.ts` compares
+     * the two, edit by edit, on the real fixture.
+     *
+     * Falls back to the full pass whenever the window pass declines — no
+     * previous pass to build on, the validator set or the token source changed
+     * under it, or a validator whose verdicts are not a function of one node
+     * (see `Validator.scope`).
+     */
+    analyze(): AnalyzeResult;
+    /**
+     * Find a node by its ID.
+     */
+    findNode(id: NodeId): RedNode | null;
+    /**
+     * Query the document tree.
+     */
+    query(q: Query): QueryResult;
+    /**
+     * Register a semantic validator.
+     */
+    registerValidator(validator: Validator): void;
+    /**
+     * Get the current document as a DocumentNode tree.
+     */
+    toDocumentNode(): DocumentNode | null;
+    /**
+     * Get the current source text.
+     */
+    toString(): string;
+    /**
+     * Parse source text to a GreenNode tree.
+     * Override this for language-specific parsing.
+     *
+     * `options.normalizeParagraphs === false` means the text is the inner span
+     * of a container rather than a whole document, and root-level grouping must
+     * be skipped. Languages without such grouping can ignore it.
+     */
+    protected parseToGreen(source: string, options?: ReparseParseOptions): GreenNode;
+    /**
+     * Build a RedNode tree from a GreenNode.
+     */
+    protected buildRedFromGreen(green: GreenNode): RedNode;
+    /**
+     * Build a red tree for `green`, reusing subtrees of `oldRed` where the green
+     * is shared by reference. The base model has no reuse-aware builder, so it
+     * falls back to a full build; language models override this
+     * (BBCodeDocumentModel uses `greenToRedNodeReusing`).
+     */
+    protected buildRedFromGreenReusing(green: GreenNode, oldRed: RedNode, stats?: {
+        adopted: number;
+    }): RedNode;
+    /**
+     * Serialize a red tree back to source text. `transact`/`undo`/`redo` rebuild
+     * from this text to keep source, green and red coherent.
+     *
+     * The base model has no syntax to serialize to, so this throws; language
+     * models override it (BBCodeDocumentModel uses the BBCodeExporter).
+     * Failing loudly here beats the alternative: silently desynchronizing the
+     * model's three representations.
+     */
+    protected exportSource(root: RedNode): string;
+}

package/dist/types/Model/NodeFactory.d.ts

@@ -0,0 +1,29 @@
+/**
+ * DocumentEngine — NodeFactory
+ *
+ * Creates DocumentNode instances, RedNode instances, and GreenNode
+ * instances from tag definitions. Centralizes node creation so
+ * plugins can provide custom node factories.
+ */
+import { RedNode } from '../Syntax/RedNode';
+import { TagRegistry } from './TagRegistry';
+export declare class NodeFactory {
+    private registry;
+    constructor(registry: TagRegistry);
+    /**
+     * Create a RedNode from a tag definition.
+     */
+    createFromTag(tagName: string, attrs?: string, start?: number, end?: number, children?: RedNode[]): RedNode;
+    /**
+     * Create a text RedNode.
+     */
+    createText(text: string, start?: number, end?: number): RedNode;
+    /**
+     * Create a self-closing tag RedNode (like [*], [img]src[/img]).
+     */
+    createSelfClosing(tagName: string, attrs?: string, start?: number, end?: number): RedNode;
+    /**
+     * Create a document root RedNode.
+     */
+    createDocument(children?: RedNode[]): RedNode;
+}

package/dist/types/Model/TagRegistry.d.ts

@@ -0,0 +1,165 @@
+/**
+ * DocumentEngine — TagRegistry
+ *
+ * The central registry for all known tags/node kinds.
+ * This is the plugin extension point for adding new BBCode tags,
+ * custom node types, or even entire new languages.
+ *
+ * Each tag definition includes:
+ * - Parser handler (how to parse this tag from tokens)
+ * - Renderer (how to render this tag to HTML, Markdown, etc.)
+ * - Validator (semantic validation rules)
+ * - Toolbar definition (for the visual editor)
+ * - Property editor (for the properties panel)
+ *
+ * Inspired by VSCode's contribution points.
+ */
+import type { NodeKind, NodeAttributes } from '../Types/core';
+import type { RedNode } from '../Syntax/RedNode';
+import type { RenderNode } from '../RenderPipeline/RenderTree';
+import type { Validator } from '../Semantic/SemanticAnalyzer';
+export interface TagHandlerContext {
+    node: RedNode;
+    source: string;
+    visitChildren: (node: RedNode) => string;
+    renderChild: (node: RedNode) => RenderNode;
+}
+export interface TagDefinition {
+    /** The tag name (e.g. 'color', 'b', 'img') */
+    name: string;
+    /** Semantic kind */
+    kind: NodeKind;
+    /** Human-readable label */
+    label: string;
+    /** Category for grouping in UI */
+    category?: 'formatting' | 'layout' | 'media' | 'special' | 'text';
+    /** Icon name for UI */
+    icon?: string;
+    /** Whether this tag is inline (span) or block (div) */
+    isInline: boolean;
+    /** Whether this tag is self-closing */
+    isSelfClosing: boolean;
+    /** Whether this tag can contain children */
+    canHaveChildren: boolean;
+    /** Whether this tag is deprecated */
+    isDeprecated?: boolean;
+    /** Replacement tag name if deprecated */
+    deprecatedReplacement?: string;
+    /** Convert a RedNode back to BBCode text */
+    toBBCode?: (ctx: TagHandlerContext) => string;
+    /** Convert a RedNode to a RenderNode for the render pipeline */
+    toRenderNode?: (ctx: TagHandlerContext) => RenderNode;
+    /** Convert a RedNode to HTML string (legacy) */
+    toHTML?: (ctx: TagHandlerContext) => string;
+    /** Default attributes for new instances */
+    defaultAttributes?: () => NodeAttributes;
+    /** Additional validator for this specific tag */
+    validator?: Validator;
+    /** Toolbar button definition */
+    toolbar?: {
+        group: string;
+        label: string;
+        icon?: string;
+        shortcut?: string;
+    };
+    /** Properties panel definition */
+    properties?: PropertyDefinition[];
+}
+export interface PropertyDefinition {
+    name: string;
+    label: string;
+    type: 'text' | 'color' | 'number' | 'select' | 'boolean' | 'slider';
+    defaultValue?: string | number | boolean;
+    options?: {
+        label: string;
+        value: string;
+    }[];
+    min?: number;
+    max?: number;
+    step?: number;
+    placeholder?: string;
+    description?: string;
+}
+/**
+ * Recursively extract plain text from a RedNode tree.
+ *
+ * A line break is a childless `spacing` leaf with no text of its own, so
+ * it has to be spelled out here or an effect spanning two lines is handed
+ * one line and exports without its break — silent data loss, and the
+ * reason every two-dimensional axis (`line`, `column`, `radial`) measured
+ * a block one line tall.
+ */
+export declare function extractTextContent(node: RedNode): string;
+export type TagHandler = {
+    [K in keyof TagDefinition]: TagDefinition[K];
+};
+export declare class TagRegistry {
+    private tags;
+    private kinds;
+    /** Names registered by the constructor — the language's own tags. */
+    private builtins;
+    /**
+     * Whether `tags`/`kinds` are still the process-wide builtin maps. While
+     * they are, this registry must not write to them.
+     */
+    private shared;
+    /**
+     * Bumped on every register/unregister, so consumers that derive something
+     * from the registry (the parser's `extraTags` map) can memoize against it
+     * instead of rebuilding per parse.
+     */
+    version: number;
+    constructor();
+    /** Take a private copy of the builtin maps before the first write. */
+    private own;
+    /**
+     * Register a tag definition.
+     */
+    register(tag: TagDefinition): void;
+    /**
+     * Unregister a tag definition.
+     */
+    unregister(name: string): void;
+    /**
+     * Whether `name` is one of the language's own tags, as opposed to a
+     * plugin registration. The distinction matters: plugin tags must reach the
+     * parser (via `ParseOptions.extraTags`) and serialize with their own name,
+     * while builtins already have both behaviors hardcoded — routing them
+     * through the plugin path would change engine semantics.
+     */
+    isBuiltin(name: string): boolean;
+    /**
+     * tag name → kind for every non-builtin registration: the parser's
+     * `extraTags`. Returns `null` when there are none, so the common case
+     * costs one size comparison and no allocation.
+     */
+    customTags(): Map<string, NodeKind> | null;
+    /**
+     * Get a tag definition by name.
+     */
+    get(name: string): TagDefinition | undefined;
+    /**
+     * Get a tag definition by semantic kind.
+     */
+    getByKind(kind: NodeKind): TagDefinition | undefined;
+    /**
+     * Check if a tag is registered.
+     */
+    has(name: string): boolean;
+    /**
+     * Get all registered tags.
+     */
+    getAll(): TagDefinition[];
+    /**
+     * Get tags by category.
+     */
+    getByCategory(category: string): TagDefinition[];
+    /**
+     * Get tags by whether they are inline.
+     */
+    getInline(): TagDefinition[];
+    /**
+     * Get block-level tags.
+     */
+    getBlock(): TagDefinition[];
+}

package/dist/types/Model/index.d.ts

@@ -0,0 +1,5 @@
+export { DocumentModel } from './DocumentModel';
+export type { DocumentModelOptions } from './DocumentModel';
+export { TagRegistry } from './TagRegistry';
+export type { TagDefinition, TagHandler, PropertyDefinition, TagHandlerContext } from './TagRegistry';
+export { NodeFactory } from './NodeFactory';

package/dist/types/Plugins/PluginAPI.d.ts

@@ -0,0 +1,44 @@
+/**
+ * DocumentEngine — PluginAPI
+ *
+ * The public API exposed to plugins.
+ * Plugin authors use this to register tags, commands, validators, etc.
+ *
+ * Inspired by VSCode's `vscode` module.
+ */
+import { DocumentModel } from '../Model/DocumentModel';
+import { TagRegistry } from '../Model/TagRegistry';
+import { CommandRegistry } from '../Commands';
+import { SemanticAnalyzer } from '../Semantic/SemanticAnalyzer';
+import { Linter } from '../Linter/Linter';
+import { RenderPipeline } from '../RenderPipeline/RenderPipeline';
+import { PluginRegistry, type PluginManifest, type PluginContribution } from './PluginRegistry';
+export declare class PluginAPI {
+    readonly model: DocumentModel;
+    readonly tags: TagRegistry;
+    readonly commands: CommandRegistry;
+    readonly semantic: SemanticAnalyzer;
+    readonly linter: Linter;
+    readonly renderer: RenderPipeline;
+    readonly plugins: PluginRegistry;
+    constructor(model: DocumentModel);
+    /**
+     * Register a plugin with all its contributions.
+     *
+     * Example:
+     * ```ts
+     * api.registerPlugin({
+     *   name: 'my-plugin',
+     *   version: '1.0.0'
+     * }, {
+     *   tags: [{ name: 'blur', kind: 'custom', ... }],
+     *   commands: [{ id: 'my-command', ... }]
+     * })
+     * ```
+     */
+    registerPlugin(manifest: PluginManifest, contributions: PluginContribution): void;
+    /**
+     * Unregister a plugin and remove its contributions.
+     */
+    unregisterPlugin(name: string): void;
+}

package/dist/types/Plugins/PluginRegistry.d.ts

@@ -0,0 +1,81 @@
+/**
+ * DocumentEngine — PluginRegistry
+ *
+ * Manages the lifecycle of plugins/extensions.
+ * Each plugin registers contributions (tags, commands, validators, etc.)
+ * and can be loaded/unloaded at runtime.
+ *
+ * Inspired by VSCode's extension system.
+ */
+import type { TagDefinition } from '../Model/TagRegistry';
+import type { Command } from '../Commands/Command';
+import type { Validator } from '../Semantic/SemanticAnalyzer';
+import type { LintRule } from '../Linter/Linter';
+import type { RenderHook } from '../RenderPipeline/RenderPipeline';
+export interface PluginManifest {
+    name: string;
+    version: string;
+    description?: string;
+    author?: string;
+    /** Dependencies on other plugins */
+    dependencies?: string[];
+}
+export interface PluginContribution {
+    /** Tags to register */
+    tags?: TagDefinition[];
+    /** Commands to register */
+    commands?: Command[];
+    /** Semantic validators */
+    validators?: Validator[];
+    /** Lint rules */
+    lintRules?: LintRule[];
+    /** Render hooks */
+    renderHooks?: RenderHook[];
+    /** CSS to inject */
+    styles?: string[];
+    /** Initialization function */
+    activate?: () => void | Promise<void>;
+    /** Cleanup function */
+    deactivate?: () => void;
+}
+export interface Plugin {
+    manifest: PluginManifest;
+    contributions: PluginContribution;
+    /** Whether the plugin is currently active */
+    active: boolean;
+}
+export declare class PluginRegistry {
+    private plugins;
+    /**
+     * Register a plugin.
+     */
+    register(manifest: PluginManifest, contributions: PluginContribution): Plugin;
+    /**
+     * Unregister and deactivate a plugin.
+     */
+    unregister(name: string): boolean;
+    /**
+     * Get a plugin by name.
+     */
+    get(name: string): Plugin | undefined;
+    /**
+     * Get all registered plugins.
+     */
+    getAll(): Plugin[];
+    /**
+     * Activate a plugin (calls activate function).
+     */
+    activate(plugin: Plugin): void;
+    /**
+     * Deactivate a plugin (calls deactivate function).
+     */
+    deactivate(plugin: Plugin): void;
+    /**
+     * Activate all registered plugins.
+     */
+    activateAll(): void;
+    /**
+     * Deactivate all plugins.
+     */
+    deactivateAll(): void;
+}

package/dist/types/Plugins/index.d.ts

@@ -0,0 +1,3 @@
+export { PluginAPI } from './PluginAPI';
+export { PluginRegistry } from './PluginRegistry';
+export type { Plugin, PluginManifest, PluginContribution } from './PluginRegistry';

package/dist/types/Queries/QueryEngine.d.ts

@@ -0,0 +1,32 @@
+/**
+ * DocumentEngine — QueryEngine
+ *
+ * CSS-inspired query engine for the document tree.
+ * Enables queries like:
+ *   query('paragraph > bold')
+ *   query('quote text')
+ *   query('[color]')
+ *   query('list > *')
+ *
+ * Useful for:
+ * - Finding nodes by structure
+ * - AI context gathering
+ * - Plugin discovery
+ * - Lint rule targeting
+ */
+import { RedNode } from '../Syntax/RedNode';
+import type { Query, QueryResult } from '../Types/queries';
+export declare class QueryEngine {
+    /**
+     * Execute a query against a RedNode tree.
+     */
+    execute(query: Query, root: RedNode): QueryResult;
+    /**
+     * Filter candidates by applying a query step's selectors.
+     */
+    private matchStep;
+    /**
+     * Check if a single node matches a single selector.
+     */
+    private matchesSelector;
+}

package/dist/types/Queries/index.d.ts

@@ -0,0 +1 @@
+export { QueryEngine } from './QueryEngine';