Dev5 ecosystem foundation (direct HF push): byte-identical shared modules + ecosystem router + serve.py registration + Dockerfile COPY. Fixes partial GitHub auto-sync; unblocks COPY.

static/shared/szl_codename_sanitizer.js

@@ -0,0 +1,127 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * (c) 2026 Lutar, Stephen P. - SZL Holdings - ORCID 0009-0001-0110-4173
+ * ============================================================================
+ * szl_codename_sanitizer.js - SHARED MODULE (byte-identical across both apps)
+ * ----------------------------------------------------------------------------
+ * Doctrine gate G5: 0 user-visible codenames. Internal route keys
+ * (amaru_* / rosie_* / sentra / jarvis) are fine as JS keys, but EVERY
+ * user-visible string must read its honest public role:
+ *     amaru  -> YACHAY     (cortex / brain / OSINT ingest)
+ *     rosie  -> Operator   (orchestrator)
+ *     sentra -> CHAPAQ     (verdict / immune)
+ *     jarvis -> Operator   (assistant / orchestrator)
+ *
+ * NO CDN. Vanilla JS. Browser + Node. This is the single mapping table so the
+ * two apps never drift, plus a live rendered-DOM scanner used by the CI gate.
+ *
+ * Public API (window.SZLCodenames / module.exports):
+ *   MAP                              - frozen {codename: publicRole}
+ *   BANNED_RE                        - the canonical detector regex (global, i)
+ *   sanitize(str)                    - replace banned tokens with public roles
+ *   scan(str)                        - return [{token, index}] of banned hits
+ *   scanDOM(rootNode?)               - scan rendered text + key attrs; returns hits[]
+ *   guardedRender(el)                - sanitize textContent of a node in-place
+ *   isClean(str)                     - boolean
+ * ============================================================================ */
+(function (root, factory) {
+  var mod = factory();
+  if (typeof module === "object" && module.exports) { module.exports = mod; }
+  if (root) { root.SZLCodenames = mod; }
+})(typeof self !== "undefined" ? self : (typeof window !== "undefined" ? window : null), function () {
+  "use strict";
+
+  // Case-preserving public-role mapping. Order: most-specific first.
+  var MAP = {
+    "amaru": "YACHAY",
+    "rosie": "Operator",
+    "sentra": "CHAPAQ",
+    "jarvis": "Operator"
+  };
+  try { Object.freeze(MAP); } catch (e) {}
+
+  // Word-ish boundary: catch amaru, rosie_digest, Sentra, JARVIS, amaru-feed.
+  // We match the bare codename token wherever it appears as a visible word part.
+  var TOKENS = ["amaru", "rosie", "sentra", "jarvis"];
+  var BANNED_RE = new RegExp("(" + TOKENS.join("|") + ")", "ig");
+
+  function _roleFor(tok) {
+    var low = String(tok).toLowerCase();
+    return MAP[low] || low;
+  }
+
+  // Replace a matched codename, preserving a leading capital if the source was
+  // capitalized (so "Rosie" -> "Operator", "rosie" -> "Operator" both read well).
+  function sanitize(str) {
+    if (str == null) { return str; }
+    return String(str).replace(BANNED_RE, function (m) { return _roleFor(m); });
+  }
+
+  function scan(str) {
+    var out = [], s = String(str == null ? "" : str), m;
+    BANNED_RE.lastIndex = 0;
+    while ((m = BANNED_RE.exec(s)) !== null) {
+      out.push({ token: m[0], index: m.index });
+      if (m.index === BANNED_RE.lastIndex) { BANNED_RE.lastIndex++; }
+    }
+    return out;
+  }
+
+  function isClean(str) { return scan(str).length === 0; }
+
+  /* Scan a rendered DOM subtree for visible banned tokens. Checks visible text
+   * nodes + the human-visible attributes (title, aria-label, alt, placeholder,
+   * value). Ignores id/class/data-* route keys (those are allowed internal keys).
+   * Returns [{token, where, sample}]. */
+  function scanDOM(rootNode) {
+    var doc = (typeof document !== "undefined") ? document : null;
+    var root = rootNode || (doc ? doc.body : null);
+    if (!root) { return []; }
+    var hits = [];
+    var VISIBLE_ATTRS = ["title", "aria-label", "alt", "placeholder", "value"];
+
+    // 1) text nodes
+    if (doc && doc.createTreeWalker) {
+      var walker = doc.createTreeWalker(root, NodeFilter.SHOW_TEXT, null, false);
+      var n;
+      while ((n = walker.nextNode())) {
+        var t = n.nodeValue || "";
+        var sc = scan(t);
+        for (var i = 0; i < sc.length; i++) {
+          hits.push({ token: sc[i].token, where: "text", sample: t.slice(Math.max(0, sc[i].index - 12), sc[i].index + 16) });
+        }
+      }
+    }
+    // 2) visible attributes
+    var all = root.querySelectorAll ? root.querySelectorAll("*") : [];
+    for (var e = 0; e < all.length; e++) {
+      for (var a = 0; a < VISIBLE_ATTRS.length; a++) {
+        var av = all[e].getAttribute ? all[e].getAttribute(VISIBLE_ATTRS[a]) : null;
+        if (av) {
+          var sca = scan(av);
+          for (var j = 0; j < sca.length; j++) {
+            hits.push({ token: sca[j].token, where: "@" + VISIBLE_ATTRS[a], sample: av.slice(0, 40) });
+          }
+        }
+      }
+    }
+    return hits;
+  }
+
+  function guardedRender(el) {
+    if (!el) { return el; }
+    if (typeof el.textContent === "string") { el.textContent = sanitize(el.textContent); }
+    return el;
+  }
+
+  return {
+    VERSION: "1.0.0",
+    MAP: MAP,
+    TOKENS: TOKENS.slice(),
+    BANNED_RE: BANNED_RE,
+    sanitize: sanitize,
+    scan: scan,
+    isClean: isClean,
+    scanDOM: scanDOM,
+    guardedRender: guardedRender
+  };
+});

