@strapi/data-transfer 5.42.0 → 5.43.0

package/dist/utils/transfer-asset-chunk.js

@@ -0,0 +1,93 @@
+'use strict';
+
+/**
+ * Canonical **outbound** asset chunk for WebSocket JSON (push and pull).
+ * Base64 string `data` keeps `JSON.parse` heap bounded vs `{ type: 'Buffer', data: [n,…] }`.
+ */ function createTransferAssetStreamChunk(assetID, chunk) {
+    if (chunk == null) {
+        throw new TypeError('Asset stream yielded a null/undefined chunk; refusing to encode (would trigger Buffer.from(undefined))');
+    }
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    return {
+        action: 'stream',
+        assetID,
+        encoding: 'base64',
+        data: buffer.toString('base64')
+    };
+}
+/**
+ * Decode a stream item from `TransferAssetFlow` after `JSON.parse` (shared by push + pull handlers
+ * and the remote source provider).
+ */ function decodeTransferAssetStreamItem(item) {
+    return decodeTransferAssetStreamData(item.data, item.encoding === 'base64' ? 'base64' : undefined);
+}
+const getLegacyBufferJsonData = (value)=>{
+    if (!value || typeof value !== 'object' || !('type' in value)) {
+        return null;
+    }
+    if (value.type !== 'Buffer') {
+        return null;
+    }
+    const raw = value.data;
+    if (Array.isArray(raw) || ArrayBuffer.isView(raw)) {
+        return raw;
+    }
+    return null;
+};
+/**
+ * Decode binary payload for `TransferAssetFlow` `action: 'stream'` after JSON.parse.
+ *
+ * Supported shapes (receivers should accept all of these):
+ * - **String `data`:** preferred wire form (`createTransferAssetStreamChunk` / `encoding: 'base64'`).
+ * - **`{ type: 'Buffer', data: number[] | TypedArray }`:** legacy `Buffer.toJSON()` from default
+ *   `JSON.stringify` (older clients/servers).
+ * - **`Buffer` instance:** in-process only.
+ *
+ * Note: Node’s `JSON.stringify` runs `Buffer.toJSON()` before any replacer, so nested `Buffer`
+ * values become the legacy object unless you pass a string (use `createTransferAssetStreamChunk`).
+ */ function decodeTransferAssetStreamData(data, encoding) {
+    if (encoding === 'base64' && typeof data === 'string') {
+        return Buffer.from(data, 'base64');
+    }
+    // `encoding: 'base64'` with a non-string payload (or no encoding) uses the same fallbacks as
+    // legacy peers — avoids throwing when flags and payload disagree.
+    if (Buffer.isBuffer(data)) {
+        return Buffer.from(data);
+    }
+    const legacyBufferData = getLegacyBufferJsonData(data);
+    if (legacyBufferData) {
+        return Buffer.from(legacyBufferData);
+    }
+    // Wire base64 string (pull generator and any other path that stringifies a string payload).
+    if (typeof data === 'string') {
+        return Buffer.from(data, 'base64');
+    }
+    throw new TypeError('Invalid transfer asset stream chunk payload');
+}
+/** Approximate decoded byte size for batching (pull asset generator). */ function transferAssetStreamChunkByteLength(chunk) {
+    if (chunk.action !== 'stream') {
+        return 0;
+    }
+    if (typeof chunk.data === 'string') {
+        return Math.floor(chunk.data.length * 3 / 4);
+    }
+    if (Buffer.isBuffer(chunk.data)) {
+        return chunk.data.byteLength;
+    }
+    const legacyBufferData = getLegacyBufferJsonData(chunk.data);
+    if (legacyBufferData) {
+        if (Array.isArray(legacyBufferData)) {
+            return legacyBufferData.length;
+        }
+        if (ArrayBuffer.isView(legacyBufferData)) {
+            return legacyBufferData.byteLength;
+        }
+    }
+    return 0;
+}
+
+exports.createTransferAssetStreamChunk = createTransferAssetStreamChunk;
+exports.decodeTransferAssetStreamData = decodeTransferAssetStreamData;
+exports.decodeTransferAssetStreamItem = decodeTransferAssetStreamItem;
+exports.transferAssetStreamChunkByteLength = transferAssetStreamChunkByteLength;
+//# sourceMappingURL=transfer-asset-chunk.js.map

