@effected/markdown 0.22.0 → 0.24.0

package/Markdown.js

@@ -3,7 +3,9 @@ import { isGuardExceeded, isRawMarkdownError } from "./internal/carriers.js";
 import { parseBlocks } from "./internal/blockParser.js";
 import { parsePhrasingText } from "./internal/phrasing.js";
 import { stringifyBlocks } from "./internal/stringify.js";
+import { assertWithinNestingDepth } from "./internal/treeDepth.js";
 import { MarkdownDiagnostic } from "./MarkdownDiagnostic.js";
+import { MarkdownTransform } from "./MarkdownTransform.js";
 import { Effect, Result, Schema, SchemaIssue, SchemaTransformation } from "effect";
 
 // src/Markdown.ts
@@ -282,8 +284,8 @@ var Markdown = class Markdown {
 	* surgical editing goes through the offset-splice edit layer instead.
 	*
 	* **The canonical form is a stability commitment, so a test may assert
-	* against these bytes.** There are no options to configure and therefore
-	* nothing to drift, the choices below are pinned by byte-level tests, and
+	* against these bytes.** The one option, `canonical`, only selects
+	* between these bytes and the author's spelling; the choices below are pinned by byte-level tests, and
 	* the engine is cross-checked against commonmark.js over the full
 	* CommonMark 0.31.2 corpus. Changing any of them is a **breaking** change
 	* to this package, never a patch. A consumer asserting on rendered
@@ -352,13 +354,24 @@ var Markdown = class Markdown {
 	* trip on a tree nesting past the depth cap fails, and only synthesized
 	* or decoded trees can nest that far.
 	*
+	* **`canonical: true` ignores fidelity fields.** With
+	* {@link MarkdownStringifyOptions.canonical} set, every fidelity field is
+	* cleared first, so a parsed `* a` list, setext heading, `_em_`, `~~~` fence
+	* or `***` break all emit the canonical spelling. It is the same as
+	* serializing `MarkdownTransform.canonicalize(node)`, without the
+	* `Mdast.toMdast` / `Mdast.fromMdastResult` round trip. The default keeps
+	* honouring fidelity fields.
+	*
 	* @param node - The document tree, or a single flow node, to serialize.
+	* @param options - Optional {@link MarkdownStringifyOptions}.
 	* @returns A `Result` succeeding with markdown source, or failing with
 	*   {@link MarkdownStringifyError}.
 	*/
-	static stringifyResult(node) {
+	static stringifyResult(node, options) {
 		try {
-			return Result.succeed(stringifyBlocks(node.type === "root" ? node.children : [node]));
+			if (options?.canonical === true) assertWithinNestingDepth(node);
+			const source = options?.canonical === true ? MarkdownTransform.canonicalize(node) : node;
+			return Result.succeed(stringifyBlocks(source.type === "root" ? source.children : [source]));
 		} catch (caught) {
 			if (isGuardExceeded(caught)) return Result.fail(new MarkdownStringifyError({ diagnostic: MarkdownDiagnostic.make({
 				code: caught.reason,
@@ -394,10 +407,12 @@ var Markdown = class Markdown {
 	* see {@link Markdown.stringifyResult}.
 	*
 	* @param node - The document tree, or a single flow node, to serialize.
+	* @param options - Optional {@link MarkdownStringifyOptions}; `canonical: true`
+	*   discards fidelity fields.
 	* @returns An `Effect` that succeeds with markdown source, or fails with
 	*   {@link MarkdownStringifyError}.
 	*/
-	static stringify = Effect.fn("Markdown.stringify")((node) => Effect.fromResult(Markdown.stringifyResult(node)));
+	static stringify = Effect.fn("Markdown.stringify")((node, options) => Effect.fromResult(Markdown.stringifyResult(node, options)));
 	/**
 	* A `Schema<Root, string>` decoding markdown source into a {@link Root}
 	* tree and encoding a tree back to canonical markdown via

package/MarkdownDiagnostic.js

@@ -1,4 +1,5 @@
 import { MARKDOWN_PARSE_ERROR_CODES } from "./internal/carriers.js";
+import { LineIndex } from "@effected/source";
 import { Schema } from "effect";
 
 // src/MarkdownDiagnostic.ts
@@ -16,14 +17,20 @@ const MarkdownParseErrorCode = Schema.Literals(MARKDOWN_PARSE_ERROR_CODES);
 * 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, which is a deliberate,
-* unrelated convention for the AST rather than a mismatch to reconcile.
+* Satisfies `@effected/source`'s `SourceDiagnostic<MarkdownParseErrorCode>`:
+* the positional core (`code`/`message`/`offset`/`length`/`line`/`character`)
+* the kit's format packages share, so a consumer printing or serving
+* diagnostics (an LSP server, a CLI annotation) is written once against that
+* shape. `line`/`character` are zero-based, `character` in UTF-16 code units,
+* with `\n`, `\r\n` and a bare `\r` as line breaks: exactly
+* `LineIndex.make(source).positionAt(offset)`, and the same index
+* {@link MarkdownDocument.lineIndex} returns. An offset at the `\n` of a
+* `\r\n` reads as the end of its line.
+*
+* The one-based `line`/`column` unist `Point`s carried on `MarkdownNode`
+* positions read the same index, one-based: a deliberate, different
+* convention for the AST rather than a mismatch to reconcile (see
+* {@link MarkdownDocument.lineIndex} for the exact mapping).
 *
 * @public
 */
@@ -40,12 +47,20 @@ var MarkdownDiagnostic = class MarkdownDiagnostic extends Schema.Class("Markdown
 	* from `offset` against the source text. Advanced — the parse entry
 	* points call this for you.
 	*
-	* @param source - The source text the record's `offset` indexes into.
+	* @remarks
+	* Pass a line index already built over the source to materialize many
+	* records without rescanning the text; a string builds one. The
+	* parameter is the structural `SourceIndex`, so an index from any
+	* installed copy of `@effected/source` is accepted. An offset
+	* outside the source clamps into it, as `LineIndex.positionAt` does.
+	*
+	* @param source - The source text the record's `offset` indexes into, or
+	*   a `LineIndex` over it.
 	* @param raw - The engine record: `code`, `message`, `offset` and `length`.
 	* @returns The diagnostic with `line` and `character` filled in.
 	*/
 	static fromRaw(source, raw) {
-		const { line, character } = lineChar(source, raw.offset);
+		const { line, character } = (typeof source === "string" ? LineIndex.make(source) : source).positionAt(raw.offset);
 		return MarkdownDiagnostic.make({
 			code: raw.code,
 			message: raw.message,
@@ -56,32 +71,5 @@ var MarkdownDiagnostic = class MarkdownDiagnostic extends Schema.Class("Markdown
 		});
 	}
 };
-/**
-* Compute the zero-based line/character position of `offset` within `text`.
-* Recognizes `\n`, `\r` and `\r\n` as line breaks; a CRLF pair counts as a
-* single newline (toml `TomlDiagnostic` precedent — kept independent of
-* `internal/lineIndex.ts`, which answers a different, one-based question
-* for AST positions).
-*/
-function lineChar(text, offset) {
-	let line = 0;
-	let lineStart = 0;
-	const limit = Math.min(offset, text.length);
-	for (let i = 0; i < limit; i++) {
-		const ch = text.charCodeAt(i);
-		if (ch === 10) {
-			line++;
-			lineStart = i + 1;
-		} else if (ch === 13) {
-			if (i + 1 < text.length && text.charCodeAt(i + 1) === 10) i++;
-			line++;
-			lineStart = i + 1;
-		}
-	}
-	return {
-		line,
-		character: offset - lineStart
-	};
-}
 
 export { MarkdownDiagnostic, MarkdownParseErrorCode };

package/MarkdownDocument.js

@@ -4,8 +4,9 @@ import { scanFrontmatter } from "./internal/blocks/frontmatter.js";
 import { preprocessLines } from "./internal/preprocess.js";
 import { normalizeLabelText } from "./internal/references.js";
 import { MarkdownDiagnostic } from "./MarkdownDiagnostic.js";
-import { parsePassResult } from "./Markdown.js";
 import { rootHeadingBounds } from "./internal/sectionBounds.js";
+import { parsePassResult } from "./Markdown.js";
+import { LineIndex } from "@effected/source";
 import { Effect, Option, Result, Schema } from "effect";
 
 // src/MarkdownDocument.ts
@@ -122,6 +123,12 @@ const phrasingText = (nodes) => {
 	return out;
 };
 /**
+* Each document's line index, built at most once. A side table rather than a
+* field: the index is derived from `source`, so it is no part of the
+* document's schema, its equality or its encoded form.
+*/
+const lineIndexes = /* @__PURE__ */ new WeakMap();
+/**
 * 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.
@@ -213,6 +220,55 @@ var MarkdownDocument = class MarkdownDocument extends Schema.Class("MarkdownDocu
 		return scanFrontmatter(preprocessLines(this.source), this.source) !== null;
 	}
 	/**
+	* The line index over `source`: offsets to zero-based `{ line, character }`
+	* and back, with exactly the rules this package's own positions use.
+	*
+	* @remarks
+	* A `LineIndex` from `@effected/source` (re-exported from this package's
+	* entry point), typed as the structural `SourceIndex` so a consumer on
+	* another installed copy of `@effected/source` can pass it on, with its
+	* default `"lsp"` line breaks: `\n`, `\r\n` and a
+	* bare `\r`, `character` in UTF-16 code units, an offset at the `\n` of a
+	* `\r\n` reading as the end of its line. So for any offset into
+	* `source`:
+	*
+	* - `doc.lineIndex.positionAt(offset)` is the `line`/`character` a
+	*   {@link MarkdownDiagnostic} at that offset carries;
+	* - a node's unist `Point` has `line` = `lineAt(offset) + 1` and
+	*   `column` = `offset - lineStart(line) + 1`: `positionAt` plus one on
+	*   both axes everywhere except at the `\n` of a `\r\n`, which a Point
+	*   counts as one column past the `\r` (as `vfile-location` does) and
+	*   `positionAt` reads as the end of its line;
+	* - `offsetAt`, `spanOf` and `rangeOf` convert an LSP `Position` or
+	*   `Range` back to an offset or a `MarkdownRange`-shaped
+	*   `{ offset, length }`.
+	*
+	* A parsed document returns the index the parse itself built; a document
+	* constructed with `make` builds one on first access. Either way it is
+	* built once per document and shared by every later access. To index a
+	* text with no document, `LineIndex.make(text)` gives the same answers.
+	*
+	* @example
+	* ```ts
+	* import { MarkdownDocument } from "@effected/markdown";
+	* import { Result } from "effect";
+	*
+	* const result = MarkdownDocument.parseResult("# Title\r\n\r\nBody\n");
+	* if (Result.isSuccess(result)) {
+	*   const index = result.success.lineIndex;
+	*   console.log(index.positionAt(12)); // => { line: 2, character: 1 }
+	*   console.log(index.offsetAt({ line: 2, character: 0 })); // => 11
+	* }
+	* ```
+	*/
+	get lineIndex() {
+		const cached = lineIndexes.get(this);
+		if (cached !== void 0) return cached;
+		const index = LineIndex.make(this.source);
+		lineIndexes.set(this, index);
+		return index;
+	}
+	/**
 	* Every heading in the document, in document order, wherever it sits —
 	* including headings nested inside blockquotes and list items.
 	*
@@ -379,12 +435,16 @@ var MarkdownDocument = class MarkdownDocument extends Schema.Class("MarkdownDocu
 	*   `MarkdownParseError`.
 	*/
 	static parseResult(text, options) {
-		return Result.map(parsePassResult(text, options), (pass) => MarkdownDocument.make({
-			source: text,
-			root: pass.root,
-			diagnostics: pass.carriers.map((carrier) => MarkdownDiagnostic.fromRaw(text, carrier)),
-			definitions: pass.refmap
-		}));
+		return Result.map(parsePassResult(text, options), (pass) => {
+			const document = MarkdownDocument.make({
+				source: text,
+				root: pass.root,
+				diagnostics: pass.carriers.map((carrier) => MarkdownDiagnostic.fromRaw(pass.lineIndex, carrier)),
+				definitions: pass.refmap
+			});
+			lineIndexes.set(document, pass.lineIndex);
+			return document;
+		});
 	}
 	/**
 	* Parse markdown into a {@link MarkdownDocument}. Defined in terms of

package/MarkdownTransform.js

@@ -1,3 +1,4 @@
+import { FIDELITY_FIELDS, clearFidelity } from "./internal/fidelity.js";
 import { rootHeadingBounds } from "./internal/sectionBounds.js";
 
 // src/MarkdownTransform.ts
@@ -76,6 +77,32 @@ var MarkdownTransform = class {
 		} });
 	}
 	/**
+	* Return a copy of the tree with every fidelity field cleared, so
+	* `Markdown.stringify` emits the canonical form instead of the author's
+	* spelling.
+	*
+	* @remarks
+	* Clears `headingStyle`, `markerChar` (emphasis, strong, thematic break),
+	* `fenceChar` and `fenceLength`, `bulletChar` and `delimiter`, and
+	* `breakStyle`. `Text`'s `escapeStyle` is an emitter instruction rather
+	* than a recorded spelling and is kept. Positions and all mdast fields are
+	* untouched. The input is never mutated; a subtree carrying no fidelity
+	* field is returned as the same instance, following
+	* {@link MarkdownTransform.(map:1)}, on which this is built. Like `map` it
+	* recurses without a depth guard, so a tree nested past the stack throws a
+	* `RangeError`; `Markdown.stringifyResult` with `canonical: true` checks
+	* depth first and fails typed at the stringifier's own limit instead.
+	*
+	* `Markdown.stringify(tree, { canonical: true })` is exactly
+	* `Markdown.stringify(MarkdownTransform.canonicalize(tree))`.
+	*
+	* @param node - The node whose fidelity fields to clear.
+	* @returns The node with fidelity fields cleared.
+	*/
+	static canonicalize(node) {
+		return mapNode(node, canonicalHandlers);
+	}
+	/**
 	* Locate the root-level sections of one heading depth by child index —
 	* no source text needed, so it works on a tree a
 	* `MarkdownTransform.map` has reshaped.
@@ -140,6 +167,7 @@ var MarkdownTransform = class {
 	}
 };
 const isHeadingDepth = (value) => Number.isInteger(value) && value >= 1 && value <= 6;
+const canonicalHandlers = Object.fromEntries(Object.keys(FIDELITY_FIELDS).map((type) => [type, clearFidelity]));
 function mapNode(node, handlers) {
 	let current = node;
 	if ("children" in node) {

package/README.md

@@ -5,7 +5,7 @@
 [![Node.js %3E%3D24.11.0](https://img.shields.io/badge/Node.js-%3E%3D24.11.0-5fa04e.svg)](https://nodejs.org/)
 [![TypeScript 7.0](https://img.shields.io/badge/TypeScript-7.0-3178c6.svg)](https://www.typescriptlang.org/)
 
-Zero-dependency CommonMark 0.31.2 and GFM parsing, editing and transformation expressed as Effect schemas and pure functions. Parse markdown into mdast-shaped nodes carrying byte offsets, navigate headings, sections and links, compute surgical offset-splice edits, normalize markers, decode frontmatter into a validated domain schema, project to and from plain mdast for the remark ecosystem, and walk a document as a `Stream`.
+CommonMark 0.31.2 and GFM parsing, editing and transformation expressed as Effect schemas and pure functions. Parse markdown into mdast-shaped nodes carrying byte offsets, navigate headings, sections and links, compute surgical offset-splice edits, normalize markers, decode frontmatter into a validated domain schema, project to and from plain mdast for the remark ecosystem, and walk a document as a `Stream`.
 
 > **Pre-`1.0.0`.** This package is part of the `@effected/*` kit, built on stable
 > Effect v4 (`effect` `^4.0.0`) and still in `0.x` development. Stable Effect
@@ -41,7 +41,7 @@ npm install @effected/markdown effect
 pnpm add @effected/markdown effect
 ```
 
-Requires Node.js >=24.11.0. `effect` v4 is a peer dependency; the package itself adds no runtime dependencies.
+Requires Node.js >=24.11.0. `effect` v4 is a peer dependency; the package's one runtime dependency is the dependency-free `@effected/source`, whose `LineIndex` it re-exports.
 
 `@effected/yaml`, `@effected/toml` and `@effected/jsonc` are **optional** peers, required only by the frontmatter codec module you import. A consumer decoding yaml frontmatter installs `@effected/yaml` and nothing else; a consumer who never touches frontmatter installs none of them.
 
@@ -314,7 +314,9 @@ Serialization matches `mdxJsxToMarkdown`'s defaults — `"` quotes, spaced self-
 
 ## The canonical form is stable
 
-`Markdown.stringify` takes no options. It emits one canonical form, that form is pinned by byte-level tests, the engine behind it is cross-checked against commonmark.js over the full CommonMark 0.31.2 corpus, and **changing any of it is a breaking change to this package rather than a patch**. So a test may assert on these bytes, and a pipeline that needs stable rendered markdown should serialize through here instead of a third-party stringifier whose defaults are free to move between releases.
+`Markdown.stringify` emits one canonical form, that form is pinned by byte-level tests, the engine behind it is cross-checked against commonmark.js over the full CommonMark 0.31.2 corpus, and **changing any of it is a breaking change to this package rather than a patch**. So a test may assert on these bytes, and a pipeline that needs stable rendered markdown should serialize through here instead of a third-party stringifier whose defaults are free to move between releases.
+
+By default a node's fidelity fields (`bulletChar`, `headingStyle`, `markerChar`, `fenceChar`, `delimiter`) win, so a parsed `* a` list or setext heading re-emits as written. To drop them, pass `{ canonical: true }` to `stringify` or `stringifyResult`, or call the pure `MarkdownTransform.canonicalize(tree)` to get a cleared copy of the tree (the input is never mutated). Both give identical output and replace the `Mdast.toMdast` / `Mdast.fromMdastResult` round trip.
 
 For a node carrying no fidelity field:
 

package/index.d.ts

@@ -1,3 +1,4 @@
+import { LineBreaks, LineIndex, LineIndexOptions, SourceDiagnostic, SourceIndex, SourceIndex as SourceIndex$1, SourceLocation, SourcePosition, SourceRange, SourceSpan } from "@effected/source";
 import { Data, Effect, Option, Result, Schema, Stream } from "effect";
 declare const Point_base: Schema.Class<Point, Schema.Struct<{
   readonly line: Schema.Number;
@@ -968,14 +969,20 @@ declare const MarkdownDiagnostic_base: Schema.Class<MarkdownDiagnostic, Schema.S
  * 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, which is a deliberate,
- * unrelated convention for the AST rather than a mismatch to reconcile.
+ * Satisfies `@effected/source`'s `SourceDiagnostic<MarkdownParseErrorCode>`:
+ * the positional core (`code`/`message`/`offset`/`length`/`line`/`character`)
+ * the kit's format packages share, so a consumer printing or serving
+ * diagnostics (an LSP server, a CLI annotation) is written once against that
+ * shape. `line`/`character` are zero-based, `character` in UTF-16 code units,
+ * with `\n`, `\r\n` and a bare `\r` as line breaks: exactly
+ * `LineIndex.make(source).positionAt(offset)`, and the same index
+ * {@link MarkdownDocument.lineIndex} returns. An offset at the `\n` of a
+ * `\r\n` reads as the end of its line.
+ *
+ * The one-based `line`/`column` unist `Point`s carried on `MarkdownNode`
+ * positions read the same index, one-based: a deliberate, different
+ * convention for the AST rather than a mismatch to reconcile (see
+ * {@link MarkdownDocument.lineIndex} for the exact mapping).
  *
  * @public
  */
@@ -985,11 +992,19 @@ export declare class MarkdownDiagnostic extends MarkdownDiagnostic_base {
    * from `offset` against the source text. Advanced — the parse entry
    * points call this for you.
    *
-   * @param source - The source text the record's `offset` indexes into.
+   * @remarks
+   * Pass a line index already built over the source to materialize many
+   * records without rescanning the text; a string builds one. The
+   * parameter is the structural `SourceIndex`, so an index from any
+   * installed copy of `@effected/source` is accepted. An offset
+   * outside the source clamps into it, as `LineIndex.positionAt` does.
+   *
+   * @param source - The source text the record's `offset` indexes into, or
+   *   a `LineIndex` over it.
    * @param raw - The engine record: `code`, `message`, `offset` and `length`.
    * @returns The diagnostic with `line` and `character` filled in.
    */
-  static fromRaw(source: string, raw: {
+  static fromRaw(source: string | SourceIndex$1, raw: {
     readonly code: MarkdownParseErrorCode;
     readonly message: string;
     readonly offset: number;
@@ -1013,6 +1028,19 @@ export declare const MarkdownDialect: Schema.Literals<readonly ["commonmark", "g
  * @public
  */
 export type MarkdownDialect = typeof MarkdownDialect.Type;
+/**
+ * Options for `Markdown.stringify` and `Markdown.stringifyResult`.
+ *
+ * @public
+ */
+interface MarkdownStringifyOptions {
+  /**
+   * Ignore fidelity fields (marker characters, fence style, heading
+   * spelling) and emit the canonical form. Defaults to `false`, which honours
+   * them.
+   */
+  readonly canonical?: boolean;
+}
 declare const MarkdownParseOptions_base: Schema.Class<MarkdownParseOptions, Schema.Struct<{
   readonly dialect: Schema.optionalKey<Schema.Literals<readonly ["commonmark", "gfm"]>>;
   readonly frontmatter: Schema.optionalKey<Schema.Boolean>;
@@ -1225,8 +1253,8 @@ export declare class Markdown {
    * surgical editing goes through the offset-splice edit layer instead.
    *
    * **The canonical form is a stability commitment, so a test may assert
-   * against these bytes.** There are no options to configure and therefore
-   * nothing to drift, the choices below are pinned by byte-level tests, and
+   * against these bytes.** The one option, `canonical`, only selects
+   * between these bytes and the author's spelling; the choices below are pinned by byte-level tests, and
    * the engine is cross-checked against commonmark.js over the full
    * CommonMark 0.31.2 corpus. Changing any of them is a **breaking** change
    * to this package, never a patch. A consumer asserting on rendered
@@ -1295,11 +1323,20 @@ export declare class Markdown {
    * trip on a tree nesting past the depth cap fails, and only synthesized
    * or decoded trees can nest that far.
    *
+   * **`canonical: true` ignores fidelity fields.** With
+   * {@link MarkdownStringifyOptions.canonical} set, every fidelity field is
+   * cleared first, so a parsed `* a` list, setext heading, `_em_`, `~~~` fence
+   * or `***` break all emit the canonical spelling. It is the same as
+   * serializing `MarkdownTransform.canonicalize(node)`, without the
+   * `Mdast.toMdast` / `Mdast.fromMdastResult` round trip. The default keeps
+   * honouring fidelity fields.
+   *
    * @param node - The document tree, or a single flow node, to serialize.
+   * @param options - Optional {@link MarkdownStringifyOptions}.
    * @returns A `Result` succeeding with markdown source, or failing with
    *   {@link MarkdownStringifyError}.
    */
-  static stringifyResult(node: Root | FlowContent): Result.Result<string, MarkdownStringifyError>;
+  static stringifyResult(node: Root | FlowContent, options?: MarkdownStringifyOptions): Result.Result<string, MarkdownStringifyError>;
   /**
    * Serialize a {@link Root} tree, or a single {@link (FlowContent:type)} node, to
    * canonical markdown. Defined in terms of {@link Markdown.stringifyResult}
@@ -1323,10 +1360,12 @@ export declare class Markdown {
    * see {@link Markdown.stringifyResult}.
    *
    * @param node - The document tree, or a single flow node, to serialize.
+   * @param options - Optional {@link MarkdownStringifyOptions}; `canonical: true`
+   *   discards fidelity fields.
    * @returns An `Effect` that succeeds with markdown source, or fails with
    *   {@link MarkdownStringifyError}.
    */
-  static readonly stringify: (node: Root | FlowContent) => Effect.Effect<string, MarkdownStringifyError, never>;
+  static readonly stringify: (node: Root | FlowContent, options?: MarkdownStringifyOptions | undefined) => 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
@@ -1629,6 +1668,49 @@ export declare class MarkdownDocument extends MarkdownDocument_base {
    * checking repeatedly.
    */
   get hasFrontmatterBlock(): boolean;
+  /**
+   * The line index over `source`: offsets to zero-based `{ line, character }`
+   * and back, with exactly the rules this package's own positions use.
+   *
+   * @remarks
+   * A `LineIndex` from `@effected/source` (re-exported from this package's
+   * entry point), typed as the structural `SourceIndex` so a consumer on
+   * another installed copy of `@effected/source` can pass it on, with its
+   * default `"lsp"` line breaks: `\n`, `\r\n` and a
+   * bare `\r`, `character` in UTF-16 code units, an offset at the `\n` of a
+   * `\r\n` reading as the end of its line. So for any offset into
+   * `source`:
+   *
+   * - `doc.lineIndex.positionAt(offset)` is the `line`/`character` a
+   *   {@link MarkdownDiagnostic} at that offset carries;
+   * - a node's unist `Point` has `line` = `lineAt(offset) + 1` and
+   *   `column` = `offset - lineStart(line) + 1`: `positionAt` plus one on
+   *   both axes everywhere except at the `\n` of a `\r\n`, which a Point
+   *   counts as one column past the `\r` (as `vfile-location` does) and
+   *   `positionAt` reads as the end of its line;
+   * - `offsetAt`, `spanOf` and `rangeOf` convert an LSP `Position` or
+   *   `Range` back to an offset or a `MarkdownRange`-shaped
+   *   `{ offset, length }`.
+   *
+   * A parsed document returns the index the parse itself built; a document
+   * constructed with `make` builds one on first access. Either way it is
+   * built once per document and shared by every later access. To index a
+   * text with no document, `LineIndex.make(text)` gives the same answers.
+   *
+   * @example
+   * ```ts
+   * import { MarkdownDocument } from "@effected/markdown";
+   * import { Result } from "effect";
+   *
+   * const result = MarkdownDocument.parseResult("# Title\r\n\r\nBody\n");
+   * if (Result.isSuccess(result)) {
+   *   const index = result.success.lineIndex;
+   *   console.log(index.positionAt(12)); // => { line: 2, character: 1 }
+   *   console.log(index.offsetAt({ line: 2, character: 0 })); // => 11
+   * }
+   * ```
+   */
+  get lineIndex(): SourceIndex$1;
   /**
    * Every heading in the document, in document order, wherever it sits —
    * including headings nested inside blockquotes and list items.
@@ -2873,6 +2955,30 @@ export declare class MarkdownTransform {
    *   a heading depth or `min > max` — a wiring error, not a data error.
    */
   static shiftHeadings<N extends MarkdownNode>(node: N, by: number, options?: ShiftHeadingsOptions): N;
+  /**
+   * Return a copy of the tree with every fidelity field cleared, so
+   * `Markdown.stringify` emits the canonical form instead of the author's
+   * spelling.
+   *
+   * @remarks
+   * Clears `headingStyle`, `markerChar` (emphasis, strong, thematic break),
+   * `fenceChar` and `fenceLength`, `bulletChar` and `delimiter`, and
+   * `breakStyle`. `Text`'s `escapeStyle` is an emitter instruction rather
+   * than a recorded spelling and is kept. Positions and all mdast fields are
+   * untouched. The input is never mutated; a subtree carrying no fidelity
+   * field is returned as the same instance, following
+   * {@link MarkdownTransform.(map:1)}, on which this is built. Like `map` it
+   * recurses without a depth guard, so a tree nested past the stack throws a
+   * `RangeError`; `Markdown.stringifyResult` with `canonical: true` checks
+   * depth first and fails typed at the stringifier's own limit instead.
+   *
+   * `Markdown.stringify(tree, { canonical: true })` is exactly
+   * `Markdown.stringify(MarkdownTransform.canonicalize(tree))`.
+   *
+   * @param node - The node whose fidelity fields to clear.
+   * @returns The node with fidelity fields cleared.
+   */
+  static canonicalize<N extends MarkdownNode>(node: N): N;
   /**
    * Locate the root-level sections of one heading depth by child index —
    * no source text needed, so it works on a tree a
@@ -2956,120 +3062,22 @@ export type MarkdownVisitorEvent = Data.TaggedEnum<{
  *
  * @public
  */
-export 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">;
-};
+export declare const MarkdownVisitorEvent: Data.TaggedEnum.Constructor<{
+  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;
+}>;
 /**
  * Walks a parsed markdown tree as a lazy sequence of `Enter`/`Exit` events in
  * document pre-order — synchronously with {@link MarkdownVisitor.walk}, or as
@@ -3395,5 +3403,5 @@ export declare const TomlFrontmatter: FrontmatterCodec;
  * @public
  */
 export declare const YamlFrontmatter: FrontmatterCodec;
-export type { DocumentHeading, DocumentLink, FrontmatterCodec, FrontmatterResolveError, FrontmatterSchemaError, FrontmatterSchemaResolver, FrontmatterWriteError, LinkBearingNode, MarkdownNodeOfType, MarkdownNodeType, MarkdownPath, MarkdownPhrasingOnlyType, MarkdownRangeLike, MarkdownSegment, MarkdownTransformHandlers, MarkdownTransformResult, MdastNode, MdastToTextOptions, SectionHeadingMatch, SectionQueryOptions, SectionSpan, SectionSpanOptions, ShiftHeadingsOptions };
+export { type DocumentHeading, type DocumentLink, type FrontmatterCodec, type FrontmatterResolveError, type FrontmatterSchemaError, type FrontmatterSchemaResolver, type FrontmatterWriteError, type LineBreaks, LineIndex, type LineIndexOptions, type LinkBearingNode, type MarkdownNodeOfType, type MarkdownNodeType, type MarkdownPath, type MarkdownPhrasingOnlyType, type MarkdownRangeLike, type MarkdownSegment, type MarkdownStringifyOptions, type MarkdownTransformHandlers, type MarkdownTransformResult, type MdastNode, type MdastToTextOptions, type SectionHeadingMatch, type SectionQueryOptions, type SectionSpan, type SectionSpanOptions, type ShiftHeadingsOptions, type SourceDiagnostic, type SourceIndex, type SourceLocation, type SourcePosition, type SourceRange, type SourceSpan };
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -5,13 +5,14 @@ import { SchemaDeclaration, SchemaDeclarationByName, SchemaDeclarationByPath, Sc
 import { FrontmatterNewline, FrontmatterSource, FrontmatterSourceBlock, FrontmatterSourceSplit } from "./FrontmatterSource.js";
 import { JsonFrontmatter } from "./JsonFrontmatter.js";
 import { MarkdownDiagnostic, MarkdownParseErrorCode } from "./MarkdownDiagnostic.js";
+import { MarkdownTransform } from "./MarkdownTransform.js";
 import { Markdown, MarkdownDialect, MarkdownParseError, MarkdownParseOptions, MarkdownStringifyError } from "./Markdown.js";
 import { DocumentSection, MarkdownDocument } from "./MarkdownDocument.js";
 import { CodeBlockStyle, MarkdownFormat, MarkdownFormattingOptions, MarkdownModificationError, MarkdownModificationErrorCode } from "./MarkdownFormat.js";
-import { MarkdownTransform } from "./MarkdownTransform.js";
 import { MarkdownVisitor, MarkdownVisitorEvent } from "./MarkdownVisitor.js";
 import { Mdast, MdastDecodeError } from "./Mdast.js";
 import { TomlFrontmatter } from "./TomlFrontmatter.js";
 import { YamlFrontmatter } from "./YamlFrontmatter.js";
+import { LineIndex } from "@effected/source";
 
-export { Blockquote, Break, BreakStyle, BulletChar, Code, CodeBlockStyle, Definition, Delete, DocumentSection, Emphasis, EmphasisChar, FenceChar, FlowContent, FootnoteDefinition, FootnoteReference, Frontmatter, FrontmatterContent, FrontmatterDecodeError, FrontmatterEncodeError, FrontmatterFormat, FrontmatterFormatMismatchError, FrontmatterMissingError, FrontmatterMissingReason, FrontmatterNewline, FrontmatterSource, FrontmatterSourceBlock, FrontmatterSourceSplit, FrontmatterValidationError, Heading, HeadingDepth, HeadingStyle, Html, Image, ImageReference, InlineCode, JsonFrontmatter, Link, LinkReference, List, ListContent, ListDelimiter, ListItem, Markdown, MarkdownDiagnostic, MarkdownDialect, MarkdownDocument, MarkdownEdit, MarkdownFormat, MarkdownFormattingOptions, MarkdownFrontmatter, MarkdownModificationError, MarkdownModificationErrorCode, MarkdownNode, MarkdownParseError, MarkdownParseErrorCode, MarkdownParseOptions, MarkdownRange, MarkdownStringifyError, MarkdownTransform, MarkdownVisitor, MarkdownVisitorEvent, Mdast, MdastDecodeError, MdxFlowExpression, MdxJsxAttribute, MdxJsxAttributeContent, MdxJsxAttributeValueExpression, MdxJsxExpressionAttribute, MdxJsxFlowElement, MdxJsxTextElement, MdxTextExpression, MdxjsEsm, 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 };
+export { Blockquote, Break, BreakStyle, BulletChar, Code, CodeBlockStyle, Definition, Delete, DocumentSection, Emphasis, EmphasisChar, FenceChar, FlowContent, FootnoteDefinition, FootnoteReference, Frontmatter, FrontmatterContent, FrontmatterDecodeError, FrontmatterEncodeError, FrontmatterFormat, FrontmatterFormatMismatchError, FrontmatterMissingError, FrontmatterMissingReason, FrontmatterNewline, FrontmatterSource, FrontmatterSourceBlock, FrontmatterSourceSplit, FrontmatterValidationError, Heading, HeadingDepth, HeadingStyle, Html, Image, ImageReference, InlineCode, JsonFrontmatter, LineIndex, Link, LinkReference, List, ListContent, ListDelimiter, ListItem, Markdown, MarkdownDiagnostic, MarkdownDialect, MarkdownDocument, MarkdownEdit, MarkdownFormat, MarkdownFormattingOptions, MarkdownFrontmatter, MarkdownModificationError, MarkdownModificationErrorCode, MarkdownNode, MarkdownParseError, MarkdownParseErrorCode, MarkdownParseOptions, MarkdownRange, MarkdownStringifyError, MarkdownTransform, MarkdownVisitor, MarkdownVisitorEvent, Mdast, MdastDecodeError, MdxFlowExpression, MdxJsxAttribute, MdxJsxAttributeContent, MdxJsxAttributeValueExpression, MdxJsxExpressionAttribute, MdxJsxFlowElement, MdxJsxTextElement, MdxTextExpression, MdxjsEsm, 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 };

package/internal/blockParser.js

@@ -1,12 +1,13 @@
-import { Frontmatter, Point, Position, Root } from "../MarkdownNode.js";
+import { Frontmatter, Position, Root } from "../MarkdownNode.js";
 import { scanFrontmatter } from "./blocks/frontmatter.js";
 import { makeBlockNode } from "./blockTypes.js";
 import { columnsToNextTabStop, preprocessLines } from "./preprocess.js";
 import { isHtmlBlockEnd } from "./blocks/htmlBlock.js";
 import { blockDialect } from "./blockRegistry.js";
 import { GuardExceeded } from "./carriers.js";
-import { LineIndex } from "./lineIndex.js";
+import { pointAt } from "./point.js";
 import { prepareInline } from "./rawInline.js";
+import { LineIndex } from "@effected/source";
 
 // src/internal/blockParser.ts
 /** Upstream's cheap pre-filter: a line that cannot start any block. */
@@ -42,9 +43,7 @@ var BlockParser = class {
 	constructor(text, dialect, dialectName, frontmatter = false) {
 		this.lines = preprocessLines(text);
 		this.frontmatterCapture = frontmatter ? scanFrontmatter(this.lines, text) : null;
-		const starts = this.lines.map((line) => line.start);
-		if (text.endsWith("\n")) starts.push(text.length);
-		this.lineIndex = LineIndex.fromLineStarts(text, starts);
+		this.lineIndex = LineIndex.make(text);
 		this.sourceLength = text.length;
 		this.dialect = dialect;
 		this.dialectName = dialectName;
@@ -306,19 +305,9 @@ var BlockParser = class {
 	position(startOffset, endOffset) {
 		const start = Math.min(Math.max(startOffset, 0), this.sourceLength);
 		const end = Math.min(Math.max(endOffset, start), this.sourceLength);
-		const startPoint = this.lineIndex.positionAt(start);
-		const endPoint = this.lineIndex.positionAt(end);
 		return Position.make({
-			start: Point.make({
-				line: startPoint.line,
-				column: startPoint.column,
-				offset: start
-			}),
-			end: Point.make({
-				line: endPoint.line,
-				column: endPoint.column,
-				offset: end
-			})
+			start: pointAt(this.lineIndex, start),
+			end: pointAt(this.lineIndex, end)
 		});
 	}
 	/**
@@ -402,7 +391,8 @@ var BlockParser = class {
 			rawInlines,
 			carriers: [],
 			refmap,
-			footnoteLabels
+			footnoteLabels,
+			lineIndex: this.lineIndex
 		};
 	}
 };

package/internal/fidelity.js

@@ -0,0 +1,25 @@
+// src/internal/fidelity.ts
+/** Node type to the fidelity keys that node may carry. */
+const FIDELITY_FIELDS = {
+	heading: ["headingStyle"],
+	emphasis: ["markerChar"],
+	strong: ["markerChar"],
+	thematicBreak: ["markerChar"],
+	code: ["fenceChar", "fenceLength"],
+	list: ["bulletChar", "delimiter"],
+	break: ["breakStyle"]
+};
+/**
+* Return `node` without its fidelity keys; the same instance when it carries
+* none, so structural sharing holds.
+*/
+const clearFidelity = (node) => {
+	const keys = FIDELITY_FIELDS[node.type];
+	if (keys === void 0 || !keys.some((key) => key in node)) return node;
+	const rest = { ...node };
+	for (const key of keys) delete rest[key];
+	const ctor = node.constructor;
+	return new ctor(rest, { disableChecks: true });
+};
+
+export { FIDELITY_FIELDS, clearFidelity };

package/internal/phrasing.js

@@ -1,8 +1,9 @@
-import { Point, Position } from "../MarkdownNode.js";
+import { Position } from "../MarkdownNode.js";
 import { preprocessLines } from "./preprocess.js";
-import { LineIndex } from "./lineIndex.js";
+import { pointAt } from "./point.js";
 import { parseInlines } from "./inlineParser.js";
 import { trimWithSegments } from "./rawInline.js";
+import { LineIndex } from "@effected/source";
 
 // src/internal/phrasing.ts
 const EMPTY_REFMAP = /* @__PURE__ */ new Map();
@@ -26,24 +27,14 @@ const parsePhrasingText = (text, dialect) => {
 	if (trimmed.text.length === 0) return [];
 	const first = trimmed.segments[0];
 	const startOffset = first === void 0 ? 0 : first.sourceOffset;
-	const lineIndex = LineIndex.fromLineStarts(text, lines.map((line) => line.start));
+	const lineIndex = LineIndex.make(text);
 	const sourceLength = text.length;
 	const positionOf = (start, end) => {
 		const clampedStart = Math.min(Math.max(start, 0), sourceLength);
 		const clampedEnd = Math.min(Math.max(end, clampedStart), sourceLength);
-		const startPoint = lineIndex.positionAt(clampedStart);
-		const endPoint = lineIndex.positionAt(clampedEnd);
 		return Position.make({
-			start: Point.make({
-				line: startPoint.line,
-				column: startPoint.column,
-				offset: clampedStart
-			}),
-			end: Point.make({
-				line: endPoint.line,
-				column: endPoint.column,
-				offset: clampedEnd
-			})
+			start: pointAt(lineIndex, clampedStart),
+			end: pointAt(lineIndex, clampedEnd)
 		});
 	};
 	return parseInlines({

package/internal/point.js

@@ -0,0 +1,32 @@
+import { Point } from "../MarkdownNode.js";
+
+// src/internal/point.ts
+/**
+* The unist `Point` of `offset` within `index`'s text: one-based `line` and
+* `column`, plus the offset itself.
+*
+* @remarks
+* The caller clamps `offset` into `[0, text.length]` first, so `offset` is
+* always the point's own offset.
+*
+* The column is `offset - lineStart(line) + 1`, NOT `positionAt(offset)`
+* plus one. The two differ at exactly one offset class, the `\n` of a
+* `\r\n`: `positionAt` reads it as the end of its line (LSP cannot name the
+* middle of a terminator), while a unist Point counts it as one column past
+* the `\r`, as `vfile-location` and `mdast-util-from-markdown` do. Node
+* positions DO land there: an empty list item before a CRLF ends at its `\n`
+* (`"*\r\na"` ends the item at offset 2, line 1, column 3), so the
+* `positionAt` form would change published positions.
+*
+* @internal
+*/
+const pointAt = (index, offset) => {
+	const line = index.lineAt(offset);
+	return Point.make({
+		line: line + 1,
+		column: offset - index.lineStart(line) + 1,
+		offset
+	});
+};
+
+export { pointAt };

package/internal/treeDepth.js

@@ -0,0 +1,19 @@
+import { GuardExceeded } from "./carriers.js";
+
+// src/internal/treeDepth.ts
+/**
+* Throws {@link GuardExceeded} when `node` nests deeper than `MAX_NESTING_DEPTH`;
+* returns otherwise. Never recurses, so it is safe on a tree of any depth.
+*
+* @internal
+*/
+const assertWithinNestingDepth = (node) => {
+	const stack = [[node, 0]];
+	while (stack.length > 0) {
+		const [current, depth] = stack.pop();
+		if (current.type !== "root" && depth > 256) throw new GuardExceeded("NestingDepthExceeded", 256, depth, current.position.start.offset);
+		if ("children" in current) for (const child of current.children) stack.push([child, depth + 1]);
+	}
+};
+
+export { assertWithinNestingDepth };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/markdown",
-	"version": "0.22.0",
+	"version": "0.24.0",
 	"private": false,
 	"description": "CommonMark and GFM markdown parse, edit and transform schemas for Effect",
 	"keywords": [
@@ -38,10 +38,13 @@
 		},
 		"./package.json": "./package.json"
 	},
+	"dependencies": {
+		"@effected/source": "^0.1.0"
+	},
 	"peerDependencies": {
-		"@effected/jsonc": "^0.20.0",
-		"@effected/toml": "^0.16.0",
-		"@effected/yaml": "^0.25.0",
+		"@effected/jsonc": "^0.21.0",
+		"@effected/toml": "^0.17.0",
+		"@effected/yaml": "^0.26.0",
 		"effect": "^4.0.0"
 	},
 	"peerDependenciesMeta": {

package/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.59.1"
+      "packageVersion": "7.59.4"
     }
   ]
 }

package/internal/lineIndex.js

@@ -1,75 +0,0 @@
-// src/internal/lineIndex.ts
-/**
-* A precomputed index of line-start offsets over a fixed source text,
-* answering `positionAt(offset)` in `O(log n)` via binary search rather than
-* rescanning the text per query.
-*
-* @remarks
-* Only `\n` begins a new line. A `\r` immediately before a `\n` (CRLF) is
-* left as the trailing character of the prior line — the pair still reads as
-* a single boundary because the following `\n` is what advances the line
-* counter, not the `\r`. A bare `\r` (old Mac line endings) is not
-* recognized as a break; CommonMark's preprocessing pass normalizes those
-* before this index is ever built.
-*/
-var LineIndex = class LineIndex {
-	text;
-	lineStarts;
-	constructor(text, lineStarts) {
-		this.text = text;
-		this.lineStarts = lineStarts;
-	}
-	/**
-	* Build a {@link LineIndex} over `text` with one forward scan.
-	*
-	* @remarks
-	* Recognizes only `\n`, which is why the block pass hands over its own
-	* line table instead — see {@link LineIndex.fromLineStarts}.
-	*/
-	static make(text) {
-		const lineStarts = [0];
-		for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === 10) lineStarts.push(i + 1);
-		return new LineIndex(text, lineStarts);
-	}
-	/**
-	* Build a {@link LineIndex} over `text` from a line table someone else
-	* already computed.
-	*
-	* @remarks
-	* The parser splits lines on `\r\n`, `\n` AND a bare `\r`; this index's
-	* own scan recognizes only `\n`. For any document without a bare `\r` the
-	* two agree, but for one with them they disagree about what a line is, and
-	* every reported line number would be wrong. Handing the parser's own
-	* table over removes the possibility rather than documenting it: there is
-	* one definition of a line, and it belongs to the preprocessor.
-	*
-	* `starts` must be ascending and begin at 0; a table that is neither is a
-	* wiring bug and dies as a defect.
-	*/
-	static fromLineStarts(text, starts) {
-		if (starts.length === 0 || starts[0] !== 0) throw new TypeError("line index: a line table must be non-empty and start at offset 0");
-		return new LineIndex(text, starts);
-	}
-	/**
-	* The 1-based `{ line, column }` of `offset` within this index's text.
-	* Out-of-range offsets clamp to the nearest valid position (`0` or
-	* `text.length`) rather than throwing.
-	*/
-	positionAt(offset) {
-		const clamped = Math.min(Math.max(offset, 0), this.text.length);
-		let low = 0;
-		let high = this.lineStarts.length - 1;
-		while (low < high) {
-			const mid = low + high + 1 >> 1;
-			if ((this.lineStarts[mid] ?? 0) <= clamped) low = mid;
-			else high = mid - 1;
-		}
-		const lineStart = this.lineStarts[low] ?? 0;
-		return {
-			line: low + 1,
-			column: clamped - lineStart + 1
-		};
-	}
-};
-
-export { LineIndex };