@agentshouse/mdmodel 0.1.0-alpha.15 → 0.1.0-alpha.16

package/API.md

@@ -0,0 +1,285 @@
+# `@agentshouse/mdmodel` API reference
+
+```ts
+import {
+  apply,
+  divide,
+  links,
+  MARKDOWN_SYNTAX_PROFILE,
+  parse,
+  project,
+  retarget,
+  serialize,
+  target,
+  validate,
+  verify,
+  verifyDocuments,
+  VERSION,
+} from '@agentshouse/mdmodel';
+
+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 checked = verify({
+  'model/task.md': '---\ntype: definition\nfields:\n  title: { kind: string }\n---\n',
+});
+if (checked.verdict === 'accept') {
+  validate({ 'tasks/one.md': '---\ntype: task\ntitle: Ship\n---\n' }, undefined, 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(definitions)` accepts definition text keyed by canonical definition
+address. It returns a verified model whose `types` expose each MD Type's name,
+address, parsed field specs, and declared sections. A field spec names its
+`kind` and `required` flag; a list carries `of`, an enum carries `values`, and a
+reference carries `to`. `verifyDocuments(definitions)` accepts already parsed
+definition Documents keyed by canonical definition address and yields the same
+verified facts without parsing their content again. A verification refusal names
+`source: 'model'` and the definition address.
+
+`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.
+When `model` is supplied, validation uses only its definitions and treats every
+Library member as content, even when its Path equals a definition address. A
+content refusal then names `source: 'content'` and its Library Path. Without
+`model`, definition Documents under `types/` are read from the Library.
+
+A typed Document carries the frontmatter fields its MD type declares, plus
+`type`, `site`, and `received`; 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`. `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: 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.
+
+`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: types['types/task.md'],
+    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,44 +14,19 @@ through either `import` or `require`; browser bundlers consume the same artifact
 npm install @agentshouse/mdmodel
 ```
 
-Package releases follow the repository release handoff after merge.
-
-## API
+## Usage
 
 ```ts
-import {
-  apply,
-  divide,
-  links,
-  MARKDOWN_SYNTAX_PROFILE,
-  parse,
-  project,
-  retarget,
-  serialize,
-  target,
-  validate,
-  verify,
-  verifyDocuments,
-  VERSION,
-} from '@agentshouse/mdmodel';
+import { apply, parse, serialize, validate, verify } from '@agentshouse/mdmodel';
 
-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 checked = verify({
   'model/task.md': '---\ntype: definition\nfields:\n  title: { kind: string }\n---\n',
 });
 if (checked.verdict === 'accept') {
   validate({ 'tasks/one.md': '---\ntype: task\ntitle: Ship\n---\n' }, undefined, checked.model);
-  const task = checked.model.types.task;
-  const titleKind = task?.fields.title?.kind;
 }
-const parsed = parse(content);
+
+const parsed = parse('---\ntype: note\ntitle: Hello\n---\n');
 if (parsed.ok) {
   const next = apply(parsed.document, {
     kind: 'field',
@@ -62,257 +35,24 @@ 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);
-  }
-}
-```
-
-`verify(definitions)` accepts definition text keyed by canonical definition
-address. It returns a verified model whose `types` expose each MD Type's name,
-address, parsed field specs, and declared sections. A field spec names its
-`kind` and `required` flag; a list carries `of`, an enum carries `values`, and a
-reference carries `to`. `verifyDocuments(definitions)` accepts already parsed
-definition Documents keyed by canonical definition address and yields the same
-verified facts without parsing their content again. A verification refusal names
-`source: 'model'` and the definition address.
-
-`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.
-When `model` is supplied, validation uses only its definitions and treats every
-Library member as content, even when its Path equals a definition address. A
-content refusal then names `source: 'content'` and its Library Path. Without
-`model`, definition Documents under `types/` are read from the Library.
-
-A typed Document carries the frontmatter fields its MD type declares, plus
-`type`, `site`, and `received`; 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.
-
-`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: 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.
-
-`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: types['types/task.md'],
-    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.
+## API
 
-## Fixtures
+| Export                               | Purpose                                                    |
+| ------------------------------------ | ---------------------------------------------------------- |
+| `verify`, `verifyDocuments`          | Verify MD Type definitions into a model                    |
+| `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 package version |
 
-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/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.1.0-alpha.15";
+export declare const VERSION = "0.1.0-alpha.16";
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -1,3 +1,3 @@
-export const VERSION = '0.1.0-alpha.15';
+export const VERSION = '0.1.0-alpha.16';
 
 //# sourceMappingURL=version.js.map

package/dist/version.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/workspace/packages/mdmodel/src/version.ts"],"sourcesContent":["export const VERSION = '0.1.0-alpha.15';\n"],"names":["VERSION"],"mappings":"AAAA,OAAO,MAAMA,UAAU,iBAAiB"}
+{"version":3,"sources":["/workspace/packages/mdmodel/src/version.ts"],"sourcesContent":["export const VERSION = '0.1.0-alpha.16';\n"],"names":["VERSION"],"mappings":"AAAA,OAAO,MAAMA,UAAU,iBAAiB"}

package/fixtures/README.md

@@ -18,11 +18,7 @@ the validation Libraries. Each row carries `name`, exact `source`, expected
 the source, compare `Document.preamble`, apply
 `{ kind: 'preamble', prior: preamble, value }`, and compare the serialized result.
 These cases cover empty and heading-free Documents, frontmatter boundaries,
-fenced headings, newline/source preservation, and the Runtime moved-export
-example from its [approved candidate](https://github.com/agentshouse/mdruntime/blob/ed0a6f0b95317d9ade846ec1f2871a3997519bc4/test/rooms.ts).
-The package check runs every row in ESM, CommonJS, and the browser-target VM
-bundle, also checking stale priors, immutable Documents, and conversion of the
-Runtime link rewrite into a preamble operation through public APIs.
+fenced headings, newline/source preservation, and a moved-export link rewrite.
 
 ## Projection
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/mdmodel",
-  "version": "0.1.0-alpha.15",
+  "version": "0.1.0-alpha.16",
   "description": "MD Type language, parser, validator, structured change application, Markdown syntax profile, and conformance fixtures",
   "license": "MIT",
   "type": "module",
@@ -21,19 +21,10 @@
   "files": [
     "dist",
     "fixtures",
+    "API.md",
     "LICENSE",
-    "README.md",
-    "markdown-syntax-profile.md"
+    "README.md"
   ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/agentshouse/mdmodel.git",
-    "directory": "packages/mdmodel"
-  },
-  "homepage": "https://github.com/agentshouse/mdmodel#readme",
-  "bugs": {
-    "url": "https://github.com/agentshouse/mdmodel/issues"
-  },
   "dependencies": {
     "@cfworker/json-schema": "4.1.1"
   }

package/markdown-syntax-profile.md

@@ -1,9 +0,0 @@
-# Markdown syntax profile
-
-The MD Model pins GitHub Flavored Markdown Spec 0.29 as its Markdown syntax
-profile:
-
-https://github.github.com/gfm/
-
-The profile is a renderer promise. The package never validates Markdown
-syntax or free body text against it.