package/dist/utils/transfer-asset-chunk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transfer-asset-chunk.js","sources":["../../src/utils/transfer-asset-chunk.ts"],"sourcesContent":["/**\n * Canonical **outbound** asset chunk for WebSocket JSON (push and pull).\n * Base64 string `data` keeps `JSON.parse` heap bounded vs `{ type: 'Buffer', data: [n,…] }`.\n */\nexport function createTransferAssetStreamChunk(\n  assetID: string,\n  chunk: Buffer | Uint8Array\n): { action: 'stream'; assetID: string; encoding: 'base64'; data: string } {\n  if (chunk == null) {\n    throw new TypeError(\n      'Asset stream yielded a null/undefined chunk; refusing to encode (would trigger Buffer.from(undefined))'\n    );\n  }\n  const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);\n  return {\n    action: 'stream',\n    assetID,\n    encoding: 'base64',\n    data: buffer.toString('base64'),\n  };\n}\n\n/**\n * Decode a stream item from `TransferAssetFlow` after `JSON.parse` (shared by push + pull handlers\n * and the remote source provider).\n */\nexport function decodeTransferAssetStreamItem(item: {\n  action: 'stream';\n  data: unknown;\n  encoding?: 'base64';\n}): Buffer {\n  return decodeTransferAssetStreamData(\n    item.data,\n    item.encoding === 'base64' ? 'base64' : undefined\n  );\n}\n\nconst getLegacyBufferJsonData = (value: unknown): Uint8Array | readonly number[] | null => {\n  if (!value || typeof value !== 'object' || !('type' in value)) {\n    return null;\n  }\n  if ((value as { type: unknown }).type !== 'Buffer') {\n    return null;\n  }\n  const raw = (value as { data?: unknown }).data;\n  if (Array.isArray(raw) || ArrayBuffer.isView(raw)) {\n    return raw as Uint8Array | readonly number[];\n  }\n  return null;\n};\n\n/**\n * Decode binary payload for `TransferAssetFlow` `action: 'stream'` after JSON.parse.\n *\n * Supported shapes (receivers should accept all of these):\n * - **String `data`:** preferred wire form (`createTransferAssetStreamChunk` / `encoding: 'base64'`).\n * - **`{ type: 'Buffer', data: number[] | TypedArray }`:** legacy `Buffer.toJSON()` from default\n *   `JSON.stringify` (older clients/servers).\n * - **`Buffer` instance:** in-process only.\n *\n * Note: Node’s `JSON.stringify` runs `Buffer.toJSON()` before any replacer, so nested `Buffer`\n * values become the legacy object unless you pass a string (use `createTransferAssetStreamChunk`).\n */\nexport function decodeTransferAssetStreamData(data: unknown, encoding?: 'base64'): Buffer {\n  if (encoding === 'base64' && typeof data === 'string') {\n    return Buffer.from(data, 'base64');\n  }\n  // `encoding: 'base64'` with a non-string payload (or no encoding) uses the same fallbacks as\n  // legacy peers — avoids throwing when flags and payload disagree.\n\n  if (Buffer.isBuffer(data)) {\n    return Buffer.from(data);\n  }\n\n  const legacyBufferData = getLegacyBufferJsonData(data);\n  if (legacyBufferData) {\n    return Buffer.from(legacyBufferData);\n  }\n\n  // Wire base64 string (pull generator and any other path that stringifies a string payload).\n  if (typeof data === 'string') {\n    return Buffer.from(data, 'base64');\n  }\n\n  throw new TypeError('Invalid transfer asset stream chunk payload');\n}\n\n/** Approximate decoded byte size for batching (pull asset generator). */\nexport function transferAssetStreamChunkByteLength(chunk: {\n  action: string;\n  data?: unknown;\n  encoding?: 'base64';\n}): number {\n  if (chunk.action !== 'stream') {\n    return 0;\n  }\n  if (typeof chunk.data === 'string') {\n    return Math.floor((chunk.data.length * 3) / 4);\n  }\n  if (Buffer.isBuffer(chunk.data)) {\n    return chunk.data.byteLength;\n  }\n\n  const legacyBufferData = getLegacyBufferJsonData(chunk.data);\n  if (legacyBufferData) {\n    if (Array.isArray(legacyBufferData)) {\n      return legacyBufferData.length;\n    }\n    if (ArrayBuffer.isView(legacyBufferData)) {\n      return legacyBufferData.byteLength;\n    }\n  }\n  return 0;\n}\n"],"names":["createTransferAssetStreamChunk","assetID","chunk","TypeError","buffer","Buffer","isBuffer","from","action","encoding","data","toString","decodeTransferAssetStreamItem","item","decodeTransferAssetStreamData","undefined","getLegacyBufferJsonData","value","type","raw","Array","isArray","ArrayBuffer","isView","legacyBufferData","transferAssetStreamChunkByteLength","Math","floor","length","byteLength"],"mappings":"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"}

package/dist/utils/transfer-asset-chunk.mjs

@@ -0,0 +1,88 @@
+/**
+ * Canonical **outbound** asset chunk for WebSocket JSON (push and pull).
+ * Base64 string `data` keeps `JSON.parse` heap bounded vs `{ type: 'Buffer', data: [n,…] }`.
+ */ function createTransferAssetStreamChunk(assetID, chunk) {
+    if (chunk == null) {
+        throw new TypeError('Asset stream yielded a null/undefined chunk; refusing to encode (would trigger Buffer.from(undefined))');
+    }
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    return {
+        action: 'stream',
+        assetID,
+        encoding: 'base64',
+        data: buffer.toString('base64')
+    };
+}
+/**
+ * Decode a stream item from `TransferAssetFlow` after `JSON.parse` (shared by push + pull handlers
+ * and the remote source provider).
+ */ function decodeTransferAssetStreamItem(item) {
+    return decodeTransferAssetStreamData(item.data, item.encoding === 'base64' ? 'base64' : undefined);
+}
+const getLegacyBufferJsonData = (value)=>{
+    if (!value || typeof value !== 'object' || !('type' in value)) {
+        return null;
+    }
+    if (value.type !== 'Buffer') {
+        return null;
+    }
+    const raw = value.data;
+    if (Array.isArray(raw) || ArrayBuffer.isView(raw)) {
+        return raw;
+    }
+    return null;
+};
+/**
+ * Decode binary payload for `TransferAssetFlow` `action: 'stream'` after JSON.parse.
+ *
+ * Supported shapes (receivers should accept all of these):
+ * - **String `data`:** preferred wire form (`createTransferAssetStreamChunk` / `encoding: 'base64'`).
+ * - **`{ type: 'Buffer', data: number[] | TypedArray }`:** legacy `Buffer.toJSON()` from default
+ *   `JSON.stringify` (older clients/servers).
+ * - **`Buffer` instance:** in-process only.
+ *
+ * Note: Node’s `JSON.stringify` runs `Buffer.toJSON()` before any replacer, so nested `Buffer`
+ * values become the legacy object unless you pass a string (use `createTransferAssetStreamChunk`).
+ */ function decodeTransferAssetStreamData(data, encoding) {
+    if (encoding === 'base64' && typeof data === 'string') {
+        return Buffer.from(data, 'base64');
+    }
+    // `encoding: 'base64'` with a non-string payload (or no encoding) uses the same fallbacks as
+    // legacy peers — avoids throwing when flags and payload disagree.
+    if (Buffer.isBuffer(data)) {
+        return Buffer.from(data);
+    }
+    const legacyBufferData = getLegacyBufferJsonData(data);
+    if (legacyBufferData) {
+        return Buffer.from(legacyBufferData);
+    }
+    // Wire base64 string (pull generator and any other path that stringifies a string payload).
+    if (typeof data === 'string') {
+        return Buffer.from(data, 'base64');
+    }
+    throw new TypeError('Invalid transfer asset stream chunk payload');
+}
+/** Approximate decoded byte size for batching (pull asset generator). */ function transferAssetStreamChunkByteLength(chunk) {
+    if (chunk.action !== 'stream') {
+        return 0;
+    }
+    if (typeof chunk.data === 'string') {
+        return Math.floor(chunk.data.length * 3 / 4);
+    }
+    if (Buffer.isBuffer(chunk.data)) {
+        return chunk.data.byteLength;
+    }
+    const legacyBufferData = getLegacyBufferJsonData(chunk.data);
+    if (legacyBufferData) {
+        if (Array.isArray(legacyBufferData)) {
+            return legacyBufferData.length;
+        }
+        if (ArrayBuffer.isView(legacyBufferData)) {
+            return legacyBufferData.byteLength;
+        }
+    }
+    return 0;
+}
+
+export { createTransferAssetStreamChunk, decodeTransferAssetStreamData, decodeTransferAssetStreamItem, transferAssetStreamChunkByteLength };
+//# sourceMappingURL=transfer-asset-chunk.mjs.map

package/dist/utils/transfer-asset-chunk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"transfer-asset-chunk.mjs","sources":["../../src/utils/transfer-asset-chunk.ts"],"sourcesContent":["/**\n * Canonical **outbound** asset chunk for WebSocket JSON (push and pull).\n * Base64 string `data` keeps `JSON.parse` heap bounded vs `{ type: 'Buffer', data: [n,…] }`.\n */\nexport function createTransferAssetStreamChunk(\n  assetID: string,\n  chunk: Buffer | Uint8Array\n): { action: 'stream'; assetID: string; encoding: 'base64'; data: string } {\n  if (chunk == null) {\n    throw new TypeError(\n      'Asset stream yielded a null/undefined chunk; refusing to encode (would trigger Buffer.from(undefined))'\n    );\n  }\n  const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);\n  return {\n    action: 'stream',\n    assetID,\n    encoding: 'base64',\n    data: buffer.toString('base64'),\n  };\n}\n\n/**\n * Decode a stream item from `TransferAssetFlow` after `JSON.parse` (shared by push + pull handlers\n * and the remote source provider).\n */\nexport function decodeTransferAssetStreamItem(item: {\n  action: 'stream';\n  data: unknown;\n  encoding?: 'base64';\n}): Buffer {\n  return decodeTransferAssetStreamData(\n    item.data,\n    item.encoding === 'base64' ? 'base64' : undefined\n  );\n}\n\nconst getLegacyBufferJsonData = (value: unknown): Uint8Array | readonly number[] | null => {\n  if (!value || typeof value !== 'object' || !('type' in value)) {\n    return null;\n  }\n  if ((value as { type: unknown }).type !== 'Buffer') {\n    return null;\n  }\n  const raw = (value as { data?: unknown }).data;\n  if (Array.isArray(raw) || ArrayBuffer.isView(raw)) {\n    return raw as Uint8Array | readonly number[];\n  }\n  return null;\n};\n\n/**\n * Decode binary payload for `TransferAssetFlow` `action: 'stream'` after JSON.parse.\n *\n * Supported shapes (receivers should accept all of these):\n * - **String `data`:** preferred wire form (`createTransferAssetStreamChunk` / `encoding: 'base64'`).\n * - **`{ type: 'Buffer', data: number[] | TypedArray }`:** legacy `Buffer.toJSON()` from default\n *   `JSON.stringify` (older clients/servers).\n * - **`Buffer` instance:** in-process only.\n *\n * Note: Node’s `JSON.stringify` runs `Buffer.toJSON()` before any replacer, so nested `Buffer`\n * values become the legacy object unless you pass a string (use `createTransferAssetStreamChunk`).\n */\nexport function decodeTransferAssetStreamData(data: unknown, encoding?: 'base64'): Buffer {\n  if (encoding === 'base64' && typeof data === 'string') {\n    return Buffer.from(data, 'base64');\n  }\n  // `encoding: 'base64'` with a non-string payload (or no encoding) uses the same fallbacks as\n  // legacy peers — avoids throwing when flags and payload disagree.\n\n  if (Buffer.isBuffer(data)) {\n    return Buffer.from(data);\n  }\n\n  const legacyBufferData = getLegacyBufferJsonData(data);\n  if (legacyBufferData) {\n    return Buffer.from(legacyBufferData);\n  }\n\n  // Wire base64 string (pull generator and any other path that stringifies a string payload).\n  if (typeof data === 'string') {\n    return Buffer.from(data, 'base64');\n  }\n\n  throw new TypeError('Invalid transfer asset stream chunk payload');\n}\n\n/** Approximate decoded byte size for batching (pull asset generator). */\nexport function transferAssetStreamChunkByteLength(chunk: {\n  action: string;\n  data?: unknown;\n  encoding?: 'base64';\n}): number {\n  if (chunk.action !== 'stream') {\n    return 0;\n  }\n  if (typeof chunk.data === 'string') {\n    return Math.floor((chunk.data.length * 3) / 4);\n  }\n  if (Buffer.isBuffer(chunk.data)) {\n    return chunk.data.byteLength;\n  }\n\n  const legacyBufferData = getLegacyBufferJsonData(chunk.data);\n  if (legacyBufferData) {\n    if (Array.isArray(legacyBufferData)) {\n      return legacyBufferData.length;\n    }\n    if (ArrayBuffer.isView(legacyBufferData)) {\n      return legacyBufferData.byteLength;\n    }\n  }\n  return 0;\n}\n"],"names":["createTransferAssetStreamChunk","assetID","chunk","TypeError","buffer","Buffer","isBuffer","from","action","encoding","data","toString","decodeTransferAssetStreamItem","item","decodeTransferAssetStreamData","undefined","getLegacyBufferJsonData","value","type","raw","Array","isArray","ArrayBuffer","isView","legacyBufferData","transferAssetStreamChunkByteLength","Math","floor","length","byteLength"],"mappings":"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"}

