@aruzone/aze-forge 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 aruzone
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,408 @@
+# AzeForge
+
+AzeForge compiles AzeMark into deterministic, self-contained HTML and continuous-layout SVG Artifacts.
+
+## Supported syntax
+
+- AzeMark v1 YAML front matter
+- ATX headings such as `# Heading`
+- Setext headings
+- paragraphs
+- plain inline text
+- equation directive Blocks (readable aliases plus trusted-local raw LaTeX)
+
+Readable equation example:
+
+```text
+:::: equation
+id: euler
+number: true
+align: center
+
+F(omega) =
+  integral t=-infinity..infinity of
+  f(t) exp(-i omega t) dt
+::::
+```
+
+Header attributes are `id`, `number: true|false`, `align: left|center|right`,
+and `syntax: readable|latex` (default `readable`). Readable aliases cover
+Greek letters, `sqrt`/`frac`/`root`, `sum`/`product`, `integral`, `limit`,
+derivatives, `matrix`, `cases`, and relations/sets; they render through
+pinned KaTeX (`0.18.5`, offline `htmlAndMathml`, `trust: false`, bounded,
+sanitized). Raw LaTeX is denied by default with
+`azeforge.security#raw-latex-disabled` and renders only with
+`--allow-raw-latex` on `validate` or `render`:
+
+```text
+:::: equation
+syntax: latex
+
+\frac{a}{b}
+::::
+```
+
+Directive envelopes are recovered as `InvalidBlock` values until Plugins are registered. Raw HTML is denied and never rendered as text or markup. Lists, Mermaid, images, and other Markdown constructs are not implemented yet.
+
+## Install
+
+Consumers install the published package; no repo checkout is needed:
+
+```bash
+npm install -g @aruzone/aze-forge
+azeforge --help
+```
+
+Prerequisites: Node.js 22 or 24, on Ubuntu or macOS.
+Windows support is parked until platform-specific verification lands (see issue #43).
+There is no standalone binary: the npm global install is the distribution
+path, so the Node prerequisite always applies. A single-file binary would
+have to bundle Node plus the pinned browser engine and fonts below, and is
+deferred; users re-install for new versions (no auto-update).
+
+The install downloads the pinned browser engine (Chrome Headless Shell
+`152.0.7977.75` into `~/.cache/puppeteer`) via the `puppeteer` postinstall
+script, so the installing machine needs network access once. Verify it with
+a browser-backed format:
+
+```bash
+azeforge capabilities --probe --json
+azeforge render /tmp/manual.aze.md --output /tmp/manual.svg
+```
+
+Offline or browser-missing installs stay structured: browser-backed formats
+(`svg`, `png`, `pdf`, Mermaid diagrams) fail with exit `1` and a
+`azeforge.renderer#browser-unavailable` (or `adapter-missing`) diagnostic
+suggesting `Reinstall AzeForge browser dependencies and retry`, never a
+stack trace. Plain-HTML rendering without diagrams keeps working. Remedy:
+re-install with network access, or fetch only the engine with
+`npx puppeteer browsers install chrome-headless-shell@152.0.7977.75`.
+
+The acceptance gate runs identically against the consumer install by
+pointing the runner at the `azeforge` on `PATH`:
+
+```bash
+AZEFORGE_CLI=azeforge node scripts/acceptance.mjs
+```
+
+(from a checkout; the runner itself ships in the repo, the CLI under test
+is the installed one).
+
+Uninstall:
+
+```bash
+npm uninstall -g @aruzone/aze-forge
+# optional: remove the downloaded browser engine
+rm -rf ~/.cache/puppeteer
+```
+
+## Build
+
+The project requires Node.js 22 or newer.
+
+Supported releases run on Node.js 22 and 24 (Ubuntu, macOS);
+Windows support is parked until platform-specific verification lands (see issue #43).
+Canonical HTML/SVG/PNG/PDF golden and visual evidence is built on pinned
+Ubuntu x64 with Node 24. `azeforge capabilities --json` reports the exact
+support matrix under `runtime`.
+
+```bash
+npm install
+npm run build
+```
+
+The examples below invoke the built CLI directly:
+
+```bash
+node dist/cli.js
+```
+## Create a Source file
+
+```bash
+cat >/tmp/manual.aze.md <<'EOF'
+---
+azemark: 1
+title: Manual AzeForge test
+author:
+  - Test Author
+theme: default
+outputs:
+  - html
+---
+
+# Introduction
+
+This document tests the current compiler.
+
+Results
+-------
+
+The render is deterministic.
+EOF
+```
+
+## Validate
+
+```bash
+node dist/cli.js validate /tmp/manual.aze.md
+echo $?
+```
+
+A valid Source produces no stdout or stderr and exits with status `0`.
+
+Add `--diagnostics json` to `validate` or file-targeted `render` to emit exactly one `azeforge.diagnostics/v1` report on stdout. The package exports `diagnosticsJsonSchema` for JSON Schema 2020-12 validation. Human diagnostics remain on stderr.
+
+## Format Source
+
+```bash
+# Write LF-formatted UTF-8 Source to stdout.
+node dist/cli.js format /tmp/manual.aze.md
+
+# Atomically replace a file.
+node dist/cli.js format /tmp/manual.aze.md --write
+
+# Emit no Source; exit 1 only when formatting is required.
+node dist/cli.js format /tmp/manual.aze.md --check
+
+# Stdin is explicit; `-` is not an alias.
+cat /tmp/manual.aze.md | node dist/cli.js format --stdin
+```
+
+Formatting removes a leading BOM, emits LF line endings, preserves comments,
+unknown directive bodies, invalid regions, and denied raw content, and writes
+nothing when structural syntax is ambiguous. `--write` rejects stdin, and
+`--write` and `--check` cannot be combined.
+
+## Render to a file
+
+```bash
+node dist/cli.js render \
+  /tmp/manual.aze.md \
+  --output /tmp/manual.html
+
+echo $?
+open /tmp/manual.html
+```
+
+A successful render exits with status `0` and atomically replaces `/tmp/manual.html`.
+
+Use an `.svg` destination or pass `--format svg` to produce SVG2 with an
+XHTML `foreignObject`. The SVG records its required `svg2` and
+`xhtml-foreign-object` capabilities in Artifact metadata; it does not emit a
+fallback format.
+
+```bash
+node dist/cli.js render \
+  /tmp/manual.aze.md \
+  --output /tmp/manual.svg
+```
+
+Check that the Artifact embeds its fonts and contains no scripts:
+
+```bash
+grep -o 'data:font/woff2;base64' /tmp/manual.html | sort -u
+grep -i '<script' /tmp/manual.html
+```
+
+The first command prints `data:font/woff2;base64`. The second prints nothing.
+
+## Render to stdout
+
+```bash
+node dist/cli.js render \
+  /tmp/manual.aze.md \
+  --stdout \
+  --format html \
+  >/tmp/manual-stdout.html
+
+cmp /tmp/manual.html /tmp/manual-stdout.html
+echo $?
+```
+
+`cmp` produces no output and exits with status `0`.
+
+## Watch a Source
+
+```bash
+node dist/cli.js watch \
+  /tmp/manual.aze.md \
+  --output /tmp/manual.html
+```
+
+`watch` compiles immediately, then fully recompiles after coalesced changes to
+the Source or its project images. Compiles are serialized; a failed cycle
+preserves the last successful Artifact and keeps watching. Add
+`--diagnostics json` to stream `azeforge.event/v1` NDJSON records on stdout
+instead of human diagnostics on stderr.
+
+## Serve a preview
+
+```bash
+node dist/cli.js serve /tmp/manual.aze.md --port 0
+# serve: listening on http://127.0.0.1:62545/ for /tmp/manual.aze.md
+```
+
+`serve` binds only loopback (ephemeral port by default) and shows the current
+HTML preview or the current diagnostics, never stale content. The preview
+wraps the exact Artifact bytes in an unhashable reload shell; only preview,
+SSE, and opaque asset routes exist. Stop with `SIGINT` or `SIGTERM`.
+
+## Check deterministic output
+
+```bash
+cp /tmp/manual.html /tmp/manual-first.html
+
+node dist/cli.js render \
+  /tmp/manual.aze.md \
+  --output /tmp/manual.html
+
+cmp /tmp/manual-first.html /tmp/manual.html
+shasum -a 256 /tmp/manual-first.html /tmp/manual.html
+```
+
+The files must be byte-identical and have the same SHA-256 value.
+
+The HTML also records the semantic content hash:
+
+```bash
+grep -o 'name="azeforge-content-hash" content="sha256:[^"]*"' \
+  /tmp/manual.html
+```
+
+## Check failure handling
+
+```bash
+cat >/tmp/invalid.aze.md <<'EOF'
+---
+azemark: 2
+---
+
+This version is unsupported.
+EOF
+
+printf 'previous successful Artifact' >/tmp/preserved.html
+
+node dist/cli.js render \
+  /tmp/invalid.aze.md \
+  --output /tmp/preserved.html
+
+echo "exit: $?"
+cat /tmp/preserved.html
+```
+
+The command reports `azeforge.source#version-unsupported`, exits with status `1`, and leaves the previous Artifact unchanged.
+
+CLI exit statuses:
+
+- `0`: the operation succeeded, including warning-only validation
+- `1`: an accepted operation failed on Source or component diagnostics
+- `2`: arguments or options could not form an operation
+
+## Test invalid Source recovery
+
+Exercise the recovery seam with malformed UTF-8, malformed front matter, duplicate IDs, unknown directives, raw HTML, CRLF, and multi-error Source:
+
+```bash
+node dist/cli.js validate /tmp/bad.aze.md; echo "exit=$?"
+node dist/cli.js validate /tmp/bad.aze.md --diagnostics json > /tmp/report.json; echo "exit=$?"
+node dist/cli.js render /tmp/bad.aze.md --output /tmp/bad.html --diagnostics json; echo "exit=$?"
+```
+
+Exit `2` is reserved for malformed operations (bad flags or arguments). Exit `1` means an accepted operation failed on Source or component diagnostics. Exit `0` with no stdout or stderr means a valid Source.
+
+Confirm the JSON report is the single finite `azeforge.diagnostics/v1` document on stdout while human diagnostics stay on stderr, and validate it against the exported `diagnosticsJsonSchema` (JSON Schema 2020-12):
+
+```bash
+node dist/cli.js render /tmp/bad.aze.md --output /tmp/bad.html --diagnostics json 2>/tmp/stderr.txt | tee /tmp/report.json
+test ! -s /tmp/stderr.txt && echo "stderr clean in json mode"
+```
+
+Confirm a failed render never commits an Artifact by pre-seeding the destination:
+
+```bash
+echo "last successful Artifact" > /tmp/out.html
+node dist/cli.js render /tmp/bad.aze.md --output /tmp/out.html; echo "exit=$?"
+grep -qx "last successful Artifact" /tmp/out.html && echo "artifact preserved"
+```
+
+Probe raw HTML denial, which must report `azeforge.security#raw-html-disabled`, exit `1`, and never render the markup:
+
+```bash
+printf -- '---\nazemark: 1\n---\n\nBefore\n\n<div>\n\nAfter\n' > /tmp/html.aze.md
+node dist/cli.js render /tmp/html.aze.md --output /tmp/html.html --diagnostics json
+grep -i '<script\|<div' /tmp/html.html || echo "no raw html rendered"
+```
+
+Repeat the probes with CRLF line endings and a BOM prefix; diagnostic ranges, columns, and offsets must still line up in the JSON report.
+
+## Automated checks
+
+```bash
+npm run typecheck
+npm test
+```
+
+`npm test` rebuilds `dist/` and runs the full suite (`test/*.test.mjs`).
+Bare `node --test` reuses the last build, so rebuild after editing `src/`.
+Target one layer while working:
+
+```bash
+npm run build
+npm run test:compiler
+npm run test:cli
+npm run test:matrix
+npm run test:browser-smoke
+npm run test:canonical-suite
+npm run test:canonical
+node --test test/equation.test.mjs
+```
+
+`test:matrix` is the browser-independent unit, schema, and installed-CLI
+compatibility seam. `test:browser-smoke` invokes the packaged pinned engine.
+`test:canonical-suite` and `test:canonical` own Golden report and visual
+evidence and are authoritative only on Ubuntu 24.04 x64 with Node 24.
+
+`test/equation.test.mjs` is the equation seam: versioned Blocks, alias
+coverage, ranged diagnostics, raw-LaTeX policy, adapter failure modes,
+registry rejection, descriptor conformance, and real CLI calls.
+
+Probe equations by hand:
+
+```bash
+cat >/tmp/eq.aze.md <<'EOF'
+---
+azemark: 1
+title: Equation check
+---
+
+:::: equation
+id: euler
+
+F(omega) = integral x=0..infinity of x^2 dx
+::::
+EOF
+
+node dist/cli.js validate /tmp/eq.aze.md && echo VALID
+node dist/cli.js render /tmp/eq.aze.md --output /tmp/eq.html
+grep -o 'class="katex"\|<math\|<annotation' /tmp/eq.html | sort | uniq -c
+```
+
+Probe the raw-LaTeX gate (denied by default, trusted-local opt-in):
+
+```bash
+cat >/tmp/raw.aze.md <<'EOF'
+---
+azemark: 1
+---
+
+:::: equation
+syntax: latex
+
+\frac{a}{b}
+::::
+EOF
+
+node dist/cli.js validate /tmp/raw.aze.md; echo "exit=$? (expect 1)"
+node dist/cli.js validate /tmp/raw.aze.md --allow-raw-latex && echo ALLOWED
+node dist/cli.js render /tmp/raw.aze.md --output /tmp/raw.html --allow-raw-latex
+```

package/dist/acceptance.d.ts

@@ -0,0 +1,48 @@
+import type { JsonValue } from "./model.js";
+export declare const ACCEPTANCE_SCHEMA_ID: "azeforge.acceptance/v1";
+export declare const ACCEPTANCE_SCHEMA_VERSION: 1;
+export declare const ACCEPTANCE_CATALOG_ID: "azeforge.acceptance/v1";
+export declare const ACCEPTANCE_CATALOG_VERSION: 1;
+export type AcceptanceGate = "p0" | "p0.5";
+export type AcceptanceEvidence = "automated" | "manual";
+export interface AcceptanceEntry {
+    readonly id: string;
+    readonly gate: AcceptanceGate;
+    readonly area: string;
+    readonly given: string;
+    readonly when: string;
+    readonly then: readonly string[];
+    readonly evidence: AcceptanceEvidence;
+    readonly required: boolean;
+    readonly contracts: readonly string[];
+}
+/**
+ * Normative P0 release inventory from the golden-report acceptance gate.
+ * P0.5 entries are required for their own gate only; a P0.5 failure never
+ * delays or invalidates P0.
+ */
+export declare const ACCEPTANCE_ENTRIES: readonly AcceptanceEntry[];
+export declare const REQUIRED_P0_IDS: readonly string[];
+export declare const AUTOMATED_P0_IDS: readonly string[];
+/**
+ * Coverage gate: every required automated P0 entry needs declared evidence,
+ * and no declaration may name an unknown ID.
+ */
+export declare function checkAcceptanceCoverage(declaredIds: readonly string[]): {
+    readonly missing: readonly string[];
+    readonly unknown: readonly string[];
+};
+export declare const acceptanceJsonSchema: JsonValue;
+export interface AcceptanceCatalogDocument {
+    readonly schema: typeof ACCEPTANCE_SCHEMA_ID;
+    readonly schemaVersion: typeof ACCEPTANCE_SCHEMA_VERSION;
+    readonly catalog: Readonly<{
+        id: typeof ACCEPTANCE_CATALOG_ID;
+        version: typeof ACCEPTANCE_CATALOG_VERSION;
+    }>;
+    readonly entries: readonly AcceptanceEntry[];
+}
+/**
+ * Canonical catalog document with logical identity azeforge.acceptance/v1.
+ */
+export declare function createAcceptanceCatalog(): AcceptanceCatalogDocument;

package/dist/acceptance.js

@@ -0,0 +1,180 @@
+export const ACCEPTANCE_SCHEMA_ID = "azeforge.acceptance/v1";
+export const ACCEPTANCE_SCHEMA_VERSION = 1;
+export const ACCEPTANCE_CATALOG_ID = "azeforge.acceptance/v1";
+export const ACCEPTANCE_CATALOG_VERSION = 1;
+function acceptanceEntry(id, gate, area, given, when, then, evidence, contracts) {
+    return { id, gate, area, given, when, then, evidence, required: true, contracts };
+}
+/**
+ * Normative P0 release inventory from the golden-report acceptance gate.
+ * P0.5 entries are required for their own gate only; a P0.5 failure never
+ * delays or invalidates P0.
+ */
+export const ACCEPTANCE_ENTRIES = Object.freeze([
+    acceptanceEntry("P0-DOC-001", "p0", "document", "Valid Engineering-notation Source", "the compiler parses and validates it", ["an error-free versioned serializable Document is produced"], "automated", ["#6"]),
+    acceptanceEntry("P0-DOC-002", "p0", "document", "Source with invalid regions", "the compiler parses it", [
+        "valid regions recover into the Document",
+        "errors prevent AzeDocument and Artifact production",
+    ], "automated", ["#6"]),
+    acceptanceEntry("P0-DOC-003", "p0", "document", "Source with metadata, version, or unknown-directive failures", "the compiler reports Diagnostics", ["each Diagnostic carries the correct SourceRange and lists alternatives"], "automated", ["#6", "#9"]),
+    acceptanceEntry("P0-DOC-004", "p0", "document", "Two Sources differing only in trivia, paths, diagnostics, ranges, or render options", "both Documents are hashed", ["both contentHashes are equal"], "automated", ["#6", "ADR 0002"]),
+    acceptanceEntry("P0-DIAG-001", "p0", "diagnostics", "A failing compilation", "an author reads the human Diagnostic report", ["every Diagnostic is line-specific and author-facing"], "automated", ["#9"]),
+    acceptanceEntry("P0-DIAG-002", "p0", "diagnostics", "A failing compilation", "a tool reads the JSON Diagnostic report", ["stable code, data, range, order, and fix semantics are preserved"], "automated", ["#9"]),
+    acceptanceEntry("P0-DIAG-003", "p0", "diagnostics", "Malformed input or a component fault", "the compiler handles it", ["the fault is bounded, redacted, and contained without crashing"], "automated", ["#9"]),
+    acceptanceEntry("P0-PLUGIN-001", "p0", "plugin", "The built-in registry, schemas, versions, and capabilities", "they are constructed", [
+        "construction is deterministic",
+        "ambiguous registrations are rejected with a stable error",
+    ], "automated", ["#7"]),
+    acceptanceEntry("P0-PLUGIN-002", "p0", "plugin", "A Plugin, Block renderer, or Renderer fault", "the fault fires mid-render", [
+        "partial Artifacts are discarded",
+        "ordered Diagnostics are preserved",
+    ], "automated", ["#7"]),
+    acceptanceEntry("P0-CLI-001", "p0", "cli", "A Source render", "it succeeds or fails", [
+        "success atomically commits exactly one requested Artifact",
+        "failure preserves the prior Artifact",
+    ], "automated", ["#8"]),
+    acceptanceEntry("P0-CLI-002", "p0", "cli", "Stdin, stdout, format, and destination modes", "they are exercised", ["behavior matches the CLI contract including binary-terminal denial"], "automated", ["#8"]),
+    acceptanceEntry("P0-CLI-003", "p0", "cli", "Validate and format commands", "they run", ["each executes only its specified layers and write modes"], "automated", ["#8"]),
+    acceptanceEntry("P0-CLI-004", "p0", "cli", "A watched Source with discovered and missing dependencies", "it changes and breaks", [
+        "rebuilds serialize",
+        "failure preserves the prior Artifact",
+    ], "automated", ["#8"]),
+    acceptanceEntry("P0-CLI-005", "p0", "cli", "A served Source", "it is previewed", [
+        "the server is loopback-only and constrained",
+        "it exposes current Diagnostics rather than stale content",
+    ], "automated", ["#8"]),
+    acceptanceEntry("P0-CLI-006", "p0", "cli", "Every CLI command", "it exits", [
+        "exit codes, stdout purity, finite JSON, NDJSON lifecycle, quiet mode, and signal cleanup match the CLI contract",
+    ], "automated", ["#8"]),
+    acceptanceEntry("P0-CLI-007", "p0", "cli", "Capability and version reports", "they are requested", ["they are complete, deterministic, local-only, and truthful"], "automated", ["#8"]),
+    acceptanceEntry("P0-EQN-001", "p0", "equation", "Readable equation Blocks", "they render", ["HTML carries visual plus MathML pairs and visual Artifacts stay consistent"], "automated", ["#7"]),
+    acceptanceEntry("P0-EQN-002", "p0", "equation", "Invalid equations and raw LaTeX", "they are compiled", [
+        "invalid equations diagnose precisely",
+        "raw LaTeX is denied by default and bounded when explicitly trusted",
+    ], "automated", ["#7", "#9"]),
+    acceptanceEntry("P0-MMD-001", "p0", "mermaid", "A Mermaid Block", "it renders offline", [
+        "the SVG is deterministic, sanitized, and accessible",
+        "active or invalid content fails safely",
+    ], "automated", ["#7", "#9"]),
+    acceptanceEntry("P0-OUT-001", "p0", "artifact", "The Golden report under all three Themes", "it renders to HTML, SVG, PNG, and PDF", ["every semantic object is present with format-appropriate proof"], "automated", ["#10", "#12"]),
+    acceptanceEntry("P0-OUT-002", "p0", "artifact", "Every rendered Artifact", "its bytes and manifest are inspected", ["it is self-contained, profile/MIME/geometry-correct, and truthfully hashed"], "automated", ["#10", "ADR 0002"]),
+    acceptanceEntry("P0-OUT-003", "p0", "artifact", "Pagination boundary fixtures", "they render to PDF", ["every keep, split, scaling, and oversize-error rule holds"], "automated", ["#10"]),
+    acceptanceEntry("P0-OUT-004", "p0", "artifact", "Reference fixtures compiled twice in fresh directories under one fingerprint", "both builds are compared", [
+        "contentHash, assetManifestHash, renderer fingerprint, Artifact bytes, and artifactHash are equal",
+        "trivia and path moves preserve identity while semantic, Theme, asset, and dependency changes invalidate only the specified identities",
+    ], "automated", ["#10", "ADR 0002"]),
+    acceptanceEntry("P0-OUT-005", "p0", "artifact", "A missing browser or format adapter", "an affected format is requested", [
+        "a structured remedy is reported",
+        "unaffected formats remain usable",
+    ], "automated", ["#10"]),
+    acceptanceEntry("P0-SEC-001", "p0", "security", "Traversal and symlink escapes", "they are attempted", ["the root confinement rejects them without leaking host paths"], "automated", ["#9"]),
+    acceptanceEntry("P0-SEC-002", "p0", "security", "An offline compilation", "its requests are observed", ["no non-loopback request or external name resolution occurs"], "automated", ["#9"]),
+    acceptanceEntry("P0-SEC-003", "p0", "security", "Raw or embedded active content, unsafe protocols, malformed assets, and unsafe sanitizer rewrites", "they are compiled", ["each is rejected"], "automated", ["#9"]),
+    acceptanceEntry("P0-SEC-004", "p0", "security", "Capability, time, memory, Diagnostic, asset, temp, and Artifact bounds", "a bound is exceeded", ["compilation fails closed without partial Artifacts"], "automated", ["#9"]),
+    acceptanceEntry("P0-COMPAT-001", "p0", "compatibility", "Supported Node and OS combinations", "the suite runs", ["all pass and system fonts, locales, and timezones do not alter Artifact eligibility"], "automated", ["#10"]),
+    acceptanceEntry("P0-AUTHOR-001", "p0", "author", "A temporary copy of the Golden report", "the modify-equation and table-value loop runs", [
+        "edits change content and Artifact identities while presence checks still pass",
+        "the missing-dx step fails line-specifically without committing an Artifact",
+        "restoration passes",
+    ], "automated", ["#12"]),
+    acceptanceEntry("P05-CIR-001", "p0.5", "circuit", "Five approved Circuit Sources", "they normalize", ["each matches its exact semantic oracle and content hash"], "manual", ["#11"]),
+    acceptanceEntry("P05-CIR-002", "p0.5", "circuit", "The closed component, value, and annotation union", "focused conformance runs", ["every member passes"], "manual", ["#11"]),
+    acceptanceEntry("P05-CIR-003", "p0.5", "circuit", "Unknown, duplicate, terminal, quantity, limit, and convention failures", "they are compiled", ["stable typed ranged Diagnostics are emitted"], "manual", ["#11", "#9"]),
+    acceptanceEntry("P05-CIR-004", "p0.5", "circuit", "Unused nodes and disconnected residual subgraphs", "they are compiled", ["each warns without cascades"], "manual", ["#11"]),
+    acceptanceEntry("P05-CIR-005", "p0.5", "circuit", "Circuit topology", "it is derived", ["only explicit terminal-node relations create connectivity"], "manual", ["#11"]),
+    acceptanceEntry("P05-CIR-006", "p0.5", "circuit", "Directional hints, limits, labels, reference ground, and unsupported layout", "they are compiled", ["behavior matches the Circuit contract"], "manual", ["#11"]),
+    acceptanceEntry("P05-OUT-001", "p0.5", "circuit-artifact", "Five Circuits under the required convention and Theme matrix", "they render canonical accessible SVG", ["every cell passes"], "manual", ["#11"]),
+    acceptanceEntry("P05-OUT-002", "p0.5", "circuit-artifact", "Five Circuits embedded through four formats", "they render", ["labels stay legible after semantic connectivity passes"], "manual", ["#11", "#10"]),
+    acceptanceEntry("P05-OUT-003", "p0.5", "circuit-artifact", "Canonical Circuit SVG bytes across claimed pilot platforms", "they are compared", ["bytes match under the pinned closure"], "manual", ["#11"]),
+    acceptanceEntry("P05-ADAPTER-001", "p0.5", "circuit-adapter", "The selected Circuit adapter", "probes run", ["restricted execution, cleanup, timeout, budget, and availability all pass"], "manual", ["#11"]),
+    acceptanceEntry("P05-ADAPTER-002", "p0.5", "circuit-adapter", "Missing, disabled, or incompatible engines", "a Circuit render is requested", [
+        "a structured exact remedy is reported",
+        "non-Circuit Documents never probe the adapter",
+    ], "manual", ["#11"]),
+    acceptanceEntry("P05-PLATFORM-001", "p0.5", "circuit-platform", "Every supported-pilot-platform manifest row", "installation and remedy rehearsal run", ["every row passes"], "manual", ["#11"]),
+    acceptanceEntry("P05-SYNTAX-001", "p0.5", "circuit-syntax", "Five lecturer-reviewed Source and semantic pairs", "they are approved", ["they freeze Circuit body syntax 1.0.0 as the conformance corpus"], "manual", ["#11"]),
+    acceptanceEntry("P05-PILOT-001", "p0.5", "circuit-pilot", "The five-fixture set with immutable evidence", "lecturers review it", [
+        "two lecturers approve the set",
+        "one course owner approves usefulness and convention",
+    ], "manual", ["#11"]),
+]);
+export const REQUIRED_P0_IDS = Object.freeze(ACCEPTANCE_ENTRIES.filter((item) => item.gate === "p0" && item.required).map((item) => item.id));
+export const AUTOMATED_P0_IDS = Object.freeze(ACCEPTANCE_ENTRIES.filter((item) => item.gate === "p0" && item.required && item.evidence === "automated").map((item) => item.id));
+/**
+ * Coverage gate: every required automated P0 entry needs declared evidence,
+ * and no declaration may name an unknown ID.
+ */
+export function checkAcceptanceCoverage(declaredIds) {
+    const known = new Set(ACCEPTANCE_ENTRIES.map((item) => item.id));
+    const declared = new Set(declaredIds);
+    return {
+        missing: AUTOMATED_P0_IDS.filter((id) => !declared.has(id)),
+        unknown: [...declared].filter((id) => !known.has(id)),
+    };
+}
+export const acceptanceJsonSchema = Object.freeze({
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: ACCEPTANCE_SCHEMA_ID,
+    type: "object",
+    required: ["schema", "schemaVersion", "catalog", "entries"],
+    additionalProperties: false,
+    properties: {
+        schema: { const: ACCEPTANCE_SCHEMA_ID },
+        schemaVersion: { const: ACCEPTANCE_SCHEMA_VERSION },
+        catalog: {
+            type: "object",
+            required: ["id", "version"],
+            additionalProperties: false,
+            properties: {
+                id: { const: ACCEPTANCE_CATALOG_ID },
+                version: { const: ACCEPTANCE_CATALOG_VERSION },
+            },
+        },
+        entries: {
+            type: "array",
+            minItems: 1,
+            items: {
+                type: "object",
+                required: [
+                    "id",
+                    "gate",
+                    "area",
+                    "given",
+                    "when",
+                    "then",
+                    "evidence",
+                    "required",
+                    "contracts",
+                ],
+                additionalProperties: false,
+                properties: {
+                    id: { type: "string", pattern: "^P0[A-Z0-9]*-[A-Z]+-[0-9]{3}$" },
+                    gate: { enum: ["p0", "p0.5"] },
+                    area: { type: "string", minLength: 1 },
+                    given: { type: "string", minLength: 1 },
+                    when: { type: "string", minLength: 1 },
+                    then: { type: "array", minItems: 1, items: { type: "string", minLength: 1 } },
+                    evidence: { enum: ["automated", "manual"] },
+                    required: { const: true },
+                    contracts: {
+                        type: "array",
+                        minItems: 1,
+                        items: { type: "string", minLength: 1 },
+                    },
+                },
+            },
+        },
+    },
+});
+/**
+ * Canonical catalog document with logical identity azeforge.acceptance/v1.
+ */
+export function createAcceptanceCatalog() {
+    return {
+        schema: ACCEPTANCE_SCHEMA_ID,
+        schemaVersion: ACCEPTANCE_SCHEMA_VERSION,
+        catalog: { id: ACCEPTANCE_CATALOG_ID, version: ACCEPTANCE_CATALOG_VERSION },
+        entries: ACCEPTANCE_ENTRIES,
+    };
+}
+//# sourceMappingURL=acceptance.js.map