npm - @dropthis/cli - Versions diffs - 0.5.0 → 0.6.1 - Mend

@dropthis/cli 0.5.0 → 0.6.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (20) hide show

package/README.md +0 -1
package/dist/cli.cjs +330 -346
package/dist/cli.cjs.map +1 -1
package/node_modules/@dropthis/node/README.md +88 -20
package/node_modules/@dropthis/node/dist/{drops-fK63OCk6.d.cts → drops-BPdmUPCT.d.cts} +65 -56
package/node_modules/@dropthis/node/dist/{drops-fK63OCk6.d.ts → drops-BPdmUPCT.d.ts} +65 -56
package/node_modules/@dropthis/node/dist/edge.cjs +389 -168
package/node_modules/@dropthis/node/dist/edge.cjs.map +1 -1
package/node_modules/@dropthis/node/dist/edge.d.cts +4 -32
package/node_modules/@dropthis/node/dist/edge.d.ts +4 -32
package/node_modules/@dropthis/node/dist/edge.mjs +389 -168
package/node_modules/@dropthis/node/dist/edge.mjs.map +1 -1
package/node_modules/@dropthis/node/dist/index.cjs +449 -429
package/node_modules/@dropthis/node/dist/index.cjs.map +1 -1
package/node_modules/@dropthis/node/dist/index.d.cts +13 -39
package/node_modules/@dropthis/node/dist/index.d.ts +13 -39
package/node_modules/@dropthis/node/dist/index.mjs +448 -429
package/node_modules/@dropthis/node/dist/index.mjs.map +1 -1
package/node_modules/@dropthis/node/package.json +1 -1
package/package.json +2 -2

package/node_modules/@dropthis/node/dist/index.cjs CHANGED Viewed

@@ -33,6 +33,7 @@ __export(index_exports, {
   CursorPage: () => CursorPage,
   DeploymentsResource: () => DeploymentsResource,
   Dropthis: () => Dropthis,
+  PublishInputError: () => PublishInputError,
   UploadsResource: () => UploadsResource,
   createErrorResult: () => createErrorResult,
   redactSecrets: () => redactSecrets
@@ -52,33 +53,42 @@ function createErrorResult(code, message, statusCode, extra = {}) {
       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.retryable !== void 0 ? { retryable: extra.retryable } : {},
+      ...extra.body !== void 0 ? { body: extra.body } : {}
     },
     headers: extra.headers ?? {}
   };
 }
-// src/publish/prepare.ts
-var import_promises2 = require("fs/promises");
-var import_node_path2 = require("path");
-// src/publish/checksum.ts
-var import_node_crypto = require("crypto");
-var import_node_fs = require("fs");
-function sha256Bytes(bytes) {
-  return (0, import_node_crypto.createHash)("sha256").update(bytes).digest("hex");
-}
-async function sha256File(path) {
-  const hash = (0, import_node_crypto.createHash)("sha256");
-  for await (const chunk of (0, import_node_fs.createReadStream)(path)) {
-    hash.update(chunk);
-  }
-  return hash.digest("hex");
+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
@@ -90,253 +100,100 @@ function isHttpUrl(value) {
     return false;
   }
 }
