@effected/markdown 0.2.0

package/index.d.ts

@@ -0,0 +1,2190 @@
+import { Data, Effect, Result, Schema, Stream } from "effect";
+//#region src/MarkdownNode.d.ts
+declare const Point_base: Schema.Class<Point, Schema.Struct<{
+  readonly line: Schema.Number;
+  readonly column: Schema.Number;
+  readonly offset: Schema.Number;
+}>, {}>;
+/**
+ * A single point in a source document: 1-based `line` and `column`, 0-based
+ * `offset`.
+ *
+ * `offset` is the index into the source string, which is what the edit layer
+ * splices against; `line`/`column` are the human-facing coordinates unist
+ * specifies.
+ *
+ * @public
+ */
+declare class Point extends Point_base {}
+declare const Position_base: Schema.Class<Position, Schema.Struct<{
+  readonly start: typeof Point;
+  readonly end: typeof Point;
+}>, {}>;
+/**
+ * The source span of a node: `start` inclusive, `end` exclusive.
+ *
+ * @public
+ */
+declare class Position extends Position_base {
+  /**
+   * The zero-width synthetic position: line 1, column 1, offset 0 at both
+   * ends — the span every node class's `make` fills in when `position` is
+   * omitted, and the same sentinel `Mdast.fromMdast` synthesizes for foreign
+   * nodes that carry none.
+   *
+   * @remarks
+   * Clearly synthetic and inert for rendering: trees carrying it serve
+   * tree-level workflows (stringify, the visitor, `MarkdownFormat.modify`
+   * replacement fragments, projection out), not offset-splice editing, whose
+   * offsets must come from a real parse.
+   */
+  static readonly synthetic: Position;
+}
+/**
+ * The explicitness of a reference, per mdast's `referenceType` enum.
+ *
+ * - `shortcut` — implicit, identifier inferred from the content (`[foo]`).
+ * - `collapsed` — explicit, identifier inferred from the content (`[foo][]`).
+ * - `full` — explicit, identifier explicitly set (`[foo][bar]`).
+ *
+ * @public
+ */
+declare const ReferenceType: Schema.Literals<readonly ["shortcut", "collapsed", "full"]>;
+/**
+ * The union of all reference-type string literals.
+ *
+ * @public
+ */
+type ReferenceType = typeof ReferenceType.Type;
+/**
+ * The two ways CommonMark spells a heading: `atx` (`# Title`) and `setext`
+ * (a title underlined with `=` or `-`).
+ *
+ * @public
+ */
+declare const HeadingStyle: Schema.Literals<readonly ["atx", "setext"]>;
+/**
+ * The union of all heading-style string literals.
+ *
+ * @public
+ */
+type HeadingStyle = typeof HeadingStyle.Type;
+/**
+ * The two ways CommonMark spells a hard line break: a trailing backslash or
+ * two-or-more trailing spaces.
+ *
+ * @public
+ */
+declare const BreakStyle: Schema.Literals<readonly ["backslash", "spaces"]>;
+/**
+ * The union of all break-style string literals.
+ *
+ * @public
+ */
+type BreakStyle = typeof BreakStyle.Type;
+/**
+ * The two fence characters a fenced code block may use.
+ *
+ * @public
+ */
+declare const FenceChar: Schema.Literals<readonly ["`", "~"]>;
+/**
+ * The union of all fence-character literals.
+ *
+ * @public
+ */
+type FenceChar = typeof FenceChar.Type;
+/**
+ * The three bullet characters an unordered list may use.
+ *
+ * @public
+ */
+declare const BulletChar: Schema.Literals<readonly ["-", "*", "+"]>;
+/**
+ * The union of all bullet-character literals.
+ *
+ * @public
+ */
+type BulletChar = typeof BulletChar.Type;
+/**
+ * The two delimiters an ordered list marker may use (`1.` or `1)`).
+ *
+ * @public
+ */
+declare const ListDelimiter: Schema.Literals<readonly [".", ")"]>;
+/**
+ * The union of all ordered-list delimiter literals.
+ *
+ * @public
+ */
+type ListDelimiter = typeof ListDelimiter.Type;
+/**
+ * The three characters a thematic break may be drawn with.
+ *
+ * @public
+ */
+declare const ThematicBreakChar: Schema.Literals<readonly ["-", "_", "*"]>;
+/**
+ * The union of all thematic-break character literals.
+ *
+ * @public
+ */
+type ThematicBreakChar = typeof ThematicBreakChar.Type;
+/**
+ * The two characters emphasis and strong emphasis may be marked with.
+ *
+ * @public
+ */
+declare const EmphasisChar: Schema.Literals<readonly ["*", "_"]>;
+/**
+ * The union of all emphasis-marker character literals.
+ *
+ * @public
+ */
+type EmphasisChar = typeof EmphasisChar.Type;
+/**
+ * The six legal ATX/setext heading depths.
+ *
+ * @public
+ */
+declare const HeadingDepth: Schema.Literals<readonly [1, 2, 3, 4, 5, 6]>;
+/**
+ * The union of all legal heading depths.
+ *
+ * @public
+ */
+type HeadingDepth = typeof HeadingDepth.Type;
+/**
+ * The three alignments a GFM table column may declare. A `null` entry in a
+ * {@link Table}'s `align` array means the column carries no alignment.
+ *
+ * @public
+ */
+declare const TableAlign: Schema.Literals<readonly ["left", "right", "center"]>;
+/**
+ * The union of all table-alignment string literals.
+ *
+ * @public
+ */
+type TableAlign = typeof TableAlign.Type;
+declare const Text_base: Schema.Class<Text, Schema.Struct<{
+  readonly type: Schema.tag<"text">;
+  readonly value: Schema.String;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+}>, {}>;
+/**
+ * Text — a run of literal characters, with entity references and backslash
+ * escapes already resolved into `value`.
+ *
+ * @public
+ */
+declare class Text extends Text_base {}
+declare const InlineCode_base: Schema.Class<InlineCode, Schema.Struct<{
+  readonly type: Schema.tag<"inlineCode">;
+  readonly value: Schema.String;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+}>, {}>;
+/**
+ * InlineCode — a code span: `foo` written between backtick fences in the
+ * source. `value` holds the span's content with the backtick fence stripped
+ * and the spec's space-stripping applied.
+ *
+ * @public
+ */
+declare class InlineCode extends InlineCode_base {}
+declare const Html_base: Schema.Class<Html, Schema.Struct<{
+  readonly type: Schema.tag<"html">;
+  readonly value: Schema.String;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+}>, {}>;
+/**
+ * Html — a fragment of raw HTML, kept verbatim. Used for both HTML blocks
+ * (flow) and inline raw HTML (phrasing); the same node type serves both, as
+ * mdast specifies.
+ *
+ * @public
+ */
+declare class Html extends Html_base {}
+declare const Break_base: Schema.Class<Break, Schema.Struct<{
+  readonly type: Schema.tag<"break">;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+  readonly breakStyle: Schema.optionalKey<Schema.Literals<readonly ["backslash", "spaces"]>>;
+}>, {}>;
+/**
+ * Break — a hard line break.
+ *
+ * `breakStyle` is a fidelity extra recording which of the two CommonMark
+ * spellings produced it.
+ *
+ * @public
+ */
+declare class Break extends Break_base {}
+declare const Image_base: Schema.Class<Image, Schema.Struct<{
+  readonly type: Schema.tag<"image">;
+  readonly url: Schema.String;
+  readonly title: Schema.optionalKey<Schema.String>;
+  readonly alt: Schema.optionalKey<Schema.String>;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+}>, {}>;
+/**
+ * Image — an inline image (`![alt](url "title")`).
+ *
+ * @public
+ */
+declare class Image extends Image_base {}
+declare const ImageReference_base: Schema.Class<ImageReference, Schema.Struct<{
+  readonly type: Schema.tag<"imageReference">;
+  readonly identifier: Schema.String;
+  readonly label: Schema.optionalKey<Schema.String>;
+  readonly referenceType: Schema.Literals<readonly ["shortcut", "collapsed", "full"]>;
+  readonly alt: Schema.optionalKey<Schema.String>;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+}>, {}>;
+/**
+ * ImageReference — an image referring to a {@link Definition} by identifier
+ * (`![alt][ref]`).
+ *
+ * The parser emits these unresolved, whether or not a matching definition
+ * exists in the tree — resolution is the consumer's business.
+ *
+ * @public
+ */
+declare class ImageReference extends ImageReference_base {}
+declare const Emphasis_base: Schema.Class<Emphasis, Schema.Struct<{
+  readonly type: Schema.tag<"emphasis">;
+  readonly children: Schema.$Array<Schema.suspend<Schema.Codec<PhrasingContent, PhrasingContent, never, never>>>;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+  readonly markerChar: Schema.optionalKey<Schema.Literals<readonly ["*", "_"]>>;
+}>, {}>;
+/**
+ * Emphasis — `*foo*` or `_foo_`.
+ *
+ * `markerChar` is a fidelity extra recording which marker produced it.
+ *
+ * @public
+ */
+declare class Emphasis extends Emphasis_base {}
+declare const Strong_base: Schema.Class<Strong, Schema.Struct<{
+  readonly type: Schema.tag<"strong">;
+  readonly children: Schema.$Array<Schema.suspend<Schema.Codec<PhrasingContent, PhrasingContent, never, never>>>;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+  readonly markerChar: Schema.optionalKey<Schema.Literals<readonly ["*", "_"]>>;
+}>, {}>;
+/**
+ * Strong — `**foo**` or `__foo__`.
+ *
+ * `markerChar` is a fidelity extra recording which marker produced it.
+ *
+ * @public
+ */
+declare class Strong extends Strong_base {}
+declare const Delete_base: Schema.Class<Delete, Schema.Struct<{
+  readonly type: Schema.tag<"delete">;
+  readonly children: Schema.$Array<Schema.suspend<Schema.Codec<PhrasingContent, PhrasingContent, never, never>>>;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+}>, {}>;
+/**
+ * Delete — GFM strikethrough (`~~foo~~`). Content that is no longer accurate
+ * or relevant.
+ *
+ * `~~` is the only marker `~~foo~~` renders through, so unlike
+ * {@link Emphasis} and {@link Strong} there is no marker-character fidelity
+ * extra to carry.
+ *
+ * @public
+ */
+declare class Delete extends Delete_base {}
+declare const Link_base: Schema.Class<Link, Schema.Struct<{
+  readonly type: Schema.tag<"link">;
+  readonly url: Schema.String;
+  readonly title: Schema.optionalKey<Schema.String>;
+  readonly children: Schema.$Array<Schema.suspend<Schema.Codec<PhrasingContent, PhrasingContent, never, never>>>;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+}>, {}>;
+/**
+ * Link — an inline link (`[text](url "title")`), including autolinks.
+ *
+ * @public
+ */
+declare class Link extends Link_base {}
+declare const LinkReference_base: Schema.Class<LinkReference, Schema.Struct<{
+  readonly type: Schema.tag<"linkReference">;
+  readonly identifier: Schema.String;
+  readonly label: Schema.optionalKey<Schema.String>;
+  readonly referenceType: Schema.Literals<readonly ["shortcut", "collapsed", "full"]>;
+  readonly children: Schema.$Array<Schema.suspend<Schema.Codec<PhrasingContent, PhrasingContent, never, never>>>;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+}>, {}>;
+/**
+ * LinkReference — a link referring to a {@link Definition} by identifier
+ * (`[text][ref]`).
+ *
+ * Emitted unresolved, on the same terms as {@link ImageReference}.
+ *
+ * @public
+ */
+declare class LinkReference extends LinkReference_base {}
+declare const FootnoteReference_base: Schema.Class<FootnoteReference, Schema.Struct<{
+  readonly type: Schema.tag<"footnoteReference">;
+  readonly identifier: Schema.String;
+  readonly label: Schema.optionalKey<Schema.String>;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+}>, {}>;
+/**
+ * FootnoteReference — a GFM footnote marker (`[^alpha]`), associating this
+ * point in the text with a {@link FootnoteDefinition} by identifier.
+ *
+ * Has no content model of its own — the marker carries no children, only the
+ * mdast Association pair `identifier`/`label`. Like {@link LinkReference},
+ * the parser emits these unresolved: resolution against a matching
+ * `FootnoteDefinition` is the consumer's business.
+ *
+ * @public
+ */
+declare class FootnoteReference extends FootnoteReference_base {}
+/**
+ * The union of every node that may appear where mdast expects **phrasing**
+ * content — the text of a document and its markup.
+ *
+ * Defined lazily via `Schema.suspend` to break the recursive reference chain
+ * `PhrasingContent -> Emphasis/Strong/Link/LinkReference -> PhrasingContent`.
+ *
+ * @public
+ */
+declare const PhrasingContent: Schema.Codec<PhrasingContent>;
+/**
+ * The union of all phrasing-content node types.
+ *
+ * @public
+ */
+type PhrasingContent = Break | Delete | Emphasis | FootnoteReference | Html | Image | ImageReference | InlineCode | Link | LinkReference | Strong | Text;
+declare const ThematicBreak_base: Schema.Class<ThematicBreak, Schema.Struct<{
+  readonly type: Schema.tag<"thematicBreak">;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+  readonly markerChar: Schema.optionalKey<Schema.Literals<readonly ["-", "_", "*"]>>;
+}>, {}>;
+/**
+ * ThematicBreak — a horizontal rule (`---`, `***`, `___`).
+ *
+ * `markerChar` is a fidelity extra recording which character drew it.
+ *
+ * @public
+ */
+declare class ThematicBreak extends ThematicBreak_base {}
+declare const Code_base: Schema.Class<Code, Schema.Struct<{
+  readonly type: Schema.tag<"code">;
+  readonly value: Schema.String;
+  readonly lang: Schema.optionalKey<Schema.String>;
+  readonly meta: Schema.optionalKey<Schema.String>;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+  readonly fenceChar: Schema.optionalKey<Schema.Literals<readonly ["`", "~"]>>;
+  readonly fenceLength: Schema.optionalKey<Schema.Number>;
+}>, {}>;
+/**
+ * Code — a code block, fenced or indented.
+ *
+ * `lang` and `meta` split the fence's info string at the first run of
+ * whitespace. The fidelity extras `fenceChar` and `fenceLength` are present
+ * for fenced blocks and **absent for indented blocks** — their absence is how
+ * the two are told apart on the way back out.
+ *
+ * @public
+ */
+declare class Code extends Code_base {}
+declare const Definition_base: Schema.Class<Definition, Schema.Struct<{
+  readonly type: Schema.tag<"definition">;
+  readonly identifier: Schema.String;
+  readonly label: Schema.optionalKey<Schema.String>;
+  readonly url: Schema.String;
+  readonly title: Schema.optionalKey<Schema.String>;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+}>, {}>;
+/**
+ * Definition — a link reference definition (`[ref]: /url "title"`).
+ *
+ * Kept in the tree at its source position rather than stripped, which is the
+ * deliberate departure from commonmark.js and the reason references can stay
+ * unresolved.
+ *
+ * @public
+ */
+declare class Definition extends Definition_base {}
+declare const FootnoteDefinition_base: Schema.Class<FootnoteDefinition, Schema.Struct<{
+  readonly type: Schema.tag<"footnoteDefinition">;
+  readonly identifier: Schema.String;
+  readonly label: Schema.optionalKey<Schema.String>;
+  readonly children: Schema.$Array<Schema.suspend<Schema.Codec<FlowContent, FlowContent, never, never>>>;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+}>, {}>;
+/**
+ * FootnoteDefinition — a GFM footnote definition (`[^alpha]: bravo.`), the
+ * content a {@link FootnoteReference} points at.
+ *
+ * Kept in the tree at its source position, on the same terms as
+ * {@link Definition} — the parser never relocates it; a consumer that wants
+ * cmark-gfm's end-of-document footnote section renders it there instead.
+ *
+ * @public
+ */
+declare class FootnoteDefinition extends FootnoteDefinition_base {}
+declare const Paragraph_base: Schema.Class<Paragraph, Schema.Struct<{
+  readonly type: Schema.tag<"paragraph">;
+  readonly children: Schema.$Array<Schema.suspend<Schema.Codec<PhrasingContent, PhrasingContent, never, never>>>;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+}>, {}>;
+/**
+ * Paragraph — a run of phrasing content.
+ *
+ * @public
+ */
+declare class Paragraph extends Paragraph_base {}
+declare const Heading_base: Schema.Class<Heading, Schema.Struct<{
+  readonly type: Schema.tag<"heading">;
+  readonly depth: Schema.Literals<readonly [1, 2, 3, 4, 5, 6]>;
+  readonly children: Schema.$Array<Schema.suspend<Schema.Codec<PhrasingContent, PhrasingContent, never, never>>>;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+  readonly headingStyle: Schema.optionalKey<Schema.Literals<readonly ["atx", "setext"]>>;
+}>, {}>;
+/**
+ * Heading — an ATX or setext heading of depth 1 to 6.
+ *
+ * `headingStyle` is a fidelity extra recording which spelling produced it;
+ * setext headings can only be depth 1 or 2.
+ *
+ * @public
+ */
+declare class Heading extends Heading_base {}
+declare const ListItem_base: Schema.Class<ListItem, Schema.Struct<{
+  readonly type: Schema.tag<"listItem">;
+  readonly spread: Schema.optionalKey<Schema.Boolean>;
+  readonly children: Schema.$Array<Schema.suspend<Schema.Codec<FlowContent, FlowContent, never, never>>>;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+  readonly checked: Schema.optionalKey<Schema.Boolean>;
+}>, {}>;
+/**
+ * ListItem — one item of a {@link List}.
+ *
+ * `spread` follows mdast in being optional: absent means "not known", which a
+ * hand-built tree may legitimately be. The parser always sets it.
+ *
+ * `checked` is a GFM extra (task-list items, `- [ ] foo` / `- [x] foo`):
+ * `true` for done, `false` for not done, and **absent** — never `null` — for
+ * an item that is not a task-list item at all. The parser only ever sets it
+ * on items it recognized as task-list markers.
+ *
+ * @public
+ */
+declare class ListItem extends ListItem_base {}
+declare const List_base: Schema.Class<List, Schema.Struct<{
+  readonly type: Schema.tag<"list">;
+  readonly ordered: Schema.optionalKey<Schema.Boolean>;
+  readonly start: Schema.optionalKey<Schema.Number>;
+  readonly spread: Schema.optionalKey<Schema.Boolean>;
+  readonly children: Schema.$Array<Schema.suspend<Schema.Codec<ListItem, ListItem, never, never>>>;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+  readonly bulletChar: Schema.optionalKey<Schema.Literals<readonly ["-", "*", "+"]>>;
+  readonly delimiter: Schema.optionalKey<Schema.Literals<readonly [".", ")"]>>;
+}>, {}>;
+/**
+ * List — an ordered or unordered list.
+ *
+ * `ordered`, `start` and `spread` are all optional per mdast (absent meaning
+ * "not known"); the parser always sets `ordered` and `spread`, and sets
+ * `start` only for ordered lists.
+ *
+ * The fidelity extras record the marker actually used: `bulletChar` for
+ * unordered lists, `delimiter` for ordered ones.
+ *
+ * @public
+ */
+declare class List extends List_base {}
+declare const Blockquote_base: Schema.Class<Blockquote, Schema.Struct<{
+  readonly type: Schema.tag<"blockquote">;
+  readonly children: Schema.$Array<Schema.suspend<Schema.Codec<FlowContent, FlowContent, never, never>>>;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+}>, {}>;
+/**
+ * Blockquote — a section quoted from somewhere else.
+ *
+ * @public
+ */
+declare class Blockquote extends Blockquote_base {}
+declare const TableCell_base: Schema.Class<TableCell, Schema.Struct<{
+  readonly type: Schema.tag<"tableCell">;
+  readonly children: Schema.$Array<Schema.suspend<Schema.Codec<PhrasingContent, PhrasingContent, never, never>>>;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+}>, {}>;
+/**
+ * TableCell — one cell of a {@link TableRow}: a header cell if its
+ * grandparent {@link Table}'s first row, a data cell otherwise.
+ *
+ * mdast's content model for `TableCell` is phrasing content **excluding**
+ * `Break` nodes — GFM tables are single-line source, so a hard break cannot
+ * occur inside one. This schema does not carve that exclusion out of
+ * `PhrasingContent`: a second phrasing union just for table cells would
+ * duplicate the whole recursive-suspend machinery above for one excluded
+ * member, and a parser that never emits `Break` inside a cell satisfies the
+ * exclusion in practice without it.
+ *
+ * @public
+ */
+declare class TableCell extends TableCell_base {}
+/**
+ * The union of every node that may appear where mdast expects **row**
+ * content — the cells in a {@link TableRow}. A one-member union, kept because
+ * mdast names the category.
+ *
+ * @public
+ */
+declare const RowContent: Schema.Codec<RowContent>;
+/**
+ * The union of all row-content node types.
+ *
+ * @public
+ */
+type RowContent = TableCell;
+declare const TableRow_base: Schema.Class<TableRow, Schema.Struct<{
+  readonly type: Schema.tag<"tableRow">;
+  readonly children: Schema.$Array<Schema.suspend<Schema.Codec<TableCell, TableCell, never, never>>>;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+}>, {}>;
+/**
+ * TableRow — one row of a {@link Table}: the labels of the columns if it is
+ * the table's first row, a data row otherwise.
+ *
+ * @public
+ */
+declare class TableRow extends TableRow_base {}
+/**
+ * The union of every node that may appear where mdast expects **table**
+ * content — the rows in a {@link Table}. A one-member union, kept because
+ * mdast names the category.
+ *
+ * @public
+ */
+declare const TableContent: Schema.Codec<TableContent>;
+/**
+ * The union of all table-content node types.
+ *
+ * @public
+ */
+type TableContent = TableRow;
+declare const Table_base: Schema.Class<Table, Schema.Struct<{
+  readonly type: Schema.tag<"table">;
+  readonly align: Schema.optionalKey<Schema.$Array<Schema.NullOr<Schema.Literals<readonly ["left", "right", "center"]>>>>;
+  readonly children: Schema.$Array<Schema.suspend<Schema.Codec<TableRow, TableRow, never, never>>>;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+}>, {}>;
+/**
+ * Table — GFM two-dimensional data.
+ *
+ * `align` is optional per mdast: absent means "not known" — which the parser
+ * never produces, since a GFM table's delimiter row always yields one
+ * `TableAlign | null` entry per column, but a hand-built tree may omit it.
+ * When present, each entry is `null` for a column with no declared alignment.
+ *
+ * @public
+ */
+declare class Table extends Table_base {}
+/**
+ * The union of every node that may appear where mdast expects **flow**
+ * content — the sections of a document.
+ *
+ * Defined lazily via `Schema.suspend` to break the recursive reference chain
+ * `FlowContent -> Blockquote/List -> FlowContent`. Widened for GFM with
+ * {@link FootnoteDefinition} and {@link Table}, per mdast's `FlowContent`
+ * (GFM) category.
+ *
+ * @public
+ */
+declare const FlowContent: Schema.Codec<FlowContent>;
+/**
+ * The union of all flow-content node types. Includes mdast's `Content`
+ * category (`Definition | Paragraph`) inline, as the spec's `FlowContent`
+ * definition does, and the GFM extras `FootnoteDefinition` and `Table`.
+ *
+ * @public
+ */
+type FlowContent = Blockquote | Code | Definition | FootnoteDefinition | Heading | Html | List | Paragraph | Table | ThematicBreak;
+/**
+ * The union of every node that may appear where mdast expects **list**
+ * content. A one-member union, kept because mdast names the category and
+ * later dialects widen it.
+ *
+ * @public
+ */
+declare const ListContent: Schema.Codec<ListContent>;
+/**
+ * The union of all list-content node types.
+ *
+ * @public
+ */
+type ListContent = ListItem;
+/**
+ * The frontmatter formats the capture recognizes, keyed by their opening
+ * fence: `---` is yaml, `+++` is toml and `---json` is json.
+ *
+ * @public
+ */
+declare const FrontmatterFormat: Schema.Literals<readonly ["yaml", "toml", "json"]>;
+/**
+ * The union of all frontmatter format string literals.
+ *
+ * @public
+ */
+type FrontmatterFormat = typeof FrontmatterFormat.Type;
+declare const Frontmatter_base: Schema.Class<Frontmatter, Schema.Struct<{
+  readonly type: Schema.tag<"frontmatter">;
+  readonly format: Schema.Literals<readonly ["yaml", "toml", "json"]>;
+  readonly value: Schema.String;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+}>, {}>;
+/**
+ * Frontmatter — the raw, fidelity-preserving capture of a document's metadata
+ * block. `value` is the source text between the fences, exactly as written
+ * (never inline-parsed, never decoded); `format` records which fence captured
+ * it. The position spans the whole block including both fence lines.
+ *
+ * mdast has no single frontmatter node: it names `yaml` in the readme and
+ * `toml` through the frontmatter extension, and json has no mdast name at
+ * all. This package captures all three through ONE node — the design doc's
+ * "text plus a format marker" — and the `Mdast` projection (P5) maps
+ * `format` onto the mdast type names where they exist. Decoding the value is
+ * the codec modules' job (`YamlFrontmatter`/`TomlFrontmatter`/
+ * `JsonFrontmatter`, P3 Task 2); the engine never looks inside it.
+ *
+ * Only ever the first child of {@link Root}, and only when parsing opted in
+ * via `MarkdownParseOptions.frontmatter` — mdast's "limited to one node, only
+ * as head" constraint is structural here, not validated.
+ *
+ * @public
+ */
+declare class Frontmatter extends Frontmatter_base {}
+/**
+ * The union of every node that may appear where mdast expects
+ * **frontmatter** content — a one-member union, kept because mdast names the
+ * category (its member there is `Yaml`; ours is the format-agnostic capture).
+ *
+ * @public
+ */
+declare const FrontmatterContent: Schema.Codec<FrontmatterContent>;
+/**
+ * The union of all frontmatter-content node types.
+ *
+ * @public
+ */
+type FrontmatterContent = Frontmatter;
+declare const Root_base: Schema.Class<Root, Schema.Struct<{
+  readonly type: Schema.tag<"root">;
+  readonly children: Schema.$Array<Schema.suspend<Schema.Codec<Frontmatter | FlowContent, Frontmatter | FlowContent, never, never>>>;
+  readonly position: Schema.withConstructorDefault<typeof Position>;
+}>, {}>;
+/**
+ * Root — a whole document, and the only node that is never a child.
+ *
+ * mdast leaves a root's content model open; a parsed markdown document is
+ * flow content, optionally headed by one {@link Frontmatter} node — mdast's
+ * `FlowContentFrontmatter` merge, which admits frontmatter at the root and
+ * nowhere else.
+ *
+ * @public
+ */
+declare class Root extends Root_base {}
+/**
+ * The union of every mdast node type this package produces — the content
+ * categories plus {@link Root}.
+ *
+ * @public
+ */
+type MarkdownNode = Root | FrontmatterContent | FlowContent | ListContent | PhrasingContent | RowContent | TableContent;
+/**
+ * A schema matching any node in the tree.
+ *
+ * @public
+ */
+declare const MarkdownNode: Schema.Codec<MarkdownNode>;
+/**
+ * The union of every node `type` tag this package produces — the selector
+ * vocabulary of `MarkdownDocument.find`/`findAll`.
+ *
+ * @public
+ */
+type MarkdownNodeType = MarkdownNode["type"];
+/**
+ * The node class whose `type` tag is `T` — how a type-string selector narrows
+ * its result (`MarkdownNodeOfType<"heading">` is {@link Heading}).
+ *
+ * @public
+ */
+type MarkdownNodeOfType<T extends MarkdownNodeType> = Extract<MarkdownNode, {
+  readonly type: T;
+}>;
+//#endregion
+//#region src/MarkdownDiagnostic.d.ts
+/**
+ * Error codes `Markdown.parse`/`MarkdownDocument.parse` can fail with. P1
+ * registers exactly the hardening-guard trip; later phases widen the union
+ * as new fatal (as opposed to diagnostic-only) conditions are identified.
+ *
+ * @public
+ */
+declare const MarkdownParseErrorCode: Schema.Literals<readonly ["NestingDepthExceeded"]>;
+/**
+ * The union of all markdown parse-error code string literals.
+ *
+ * @public
+ */
+type MarkdownParseErrorCode = typeof MarkdownParseErrorCode.Type;
+declare const MarkdownDiagnostic_base: Schema.Class<MarkdownDiagnostic, Schema.Struct<{
+  readonly code: Schema.Literals<readonly ["NestingDepthExceeded"]>;
+  readonly message: Schema.String;
+  readonly offset: Schema.Number;
+  readonly length: Schema.Number;
+  readonly line: Schema.Number;
+  readonly character: Schema.Number;
+}>, {}>;
+/**
+ * One structured diagnostic: its {@link (MarkdownParseErrorCode:type)}, a
+ * human-readable `message`, and its exact position (`offset`/`length`, plus
+ * zero-based `line`/`character`).
+ *
+ * @remarks
+ * The five-field positional core (`code`/`offset`/`length`/`line`/`character`)
+ * is structurally identical to `@effected/toml`'s `TomlDiagnostic` (and, by
+ * the same cross-package contract, `@effected/jsonc`'s parse-error detail
+ * shape and `@effected/yaml`'s `YamlDiagnostic`); `message` is this
+ * package's additive extra. `line`/`character` here are zero-based to match
+ * that contract — a different numbering from the one-based `line`/`column`
+ * unist `Point`s carried on `MarkdownNode` positions (`internal/lineIndex.ts`),
+ * which is a deliberate, unrelated convention for the AST rather than a
+ * mismatch to reconcile.
+ *
+ * @public
+ */
+declare class MarkdownDiagnostic extends MarkdownDiagnostic_base {
+  /**
+   * Materialize an engine record, deriving zero-based `line`/`character`
+   * from `offset` against the source `text`. Advanced — the parse entry
+   * points call this for you.
+   */
+  static fromRaw(source: string, raw: {
+    readonly code: MarkdownParseErrorCode;
+    readonly message: string;
+    readonly offset: number;
+    readonly length: number;
+  }): MarkdownDiagnostic;
+}
+//#endregion
+//#region src/Markdown.d.ts
+/**
+ * The markdown dialects the parser can be pointed at. `"gfm"` — CommonMark
+ * 0.31.2 plus the GitHub extensions (tables, strikethrough, autolink
+ * literals, task-list items, footnotes, and the tagfilter's output contract)
+ * — is the default; `"commonmark"` opts out of every extension. A dialect is
+ * a registry composition in the engine, so widening this union is additive
+ * and never changes an existing dialect's behavior.
+ *
+ * @public
+ */
+declare const MarkdownDialect: Schema.Literals<readonly ["commonmark", "gfm"]>;
+/**
+ * The union of all markdown dialect string literals.
+ *
+ * @public
+ */
+type MarkdownDialect = typeof MarkdownDialect.Type;
+declare const MarkdownParseOptions_base: Schema.Class<MarkdownParseOptions, Schema.Struct<{
+  readonly dialect: Schema.optionalKey<Schema.Literals<readonly ["commonmark", "gfm"]>>;
+  readonly frontmatter: Schema.optionalKey<Schema.Boolean>;
+}>, {}>;
+/**
+ * Options controlling parse behavior: `dialect` (omitted, `"gfm"`) and
+ * `frontmatter` (omitted, `false` — capture is opt-in).
+ *
+ * @remarks
+ * Frontmatter capture is OFF by default because it changes how a document
+ * opening with `---` parses: CommonMark reads the fence document
+ * `---\nfoo: bar\n---` as a thematic break and a setext heading, and that
+ * spec-conformant reading must hold unless a consumer opts in. Enabled, the
+ * engine captures `---`/`+++`/`---json` blocks at offset 0 into a raw
+ * `Frontmatter` head node — decoding it is the frontmatter codec modules'
+ * job.
+ *
+ * @public
+ */
+declare class MarkdownParseOptions extends MarkdownParseOptions_base {}
+declare const MarkdownParseError_base: Schema.Class<MarkdownParseError, Schema.TaggedStruct<"MarkdownParseError", {
+  readonly diagnostic: typeof MarkdownDiagnostic;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Parse failure: the {@link MarkdownDiagnostic} describing why the document
+ * was rejected.
+ *
+ * @remarks
+ * CommonMark has no syntax errors — every string is a valid document — so
+ * this error carries only hardening-guard trips (P1: `NestingDepthExceeded`).
+ * Recoverable oddities are diagnostics on {@link MarkdownDocument}, not
+ * failures. A malformed-looking document parses; a nesting bomb fails here
+ * rather than crashing with a `RangeError`.
+ *
+ * @public
+ */
+declare class MarkdownParseError extends MarkdownParseError_base {
+  get message(): string;
+}
+declare const MarkdownStringifyError_base: Schema.Class<MarkdownStringifyError, Schema.TaggedStruct<"MarkdownStringifyError", {
+  readonly diagnostic: typeof MarkdownDiagnostic;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Stringify failure: the {@link MarkdownDiagnostic} describing why the tree
+ * was refused.
+ *
+ * @remarks
+ * Serialization is total over parser-produced trees — the parser cannot
+ * produce one that nests past the guard, because parsing it would have been
+ * refused first. The only failures here are hardening-guard trips on
+ * synthesized or decoded hostile trees, symmetric with
+ * {@link MarkdownParseError}'s posture on parse. Stringify has no source
+ * text to derive positions from, so the diagnostic's `line`/`character` are
+ * `0` and `offset` carries whatever the offending node's position claimed.
+ *
+ * @public
+ */
+declare class MarkdownStringifyError extends MarkdownStringifyError_base {
+  get message(): string;
+}
+/**
+ * The markdown facade: parse markdown source — GFM by default, CommonMark by
+ * option — into an mdast-shaped {@link Root} tree, as a pure `Result` or as
+ * an `Effect`.
+ *
+ * @public
+ */
+declare class Markdown {
+  /**
+   * Parse markdown into a {@link Root} tree, synchronously, as a `Result`.
+   * The pure primitive: a non-Effect caller (a build script, a Vite plugin,
+   * a language-server tick) can call this directly instead of wrapping
+   * `Effect.runSync(Effect.result(Markdown.parse(text)))`.
+   *
+   * @remarks
+   * {@link Markdown.parse} is defined in terms of this function; the two
+   * never diverge. Reach for the `Effect` variant inside Effect code — it
+   * carries the `Markdown.parse` tracing span — and for this one at
+   * synchronous boundaries. This function carries no span: it is not an
+   * `Effect`.
+   *
+   * Failure is rare by design: every string is a valid markdown document in
+   * both dialects, so the only failures are hardening-guard trips such as
+   * nesting past the 256-container cap. Programmer errors are not converted
+   * — they propagate as thrown defects.
+   *
+   * @example
+   * ```ts
+   * import { Markdown } from "@effected/markdown";
+   * import { Result } from "effect";
+   *
+   * const ok = Markdown.parseResult("# Title\n\nBody *text*.\n");
+   * if (Result.isSuccess(ok)) {
+   *   console.log(ok.success.children.length); // => 2
+   * }
+   * ```
+   *
+   * @param text - The markdown source to parse.
+   * @param options - Optional {@link MarkdownParseOptions}; the dialect
+   *   defaults to `"gfm"`.
+   * @returns A `Result` succeeding with the document {@link Root}, or
+   *   failing with {@link MarkdownParseError}.
+   */
+  static parseResult(text: string, options?: MarkdownParseOptions): Result.Result<Root, MarkdownParseError>;
+  /**
+   * Parse markdown into a {@link Root} tree. Defined in terms of
+   * {@link Markdown.parseResult} — synchronous callers can use that variant
+   * directly.
+   *
+   * @param text - The markdown source to parse.
+   * @param options - Optional {@link MarkdownParseOptions}; the dialect
+   *   defaults to `"gfm"`.
+   * @returns An `Effect` that succeeds with the document {@link Root}, or
+   *   fails with {@link MarkdownParseError}.
+   */
+  static readonly parse: (text: string, options?: MarkdownParseOptions | undefined) => Effect.Effect<Root, MarkdownParseError, never>;
+  /**
+   * Serialize a {@link Root} tree to canonical markdown, synchronously, as a
+   * `Result`. The pure primitive twin of {@link Markdown.stringify}, on the
+   * same terms as {@link Markdown.parseResult}.
+   *
+   * @remarks
+   * Canonical serialization: fidelity fields (marker characters, fence
+   * style, heading spelling) win when present; documented canonical
+   * defaults apply when absent. The output re-parses to a render-equivalent
+   * document — the corpus-pinned contract — but is not a byte-level
+   * round-trip of any original source; surgical editing goes through the
+   * offset-splice edit layer instead.
+   *
+   * Failure is rare by design, symmetric with parse: only a hardening-guard
+   * trip on a tree nesting past the depth cap fails, and only synthesized
+   * or decoded trees can nest that far.
+   *
+   * @param root - The document tree to serialize.
+   * @returns A `Result` succeeding with markdown source, or failing with
+   *   {@link MarkdownStringifyError}.
+   */
+  static stringifyResult(root: Root): Result.Result<string, MarkdownStringifyError>;
+  /**
+   * Serialize a {@link Root} tree to canonical markdown. Defined in terms of
+   * {@link Markdown.stringifyResult} — synchronous callers can use that
+   * variant directly.
+   *
+   * @param root - The document tree to serialize.
+   * @returns An `Effect` that succeeds with markdown source, or fails with
+   *   {@link MarkdownStringifyError}.
+   */
+  static readonly stringify: (root: Root) => Effect.Effect<string, MarkdownStringifyError, never>;
+  /**
+   * A `Schema<Root, string>` decoding markdown source into a {@link Root}
+   * tree and encoding a tree back to canonical markdown via
+   * {@link Markdown.stringifyResult}.
+   *
+   * @remarks
+   * Schema-producing: each call returns a fresh schema whose derivation
+   * caches are not shared across calls. Bind the result to a `const` on hot
+   * paths; the pre-bound {@link Markdown.MarkdownFromString} covers the
+   * common case.
+   *
+   * @param options - Optional {@link MarkdownParseOptions} applied on
+   *   decode.
+   * @returns A `Schema.Codec<Root, string>`.
+   */
+  static fromString(options?: MarkdownParseOptions): Schema.Codec<Root, string>;
+  /**
+   * The zero-config `Schema<Root, string>` — `Markdown.fromString()`
+   * pre-bound so the common case needs no memoization discipline.
+   */
+  static readonly MarkdownFromString: Schema.Codec<Root, string>;
+}
+//#endregion
+//#region src/MarkdownEdit.d.ts
+/**
+ * A single path segment: a `number` for child indices in the node tree, or a
+ * `string` for named addressing (reserved for the navigation surface — e.g.
+ * definition identifiers — which arrives with the visitor phase).
+ *
+ * @public
+ */
+type MarkdownSegment = string | number;
+/**
+ * An ordered sequence of {@link MarkdownSegment} values describing a location
+ * within a markdown document tree.
+ *
+ * @public
+ */
+type MarkdownPath = ReadonlyArray<MarkdownSegment>;
+declare const MarkdownRange_base: Schema.Class<MarkdownRange, Schema.Struct<{
+  readonly offset: Schema.Number;
+  readonly length: Schema.Number;
+}>, {}>;
+/**
+ * A range within a markdown document, expressed as a zero-based character
+ * `offset` and a `length` in UTF-16 code units. Pass to `MarkdownFormat.format`
+ * to restrict formatting to a region.
+ *
+ * @public
+ */
+declare class MarkdownRange extends MarkdownRange_base {}
+declare const MarkdownEdit_base: Schema.Class<MarkdownEdit, Schema.Struct<{
+  readonly offset: Schema.Number;
+  readonly length: Schema.Number;
+  readonly content: Schema.String;
+}>, {}>;
+/**
+ * A non-mutating text edit: replace the span `[offset, offset + length)` with
+ * `content`. Set `length` to `0` to insert, `content` to `""` to delete.
+ *
+ * @remarks
+ * Structurally identical to `@effected/jsonc`'s, `@effected/yaml`'s and
+ * `@effected/toml`'s edit shapes (same field names, types and semantics) per
+ * the cross-package parity convention, so consumer code can be written once
+ * over "a document codec's Edit/Range/Path".
+ *
+ * @public
+ */
+declare class MarkdownEdit extends MarkdownEdit_base {
+  /**
+   * Apply `edits` to `text`, producing a new string. Edits are applied in
+   * reverse-offset order so earlier offsets stay valid; the input `edits`
+   * array is not mutated. Overlapping edits are a programmer error and throw
+   * as a defect — `MarkdownFormat` never produces them.
+   */
+  static applyAll(text: string, edits: ReadonlyArray<MarkdownEdit>): string;
+}
+//#endregion
+//#region src/MarkdownDocument.d.ts
+/**
+ * A heading entry from {@link MarkdownDocument.headings}: the {@link Heading}
+ * node plus the derivations navigation wants — its `depth` and its plain-text
+ * content.
+ *
+ * @remarks
+ * `text` concatenates the values of text and inline-code descendants, uses
+ * image `alt` text where present, renders a hard break as a single space and
+ * contributes nothing for raw HTML or footnote references.
+ *
+ * @public
+ */
+interface DocumentHeading {
+  readonly node: Heading;
+  readonly depth: HeadingDepth;
+  readonly text: string;
+}
+/**
+ * A heading-delimited span from {@link MarkdownDocument.sections}: the
+ * heading, its depth, the source `range` the section occupies and the
+ * root-level blocks that follow the heading inside it.
+ *
+ * @remarks
+ * A section runs from its heading's start offset to the start of the next
+ * root-level heading of equal or shallower depth, or to the end of the
+ * source. Deeper headings nest inside, so a parent section's `range` and
+ * `children` include its subsections — the list is flat, in document order,
+ * with `depth` carrying the hierarchy.
+ *
+ * @public
+ */
+interface DocumentSection {
+  readonly heading: Heading;
+  readonly depth: HeadingDepth;
+  readonly range: MarkdownRange;
+  readonly children: ReadonlyArray<FlowContent>;
+}
+/**
+ * The node types {@link MarkdownDocument.links} collects: the nodes that
+ * carry an outbound URL themselves ({@link Link}, {@link Image},
+ * {@link Definition}) and the reference nodes that reach one through the
+ * definition index ({@link LinkReference}, {@link ImageReference}).
+ *
+ * @public
+ */
+type LinkBearingNode = Link | Image | Definition | LinkReference | ImageReference;
+/**
+ * A link entry from {@link MarkdownDocument.links}: the link-bearing node and
+ * the URL it points at.
+ *
+ * @remarks
+ * `url` is the node's own `url` field, unmodified — bundle-relative and
+ * otherwise non-normalized hrefs pass through exactly as written. For
+ * reference nodes it is the matching definition's `url`; when no definition
+ * matches (possible only on trees decoded from foreign mdast — the parser
+ * never forms an unmatched reference), the field is genuinely absent.
+ *
+ * @public
+ */
+interface DocumentLink {
+  readonly node: LinkBearingNode;
+  readonly url?: string;
+}
+declare const MarkdownDocument_base: Schema.Class<MarkdownDocument, Schema.Struct<{
+  readonly source: Schema.String;
+  readonly root: typeof Root;
+  readonly diagnostics: Schema.$Array<typeof MarkdownDiagnostic>;
+  readonly definitions: Schema.$ReadonlyMap<Schema.String, typeof Definition>;
+}>, {}>;
+/**
+ * A parsed markdown document: the original `source`, the mdast-shaped
+ * {@link Root} tree, the non-fatal {@link MarkdownDiagnostic}s the parse
+ * produced, and the link-reference `definitions` index.
+ *
+ * @remarks
+ * The document is the lossless unit — `source` is retained so offsets on the
+ * tree stay meaningful and so P4's edit/format layer can splice against the
+ * exact bytes that were parsed.
+ *
+ * `definitions` is an index over the {@link Definition} nodes that remain in
+ * the tree, keyed by case-folded label with the first definition winning; it
+ * is not a place they were moved to. References are emitted unresolved, so
+ * resolution happens against this map.
+ *
+ * `diagnostics` is empty for every input the P1 parser accepts, and that is
+ * the current state of the world rather than a missing feature: the plumbing
+ * from the engine through to this field is real and exercised, but no P1
+ * construct emits a non-fatal diagnostic yet. The producers arrive with the
+ * conditions that warrant them — unresolved link references, and
+ * present-but-unparseable frontmatter in P3. Read an empty array as "nothing
+ * to report", not as "not implemented", and do not code against it staying
+ * empty.
+ *
+ * The navigation accessors (`headings`, `sections`, `links`) are derived
+ * getters over the tree — no stored state, no parse-time cost, and they can
+ * never disagree with the tree they read.
+ *
+ * @public
+ */
+declare class MarkdownDocument extends MarkdownDocument_base {
+  /**
+   * The document's frontmatter capture, or `undefined` when there is none.
+   *
+   * @remarks
+   * Derived from the tree rather than stored: a {@link Frontmatter} node can
+   * only ever sit at the head of `root.children` (the capture fires at most
+   * once, at offset 0), so the tree is the single source of truth and the
+   * accessor can never disagree with it. `undefined` covers both a document
+   * with no frontmatter block and one parsed with the capture toggle off.
+   */
+  get frontmatter(): Frontmatter | undefined;
+  /**
+   * Every heading in the document, in document order, wherever it sits —
+   * including headings nested inside blockquotes and list items.
+   *
+   * @remarks
+   * Each {@link DocumentHeading} carries the node, its depth and its
+   * plain-text content. For an outline restricted to section boundaries, use
+   * {@link MarkdownDocument.sections}, which considers root-level headings
+   * only.
+   */
+  get headings(): ReadonlyArray<DocumentHeading>;
+  /**
+   * The document's heading-delimited sections, flat and in document order.
+   *
+   * @remarks
+   * Only root-level headings delimit sections — a heading inside a
+   * blockquote or list cannot mark a span of root-level source. Content
+   * before the first heading (the preamble) and the frontmatter block belong
+   * to no section. Each {@link DocumentSection.range} is spliceable by the
+   * edit layer: it runs from the heading's start offset to the next
+   * boundary heading's start, or to the end of the source.
+   */
+  get sections(): ReadonlyArray<DocumentSection>;
+  /**
+   * Every link-bearing node in the document, in document order: links,
+   * images, definitions, and the reference forms resolved through the
+   * definition index.
+   *
+   * @remarks
+   * See {@link DocumentLink} for the url semantics — the raw `url` string
+   * passes through unmodified, and an unresolvable foreign reference leaves
+   * the field genuinely absent. Autolinks and GFM autolink literals are
+   * {@link Link} nodes, so they appear with no special casing. Footnote
+   * references carry no URL and are not link entries.
+   */
+  get links(): ReadonlyArray<DocumentLink>;
+  /**
+   * Find the first node matching a selector, in document pre-order — the
+   * same order {@link MarkdownVisitor} enters nodes, starting at the root
+   * itself.
+   *
+   * @remarks
+   * A string selector matches on the node's `type` tag and narrows the
+   * result (`find("heading")` is `Heading | undefined`); a type-guard
+   * predicate narrows the same way, and a plain predicate returns the wide
+   * `MarkdownNode` union. The returned node is the document's own — matched
+   * and returnable by identity, so it feeds `MarkdownFormat.modify`
+   * directly. Like the navigation getters, the walk is synchronous with no
+   * error channel: a tree nested past the depth cap (reachable only via a
+   * hand-built or foreign decoded tree) is a thrown defect.
+   *
+   * @param selector - A node `type` tag or a predicate over nodes.
+   * @returns The first matching node in document order, or `undefined`.
+   */
+  find<T extends MarkdownNodeType>(selector: T): MarkdownNodeOfType<T> | undefined;
+  find<T extends MarkdownNode>(selector: (node: MarkdownNode) => node is T): T | undefined;
+  find(selector: (node: MarkdownNode) => boolean): MarkdownNode | undefined;
+  /**
+   * Find every node matching a selector, in document pre-order — the same
+   * order {@link MarkdownVisitor} enters nodes, starting at the root itself.
+   *
+   * @remarks
+   * Selector and narrowing semantics are `MarkdownDocument.find`'s; so is
+   * the guard posture — an over-deep hand-built or foreign tree is a
+   * thrown defect. Nodes are the document's own, matched by identity, so
+   * `findAll("heading")[1]` addresses the second heading for
+   * `MarkdownFormat.modify` without raw child indexing.
+   *
+   * @param selector - A node `type` tag or a predicate over nodes.
+   * @returns Every matching node, in document order; empty when none match.
+   */
+  findAll<T extends MarkdownNodeType>(selector: T): ReadonlyArray<MarkdownNodeOfType<T>>;
+  findAll<T extends MarkdownNode>(selector: (node: MarkdownNode) => node is T): ReadonlyArray<T>;
+  findAll(selector: (node: MarkdownNode) => boolean): ReadonlyArray<MarkdownNode>;
+  /**
+   * Parse markdown into a {@link MarkdownDocument}, synchronously, as a
+   * `Result`. The pure primitive; {@link MarkdownDocument.parse} is defined
+   * in terms of it, so the two never diverge.
+   *
+   * @remarks
+   * Carries no span: it is not an `Effect`. Effect callers should reach for
+   * {@link MarkdownDocument.parse}, which carries the
+   * `MarkdownDocument.parse` tracing span.
+   *
+   * @param text - The markdown source to parse.
+   * @param options - Optional {@link MarkdownParseOptions}; the dialect
+   *   defaults to `"gfm"`.
+   * @returns A `Result` succeeding with the document, or failing with
+   *   `MarkdownParseError`.
+   */
+  static parseResult(text: string, options?: MarkdownParseOptions): Result.Result<MarkdownDocument, MarkdownParseError>;
+  /**
+   * Parse markdown into a {@link MarkdownDocument}. Defined in terms of
+   * {@link MarkdownDocument.parseResult} — synchronous callers can use that
+   * variant directly.
+   *
+   * @param text - The markdown source to parse.
+   * @param options - Optional {@link MarkdownParseOptions}; the dialect
+   *   defaults to `"gfm"`.
+   * @returns An `Effect` that succeeds with the document, or fails with
+   *   `MarkdownParseError`.
+   */
+  static readonly parse: (text: string, options?: MarkdownParseOptions | undefined) => Effect.Effect<MarkdownDocument, MarkdownParseError, never>;
+}
+//#endregion
+//#region src/Frontmatter.d.ts
+declare const FrontmatterFormatMismatchError_base: Schema.Class<FrontmatterFormatMismatchError, Schema.TaggedStruct<"FrontmatterFormatMismatchError", {
+  /** The format the codec decodes. */
+  readonly expected: Schema.Literals<readonly ["yaml", "toml", "json"]>;
+  /** The format the capture node actually carries. */
+  readonly actual: Schema.Literals<readonly ["yaml", "toml", "json"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Indicates that a frontmatter codec was handed a capture of a different
+ * format — a yaml codec applied to a `+++` toml capture, for example.
+ *
+ * @remarks
+ * The mismatch is detected before any parsing happens, so `cause`-free: the
+ * node's `format` marker and the codec's declared `format` simply disagree.
+ * Route on the `"FrontmatterFormatMismatchError"` tag with `Effect.catchTag`.
+ *
+ * @public
+ */
+declare class FrontmatterFormatMismatchError extends FrontmatterFormatMismatchError_base {
+  get message(): string;
+}
+declare const FrontmatterDecodeError_base: Schema.Class<FrontmatterDecodeError, Schema.TaggedStruct<"FrontmatterDecodeError", {
+  /** The format that failed to parse. */
+  readonly format: Schema.Literals<readonly ["yaml", "toml", "json"]>;
+  /** The underlying format-package failure, preserved structurally. */
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Indicates that a frontmatter capture's content failed to parse in its
+ * declared format.
+ *
+ * @remarks
+ * The underlying format package's failure is preserved structurally in
+ * `cause` — never stringified — so a consumer can reach the positioned
+ * diagnostics the format engines carry. Route on the
+ * `"FrontmatterDecodeError"` tag with `Effect.catchTag`.
+ *
+ * @public
+ */
+declare class FrontmatterDecodeError extends FrontmatterDecodeError_base {
+  get message(): string;
+}
+declare const FrontmatterEncodeError_base: Schema.Class<FrontmatterEncodeError, Schema.TaggedStruct<"FrontmatterEncodeError", {
+  /** The format that failed to serialize. */
+  readonly format: Schema.Literals<readonly ["yaml", "toml", "json"]>;
+  /** The underlying format-package failure, preserved structurally. */
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Indicates that frontmatter data failed to serialize in a codec's format.
+ *
+ * @remarks
+ * The exact mirror of {@link FrontmatterDecodeError} on the write side: the
+ * underlying format package's failure is preserved structurally in `cause` —
+ * never stringified — so a consumer can reach the typed stringify error the
+ * format engines carry (a `JsoncStringifyError`'s `code`, for example). Route
+ * on the `"FrontmatterEncodeError"` tag with `Effect.catchTag`.
+ *
+ * @public
+ */
+declare class FrontmatterEncodeError extends FrontmatterEncodeError_base {
+  get message(): string;
+}
+/**
+ * A frontmatter codec: how to turn a raw `Frontmatter` capture into decoded
+ * data, and data back into a serialized frontmatter body.
+ *
+ * @remarks
+ * The three built-in codecs — `YamlFrontmatter`, `TomlFrontmatter` and
+ * `JsonFrontmatter` — are free-standing named exports, one per module, each
+ * peering on its format package (`@effected/yaml`, `@effected/toml`,
+ * `@effected/jsonc`). They are deliberately never collected into a namespace
+ * object: name the one codec you use and a bundler drops the rest, engines
+ * included.
+ *
+ * A codec checks the capture's `format` marker before parsing and fails with
+ * {@link FrontmatterFormatMismatchError} when handed the wrong format;
+ * unparseable content fails with {@link FrontmatterDecodeError} carrying the
+ * format package's failure structurally.
+ *
+ * `encode` is the mirror: it serializes data to the body text that belongs
+ * between the fences — never the fences themselves, which are
+ * format-determined and rendered by the write seam
+ * ({@link MarkdownFrontmatter.set}). The engine's native output is returned
+ * as-is; the seam normalizes the final line terminator when fencing.
+ * Serialization failures — a circular reference, a value the format cannot
+ * represent — fail with {@link FrontmatterEncodeError} carrying the format
+ * package's failure structurally.
+ *
+ * @public
+ */
+interface FrontmatterCodec {
+  /** The format this codec decodes and encodes. */
+  readonly format: FrontmatterFormat;
+  /** Decode a capture node's raw value into data. */
+  readonly decode: (node: Frontmatter) => Effect.Effect<unknown, FrontmatterDecodeError | FrontmatterFormatMismatchError>;
+  /** Serialize data into a frontmatter body, without fences. */
+  readonly encode: (data: unknown) => Effect.Effect<string, FrontmatterEncodeError>;
+}
+declare const FrontmatterMissingError_base: Schema.Class<FrontmatterMissingError, Schema.TaggedStruct<"FrontmatterMissingError", {}>, import("effect/Cause").YieldableError>;
+/**
+ * Indicates that a document handed to a frontmatter decoder carries no
+ * frontmatter capture.
+ *
+ * @remarks
+ * Raised when the document genuinely has no frontmatter block — including
+ * when it has one in the source but was parsed with the capture toggle off
+ * (`MarkdownParseOptions.frontmatter` defaults to `false`). Cause-free: there
+ * is nothing to diagnose beyond the absence itself. Consumers wanting
+ * optional semantics can `Effect.catchTag("FrontmatterMissingError", ...)`
+ * to a default.
+ *
+ * @public
+ */
+declare class FrontmatterMissingError extends FrontmatterMissingError_base {
+  get message(): string;
+}
+declare const FrontmatterValidationError_base: Schema.Class<FrontmatterValidationError, Schema.TaggedStruct<"FrontmatterValidationError", {
+  /** The structured schema issue. Never a string. */
+  readonly issue: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Indicates that decoded frontmatter data did not satisfy the consumer's
+ * schema.
+ *
+ * @remarks
+ * `issue` carries the **structured** schema failure — at runtime a
+ * `SchemaIssue.Issue` tree, reachable through `_tag` and nested `issues` —
+ * never a stringified rendering (the `ConfigValidationError` precedent from
+ * `@effected/config-file`). It is typed `unknown` because v4 exposes no
+ * `Schema` for `Issue`; narrow it with the `SchemaIssue` module.
+ *
+ * @public
+ */
+declare class FrontmatterValidationError extends FrontmatterValidationError_base {
+  get message(): string;
+}
+/**
+ * The union of everything a composed frontmatter decoder can fail with.
+ *
+ * @public
+ */
+type FrontmatterSchemaError = FrontmatterMissingError | FrontmatterFormatMismatchError | FrontmatterDecodeError | FrontmatterValidationError;
+/**
+ * The union of everything the frontmatter write seam can fail with.
+ *
+ * @remarks
+ * Deliberately without `FrontmatterMissingError`: a document with no
+ * frontmatter capture is the **insert** path of {@link MarkdownFrontmatter.set},
+ * not an error.
+ *
+ * @public
+ */
+type FrontmatterWriteError = FrontmatterFormatMismatchError | FrontmatterEncodeError | FrontmatterValidationError;
+/**
+ * The frontmatter schema composition facade — typed gray-matter parity.
+ *
+ * @remarks
+ * The design doc's indicative spelling was `Frontmatter.schema`, but
+ * `Frontmatter` names the capture node class (the node classes co-locate in
+ * `MarkdownNode.ts` and are named after their mdast types), so the facade
+ * follows the package's Markdown-prefix convention instead.
+ *
+ * @public
+ */
+declare class MarkdownFrontmatter {
+  /**
+   * Compose a consumer schema with a {@link FrontmatterCodec} into a typed
+   * decoder over a parsed `MarkdownDocument`.
+   *
+   * @remarks
+   * The decoder reads the document's frontmatter capture (parse with
+   * `frontmatter: true` — the toggle defaults off), decodes its raw value
+   * through the codec, then validates the data against `schema`. Each stage
+   * fails typed: no capture is {@link FrontmatterMissingError}, a
+   * wrong-format codec is {@link FrontmatterFormatMismatchError}, unparseable
+   * content is {@link FrontmatterDecodeError}, and schema-invalid data is
+   * {@link FrontmatterValidationError} carrying the structured issue.
+   *
+   * The seam takes the parsed document, not raw source: parse options
+   * (dialect, the frontmatter toggle) stay at the consumer's parse call and
+   * are never guessed here. Node-level composition remains available through
+   * `MarkdownDocument.frontmatter` plus the codec's own `decode`.
+   *
+   * Schema-producing in spirit: bind the returned decoder to a `const` when
+   * decoding many documents.
+   *
+   * @param schema - The schema the decoded frontmatter data must satisfy.
+   * @param codec - The format codec to decode the raw capture with.
+   * @returns A function from a parsed document to an `Effect` of the typed
+   *   frontmatter data.
+   */
+  static schema<T, E, RD = never, RE = never>(schema: Schema.Codec<T, E, RD, RE>, codec: FrontmatterCodec): (document: MarkdownDocument) => Effect.Effect<T, FrontmatterSchemaError, RD>;
+  /**
+   * Compose a consumer schema with a {@link FrontmatterCodec} into a typed
+   * frontmatter **writer** over a parsed `MarkdownDocument` — the write
+   * mirror of {@link MarkdownFrontmatter.schema}.
+   *
+   * @remarks
+   * The writer schema-**encodes** the typed data, serializes it through the
+   * codec and returns the offset-splice edits that put the block in place —
+   * always exactly one:
+   *
+   * - A document **with** a frontmatter capture of the codec's format gets a
+   *   replacement of the entire block, both fence lines included; everything
+   *   outside the block survives byte-identical. A capture of a *different*
+   *   format fails with {@link FrontmatterFormatMismatchError} — the fences
+   *   are never switched.
+   * - A document with **no** capture gets one insert at offset 0: the fenced
+   *   block plus a blank line separating it from the existing content. Parse
+   *   with `frontmatter: true` (the toggle defaults off) — the same
+   *   precondition `schema` has — so absence means genuinely-no-frontmatter
+   *   and the insert cannot double a block the parse ignored.
+   *
+   * Each stage fails typed: schema-invalid data is
+   * {@link FrontmatterValidationError} carrying the structured issue, and a
+   * value the format cannot serialize is {@link FrontmatterEncodeError}
+   * carrying the format package's failure structurally.
+   *
+   * The block is re-serialized **whole** from the encoded data — gray-matter
+   * parity, not surgical editing — so anything the format's data model does
+   * not carry is not preserved: comments inside a yaml frontmatter block do
+   * **not** survive `set`. A per-key surgical mode over the format packages'
+   * edit layers is a documented future refinement, not current scope.
+   *
+   * Schema-producing in spirit: bind the returned writer to a `const` when
+   * writing many documents.
+   *
+   * @param schema - The schema the frontmatter data is encoded through.
+   * @param codec - The format codec to serialize the encoded data with.
+   * @returns A function from a parsed document and the typed data to an
+   *   `Effect` of the edits that install the block.
+   */
+  static set<T, E, RD = never, RE = never>(schema: Schema.Codec<T, E, RD, RE>, codec: FrontmatterCodec): (document: MarkdownDocument, data: T) => Effect.Effect<ReadonlyArray<MarkdownEdit>, FrontmatterWriteError, RE>;
+  /**
+   * Like {@link MarkdownFrontmatter.set}, but applies the edits to the
+   * document's source and returns the updated markdown text — the
+   * `modifyToString` parallel.
+   *
+   * @remarks
+   * Everything `set` documents holds verbatim: the whole-block
+   * re-serialization, the format-mismatch posture, the `frontmatter: true`
+   * precondition and the typed failures.
+   *
+   * @param schema - The schema the frontmatter data is encoded through.
+   * @param codec - The format codec to serialize the encoded data with.
+   * @returns A function from a parsed document and the typed data to an
+   *   `Effect` of the updated source text.
+   */
+  static setToString<T, E, RD = never, RE = never>(schema: Schema.Codec<T, E, RD, RE>, codec: FrontmatterCodec): (document: MarkdownDocument, data: T) => Effect.Effect<string, FrontmatterWriteError, RE>;
+}
+//#endregion
+//#region src/FrontmatterResolver.d.ts
+declare const SchemaDeclarationByUrl_base: Schema.Class<SchemaDeclarationByUrl, Schema.TaggedStruct<"ByUrl", {
+  /** The URL as written in the declaration. */
+  readonly url: Schema.String;
+}>, {}>;
+/**
+ * A `$schema` declaration referencing a schema by URL — any string containing
+ * `://`.
+ *
+ * @remarks
+ * Carried as data, never resolved in-package: the pure tier does no IO. An
+ * external resolver implementing {@link FrontmatterSchemaResolver} may fetch
+ * and interpret it.
+ *
+ * @public
+ */
+declare class SchemaDeclarationByUrl extends SchemaDeclarationByUrl_base {}
+declare const SchemaDeclarationByPath_base: Schema.Class<SchemaDeclarationByPath, Schema.TaggedStruct<"ByPath", {
+  /** The path as written in the declaration. */
+  readonly path: Schema.String;
+}>, {}>;
+/**
+ * A `$schema` declaration referencing a schema by path — any string starting
+ * `./`, `../` or `/` (a bundle- or file-relative reference).
+ *
+ * @remarks
+ * Carried as data, never resolved in-package: the pure tier does no IO.
+ *
+ * @public
+ */
+declare class SchemaDeclarationByPath extends SchemaDeclarationByPath_base {}
+declare const SchemaDeclarationInline_base: Schema.Class<SchemaDeclarationInline, Schema.TaggedStruct<"Inline", {
+  /** The inline schema document, exactly as decoded from the frontmatter. */
+  readonly document: Schema.Unknown;
+}>, {}>;
+/**
+ * A `$schema` declaration carrying an inline JSON-Schema-like document — the
+ * declaration value is itself a mapping.
+ *
+ * @remarks
+ * Carried as data: the kit deliberately ships no JSON Schema engine
+ * (`@effected/json-schema` is off the roadmap), so an inline document is
+ * interpretable only through an external resolver plugged into the
+ * {@link FrontmatterSchemaResolver} seam.
+ *
+ * @public
+ */
+declare class SchemaDeclarationInline extends SchemaDeclarationInline_base {}
+declare const SchemaDeclarationByName_base: Schema.Class<SchemaDeclarationByName, Schema.TaggedStruct<"ByName", {
+  /** The name as written, scope included. */
+  readonly name: Schema.String;
+  /** The version as written, when the declaration carries one. */
+  readonly version: Schema.optionalKey<Schema.String>;
+}>, {}>;
+/**
+ * A `$schema` declaration referencing a registered schema by name — any other
+ * string, with the committed `name[@version]` grammar.
+ *
+ * @remarks
+ * The string splits at the **last** `@`, so a leading npm-style scope
+ * survives: `@savvy/skill@2.1.0` is name `@savvy/skill`, version `2.1.0`.
+ * The version grammar is `X[.Y[.Z]]` — one to three dot-separated
+ * non-negative integers; no prerelease, no build metadata, no npm range
+ * operators. The recorded cost: `@` in a name is reserved forever as the
+ * version separator, except the leading scope `@`.
+ *
+ * @public
+ */
+declare class SchemaDeclarationByName extends SchemaDeclarationByName_base {}
+/**
+ * The classified `$schema` declaration union — the full grammar contract for
+ * how a frontmatter block may self-describe its schema.
+ *
+ * @public
+ */
+declare const SchemaDeclaration: Schema.Union<readonly [typeof SchemaDeclarationByUrl, typeof SchemaDeclarationByPath, typeof SchemaDeclarationInline, typeof SchemaDeclarationByName]>;
+/**
+ * The union of all classified `$schema` declaration shapes.
+ *
+ * @public
+ */
+type SchemaDeclaration = SchemaDeclarationByUrl | SchemaDeclarationByPath | SchemaDeclarationInline | SchemaDeclarationByName;
+declare const SchemaDeclarationInvalidError_base: Schema.Class<SchemaDeclarationInvalidError, Schema.TaggedStruct<"SchemaDeclarationInvalidError", {
+  /** Why the value failed to classify. */
+  readonly reason: Schema.String;
+  /** The offending value, preserved structurally. */
+  readonly value: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Indicates that a `$schema` value does not classify: not a string or a
+ * mapping, an empty string, or a name whose version segment falls outside the
+ * committed `X[.Y[.Z]]` grammar.
+ *
+ * @public
+ */
+declare class SchemaDeclarationInvalidError extends SchemaDeclarationInvalidError_base {
+  get message(): string;
+}
+declare const SchemaDeclarationMissingError_base: Schema.Class<SchemaDeclarationMissingError, Schema.TaggedStruct<"SchemaDeclarationMissingError", {}>, import("effect/Cause").YieldableError>;
+/**
+ * Indicates that frontmatter data carries no `$schema` declaration where one
+ * is required — the `requireDeclaration` strictness knob, or a registry
+ * resolver that has nothing to dispatch on.
+ *
+ * @public
+ */
+declare class SchemaDeclarationMissingError extends SchemaDeclarationMissingError_base {
+  get message(): string;
+}
+declare const SchemaNameUnknownError_base: Schema.Class<SchemaNameUnknownError, Schema.TaggedStruct<"SchemaNameUnknownError", {
+  /** The declaration that failed to resolve, when one exists. */
+  readonly declaration: Schema.optionalKey<Schema.Union<readonly [typeof SchemaDeclarationByUrl, typeof SchemaDeclarationByPath, typeof SchemaDeclarationInline, typeof SchemaDeclarationByName]>>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Indicates that a declaration named a schema the resolver does not know —
+ * an unregistered name, or a URL/path/inline declaration handed to the
+ * name-keyed registry resolver.
+ *
+ * @public
+ */
+declare class SchemaNameUnknownError extends SchemaNameUnknownError_base {
+  get message(): string;
+}
+declare const SchemaVersionUnresolvableError_base: Schema.Class<SchemaVersionUnresolvableError, Schema.TaggedStruct<"SchemaVersionUnresolvableError", {
+  /** The registered name whose version could not be satisfied. */
+  readonly name: Schema.String;
+  /** The requested version, when the declaration carried one. */
+  readonly version: Schema.optionalKey<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Indicates that a declaration's name is registered but its version segments
+ * match no registration exactly — distinct from {@link SchemaNameUnknownError}
+ * by design, so a legal-but-unsatisfied partial version (`skill@2` against a
+ * `skill@2.1.0` registration) is diagnosable as a version problem, not an
+ * unknown schema.
+ *
+ * @public
+ */
+declare class SchemaVersionUnresolvableError extends SchemaVersionUnresolvableError_base {
+  get message(): string;
+}
+/**
+ * The union of everything declaration resolution can fail with.
+ *
+ * @public
+ */
+type FrontmatterResolveError = SchemaDeclarationMissingError | SchemaNameUnknownError | SchemaVersionUnresolvableError;
+/**
+ * The resolver seam: given a classified declaration **and** the whole decoded
+ * frontmatter data, produce the schema to validate with, or fail typed.
+ *
+ * @remarks
+ * The whole-data second argument is the dispatch seam: because a resolver
+ * sees everything the frontmatter decoded to, it need not key on `$schema`
+ * at all — an OKF resolver dispatches on OKF's `type` field with zero OKF
+ * code in this package. `E` widens the error channel for custom resolvers;
+ * the built-in registry resolver keeps it `never`.
+ *
+ * @public
+ */
+interface FrontmatterSchemaResolver<E = never> {
+  /** Resolve a declaration (possibly absent) against decoded frontmatter data. */
+  readonly resolve: (declaration: SchemaDeclaration | undefined, data: unknown) => Effect.Effect<Schema.Top, FrontmatterResolveError | E>;
+}
+/**
+ * The `$schema` declaration classifier and the package's one built-in
+ * resolver implementation.
+ *
+ * @public
+ */
+declare class SchemaResolver {
+  /**
+   * Classify a raw `$schema` value into the declaration union.
+   *
+   * @remarks
+   * Total over its legal domain and typed on junk: a string containing
+   * `://` is {@link SchemaDeclarationByUrl}; a string starting `./`, `../`
+   * or `/` is {@link SchemaDeclarationByPath}; a mapping is
+   * {@link SchemaDeclarationInline}; any other non-empty string is
+   * {@link SchemaDeclarationByName} under the `name[@version]` grammar.
+   * Everything else — and a name whose version falls outside `X[.Y[.Z]]` —
+   * fails with {@link SchemaDeclarationInvalidError}.
+   *
+   * @param value - The raw `$schema` value from decoded frontmatter data.
+   * @returns The classified declaration, or the typed classification error.
+   */
+  static classify(value: unknown): Result.Result<SchemaDeclaration, SchemaDeclarationInvalidError>;
+  /**
+   * Extract and classify the `$schema` declaration from decoded frontmatter
+   * data.
+   *
+   * @remarks
+   * Non-mapping data and a mapping without a `$schema` key both carry no
+   * declaration: the result succeeds with `undefined` by default, or fails
+   * with {@link SchemaDeclarationMissingError} under `requireDeclaration` —
+   * the design's strictness knob, applied at extraction where the
+   * present-or-absent branch actually lives.
+   *
+   * @param data - The decoded frontmatter data.
+   * @param options - `requireDeclaration` makes a missing `$schema` a typed
+   *   error.
+   * @returns The classified declaration, `undefined` when absent and
+   *   tolerated, or the typed error.
+   */
+  static declarationOf(data: unknown, options?: {
+    readonly requireDeclaration?: boolean;
+  }): Result.Result<SchemaDeclaration | undefined, SchemaDeclarationInvalidError | SchemaDeclarationMissingError>;
+  /**
+   * The package's one built-in resolver: a name-keyed registry with day-one
+   * exact version-segment resolution.
+   *
+   * @remarks
+   * Registration keys use the same `name[@version]` grammar as declarations
+   * — carrying a concrete version or none — and are validated eagerly: a key
+   * outside the grammar, or two keys whose version segments collide
+   * numerically, throws at construction (programmer error, not input).
+   *
+   * Resolution is exact: a declaration resolves only against an identically
+   * written registration (version segments compared numerically), a
+   * versionless declaration only against a versionless registration, and a
+   * legal-but-unsatisfied version fails with the dedicated
+   * {@link SchemaVersionUnresolvableError}, distinct from
+   * {@link SchemaNameUnknownError}. URL, path and inline declarations are
+   * never resolvable here — those belong to external resolvers plugged into
+   * the same seam. A registry cannot dispatch without a declaration, so an
+   * absent one fails with {@link SchemaDeclarationMissingError}.
+   *
+   * @param registrations - Schemas keyed by `name[@version]`.
+   * @returns The registry-backed resolver.
+   */
+  static fromRegistry(registrations: Readonly<Record<string, Schema.Top>>): FrontmatterSchemaResolver;
+}
+//#endregion
+//#region src/JsonFrontmatter.d.ts
+/**
+ * The json frontmatter codec, over `@effected/jsonc`.
+ *
+ * @remarks
+ * Decodes a `---json`-fenced capture's raw value with `Jsonc.parse`, so the
+ * jsonc engine's nesting depth cap fails through the typed channel: a hostile
+ * frontmatter block surfaces as a {@link FrontmatterDecodeError} carrying the
+ * `JsoncParseError` structurally, never a defect. JSONC being a JSON
+ * superset, comments and trailing commas in a json capture decode rather than
+ * fail — deliberate leniency, matching the kit's one JSON-family engine. An
+ * empty capture fails typed: unlike yaml and toml, JSON has no
+ * empty-document value.
+ *
+ * Encodes with `Jsonc.stringify` — plain 2-space JSON emission, never
+ * comments; a circular reference, a `bigint` or a top-level unrepresentable
+ * value fails as a {@link FrontmatterEncodeError} carrying the
+ * `JsoncStringifyError` structurally. An empty object encodes to `{}`.
+ *
+ * `@effected/jsonc` is an optional peer — importing this module is what
+ * requires it; a consumer who never touches json frontmatter never loads the
+ * jsonc engine.
+ *
+ * @public
+ */
+declare const JsonFrontmatter: FrontmatterCodec;
+//#endregion
+//#region src/MarkdownFormat.d.ts
+/**
+ * A range accepted at the `format`/`formatToString` call sites: either a
+ * {@link MarkdownRange} instance or a plain `{ offset, length }` literal (the
+ * two are structurally interchangeable — only `offset`/`length` are read).
+ *
+ * @public
+ */
+type MarkdownRangeLike = MarkdownRange | {
+  readonly offset: number;
+  readonly length: number;
+};
+declare const MarkdownFormattingOptions_base: Schema.Class<MarkdownFormattingOptions, Schema.Struct<{
+  readonly dialect: Schema.optionalKey<Schema.Literals<readonly ["commonmark", "gfm"]>>;
+  readonly frontmatter: Schema.optionalKey<Schema.Boolean>;
+  readonly headingStyle: Schema.optionalKey<Schema.Literals<readonly ["atx", "setext"]>>;
+  readonly bulletChar: Schema.optionalKey<Schema.Literals<readonly ["-", "*", "+"]>>;
+  readonly emphasisChar: Schema.optionalKey<Schema.Literals<readonly ["*", "_"]>>;
+  readonly fenceChar: Schema.optionalKey<Schema.Literals<readonly ["`", "~"]>>;
+  readonly thematicBreakChar: Schema.optionalKey<Schema.Literals<readonly ["-", "_", "*"]>>;
+}>, {}>;
+/**
+ * Options controlling formatting: which concrete-syntax markers to normalize,
+ * plus the parse knobs (`dialect`, `frontmatter`) the formatter parses the
+ * source with (same defaults as `Markdown.parse`). Every marker option is
+ * optional and independent; an absent option normalizes nothing.
+ *
+ * Day-one scope is marker normalization only — heading style, bullet
+ * character, emphasis/strong marker, fence character, thematic-break
+ * character. Content is never rewritten, rewrapped or reflowed.
+ *
+ * @public
+ */
+declare class MarkdownFormattingOptions extends MarkdownFormattingOptions_base {}
+/**
+ * Error codes `MarkdownFormat.modify` can fail with.
+ *
+ * @public
+ */
+declare const MarkdownModificationErrorCode: Schema.Literals<readonly ["NodeNotInDocument", "UnsupportedTarget", "FragmentCategoryMismatch", "FragmentUnrenderable"]>;
+/**
+ * The union of all modification-error code string literals.
+ *
+ * @public
+ */
+type MarkdownModificationErrorCode = typeof MarkdownModificationErrorCode.Type;
+declare const MarkdownModificationError_base: Schema.Class<MarkdownModificationError, Schema.TaggedStruct<"MarkdownModificationError", {
+  readonly code: Schema.Literals<readonly ["NodeNotInDocument", "UnsupportedTarget", "FragmentCategoryMismatch", "FragmentUnrenderable"]>;
+  readonly detail: Schema.String;
+  readonly offset: Schema.Number;
+  readonly length: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Raised when `MarkdownFormat.modify` cannot perform the requested
+ * replacement: the target node is not in the document (`NodeNotInDocument`),
+ * the target kind or splice context is outside the day-one scope
+ * (`UnsupportedTarget`), the fragment's content category does not fit the
+ * target's slot (`FragmentCategoryMismatch`), or the fragment trips the
+ * stringifier's hardening guard (`FragmentUnrenderable`). Carries the typed
+ * `code` plus the target's `offset`/`length` where known — never a collapsed
+ * reason string alone.
+ *
+ * @public
+ */
+declare class MarkdownModificationError extends MarkdownModificationError_base {
+  get message(): string;
+}
+/**
+ * Formatting and modification statics. Not instantiable.
+ *
+ * @remarks
+ * `format`/`formatToString` are pure and total: input that trips a parse
+ * hardening guard yields no edits rather than corrupting the document, and
+ * every emitted edit is guarded against the re-parse hazards listed in the
+ * module documentation — a hazardous conversion is skipped, never attempted.
+ * `modify`/`modifyToString` carry a real error channel
+ * ({@link MarkdownModificationError}) and render every replacement through
+ * the canonical stringifier, so a modified document re-parses cleanly by
+ * construction.
+ *
+ * @public
+ */
+declare class MarkdownFormat {
+  private constructor();
+  /**
+   * Compute marker-normalization edits per the requested
+   * {@link MarkdownFormattingOptions}: heading style, bullet character,
+   * emphasis/strong marker, fence character and thematic-break character,
+   * each only where the node's concrete syntax differs from the target and
+   * the rewrite is provably safe. Content is never touched. `range`
+   * restricts edits to the nodes intersecting it (the owning-node
+   * intersection posture, matching toml). Non-mutating — apply with
+   * `MarkdownEdit.applyAll` (or use {@link MarkdownFormat.formatToString}).
+   */
+  static format(text: string, range?: MarkdownRangeLike, options?: MarkdownFormattingOptions): ReadonlyArray<MarkdownEdit>;
+  /**
+   * Format `text` and apply the resulting edits in one step
+   * (`MarkdownEdit.applyAll ∘ format`). Pure and total.
+   */
+  static formatToString(text: string, range?: MarkdownRangeLike, options?: MarkdownFormattingOptions): string;
+  /**
+   * Compute the edit that replaces `target` — a node from `document`'s own
+   * tree, matched by identity — with `replacement`: a plain string (treated
+   * as literal text and escaped; block-wrapped when the target is a flow
+   * node) or a node fragment whose content category must fit the target's
+   * slot (flow for flow targets, phrasing for phrasing targets and table
+   * cells). Every replacement renders through the canonical stringifier, so
+   * the modified document re-parses cleanly by construction. Day-one scope:
+   * list items, table rows, frontmatter and the root refuse with
+   * `UnsupportedTarget`, as does a multi-line replacement whose target sits
+   * inside a container (a blockquote, list, table or heading) whose
+   * continuation lines the splice cannot prefix.
+   */
+  static readonly modify: (document: MarkdownDocument, target: MarkdownNode, replacement: string | MarkdownNode) => Effect.Effect<readonly MarkdownEdit[], MarkdownModificationError, never>;
+  /**
+   * Modify `document` and apply the resulting edit in one step
+   * (`MarkdownEdit.applyAll ∘ modify`).
+   */
+  static readonly modifyToString: (document: MarkdownDocument, target: MarkdownNode, replacement: string | MarkdownNode) => Effect.Effect<string, MarkdownModificationError, never>;
+}
+//#endregion
+//#region src/MarkdownVisitor.d.ts
+/**
+ * The discriminated union of markdown visitor events, in document pre-order.
+ * `Enter` fires when the walk reaches a node, `Exit` when it leaves — for a
+ * leaf the two fire back to back. Every variant carries `path` (child
+ * indexes from the root; the root's own path is empty) and `depth`
+ * (zero-based; the root is 0). `Error` is terminal: it carries the
+ * depth-guard diagnostic for a decoded foreign tree nested past
+ * `MAX_NESTING_DEPTH` and nothing follows it.
+ *
+ * @public
+ */
+type MarkdownVisitorEvent = Data.TaggedEnum<{
+  Enter: {
+    readonly node: MarkdownNode;
+    readonly path: MarkdownPath;
+    readonly depth: number;
+  };
+  Exit: {
+    readonly node: MarkdownNode;
+    readonly path: MarkdownPath;
+    readonly depth: number;
+  };
+  Error: {
+    readonly diagnostic: MarkdownDiagnostic;
+    readonly path: MarkdownPath;
+    readonly depth: number;
+  };
+}>;
+/**
+ * Constructors and matchers for the `MarkdownVisitorEvent` union (e.g.
+ * `MarkdownVisitorEvent.Enter({ node, path, depth })`,
+ * `MarkdownVisitorEvent.$is("Exit")`).
+ *
+ * @public
+ */
+declare const MarkdownVisitorEvent: {
+  readonly $is: <Tag extends "Enter" | "Error" | "Exit">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Enter";
+    readonly node: MarkdownNode;
+    readonly path: MarkdownPath;
+    readonly depth: number;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Error";
+    readonly diagnostic: MarkdownDiagnostic;
+    readonly path: MarkdownPath;
+    readonly depth: number;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Exit";
+    readonly node: MarkdownNode;
+    readonly path: MarkdownPath;
+    readonly depth: number;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends {
+      readonly Enter: (args: {
+        readonly _tag: "Enter";
+        readonly node: MarkdownNode;
+        readonly path: MarkdownPath;
+        readonly depth: number;
+      }) => any;
+      readonly Error: (args: {
+        readonly _tag: "Error";
+        readonly diagnostic: MarkdownDiagnostic;
+        readonly path: MarkdownPath;
+        readonly depth: number;
+      }) => any;
+      readonly Exit: (args: {
+        readonly _tag: "Exit";
+        readonly node: MarkdownNode;
+        readonly path: MarkdownPath;
+        readonly depth: number;
+      }) => any;
+    }>(cases: Cases): (value: {
+      readonly _tag: "Enter";
+      readonly node: MarkdownNode;
+      readonly path: MarkdownPath;
+      readonly depth: number;
+    } | {
+      readonly _tag: "Error";
+      readonly diagnostic: MarkdownDiagnostic;
+      readonly path: MarkdownPath;
+      readonly depth: number;
+    } | {
+      readonly _tag: "Exit";
+      readonly node: MarkdownNode;
+      readonly path: MarkdownPath;
+      readonly depth: number;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Enter" | "Error" | "Exit"]>>;
+    <Cases extends {
+      readonly Enter: (args: {
+        readonly _tag: "Enter";
+        readonly node: MarkdownNode;
+        readonly path: MarkdownPath;
+        readonly depth: number;
+      }) => any;
+      readonly Error: (args: {
+        readonly _tag: "Error";
+        readonly diagnostic: MarkdownDiagnostic;
+        readonly path: MarkdownPath;
+        readonly depth: number;
+      }) => any;
+      readonly Exit: (args: {
+        readonly _tag: "Exit";
+        readonly node: MarkdownNode;
+        readonly path: MarkdownPath;
+        readonly depth: number;
+      }) => any;
+    }>(value: {
+      readonly _tag: "Enter";
+      readonly node: MarkdownNode;
+      readonly path: MarkdownPath;
+      readonly depth: number;
+    } | {
+      readonly _tag: "Error";
+      readonly diagnostic: MarkdownDiagnostic;
+      readonly path: MarkdownPath;
+      readonly depth: number;
+    } | {
+      readonly _tag: "Exit";
+      readonly node: MarkdownNode;
+      readonly path: MarkdownPath;
+      readonly depth: number;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Enter" | "Error" | "Exit"]>>;
+  };
+  readonly Enter: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Enter";
+    readonly node: MarkdownNode;
+    readonly path: MarkdownPath;
+    readonly depth: number;
+  }, "_tag">;
+  readonly Error: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Error";
+    readonly diagnostic: MarkdownDiagnostic;
+    readonly path: MarkdownPath;
+    readonly depth: number;
+  }, "_tag">;
+  readonly Exit: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Exit";
+    readonly node: MarkdownNode;
+    readonly path: MarkdownPath;
+    readonly depth: number;
+  }, "_tag">;
+};
+/**
+ * SAX-style markdown tree visitor statics. Not instantiable.
+ *
+ * @public
+ */
+declare class MarkdownVisitor {
+  private constructor();
+  /**
+   * Create a lazy `Stream` of `MarkdownVisitorEvent` walking `root` in
+   * document pre-order: `Enter` and `Exit` for every node including the
+   * root and every leaf. Events are produced on demand, so combining with
+   * `Stream.take` allows efficient partial scans without walking the rest
+   * of the tree.
+   *
+   * @remarks
+   * Infallible at the type level. A tree produced by `Markdown.parse` can
+   * never trip the walk's depth guard — the parser refuses deeper input —
+   * but a decoded foreign tree (`Mdast.fromMdast`) can; the trip surfaces
+   * as a terminal `MarkdownVisitorEvent` `Error` event carrying a
+   * `NestingDepthExceeded` {@link MarkdownDiagnostic}, mirroring the typed
+   * failure `Markdown.stringify` produces for the same tree.
+   */
+  static visit(root: Root): Stream.Stream<MarkdownVisitorEvent>;
+}
+//#endregion
+//#region src/Mdast.d.ts
+/**
+ * A plain mdast node: a `type` tag plus whatever fields that type carries.
+ *
+ * @remarks
+ * Deliberately loose — plain-object mdast is a foreign, structurally-typed
+ * contract; the precise shapes live in the mdast specification, and
+ * {@link Mdast.fromMdast} is the checked way back into typed nodes.
+ *
+ * @public
+ */
+interface MdastNode {
+  readonly type: string;
+  readonly [key: string]: unknown;
+}
+declare const MdastDecodeError_base: Schema.Class<MdastDecodeError, Schema.TaggedStruct<"MdastDecodeError", {
+  /** The structured schema issue. Never a string. */
+  readonly issue: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Indicates that foreign mdast input failed to decode into the package's
+ * node classes.
+ *
+ * @remarks
+ * `issue` carries the **structured** schema failure — at runtime a
+ * `SchemaIssue.Issue` tree, reachable through `_tag` and nested `issues` —
+ * never a stringified rendering (the `FrontmatterValidationError`
+ * precedent). It is typed `unknown` because v4 exposes no `Schema` for
+ * `Issue`; narrow it with the `SchemaIssue` module.
+ *
+ * @public
+ */
+declare class MdastDecodeError extends MdastDecodeError_base {
+  get message(): string;
+}
+/**
+ * The mdast projection facade — the remark-ecosystem interop boundary.
+ *
+ * @public
+ */
+declare class Mdast {
+  /**
+   * Project a parsed {@link Root} to plain mdast JSON.
+   *
+   * @remarks
+   * Total and pure: every tree the parser or {@link Mdast.fromMdast}
+   * produces projects without failure. Fidelity extras are stripped;
+   * optional mdast fields are spelled the way `mdast-util-from-markdown`
+   * spells them, so the output deep-equals the reference utility's trees
+   * (the vendored interop corpus pins this). The frontmatter capture
+   * projects to a `yaml`/`toml`/`json` literal node.
+   *
+   * @param root - The parsed document tree.
+   * @returns A plain mdast `root` object with unist positions.
+   */
+  static toMdast(root: Root): MdastNode;
+  /**
+   * Decode foreign plain mdast into the package's node classes,
+   * synchronously, as a `Result`. The pure primitive twin of
+   * {@link Mdast.fromMdast}.
+   *
+   * @remarks
+   * unist makes positions optional and this package's classes require
+   * them, so missing or incomplete positions are synthesized as the
+   * zero-width sentinel (line 1, column 1, offset 0) — clearly synthetic
+   * and inert for rendering. Trees carrying sentinel positions serve
+   * tree-level workflows (stringify, the visitor, projection back out),
+   * not offset-splice editing, whose offsets must come from a real parse.
+   * `null` values on optional fields normalize to absence per unist's
+   * null-equals-absent convention; foreign `data` and other unrecognized
+   * fields are dropped at the boundary; `yaml`/`toml`/`json` literal nodes
+   * decode into the {@link Frontmatter} capture. Unknown node types fail
+   * typed.
+   *
+   * @param input - A plain mdast tree, typically a `root`.
+   * @returns A `Result` succeeding with the decoded {@link Root}, or
+   *   failing with {@link MdastDecodeError} carrying the structured issue.
+   */
+  static fromMdastResult(input: unknown): Result.Result<Root, MdastDecodeError>;
+  /**
+   * Decode foreign plain mdast into the package's node classes. Defined in
+   * terms of {@link Mdast.fromMdastResult} — synchronous callers can use
+   * that variant directly.
+   *
+   * @param input - A plain mdast tree, typically a `root`.
+   * @returns An `Effect` that succeeds with the decoded {@link Root}, or
+   *   fails with {@link MdastDecodeError}.
+   */
+  static readonly fromMdast: (input: unknown) => Effect.Effect<Root, MdastDecodeError, never>;
+}
+//#endregion
+//#region src/TomlFrontmatter.d.ts
+/**
+ * The toml frontmatter codec, over `@effected/toml`.
+ *
+ * @remarks
+ * Decodes a `+++`-fenced capture's raw value with `Toml.parse`, so the toml
+ * engine's nesting depth cap fails through the typed channel: a hostile
+ * frontmatter block surfaces as a {@link FrontmatterDecodeError} carrying the
+ * `TomlParseError` structurally, never a defect. An empty capture decodes to
+ * an empty table (`{}`), toml's empty-document value.
+ *
+ * Encodes with `Toml.stringify`; a value toml cannot represent fails as a
+ * {@link FrontmatterEncodeError} carrying the `TomlStringifyError`
+ * structurally. An empty object encodes to the **empty body** — the exact
+ * mirror of the decode ruling above, rendering as adjacent `+++` fences —
+ * so `set`-then-decode recovers `{}` exactly.
+ *
+ * `@effected/toml` is an optional peer — importing this module is what
+ * requires it; a consumer who never touches toml frontmatter never loads the
+ * toml engine.
+ *
+ * @public
+ */
+declare const TomlFrontmatter: FrontmatterCodec;
+//#endregion
+//#region src/YamlFrontmatter.d.ts
+/**
+ * The yaml frontmatter codec, over `@effected/yaml`.
+ *
+ * @remarks
+ * Decodes a `---`-fenced capture's raw value with `Yaml.parse`, so the yaml
+ * engine's input hardening — the alias-expansion budget and the nesting depth
+ * cap — fails through the typed channel: a hostile frontmatter block surfaces
+ * as a {@link FrontmatterDecodeError} carrying the `YamlParseError`
+ * structurally, never a defect. An empty capture decodes to `null`, yaml's
+ * empty-document value.
+ *
+ * Encodes with `Yaml.stringify`; an unserializable value fails as a
+ * {@link FrontmatterEncodeError} carrying the `YamlStringifyError`
+ * structurally. An empty object encodes to the flow mapping `{}` —
+ * deliberately not an empty body, which would round-trip as `null` — so
+ * `set`-then-decode recovers `{}` exactly.
+ *
+ * `@effected/yaml` is an optional peer — importing this module is what
+ * requires it; a consumer who never touches yaml frontmatter never loads the
+ * yaml engine.
+ *
+ * @public
+ */
+declare const YamlFrontmatter: FrontmatterCodec;
+//#endregion
+export { Blockquote, Break, BreakStyle, BulletChar, Code, Definition, Delete, type DocumentHeading, type DocumentLink, type DocumentSection, Emphasis, EmphasisChar, FenceChar, FlowContent, FootnoteDefinition, FootnoteReference, Frontmatter, type FrontmatterCodec, FrontmatterContent, FrontmatterDecodeError, FrontmatterEncodeError, FrontmatterFormat, FrontmatterFormatMismatchError, FrontmatterMissingError, type FrontmatterResolveError, type FrontmatterSchemaError, type FrontmatterSchemaResolver, FrontmatterValidationError, type FrontmatterWriteError, Heading, HeadingDepth, HeadingStyle, Html, Image, ImageReference, InlineCode, JsonFrontmatter, Link, type LinkBearingNode, LinkReference, List, ListContent, ListDelimiter, ListItem, Markdown, MarkdownDiagnostic, MarkdownDialect, MarkdownDocument, MarkdownEdit, MarkdownFormat, MarkdownFormattingOptions, MarkdownFrontmatter, MarkdownModificationError, MarkdownModificationErrorCode, MarkdownNode, type MarkdownNodeOfType, type MarkdownNodeType, MarkdownParseError, MarkdownParseErrorCode, MarkdownParseOptions, type MarkdownPath, MarkdownRange, type MarkdownRangeLike, type MarkdownSegment, MarkdownStringifyError, MarkdownVisitor, MarkdownVisitorEvent, Mdast, MdastDecodeError, type MdastNode, Paragraph, PhrasingContent, Point, Position, ReferenceType, Root, RowContent, SchemaDeclaration, SchemaDeclarationByName, SchemaDeclarationByPath, SchemaDeclarationByUrl, SchemaDeclarationInline, SchemaDeclarationInvalidError, SchemaDeclarationMissingError, SchemaNameUnknownError, SchemaResolver, SchemaVersionUnresolvableError, Strong, Table, TableAlign, TableCell, TableContent, TableRow, Text, ThematicBreak, ThematicBreakChar, TomlFrontmatter, YamlFrontmatter };
+//# sourceMappingURL=index.d.ts.map