@superatomai/sdk-node 0.0.94-dsp → 0.0.95-dsp

package/dist/index.d.mts

@@ -4836,6 +4836,8 @@ interface ParcelRef {
 interface ParcelFileRef extends ParcelRef {
     name?: string;
     contentType: string;
+    /** The file's bytes as base64, when storage was down and they travel in the message instead. */
+    data?: string;
 }
 interface ParcelClientOptions {
     apiUrl: string;
@@ -4854,6 +4856,8 @@ declare class ParcelClient {
     constructor(opts: ParcelClientOptions);
     private url;
     private call;
+    /** The receipt the bytes would get, without storing them. */
+    refFor(bytes: Uint8Array, ext: string): ParcelRef;
     /** Stores the bytes and returns the receipt for them. */
     upload(bytes: Uint8Array, ext?: string, contentType?: string): Promise<ParcelRef>;
     /** The bytes behind a receipt, checked against its hash. */
@@ -4872,7 +4876,11 @@ declare class ParcelFile {
     readonly size: number;
     readonly contentType: string;
     constructor(ref: ParcelFileRef, client: ParcelClient | null);
-    /** The file's bytes, checked against their hash. Throws if they cannot be fetched. */
+    /**
+     * The file's bytes, checked against their hash — from the message itself when
+     * it carried them (storage was down), otherwise from storage. Throws if they
+     * cannot be fetched.
+     */
     download(): Promise<Uint8Array>;
     toJSON(): {
         __parcelFile: ParcelFileRef;

package/dist/index.d.ts

@@ -4836,6 +4836,8 @@ interface ParcelRef {
 interface ParcelFileRef extends ParcelRef {
     name?: string;
     contentType: string;
+    /** The file's bytes as base64, when storage was down and they travel in the message instead. */
+    data?: string;
 }
 interface ParcelClientOptions {
     apiUrl: string;
@@ -4854,6 +4856,8 @@ declare class ParcelClient {
     constructor(opts: ParcelClientOptions);
     private url;
     private call;
+    /** The receipt the bytes would get, without storing them. */
+    refFor(bytes: Uint8Array, ext: string): ParcelRef;
     /** Stores the bytes and returns the receipt for them. */
     upload(bytes: Uint8Array, ext?: string, contentType?: string): Promise<ParcelRef>;
     /** The bytes behind a receipt, checked against its hash. */
@@ -4872,7 +4876,11 @@ declare class ParcelFile {
     readonly size: number;
     readonly contentType: string;
     constructor(ref: ParcelFileRef, client: ParcelClient | null);
-    /** The file's bytes, checked against their hash. Throws if they cannot be fetched. */
+    /**
+     * The file's bytes, checked against their hash — from the message itself when
+     * it carried them (storage was down), otherwise from storage. Throws if they
+     * cannot be fetched.
+     */
     download(): Promise<Uint8Array>;
     toJSON(): {
         __parcelFile: ParcelFileRef;

package/dist/index.js

@@ -28370,12 +28370,19 @@ var import_crypto7 = require("crypto");
 var PARCEL_THRESHOLD_BYTES = 256 * 1024;
 var MAX_INLINE_BYTES = 900 * 1024;
 var MAX_PARCEL_BYTES = 95 * 1024 * 1024;
+var PART_BYTES = 600 * 1024;
+var PART_WAIT_MS = 6e4;
 var NEVER_PARCEL = /* @__PURE__ */ new Set(["PING", "PONG", "BUNDLE_CHUNK", "BUNDLE_CSS_CHUNK"]);
 var RETRY_DELAYS_MS = [500, 1500];
 var REQUEST_TIMEOUT_MS = 6e4;
 var MAX_DEPTH = 32;
 var PARCEL_FIELD = "__parcel";
 var FILE_FIELD = "__parcelFile";
+var PART_FIELD = "__parcelPart";
+var partOf = (payload) => {
+  const p = payload?.[PART_FIELD];
+  return p && typeof p.id === "string" && typeof p.data === "string" && Number.isInteger(p.total) && Number.isInteger(p.index) && p.total > 0 && p.index >= 0 && p.index < p.total ? p : null;
+};
 var isRef = (ref) => !!ref && typeof ref === "object" && typeof ref.projectId === "string" && typeof ref.hash === "string" && typeof ref.ext === "string" && typeof ref.size === "number";
 function parcelRefOf(payload) {
   const ref = payload?.[PARCEL_FIELD];
@@ -28430,12 +28437,16 @@ var ParcelClient = class {
     }
     return res;
   }
+  /** The receipt the bytes would get, without storing them. */
+  refFor(bytes, ext) {
+    return { projectId: this.opts.projectId, hash: sha256Hex(bytes), ext, size: bytes.byteLength };
+  }
   /** Stores the bytes and returns the receipt for them. */
   async upload(bytes, ext = "json", contentType = "application/json") {
     if (bytes.byteLength > MAX_PARCEL_BYTES) {
       throw new Error(`Parcel too large (${bytes.byteLength} bytes, limit ${MAX_PARCEL_BYTES})`);
     }
-    const ref = { projectId: this.opts.projectId, hash: sha256Hex(bytes), ext, size: bytes.byteLength };
+    const ref = this.refFor(bytes, ext);
     await withRetries(
       "upload",
       () => this.call(this.url(ref), { method: "PUT", headers: { "Content-Type": contentType }, body: bytes })
@@ -28462,8 +28473,17 @@ var ParcelFile = class {
     this.size = ref.size;
     this.contentType = ref.contentType;
   }
-  /** The file's bytes, checked against their hash. Throws if they cannot be fetched. */
+  /**
+   * The file's bytes, checked against their hash — from the message itself when
+   * it carried them (storage was down), otherwise from storage. Throws if they
+   * cannot be fetched.
+   */
   async download() {
+    if (typeof this.ref.data === "string") {
+      const bytes = new Uint8Array(Buffer.from(this.ref.data, "base64"));
+      if (sha256Hex(bytes) !== this.ref.hash) throw new Error("File content does not match its hash");
+      return bytes;
+    }
     if (!this.client) throw new Error("Cannot download files: SA_API_URL or the API key is not set");
     return this.client.download(this.ref);
   }
@@ -28492,28 +28512,55 @@ function hasFileRef(value, depth = 0) {
   return false;
 }
 var extOf = (name) => typeof name === "string" && /\.([a-z0-9]{1,10})$/i.exec(name)?.[1]?.toLowerCase() || "bin";
-async function uploadFiles(value, client, parent, depth = 0) {
+async function uploadFiles(value, client, storage, parent, depth = 0) {
   if (isBinary(value)) {
     const bytes = value instanceof Uint8Array ? value : new Uint8Array(value);
     const name = parent?.name ?? parent?.fileName;
     const contentType = String(parent?.contentType ?? parent?.mimeType ?? "application/octet-stream");
-    const ref = await client.upload(bytes, extOf(name), contentType);
-    const fileRef = { ...ref, contentType, ...typeof name === "string" ? { name } : {} };
+    const named = typeof name === "string" ? { name } : {};
+    if (!storage.down) {
+      try {
+        const ref = await client.upload(bytes, extOf(name), contentType);
+        const fileRef2 = { ...ref, contentType, ...named };
+        return { [FILE_FIELD]: fileRef2 };
+      } catch (err) {
+        if (bytes.byteLength > MAX_PARCEL_BYTES) throw err;
+        storage.down = true;
+        logger.warn(`[parcels] file upload failed, sending it in the message instead: ${err?.message ?? err}`);
+      }
+    }
+    const fileRef = {
+      ...client.refFor(bytes, extOf(name)),
+      contentType,
+      ...named,
+      data: Buffer.from(bytes).toString("base64")
+    };
     return { [FILE_FIELD]: fileRef };
   }
   if (depth >= MAX_DEPTH) return value;
   if (Array.isArray(value)) {
     const out = [];
-    for (const v of value) out.push(await uploadFiles(v, client, void 0, depth + 1));
+    for (const v of value) out.push(await uploadFiles(v, client, storage, void 0, depth + 1));
     return out;
   }
   if (isPlain(value)) {
     const out = {};
-    for (const [k, v] of Object.entries(value)) out[k] = await uploadFiles(v, client, value, depth + 1);
+    for (const [k, v] of Object.entries(value)) out[k] = await uploadFiles(v, client, storage, value, depth + 1);
     return out;
   }
   return value;
 }
+function splitPayload(payload) {
+  const bytes = Buffer.from(JSON.stringify(payload ?? null), "utf8");
+  const total = Math.max(1, Math.ceil(bytes.byteLength / PART_BYTES));
+  const id = (0, import_crypto7.randomUUID)();
+  return Array.from({ length: total }, (_, index) => ({
+    id,
+    index,
+    total,
+    data: bytes.subarray(index * PART_BYTES, (index + 1) * PART_BYTES).toString("base64")
+  }));
+}
 function toFileHandles(value, client, depth = 0) {
   const ref = fileRefOf(value);
   if (ref) return new ParcelFile(ref, client);
@@ -28593,8 +28640,7 @@ var OutgoingParcels = class {
       if (Buffer.byteLength(wire, "utf8") < this.threshold) return this.now(message, wire);
     }
     this.queueFor(message).run(async () => {
-      const out = await this.prepare(message, files);
-      this.deliver(out.message, out.wire);
+      for (const out of await this.prepare(message, files)) this.deliver(out.message, out.wire);
     });
     return true;
   }
@@ -28619,44 +28665,60 @@ var OutgoingParcels = class {
   async idle() {
     await Promise.all(Array.from(this.queues.values(), (queue) => queue.idle()));
   }
+  /**
+   * What actually goes on the socket for this message: usually one message (as
+   * is, or as a parcel receipt); several parts when storage is down and the
+   * message is too large for the relay.
+   */
   async prepare(message, files) {
     let current = message;
+    const storage = { down: false };
     if (files) {
-      const started2 = Date.now();
+      const started = Date.now();
       try {
-        current = { ...message, payload: await uploadFiles(message.payload, this.client) };
-        logger.info(`[parcels] ${message.type} ${message.id ?? ""}: file(s) uploaded (${Date.now() - started2}ms)`);
+        current = { ...message, payload: await uploadFiles(message.payload, this.client, storage) };
+        if (!storage.down) logger.info(`[parcels] ${message.type} ${message.id ?? ""}: file(s) uploaded (${Date.now() - started}ms)`);
       } catch (err) {
-        const reason = err?.message ?? String(err);
-        logger.error(`[parcels] file upload failed for ${message.type}, sending an error instead: ${reason}`);
-        return { message: asError(message, `Could not send a file: ${reason}`) };
+        const reason2 = err?.message ?? String(err);
+        logger.error(`[parcels] file upload failed for ${message.type}, sending an error instead: ${reason2}`);
+        return [{ message: asError(message, `Could not send a file: ${reason2}`) }];
       }
     }
     let wire;
     try {
       wire = JSON.stringify(current);
     } catch {
-      return { message: current };
+      return [{ message: current }];
     }
     const size = Buffer.byteLength(wire, "utf8");
-    if (!this.jsonParcels || size < this.threshold) return { message: current, wire };
-    const started = Date.now();
-    try {
-      const bytes = Buffer.from(JSON.stringify(current.payload ?? null), "utf8");
-      const ref = await this.client.upload(bytes);
-      logger.info(
-        `[parcels] ${message.type} ${message.id ?? ""} \u2192 parcel ${ref.hash.slice(0, 12)} (${ref.size} bytes, ${Date.now() - started}ms)`
-      );
-      return { message: { ...current, payload: { [PARCEL_FIELD]: ref } } };
-    } catch (err) {
-      const reason = err?.message ?? String(err);
-      if (size <= MAX_INLINE_BYTES) {
-        logger.warn(`[parcels] upload failed for ${message.type}, sending inline (${size} bytes): ${reason}`);
-        return { message: current, wire };
+    if (size < this.threshold) return [{ message: current, wire }];
+    let reason = "large-JSON parcels are off";
+    if (this.jsonParcels && !storage.down) {
+      const started = Date.now();
+      try {
+        const bytes = Buffer.from(JSON.stringify(current.payload ?? null), "utf8");
+        const ref = await this.client.upload(bytes);
+        logger.info(
+          `[parcels] ${message.type} ${message.id ?? ""} \u2192 parcel ${ref.hash.slice(0, 12)} (${ref.size} bytes, ${Date.now() - started}ms)`
+        );
+        return [{ message: { ...current, payload: { [PARCEL_FIELD]: ref } } }];
+      } catch (err) {
+        reason = err?.message ?? String(err);
       }
-      logger.error(`[parcels] upload failed for ${message.type} (${size} bytes), sending an error instead: ${reason}`);
-      return { message: asError(message, `The message was too large to deliver (${size} bytes): ${reason}`) };
+    } else if (storage.down) {
+      reason = "storage is down";
+    }
+    if (size <= MAX_INLINE_BYTES) {
+      if (this.jsonParcels) logger.warn(`[parcels] ${message.type} not stored (${reason}), sending inline (${size} bytes)`);
+      return [{ message: current, wire }];
     }
+    if (size > MAX_PARCEL_BYTES) {
+      logger.error(`[parcels] ${message.type} (${size} bytes) is too large to send`);
+      return [{ message: asError(message, `The message was too large to deliver (${size} bytes): ${reason}`) }];
+    }
+    const parts = splitPayload(current.payload);
+    logger.warn(`[parcels] ${message.type} not stored (${reason}), sending in ${parts.length} parts (${size} bytes)`);
+    return parts.map((part) => ({ message: { ...current, payload: { [PART_FIELD]: part } } }));
   }
 };
 var IncomingParcels = class {
@@ -28664,12 +28726,22 @@ var IncomingParcels = class {
     this.client = client;
     this.dispatch = dispatch;
     this.queue = new InOrder();
+    /** Split messages still waiting for parts, by part id. */
+    this.partial = /* @__PURE__ */ new Map();
+    /** Split messages already rebuilt, so a second copy of their parts is ignored. */
+    this.rebuilt = /* @__PURE__ */ new Set();
   }
   /**
    * `raw` is the message's text when it is at hand: a message that never
    * mentions a file placeholder is not searched for one.
    */
   receive(message, raw) {
+    const part = partOf(message?.payload);
+    if (part) {
+      const whole = this.collect(message, part);
+      if (whole) this.receive(whole);
+      return;
+    }
     const ref = parcelRefOf(message?.payload);
     if (!ref) {
       const withFiles = raw === void 0 || raw.includes(FILE_FIELD) ? this.withFiles(message) : message;
@@ -28685,6 +28757,38 @@ var IncomingParcels = class {
   idle() {
     return this.queue.idle();
   }
+  /**
+   * Holds one part; once all of them are here, the original message (envelope
+   * from the last part, payload rebuilt). Null while parts are still missing.
+   */
+  collect(message, part) {
+    if (this.rebuilt.has(part.id)) return null;
+    let entry = this.partial.get(part.id);
+    if (!entry) {
+      const timer = setTimeout(() => {
+        this.partial.delete(part.id);
+        logger.warn(`[parcels] ${message.type}: gave up waiting for the rest of a split message (${part.id})`);
+      }, PART_WAIT_MS).unref();
+      entry = { parts: new Array(part.total), got: 0, timer };
+      this.partial.set(part.id, entry);
+    }
+    if (entry.parts.length !== part.total || entry.parts[part.index] !== void 0) return null;
+    entry.parts[part.index] = part.data;
+    if (++entry.got < part.total) return null;
+    clearTimeout(entry.timer);
+    this.partial.delete(part.id);
+    this.rebuilt.add(part.id);
+    setTimeout(() => this.rebuilt.delete(part.id), PART_WAIT_MS).unref();
+    try {
+      const bytes = Buffer.concat(entry.parts.map((data) => Buffer.from(data, "base64")));
+      logger.info(`[parcels] ${message.type} ${message.id ?? ""} rebuilt from ${part.total} parts (${bytes.byteLength} bytes)`);
+      return { ...message, payload: JSON.parse(bytes.toString("utf8")) };
+    } catch (err) {
+      const reason = err?.message ?? String(err);
+      logger.error(`[parcels] could not rebuild a split ${message.type}: ${reason}`);
+      return asError(message, `Could not rebuild the message: ${reason}`);
+    }
+  }
   withFiles(message) {
     try {
       return hasFileRef(message.payload) ? { ...message, payload: toFileHandles(message.payload, this.client) } : message;

package/dist/index.mjs

@@ -6,7 +6,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/index.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 
 // src/websocket.ts
 import WebSocket from "ws";
@@ -28246,16 +28246,23 @@ var ReportManager = class {
 };
 
 // src/parcels/index.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
 var PARCEL_THRESHOLD_BYTES = 256 * 1024;
 var MAX_INLINE_BYTES = 900 * 1024;
 var MAX_PARCEL_BYTES = 95 * 1024 * 1024;
+var PART_BYTES = 600 * 1024;
+var PART_WAIT_MS = 6e4;
 var NEVER_PARCEL = /* @__PURE__ */ new Set(["PING", "PONG", "BUNDLE_CHUNK", "BUNDLE_CSS_CHUNK"]);
 var RETRY_DELAYS_MS = [500, 1500];
 var REQUEST_TIMEOUT_MS = 6e4;
 var MAX_DEPTH = 32;
 var PARCEL_FIELD = "__parcel";
 var FILE_FIELD = "__parcelFile";
+var PART_FIELD = "__parcelPart";
+var partOf = (payload) => {
+  const p = payload?.[PART_FIELD];
+  return p && typeof p.id === "string" && typeof p.data === "string" && Number.isInteger(p.total) && Number.isInteger(p.index) && p.total > 0 && p.index >= 0 && p.index < p.total ? p : null;
+};
 var isRef = (ref) => !!ref && typeof ref === "object" && typeof ref.projectId === "string" && typeof ref.hash === "string" && typeof ref.ext === "string" && typeof ref.size === "number";
 function parcelRefOf(payload) {
   const ref = payload?.[PARCEL_FIELD];
@@ -28310,12 +28317,16 @@ var ParcelClient = class {
     }
     return res;
   }
+  /** The receipt the bytes would get, without storing them. */
+  refFor(bytes, ext) {
+    return { projectId: this.opts.projectId, hash: sha256Hex(bytes), ext, size: bytes.byteLength };
+  }
   /** Stores the bytes and returns the receipt for them. */
   async upload(bytes, ext = "json", contentType = "application/json") {
     if (bytes.byteLength > MAX_PARCEL_BYTES) {
       throw new Error(`Parcel too large (${bytes.byteLength} bytes, limit ${MAX_PARCEL_BYTES})`);
     }
-    const ref = { projectId: this.opts.projectId, hash: sha256Hex(bytes), ext, size: bytes.byteLength };
+    const ref = this.refFor(bytes, ext);
     await withRetries(
       "upload",
       () => this.call(this.url(ref), { method: "PUT", headers: { "Content-Type": contentType }, body: bytes })
@@ -28342,8 +28353,17 @@ var ParcelFile = class {
     this.size = ref.size;
     this.contentType = ref.contentType;
   }
-  /** The file's bytes, checked against their hash. Throws if they cannot be fetched. */
+  /**
+   * The file's bytes, checked against their hash — from the message itself when
+   * it carried them (storage was down), otherwise from storage. Throws if they
+   * cannot be fetched.
+   */
   async download() {
+    if (typeof this.ref.data === "string") {
+      const bytes = new Uint8Array(Buffer.from(this.ref.data, "base64"));
+      if (sha256Hex(bytes) !== this.ref.hash) throw new Error("File content does not match its hash");
+      return bytes;
+    }
     if (!this.client) throw new Error("Cannot download files: SA_API_URL or the API key is not set");
     return this.client.download(this.ref);
   }
@@ -28372,28 +28392,55 @@ function hasFileRef(value, depth = 0) {
   return false;
 }
 var extOf = (name) => typeof name === "string" && /\.([a-z0-9]{1,10})$/i.exec(name)?.[1]?.toLowerCase() || "bin";
-async function uploadFiles(value, client, parent, depth = 0) {
+async function uploadFiles(value, client, storage, parent, depth = 0) {
   if (isBinary(value)) {
     const bytes = value instanceof Uint8Array ? value : new Uint8Array(value);
     const name = parent?.name ?? parent?.fileName;
     const contentType = String(parent?.contentType ?? parent?.mimeType ?? "application/octet-stream");
-    const ref = await client.upload(bytes, extOf(name), contentType);
-    const fileRef = { ...ref, contentType, ...typeof name === "string" ? { name } : {} };
+    const named = typeof name === "string" ? { name } : {};
+    if (!storage.down) {
+      try {
+        const ref = await client.upload(bytes, extOf(name), contentType);
+        const fileRef2 = { ...ref, contentType, ...named };
+        return { [FILE_FIELD]: fileRef2 };
+      } catch (err) {
+        if (bytes.byteLength > MAX_PARCEL_BYTES) throw err;
+        storage.down = true;
+        logger.warn(`[parcels] file upload failed, sending it in the message instead: ${err?.message ?? err}`);
+      }
+    }
+    const fileRef = {
+      ...client.refFor(bytes, extOf(name)),
+      contentType,
+      ...named,
+      data: Buffer.from(bytes).toString("base64")
+    };
     return { [FILE_FIELD]: fileRef };
   }
   if (depth >= MAX_DEPTH) return value;
   if (Array.isArray(value)) {
     const out = [];
-    for (const v of value) out.push(await uploadFiles(v, client, void 0, depth + 1));
+    for (const v of value) out.push(await uploadFiles(v, client, storage, void 0, depth + 1));
     return out;
   }
   if (isPlain(value)) {
     const out = {};
-    for (const [k, v] of Object.entries(value)) out[k] = await uploadFiles(v, client, value, depth + 1);
+    for (const [k, v] of Object.entries(value)) out[k] = await uploadFiles(v, client, storage, value, depth + 1);
     return out;
   }
   return value;
 }
+function splitPayload(payload) {
+  const bytes = Buffer.from(JSON.stringify(payload ?? null), "utf8");
+  const total = Math.max(1, Math.ceil(bytes.byteLength / PART_BYTES));
+  const id = randomUUID3();
+  return Array.from({ length: total }, (_, index) => ({
+    id,
+    index,
+    total,
+    data: bytes.subarray(index * PART_BYTES, (index + 1) * PART_BYTES).toString("base64")
+  }));
+}
 function toFileHandles(value, client, depth = 0) {
   const ref = fileRefOf(value);
   if (ref) return new ParcelFile(ref, client);
@@ -28473,8 +28520,7 @@ var OutgoingParcels = class {
       if (Buffer.byteLength(wire, "utf8") < this.threshold) return this.now(message, wire);
     }
     this.queueFor(message).run(async () => {
-      const out = await this.prepare(message, files);
-      this.deliver(out.message, out.wire);
+      for (const out of await this.prepare(message, files)) this.deliver(out.message, out.wire);
     });
     return true;
   }
@@ -28499,44 +28545,60 @@ var OutgoingParcels = class {
   async idle() {
     await Promise.all(Array.from(this.queues.values(), (queue) => queue.idle()));
   }
+  /**
+   * What actually goes on the socket for this message: usually one message (as
+   * is, or as a parcel receipt); several parts when storage is down and the
+   * message is too large for the relay.
+   */
   async prepare(message, files) {
     let current = message;
+    const storage = { down: false };
     if (files) {
-      const started2 = Date.now();
+      const started = Date.now();
       try {
-        current = { ...message, payload: await uploadFiles(message.payload, this.client) };
-        logger.info(`[parcels] ${message.type} ${message.id ?? ""}: file(s) uploaded (${Date.now() - started2}ms)`);
+        current = { ...message, payload: await uploadFiles(message.payload, this.client, storage) };
+        if (!storage.down) logger.info(`[parcels] ${message.type} ${message.id ?? ""}: file(s) uploaded (${Date.now() - started}ms)`);
       } catch (err) {
-        const reason = err?.message ?? String(err);
-        logger.error(`[parcels] file upload failed for ${message.type}, sending an error instead: ${reason}`);
-        return { message: asError(message, `Could not send a file: ${reason}`) };
+        const reason2 = err?.message ?? String(err);
+        logger.error(`[parcels] file upload failed for ${message.type}, sending an error instead: ${reason2}`);
+        return [{ message: asError(message, `Could not send a file: ${reason2}`) }];
       }
     }
     let wire;
     try {
       wire = JSON.stringify(current);
     } catch {
-      return { message: current };
+      return [{ message: current }];
     }
     const size = Buffer.byteLength(wire, "utf8");
-    if (!this.jsonParcels || size < this.threshold) return { message: current, wire };
-    const started = Date.now();
-    try {
-      const bytes = Buffer.from(JSON.stringify(current.payload ?? null), "utf8");
-      const ref = await this.client.upload(bytes);
-      logger.info(
-        `[parcels] ${message.type} ${message.id ?? ""} \u2192 parcel ${ref.hash.slice(0, 12)} (${ref.size} bytes, ${Date.now() - started}ms)`
-      );
-      return { message: { ...current, payload: { [PARCEL_FIELD]: ref } } };
-    } catch (err) {
-      const reason = err?.message ?? String(err);
-      if (size <= MAX_INLINE_BYTES) {
-        logger.warn(`[parcels] upload failed for ${message.type}, sending inline (${size} bytes): ${reason}`);
-        return { message: current, wire };
+    if (size < this.threshold) return [{ message: current, wire }];
+    let reason = "large-JSON parcels are off";
+    if (this.jsonParcels && !storage.down) {
+      const started = Date.now();
+      try {
+        const bytes = Buffer.from(JSON.stringify(current.payload ?? null), "utf8");
+        const ref = await this.client.upload(bytes);
+        logger.info(
+          `[parcels] ${message.type} ${message.id ?? ""} \u2192 parcel ${ref.hash.slice(0, 12)} (${ref.size} bytes, ${Date.now() - started}ms)`
+        );
+        return [{ message: { ...current, payload: { [PARCEL_FIELD]: ref } } }];
+      } catch (err) {
+        reason = err?.message ?? String(err);
       }
-      logger.error(`[parcels] upload failed for ${message.type} (${size} bytes), sending an error instead: ${reason}`);
-      return { message: asError(message, `The message was too large to deliver (${size} bytes): ${reason}`) };
+    } else if (storage.down) {
+      reason = "storage is down";
+    }
+    if (size <= MAX_INLINE_BYTES) {
+      if (this.jsonParcels) logger.warn(`[parcels] ${message.type} not stored (${reason}), sending inline (${size} bytes)`);
+      return [{ message: current, wire }];
     }
+    if (size > MAX_PARCEL_BYTES) {
+      logger.error(`[parcels] ${message.type} (${size} bytes) is too large to send`);
+      return [{ message: asError(message, `The message was too large to deliver (${size} bytes): ${reason}`) }];
+    }
+    const parts = splitPayload(current.payload);
+    logger.warn(`[parcels] ${message.type} not stored (${reason}), sending in ${parts.length} parts (${size} bytes)`);
+    return parts.map((part) => ({ message: { ...current, payload: { [PART_FIELD]: part } } }));
   }
 };
 var IncomingParcels = class {
@@ -28544,12 +28606,22 @@ var IncomingParcels = class {
     this.client = client;
     this.dispatch = dispatch;
     this.queue = new InOrder();
+    /** Split messages still waiting for parts, by part id. */
+    this.partial = /* @__PURE__ */ new Map();
+    /** Split messages already rebuilt, so a second copy of their parts is ignored. */
+    this.rebuilt = /* @__PURE__ */ new Set();
   }
   /**
    * `raw` is the message's text when it is at hand: a message that never
    * mentions a file placeholder is not searched for one.
    */
   receive(message, raw) {
+    const part = partOf(message?.payload);
+    if (part) {
+      const whole = this.collect(message, part);
+      if (whole) this.receive(whole);
+      return;
+    }
     const ref = parcelRefOf(message?.payload);
     if (!ref) {
       const withFiles = raw === void 0 || raw.includes(FILE_FIELD) ? this.withFiles(message) : message;
@@ -28565,6 +28637,38 @@ var IncomingParcels = class {
   idle() {
     return this.queue.idle();
   }
+  /**
+   * Holds one part; once all of them are here, the original message (envelope
+   * from the last part, payload rebuilt). Null while parts are still missing.
+   */
+  collect(message, part) {
+    if (this.rebuilt.has(part.id)) return null;
+    let entry = this.partial.get(part.id);
+    if (!entry) {
+      const timer = setTimeout(() => {
+        this.partial.delete(part.id);
+        logger.warn(`[parcels] ${message.type}: gave up waiting for the rest of a split message (${part.id})`);
+      }, PART_WAIT_MS).unref();
+      entry = { parts: new Array(part.total), got: 0, timer };
+      this.partial.set(part.id, entry);
+    }
+    if (entry.parts.length !== part.total || entry.parts[part.index] !== void 0) return null;
+    entry.parts[part.index] = part.data;
+    if (++entry.got < part.total) return null;
+    clearTimeout(entry.timer);
+    this.partial.delete(part.id);
+    this.rebuilt.add(part.id);
+    setTimeout(() => this.rebuilt.delete(part.id), PART_WAIT_MS).unref();
+    try {
+      const bytes = Buffer.concat(entry.parts.map((data) => Buffer.from(data, "base64")));
+      logger.info(`[parcels] ${message.type} ${message.id ?? ""} rebuilt from ${part.total} parts (${bytes.byteLength} bytes)`);
+      return { ...message, payload: JSON.parse(bytes.toString("utf8")) };
+    } catch (err) {
+      const reason = err?.message ?? String(err);
+      logger.error(`[parcels] could not rebuild a split ${message.type}: ${reason}`);
+      return asError(message, `Could not rebuild the message: ${reason}`);
+    }
+  }
   withFiles(message) {
     try {
       return hasFileRef(message.payload) ? { ...message, payload: toFileHandles(message.payload, this.client) } : message;
@@ -30592,7 +30696,7 @@ var SuperatomSDK = class {
       waiters.push(finish);
       this.registryWaiters.set(resType, waiters);
       const sent = this.send({
-        id: `${reqType.toLowerCase()}_${randomUUID3()}`,
+        id: `${reqType.toLowerCase()}_${randomUUID4()}`,
         type: reqType,
         from: { type: this.type },
         to: { type: "runtime" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superatomai/sdk-node",
-  "version": "0.0.94-dsp",
+  "version": "0.0.95-dsp",
   "description": "Node.js TypeScript SDK for Superatom",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",