@dropthis/cli 0.4.1 → 0.6.0

package/node_modules/@dropthis/node/dist/edge.cjs

@@ -0,0 +1,805 @@
+"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/edge.ts
+var edge_exports = {};
+__export(edge_exports, {
+  DropthisEdge: () => DropthisEdge
+});
+module.exports = __toCommonJS(edge_exports);
+
+// src/errors.ts
+var API_KEY_RE = /sk_[A-Za-z0-9_-]+/g;
+function redactSecrets(message) {
+  return message.replace(API_KEY_RE, "sk_[redacted]");
+}
+function createErrorResult(code, message, statusCode, extra = {}) {
+  return {
+    data: null,
+    error: {
+      code,
+      message: redactSecrets(message),
+      statusCode,
+      ...extra.type ? { type: extra.type } : {},
+      ...extra.title !== void 0 ? { title: extra.title } : {},
+      ...extra.detail !== void 0 ? { detail: extra.detail } : {},
+      ...extra.instance !== void 0 ? { instance: extra.instance } : {},
+      ...extra.param !== void 0 ? { param: extra.param } : {},
+      ...extra.currentRevision !== void 0 ? { currentRevision: extra.currentRevision } : {},
+      ...extra.requestId !== void 0 ? { requestId: extra.requestId } : {},
+      ...extra.suggestion !== void 0 ? { suggestion: extra.suggestion } : {},
+      ...extra.retryable !== void 0 ? { retryable: extra.retryable } : {},
+      ...extra.body !== void 0 ? { body: extra.body } : {}
+    },
+    headers: extra.headers ?? {}
+  };
+}
+var PublishInputError = class extends Error {
+  constructor(code, message, param, suggestion) {
+    super(message);
+    this.code = code;
+    this.param = param;
+    this.suggestion = suggestion;
+    this.name = "PublishInputError";
+  }
+  code;
+  param;
+  suggestion;
+};
+function toErrorResult(err) {
+  if (err instanceof PublishInputError)
+    return createErrorResult(err.code, err.message, null, {
+      param: err.param ?? null,
+      suggestion: err.suggestion ?? null
+    });
+  return createErrorResult(
+    "sdk_error",
+    err instanceof Error ? err.message : "Unknown SDK error",
+    null
+  );
+}
+
+// src/publish/detect.ts
+function isHttpUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function containsHtmlTag(value) {
+  return /<[a-z!/][^>]*>/i.test(value);
+}
+function contentTypeForString(value, override) {
+  if (override) return override;
+  return containsHtmlTag(value) ? "text/html" : "text/plain; charset=utf-8";
+}
+function detectBytesContentType(bytes) {
+  const text = new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+  if (text.includes("\uFFFD")) return "application/octet-stream";
+  return containsHtmlTag(text) ? "text/html" : "text/plain; charset=utf-8";
+}
+function entryForContentType(contentType) {
+  const m = contentType.toLowerCase().split(";", 1)[0]?.trim() ?? "";
+  if (m === "text/html" || m === "application/xhtml+xml") return "index.html";
+  if (m === "application/json") return "index.json";
+  if (m === "text/css") return "index.css";
+  if (m === "text/javascript" || m === "application/javascript")
+    return "index.js";
+  if (m.startsWith("text/")) return "index.txt";
+  return "index";
+}
+
+// src/publish/paths.ts
+function normalizeManifestPath(path) {
+  return path.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function assertValidManifestPath(path) {
+  if (path.includes("\\"))
+    throw new PublishInputError(
+      "invalid_path",
+      `Manifest path must use "/": "${path}".`,
+      path
+    );
+  const p = normalizeManifestPath(path);
+  if (p === "")
+    throw new PublishInputError(
+      "invalid_path",
+      "Manifest path must not be empty.",
+      path
+    );
+  if (p.startsWith("/"))
+    throw new PublishInputError(
+      "invalid_path",
+      `Manifest path must be relative: "${path}".`,
+      path
+    );
+  if (p.startsWith("~"))
+    throw new PublishInputError(
+      "invalid_path",
+      `Manifest path must not start with "~": "${path}".`,
+      path
+    );
+  if (p.split("/").includes(".."))
+    throw new PublishInputError(
+      "invalid_path",
+      `Manifest path must not contain "..": "${path}".`,
+      path
+    );
+}
+function assertNoDuplicatePaths(paths) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of paths) {
+    const p = normalizeManifestPath(raw);
+    if (seen.has(p))
+      throw new PublishInputError(
+        "duplicate_path",
+        `Duplicate file path after normalization: "${p}".`,
+        p,
+        "Give each file a unique path; basename mapping for string[] can collide."
+      );
+    seen.add(p);
+  }
+}
+function assertNonEmptyBundle(paths) {
+  if (paths.length === 0)
+    throw new PublishInputError(
+      "empty_bundle",
+      "Nothing to publish: the bundle has no files.",
+      void 0,
+      "Pass at least one file, or a directory that contains files."
+    );
+}
+
+// src/publish/core.ts
+var VALID_VISIBILITIES = ["public", "unlisted"];
+var MAX_TITLE_LENGTH = 500;
+function validatePublishOptions(options) {
+  if (options.title !== void 0 && options.title !== null && options.title.length > MAX_TITLE_LENGTH) {
+    throw new Error(`Title must be ${MAX_TITLE_LENGTH} characters or less.`);
+  }
+  if (options.visibility !== void 0 && options.visibility !== null) {
+    if (!VALID_VISIBILITIES.includes(options.visibility)) {
+      throw new Error(
+        `Invalid visibility "${options.visibility}". Use "public" or "unlisted".`
+      );
+    }
+  }
+  if (options.expiresAt !== void 0 && options.expiresAt !== null) {
+    if (options.expiresAt instanceof Date) {
+      if (Number.isNaN(options.expiresAt.getTime())) {
+        throw new Error("Invalid expiresAt date.");
+      }
+    } else if (typeof options.expiresAt === "string") {
+      const parsed = new Date(options.expiresAt);
+      if (Number.isNaN(parsed.getTime())) {
+        throw new Error("Invalid expiresAt date.");
+      }
+    }
+  }
+}
+function optionsBody(options) {
+  validatePublishOptions(options);
+  return {
+    title: options.title,
+    visibility: options.visibility,
+    password: options.password,
+    noindex: options.noindex,
+    expiresAt: options.expiresAt instanceof Date ? options.expiresAt.toISOString() : options.expiresAt
+  };
+}
+function buildStagedRequest(files, options, entry) {
+  assertNonEmptyBundle(files.map((f) => f.path));
+  const normalizedPaths = files.map((f) => normalizeManifestPath(f.path));
+  assertNoDuplicatePaths(normalizedPaths);
+  const manifestFiles = files.map((file) => ({
+    path: normalizeManifestPath(file.path),
+    contentType: file.contentType,
+    sizeBytes: file.sizeBytes,
+    ...file.checksumSha256 ? { checksumSha256: file.checksumSha256 } : {}
+  }));
+  const resolvedEntry = entry ?? options.entry;
+  if (resolvedEntry !== void 0) assertValidManifestPath(resolvedEntry);
+  const manifest = {
+    schemaVersion: 1,
+    files: manifestFiles,
+    ...resolvedEntry ? { entry: resolvedEntry } : {}
+  };
+  const prepared = {
+    kind: "staged",
+    manifest,
+    files,
+    options: optionsBody(options)
+  };
+  if (options.metadata) prepared.metadata = options.metadata;
+  return prepared;
+}
+function buildSourceRequest(sourceUrl, options) {
+  if (!isHttpUrl(sourceUrl)) {
+    throw new PublishInputError(
+      "invalid_source_url",
+      "source_url must be an http(s) URL.",
+      sourceUrl,
+      "Fetch the content first, then pass it as content/files."
+    );
+  }
+  const prepared = {
+    kind: "source",
+    sourceUrl,
+    options: optionsBody(options)
+  };
+  if (options.metadata) prepared.metadata = options.metadata;
+  return prepared;
+}
+function decodeBase64(value) {
+  const binary = atob(value);
+  return Uint8Array.from(binary, (c) => c.charCodeAt(0));
+}
+function fileBytes(file) {
+  if (file.content !== void 0) return new TextEncoder().encode(file.content);
+  if (file.contentBase64 !== void 0) return decodeBase64(file.contentBase64);
+  if (file.bytes !== void 0) return file.bytes;
+  throw new PublishInputError(
+    "missing_file_bytes",
+    `File "${file.path}" is missing content bytes.`,
+    file.path,
+    "Provide one of content, contentBase64, or bytes."
+  );
+}
+function singleStagedFile(path, contentType, bytes, options) {
+  return buildStagedRequest(
+    [
+      {
+        path,
+        contentType,
+        sizeBytes: bytes.byteLength,
+        getBody: async () => bytes
+      }
+    ],
+    options
+  );
+}
+async function resolveInMemory(input, options = {}) {
+  if (input instanceof URL) {
+    return buildSourceRequest(input.toString(), options);
+  }
+  if (typeof input === "string") {
+    if (isHttpUrl(input)) return buildSourceRequest(input, options);
+    const contentType = contentTypeForString(input, options.contentType);
+    if (options.path !== void 0) assertValidManifestPath(options.path);
+    const path = options.path ?? entryForContentType(contentType);
+    const bytes = new TextEncoder().encode(input);
+    return singleStagedFile(path, contentType, bytes, options);
+  }
+  if (input instanceof Uint8Array) {
+    const contentType = options.contentType ?? detectBytesContentType(input);
+    if (options.path !== void 0) assertValidManifestPath(options.path);
+    const path = options.path ?? entryForContentType(contentType);
+    return singleStagedFile(path, contentType, input, options);
+  }
+  if (input.kind === "content") {
+    const contentType = input.contentType ?? options.contentType ?? "text/html";
+    if (input.path !== void 0) assertValidManifestPath(input.path);
+    if (options.path !== void 0) assertValidManifestPath(options.path);
+    const path = input.path ?? options.path ?? entryForContentType(contentType);
+    const bytes = new TextEncoder().encode(input.content);
+    return singleStagedFile(path, contentType, bytes, options);
+  }
+  if (input.kind === "source_url") {
+    return buildSourceRequest(input.sourceUrl, options);
+  }
+  const files = input.files.map((file) => {
+    assertValidManifestPath(file.path);
+    const bytes = fileBytes(file);
+    const contentType = file.contentType ?? detectBytesContentType(bytes);
+    return {
+      path: file.path,
+      contentType,
+      sizeBytes: bytes.byteLength,
+      getBody: async () => bytes
+    };
+  });
+  return buildStagedRequest(files, options, input.entry);
+}
+function errorResult(result) {
+  if (!result.error) throw new Error("Expected an error result");
+  return { data: null, error: result.error, headers: result.headers };
+}
+async function publishStaged(transport, prepared, finalPath, options = {}) {
+  const baseKey = options.idempotencyKey ?? `sdk-${crypto.randomUUID()}`;
+  const createResult = await transport.request(
+    "POST",
+    "/uploads",
+    {
+      body: prepared.manifest,
+      idempotencyKey: `${baseKey}:create-upload`
+    }
+  );
+  if (createResult.error) return errorResult(createResult);
+  for (const file of prepared.files) {
+    const target = createResult.data.files.find((f) => f.path === file.path);
+    if (!target) {
+      return createErrorResult(
+        "upload_target_missing",
+        `Upload target missing for ${file.path}`,
+        null
+      );
+    }
+    if (target.upload.strategy !== "single_put") {
+      return createErrorResult(
+        "unsupported_upload_strategy",
+        `Unsupported upload strategy "${target.upload.strategy}" for ${file.path}. This SDK uploads via single PUT only.`,
+        null
+      );
+    }
+    const put = await transport.putSignedUrl(
+      target.upload.url,
+      await file.getBody(),
+      target.upload.headers
+    );
+    if (put.error) return errorResult(put);
+  }
+  const completeResult = await transport.request(
+    "POST",
+    `/uploads/${encodeURIComponent(createResult.data.uploadId)}/complete`,
+    {
+      body: { files: {} },
+      idempotencyKey: `${baseKey}:complete-upload`
+    }
+  );
+  if (completeResult.error) return errorResult(completeResult);
+  const finalOptions = {
+    body: {
+      uploadId: createResult.data.uploadId,
+      options: prepared.options,
+      ...prepared.metadata ? { metadata: prepared.metadata } : {}
+    },
+    idempotencyKey: `${baseKey}:publish`
+  };
+  if (options.ifRevision !== void 0)
+    finalOptions.ifRevision = options.ifRevision;
+  return transport.request("POST", finalPath, finalOptions);
+}
+async function publishSource(transport, prepared, finalPath, options = {}) {
+  const baseKey = options.idempotencyKey ?? `sdk-${crypto.randomUUID()}`;
+  return transport.request("POST", finalPath, {
+    body: {
+      sourceUrl: prepared.sourceUrl,
+      options: prepared.options,
+      ...prepared.metadata ? { metadata: prepared.metadata } : {}
+    },
+    idempotencyKey: `${baseKey}:publish`,
+    ...options.ifRevision !== void 0 ? { ifRevision: options.ifRevision } : {}
+  });
+}
+
+// src/resources/account.ts
+var AccountResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  get() {
+    return this.transport.request("GET", "/account");
+  }
+  update(input) {
+    return this.transport.request("PATCH", "/account", { body: input });
+  }
+  delete() {
+    return this.transport.request("DELETE", "/account");
+  }
+};
+
+// src/resources/api-keys.ts
+var ApiKeysResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  list() {
+    return this.transport.request("GET", "/api-keys");
+  }
+  create(input) {
+    return this.transport.request("POST", "/api-keys", { body: input });
+  }
+  delete(keyId) {
+    return this.transport.request(
+      "DELETE",
+      `/api-keys/${encodeURIComponent(keyId)}`
+    );
+  }
+};
+
+// src/resources/deployments.ts
+var DeploymentsResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  list(dropId, params = {}) {
+    return this.transport.request(
+      "GET",
+      `/drops/${encodeURIComponent(dropId)}/deployments`,
+      { params }
+    );
+  }
+  get(dropId, deploymentId) {
+    return this.transport.request(
+      "GET",
+      `/drops/${encodeURIComponent(dropId)}/deployments/${encodeURIComponent(deploymentId)}`
+    );
+  }
+};
+
+// src/pagination.ts
+var CursorPage = class {
+  object = "list";
+  data;
+  hasMore;
+  nextCursor;
+  fetchNextPage;
+  constructor(input) {
+    this.data = input.data;
+    this.hasMore = input.hasMore;
+    this.nextCursor = input.nextCursor;
+    this.fetchNextPage = input.fetchNextPage;
+  }
+  async autoPagingToArray(options = {}) {
+    const items = [];
+    for await (const item of this) {
+      items.push(item);
+      if (options.limit !== void 0 && items.length >= options.limit) break;
+    }
+    return items;
+  }
+  async *[Symbol.asyncIterator]() {
+    for (const item of this.data) yield item;
+    let current = this;
+    while (current.hasMore && current.fetchNextPage) {
+      const next = await current.fetchNextPage();
+      if (next.error) break;
+      current = next.data;
+      for (const item of current.data) yield item;
+    }
+  }
+};
+
+// src/resources/drops.ts
+var DropsResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async list(params = {}) {
+    const result = await this.transport.request("GET", "/drops", {
+      params
+    });
+    if (result.error) return result;
+    const page = new CursorPage({
+      data: result.data.drops,
+      nextCursor: result.data.nextCursor,
+      hasMore: result.data.nextCursor !== null,
+      fetchNextPage: result.data.nextCursor ? () => this.list({ ...params, cursor: result.data.nextCursor }) : void 0
+    });
+    return { data: page, error: null, headers: result.headers };
+  }
+  get(dropId) {
+    return this.transport.request(
+      "GET",
+      `/drops/${encodeURIComponent(dropId)}`
+    );
+  }
+  update(dropId, options = {}) {
+    const requestOptions = {
+      body: updateBody(options)
+    };
+    if (options.idempotencyKey)
+      requestOptions.idempotencyKey = options.idempotencyKey;
+    if (options.ifRevision !== void 0)
+      requestOptions.ifRevision = options.ifRevision;
+    return this.transport.request(
+      "PATCH",
+      `/drops/${encodeURIComponent(dropId)}`,
+      requestOptions
+    );
+  }
+  delete(dropId) {
+    return this.transport.request(
+      "DELETE",
+      `/drops/${encodeURIComponent(dropId)}`
+    );
+  }
+};
+var SETTINGS = [
+  "title",
+  "visibility",
+  "password",
+  "noindex",
+  "expiresAt",
+  "slug"
+];
+function updateBody(options) {
+  const out = {};
+  for (const key of SETTINGS)
+    if (options[key] !== void 0) out[key] = options[key];
+  return {
+    options: out,
+    ...options.metadata !== void 0 ? { metadata: options.metadata } : {}
+  };
+}
+
+// src/case.ts
+function toCamelKey(key) {
+  return key.replace(/_([a-z])/g, (_, char) => char.toUpperCase());
+}
+function toSnakeKey(key) {
+  return key.replace(/[A-Z]/g, (char) => `_${char.toLowerCase()}`);
+}
+var PASSTHROUGH_KEYS = /* @__PURE__ */ new Set(["metadata"]);
+function toCamelCase(value) {
+  if (Array.isArray(value)) return value.map(toCamelCase);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [
+        toCamelKey(key),
+        PASSTHROUGH_KEYS.has(key) ? item : toCamelCase(item)
+      ])
+    );
+  }
+  return value;
+}
+function toSnakeCase(value) {
+  if (Array.isArray(value)) return value.map(toSnakeCase);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, item]) => item !== void 0).map(([key, item]) => [
+        toSnakeKey(key),
+        PASSTHROUGH_KEYS.has(key) ? item : toSnakeCase(item)
+      ])
+    );
+  }
+  return value;
+}
+
+// src/transport.ts
+var DEFAULT_BASE_URL = "https://api.dropthis.app";
+var SDK_VERSION = "0.6.0";
+var Transport = class {
+  apiKey;
+  baseUrl;
+  timeoutMs;
+  uploadTimeoutMs;
+  fetchImpl;
+  constructor(options = {}) {
+    const resolved = typeof options === "string" ? { apiKey: options } : options;
+    this.apiKey = resolved.apiKey ?? (typeof process !== "undefined" ? process.env?.DROPTHIS_API_KEY : void 0);
+    this.baseUrl = (resolved.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.timeoutMs = resolved.timeoutMs ?? 3e4;
+    this.uploadTimeoutMs = resolved.uploadTimeoutMs ?? 12e4;
+    this.fetchImpl = resolved.fetch ?? globalThis.fetch;
+  }
+  async putSignedUrl(url, body, headers) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.uploadTimeoutMs);
+    try {
+      const request = {
+        method: "PUT",
+        headers,
+        body,
+        signal: controller.signal
+      };
+      if (body instanceof ReadableStream) request.duplex = "half";
+      const response = await this.fetchImpl(url, request);
+      const responseHeaders = headersToObject(response.headers);
+      if (!response.ok) {
+        const text = await response.text();
+        return createErrorResult(
+          `signed_upload_${response.status}`,
+          text || response.statusText,
+          response.status,
+          { headers: responseHeaders }
+        );
+      }
+      return {
+        data: {
+          etag: response.headers.get("ETag") ?? responseHeaders.etag ?? null
+        },
+        error: null,
+        headers: responseHeaders
+      };
+    } catch (error) {
+      const message = error instanceof Error && error.name === "AbortError" ? "Request timed out" : error instanceof Error ? error.message : "Network error";
+      return createErrorResult(
+        error instanceof Error && error.name === "AbortError" ? "timeout" : "network_error",
+        message,
+        null
+      );
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async request(method, path, options = {}) {
+    const authenticated = options.authenticated ?? true;
+    if (authenticated && !this.apiKey) {
+      return createErrorResult(
+        "missing_api_key",
+        "No API key provided. Pass apiKey or set DROPTHIS_API_KEY.",
+        null
+      );
+    }
+    const headers = {
+      "user-agent": `dropthis-node/${SDK_VERSION}`
+    };
+    if (authenticated && this.apiKey)
+      headers.authorization = `Bearer ${this.apiKey}`;
+    if (options.idempotencyKey)
+      headers["idempotency-key"] = options.idempotencyKey;
+    if (options.ifRevision !== void 0)
+      headers["if-revision"] = String(options.ifRevision);
+    if (options.body !== void 0 && !(options.body instanceof FormData))
+      headers["content-type"] = "application/json";
+    const url = new URL(`${this.baseUrl}${path}`);
+    const wireParams = options.bodyCase === "raw" ? options.params : toSnakeCase(options.params ?? {});
+    for (const [key, value] of Object.entries(wireParams ?? {})) {
+      if (value !== void 0 && value !== null)
+        url.searchParams.set(key, String(value));
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(
+      () => controller.abort(),
+      options.timeoutMs ?? this.timeoutMs
+    );
+    try {
+      const request = {
+        method,
+        headers,
+        signal: controller.signal
+      };
+      if (options.body instanceof FormData) {
+        request.body = options.body;
+      } else if (options.body !== void 0) {
+        const wireBody = options.bodyCase === "raw" ? options.body : toSnakeCase(options.body);
+        request.body = JSON.stringify(wireBody);
+      }
+      const response = await this.fetchImpl(url.toString(), request);
+      const responseHeaders = headersToObject(response.headers);
+      const text = await response.text();
+      const parsed = parseJson(text);
+      if (!response.ok) {
+        const body = parsed && typeof parsed === "object" ? parsed : {};
+        const message = stringValue(body.detail) ?? stringValue(body.title) ?? response.statusText;
+        const code = stringValue(body.code) ?? stringValue(body.error_code) ?? `http_${response.status}`;
+        const currentRevision = numberValue(body.current_revision);
+        const type = stringValue(body.type);
+        const title = stringValue(body.title);
+        const instance = stringValue(body.instance);
+        return createErrorResult(code, message, response.status, {
+          body,
+          ...type !== null ? { type } : {},
+          ...title !== null ? { title } : {},
+          ...instance !== null ? { instance } : {},
+          detail: stringValue(body.detail),
+          param: stringValue(body.param),
+          ...currentRevision !== void 0 ? { currentRevision } : {},
+          requestId: stringValue(body.request_id) ?? responseHeaders["x-request-id"] ?? null,
+          suggestion: stringValue(body.suggestion),
+          retryable: booleanValue(body.retryable),
+          headers: responseHeaders
+        });
+      }
+      return {
+        data: toCamelCase(parsed),
+        error: null,
+        headers: responseHeaders
+      };
+    } catch (error) {
+      const message = error instanceof Error && error.name === "AbortError" ? "Request timed out" : error instanceof Error ? error.message : "Network error";
+      return createErrorResult(
+        error instanceof Error && error.name === "AbortError" ? "timeout" : "network_error",
+        message,
+        null
+      );
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+};
+function headersToObject(headers) {
+  const result = {};
+  headers.forEach((value, key) => {
+    result[key.toLowerCase()] = value;
+  });
+  return result;
+}
+function parseJson(text) {
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function stringValue(value) {
+  return typeof value === "string" ? value : null;
+}
+function numberValue(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function booleanValue(value) {
+  return typeof value === "boolean" ? value : null;
+}
+
+// src/edge.ts
+var DropthisEdge = class {
+  transport;
+  dropsResource;
+  accountResource;
+  apiKeysResource;
+  deploymentsResource;
+  constructor(options = {}) {
+    this.transport = new Transport(options);
+  }
+  get drops() {
+    if (!this.dropsResource)
+      this.dropsResource = new DropsResource(this.transport);
+    return this.dropsResource;
+  }
+  get account() {
+    if (!this.accountResource)
+      this.accountResource = new AccountResource(this.transport);
+    return this.accountResource;
+  }
+  get apiKeys() {
+    if (!this.apiKeysResource)
+      this.apiKeysResource = new ApiKeysResource(this.transport);
+    return this.apiKeysResource;
+  }
+  get deployments() {
+    if (!this.deploymentsResource)
+      this.deploymentsResource = new DeploymentsResource(this.transport);
+    return this.deploymentsResource;
+  }
+  /** Publish a NEW drop from in-memory content. */
+  async publish(input, options = {}) {
+    let prepared;
+    try {
+      prepared = await resolveInMemory(input, options);
+    } catch (e) {
+      return toErrorResult(e);
+    }
+    return prepared.kind === "source" ? publishSource(this.transport, prepared, "/drops", options) : publishStaged(this.transport, prepared, "/drops", options);
+  }
+  /** Publish a NEW content version to an existing drop, keeping its URL. */
+  async deploy(dropId, input, options = {}) {
+    let prepared;
+    try {
+      prepared = await resolveInMemory(input, options);
+    } catch (e) {
+      return toErrorResult(e);
+    }
+    const path = `/drops/${encodeURIComponent(dropId)}/deployments`;
+    return prepared.kind === "source" ? publishSource(this.transport, prepared, path, options) : publishStaged(this.transport, prepared, path, options);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DropthisEdge
+});
+//# sourceMappingURL=edge.cjs.map