@markup-carve/carve-wasm 0.1.0 → 0.1.2

package/README.md

@@ -27,6 +27,10 @@ import policy and canonical writer as carve-rs. Modes are `safe` (default),
 const { value, report } = htmlToCarve('<p>Hello <strong>world</strong></p>', 'safe')
 ```
 
+Portable migration code can use `fromHtml(html, mode)` and
+`fromMarkdown(markdown)`. Both return `{ value, report }`; Markdown carries an
+empty diagnostics list because the engine migrates the document whole.
+
 ### Core renderer
 
 Renders Carve markup to HTML with no extensions enabled.
@@ -38,6 +42,8 @@ call.
 ```js
 import { toHtml } from '@markup-carve/carve-wasm'
 
+// The other core targets are toMarkdown, toPlainText, toAnsi, and toCarve.
+
 const html = toHtml('# Hello, Carve!')
 document.body.innerHTML = html
 ```
@@ -126,11 +132,25 @@ toHtmlWithOptions('# A\n\np\n', { sections: false })
 toHtmlWithOptions(src, { sections: false, symbols: { rocket: '🚀' }, full: true })
 ```
 
-Every field is optional - `sections` (default `true`), `symbols` (same trusted-raw
-contract as `toHtmlWithSymbols`), `extensions` (an array of names; takes
-precedence over `full`), and `full` (default `false`, enabling the preview set).
-Omitting the object, or passing `null`, renders with defaults, so the three
-shorthands above remain the zero-config forms.
+Every field is optional. Omitting the object, or passing `null`, renders with
+defaults, so the three shorthands above remain the zero-config forms.
+
+| Field | Default | What it does |
+|---|---|---|
+| `sections` | `true` | Wrap each top-level heading and its content in a `<section>` |
+| `symbols` | none | `:name:` to value, TRUSTED-RAW (see above) |
+| `extensions` | none | Array of registry names; takes precedence over `full` |
+| `full` | `false` | Enable the preview extension set |
+| `rawHtml` | `true` | Emit an explicit passthrough as markup; `false` escapes it |
+| `profile` | none | `full` / `article` / `comment` / `minimal`; rejection throws |
+| `profileBaseHost` | none | The host the profile's link policy counts as internal |
+| `mode` | `interactive` | `static` renders the self-contained form: no client scripts |
+| `sourceLine` | `false` | Stamp top-level blocks with `data-source-line` |
+| `positions` | `false` | Keep source offsets on the nodes |
+| `labels` | none | Override engine-written strings, for a page not in English |
+| `smartTypography` | `glyph` | `source` keeps the author's run instead of the glyph |
+| `lowercaseHeadingIds` | `false` | Lowercase the generated heading ids |
+| `asciiHeadingIds` | `off` | `fold` transliterates, `strict` guarantees ASCII |
 
 An unrecognized key is ignored, because the object is configuration and a typo
 should not break a render. A recognized key with the wrong type throws a
@@ -148,6 +168,72 @@ Nothing else changes: ids, collision dedup, `</#id>` cross-references, implicit
 rather than the element carrying it. The endnotes
 `<section role="doc-endnotes">` is a separate construct and is still emitted.
 
