@agentshouse/mdmodel 0.1.0-alpha.9 → 0.1.0-c2987f5d89720

package/API.md

@@ -0,0 +1,302 @@
+# `@agentshouse/mdmodel` API reference
+
+```ts
+import {
+  apply,
+  divide,
+  links,
+  MARKDOWN_SYNTAX_PROFILE,
+  parse,
+  project,
+  retarget,
+  serialize,
+  target,
+  validate,
+  verify,
+  VERSION,
+} from '@agentshouse/mdmodel';
+
+const checked = verify('task:\n  properties:\n    title: { type: string }\n');
+if (checked.verdict === 'accept') {
+  validate(
+    { 'tasks/one.md': '---\ntype: task\ntitle: Ship\n---\n![Figure](assets/figure.png)\n' },
+    { binaryTargets: ['assets/figure.png'] },
+    checked.model,
+  );
+}
+const parsed = parse(content);
+if (parsed.ok) {
+  for (const link of links(parsed.document, 'tasks/two.md')) {
+    if (link.target !== 'data/export.csv') continue;
+    const moved = apply(parsed.document, {
+      kind: 'link',
+      href: link.href,
+      to: '../files/export.csv',
+    });
+    if (moved.outcome === 'applied') serialize(moved.document);
+  }
+}
+```
+
+`verify(schema)` reads one schema text, the MD Types of one Room or App: one
+JSON Schema document (draft 2020-12) in the YAML subset. Every top-level key but
+`$defs` names an MD Type holding the JSON Schema of its frontmatter; `$defs`
+holds shapes the types reuse, reached by a `$ref` under `#/$defs/` alone. `type`
+and the built-in `any` are never declared. The model adds three keywords:
+`reference` on a string names one MD Type, several, `any` or `attachment`;
+`sections` declares a type's H2 sections, each `{ kind: text }` or `{ kind:
+list, items }` over one string, number, integer or boolean, optionally
+`required: true`; `member_document: true` marks at most one type.
+
+```yaml
+$defs:
+  address: { type: object, properties: { city: { type: string } }, required: [city] }
+plan:
+  properties:
+    status: { enum: [active, done] }
+    owner: { type: string, reference: contact }
+    shipping: { $ref: '#/$defs/address' }
+  required: [status]
+  sections: { Goals: { kind: text, required: true } }
+contact: { member_document: true }
+```
+
+The model's `types` expose each MD Type's `name`, `memberDocument`, `sections`,
+`shape` (the type as written with every `$defs` shape it reaches), the facts of
+its `frontmatter` and `fields`, its top-level ones: JSON `type`, `format`,
+`values`, `reference` targets, `items`, `properties`, an open map's `patterns`
+and `additional`, and `prose`, a string with no `enum`, `const`, `format`,
+`pattern` or `reference`. Facts join `$ref` and `allOf` to their siblings and
+the variants of `anyOf`, `oneOf`, `then`, `else` and `dependentSchemas`; a path
+without one `type`, `null` aside, has none. A malformed schema is refused
+whole, naming its `rule`, the keyword or the model's own, and the JSON Pointer
+`location` it concerns, such as `/plan/properties/status/enum`, or `line <n>`
+outside the YAML subset.
+
+`validate(library, context?, model?)` takes the resulting text Library and one
+`ValidationContext` of `binaryTargets: readonly string[]`, none when omitted.
+Library keys and binary targets share one canonical collection-relative path
+namespace; a path declared text and binary is refused. Ordinary links and images
+in typed Documents may resolve to either membership, relative to the source
+Document, and one to a path neither holds is not refused: it dangles, as a
+deleted file's links do. A destination that is an absolute path or leaves the
+collection is `unresolved-link`. A binary target supplies no Document or MD Type. `model` is the
+verified schema that types the Library, and every Library member is content,
+whatever its Path. Without `model` the Library declares no type.
+
+A typed Document's frontmatter satisfies its type's schema, every keyword with
+its JSON Schema meaning, formats asserted and defaults never filled, except that
+an object schema declaring neither `additionalProperties` nor
+`unevaluatedProperties` is closed: an undeclared key is refused as `undeclared-
+field`. `type`, `SITE_FIELD` and `RECEIVED_FIELD` count as declared on every
+type, and the string `MEMBER_FIELD` on the `member_document` type. A refusal
+names the keyword, such as `required`, and the value's JSON Pointer, such as
+`/shipping/city`. Every occurrence of a declared list section is a list of
+values of its item schema, else `structured-section`; a reference item is one
+ordinary link alone, such as `- [Ada](ada.md)`. A reference, at any depth or a
+section item, reaching a URL, a binary target, or a Document of a type it does
+not name is `unresolved-reference`, and a frontmatter one reaching no member is
+`referenced-missing-file` naming its `referrers`; `attachment` admits any path,
+and no body link is a referrer.
+
+Validation returns acceptance or one refusal naming the file, the field or
+section, and the violated rule. `parse`, `apply`, and `serialize` operate on a single text
+Document; they do not validate collection membership or consume binary bytes.
+`apply` sets one typed field, including a list field as a whole, replaces
+one existing section body or the preamble against that value's prior content,
+or rewrites one Markdown link destination. A section need not be declared by
+the Document's MD Type to be replaced. A field change does not reformat the rest of the file.
+
+`Document.preamble` is a readonly string containing the exact source after
+frontmatter and before the first section heading recognized by the existing
+section parser. Without a section it is the entire post-frontmatter body;
+without frontmatter it starts at the beginning of the Document. An empty span
+is `''`. It includes whitespace, newlines, a leading H1, and any fenced text
+before the first section. The closing frontmatter delimiter and its line ending
+belong to frontmatter. Section recognition and the syntax profile are unchanged.
+
+```ts
+const parsed = parse(content);
+if (parsed.ok) {
+  const change = {
+    kind: 'preamble' as const,
+    prior: parsed.document.preamble,
+    value: 'Updated introduction.\n\n',
+  };
+  const result = apply(parsed.document, change);
+  if (result.outcome === 'applied') serialize(result.document);
+}
+```
+
+`apply(document, { kind: 'preamble', prior, value })` compares `prior` to the
+current preamble exactly. A mismatch returns `{ outcome: 'stale', document }`
+with the unchanged current Document. A match replaces only that source span,
+then parses a new immutable Document; the original is unchanged. Frontmatter
+and section source outside the span retain their exact bytes, including newline
+and heading syntax. As with section replacement, `value` is literal source:
+no newline or separator is inserted, and the resulting source is parsed again.
+An invalid frontmatter result receives the existing parse refusal. Independent
+field, section, and preamble edits keep their own prior values valid.
+
+For a moved link, use `links` and the `link` change below to obtain the rewritten
+Document, then compare its public `preamble` and `sections` to the original.
+Submit the changed values with their original priors. Consumers need no source
+span calculation or private Model import. Collection validation remains a
+separate call against the resulting Library.
+
+`links(document, file)` is the inventory of that Document's ordinary link and
+image destinations that resolve to a collection Path, each with the destination
+`href` exactly as written and the `target` Path it resolves to relative to
+`file`. A `?query` or `#fragment` the destination carries is part of `href` and
+not part of `target`. Entries are ordered by the position of the destination
+text a rewrite would change, and one destination written the same way appears
+once however many times it occurs. A destination that the syntax profile does not read as a
+link, one that is empty, a bare fragment, or carries a URL scheme, and one that
+leaves the collection are not in the inventory. Frontmatter field values,
+including typed references, are not link destinations and are never enumerated.
+
+`target(file, href)` is the collection Path one written destination resolves to
+relative to `file`, by the rule `links` and `validate` read: surrounding spaces
+and the `?query` or `#fragment` it carries are not part of that Path. A
+destination that is empty, a bare fragment, carries a URL scheme, starts at `/`,
+or leaves the collection resolves to `null`. It reads a destination written
+anywhere, such as a typed reference field value, which `links` never
+enumerates. `retarget(href, to)` is that destination rewritten to `to`, keeping
+the `?query` or `#fragment` it carried, which is the destination the `link`
+change below writes.
+
+`references(document, definition)` lists each frontmatter `reference` string at
+any depth as `pointer`, `value` and `to`; `apply(document, { kind: 'reference',
+pointer, value, prior })` rewrites one in place, keeping its quotes, or is
+`stale`. `relativize(document, file, handle, definition?)` rewrites each link
+destination and reference written `/rooms/<handle>/<path>` to `relative(file,
+path)`, keeping its `?query` or `#fragment`; `relativizeBody(body, file,
+handle)` does so to a text without frontmatter, refusing one left under
+`/rooms/` as `unresolved-link`.
+
+```ts
+target('items/six.md', ' ../projects/atlas.md#overview '); // 'projects/atlas.md'
+retarget(' ../projects/atlas.md#overview ', '../archive/atlas.md'); // '../archive/atlas.md#overview'
+```
+
+`apply(document, { kind: 'link', href, to })` rewrites every body occurrence of
+that written destination and changes nothing else, so a caller that moves a Path
+rewrites its referring Documents without a second Markdown parser. `to` is the
+Path the destination must resolve to instead; the `?query` or `#fragment` the
+written destination carried is not part of that Path and is kept. A Document
+that does not carry the destination is `stale`. A reference definition is
+rewritten once however many uses name it. The destination is
+written in the form the syntax profile reads back: bare when it carries no
+whitespace, does not open with `<`, and balances its parentheses, otherwise
+inside angle brackets, which the original form is kept in when it still fits. A
+destination that neither form can carry is refused as `unwritable-link`.
+
+`project(document, file, context?)` is the Embedding projection input of one
+Document: the prose a consumer embeds, with every internal Markdown-document
+link reduced to the label a reader sees. A Document that declares no MD type
+contributes its body after the frontmatter fence. A typed one contributes its
+prose values, its preamble, and every H2 section its MD type does not declare as
+structure, each with its own heading line and every occurrence of a repeated
+name, in Document order: a declared text section, a list section of prose items
+and an undeclared section are in; a list section of any other item schema is
+not. A prose value is a frontmatter string at any depth whose schema is prose,
+projected bare and followed by a blank line, in the order the Document writes
+them, exactly as written. The Path and every other value stay outside, so
+changing them alone leaves the projection unchanged.
+
+```ts
+const parsed = parse(content);
+if (parsed.ok) {
+  const projected = project(parsed.document, 'tasks/two.md', {
+    documentTargets: ['plans/q3.md', 'people/ana.md'],
+    definition: model.types.task,
+  });
+  if (projected.ok) embed(projected.text);
+}
+```
+
+`ProjectionContext` carries `documentTargets`, the collection-relative Paths the
+caller holds as Markdown documents, and `definition`, the verified MD Type the
+Document's `type` names, taken from the model `verify` returned. A Document that
+declares a type the caller supplies no definition for is refused as
+`unknown-type`. `documentTargets` is what makes a destination internal: a
+destination resolving to a supplied Path is internal, and every other
+destination stays authored text, a retained binary target and a Path nobody
+supplied alike. The caller supplies that membership, as it does for `validate`;
+the model reads no bytes, resolves no authority, and classifies nothing it was
+not given.
+
+An internal link contributes its visible label and no destination, fragment, or
+title, in the inline `[label](path)`, full `[label][id]`, collapsed
+`[label][]`, and shortcut `[label]` forms, and the link reference definition an
+enumerated use resolves through leaves the projection with it. An image at a
+supplied document target contributes its alt text the same way, because a move
+rewrites that destination too. External URLs, retained binary targets,
+unsupplied destinations, bare fragments, code spans, fenced code, and escaped
+syntax stay exactly as authored, read through the same syntax profile `links`
+and `validate` read. `project` returns text and never rewrites the Document.
+
+A `link` change leaves the projection of every Document it rewrites
+byte-identical, while a changed visible label changes it.
+
+`divide(document, file, context)` divides that same Embedding projection input
+into ordered Spans under the budget the caller supplies. Each Span carries the
+`text` to embed and the `start` and `end` of the extent it addresses in the
+Document's own source, as UTF-8 byte offsets into that source and never string
+positions, so a caller stores the extent and hydrates the text it shows from
+the Document itself.
+
+```ts
+const parsed = parse(content);
+if (parsed.ok) {
+  const divided = divide(parsed.document, 'tasks/two.md', {
+    documentTargets: ['plans/q3.md', 'people/ana.md'],
+    definition: model.types.task,
+    budget: 2000,
+  });
+  if (divided.ok) for (const span of divided.spans) embed(span.text);
+}
+```
+
+`DivisionContext` is a `ProjectionContext` and one `budget`, the greatest number
+of characters a Span's embedded text may carry, counted the way JavaScript
+counts a string's length and not in the bytes the extent is measured in. No
+Span's text is ever longer than the budget. A bound cut never divides a
+character: where the budget ends between the two halves of a surrogate pair,
+the cut falls before the pair. A cut never falls inside link syntax either: it
+falls before an internal link, and a label longer than a whole piece's room is
+divided at the bound like any other text. The smallest budget is `2`, the
+length of one astral character; a budget that is not a whole number of at least
+`2` is refused with `division-budget` before any division. The budget is the
+caller's number alone: the model holds no tokenizer, counts nothing else, and
+refuses no input for being too long. A Document the caller supplies no
+definition for carries the same `unknown-type` refusal `project` returns.
+
+The division descends one level at a time, and only into the piece that does not
+fit: the whole input, a heading node, adjacent sibling nodes packed under one
+parent, adjacent blocks inside a node, sentences inside a block, and a bound cut
+inside a single sentence. A Span covers whole heading nodes or one contiguous
+piece inside a single node, never a partial node beside another. A Span that
+continues a node repeats that node's own heading line, projected like any other
+text and so carrying an internal link's label rather than its destination, and
+never an ancestor's heading, so renaming a heading costs what editing that
+heading's own body costs. A heading the budget cannot hold beside any text is
+not repeated, a continuation piece that begins with an astral character the
+room beside its heading cannot hold is carried without the heading, and a
+heading with no body of its own leads its first child node rather than standing
+as a Span of nothing but itself. Overlap exists at the
+sentence level alone, where each Span after the first repeats its predecessor's
+last sentence whenever the budget holds both; when it cannot hold both, the
+Span carries its own sentence alone. An untyped input arrives without a
+definition and descends the same ladder.
+
+Division is total: every authored character of the input belongs to at least one
+Span, and an input carrying no authored text divides into no Span at all. A
+Span's extent is the smallest range of the source that contains everything the
+Span covers, so it spans what the input excludes between two eligible pieces,
+and the extent addresses the authored source where the embedded text carries a
+repeated heading, an internal link's visible label, or a frontmatter value the
+author quoted. A Span divided out of one free-text field value addresses that
+whole value, because a YAML scalar's own positions are the only ones its source
+has, and a Span carrying part of one internal link's label addresses that whole
+link, because a cut never falls inside link syntax.