static/shared/szl_label_engine.js

@@ -0,0 +1,161 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * (c) 2026 Lutar, Stephen P. - SZL Holdings - ORCID 0009-0001-0110-4173
+ * ============================================================================
+ * szl_label_engine.js - SHARED MODULE (byte-identical across a11oy + killinchu)
+ * ----------------------------------------------------------------------------
+ * The single honest-label primitive for the SZL estate. Renders the canonical
+ * doctrine badges. NO build step, NO CDN, vanilla ES5-safe JS, browser + Node.
+ *
+ * Doctrine gate G7 (honest labels) + G8 (the half-state is the only
+ * unacceptable outcome). Every demo surface labels what is real; this module is
+ * the one place the badge vocabulary, colors and semantics live so the two apps
+ * never drift. Importing tabs MUST NOT invent their own pills.
+ *
+ * Canonical badge vocabulary (the ONLY allowed honest labels):
+ *   LIVE          - real backend wired, data is genuinely live, honest
+ *   SAMPLE        - honest sample / illustrative fixture (not live)
+ *   FORECAST      - model-produced forward estimate (e.g. seismic pulse)
+ *   OSINT         - open-source intelligence (sensed, unauthenticated claims)
+ *   MODELED       - deterministic model output, labeled (e.g. RUL, ent. forecast)
+ *   SIMULATED     - effector / decision simulation, human-on-the-loop (G6)
+ *   CONNECT-READY - real schema, awaits OAuth; sample until connected
+ *   EXPERIMENTAL  - CI-green Lean wave, not locked-8
+ *   HEURISTIC     - rule/heuristic advisory, not proven
+ *   PQC-ROADMAP   - post-quantum signing is roadmap, never shown deployed (G4)
+ *   ILLUSTRATIVE  - explicitly illustrative (e.g. wow ROI)
+ *
+ * Public API (window.SZLLabels / module.exports):
+ *   SCHEMES                          - frozen registry {KEY:{label,cls,title,...}}
+ *   badge(key, opts?)                - returns an HTMLElement <span class="szl-pill ...">
+ *   badgeHTML(key, opts?)            - returns a sanitized HTML string
+ *   isHonestLabel(key)               - boolean: is this a canonical honest label?
+ *   normalize(key)                   - canonicalizes aliases ("connect_ready" -> "CONNECT-READY")
+ *   auditText(str)                   - returns [] of forbidden raw claims (e.g. "100%", "tamper-proof")
+ *   ensureStyle(doc?)                - injects the <style> once (idempotent)
+ * ============================================================================ */
+(function (root, factory) {
+  var mod = factory();
+  if (typeof module === "object" && module.exports) { module.exports = mod; }
+  if (root) { root.SZLLabels = mod; }
+})(typeof self !== "undefined" ? self : (typeof window !== "undefined" ? window : null), function () {
+  "use strict";
+
+  /* Canonical registry. cls is a CSS modifier; colors are doctrine-fixed so the
+   * two apps render identical pills. tone: ok|warn|info|sim|bad — drives color. */
+  var SCHEMES = {
+    "LIVE":          { label: "LIVE",          tone: "ok",   title: "Real backend wired - data is genuinely live and honest." },
+    "SAMPLE":        { label: "SAMPLE",        tone: "info", title: "Honest sample / illustrative fixture - not a live feed." },
+    "FORECAST":      { label: "FORECAST",      tone: "warn", title: "Model-produced forward estimate. Not an observation." },
+    "OSINT":         { label: "OSINT",         tone: "info", title: "Open-source intelligence. Sensed, unauthenticated claims." },
+    "MODELED":       { label: "MODELED",       tone: "warn", title: "Deterministic model output, labeled. Not measured." },
+    "SIMULATED":     { label: "SIMULATED",     tone: "sim",  title: "Effector / decision simulation, human-on-the-loop. No live control." },
+    "CONNECT-READY": { label: "CONNECT-READY", tone: "info", title: "Real schema, awaits OAuth. Sample data until connected." },
+    "EXPERIMENTAL":  { label: "EXPERIMENTAL",  tone: "warn", title: "CI-green Lean wave - NOT part of the locked-8." },
+    "HEURISTIC":     { label: "HEURISTIC",     tone: "warn", title: "Rule / heuristic advisory. Not a proven result." },
+    "PQC-ROADMAP":   { label: "PQC-ROADMAP",   tone: "warn", title: "Post-quantum signing is roadmap. Never shown as deployed (G4)." },
+    "ILLUSTRATIVE":  { label: "ILLUSTRATIVE",  tone: "info", title: "Explicitly illustrative figure (e.g. ROI)." }
+  };
+  // freeze so importing tabs cannot mutate the doctrine vocabulary
+  try { Object.freeze(SCHEMES); for (var k in SCHEMES) { Object.freeze(SCHEMES[k]); } } catch (e) {}
+
+  var ALIASES = {
+    "CONNECT_READY": "CONNECT-READY", "CONNECTREADY": "CONNECT-READY",
+    "PQC_ROADMAP": "PQC-ROADMAP", "PQCROADMAP": "PQC-ROADMAP", "PQC": "PQC-ROADMAP",
+    "SIM": "SIMULATED", "EXP": "EXPERIMENTAL", "MODEL": "MODELED"
+  };
+
+  function normalize(key) {
+    if (key == null) { return ""; }
+    var u = String(key).trim().toUpperCase().replace(/\s+/g, "-");
+    if (SCHEMES[u]) { return u; }
+    var nodash = u.replace(/[-_]/g, "");
+    if (ALIASES[u]) { return ALIASES[u]; }
+    if (ALIASES[nodash]) { return ALIASES[nodash]; }
+    return u; // unknown - caller decides
+  }
+
+  function isHonestLabel(key) { return Object.prototype.hasOwnProperty.call(SCHEMES, normalize(key)); }
+
+  function esc(s) {
+    return String(s == null ? "" : s)
+      .replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
+      .replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+  }
+
+  /* Forbidden raw claims a tab must never render (doctrine G2/G3/G4/G7).
+   * auditText() returns the list of violations found in a rendered string. */
+  var FORBIDDEN = [
+    { re: /\b100\s*%/,                              why: "trust is never 100% (Lambda capped < 1.0)" },
+    { re: /\btamper-?proof\b/i,                     why: "use 'tamper-evident', not 'tamper-proof' (G3)" },
+    { re: /\bunique\s+theorem\b/i,                  why: "Lambda uniqueness is Conjecture 1, not a theorem (G2)" },
+    { re: /\bunconditional(ly)?\s+(unique|proven)\b/i, why: "Lambda uniqueness is conditional (Conjecture 1) (G2)" },
+    { re: /\bSLSA\s*L3\b(?!\s*roadmap)/i,           why: "SLSA must read 'L1 honest / L2 attested / L3 roadmap' (G4)" },
+    { re: /\b(FedRAMP|IronBank|CMMC|ATO)\b/i,       why: "never claim FedRAMP/IronBank/CMMC/ATO as achieved (G4)" },
+    { re: /\blocked\s*=?\s*5\b/i,                   why: "locked-proven is EXACTLY 8, never 5 (G1)" }
+  ];
+  function auditText(str) {
+    var out = [], s = String(str == null ? "" : str), i;
+    for (i = 0; i < FORBIDDEN.length; i++) { if (FORBIDDEN[i].re.test(s)) { out.push(FORBIDDEN[i].why); } }
+    return out;
+  }
+
+  var STYLE_ID = "szl-label-engine-style";
+  var CSS =
+    "." + "szl-pill{display:inline-flex;align-items:center;gap:6px;font:700 11px/1 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;" +
+    "letter-spacing:.04em;padding:4px 9px;border-radius:7px;border:1px solid;text-transform:uppercase;white-space:nowrap;vertical-align:middle;}" +
+    ".szl-pill .szl-dot{width:7px;height:7px;border-radius:50%;background:currentColor;flex:0 0 auto;}" +
+    ".szl-pill.ok{color:#16c784;border-color:#16c78455;background:#16c7841a;}" +
+    ".szl-pill.warn{color:#e0a106;border-color:#e0a10655;background:#e0a1061a;}" +
+    ".szl-pill.info{color:#3aa0ff;border-color:#3aa0ff55;background:#3aa0ff1a;}" +
+    ".szl-pill.sim{color:#b07cff;border-color:#b07cff55;background:#b07cff1a;}" +
+    ".szl-pill.bad{color:#ff5c5c;border-color:#ff5c5c55;background:#ff5c5c1a;}" +
+    ".szl-pill.unknown{color:#888;border-color:#88888855;background:#8888881a;}";
+
+  function ensureStyle(doc) {
+    var d = doc || (typeof document !== "undefined" ? document : null);
+    if (!d || d.getElementById(STYLE_ID)) { return; }
+    var st = d.createElement("style"); st.id = STYLE_ID; st.textContent = CSS;
+    (d.head || d.documentElement).appendChild(st);
+  }
+
+  function resolve(key) {
+    var nk = normalize(key);
+    var s = SCHEMES[nk];
+    if (s) { return { key: nk, label: s.label, tone: s.tone, title: s.title, known: true }; }
+    return { key: nk, label: nk || "?", tone: "unknown", title: "Unknown / non-canonical label - not part of the honest vocabulary.", known: false };
+  }
+
+  function badgeHTML(key, opts) {
+    opts = opts || {};
+    var r = resolve(key);
+    var label = opts.label != null ? String(opts.label) : r.label;
+    var title = opts.title != null ? String(opts.title) : r.title;
+    var extra = opts.className ? (" " + String(opts.className)) : "";
+    var dot = opts.dot === false ? "" : '<span class="szl-dot" aria-hidden="true"></span>';
+    return '<span class="szl-pill ' + esc(r.tone) + extra + '" data-szl-label="' + esc(r.key) +
+      '" title="' + esc(title) + '" role="img" aria-label="data label: ' + esc(label) + '">' +
+      dot + esc(label) + "</span>";
+  }
+
+  function badge(key, opts) {
+    opts = opts || {};
+    var doc = opts.document || (typeof document !== "undefined" ? document : null);
+    if (!doc) { throw new Error("SZLLabels.badge requires a DOM document; use badgeHTML in Node."); }
+    ensureStyle(doc);
+    var tmp = doc.createElement("div");
+    tmp.innerHTML = badgeHTML(key, opts);
+    return tmp.firstChild;
+  }
+
+  return {
+    VERSION: "1.0.0",
+    SCHEMES: SCHEMES,
+    badge: badge,
+    badgeHTML: badgeHTML,
+    isHonestLabel: isHonestLabel,
+    normalize: normalize,
+    auditText: auditText,
+    ensureStyle: ensureStyle,
+    keys: function () { var a = [], k; for (k in SCHEMES) { a.push(k); } return a; }
+  };
+});