+### Rendering a document you did not write
+
+`rawHtml: false` renders an explicit passthrough - the `=html` raw block and the
+`` `…`{=html} `` inline raw span - as escaped text instead of markup. It is the
+switch carve-js spells `allowRawHtml`.
+
+```js
+toHtmlWithOptions(fromTheReader, { rawHtml: false })
+```
+
+Reach for it whenever the document comes from somewhere other than the person
+running the page: a shared link, a comment field, a pasted file. A passthrough is
+the one construct that puts author-controlled markup on your origin, so leaving
+it on for a document a reader supplied is a way to run their script.
+
+The symbols map is unaffected and stays TRUSTED-RAW either way - it is
+configuration the host wrote, not content the document carries.
+
+### Rendering with a profile
+
+`rawHtml: false` closes the passthrough vector. It does not cap input length,
+deny a construct, or constrain link schemes - that is what a profile is for, and
+the four presets match the ones the spec and the sibling bindings describe.
+
+```js
+toHtmlWithOptions(fromTheReader, { profile: 'comment', rawHtml: false })
+```
+
+**A rejected document throws.** The engine's infallible entry point turns a
+profile rejection - input past `max_length`, or a denied construct when the
+action is Error - into an EMPTY STRING, and a caller cannot tell that from a
+document that legitimately rendered to nothing. This binding renders through the
+fallible one, so a rejection arrives as an `Error` whose `name` is
+`ProfileViolationError` and whose `violations` array carries one message per
+refused construct.
+
+```js
+try {
+  html = toHtmlWithOptions(fromTheReader, { profile: 'comment' })
+} catch (error) {
+  if (error.name === 'ProfileViolationError') report(error.violations)
+}
+```
+
+### Editing a tree, and reading one back
+
+`parseJson` serializes a document out. `astJsonToHtml` renders one back, and
+`astJsonToCarve` writes one back as source, so a host that reads the tree in
+order to change something can display and save the result without a server.
+
+```js
+const tree = JSON.parse(parseJson(source))
+tree.children.unshift({ type: 'heading', level: 1, children: [{ type: 'text', value: 'Added' }] })
+const html = astJsonToHtml(JSON.stringify(tree), { full: true })
+const carve = astJsonToCarve(JSON.stringify(tree))
+```
+
+A tree carrying something no Carve source can spell is refused by
+`astJsonToCarve` rather than written approximately, and an invalid tree throws
+from either.
+
+`lintCarve` returns the degradation diagnostics as
+`{ line, column, rule, message, start, end }`, with the rule ids carve-js and
+carve-php use for the same triggers. Offsets are BYTE offsets into the source,
+matching the engine.
+
 ### TypeScript
 
 The package ships `.d.ts` declarations. Types are inferred automatically when
@@ -167,8 +253,20 @@ const html: string = toHtml('_Hello_')
 | `toHtml` | `(source: string) => string` | Core renderer, no extensions |
 | `toHtmlWithSymbols` | `(source: string, symbols?: object \| null) => string` | Core renderer + a `:name:` -> value symbols map (values are raw, see above) |
 | `toHtmlFull` | `(source: string, symbols?: object \| null) => string` | Core + common extensions (matches playground), optional symbols map |
-| `toHtmlWithOptions` | `(source: string, options?: object \| null) => string` | General form: `{ sections?, symbols?, full? }`, every field optional |
+| `toHtmlWithOptions` | `(source: string, options?: object \| null) => string` | General form; see the options table above. Throws `ProfileViolationError` when a profile rejects the document |
+| `toHtmlWithReport` | `(source: string, strict?: boolean, maximum?: number) => RenderResult` | HTML plus bounded `raw-format-dropped` losses; strict mode throws `RenderLossError` |
+| `toMarkdownWithReport` | `(source: string, strict?: boolean, maximum?: number) => RenderResult` | Checked Markdown render |
+| `toPlainTextWithReport` | `(source: string, strict?: boolean, maximum?: number) => RenderResult` | Checked plain-text render |
+| `toAnsiWithReport` | `(source: string, strict?: boolean, maximum?: number) => RenderResult` | Checked ANSI render |
+| `toCarveWithReport` | `(source: string, strict?: boolean, maximum?: number) => RenderResult` | Checked canonical Carve render (lossless) |
 | `parseJson` | `(source: string) => string` | The parsed AST as JSON (PART 12 exchange shape) |