package/dist/utils/transfer-websocket-json.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared `JSON.stringify` replacer for data-transfer WebSocket frames (push and pull).
+ *
+ * Default `JSON.stringify` uses `Buffer.toJSON()` → `{ type: 'Buffer', data: [n,n,...] }`, which
+ * allocates a large array on the peer during `JSON.parse`. Encode binary values as compact base64 strings instead.
+ *
+ * Note: Node runs `Buffer.prototype.toJSON` before the replacer sees a `Buffer` property, so the
+ * replacer receives `{ type: 'Buffer', data: [...] }` unless the value is already a string (see
+ * `createTransferAssetStreamChunk` in `transfer-asset-chunk.ts`).
+ */
+export declare const replacerForTransferWebSocket: (_key: string, value: unknown) => unknown;
+/**
+ * `JSON.stringify` invokes an own enumerable `toJSON` on the root value before replacers run. If that
+ * method returns `undefined`, the whole `JSON.stringify` result is `undefined`, and `ws.send(undefined)`
+ * throws ("The first argument must be of type string or an instance of Buffer... Received undefined").
+ * Spreading transfer messages (`{ ...message, uuid }`) can copy an enumerable `toJSON` from user / ORM
+ * objects onto the wire payload — strip it on the root object we control.
+ */
+export declare function stripRootToJSONMethod(payload: Record<string, unknown>): void;
+/**
+ * Serialize a transfer WebSocket envelope. Never returns `undefined` (unlike raw `JSON.stringify`).
+ */
+export declare function stringifyTransferWebSocketPayload(payload: Record<string, unknown>): string;
+//# sourceMappingURL=transfer-websocket-json.d.ts.map

package/dist/utils/transfer-websocket-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transfer-websocket-json.d.ts","sourceRoot":"","sources":["../../src/utils/transfer-websocket-json.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,eAAO,MAAM,4BAA4B,SAAU,MAAM,SAAS,OAAO,KAAG,OA4B3E,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAI5E;AAED;;GAEG;AACH,wBAAgB,iCAAiC,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAe1F"}

package/dist/utils/transfer-websocket-json.js

@@ -0,0 +1,67 @@
+'use strict';
+
+/**
+ * Shared `JSON.stringify` replacer for data-transfer WebSocket frames (push and pull).
+ *
+ * Default `JSON.stringify` uses `Buffer.toJSON()` → `{ type: 'Buffer', data: [n,n,...] }`, which
+ * allocates a large array on the peer during `JSON.parse`. Encode binary values as compact base64 strings instead.
+ *
+ * Note: Node runs `Buffer.prototype.toJSON` before the replacer sees a `Buffer` property, so the
+ * replacer receives `{ type: 'Buffer', data: [...] }` unless the value is already a string (see
+ * `createTransferAssetStreamChunk` in `transfer-asset-chunk.ts`).
+ */ const replacerForTransferWebSocket = (_key, value)=>{
+    /** `JSON.stringify` throws on bigint; upload metadata or ORM fields may surface as BigInt. */ if (typeof value === 'bigint') {
+        return value.toString();
+    }
+    if (Buffer.isBuffer(value)) {
+        return value.toString('base64');
+    }
+    if (value instanceof Uint8Array) {
+        const { buffer, byteOffset, byteLength } = value;
+        if (buffer == null) {
+            throw new TypeError('Invalid Uint8Array in transfer payload (missing underlying ArrayBuffer); cannot encode for WebSocket');
+        }
+        return Buffer.from(buffer, byteOffset, byteLength).toString('base64');
+    }
+    if (ArrayBuffer.isView(value) && !(value instanceof DataView)) {
+        const v = value;
+        const { buffer, byteOffset, byteLength } = v;
+        if (buffer == null) {
+            throw new TypeError('Invalid typed array in transfer payload (missing underlying ArrayBuffer); cannot encode for WebSocket');
+        }
+        return Buffer.from(buffer, byteOffset, byteLength).toString('base64');
+    }
+    return value;
+};
+/**
+ * `JSON.stringify` invokes an own enumerable `toJSON` on the root value before replacers run. If that
+ * method returns `undefined`, the whole `JSON.stringify` result is `undefined`, and `ws.send(undefined)`
+ * throws ("The first argument must be of type string or an instance of Buffer... Received undefined").
+ * Spreading transfer messages (`{ ...message, uuid }`) can copy an enumerable `toJSON` from user / ORM
+ * objects onto the wire payload — strip it on the root object we control.
+ */ function stripRootToJSONMethod(payload) {
+    if (typeof payload.toJSON === 'function') {
+        delete payload.toJSON;
+    }
+}
+/**
+ * Serialize a transfer WebSocket envelope. Never returns `undefined` (unlike raw `JSON.stringify`).
+ */ function stringifyTransferWebSocketPayload(payload) {
+    stripRootToJSONMethod(payload);
+    let s;
+    try {
+        s = JSON.stringify(payload, replacerForTransferWebSocket);
+    } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new TypeError(`Transfer WebSocket payload could not be serialized to JSON: ${message}`);
+    }
+    if (typeof s !== 'string') {
+        throw new TypeError('Transfer WebSocket payload could not be serialized to JSON (result was undefined). Check for Symbol or other non-JSON values on the root payload.');
+    }
+    return s;
+}
+
+exports.replacerForTransferWebSocket = replacerForTransferWebSocket;
+exports.stringifyTransferWebSocketPayload = stringifyTransferWebSocketPayload;
+exports.stripRootToJSONMethod = stripRootToJSONMethod;
+//# sourceMappingURL=transfer-websocket-json.js.map

