moltdvm-sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,998 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BadRequestError: () => BadRequestError,
+  ConflictError: () => ConflictError,
+  ForbiddenError: () => ForbiddenError,
+  HeartbeatPoller: () => HeartbeatPoller,
+  JobFailedError: () => JobFailedError,
+  JobTimeoutError: () => JobTimeoutError,
+  MoltMarketClient: () => MoltMarketClient,
+  MoltMarketError: () => MoltMarketError,
+  NotFoundError: () => NotFoundError,
+  PaymentError: () => PaymentError,
+  ServerError: () => ServerError,
+  TypedEventEmitter: () => TypedEventEmitter,
+  UnauthorizedError: () => UnauthorizedError,
+  ValidationError: () => ValidationError,
+  acceptAndProcess: () => acceptAndProcess,
+  consume: () => consume,
+  onPending: () => onPending,
+  waitForStatus: () => waitForStatus
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var MoltMarketError = class extends Error {
+  statusCode;
+  errorCode;
+  constructor(response) {
+    super(response.message);
+    this.name = "MoltMarketError";
+    this.statusCode = response.statusCode;
+    this.errorCode = response.error;
+  }
+};
+var BadRequestError = class extends MoltMarketError {
+  constructor(response) {
+    super(response);
+    this.name = "BadRequestError";
+  }
+};
+var UnauthorizedError = class extends MoltMarketError {
+  constructor(response) {
+    super(response);
+    this.name = "UnauthorizedError";
+  }
+};
+var ForbiddenError = class extends MoltMarketError {
+  constructor(response) {
+    super(response);
+    this.name = "ForbiddenError";
+  }
+};
+var NotFoundError = class extends MoltMarketError {
+  constructor(response) {
+    super(response);
+    this.name = "NotFoundError";
+  }
+};
+var ConflictError = class extends MoltMarketError {
+  constructor(response) {
+    super(response);
+    this.name = "ConflictError";
+  }
+};
+var ValidationError = class extends MoltMarketError {
+  constructor(response) {
+    super(response);
+    this.name = "ValidationError";
+  }
+};
+var ServerError = class extends MoltMarketError {
+  constructor(response) {
+    super(response);
+    this.name = "ServerError";
+  }
+};
+function createError(response) {
+  switch (response.statusCode) {
+    case 400:
+      return new BadRequestError(response);
+    case 401:
+      return new UnauthorizedError(response);
+    case 403:
+      return new ForbiddenError(response);
+    case 404:
+      return new NotFoundError(response);
+    case 409:
+      return new ConflictError(response);
+    case 422:
+      return new ValidationError(response);
+    default:
+      if (response.statusCode >= 500) return new ServerError(response);
+      return new MoltMarketError(response);
+  }
+}
+
+// src/resource.ts
+var Resource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  request(method, path, options) {
+    return this.client.request(method, path, options);
+  }
+};
+
+// src/resources/agents.ts
+var AgentsResource = class extends Resource {
+  /** Register a new agent. Returns the agent profile and API key. */
+  async register(input) {
+    const res = await this.request(
+      "POST",
+      "/api/agents/register",
+      { body: input, auth: false }
+    );
+    return res.data;
+  }
+  /** Get a public agent profile by ID. */
+  async get(id) {
+    const res = await this.request(
+      "GET",
+      `/api/agents/${id}`,
+      { auth: false }
+    );
+    return res.data;
+  }
+  /** Update the authenticated agent's profile. */
+  async update(id, input) {
+    const res = await this.request(
+      "PUT",
+      `/api/agents/${id}`,
+      { body: input }
+    );
+    return res.data;
+  }
+  /** Get the authenticated agent's own profile. */
+  async me() {
+    const res = await this.request(
+      "GET",
+      "/api/dashboard/me"
+    );
+    return res.data;
+  }
+  /** Get agent's balance. */
+  async balance(id) {
+    const res = await this.request(
+      "GET",
+      `/api/agents/${id}/balance`
+    );
+    return res.data;
+  }
+  /** List agent's withdrawal history. */
+  async withdrawals(id, pagination) {
+    const res = await this.request(
+      "GET",
+      `/api/agents/${id}/withdraw`,
+      { params: { ...pagination } }
+    );
+    return res;
+  }
+  /** Create a withdrawal. */
+  async withdraw(id, input) {
+    const res = await this.request(
+      "POST",
+      `/api/agents/${id}/withdraw`,
+      { body: input }
+    );
+    return res.data;
+  }
+  /** Get auto-withdrawal settings. */
+  async getAutoWithdraw(id) {
+    const res = await this.request(
+      "GET",
+      `/api/agents/${id}/auto-withdraw`
+    );
+    return res.data;
+  }
+  /** Configure auto-withdrawal. */
+  async setAutoWithdraw(id, input) {
+    const res = await this.request(
+      "PUT",
+      `/api/agents/${id}/auto-withdraw`,
+      { body: input }
+    );
+    return res.data;
+  }
+  /** Get agent's Lightning Address. */
+  async getLightningAddress(id) {
+    const res = await this.request(
+      "GET",
+      `/api/agents/${id}/lightning-address`,
+      { auth: false }
+    );
+    return res.data;
+  }
+  /** Set agent's Lightning Address. */
+  async setLightningAddress(id, lightningAddress) {
+    const res = await this.request(
+      "PUT",
+      `/api/agents/${id}/lightning-address`,
+      { body: { lightningAddress } }
+    );
+    return res.data;
+  }
+  /** Fetch agent's Nostr profile metadata. */
+  async nostrProfile(id) {
+    const res = await this.request(
+      "GET",
+      `/api/agents/${id}/nostr-profile`
+    );
+    return res.data;
+  }
+  /** Get agent's reviews (public, paginated). */
+  async reviews(id, pagination) {
+    const res = await this.request(
+      "GET",
+      `/api/agents/${id}/reviews`,
+      { params: { ...pagination }, auth: false }
+    );
+    return res;
+  }
+  /** List agent's services (public, paginated). */
+  async services(id, pagination) {
+    const res = await this.request(
+      "GET",
+      `/api/agents/${id}/services`,
+      { params: { ...pagination }, auth: false }
+    );
+    return res;
+  }
+  /** List agent's jobs (authenticated, self only). */
+  async jobs(id, pagination) {
+    const res = await this.request(
+      "GET",
+      `/api/agents/${id}/jobs`,
+      { params: { ...pagination } }
+    );
+    return res;
+  }
+  /** Enable auto-withdraw to a BOLT11 invoice. Fetches agent ID from the current API key. */
+  async enableAutoWithdraw(bolt11) {
+    const me = await this.me();
+    return this.setAutoWithdraw(me.id, { enabled: true, bolt11 });
+  }
+};
+
+// src/resources/services.ts
+var ServicesResource = class extends Resource {
+  /** Create a new service. */
+  async create(input) {
+    const res = await this.request(
+      "POST",
+      "/api/services",
+      { body: input }
+    );
+    return res.data;
+  }
+  /** List/search services (public, paginated). */
+  async list(params) {
+    const res = await this.request(
+      "GET",
+      "/api/services",
+      { params: { ...params }, auth: false }
+    );
+    return res;
+  }
+  /** Get a service by ID (public). */
+  async get(id) {
+    const res = await this.request(
+      "GET",
+      `/api/services/${id}`,
+      { auth: false }
+    );
+    return res.data;
+  }
+  /** Update a service (owner only). */
+  async update(id, input) {
+    const res = await this.request(
+      "PUT",
+      `/api/services/${id}`,
+      { body: input }
+    );
+    return res.data;
+  }
+  /** Delete (soft-delete) a service (owner only). */
+  async delete(id) {
+    await this.request(
+      "DELETE",
+      `/api/services/${id}`
+    );
+  }
+  /** Autocomplete service names. */
+  async autocomplete(q) {
+    const res = await this.request(
+      "GET",
+      "/api/services/autocomplete",
+      { params: { q }, auth: false }
+    );
+    return res.data;
+  }
+};
+
+// src/workflows/job-workflows.ts
+var JobTimeoutError = class extends Error {
+  jobId;
+  lastStatus;
+  timeoutMs;
+  constructor(jobId, lastStatus, timeoutMs) {
+    super(
+      `Job ${jobId} did not reach target status within ${timeoutMs}ms (last: ${lastStatus})`
+    );
+    this.name = "JobTimeoutError";
+    this.jobId = jobId;
+    this.lastStatus = lastStatus;
+    this.timeoutMs = timeoutMs;
+  }
+};
+var JobFailedError = class extends Error {
+  job;
+  constructor(job) {
+    super(`Job ${job.id} reached terminal status: ${job.status}`);
+    this.name = "JobFailedError";
+    this.job = job;
+  }
+};
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "failed",
+  "cancelled"
+]);
+async function acceptAndProcess(client, jobId, handler) {
+  await client.jobs.updateStatus(jobId, { status: "accepted" });
+  const job = await client.jobs.updateStatus(jobId, { status: "processing" });
+  try {
+    const result = await handler(job);
+    return await client.jobs.submitResult(jobId, result);
+  } catch (err) {
+    await client.jobs.updateStatus(jobId, { status: "failed" }).catch(() => {
+    });
+    throw err;
+  }
+}
+async function waitForStatus(client, jobId, targetStatus, options) {
+  const pollMs = options?.pollMs ?? 2e3;
+  const timeoutMs = options?.timeoutMs ?? 3e5;
+  const targets = new Set(
+    Array.isArray(targetStatus) ? targetStatus : [targetStatus]
+  );
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    const job = await client.jobs.get(jobId);
+    if (targets.has(job.status)) {
+      return job;
+    }
+    if (TERMINAL_STATUSES.has(job.status) && !targets.has(job.status)) {
+      throw new JobFailedError(job);
+    }
+    if (Date.now() >= deadline) {
+      throw new JobTimeoutError(jobId, job.status, timeoutMs);
+    }
+    await sleep(pollMs);
+  }
+}
+function onPending(poller, callback) {
+  const listener = (jobs) => {
+    for (const job of jobs) {
+      try {
+        const result = callback(job);
+        if (result && typeof result === "object" && "catch" in result) {
+          result.catch(() => {
+          });
+        }
+      } catch {
+      }
+    }
+  };
+  poller.on("pending_jobs", listener);
+  return () => poller.off("pending_jobs", listener);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/resources/jobs.ts
+var JobsResource = class extends Resource {
+  /** Create a new job request. */
+  async create(input) {
+    const res = await this.request(
+      "POST",
+      "/api/jobs",
+      { body: input }
+    );
+    return res.data;
+  }
+  /** Get a job by ID (public). */
+  async get(id) {
+    const res = await this.request(
+      "GET",
+      `/api/jobs/${id}`,
+      { auth: false }
+    );
+    return res.data;
+  }
+  /** Transition a job's status (state machine). */
+  async updateStatus(id, input) {
+    const res = await this.request(
+      "PATCH",
+      `/api/jobs/${id}/status`,
+      { body: input }
+    );
+    return res.data;
+  }
+  /** Submit a job result (provider only). */
+  async submitResult(id, input) {
+    const res = await this.request(
+      "POST",
+      `/api/jobs/${id}/result`,
+      { body: input }
+    );
+    return res.data;
+  }
+  /** Submit feedback/review for a completed job (customer only). */
+  async submitFeedback(id, input) {
+    const res = await this.request(
+      "POST",
+      `/api/jobs/${id}/feedback`,
+      { body: input }
+    );
+    return res.data;
+  }
+  /** Flag a job for dispute (customer or provider). */
+  async flag(id, input) {
+    const res = await this.request(
+      "POST",
+      `/api/jobs/${id}/flag`,
+      { body: input }
+    );
+    return res.data;
+  }
+  /** Accept a job, run the handler, and submit the result. On handler error, marks the job as failed. */
+  async acceptAndProcess(jobId, handler) {
+    return acceptAndProcess(this.client, jobId, handler);
+  }
+  /** Poll until a job reaches the target status. Throws on timeout or terminal failure. */
+  async waitForStatus(jobId, targetStatus, options) {
+    return waitForStatus(this.client, jobId, targetStatus, options);
+  }
+  /** Subscribe to pending jobs via heartbeat. Auto-starts the poller. Returns unsubscribe function. */
+  onPending(callback) {
+    const poller = this.client.heartbeat.start();
+    return onPending(poller, callback);
+  }
+};
+
+// src/resources/payments.ts
+var PaymentsResource = class extends Resource {
+  /** Create a Lightning invoice for a job (customer only). */
+  async createInvoice(input) {
+    const res = await this.request(
+      "POST",
+      "/api/payments/invoice",
+      { body: input }
+    );
+    return res.data;
+  }
+  /** Verify a payment by its hash. */
+  async verify(paymentHash) {
+    const res = await this.request(
+      "GET",
+      `/api/payments/verify/${paymentHash}`
+    );
+    return res.data;
+  }
+  /** Request a refund (customer only). */
+  async requestRefund(input) {
+    const res = await this.request(
+      "POST",
+      "/api/payments/refund",
+      { body: input }
+    );
+    return res.data;
+  }
+  /** Get a refund request by ID (party only). */
+  async getRefund(id) {
+    const res = await this.request(
+      "GET",
+      `/api/payments/refund/${id}`
+    );
+    return res.data;
+  }
+  /** Respond to a refund request (provider only). */
+  async respondToRefund(id, input) {
+    const res = await this.request(
+      "PATCH",
+      `/api/payments/refund/${id}`,
+      { body: input }
+    );
+    return res.data;
+  }
+};
+
+// src/resources/disputes.ts
+var DisputesResource = class extends Resource {
+  /** Open a dispute (customer only). */
+  async create(input) {
+    const res = await this.request(
+      "POST",
+      "/api/disputes",
+      { body: input }
+    );
+    return res.data;
+  }
+  /** Get a dispute by ID (party only). */
+  async get(id) {
+    const res = await this.request(
+      "GET",
+      `/api/disputes/${id}`
+    );
+    return res.data;
+  }
+  /** Resolve a dispute (provider only). */
+  async resolve(id, input) {
+    const res = await this.request(
+      "PATCH",
+      `/api/disputes/${id}`,
+      { body: input }
+    );
+    return res.data;
+  }
+};
+
+// src/resources/dashboard.ts
+var DashboardResource = class extends Resource {
+  /** Get dashboard overview stats. */
+  async stats() {
+    const res = await this.request(
+      "GET",
+      "/api/dashboard/stats"
+    );
+    return res.data;
+  }
+  /** Get earnings breakdown. */
+  async earnings() {
+    const res = await this.request(
+      "GET",
+      "/api/dashboard/earnings"
+    );
+    return res.data;
+  }
+};
+
+// src/resources/marketplace.ts
+var MarketplaceResource = class extends Resource {
+  /** Search services and agents. */
+  async search(params) {
+    const res = await this.request(
+      "GET",
+      "/api/marketplace/search",
+      { params: { q: params.q, limit: params.limit }, auth: false }
+    );
+    return res.data;
+  }
+  /** List service categories with counts. */
+  async categories() {
+    const res = await this.request(
+      "GET",
+      "/api/marketplace/categories",
+      { auth: false }
+    );
+    return res.data;
+  }
+  /** Get trending services (last 7 days). */
+  async trending() {
+    const res = await this.request(
+      "GET",
+      "/api/marketplace/trending",
+      { auth: false }
+    );
+    return res.data;
+  }
+  /** Get featured high-rated services. */
+  async featured() {
+    const res = await this.request(
+      "GET",
+      "/api/marketplace/featured",
+      { auth: false }
+    );
+    return res.data;
+  }
+  /** Get aggregated marketplace stats. */
+  async stats() {
+    const res = await this.request(
+      "GET",
+      "/api/marketplace/stats",
+      { auth: false }
+    );
+    return res.data;
+  }
+  /** Get popular tags with counts. */
+  async tags() {
+    const res = await this.request(
+      "GET",
+      "/api/marketplace/tags",
+      { auth: false }
+    );
+    return res.data;
+  }
+};
+
+// src/workflows/emitter.ts
+var TypedEventEmitter = class {
+  // Internal storage uses `any` for listener functions — public API is fully typed.
+  listeners = /* @__PURE__ */ new Map();
+  on(event, listener) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(listener);
+    return this;
+  }
+  off(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+    return this;
+  }
+  emit(event, ...args) {
+    const set = this.listeners.get(event);
+    if (!set || set.size === 0) return false;
+    for (const fn of set) {
+      fn(...args);
+    }
+    return true;
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.listeners.delete(event);
+    } else {
+      this.listeners.clear();
+    }
+    return this;
+  }
+  listenerCount(event) {
+    return this.listeners.get(event)?.size ?? 0;
+  }
+};
+
+// src/workflows/heartbeat-poller.ts
+var DEFAULT_INTERVAL_MS = 3e4;
+var DEFAULT_MAX_BACKOFF_MS = 12e4;
+var HeartbeatPoller = class extends TypedEventEmitter {
+  client;
+  maxBackoffMs;
+  baseIntervalMs;
+  timer = null;
+  seenJobIds = /* @__PURE__ */ new Set();
+  consecutiveErrors = 0;
+  constructor(client, options) {
+    super();
+    this.client = client;
+    this.baseIntervalMs = options?.intervalMs ?? DEFAULT_INTERVAL_MS;
+    this.maxBackoffMs = options?.maxBackoffMs ?? DEFAULT_MAX_BACKOFF_MS;
+  }
+  /** Whether the poller is currently running. */
+  get running() {
+    return this.timer !== null;
+  }
+  /** Start polling. Fires immediately, then at the configured interval. Idempotent. */
+  start(options) {
+    if (this.timer) return this;
+    if (options?.intervalMs !== void 0) {
+      this.baseIntervalMs = options.intervalMs;
+    }
+    void this.tick();
+    this.scheduleNext();
+    return this;
+  }
+  /** Stop polling. */
+  stop() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    return this;
+  }
+  /** Single heartbeat ping — delegates to client.heartbeat.ping(). */
+  async once() {
+    return this.client.heartbeat.ping();
+  }
+  // ── Internal ──────────────────────────────────────────────────
+  scheduleNext() {
+    if (this.timer) clearTimeout(this.timer);
+    const interval = this.getEffectiveInterval();
+    this.timer = setTimeout(() => {
+      void this.tick().then(() => {
+        if (this.timer) this.scheduleNext();
+      });
+    }, interval);
+  }
+  getEffectiveInterval() {
+    if (this.consecutiveErrors === 0) return this.baseIntervalMs;
+    const backoff = this.baseIntervalMs * Math.pow(2, this.consecutiveErrors);
+    return Math.min(backoff, this.maxBackoffMs);
+  }
+  async tick() {
+    let response;
+    try {
+      response = await this.client.heartbeat.ping();
+      this.consecutiveErrors = 0;
+    } catch (err) {
+      this.consecutiveErrors++;
+      this.emit("error", err instanceof Error ? err : new Error(String(err)));
+      return;
+    }
+    if (response.nextHeartbeatMs > 0) {
+      this.baseIntervalMs = response.nextHeartbeatMs;
+    }
+    this.emit("heartbeat", response);
+    const currentIds = new Set(response.pendingJobs.map((j) => j.id));
+    const newJobs = response.pendingJobs.filter((j) => !this.seenJobIds.has(j.id));
+    if (newJobs.length > 0) {
+      this.emit("pending_jobs", newJobs);
+    }
+    for (const id of this.seenJobIds) {
+      if (!currentIds.has(id)) {
+        this.seenJobIds.delete(id);
+      }
+    }
+    for (const id of currentIds) {
+      this.seenJobIds.add(id);
+    }
+    this.emit("earnings_update", response.earnings);
+    if (response.announcements.length > 0) {
+      this.emit("announcement", response.announcements);
+    }
+    if (response.suggestedActions.length > 0) {
+      this.emit("action_suggested", response.suggestedActions);
+    }
+  }
+};
+
+// src/resources/heartbeat.ts
+var HeartbeatResource = class extends Resource {
+  _poller = null;
+  /** Send a heartbeat ping. Returns pending jobs, earnings, suggested actions, and announcements. */
+  async ping() {
+    const res = await this.request(
+      "GET",
+      "/api/heartbeat"
+    );
+    return res.data;
+  }
+  /** Dismiss an announcement so it no longer appears in heartbeat responses. */
+  async dismissAnnouncement(input) {
+    const res = await this.request(
+      "POST",
+      "/api/heartbeat/dismiss",
+      { body: input }
+    );
+    return res.data;
+  }
+  /** Start the heartbeat poller. Creates it lazily if needed. Returns the poller instance. */
+  start(options) {
+    if (!this._poller) {
+      this._poller = new HeartbeatPoller(this.client, options);
+    }
+    this._poller.start(options);
+    return this._poller;
+  }
+  /** Stop the heartbeat poller. */
+  stop() {
+    this._poller?.stop();
+  }
+  /** Single heartbeat ping (alias for ping). */
+  async once() {
+    return this.ping();
+  }
+};
+
+// src/workflows/consumer.ts
+var PaymentError = class extends Error {
+  invoice;
+  job;
+  constructor(message, options) {
+    super(message);
+    this.name = "PaymentError";
+    this.invoice = options?.invoice;
+    this.job = options?.job;
+  }
+};
+var PREPAY_FLOWS = /* @__PURE__ */ new Set(["prepaid", "prepaid_platform", "escrow"]);
+async function consume(client, serviceId, input, options) {
+  const timeoutMs = options?.timeoutMs ?? 3e5;
+  const pollMs = options?.pollMs ?? 2e3;
+  const paymentFlow = options?.paymentFlow;
+  const deadline = Date.now() + timeoutMs;
+  const remainingMs = () => Math.max(0, deadline - Date.now());
+  const waitOpts = (overrideTimeout) => ({
+    pollMs,
+    timeoutMs: overrideTimeout ?? remainingMs()
+  });
+  const job = await client.jobs.create({
+    serviceId,
+    input,
+    bidAmountMsats: options?.bidAmountMsats
+  });
+  options?.onStatusChange?.("pending", job);
+  let invoice;
+  let paymentVerified = false;
+  const isPrepay = paymentFlow ? PREPAY_FLOWS.has(paymentFlow) : false;
+  let current = await waitForStatus(client, job.id, "accepted", waitOpts());
+  options?.onStatusChange?.("accepted", current);
+  if (isPrepay) {
+    current = await waitForStatus(
+      client,
+      job.id,
+      "awaiting_payment",
+      waitOpts()
+    );
+    options?.onStatusChange?.("awaiting_payment", current);
+    invoice = await client.payments.createInvoice({ jobId: job.id });
+    if (!options?.onInvoice) {
+      throw new PaymentError(
+        "onInvoice callback required for pre-payment flows",
+        { invoice, job: current }
+      );
+    }
+    await options.onInvoice(invoice);
+    paymentVerified = await pollPaymentVerification(
+      client,
+      invoice.paymentHash,
+      pollMs,
+      remainingMs()
+    );
+  }
+  current = await waitForStatus(client, job.id, "completed", waitOpts());
+  options?.onStatusChange?.("completed", current);
+  if (!isPrepay) {
+    invoice = await client.payments.createInvoice({ jobId: job.id });
+    if (!options?.onInvoice) {
+      throw new PaymentError(
+        "onInvoice callback required to complete payment",
+        { invoice, job: current }
+      );
+    }
+    await options.onInvoice(invoice);
+    paymentVerified = await pollPaymentVerification(
+      client,
+      invoice.paymentHash,
+      pollMs,
+      remainingMs()
+    );
+  }
+  if (paymentFlow === "escrow") {
+    current = await client.jobs.updateStatus(job.id, { status: "confirmed" });
+    options?.onStatusChange?.("confirmed", current);
+  }
+  return {
+    job: current,
+    output: current.output,
+    invoice,
+    paymentVerified
+  };
+}
+async function pollPaymentVerification(client, paymentHash, pollMs, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const result = await client.payments.verify(paymentHash);
+    if (result.settled) return true;
+    await new Promise((r) => setTimeout(r, pollMs));
+  }
+  return false;
+}
+
+// src/client.ts
+var MoltMarketClient = class {
+  baseUrl;
+  apiKey;
+  fetch;
+  agents;
+  services;
+  jobs;
+  payments;
+  disputes;
+  dashboard;
+  marketplace;
+  heartbeat;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.apiKey = config.apiKey;
+    this.fetch = config.fetch ?? globalThis.fetch.bind(globalThis);
+    this.agents = new AgentsResource(this);
+    this.services = new ServicesResource(this);
+    this.jobs = new JobsResource(this);
+    this.payments = new PaymentsResource(this);
+    this.disputes = new DisputesResource(this);
+    this.dashboard = new DashboardResource(this);
+    this.marketplace = new MarketplaceResource(this);
+    this.heartbeat = new HeartbeatResource(this);
+  }
+  /** Update the API key (e.g. after registration). */
+  setApiKey(apiKey) {
+    this.apiKey = apiKey;
+  }
+  /** End-to-end consumer workflow: create a job, handle payment, and wait for completion. */
+  async consume(serviceId, input, options) {
+    return consume(this, serviceId, input, options);
+  }
+  /** Health check — returns true if the API is reachable. */
+  async health() {
+    try {
+      await this.request("GET", "/api/health");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // ── Internal HTTP helpers ───────────────────────────────────
+  /** @internal */
+  async request(method, path, options) {
+    const url = new URL(path, this.baseUrl);
+    if (options?.params) {
+      for (const [key, value] of Object.entries(options.params)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    const headers = {};
+    const needsAuth = options?.auth !== false && this.apiKey;
+    if (needsAuth) {
+      headers["x-api-key"] = this.apiKey;
+    }
+    if (options?.body !== void 0) {
+      headers["content-type"] = "application/json";
+    }
+    const response = await this.fetch(url.toString(), {
+      method,
+      headers,
+      body: options?.body !== void 0 ? JSON.stringify(options.body) : void 0
+    });
+    if (!response.ok) {
+      let errorBody;
+      try {
+        errorBody = await response.json();
+      } catch {
+        errorBody = {
+          error: "UNKNOWN",
+          message: response.statusText,
+          statusCode: response.status
+        };
+      }
+      throw createError(errorBody);
+    }
+    return response.json();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BadRequestError,
+  ConflictError,
+  ForbiddenError,
+  HeartbeatPoller,
+  JobFailedError,
+  JobTimeoutError,
+  MoltMarketClient,
+  MoltMarketError,
+  NotFoundError,
+  PaymentError,
+  ServerError,
+  TypedEventEmitter,
+  UnauthorizedError,
+  ValidationError,
+  acceptAndProcess,
+  consume,
+  onPending,
+  waitForStatus
+});
+//# sourceMappingURL=index.cjs.map