+| `astJsonToHtml` | `(json: string, options?: object \| null) => string` | Render an AST-JSON document; takes the same options object |
+| `astJsonToCarve` | `(json: string) => string` | Write an AST-JSON document back as canonical Carve source |
+| `lintCarve` | `(source: string) => LintWarning[]` | Degradation diagnostics, with the rule ids carve-js and carve-php share |
+| `readStamp` | `(source: string) => { version, generatedBy } \| null` | The document's provenance marker, if it carries one |
+| `needsReview` | `(source: string, currentVersion: string) => boolean` | Whether the stamp predates `currentVersion`; unstamped counts as yes |
+| `fromDjot` | `(source: string) => string` | Convert Djot source to Carve |
+| `fromBbcode` | `(source: string) => string` | Convert BBCode source to Carve; throws past the engine's size cap |
 | `version` | `() => string` | Returns the carve-wasm package version |
 
 ### The parsed AST
@@ -232,6 +330,23 @@ cargo test && wasm-pack build --target nodejs && node tests/smoke.mjs
 CARVE_SPEC_CORPUS=/path/to/carve/tests/corpus node tests/corpus.mjs
 ```
 
+`scripts/check-engine-floor.py` is what notices a pin left behind. CI runs it
+against the revision carve-rb embeds:
+
+```sh
+python3 scripts/check-engine-floor.py \
+    --engine <carve-rs checkout> --manifest Cargo.toml --lock Cargo.lock \
+    --sibling-name carve-rb --sibling-manifest <carve-rb>/ext/carve/Cargo.toml \
+    --changelog CHANGELOG.md
+```
+
+It fails when this pin is a strict ancestor of the sibling's, and it also fails
+when the `[Unreleased]` changelog section names a revision the build does not
+embed - a revision quoted in prose is a second copy of the pin, and the second
+copy is the one nothing else reads. A floor rather than a leash: it is
+deliberately not a distance check against carve-rs `main`, which merges
+continuously and would be red from the moment any pull request opens there.
+
 That last line is the one that can tell a drifted pin from a current one.
 `smoke.mjs` asserts hand-written expectations, which a stale engine satisfies
 happily; `corpus.mjs` renders all ~530 mandatory spec documents through the
@@ -281,6 +396,36 @@ CARVE_WASM_PKG=some/other/pkg node tests/smoke.mjs
 Both wasm-pack targets load. Unset, it is `pkg/`, so nothing changes for the
 ordinary loop.
 
+### Rendering-only browser build
+
+All capabilities are enabled by default, so ordinary builds and the published
+package keep their complete API. A browser host that only renders Carve to HTML
+can leave the importers, reports, AST serialization, and other output formats
+out of its artifact:
+
+```sh
+wasm-pack build --target web --release --out-dir pkg-render . --no-default-features
+```
+
+The basic HTML rendering exports, including `toHtml`, `toHtmlFull`, and
+`toHtmlWithOptions`, remain available. Checked rendering through
+`toHtmlWithReport` is part of the omitted `reports` capability. The optional
+features are:
+
+| Feature | Exports |
+| --- | --- |
+| `html-import` | `htmlToCarve`, `fromHtml` |
+| `markdown-import` | `fromMarkdown` |
+| `reports` | all five `*WithReport` renderers |
+| `ast-json` | `parseJson`, `astJsonToHtml`, `astJsonToCarve` |
+| `other-renderers` | the basic Markdown, plain-text, ANSI, and Carve renderers |
+| `lint` | `lintCarve` |
+| `stamp` | `readStamp`, `needsReview` |
+| `other-imports` | `fromDjot`, `fromBbcode` |
+
+Use a separate output directory as above if a full build also exists in the
+checkout.
+
 ## Release
 
 Publishing is gated. `.github/workflows/release.yml` has two jobs, and

package/carve_wasm.d.ts

@@ -1,6 +1,50 @@
 /* tslint:disable */
 /* eslint-disable */
 
+export interface LintWarning {
+    /** 1-based line number. */
+    line: number;
+    /** 1-based column number. */
+    column: number;
+    /** Stable rule id, shared with carve-js and carve-php. */
+    rule: string;
+    message: string;
+    /** 0-based BYTE offset into the source, inclusive. */
+    start: number;
+    /** 0-based BYTE offset into the source, exclusive. */
+    end: number;
+}
+
+export interface Stamp {
+    /** The spec version the document was last processed under. */
+    version: string;
+    /** The engine that wrote the marker, when it recorded one. */
+    generatedBy: string | null;
+}
+
+
+
+/**
+ * Render an AST-JSON document (PART 12) back to canonical Carve source.
+ *
+ * The round trip a host needs to SAVE an edited tree, rather than only display
+ * it. A tree holding something no Carve source can spell is refused rather
+ * than written approximately.
+ */
+export function astJsonToCarve(json: string): string;
+
+/**
+ * Render an AST-JSON document (PART 12) to HTML.
+ *
+ * The other half of `parseJson`. A host that reads the tree in a browser does
+ * it to CHANGE something, and until now there was no way to render the result:
+ * the binding could serialize a tree out and not take one back.
+ *
+ * Takes the same options object as [`to_html_with_options`], so an edited tree
+ * renders under the profile, labels and switches the host already configured.
+ */
+export function astJsonToHtml(json: string, options?: object | null): string;
+
 /**
  * Every extension name this build accepts, in registry order.
  *
@@ -9,6 +53,28 @@
  */
 export function extensions(): string[];
 
+/**
+ * Convert BBCode source to Carve.
+ *
+ * Rejects input past the engine's `BBCODE_MAX_INPUT_LENGTH` rather than
+ * working on it: the importer's cost is superlinear in places, and a browser
+ * host cannot afford to find that out on the main thread.
+ */
+export function fromBbcode(source: string): string;
+
+/**
+ * Convert Djot source to Carve.
+ *
+ * Carve diverges from Djot deliberately - the emphasis delimiters are swapped,
+ * among others - so a Djot document is not Carve source and pasting one in
+ * renders wrongly rather than failing.
+ */
+export function fromDjot(source: string): string;
+
+export function fromHtml(source: string, mode?: string | null): any;
+
+export function fromMarkdown(source: string): any;
+
 /**
  * Import HTML through the Rust HTML5 DOM and canonical Carve writer.
  *
@@ -17,6 +83,25 @@ export function extensions(): string[];
  */
 export function htmlToCarve(source: string, mode?: string | null): any;
 
+/**
+ * Lint a document for the degradations PART 15 describes.
+ *
+ * Returns an array of `{ line, column, rule, message, start, end }`. The rule
+ * ids are shared with carve-js and carve-php, so the same trigger reports the
+ * same id everywhere. Offsets are BYTE offsets into the source, matching the
+ * engine.
+ *
+ * Built as JS objects rather than a JSON string: a message carries arbitrary
+ * document text, and hand-rolled JSON escaping is where that goes wrong.
+ */
+export function lintCarve(source: string): LintWarning[];
+
+/**
+ * Whether a document was last processed under an older spec version than
+ * `currentVersion`. An unstamped document counts as needing review.
+ */
+export function needsReview(source: string, current_version: string): boolean;
+
 /**
  * Parse Carve source and return its AST as a JSON string.
  *
@@ -37,6 +122,19 @@ export function htmlToCarve(source: string, mode?: string | null): any;
  */
 export function parseJson(source: string): string;
 
+/**
+ * Read a document's provenance marker: `{ version, generatedBy }`, or `null`.
+ */
+export function readStamp(source: string): Stamp | null;
+
+export function toAnsi(source: string): string;
+
+export function toAnsiWithReport(source: string, strict?: boolean | null, maximum?: number | null): any;
+
+export function toCarve(source: string): string;
+
+export function toCarveWithReport(source: string, strict?: boolean | null, maximum?: number | null): any;
+
 export function toHtml(source: string): string;
 
 /**
@@ -64,6 +162,8 @@ export function toHtmlFull(source: string, symbols?: object | null): string;
  * // '<h1 id="A">A</h1>\n<p>p</p>'
  *
  * toHtmlWithOptions(src, { sections: false, symbols: { rocket: '🚀' }, full: true })
+ *
+ * toHtmlWithOptions(untrusted, { rawHtml: false })
  * ```
  *
  * Every field is optional:
