@dvmkit/sdk 0.3.1-rc.10 → 0.3.3-rc.10

package/dist/{chunk-2D75MNNG.js → chunk-2SD2W2BG.js}

@@ -3,7 +3,10 @@ import {
 } from "./chunk-COYKJRMM.js";
 import {
   applyRetryToPool
-} from "./chunk-C3MTFLC6.js";
+} from "./chunk-P6QON7ER.js";
+import {
+  diagnosticConsole
+} from "./chunk-ETXDTUJO.js";
 
 // src/sdk/server/credit-ledger.ts
 import { randomUUID } from "crypto";
@@ -1323,15 +1326,15 @@ var CreditLedger = class {
     const uncovered = Number(rows[0]?.uncovered ?? 0);
     const unbacked = Number(rows[0]?.unbacked ?? 0);
     if (rowCount === 0 && uncovered === 0 && unbacked === 0) return;
-    console.warn(
-      JSON.stringify({
+    diagnosticConsole.warn(
+      {
         level: uncovered > 0 ? "warn" : "info",
         event: "credit_funding_lot_backfill",
         backfilled: rowCount ?? 0,
         uncovered_credits: uncovered,
         unbacked_credits: unbacked,
-        message: uncovered > 0 ? "Some open Bitcoin credits hold more balance than their funding lots cover. Those reclaims are priced off a live rate rather than in kind until the gap is repaired." : "Funding lots are in place for every open Bitcoin credit."
-      })
+        message: void 0
+      }
     );
   }
   /**

package/dist/{chunk-XZ7LW4S5.js → chunk-4J32DTLT.js}

@@ -1,3 +1,7 @@
+import {
+  diagnosticConsole
+} from "./chunk-ETXDTUJO.js";
+
 // src/sdk/server/mpp-setup.ts
 import { randomUUID } from "crypto";
 import { Errors as MppxErrors, PaymentRequest } from "mppx";
@@ -117,8 +121,8 @@ var TempoSettlementReadiness = class {
       ...failure.creditId ? { creditId: failure.creditId } : {},
       ...failure.drainId ? { drainId: failure.drainId } : {}
     };
-    console.warn(
-      JSON.stringify({
+    diagnosticConsole.warn(
+      {
         level: "warn",
         event: "tempo_settlement_insufficient_funds",
         address: observation.address,
@@ -129,7 +133,7 @@ var TempoSettlementReadiness = class {
         ...observation.channelId ? { channel_id: observation.channelId } : {},
         ...observation.creditId ? { credit_id: observation.creditId } : {},
         ...observation.drainId ? { drain_id: observation.drainId } : {}
-      })
+      }
     );
     await this.notify((listener) => listener.onFailure?.(observation));
     if (sharedLatchWritten && this.failureBalanceMicro === void 0) {
@@ -259,8 +263,8 @@ var TempoSettlementReadiness = class {
       checkedAt: this.now(),
       ready: this.available()
     };
-    console.info(
-      JSON.stringify({
+    diagnosticConsole.info(
+      {
         level: "info",
         event: "tempo_settlement_fee_balance",
         address: observation.address,
@@ -269,7 +273,7 @@ var TempoSettlementReadiness = class {
         balance_micro: observation.balanceMicro.toString(),
         low_balance_micro: observation.lowBalanceMicro.toString(),
         ready: observation.ready
-      })
+      }
     );
     await this.notify((listener) => listener.onBalance?.(observation));
     return observation;
@@ -286,22 +290,22 @@ function isTempoInsufficientFundsError(error) {
   if (error instanceof InsufficientFundsError) return true;
   return error instanceof BaseError && error.walk((cause) => cause instanceof InsufficientFundsError) !== null;
 }
-function logBalanceFailure(error) {
-  console.warn(
-    JSON.stringify({
+function logBalanceFailure(_error) {
+  diagnosticConsole.warn(
+    {
       level: "warn",
       event: "tempo_settlement_fee_balance_failed",
-      error_name: error instanceof Error ? error.name : "unknown"
-    })
+      error_name: void 0
+    }
   );
 }
-function logStateFailure(error) {
-  console.warn(
-    JSON.stringify({
+function logStateFailure(_error) {
+  diagnosticConsole.warn(
+    {
       level: "warn",
       event: "tempo_settlement_readiness_state_failed",
-      error_name: error instanceof Error ? error.name : "unknown"
-    })
+      error_name: void 0
+    }
   );
 }
 

package/dist/{chunk-XMDQOXHO.js → chunk-4UZN2GP5.js}

@@ -1,6 +1,9 @@
 import {
   withSdkInitLock
 } from "./chunk-COYKJRMM.js";
+import {
+  diagnosticConsole
+} from "./chunk-ETXDTUJO.js";
 
 // src/sdk/server/payout-reporter.ts
 import { createHash, randomUUID } from "crypto";
@@ -719,7 +722,7 @@ function message(err) {
   return err instanceof Error ? err.message : String(err);
 }
 function warn(level, fields) {
-  console.warn(JSON.stringify({ level, ...fields }));
+  diagnosticConsole.warn({ level, ...fields });
 }
 
 export {

package/dist/{chunk-YO56VCTQ.js → chunk-6DOGTAHA.js}

@@ -1,6 +1,14 @@
 import {
   initCallerLoggers
 } from "./chunk-66HGCPBU.js";
+import {
+  bindDiagnosticCapabilityAuthority,
+  bindDiagnosticIdentityAuthority,
+  emitDiagnostic,
+  extendDiagnosticIdentityAuthority,
+  projectDiagnosticFields,
+  projectSpanRow
+} from "./chunk-ETXDTUJO.js";
 
 // src/sdk/step-cache.ts
 var StepCache = class _StepCache {
@@ -36,36 +44,34 @@ var StepCache = class _StepCache {
 };
 
 // src/sdk/logger.ts
-function createConsoleLogger(jobId) {
-  const fmt = (message, data) => {
-    const parts = [`[${jobId}] ${message}`];
-    if (data) parts.push(data);
-    return parts;
-  };
+function createConsoleLogger(_jobId) {
   return {
-    debug(message, data) {
-      console.debug(...fmt(message, data));
+    debug(_message, data) {
+      emitDiagnostic("debug", "diagnostic.message", data);
     },
-    info(message, data) {
-      console.info(...fmt(message, data));
+    info(_message, data) {
+      emitDiagnostic("info", "diagnostic.message", data);
     },
-    warn(message, data) {
-      console.warn(...fmt(message, data));
+    warn(_message, data) {
+      emitDiagnostic("warn", "diagnostic.message", data);
     },
-    error(message, data) {
-      console.error(...fmt(message, data));
+    error(_message, data) {
+      emitDiagnostic("error", "diagnostic.message", data);
     }
   };
 }
 function createStdoutLogger(context) {
-  const emit = (sink, level) => (message, data) => {
-    sink(JSON.stringify({ level, msg: message, ...context, ...data }));
+  const emit = (level) => (_message, data) => {
+    emitDiagnostic(level, "diagnostic.message", {
+      ...projectDiagnosticFields(context),
+      ...projectDiagnosticFields(data)
+    });
   };
   return {
-    debug: emit(console.debug.bind(console), "debug"),
-    info: emit(console.info.bind(console), "info"),
-    warn: emit(console.warn.bind(console), "warn"),
-    error: emit(console.error.bind(console), "error")
+    debug: emit("debug"),
+    info: emit("info"),
+    warn: emit("warn"),
+    error: emit("error")
   };
 }
 function createNoopLogger() {
@@ -108,6 +114,17 @@ function currentContext(service) {
   };
 }
 function pinDimension(key, value) {
+  const ctx = storage.getStore();
+  if (ctx) {
+    ctx.dimensions = { ...ctx.dimensions, [key]: value };
+    ctx.diagnosticIdentityAuthority = extendDiagnosticIdentityAuthority(
+      ctx.diagnosticIdentityAuthority,
+      key,
+      value
+    );
+  }
+}
+function setDimension(key, value) {
   const ctx = storage.getStore();
   if (ctx) {
     ctx.dimensions = { ...ctx.dimensions, [key]: value };
@@ -121,36 +138,35 @@ function rawContext() {
 import { hostname } from "os";
 
 // src/observability/stdout-sink.ts
-var SENSITIVE_KEY_RE = /secret|token|password|private|bearer|seed|preimage|api[_-]?key|signing[_-]?key|priv[_-]?key/i;
 var isTTY = typeof process.stdout.isTTY === "boolean" && process.stdout.isTTY;
 var RED = isTTY ? "\x1B[31m" : "";
 var YELLOW = isTTY ? "\x1B[33m" : "";
 var RESET = isTTY ? "\x1B[0m" : "";
 function formatSpanLine(span) {
-  const ts = new Date(span.started_at_ms).toISOString();
-  const levelStr = colorLevel(span.level);
-  const parts = [`[${ts}]`, span.dataset, `${levelStr}:`, span.name];
-  if (span.trace_id) {
-    parts.push(`trace=${span.trace_id}`);
+  const result = projectSpanRow(span);
+  if (!result.ok) return "";
+  const safeSpan = result.row;
+  const ts = new Date(safeSpan.started_at_ms).toISOString();
+  const levelStr = colorLevel(safeSpan.level);
+  const parts = [`[${ts}]`, safeSpan.dataset, `${levelStr}:`, safeSpan.name];
+  if (safeSpan.trace_id) {
+    parts.push(`trace=${safeSpan.trace_id}`);
   }
-  for (const [k, v] of Object.entries(span.dimensions)) {
+  for (const [k, v] of Object.entries(safeSpan.dimensions)) {
     parts.push(formatKV(k, v));
   }
-  for (const [k, v] of Object.entries(span.attributes)) {
+  for (const [k, v] of Object.entries(safeSpan.attributes)) {
     parts.push(formatKV(k, v));
   }
-  const durationMs = span.ended_at_ms - span.started_at_ms;
+  const durationMs = safeSpan.ended_at_ms - safeSpan.started_at_ms;
   if (durationMs > 0) {
     parts.push(`duration=${durationMs}ms`);
   }
-  if (span.error_message) {
-    parts.push(`error=${truncate(span.error_message, 120)}`);
-  }
   return parts.join(" ");
 }
 function writeSpanLine(span) {
   const line = formatSpanLine(span);
-  process.stdout.write(line + "\n");
+  if (line) process.stdout.write(line + "\n");
 }
 function colorLevel(level) {
   if (level === "error") return `${RED}error${RESET}`;
@@ -158,7 +174,6 @@ function colorLevel(level) {
   return level;
 }
 function formatKV(key, value) {
-  if (SENSITIVE_KEY_RE.test(key)) return `${key}=[REDACTED]`;
   return `${key}=${truncate(stringify(value), 80)}`;
 }
 function stringify(value) {
@@ -182,28 +197,88 @@ function setEmitter(fn) {
 }
 var cachedHost = hostname();
 var serviceVersion = process.env.GIT_SHA ?? process.env.FLY_IMAGE_REF ?? "dev";
+function ownDataValue(input, key) {
+  if ((typeof input !== "object" || input === null) && typeof input !== "function") {
+    return void 0;
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(input, key);
+  if (!descriptor) return void 0;
+  if (!("value" in descriptor)) throw new TypeError("accessor override");
+  return descriptor.value;
+}
+function ownIdentityKeys(input) {
+  try {
+    return ["dvm_id", "dvm_slug", "builder_id"].filter((key) => {
+      const descriptor = (typeof input === "object" && input !== null || typeof input === "function") && Object.getOwnPropertyDescriptor(input, key);
+      return descriptor && "value" in descriptor;
+    });
+  } catch {
+    return [];
+  }
+}
 async function withSpan(opts, fn) {
   const spanId = randomSpanId();
   const existingCtx = rawContext();
   const ctx = existingCtx ?? currentContext();
+  const authority = ctx.diagnosticCapabilityAuthority;
+  const identityAuthority = ctx.diagnosticIdentityAuthority;
   const startMs = opts.startMs ?? Date.now();
+  const attributeInput = opts.attrs;
+  const attributeIdentityKeys = ownIdentityKeys(attributeInput);
   let status = "ok";
   let level = opts.level;
-  let errorMessage = null;
-  let errorStack = null;
   if (opts.err) {
     status = "error";
-    errorMessage = opts.err.message;
-    errorStack = opts.err.stack ?? null;
   }
+  let attributes = projectDiagnosticFields(
+    attributeInput,
+    opts.dataset,
+    authority,
+    identityAuthority
+  );
+  const childDimensions = bindDiagnosticIdentityAuthority(
+    bindDiagnosticCapabilityAuthority(
+      {
+        ...projectDiagnosticFields(
+          ctx.dimensions,
+          opts.dataset,
+          authority,
+          identityAuthority
+        ),
+        ...projectDiagnosticFields(
+          opts.dims,
+          opts.dataset,
+          authority,
+          identityAuthority
+        )
+      },
+      authority
+    ),
+    identityAuthority
+  );
   const childCtx = {
     traceId: ctx.traceId,
     spanId,
-    dimensions: { ...ctx.dimensions, ...opts.dims },
+    dimensions: childDimensions,
     service: ctx.service,
-    tracestate: ctx.tracestate
+    tracestate: ctx.tracestate,
+    diagnosticCapabilityAuthority: authority,
+    diagnosticIdentityAuthority: identityAuthority
+  };
+  const latestIdentityAuthority = () => childCtx.diagnosticIdentityAuthority;
+  const refreshAttributes = () => {
+    const identityCandidates = Object.fromEntries(
+      attributeIdentityKeys.map((key) => [key, null])
+    );
+    attributes = projectDiagnosticFields(
+      { ...attributes, ...identityCandidates },
+      opts.dataset,
+      authority,
+      latestIdentityAuthority()
+    );
   };
   const emitRow = () => {
+    const activeIdentityAuthority = latestIdentityAuthority();
     const endMs = opts.endMs ?? Date.now();
     const row = {
       span_id: spanId,
@@ -219,43 +294,81 @@ async function withSpan(opts, fn) {
       service_version: serviceVersion,
       host: cachedHost,
       pid: process.pid,
-      dimensions: childCtx.dimensions,
-      attributes: opts.attrs ?? {},
-      error_message: errorMessage,
-      error_stack: errorStack,
+      dimensions: projectDiagnosticFields(
+        childCtx.dimensions,
+        opts.dataset,
+        authority,
+        activeIdentityAuthority
+      ),
+      attributes,
+      error_message: null,
+      error_stack: null,
       sample_rate: 1
     };
-    writeSpanLine(row);
-    if (emitter) emitter(row);
+    bindDiagnosticCapabilityAuthority(row, authority);
+    bindDiagnosticIdentityAuthority(row, activeIdentityAuthority);
+    const projected = projectSpanRow(row);
+    if (!projected.ok) return;
+    try {
+      writeSpanLine(projected.row);
+    } catch {
+    }
+    try {
+      if (emitter) emitter(projected.row);
+    } catch {
+    }
   };
+  let result;
   try {
-    const result = await withTraceContext(childCtx, () => fn());
-    if (opts.inspect) {
-      const overrides = opts.inspect(result);
-      if (overrides) {
-        if (overrides.status) status = overrides.status;
-        if (overrides.level) level = overrides.level;
-        if (overrides.errorMessage !== void 0) errorMessage = overrides.errorMessage;
-        if (overrides.attrs) Object.assign(opts.attrs ??= {}, overrides.attrs);
-      }
-    }
-    emitRow();
-    return result;
+    result = await withTraceContext(childCtx, () => fn());
   } catch (err) {
     status = "error";
-    if (err instanceof Error) {
-      errorMessage = err.message;
-      errorStack = err.stack ?? null;
-    } else {
-      errorMessage = String(err);
-    }
-    if (opts.onError) {
-      const overrides = opts.onError(err);
-      if (overrides) Object.assign(opts.attrs ??= {}, overrides);
+    refreshAttributes();
+    try {
+      const onError = opts.onError;
+      if (onError) {
+        const overrides = onError(err);
+        attributes = {
+          ...attributes,
+          ...projectDiagnosticFields(
+            overrides,
+            opts.dataset,
+            authority,
+            latestIdentityAuthority()
+          )
+        };
+      }
+    } catch {
     }
     emitRow();
     throw err;
   }
+  refreshAttributes();
+  try {
+    const inspect = opts.inspect;
+    if (inspect) {
+      const overrides = inspect(result);
+      const nextStatus = ownDataValue(overrides, "status");
+      const nextLevel = ownDataValue(overrides, "level");
+      const nextAttributes = ownDataValue(overrides, "attrs");
+      const projectedAttributes = nextAttributes === void 0 ? void 0 : projectDiagnosticFields(
+        nextAttributes,
+        opts.dataset,
+        authority,
+        latestIdentityAuthority()
+      );
+      if (nextStatus === "ok" || nextStatus === "error") status = nextStatus;
+      if (nextLevel === "info" || nextLevel === "warn" || nextLevel === "error") {
+        level = nextLevel;
+      }
+      if (projectedAttributes) {
+        attributes = { ...attributes, ...projectedAttributes };
+      }
+    }
+  } catch {
+  }
+  emitRow();
+  return result;
 }
 
 // src/observability/datasets.ts
@@ -298,11 +411,15 @@ function createLogger(dataset, bakedDims) {
       void withSpan({ dataset, name, level: "warn", attrs, dims: bakedDims }, noop).catch(noop);
     },
     error(name, attrs) {
-      const err = attrs?.err instanceof Error ? attrs.err : void 0;
-      const cleanAttrs = attrs ? { ...attrs } : void 0;
-      if (cleanAttrs) delete cleanAttrs.err;
       void withSpan(
-        { dataset, name, level: "error", attrs: cleanAttrs, dims: bakedDims, err },
+        {
+          dataset,
+          name,
+          level: "error",
+          attrs,
+          dims: bakedDims,
+          err: new Error()
+        },
         noop
       ).catch(noop);
     },
@@ -314,15 +431,13 @@ function createLogger(dataset, bakedDims) {
       return {
         [Symbol.dispose]() {
           const endMs = Date.now();
-          void withSpan({ dataset, name, attrs, dims: bakedDims, startMs, endMs }, noop).catch(
-            noop
-          );
+          void withSpan({ dataset, name, attrs, dims: bakedDims, startMs, endMs }, noop).catch(noop);
         }
       };
     },
     set(dims) {
       for (const [k, v] of Object.entries(dims)) {
-        pinDimension(k, v);
+        setDimension(k, v);
       }
     },
     extend(dims) {