package/dist/utils/transfer-websocket-json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transfer-websocket-json.js","sources":["../../src/utils/transfer-websocket-json.ts"],"sourcesContent":["/**\n * Shared `JSON.stringify` replacer for data-transfer WebSocket frames (push and pull).\n *\n * Default `JSON.stringify` uses `Buffer.toJSON()` → `{ type: 'Buffer', data: [n,n,...] }`, which\n * allocates a large array on the peer during `JSON.parse`. Encode binary values as compact base64 strings instead.\n *\n * Note: Node runs `Buffer.prototype.toJSON` before the replacer sees a `Buffer` property, so the\n * replacer receives `{ type: 'Buffer', data: [...] }` unless the value is already a string (see\n * `createTransferAssetStreamChunk` in `transfer-asset-chunk.ts`).\n */\nexport const replacerForTransferWebSocket = (_key: string, value: unknown): unknown => {\n  /** `JSON.stringify` throws on bigint; upload metadata or ORM fields may surface as BigInt. */\n  if (typeof value === 'bigint') {\n    return value.toString();\n  }\n  if (Buffer.isBuffer(value)) {\n    return value.toString('base64');\n  }\n  if (value instanceof Uint8Array) {\n    const { buffer, byteOffset, byteLength } = value;\n    if (buffer == null) {\n      throw new TypeError(\n        'Invalid Uint8Array in transfer payload (missing underlying ArrayBuffer); cannot encode for WebSocket'\n      );\n    }\n    return Buffer.from(buffer, byteOffset, byteLength).toString('base64');\n  }\n  if (ArrayBuffer.isView(value) && !(value instanceof DataView)) {\n    const v = value as NodeJS.TypedArray;\n    const { buffer, byteOffset, byteLength } = v;\n    if (buffer == null) {\n      throw new TypeError(\n        'Invalid typed array in transfer payload (missing underlying ArrayBuffer); cannot encode for WebSocket'\n      );\n    }\n    return Buffer.from(buffer, byteOffset, byteLength).toString('base64');\n  }\n  return value;\n};\n\n/**\n * `JSON.stringify` invokes an own enumerable `toJSON` on the root value before replacers run. If that\n * method returns `undefined`, the whole `JSON.stringify` result is `undefined`, and `ws.send(undefined)`\n * throws (\"The first argument must be of type string or an instance of Buffer... Received undefined\").\n * Spreading transfer messages (`{ ...message, uuid }`) can copy an enumerable `toJSON` from user / ORM\n * objects onto the wire payload — strip it on the root object we control.\n */\nexport function stripRootToJSONMethod(payload: Record<string, unknown>): void {\n  if (typeof payload.toJSON === 'function') {\n    delete payload.toJSON;\n  }\n}\n\n/**\n * Serialize a transfer WebSocket envelope. Never returns `undefined` (unlike raw `JSON.stringify`).\n */\nexport function stringifyTransferWebSocketPayload(payload: Record<string, unknown>): string {\n  stripRootToJSONMethod(payload);\n  let s: string | undefined;\n  try {\n    s = JSON.stringify(payload, replacerForTransferWebSocket);\n  } catch (err) {\n    const message = err instanceof Error ? err.message : String(err);\n    throw new TypeError(`Transfer WebSocket payload could not be serialized to JSON: ${message}`);\n  }\n  if (typeof s !== 'string') {\n    throw new TypeError(\n      'Transfer WebSocket payload could not be serialized to JSON (result was undefined). Check for Symbol or other non-JSON values on the root payload.'\n    );\n  }\n  return s;\n}\n"],"names":["replacerForTransferWebSocket","_key","value","toString","Buffer","isBuffer","Uint8Array","buffer","byteOffset","byteLength","TypeError","from","ArrayBuffer","isView","DataView","v","stripRootToJSONMethod","payload","toJSON","stringifyTransferWebSocketPayload","s","JSON","stringify","err","message","Error","String"],"mappings":";;AAAA;;;;;;;;;AASC,IACM,MAAMA,4BAAAA,GAA+B,CAACC,IAAAA,EAAcC,KAAAA,GAAAA;AACzD,mGACA,IAAI,OAAOA,KAAAA,KAAU,QAAA,EAAU;AAC7B,QAAA,OAAOA,MAAMC,QAAQ,EAAA;AACvB,IAAA;IACA,IAAIC,MAAAA,CAAOC,QAAQ,CAACH,KAAAA,CAAAA,EAAQ;QAC1B,OAAOA,KAAAA,CAAMC,QAAQ,CAAC,QAAA,CAAA;AACxB,IAAA;AACA,IAAA,IAAID,iBAAiBI,UAAAA,EAAY;AAC/B,QAAA,MAAM,EAAEC,MAAM,EAAEC,UAAU,EAAEC,UAAU,EAAE,GAAGP,KAAAA;AAC3C,QAAA,IAAIK,UAAU,IAAA,EAAM;AAClB,YAAA,MAAM,IAAIG,SAAAA,CACR,sGAAA,CAAA;AAEJ,QAAA;AACA,QAAA,OAAON,OAAOO,IAAI,CAACJ,QAAQC,UAAAA,EAAYC,UAAAA,CAAAA,CAAYN,QAAQ,CAAC,QAAA,CAAA;AAC9D,IAAA;IACA,IAAIS,WAAAA,CAAYC,MAAM,CAACX,KAAAA,CAAAA,IAAU,EAAEA,KAAAA,YAAiBY,QAAO,CAAA,EAAI;AAC7D,QAAA,MAAMC,CAAAA,GAAIb,KAAAA;AACV,QAAA,MAAM,EAAEK,MAAM,EAAEC,UAAU,EAAEC,UAAU,EAAE,GAAGM,CAAAA;AAC3C,QAAA,IAAIR,UAAU,IAAA,EAAM;AAClB,YAAA,MAAM,IAAIG,SAAAA,CACR,uGAAA,CAAA;AAEJ,QAAA;AACA,QAAA,OAAON,OAAOO,IAAI,CAACJ,QAAQC,UAAAA,EAAYC,UAAAA,CAAAA,CAAYN,QAAQ,CAAC,QAAA,CAAA;AAC9D,IAAA;IACA,OAAOD,KAAAA;AACT;AAEA;;;;;;IAOO,SAASc,qBAAAA,CAAsBC,OAAgC,EAAA;AACpE,IAAA,IAAI,OAAOA,OAAAA,CAAQC,MAAM,KAAK,UAAA,EAAY;AACxC,QAAA,OAAOD,QAAQC,MAAM;AACvB,IAAA;AACF;AAEA;;IAGO,SAASC,iCAAAA,CAAkCF,OAAgC,EAAA;IAChFD,qBAAAA,CAAsBC,OAAAA,CAAAA;IACtB,IAAIG,CAAAA;IACJ,IAAI;QACFA,CAAAA,GAAIC,IAAAA,CAAKC,SAAS,CAACL,OAAAA,EAASjB,4BAAAA,CAAAA;AAC9B,IAAA,CAAA,CAAE,OAAOuB,GAAAA,EAAK;AACZ,QAAA,MAAMC,UAAUD,GAAAA,YAAeE,KAAAA,GAAQF,GAAAA,CAAIC,OAAO,GAAGE,MAAAA,CAAOH,GAAAA,CAAAA;AAC5D,QAAA,MAAM,IAAIb,SAAAA,CAAU,CAAC,4DAA4D,EAAEc,OAAAA,CAAAA,CAAS,CAAA;AAC9F,IAAA;IACA,IAAI,OAAOJ,MAAM,QAAA,EAAU;AACzB,QAAA,MAAM,IAAIV,SAAAA,CACR,mJAAA,CAAA;AAEJ,IAAA;IACA,OAAOU,CAAAA;AACT;;;;;;"}

