@byollm/conformance 0.1.0-alpha.8 → 0.1.0-alpha.81

package/README.md

@@ -1,5 +1,5 @@
 > [!WARNING]
-> **Alpha (`0.1.0-alpha.8`) — under active development. Don't use this yet.**
+> **Alpha (`0.1.0-alpha.81`) — under active development. Don't use this yet.**
 >
 > Install it deliberately: `npm install @byollm/conformance@alpha`.
 >
@@ -11,7 +11,109 @@
 > npm assigns `latest` on a first publish and won't let it be removed, so a
 > bare install resolves here too. This notice is the only guard — deliberately
 > not an npm deprecation, which would read as *abandoned* rather than *early*.
-> Ask for `@alpha` explicitly so your lockfile records that you meant to.
+> Ask for `@alpha` explicitly so your lockfile records that you meant to.>
+> **`alpha.15` is a breaking wire change, and it breaks daemons and relays —
+> not app authors.** If you call `app.enqueue(...)` and read results, nothing
+> in your code changes. If you run a daemon or an upstream, every package must
+> move together: a mixed pair refuses on both sides, because both ends parse
+> `.strict()`.
+>
+> What moved, all of it reconciling the frozen `byollm_009` with its code:
+> `JobStub` gains `site` (the site's identity key id) and loses
+> `audienceAllow`; `ResultRequest` gains `leaseId`; `HeartbeatResponse` loses
+> `leases`, which nothing read; `WireErrorCode` gains `not-ready`,
+> `clock-skew` and `forbidden`, and `403` is `forbidden` rather than
+> `unauthorized`. `RESULT_PROVENANCE` is superseded by
+> `PROVENANCE_NAMES_DEVICE`. See `byollm_009` Amendment A.>
+> **`alpha.16` is a breaking wire change — daemons and relays again, not app
+> authors.** `app.enqueue(...)` and reading results are unchanged. All five
+> packages move together: both ends parse `.strict()`, so a mixed pair
+> refuses.
+>
+> What moved, all of it Tier 2 of `cloud_008`: `model`, `backendClass` and
+> `durationMs` come off `ResultRequest` and are sealed **inside** the result
+> envelope as `SealedOutcome = { outcome, ran }` — so a daemon can no longer
+> declare a model it did not sign, and a relay carries neither.
+> `HeartbeatResponse` loses `leases` (nothing read it) and now reports real
+> cancellations instead of an empty list. `WireErrorCode` gains `forbidden`
+> for 403, leaving `unauthorized` at exactly 401. The relay gained a
+> site-plane `cancel` endpoint, honours `stub.deadlineAt`, honours
+> `stub.audience`, and remembers a refusal.>
+> **`alpha.17` is additive** — no wire change. It exports `ReleaseReason`,
+> which `RoutingStore.releaseLeases` names and the package did not export, so
+> the interface was unimplementable outside this repo.>
+> **`alpha.18` is a breaking wire change — daemons and relays, not app
+> authors.** `app.enqueue(...)` and reading results are unchanged. All five
+> packages move together.
+>
+> The **bearer token is gone**: off `PairPollResponse`, off the runner row,
+> off the daemon's pairings file, out of the adapter's schema. It was minted,
+> hashed and stored on two disks and never sent, looked up or compared —
+> `REQUESTS_SIGNED_NOT_BEARER` was enforced by signatures the whole time. If
+> you run the Supabase adapter, apply
+> `20260819000000_drop_runner_token.sql`; `byollm_approve_pairing` now takes
+> one argument. A pairings file written by an older daemon still loads.
+>
+> `model`, `backendClass` and `durationMs` moved **inside** the sealed result
+> (`SealedOutcome = { outcome, ran }`), so a daemon cannot declare a model it
+> did not sign and a relay carries none of them. Writing a `RoutingStore`?
+> `releaseLeases` takes an optional `reason` and `complete` requires
+> `leaseId`, and **an implementation that ignores either still typechecks** —
+> run the store contract tests.>
+> **`alpha.19` is additive on the wire and a behaviour change in every
+> store.** `ResultResponse` gains an optional `duplicate`. Nothing is removed,
+> so an older daemon keeps working — but the *order* two rules are checked in
+> has changed, and a `RoutingStore` implementation must change with it.
+>
+> `complete` now checks **terminal state before holder**, scoped to the device
+> that finished the job: a replay from that device is answered `duplicate:
+> true` with a 2xx, and anyone else gets exactly the refusal they would get
+> for a job that is not terminal. Previously `RESULT_IDEMPOTENT` held only
+> because the lease is nulled on success, so the holder check tripped first —
+> deleting the idempotency branch failed no test. Run the store contract
+> tests; the compiler cannot see this.
+
+<!-- release-note 0.1.0-alpha.21 -->
+> [!NOTE]
+> **`0.1.0-alpha.20` is not a complete release — do not pin it.** Four
+> packages published and `@byollm/server` did not: a Sigstore
+> transparency-log 409 on its provenance attestation. The workflow's
+> "already published" guard correctly refuses to resume a partial publish,
+> so `0.1.0-alpha.21` is that release, whole.
+>
+> If you run the Supabase adapter, `alpha.21` needs
+> `20260819010000_completed_by_lease_id.sql`: alpha.19 shipped §3.6's
+> ordering without the column it stores the grant in.
+
+<!-- release-note 0.1.0-alpha.40 -->
+**`byollm install` — stop keeping a terminal open.** The daemon can now run
+under your computer's own supervisor and restart itself if it stops: a launchd
+agent on macOS, a `systemd --user` unit on Linux, a logon task on Windows. All
+user-level — no root, no system directories, and `byollm uninstall` takes it
+away. `byollm status` gained a line saying whether it is actually supervised
+right now, including the state that matters most: installed but not running,
+which looks fine from an app's dashboard and serves nothing.
+
+If you are running via `npx`, install properly first (`npm install -g
+byollm@alpha`) — `install` refuses to supervise a copy in npx's cache, because
+npm deletes that directory and the service would fail at some later boot.
+
+<!-- release-note 0.1.0-alpha.41 -->
+**`onNoRunner` takes a string.** Your fallback answer is your own value, not
+wire data, and handing back a whole result record for it was ceremony — the
+README's own example got the shape wrong, which is how this was found.
+
+```ts
+const { outcome, fallback } = await job.result({
+  onNoRunner: () => runOnHostedModel(transcript),
+});
+```
+
+Whatever you return, `result()` labels it `fallback: true` — the stamp is
+applied by the wait, not taken from you, so an answer that did not run on
+somebody's device cannot be reported as though it did (`FALLBACK_LABELED`).
+Both delivery channels do it, polling and Supabase Realtime. Records still
+work; they just get labelled too.
 
 # `@byollm/conformance`
 
@@ -29,7 +131,7 @@ byollm conformance — my server
   ✓ C001_PAIRING_BINDS_ONE_USER  a runner token is bound to exactly the approving user  (279ms)
   ✓ C002_JOB_ROUND_TRIP  an enqueued job runs on the owner's daemon and the result comes back  (83ms)
   …
-  16 checks passed — my server is byollm-compatible.
+  32 checks passed — my server is byollm-compatible.
 ```
 
 ## What it actually does
@@ -79,7 +181,7 @@ Two optional hooks worth knowing about:
 
 - **`ownerId`** exists because owner ids are server-namespace-local. A target
   backed by real auth uses uuids, not names, and a kit that assumed names
-  round-tripped would be assuming away the very thing the `named` allowlist is
+  round-tripped would be assuming away the very thing the `team` allowlist is
   about.
 - **`advanceTime`** lets an in-memory server run the lease and TTL checks in
   milliseconds. A real Postgres cannot fake its clock, so the kit waits for
@@ -95,7 +197,7 @@ Two optional hooks worth knowing about:
 | `C003_UNKNOWN_KIND_REFUSED`            | a daemon is never handed a kind it did not advertise         |
 | `C004_LEASE_RECLAIM`                   | a job whose runner vanished is offered again, losing nothing |
 | `C005_AUDIENCE_MATRIX`                 | all nine audience × offer-scope combinations                 |
-| `C006_NAMED_LOCAL_ALLOWLIST`           | `named` runs only once the daemon's own list admits it       |
+| `C006_NAMED_LOCAL_ALLOWLIST`           | `team` runs only once the daemon's own list admits it        |
 | `C007_SUBSCRIPTION_SELF_LOCK`          | a subscription backend refuses others' work at any scope     |
 | `C008_REVOCATION`                      | a revoked daemon stops mid-queue                             |
 | `C009_CANCEL_MID_FLIGHT`               | cancel aborts a running job's backend call                   |

package/dist/audit-cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/audit-cli.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import {
+  auditDeployment,
+  formatPostureReport
+} from "./chunk-2EJHYOQS.js";
+
+// src/audit-cli.ts
+var [url, basePath, originAddress] = process.argv.slice(2);
+if (url === void 0) {
+  process.stderr.write(
+    "usage: byollm-audit-deployment <url> [base-path] [origin-address]\n  e.g. byollm-audit-deployment https://hub.byollm.cloud\n"
+  );
+  process.exit(2);
+}
+var report = await auditDeployment({
+  url,
+  ...basePath === void 0 ? {} : { basePath },
+  // `D008` asks the origin directly. Without it that check says so rather
+  // than guessing an address and reporting a posture it never tested.
+  ...originAddress === void 0 ? {} : { originAddress }
+});
+process.stdout.write(`
+${formatPostureReport(report)}`);
+process.exit(report.passed ? 0 : 1);
+//# sourceMappingURL=audit-cli.js.map

package/dist/audit-cli.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/audit-cli.ts"],"sourcesContent":["#!/usr/bin/env node\nimport { auditDeployment, formatPostureReport } from \"./deployment.js\";\n\n/**\n * `byollm-audit-deployment <url>` — what a stranger can do to a running relay.\n *\n * Distinct from `byollm-certify`, which drives a real daemon against a target\n * that may be an in-process handler. This one has a URL and nothing else,\n * which is exactly what an attacker has, and it exists because eight\n * freeze-gate findings came from a suite in which nothing was ever a stranger.\n *\n * ```bash\n * npx byollm-audit-deployment https://hub.byollm.cloud\n * ```\n *\n * Safe to run against production: nothing writes, nothing floods, and every\n * request is one an ordinary scanner would make.\n */\nconst [url, basePath, originAddress] = process.argv.slice(2);\n\nif (url === undefined) {\n  process.stderr.write(\n    \"usage: byollm-audit-deployment <url> [base-path] [origin-address]\\n\" +\n      \"  e.g. byollm-audit-deployment https://hub.byollm.cloud\\n\",\n  );\n  process.exit(2);\n}\n\nconst report = await auditDeployment({\n  url,\n  ...(basePath === undefined ? {} : { basePath }),\n  // `D008` asks the origin directly. Without it that check says so rather\n  // than guessing an address and reporting a posture it never tested.\n  ...(originAddress === undefined ? {} : { originAddress }),\n});\nprocess.stdout.write(`\\n${formatPostureReport(report)}`);\nprocess.exit(report.passed ? 0 : 1);\n"],"mappings":";;;;;;;AAkBA,IAAM,CAAC,KAAK,UAAU,aAAa,IAAI,QAAQ,KAAK,MAAM,CAAC;AAE3D,IAAI,QAAQ,QAAW;AACrB,UAAQ,OAAO;AAAA,IACb;AAAA,EAEF;AACA,UAAQ,KAAK,CAAC;AAChB;AAEA,IAAM,SAAS,MAAM,gBAAgB;AAAA,EACnC;AAAA,EACA,GAAI,aAAa,SAAY,CAAC,IAAI,EAAE,SAAS;AAAA;AAAA;AAAA,EAG7C,GAAI,kBAAkB,SAAY,CAAC,IAAI,EAAE,cAAc;AACzD,CAAC;AACD,QAAQ,OAAO,MAAM;AAAA,EAAK,oBAAoB,MAAM,CAAC,EAAE;AACvD,QAAQ,KAAK,OAAO,SAAS,IAAI,CAAC;","names":[]}

package/dist/chunk-2EJHYOQS.js

@@ -0,0 +1,469 @@
+// src/deployment.ts
+import { connect as tlsConnect } from "tls";
+import { request as httpsRequest } from "https";
+import {
+  PROTOCOL_VERSION,
+  generateKeys,
+  signRequest,
+  signSiteRequest
+} from "@byollm/protocol";
+var STUB = {
+  id: "posture-probe",
+  kind: "llm.generate",
+  owner: "nobody",
+  audience: "private",
+  sizeClass: "small",
+  streaming: false,
+  // Far enough out that a deployment cannot pass by calling it expired.
+  deadlineAt: 41024448e5
+};
+var REFUSED = /* @__PURE__ */ new Set([401, 403, 404]);
+async function refusedByByollm(response) {
+  if (!REFUSED.has(response.status)) {
+    return { ok: false, why: `answered ${String(response.status)}` };
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    return {
+      ok: false,
+      why: `answered ${String(response.status)} but not as byollm \u2014 something else is serving this path`
+    };
+  }
+  const shaped = typeof body === "object" && body !== null && typeof body.error === "string";
+  return shaped ? { ok: true, why: `answered ${String(response.status)}` } : {
+    ok: false,
+    why: `answered ${String(response.status)} with a body byollm would not send \u2014 something else is serving this path`
+  };
+}
+var outcome = (passed, detail) => ({
+  passed,
+  detail
+});
+async function servedCertificate(address, host) {
+  return new Promise((resolve) => {
+    const socket = tlsConnect(
+      {
+        host: address,
+        servername: host,
+        port: 443,
+        timeout: 15e3,
+        rejectUnauthorized: false
+      },
+      () => {
+        const peer = socket.getPeerCertificate();
+        const alt = (peer.subjectaltname ?? "").split(",").map((entry) => entry.trim().replace(/^DNS:/, "")).filter((entry) => entry.length > 0);
+        const cn = peer.subject.CN;
+        socket.end();
+        resolve({
+          names: alt.length > 0 ? alt : [typeof cn === "string" ? cn : ""],
+          validTo: peer.valid_to
+        });
+      }
+    );
+    socket.on("error", () => {
+      resolve(void 0);
+    });
+    socket.on("timeout", () => {
+      socket.destroy();
+      resolve(void 0);
+    });
+  });
+}
+var POSTURE_CHECKS = Object.freeze([
+  {
+    id: "D001_SITE_ENQUEUE_REFUSES_UNSIGNED",
+    title: "an anonymous caller cannot enqueue work in a site's name",
+    cites: ["REQUESTS_SIGNED_NOT_BEARER"],
+    async run({ origin, fetch: f }) {
+      const response = await f(`${origin}/relay/site/enqueue`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        // The version, because the auditor is a site-plane client like any
+        // other (§B.4). Without it the relay refuses on the handshake and
+        // this check would report "refused" for a reason that has nothing to
+        // do with signatures — success for an unrelated reason, which is the
+        // failure this whole file was written against.
+        body: JSON.stringify({
+          protocolVersion: PROTOCOL_VERSION,
+          siteId: "any-site",
+          stub: STUB
+        })
+      });
+      const refusal = await refusedByByollm(response);
+      return outcome(refusal.ok, `POST /relay/site/enqueue ${refusal.why}`);
+    }
+  },
+  {
+    id: "D002_SITE_READS_REFUSE_UNSIGNED",
+    title: "an anonymous caller cannot read who is online",
+    cites: ["REQUESTS_SIGNED_NOT_BEARER"],
+    async run({ origin, fetch: f }) {
+      const why = [];
+      let ok = true;
+      for (const path of ["pending", "results"]) {
+        const response = await f(
+          `${origin}/relay/site/${path}?siteId=any-site&protocolVersion=${PROTOCOL_VERSION}`
+        );
+        const refusal = await refusedByByollm(response);
+        ok &&= refusal.ok;
+        why.push(`${path} ${refusal.why}`);
+      }
+      return outcome(ok, why.join("; "));
+    }
+  },
+  {
+    id: "D003_DAEMON_PLANE_REFUSES_UNSIGNED",
+    title: "an anonymous caller cannot claim work",
+    cites: ["REQUESTS_SIGNED_NOT_BEARER", "CLAIM_REQUIRES_CAPABILITY"],
+    async run({ origin, basePath, fetch: f }) {
+      const response = await f(`${origin}${basePath}/claim`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          protocolVersion: PROTOCOL_VERSION,
+          runnerId: "nobody",
+          max: 1,
+          capabilities: [{ kind: "llm.generate", models: ["any"] }]
+        })
+      });
+      const refusal = await refusedByByollm(response);
+      return outcome(refusal.ok, `POST ${basePath}/claim ${refusal.why}`);
+    }
+  },
+  {
+    id: "D004_REFUSES_A_STRANGER_S_VALID_SIGNATURE",
+    title: "a well-formed signature from an unknown key is not enough",
+    cites: ["REQUESTS_SIGNED_NOT_BEARER", "KEYS_EXCHANGED_AT_CONSENT"],
+    async run({ origin, basePath, fetch: f }) {
+      const stranger = generateKeys(Date.now());
+      const now = Date.now();
+      const siteBody = JSON.stringify({
+        protocolVersion: PROTOCOL_VERSION,
+        siteId: "any-site",
+        stub: STUB
+      });
+      const siteSignature = signSiteRequest(stranger, {
+        endpoint: "enqueue",
+        siteId: "any-site",
+        issuedAt: now,
+        body: siteBody
+      });
+      const site = await f(`${origin}/relay/site/enqueue`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "x-byollm-site": "any-site",
+          "x-byollm-issued-at": String(siteSignature.issuedAt),
+          "x-byollm-signature": siteSignature.signature
+        },
+        body: siteBody
+      });
+      const daemonBody = JSON.stringify({
+        protocolVersion: PROTOCOL_VERSION,
+        runnerId: "nobody",
+        max: 1,
+        capabilities: [{ kind: "llm.generate", models: ["any"] }]
+      });
+      const daemonSignature = signRequest(stranger, {
+        endpoint: "claim",
+        runnerId: "nobody",
+        issuedAt: now,
+        body: daemonBody
+      });
+      const daemon = await f(`${origin}${basePath}/claim`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "x-byollm-runner": "nobody",
+          "x-byollm-issued-at": String(daemonSignature.issuedAt),
+          "x-byollm-signature": daemonSignature.signature
+        },
+        body: daemonBody
+      });
+      const siteRefusal = await refusedByByollm(site);
+      const daemonRefusal = await refusedByByollm(daemon);
+      return outcome(
+        siteRefusal.ok && daemonRefusal.ok,
+        `signed by a stranger: site ${siteRefusal.why}, daemon ${daemonRefusal.why}`
+      );
+    }
+  },
+  {
+    id: "D011_VERSION_NAMED_ON_BOTH_PLANES",
+    title: "an unknown protocol version is refused by name, not by accident",
+    cites: ["VERSION_HANDSHAKE_REQUIRED"],
+    async run({ origin, fetch: f }) {
+      const probes = [
+        {
+          where: "daemon",
+          response: await f(`${origin}/byollm/claim`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ protocolVersion: "99", max: 1 })
+          })
+        },
+        {
+          where: "site",
+          response: await f(`${origin}/relay/site/enqueue`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+              protocolVersion: "99",
+              siteId: "any-site",
+              stub: STUB
+            })
+          })
+        }
+      ];
+      const wrong = [];
+      for (const probe of probes) {
+        let body = {};
+        try {
+          body = await probe.response.json();
+        } catch {
+          wrong.push(
+            `${probe.where}: answered ${String(probe.response.status)} and not as byollm`
+          );
+          continue;
+        }
+        if (body.error !== "unsupported-protocol-version") {
+          wrong.push(
+            `${probe.where}: answered ${String(probe.response.status)} ${String(body.error)}`
+          );
+          continue;
+        }
+        if (!Array.isArray(body.supported)) {
+          wrong.push(`${probe.where}: refused without naming what it speaks`);
+        }
+      }
+      return outcome(
+        wrong.length === 0,
+        wrong.length === 0 ? "both planes name the version they speak" : wrong.join("; ")
+      );
+    }
+  },
+  {
+    id: "D005_NO_DEBUG_SURFACE",
+    title: "the debug page is not on the internet",
+    cites: [],
+    async run({ origin, basePath, fetch: f }) {
+      const paths = ["/debug", `${basePath}/debug`];
+      const statuses = [];
+      for (const path of paths) {
+        const response = await f(`${origin}${path}`);
+        statuses.push(response.status);
+      }
+      return outcome(
+        // **Not merely "not 200"** — cloud_009 §3 made the page per-site, so
+        // an enabled one answers a probe with no site id `400` rather than
+        // rendering. A check that accepted anything but 200 would pass
+        // against a deployment whose debug page is one query parameter away,
+        // which is finding eleven with a shorter walk.
+        //
+        // `404` is the only answer that means the route does not exist. The
+        // reference relay says exactly that when its debug page is off, and
+        // says `400` when it is on and the caller named no site.
+        statuses.every((status) => status === 404),
+        `debug paths answered ${statuses.map(String).join("/")}`
+      );
+    }
+  },
+  {
+    id: "D006_NO_PATH_DISPATCH",
+    title: "a handler cannot be reached by dressing a path up to look like it",
+    cites: ["REQUESTS_SIGNED_NOT_BEARER"],
+    async run({ origin, fetch: f }) {
+      const response = await f(`${origin}/literally/anything/claim`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ protocolVersion: PROTOCOL_VERSION, max: 1 })
+      });
+      const refusal = await refusedByByollm(response);
+      return outcome(
+        refusal.ok && response.status === 404,
+        `POST /literally/anything/claim ${refusal.why}`
+      );
+    }
+  },
+  {
+    id: "D007_TLS_ONLY",
+    title: "the deployment is reached over TLS, and plaintext is not served",
+    cites: [],
+    async run({ origin, fetch: f }) {
+      if (!origin.startsWith("https://")) {
+        return outcome(false, `origin is ${origin} \u2014 this audit saw no TLS`);
+      }
+      const plain = origin.replace("https://", "http://");
+      const response = await f(`${plain}/healthz`, { redirect: "manual" });
+      const redirected = response.status >= 300 && response.status < 400 && (response.headers.get("location") ?? "").startsWith("https://");
+      return outcome(
+        redirected || REFUSED.has(response.status),
+        `plaintext answered ${String(response.status)}${redirected ? " and redirects to https" : ""}`
+      );
+    }
+  },
+  {
+    id: "D008_ORIGIN_NOT_PUBLIC",
+    title: "the origin answers the edge, and nobody else",
+    cites: [],
+    async run({ origin, originAddress }) {
+      if (originAddress === void 0) {
+        return outcome(
+          false,
+          "no origin address given \u2014 this posture was not measured (pass the origin's address as the third argument)"
+        );
+      }
+      const host = new URL(origin).host;
+      const status = await new Promise((resolve) => {
+        const request = httpsRequest(
+          {
+            host: originAddress,
+            servername: host,
+            headers: { host },
+            path: "/readyz",
+            method: "GET",
+            rejectUnauthorized: false,
+            timeout: 15e3
+          },
+          (response) => {
+            response.resume();
+            resolve(response.statusCode ?? 0);
+          }
+        );
+        request.on("error", () => {
+          resolve("refused");
+        });
+        request.on("timeout", () => {
+          request.destroy();
+          resolve("refused");
+        });
+        request.end();
+      });
+      if (status === "refused") {
+        return outcome(true, "the origin address refused the connection");
+      }
+      return outcome(
+        status === 403,
+        `the origin answered ${String(status)} to a direct request`
+      );
+    }
+  },
+  {
+    id: "D009_CERT_NAMES_THE_PINNED_HOST",
+    title: "the certificate names the hostname daemons pin",
+    cites: [],
+    async run({ origin, originAddress }) {
+      const host = new URL(origin).host;
+      if (originAddress === void 0) {
+        return outcome(
+          false,
+          "no origin address given \u2014 this posture was not measured. Asking the hostname reads the edge's certificate, which names it by construction and proves nothing about the origin"
+        );
+      }
+      const served = await servedCertificate(originAddress, host);
+      const names = served?.names;
+      if (names === void 0) {
+        return outcome(
+          false,
+          `could not read a certificate from ${originAddress}`
+        );
+      }
+      const covered = names.some(
+        (name) => name === host || name.startsWith("*.") && host.endsWith(name.slice(1))
+      );
+      return outcome(
+        covered,
+        covered ? `served a certificate naming ${host}` : `the certificate names ${names.join(", ")} \u2014 not ${host}`
+      );
+    }
+  },
+  {
+    id: "D010_CERT_HAS_LIFE_LEFT",
+    title: "the certificate is not about to expire",
+    cites: [],
+    async run({ origin, originAddress }) {
+      const host = new URL(origin).host;
+      if (originAddress === void 0) {
+        return outcome(
+          false,
+          "no origin address given \u2014 this posture was not measured (the edge's certificate is Cloudflare's to renew, not ours)"
+        );
+      }
+      const served = await servedCertificate(originAddress, host);
+      if (served === void 0) {
+        return outcome(
+          false,
+          `could not read a certificate from ${originAddress}`
+        );
+      }
+      const days = Math.round(
+        (Date.parse(served.validTo) - Date.now()) / 864e5
+      );
+      return outcome(
+        days > 90,
+        `the certificate expires ${served.validTo} (${String(days)} days)`
+      );
+    }
+  }
+]);
+async function auditDeployment(options) {
+  const origin = options.url.replace(/\/+$/, "");
+  const context = {
+    origin,
+    basePath: (options.basePath ?? "/byollm").replace(/\/+$/, ""),
+    ...options.originAddress === void 0 ? {} : { originAddress: options.originAddress },
+    fetch: options.fetch ?? globalThis.fetch
+  };
+  const results = [];
+  for (const check of POSTURE_CHECKS) {
+    let result;
+    try {
+      result = { ...await check.run(context), ...describe(check) };
+    } catch (error) {
+      result = {
+        ...describe(check),
+        passed: false,
+        detail: `the probe failed: ${error instanceof Error ? error.message : "unknown"}`
+      };
+    }
+    results.push(result);
+    options.onProgress?.(result);
+  }
+  return {
+    origin,
+    passed: results.every((result) => result.passed),
+    results
+  };
+}
+var describe = (check) => ({
+  id: check.id,
+  title: check.title,
+  cites: check.cites
+});
+function formatPostureReport(report) {
+  const lines = [`deployment posture \u2014 ${report.origin}`, ""];
+  for (const result of report.results) {
+    lines.push(`  ${result.passed ? "ok  " : "FAIL"}  ${result.id}`);
+    lines.push(`        ${result.title}`);
+    lines.push(`        ${result.detail}`);
+    if (result.cites.length > 0) {
+      lines.push(`        cites ${result.cites.join(", ")}`);
+    }
+  }
+  const passed = report.results.filter((result) => result.passed).length;
+  lines.push(
+    "",
+    report.passed ? `${String(passed)}/${String(report.results.length)} \u2014 a stranger got nowhere.` : `${String(passed)}/${String(report.results.length)} \u2014 a stranger got somewhere. See FAIL above.`,
+    ""
+  );
+  return lines.join("\n");
+}
+
+export {
+  POSTURE_CHECKS,
+  auditDeployment,
+  formatPostureReport
+};
+//# sourceMappingURL=chunk-2EJHYOQS.js.map