openpond-sdk 0.11.0 → 0.11.3

package/dist/dataset-commerce.js

@@ -0,0 +1,773 @@
+// src/dataset-commerce-files.ts
+import { z as z3 } from "zod";
+
+// src/dataset-commerce-contracts.ts
+import { z } from "zod";
+var CommerceId = z.string().min(1).max(191);
+var CommerceHash = z.string().regex(/^[a-f0-9]{64}$/);
+var UsdcAmount = z.string().regex(/^[1-9][0-9]{0,11}$/);
+var CommerceOperation = z.object({ operationId: CommerceId });
+var CommerceReleaseRef = z.object({
+  id: CommerceId,
+  revision: z.number().int().positive(),
+  contentHash: CommerceHash
+}).strict();
+var ListingTerms = z.object({
+  title: z.string().trim().min(3).max(160),
+  description: z.string().trim().min(10).max(8e3),
+  category: z.string().trim().min(1).max(80),
+  tags: z.array(z.string().trim().min(1).max(40)).max(12),
+  priceBaseUnits: UsdcAmount,
+  license: z.string().trim().min(3).max(4e3)
+}).strict();
+var CaptureCommerceRelease = CommerceOperation.extend({
+  tasksetId: CommerceId,
+  release: CommerceReleaseRef,
+  packageHash: CommerceHash,
+  sampleTaskIds: z.array(CommerceId).min(1).max(10),
+  approvedSample: z.literal(true)
+}).strict();
+var WriteCommerceListing = CommerceOperation.extend({
+  id: CommerceId.optional(),
+  expectedRevision: z.number().int().nonnegative(),
+  releaseId: CommerceId,
+  terms: ListingTerms,
+  state: z.enum(["draft", "listed", "paused", "retired"])
+}).strict();
+var CommerceCursor = z.string().min(1).max(1024);
+var CommerceDatasetFormat = z.enum([
+  "native",
+  "csv",
+  "jsonl",
+  "parquet"
+]);
+var CommerceBrowse = z.object({
+  search: z.string().max(120).optional(),
+  category: z.string().max(80).optional(),
+  format: CommerceDatasetFormat.optional(),
+  license: z.string().max(120).optional(),
+  minPriceBaseUnits: z.string().regex(/^(0|[1-9][0-9]{0,11})$/).optional(),
+  maxPriceBaseUnits: UsdcAmount.optional(),
+  sort: z.enum(["newest", "price_low", "price_high"]).default("newest"),
+  cursor: CommerceCursor.optional(),
+  limit: z.coerce.number().int().min(1).max(50).default(20)
+}).refine(
+  (value) => !value.minPriceBaseUnits || !value.maxPriceBaseUnits || BigInt(value.minPriceBaseUnits) <= BigInt(value.maxPriceBaseUnits),
+  {
+    message: "Minimum price must not exceed maximum price.",
+    path: ["maxPriceBaseUnits"]
+  }
+);
+var DatasetRequestContent = z.object({
+  title: z.string().trim().min(3).max(160),
+  description: z.string().trim().min(10).max(8e3),
+  category: z.string().trim().min(1).max(80),
+  budgetBaseUnits: UsdcAmount,
+  requirements: z.object({
+    schema: z.string().max(8e3).default(""),
+    formats: z.array(z.enum(["native", "csv", "jsonl", "parquet"])).min(1),
+    minRecords: z.number().int().nonnegative().optional(),
+    maxRecords: z.number().int().positive().optional(),
+    languages: z.array(z.string().max(80)).max(20).default([]),
+    provenance: z.string().max(4e3).default(""),
+    license: z.string().max(4e3).default(""),
+    privacy: z.string().max(4e3).default(""),
+    acceptance: z.string().max(4e3).default("")
+  }).strict(),
+  deadline: z.string().datetime().nullable(),
+  projectId: CommerceId.nullable()
+}).strict();
+var WriteDatasetRequest = CommerceOperation.extend({
+  id: CommerceId.optional(),
+  expectedRevision: z.number().int().nonnegative(),
+  content: DatasetRequestContent,
+  state: z.enum(["draft", "open", "paused", "closed", "cancelled"])
+}).strict();
+var SubmitDatasetOffer = CommerceOperation.extend({
+  requestId: CommerceId,
+  requestRevision: z.number().int().positive(),
+  expectedRevision: z.number().int().nonnegative(),
+  releaseId: CommerceId,
+  priceBaseUnits: UsdcAmount,
+  license: z.string().min(3).max(4e3),
+  explanation: z.string().min(10).max(8e3),
+  expiresAt: z.string().datetime()
+}).strict();
+var ReviewDatasetOffer = CommerceOperation.extend({
+  id: CommerceId,
+  expectedRevision: z.number().int().positive(),
+  expectedUpdatedAt: z.string().datetime(),
+  state: z.enum(["submitted", "shortlisted", "changes_requested", "declined"]),
+  note: z.string().max(8e3).optional()
+}).strict();
+var CommerceCheckout = CommerceOperation.extend({
+  source: z.enum(["listing", "offer"]),
+  sourceId: CommerceId,
+  sourceRevision: z.number().int().positive(),
+  destinationProjectId: CommerceId.nullable(),
+  acceptedTermsHash: CommerceHash
+}).strict();
+var CommerceProfileContent = z.object({
+  bio: z.string().max(2e3),
+  specialties: z.array(z.string().min(1).max(80)).max(12)
+}).strict();
+var WriteCommerceProfile = CommerceOperation.extend({
+  expectedRevision: z.number().int().nonnegative(),
+  content: CommerceProfileContent
+}).strict();
+
+// src/dataset-commerce-responses.ts
+import { z as z2 } from "zod";
+var Timestamp = z2.string().datetime({ offset: true });
+var Address = z2.string().regex(/^0x[a-fA-F0-9]{40}$/);
+var TransactionHash = z2.string().regex(/^0x[a-fA-F0-9]{64}$/);
+var CommerceSampleSchema = z2.array(z2.object({ taskId: CommerceId, input: z2.unknown() }).strict()).max(10);
+var CommerceCapturedReleaseSchema = z2.object({
+  id: CommerceId,
+  release: CommerceReleaseRef,
+  packageHash: CommerceHash,
+  sample: CommerceSampleSchema,
+  sampleHash: CommerceHash,
+  taskCount: z2.number().int().nonnegative(),
+  sizeBytes: z2.number().int().nonnegative()
+}).strict();
+var CommerceListingSchema = CommerceCapturedReleaseSchema.extend({
+  format: CommerceDatasetFormat,
+  revision: z2.number().int().positive(),
+  teamId: CommerceId,
+  sellerUserId: CommerceId,
+  releaseId: CommerceId,
+  state: z2.enum(["draft", "listed", "paused", "retired"]),
+  terms: ListingTerms,
+  termsHash: CommerceHash,
+  createdAt: Timestamp
+}).strict();
+var CommerceListingReceiptSchema = z2.object({
+  id: CommerceId,
+  revision: z2.number().int().positive(),
+  releaseId: CommerceId,
+  state: z2.enum(["draft", "listed", "paused", "retired"]),
+  terms: ListingTerms,
+  termsHash: CommerceHash,
+  payee: Address
+}).strict();
+var CommerceListingsPageSchema = z2.object({
+  items: z2.array(CommerceListingSchema).max(50),
+  cursor: CommerceCursor.nullable()
+}).strict();
+var CommerceInventorySchema = z2.object({
+  releases: z2.array(
+    CommerceCapturedReleaseSchema.omit({
+      sizeBytes: true,
+      sample: true
+    }).extend({
+      tasksetId: CommerceId,
+      title: z2.string()
+    })
+  ).max(100),
+  listings: z2.array(CommerceListingSchema.omit({ sample: true })).max(100)
+}).strict();
+var CommerceOrderSchema = z2.object({
+  id: CommerceId,
+  buyerUserId: CommerceId,
+  buyerTeamId: CommerceId,
+  sellerUserId: CommerceId,
+  sellerTeamId: CommerceId,
+  source: z2.enum(["listing", "offer"]),
+  sourceId: CommerceId,
+  sourceRevision: z2.number().int().positive(),
+  releaseId: CommerceId,
+  termsHash: CommerceHash,
+  amountBaseUnits: UsdcAmount,
+  sender: Address,
+  payee: Address,
+  chainId: z2.literal(42161),
+  tokenAddress: Address,
+  authorizationNonce: TransactionHash,
+  issuedBlock: z2.string().regex(/^[0-9]+$/),
+  scannedBlock: z2.string().regex(/^[0-9]+$/).nullable(),
+  validAfter: Timestamp,
+  expiresAt: Timestamp,
+  destinationProjectId: CommerceId.nullable(),
+  state: z2.enum([
+    "awaiting_payment",
+    "confirming",
+    "paid",
+    "delivery_failed",
+    "delivered",
+    "expired"
+  ]),
+  transactionHash: TransactionHash.nullable(),
+  deliveryTasksetId: CommerceId.nullable(),
+  errorCode: z2.string().nullable(),
+  deliveryKind: z2.enum(["draft", "release"]).optional(),
+  deliveredAt: Timestamp.nullable(),
+  nextAttemptAt: Timestamp,
+  createdAt: Timestamp,
+  updatedAt: Timestamp
+}).strict();
+var CommercePaymentSubmissionSchema = z2.union([
+  z2.object({
+    orderId: CommerceId,
+    state: z2.enum(["awaiting_payment", "confirming"])
+  }).strict(),
+  CommerceOrderSchema
+]);
+var CommerceRequestSchema = z2.object({
+  id: CommerceId,
+  buyerUserId: CommerceId,
+  revision: z2.number().int().positive(),
+  state: z2.enum([
+    "draft",
+    "open",
+    "paused",
+    "closed",
+    "cancelled",
+    "fulfilled"
+  ]),
+  content: DatasetRequestContent,
+  createdAt: Timestamp
+}).strict();
+var CommerceRequestsPageSchema = z2.object({
+  items: z2.array(CommerceRequestSchema).max(50),
+  cursor: CommerceCursor.nullable()
+}).strict();
+var CommerceRequestReceiptSchema = CommerceRequestSchema.omit({
+  buyerUserId: true,
+  createdAt: true
+});
+var CommerceOwnedRequestSchema = CommerceRequestSchema.extend({
+  teamId: CommerceId,
+  selectedOrderId: CommerceId.nullable(),
+  updatedAt: Timestamp
+}).strict();
+var CommerceOfferSchema = z2.object({
+  id: CommerceId,
+  requestId: CommerceId,
+  requestTitle: z2.string(),
+  requestRevision: z2.number().int().positive(),
+  buyerUserId: CommerceId,
+  sellerUserId: CommerceId,
+  state: z2.enum([
+    "submitted",
+    "shortlisted",
+    "changes_requested",
+    "declined",
+    "withdrawn",
+    "selected",
+    "purchased",
+    "not_selected"
+  ]),
+  revision: z2.number().int().positive(),
+  updatedAt: Timestamp,
+  proposal: z2.object({
+    offerId: CommerceId,
+    revision: z2.number().int().positive(),
+    requestRevision: z2.number().int().positive(),
+    releaseId: CommerceId,
+    priceBaseUnits: UsdcAmount,
+    license: z2.string(),
+    explanation: z2.string(),
+    payee: Address,
+    termsHash: CommerceHash,
+    expiresAt: Timestamp,
+    createdAt: Timestamp
+  }).strict(),
+  release: CommerceReleaseRef,
+  taskCount: z2.number().int().nonnegative(),
+  sample: CommerceSampleSchema,
+  sampleHash: CommerceHash,
+  notes: z2.array(
+    z2.object({
+      id: CommerceId,
+      authorUserId: CommerceId,
+      body: z2.string(),
+      createdAt: Timestamp
+    }).strict()
+  ).max(1e3)
+}).strict();
+var CommerceOfferSummarySchema = CommerceOfferSchema.omit({
+  sample: true,
+  notes: true
+});
+var CommerceOfferDetailSchema = CommerceOfferSchema.extend({
+  notes: CommerceOfferSchema.shape.notes.max(20),
+  notesCursor: CommerceId.nullable(),
+  history: z2.array(CommerceOfferSchema.shape.proposal).max(20),
+  historyBefore: z2.number().int().positive().nullable(),
+  canReview: z2.boolean()
+}).strict();
+var CommerceOfferSubmissionSchema = z2.object({
+  id: CommerceId,
+  revision: z2.number().int().positive(),
+  state: z2.literal("submitted"),
+  termsHash: CommerceHash
+}).strict();
+var CommerceOfferReviewReceiptSchema = z2.object({
+  id: CommerceId,
+  revision: z2.number().int().positive(),
+  state: z2.enum([
+    "submitted",
+    "shortlisted",
+    "changes_requested",
+    "declined"
+  ])
+}).strict();
+
+// src/dataset-commerce-files.ts
+var CommerceFileMetadataSchema = z3.object({
+  name: z3.string().min(1).max(160).regex(/^[a-zA-Z0-9][a-zA-Z0-9_. -]*$/).refine((name) => !name.includes("..")),
+  format: z3.enum(["csv", "jsonl", "parquet"]),
+  contentHash: CommerceHash,
+  sizeBytes: z3.number().int().positive().max(16 * 1024 * 1024)
+}).strict();
+var PrepareCommerceFileSchema = CommerceOperation.extend({
+  file: CommerceFileMetadataSchema
+}).strict();
+var CaptureCommerceFileSchema = z3.object({
+  uploadId: CommerceId,
+  capture: CommerceOperation.extend({
+    expectedHash: CommerceHash,
+    sampleTaskIds: z3.array(CommerceId).min(1).max(10),
+    approvedSample: z3.literal(true)
+  }).strict()
+}).strict();
+var CommerceFilePreviewSchema = CommerceFileMetadataSchema.extend({
+  rowCount: z3.number().int().nonnegative().max(1e7),
+  columns: z3.array(z3.string()).max(256),
+  rows: z3.array(z3.object({ taskId: CommerceId, input: z3.record(z3.string(), z3.unknown()) }).strict()).max(50)
+}).strict();
+var Ticket = z3.object({ uploadId: CommerceId, uploadUrl: z3.string().url(), expiresAt: z3.string().datetime() }).strict();
+var OpenPondCommerceFiles = class {
+  constructor(request, fetcher) {
+    this.request = request;
+    this.fetcher = fetcher;
+  }
+  request;
+  fetcher;
+  async prepare(input, options = {}) {
+    const value = PrepareCommerceFileSchema.parse(input);
+    if (!value.file.name.toLowerCase().endsWith(`.${value.file.format}`))
+      throw new Error("Filename must match the dataset format.");
+    const result = Ticket.parse(await this.request("/prepare-file", options, value));
+    const url = new URL(result.uploadUrl);
+    if (result.uploadId !== value.operationId || url.protocol !== "https:" || url.username || url.password || new Date(result.expiresAt).getTime() <= Date.now())
+      throw new Error("Dataset upload ticket does not match this operation.");
+    return result;
+  }
+  async preview(uploadId, options = {}) {
+    return CommerceFilePreviewSchema.parse(
+      await this.request("/preview-file", options, { uploadId: CommerceId.parse(uploadId) })
+    );
+  }
+  async capture(input, options = {}) {
+    const value = CaptureCommerceFileSchema.parse(input);
+    const result = CommerceCapturedReleaseSchema.parse(
+      await this.request("/capture-file", options, value)
+    );
+    if (result.packageHash !== value.capture.expectedHash || result.sample.length !== new Set(value.capture.sampleTaskIds).size || result.sample.some((row) => !value.capture.sampleTaskIds.includes(row.taskId)))
+      throw new Error("Captured file does not match the approved preview.");
+    return result;
+  }
+  async upload(input, options = {}) {
+    const bytes = Uint8Array.from(input.bytes);
+    if (!bytes.length || bytes.length > 16 * 1024 * 1024)
+      throw new Error("Choose a nonempty dataset file up to 16 MiB.");
+    const hash = new Uint8Array(await crypto.subtle.digest("SHA-256", bytes));
+    const contentHash = Array.from(hash, (byte) => byte.toString(16).padStart(2, "0")).join("");
+    const file = { name: input.name, format: input.format, contentHash, sizeBytes: bytes.length };
+    const ticket = await this.prepare({ operationId: input.operationId, file }, options);
+    const response = await this.fetcher(ticket.uploadUrl, {
+      method: "PUT",
+      body: bytes,
+      headers: { "Content-Type": "application/octet-stream" },
+      redirect: "error",
+      credentials: "omit",
+      signal: options.signal
+    });
+    if (!response.ok)
+      throw new Error(
+        `Private dataset upload failed (${response.status}). Retry with the same operation ID.`
+      );
+    const preview = await this.preview(ticket.uploadId, options);
+    if (preview.contentHash !== contentHash || preview.sizeBytes !== bytes.length || preview.name !== input.name || preview.format !== input.format)
+      throw new Error("Uploaded dataset preview does not match the supplied file.");
+    return { uploadId: ticket.uploadId, preview };
+  }
+};
+
+// src/dataset-commerce.ts
+import { z as z4 } from "zod";
+var OpenPondDatasetCommerceError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "OpenPondDatasetCommerceError";
+  }
+  status;
+  code;
+};
+var OpenPondDatasetCommerceClient = class {
+  #options;
+  files;
+  constructor(options) {
+    const url = new URL(options.baseUrl);
+    if (!["https:", "http:"].includes(url.protocol) || url.username || url.password || url.search || url.hash)
+      throw new Error(
+        "Dataset commerce base URL must be an HTTP(S) endpoint without credentials, query, or fragment."
+      );
+    this.#options = { ...options, baseUrl: url.toString().replace(/\/+$/, "") };
+    this.files = new OpenPondCommerceFiles(
+      (path, requestOptions, input) => this.#request(path, requestOptions, input),
+      options.fetch ?? globalThis.fetch
+    );
+  }
+  async browse(query = {}, options = {}) {
+    const input = CommerceBrowse.parse(query), search = new URLSearchParams();
+    for (const [key, value] of Object.entries(input))
+      if (value !== void 0) search.set(key, String(value));
+    const result = CommerceListingsPageSchema.parse(
+      await this.#request(`/listings?${search}`, options)
+    );
+    if (result.items.length > input.limit || result.items.some(
+      (item) => item.state !== "listed" || input.category && item.terms.category !== input.category || input.format && item.format !== input.format || input.license && !item.terms.license.toLowerCase().includes(input.license.toLowerCase()) || input.minPriceBaseUnits && BigInt(item.terms.priceBaseUnits) < BigInt(input.minPriceBaseUnits) || input.maxPriceBaseUnits && BigInt(item.terms.priceBaseUnits) > BigInt(input.maxPriceBaseUnits)
+    ))
+      this.#mismatch();
+    return result;
+  }
+  async listing(id, options = {}) {
+    CommerceId.parse(id);
+    const result = CommerceListingSchema.parse(
+      await this.#request(`/listings/${encodeURIComponent(id)}`, options)
+    );
+    if (result.id !== id) this.#mismatch();
+    return result;
+  }
+  async inventory(options = {}) {
+    const result = CommerceInventorySchema.parse(
+      await this.#request("/inventory", options, void 0, true)
+    );
+    if (result.listings.some((item) => item.teamId !== this.#options.teamId))
+      this.#mismatch();
+    return result;
+  }
+  async capture(input, options = {}) {
+    const request = CaptureCommerceRelease.parse(input);
+    const result = CommerceCapturedReleaseSchema.parse(
+      await this.#request("/capture", options, request)
+    );
+    if (result.packageHash !== request.packageHash || result.release.id !== request.release.id || result.release.revision !== request.release.revision || result.release.contentHash !== request.release.contentHash || result.sample.length !== new Set(request.sampleTaskIds).size || result.sample.some((item) => !request.sampleTaskIds.includes(item.taskId)))
+      this.#mismatch();
+    return result;
+  }
+  async writeListing(input, options = {}) {
+    const request = WriteCommerceListing.parse(input);
+    const result = CommerceListingReceiptSchema.parse(
+      await this.#request("/write-listing", options, request)
+    );
+    if (request.id && result.id !== request.id || result.revision !== request.expectedRevision + 1 || result.releaseId !== request.releaseId || result.state !== request.state || JSON.stringify(result.terms) !== JSON.stringify(request.terms))
+      this.#mismatch();
+    return result;
+  }
+  async checkout(input, options = {}) {
+    const request = CommerceCheckout.parse(input);
+    const result = CommerceOrderSchema.parse(
+      await this.#request("/checkout", options, request)
+    );
+    if (result.buyerTeamId !== this.#options.teamId || result.source !== request.source || result.sourceId !== request.sourceId || result.sourceRevision !== request.sourceRevision || result.termsHash !== request.acceptedTermsHash || result.destinationProjectId !== request.destinationProjectId)
+      this.#mismatch();
+    return result;
+  }
+  async order(id, options = {}) {
+    CommerceId.parse(id);
+    const result = CommerceOrderSchema.parse(
+      await this.#request(
+        `/order/${encodeURIComponent(id)}`,
+        options,
+        void 0,
+        true
+      )
+    );
+    if (result.id !== id || result.buyerTeamId !== this.#options.teamId && result.sellerTeamId !== this.#options.teamId)
+      this.#mismatch();
+    return result;
+  }
+  async download(id, options = {}) {
+    CommerceId.parse(id);
+    const result = z4.object({
+      orderId: CommerceId,
+      url: z4.string().url(),
+      expiresAt: z4.string().datetime(),
+      name: z4.string(),
+      format: z4.enum([
+        "csv",
+        "jsonl",
+        "parquet",
+        "openpond.datasetCatalogSnapshot.v1"
+      ]),
+      contentHash: z4.string().regex(/^[a-f0-9]{64}$/),
+      sizeBytes: z4.number().int().positive().max(128 * 1024 * 1024)
+    }).strict().parse(
+      await this.#request(
+        `/download/${encodeURIComponent(id)}`,
+        options,
+        void 0,
+        true
+      )
+    );
+    const url = new URL(result.url);
+    if (result.orderId !== id || url.protocol !== "https:" || url.username || url.password || new Date(result.expiresAt).getTime() <= Date.now())
+      this.#mismatch();
+    return result;
+  }
+  async retryDelivery(input, options = {}) {
+    const value = CommerceOperation.extend({ orderId: CommerceId }).strict().parse(input);
+    const result = z4.object({
+      orderId: CommerceId,
+      state: z4.enum(["paid", "delivery_failed", "delivered"])
+    }).strict().parse(await this.#request("/retry-delivery", options, value));
+    if (result.orderId !== value.orderId) this.#mismatch();
+    return result;
+  }
+  async purchases(options = {}) {
+    return this.#orders("purchases", options);
+  }
+  async sales(options = {}) {
+    return this.#orders("sales", options);
+  }
+  async submitPayment(input, options = {}) {
+    const request = CommerceOperation.extend({
+      orderId: CommerceId,
+      transactionHash: z4.string().regex(/^0x[a-fA-F0-9]{64}$/)
+    }).strict().parse(input);
+    const result = CommercePaymentSubmissionSchema.parse(
+      await this.#request("/submit-payment", options, request)
+    );
+    if (("orderId" in result ? result.orderId : result.id) !== request.orderId)
+      this.#mismatch();
+    return result;
+  }
+  async requests(query = {}, options = {}) {
+    const input = CommerceBrowse.parse(query), search = new URLSearchParams();
+    for (const [key, value] of Object.entries(input))
+      if (value !== void 0) search.set(key, String(value));
+    const result = CommerceRequestsPageSchema.parse(
+      await this.#request(`/requests?${search}`, options)
+    );
+    if (result.items.length > input.limit || result.items.some(
+      (item) => item.state !== "open" || item.content.projectId !== null || input.category && item.content.category !== input.category || input.format && !item.content.requirements.formats.includes(input.format) || input.license && !item.content.requirements.license.toLowerCase().includes(input.license.toLowerCase()) || input.minPriceBaseUnits && BigInt(item.content.budgetBaseUnits) < BigInt(input.minPriceBaseUnits) || input.maxPriceBaseUnits && BigInt(item.content.budgetBaseUnits) > BigInt(input.maxPriceBaseUnits)
+    ))
+      this.#mismatch();
+    return result;
+  }
+  async request(id, options = {}) {
+    CommerceId.parse(id);
+    const result = CommerceRequestSchema.parse(
+      await this.#request(`/requests/${encodeURIComponent(id)}`, options)
+    );
+    if (result.id !== id || result.content.projectId !== null) this.#mismatch();
+    return result;
+  }
+  async myRequests(options = {}) {
+    const result = z4.array(CommerceOwnedRequestSchema).max(100).parse(await this.#request("/my-requests", options, void 0, true));
+    if (result.some((item) => item.teamId !== this.#options.teamId))
+      this.#mismatch();
+    return result;
+  }
+  async writeRequest(input, options = {}) {
+    const request = WriteDatasetRequest.parse(input), result = CommerceRequestReceiptSchema.parse(
+      await this.#request("/write-request", options, request)
+    );
+    if (request.id && result.id !== request.id || result.revision !== request.expectedRevision + 1 || result.state !== request.state || JSON.stringify(result.content) !== JSON.stringify(request.content))
+      this.#mismatch();
+    return result;
+  }
+  async submitOffer(input, options = {}) {
+    const request = SubmitDatasetOffer.parse(input), result = CommerceOfferSubmissionSchema.parse(
+      await this.#request("/submit-offer", options, request)
+    );
+    if (result.revision !== request.expectedRevision + 1) this.#mismatch();
+    return result;
+  }
+  async offers(direction, options = {}) {
+    z4.enum(["sent", "received"]).parse(direction);
+    const result = z4.array(CommerceOfferSummarySchema).max(20).parse(
+      await this.#request(
+        `/${direction}-offers`,
+        options,
+        z4.object({
+          cursor: CommerceId.optional(),
+          limit: z4.number().int().min(1).max(20).optional()
+        }).parse({ cursor: options.cursor, limit: options.limit }),
+        true
+      )
+    );
+    if (result.some(
+      (item) => item.proposal.offerId !== item.id || item.proposal.revision !== item.revision
+    ))
+      this.#mismatch();
+    return result;
+  }
+  async offer(input, options = {}) {
+    const request = z4.object({
+      id: CommerceId,
+      notesCursor: CommerceId.nullable().optional(),
+      historyBefore: z4.number().int().positive().nullable().optional()
+    }).strict().parse(input);
+    const result = CommerceOfferDetailSchema.parse(
+      await this.#request("/offer", options, request, true)
+    );
+    if (result.id !== request.id || result.proposal.offerId !== result.id || result.proposal.revision !== result.revision || !result.canReview && result.notes.length)
+      this.#mismatch();
+    return result;
+  }
+  async reviewOffer(input, options = {}) {
+    const request = ReviewDatasetOffer.parse(input), result = CommerceOfferReviewReceiptSchema.parse(
+      await this.#request("/review-offer", options, request)
+    );
+    if (result.id !== request.id || result.revision !== request.expectedRevision || result.state !== request.state)
+      this.#mismatch();
+    return result;
+  }
+  async withdrawOffer(input, options = {}) {
+    const request = CommerceOperation.extend({
+      id: CommerceId,
+      expectedRevision: z4.number().int().positive(),
+      expectedUpdatedAt: z4.string().datetime()
+    }).strict().parse(input);
+    const result = z4.object({ id: CommerceId, state: z4.literal("withdrawn") }).strict().parse(await this.#request("/withdraw-offer", options, request));
+    if (result.id !== request.id) this.#mismatch();
+    return result;
+  }
+  async #orders(side, options) {
+    const result = z4.array(CommerceOrderSchema).max(100).parse(await this.#request(`/${side}`, options, void 0, true));
+    if (result.some(
+      (item) => (side === "purchases" ? item.buyerTeamId : item.sellerTeamId) !== this.#options.teamId
+    ))
+      this.#mismatch();
+    return result;
+  }
+  #mismatch() {
+    throw new OpenPondDatasetCommerceError(
+      502,
+      "dataset_commerce_identity_mismatch",
+      "Dataset commerce response did not match the requested release, terms, or workspace."
+    );
+  }
+  async #request(path, options, body, authenticated = false) {
+    const auth = authenticated || body !== void 0 || Boolean(this.#options.apiKey && this.#options.teamId);
+    if (auth && (!this.#options.apiKey?.trim() || !this.#options.teamId?.trim()))
+      throw new Error(
+        "An API key and explicit workspace are required for this dataset commerce operation."
+      );
+    const response = await (this.#options.fetch ?? globalThis.fetch)(
+      `${this.#options.baseUrl}/v1/dataset-commerce${path}`,
+      {
+        method: body === void 0 ? "GET" : "POST",
+        signal: options.signal,
+        redirect: "error",
+        headers: {
+          Accept: "application/json",
+          ...auth ? {
+            Authorization: `Bearer ${this.#options.apiKey}`,
+            "X-OpenPond-Team-Id": this.#options.teamId
+          } : {},
+          ...body === void 0 ? {} : { "Content-Type": "application/json" }
+        },
+        ...body === void 0 ? {} : { body: JSON.stringify(body) }
+      }
+    );
+    const reader = response.body?.getReader();
+    if (!reader)
+      throw new OpenPondDatasetCommerceError(
+        response.status,
+        "empty_response",
+        "Dataset commerce response was empty."
+      );
+    const decoder = new TextDecoder();
+    let bytes = 0, text = "";
+    try {
+      while (true) {
+        const chunk = await reader.read();
+        if (chunk.done) break;
+        bytes += chunk.value.byteLength;
+        if (bytes > 4194304)
+          throw new OpenPondDatasetCommerceError(
+            response.status,
+            "response_too_large",
+            "Dataset commerce response exceeded 4 MiB."
+          );
+        text += decoder.decode(chunk.value, { stream: true });
+      }
+      text += decoder.decode();
+    } finally {
+      await reader.cancel();
+      reader.releaseLock();
+    }
+    let payload;
+    try {
+      payload = JSON.parse(text);
+    } catch {
+      throw new OpenPondDatasetCommerceError(
+        response.status,
+        "invalid_response",
+        "Dataset commerce response was not valid JSON."
+      );
+    }
+    if (!response.ok) {
+      const error = z4.object({ code: z4.string().min(1), message: z4.string().min(1) }).safeParse(payload);
+      throw new OpenPondDatasetCommerceError(
+        response.status,
+        error.success ? error.data.code : "invalid_error_response",
+        error.success ? error.data.message : `Dataset commerce request failed (${response.status}).`
+      );
+    }
+    return payload;
+  }
+};
+export {
+  CaptureCommerceFileSchema,
+  CaptureCommerceRelease,
+  CommerceBrowse,
+  CommerceCapturedReleaseSchema,
+  CommerceCheckout,
+  CommerceCursor,
+  CommerceDatasetFormat,
+  CommerceFileMetadataSchema,
+  CommerceFilePreviewSchema,
+  CommerceHash,
+  CommerceId,
+  CommerceInventorySchema,
+  CommerceListingReceiptSchema,
+  CommerceListingSchema,
+  CommerceListingsPageSchema,
+  CommerceOfferDetailSchema,
+  CommerceOfferReviewReceiptSchema,
+  CommerceOfferSchema,
+  CommerceOfferSubmissionSchema,
+  CommerceOfferSummarySchema,
+  CommerceOperation,
+  CommerceOrderSchema,
+  CommerceOwnedRequestSchema,
+  CommercePaymentSubmissionSchema,
+  CommerceProfileContent,
+  CommerceReleaseRef,
+  CommerceRequestReceiptSchema,
+  CommerceRequestSchema,
+  CommerceRequestsPageSchema,
+  CommerceSampleSchema,
+  DatasetRequestContent,
+  ListingTerms,
+  OpenPondCommerceFiles,
+  OpenPondDatasetCommerceClient,
+  OpenPondDatasetCommerceError,
+  PrepareCommerceFileSchema,
+  ReviewDatasetOffer,
+  SubmitDatasetOffer,
+  UsdcAmount,
+  WriteCommerceListing,
+  WriteCommerceProfile,
+  WriteDatasetRequest
+};
+//# sourceMappingURL=dataset-commerce.js.map