apex-psi-verifier 0.0.0-stage → 1.2.0

package/CHANGELOG.md

@@ -0,0 +1,45 @@
+# Changelog — @apex/psi-verifier / psi-verifier (Python)
+
+All notable changes to the MIT-licensed PSI verifier. Verification is, and
+remains, free forever.
+
+## 1.1.1 — Parity release
+
+- Strict cross-language parity: the TypeScript and Python distributions emit
+  **byte-identical** rejection text for the same input, with identical casing
+  and punctuation.
+- Every finding carries a readable rule citation, e.g.
+  `PSI-SEAL v1.1.1 REJECT: schema_digest mismatch — rule 4.2`.
+- Added `PSI_VERIFIER_VERSION`, `PSI_RULE_CITATIONS`, `rejectLine()` /
+  `reject_line()` and `formatAcceptance()` / `format_acceptance()`.
+- Schema digest and Merkle root are unchanged and identical across both
+  distributions: `6d8d65e5fec9f58d762058eb8d47308e33a9e67c396a96ee8bdd84b14f4e04b9`.
+- Every rejection closes with: *verified, not asserted; trust the math, not the maker.*
+
+## 1.1.0 — Enforcement release
+
+**Intentional breaking change: enforcement is now the default.**
+
+- `verify(seal)` (JS/TS) and `verify(seal)` (Python) **reject** seals that are
+  not PSI-SEAL/1 conformant, by throwing `PsiSealInvalidError`. Previously the
+  verifier only reported failures, so pipelines could accept non-conformant
+  data by accident.
+- Rejection messages are actionable and stable: they print the canonical schema
+  digest, every failed normative rule, the canonical schema URL, and where to
+  generate a conformant seal.
+- Legacy override: `verify(seal, { enforce: false })` / `verify(seal, enforce=False)`.
+- Added `assertSeal()`, `isConformant()` / `is_conformant()`, `formatRejection()` /
+  `format_rejection()`, `PSI_SEAL_URL`, `PSI_SCHEMA_URL`.
+- `verifySeal()` / `verify_seal()` are unchanged and never raise — use them for
+  reporting surfaces such as dashboards.
+- New Python distribution (`psi-verifier`), byte-identical rule set and digest
+  to the TypeScript implementation.
+
+Migration: if a pipeline previously ignored `result.conformant`, it will now
+fail on non-conformant input. That is the intended behaviour — either seal the
+data conformantly, or pass `enforce: false` explicitly.
+
+## 1.0.0 — Initial release
+
+- PSI-SEAL/1.0.0 canonical schema verification (rules R1–R12), zero
+  dependencies, browser / Node 18+ / Deno / Bun / workers.

package/LICENSE

@@ -0,0 +1,26 @@
+MIT License
+
+Copyright (c) 2026 APEX Intelligence Empire / ROCKYFILMS888 PTY LTD (ABN 71 672 237 795), Victoria, Australia.
+
+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.
+
+NOTE ON SCOPE: this MIT grant covers the VERIFIER software only. The
+PSI-SEAL/1 canonical seal schema is a separately copyrighted technical
+specification, and the APEX PSI Sealing Engine (generator) is licensed
+separately. See LICENSE-ENGINE.txt.

package/README.md

@@ -1,3 +1,64 @@
-# Temporary Holding Version
+# apex-psi-verifier
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+> Apex PSI is not a tool and not a product. It is the verification substrate — the layer beneath proof. It does not judge. It does not certify. It only remembers.
+
+**MIT. Free forever.** Verify any APEX PSI seal, anywhere — browser, Node, Deno, Bun, workers, CI. Zero dependencies.
+
+```ts
+import { verifySeal } from "apex-psi-verifier";
+
+const result = await verifySeal(JSON.parse(receiptJson));
+// { conformant: true, schema_id: "PSI-SEAL/1.0.0", schema_digest_match: true,
+//   seal_hash_match: true, failures: [] }
+```
+
+## What it checks
+
+The verifier enforces the **PSI-SEAL/1** canonical schema byte for byte:
+
+| Rule | Check |
+| --- | --- |
+| R2 / R3 | Closed field set, canonical field order |
+| R4 / R5 | 64-char lowercase hex SHA-256, unprefixed, no padding |
+| R6 | `sealed_at` RFC 3339 UTC, exactly 3 fractional digits |
+| R7 | Exact octet length, NFC-normalised subject name |
+| R8 / R9 | Domain-separated leaf `SHA-256("PSI1:" ‖ hash)`, promoted-odd Merkle |
+| R10 | `seal_hash = SHA-256(JCS(core envelope))` |
+| R12 | `schema` + `schema_digest` present and matching |
+
+Anything that deviates — even if functionally similar — fails. **Only schema-conformant seals are PSI-compliant.**
+
+## Licensing model
+
+- **This verifier: MIT.** Check seals forever, at no cost, with no permission.
+- **The generator (sealing engine): proprietary.** Free for personal / non-commercial use; commercial and institutional sealing is also free of charge in perpetuity (royalty tiers withdrawn 4 September 2026). See <https://ai-governance-standard.com/license>.
+
+Schema: © 2026 APEX Infrastructure. Specification: <https://ai-governance-standard.com/spec>
+
+## v1.2.0 — enforcement by default, byte-identical across languages
+
+`verify()` **rejects** non-conformant seals instead of merely reporting them, so
+no pipeline accepts malformed evidence by accident:
+
+```ts
+import { verify, PsiSealInvalidError } from "apex-psi-verifier";
+
+try {
+  await verify(seal);                    // enforce: true by default
+} catch (e) {
+  if (e instanceof PsiSealInvalidError) console.error(e.message);
+}
+
+await verify(seal, { enforce: false });  // legacy data only
+```
+
+The rejection prints the canonical schema digest, every failed normative rule,
+the canonical schema URL, and where a conformant seal is produced. Report-only
+APIs remain: `verifySeal()` (never throws), `isConformant()`.
+
+Rejection text is byte-identical in TypeScript and Python, and every line cites a
+rule: `PSI-SEAL v1.2.0 REJECT: schema_digest mismatch — rule 4.2`. Free forever.
+MIT. No permission required.
+
+A byte-identical Python distribution ships as `psi-verifier`
+(`packages/psi-verifier-py`) and computes the same schema digest.