static/shared/szl_receipt_cosign.js

@@ -0,0 +1,237 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * (c) 2026 Lutar, Stephen P. - SZL Holdings - ORCID 0009-0001-0110-4173
+ * ============================================================================
+ * szl_receipt_cosign.js - SHARED MODULE (byte-identical across a11oy + killinchu)
+ * ----------------------------------------------------------------------------
+ * The single DSSE receipt + cosign-verify primitive for the SZL estate.
+ * NO CDN, no build step. Browser-native SubtleCrypto only. Node-safe import.
+ *
+ *   *** ONE documented signing scheme for the whole estate: ***
+ *       ECDSA P-256 (SECP256R1) over SHA-256  ==  Sigstore cosign default.
+ *
+ * WHY P-256 and NOT Ed25519 (resolving the signing-scheme drift, gate G4):
+ *   - The deployed estate, szl_dsse.py (byte-identical in both apps), every
+ *     server verify path, and the PUBLISHED key szl-holdings/.github/cosign.pub
+ *     are ALL ECDSA P-256. cosign sign-blob / verify-blob round-trips against it.
+ *   - a11oy_signing_key.py states the curve is "deliberately NOT Ed25519" to
+ *     match cosign.pub and every existing verify path.
+ *   - Switching to Ed25519 would orphan cosign.pub and break cosign-CLI
+ *     interop. Doctrine G8 ("don't claim/ship more than is real") => keep the
+ *     scheme that actually verifies. The Ed25519 suggestion is therefore
+ *     RESOLVED in favor of ECDSA-P256. HMAC is forbidden (symmetric, not
+ *     publicly verifiable). This is the single source of truth for clients.
+ *
+ * DSSE (secure-systems-lab/dsse) PAE pre-authentication encoding (must match
+ * szl_dsse.py byte-for-byte):
+ *   PAE(type, body) = "DSSEv1" SP LEN(type) SP type SP LEN(body) SP body
+ *   SIGNATURE       = ECDSA-P256-SHA256( PAE(payloadType, canonical_body) )
+ *
+ * HONESTY (gate G7/G8): this module NEVER fabricates a signature. Signing is
+ * done by the SAME-ORIGIN server endpoint POST /khipu/sign (which holds the
+ * szlholdings-cosign private key). The client:
+ *   - builds the canonical receipt + chain hash (SHA-256, re-checkable),
+ *   - asks the server to sign,
+ *   - records keyid + sig_type returned (truthfully),
+ *   - if the signer is unreachable OR returns an ephemeral/non-canonical key,
+ *     marks the receipt UNSIGNED / CROSS-APP-PENDING and shows it honestly.
+ *
+ * Public API (window.SZLReceipts / module.exports):
+ *   SCHEME                              - "ECDSA-P256-SHA256" (frozen)
+ *   COSIGN_KEYID                        - "szlholdings-cosign" (frozen)
+ *   COSIGN_PUB_URL                      - canonical published key URL
+ *   canonicalJSON(obj)                  - deterministic JSON (sorted keys)
+ *   sha256Hex(strOrBytes) -> Promise    - SubtleCrypto SHA-256 hex
+ *   pae(type, bodyBytes) -> Uint8Array  - DSSE PAE bytes
+ *   chainHash(prevHash, receipt) -> P   - SHA-256 of (prev_hash || canonical)
+ *   signReceipt(receipt, opts) -> P     - POST /khipu/sign; honest never-fake
+ *   verifyEnvelope(env, opts) -> P      - POST /khipu/verify; cross-app verdict
+ *   isCanonicalKey(keyid)               - keyid === szlholdings-cosign ?
+ *   newChain(opts)                      - a small append-only signed chain helper
+ * ============================================================================ */
+(function (root, factory) {
+  var mod = factory();
+  if (typeof module === "object" && module.exports) { module.exports = mod; }
+  if (root) { root.SZLReceipts = mod; }
+})(typeof self !== "undefined" ? self : (typeof window !== "undefined" ? window : null), function () {
+  "use strict";
+
+  var SCHEME = "ECDSA-P256-SHA256";
+  var COSIGN_KEYID = "szlholdings-cosign";
+  var COSIGN_PUB_URL = "https://github.com/szl-holdings/.github/blob/main/cosign.pub";
+  var KHIPU_PAYLOAD_TYPE = "application/vnd.szl.khipu+json";
+
+  function _subtle() {
+    var c = (typeof self !== "undefined" && self.crypto) ? self.crypto
+          : (typeof window !== "undefined" && window.crypto) ? window.crypto
+          : (typeof globalThis !== "undefined" && globalThis.crypto) ? globalThis.crypto : null;
+    return c && c.subtle ? c.subtle : null;
+  }
+
+  /* Deterministic canonical JSON: object keys sorted recursively, no spaces.
+   * MUST match szl_dsse.canonical_json (json.dumps(sort_keys, separators=(',',':'))). */
+  function canonicalJSON(obj) {
+    if (obj === null || typeof obj !== "object") { return JSON.stringify(obj); }
+    if (Object.prototype.toString.call(obj) === "[object Array]") {
+      var items = []; for (var i = 0; i < obj.length; i++) { items.push(canonicalJSON(obj[i])); }
+      return "[" + items.join(",") + "]";
+    }
+    var keys = []; for (var k in obj) { if (Object.prototype.hasOwnProperty.call(obj, k)) { keys.push(k); } }
+    keys.sort();
+    var parts = []; for (var j = 0; j < keys.length; j++) { parts.push(JSON.stringify(keys[j]) + ":" + canonicalJSON(obj[keys[j]])); }
+    return "{" + parts.join(",") + "}";
+  }
+
+  function _toBytes(strOrBytes) {
+    if (strOrBytes instanceof Uint8Array) { return strOrBytes; }
+    var s = String(strOrBytes);
+    if (typeof TextEncoder !== "undefined") { return new TextEncoder().encode(s); }
+    var arr = []; for (var i = 0; i < s.length; i++) { arr.push(s.charCodeAt(i) & 0xff); }
+    return new Uint8Array(arr);
+  }
+  function _hex(buf) {
+    var b = new Uint8Array(buf), h = ""; for (var i = 0; i < b.length; i++) { h += (b[i] < 16 ? "0" : "") + b[i].toString(16); }
+    return h;
+  }
+
+  function sha256Hex(strOrBytes) {
+    var sub = _subtle();
+    if (!sub) { return Promise.reject(new Error("SubtleCrypto unavailable (needs HTTPS/secure context)")); }
+    return sub.digest("SHA-256", _toBytes(strOrBytes)).then(_hex);
+  }
+
+  /* DSSE PAE bytes. Lengths are decimal ASCII of the UTF-8 byte length. */
+  function pae(payloadType, bodyBytes) {
+    var t = _toBytes(payloadType), b = (bodyBytes instanceof Uint8Array) ? bodyBytes : _toBytes(bodyBytes);
+    var head = "DSSEv1 " + t.length + " ";
+    var mid = " " + b.length + " ";
+    var pre = _toBytes(head), tb = t, midb = _toBytes(mid);
+    var out = new Uint8Array(pre.length + tb.length + midb.length + b.length);
+    var o = 0;
+    out.set(pre, o); o += pre.length;
+    out.set(tb, o); o += tb.length;
+    out.set(midb, o); o += midb.length;
+    out.set(b, o);
+    return out;
+  }
+
+  function chainHash(prevHash, receipt) {
+    var canonical = canonicalJSON(receipt);
+    return sha256Hex(String(prevHash || "0") + "|" + canonical).then(function (h) {
+      return { hash: h, canonical: canonical };
+    });
+  }
+
+  function isCanonicalKey(keyid) { return keyid === COSIGN_KEYID; }
+
+  /* Ask the SAME-ORIGIN server to sign. NEVER fabricates a signature.
+   * opts: { base:"", payloadType, fetchImpl } */
+  function signReceipt(receipt, opts) {
+    opts = opts || {};
+    var base = opts.base || "";
+    var f = opts.fetchImpl || (typeof fetch !== "undefined" ? fetch : null);
+    if (!f) { return Promise.reject(new Error("fetch unavailable")); }
+    var body = JSON.stringify(receipt);
+    return f(base + "/khipu/sign", {
+      method: "POST", headers: { "Content-Type": "application/json" }, body: body
+    }).then(function (resp) {
+      var ct = resp.headers && resp.headers.get ? (resp.headers.get("content-type") || "") : "";
+      if (!resp.ok) { return resp.text().then(function (t) { throw new Error("signer HTTP " + resp.status + ": " + t.slice(0, 160)); }); }
+      if (ct.indexOf("application/json") === -1) { throw new Error("signer returned non-JSON (route not mounted)"); }
+      return resp.json();
+    }).then(function (j) {
+      var env = j.envelope || j;
+      var sig0 = (env.signatures && env.signatures[0]) || null;
+      var keyid = sig0 ? sig0.keyid : null;
+      var sigType = (sig0 && sig0.sig_type) || (j.sig_types && j.sig_types[0]) || SCHEME;
+      var hasSig = !!(sig0 && sig0.sig);
+      var canonical = isCanonicalKey(keyid);
+      return {
+        signed: hasSig,
+        canonicalKey: canonical,
+        crossAppVerifiable: hasSig && canonical,
+        keyid: keyid,
+        sigType: sigType,
+        sig: sig0 ? sig0.sig : null,
+        envelope: env,
+        signerNote: hasSig
+          ? (canonical ? "" : "signer used a NON-CANONICAL key (" + keyid + "); cross-app verify PENDING operator cosign secret")
+          : "signer returned no signature - receipt is UNSIGNED (honest)"
+      };
+    })["catch"](function (err) {
+      // HONEST failure - never fake a signature
+      return {
+        signed: false, canonicalKey: false, crossAppVerifiable: false,
+        keyid: null, sigType: null, sig: null, envelope: null,
+        signerNote: "signer unreachable - receipt is UNSIGNED (honest): " + err.message
+      };
+    });
+  }
+
+  /* Verify a DSSE envelope via the server /khipu/verify (verifies against the
+   * published cosign.pub). Returns a truthful verdict. */
+  function verifyEnvelope(envelope, opts) {
+    opts = opts || {};
+    var base = opts.base || "";
+    var f = opts.fetchImpl || (typeof fetch !== "undefined" ? fetch : null);
+    if (!f) { return Promise.reject(new Error("fetch unavailable")); }
+    return f(base + "/khipu/verify", {
+      method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(envelope)
+    }).then(function (resp) {
+      if (!resp.ok) { throw new Error("verify HTTP " + resp.status); }
+      return resp.json();
+    }).then(function (j) {
+      return {
+        verified: j.verified === true,
+        keyidMatch: j.keyid_match === true,
+        keyidExpected: (j.detail && j.detail.keyid_expected) || COSIGN_KEYID,
+        pubFingerprint: (j.detail && j.detail.pub_fingerprint_sha256) || null,
+        verifyKeyUrl: (j.detail && j.detail.verify_key_url) || COSIGN_PUB_URL,
+        raw: j
+      };
+    });
+  }
+
+  /* Small append-only signed chain helper. Each push() hashes (prev||receipt),
+   * signs via the server, and links. Honest about UNSIGNED / cross-app state. */
+  function newChain(opts) {
+    opts = opts || {};
+    var base = opts.base || "";
+    var chain = [];
+    var tip = "0";
+    return {
+      receipts: chain,
+      tip: function () { return tip; },
+      push: function (action, data) {
+        var seq = chain.length;
+        var receipt = { action: String(action), seq: seq, prev_hash: tip, data: data || {}, ts: new Date().toISOString() };
+        return chainHash(tip, receipt).then(function (ch) {
+          receipt.hash = ch.hash; receipt.canonical = ch.canonical;
+          return signReceipt({ action: receipt.action, seq: seq, prev_hash: tip, data: receipt.data }, { base: base });
+        }).then(function (sg) {
+          receipt.signed = sg.signed; receipt.keyid = sg.keyid; receipt.sigType = sg.sigType;
+          receipt.sig = sg.sig; receipt.canonicalKey = sg.canonicalKey;
+          receipt.crossAppVerifiable = sg.crossAppVerifiable; receipt.signerNote = sg.signerNote;
+          chain.push(receipt); tip = receipt.hash;
+          return receipt;
+        });
+      }
+    };
+  }
+
+  try { /* freeze constants */ } catch (e) {}
+  return {
+    VERSION: "1.0.0",
+    SCHEME: SCHEME,
+    COSIGN_KEYID: COSIGN_KEYID,
+    COSIGN_PUB_URL: COSIGN_PUB_URL,
+    PAYLOAD_TYPE: KHIPU_PAYLOAD_TYPE,
+    canonicalJSON: canonicalJSON,
+    sha256Hex: sha256Hex,
+    pae: pae,
+    chainHash: chainHash,
+    isCanonicalKey: isCanonicalKey,
+    signReceipt: signReceipt,
+    verifyEnvelope: verifyEnvelope,
+    newChain: newChain
+  };
+});