package/dist/utils/transfer-websocket-json.mjs

@@ -0,0 +1,63 @@
+/**
+ * Shared `JSON.stringify` replacer for data-transfer WebSocket frames (push and pull).
+ *
+ * Default `JSON.stringify` uses `Buffer.toJSON()` → `{ type: 'Buffer', data: [n,n,...] }`, which
+ * allocates a large array on the peer during `JSON.parse`. Encode binary values as compact base64 strings instead.
+ *
+ * Note: Node runs `Buffer.prototype.toJSON` before the replacer sees a `Buffer` property, so the
+ * replacer receives `{ type: 'Buffer', data: [...] }` unless the value is already a string (see
+ * `createTransferAssetStreamChunk` in `transfer-asset-chunk.ts`).
+ */ const replacerForTransferWebSocket = (_key, value)=>{
+    /** `JSON.stringify` throws on bigint; upload metadata or ORM fields may surface as BigInt. */ if (typeof value === 'bigint') {
+        return value.toString();
+    }
+    if (Buffer.isBuffer(value)) {
+        return value.toString('base64');
+    }
+    if (value instanceof Uint8Array) {
+        const { buffer, byteOffset, byteLength } = value;
+        if (buffer == null) {
+            throw new TypeError('Invalid Uint8Array in transfer payload (missing underlying ArrayBuffer); cannot encode for WebSocket');
+        }
+        return Buffer.from(buffer, byteOffset, byteLength).toString('base64');
+    }
+    if (ArrayBuffer.isView(value) && !(value instanceof DataView)) {
+        const v = value;
+        const { buffer, byteOffset, byteLength } = v;
+        if (buffer == null) {
+            throw new TypeError('Invalid typed array in transfer payload (missing underlying ArrayBuffer); cannot encode for WebSocket');
+        }
+        return Buffer.from(buffer, byteOffset, byteLength).toString('base64');
+    }
+    return value;
+};
+/**
+ * `JSON.stringify` invokes an own enumerable `toJSON` on the root value before replacers run. If that
+ * method returns `undefined`, the whole `JSON.stringify` result is `undefined`, and `ws.send(undefined)`
+ * throws ("The first argument must be of type string or an instance of Buffer... Received undefined").
+ * Spreading transfer messages (`{ ...message, uuid }`) can copy an enumerable `toJSON` from user / ORM
+ * objects onto the wire payload — strip it on the root object we control.
+ */ function stripRootToJSONMethod(payload) {
+    if (typeof payload.toJSON === 'function') {
+        delete payload.toJSON;
+    }
+}
+/**
+ * Serialize a transfer WebSocket envelope. Never returns `undefined` (unlike raw `JSON.stringify`).
+ */ function stringifyTransferWebSocketPayload(payload) {
+    stripRootToJSONMethod(payload);
+    let s;
+    try {
+        s = JSON.stringify(payload, replacerForTransferWebSocket);
+    } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new TypeError(`Transfer WebSocket payload could not be serialized to JSON: ${message}`);
+    }
+    if (typeof s !== 'string') {
+        throw new TypeError('Transfer WebSocket payload could not be serialized to JSON (result was undefined). Check for Symbol or other non-JSON values on the root payload.');
+    }
+    return s;
+}
+
+export { replacerForTransferWebSocket, stringifyTransferWebSocketPayload, stripRootToJSONMethod };
+//# sourceMappingURL=transfer-websocket-json.mjs.map