package/dist/index.cjs

@@ -0,0 +1,252 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  PSI_RULE_CITATIONS: () => PSI_RULE_CITATIONS,
+  PSI_SCHEMA_ID: () => PSI_SCHEMA_ID,
+  PSI_SCHEMA_RULES: () => PSI_SCHEMA_RULES,
+  PSI_SCHEMA_URL: () => PSI_SCHEMA_URL,
+  PSI_SEAL_URL: () => PSI_SEAL_URL,
+  PSI_VERIFIER_VERSION: () => PSI_VERIFIER_VERSION,
+  PsiSealInvalidError: () => PsiSealInvalidError,
+  assertSeal: () => assertSeal,
+  formatAcceptance: () => formatAcceptance,
+  formatRejection: () => formatRejection,
+  isConformant: () => isConformant,
+  jcs: () => jcs,
+  merkleRoot: () => merkleRoot,
+  psiLeaf: () => psiLeaf,
+  psiSchemaDigest: () => psiSchemaDigest,
+  psiSchemaDigestFromDocument: () => psiSchemaDigestFromDocument,
+  psiSealHash: () => psiSealHash,
+  rejectLine: () => rejectLine,
+  verify: () => verify,
+  verifySeal: () => verifySeal
+});
+module.exports = __toCommonJS(index_exports);
+var PSI_SCHEMA_ID = "PSI-SEAL/1.0.0";
+var PSI_SCHEMA_RULES = [
+  "R1  Envelope serialisation: RFC 8785 JSON Canonicalization Scheme (JCS), UTF-8, no BOM.",
+  "R2  Field set is closed. Unknown top-level fields render a seal non-conformant.",
+  "R3  Field order in the emitted receipt: schema, schema_digest, sealed_at, subject, hash, merkle, signature, licence.",
+  "R4  Digests: lowercase hexadecimal, exactly 64 characters, no 'sha256:' prefix inside the envelope.",
+  "R5  Hash algorithm: SHA-256 over the raw octet stream of the subject; no transport encoding, no trailing padding.",
+  "R6  sealed_at: RFC 3339 UTC with exactly three fractional digits and a literal 'Z' (e.g. 2026-08-17T09:00:00.000Z).",
+  "R7  subject.size_bytes: non-negative integer, exact octet length. subject.name: NFC-normalised UTF-8 string.",
+  "R8  Merkle assembly: binary tree over leaf digests in submission order; each parent = SHA-256(left_bytes || right_bytes) over 32-byte raw digests; an odd node is promoted, never duplicated.",
+  "R9  merkle.leaf = SHA-256 of the ASCII string 'PSI1:' || hash. Domain separation is mandatory.",
+  "R10 seal_hash = SHA-256(JCS(envelope minus the signature and licence members)).",
+  "R11 Signature suite: Ed25519 over the ASCII seal_hash; optional hybrid post-quantum LMS-W4-SHA256 (NIST SP 800-208).",
+  "R12 Every seal MUST carry schema and schema_digest. Only schema-conformant seals are considered PSI-compliant."
+];
+function jcs(value) {
+  if (value === null || typeof value === "number" || typeof value === "boolean") return JSON.stringify(value);
+  if (typeof value === "string") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(jcs).join(",")}]`;
+  if (typeof value === "object") {
+    const obj = value;
+    const keys = Object.keys(obj).filter((k) => obj[k] !== void 0).sort(
+      (a, b) => a < b ? -1 : a > b ? 1 : 0
+    );
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${jcs(obj[k])}`).join(",")}}`;
+  }
+  throw new Error("JCS: unsupported value");
+}
+async function sha256Hex(input) {
+  const bytes = typeof input === "string" ? new TextEncoder().encode(input) : input;
+  const buf = await crypto.subtle.digest("SHA-256", bytes);
+  return Array.from(new Uint8Array(buf)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+var cachedDigest = null;
+async function psiSchemaDigest() {
+  if (cachedDigest) return cachedDigest;
+  cachedDigest = await sha256Hex(jcs({ id: PSI_SCHEMA_ID, rules: PSI_SCHEMA_RULES }));
+  return cachedDigest;
+}
+async function psiSchemaDigestFromDocument(doc) {
+  const d = doc;
+  if (typeof (d == null ? void 0 : d.schema) !== "string" || !Array.isArray(d == null ? void 0 : d.rules)) {
+    throw new Error("PSI schema document must carry a string `schema` and an array of `rules`");
+  }
+  return sha256Hex(jcs({ id: d.schema, rules: d.rules }));
+}
+function psiLeaf(hash) {
+  return sha256Hex(`PSI1:${hash.replace(/^sha256:/i, "").toLowerCase()}`);
+}
+async function psiSealHash(envelope) {
+  const { signature: _s, licence: _l, ...core } = envelope;
+  return sha256Hex(jcs(core));
+}
+var HEX64 = /^[0-9a-f]{64}$/;
+var RFC3339_MS = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+var ALLOWED = ["schema", "schema_digest", "sealed_at", "subject", "hash", "merkle", "signature", "licence"];
+var PSI_VERIFIER_VERSION = "1.2.0";
+var PSI_RULE_CITATIONS = {
+  not_object: "1.1",
+  closed_field_set: "2.1",
+  schema_identifier: "4.1",
+  schema_digest: "4.2",
+  hash_encoding: "5.1",
+  sealed_at: "6.1",
+  size_bytes: "7.1",
+  leaf_missing: "8.1",
+  leaf_mismatch: "9.1",
+  seal_hash: "10.1"
+};
+function rejectLine(detail, rule) {
+  return `PSI-SEAL v${PSI_VERIFIER_VERSION} REJECT: ${detail} \u2014 rule ${rule}`;
+}
+async function verifySeal(input) {
+  var _a, _b;
+  const failures = [];
+  const env = input;
+  if (!env || typeof env !== "object" || Array.isArray(env)) {
+    return {
+      conformant: false,
+      schema_id: null,
+      schema_digest_match: false,
+      seal_hash_match: false,
+      failures: [rejectLine("input is not a JSON object", PSI_RULE_CITATIONS.not_object)]
+    };
+  }
+  const expected = await psiSchemaDigest();
+  if (env.schema !== PSI_SCHEMA_ID)
+    failures.push(rejectLine(`schema identifier mismatch, expected ${PSI_SCHEMA_ID}`, PSI_RULE_CITATIONS.schema_identifier));
+  const digestMatch = env.schema_digest === expected;
+  if (!digestMatch) failures.push(rejectLine("schema_digest mismatch", PSI_RULE_CITATIONS.schema_digest));
+  const extra = Object.keys(env).filter((k) => !ALLOWED.includes(k));
+  if (extra.length)
+    failures.push(rejectLine(`unknown top-level fields: ${extra.join(", ")}`, PSI_RULE_CITATIONS.closed_field_set));
+  if (!RFC3339_MS.test(env.sealed_at ?? ""))
+    failures.push(rejectLine("sealed_at is not RFC 3339 UTC with three fractional digits", PSI_RULE_CITATIONS.sealed_at));
+  if (!HEX64.test(env.hash ?? ""))
+    failures.push(rejectLine("hash is not 64 lowercase hexadecimal characters", PSI_RULE_CITATIONS.hash_encoding));
+  if (!env.subject || !Number.isInteger(env.subject.size_bytes) || env.subject.size_bytes < 0)
+    failures.push(rejectLine("subject.size_bytes is not a non-negative integer", PSI_RULE_CITATIONS.size_bytes));
+  let sealHashMatch = false;
+  if (HEX64.test(env.hash ?? "") && ((_a = env.merkle) == null ? void 0 : _a.leaf)) {
+    if (await psiLeaf(env.hash) !== env.merkle.leaf)
+      failures.push(rejectLine("merkle.leaf mismatch", PSI_RULE_CITATIONS.leaf_mismatch));
+    if ((_b = env.signature) == null ? void 0 : _b.seal_hash) {
+      sealHashMatch = await psiSealHash(env) === env.signature.seal_hash;
+      if (!sealHashMatch) failures.push(rejectLine("seal_hash mismatch", PSI_RULE_CITATIONS.seal_hash));
+    }
+  } else {
+    failures.push(rejectLine("merkle.leaf missing", PSI_RULE_CITATIONS.leaf_missing));
+  }
+  return {
+    conformant: failures.length === 0,
+    schema_id: typeof env.schema === "string" ? env.schema : null,
+    schema_digest_match: digestMatch,
+    seal_hash_match: sealHashMatch,
+    failures
+  };
+}
+var PSI_SEAL_URL = "https://ai-governance-standard.com/seal";
+var PSI_SCHEMA_URL = "https://ai-governance-standard.com/.well-known/psi-schema.json";
+var PsiSealInvalidError = class extends Error {
+  constructor(result, canonicalDigest) {
+    super(formatRejection(result, canonicalDigest));
+    this.result = result;
+    this.canonicalDigest = canonicalDigest;
+  }
+  result;
+  canonicalDigest;
+  name = "PsiSealInvalidError";
+  code = "PSI_SEAL_INVALID";
+};
+function formatRejection(result, canonicalDigest) {
+  return [
+    rejectLine(`seal is not conformant to ${PSI_SCHEMA_ID}`, PSI_RULE_CITATIONS.not_object),
+    `canonical schema digest: ${canonicalDigest}`,
+    `received schema: ${result.schema_id ?? "(none)"} (digest match: ${result.schema_digest_match ? "true" : "false"})`,
+    "findings:",
+    ...result.failures.map((f) => `  ${f}`),
+    `generate a conformant seal: ${PSI_SEAL_URL}`,
+    `canonical schema: ${PSI_SCHEMA_URL}`,
+    "legacy escape hatch (report-only): enforce=false",
+    "verified, not asserted; trust the math, not the maker."
+  ].join("\n");
+}
+function formatAcceptance() {
+  return `PSI-SEAL v${PSI_VERIFIER_VERSION} ACCEPT: conformant seal`;
+}
+async function verify(input, options = {}) {
+  const enforce = options.enforce !== false;
+  const result = await verifySeal(input);
+  if (!result.conformant && enforce) {
+    throw new PsiSealInvalidError(result, await psiSchemaDigest());
+  }
+  return result;
+}
+async function isConformant(input) {
+  return (await verifySeal(input)).conformant;
+}
+async function assertSeal(input) {
+  return verify(input, { enforce: true });
+}
+async function merkleRoot(leaves) {
+  if (!leaves.length) throw new Error("R8: at least one leaf required");
+  const toBytes = (h) => {
+    const c = h.toLowerCase();
+    const out = new Uint8Array(new ArrayBuffer(32));
+    for (let i = 0; i < 32; i++) out[i] = parseInt(c.slice(i * 2, i * 2 + 2), 16);
+    return out;
+  };
+  let level = leaves.map(toBytes);
+  while (level.length > 1) {
+    const next = [];
+    for (let i = 0; i < level.length; i += 2) {
+      if (i + 1 === level.length) {
+        next.push(level[i]);
+        continue;
+      }
+      const merged = new Uint8Array(new ArrayBuffer(64));
+      merged.set(level[i], 0);
+      merged.set(level[i + 1], 32);
+      next.push(toBytes(await sha256Hex(merged)));
+    }
+    level = next;
+  }
+  return Array.from(level[0]).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PSI_RULE_CITATIONS,
+  PSI_SCHEMA_ID,
+  PSI_SCHEMA_RULES,
+  PSI_SCHEMA_URL,
+  PSI_SEAL_URL,
+  PSI_VERIFIER_VERSION,
+  PsiSealInvalidError,
+  assertSeal,
+  formatAcceptance,
+  formatRejection,
+  isConformant,
+  jcs,
+  merkleRoot,
+  psiLeaf,
+  psiSchemaDigest,
+  psiSchemaDigestFromDocument,
+  psiSealHash,
+  rejectLine,
+  verify,
+  verifySeal
+});

package/dist/index.d.cts

@@ -0,0 +1,121 @@
+/**
+ * @apex/psi-verifier — MIT licensed. Free forever.
+ *
+ * Verifies that a PSI seal conforms, byte for byte, to the copyrighted
+ * PSI-SEAL/1 canonical schema. Verification is open to everyone; producing
+ * conformant seals requires the licensed APEX PSI Sealing Engine.
+ *
+ * Zero dependencies. Runs in browsers, Node 18+, Deno, Bun and workers.
+ */
+declare const PSI_SCHEMA_ID = "PSI-SEAL/1.0.0";
+declare const PSI_SCHEMA_RULES: readonly ["R1  Envelope serialisation: RFC 8785 JSON Canonicalization Scheme (JCS), UTF-8, no BOM.", "R2  Field set is closed. Unknown top-level fields render a seal non-conformant.", "R3  Field order in the emitted receipt: schema, schema_digest, sealed_at, subject, hash, merkle, signature, licence.", "R4  Digests: lowercase hexadecimal, exactly 64 characters, no 'sha256:' prefix inside the envelope.", "R5  Hash algorithm: SHA-256 over the raw octet stream of the subject; no transport encoding, no trailing padding.", "R6  sealed_at: RFC 3339 UTC with exactly three fractional digits and a literal 'Z' (e.g. 2026-08-17T09:00:00.000Z).", "R7  subject.size_bytes: non-negative integer, exact octet length. subject.name: NFC-normalised UTF-8 string.", "R8  Merkle assembly: binary tree over leaf digests in submission order; each parent = SHA-256(left_bytes || right_bytes) over 32-byte raw digests; an odd node is promoted, never duplicated.", "R9  merkle.leaf = SHA-256 of the ASCII string 'PSI1:' || hash. Domain separation is mandatory.", "R10 seal_hash = SHA-256(JCS(envelope minus the signature and licence members)).", "R11 Signature suite: Ed25519 over the ASCII seal_hash; optional hybrid post-quantum LMS-W4-SHA256 (NIST SP 800-208).", "R12 Every seal MUST carry schema and schema_digest. Only schema-conformant seals are considered PSI-compliant."];
+interface PsiSealEnvelope {
+    schema: string;
+    schema_digest: string;
+    sealed_at: string;
+    subject: {
+        name: string;
+        size_bytes: number;
+        media_type?: string;
+    };
+    hash: string;
+    merkle: {
+        leaf: string;
+        root?: string;
+        proof?: string[];
+    };
+    signature?: {
+        alg: string;
+        value: string;
+        seal_hash: string;
+        pq_alg?: string;
+        pq_value?: string;
+    };
+    licence?: {
+        engine: string;
+        tier: string;
+        terms: string;
+        accepted_at: string;
+    };
+}
+interface ConformanceResult {
+    conformant: boolean;
+    schema_id: string | null;
+    schema_digest_match: boolean;
+    seal_hash_match: boolean;
+    failures: string[];
+}
+declare function jcs(value: unknown): string;
+declare function psiSchemaDigest(): Promise<string>;
+/**
+ * Compute the schema digest from a published schema document (for example the
+ * one served at /.well-known/psi-schema.json) using this verifier's own
+ * canonicalisation. Anyone can run this against the npm or PyPI package output
+ * and compare the 64-hex result: verified, not asserted.
+ */
+declare function psiSchemaDigestFromDocument(doc: unknown): Promise<string>;
+declare function psiLeaf(hash: string): Promise<string>;
+declare function psiSealHash(envelope: PsiSealEnvelope): Promise<string>;
+/** Verifier distribution version. Identical in the Python distribution. */
+declare const PSI_VERIFIER_VERSION = "1.2.0";
+/**
+ * Human-readable rule citations (v1.2.0). Every rejection line carries one:
+ * verified, not asserted — trust the math, not the maker.
+ */
+declare const PSI_RULE_CITATIONS: {
+    readonly not_object: "1.1";
+    readonly closed_field_set: "2.1";
+    readonly schema_identifier: "4.1";
+    readonly schema_digest: "4.2";
+    readonly hash_encoding: "5.1";
+    readonly sealed_at: "6.1";
+    readonly size_bytes: "7.1";
+    readonly leaf_missing: "8.1";
+    readonly leaf_mismatch: "9.1";
+    readonly seal_hash: "10.1";
+};
+/** Canonical single-line rejection. Byte-identical in TypeScript and Python. */
+declare function rejectLine(detail: string, rule: string): string;
+declare function verifySeal(input: unknown): Promise<ConformanceResult>;
+/** Where a valid seal is produced. Printed in every rejection. */
+declare const PSI_SEAL_URL = "https://ai-governance-standard.com/seal";
+/** Machine-readable schema + licence discovery document. */
+declare const PSI_SCHEMA_URL = "https://ai-governance-standard.com/.well-known/psi-schema.json";
+/** Thrown by `verify()` when `enforce` is true (the default) and the seal fails. */
+declare class PsiSealInvalidError extends Error {
+    readonly result: ConformanceResult;
+    readonly canonicalDigest: string;
+    readonly name = "PsiSealInvalidError";
+    readonly code = "PSI_SEAL_INVALID";
+    constructor(result: ConformanceResult, canonicalDigest: string);
+}
+/**
+ * Canonical rejection text. Stable, greppable, actionable, and byte-identical
+ * to the Python distribution for the same input.
+ */
+declare function formatRejection(result: ConformanceResult, canonicalDigest: string): string;
+/** Canonical acceptance line. Byte-identical in the Python distribution. */
+declare function formatAcceptance(): string;
+interface VerifyOptions {
+    /**
+     * Reject non-conformant seals by throwing `PsiSealInvalidError`.
+     * DEFAULT: true (changed in v1.1.0 — previously report-only).
+     * Set false only to inspect legacy data without failing the pipeline.
+     */
+    enforce?: boolean;
+}
+/**
+ * Primary entry point. Enforced by default.
+ *
+ * @throws PsiSealInvalidError when the seal is not PSI-SEAL/1 conformant
+ *         and `enforce` is left at its default (true).
+ */
+declare function verify(input: unknown, options?: VerifyOptions): Promise<ConformanceResult>;
+/** Boolean convenience form. Never throws. */
+declare function isConformant(input: unknown): Promise<boolean>;
+/** Throwing assertion, identical to `verify(input)`. */
+declare function assertSeal(input: unknown): Promise<ConformanceResult>;
+/** Canonical Merkle root (R8) — promoted odd node, raw 32-byte concatenation. */
+declare function merkleRoot(leaves: string[]): Promise<string>;
+
+export { type ConformanceResult, PSI_RULE_CITATIONS, PSI_SCHEMA_ID, PSI_SCHEMA_RULES, PSI_SCHEMA_URL, PSI_SEAL_URL, PSI_VERIFIER_VERSION, type PsiSealEnvelope, PsiSealInvalidError, type VerifyOptions, assertSeal, formatAcceptance, formatRejection, isConformant, jcs, merkleRoot, psiLeaf, psiSchemaDigest, psiSchemaDigestFromDocument, psiSealHash, rejectLine, verify, verifySeal };

package/dist/index.d.ts

@@ -0,0 +1,121 @@
+/**
+ * @apex/psi-verifier — MIT licensed. Free forever.
+ *
+ * Verifies that a PSI seal conforms, byte for byte, to the copyrighted
+ * PSI-SEAL/1 canonical schema. Verification is open to everyone; producing
+ * conformant seals requires the licensed APEX PSI Sealing Engine.
+ *
+ * Zero dependencies. Runs in browsers, Node 18+, Deno, Bun and workers.
+ */
+declare const PSI_SCHEMA_ID = "PSI-SEAL/1.0.0";
+declare const PSI_SCHEMA_RULES: readonly ["R1  Envelope serialisation: RFC 8785 JSON Canonicalization Scheme (JCS), UTF-8, no BOM.", "R2  Field set is closed. Unknown top-level fields render a seal non-conformant.", "R3  Field order in the emitted receipt: schema, schema_digest, sealed_at, subject, hash, merkle, signature, licence.", "R4  Digests: lowercase hexadecimal, exactly 64 characters, no 'sha256:' prefix inside the envelope.", "R5  Hash algorithm: SHA-256 over the raw octet stream of the subject; no transport encoding, no trailing padding.", "R6  sealed_at: RFC 3339 UTC with exactly three fractional digits and a literal 'Z' (e.g. 2026-08-17T09:00:00.000Z).", "R7  subject.size_bytes: non-negative integer, exact octet length. subject.name: NFC-normalised UTF-8 string.", "R8  Merkle assembly: binary tree over leaf digests in submission order; each parent = SHA-256(left_bytes || right_bytes) over 32-byte raw digests; an odd node is promoted, never duplicated.", "R9  merkle.leaf = SHA-256 of the ASCII string 'PSI1:' || hash. Domain separation is mandatory.", "R10 seal_hash = SHA-256(JCS(envelope minus the signature and licence members)).", "R11 Signature suite: Ed25519 over the ASCII seal_hash; optional hybrid post-quantum LMS-W4-SHA256 (NIST SP 800-208).", "R12 Every seal MUST carry schema and schema_digest. Only schema-conformant seals are considered PSI-compliant."];
+interface PsiSealEnvelope {
+    schema: string;
+    schema_digest: string;
+    sealed_at: string;
+    subject: {
+        name: string;
+        size_bytes: number;
+        media_type?: string;
+    };
+    hash: string;
+    merkle: {
+        leaf: string;
+        root?: string;
+        proof?: string[];
+    };
+    signature?: {
+        alg: string;
+        value: string;
+        seal_hash: string;
+        pq_alg?: string;
+        pq_value?: string;
+    };
+    licence?: {
+        engine: string;
+        tier: string;
+        terms: string;
+        accepted_at: string;
+    };
+}
+interface ConformanceResult {
+    conformant: boolean;
+    schema_id: string | null;
+    schema_digest_match: boolean;
+    seal_hash_match: boolean;
+    failures: string[];
+}
+declare function jcs(value: unknown): string;
+declare function psiSchemaDigest(): Promise<string>;
+/**
+ * Compute the schema digest from a published schema document (for example the
+ * one served at /.well-known/psi-schema.json) using this verifier's own
+ * canonicalisation. Anyone can run this against the npm or PyPI package output
+ * and compare the 64-hex result: verified, not asserted.
+ */
+declare function psiSchemaDigestFromDocument(doc: unknown): Promise<string>;
+declare function psiLeaf(hash: string): Promise<string>;
+declare function psiSealHash(envelope: PsiSealEnvelope): Promise<string>;
+/** Verifier distribution version. Identical in the Python distribution. */
+declare const PSI_VERIFIER_VERSION = "1.2.0";
+/**
+ * Human-readable rule citations (v1.2.0). Every rejection line carries one:
+ * verified, not asserted — trust the math, not the maker.
+ */
+declare const PSI_RULE_CITATIONS: {
+    readonly not_object: "1.1";
+    readonly closed_field_set: "2.1";
+    readonly schema_identifier: "4.1";
+    readonly schema_digest: "4.2";
+    readonly hash_encoding: "5.1";
+    readonly sealed_at: "6.1";
+    readonly size_bytes: "7.1";
+    readonly leaf_missing: "8.1";
+    readonly leaf_mismatch: "9.1";
+    readonly seal_hash: "10.1";
+};
+/** Canonical single-line rejection. Byte-identical in TypeScript and Python. */
+declare function rejectLine(detail: string, rule: string): string;
+declare function verifySeal(input: unknown): Promise<ConformanceResult>;
+/** Where a valid seal is produced. Printed in every rejection. */
+declare const PSI_SEAL_URL = "https://ai-governance-standard.com/seal";
+/** Machine-readable schema + licence discovery document. */
+declare const PSI_SCHEMA_URL = "https://ai-governance-standard.com/.well-known/psi-schema.json";
+/** Thrown by `verify()` when `enforce` is true (the default) and the seal fails. */
+declare class PsiSealInvalidError extends Error {
+    readonly result: ConformanceResult;
+    readonly canonicalDigest: string;
+    readonly name = "PsiSealInvalidError";
+    readonly code = "PSI_SEAL_INVALID";
+    constructor(result: ConformanceResult, canonicalDigest: string);
+}
+/**
+ * Canonical rejection text. Stable, greppable, actionable, and byte-identical
+ * to the Python distribution for the same input.
+ */
+declare function formatRejection(result: ConformanceResult, canonicalDigest: string): string;
+/** Canonical acceptance line. Byte-identical in the Python distribution. */
+declare function formatAcceptance(): string;
+interface VerifyOptions {
+    /**
+     * Reject non-conformant seals by throwing `PsiSealInvalidError`.
+     * DEFAULT: true (changed in v1.1.0 — previously report-only).
+     * Set false only to inspect legacy data without failing the pipeline.
+     */
+    enforce?: boolean;
+}
+/**
+ * Primary entry point. Enforced by default.
+ *
+ * @throws PsiSealInvalidError when the seal is not PSI-SEAL/1 conformant
+ *         and `enforce` is left at its default (true).
+ */
+declare function verify(input: unknown, options?: VerifyOptions): Promise<ConformanceResult>;
+/** Boolean convenience form. Never throws. */
+declare function isConformant(input: unknown): Promise<boolean>;
+/** Throwing assertion, identical to `verify(input)`. */
+declare function assertSeal(input: unknown): Promise<ConformanceResult>;
+/** Canonical Merkle root (R8) — promoted odd node, raw 32-byte concatenation. */
+declare function merkleRoot(leaves: string[]): Promise<string>;
+
+export { type ConformanceResult, PSI_RULE_CITATIONS, PSI_SCHEMA_ID, PSI_SCHEMA_RULES, PSI_SCHEMA_URL, PSI_SEAL_URL, PSI_VERIFIER_VERSION, type PsiSealEnvelope, PsiSealInvalidError, type VerifyOptions, assertSeal, formatAcceptance, formatRejection, isConformant, jcs, merkleRoot, psiLeaf, psiSchemaDigest, psiSchemaDigestFromDocument, psiSealHash, rejectLine, verify, verifySeal };

package/dist/index.js

@@ -0,0 +1,209 @@
+// src/index.ts
+var PSI_SCHEMA_ID = "PSI-SEAL/1.0.0";
+var PSI_SCHEMA_RULES = [
+  "R1  Envelope serialisation: RFC 8785 JSON Canonicalization Scheme (JCS), UTF-8, no BOM.",
+  "R2  Field set is closed. Unknown top-level fields render a seal non-conformant.",
+  "R3  Field order in the emitted receipt: schema, schema_digest, sealed_at, subject, hash, merkle, signature, licence.",
+  "R4  Digests: lowercase hexadecimal, exactly 64 characters, no 'sha256:' prefix inside the envelope.",
+  "R5  Hash algorithm: SHA-256 over the raw octet stream of the subject; no transport encoding, no trailing padding.",
+  "R6  sealed_at: RFC 3339 UTC with exactly three fractional digits and a literal 'Z' (e.g. 2026-08-17T09:00:00.000Z).",
+  "R7  subject.size_bytes: non-negative integer, exact octet length. subject.name: NFC-normalised UTF-8 string.",
+  "R8  Merkle assembly: binary tree over leaf digests in submission order; each parent = SHA-256(left_bytes || right_bytes) over 32-byte raw digests; an odd node is promoted, never duplicated.",
+  "R9  merkle.leaf = SHA-256 of the ASCII string 'PSI1:' || hash. Domain separation is mandatory.",
+  "R10 seal_hash = SHA-256(JCS(envelope minus the signature and licence members)).",
+  "R11 Signature suite: Ed25519 over the ASCII seal_hash; optional hybrid post-quantum LMS-W4-SHA256 (NIST SP 800-208).",
+  "R12 Every seal MUST carry schema and schema_digest. Only schema-conformant seals are considered PSI-compliant."
+];
+function jcs(value) {
+  if (value === null || typeof value === "number" || typeof value === "boolean") return JSON.stringify(value);
+  if (typeof value === "string") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(jcs).join(",")}]`;
+  if (typeof value === "object") {
+    const obj = value;
+    const keys = Object.keys(obj).filter((k) => obj[k] !== void 0).sort(
+      (a, b) => a < b ? -1 : a > b ? 1 : 0
+    );
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${jcs(obj[k])}`).join(",")}}`;
+  }
+  throw new Error("JCS: unsupported value");
+}
+async function sha256Hex(input) {
+  const bytes = typeof input === "string" ? new TextEncoder().encode(input) : input;
+  const buf = await crypto.subtle.digest("SHA-256", bytes);
+  return Array.from(new Uint8Array(buf)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+var cachedDigest = null;
+async function psiSchemaDigest() {
+  if (cachedDigest) return cachedDigest;
+  cachedDigest = await sha256Hex(jcs({ id: PSI_SCHEMA_ID, rules: PSI_SCHEMA_RULES }));
+  return cachedDigest;
+}
+async function psiSchemaDigestFromDocument(doc) {
+  const d = doc;
+  if (typeof (d == null ? void 0 : d.schema) !== "string" || !Array.isArray(d == null ? void 0 : d.rules)) {
+    throw new Error("PSI schema document must carry a string `schema` and an array of `rules`");
+  }
+  return sha256Hex(jcs({ id: d.schema, rules: d.rules }));
+}
+function psiLeaf(hash) {
+  return sha256Hex(`PSI1:${hash.replace(/^sha256:/i, "").toLowerCase()}`);
+}
+async function psiSealHash(envelope) {
+  const { signature: _s, licence: _l, ...core } = envelope;
+  return sha256Hex(jcs(core));
+}
+var HEX64 = /^[0-9a-f]{64}$/;
+var RFC3339_MS = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+var ALLOWED = ["schema", "schema_digest", "sealed_at", "subject", "hash", "merkle", "signature", "licence"];
+var PSI_VERIFIER_VERSION = "1.2.0";
+var PSI_RULE_CITATIONS = {
+  not_object: "1.1",
+  closed_field_set: "2.1",
+  schema_identifier: "4.1",
+  schema_digest: "4.2",
+  hash_encoding: "5.1",
+  sealed_at: "6.1",
+  size_bytes: "7.1",
+  leaf_missing: "8.1",
+  leaf_mismatch: "9.1",
+  seal_hash: "10.1"
+};
+function rejectLine(detail, rule) {
+  return `PSI-SEAL v${PSI_VERIFIER_VERSION} REJECT: ${detail} \u2014 rule ${rule}`;
+}
+async function verifySeal(input) {
+  var _a, _b;
+  const failures = [];
+  const env = input;
+  if (!env || typeof env !== "object" || Array.isArray(env)) {
+    return {
+      conformant: false,
+      schema_id: null,
+      schema_digest_match: false,
+      seal_hash_match: false,
+      failures: [rejectLine("input is not a JSON object", PSI_RULE_CITATIONS.not_object)]
+    };
+  }
+  const expected = await psiSchemaDigest();
+  if (env.schema !== PSI_SCHEMA_ID)
+    failures.push(rejectLine(`schema identifier mismatch, expected ${PSI_SCHEMA_ID}`, PSI_RULE_CITATIONS.schema_identifier));
+  const digestMatch = env.schema_digest === expected;
+  if (!digestMatch) failures.push(rejectLine("schema_digest mismatch", PSI_RULE_CITATIONS.schema_digest));
+  const extra = Object.keys(env).filter((k) => !ALLOWED.includes(k));
+  if (extra.length)
+    failures.push(rejectLine(`unknown top-level fields: ${extra.join(", ")}`, PSI_RULE_CITATIONS.closed_field_set));
+  if (!RFC3339_MS.test(env.sealed_at ?? ""))
+    failures.push(rejectLine("sealed_at is not RFC 3339 UTC with three fractional digits", PSI_RULE_CITATIONS.sealed_at));
+  if (!HEX64.test(env.hash ?? ""))
+    failures.push(rejectLine("hash is not 64 lowercase hexadecimal characters", PSI_RULE_CITATIONS.hash_encoding));
+  if (!env.subject || !Number.isInteger(env.subject.size_bytes) || env.subject.size_bytes < 0)
+    failures.push(rejectLine("subject.size_bytes is not a non-negative integer", PSI_RULE_CITATIONS.size_bytes));
+  let sealHashMatch = false;
+  if (HEX64.test(env.hash ?? "") && ((_a = env.merkle) == null ? void 0 : _a.leaf)) {
+    if (await psiLeaf(env.hash) !== env.merkle.leaf)
+      failures.push(rejectLine("merkle.leaf mismatch", PSI_RULE_CITATIONS.leaf_mismatch));
+    if ((_b = env.signature) == null ? void 0 : _b.seal_hash) {
+      sealHashMatch = await psiSealHash(env) === env.signature.seal_hash;
+      if (!sealHashMatch) failures.push(rejectLine("seal_hash mismatch", PSI_RULE_CITATIONS.seal_hash));
+    }
+  } else {
+    failures.push(rejectLine("merkle.leaf missing", PSI_RULE_CITATIONS.leaf_missing));
+  }
+  return {
+    conformant: failures.length === 0,
+    schema_id: typeof env.schema === "string" ? env.schema : null,
+    schema_digest_match: digestMatch,
+    seal_hash_match: sealHashMatch,
+    failures
+  };
+}
+var PSI_SEAL_URL = "https://ai-governance-standard.com/seal";
+var PSI_SCHEMA_URL = "https://ai-governance-standard.com/.well-known/psi-schema.json";
+var PsiSealInvalidError = class extends Error {
+  constructor(result, canonicalDigest) {
+    super(formatRejection(result, canonicalDigest));
+    this.result = result;
+    this.canonicalDigest = canonicalDigest;
+  }
+  result;
+  canonicalDigest;
+  name = "PsiSealInvalidError";
+  code = "PSI_SEAL_INVALID";
+};
+function formatRejection(result, canonicalDigest) {
+  return [
+    rejectLine(`seal is not conformant to ${PSI_SCHEMA_ID}`, PSI_RULE_CITATIONS.not_object),
+    `canonical schema digest: ${canonicalDigest}`,
+    `received schema: ${result.schema_id ?? "(none)"} (digest match: ${result.schema_digest_match ? "true" : "false"})`,
+    "findings:",
+    ...result.failures.map((f) => `  ${f}`),
+    `generate a conformant seal: ${PSI_SEAL_URL}`,
+    `canonical schema: ${PSI_SCHEMA_URL}`,
+    "legacy escape hatch (report-only): enforce=false",
+    "verified, not asserted; trust the math, not the maker."
+  ].join("\n");
+}
+function formatAcceptance() {
+  return `PSI-SEAL v${PSI_VERIFIER_VERSION} ACCEPT: conformant seal`;
+}
+async function verify(input, options = {}) {
+  const enforce = options.enforce !== false;
+  const result = await verifySeal(input);
+  if (!result.conformant && enforce) {
+    throw new PsiSealInvalidError(result, await psiSchemaDigest());
+  }
+  return result;
+}
+async function isConformant(input) {
+  return (await verifySeal(input)).conformant;
+}
+async function assertSeal(input) {
+  return verify(input, { enforce: true });
+}
+async function merkleRoot(leaves) {
+  if (!leaves.length) throw new Error("R8: at least one leaf required");
+  const toBytes = (h) => {
+    const c = h.toLowerCase();
+    const out = new Uint8Array(new ArrayBuffer(32));
+    for (let i = 0; i < 32; i++) out[i] = parseInt(c.slice(i * 2, i * 2 + 2), 16);
+    return out;
+  };
+  let level = leaves.map(toBytes);
+  while (level.length > 1) {
+    const next = [];
+    for (let i = 0; i < level.length; i += 2) {
+      if (i + 1 === level.length) {
+        next.push(level[i]);
+        continue;
+      }
+      const merged = new Uint8Array(new ArrayBuffer(64));
+      merged.set(level[i], 0);
+      merged.set(level[i + 1], 32);
+      next.push(toBytes(await sha256Hex(merged)));
+    }
+    level = next;
+  }
+  return Array.from(level[0]).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+export {
+  PSI_RULE_CITATIONS,
+  PSI_SCHEMA_ID,
+  PSI_SCHEMA_RULES,
+  PSI_SCHEMA_URL,
+  PSI_SEAL_URL,
+  PSI_VERIFIER_VERSION,
+  PsiSealInvalidError,
+  assertSeal,
+  formatAcceptance,
+  formatRejection,
+  isConformant,
+  jcs,
+  merkleRoot,
+  psiLeaf,
+  psiSchemaDigest,
+  psiSchemaDigestFromDocument,
+  psiSealHash,
+  rejectLine,
+  verify,
+  verifySeal
+};

package/package.json

@@ -1,6 +1,61 @@
 {
   "name": "apex-psi-verifier",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.2.0",
+  "description": "MIT-licensed verifier for the PSI-SEAL/1 canonical seal schema. Verification is free forever; non-conformant seals are rejected by default.",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "types": "dist/index.d.ts",
+  "module": "dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "psi",
+    "apex",
+    "apex-psi",
+    "verification",
+    "verifier",
+    "ai-governance",
+    "eu-ai-act",
+    "sha256",
+    "ed25519",
+    "merkle-tree",
+    "rfc8785",
+    "post-quantum",
+    "provenance"
+  ],
+  "author": "APEX Intelligence Empire / ROCKYFILMS888 PTY LTD (ABN 71 672 237 795)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kawal393/APEX-PSI.git",
+    "directory": "packages/psi-verifier"
+  },
+  "bugs": {
+    "url": "https://github.com/kawal393/APEX-PSI/issues"
+  },
+  "homepage": "https://ai-governance-standard.com/license",
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  },
+  "sideEffects": false
 }