@dvmkit/sdk 0.1.3-rc.7 → 0.1.4-rc.7

package/dist/{chunk-3ZHMQCYP.js → chunk-QK3VJNCK.js}

@@ -35,7 +35,7 @@ import {
   localMessage,
   providerMessage,
   toJobRecord
-} from "./chunk-4B56DEEV.js";
+} from "./chunk-U6M3ATSG.js";
 import {
   ADMIN_AUTH_CLOCK_SKEW_SECONDS,
   ADMIN_AUTH_NONCE_TTL_SECONDS,
@@ -59,7 +59,7 @@ import {
   toLockPubkey,
   verifyCashuToken,
   verifyChallenge
-} from "./chunk-2K7E3N2D.js";
+} from "./chunk-VRQDX5P4.js";
 import {
   X402_BATCH_SETTLEMENT_SCHEME,
   X402_DEFAULT_FACILITATOR,
@@ -99,7 +99,7 @@ import {
   pinDimension,
   withSpan,
   withTraceContext
-} from "./chunk-YDIYXGYL.js";
+} from "./chunk-E4EVGPDX.js";
 import {
   FxRateUnavailableError,
   InvalidCurrencyError,
@@ -6360,8 +6360,8 @@ function authErrorBody(err, opts = {}) {
     hint: "Regenerate the request with the current timestamp + a fresh nonce; sign with secp256k1+BIP-340 Schnorr over the canonical JSON form of the input."
   };
 }
