@voidly/session 1.0.0 → 1.2.1

package/dist/proofsAuto.mjs

@@ -0,0 +1,554 @@
+import nacl3 from "tweetnacl";
+import nacl from "tweetnacl";
+import __naclUtil0 from "tweetnacl-util";
+const { decodeBase64 } = __naclUtil0;
+var MAX_WINDOW_MS = 3600 * 1e3, MAX_CLOCK_SKEW_MS = 30 * 1e3;
+function canonicalize(value) {
+  if (value == null) return "null";
+  if (typeof value == "boolean") return value ? "true" : "false";
+  if (typeof value == "number") {
+    if (!Number.isFinite(value) || !Number.isInteger(value)) throw new Error("canonicalize: only finite integers supported");
+    return value.toString(10);
+  }
+  if (typeof value == "bigint") return value.toString(10);
+  if (typeof value == "string") return JSON.stringify(value);
+  if (Array.isArray(value)) return "[" + value.map(canonicalize).join(",") + "]";
+  if (typeof value == "object") {
+    let obj = value;
+    return "{" + Object.keys(obj).filter((k) => obj[k] !== null && obj[k] !== void 0).sort().map((k) => JSON.stringify(k) + ":" + canonicalize(obj[k])).join(",") + "}";
+  }
+  throw new Error(`canonicalize: unsupported type ${typeof value}`);
+}
+function canonicalBytes(value) {
+  return new TextEncoder().encode(canonicalize(value));
+}
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function toBase58(bytes) {
+  let result = "", num = BigInt("0x" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join(""));
+  for (; num > 0n; ) {
+    let remainder = num % 58n;
+    num = num / 58n, result = BASE58_ALPHABET[Number(remainder)] + result;
+  }
+  for (let byte of bytes) if (byte === 0) result = "1" + result;
+  else break;
+  return result || "1";
+}
+function deriveDidFromSigningKey(signingPublicKey) {
+  return `did:voidly:${toBase58(signingPublicKey.slice(0, 16))}`;
+}
+async function sha256Bytes(bytes) {
+  let buf = await crypto.subtle.digest("SHA-256", bytes);
+  return new Uint8Array(buf);
+}
+async function sha256Hex(bytes) {
+  let digest = await sha256Bytes(bytes);
+  return Array.from(digest).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+var FRAME_OFFER_HASH_BYTES = 32, FRAME_BODY_NONCE_BYTES = 24, FRAME_HEADER_LENGTH = FRAME_OFFER_HASH_BYTES + FRAME_BODY_NONCE_BYTES + 4, MIN_FRAME_BUCKET = 512;
+var SECRETBOX_TAG_BYTES = 16, CAPSULE_SALT_BYTES = 32;
+function base64Length(bytes) {
+  return 4 * Math.ceil(bytes / 3);
+}
+var SESSION_MAX_BODY_BYTES = 32 * 1024, SESSION_WORST_CASE_ENVELOPE_BYTES = 4972, MAX_FRAME_BUCKET_BYTES = (() => {
+  let best = 0;
+  for (let bucket = MIN_FRAME_BUCKET; bucket <= SESSION_MAX_BODY_BYTES; bucket *= 2) base64Length(bucket + SECRETBOX_TAG_BYTES) + SESSION_WORST_CASE_ENVELOPE_BYTES <= SESSION_MAX_BODY_BYTES && (best = bucket);
+  if (best === 0) throw new Error("wireBudget: the transport ceiling cannot carry the minimum frame bucket");
+  return best;
+})(), MAX_CAPSULE_BODY_BYTES = MAX_FRAME_BUCKET_BYTES + SECRETBOX_TAG_BYTES, MAX_CAPSULE_BODY_BASE64_LENGTH = base64Length(MAX_CAPSULE_BODY_BYTES), MAX_SEALED_PAYLOAD_BYTES = MAX_FRAME_BUCKET_BYTES - FRAME_HEADER_LENGTH, SESSION_EVIDENCE_HEADROOM_BYTES = SESSION_MAX_BODY_BYTES - MAX_CAPSULE_BODY_BASE64_LENGTH - SESSION_WORST_CASE_ENVELOPE_BYTES;
+var TASK_BRIEF_SCHEMA = "voidly-task-brief/v1";
+var TASK_RESULT_SCHEMA = "voidly-task-result/v1";
+var MAX_OFFER_TTL_MS = 1440 * 60 * 1e3, MAX_GRANT_TTL_MS = 1440 * 60 * 1e3;
+var SESSION_RAIL_MIN_CONFIRMATIONS = 12, SESSION_RAIL_BLOCK_TIME_MS = 2e3, MIN_GRANT_TTL_MS = SESSION_RAIL_MIN_CONFIRMATIONS * SESSION_RAIL_BLOCK_TIME_MS + MAX_CLOCK_SKEW_MS, MAX_SERVICE_REF_LENGTH = 128;
+var BRIEF_SALT_BASE64_LENGTH = base64Length(CAPSULE_SALT_BYTES), canonicalPayloadOverhead = (schema, field) => canonicalBytes({ schema, [field]: "", salt_base64: "A".repeat(BRIEF_SALT_BASE64_LENGTH) }).length, MAX_BRIEF_LENGTH = MAX_SEALED_PAYLOAD_BYTES - Math.max(canonicalPayloadOverhead(TASK_BRIEF_SCHEMA, "brief"), canonicalPayloadOverhead(TASK_RESULT_SCHEMA, "result"));
+var MAX_RECOVERY_TTL_MS = 10080 * 60 * 1e3;
+var DID_RE = /^did:voidly:[A-Za-z0-9._-]{1,64}$/;
+function hasOnlyKeys(raw, allowed) {
+  for (let k of Object.keys(raw)) if (!allowed.includes(k)) return false;
+  return true;
+}
+function isBase64Key32(value, decode) {
+  if (typeof value != "string" || value.length === 0) return false;
+  try {
+    return decode(value).length === 32;
+  } catch {
+    return false;
+  }
+}
+var CAIP2_RE = /^[-a-z0-9]{3,8}:[-_a-zA-Z0-9]{1,32}$/, CAIP10_RE = /^[-a-z0-9]{3,8}:[-_a-zA-Z0-9]{1,32}:[-.%a-zA-Z0-9]{1,128}$/, CAIP19_RE = /^[-a-z0-9]{3,8}:[-_a-zA-Z0-9]{1,32}\/[-a-z0-9]{3,8}:[-.%a-zA-Z0-9]{1,128}(\/[-.%a-zA-Z0-9]{1,78})?$/, POSITIVE_DECIMAL_RE = /^[1-9][0-9]{0,77}$/;
+function isCaip2(s) {
+  return typeof s == "string" && CAIP2_RE.test(s);
+}
+function isCaip10(s) {
+  return typeof s == "string" && CAIP10_RE.test(s);
+}
+function isCaip19(s) {
+  return typeof s == "string" && CAIP19_RE.test(s);
+}
+function isPositiveDecimalString(s) {
+  return typeof s == "string" && POSITIVE_DECIMAL_RE.test(s);
+}
+import __naclUtil1 from "tweetnacl-util";
+const { decodeBase64: decodeBase642 } = __naclUtil1;
+var SESSION_HIRE_SCHEMA = "voidly-session-hire/v1";
+var AUTHORIZATION_ENTRY_POINTS = ["transfer_with_authorization", "receive_with_authorization"];
+import nacl2 from "tweetnacl";
+import __naclUtil2 from "tweetnacl-util";
+const { decodeBase64: decodeBase643 } = __naclUtil2;
+var MINTED = /* @__PURE__ */ new WeakMap();
+function containerCopy(value) {
+  if (value === null || typeof value != "object") return null;
+  if (Array.isArray(value)) {
+    let source = value, sink = [];
+    for (let key of Object.keys(source)) sink[key] = source[key];
+    return sink;
+  }
+  return { ...value };
+}
+function rebuildDocumentDeep(document) {
+  let top = containerCopy(document);
+  if (top === null) return document;
+  let made = /* @__PURE__ */ new Map();
+  made.set(document, top);
+  let pending2 = [top];
+  for (; pending2.length > 0; ) {
+    let frame = pending2.pop();
+    if (frame === void 0) break;
+    for (let key of Object.keys(frame)) {
+      let child = frame[key];
+      if (child === null || typeof child != "object") continue;
+      let already = made.get(child);
+      if (already !== void 0) {
+        frame[key] = already;
+        continue;
+      }
+      let copy = containerCopy(child);
+      copy !== null && (made.set(child, copy), frame[key] = copy, pending2.push(copy));
+    }
+  }
+  return top;
+}
+function freezeManifestDeep(m) {
+  let seen = /* @__PURE__ */ new Set(), pending2 = [m];
+  for (; pending2.length > 0; ) {
+    let node = pending2.pop();
+    if (node === null || typeof node != "object") continue;
+    let container = node;
+    if (!seen.has(container)) {
+      seen.add(container), Object.freeze(container);
+      for (let key of Reflect.ownKeys(container)) {
+        if (typeof key == "symbol") continue;
+        let d = Object.getOwnPropertyDescriptor(container, key);
+        d !== void 0 && "value" in d && pending2.push(d.value);
+      }
+    }
+  }
+  return m;
+}
+function mintVerifiedProvider(manifest) {
+  let document = freezeManifestDeep(rebuildDocumentDeep(manifest)), provider = Object.freeze({ manifest: document });
+  return MINTED.set(provider, document), provider;
+}
+var PROVIDER_MANIFEST_SCHEMA = "voidly.session.provider.manifest/v1", PROVIDER_MANIFEST_KEYS = ["schema", "provider_did", "signing_public_key_base64", "encryption_public_key_base64", "attestor_public_key_base64", "accept_url", "hire_message_schema", "worker_base_url", "hint_url", "relays", "grant_ttl_ms", "acceptance_ttl_ms", "services", "payment_buys", "notes", "signature_base64"];
+function manifestSigningBytes(m) {
+  return canonicalBytes(m);
+}
+function isNonEmptyString(v, max = 2048) {
+  return typeof v == "string" && v.length > 0 && v.length <= max;
+}
+function isPositiveInt(v) {
+  return typeof v == "number" && Number.isInteger(v) && v > 0;
+}
+function verifyManifest(raw, expectedProviderDid) {
+  if (typeof raw != "object" || raw === null || Array.isArray(raw)) return { ok: false, reason: "manifest_not_object" };
+  let r = { ...raw };
+  if (r.schema !== PROVIDER_MANIFEST_SCHEMA) return { ok: false, reason: "manifest_schema_mismatch" };
+  if (!hasOnlyKeys(r, PROVIDER_MANIFEST_KEYS)) return { ok: false, reason: "manifest_unexpected_field" };
+  if (r.signature_base64 === void 0 || r.signature_base64 === null) return { ok: false, reason: "manifest_signature_missing" };
+  if (typeof r.signature_base64 != "string" || r.signature_base64.length === 0) return { ok: false, reason: "manifest_signature_malformed" };
+  let signature;
+  try {
+    signature = decodeBase643(r.signature_base64);
+  } catch {
+    return { ok: false, reason: "manifest_signature_malformed" };
+  }
+  if (signature.length !== nacl2.sign.signatureLength) return { ok: false, reason: "manifest_signature_malformed" };
+  if (!isBase64Key32(r.signing_public_key_base64, decodeBase643)) return { ok: false, reason: "manifest_field_malformed" };
+  if (!isBase64Key32(r.encryption_public_key_base64, decodeBase643)) return { ok: false, reason: "manifest_field_malformed" };
+  if (!isBase64Key32(r.attestor_public_key_base64, decodeBase643)) return { ok: false, reason: "manifest_field_malformed" };
+  if (typeof r.provider_did != "string" || !DID_RE.test(r.provider_did)) return { ok: false, reason: "manifest_field_malformed" };
+  if (!isNonEmptyString(r.accept_url) || !isNonEmptyString(r.worker_base_url)) return { ok: false, reason: "manifest_field_malformed" };
+  let rawHintUrl = r.hint_url;
+  if (rawHintUrl !== void 0 && !isNonEmptyString(rawHintUrl)) return { ok: false, reason: "manifest_field_malformed" };
+  let hintUrl = rawHintUrl === void 0 ? void 0 : rawHintUrl, rawRelays = r.relays, relays;
+  if (rawRelays !== void 0) {
+    if (typeof rawRelays != "object" || rawRelays === null || Array.isArray(rawRelays)) return { ok: false, reason: "manifest_field_malformed" };
+    let rel = { ...rawRelays };
+    if (!hasOnlyKeys(rel, ["provider_submits", "accepted_entry_points"])) return { ok: false, reason: "manifest_field_malformed" };
+    if (typeof rel.provider_submits != "boolean") return { ok: false, reason: "manifest_field_malformed" };
+    let rawDoors = rel.accepted_entry_points;
+    if (!Array.isArray(rawDoors) || rawDoors.length === 0 || rawDoors.length > AUTHORIZATION_ENTRY_POINTS.length) return { ok: false, reason: "manifest_field_malformed" };
+    let doors = [];
+    for (let i = 0; i < rawDoors.length; i += 1) {
+      let door = rawDoors[i];
+      if (typeof door != "string" || !AUTHORIZATION_ENTRY_POINTS.includes(door)) return { ok: false, reason: "manifest_field_malformed" };
+      if (doors.includes(door)) return { ok: false, reason: "manifest_field_malformed" };
+      doors.push(door);
+    }
+    relays = { provider_submits: rel.provider_submits, accepted_entry_points: doors };
+  }
+  if (r.hire_message_schema !== SESSION_HIRE_SCHEMA) return { ok: false, reason: "manifest_field_malformed" };
+  if (r.payment_buys !== "an attempt, not an outcome") return { ok: false, reason: "manifest_field_malformed" };
+  if (!isPositiveInt(r.acceptance_ttl_ms)) return { ok: false, reason: "manifest_field_malformed" };
+  let ttl = r.grant_ttl_ms;
+  if (typeof ttl != "object" || ttl === null || Array.isArray(ttl)) return { ok: false, reason: "manifest_field_malformed" };
+  let ttlSnap = { ...ttl };
+  if (!hasOnlyKeys(ttlSnap, ["min", "max"])) return { ok: false, reason: "manifest_field_malformed" };
+  if (!isPositiveInt(ttlSnap.min) || !isPositiveInt(ttlSnap.max)) return { ok: false, reason: "manifest_field_malformed" };
+  if (ttlSnap.min > ttlSnap.max || ttlSnap.max > MAX_GRANT_TTL_MS) return { ok: false, reason: "manifest_field_malformed" };
+  let rawNotes = r.notes;
+  if (!Array.isArray(rawNotes)) return { ok: false, reason: "manifest_field_malformed" };
+  let notes = [];
+  for (let i = 0; i < rawNotes.length; i += 1) {
+    let note = rawNotes[i];
+    if (!isNonEmptyString(note, 4096)) return { ok: false, reason: "manifest_field_malformed" };
+    notes.push(note);
+  }
+  let rawServices = r.services;
+  if (!Array.isArray(rawServices) || rawServices.length === 0) return { ok: false, reason: "manifest_field_malformed" };
+  let services = [];
+  for (let i = 0; i < rawServices.length; i += 1) {
+    let entry = rawServices[i];
+    if (typeof entry != "object" || entry === null || Array.isArray(entry)) return { ok: false, reason: "manifest_field_malformed" };
+    let s = { ...entry };
+    if (!hasOnlyKeys(s, ["ref", "description", "price"])) return { ok: false, reason: "manifest_field_malformed" };
+    if (!isNonEmptyString(s.ref, MAX_SERVICE_REF_LENGTH) || typeof s.description != "string") return { ok: false, reason: "manifest_field_malformed" };
+    let price = s.price;
+    if (typeof price != "object" || price === null || Array.isArray(price)) return { ok: false, reason: "manifest_field_malformed" };
+    let p = { ...price };
+    if (!hasOnlyKeys(p, ["chain", "asset", "payee_account", "min_amount", "max_amount"])) return { ok: false, reason: "manifest_field_malformed" };
+    if (typeof p.chain != "string" || !isCaip2(p.chain)) return { ok: false, reason: "manifest_field_malformed" };
+    if (typeof p.asset != "string" || !isCaip19(p.asset)) return { ok: false, reason: "manifest_field_malformed" };
+    if (typeof p.payee_account != "string" || !isCaip10(p.payee_account)) return { ok: false, reason: "manifest_field_malformed" };
+    if (typeof p.min_amount != "string" || !isPositiveDecimalString(p.min_amount)) return { ok: false, reason: "manifest_field_malformed" };
+    if (typeof p.max_amount != "string" || !isPositiveDecimalString(p.max_amount)) return { ok: false, reason: "manifest_field_malformed" };
+    services.push({ ref: s.ref, description: s.description, price: { chain: p.chain, asset: p.asset, payee_account: p.payee_account, min_amount: p.min_amount, max_amount: p.max_amount } });
+  }
+  let signingKey = decodeBase643(r.signing_public_key_base64), derived = null;
+  try {
+    derived = deriveDidFromSigningKey(signingKey);
+  } catch {
+    derived = null;
+  }
+  if (derived === null || derived !== r.provider_did) return { ok: false, reason: "manifest_did_not_derived" };
+  let body = { schema: PROVIDER_MANIFEST_SCHEMA, provider_did: r.provider_did, signing_public_key_base64: r.signing_public_key_base64, encryption_public_key_base64: r.encryption_public_key_base64, attestor_public_key_base64: r.attestor_public_key_base64, accept_url: r.accept_url, hire_message_schema: SESSION_HIRE_SCHEMA, worker_base_url: r.worker_base_url, ...hintUrl !== void 0 ? { hint_url: hintUrl } : {}, ...relays !== void 0 ? { relays } : {}, grant_ttl_ms: { min: ttlSnap.min, max: ttlSnap.max }, acceptance_ttl_ms: r.acceptance_ttl_ms, services, payment_buys: "an attempt, not an outcome", notes }, verified = false;
+  try {
+    verified = nacl2.sign.detached.verify(manifestSigningBytes(body), signature, signingKey);
+  } catch {
+    verified = false;
+  }
+  return verified ? expectedProviderDid !== void 0 && expectedProviderDid !== body.provider_did ? { ok: false, reason: "manifest_did_not_pinned" } : { ok: true, manifest: { ...body, signature_base64: r.signature_base64 } } : { ok: false, reason: "manifest_signature_invalid" };
+}
+function verifyProvider(raw, expectedProviderDid) {
+  if (typeof expectedProviderDid != "string" || !DID_RE.test(expectedProviderDid)) return { ok: false, reason: "manifest_pin_not_a_did" };
+  let verdict = verifyManifest(raw, expectedProviderDid);
+  if (!verdict.ok) return { ok: false, reason: verdict.reason };
+  let refs = /* @__PURE__ */ new Set();
+  for (let offering of verdict.manifest.services) {
+    if (refs.has(offering.ref)) return { ok: false, reason: "manifest_service_ref_duplicated" };
+    refs.add(offering.ref);
+  }
+  return { ok: true, provider: mintVerifiedProvider(verdict.manifest) };
+}
+function automaticCanonicalJson(value) {
+  if (value === null || typeof value == "string" || typeof value == "boolean" || typeof value == "number" && Number.isSafeInteger(value)) return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(automaticCanonicalJson).join(",")}]`;
+  if (value !== null && typeof value == "object" && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null)) {
+    let record = value;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${automaticCanonicalJson(record[key])}`).join(",")}}`;
+  }
+  throw new TypeError("Unsupported automatic collection JSON value");
+}
+var PROOFS_FIXTURE = { schema: "voidly.session.provider.manifest/v1", provider_did: "did:voidly:E41eeJuRTVxE7411zGGF9H", signing_public_key_base64: "abJvEa/votvZLFZzFKEhwNxyBoIqBRYgvL6mrNysGFI=", encryption_public_key_base64: "CwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCws=", attestor_public_key_base64: "ExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExM=", accept_url: "https://fixture.example.test/session/accept", hire_message_schema: "voidly-session-hire/v1", worker_base_url: "https://fixture.example.test", grant_ttl_ms: { min: 3e5, max: 216e5 }, acceptance_ttl_ms: 3e5, services: [{ ref: "sessions.public.fixture/v1", description: "Offline signature verification fixture only.", price: { chain: "eip155:8453", asset: "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913", payee_account: "eip155:8453:0x2222222222222222222222222222222222222222", min_amount: "1", max_amount: "1" } }], payment_buys: "an attempt, not an outcome", notes: ["Public offline fixture. Never contact these example endpoints or use this manifest for a payment."], signature_base64: "1gE/tewhX6oLaymE2i1w2vrR5gzZv3WTz5EzIECoetx4Dma+aVTAZDyzSLDHeHi/fc57mO7Sd6+3cR/WjfcJDA==" }, PROOFS_FIXTURE_DIGEST = "ccf7933183585166962b3244e19df341b6011895daa4fd43337011bc94b0846a";
+var TITLE = "Your proof artwork", DESCRIPTION = "Code-generated artwork for a saved proof. Decorative, not a signed receipt or evidence of identity, payment, or impact.", PALETTES = [[[184, 166, 237], [237, 227, 206]], [[158, 190, 214], [224, 227, 238]], [[219, 185, 171], [194, 176, 230]]];
+function generator(id) {
+  let a = parseInt(id.slice(0, 8), 16) | 0, b = parseInt(id.slice(8, 16), 16) | 0, c = parseInt(id.slice(16, 24), 16) | 0, d = parseInt(id.slice(24, 32), 16) | 0;
+  function next() {
+    let value = (a + b | 0) + d | 0;
+    return d = d + 1 | 0, a = b ^ b >>> 9, b = c + (c << 3) | 0, c = (c << 21 | c >>> 11) + value | 0, (value >>> 0) / 4294967296;
+  }
+  for (let index = 0; index < 16; index++) next();
+  return next;
+}
+function proofArtworkSvg(id) {
+  if (typeof id != "string" || !/^[0-9a-f]{32}$/.test(id)) throw new Error("Artwork requires a valid saved proof event ID.");
+  let random = generator(id), palette = PALETTES[Math.floor(random() * PALETTES.length)], rotation = random() * Math.PI * 2, phase = random() * Math.PI * 2, lobes = 2 + Math.floor(random() * 4), twist = (random() - 0.5) * 4.8, amplitude = 0.07 + random() * 0.12, stretch = 0.58 + random() * 0.4, driftX = (random() - 0.5) * 54, driftY = (random() - 0.5) * 54, aperture = 5 + random() * 23, power = 0.75 + random() * 0.75, paths = [];
+  for (let ring = 0; ring < 38; ring++) {
+    let progress = ring / 37, radius = aperture + progress * (102 - aperture), turn = rotation + twist * (1 - progress) ** 2, points = [];
+    for (let sample = 0; sample < 112; sample++) {
+      let angle = sample / 112 * Math.PI * 2, ripple = 1 + Math.sin(angle * lobes + phase + progress) * amplitude + Math.cos(angle * 2 - phase) * 0.025, cos = Math.cos(angle), sin = Math.sin(angle), x = Math.sign(cos) * Math.abs(cos) ** power * radius * ripple, y = Math.sign(sin) * Math.abs(sin) ** power * radius * ripple * stretch, px = 160 + Math.cos(turn) * x - Math.sin(turn) * y + driftX * (1 - progress), py = 160 + Math.sin(turn) * x + Math.cos(turn) * y + driftY * (1 - progress);
+      points.push(`${sample ? "L" : "M"}${px.toFixed(2)} ${py.toFixed(2)}`);
+    }
+    let color = palette[0].map((value, index) => Math.round(value + (palette[1][index] - value) * progress));
+    paths.push(`<path d="${points.join("")}Z" fill="none" stroke="rgb(${color.join(",")})" stroke-width="${ring % 6 === 0 ? 1.4 : 0.9}"/>`);
+  }
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="1200" height="1200" viewBox="0 0 320 320" role="img" aria-label="${TITLE}"><title>${TITLE}</title><desc>${DESCRIPTION}</desc><rect width="320" height="320" fill="#050506"/>${paths.join("")}</svg>`;
+}
+var PUBLIC_EXERCISE_SCHEMA = "voidpay.proof-collection.public-exercise/v3", PUBLIC_RESULT_SCHEMA = "voidpay.proof-collection.public-result/v3", PUBLIC_RESPONSE_SCHEMA = "voidpay.proof-collection.public-response/v3", SESSIONS_PROOFS_TASK = Object.freeze({ id: "sessions-public-check-01", version: 1, acceptance_rule_sha256: "1be9d67c2f8caffa45fd985b7454371838c29e4fadbd8dadc2a4e6663b0f7bc5" }), SESSIONS_PROOFS_PROVIDER = Object.freeze({ provider_did: "did:voidly:6rGTFa5apSnKNF14bGXZfu", manifest_url: "https://intelligence.voidly.ai:8443/.well-known/voidly-session-provider.json", index_url: "https://api.voidly.ai/v1/session/providers" }), PUBLIC_EXERCISE_MAX_BYTES = 8192, PUBLIC_EXERCISE_TTL_MS = 6e5, WRONG_PIN = "did:voidly:2222222222222222", HEX32 = /^[0-9a-f]{32}$/, HEX64 = /^[0-9a-f]{64}$/, PublicExerciseError = class extends Error {
+  constructor(code) {
+    super(code), this.name = "PublicExerciseError", this.code = code;
+  }
+};
+function requireCondition(value, code) {
+  if (!value) throw new PublicExerciseError(code);
+}
+function plain(value) {
+  return value !== null && typeof value == "object" && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+function exact(value, keys) {
+  return plain(value) && Object.keys(value).length === keys.length && keys.every((key) => Object.prototype.hasOwnProperty.call(value, key));
+}
+function same(value, expected) {
+  return exact(value, Object.keys(expected)) && Object.entries(expected).every(([key, field]) => value[key] === field);
+}
+function iso(value) {
+  return typeof value == "string" && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(value) && Number.isFinite(Date.parse(value)) && new Date(value).toISOString() === value;
+}
+function parsePublicExercise(text, nowMs = Date.now()) {
+  requireCondition(typeof text == "string" && new TextEncoder().encode(text).length <= PUBLIC_EXERCISE_MAX_BYTES, "exercise_invalid");
+  let input;
+  try {
+    input = JSON.parse(text);
+  } catch {
+    throw new PublicExerciseError("exercise_invalid");
+  }
+  return requireCondition(exact(input, ["schema", "task", "challenge_id", "challenge", "issued_at", "expires_at", "provider"]), "exercise_invalid"), requireCondition(input.schema === PUBLIC_EXERCISE_SCHEMA && same(input.task, SESSIONS_PROOFS_TASK) && same(input.provider, SESSIONS_PROOFS_PROVIDER) && typeof input.challenge_id == "string" && HEX32.test(input.challenge_id) && typeof input.challenge == "string" && HEX64.test(input.challenge) && iso(input.issued_at) && iso(input.expires_at), "exercise_invalid"), requireCondition(Number.isFinite(nowMs) && Date.parse(input.expires_at) - Date.parse(input.issued_at) === PUBLIC_EXERCISE_TTL_MS && Date.parse(input.issued_at) <= nowMs + 3e4, "exercise_invalid"), requireCondition(Date.parse(input.expires_at) > nowMs, "exercise_expired"), { schema: PUBLIC_EXERCISE_SCHEMA, task: SESSIONS_PROOFS_TASK, challenge_id: input.challenge_id, challenge: input.challenge, issued_at: input.issued_at, expires_at: input.expires_at, provider: SESSIONS_PROOFS_PROVIDER };
+}
+async function runSessionsSelfTest() {
+  let found = verifyProvider(PROOFS_FIXTURE, PROOFS_FIXTURE.provider_did), wrong = verifyProvider(PROOFS_FIXTURE, WRONG_PIN), altered = verifyProvider({ ...PROOFS_FIXTURE, accept_url: "https://changed.example.test/accept" }, PROOFS_FIXTURE.provider_did), digest = found.ok ? await sha256Hex(canonicalBytes(found.provider.manifest)) : null, checks = { signed_manifest_verified: found.ok, wrong_pin_refused: !wrong.ok && wrong.reason === "manifest_did_not_pinned", changed_manifest_refused: !altered.ok && altered.reason === "manifest_signature_invalid", canonical_digest_matches: digest === PROOFS_FIXTURE_DIGEST };
+  return { schema: "voidly.session.self-test/v1", ok: Object.values(checks).every(Boolean), mode: "offline", checks, network_requests: 0, saved_proof: false };
+}
+async function verifyPublicExercise(exercise, index, manifest, nowMs = Date.now()) {
+  let parsed = parsePublicExercise(JSON.stringify(exercise), nowMs);
+  requireCondition(plain(index) && Array.isArray(index.providers) && index.providers.length <= 1e3 && index.providers.some((entry) => plain(entry) && entry.provider_did === SESSIONS_PROOFS_PROVIDER.provider_did && entry.manifest_url === SESSIONS_PROOFS_PROVIDER.manifest_url), "provider_not_listed");
+  let verified = verifyProvider(manifest, SESSIONS_PROOFS_PROVIDER.provider_did);
+  requireCondition(verified.ok, "manifest_invalid");
+  let wrong = verifyProvider(verified.provider.manifest, WRONG_PIN);
+  requireCondition(!wrong.ok && wrong.reason === "manifest_did_not_pinned", "wrong_pin_not_refused");
+  let manifest_digest_sha256 = await sha256Hex(canonicalBytes(verified.provider.manifest)), challenge_response_sha256 = await sha256Hex(canonicalBytes({ schema: PUBLIC_RESPONSE_SCHEMA, task: parsed.task, challenge_id: parsed.challenge_id, challenge: parsed.challenge, manifest_digest_sha256 }));
+  return { schema: PUBLIC_RESULT_SCHEMA, task: parsed.task, challenge_id: parsed.challenge_id, challenge: parsed.challenge, manifest_digest_sha256, challenge_response_sha256, checks: { provider_pair_listed: true, manifest_verified: true, wrong_pin_refused: true } };
+}
+async function readFixedJson(url, maxBytes, fetchImpl) {
+  let controller = new AbortController(), timer, reader, response, deadlineAt = performance.now() + 8e3, deadline = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      controller.abort(), reject(new PublicExerciseError("upstream_unavailable"));
+    }, 8e3);
+  });
+  try {
+    let fetched = Promise.resolve(fetchImpl(url, { method: "GET", headers: { accept: "application/json" }, redirect: "error", credentials: "omit", cache: "no-store", referrerPolicy: "no-referrer", signal: controller.signal })).then((value) => {
+      if (controller.signal.aborted) throw value.body && !value.body.locked && value.body.cancel().catch(() => {
+      }), new PublicExerciseError("upstream_unavailable");
+      return value;
+    });
+    response = await Promise.race([fetched, deadline]), requireCondition(performance.now() < deadlineAt, "upstream_unavailable"), requireCondition(!response.redirected && (response.url === "" || response.url === url), "upstream_redirect"), requireCondition(response.ok && response.body, "upstream_unavailable"), requireCondition(/^application\/json(?:\s*;|$)/i.test(response.headers.get("content-type") ?? ""), "upstream_not_json");
+    let contentLength = response.headers.get("content-length");
+    requireCondition(contentLength === null || /^\d+$/.test(contentLength) && Number(contentLength) <= maxBytes, "upstream_too_large"), reader = response.body.getReader();
+    let chunks = [], size = 0, reads = 0, emptyReads = 0;
+    for (; ; ) {
+      requireCondition(performance.now() < deadlineAt, "upstream_unavailable"), requireCondition(++reads <= 2048, "upstream_too_large");
+      let part = await Promise.race([reader.read(), deadline]);
+      if (requireCondition(performance.now() < deadlineAt, "upstream_unavailable"), part.done) break;
+      if (part.value.byteLength === 0) {
+        requireCondition(++emptyReads <= 128, "upstream_too_large");
+        continue;
+      }
+      size += part.value.byteLength, requireCondition(size <= maxBytes, "upstream_too_large"), chunks.push(part.value);
+    }
+    let bytes = new Uint8Array(size), offset = 0;
+    for (let chunk of chunks) bytes.set(chunk, offset), offset += chunk.byteLength;
+    try {
+      return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    } catch {
+      throw new PublicExerciseError("upstream_not_json");
+    }
+  } catch (error) {
+    throw error instanceof PublicExerciseError ? error : new PublicExerciseError("upstream_unavailable");
+  } finally {
+    clearTimeout(timer), controller.abort(), reader ? (reader.cancel().catch(() => {
+    }), reader.releaseLock()) : response?.body && !response.body.locked && response.body.cancel().catch(() => {
+    });
+  }
+}
+async function runPublicExercise(text, options = {}) {
+  let nowMs = options.nowMs ?? Date.now(), exercise = parsePublicExercise(text, nowMs), fetchImpl = options.fetchImpl ?? fetch, index = await readFixedJson(SESSIONS_PROOFS_PROVIDER.index_url, 262144, fetchImpl), manifest = await readFixedJson(SESSIONS_PROOFS_PROVIDER.manifest_url, 65536, fetchImpl);
+  return verifyPublicExercise(exercise, index, manifest, options.nowMs ?? Date.now());
+}
+var AUTOMATIC_HANDOFF_SCHEMA = "voidpay.proof-collection.agent-handoff/v4", AUTOMATIC_TASK = Object.freeze({ id: "sessions-auto-save-01", version: 1, acceptance_rule_sha256: "b58e042e088740892856e96f4c8eee079bd94819c518e8e486ef250184ffb230" }), AUTOMATIC_BASE = "https://api.voidly.ai/v4/proofs/collections", AUTOMATIC_ISSUER = "https://api.voidly.ai/v2/proofs/collections/issuer", AUTOMATIC_RECEIPT_DOMAIN = `voidpay-proof-collection-receipt/v4
+`, AUTOMATIC_RUN_BINDING_DOMAIN = `voidpay-proof-collection-run-binding/v4
+`, AUTOMATIC_SCOPE = "public-provider-discovery-and-owner-preauthorized-private-save-only", AUTOMATIC_HANDOFF_MAX_BYTES = 1024, AUTOMATIC_BOUNDARY = Object.freeze({ decision: "STOP", wallet_required: false, payment_action_allowed: false, authorization_created: false, transaction_broadcast: false, settlement_observed: false, reward_offered: false, reward_amount: "0", reward_asset: null, customer_identity_verified: false, commercial_transaction: false, credited_to_traction_metrics: false, unique_person_verified: false, impact_verified: false }), SERVER_CHECKS = ["owner_preauthorized", "challenge_unexpired", "provider_pair_listed", "manifest_verified", "wrong_pin_refused"], CLAIMANT_CHECKS = ["manifest_digest_matches", "challenge_response_matches"], HEX322 = /^[0-9a-f]{32}$/, HEX642 = /^[0-9a-f]{64}$/, RETENTION_MS = 15552e6, MAX_RESPONSE_BYTES = 32768, MAX_ATTEMPTS = 3, AutomaticProofError = class extends Error {
+  constructor(code) {
+    super(code);
+    this.code = code;
+    this.name = "AutomaticProofError";
+  }
+}, AutomaticHttpError = class extends AutomaticProofError {
+  constructor(code, status) {
+    super(code);
+    this.status = status;
+  }
+};
+function requireCondition2(value, code) {
+  if (!value) throw new AutomaticProofError(code);
+}
+function exact2(value, keys) {
+  return value !== null && typeof value == "object" && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null) && Object.keys(value).length === keys.length && keys.every((key) => Object.prototype.hasOwnProperty.call(value, key));
+}
+function same2(value, expected) {
+  return exact2(value, Object.keys(expected)) && JSON.stringify(value, Object.keys(expected).sort()) === JSON.stringify(expected, Object.keys(expected).sort());
+}
+function iso2(value) {
+  return typeof value == "string" && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(value) && Number.isFinite(Date.parse(value)) && new Date(value).toISOString() === value;
+}
+function unhex(value) {
+  return Uint8Array.from(value.match(/../g) ?? [], (pair) => Number.parseInt(pair, 16));
+}
+function parseAutomaticHandoff(text) {
+  requireCondition2(typeof text == "string" && new TextEncoder().encode(text).length <= AUTOMATIC_HANDOFF_MAX_BYTES, "handoff_invalid");
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    throw new AutomaticProofError("handoff_invalid");
+  }
+  return requireCondition2(exact2(value, ["schema", "run_id", "completion_capability"]) && value.schema === AUTOMATIC_HANDOFF_SCHEMA && typeof value.run_id == "string" && HEX322.test(value.run_id) && typeof value.completion_capability == "string" && HEX642.test(value.completion_capability), "handoff_invalid"), { schema: AUTOMATIC_HANDOFF_SCHEMA, run_id: value.run_id, completion_capability: value.completion_capability };
+}
+async function requestJson(kind, handoff, body, fetchImpl) {
+  let url = kind === "issuer" ? AUTOMATIC_ISSUER : `${AUTOMATIC_BASE}/${kind}`, controller = new AbortController(), timer, reader, response, deadlineAt = performance.now() + (kind === "submit" ? 2e4 : 1e4), deadline = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      controller.abort(), reject(new AutomaticProofError("completion_unavailable"));
+    }, kind === "submit" ? 2e4 : 1e4);
+  });
+  try {
+    let headers = { accept: "application/json" };
+    kind !== "issuer" && (headers["content-type"] = "application/json", headers.authorization = `Bearer ${handoff.completion_capability}`);
+    let fetched = Promise.resolve(fetchImpl(url, { method: kind === "issuer" ? "GET" : "POST", headers, ...kind === "issuer" ? {} : { body: JSON.stringify(body) }, redirect: "error", credentials: "omit", cache: "no-store", referrerPolicy: "no-referrer", signal: controller.signal })).then((value2) => {
+      if (controller.signal.aborted) throw value2.body && !value2.body.locked && value2.body.cancel().catch(() => {
+      }), new AutomaticProofError("completion_unavailable");
+      return value2;
+    });
+    response = await Promise.race([fetched, deadline]), requireCondition2(performance.now() < deadlineAt, "completion_unavailable"), requireCondition2(!response.redirected && response.type !== "opaqueredirect" && (response.url === "" || response.url === url) && response.status !== 0 && !(response.status >= 300 && response.status < 400), "response_invalid"), requireCondition2(/^application\/json(?:\s*;|$)/i.test(response.headers.get("content-type") ?? "") && response.body, "response_invalid");
+    let length = response.headers.get("content-length");
+    requireCondition2(length === null || /^\d+$/.test(length) && Number(length) <= MAX_RESPONSE_BYTES, "response_invalid"), reader = response.body.getReader();
+    let chunks = [], size = 0, reads = 0, emptyReads = 0;
+    for (; ; ) {
+      requireCondition2(performance.now() < deadlineAt, "completion_unavailable"), requireCondition2(++reads <= 2048, "response_invalid");
+      let next = await Promise.race([reader.read(), deadline]);
+      if (requireCondition2(performance.now() < deadlineAt, "completion_unavailable"), next.done) break;
+      if (next.value.byteLength === 0) {
+        requireCondition2(++emptyReads <= 128, "response_invalid");
+        continue;
+      }
+      size += next.value.byteLength, requireCondition2(size <= MAX_RESPONSE_BYTES, "response_invalid"), chunks.push(next.value);
+    }
+    let bytes = new Uint8Array(size), offset = 0;
+    for (let chunk of chunks) bytes.set(chunk, offset), offset += chunk.byteLength;
+    let value;
+    try {
+      value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    } catch {
+      throw new AutomaticProofError("response_invalid");
+    }
+    if (requireCondition2(!JSON.stringify(value).includes(handoff.completion_capability), "response_invalid"), !response.ok) {
+      requireCondition2(exact2(value, ["schema", "ok", "error"]) && value.schema === "voidpay.proof-collection.error/v4" && value.ok === false && exact2(value.error, ["code"]) && typeof value.error.code == "string", "response_invalid");
+      let code = response.status === 401 || response.status === 403 ? "permission_refused" : response.status === 404 || response.status === 410 ? "run_expired_or_revoked" : response.status === 429 ? value.error.code === "verifier_attempts_exhausted" ? "attempts_exhausted" : "rate_limited" : "completion_unavailable";
+      throw new AutomaticHttpError(code, response.status);
+    }
+    return value;
+  } catch (error) {
+    throw error instanceof AutomaticProofError ? error : new AutomaticProofError("completion_unavailable");
+  } finally {
+    clearTimeout(timer), controller.abort(), reader ? (reader.cancel().catch(() => {
+    }), reader.releaseLock()) : response?.body && !response.body.locked && response.body.cancel().catch(() => {
+    });
+  }
+}
+async function issuerKeys(handoff, fetchImpl) {
+  let value = await requestJson("issuer", handoff, void 0, fetchImpl);
+  requireCondition2(exact2(value, ["schema", "issuer", "keys", "unknown_key_policy"]) && value.schema === "voidpay.proof-collection.issuer/v2" && value.issuer === AUTOMATIC_ISSUER && value.unknown_key_policy === "untrusted; never trust an embedded receipt key" && Array.isArray(value.keys) && value.keys.length > 0 && value.keys.length <= 8, "issuer_invalid");
+  let keys = /* @__PURE__ */ new Map();
+  for (let key of value.keys) requireCondition2(exact2(key, ["issuer", "key_id", "algorithm", "public_key_hex", "status"]) && key.issuer === AUTOMATIC_ISSUER && key.algorithm === "Ed25519" && key.status === "active" && typeof key.key_id == "string" && HEX642.test(key.key_id) && typeof key.public_key_hex == "string" && HEX642.test(key.public_key_hex) && !keys.has(key.key_id) && await sha256Hex(unhex(key.public_key_hex)) === key.key_id, "issuer_invalid"), keys.set(key.key_id, key.public_key_hex);
+  return keys;
+}
+async function verifyComplete(value, handoff, fetchImpl, now) {
+  requireCondition2(exact2(value, ["schema", "ok", "status", "run_id", "exercise", "record", "already_completed"]) && value.schema === "voidpay.proof-collection.result/v4" && value.ok === true && value.status === "complete" && value.run_id === handoff.run_id && typeof value.already_completed == "boolean", "response_invalid");
+  let record = value.record;
+  requireCondition2(exact2(record, ["event_id", "visibility", "public_url", "expires_at", "receipt"]) && typeof record.event_id == "string" && HEX322.test(record.event_id) && iso2(record.expires_at) && (record.visibility === "private" || record.visibility === "public") && (value.already_completed || record.visibility === "private") && record.public_url === (record.visibility === "private" ? null : `https://api.voidly.ai/v2/proofs/collections/public/${record.event_id}`) && exact2(record.receipt, ["statement", "signature_hex"]), "receipt_invalid");
+  let receipt = record.receipt, s = receipt.statement;
+  requireCondition2(exact2(s, ["schema", "issuer", "key_id", "event_id", "run_binding_sha256", "exercise_binding_sha256", "artwork", "task", "computation_task", "checked_at", "completed_at", "outcome", "checks", "provider", "scope", "boundary"]) && s.schema === "voidpay.proof-collection.receipt/v4" && s.issuer === AUTOMATIC_ISSUER && s.event_id === record.event_id && typeof s.key_id == "string" && HEX642.test(s.key_id) && typeof s.run_binding_sha256 == "string" && HEX642.test(s.run_binding_sha256) && typeof s.exercise_binding_sha256 == "string" && HEX642.test(s.exercise_binding_sha256) && typeof receipt.signature_hex == "string" && /^[0-9a-f]{128}$/.test(receipt.signature_hex) && same2(s.task, AUTOMATIC_TASK) && same2(s.computation_task, SESSIONS_PROOFS_TASK) && s.scope === AUTOMATIC_SCOPE && same2(s.boundary, AUTOMATIC_BOUNDARY) && s.outcome === "PASS" && iso2(s.checked_at) && iso2(s.completed_at) && s.checked_at <= s.completed_at && Date.parse(s.completed_at) <= now + 3e4 && Date.parse(record.expires_at) === Date.parse(s.completed_at) + RETENTION_MS && Date.parse(record.expires_at) > now && same2(s.provider, { provider_did: SESSIONS_PROOFS_PROVIDER.provider_did, manifest_url: SESSIONS_PROOFS_PROVIDER.manifest_url }) && same2(s.artwork, { recipe: "contours-v1", seed: record.event_id }) && exact2(s.checks, ["server", "claimant"]) && exact2(s.checks.server, SERVER_CHECKS) && exact2(s.checks.claimant, CLAIMANT_CHECKS) && [...Object.values(s.checks.server), ...Object.values(s.checks.claimant)].every((check) => check === true), "receipt_invalid");
+  let exercise;
+  try {
+    exercise = parsePublicExercise(JSON.stringify(value.exercise), Date.parse(s.checked_at));
+  } catch {
+    throw new AutomaticProofError("receipt_invalid");
+  }
+  requireCondition2(exercise.challenge_id === handoff.run_id && Date.parse(exercise.issued_at) <= Date.parse(s.checked_at) && Date.parse(exercise.expires_at) > Date.parse(s.completed_at) && await sha256Hex(new TextEncoder().encode(AUTOMATIC_RUN_BINDING_DOMAIN + handoff.run_id)) === s.run_binding_sha256 && await sha256Hex(new TextEncoder().encode(automaticCanonicalJson(exercise))) === s.exercise_binding_sha256, "receipt_invalid");
+  let key = (await issuerKeys(handoff, fetchImpl)).get(s.key_id);
+  requireCondition2(key && nacl3.sign.detached.verify(new TextEncoder().encode(AUTOMATIC_RECEIPT_DOMAIN + automaticCanonicalJson(s)), unhex(receipt.signature_hex), unhex(key)), "receipt_invalid");
+  let svg = proofArtworkSvg(record.event_id), result = { schema: "voidly.session.automatic-proof/v1", ok: true, saved_proof: true, event_id: record.event_id, visibility: record.visibility, already_completed: value.already_completed, receipt: JSON.parse(JSON.stringify(receipt)), artwork: { recipe: "contours-v1", seed: record.event_id, svg, sha256: await sha256Hex(new TextEncoder().encode(svg)) }, return_url: "https://voidly.ai/pay/proofs", payment_boundary: "STOP" };
+  return requireCondition2(!JSON.stringify(result).includes(handoff.completion_capability), "response_invalid"), result;
+}
+function pending(value, runId) {
+  return exact2(value, ["schema", "ok", "status", "run_id", "record"]) && value.schema === "voidpay.proof-collection.result/v4" && value.ok === true && value.status === "pending" && value.run_id === runId && value.record === null;
+}
+function transient(error) {
+  return error instanceof AutomaticHttpError ? error.status === 409 || error.status >= 500 : error instanceof AutomaticProofError && error.code === "completion_unavailable";
+}
+async function completeAutomaticProof(text, options = {}) {
+  let handoff = parseAutomaticHandoff(text), fetchImpl = options.fetchImpl ?? fetch, now = () => options.nowMs ?? Date.now();
+  requireCondition2((await runSessionsSelfTest()).ok, "self_test_failed");
+  let mayHaveSaved = false;
+  try {
+    for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) try {
+      let existing = await requestJson("result", handoff, { run_id: handoff.run_id }, fetchImpl);
+      if (!pending(existing, handoff.run_id)) return await verifyComplete(existing, handoff, fetchImpl, now());
+      let fresh = await requestJson("exercise", handoff, { run_id: handoff.run_id }, fetchImpl);
+      if (exact2(fresh, ["schema", "ok", "status", "run_id", "exercise", "record", "already_completed"])) return await verifyComplete(fresh, handoff, fetchImpl, now());
+      requireCondition2(exact2(fresh, ["schema", "ok", "action", "run_id", "exercise"]) && fresh.schema === "voidpay.proof-collection.response/v4" && fresh.ok === true && fresh.action === "exercise" && fresh.run_id === handoff.run_id, "response_invalid");
+      let exercise = parsePublicExercise(JSON.stringify(fresh.exercise), now());
+      requireCondition2(exercise.challenge_id === handoff.run_id, "response_invalid");
+      let result = await runPublicExercise(JSON.stringify(exercise), { fetchImpl, nowMs: options.nowMs });
+      mayHaveSaved = true;
+      let completed = await requestJson("submit", handoff, { run_id: handoff.run_id, result }, fetchImpl);
+      return await verifyComplete(completed, handoff, fetchImpl, now());
+    } catch (error) {
+      if (error instanceof PublicExerciseError) {
+        if (error.code !== "upstream_unavailable") throw new AutomaticProofError("provider_check_failed");
+        error = new AutomaticProofError("completion_unavailable");
+      }
+      if (!transient(error)) throw error;
+      attempt < MAX_ATTEMPTS - 1 && await new Promise((resolve) => setTimeout(resolve, 1e3));
+    }
+    if (mayHaveSaved) try {
+      let existing = await requestJson("result", handoff, { run_id: handoff.run_id }, fetchImpl);
+      if (!pending(existing, handoff.run_id)) return await verifyComplete(existing, handoff, fetchImpl, now());
+    } catch (error) {
+      if (!transient(error)) throw error;
+    }
+    throw new AutomaticProofError(mayHaveSaved ? "completion_uncertain" : "completion_unavailable");
+  } finally {
+    handoff.completion_capability = "";
+  }
+}
+export {
+  AUTOMATIC_BASE,
+  AUTOMATIC_BOUNDARY,
+  AUTOMATIC_HANDOFF_MAX_BYTES,
+  AUTOMATIC_HANDOFF_SCHEMA,
+  AUTOMATIC_ISSUER,
+  AUTOMATIC_RECEIPT_DOMAIN,
+  AUTOMATIC_RUN_BINDING_DOMAIN,
+  AUTOMATIC_SCOPE,
+  AUTOMATIC_TASK,
+  AutomaticProofError,
+  completeAutomaticProof,
+  parseAutomaticHandoff
+};