package/README.md

@@ -1,14 +1,12 @@
 # `@agentshouse/mdmodel`
 
-The standalone MD Model: the MD Type language, its parser, its validator, the
-deterministic application of one structured change to Document content, the
-Markdown syntax profile, and the conformance fixtures.
+Typed Markdown documents: MD Types declared in JSON Schema, a parser, a validator, and the
+deterministic application of one structured change to a Document, plus a
+conformance fixture corpus.
 
-The package runs in a browser and in Node. It makes no network call and reads
-no filesystem on its own. Callers pass text Library state as path-to-content and declare retained binary
-link targets separately in a `ValidationContext`.
-The public root exposes one ESM artifact. Node 24.21.0 and later can load it
-through either `import` or `require`; browser bundlers consume the same artifact.
+It runs in the browser and in Node, makes no network call, and reads no
+filesystem on its own. It ships one ESM artifact that Node 24.21.0 and later
+loads through `import` or `require`.
 
 ## Install
 
@@ -16,31 +14,17 @@ through either `import` or `require`; browser bundlers consume the same artifact
 npm install @agentshouse/mdmodel
 ```
 
-Package releases are published after the User confirms.
-
-## API
+## Usage
 
 ```ts
-import {
-  apply,
-  links,
-  MARKDOWN_SYNTAX_PROFILE,
-  parse,
-  project,
-  serialize,
-  validate,
-  VERSION,
-} from '@agentshouse/mdmodel';
+import { apply, parse, serialize, validate, verify } from '@agentshouse/mdmodel';
+
+const checked = verify('task:\n  properties:\n    title: { type: string }\n');
+if (checked.verdict === 'accept') {
+  validate({ 'tasks/one.md': '---\ntype: task\ntitle: Ship\n---\n' }, undefined, checked.model);
+}
 