@@ -86,6 +186,31 @@ export function toHtmlFull(source: string, symbols?: object | null): string;
  *   over `full`.
  * * `full` (default `false`) - enable the preview extension set instead of
  *   rendering core-only.
+ * * `rawHtml` (default `true`) - render an explicit passthrough - the `=html`
+ *   raw block and the `` `…`{=html} `` inline raw span - as markup. `false`
+ *   emits it as escaped text instead, the same switch carve-js spells
+ *   `allowRawHtml`. A host that renders a document it did not author (a shared
+ *   link, a comment field, anything a reader supplies) wants `false`: without
+ *   it a passthrough is a way to run script on the host's origin.
+ * * `profile` - one of `"full"`, `"article"`, `"comment"`, `"minimal"`. The
+ *   rest of the untrusted-input story: input length, denied constructs, link
+ *   policy. A document the profile REJECTS throws a `ProfileViolationError`
+ *   carrying `violations`, rather than resolving to an empty string.
+ * * `profileBaseHost` - the host counted as internal when the profile's link
+ *   policy distinguishes internal from external links.
+ * * `mode` - `"interactive"` (default) or `"static"`, the self-contained form
+ *   for print, PDF and archival: no client scripts.
+ * * `sourceLine` (default `false`) - stamp top-level blocks with
+ *   `data-source-line`, for editor preview scroll-sync.
+ * * `positions` (default `false`) - keep source offsets on the nodes.
+ * * `labels` - override the engine-written strings (admonition names, the
+ *   endnotes heading, backlink text) for a page that is not in English. These
+ *   are TEXT and are escaped where they land, unlike `symbols`.
+ * * `smartTypography` - `"glyph"` (default) resolves `...` to an ellipsis,
+ *   `"source"` keeps the author's run.
+ * * `lowercaseHeadingIds` (default `false`) and `asciiHeadingIds`
+ *   (`"off"` (default), `"fold"`, `"strict"`) - the slug policy, for a host
+ *   whose anchors have to match another generator's.
  *
  * An unrecognized key is ignored: the object is configuration, and a caller
  * who mistypes one deserves the render to still work. A wrong TYPE on a key