-function looksLikeHtml(value) {
-  const trimmed = value.trimStart().toLowerCase();
-  return trimmed.startsWith("<!doctype html") || trimmed.startsWith("<html") || /^<[a-z][a-z0-9:-]*(\s|>)/.test(trimmed);
+function containsHtmlTag(value) {
+  return /<[a-z!/][^>]*>/i.test(value);
 }
-function detectStringInput(value) {
-  if (isHttpUrl(value)) return { mode: "sourceUrl" };
-  return {
-    mode: "content",
-    contentType: looksLikeHtml(value) ? "text/html" : "text/plain; charset=utf-8"
-  };
+var FILE_EXT = /\.[A-Za-z0-9]{1,8}([?#].*)?$/;
+function isPathShaped(value) {
+  if (value.length === 0 || value.length > 4096 || value.includes("\n"))
+    return false;
+  if (containsHtmlTag(value)) return false;
+  if (value.includes("/") || value.includes("\\")) return true;
+  if (/^[A-Za-z]:[\\/]/.test(value)) return true;
+  return FILE_EXT.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 = Buffer.from(bytes).toString("utf8");
+  const text = new TextDecoder("utf-8", { fatal: false }).decode(bytes);
   if (text.includes("\uFFFD")) return "application/octet-stream";
-  return looksLikeHtml(text) ? "text/html" : "text/plain; charset=utf-8";
-}
-// src/publish/files.ts
-var import_promises = require("fs/promises");
-var import_node_path = require("path");
-var import_fast_glob = __toESM(require("fast-glob"), 1);
-var import_ignore = __toESM(require("ignore"), 1);
-var import_mime_types = require("mime-types");
-var DEFAULT_IGNORES = [
-  ".git",
-  ".git/**",
-  "node_modules",
-  "node_modules/**",
-  ".DS_Store",
-  ".env",
-  ".env.*",
-  ".cache",
-  ".cache/**",
-  ".tmp",
-  ".tmp/**",
-  "dist/.cache",
-  "dist/.cache/**"
-];
-async function collectPublishFiles(inputPath, options = {}) {
-  const inputStat = await (0, import_promises.stat)(inputPath);
-  if (inputStat.isFile()) {
-    return [
-      {
-        absolutePath: inputPath,
-        path: (0, import_node_path.basename)(inputPath),
-        contentType: await detectPathContentType(inputPath),
-        sizeBytes: inputStat.size
-      }
-    ];
-  }
-  if (!inputStat.isDirectory()) {
-    throw new Error(`Input is not a file or directory: ${inputPath}`);
-  }
-  const matcher = (0, import_ignore.default)().add([
-    ...options.ignoreDefaults === false ? [] : DEFAULT_IGNORES,
-    ...options.ignore ?? []
-  ]);
-  const entries = await (0, import_fast_glob.default)("**/*", {
-    cwd: inputPath,
-    onlyFiles: true,
-    followSymbolicLinks: false,
-    dot: true,
-    unique: true
-  });
-  const paths = entries.map((entry) => entry.split(import_node_path.sep).join("/")).filter((entry) => !matcher.ignores(entry)).sort((a, b) => a.localeCompare(b));
-  return Promise.all(
-    paths.map(async (path) => {
-      const absolutePath = `${inputPath}/${path}`;
-      const fileStat = await (0, import_promises.stat)(absolutePath);
-      return {
-        absolutePath,
-        path,
-        contentType: await detectPathContentType(absolutePath),
-        sizeBytes: fileStat.size
-      };
-    })
-  );
-}
-async function detectPathContentType(path) {
-  const detected = (0, import_mime_types.lookup)(path);
-  if (detected) return detected;
-  return detectBytesContentType(await (0, import_promises.readFile)(path));
-}
-// src/publish/prepare.ts
-var SINGLE_PUT_CHECKSUM_THRESHOLD_BYTES = 10 * 1024 * 1024;
-async function preparePublishRequest(input, options = {}) {
-  if (input instanceof URL) {
-    return sourceRequest(input.toString(), options);
-  }
-  if (typeof input === "string") {
-    const local = await localKind(input);
-    if (local === "file") {
-      return fileStaged(input, options);
-    }
-    if (local === "directory") {
-      return folderStaged(input, options);
-    }
-    const detection = detectStringInput(input);
-    if (detection.mode === "sourceUrl") return sourceRequest(input, options);
-    return stringContent(input, options, detection.contentType);
-  }
-  if (input instanceof Uint8Array || Buffer.isBuffer(input)) {
-    return bytesStaged(input, options);
-  }
-  return explicitInput(input, options);
-}
-async function stringContent(content, options, detectedContentType) {
-  const contentType = options.contentType ?? detectedContentType;
-  return bytesStaged(Buffer.from(content), {
-    ...options,
-    path: options.path ?? entryForContentType(contentType),
-    contentType
-  });
+  return containsHtmlTag(text) ? "text/html" : "text/plain; charset=utf-8";
 }
 function entryForContentType(contentType) {
-  const normalized = contentType.toLowerCase().split(";", 1)[0]?.trim() ?? "";
-  if (normalized === "text/html" || normalized === "application/xhtml+xml")
-    return "index.html";
-  if (normalized === "application/json") return "index.json";
-  if (normalized === "text/css") return "index.css";
-  if (normalized === "text/javascript" || normalized === "application/javascript")
+  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 (normalized.startsWith("text/")) return "index.txt";
+  if (m.startsWith("text/")) return "index.txt";
   return "index";
 }
-async function localKind(input) {
-  try {
-    const info = await (0, import_promises2.stat)(input);
-    if (info.isFile()) return "file";
-    if (info.isDirectory()) return "directory";
-    return "none";
-  } catch {
-    return "none";
-  }
-}
-async function fileStaged(path, options) {
-  const fileStat = await (0, import_promises2.stat)(path);
-  const manifestPath = options.path ?? (0, import_node_path2.basename)(path);
-  return stagedRequest(
-    [
-      {
-        path: manifestPath,
-        contentType: options.contentType ?? await detectPathContentType(path),
-        sizeBytes: fileStat.size,
-        source: { kind: "path", path }
-      }
-    ],
-    { ...options, entry: options.entry ?? manifestPath }
-  );
-}
-async function folderStaged(path, options) {
-  const files = (await collectPublishFiles(path, options)).map((file) => ({
-    path: file.path,
-    contentType: file.contentType,
-    sizeBytes: file.sizeBytes,
-    source: { kind: "path", path: file.absolutePath }
-  }));
-  return stagedRequest(files, options);
-}
-async function bytesStaged(bytes, options) {
-  return stagedRequest(
-    [
-      {
-        path: options.path ?? "index",
-        contentType: options.contentType ?? detectBytesContentType(bytes),
-        sizeBytes: bytes.byteLength,
-        source: { kind: "bytes", bytes }
-      }
-    ],
-    options
-  );
-}
-async function stagedRequest(files, options) {
-  const preparedFiles = await Promise.all(
-    files.map(async (file) => {
-      if (file.sizeBytes <= SINGLE_PUT_CHECKSUM_THRESHOLD_BYTES) return file;
-      const checksumSha256 = file.source.kind === "bytes" ? sha256Bytes(file.source.bytes) : await sha256File(file.source.path);
-      return { ...file, checksumSha256 };
-    })
-  );
-  const manifestFiles = preparedFiles.map((file) => ({
-    path: file.path,
-    contentType: file.contentType,
-    sizeBytes: file.sizeBytes,
-    ...file.checksumSha256 ? { checksumSha256: file.checksumSha256 } : {}
-  }));
-  const prepared = {
-    kind: "staged",
-    manifest: {
-      schemaVersion: 1,
-      files: manifestFiles,
-      ...options.entry ? { entry: options.entry } : {}
-    },
-    files: preparedFiles,
-    options: optionsBody(options)
-  };
-  if (options.metadata) prepared.metadata = options.metadata;
-  return prepared;
+// src/publish/paths.ts
+function normalizeManifestPath(path) {
+  return path.replace(/\\/g, "/").replace(/^\.\//, "");
 }
-function sourceRequest(sourceUrl, options) {
-  if (!isHttpUrl(sourceUrl)) {
-    throw new Error(
-      "source_url must be an http(s) URL. Fetch the content first, then pass it as a string or file."
+function assertValidManifestPath(path) {
+  if (path.includes("\\"))
+    throw new PublishInputError(
+      "invalid_path",
+      `Manifest path must use "/": "${path}".`,
+      path
     );
-  }
-  const prepared = {
-    kind: "source",
-    sourceUrl,
-    options: optionsBody(options)
-  };
-  if (options.metadata) prepared.metadata = options.metadata;
-  return prepared;
-}
-async function explicitInput(input, options) {
-  if ("content" in input)
-    return stringContent(
-      input.content,
-      { ...options, ...input },
-      input.contentType ?? options.contentType ?? "text/html"
+  const p = normalizeManifestPath(path);
+  if (p === "")
+    throw new PublishInputError(
+      "invalid_path",
+      "Manifest path must not be empty.",
+      path
     );
-  if ("sourceUrl" in input)
-    return sourceRequest(input.sourceUrl, { ...options, ...input });
-  if ("sourceUrls" in input)
-    throw new Error(
-      "sourceUrls inputs are not supported in v1. Publish a single source_url, or fetch the content first."
+  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
     );
-  return stagedRequest(
-    input.files.map((file) => {
-      const bytes = explicitFileBytes(file);
-      return {
-        path: file.path,
-        contentType: file.contentType,
-        sizeBytes: bytes.byteLength,
-        source: { kind: "bytes", bytes }
-      };
-    }),
-    { ...options, ...input }
-  );
 }
-function explicitFileBytes(file) {
-  if (file.content !== void 0) return Buffer.from(file.content);
-  if (file.contentBase64 !== void 0)
-    return Buffer.from(file.contentBase64, "base64");
-  if (file.bytes !== void 0) return file.bytes;
-  throw new TypeError(`Explicit file ${file.path} is missing content bytes`);
+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) {
@@ -373,69 +230,125 @@ function optionsBody(options) {
     expiresAt: options.expiresAt instanceof Date ? options.expiresAt.toISOString() : options.expiresAt
   };
 }
-// src/publish/upload.ts
-var import_node_crypto2 = require("crypto");
-var import_promises3 = require("fs/promises");
-// src/publish/multipart.ts
-var MAX_PART_TARGETS_PER_REQUEST = 100;
-async function uploadMultipartFile(transport, uploadId, fileId, bytes, partSize) {
-  if (!partSize || partSize < 1) {
-    return createErrorResult(
-      "invalid_upload_target",
-      "Multipart upload target did not include a valid part size.",
-      null
+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 partNumbers = Array.from(
-    { length: Math.ceil(bytes.byteLength / partSize) },
-    (_, index) => index + 1
+  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."
   );
-  const parts = [];
-  for (let startIndex = 0; startIndex < partNumbers.length; startIndex += MAX_PART_TARGETS_PER_REQUEST) {
-    const partNumberBatch = partNumbers.slice(
-      startIndex,
-      startIndex + MAX_PART_TARGETS_PER_REQUEST
-    );
-    const targetsResult = await transport.request(
-      "POST",
-      `/uploads/${encodeURIComponent(uploadId)}/parts`,
-      { body: { fileId, partNumbers: partNumberBatch } }
-    );
-    if (targetsResult.error) return errorResult(targetsResult);
-    for (const target of targetsResult.data.parts) {
-      const start = (target.partNumber - 1) * partSize;
-      const end = Math.min(start + partSize, bytes.byteLength);
-      const uploadResult = await transport.putSignedUrl(
-        target.url,
-        bytes.slice(start, end),
-        target.headers
-      );
-      if (uploadResult.error) return errorResult(uploadResult);
-      if (!uploadResult.data.etag) {
-        return createErrorResult(
-          "missing_upload_etag",
-          "Signed upload response did not include an ETag.",
-          null
-        );
+}
+function singleStagedFile(path, contentType, bytes, options) {
+  return buildStagedRequest(
+    [
+      {
+        path,
+        contentType,
+        sizeBytes: bytes.byteLength,
+        getBody: async () => bytes
       }
-      parts.push({
-        partNumber: target.partNumber,
-        etag: uploadResult.data.etag
-      });
-    }
+    ],
+    options
+  );
+}
+async function resolveInMemory(input, options = {}) {
+  if (input instanceof URL) {
+    return buildSourceRequest(input.toString(), options);
   }
-  return { data: parts, error: null, headers: {} };
+  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 };
 }
-// src/publish/upload.ts
 async function publishStaged(transport, prepared, finalPath, options = {}) {
-  const baseKey = options.idempotencyKey ?? `sdk-${(0, import_node_crypto2.randomUUID)()}`;
+  const baseKey = options.idempotencyKey ?? `sdk-${crypto.randomUUID()}`;
   const createResult = await transport.request(
     "POST",
     "/uploads",
@@ -444,12 +357,9 @@ async function publishStaged(transport, prepared, finalPath, options = {}) {
       idempotencyKey: `${baseKey}:create-upload`
     }
   );
-  if (createResult.error) return errorResult2(createResult);
-  const completedFiles = {};
+  if (createResult.error) return errorResult(createResult);
   for (const file of prepared.files) {
-    const target = createResult.data.files.find(
-      (candidate) => candidate.path === file.path
-    );
+    const target = createResult.data.files.find((f) => f.path === file.path);
     if (!target) {
       return createErrorResult(
         "upload_target_missing",
@@ -457,36 +367,29 @@ async function publishStaged(transport, prepared, finalPath, options = {}) {
         null
       );
     }
-    if (target.upload.strategy === "multipart") {
-      const bytes2 = await fileBytes(file);
-      const partsResult = await uploadMultipartFile(
-        transport,
-        createResult.data.uploadId,
-        target.fileId,
-        bytes2,
-        target.upload.partSize
+    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
       );
-      if (partsResult.error) return errorResult2(partsResult);
-      completedFiles[target.fileId] = { parts: partsResult.data };
-      continue;
     }
-    const bytes = await fileBytes(file);
-    const uploadResult = await transport.putSignedUrl(
+    const put = await transport.putSignedUrl(
       target.upload.url,
-      bytes,
+      await file.getBody(),
       target.upload.headers
     );
-    if (uploadResult.error) return errorResult2(uploadResult);
+    if (put.error) return errorResult(put);
   }
   const completeResult = await transport.request(
     "POST",
     `/uploads/${encodeURIComponent(createResult.data.uploadId)}/complete`,
     {
-      body: { files: completedFiles },
+      body: { files: {} },
       idempotencyKey: `${baseKey}:complete-upload`
     }
   );
-  if (completeResult.error) return errorResult2(completeResult);
+  if (completeResult.error) return errorResult(completeResult);
   const finalOptions = {
     body: {
       uploadId: createResult.data.uploadId,
@@ -499,13 +402,184 @@ async function publishStaged(transport, prepared, finalPath, options = {}) {
     finalOptions.ifRevision = options.ifRevision;
   return transport.request("POST", finalPath, finalOptions);
 }
-async function fileBytes(file) {
-  if (file.source.kind === "bytes") return file.source.bytes;
-  return (0, import_promises3.readFile)(file.source.path);
+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/publish/node.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = require("path");
+// src/publish/checksum.ts
+var import_node_crypto = require("crypto");
+var import_node_fs = require("fs");
+async function sha256File(path) {
+  const hash = (0, import_node_crypto.createHash)("sha256");
+  for await (const chunk of (0, import_node_fs.createReadStream)(path)) {
+    hash.update(chunk);
+  }
+  return hash.digest("hex");
 }
-function errorResult2(result) {
-  if (!result.error) throw new Error("Expected an error result");
-  return { data: null, error: result.error, headers: result.headers };
+// src/publish/files.ts
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_ignore = __toESM(require("ignore"), 1);
+var import_mime_types = require("mime-types");
+var DEFAULT_IGNORES = [
+  ".git",
+  ".git/**",
+  "node_modules",
+  "node_modules/**",
+  ".DS_Store",
+  ".env",
+  ".env.*",
+  ".cache",
+  ".cache/**",
+  ".tmp",
+  ".tmp/**",
+  "dist/.cache",
+  "dist/.cache/**"
+];
+async function collectPublishFiles(inputPath, options = {}) {
+  const inputStat = await (0, import_promises.stat)(inputPath);
+  if (inputStat.isFile()) {
+    return [
+      {
+        absolutePath: inputPath,
+        path: (0, import_node_path.basename)(inputPath),
+        contentType: await detectPathContentType(inputPath),
+        sizeBytes: inputStat.size
+      }
+    ];
+  }
+  if (!inputStat.isDirectory()) {
+    throw new Error(`Input is not a file or directory: ${inputPath}`);
+  }
+  const matcher = (0, import_ignore.default)().add([
+    ...options.ignoreDefaults === false ? [] : DEFAULT_IGNORES,
+    ...options.ignore ?? []
+  ]);
+  const entries = await (0, import_fast_glob.default)("**/*", {
+    cwd: inputPath,
+    onlyFiles: true,
+    followSymbolicLinks: false,
+    dot: true,
+    unique: true
+  });
+  const paths = entries.map((entry) => entry.split(import_node_path.sep).join("/")).filter((entry) => !matcher.ignores(entry)).sort((a, b) => a.localeCompare(b));
+  return Promise.all(
+    paths.map(async (path) => {
+      const absolutePath = `${inputPath}/${path}`;
+      const fileStat = await (0, import_promises.stat)(absolutePath);
+      return {
+        absolutePath,
+        path,
+        contentType: await detectPathContentType(absolutePath),
+        sizeBytes: fileStat.size
+      };
+    })
+  );
+}
+async function detectPathContentType(path) {
+  const detected = (0, import_mime_types.lookup)(path);
+  if (detected) return detected;
+  return detectBytesContentType(await (0, import_promises.readFile)(path));
+}
+// src/publish/node.ts
+var SINGLE_PUT_CHECKSUM_THRESHOLD = 10 * 1024 * 1024;
+async function resolveInput(input, options = {}) {
+  if (input instanceof URL || input instanceof Uint8Array || typeof input === "object" && input !== null && "kind" in input) {
+    return resolveInMemory(input, options);
+  }
+  if (Array.isArray(input)) {
+    return resolveBundle(input, options);
+  }
+  if (typeof input === "string") {
+    return resolveString(input, options);
+  }
+  return resolveInMemory(input, options);
+}
+async function resolveString(value, options) {
+  if (isHttpUrl(value)) return resolveInMemory(value, options);
+  if (value.includes("\n") || value.length > 4096) {
+    return resolveInMemory(value, options);
+  }
+  let info;
+  try {
+    info = await (0, import_promises2.stat)(value);
+  } catch {
+    info = void 0;
+  }
+  if (info?.isFile()) return fileStaged(value, options);
+  if (info?.isDirectory()) return folderStaged(value, options);
+  if (isPathShaped(value)) {
+    throw new PublishInputError(
+      "file_not_found",
+      `No file or directory at "${value}".`,
+      value,
+      'To publish this as inline text, pass { kind: "content", content }.'
+    );
+  }
+  return resolveInMemory(value, options);
+}
+async function fileStaged(path, options) {
+  const fileStat = await (0, import_promises2.stat)(path);
+  if (options.path !== void 0) assertValidManifestPath(options.path);
+  const manifestPath = options.path ?? (0, import_node_path2.basename)(path);
+  const contentType = options.contentType ?? await detectPathContentType(path);
+  const checksumSha256 = fileStat.size > SINGLE_PUT_CHECKSUM_THRESHOLD ? await sha256File(path) : void 0;
+  const file = {
+    path: manifestPath,
+    contentType,
+    sizeBytes: fileStat.size,
+    ...checksumSha256 ? { checksumSha256 } : {},
+    getBody: () => (0, import_promises2.readFile)(path)
+  };
+  return buildStagedRequest([file], options);
+}
+async function folderStaged(path, options) {
+  const files = await collectPublishFiles(path, options);
+  const preparedFiles = await Promise.all(files.map(toPreparedFile));
+  return buildStagedRequest(preparedFiles, options);
+}
+async function resolveBundle(paths, options) {
+  const collected = [];
+  for (const element of paths) {
+    try {
+      await (0, import_promises2.stat)(element);
+    } catch {
+      throw new PublishInputError(
+        "file_not_found",
+        `No file or directory at "${element}".`,
+        element
+      );
+    }
+    collected.push(...await collectPublishFiles(element, options));
+  }
+  const preparedFiles = await Promise.all(collected.map(toPreparedFile));
+  return buildStagedRequest(preparedFiles, options);
+}
+async function toPreparedFile(pf) {
+  const checksumSha256 = pf.sizeBytes > SINGLE_PUT_CHECKSUM_THRESHOLD ? await sha256File(pf.absolutePath) : void 0;
+  return {
+    path: pf.path,
+    contentType: pf.contentType,
+    sizeBytes: pf.sizeBytes,
+    ...checksumSha256 ? { checksumSha256 } : {},
+    getBody: () => (0, import_promises2.readFile)(pf.absolutePath)
+  };
 }
 // src/resources/account.ts
@@ -574,33 +648,6 @@ var DeploymentsResource = class {
     this.transport = transport;
   }
   transport;
-  create(dropId, body, options = {}) {
-    const requestOptions = { body };
-    if (options.idempotencyKey)
-      requestOptions.idempotencyKey = options.idempotencyKey;
-    if (options.ifRevision !== void 0)
-      requestOptions.ifRevision = options.ifRevision;
-    return this.transport.request(
-      "POST",
-      `/drops/${encodeURIComponent(dropId)}/deployments`,
-      requestOptions
-    );
-  }
-  createRaw(dropId, body, options = {}) {
-    const requestOptions = {
-      body,
-      bodyCase: "raw"
-    };
-    if (options.idempotencyKey)
-      requestOptions.idempotencyKey = options.idempotencyKey;
-    if (options.ifRevision !== void 0)
-      requestOptions.ifRevision = options.ifRevision;
-    return this.transport.request(
-      "POST",
-      `/drops/${encodeURIComponent(dropId)}/deployments`,
-      requestOptions
-    );
-  }
   list(dropId, params = {}) {
     return this.transport.request(
       "GET",
@@ -655,21 +702,6 @@ var DropsResource = class {
     this.transport = transport;
   }
   transport;
-  create(body, options = {}) {
-    const requestOptions = { body };
-    if (options.idempotencyKey)
-      requestOptions.idempotencyKey = options.idempotencyKey;
-    return this.transport.request("POST", "/drops", requestOptions);
-  }
-  createRaw(body, options = {}) {
-    const requestOptions = {
-      body,
-      bodyCase: "raw"
-    };
-    if (options.idempotencyKey)
-      requestOptions.idempotencyKey = options.idempotencyKey;
-    return this.transport.request("POST", "/drops", requestOptions);
-  }
   async list(params = {}) {
     const result = await this.transport.request("GET", "/drops", {
       params
@@ -710,15 +742,22 @@ var DropsResource = class {
     );
   }
 };
+var SETTINGS = [
+  "title",
+  "visibility",
+  "password",
+  "noindex",
+  "expiresAt",
+  "slug"
+];
 function updateBody(options) {
-  const {
-    metadata,
-    idempotencyKey: _idempotencyKey,
-    ifRevision: _ifRevision,
-    entry: _entry,
-    ...dropOptions
-  } = options;
-  return { options: dropOptions, metadata };
+  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/resources/uploads.ts
@@ -739,13 +778,6 @@ var UploadsResource = class {
       `/uploads/${encodeURIComponent(uploadId)}`
     );
   }
-  createPartTargets(uploadId, body) {
-    return this.transport.request(
-      "POST",
-      `/uploads/${encodeURIComponent(uploadId)}/parts`,
-      { body }
-    );
-  }
   complete(uploadId, body, options = {}) {
     const requestOptions = { body };
     if (options.idempotencyKey)
@@ -799,25 +831,24 @@ function toSnakeCase(value) {
 // src/transport.ts
 var DEFAULT_BASE_URL = "https://api.dropthis.app";
-var SDK_VERSION = "0.5.0";
+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;
   }
-  multipart(method, path, form, options = {}) {
-    return this.request(method, path, { ...options, body: form });
-  }
   async putSignedUrl(url, body, headers) {
     const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    const timeout = setTimeout(() => controller.abort(), this.uploadTimeoutMs);
     try {
       const request = {
         method: "PUT",
@@ -872,7 +903,7 @@ var Transport = class {
     if (options.idempotencyKey)
       headers["idempotency-key"] = options.idempotencyKey;
     if (options.ifRevision !== void 0)
-      headers["If-Revision"] = String(options.ifRevision);
+      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}`);
@@ -904,11 +935,18 @@ var Transport = class {
       const parsed = parseJson(text);
       if (!response.ok) {
         const body = parsed && typeof parsed === "object" ? parsed : {};
-        const message = stringValue(body.detail) ?? stringValue(body.error) ?? stringValue(body.message) ?? response.statusText;
+        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, {
-          detail: body,
+          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,
@@ -1002,55 +1040,37 @@ var Dropthis = class {
     return this.uploadsResource;
   }
   async prepare(input, options = {}) {
-    return preparePublishRequest(input, options);
+    return resolveInput(input, options);
   }
   async publish(input, options = {}) {
-    const prepared = await preparePublishRequest(input, options);
-    if (prepared.kind === "source")
-      return this.publishSource(prepared, "/drops", options);
-    return publishStaged(this.transport, prepared, "/drops", options);
+    let prepared;
+    try {
+      prepared = await resolveInput(input, options);
+    } catch (e) {
+      return toErrorResult(e);
+    }
+    return prepared.kind === "source" ? publishSource(this.transport, prepared, "/drops", options) : publishStaged(this.transport, prepared, "/drops", options);
   }
   async deploy(dropId, input, options = {}) {
-    const prepared = await preparePublishRequest(input, options);
+    let prepared;
+    try {
+      prepared = await resolveInput(input, options);
+    } catch (e) {
+      return toErrorResult(e);
+    }
     const path = `/drops/${encodeURIComponent(dropId)}/deployments`;
-    if (prepared.kind === "source")
-      return createErrorResult(
-        "source_url_unsupported_for_deployment",
-        "Publishing a deployment from a source_url is not supported yet. Fetch the content first, then pass it as a string or file.",
-        null
-      );
-    return publishStaged(this.transport, prepared, path, options);
-  }
-  publishSource(prepared, path, options) {
-    const body = {
-      sourceUrl: prepared.sourceUrl,
-      options: prepared.options
-    };
-    if (prepared.metadata) body.metadata = prepared.metadata;
-    const baseKey = options.idempotencyKey ?? `sdk-${crypto.randomUUID()}`;
-    return this.transport.request("POST", path, {
-      body,
-      idempotencyKey: `${baseKey}:publish`
-    });
+    return prepared.kind === "source" ? publishSource(this.transport, prepared, path, options) : publishStaged(this.transport, prepared, path, options);
   }
   async update(dropId, options = {}) {
     return this.drops.update(dropId, options);
   }
-  request(method, path, options = {}) {
-    return this.transport.request(method, path, {
-      ...options,
-      bodyCase: "raw"
-    });
-  }
-  requestSignedUpload(url, bytes, headers) {
-    return this.transport.putSignedUrl(url, bytes, headers);
-  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CursorPage,
   DeploymentsResource,
   Dropthis,
+  PublishInputError,
   UploadsResource,
   createErrorResult,
   redactSecrets