package/dist/utils/transfer-websocket-json.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"transfer-websocket-json.mjs","sources":["../../src/utils/transfer-websocket-json.ts"],"sourcesContent":["/**\n * Shared `JSON.stringify` replacer for data-transfer WebSocket frames (push and pull).\n *\n * Default `JSON.stringify` uses `Buffer.toJSON()` → `{ type: 'Buffer', data: [n,n,...] }`, which\n * allocates a large array on the peer during `JSON.parse`. Encode binary values as compact base64 strings instead.\n *\n * Note: Node runs `Buffer.prototype.toJSON` before the replacer sees a `Buffer` property, so the\n * replacer receives `{ type: 'Buffer', data: [...] }` unless the value is already a string (see\n * `createTransferAssetStreamChunk` in `transfer-asset-chunk.ts`).\n */\nexport const replacerForTransferWebSocket = (_key: string, value: unknown): unknown => {\n  /** `JSON.stringify` throws on bigint; upload metadata or ORM fields may surface as BigInt. */\n  if (typeof value === 'bigint') {\n    return value.toString();\n  }\n  if (Buffer.isBuffer(value)) {\n    return value.toString('base64');\n  }\n  if (value instanceof Uint8Array) {\n    const { buffer, byteOffset, byteLength } = value;\n    if (buffer == null) {\n      throw new TypeError(\n        'Invalid Uint8Array in transfer payload (missing underlying ArrayBuffer); cannot encode for WebSocket'\n      );\n    }\n    return Buffer.from(buffer, byteOffset, byteLength).toString('base64');\n  }\n  if (ArrayBuffer.isView(value) && !(value instanceof DataView)) {\n    const v = value as NodeJS.TypedArray;\n    const { buffer, byteOffset, byteLength } = v;\n    if (buffer == null) {\n      throw new TypeError(\n        'Invalid typed array in transfer payload (missing underlying ArrayBuffer); cannot encode for WebSocket'\n      );\n    }\n    return Buffer.from(buffer, byteOffset, byteLength).toString('base64');\n  }\n  return value;\n};\n\n/**\n * `JSON.stringify` invokes an own enumerable `toJSON` on the root value before replacers run. If that\n * method returns `undefined`, the whole `JSON.stringify` result is `undefined`, and `ws.send(undefined)`\n * throws (\"The first argument must be of type string or an instance of Buffer... Received undefined\").\n * Spreading transfer messages (`{ ...message, uuid }`) can copy an enumerable `toJSON` from user / ORM\n * objects onto the wire payload — strip it on the root object we control.\n */\nexport function stripRootToJSONMethod(payload: Record<string, unknown>): void {\n  if (typeof payload.toJSON === 'function') {\n    delete payload.toJSON;\n  }\n}\n\n/**\n * Serialize a transfer WebSocket envelope. Never returns `undefined` (unlike raw `JSON.stringify`).\n */\nexport function stringifyTransferWebSocketPayload(payload: Record<string, unknown>): string {\n  stripRootToJSONMethod(payload);\n  let s: string | undefined;\n  try {\n    s = JSON.stringify(payload, replacerForTransferWebSocket);\n  } catch (err) {\n    const message = err instanceof Error ? err.message : String(err);\n    throw new TypeError(`Transfer WebSocket payload could not be serialized to JSON: ${message}`);\n  }\n  if (typeof s !== 'string') {\n    throw new TypeError(\n      'Transfer WebSocket payload could not be serialized to JSON (result was undefined). Check for Symbol or other non-JSON values on the root payload.'\n    );\n  }\n  return s;\n}\n"],"names":["replacerForTransferWebSocket","_key","value","toString","Buffer","isBuffer","Uint8Array","buffer","byteOffset","byteLength","TypeError","from","ArrayBuffer","isView","DataView","v","stripRootToJSONMethod","payload","toJSON","stringifyTransferWebSocketPayload","s","JSON","stringify","err","message","Error","String"],"mappings":"AAAA;;;;;;;;;AASC,IACM,MAAMA,4BAAAA,GAA+B,CAACC,IAAAA,EAAcC,KAAAA,GAAAA;AACzD,mGACA,IAAI,OAAOA,KAAAA,KAAU,QAAA,EAAU;AAC7B,QAAA,OAAOA,MAAMC,QAAQ,EAAA;AACvB,IAAA;IACA,IAAIC,MAAAA,CAAOC,QAAQ,CAACH,KAAAA,CAAAA,EAAQ;QAC1B,OAAOA,KAAAA,CAAMC,QAAQ,CAAC,QAAA,CAAA;AACxB,IAAA;AACA,IAAA,IAAID,iBAAiBI,UAAAA,EAAY;AAC/B,QAAA,MAAM,EAAEC,MAAM,EAAEC,UAAU,EAAEC,UAAU,EAAE,GAAGP,KAAAA;AAC3C,QAAA,IAAIK,UAAU,IAAA,EAAM;AAClB,YAAA,MAAM,IAAIG,SAAAA,CACR,sGAAA,CAAA;AAEJ,QAAA;AACA,QAAA,OAAON,OAAOO,IAAI,CAACJ,QAAQC,UAAAA,EAAYC,UAAAA,CAAAA,CAAYN,QAAQ,CAAC,QAAA,CAAA;AAC9D,IAAA;IACA,IAAIS,WAAAA,CAAYC,MAAM,CAACX,KAAAA,CAAAA,IAAU,EAAEA,KAAAA,YAAiBY,QAAO,CAAA,EAAI;AAC7D,QAAA,MAAMC,CAAAA,GAAIb,KAAAA;AACV,QAAA,MAAM,EAAEK,MAAM,EAAEC,UAAU,EAAEC,UAAU,EAAE,GAAGM,CAAAA;AAC3C,QAAA,IAAIR,UAAU,IAAA,EAAM;AAClB,YAAA,MAAM,IAAIG,SAAAA,CACR,uGAAA,CAAA;AAEJ,QAAA;AACA,QAAA,OAAON,OAAOO,IAAI,CAACJ,QAAQC,UAAAA,EAAYC,UAAAA,CAAAA,CAAYN,QAAQ,CAAC,QAAA,CAAA;AAC9D,IAAA;IACA,OAAOD,KAAAA;AACT;AAEA;;;;;;IAOO,SAASc,qBAAAA,CAAsBC,OAAgC,EAAA;AACpE,IAAA,IAAI,OAAOA,OAAAA,CAAQC,MAAM,KAAK,UAAA,EAAY;AACxC,QAAA,OAAOD,QAAQC,MAAM;AACvB,IAAA;AACF;AAEA;;IAGO,SAASC,iCAAAA,CAAkCF,OAAgC,EAAA;IAChFD,qBAAAA,CAAsBC,OAAAA,CAAAA;IACtB,IAAIG,CAAAA;IACJ,IAAI;QACFA,CAAAA,GAAIC,IAAAA,CAAKC,SAAS,CAACL,OAAAA,EAASjB,4BAAAA,CAAAA;AAC9B,IAAA,CAAA,CAAE,OAAOuB,GAAAA,EAAK;AACZ,QAAA,MAAMC,UAAUD,GAAAA,YAAeE,KAAAA,GAAQF,GAAAA,CAAIC,OAAO,GAAGE,MAAAA,CAAOH,GAAAA,CAAAA;AAC5D,QAAA,MAAM,IAAIb,SAAAA,CAAU,CAAC,4DAA4D,EAAEc,OAAAA,CAAAA,CAAS,CAAA;AAC9F,IAAA;IACA,IAAI,OAAOJ,MAAM,QAAA,EAAU;AACzB,QAAA,MAAM,IAAIV,SAAAA,CACR,mJAAA,CAAA;AAEJ,IAAA;IACA,OAAOU,CAAAA;AACT;;;;"}

package/dist/utils/writable-async-write.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import type { Writable } from 'stream';
+/**
+ * Async helper for application code that `await`s sequential writes to a `Writable`.
+ *
+ * 1. Waits until `writable.write` invokes its callback (chunk accepted / `_write` finished).
+ * 2. If `write()` returned `false` **and** `writable.writableNeedDrain` is still true after the
+ *    callback, waits for `'drain'`.
+ *
+ * We check both: the return value tells us backpressure was signaled; `writableNeedDrain` avoids
+ * awaiting `'drain'` when it already fired before we subscribed (would otherwise hang forever).
+ *
+ * While waiting for `'drain'`, we also race {@link finished} so destroying the writable (e.g. abort)
+ * cannot leave this promise pending forever.
+ */
+export declare function write(writable: Writable, chunk: unknown): Promise<void>;
+//# sourceMappingURL=writable-async-write.d.ts.map

package/dist/utils/writable-async-write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writable-async-write.d.ts","sourceRoot":"","sources":["../../src/utils/writable-async-write.ts"],"names":[],"mappings":";AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAEvC;;;;;;;;;;;;GAYG;AACH,wBAAsB,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAuC7E"}

package/dist/utils/writable-async-write.js