@@ -99,6 +224,8 @@ export function toHtmlFull(source: string, symbols?: object | null): string;
  */
 export function toHtmlWithOptions(source: string, options?: object | null): string;
 
+export function toHtmlWithReport(source: string, strict?: boolean | null, maximum?: number | null): any;
+
 /**
  * Render with the core profile and a **symbols map**: `{ rocket: "🚀" }` (a
  * plain object or a `Map`). A `:name:` symbol whose name is in the map renders
@@ -117,4 +244,12 @@ export function toHtmlWithOptions(source: string, options?: object | null): stri
  */
 export function toHtmlWithSymbols(source: string, symbols?: object | null): string;
 
+export function toMarkdown(source: string): string;
+
+export function toMarkdownWithReport(source: string, strict?: boolean | null, maximum?: number | null): any;
+
+export function toPlainText(source: string): string;
+
+export function toPlainTextWithReport(source: string, strict?: boolean | null, maximum?: number | null): any;
+
 export function version(): string;

package/carve_wasm.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./carve_wasm_bg.js";
 __wbg_set_wasm(wasm);
 wasm.__wbindgen_start();
 export {
-    extensions, htmlToCarve, parseJson, toHtml, toHtmlFull, toHtmlWithOptions, toHtmlWithSymbols, version
+    astJsonToCarve, astJsonToHtml, extensions, fromBbcode, fromDjot, fromHtml, fromMarkdown, htmlToCarve, lintCarve, needsReview, parseJson, readStamp, toAnsi, toAnsiWithReport, toCarve, toCarveWithReport, toHtml, toHtmlFull, toHtmlWithOptions, toHtmlWithReport, toHtmlWithSymbols, toMarkdown, toMarkdownWithReport, toPlainText, toPlainTextWithReport, version
 } from "./carve_wasm_bg.js";

