@dvmkit/sdk 0.7.0-rc.8 → 0.8.0

package/dist/{chunk-KXWROQGK.js → chunk-FUJ36YDV.js}

@@ -45,30 +45,7 @@ function isOpaqueToken(segment) {
   return false;
 }
 
-// src/lib/caller-loggers.ts
-var callerLoggers = buildNoopLoggers();
-function initCallerLoggers(nextLoggers) {
-  callerLoggers = nextLoggers;
-}
-function buildNoopLoggers() {
-  const noopLogger = {
-    // eslint-disable-next-line @typescript-eslint/no-empty-function -- standalone caller has no exporter
-    info() {
-    },
-    async span(_name, _attrs, fn) {
-      return fn();
-    }
-  };
-  return {
-    cashu: noopLogger,
-    lightning: noopLogger,
-    x402: noopLogger
-  };
-}
-
 export {
   redactUrl,
-  redactUrlsInText,
-  callerLoggers,
-  initCallerLoggers
+  redactUrlsInText
 };

package/dist/{chunk-KYCLHWKO.js → chunk-GB5XPAA5.js}

@@ -1,6 +1,9 @@
+import {
+  loggers
+} from "./chunk-BL6LRWXD.js";
 import {
   diagnosticConsole
-} from "./chunk-FXDQMJQ2.js";
+} from "./chunk-DZQYQN2X.js";
 
 // src/sdk/server/mpp-setup.ts
 import { createHash, randomUUID } from "crypto";
@@ -533,7 +536,7 @@ function buildMppMethods(opts, env) {
       })
     );
     if (opts.tempoSession) {
-      methods.push(
+      methods.push(withAuthenticationOnlyValidation(
         tempo.session({
           recipient: opts.tempoRecipient,
           account: opts.tempoSession.account,
@@ -557,12 +560,25 @@ function buildMppMethods(opts, env) {
             onSessionSettlement: opts.tempoSession.onSessionSettlement
           }
         })
-      );
+      ));
     }
   }
   if (methods.length === 0 || !tempoConfiguration) return void 0;
   return { methods, tempoConfiguration };
 }
+function withAuthenticationOnlyValidation(method) {
+  if (method.validate) return method;
+  const validate = async ({ credential, request }) => ({
+    challenge: credential.challenge,
+    credential,
+    details: void 0,
+    intent: method.intent,
+    method: method.name,
+    request,
+    ...credential.source !== void 0 && { source: credential.source }
+  });
+  return { ...method, validate };
+}
 function resolveTempoNetwork(env) {
   const testnet = env.DVMKIT_TEMPO_TESTNET === "1" || env.DVMKIT_TEMPO_TESTNET === "true";
   const rawChainId = env.DVMKIT_TEMPO_CHAIN_ID?.trim();
@@ -612,6 +628,9 @@ function wrapMppx(mppx) {
   };
   return Object.assign(server, { issueChallenge });
 }
