Add measured source attestation route

Dockerfile

@@ -23,6 +23,7 @@ WORKDIR /app
 
 # Self-contained server bundle, the vite-built SPA, and the REAL receipt/evidence chain.
 COPY dist/immune-server.js ./immune-server.js
+COPY dist/szl-source-attestation.mjs ./szl-source-attestation.mjs
 COPY dist/public ./public
 COPY dist/data ./data
 

dist/immune-server.js

@@ -1,4 +1,5 @@
 import { createRequire as __immuneCreateRequire } from 'node:module'; globalThis.require = globalThis.require || __immuneCreateRequire(import.meta.url);
+import { buildSourceAttestation } from "./szl-source-attestation.mjs";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -34263,10 +34264,34 @@ var __serverDir = path3.dirname(fileURLToPath(import.meta.url));
 var app = (0, import_express3.default)();
 app.disable("x-powered-by");
 app.set("trust proxy", 1);
+app.use((_req, res, next) => {
+  res.set("X-Content-Type-Options", "nosniff");
+  res.set("Referrer-Policy", "no-referrer");
+  res.set(
+    "Permissions-Policy",
+    "camera=(), microphone=(), geolocation=(), payment=(), usb=()"
+  );
+  next();
+});
 app.use(import_express3.default.json({ limit: "2mb" }));
 app.get("/healthz", (_req, res) => {
   res.json({ ok: true, service: "immune-standalone" });
 });