package/carve_wasm_bg.js

@@ -1,3 +1,67 @@
+/**
+ * Render an AST-JSON document (PART 12) back to canonical Carve source.
+ *
+ * The round trip a host needs to SAVE an edited tree, rather than only display
+ * it. A tree holding something no Carve source can spell is refused rather
+ * than written approximately.
+ * @param {string} json
+ * @returns {string}
+ */
+export function astJsonToCarve(json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.astJsonToCarve(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Render an AST-JSON document (PART 12) to HTML.
+ *
+ * The other half of `parseJson`. A host that reads the tree in a browser does
+ * it to CHANGE something, and until now there was no way to render the result:
+ * the binding could serialize a tree out and not take one back.
+ *
+ * Takes the same options object as [`to_html_with_options`], so an edited tree
+ * renders under the profile, labels and switches the host already configured.
+ * @param {string} json
+ * @param {object | null} [options]
+ * @returns {string}
+ */
+export function astJsonToHtml(json, options) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.astJsonToHtml(ptr0, len0, isLikeNone(options) ? 0 : addToExternrefTable0(options));
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * Every extension name this build accepts, in registry order.
  *
@@ -12,6 +76,91 @@ export function extensions() {
     return v1;
 }
 
+/**
+ * Convert BBCode source to Carve.
+ *
+ * Rejects input past the engine's `BBCODE_MAX_INPUT_LENGTH` rather than
+ * working on it: the importer's cost is superlinear in places, and a browser
+ * host cannot afford to find that out on the main thread.
+ * @param {string} source
+ * @returns {string}
+ */
+export function fromBbcode(source) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.fromBbcode(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Convert Djot source to Carve.
+ *
+ * Carve diverges from Djot deliberately - the emphasis delimiters are swapped,
+ * among others - so a Djot document is not Carve source and pasting one in
+ * renders wrongly rather than failing.
+ * @param {string} source
+ * @returns {string}
+ */
+export function fromDjot(source) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.fromDjot(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {string} source
+ * @param {string | null} [mode]
+ * @returns {any}
+ */
+export function fromHtml(source, mode) {
+    const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(mode) ? 0 : passStringToWasm0(mode, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.fromHtml(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {string} source
+ * @returns {any}
+ */
+export function fromMarkdown(source) {
+    const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.fromMarkdown(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Import HTML through the Rust HTML5 DOM and canonical Carve writer.
  *
@@ -33,6 +182,45 @@ export function htmlToCarve(source, mode) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Lint a document for the degradations PART 15 describes.
+ *
+ * Returns an array of `{ line, column, rule, message, start, end }`. The rule
+ * ids are shared with carve-js and carve-php, so the same trigger reports the
+ * same id everywhere. Offsets are BYTE offsets into the source, matching the
+ * engine.
+ *
+ * Built as JS objects rather than a JSON string: a message carries arbitrary
+ * document text, and hand-rolled JSON escaping is where that goes wrong.
+ * @param {string} source
+ * @returns {LintWarning[]}
+ */
+export function lintCarve(source) {
+    const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.lintCarve(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Whether a document was last processed under an older spec version than
+ * `currentVersion`. An unstamped document counts as needing review.
+ * @param {string} source
+ * @param {string} current_version
+ * @returns {boolean}
+ */
+export function needsReview(source, current_version) {
+    const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(current_version, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.needsReview(ptr0, len0, ptr1, len1);
+    return ret !== 0;
+}
+
 /**
  * Parse Carve source and return its AST as a JSON string.
  *
@@ -68,6 +256,91 @@ export function parseJson(source) {
     }
 }
 
+/**
+ * Read a document's provenance marker: `{ version, generatedBy }`, or `null`.
+ * @param {string} source
+ * @returns {Stamp | null}
+ */
+export function readStamp(source) {
+    const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.readStamp(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {string} source
+ * @returns {string}
+ */
+export function toAnsi(source) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.toAnsi(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {string} source
+ * @param {boolean | null} [strict]
+ * @param {number | null} [maximum]
+ * @returns {any}
+ */
+export function toAnsiWithReport(source, strict, maximum) {
+    const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.toAnsiWithReport(ptr0, len0, isLikeNone(strict) ? 0xFFFFFF : strict ? 1 : 0, isLikeNone(maximum) ? 0x100000001 : (maximum) >>> 0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {string} source
+ * @returns {string}
+ */
+export function toCarve(source) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.toCarve(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {string} source
+ * @param {boolean | null} [strict]
+ * @param {number | null} [maximum]
+ * @returns {any}
+ */
+export function toCarveWithReport(source, strict, maximum) {
+    const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.toCarveWithReport(ptr0, len0, isLikeNone(strict) ? 0xFFFFFF : strict ? 1 : 0, isLikeNone(maximum) ? 0x100000001 : (maximum) >>> 0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * @param {string} source
  * @returns {string}
@@ -134,6 +407,8 @@ export function toHtmlFull(source, symbols) {
  * // '<h1 id="A">A</h1>\n<p>p</p>'
  *
  * toHtmlWithOptions(src, { sections: false, symbols: { rocket: '🚀' }, full: true })
+ *
+ * toHtmlWithOptions(untrusted, { rawHtml: false })
  * ```
  *
  * Every field is optional:
@@ -156,6 +431,31 @@ export function toHtmlFull(source, symbols) {
  *   over `full`.
  * * `full` (default `false`) - enable the preview extension set instead of
  *   rendering core-only.
+ * * `rawHtml` (default `true`) - render an explicit passthrough - the `=html`
+ *   raw block and the `` `…`{=html} `` inline raw span - as markup. `false`
+ *   emits it as escaped text instead, the same switch carve-js spells
+ *   `allowRawHtml`. A host that renders a document it did not author (a shared
+ *   link, a comment field, anything a reader supplies) wants `false`: without
+ *   it a passthrough is a way to run script on the host's origin.
+ * * `profile` - one of `"full"`, `"article"`, `"comment"`, `"minimal"`. The
+ *   rest of the untrusted-input story: input length, denied constructs, link
+ *   policy. A document the profile REJECTS throws a `ProfileViolationError`
+ *   carrying `violations`, rather than resolving to an empty string.
+ * * `profileBaseHost` - the host counted as internal when the profile's link
+ *   policy distinguishes internal from external links.
+ * * `mode` - `"interactive"` (default) or `"static"`, the self-contained form
+ *   for print, PDF and archival: no client scripts.
+ * * `sourceLine` (default `false`) - stamp top-level blocks with
+ *   `data-source-line`, for editor preview scroll-sync.
+ * * `positions` (default `false`) - keep source offsets on the nodes.
+ * * `labels` - override the engine-written strings (admonition names, the
+ *   endnotes heading, backlink text) for a page that is not in English. These
+ *   are TEXT and are escaped where they land, unlike `symbols`.
+ * * `smartTypography` - `"glyph"` (default) resolves `...` to an ellipsis,
+ *   `"source"` keeps the author's run.
+ * * `lowercaseHeadingIds` (default `false`) and `asciiHeadingIds`
+ *   (`"off"` (default), `"fold"`, `"strict"`) - the slug policy, for a host
+ *   whose anchors have to match another generator's.
  *
  * An unrecognized key is ignored: the object is configuration, and a caller
  * who mistypes one deserves the render to still work. A wrong TYPE on a key
@@ -191,6 +491,22 @@ export function toHtmlWithOptions(source, options) {
     }
 }
 
+/**
+ * @param {string} source
+ * @param {boolean | null} [strict]
+ * @param {number | null} [maximum]
+ * @returns {any}
+ */
+export function toHtmlWithReport(source, strict, maximum) {
+    const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.toHtmlWithReport(ptr0, len0, isLikeNone(strict) ? 0xFFFFFF : strict ? 1 : 0, isLikeNone(maximum) ? 0x100000001 : (maximum) >>> 0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Render with the core profile and a **symbols map**: `{ rocket: "🚀" }` (a
  * plain object or a `Map`). A `:name:` symbol whose name is in the map renders
@@ -231,6 +547,76 @@ export function toHtmlWithSymbols(source, symbols) {
     }
 }
 
+/**
+ * @param {string} source
+ * @returns {string}
+ */
+export function toMarkdown(source) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.toMarkdown(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {string} source
+ * @param {boolean | null} [strict]
+ * @param {number | null} [maximum]
+ * @returns {any}
+ */
+export function toMarkdownWithReport(source, strict, maximum) {
+    const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.toMarkdownWithReport(ptr0, len0, isLikeNone(strict) ? 0xFFFFFF : strict ? 1 : 0, isLikeNone(maximum) ? 0x100000001 : (maximum) >>> 0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {string} source
+ * @returns {string}
+ */
+export function toPlainText(source) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.toPlainText(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {string} source
+ * @param {boolean | null} [strict]
+ * @param {number | null} [maximum]
+ * @returns {any}
+ */
+export function toPlainTextWithReport(source, strict, maximum) {
+    const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.toPlainTextWithReport(ptr0, len0, isLikeNone(strict) ? 0xFFFFFF : strict ? 1 : 0, isLikeNone(maximum) ? 0x100000001 : (maximum) >>> 0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * @returns {string}
  */
@@ -330,15 +716,35 @@ export function __wbg_new_4f9fafbb3909af72() {
     const ret = new Object();
     return ret;
 }
+export function __wbg_new_e3b04b4d53d1b593(arg0, arg1) {
+    const ret = new Error(getStringFromWasm0(arg0, arg1));
+    return ret;
+}
+export function __wbg_new_f3c9df4f38f3f798() {
+    const ret = new Array();
+    return ret;
+}
 export function __wbg_parse_545d11396395fbbd() { return handleError(function (arg0, arg1) {
     const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
     return ret;
 }, arguments); }
+export function __wbg_push_6bdbc990be5ac37b(arg0, arg1) {
+    const ret = arg0.push(arg1);
+    return ret;
+}
 export function __wbg_set_8ee2d34facb8466e() { return handleError(function (arg0, arg1, arg2) {
     const ret = Reflect.set(arg0, arg1, arg2);
     return ret;
 }, arguments); }
-export function __wbindgen_cast_0000000000000001(arg0, arg1) {
+export function __wbg_set_name_ab9c98596fd7310a(arg0, arg1, arg2) {
+    arg0.name = getStringFromWasm0(arg1, arg2);
+}
+export function __wbindgen_cast_0000000000000001(arg0) {
+    // Cast intrinsic for `F64 -> Externref`.
+    const ret = arg0;
+    return ret;
+}
+export function __wbindgen_cast_0000000000000002(arg0, arg1) {
     // Cast intrinsic for `Ref(String) -> Externref`.
     const ret = getStringFromWasm0(arg0, arg1);
     return ret;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@markup-carve/carve-wasm",
   "type": "module",
   "description": "WASM bindings for the Carve parser and HTML renderer.",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "license": "MIT",
   "repository": {
     "type": "git",