-validate({ 'note.md': '# Hello\n' });
-validate(
-  {
-    'types/note.md': '---\ntype: definition\n---\n',
-    'note.md': '---\ntype: note\n---\n![Figure](assets/figure.png)\n',
-  },
-  { binaryTargets: ['assets/figure.png'] },
-);
-const parsed = parse(content);
+const parsed = parse('---\ntype: note\ntitle: Hello\n---\n');
 if (parsed.ok) {
   const next = apply(parsed.document, {
     kind: 'field',
@@ -49,166 +33,27 @@ if (parsed.ok) {
     prior: 'Hello',
   });
   if (next.outcome === 'applied') serialize(next.document);
-  for (const link of links(parsed.document, 'tasks/two.md')) {
-    if (link.target !== 'data/export.csv') continue;
-    const moved = apply(parsed.document, {
-      kind: 'link',
-      href: link.href,
-      to: '../files/export.csv',
-    });
-    if (moved.outcome === 'applied') serialize(moved.document);
-  }
 }
 ```
 
-`validate(library, context?)` takes the resulting text Library and one
-`ValidationContext` containing `binaryTargets: readonly string[]`. Omitting the
-context declares no binary targets. Library keys and binary targets use the
-same collection-relative path namespace; callers supply canonical paths, and
-a path declared as both text and binary is refused. Ordinary links and images
-in typed Documents may resolve to either membership, including relative
-normalization from the source Document. A binary target supplies no Document
-or MD Type and cannot satisfy a typed reference, including one to `any`.
-The existing `any` Document rules are unchanged.
-
-A typed Document carries only the frontmatter fields its MD type declares, so
-any other field is refused as `undeclared-field` at that field name. A field
-name YAML carries to a record prototype, `__proto__` among them, is an ordinary
-undeclared field and is refused as one. A declared list section is validated as
-a list; its declared item kind governs projection eligibility rather than the
-value of each item, which validation reads no further than that list form.
-Validation returns acceptance or one refusal naming the file, the field or
-section, the violated rule, and `VERSION`. Every caller operation that validates
-a resulting collection supplies that collection's context to this same
-`validate` function. `parse`, `apply`, and `serialize` operate on a single text
-Document; they do not validate collection membership or consume binary bytes.
-`apply` sets one typed field, including a list field as a whole, replaces
-one existing section body or the preamble against that value's prior content,
-or rewrites one Markdown link destination. A section need not be declared by
-the Document's MD Type to be replaced. A field change does not reformat the rest of the file.
-
-`Document.preamble` is a readonly string containing the exact source after
-frontmatter and before the first section heading recognized by the existing
-section parser. Without a section it is the entire post-frontmatter body;
-without frontmatter it starts at the beginning of the Document. An empty span
-is `''`. It includes whitespace, newlines, a leading H1, and any fenced text
-before the first section. The closing frontmatter delimiter and its line ending
-belong to frontmatter. Section recognition and the syntax profile are unchanged.
-
-```ts
-const parsed = parse(content);
-if (parsed.ok) {
-  const change = {
-    kind: 'preamble' as const,
-    prior: parsed.document.preamble,
-    value: 'Updated introduction.\n\n',
-  };
-  const result = apply(parsed.document, change);
-  if (result.outcome === 'applied') serialize(result.document);
-}
-```
-
-`apply(document, { kind: 'preamble', prior, value })` compares `prior` to the
-current preamble exactly. A mismatch returns `{ outcome: 'stale', document }`
-with the unchanged current Document. A match replaces only that source span,
-then parses a new immutable Document; the original is unchanged. Frontmatter
-and section source outside the span retain their exact bytes, including newline
-and heading syntax. As with section replacement, `value` is literal source:
-no newline or separator is inserted, and the resulting source is parsed again.
-An invalid frontmatter result receives the existing parse refusal. Independent
-field, section, and preamble edits keep their own prior values valid.
-
-For a moved link, use `links` and the `link` change below to obtain the rewritten
-Document, then compare its public `preamble` and `sections` to the original.
-Submit the changed values with their original priors. Consumers need no source
-span calculation or private Model import. Collection validation remains a
-separate call against the resulting Library.
-
-`links(document, file)` is the inventory of that Document's ordinary link and
-image destinations that resolve to a collection Path, each with the destination
-`href` exactly as written and the `target` Path it resolves to relative to
-`file`. A `?query` or `#fragment` the destination carries is part of `href` and
-not part of `target`. Entries are ordered by the position of the destination
-text a rewrite would change, and one destination written the same way appears
-once however many times it occurs. A destination that the syntax profile does not read as a
-link, one that is empty, a bare fragment, or carries a URL scheme, and one that
-leaves the collection are not in the inventory. Frontmatter field values,
-including typed references, are not link destinations and are never enumerated.
-
-`apply(document, { kind: 'link', href, to })` rewrites every body occurrence of
-that written destination and changes nothing else, so a caller that moves a Path
-rewrites its referring Documents without a second Markdown parser. `to` is the
-Path the destination must resolve to instead; the `?query` or `#fragment` the
-written destination carried is not part of that Path and is kept. A Document
-that does not carry the destination is `stale`. A reference definition is
-rewritten once however many uses name it. The destination is
-written in the form the syntax profile reads back: bare when it carries no
-whitespace, does not open with `<`, and balances its parentheses, otherwise
-inside angle brackets, which the original form is kept in when it still fits. A
-destination that neither form can carry is refused as `unwritable-link`.
-
-`project(document, file, context?)` is the Embedding projection input of one
-Document: the prose a consumer embeds, with every internal Markdown-document
-link reduced to the label a reader sees. A Document that declares no MD type
-contributes its body after the frontmatter fence. A Document that declares one
-contributes its free-text field values, its preamble, and every H2 section its
-MD type does not declare as structure, each section with its own heading line
-and every occurrence of a repeated name, in the order the Document carries
-them. A declared free-text section, a declared list section whose items are
-free text, and a section the MD type does not declare at all are all inside
-that input; a declared list section of any other item kind is not, so
-eligibility follows the declared kind rather than the form the author wrote.
-Each free-text field value is projected bare, without its field name and
-followed by a blank line, in the order the MD Type declares its fields, and
-every item of a free-text list field is one such value, projected as the author
-wrote it: the link inventory reads the body, so link syntax inside a
-frontmatter value is text like any other. The Document's Path and its typed
-fields of every other kind stay outside that input.
-
-```ts
-const parsed = parse(content);
-if (parsed.ok) {
-  const projected = project(parsed.document, 'tasks/two.md', {
-    documentTargets: ['plans/q3.md', 'people/ana.md'],
-    definition: types['types/task.md'],
-  });
-  if (projected.ok) embed(projected.text);
-}
-```
-
-`ProjectionContext` carries `documentTargets`, the collection-relative Paths the
-caller holds as Markdown documents, and `definition`, the source of the MD Type
-definition Document the Document's `type` names. A Document that declares a type
-the caller supplies no definition for is refused as `unknown-type`, and a
-definition source the model cannot read carries its own refusal naming
-`types/<type>.md`. `documentTargets` is what makes a destination internal: a
-destination resolving to a supplied Path is internal, and every other
-destination stays authored text, a retained binary target and a Path nobody
-supplied alike. The caller supplies that membership, as it does for `validate`;
-the model reads no bytes, resolves no authority, and classifies nothing it was
-not given.
-
-An internal link contributes its visible label and no destination, fragment, or
-title, in the inline `[label](path)`, full `[label][id]`, and collapsed
-`[label][]` forms, and the link reference definition an enumerated use resolves
-through leaves the projection with it. An image at a supplied document target
-contributes its alt text the same way, because a move rewrites that destination
-too. External URLs, retained binary targets, unsupplied destinations, bare
-fragments, code spans, fenced code, and escaped syntax stay exactly as authored,
-read through the same syntax profile `links` and `validate` read. `project`
-returns text and never rewrites the Document.
-
-Because a moved Path changes destinations alone, applying a `link` change leaves
-the projection of every Document it rewrites byte-identical, while a changed
-visible label changes it. `fixtures/projection.json` carries every move row of
-that corpus; the label change is proven at this package's own `project` seam.
-
-## Fixtures
-
-The conformance corpus ships in `fixtures/`. Its verdict format and rule ids
-are documented in [`fixtures/README.md`](fixtures/README.md).
-
-## Markdown syntax profile
+## API
 
-GitHub Flavored Markdown Spec 0.29, as documentation, not as validation.
-See [`markdown-syntax-profile.md`](markdown-syntax-profile.md).
+| Export                                         | Purpose                                                           |
+| ---------------------------------------------- | ----------------------------------------------------------------- |
+| `verify`                                       | Verify one schema text into a model of MD Types                   |
+| `validate`                                     | Validate a text Library; returns acceptance or one refusal        |
+| `parse`, `serialize`                           | Read and write one Document                                       |
+| `apply`                                        | Apply one field, section, preamble, or link change                |
+| `links`, `target`, `retarget`                  | Inventory and rewrite link destinations                           |
+| `escapePointer`                                | Write one key as a JSON Pointer token                             |
+| `project`, `divide`                            | Embedding projection input and its division into Spans            |
+| `facts`, `factKind`, `holds`, `fires`          | A condition over a Document and over one of its changes           |
+| `MARKDOWN_SYNTAX_PROFILE`, `VERSION`           | The pinned Markdown profile (GFM 0.29) and MD model version       |
+| `MEMBER_FIELD`, `SITE_FIELD`, `RECEIVED_FIELD` | The field names validation counts as declared beyond a type's own |
+
+The full reference is in [`API.md`](API.md). The conformance corpus and its
+verdict format and rule ids are described in [`fixtures/README.md`](fixtures/README.md).
+
+## License
+
+MIT

package/dist/blocks.d.ts

@@ -0,0 +1,11 @@
+import type { Extent } from './types.js';
+export type HeadingLine = {
+    readonly level: number;
+    readonly name: string;
+    readonly start: number;
+    readonly textEnd: number;
+    readonly next: number;
+};
+export declare function headingLines(content: string, from: number, to: number): HeadingLine[];
+export declare function blockRanges(content: string, from: number, to: number): Extent[];
+//# sourceMappingURL=blocks.d.ts.map

package/dist/blocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocks.d.ts","sourceRoot":"","sources":["../src/blocks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEzC,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB,CAAC;AAmCF,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,WAAW,EAAE,CAiBrF;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,CAe/E"}

package/dist/blocks.js

@@ -0,0 +1,62 @@
+import { fenceSpans } from './links.js';
+const HEADING = /^(#{1,6})(?!#)[ \t]+(.+?)[ \t]*#*[ \t]*$/;
+function lineAt(content, from, to) {
+    const nl = content.indexOf('\n', from);
+    const end = nl === -1 || nl >= to ? to : nl;
+    const raw = content.slice(from, end);
+    return { text: raw.endsWith('\r') ? raw.slice(0, -1) : raw, next: end === to ? to : end + 1 };
+}
+function scan(content, from, to, visit) {
+    const fences = fenceSpans(content.slice(from, to));
+    let i = from;
+    while (i < to) {
+        const { text, next } = lineAt(content, i, to);
+        const at = i - from;
+        visit({
+            text,
+            start: i,
+            next,
+            fenced: fences.some(([start, end]) => at >= start && at < end),
+        });
+        if (next === i)
+            break;
+        i = next;
+    }
+}
+export function headingLines(content, from, to) {
+    const found = [];
+    scan(content, from, to, (line) => {
+        if (line.fenced)
+            return;
+        const match = HEADING.exec(line.text);
+        const hashes = match?.[1];
+        const name = match?.[2];
+        if (hashes === undefined || name === undefined)
+            return;
+        found.push({
+            level: hashes.length,
+            name: name.trim(),
+            start: line.start,
+            textEnd: line.start + line.text.length,
+            next: line.next,
+        });
+    });
+    return found;
+}
+export function blockRanges(content, from, to) {
+    const starts = [];
+    let open = false;
+    scan(content, from, to, (line) => {
+        if (!line.fenced && line.text.trim() === '') {
+            open = false;
+            return;
+        }
+        if (!open)
+            starts.push(line.start);
+        open = true;
+    });
+    return starts.map((start, index) => ({
+        start: index === 0 ? from : start,
+        end: starts[index + 1] ?? to,
+    }));
+}