+app.get("/.well-known/szl-source.json", async (req, res) => {
+  const force = req.query.refresh === "1";
+  const document = await buildSourceAttestation({ force });
+  res.set("Cache-Control", "no-store");
+  res.set(
+    "Content-Security-Policy",
+    "default-src 'none'; frame-ancestors 'none'; base-uri 'none'"
+  );
+  res.set("Cross-Origin-Resource-Policy", "same-origin");
+  res.set("X-SZL-Transport-State", "REACHABLE");
+  res.set("X-SZL-Evidence-State", document.evidence_state);
+  res.set("X-SZL-Verification-State", "STRUCTURAL_ONLY");
+  res.set("X-SZL-Authority-State", "READ_ONLY");
+  res.json(document);
+});
 app.use("/api/immune", immune_default);
 app.use("/api", (_req, res) => {
   res.status(404).json({ error: "not found" });

dist/szl-source-attestation.mjs

@@ -0,0 +1,139 @@
+const SHA40 = /^[0-9a-f]{40}$/;
+const SPACE_ID = "SZLHOLDINGS/immune";
+const SOURCE_REFERENCE = {
+  repository: "szl-holdings/immune",
+  commit: "649e7bb87063f3a83dfa978e77c1359e4728ddd8",
+  path: "",
+  relation: "direct-mirror-declaration",
+  commit_state: "MEASURED_GITHUB_MAIN_REFERENCE",
+  build_source_state: "NOT_PROVEN"
+};
+const OVERLAY_BASE_REVISION = "f26b626ef36f09ca878d58ab70835c61ae4df24f";
+
+let cached = null;
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function validSha(value) {
+  const candidate = String(value || "").trim().toLowerCase();
+  return SHA40.test(candidate) ? candidate : null;
+}
+
+export function clearSourceAttestationCache() {
+  cached = null;
+}
+
+export async function measureHfHead({
+  force = false,
+  fetchImpl = globalThis.fetch,
+  env = process.env,
+  now = Date.now
+} = {}) {
+  const at = now();
+  if (!force && cached && at - cached.storedAt < 60_000) {
+    return { ...cached.measurement };
+  }
+
+  const envRevision = validSha(env.SPACE_REPOSITORY_COMMIT);
+  if (envRevision) {
+    const measurement = {
+      hf_revision: envRevision,
+      last_modified: null,
+      observed_at: nowIso(),
+      state: "MEASURED",
+      method: "SPACE_REPOSITORY_COMMIT",
+      resolver: "runtime environment",
+      semantics: "Exact commit exposed by the running Hugging Face Space."
+    };
+    cached = { storedAt: now(), measurement: { ...measurement } };
+    return measurement;
+  }
+
+  const endpoint =
+    `https://huggingface.co/api/spaces/${SPACE_ID}?expand[]=sha&expand[]=lastModified`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 4_000);
+  let measurement;
+  try {
+    const response = await fetchImpl(endpoint, {
+      headers: {
+        Accept: "application/json",
+        "User-Agent": "szl-immune-source-attestation/1.0"
+      },
+      signal: controller.signal
+    });
+    if (!response.ok) throw new Error(`HTTP_${response.status}`);
+    const payload = await response.json();
+    const revision = validSha(payload.sha);
+    measurement = {
+      hf_revision: revision,
+      last_modified:
+        typeof payload.lastModified === "string" ? payload.lastModified : null,
+      observed_at: nowIso(),
+      state: revision ? "MEASURED" : "UNAVAILABLE",
+      method: revision ? "HUGGINGFACE_API" : "UNAVAILABLE",
+      resolver: endpoint,
+      semantics:
+        "Measured Hugging Face repository head; not proof of a rolling process revision."
+    };
+  } catch (error) {
+    measurement = {
+      hf_revision: null,
+      last_modified: null,
+      observed_at: nowIso(),
+      state: "UNAVAILABLE",
+      method: "UNAVAILABLE",
+      resolver: endpoint,
+      error: error instanceof Error ? error.name : "Error",
+      semantics: "No revision guessed when measurement is unavailable."
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+  cached = { storedAt: now(), measurement: { ...measurement } };
+  return measurement;
+}
+
+export async function buildSourceAttestation(options = {}) {
+  const measurement = await measureHfHead(options);
+  return {
+    schema: "szl.deployment-source/v1",
+    source: { ...SOURCE_REFERENCE },
+    deployment: {
+      hf_space: SPACE_ID,
+      hf_revision: measurement.hf_revision
+    },
+    built_at: measurement.last_modified,
+    observed_at: measurement.observed_at,
+    transport_state: "REACHABLE",
+    evidence_state: measurement.hf_revision ? "COMPUTED" : "UNAVAILABLE",
+    verification_state: "STRUCTURAL_ONLY",
+    authority_state: "READ_ONLY",
+    alignment_state: "SOURCE_REFERENCE_ONLY",
+    attestation_state: "UNSIGNED_STRUCTURAL",
+    claims: {
+      github_parity: "NOT_CLAIMED",
+      reproducible_build: "NOT_CLAIMED",
+      running_process_revision:
+        measurement.method === "SPACE_REPOSITORY_COMMIT"
+          ? "MEASURED_FROM_RUNTIME_ENVIRONMENT"
+          : "NOT_CLAIMED"
+    },
+    extensions: {
+      schema: "szl.deployment-source-evidence/v1",
+      deployment_revision_evidence: measurement,
+      overlay: {
+        base_revision: OVERLAY_BASE_REVISION,
+        base_revision_semantics:
+          "Hugging Face head inspected before this attestation overlay."
+      }
+    },
+    limits: [
+      "The GitHub commit is a measured source reference, not asserted build provenance.",
+      "Repository-head evidence does not establish deployed-artifact equivalence.",
+      "This unsigned structural document does not establish SLSA provenance or reproducible builds."
+    ]
+  };
+}

tests/test-source-attestation.mjs

@@ -0,0 +1,75 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  buildSourceAttestation,
+  clearSourceAttestationCache,
+  measureHfHead
+} from "../dist/szl-source-attestation.mjs";
+
+test("runtime revision is measured without parity overclaim", async () => {
+  clearSourceAttestationCache();
+  const revision = "a".repeat(40);
+  const document = await buildSourceAttestation({
+    force: true,
+    env: { SPACE_REPOSITORY_COMMIT: revision }
+  });
+  assert.equal(document.deployment.hf_revision, revision);
+  assert.equal(document.verification_state, "STRUCTURAL_ONLY");
+  assert.equal(document.authority_state, "READ_ONLY");
+  assert.equal(document.claims.github_parity, "NOT_CLAIMED");
+  assert.equal(document.claims.reproducible_build, "NOT_CLAIMED");
+  assert.equal(
+    document.claims.running_process_revision,
+    "MEASURED_FROM_RUNTIME_ENVIRONMENT"
+  );
+});
+
+test("Hub API fallback reports repository-head semantics", async () => {
+  clearSourceAttestationCache();
+  const revision = "b".repeat(40);
+  const fetchImpl = async () => ({
+    ok: true,
+    json: async () => ({
+      sha: revision,
+      lastModified: "2026-07-11T22:00:00.000Z"
+    })
+  });
+  const measurement = await measureHfHead({
+    force: true,
+    env: {},
+    fetchImpl
+  });
+  assert.equal(measurement.hf_revision, revision);
+  assert.equal(measurement.method, "HUGGINGFACE_API");
+  assert.match(measurement.semantics, /repository head/);
+});
+
+test("measurement failure never invents a revision", async () => {
+  clearSourceAttestationCache();
+  const measurement = await measureHfHead({
+    force: true,
+    env: {},
+    fetchImpl: async () => {
+      throw new Error("offline");
+    }
+  });
+  assert.equal(measurement.hf_revision, null);
+  assert.equal(measurement.state, "UNAVAILABLE");
+});
+
+test("well-known route precedes API and SPA fallbacks", async () => {
+  const fs = await import("node:fs/promises");
+  const server = await fs.readFile(
+    new URL("../dist/immune-server.js", import.meta.url),
+    "utf8"
+  );
+  assert.ok(
+    server.indexOf('app.get("/.well-known/szl-source.json"') <
+      server.indexOf('app.use("/api/immune"')
+  );
+  assert.ok(
+    server.indexOf('app.get("/.well-known/szl-source.json"') <
+      server.indexOf('app.get("/{*splat}"')
+  );
+  assert.match(server, /Cache-Control", "no-store"/);
+});