-function infoSchemaUrl(requestUrl) {
-  return `${new URL(requestUrl).origin}/v1/info`;
+function infoSchemaUrl(requestUrl, publicOrigin) {
+  return `${publicOrigin ?? new URL(requestUrl).origin}/v1/info`;
 }
 function callerInputIssues(issues) {
   if (!issues) return [];
@@ -9118,6 +9118,7 @@ function isRecord2(value) {
 import { randomBytes as randomBytes4 } from "crypto";
 
 // src/sdk/server/context.ts
+import { AsyncLocalStorage } from "async_hooks";
 import { randomBytes as randomBytes3 } from "crypto";
 
 // src/sdk/server/instrumented-kv.ts
@@ -9160,6 +9161,7 @@ function instrumentKVStore(inner) {
 }
 
 // src/sdk/server/context.ts
+var stepCostScope = new AsyncLocalStorage();
 function buildContext(job, opts) {
   const log = createConsoleLogger(job.id);
   const instrumentedStore = instrumentKVStore(opts.store);
@@ -9180,6 +9182,45 @@ function buildContext(job, opts) {
   let creditedToHandlerMsats = 0;
   let creditedToHandlerMicro = 0;
   let poolBasis = false;
+  let declaredCostAmount = 0;
+  let declaredCostCurrency;
+  let declaredCostRevision = 0;
+  let costPoisoned = false;
+  const stepCostOwner = {};
+  const declareCost = (declared) => {
+    if (terminated("cost")) return;
+    const currency = validateCurrency(declared.currency);
+    const total = declaredCostAmount + declared.amount;
+    const micro = Math.round(total * 1e6);
+    if (!Number.isFinite(declared.amount) || declared.amount < 0 || !Number.isSafeInteger(micro)) {
+      throw new RangeError(
+        `ctx.cost amounts must each be a finite, non-negative number of currency units, and must total no more than ${Math.floor(Number.MAX_SAFE_INTEGER / 1e6)}; got ${String(declared.amount)}`
+      );
+    }
+    declaredCostRevision += 1;
+    job.costRevision = declaredCostRevision;
+    const replayable = { amount: declared.amount, currency };
+    const scope = stepCostScope.getStore();
+    if (scope?.owner === stepCostOwner) {
+      for (const frame of scope.frames) frame.push(replayable);
+    }
+    if (declaredCostCurrency !== void 0 && declaredCostCurrency !== currency) {
+      costPoisoned = true;
+      log.error("ctx.cost() currency switched mid-job \u2014 this job reports no cost", {
+        declared: currency,
+        pinned: declaredCostCurrency
+      });
+    }
+    declaredCostCurrency ??= currency;
+    if (costPoisoned) {
+      job.costAmountMicro = void 0;
+      job.costCurrency = void 0;
+      return;
+    }
+    declaredCostAmount = total;
+    job.costAmountMicro = micro;
+    job.costCurrency = currency;
+  };
   return {
     jobId: job.id,
     tags: job.tags,
@@ -9572,10 +9613,21 @@ function buildContext(job, opts) {
       providerMessage(job, "cancel", { reason: error });
       runTerminal();
     },
+    cost: declareCost,
     step: async (id, fn) => {
-      if (job.stepCache.has(id)) return job.stepCache.get(id);
-      const result = await fn();
-      job.stepCache.set(id, result);
+      if (job.stepCache.has(id)) {
+        const record = job.stepCache.getRecord(id);
+        for (const declared of record.costs ?? []) declareCost(declared);
+        return record.value;
+      }
+      const costs = [];
+      const scope = stepCostScope.getStore();
+      const parentFrames = scope?.owner === stepCostOwner ? scope.frames : [];
+      const result = await stepCostScope.run(
+        { owner: stepCostOwner, frames: [...parentFrames, costs] },
+        fn
+      );
+      job.stepCache.set(id, result, costs);
       return result;
     },
     state: job.state,
@@ -9941,6 +9993,9 @@ async function reapExpiredKeysetRows(opts, db) {
 // src/sdk/server/job-manager.ts
 var STALE_JOB_WATCHDOG_HEADROOM_MS = 9e4;
 var DEFAULT_PROCESSING_WATCHDOG_MS = 5 * 6e4;
+var TERMINAL_COST_RECOVERY_BATCH = 100;
+var TERMINAL_COST_RECOVERY_MAX_PAGES = 10;
+var TERMINAL_COST_RECOVERY_INTERVAL_MS = 3e4;
 var DEFAULT_HEARTBEAT_INTERVAL_MS = 3e4;
 var DEFAULT_REACTIVATION_CLAIM_GRACE_MS = 150;
 var REACTIVATION_CLAIM_POLL_MS = 25;
@@ -9959,7 +10014,12 @@ var ORPHAN_SWEEP_CLAIMS = /* @__PURE__ */ new WeakSet();
 var ATTACH_RAILS = ["cashu", "x402", "tempo"];
 var CREDIT_INBOUND_ATTEMPTS = 3;
 var CREDIT_INBOUND_BACKOFF_MS = 50;
+var TERMINAL_COST_HANDOFF_RETRY_INITIAL_MS = 100;
+var TERMINAL_COST_HANDOFF_RETRY_MAX_MS = 3e4;
 var CREDIT_INBOUND_READ_ATTEMPTS = 2;
+function isTerminalCostRecoveryStore(store) {
+  return "saveForDvm" in store && "listUnreportedTerminalCosts" in store && "markTerminalCostReported" in store;
+}
 var JobManager = class {
   descriptor;
   opts;
@@ -9967,6 +10027,8 @@ var JobManager = class {
   jobStore;
   idleTimers = /* @__PURE__ */ new Map();
   cleanupTimers = /* @__PURE__ */ new Map();
+  /** Cost revisions held only by a terminal handler owner until its durable merge succeeds. */
+  terminalCostHandoffRetryTimers = /* @__PURE__ */ new Map();
   /** Per-job NOTIFY unsubscribe handles for the durable-status watch (internal-review). */
   statusWatchers = /* @__PURE__ */ new Map();
   /** Job ids whose durable-status re-read is in flight — coalesces notify storms (internal-review). */
@@ -9990,6 +10052,7 @@ var JobManager = class {
   staleSweepTimer;
   heartbeatTimer;
   orphanDrawSweepTimer;
+  terminalCostRecoveryTimer;
   jobRetentionSweepTimer;
   jobRetentionBootTimer;
   /** This manager holds {@link ORPHAN_SWEEP_CLAIMS} for its ledger. */
@@ -10007,6 +10070,8 @@ var JobManager = class {
   monotonicNowMs = createMonotonicClock();
   sweepInFlight = false;
   orphanSweepInFlight = false;
+  terminalCostRecoveryInFlight = false;
+  terminalCostRecoveryResumeAfter;
   jobRetentionSweepInFlight = false;
   heartbeatInFlight = false;
   /**
@@ -10132,6 +10197,19 @@ var JobManager = class {
         }
       }
     }
+    if (opts.dvmId && opts.onJobCost && isTerminalCostRecoveryStore(this.jobStore)) {
+      this.terminalCostRecoveryTimer = setInterval(() => {
+        void this.recoverTerminalCosts().catch((err) => {
+          console.error(
+            JSON.stringify({
+              level: "terminal_cost_recovery_failed",
+              error: err instanceof Error ? err.message : String(err)
+            })
+          );
+        });
+      }, TERMINAL_COST_RECOVERY_INTERVAL_MS);
+      this.terminalCostRecoveryTimer.unref();
+    }
   }
   /** Active in-memory jobs. */
   get activeJobs() {
@@ -10431,7 +10509,11 @@ var JobManager = class {
         record.seq = Math.max(record.seq, highSeq);
       }
     }
-    await this.jobStore.save(record);
+    if (this.opts.dvmId && isTerminalCostRecoveryStore(this.jobStore)) {
+      await this.jobStore.saveForDvm(record, this.opts.dvmId);
+    } else {
+      await this.jobStore.save(record);
+    }
   }
   /**
    * Cross-machine terminal guard (internal-review). `buildContext`'s guard reads the
@@ -10472,6 +10554,7 @@ var JobManager = class {
     job.pendingPrompts.clear();
     job.pendingPayment = null;
     abortJob(job, reason);
+    const terminalCostPersisted = durable.status === "completed" ? true : await this.tryPersistAdoptedTerminalCost(job, 1);
     if (durable.status !== "completed") {
       localMessage(job, "provider", "cancel", { reason });
     }
@@ -10486,8 +10569,78 @@ var JobManager = class {
     this.clearIdleTimer(job.id);
     void this.issueReceiptForStoredJob(job.id);
     this.scheduleCleanup(job);
+    if (durable.status !== "completed" && terminalCostPersisted) {
+      await this.reportJobCost(job);
+    }
     return true;
   }
+  /**
+   * Persist an adopted terminal cost, retaining the in-memory revision for a
+   * later retry when the durable store is transiently unavailable.
+   */
+  async tryPersistAdoptedTerminalCost(job, attempt) {
+    try {
+      await this.persistAdoptedTerminalCost(job);
+      return true;
+    } catch (err) {
+      this.scheduleTerminalCostHandoffRetry(job, attempt, err);
+      return false;
+    }
+  }
+  /** Retry outside the status watcher, which correctly stops once the job is terminal. */
+  scheduleTerminalCostHandoffRetry(job, attempt, err) {
+    if (this.terminalCostHandoffRetryTimers.has(job.id)) return;
+    const delayMs = Math.min(
+      TERMINAL_COST_HANDOFF_RETRY_INITIAL_MS * 2 ** Math.min(attempt - 1, 8),
+      TERMINAL_COST_HANDOFF_RETRY_MAX_MS
+    );
+    console.error(
+      JSON.stringify({
+        level: "terminal_cost_handoff_retry_scheduled",
+        jobId: job.id,
+        attempt,
+        delayMs,
+        error: err instanceof Error ? err.message : String(err)
+      })
+    );
+    const timer = setTimeout(() => {
+      this.terminalCostHandoffRetryTimers.delete(job.id);
+      void this.retryTerminalCostHandoff(job, attempt + 1);
+    }, delayMs);
+    timer.unref();
+    this.terminalCostHandoffRetryTimers.set(job.id, timer);
+  }
+  async retryTerminalCostHandoff(job, attempt) {
+    if (!await this.tryPersistAdoptedTerminalCost(job, attempt)) return;
+    await this.reportJobCost(job);
+  }
+  /** Durably merge a terminal handler owner's latest cost before reporting it. */
+  async persistAdoptedTerminalCost(job) {
+    const dvmId = this.opts.dvmId;
+    const localRevision = job.costRevision;
+    if (localRevision === void 0 || !dvmId || !isTerminalCostRecoveryStore(this.jobStore)) {
+      return;
+    }
+    const durable = await this.jobStore.get(job.id);
+    if (!durable || durable.status !== job.status) {
+      throw new Error(`Terminal cost merge lost durable job ${job.id}`);
+    }
+    if ((durable.costRevision ?? -1) > localRevision) {
+      job.costAmountMicro = durable.costAmountMicro;
+      job.costCurrency = durable.costCurrency;
+      job.costRevision = durable.costRevision;
+      return;
+    }
+    await this.jobStore.saveForDvm(
+      {
+        ...durable,
+        costAmountMicro: job.costAmountMicro,
+        costCurrency: job.costCurrency,
+        costRevision: localRevision
+      },
+      dvmId
+    );
+  }
   /**
    * Watch the durable status of a locally-active job (internal-review).
    *
@@ -10763,7 +10916,7 @@ var JobManager = class {
         );
         if (claimed) {
           swept++;
-          await this.issueReceiptForStoredJob(record.id);
+          await this.finalizeStoredTerminal(record.id);
           console.warn(
             JSON.stringify({
               level: awaiting ? "stale_job_cancelled" : "stale_job_failed",
@@ -12135,6 +12288,7 @@ var JobManager = class {
   async finalizeTerminal(job) {
     await this.attachReceipt(job);
     await this.persistJob(job).catch(() => void 0);
+    await this.reportJobCost(job);
   }
   /**
    * Issue a receipt for a job this process doesn't hold in `activeJobs` — a
@@ -12151,13 +12305,117 @@ var JobManager = class {
     if (active && receipt) active.receipt = receipt;
     return receipt;
   }
+  /**
+   * Finish accounting for a terminal written directly to the store — the
+   * stale reaper and a cancel handled on a different machine (internal-review).
+   */
+  async finalizeStoredTerminal(jobId) {
+    const receipt = await this.issueReceiptForStoredJob(jobId);
+    const record = await this.jobStore.get(jobId).catch(() => void 0);
+    if (record && isTerminal(record.status)) await this.reportJobCost(record);
+    return receipt;
+  }
   /** Handle job reaching terminal state (completed, failed, cancelled). */
   async handleJobTerminal(job) {
     this.clearIdleTimer(job.id);
     await this.attachReceipt(job);
-    await this.bookRevenue(job);
+    const booked = await this.bookRevenue(job);
+    if (!booked) await this.reportJobCost(job);
     this.scheduleCleanup(job);
   }
+  /**
+   * Re-enqueue terminal cost-only rows left between the job commit and outbox
+   * insert. The marker advances only after `onJobCost` resolves, which for the
+   * SDK reporter means the local durable insert has committed; a crash after
+   * that insert but before the marker can duplicate a payload, but the
+   * revisioned platform contract makes that replay harmless.
+   */
+  async recoverTerminalCosts() {
+    const store = this.jobStore;
+    const dvmId = this.opts.dvmId;
+    if (!dvmId || !this.opts.onJobCost || !isTerminalCostRecoveryStore(store)) {
+      return { examined: 0, queued: 0, complete: true };
+    }
+    if (this.terminalCostRecoveryInFlight) {
+      return { examined: 0, queued: 0, complete: false };
+    }
+    this.terminalCostRecoveryInFlight = true;
+    let examined = 0;
+    let queued = 0;
+    let cursor = this.terminalCostRecoveryResumeAfter;
+    try {
+      for (let page = 0; page < TERMINAL_COST_RECOVERY_MAX_PAGES; page++) {
+        const candidates = await store.listUnreportedTerminalCosts({
+          dvmId,
+          limit: TERMINAL_COST_RECOVERY_BATCH,
+          ...cursor ? { afterJobId: cursor } : {}
+        });
+        for (const record of candidates) {
+          examined++;
+          cursor = record.id;
+          if (await this.reportJobCost(record)) queued++;
+        }
+        if (candidates.length < TERMINAL_COST_RECOVERY_BATCH) {
+          this.terminalCostRecoveryResumeAfter = void 0;
+          if (examined > 0) {
+            console.log(
+              JSON.stringify({
+                level: "info",
+                event: "terminal_cost_recovery_complete",
+                dvmId,
+                examined,
+                queued
+              })
+            );
+          }
+          return { examined, queued, complete: true };
+        }
+      }
+      this.terminalCostRecoveryResumeAfter = cursor;
+      console.warn(
+        JSON.stringify({
+          level: "terminal_cost_recovery_truncated",
+          dvmId,
+          examined,
+          queued,
+          resumeAfterJobId: cursor
+        })
+      );
+      return { examined, queued, complete: false };
+    } finally {
+      this.terminalCostRecoveryInFlight = false;
+    }
+  }
+  /** Report the latest declared-cost state only when no revenue event carried it. */
+  async reportJobCost(job) {
+    const onJobCost = this.opts.onJobCost;
+    if (!onJobCost || job.status !== "completed" && job.status !== "failed" && job.status !== "cancelled") {
+      return false;
+    }
+    const costRevision = job.costRevision ?? (job.costAmountMicro !== void 0 && job.costCurrency !== void 0 ? 0 : void 0);
+    if (costRevision === void 0) return false;
+    const payload = {
+      dvmId: this.opts.dvmId ?? "",
+      jobId: job.id,
+      ...job.capability ? { capability: job.capability } : {},
+      outcome: job.status,
+      costRevision,
+      cost: job.costAmountMicro !== void 0 && job.costCurrency !== void 0 ? { amountMicro: job.costAmountMicro, currency: job.costCurrency } : null
+    };
+    try {
+      await onJobCost(payload);
+      if (isTerminalCostRecoveryStore(this.jobStore)) {
+        const marked = await this.jobStore.markTerminalCostReported(job.id, costRevision);
+        if (!marked) {
+          return false;
+        }
+      }
+    } catch (err) {
+      console.error(`[${job.id}] Job cost reporting failed:`, err);
+      return false;
+    }
+    return true;
+  }
   /**
    * Report a completed paid job's revenue (internal-review, re-keyed by internal-review).
    * Fire-and-forget — the `RevenueReporter` owns persistence and retry.
@@ -12296,6 +12554,9 @@ var JobManager = class {
       onJobCompleted({
         dvmId: this.opts.dvmId ?? "",
         jobId: job.id,
+        // Legacy Postgres rows surface a missing capability as `""`. Keep
+        // that absence distinct from every real capability name on the wire.
+        ...job.capability ? { capability: job.capability } : {},
         paidMsats: bookedMsats,
         paymentMint: job.paymentMint,
         rail: job.paymentRail,
@@ -12303,6 +12564,11 @@ var JobManager = class {
         nativeAmount: job.nativeAmount,
         nativeAsset: job.nativeAsset,
         cashuFlow: job.cashuFlow,
+        // Absent unless the handler declared one, and absent is a fact: the
+        // platform shows "no costs reported" rather than a zero cost and a
+        // 100% margin (internal-review). Both halves or neither — a bare amount
+        // in an unnamed currency is not a cost.
+        ...job.costAmountMicro !== void 0 && job.costCurrency !== void 0 ? { cost: { amountMicro: job.costAmountMicro, currency: job.costCurrency } } : {},
         ...credit
       })
     ).catch((err) => {
@@ -12329,6 +12595,10 @@ var JobManager = class {
       clearTimeout(timer);
       this.cleanupTimers.delete(id);
     }
+    for (const [id, timer] of this.terminalCostHandoffRetryTimers) {
+      clearTimeout(timer);
+      this.terminalCostHandoffRetryTimers.delete(id);
+    }
     for (const id of [...this.statusWatchers.keys()]) {
       this.unwatchDurableStatus(id);
     }
@@ -12348,6 +12618,10 @@ var JobManager = class {
       clearInterval(this.orphanDrawSweepTimer);
       this.orphanDrawSweepTimer = void 0;
     }
+    if (this.terminalCostRecoveryTimer) {
+      clearInterval(this.terminalCostRecoveryTimer);
+      this.terminalCostRecoveryTimer = void 0;
+    }
     if (this.jobRetentionBootTimer) {
       clearTimeout(this.jobRetentionBootTimer);
       this.jobRetentionBootTimer = void 0;
@@ -15293,6 +15567,23 @@ function parseSerializedDleq(raw) {
   return { e: dleq.e, s: dleq.s, ...dleq.r !== void 0 ? { r: dleq.r } : {} };
 }
 
+// src/sdk/server/caller-facing-url.ts
+function resolvePublicOrigin(value) {
+  if (!value) return void 0;
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return void 0;
+    return url.origin;
+  } catch {
+    return void 0;
+  }
+}
+function callerFacingRequestUrl(requestUrl, publicOrigin) {
+  if (!publicOrigin) return requestUrl;
+  const request = new URL(requestUrl);
+  return `${publicOrigin}${request.pathname}${request.search}`;
+}
+
 // src/sdk/server/credit-expiry-sweep.ts
 function startCreditExpirySweep(ledger, opts = {}) {
   const sweepExpiredCredits = ledger.sweepExpiredCredits?.bind(ledger);
@@ -16323,7 +16614,7 @@ async function createDVMServer(descriptor, opts) {
   let revenueReporter;
   let payoutReporter;
   if (!opts.onJobCompleted && platformToken && platformUrl && dvmId && opts.db) {
-    const { RevenueReporter } = await import("./revenue-reporter-XXSU5KVB.js");
+    const { RevenueReporter } = await import("./revenue-reporter-ASZ7SHHH.js");
     const reporter = new RevenueReporter(opts.db, platformUrl, platformToken);
     await reporter.init();
     reporter.startRetryLoop();
@@ -16349,6 +16640,7 @@ async function createDVMServer(descriptor, opts) {
     hasPgPool: !!opts.db
   });
   const effectiveOnJobCompleted = opts.onJobCompleted ?? (revenueReporter ? (info) => revenueReporter.report(info) : void 0);
+  const effectiveOnJobCost = opts.onJobCost ?? (revenueReporter ? (info) => revenueReporter.reportCost(info) : void 0);
   const effectiveOnPaidJobDeath = opts.onPaidJobDeath ?? (revenueReporter ? (info) => revenueReporter.reportPaidJobDeath(info) : void 0);
   const effectiveOnRevenueSkippedNoRail = opts.onRevenueSkippedNoRail ?? (revenueReporter ? (info) => revenueReporter.reportRevenueSkippedNoRail(info) : void 0);
   const enqueueCreditDeposit = !opts.onCreditFunded && revenueReporter ? revenueReporter.enqueueDeposit.bind(revenueReporter) : void 0;
@@ -16468,6 +16760,7 @@ async function createDVMServer(descriptor, opts) {
     creditLedger,
     processedPayments,
     onJobCompleted: effectiveOnJobCompleted,
+    onJobCost: effectiveOnJobCost,
     onPaidJobDeath: effectiveOnPaidJobDeath,
     onRevenueSkippedNoRail: effectiveOnRevenueSkippedNoRail,
     onCreditFunded: opts.onCreditFunded,
@@ -16479,6 +16772,7 @@ async function createDVMServer(descriptor, opts) {
     x402ExactSettlement,
     payoutReporter
   });
+  await server.jobManager.recoverTerminalCosts();
   return {
     app: server.app,
     authAudience: server.authAudience,
@@ -16507,6 +16801,8 @@ var DVMServer = class {
   mintHealthTracker;
   descriptor;
   opts;
+  /** Validated `DVMKIT_PUBLIC_URL` origin, or request-derived URLs when absent. */
+  publicOrigin;
   consumedCredentialStore;
   adminCashuNonceStore;
   ownsMintHealthTracker;
@@ -16550,6 +16846,7 @@ var DVMServer = class {
     this.descriptor = descriptor;
     this.pricingCurrency = descriptor.currency ?? "usd";
     this.opts = opts;
+    this.publicOrigin = resolvePublicOrigin(opts.env.DVMKIT_PUBLIC_URL);
     this.authAudience = this.resolveAuthAudience();
     this.x402BatchSettlement = opts.x402BatchSettlement;
     this.x402ExactSettlement = opts.x402ExactSettlement;
@@ -16631,6 +16928,7 @@ var DVMServer = class {
       pricingCurrency: this.pricingCurrency,
       onCreditFunded: opts.onCreditFunded,
       onJobCompleted: opts.onJobCompleted,
+      onJobCost: opts.onJobCost,
       onPaidJobDeath: opts.onPaidJobDeath,
       onRevenueSkippedNoRail: opts.onRevenueSkippedNoRail,
       onJobRetentionSweepFailed: opts.onJobRetentionSweepFailed,
@@ -17368,7 +17666,7 @@ var DVMServer = class {
       x402ExactSettlement: this.x402ExactSettlement,
       x402ExactVersions: x402Support?.exact,
       x402BatchSettlement,
-      x402Resource: c.req.url,
+      x402Resource: callerFacingRequestUrl(c.req.url, this.publicOrigin),
       mppCredential,
       mpp: this.opts.mpp,
       resourcePath: c.req.path,
@@ -17698,7 +17996,8 @@ var DVMServer = class {
             500
           );
         }
-        if (err instanceof SignedRequestError) return buildAuthErrorResponse(c, err);
+        if (err instanceof SignedRequestError)
+          return buildAuthErrorResponse(c, err, this.publicOrigin);
         throw err;
       }
     }
@@ -17723,7 +18022,7 @@ var DVMServer = class {
             { onError: () => ({ "error.code": "invalid_quote_data" }) }
           );
         } catch (err) {
-          const schemaUrl = infoSchemaUrl(c.req.url);
+          const schemaUrl = infoSchemaUrl(c.req.url, this.publicOrigin);
           const { message, hint } = err instanceof z2.ZodError ? humanizeZodError(err, { schemaUrl }) : {
             message: "Quote-input validation failed",
             hint: `Inspect ${schemaUrl} for the expected input schema.`
@@ -17837,7 +18136,7 @@ var DVMServer = class {
    */
   requireCapabilityFromBody(c, capability) {
     const known = this.jobManager.capabilityNames();
-    const infoUrl = `${new URL(c.req.url).origin}/v1/info`;
+    const infoUrl = infoSchemaUrl(c.req.url, this.publicOrigin);
     if (typeof capability !== "string" || capability.length === 0) {
       return {
         error: c.json(
@@ -17878,7 +18177,7 @@ var DVMServer = class {
     try {
       return { body: await c.req.json() };
     } catch {
-      const infoUrl = `${new URL(c.req.url).origin}/v1/info`;
+      const infoUrl = infoSchemaUrl(c.req.url, this.publicOrigin);
       return {
         error: c.json(
           {
@@ -17913,7 +18212,7 @@ var DVMServer = class {
    * relayed to a human don't change with the status.
    */
   invalidInputResponse(c, err) {
-    const schemaUrl = infoSchemaUrl(c.req.url);
+    const schemaUrl = infoSchemaUrl(c.req.url, this.publicOrigin);
     const issues = zodIssuesOf(err);
     if (issues) {
       const inputIssues = callerInputIssues(issues);
@@ -18027,7 +18326,8 @@ var DVMServer = class {
           500
         );
       }
-      if (error instanceof SignedRequestError) return buildAuthErrorResponse(c, error);
+      if (error instanceof SignedRequestError)
+        return buildAuthErrorResponse(c, error, this.publicOrigin);
       throw error;
     }
     const signedRequestId = requestIdFromEnvelope(body.data);
@@ -18081,6 +18381,7 @@ var DVMServer = class {
     const capabilityResult = this.requireCapabilityFromBody(c, body.capability);
     if ("error" in capabilityResult) return capabilityResult.error;
     const capabilityName = capabilityResult.name;
+    pinDimension("capability", capabilityName);
     const cap = this.descriptor.capabilities[capabilityName];
     let parsedInput;
     let deferredInputError;
@@ -18145,7 +18446,8 @@ var DVMServer = class {
             500
           );
         }
-        if (err instanceof SignedRequestError) return buildAuthErrorResponse(c, err);
+        if (err instanceof SignedRequestError)
+          return buildAuthErrorResponse(c, err, this.publicOrigin);
         throw err;
       }
     }
@@ -18378,7 +18680,7 @@ var DVMServer = class {
         } catch (err) {
           if (err instanceof SignedRequestError && err.sub_reason === "replay_detected" && exactAdmission?.replayed) {
           } else if (err instanceof SignedRequestError) {
-            return buildAuthErrorResponse(c, err);
+            return buildAuthErrorResponse(c, err, this.publicOrigin);
           } else {
             throw err;
           }
@@ -18936,8 +19238,7 @@ var DVMServer = class {
         summary,
         lastActivityAt: Date.now()
       });
-      const baseUrl = new URL(c.req.url);
-      const infoUrl = `${baseUrl.origin}/v1/info`;
+      const infoUrl = infoSchemaUrl(c.req.url, this.publicOrigin);
       return c.json(
         {
           error: "unknown_capability",
@@ -18960,7 +19261,7 @@ var DVMServer = class {
           summary: "Persisted auth envelope failed signature re-verification on reactivation",
           lastActivityAt: Date.now()
         }).catch(() => void 0);
-        return buildAuthErrorResponse(c, err);
+        return buildAuthErrorResponse(c, err, this.publicOrigin);
       }
       if (err instanceof ReactivationAuthSchemaError) {
         return c.json(
@@ -19077,13 +19378,13 @@ var DVMServer = class {
       if (isStreamableJobStore(store)) {
         const cancelled = await store.cancelJob(id, reason ?? "Job cancelled");
         if (!cancelled) return this.jobNotActiveResponse(c);
-        await jm.issueReceiptForStoredJob(id);
+        await jm.finalizeStoredTerminal(id);
         return c.json({ status: "cancelled" });
       }
       record.status = "cancelled";
       record.lastActivityAt = Date.now();
       await jm.store.save(record);
-      await jm.issueReceiptForStoredJob(id);
+      await jm.finalizeStoredTerminal(id);
       return c.json({ status: "cancelled" });
     }
     if (!isJobOwner(c, job)) return c.json({ error: "Job not found" }, 404);
@@ -19350,8 +19651,8 @@ var PaymentValidationError = class extends Error {
   }
   detail;
 };
-function buildAuthErrorResponse(c, err) {
-  return c.json(authErrorBody(err, { schemaUrl: infoSchemaUrl(c.req.url) }), 401);
+function buildAuthErrorResponse(c, err, publicOrigin) {
+  return c.json(authErrorBody(err, { schemaUrl: infoSchemaUrl(c.req.url, publicOrigin) }), 401);
 }
 function validateMessageContent(type, content, devMode) {
   if (type === "response") {