@@ -0,0 +1,61 @@
+'use strict';
+
+var node_events = require('node:events');
+var promises = require('node:stream/promises');
+
+/**
+ * Async helper for application code that `await`s sequential writes to a `Writable`.
+ *
+ * 1. Waits until `writable.write` invokes its callback (chunk accepted / `_write` finished).
+ * 2. If `write()` returned `false` **and** `writable.writableNeedDrain` is still true after the
+ *    callback, waits for `'drain'`.
+ *
+ * We check both: the return value tells us backpressure was signaled; `writableNeedDrain` avoids
+ * awaiting `'drain'` when it already fired before we subscribed (would otherwise hang forever).
+ *
+ * While waiting for `'drain'`, we also race {@link finished} so destroying the writable (e.g. abort)
+ * cannot leave this promise pending forever.
+ */ async function write(writable, chunk) {
+    let flushed = true;
+    await new Promise((resolve, reject)=>{
+        let settled = false;
+        const finish = (fn)=>{
+            if (settled) {
+                return;
+            }
+            settled = true;
+            writable.off('error', onError);
+            fn();
+        };
+        const onError = (err)=>{
+            finish(()=>reject(err));
+        };
+        writable.once('error', onError);
+        flushed = writable.write(chunk, (err)=>{
+            if (err) {
+                // Do not reject or remove `error` here: Node may emit `error` after this callback, and
+                // clearing the listener first would leave that emission unhandled.
+                setImmediate(()=>{
+                    if (!settled) {
+                        finish(()=>reject(err));
+                    }
+                });
+                return;
+            }
+            finish(()=>resolve());
+        });
+    });
+    if (!flushed && writable.writableNeedDrain) {
+        // Without `finished`, awaiting only `drain` can hang forever if the writable is destroyed first.
+        await Promise.race([
+            node_events.once(writable, 'drain'),
+            promises.finished(writable, {
+                readable: false,
+                writable: true
+            })
+        ]);
+    }
+}
+
+exports.write = write;
+//# sourceMappingURL=writable-async-write.js.map

package/dist/utils/writable-async-write.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"writable-async-write.js","sources":["../../src/utils/writable-async-write.ts"],"sourcesContent":["import { once } from 'node:events';\nimport { finished } from 'node:stream/promises';\nimport type { Writable } from 'stream';\n\n/**\n * Async helper for application code that `await`s sequential writes to a `Writable`.\n *\n * 1. Waits until `writable.write` invokes its callback (chunk accepted / `_write` finished).\n * 2. If `write()` returned `false` **and** `writable.writableNeedDrain` is still true after the\n *    callback, waits for `'drain'`.\n *\n * We check both: the return value tells us backpressure was signaled; `writableNeedDrain` avoids\n * awaiting `'drain'` when it already fired before we subscribed (would otherwise hang forever).\n *\n * While waiting for `'drain'`, we also race {@link finished} so destroying the writable (e.g. abort)\n * cannot leave this promise pending forever.\n */\nexport async function write(writable: Writable, chunk: unknown): Promise<void> {\n  let flushed = true;\n\n  await new Promise<void>((resolve, reject) => {\n    let settled = false;\n    const finish = (fn: () => void) => {\n      if (settled) {\n        return;\n      }\n      settled = true;\n      writable.off('error', onError);\n      fn();\n    };\n    const onError = (err: Error) => {\n      finish(() => reject(err));\n    };\n    writable.once('error', onError);\n    flushed = writable.write(chunk, (err) => {\n      if (err) {\n        // Do not reject or remove `error` here: Node may emit `error` after this callback, and\n        // clearing the listener first would leave that emission unhandled.\n        setImmediate(() => {\n          if (!settled) {\n            finish(() => reject(err));\n          }\n        });\n        return;\n      }\n      finish(() => resolve());\n    });\n  });\n\n  if (!flushed && writable.writableNeedDrain) {\n    // Without `finished`, awaiting only `drain` can hang forever if the writable is destroyed first.\n    await Promise.race([\n      once(writable, 'drain'),\n      finished(writable, { readable: false, writable: true }),\n    ]);\n  }\n}\n"],"names":["write","writable","chunk","flushed","Promise","resolve","reject","settled","finish","fn","off","onError","err","once","setImmediate","writableNeedDrain","race","finished","readable"],"mappings":";;;;;AAIA;;;;;;;;;;;;AAYC,IACM,eAAeA,KAAAA,CAAMC,QAAkB,EAAEC,KAAc,EAAA;AAC5D,IAAA,IAAIC,OAAAA,GAAU,IAAA;IAEd,MAAM,IAAIC,OAAAA,CAAc,CAACC,OAAAA,EAASC,MAAAA,GAAAA;AAChC,QAAA,IAAIC,OAAAA,GAAU,KAAA;AACd,QAAA,MAAMC,SAAS,CAACC,EAAAA,GAAAA;AACd,YAAA,IAAIF,OAAAA,EAAS;AACX,gBAAA;AACF,YAAA;YACAA,OAAAA,GAAU,IAAA;YACVN,QAAAA,CAASS,GAAG,CAAC,OAAA,EAASC,OAAAA,CAAAA;AACtBF,YAAAA,EAAAA,EAAAA;AACF,QAAA,CAAA;AACA,QAAA,MAAME,UAAU,CAACC,GAAAA,GAAAA;AACfJ,YAAAA,MAAAA,CAAO,IAAMF,MAAAA,CAAOM,GAAAA,CAAAA,CAAAA;AACtB,QAAA,CAAA;QACAX,QAAAA,CAASY,IAAI,CAAC,OAAA,EAASF,OAAAA,CAAAA;AACvBR,QAAAA,OAAAA,GAAUF,QAAAA,CAASD,KAAK,CAACE,KAAAA,EAAO,CAACU,GAAAA,GAAAA;AAC/B,YAAA,IAAIA,GAAAA,EAAK;;;gBAGPE,YAAAA,CAAa,IAAA;AACX,oBAAA,IAAI,CAACP,OAAAA,EAAS;AACZC,wBAAAA,MAAAA,CAAO,IAAMF,MAAAA,CAAOM,GAAAA,CAAAA,CAAAA;AACtB,oBAAA;AACF,gBAAA,CAAA,CAAA;AACA,gBAAA;AACF,YAAA;AACAJ,YAAAA,MAAAA,CAAO,IAAMH,OAAAA,EAAAA,CAAAA;AACf,QAAA,CAAA,CAAA;AACF,IAAA,CAAA,CAAA;AAEA,IAAA,IAAI,CAACF,OAAAA,IAAWF,QAAAA,CAASc,iBAAiB,EAAE;;QAE1C,MAAMX,OAAAA,CAAQY,IAAI,CAAC;AACjBH,YAAAA,gBAAAA,CAAKZ,QAAAA,EAAU,OAAA,CAAA;AACfgB,YAAAA,iBAAAA,CAAShB,QAAAA,EAAU;gBAAEiB,QAAAA,EAAU,KAAA;gBAAOjB,QAAAA,EAAU;AAAK,aAAA;AACtD,SAAA,CAAA;AACH,IAAA;AACF;;;;"}

package/dist/utils/writable-async-write.mjs

