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

package/API.md

@@ -0,0 +1,298 @@
+# `@agentshouse/mdmodel` API reference
+
+```ts
+import {
+  apply,
+  divide,
+  links,
+  MARKDOWN_SYNTAX_PROFILE,
+  parse,
+  project,
+  retarget,
+  serialize,
+  target,
+  validate,
+  verify,
+  VERSION,
+} from '@agentshouse/mdmodel';
+
+validate({ 'note.md': '# Hello\n' });
+const checked = verify('types:\n  task:\n    fields:\n      title: { kind: 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 task = checked.model.types.task;
+  const titleKind = task?.fields.title?.kind;
+}
+const parsed = parse(content);
+if (parsed.ok) {
+  const next = apply(parsed.document, {
+    kind: 'field',
+    name: 'title',
+    value: 'World',
+    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);
+  }
+}
+```
+
+`verify(schema)` reads one schema text, the MD Types of one Room or App, and
+returns a verified model whose `types` expose each MD Type's `name`,
+`memberDocument` flag, parsed field specs, and declared sections. The text is a
+YAML mapping in the frontmatter subset whose one key, `types`, maps each MD Type
+name to an entry of optional `fields`, `sections`, and boolean `member_document`:
+
+```yaml
+types:
+  plan:
+    fields:
+      title: { kind: string, required: true }
+      status: { kind: enum, values: [active, done] }
+      owner: { kind: reference, to: contact }
+    sections:
+      Goals: { kind: text }
+  contact:
+    member_document: true
+    fields:
+      name: { kind: string, required: true }
+```
+
+A field spec names its `kind` and `required` flag; a list carries `of`, an enum
+carries `values`, and a reference carries `to`, which names `any` or a type of
+the same schema. At most one type is marked `member_document: true`. A
+malformed schema is refused whole, naming its `rule` and, where the
+rule concerns one part of the text, its `location`: a dotted path such as
+`types.plan.fields.status`, or `line <n>` where the text leaves the YAML subset.
+
+`validate(library, context?, model?)` 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.
+`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 carries the frontmatter fields its MD type declares, plus
+`type`, `SITE_FIELD` and `RECEIVED_FIELD`, the `site` and `received` a Site
+submission adds; a Document of the type marked `member_document` also carries
+`MEMBER_FIELD`, `member`, a string, unless that type declares it. 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. Every occurrence of a declared list section is a list
+whose every item is one value of its declared item kind, or it is refused as `structured-section`.
+A free-text or string item is any text; a number, date, or enum item is that value alone, such
+as `- 3`; a reference item is one ordinary link alone, such as `- [Ada](ada.md)`, refused as
+`unresolved-reference` where it reaches a binary target, a URL, or another MD type's Document.
+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.
+
+```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 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: 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.
+
+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.
+
+`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: the MD Type language, 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('types:\n  task:\n    fields:\n      title: { kind: 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,25 @@ 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.
+## API
 
-## Fixtures
+| 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                           |
+| `project`, `divide`                            | Embedding projection input and its division into Spans            |
+| `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 conformance corpus ships in `fixtures/`. Its verdict format and rule ids
-are documented in [`fixtures/README.md`](fixtures/README.md).
+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).
 
-## Markdown syntax profile
+## License
 
-GitHub Flavored Markdown Spec 0.29, as documentation, not as validation.
-See [`markdown-syntax-profile.md`](markdown-syntax-profile.md).
+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,
+    }));
+}

package/dist/definition.d.ts

@@ -1,4 +1,4 @@
-import type { Document, Refusal } from './types.js';
+import type { VerifiedModel } from './types.js';
 export type TextSpec = {
     readonly kind: 'text';
     readonly required: boolean;
@@ -30,9 +30,13 @@ export type FieldSpec = ScalarSpec | ListSpec;
 export type SectionSpec = TextSpec | ListSpec;
 export type Definition = {
     readonly name: string;
-    readonly file: string;
+    readonly memberDocument: boolean;
     readonly fields: Readonly<Record<string, FieldSpec>>;
     readonly sections: Readonly<Record<string, SectionSpec>>;
 };
-export declare function readDefinition(file: string, document: Document): Definition | Refusal;
+export type Failure = {
+    readonly rule: string;
+    readonly location?: string;
+};
+export declare function readSchema(text: string): VerifiedModel | Failure;
 //# sourceMappingURL=definition.d.ts.map

package/dist/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../src/definition.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAEpD,MAAM,MAAM,QAAQ,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAC;AAE7E,MAAM,MAAM,UAAU,GAClB,QAAQ,GACR;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,GACvD;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,GACvD;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,GACrD;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GACzF;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpF,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,QAAQ,CAAC;AAE9C,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE9C,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;IACrD,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;CAC1D,CAAC;AAsGF,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,UAAU,GAAG,OAAO,CA6BrF"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../src/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAGhD,MAAM,MAAM,QAAQ,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAC;AAE7E,MAAM,MAAM,UAAU,GAClB,QAAQ,GACR;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,GACvD;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,GACvD;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,GACrD;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GACzF;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpF,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,QAAQ,CAAC;AAE9C,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE9C,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;IACrD,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;CAC1D,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAwJ5E,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,OAAO,CAgChE"}