@byollm/conformance 0.1.0-alpha.2 → 0.1.0-alpha.21

package/dist/chunk-PDQJJ3Q2.js

@@ -1,880 +0,0 @@
-// src/checks.ts
-import { AUDIENCES, OFFER_SCOPES } from "@byollm/protocol";
-
-// src/harness.ts
-import { mkdtemp, rm } from "fs/promises";
-import { tmpdir } from "os";
-import { join } from "path";
-import {
-  Allowlist,
-  Budgets,
-  IngressLog,
-  ProtocolClient,
-  Runner,
-  connect,
-  resolveConfig,
-  DaemonConfig
-} from "byollm";
-var EchoBackend = class {
-  id = "openai-http";
-  class = "http";
-  /** Prompts this backend was asked to run, in order. */
-  seen = [];
-  /** Set to make the next call hang, for lease and cancel checks. */
-  hangMs = 0;
-  health() {
-    return Promise.resolve({ healthy: true, models: ["echo-model"] });
-  }
-  async execute(request) {
-    this.seen.push(request.prompt);
-    const started = Date.now();
-    if (this.hangMs > 0) {
-      const hung = request.signal.aborted ? "aborted" : await new Promise((resolve) => {
-        const timer = setTimeout(() => {
-          resolve("done");
-        }, this.hangMs);
-        request.signal.addEventListener(
-          "abort",
-          () => {
-            clearTimeout(timer);
-            resolve("aborted");
-          },
-          { once: true }
-        );
-      });
-      if (hung === "aborted") {
-        return {
-          ok: false,
-          code: "canceled",
-          message: "the job was canceled",
-          retryable: false,
-          durationMs: Date.now() - started
-        };
-      }
-    }
-    return {
-      ok: true,
-      text: `echo: ${request.prompt}`,
-      durationMs: Date.now() - started
-    };
-  }
-};
-function daemonConfig(options) {
-  const backendId = options.subscription ? "claude-cli" : "openai-http";
-  return resolveConfig(
-    DaemonConfig.parse({
-      backends: {
-        primary: {
-          backend: backendId,
-          ...options.subscription ? {} : { baseUrl: "http://127.0.0.1:11434/v1" },
-          offer: options.offer
-        }
-      },
-      routes: {
-        "llm.generate": { backend: "primary", model: "echo-model" },
-        "llm.chat": { backend: "primary", model: "echo-model" }
-      },
-      concurrency: 4
-    })
-  );
-}
-async function pairDaemon(target, options) {
-  const home = await mkdtemp(join(tmpdir(), "byollm-conformance-"));
-  const loaded = daemonConfig({
-    offer: options.offer ?? "self",
-    subscription: options.subscription ?? false
-  });
-  const allowlist = new Allowlist(join(home, "allow.json"));
-  await allowlist.load();
-  const budgets = new Budgets(
-    join(home, "budgets.json"),
-    loaded.config.community
-  );
-  await budgets.load(Date.now());
-  const ingress = new IngressLog({
-    path: join(home, "ingress.log"),
-    communityPromptDays: 7,
-    keepSelfPrompts: true
-  });
-  const backend = new EchoBackend();
-  const fetchImpl = (input, init) => target.fetch(new Request(input, init));
-  const capabilities = loaded.routes.map((route) => ({
-    kind: route.kind,
-    backendId: route.backendId,
-    backendClass: route.backendClass,
-    model: route.model,
-    offerScope: route.offerScope
-  }));
-  const pairingClient = new ProtocolClient({
-    origin: target.origin,
-    fetch: fetchImpl
-  });
-  let userCode = "";
-  const pairingAbort = new AbortController();
-  let pairingError;
-  const pairing = connect({
-    client: pairingClient,
-    daemonVersion: "conformance",
-    label: options.label ?? `daemon-${options.owner}`,
-    capabilities,
-    onCode: (info) => {
-      userCode = info.userCode;
-    },
-    // A real macrotask, not `Promise.resolve()`: a zero-delay microtask loop
-    // never yields to the event loop, so the approval below could never run
-    // and the poll would spin until the process died.
-    sleep: () => sleep(1),
-    signal: pairingAbort.signal
-  }).catch((error) => {
-    pairingError = error;
-    return { ok: false, reason: "aborted", message: "" };
-  });
-  try {
-    await waitFor(() => userCode !== "", { what: "a pairing code" });
-    await target.approvePairing(userCode, options.owner);
-  } catch (error) {
-    pairingAbort.abort();
-    await pairing;
-    await rm(home, { recursive: true, force: true });
-    throw error;
-  }
-  const result = await pairing;
-  if (!result.ok) {
-    pairingAbort.abort();
-    await rm(home, { recursive: true, force: true });
-    throw new Error(
-      `conformance harness could not pair: ${pairingError instanceof Error ? pairingError.message : result.message}`
-    );
-  }
-  const runner = new Runner({
-    client: new ProtocolClient({
-      origin: target.origin,
-      token: result.pairing.token,
-      fetch: fetchImpl
-    }),
-    runnerId: result.pairing.runnerId,
-    owner: result.pairing.owner,
-    daemonVersion: "conformance",
-    loaded,
-    allowlist,
-    budgets,
-    ingress,
-    backendFactory: () => backend
-  });
-  return {
-    runner,
-    backend,
-    allowlist,
-    runnerId: result.pairing.runnerId,
-    owner: result.pairing.owner,
-    home,
-    ingress,
-    dispose: async () => {
-      runner.cancelAll();
-      await waitFor(() => runner.status().activeJobs === 0, {
-        timeoutMs: 2e3,
-        what: "in-flight jobs to unwind"
-      }).catch(() => void 0);
-      await rm(home, { recursive: true, force: true });
-    },
-    abandon: async () => {
-      await rm(home, { recursive: true, force: true });
-    }
-  };
-}
-async function ownerIdFor(target, name) {
-  return target.ownerId ? target.ownerId(name) : name;
-}
-async function waitFor(predicate, options = {}) {
-  const timeoutMs = options.timeoutMs ?? 5e3;
-  const intervalMs = options.intervalMs ?? 10;
-  const deadline = Date.now() + timeoutMs;
-  for (; ; ) {
-    if (await predicate()) return;
-    if (Date.now() >= deadline) {
-      throw new Error(
-        `timed out after ${String(timeoutMs)}ms waiting for ${options.what ?? "a condition"}`
-      );
-    }
-    await sleep(intervalMs);
-  }
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function advance(target, ms) {
-  if (target.advanceTime) {
-    await target.advanceTime(ms);
-  } else {
-    await sleep(ms);
-  }
-  await target.sweep();
-}
-
-// src/checks.ts
-function assert(condition, message) {
-  if (!condition) throw new Error(message);
-}
-var prompt = (text = "hello") => ({ prompt: text });
-var CHECKS = [
-  {
-    id: "C001_PAIRING_BINDS_ONE_USER",
-    title: "a runner token is bound to exactly the approving user",
-    musts: ["PAIR_ONE_USER", "PAIR_INTERACTIVE"],
-    async run(target) {
-      const alice = await pairDaemon(target, { owner: "alice" });
-      try {
-        assert(
-          alice.owner === await ownerIdFor(target, "alice"),
-          `runner was bound to "${alice.owner}", not to the approving user`
-        );
-        const bob = await pairDaemon(target, { owner: "bob" });
-        assert(
-          bob.owner !== alice.owner,
-          "two different approvers produced the same runner owner"
-        );
-        try {
-          const job = await target.enqueue({
-            kind: "llm.generate",
-            payload: prompt("alice's private prompt"),
-            owner: "alice",
-            audience: "self"
-          });
-          await bob.runner.tick();
-          await sleep(50);
-          const state = await target.job(job.id);
-          assert(
-            state?.state === "queued",
-            `another user's daemon took a self job (state: ${String(state?.state)})`
-          );
-        } finally {
-          await bob.dispose();
-        }
-      } finally {
-        await alice.dispose();
-      }
-    }
-  },
-  {
-    id: "C002_JOB_ROUND_TRIP",
-    title: "an enqueued job runs on the owner's daemon and the result comes back",
-    musts: ["CLAIM_REQUIRES_CAPABILITY", "RESULT_IDEMPOTENT"],
-    async run(target) {
-      const daemon = await pairDaemon(target, { owner: "alice" });
-      try {
-        const job = await target.enqueue({
-          kind: "llm.generate",
-          payload: prompt("summarise this"),
-          owner: "alice"
-        });
-        await daemon.runner.tick();
-        await waitFor(async () => (await target.job(job.id))?.state === "ok", {
-          what: "the job to complete"
-        });
-        const finished = await target.job(job.id);
-        assert(
-          finished?.outcome?.text === "echo: summarise this",
-          "the result text did not survive the round trip"
-        );
-        assert(
-          daemon.backend.seen[0] === "summarise this",
-          "the prompt did not reach the model verbatim"
-        );
-      } finally {
-        await daemon.dispose();
-      }
-    }
-  },
-  {
-    id: "C003_UNKNOWN_KIND_REFUSED",
-    title: "a daemon is never handed a kind it did not advertise",
-    musts: ["KIND_TYPED_ONLY", "CLAIM_REQUIRES_CAPABILITY"],
-    async run(target) {
-      const daemon = await pairDaemon(target, { owner: "alice" });
-      try {
-        const job = await target.enqueue({
-          kind: "llm.chat",
-          payload: { messages: [{ role: "user", content: "hi" }] },
-          owner: "alice"
-        });
-        const before = daemon.backend.seen.length;
-        await daemon.runner.tick();
-        await sleep(50);
-        const state = await target.job(job.id);
-        assert(
-          state?.state === "ok" || state?.state === "running" || state?.state === "claimed",
-          `a job for an advertised kind was not taken (state: ${String(state?.state)})`
-        );
-        assert(
-          daemon.backend.seen.length > before,
-          "the advertised kind never reached the backend"
-        );
-      } finally {
-        await daemon.dispose();
-      }
-    }
-  },
-  {
-    id: "C004_LEASE_RECLAIM",
-    title: "a job whose runner vanished is offered again, losing nothing",
-    musts: ["LEASE_RECLAIMABLE", "LEASE_HONORED"],
-    async run(target) {
-      const dead = await pairDaemon(target, { owner: "alice", label: "dead" });
-      const job = await target.enqueue({
-        kind: "llm.generate",
-        payload: prompt("work"),
-        owner: "alice"
-      });
-      dead.backend.hangMs = 6e4;
-      await dead.runner.tick();
-      await waitFor(
-        async () => {
-          const state = await target.job(job.id);
-          return state?.state === "claimed" || state?.state === "running";
-        },
-        { what: "the job to be claimed" }
-      );
-      await dead.abandon();
-      await advance(target, target.leaseMs + 500);
-      const alive = await pairDaemon(target, {
-        owner: "alice",
-        label: "alive"
-      });
-      try {
-        await alive.runner.tick();
-        await waitFor(async () => (await target.job(job.id))?.state === "ok", {
-          what: "the reclaimed job to complete"
-        });
-      } finally {
-        await alive.dispose();
-      }
-    }
-  },
-  {
-    id: "C005_AUDIENCE_MATRIX",
-    title: "all nine audience \xD7 offer-scope combinations behave as specified",
-    musts: ["AUDIENCE_BOTH_SIDES", "NAMED_LOCAL_ALLOWLIST"],
-    async run(target) {
-      const expected = {
-        "self:self": false,
-        "self:named": false,
-        "self:public": false,
-        "named:self": false,
-        "named:named": false,
-        // refused locally — allowlist is empty
-        "named:public": true,
-        "public:self": false,
-        "public:named": false,
-        // refused locally — allowlist is empty
-        "public:public": true
-      };
-      for (const audience of AUDIENCES) {
-        for (const offer of OFFER_SCOPES) {
-          await target.reset();
-          const bob = await pairDaemon(target, { owner: "bob", offer });
-          try {
-            const job = await target.enqueue({
-              kind: "llm.generate",
-              payload: prompt("community work"),
-              owner: "alice",
-              audience
-            });
-            await bob.runner.tick();
-            await sleep(80);
-            const state = await target.job(job.id);
-            const ran = state?.state === "ok";
-            const shouldRun = expected[`${audience}:${offer}`] ?? false;
-            assert(
-              ran === shouldRun,
-              `audience=${audience} offer=${offer}: expected ${shouldRun ? "to run" : "to be refused"}, got state "${String(state?.state)}"`
-            );
-          } finally {
-            await bob.dispose();
-          }
-        }
-      }
-    }
-  },
-  {
-    id: "C006_NAMED_LOCAL_ALLOWLIST",
-    title: "a named job runs only once the daemon's own allowlist admits it",
-    musts: ["NAMED_LOCAL_ALLOWLIST", "REFUSAL_NOT_REOFFERED"],
-    async run(target) {
-      const bob = await pairDaemon(target, { owner: "bob", offer: "named" });
-      try {
-        const refused = await target.enqueue({
-          kind: "llm.generate",
-          payload: prompt("before"),
-          owner: "alice",
-          audience: "named"
-        });
-        await bob.runner.tick();
-        await sleep(80);
-        assert(
-          (await target.job(refused.id))?.state !== "ok",
-          "a named job ran without the daemon's local allowlist admitting it"
-        );
-        const before = bob.backend.seen.length;
-        await bob.runner.tick();
-        await sleep(50);
-        assert(
-          bob.backend.seen.length === before,
-          "a refused job was re-offered to the runner that refused it"
-        );
-        await bob.allowlist.add(
-          { origin: target.origin, owner: await ownerIdFor(target, "alice") },
-          Date.now()
-        );
-        const allowed = await target.enqueue({
-          kind: "llm.generate",
-          payload: prompt("after"),
-          owner: "alice",
-          audience: "named"
-        });
-        await bob.runner.tick();
-        await waitFor(
-          async () => (await target.job(allowed.id))?.state === "ok",
-          { what: "the allowed named job to run" }
-        );
-      } finally {
-        await bob.dispose();
-      }
-    }
-  },
-  {
-    id: "C007_SUBSCRIPTION_SELF_LOCK",
-    title: "a subscription backend refuses another user's work at any configured scope",
-    musts: ["SUBSCRIPTION_SELF_LOCK"],
-    async run(target) {
-      const bob = await pairDaemon(target, {
-        owner: "bob",
-        offer: "public",
-        subscription: true
-      });
-      try {
-        await bob.allowlist.add(
-          { origin: target.origin, owner: await ownerIdFor(target, "alice") },
-          Date.now()
-        );
-        const job = await target.enqueue({
-          kind: "llm.generate",
-          payload: prompt("someone else's work"),
-          owner: "alice",
-          audience: "public"
-        });
-        await bob.runner.tick();
-        await sleep(80);
-        const state = await target.job(job.id);
-        assert(
-          state?.state !== "ok",
-          "a subscription backend ran another user's job"
-        );
-        assert(
-          bob.backend.seen.length === 0,
-          "another user's prompt reached a subscription backend"
-        );
-        const own = await target.enqueue({
-          kind: "llm.generate",
-          payload: prompt("my own work"),
-          owner: "bob",
-          audience: "self"
-        });
-        await bob.runner.tick();
-        await waitFor(async () => (await target.job(own.id))?.state === "ok", {
-          what: "the owner's own subscription job to run"
-        });
-      } finally {
-        await bob.dispose();
-      }
-    }
-  },
-  {
-    id: "C008_REVOCATION",
-    title: "a revoked daemon stops mid-queue",
-    musts: ["REVOCATION_HONORED"],
-    async run(target) {
-      const daemon = await pairDaemon(target, { owner: "alice" });
-      try {
-        await target.revokeRunner(daemon.runnerId);
-        const job = await target.enqueue({
-          kind: "llm.generate",
-          payload: prompt("after revocation"),
-          owner: "alice"
-        });
-        await daemon.runner.tick();
-        await sleep(80);
-        assert(
-          daemon.runner.status().revoked,
-          "the daemon did not learn it was revoked"
-        );
-        assert(
-          (await target.job(job.id))?.state === "queued",
-          "a revoked daemon took new work"
-        );
-      } finally {
-        await daemon.dispose();
-      }
-    }
-  },
-  {
-    id: "C009_CANCEL_MID_FLIGHT",
-    title: "cancel aborts a running job's backend call",
-    musts: ["CANCEL_HONORED"],
-    async run(target) {
-      const daemon = await pairDaemon(target, { owner: "alice" });
-      try {
-        daemon.backend.hangMs = 3e4;
-        const job = await target.enqueue({
-          kind: "llm.generate",
-          payload: prompt("long job"),
-          owner: "alice"
-        });
-        await daemon.runner.tick();
-        await waitFor(() => daemon.backend.seen.length > 0, {
-          what: "the job to start running"
-        });
-        await target.cancelJob(job.id);
-        await daemon.runner.tick();
-        await waitFor(
-          async () => (await target.job(job.id))?.state === "canceled",
-          { what: "the job to report canceled", timeoutMs: 1e4 }
-        );
-      } finally {
-        await daemon.dispose();
-      }
-    }
-  },
-  {
-    id: "C010_RESULT_IDEMPOTENT",
-    title: "the first terminal outcome wins",
-    musts: ["RESULT_IDEMPOTENT"],
-    async run(target) {
-      const daemon = await pairDaemon(target, { owner: "alice" });
-      try {
-        const job = await target.enqueue({
-          kind: "llm.generate",
-          payload: prompt("once"),
-          owner: "alice"
-        });
-        await daemon.runner.tick();
-        await waitFor(async () => (await target.job(job.id))?.state === "ok", {
-          what: "the job to complete"
-        });
-        const first = await target.job(job.id);
-        const response = await target.fetch(
-          new Request(`${target.origin}/byollm/result`, {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({
-              protocolVersion: "0",
-              runnerId: daemon.runnerId,
-              jobId: job.id,
-              outcome: { outcome: "ok", text: "SECOND ANSWER" },
-              model: "echo-model",
-              backendClass: "http",
-              durationMs: 1
-            })
-          })
-        );
-        void response;
-        const after = await target.job(job.id);
-        assert(
-          after?.outcome?.text === first?.outcome?.text,
-          "a second result overwrote the first"
-        );
-      } finally {
-        await daemon.dispose();
-      }
-    }
-  },
-  {
-    id: "C011_DEPENDENCY_ORDER",
-    title: "a dependent job waits for its dependency, across two daemons",
-    musts: ["DEPENDS_ON_GATING", "TTL_EXPIRY"],
-    async run(target) {
-      const alice = await pairDaemon(target, { owner: "alice" });
-      const bob = await pairDaemon(target, { owner: "bob" });
-      try {
-        const first = await target.enqueue({
-          kind: "llm.generate",
-          payload: prompt("step one"),
-          owner: "bob",
-          audience: "self"
-        });
-        const second = await target.enqueue({
-          kind: "llm.generate",
-          payload: prompt("step two"),
-          owner: "alice",
-          audience: "self",
-          dependsOn: [first.id]
-        });
-        await alice.runner.tick();
-        await sleep(80);
-        assert(
-          alice.backend.seen.length === 0,
-          "a dependent job ran before its dependency completed"
-        );
-        assert(
-          (await target.job(second.id))?.state === "queued",
-          "a dependent job left the queue early"
-        );
-        await bob.runner.tick();
-        await waitFor(
-          async () => (await target.job(first.id))?.state === "ok",
-          { what: "the dependency to complete" }
-        );
-        await alice.runner.tick();
-        await waitFor(
-          async () => (await target.job(second.id))?.state === "ok",
-          { what: "the dependent job to complete" }
-        );
-      } finally {
-        await alice.dispose();
-        await bob.dispose();
-      }
-    }
-  },
-  {
-    id: "C012_TTL_AND_NO_RUNNER",
-    title: "an unclaimed job expires and no-runner is surfaced, but not while blocked",
-    musts: ["TTL_EXPIRY", "NO_RUNNER_SIGNAL"],
-    async run(target) {
-      const availability = await target.runnerAvailability({
-        kind: "llm.generate",
-        owner: "alice"
-      });
-      assert(
-        !availability.available,
-        "no-runner was not surfaced with nothing paired"
-      );
-      const job = await target.enqueue({
-        kind: "llm.generate",
-        payload: prompt("nobody will run this"),
-        owner: "alice",
-        ttlMs: target.ttlMs
-      });
-      await advance(target, target.ttlMs + 500);
-      const state = await target.job(job.id);
-      assert(
-        state?.state === "expired",
-        `an unclaimed job past its TTL was "${String(state?.state)}", not expired`
-      );
-    }
-  },
-  {
-    id: "C013_TTL_CLOCK_STARTS_WHEN_CLAIMABLE",
-    title: "a dependent job's TTL starts when it becomes claimable, not at enqueue",
-    musts: ["TTL_EXPIRY"],
-    async run(target) {
-      const daemon = await pairDaemon(target, { owner: "alice" });
-      try {
-        daemon.backend.hangMs = target.ttlMs * 2;
-        const first = await target.enqueue({
-          kind: "llm.generate",
-          payload: prompt("slow step"),
-          owner: "alice"
-        });
-        const second = await target.enqueue({
-          kind: "llm.generate",
-          payload: prompt("waiting step"),
-          owner: "alice",
-          dependsOn: [first.id],
-          ttlMs: target.ttlMs
-        });
-        await daemon.runner.tick();
-        await advance(target, target.ttlMs + 200);
-        const blocked = await target.job(second.id);
-        assert(
-          blocked?.state === "queued",
-          `a blocked job expired while waiting on its dependency (state: ${String(blocked?.state)}) \u2014 the TTL clock started too early`
-        );
-      } finally {
-        await daemon.dispose();
-      }
-    }
-  },
-  {
-    id: "C014_RESULT_PROVENANCE",
-    title: "a community result arrives marked untrusted, a self result does not",
-    musts: ["RESULT_PROVENANCE"],
-    async run(target) {
-      const bob = await pairDaemon(target, { owner: "bob", offer: "public" });
-      try {
-        const community = await target.enqueue({
-          kind: "llm.generate",
-          payload: prompt("run this anywhere"),
-          owner: "alice",
-          audience: "public"
-        });
-        await bob.runner.tick();
-        await waitFor(
-          async () => (await target.job(community.id))?.state === "ok",
-          { what: "the community job to complete" }
-        );
-        const delivered = await target.job(community.id);
-        assert(
-          delivered?.provenance?.untrusted === true,
-          "a public result was not marked untrusted"
-        );
-        assert(
-          delivered.provenance.runnerOwner === "bob",
-          "the result did not carry the runner's owner"
-        );
-        const own = await target.enqueue({
-          kind: "llm.generate",
-          payload: prompt("my own"),
-          owner: "bob",
-          audience: "self"
-        });
-        await bob.runner.tick();
-        await waitFor(async () => (await target.job(own.id))?.state === "ok", {
-          what: "the self job to complete"
-        });
-        assert(
-          (await target.job(own.id))?.provenance?.untrusted === false,
-          "a self result was marked untrusted"
-        );
-      } finally {
-        await bob.dispose();
-      }
-    }
-  },
-  {
-    id: "C015_INGRESS_BEFORE_EXECUTION",
-    title: "every executed prompt is in the ingress log",
-    musts: ["INGRESS_LOGGED_BEFORE_EXECUTION"],
-    async run(target) {
-      const daemon = await pairDaemon(target, { owner: "alice" });
-      try {
-        const job = await target.enqueue({
-          kind: "llm.generate",
-          payload: prompt("logged prompt"),
-          owner: "alice"
-        });
-        await daemon.runner.tick();
-        await waitFor(async () => (await target.job(job.id))?.state === "ok", {
-          what: "the job to complete"
-        });
-        const entries = await daemon.ingress.read();
-        const logged = entries.find(
-          (entry) => entry.type === "prompt" && entry.jobId === job.id
-        );
-        assert(
-          logged !== void 0,
-          "the executed prompt is not in the ingress log"
-        );
-        assert(
-          logged.type === "prompt" && logged.prompt === "logged prompt",
-          "the ingress log did not record the prompt text"
-        );
-      } finally {
-        await daemon.dispose();
-      }
-    }
-  },
-  {
-    id: "C016_UNAUTHENTICATED_REFUSED",
-    title: "the protocol endpoints refuse an unknown token",
-    musts: ["PAIR_ONE_USER"],
-    async run(target) {
-      for (const endpoint of ["claim", "heartbeat", "result", "release"]) {
-        const response = await target.fetch(
-          new Request(`${target.origin}/byollm/${endpoint}`, {
-            method: "POST",
-            headers: {
-              "content-type": "application/json",
-              authorization: "Bearer definitely-not-a-real-token"
-            },
-            body: JSON.stringify({ protocolVersion: "0" })
-          })
-        );
-        assert(
-          response.status === 401,
-          `${endpoint} answered ${String(response.status)} to an unknown token, not 401`
-        );
-      }
-    }
-  }
-];
-
-// src/certify.ts
-import { MUSTS, MUST_IDS } from "@byollm/protocol";
-async function certify(target, options = {}) {
-  const only = options.only;
-  const selected = only ? CHECKS.filter((check) => only.includes(check.id)) : CHECKS;
-  const results = [];
-  for (const check of selected) {
-    await target.reset();
-    const started = Date.now();
-    try {
-      await check.run(target);
-      const result = {
-        check,
-        passed: true,
-        durationMs: Date.now() - started
-      };
-      results.push(result);
-      options.onProgress?.(result);
-    } catch (error) {
-      const result = {
-        check,
-        passed: false,
-        durationMs: Date.now() - started,
-        error: error instanceof Error ? error.message : String(error)
-      };
-      results.push(result);
-      options.onProgress?.(result);
-    }
-  }
-  return {
-    target: target.name,
-    passed: results.every((result) => result.passed),
-    results,
-    uncoveredMusts: uncoveredMusts(selected)
-  };
-}
-function uncoveredMusts(checks = CHECKS) {
-  const covered = new Set(checks.flatMap((check) => check.musts));
-  return MUST_IDS.filter((id) => !covered.has(id));
-}
-function formatReport(report) {
-  const lines = [];
-  lines.push(`byollm conformance \u2014 ${report.target}`);
-  lines.push("");
-  for (const result of report.results) {
-    lines.push(
-      `  ${result.passed ? "\u2713" : "\u2717"} ${result.check.id}  ${result.check.title}  (${String(result.durationMs)}ms)`
-    );
-    if (!result.passed && result.error !== void 0) {
-      lines.push(`      ${result.error}`);
-    }
-  }
-  const failed = report.results.filter((result) => !result.passed).length;
-  lines.push("");
-  lines.push(
-    report.passed ? `  ${String(report.results.length)} checks passed \u2014 ${report.target} is byollm-compatible.` : `  ${String(failed)} of ${String(report.results.length)} checks failed \u2014 not compatible.`
-  );
-  if (report.uncoveredMusts.length > 0) {
-    lines.push("");
-    lines.push("  MUSTs with no check yet (the kit is honest about its gaps):");
-    for (const id of report.uncoveredMusts) {
-      lines.push(`    - ${id}: ${MUSTS[id].statement}`);
-    }
-  }
-  return `${lines.join("\n")}
-`;
-}
-
-export {
-  EchoBackend,
-  pairDaemon,
-  ownerIdFor,
-  waitFor,
-  sleep,
-  advance,
-  CHECKS,
-  certify,
-  uncoveredMusts,
-  formatReport
-};
-//# sourceMappingURL=chunk-PDQJJ3Q2.js.map