@@ -0,0 +1,59 @@
+import { once } from 'node:events';
+import { finished } from 'node:stream/promises';
+
+/**
+ * Async helper for application code that `await`s sequential writes to a `Writable`.
+ *
+ * 1. Waits until `writable.write` invokes its callback (chunk accepted / `_write` finished).
+ * 2. If `write()` returned `false` **and** `writable.writableNeedDrain` is still true after the
+ *    callback, waits for `'drain'`.
+ *
+ * We check both: the return value tells us backpressure was signaled; `writableNeedDrain` avoids
+ * awaiting `'drain'` when it already fired before we subscribed (would otherwise hang forever).
+ *
+ * While waiting for `'drain'`, we also race {@link finished} so destroying the writable (e.g. abort)
+ * cannot leave this promise pending forever.
+ */ async function write(writable, chunk) {
+    let flushed = true;
+    await new Promise((resolve, reject)=>{
+        let settled = false;
+        const finish = (fn)=>{
+            if (settled) {
+                return;
+            }
+            settled = true;
+            writable.off('error', onError);
+            fn();
+        };
+        const onError = (err)=>{
+            finish(()=>reject(err));
+        };
+        writable.once('error', onError);
+        flushed = writable.write(chunk, (err)=>{
+            if (err) {
+                // Do not reject or remove `error` here: Node may emit `error` after this callback, and
+                // clearing the listener first would leave that emission unhandled.
+                setImmediate(()=>{
+                    if (!settled) {
+                        finish(()=>reject(err));
+                    }
+                });
+                return;
+            }
+            finish(()=>resolve());
+        });
+    });
+    if (!flushed && writable.writableNeedDrain) {
+        // Without `finished`, awaiting only `drain` can hang forever if the writable is destroyed first.
+        await Promise.race([
+            once(writable, 'drain'),
+            finished(writable, {
+                readable: false,
+                writable: true
+            })
+        ]);
+    }
+}
+
+export { write };
+//# sourceMappingURL=writable-async-write.mjs.map

package/dist/utils/writable-async-write.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"writable-async-write.mjs","sources":["../../src/utils/writable-async-write.ts"],"sourcesContent":["import { once } from 'node:events';\nimport { finished } from 'node:stream/promises';\nimport type { Writable } from 'stream';\n\n/**\n * Async helper for application code that `await`s sequential writes to a `Writable`.\n *\n * 1. Waits until `writable.write` invokes its callback (chunk accepted / `_write` finished).\n * 2. If `write()` returned `false` **and** `writable.writableNeedDrain` is still true after the\n *    callback, waits for `'drain'`.\n *\n * We check both: the return value tells us backpressure was signaled; `writableNeedDrain` avoids\n * awaiting `'drain'` when it already fired before we subscribed (would otherwise hang forever).\n *\n * While waiting for `'drain'`, we also race {@link finished} so destroying the writable (e.g. abort)\n * cannot leave this promise pending forever.\n */\nexport async function write(writable: Writable, chunk: unknown): Promise<void> {\n  let flushed = true;\n\n  await new Promise<void>((resolve, reject) => {\n    let settled = false;\n    const finish = (fn: () => void) => {\n      if (settled) {\n        return;\n      }\n      settled = true;\n      writable.off('error', onError);\n      fn();\n    };\n    const onError = (err: Error) => {\n      finish(() => reject(err));\n    };\n    writable.once('error', onError);\n    flushed = writable.write(chunk, (err) => {\n      if (err) {\n        // Do not reject or remove `error` here: Node may emit `error` after this callback, and\n        // clearing the listener first would leave that emission unhandled.\n        setImmediate(() => {\n          if (!settled) {\n            finish(() => reject(err));\n          }\n        });\n        return;\n      }\n      finish(() => resolve());\n    });\n  });\n\n  if (!flushed && writable.writableNeedDrain) {\n    // Without `finished`, awaiting only `drain` can hang forever if the writable is destroyed first.\n    await Promise.race([\n      once(writable, 'drain'),\n      finished(writable, { readable: false, writable: true }),\n    ]);\n  }\n}\n"],"names":["write","writable","chunk","flushed","Promise","resolve","reject","settled","finish","fn","off","onError","err","once","setImmediate","writableNeedDrain","race","finished","readable"],"mappings":";;;AAIA;;;;;;;;;;;;AAYC,IACM,eAAeA,KAAAA,CAAMC,QAAkB,EAAEC,KAAc,EAAA;AAC5D,IAAA,IAAIC,OAAAA,GAAU,IAAA;IAEd,MAAM,IAAIC,OAAAA,CAAc,CAACC,OAAAA,EAASC,MAAAA,GAAAA;AAChC,QAAA,IAAIC,OAAAA,GAAU,KAAA;AACd,QAAA,MAAMC,SAAS,CAACC,EAAAA,GAAAA;AACd,YAAA,IAAIF,OAAAA,EAAS;AACX,gBAAA;AACF,YAAA;YACAA,OAAAA,GAAU,IAAA;YACVN,QAAAA,CAASS,GAAG,CAAC,OAAA,EAASC,OAAAA,CAAAA;AACtBF,YAAAA,EAAAA,EAAAA;AACF,QAAA,CAAA;AACA,QAAA,MAAME,UAAU,CAACC,GAAAA,GAAAA;AACfJ,YAAAA,MAAAA,CAAO,IAAMF,MAAAA,CAAOM,GAAAA,CAAAA,CAAAA;AACtB,QAAA,CAAA;QACAX,QAAAA,CAASY,IAAI,CAAC,OAAA,EAASF,OAAAA,CAAAA;AACvBR,QAAAA,OAAAA,GAAUF,QAAAA,CAASD,KAAK,CAACE,KAAAA,EAAO,CAACU,GAAAA,GAAAA;AAC/B,YAAA,IAAIA,GAAAA,EAAK;;;gBAGPE,YAAAA,CAAa,IAAA;AACX,oBAAA,IAAI,CAACP,OAAAA,EAAS;AACZC,wBAAAA,MAAAA,CAAO,IAAMF,MAAAA,CAAOM,GAAAA,CAAAA,CAAAA;AACtB,oBAAA;AACF,gBAAA,CAAA,CAAA;AACA,gBAAA;AACF,YAAA;AACAJ,YAAAA,MAAAA,CAAO,IAAMH,OAAAA,EAAAA,CAAAA;AACf,QAAA,CAAA,CAAA;AACF,IAAA,CAAA,CAAA;AAEA,IAAA,IAAI,CAACF,OAAAA,IAAWF,QAAAA,CAASc,iBAAiB,EAAE;;QAE1C,MAAMX,OAAAA,CAAQY,IAAI,CAAC;AACjBH,YAAAA,IAAAA,CAAKZ,QAAAA,EAAU,OAAA,CAAA;AACfgB,YAAAA,QAAAA,CAAShB,QAAAA,EAAU;gBAAEiB,QAAAA,EAAU,KAAA;gBAAOjB,QAAAA,EAAU;AAAK,aAAA;AACtD,SAAA,CAAA;AACH,IAAA;AACF;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/data-transfer",
-  "version": "5.42.0",
+  "version": "5.43.0",
   "description": "Data transfer capabilities for Strapi",
   "keywords": [
     "strapi",
@@ -51,15 +51,15 @@
     "watch": "run -T rollup -c -w"
   },
   "dependencies": {
-    "@strapi/logger": "5.42.0",
-    "@strapi/types": "5.42.0",
-    "@strapi/utils": "5.42.0",
+    "@strapi/logger": "5.43.0",
+    "@strapi/types": "5.43.0",
+    "@strapi/utils": "5.43.0",
     "chalk": "4.1.2",
     "cli-table3": "0.6.5",
     "commander": "8.3.0",
     "fs-extra": "11.2.0",
     "inquirer": "9.3.8",
-    "lodash": "4.17.23",
+    "lodash": "4.18.1",
     "ora": "5.4.1",
     "resolve-cwd": "3.0.0",
     "semver": "7.5.4",
@@ -70,7 +70,7 @@
     "ws": "8.17.1"
   },
   "devDependencies": {
-    "@strapi/database": "5.42.0",
+    "@strapi/database": "5.43.0",
     "@types/fs-extra": "11.0.4",
     "@types/jest": "29.5.2",
     "@types/koa": "2.13.4",