+var TEMPO_CLOSE_LOG_WINDOW = 5000n;
+var TEMPO_CLOSE_LOG_SLACK_MS = 10 * 60 * 1e3;
+var TEMPO_CLOSE_LOG_MAX_WINDOWS = 500;
 var DEFAULT_TEMPO_SESSION_CHAIN_OPS = {
   getChannelStatesBatch: TempoSession.Precompile.Chain.getChannelStatesBatch,
   settle: TempoSession.Server.settle,
@@ -621,7 +640,32 @@ var DEFAULT_TEMPO_SESSION_CHAIN_OPS = {
       "ChannelClosed",
       channelId
     )
-  )
+  ),
+  findChannelClose: async (client, channelId, escrowContract, notBeforeMs) => {
+    const { getBlock, getBlockNumber, getLogs } = await import("viem/actions");
+    const event = TempoSession.Precompile.escrowAbi.find(
+      (item) => item.type === "event" && item.name === "ChannelClosed"
+    );
+    if (!event || event.type !== "event") throw new Error("Tempo escrow ABI has no ChannelClosed event");
+    let toBlock = await getBlockNumber(client);
+    for (let window = 0; window < TEMPO_CLOSE_LOG_MAX_WINDOWS; window += 1) {
+      const fromBlock = toBlock >= TEMPO_CLOSE_LOG_WINDOW ? toBlock - TEMPO_CLOSE_LOG_WINDOW + 1n : 0n;
+      const logs = await getLogs(client, {
+        address: escrowContract,
+        event,
+        args: { channelId },
+        fromBlock,
+        toBlock
+      });
+      const closed = logs.find((log) => log.transactionHash);
+      if (closed?.transactionHash) return closed.transactionHash;
+      if (fromBlock === 0n) return null;
+      const start = await getBlock(client, { blockNumber: fromBlock });
+      if (Number(start.timestamp) * 1e3 < notBeforeMs - TEMPO_CLOSE_LOG_SLACK_MS) return null;
+      toBlock = fromBlock - 1n;
+    }
+    throw new Error(`Tempo close search for channel ${channelId} exceeded its block budget`);
+  }
 };
 function attachTempoSessionRuntime(mppx, config, chainOpOverrides = {}) {
   let creditLedger;
@@ -642,6 +686,102 @@ function attachTempoSessionRuntime(mppx, config, chainOpOverrides = {}) {
   }
   if (store) {
     Object.assign(mppx, {
+      assertTempoSessionCloseVoucher: async (voucher) => {
+        const descriptor = readChannelDescriptor(voucher.descriptor);
+        if (!descriptor) {
+          throw new MppxErrors.VerificationFailedError({
+            reason: "descriptor required for TIP-1034 session action"
+          });
+        }
+        const details = isStateRecord(voucher.request.methodDetails) ? voucher.request.methodDetails : {};
+        const stored = await store.get(voucher.channelId.toLowerCase());
+        const state = readTempoSessionState(stored);
+        const chainId = typeof details.chainId === "number" ? details.chainId : state?.chainId;
+        const escrow = typeof details.escrowContract === "string" ? details.escrowContract : state?.escrowContract;
+        if (chainId === void 0 || escrow === void 0) {
+          throw new MppxErrors.VerificationFailedError({ reason: "invalid session request" });
+        }
+        const computed = TempoSession.Precompile.Channel.computeId({
+          ...descriptor,
+          chainId,
+          escrow
+        });
+        if (computed.toLowerCase() !== voucher.channelId.toLowerCase()) {
+          throw new MppxErrors.VerificationFailedError({
+            reason: "channel descriptor does not match channelId"
+          });
+        }
+        if (!sameHex(descriptor.payee, voucher.request.recipient)) {
+          throw new MppxErrors.VerificationFailedError({
+            reason: "channel descriptor payee does not match server destination"
+          });
+        }
+        if (!sameHex(descriptor.token, voucher.request.currency)) {
+          throw new MppxErrors.VerificationFailedError({
+            reason: "channel descriptor token does not match server token"
+          });
+        }
+        if (!sameHex(descriptor.operator, details.operator ?? ZERO_ADDRESS)) {
+          throw new MppxErrors.VerificationFailedError({
+            reason: "channel descriptor operator does not match server operator"
+          });
+        }
+        if (!state || !isStateRecord(stored)) {
+          throw new MppxErrors.ChannelNotFoundError({ reason: "channel not found" });
+        }
+        if (stored.backend !== "precompile") {
+          throw new MppxErrors.VerificationFailedError({
+            reason: "channel is not precompile-backed"
+          });
+        }
+        const storedDescriptor = readChannelDescriptor(stored.descriptor);
+        if (!storedDescriptor || !sameDescriptor(descriptor, storedDescriptor)) {
+          throw new MppxErrors.VerificationFailedError({
+            reason: "credential descriptor does not match stored channel"
+          });
+        }
+        const signer = stored.authorizedSigner;
+        if (typeof signer !== "string" || !HEX_ADDRESS_RE.test(signer)) {
+          throw new MppxErrors.ChannelNotFoundError({ reason: "channel not found" });
+        }
+        if (state.finalized) {
+          throw new MppxErrors.ChannelClosedError({ reason: "channel is already finalized" });
+        }
+        if (state.closeRequestedAt !== 0n) {
+          throw new MppxErrors.ChannelClosedError({ reason: "channel has a pending close request" });
+        }
+        if (state.deposit === 0n && (voucher.cumulativeAmount !== 0n || state.spent !== 0n)) {
+          throw new MppxErrors.ChannelClosedError({ reason: "channel deposit is zero (settled)" });
+        }
+        if (voucher.cumulativeAmount < state.spent) {
+          throw new MppxErrors.VerificationFailedError({
+            reason: `close voucher amount must be >= ${state.spent} (spent)`
+          });
+        }
+        if (voucher.cumulativeAmount < state.settledOnChain) {
+          throw new MppxErrors.VerificationFailedError({
+            reason: `close voucher amount must be >= ${state.settledOnChain} (on-chain settled)`
+          });
+        }
+        const valid = TempoSession.Precompile.Voucher.verifyVoucher(
+          escrow,
+          chainId,
+          {
+            channelId: voucher.channelId,
+            cumulativeAmount: voucher.cumulativeAmount,
+            signature: voucher.signature
+          },
+          signer
+        );
+        if (!valid) {
+          throw new MppxErrors.InvalidSignatureError({ reason: "invalid voucher signature" });
+        }
+        if (maxBigInt(state.spent, state.settledOnChain) > state.deposit) {
+          throw new MppxErrors.AmountExceedsDepositError({
+            reason: "close capture amount exceeds on-chain deposit"
+          });
+        }
+      },
       getTempoSessionSpent: async (channelId) => {
         const state = readTempoSessionState(await store.get(channelId.toLowerCase()));
         if (!state) throw new Error(`Tempo session channel ${channelId} not found`);
@@ -984,7 +1124,32 @@ function attachTempoSessionRuntime(mppx, config, chainOpOverrides = {}) {
       finalized = chainState.deposit === 0n;
     }
     if (!finalized) return null;
-    const recovered = await store.confirmClose(channelId, drainId, `channel:${channelId}`);
+    const pending = await config.hostedObligations?.pendingTempoClose(channelId, drainId);
+    let reference = pending?.txHash ?? void 0;
+    if (pending && !reference) {
+      const client = await getClient({ chainId: current.chainId });
+      const txHash = await chainOps.findChannelClose(
+        client,
+        current.channelId,
+        current.escrowContract,
+        pending.reservedAtMs
+      );
+      if (txHash) {
+        await config.hostedObligations.recordSubmitted(pending.id, txHash);
+        reference = txHash;
+      } else {
+        loggers.tempo.warn("tempo_session_close_recovery_unmatched", {
+          channel_id: current.channelId,
+          drain_id: drainId,
+          obligation_id: pending.id
+        });
+      }
+    }
+    const recovered = await store.confirmClose(
+      channelId,
+      drainId,
+      reference ?? `channel:${channelId}`
+    );
     return recovered.reference;
   };
   const getClose = store.getClose?.bind(store) ?? (() => Promise.resolve(null));
@@ -1028,6 +1193,27 @@ function maxBigInt(left, right) {
 function isStateRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
+var ZERO_ADDRESS = `0x${"00".repeat(20)}`;
+var DESCRIPTOR_ADDRESSES = ["payer", "payee", "operator", "token", "authorizedSigner"];
+var DESCRIPTOR_WORDS = ["salt", "expiringNonceHash"];
+function readChannelDescriptor(value) {
+  if (!isStateRecord(value)) return void 0;
+  for (const field of DESCRIPTOR_ADDRESSES) {
+    if (typeof value[field] !== "string" || !HEX_ADDRESS_RE.test(value[field])) return void 0;
+  }
+  for (const field of DESCRIPTOR_WORDS) {
+    if (typeof value[field] !== "string" || !/^0x[0-9a-fA-F]{64}$/.test(value[field])) {
+      return void 0;
+    }
+  }
+  return value;
+}
+function sameHex(left, right) {
+  return typeof left === "string" && typeof right === "string" && left.toLowerCase() === right.toLowerCase();
+}
+function sameDescriptor(left, right) {
+  return DESCRIPTOR_ADDRESSES.every((field) => sameHex(left[field], right[field])) && DESCRIPTOR_WORDS.every((field) => sameHex(left[field], right[field]));
+}
 function tempoSettlementDue(args) {
   const { channel, chainSettled, forcedClose, intervalMs } = args;
   const settlementBoundary = Date.parse(channel.lastSettlementAt ?? channel.createdAt ?? "");

package/dist/{chunk-Z6EJOVIU.js → chunk-GSPV3UIM.js}

@@ -7,10 +7,10 @@ import {
   installHostedTempoCloseGuard,
   isTempoInsufficientFundsError,
   resolveTempoNetwork
-} from "./chunk-KYCLHWKO.js";
+} from "./chunk-GB5XPAA5.js";
 import {
   x402EarnedCeiling
-} from "./chunk-3VFEX2Y3.js";
+} from "./chunk-X3JEME6P.js";
 import {
   createX402FacilitatorAuthHeaders,
   createX402FacilitatorClient,
@@ -19,13 +19,13 @@ import {
   verifyWithFacilitator,
   withPaymentDiagnostics,
   withPaymentStage
-} from "./chunk-XEOTTFLH.js";
+} from "./chunk-ATXDKX6F.js";
 import {
   MemoryCreditLedger
-} from "./chunk-FOJKZ4E7.js";
+} from "./chunk-EBCLWOKF.js";
 import {
   PostgresJobStore
-} from "./chunk-KB7MEWBE.js";
+} from "./chunk-QPXI7YPH.js";
 import {
   parseStoreValue
 } from "./chunk-YG7G4DPZ.js";
@@ -36,7 +36,7 @@ import {
   humanizeZodIssues,
   signedRequestInput,
   zodIssuesOf
-} from "./chunk-X5RY2G3C.js";
+} from "./chunk-5K5E6ME6.js";
 import {
   MemoryJobStore,
   UNCAPPABLE_ASK_TOTAL,
@@ -45,7 +45,7 @@ import {
   isJobRetentionStore,
   isReceiptIssuingStore,
   isStreamableJobStore
-} from "./chunk-MYJOV4R4.js";
+} from "./chunk-I6PHA54S.js";
 import {
   ContentHoldError,
   JobCancelledError,
@@ -85,7 +85,7 @@ import {
   signReceipt,
   toLockPubkey,
   verifyChallenge
-} from "./chunk-XO5EUHCW.js";
+} from "./chunk-RTFBVXCN.js";
 import {
   X402_BATCH_SETTLEMENT_SCHEME,
   X402_DEFAULT_FACILITATOR,
@@ -112,12 +112,14 @@ import {
   isZodSchema
 } from "./chunk-UKD3R2KU.js";
 import {
-  createConsoleLogger,
+  createConsoleLogger
+} from "./chunk-IFWUWHTW.js";
+import {
   loggers,
   pinDimension,
   withSpan,
   withTraceContext
-} from "./chunk-SX4WCPW7.js";
+} from "./chunk-BL6LRWXD.js";
 import {
   StepCache
 } from "./chunk-BQJIFRAZ.js";
@@ -134,7 +136,7 @@ import {
   roundUsd,
   satsToFiat,
   validateCurrency
-} from "./chunk-LQQ6H4UB.js";
+} from "./chunk-5CQKSLAU.js";
 import {
   CreditLedger,
   CreditLedgerError,
@@ -150,10 +152,10 @@ import {
   isNonChannelBitcoinRail,
   netOwedSats,
   x402SettlementPending
-} from "./chunk-WP7UX6RF.js";
+} from "./chunk-VYP6ADCS.js";
 import {
   withPostgresRecoveryContext
-} from "./chunk-6RYCZLCK.js";
+} from "./chunk-6FEHRZO7.js";
 import {
   DvmError,
   x402NetworkByCaip2
@@ -161,7 +163,7 @@ import {
 import {
   createDiagnosticCapabilityAuthority,
   diagnosticConsole
-} from "./chunk-FXDQMJQ2.js";
+} from "./chunk-DZQYQN2X.js";
 import {
   MemoryProcessedPaymentStore,
   PostgresProcessedPaymentStore,
@@ -3118,6 +3120,10 @@ function decodeBatchPayment(header) {
   if (!isBatchSettlementDepositPayload2(parsed.payload) && !isBatchSettlementVoucherPayload(parsed.payload) && !isBatchSettlementRefundPayload2(parsed.payload)) {
     throw new Error("invalid batch-settlement payload");
   }
+  const voucher = parsed.payload.voucher;
+  if (typeof voucher.channelId !== "string" || typeof voucher.maxClaimableAmount !== "string" || typeof voucher.signature !== "string") {
+    throw new Error("invalid batch-settlement voucher");
+  }
   return parsed;
 }
 function batchVoucher(payload) {
@@ -3877,7 +3883,7 @@ async function verifyUpfrontPaymentInScope(opts) {
           x402Requirements
         });
       }
-      const { verifyX402Payment } = await import("./x402-BN26TQZ6.js");
+      const { verifyX402Payment } = await import("./x402-Q4S36NHQ.js");
       const receipt = await withPaymentStage("verifier_broadcast", () => verifyX402Payment(
         x402Payment,
         x402Config,
@@ -4040,6 +4046,30 @@ async function verifyUpfrontPaymentInScope(opts) {
       }
       const expectedAmount = opts.priceFiat?.currency === "usd" ? fiatMicroToMethodAmount(opts.priceFiat.amountMicro, cred.challenge.method) : msatsToMethodAmount(requiredMsats, cred.challenge.method, rate);
       const sessionBasis = mppSessionBasis(cred);
+      const replayRealm = mpp.realm ?? cred.challenge.realm;
+      if (consumedCredentialStore && await withPaymentStage("replay_store", () => consumedCredentialStore.has(replayRealm, cred.challenge.id))) {
+        const mppChallenges = await issueUpfrontChallenges(
+          mpp,
+          requiredMsats,
+          resourcePath ?? "/v1/job",
+          rate,
+          sessionIssuable,
+          opts.fundOnly?.allowOneShotStablecoin,
+          opts.priceFiat
+        );
+        return {
+          paidMsats: 0,
+          receivedProofs: [],
+          error: {
+            body: paymentErrorBody("payment_invalid", {
+              message: "MPP credential already used"
+            }),
+            status: 402,
+            mppChallenges,
+            ...x402Requirements && { x402Requirements }
+          }
+        };
+      }
       let tempoReceipt;
       const broadcast = async () => {
         const receipt = await loggers.tempo.span(
@@ -4157,35 +4187,12 @@ async function verifyUpfrontPaymentInScope(opts) {
           }
         };
       }
-      if (consumedCredentialStore) {
-        const realm = mpp.realm;
-        const id = cred.challenge.id;
-        if (await withPaymentStage("replay_store", () => consumedCredentialStore.has(realm, id))) {
-          const mppChallenges = await issueUpfrontChallenges(
-            mpp,
-            requiredMsats,
-            resourcePath ?? "/v1/job",
-            rate,
-            sessionIssuable,
-            opts.fundOnly?.allowOneShotStablecoin,
-            opts.priceFiat
-          );
-          return {
-            paidMsats: 0,
-            receivedProofs: [],
-            error: {
-              body: paymentErrorBody("payment_invalid", {
-                message: "MPP credential already used"
-              }),
-              status: 402,
-              mppChallenges,
-              ...x402Requirements && { x402Requirements }
-            }
-          };
-        }
-        if (!sessionBasis) {
-          await withPaymentStage("replay_store", () => consumedCredentialStore.mark(realm, id, CONSUMED_CREDENTIAL_TTL_MS / 1e3));
-        }
+      if (consumedCredentialStore && !sessionBasis) {
+        await withPaymentStage("replay_store", () => consumedCredentialStore.mark(
+          replayRealm,
+          cred.challenge.id,
+          CONSUMED_CREDENTIAL_TTL_MS / 1e3
+        ));
       }
       if (ledgerCtx) {
         try {
@@ -4208,10 +4215,18 @@ async function verifyUpfrontPaymentInScope(opts) {
       }
       if (sessionBasis && consumedCredentialStore) {
         await withPaymentStage("replay_store", () => consumedCredentialStore.mark(
-          mpp.realm,
+          replayRealm,
           cred.challenge.id,
           CONSUMED_CREDENTIAL_TTL_MS / 1e3
-        ));
+        )).catch((error) => {
+          diagnosticConsole.warn({
+            level: "warn",
+            event: "tempo_replay_mark_failed",
+            phase: "upfront",
+            rail: "tempo",
+            ...paymentFailureFields(error)
+          });
+        });
       }
       if (credited) {
         await mpp.completeHostedTempoCharge?.(cred.challenge.id).catch((error) => {
@@ -4420,6 +4435,22 @@ async function verifyTempoSessionManagementCredential(args) {
       throw new Error("Hosted Tempo close requires non-mutating credential validation");
     }
     await args.mpp.validateCredential(credential, verifyOptions);
+    if (args.action === "close") {
+      if (!args.mpp.assertTempoSessionCloseVoucher) {
+        throw new Error("Hosted Tempo close requires stored-channel voucher validation");
+      }
+      const { cumulativeAmount, signature } = credential.payload;
+      if (typeof cumulativeAmount !== "string" || typeof signature !== "string") {
+        throw new Error("Expected a Tempo session close voucher");
+      }
+      await args.mpp.assertTempoSessionCloseVoucher({
+        channelId: payload.channelId,
+        cumulativeAmount: BigInt(cumulativeAmount),
+        signature,
+        descriptor: credential.payload.descriptor,
+        request: credential.challenge.request
+      });
+    }
   }
   await args.onBound?.();
   const receipt = await args.mpp.broadcastCredential(credential, verifyOptions);
@@ -4865,7 +4896,7 @@ async function verifyIncomingPaymentInScope(body, opts, snapshot) {
           snapshot
         });
       }
-      const { verifyX402Payment } = await import("./x402-BN26TQZ6.js");
+      const { verifyX402Payment } = await import("./x402-Q4S36NHQ.js");
       const receipt = await withPaymentStage("verifier_broadcast", () => verifyX402Payment(
         body.content.x402_payment,
         opts.x402Config,
@@ -5296,7 +5327,7 @@ async function processIncomingPaymentInScope(job, body, opts) {
     try {
       const requiredMsats = job.pendingPaymentMsats ?? 0;
       const requiredUsdcMicro = job.pendingX402AmountUsdcMicro !== void 0 ? BigInt(job.pendingX402AmountUsdcMicro) : BigInt(msatsToUsdc(requiredMsats, rate));
-      const { verifyX402Payment } = await import("./x402-BN26TQZ6.js");
+      const { verifyX402Payment } = await import("./x402-Q4S36NHQ.js");
       const receipt = await withPaymentStage("verifier_broadcast", () => verifyX402Payment(
         body.content.x402_payment,
         opts.x402Config,
@@ -10062,6 +10093,18 @@ var HostedSettlementReportObligations = class {
     );
     return result.rows[0];
   }
+  /** The original close obligation reserved for this drain, while its report is outstanding. */
+  async pendingTempoClose(channelId, drainId) {
+    const result = await this.pool.query(
+      `SELECT id,tx_hash,created_at_ms FROM sdk_hosted_settlement_report_obligations
+       WHERE dvm_id=$1 AND scope=$2 AND rail='tempo' AND operation='close' AND channel_id=$3
+         AND original->>'drainId'=$4 AND state NOT IN ('delivered','no_report')
+       ORDER BY created_at_ms DESC LIMIT 1`,
+      [this.dvmId, this.scope, channelId.toLowerCase(), drainId]
+    );
+    const row = result.rows[0];
+    return row && { id: row.id, txHash: row.tx_hash, reservedAtMs: Number(row.created_at_ms) };
+  }
   async submittedIds(rail, operation, txHash, batchId) {
     if (!hex(txHash, 32)) throw new Error("Hosted effect has no exact transaction hash");
     const result = await this.pool.query(
@@ -10201,6 +10244,10 @@ var HostedSettlementReportObligations = class {
     }));
   }
   async recoverOriginalX402Refunds() {
+    const table = await this.pool.query(
+      "SELECT to_regclass('x402_batch_settlements') IS NOT NULL AS present"
+    );
+    if (!table.rows[0]?.present) return [];
     const rows2 = await this.pool.query(
       `SELECT obligation.id,settlement.settle_response AS response
        FROM sdk_hosted_settlement_report_obligations obligation
@@ -19537,7 +19584,7 @@ async function createDVMServer(descriptor, opts) {
       }
     }
     if (!opts.onJobCompleted && platformToken && platformUrl && dvmId && opts.db) {
-      const { RevenueReporter } = await import("./revenue-reporter-E56J3NZK.js");
+      const { RevenueReporter } = await import("./revenue-reporter-X52GPZ5U.js");
       const reporter = new RevenueReporter(
         opts.db,
         platformUrl,
@@ -19547,7 +19594,7 @@ async function createDVMServer(descriptor, opts) {
       revenueReporter = reporter;
       await reporter.init();
       reporter.startRetryLoop();
-      const { MemoryX402BatchStore, PayoutReporter } = await import("./payout-reporter-3UVWPGMO.js");
+      const { MemoryX402BatchStore, PayoutReporter } = await import("./payout-reporter-HQSIIBFL.js");
       payoutReporter = new PayoutReporter({
         dvmId,
         db: opts.db,
@@ -20905,7 +20952,7 @@ var DVMServer = class {
         // sees only the shortened list cannot tell a DVM that never did
         // sessions from one whose observer is down for a minute.
         ...withheld.length && { withheld },
-        realm: this.opts.mpp.realm,
+        ...this.opts.mpp.realm && { realm: this.opts.mpp.realm },
         ...this.opts.mpp.tempoConfiguration && {
           recipient: this.opts.mpp.tempoConfiguration.recipient,
           payment_token: this.opts.mpp.tempoConfiguration.paymentToken,

package/dist/{chunk-MYJOV4R4.js → chunk-I6PHA54S.js}

@@ -5,10 +5,10 @@ import {
 } from "./chunk-AFV77S4C.js";
 import {
   loggers
-} from "./chunk-SX4WCPW7.js";
+} from "./chunk-BL6LRWXD.js";
 import {
   redactUrl
-} from "./chunk-KXWROQGK.js";
+} from "./chunk-FUJ36YDV.js";
 
 // src/sdk/server/job-store.ts
 function accumulateAskedTopUp(prior, ask) {

package/dist/chunk-IFWUWHTW.js

@@ -0,0 +1,47 @@
+import {
+  emitDiagnostic,
+  projectDiagnosticFields
+} from "./chunk-DZQYQN2X.js";
+
+// src/sdk/logger.ts
+function createConsoleLogger(_jobId) {
+  return {
+    debug(_message, data) {
+      emitDiagnostic("debug", "diagnostic.message", data);
+    },
+    info(_message, data) {
+      emitDiagnostic("info", "diagnostic.message", data);
+    },
+    warn(_message, data) {
+      emitDiagnostic("warn", "diagnostic.message", data);
+    },
+    error(_message, data) {
+      emitDiagnostic("error", "diagnostic.message", data);
+    }
+  };
+}
+function createStdoutLogger(context) {
+  const emit = (level) => (_message, data) => {
+    emitDiagnostic(level, "diagnostic.message", {
+      ...projectDiagnosticFields(context),
+      ...projectDiagnosticFields(data)
+    });
+  };
+  return {
+    debug: emit("debug"),
+    info: emit("info"),
+    warn: emit("warn"),
+    error: emit("error")
+  };
+}
+function createNoopLogger() {
+  const noop = () => {
+  };
+  return { debug: noop, info: noop, warn: noop, error: noop };
+}
+
+export {
+  createConsoleLogger,
+  createStdoutLogger,
+  createNoopLogger
+};

package/dist/{chunk-GDCIHJAR.js → chunk-P5WEZXJ2.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-YG7G4DPZ.js";
 import {
   withPostgresTransactionRecovery
-} from "./chunk-6RYCZLCK.js";
+} from "./chunk-6FEHRZO7.js";
 import {
   withSdkInitLock
 } from "./chunk-COYKJRMM.js";

package/dist/{chunk-YK54BJ2L.js → chunk-PRSKC7AD.js}

@@ -1,6 +1,6 @@
 import {
   diagnosticConsole
-} from "./chunk-FXDQMJQ2.js";
+} from "./chunk-DZQYQN2X.js";
 import {
   withSdkInitLock
 } from "./chunk-COYKJRMM.js";

package/dist/{chunk-KB7MEWBE.js → chunk-QPXI7YPH.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-AFV77S4C.js";
 import {
   diagnosticConsole
-} from "./chunk-FXDQMJQ2.js";
+} from "./chunk-DZQYQN2X.js";
 import {
   withSdkInitLock
 } from "./chunk-COYKJRMM.js";