diffio 0.1.111 → 0.2.0

package/README.md

@@ -1,6 +1,6 @@
 # Diffio JS SDK
 
-The Diffio JS SDK helps you call the Diffio API from Node. This version covers project creation, upload, generation, progress checks, and download URLs.
+The Diffio JS SDK helps you call the Diffio API from Node. This version covers project creation, edge upload, Diffio 4.5 generations, progress checks, and download URLs.
 
 ## Install
 
@@ -42,9 +42,34 @@ const projects = await client.listProjects({
 });
 ```
 
+## Models
+
+| Model | `model` value | Endpoint | Notes |
+|---|---|---|---|
+| Diffio 4.5 Flash | `diffio-4.5-flash` | `/v1/diffio-4.5-flash-generation` | Default. Fast, high quality speech restoration. |
+| Diffio 4.5 Pro | `diffio-4.5-pro` | `/v1/diffio-4.5-pro-generation` | Best quality. Paid accounts only. |
+
+Omitting `model` uses `diffio-4.5-flash`. Earlier models (`diffio-2`, `diffio-2-flash`, `diffio-3.2`,
+`diffio-3.4`, `diffio-3.5`, `diffio-4.0-flash`, `diffio-4.0-pro`) are retired: the SDK refuses them
+before sending a request, and the API answers their endpoints with HTTP 410 `model_retired`.
+Generations created before a model was retired keep their original `modelKey`, so response
+`modelKey` fields are typed as `string`.
+
 ## Create a project and generation
 
-`createProject` uploads the file and returns the project metadata.
+`createProject` creates the project, uploads the file through Diffio's upload edge, and confirms
+the upload, so the project is ready for a generation when it returns.
+
+The upload follows the session `create_project` returns: the SDK starts a multipart upload at
+`{edgeBaseUrl}/v1/uploads/start`, sends the file in parts of `partSizeBytes` (32 MiB, three at a time)
+to `/v1/uploads/parts/{partNumber}`, completes it with `/v1/uploads/complete`, and then calls
+`/v1/complete_project_upload`. Each part is tried up to four times on network errors, timeouts,
+`408`, `429`, and `5xx` answers. A failed upload is aborted and raises `DiffioUploadError` (a
+`DiffioApiError`) with `uploadErrorCode` (`upload/too-large`, `upload/unauthorized`,
+`upload/rejected`, `upload/network`, `upload/server`, `upload/invalid-response`, or
+`upload/canceled`), the edge's `edgeErrorCode` when it sent one, and the `apiProjectId`. Files
+larger than the session's `maxBytes` (2 GiB) are refused before any bytes are sent. The upload token
+is used only inside the SDK and is not part of the returned project.
 
 ```ts
 import { DiffioClient } from "diffio";
@@ -58,12 +83,19 @@ const project = await client.createProject({
 
 const generation = await client.createGeneration({
   apiProjectId: project.apiProjectId,
-  model: "diffio-4.0-flash",
-  sampling: { steps: 12, guidance: 1.5 },
+  model: "diffio-4.5-flash",
   idempotencyKey: "restore-sample-001"
 });
 
 console.log(generation.generationId, generation.idempotentReplay ?? false);
+console.log(project.upload.objectKey, project.uploadCompletion.sizeBytes);
+```
+
+If `createProject` uploaded the file but the confirmation call failed, confirm it yourself. The call
+is idempotent, and Diffio also records the upload on its own shortly after the edge completes it.
+
+```ts
+await client.projects.completeUpload({ apiProjectId: "proj_123" });
 ```
 
 Reuse the same `idempotencyKey` when retrying generation creation for a project. The API then
@@ -77,11 +109,12 @@ retrying after an uncertain response.
 
 `waitForGeneration` and `generations.waitForComplete` wait for the overall `status` to become
 `complete`. Individual stages reaching 100% or `complete` do not end polling while video publication
-or usage settlement is still pending. For Diffio 2.0, `complete` means restored media is ready;
-transcription can still be `pending`, become `available` later, or finish as `unavailable`.
-Read `progress.transcription?.status` independently. Older responses omit `transcription`;
-absence does not establish availability. Unavailable transcription does not fail completed
-Diffio 2.0 media. Diffio 3.5 requires its transcript before restoration can complete.
+or usage settlement is still pending. They poll for up to 600 seconds unless you pass `timeout`
+or `timeoutInSeconds`. `complete` means restored media is ready. Diffio 4.5 transcribes the recording before
+restoration starts, so a completed generation has its transcript unless transcription finished as
+`unavailable`; while a generation runs, transcription can be `pending`, `available`, or `unavailable`. Read
+`progress.transcription?.status` independently. Older responses omit `transcription`; absence does
+not establish availability. Unavailable transcription does not fail completed media.
 
 ## Audio isolation helper
 
@@ -91,8 +124,7 @@ import { DiffioClient } from "diffio";
 const client = new DiffioClient({ apiKey: "diffio_live_..." });
 const result = await client.audioIsolation.isolate({
   filePath: "sample.wav",
-  model: "diffio-4.0-flash",
-  sampling: { steps: 12, guidance: 1.5 },
+  model: "diffio-4.5-flash",
   idempotencyKey: "restore-sample-001"
 });
 
@@ -113,8 +145,7 @@ import { DiffioClient } from "diffio";
 const client = new DiffioClient({ apiKey: "diffio_live_..." });
 const [audioBytes, info] = await client.restoreAudio({
   filePath: "sample.wav",
-  model: "diffio-4.0-flash",
-  sampling: { steps: 12, guidance: 1.5 },
+  model: "diffio-4.5-flash",
   idempotencyKey: "restore-sample-001",
   onProgress: (progress) => console.log(progress.status)
 });
@@ -139,10 +170,17 @@ const progress = await client.generations.getProgress({
   apiProjectId: "proj_123"
 });
 
-console.log(progress.status);
+console.log(progress.status, progress.stage);
+console.log(progress.queue?.message ?? "not queued");
+console.log(progress.stageProgress?.overallPercent);
 console.log(progress.transcription?.status ?? "not reported");
 ```
 
+`stage` names the one step the generation is in (`pending`, `preparing`, `transcribing`, `queued`,
+`starting`, `downloading`, `decoding`, `restoring`, `finalizing`, `uploading`, `complete`, or
+`failed`). While it waits for a processing worker, `queue` reports its position and why it waits;
+while a worker runs it, `stageProgress` reports percentages and byte counts when known.
+
 ## Generation download
 
 ```ts
@@ -158,6 +196,10 @@ const download = await client.generations.getDownload({
 console.log(download.downloadUrl);
 ```
 
+`downloadUrl` is a signed, time-limited media URL that needs no `Authorization` header. The
+response has `generationId`, `apiProjectId`, `downloadType`, `downloadUrl`, `fileName`,
+`storagePath`, and `mimeType`.
+
 Set `downloadType` to `"transcript"` to fetch the transcript JSON artifact when available.
 Pending transcripts raise `DiffioApiError` with `statusCode === 409` and error code
 `TRANSCRIPT_PENDING`. Unavailable transcripts return `404` with `TRANSCRIPT_UNAVAILABLE`.
@@ -260,9 +302,9 @@ console.log(event.svixMessageId);
 Use the raw request body (not parsed JSON) plus the `svix-*` headers and your webhook signing secret.
 
 Verified events expose the same optional `event.transcription` object as generation progress.
-A Diffio 2.0 `generation.completed` event can report `pending` or `unavailable` transcription.
-Later transcript publication does not emit another completion event; poll progress when you need
-to follow a pending transcript. Older events can omit `transcription`.
+A `generation.completed` event reports `available` transcription, or `unavailable` when no
+transcript could be produced; completion does not wait for a later transcript. Older events can omit
+`transcription`.
 
 ```ts
 import express from "express";
@@ -303,4 +345,5 @@ Examples use ES modules. Save files with a `.mjs` extension or set `"type": "mod
 ```bash
 cd diffio-js
 npm run build
+npm test
 ```

package/dist/Client.d.ts

@@ -1,5 +1,5 @@
 import type { BaseClientOptions, BaseRequestOptions, NormalizedClientOptions } from "./BaseClient";
-import type { AccountSettingsResponse, ApiKeyResponse, ApiKeysListResponse, AudioIsolationResult, CreateGenerationResponse, CreateProjectResponse, GenerationDownloadResponse, GenerationProgressResponse, ListProjectGenerationsResponse, ListProjectsResponse, ModelKey, RestoreMetadata, UsageSummaryResponse, WebhookConfigureResponse, WebhookTestEventResponse } from "./api/types";
+import type { AccountSettingsResponse, ApiKeyResponse, ApiKeysListResponse, AudioIsolationResult, CompleteProjectUploadResponse, CreateGenerationResponse, CreateProjectResponse, GenerationDownloadResponse, GenerationProgressResponse, ListProjectGenerationsResponse, ListProjectsResponse, ModelKey, RestoreMetadata, UsageSummaryResponse, WebhookConfigureResponse, WebhookTestEventResponse } from "./api/types";
 import { AccountClient, ApiKeysClient, AudioIsolationClient, GenerationsClient, ProjectsClient, UsageClient, WebhooksClient } from "./api/resources";
 export declare namespace DiffioClient {
     type Options = BaseClientOptions;
@@ -25,7 +25,16 @@ export declare class DiffioClient {
         fileFormat?: string;
         requestOptions?: DiffioClient.RequestOptions;
     }): Promise<CreateProjectResponse>;
-    private _uploadFile;
+    /**
+     * Confirms that a project's edge upload landed and starts preprocessing. createProject calls it;
+     * call it yourself only to finish an upload whose confirmation failed. It is idempotent.
+     */
+    completeProjectUpload(options: {
+        apiProjectId: string;
+        requestOptions?: DiffioClient.RequestOptions;
+    }): Promise<CompleteProjectUploadResponse>;
+    /** Sends one edge upload call with the session's upload token; never the API key or SDK default headers. */
+    private _sendEdgeUploadRequest;
     /** Retries generation admission only when the caller supplies a nonblank idempotency key. */
     createGeneration(options: {
         apiProjectId: string;
@@ -47,7 +56,7 @@ export declare class DiffioClient {
         apiProjectId?: string;
         requestOptions?: DiffioClient.RequestOptions;
     }): Promise<GenerationProgressResponse>;
-    /** Waits for media completion and settlement. Diffio 2.0 transcription may still be pending or unavailable. */
+    /** Waits for media completion and settlement; transcription may still be pending or unavailable. */
     waitForGeneration(options: {
         generationId: string;
         apiProjectId?: string;

package/dist/Client.js

@@ -40,22 +40,29 @@ const supplier_1 = require("./core/supplier");
 const url_1 = require("./core/url");
 const retry_1 = require("./core/retry");
 const errors_1 = require("./errors");
+const edgeUpload_1 = require("./core/edgeUpload");
 const serialization_1 = require("./api/serialization");
 const resources_1 = require("./api/resources");
 const mime_types_1 = require("mime-types");
 const DEFAULT_BASE_URL = "https://api.diffio.ai";
 const API_PREFIX = "v1";
+/** Generation endpoint for each supported model, as api/model_registry.json in diffio-ui lists them. */
 const MODEL_ENDPOINTS = {
-    "diffio-2": "diffio-2.0-generation",
-    "diffio-2-flash": "diffio-2.0-flash-generation",
-    "diffio-3.4": "diffio-3.4-generation",
-    "diffio-3.5": "diffio-3.5-generation",
-    "diffio-4.0-flash": "diffio-4.0-flash-generation",
-    "diffio-4.0-pro": "diffio-4.0-pro-generation"
+    "diffio-4.5-flash": "diffio-4.5-flash-generation",
+    "diffio-4.5-pro": "diffio-4.5-pro-generation"
 };
+/** The registry's `freeDefault` model; Pro is paid-only, so it cannot be the default for every key. */
+const DEFAULT_MODEL_KEY = "diffio-4.5-flash";
+const SUPPORTED_MODEL_KEYS = Object.keys(MODEL_ENDPOINTS);
+/** Per-request timeout for one edge upload call; a 32 MiB part needs about 1 Mbit/s to finish in time. */
+const DEFAULT_EDGE_UPLOAD_TIMEOUT_SECONDS = 300;
+/** complete_project_upload is idempotent, so it is retried even when the client disables retries by default. */
+const DEFAULT_COMPLETE_UPLOAD_MAX_RETRIES = 3;
 const DEFAULT_RETRY_STATUS_CODES = [408, 429, 500, 502, 503, 504];
 const DEFAULT_RETRY_BACKOFF = 0.5;
 const DEFAULT_TIMEOUT_SECONDS = 60;
+/** How long waitForGeneration polls by default; fleet generations can queue and run for minutes (matches the Python SDK). */
+const DEFAULT_GENERATION_WAIT_TIMEOUT_SECONDS = 600;
 const WEBHOOK_EVENT_TYPES = [
     "generation.queued",
     "generation.processing",
@@ -107,45 +114,75 @@ class DiffioClient {
             payload.fileFormat = fileFormat;
         }
         const response = await this._requestJson("POST", "create_project", payload, requestOptions);
-        const project = (0, serialization_1.parseCreateProjectResponse)(response);
-        await this._uploadFile({
-            uploadUrl: project.uploadUrl,
-            uploadMethod: project.uploadMethod,
-            filePath,
-            contentType: resolvedContentType,
-            requestOptions
-        });
-        return project;
-    }
-    async _uploadFile(options) {
-        const { uploadUrl, uploadMethod, filePath, data, contentType, requestOptions } = options;
-        if ((filePath == null) === (data == null)) {
-            throw new errors_1.DiffioApiError("Provide filePath or data");
+        const apiProjectId = typeof response?.apiProjectId === "string" ? response.apiProjectId : undefined;
+        const session = (0, edgeUpload_1.parseEdgeUploadSession)(response?.upload);
+        if (!apiProjectId || !session) {
+            throw new errors_1.DiffioUploadError("upload/invalid-response", "create_project did not return an upload session (apiProjectId and upload are required).", { responseBody: response, apiProjectId });
+        }
+        try {
+            const sizeBytes = getFileSize(filePath);
+            const fileHandle = await openFileForReading(filePath);
+            try {
+                await (0, edgeUpload_1.uploadProjectMediaToEdge)({
+                    session,
+                    sizeBytes,
+                    readPartBytes: (startByte, endByte) => readFileBytes(fileHandle, startByte, endByte),
+                    sendEdgeRequest: (request) => this._sendEdgeUploadRequest(request, requestOptions)
+                });
+            }
+            finally {
+                await fileHandle.close();
+            }
         }
-        let resolvedContentType = contentType;
-        if (!resolvedContentType && filePath) {
-            const guessed = (0, mime_types_1.lookup)(filePath);
-            resolvedContentType = typeof guessed === "string" ? guessed : undefined;
+        catch (error) {
+            if (error instanceof errors_1.DiffioUploadError) {
+                error.apiProjectId = error.apiProjectId ?? apiProjectId;
+            }
+            throw error;
         }
-        if (!resolvedContentType) {
-            resolvedContentType = "application/octet-stream";
+        const uploadCompletion = await this.completeProjectUpload({ apiProjectId, requestOptions });
+        return (0, serialization_1.createProjectUploadResult)(response, session, uploadCompletion);
+    }
+    /**
+     * Confirms that a project's edge upload landed and starts preprocessing. createProject calls it;
+     * call it yourself only to finish an upload whose confirmation failed. It is idempotent.
+     */
+    async completeProjectUpload(options) {
+        const { apiProjectId, requestOptions } = options;
+        if (!apiProjectId) {
+            throw new errors_1.DiffioApiError("apiProjectId is required");
         }
-        const method = (uploadMethod || "PUT").toUpperCase();
-        const extraHeaders = {
-            "Content-Type": resolvedContentType
+        const completeRequestOptions = {
+            ...requestOptions,
+            maxRetries: requestOptions?.maxRetries ?? this._options.maxRetries ?? DEFAULT_COMPLETE_UPLOAD_MAX_RETRIES
         };
-        if (isStorageEmulatorUrl(uploadUrl)) {
-            extraHeaders.Authorization = "Bearer owner";
+        const response = await this._requestJson("POST", "complete_project_upload", { apiProjectId }, completeRequestOptions);
+        return (0, serialization_1.parseCompleteProjectUploadResponse)(response);
+    }
+    /** Sends one edge upload call with the session's upload token; never the API key or SDK default headers. */
+    async _sendEdgeUploadRequest(request, requestOptions) {
+        const fetchFn = this._options.fetch ?? globalThis.fetch;
+        if (!fetchFn) {
+            throw new errors_1.DiffioApiError("fetch is not available in this runtime");
         }
-        const bodyFactory = filePath ? () => createFileReadStream(filePath) : () => data;
-        await this._requestBinary(method, uploadUrl, bodyFactory, requestOptions, extraHeaders, true);
+        const timeoutSeconds = requestOptions?.timeoutInSeconds ?? requestOptions?.timeout ?? DEFAULT_EDGE_UPLOAD_TIMEOUT_SECONDS;
+        // A Uint8Array or string body has a known length, so fetch sends the Content-Length the edge requires.
+        const response = await fetchWithTimeout(fetchFn, request.url, {
+            method: request.method,
+            headers: {
+                Authorization: `Bearer ${request.bearerToken}`,
+                "Content-Type": request.contentType
+            },
+            body: request.body
+        }, timeoutSeconds * 1000, requestOptions?.abortSignal);
+        return { status: response.status, bodyText: await response.text() };
     }
     /** Retries generation admission only when the caller supplies a nonblank idempotency key. */
     async createGeneration(options) {
-        const { apiProjectId, model = "diffio-4.0-flash", sampling, params, idempotencyKey, requestOptions } = options;
-        const endpoint = MODEL_ENDPOINTS[model];
+        const { apiProjectId, model = DEFAULT_MODEL_KEY, sampling, params, idempotencyKey, requestOptions } = options;
+        const endpoint = Object.prototype.hasOwnProperty.call(MODEL_ENDPOINTS, model) ? MODEL_ENDPOINTS[model] : undefined;
         if (!endpoint) {
-            throw new errors_1.DiffioApiError(`Unsupported model: ${model}`);
+            throw new errors_1.DiffioApiError(`Unsupported model: ${model}. Use ${SUPPORTED_MODEL_KEYS.join(" or ")}.`);
         }
         const payload = { apiProjectId };
         if (sampling != null) {
@@ -184,10 +221,10 @@ class DiffioClient {
         const response = await this._requestJson("POST", "get_generation_progress", payload, requestOptions);
         return (0, serialization_1.parseGenerationProgressResponse)(response);
     }
-    /** Waits for media completion and settlement. Diffio 2.0 transcription may still be pending or unavailable. */
+    /** Waits for media completion and settlement; transcription may still be pending or unavailable. */
     async waitForGeneration(options) {
         const { generationId, apiProjectId, pollInterval = 2, timeout, timeoutInSeconds, onProgress, showProgress, requestOptions } = options;
-        const timeoutSeconds = timeoutInSeconds ?? timeout ?? DEFAULT_TIMEOUT_SECONDS;
+        const timeoutSeconds = timeoutInSeconds ?? timeout ?? DEFAULT_GENERATION_WAIT_TIMEOUT_SECONDS;
         const deadline = Date.now() + timeoutSeconds * 1000;
         let lastProgress = null;
         while (Date.now() < deadline) {
@@ -450,11 +487,8 @@ class DiffioClient {
         return (0, serialization_1.createAudioIsolationResult)(project, generation);
     }
     async _downloadBinary(downloadUrl, requestOptions) {
-        const extraHeaders = {};
-        if (isStorageEmulatorUrl(downloadUrl)) {
-            extraHeaders.Authorization = "Bearer owner";
-        }
-        const response = await this._requestBinary("GET", downloadUrl, () => undefined, requestOptions, extraHeaders, true);
+        // The download URL is a signed edge media URL; it needs no Authorization header.
+        const response = await this._requestBinary("GET", downloadUrl, () => undefined, requestOptions, {}, true);
         return response;
     }
     async _requestJson(method, path, payload, requestOptions) {
@@ -636,9 +670,12 @@ async function parseErrorResponse(response) {
 }
 function getErrorMessage(body, status) {
     if (body && typeof body === "object" && "error" in body) {
-        const message = body.error;
-        if (message) {
-            return String(message);
+        const error = body.error;
+        if (error && typeof error === "object" && typeof error.message === "string") {
+            return error.message;
+        }
+        if (error) {
+            return String(error);
         }
     }
     return `Request failed with status ${status}`;
@@ -657,36 +694,6 @@ function guessContentType(filePath) {
     }
     return undefined;
 }
-function isStorageEmulatorUrl(url) {
-    try {
-        const parsed = new URL(url);
-        const host = parsed.hostname.toLowerCase();
-        const port = parsed.port ? Number(parsed.port) : parsed.protocol === "https:" ? 443 : 80;
-        if (["127.0.0.1", "localhost", "0.0.0.0", "::1"].includes(host)) {
-            if (!parsed.port || port === 9199) {
-                return true;
-            }
-        }
-        const envHost = typeof process !== "undefined"
-            ? process.env.STORAGE_EMULATOR_HOST || process.env.FIREBASE_STORAGE_EMULATOR_HOST
-            : undefined;
-        if (!envHost) {
-            return false;
-        }
-        const normalized = envHost.startsWith("http://") || envHost.startsWith("https://") ? envHost : `http://${envHost}`;
-        const emulatorParsed = new URL(normalized);
-        const emulatorHost = emulatorParsed.hostname.toLowerCase();
-        const emulatorPort = emulatorParsed.port
-            ? Number(emulatorParsed.port)
-            : emulatorParsed.protocol === "https:"
-                ? 443
-                : 80;
-        return host === emulatorHost && port === emulatorPort;
-    }
-    catch {
-        return false;
-    }
-}
 function isNodeReadable(value) {
     return Boolean(value) && typeof value === "object" && typeof value.pipe === "function";
 }
@@ -698,14 +705,23 @@ function destroyNodeReadable(value) {
         destroy.call(value);
     }
 }
-async function createFileReadStream(filePath) {
-    const fs = await Promise.resolve().then(() => __importStar(require("node:fs")));
-    const stream = fs.createReadStream(filePath);
-    await new Promise((resolve, reject) => {
-        stream.once("open", () => resolve());
-        stream.once("error", reject);
-    });
-    return stream;
+async function openFileForReading(filePath) {
+    const fs = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
+    return fs.open(filePath, "r");
+}
+/** Reads bytes [startByte, endByte) of an open file into one buffer, looping over short reads. */
+async function readFileBytes(fileHandle, startByte, endByte) {
+    const length = endByte - startByte;
+    const buffer = Buffer.alloc(length);
+    let offset = 0;
+    while (offset < length) {
+        const { bytesRead } = await fileHandle.read(buffer, offset, length - offset, startByte + offset);
+        if (bytesRead === 0) {
+            throw new errors_1.DiffioUploadError("upload/invalid-response", "The file became shorter while it was uploading.");
+        }
+        offset += bytesRead;
+    }
+    return buffer;
 }
 function getFileSize(filePath) {
     const fs = require("node:fs");

package/dist/api/resources/projects/client/Client.d.ts

@@ -1,5 +1,5 @@
 import type { DiffioClient } from "../../../../Client";
-import type { ListProjectGenerationsResponse, ListProjectsResponse } from "../../../types";
+import type { CompleteProjectUploadResponse, ListProjectGenerationsResponse, ListProjectsResponse } from "../../../types";
 export interface ProjectsListOptions {
     requestOptions?: DiffioClient.RequestOptions;
 }
@@ -7,9 +7,15 @@ export interface ProjectsListGenerationsOptions {
     apiProjectId: string;
     requestOptions?: DiffioClient.RequestOptions;
 }
+export interface ProjectsCompleteUploadOptions {
+    apiProjectId: string;
+    requestOptions?: DiffioClient.RequestOptions;
+}
 export declare class ProjectsClient {
     private _parent;
     constructor(parent: DiffioClient);
     list(options?: ProjectsListOptions): Promise<ListProjectsResponse>;
+    /** Confirms a finished edge upload and starts preprocessing; createProject already does this. */
+    completeUpload(options: ProjectsCompleteUploadOptions): Promise<CompleteProjectUploadResponse>;
     listGenerations(options: ProjectsListGenerationsOptions): Promise<ListProjectGenerationsResponse>;
 }

package/dist/api/resources/projects/client/Client.js

@@ -8,6 +8,10 @@ class ProjectsClient {
     async list(options = {}) {
         return this._parent.listProjects(options);
     }
+    /** Confirms a finished edge upload and starts preprocessing; createProject already does this. */
+    async completeUpload(options) {
+        return this._parent.completeProjectUpload(options);
+    }
     async listGenerations(options) {
         return this._parent.listProjectGenerations(options);
     }

package/dist/api/serialization.d.ts

@@ -1,5 +1,8 @@
-import type { AccountSettingsResponse, ApiKeyResponse, ApiKeysListResponse, AudioIsolationResult, CreateGenerationResponse, CreateProjectResponse, GenerationWebhookEvent, GenerationDownloadResponse, GenerationProgressResponse, GenerationProgressStage, ListProjectGenerationsResponse, ListProjectsResponse, ProjectGenerationSummary, ProjectSummary, UsageSummaryResponse, WebhookConfigureResponse, WebhookTestEventResponse } from "./types";
-export declare function parseCreateProjectResponse(data: any): CreateProjectResponse;
+import type { EdgeUploadSession } from "../core/edgeUpload";
+import type { AccountSettingsResponse, ApiKeyResponse, ApiKeysListResponse, AudioIsolationResult, CompleteProjectUploadResponse, CreateGenerationResponse, CreateProjectResponse, GenerationWebhookEvent, GenerationDownloadResponse, GenerationProgressResponse, GenerationProgressStage, ListProjectGenerationsResponse, ListProjectsResponse, ProjectGenerationSummary, ProjectSummary, UsageSummaryResponse, WebhookConfigureResponse, WebhookTestEventResponse } from "./types";
+/** Builds the public createProject result; it omits the upload token, which can still overwrite the upload. */
+export declare function createProjectUploadResult(data: any, session: EdgeUploadSession, uploadCompletion: CompleteProjectUploadResponse): CreateProjectResponse;
+export declare function parseCompleteProjectUploadResponse(data: any): CompleteProjectUploadResponse;
 export declare function parseProjectSummary(data: any): ProjectSummary;
 export declare function parseListProjectsResponse(data: any): ListProjectsResponse;
 export declare function parseCreateGenerationResponse(data: any): CreateGenerationResponse;

package/dist/api/serialization.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseCreateProjectResponse = parseCreateProjectResponse;
+exports.createProjectUploadResult = createProjectUploadResult;
+exports.parseCompleteProjectUploadResponse = parseCompleteProjectUploadResponse;
 exports.parseProjectSummary = parseProjectSummary;
 exports.parseListProjectsResponse = parseListProjectsResponse;
 exports.parseCreateGenerationResponse = parseCreateGenerationResponse;
@@ -17,14 +18,30 @@ exports.parseUsageSummaryResponse = parseUsageSummaryResponse;
 exports.parseWebhookConfigureResponse = parseWebhookConfigureResponse;
 exports.parseGenerationWebhookEvent = parseGenerationWebhookEvent;
 exports.createAudioIsolationResult = createAudioIsolationResult;
-function parseCreateProjectResponse(data) {
+/** Builds the public createProject result; it omits the upload token, which can still overwrite the upload. */
+function createProjectUploadResult(data, session, uploadCompletion) {
+    const upload = {
+        uploadSessionId: session.uploadSessionId,
+        edgeBaseUrl: session.edgeBaseUrl,
+        objectKey: session.objectKey,
+        partSizeBytes: session.partSizeBytes,
+        maxBytes: session.maxBytes,
+        expiresAt: session.expiresAt
+    };
     return {
         apiProjectId: data.apiProjectId,
-        uploadUrl: data.uploadUrl,
-        uploadMethod: data.uploadMethod || "PUT",
-        objectPath: data.objectPath,
-        bucket: data.bucket,
-        expiresAt: data.expiresAt
+        upload,
+        objectPath: data.objectPath ?? session.objectKey,
+        expiresAt: data.expiresAt ?? session.expiresAt,
+        uploadCompletion
+    };
+}
+function parseCompleteProjectUploadResponse(data) {
+    const sizeBytes = data?.sizeBytes;
+    return {
+        apiProjectId: data?.apiProjectId,
+        status: data?.status ?? "uploaded",
+        sizeBytes: typeof sizeBytes === "number" ? sizeBytes : null
     };
 }
 function parseProjectSummary(data) {
@@ -86,6 +103,8 @@ function parseGenerationProgressStage(data) {
 function parseGenerationProgressResponse(data) {
     const restoredVideo = data?.restoredVideo;
     const transcription = parseGenerationTranscription(data?.transcription);
+    const stageProgress = parseGenerationStageProgress(data?.stageProgress);
+    const queue = parseGenerationQueueStatus(data?.queue);
     return {
         generationId: data.generationId,
         apiProjectId: data.apiProjectId,
@@ -94,6 +113,9 @@ function parseGenerationProgressResponse(data) {
         preProcessing: parseGenerationProgressStage(data.preProcessing),
         inference: parseGenerationProgressStage(data.inference),
         restoredVideo: restoredVideo ? parseGenerationProgressStage(restoredVideo) : null,
+        ...(typeof data?.stage === "string" ? { stage: data.stage } : {}),
+        ...(stageProgress ? { stageProgress } : {}),
+        ...(queue ? { queue } : {}),
         ...(transcription ? { transcription } : {}),
         error: data.error ?? null,
         errorDetails: data.errorDetails ?? null
@@ -107,7 +129,6 @@ function parseGenerationDownloadResponse(data) {
         downloadUrl: data.downloadUrl,
         fileName: data.fileName,
         storagePath: data.storagePath,
-        bucket: data.bucket,
         mimeType: data.mimeType
     };
 }
@@ -175,6 +196,42 @@ function parseGenerationWebhookEvent(data) {
         errorDetails: data.errorDetails ?? null
     };
 }
+const optionalNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+function parseGenerationStageProgress(data) {
+    if (data == null || typeof data !== "object" || Array.isArray(data)) {
+        return undefined;
+    }
+    const source = data;
+    const progress = {};
+    for (const key of [
+        "overallPercent",
+        "stagePercent",
+        "bytesDone",
+        "bytesTotal",
+        "availableThroughSeconds",
+        "durationSeconds"
+    ]) {
+        const value = optionalNumber(source[key]);
+        if (value != null) {
+            progress[key] = value;
+        }
+    }
+    return progress;
+}
+function parseGenerationQueueStatus(data) {
+    if (data == null || typeof data !== "object" || Array.isArray(data)) {
+        return undefined;
+    }
+    const source = data;
+    return {
+        position: optionalNumber(source.position),
+        connectedWorkers: optionalNumber(source.connectedWorkers),
+        idleWorkers: optionalNumber(source.idleWorkers),
+        busyWorkers: optionalNumber(source.busyWorkers),
+        waitReason: typeof source.waitReason === "string" ? source.waitReason : null,
+        message: typeof source.message === "string" ? source.message : ""
+    };
+}
 function parseGenerationTranscription(data) {
     if (data == null || typeof data !== "object" || !("status" in data)) {
         return undefined;

package/dist/api/types.d.ts

@@ -1,4 +1,5 @@
-export type ModelKey = "diffio-2" | "diffio-2-flash" | "diffio-3.4" | "diffio-3.5" | "diffio-4.0-flash" | "diffio-4.0-pro";
+/** Models new generations can use (api/model_registry.json in diffio-ui); each has its own endpoint. */
+export type ModelKey = "diffio-4.5-flash" | "diffio-4.5-pro";
 export type DownloadType = "audio" | "video" | "transcript";
 export type WebhookMode = "test" | "live";
 export type WebhookEventType = "generation.queued" | "generation.processing" | "generation.failed" | "generation.completed";
@@ -7,13 +8,28 @@ export type TranscriptionStatus = "pending" | "available" | "unavailable";
 export interface GenerationTranscription {
     status: TranscriptionStatus;
 }
+/** The edge upload session create_project opened; the upload token stays inside the SDK. */
+export interface ProjectUploadSession {
+    uploadSessionId: string;
+    edgeBaseUrl: string;
+    objectKey: string;
+    partSizeBytes: number;
+    maxBytes: number;
+    expiresAt: string;
+}
+/** Response of `/v1/complete_project_upload`; repeated calls return the same answer. */
+export interface CompleteProjectUploadResponse {
+    apiProjectId: string;
+    status: "uploaded" | string;
+    sizeBytes: number | null;
+}
+/** A created project whose media `createProject` already uploaded through the edge and confirmed. */
 export interface CreateProjectResponse {
     apiProjectId: string;
-    uploadUrl: string;
-    uploadMethod: string;
+    upload: ProjectUploadSession;
     objectPath: string;
-    bucket: string;
     expiresAt: string;
+    uploadCompletion: CompleteProjectUploadResponse;
 }
 export interface ProjectSummary {
     apiProjectId: string;
@@ -31,14 +47,16 @@ export interface ListProjectsResponse {
 export interface CreateGenerationResponse {
     generationId: string;
     apiProjectId: string;
-    modelKey: ModelKey | string;
+    /** A string because generations created before a model was retired keep their original key. */
+    modelKey: string;
     status: string;
     idempotentReplay?: boolean;
 }
 export interface ProjectGenerationSummary {
     generationId: string;
     status: string;
-    modelKey?: ModelKey | string | null;
+    /** Older generations keep the key of the model that produced them. */
+    modelKey?: string | null;
     progress?: number | null;
     createdAt?: string | null;
     updatedAt?: string | null;
@@ -56,6 +74,26 @@ export interface GenerationProgressStage {
     error?: string | null;
     errorDetails?: string | null;
 }
+/** The one stage a generation is in, as `get_generation_progress` reports it. */
+export type GenerationStage = "pending" | "preparing" | "transcribing" | "queued" | "starting" | "downloading" | "decoding" | "restoring" | "finalizing" | "uploading" | "complete" | "failed";
+/** Progress within the current fleet stage; every field is optional and present only when known. */
+export interface GenerationStageProgress {
+    overallPercent?: number;
+    stagePercent?: number;
+    bytesDone?: number;
+    bytesTotal?: number;
+    availableThroughSeconds?: number;
+    durationSeconds?: number;
+}
+/** Why a queued generation waits for a Mac fleet worker. */
+export interface GenerationQueueStatus {
+    position: number | null;
+    connectedWorkers: number | null;
+    idleWorkers: number | null;
+    busyWorkers: number | null;
+    waitReason: "all_busy" | "no_workers" | "next_in_line" | string | null;
+    message: string;
+}
 export interface GenerationProgressResponse {
     generationId: string;
     apiProjectId: string;
@@ -64,6 +102,12 @@ export interface GenerationProgressResponse {
     preProcessing: GenerationProgressStage;
     inference: GenerationProgressStage;
     restoredVideo?: GenerationProgressStage | null;
+    /** Omitted by older API versions. */
+    stage?: GenerationStage | string;
+    /** Present while a fleet stage reports progress. */
+    stageProgress?: GenerationStageProgress;
+    /** Present while the generation waits in the fleet queue. */
+    queue?: GenerationQueueStatus;
     /** Independent of media completion; omitted by older API versions. */
     transcription?: GenerationTranscription;
     error?: string | null;
@@ -76,7 +120,6 @@ export interface GenerationDownloadResponse {
     downloadUrl: string;
     fileName: string;
     storagePath: string;
-    bucket: string;
     mimeType: string;
 }
 export interface AudioIsolationResult {
@@ -128,8 +171,9 @@ export interface GenerationWebhookEvent {
     generationId: string;
     status: GenerationWebhookStatus | string;
     hasVideo?: boolean | null;
-    modelKey?: ModelKey | string | null;
-    /** A completed Diffio 2.0 generation may still have a pending or unavailable transcript. */
+    /** Older generations keep the key of the model that produced them. */
+    modelKey?: string | null;
+    /** A completed generation may still have a pending or unavailable transcript. */
     transcription?: GenerationTranscription;
     error?: string | null;
     errorDetails?: string | null;

package/dist/core/edgeUpload.d.ts

@@ -0,0 +1,62 @@
+import { DiffioUploadError } from "../errors";
+/** The upload session create_project returns; `uploadToken` authorizes edge calls for this one object. */
+export interface EdgeUploadSession {
+    uploadSessionId: string;
+    edgeBaseUrl: string;
+    uploadToken: string;
+    objectKey: string;
+    partSizeBytes: number;
+    maxBytes: number;
+    expiresAt: string;
+}
+/** One planned multipart part: bytes [startByte, endByte) of the file. */
+export interface EdgeUploadPartPlan {
+    partNumber: number;
+    startByte: number;
+    endByte: number;
+}
+/** A finished part as the edge acknowledges it, replayed on completion. */
+export interface EdgeUploadPartReceipt {
+    partNumber: number;
+    etag: string;
+}
+/** The edge's answer to `POST /v1/uploads/complete`. */
+export interface EdgeUploadCompletion {
+    objectKey: string;
+    sizeBytes: number;
+    etag: string;
+}
+/** One HTTP request to the edge; the body is a fixed-length buffer because parts need a Content-Length. */
+export interface EdgeUploadHttpRequest {
+    method: "POST" | "PUT";
+    url: string;
+    bearerToken: string;
+    body: Uint8Array | string;
+    contentType: string;
+}
+/** The edge's answer to one request. Transport failures are thrown instead. */
+export interface EdgeUploadHttpResponse {
+    status: number;
+    bodyText: string;
+}
+/** Inputs for one upload of a project's original media through the edge. */
+export interface EdgeUploadOptions {
+    session: EdgeUploadSession;
+    sizeBytes: number;
+    /** Reads bytes [startByte, endByte) of the media; called once per part. */
+    readPartBytes: (startByte: number, endByte: number) => Promise<Uint8Array>;
+    sendEdgeRequest: (request: EdgeUploadHttpRequest) => Promise<EdgeUploadHttpResponse>;
+    partConcurrency?: number;
+    maxAttempts?: number;
+    sleep?: (delayMs: number) => Promise<void>;
+}
+/** Splits a file into fixed-size parts numbered from 1; an empty file is one empty part. */
+export declare function planEdgeUploadParts(sizeBytes: number, partSizeBytes: number): EdgeUploadPartPlan[];
+/** Backoff before retry `attempt` (2 = first retry): 1 s, 2 s, 4 s, capped at 8 s. */
+export declare function resolveEdgeUploadRetryDelayMs(attempt: number): number;
+/** Validates the `upload` object of a create_project response; null when it is missing or incomplete. */
+export declare function parseEdgeUploadSession(value: unknown): EdgeUploadSession | null;
+/** Classifies a non-2xx edge response (`{"error": {"code", "message"}}`) as a typed upload error. */
+export declare function classifyEdgeUploadResponse(response: EdgeUploadHttpResponse): DiffioUploadError;
+/** Uploads media through the edge in parts and completes the multipart object; the caller then confirms it. */
+export declare function uploadProjectMediaToEdge(options: EdgeUploadOptions): Promise<EdgeUploadCompletion>;

package/dist/core/edgeUpload.js

@@ -0,0 +1,213 @@
+"use strict";
+// Client for the edge Worker upload API ("Uploads" in diffio-ui specs/MacFleetArchitecture.md).
+// create_project opens the session and owns every auth decision; the edge only checks the
+// session's upload token and streams fixed-size parts into R2. The flow mirrors the web app's
+// uploader (diffio-ui app/services/edgeUploads.ts): start, PUT parts numbered from 1 with up to
+// four attempts each, complete with the sorted receipts, and abort on a fatal failure.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planEdgeUploadParts = planEdgeUploadParts;
+exports.resolveEdgeUploadRetryDelayMs = resolveEdgeUploadRetryDelayMs;
+exports.parseEdgeUploadSession = parseEdgeUploadSession;
+exports.classifyEdgeUploadResponse = classifyEdgeUploadResponse;
+exports.uploadProjectMediaToEdge = uploadProjectMediaToEdge;
+const errors_1 = require("../errors");
+const DEFAULT_EDGE_UPLOAD_PART_CONCURRENCY = 3;
+const DEFAULT_EDGE_UPLOAD_MAX_ATTEMPTS = 4;
+const defaultSleep = (delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs));
+const isUnknownRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+/** Splits a file into fixed-size parts numbered from 1; an empty file is one empty part. */
+function planEdgeUploadParts(sizeBytes, partSizeBytes) {
+    if (!Number.isSafeInteger(sizeBytes) || sizeBytes < 0)
+        throw new Error("sizeBytes must be a non-negative integer");
+    if (!Number.isSafeInteger(partSizeBytes) || partSizeBytes <= 0) {
+        throw new Error("partSizeBytes must be a positive integer");
+    }
+    if (sizeBytes === 0)
+        return [{ partNumber: 1, startByte: 0, endByte: 0 }];
+    const parts = [];
+    for (let startByte = 0, partNumber = 1; startByte < sizeBytes; startByte += partSizeBytes, partNumber += 1) {
+        parts.push({ partNumber, startByte, endByte: Math.min(sizeBytes, startByte + partSizeBytes) });
+    }
+    return parts;
+}
+/** Backoff before retry `attempt` (2 = first retry): 1 s, 2 s, 4 s, capped at 8 s. */
+function resolveEdgeUploadRetryDelayMs(attempt) {
+    return Math.min(8000, 1000 * 2 ** Math.max(0, attempt - 2));
+}
+/** Validates the `upload` object of a create_project response; null when it is missing or incomplete. */
+function parseEdgeUploadSession(value) {
+    if (!isUnknownRecord(value))
+        return null;
+    const { uploadSessionId, uploadToken, edgeBaseUrl, objectKey, partSizeBytes, maxBytes, expiresAt } = value;
+    if (typeof uploadSessionId !== "string" || !uploadSessionId ||
+        typeof uploadToken !== "string" || !uploadToken ||
+        typeof edgeBaseUrl !== "string" || !/^https?:\/\//i.test(edgeBaseUrl) ||
+        typeof objectKey !== "string" || !objectKey ||
+        typeof partSizeBytes !== "number" || !Number.isSafeInteger(partSizeBytes) || partSizeBytes <= 0 ||
+        typeof maxBytes !== "number" || !Number.isSafeInteger(maxBytes) || maxBytes <= 0) {
+        return null;
+    }
+    return {
+        uploadSessionId,
+        uploadToken,
+        edgeBaseUrl: edgeBaseUrl.replace(/\/+$/, ""),
+        objectKey,
+        partSizeBytes,
+        maxBytes,
+        expiresAt: typeof expiresAt === "string" ? expiresAt : ""
+    };
+}
+const parseJsonBody = (bodyText) => {
+    try {
+        const parsed = JSON.parse(bodyText);
+        return isUnknownRecord(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+};
+/** Classifies a non-2xx edge response (`{"error": {"code", "message"}}`) as a typed upload error. */
+function classifyEdgeUploadResponse(response) {
+    const body = parseJsonBody(response.bodyText);
+    const error = isUnknownRecord(body.error) ? body.error : {};
+    const message = typeof error.message === "string" && error.message
+        ? error.message
+        : `Upload failed with HTTP ${response.status}`;
+    const edgeErrorCode = typeof error.code === "string" ? error.code : undefined;
+    const responseBody = Object.keys(body).length > 0 ? body : response.bodyText || null;
+    const base = { statusCode: response.status, responseBody, edgeErrorCode };
+    let code = "upload/rejected";
+    let retryable = false;
+    if (response.status === 413)
+        code = "upload/too-large";
+    else if (response.status === 401 || response.status === 403)
+        code = "upload/unauthorized";
+    else if (response.status === 408 || response.status === 429 || response.status >= 500) {
+        code = "upload/server";
+        retryable = true;
+    }
+    return new errors_1.DiffioUploadError(code, message, { ...base, retryable });
+}
+const isAbortError = (error) => isUnknownRecord(error) && error.name === "AbortError";
+/** Turns a thrown transport failure into an upload error; caller aborts are final, other failures retryable. */
+function toEdgeUploadError(error) {
+    if (error instanceof errors_1.DiffioUploadError)
+        return error;
+    if (isAbortError(error) || (error instanceof Error && error.name === "AbortError")) {
+        return new errors_1.DiffioUploadError("upload/canceled", "Upload was canceled.");
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return new errors_1.DiffioUploadError("upload/network", message || "Network error during upload", { retryable: true });
+}
+/** Uploads media through the edge in parts and completes the multipart object; the caller then confirms it. */
+async function uploadProjectMediaToEdge(options) {
+    const { session, sizeBytes, readPartBytes, sendEdgeRequest } = options;
+    const sleep = options.sleep ?? defaultSleep;
+    const concurrency = Math.max(1, options.partConcurrency ?? DEFAULT_EDGE_UPLOAD_PART_CONCURRENCY);
+    const maxAttempts = Math.max(1, options.maxAttempts ?? DEFAULT_EDGE_UPLOAD_MAX_ATTEMPTS);
+    if (sizeBytes > session.maxBytes) {
+        throw new errors_1.DiffioUploadError("upload/too-large", `This file is ${sizeBytes} bytes; the upload limit is ${session.maxBytes} bytes.`);
+    }
+    const sendOnce = async (request) => {
+        let response;
+        try {
+            response = await sendEdgeRequest({ ...request, bearerToken: session.uploadToken });
+        }
+        catch (error) {
+            throw toEdgeUploadError(error);
+        }
+        if (response.status < 200 || response.status >= 300)
+            throw classifyEdgeUploadResponse(response);
+        return parseJsonBody(response.bodyText);
+    };
+    // Set by the first part that fails for good; the other lanes then stop instead of retrying.
+    let fatalError = null;
+    // Start, parts, and complete are all safe to repeat: a repeated start only opens a fresh
+    // multipart upload, and the edge answers a repeated complete from the stored object.
+    const sendWithRetries = async (describe, readResult) => {
+        for (let attempt = 1;; attempt += 1) {
+            try {
+                return readResult(await sendOnce(await describe()));
+            }
+            catch (error) {
+                const uploadError = toEdgeUploadError(error);
+                if (fatalError || !uploadError.retryable || attempt >= maxAttempts)
+                    throw fatalError ?? uploadError;
+                await sleep(resolveEdgeUploadRetryDelayMs(attempt + 1));
+            }
+        }
+    };
+    const jsonRequest = (path, body) => ({
+        method: "POST",
+        url: `${session.edgeBaseUrl}${path}`,
+        body: JSON.stringify(body),
+        contentType: "application/json"
+    });
+    const started = await sendWithRetries(() => jsonRequest("/v1/uploads/start", {}), (body) => {
+        if (typeof body.uploadId !== "string" || !body.uploadId) {
+            throw new errors_1.DiffioUploadError("upload/invalid-response", "The edge did not return an uploadId.");
+        }
+        const partSizeBytes = typeof body.partSizeBytes === "number" && Number.isSafeInteger(body.partSizeBytes) &&
+            body.partSizeBytes > 0
+            ? body.partSizeBytes
+            : session.partSizeBytes;
+        return { uploadId: body.uploadId, partSizeBytes };
+    });
+    const { uploadId } = started;
+    const parts = planEdgeUploadParts(sizeBytes, started.partSizeBytes);
+    const pending = [...parts];
+    const receipts = [];
+    const uploadPart = async (part) => {
+        let bytes = null;
+        const receipt = await sendWithRetries(async () => {
+            if (fatalError)
+                throw fatalError;
+            bytes = bytes ?? await readPartBytes(part.startByte, part.endByte);
+            return {
+                method: "PUT",
+                url: `${session.edgeBaseUrl}/v1/uploads/parts/${part.partNumber}?uploadId=${encodeURIComponent(uploadId)}`,
+                body: bytes,
+                contentType: "application/octet-stream"
+            };
+        }, (body) => {
+            if (typeof body.etag !== "string" || !body.etag) {
+                throw new errors_1.DiffioUploadError("upload/invalid-response", `Part ${part.partNumber} returned no etag.`);
+            }
+            return { partNumber: part.partNumber, etag: body.etag };
+        });
+        receipts.push(receipt);
+    };
+    const runLane = async () => {
+        while (pending.length > 0 && !fatalError) {
+            const part = pending.shift();
+            if (!part)
+                return;
+            try {
+                await uploadPart(part);
+            }
+            catch (error) {
+                fatalError = fatalError ?? toEdgeUploadError(error);
+                throw fatalError;
+            }
+        }
+    };
+    const lanes = Array.from({ length: Math.min(concurrency, parts.length) }, () => runLane());
+    const laneResults = await Promise.allSettled(lanes);
+    const failedLane = laneResults.find((result) => result.status === "rejected");
+    if (failedLane) {
+        const uploadError = fatalError ?? toEdgeUploadError(failedLane.reason);
+        // Release the partial upload; a failure here never masks the transfer error.
+        await sendOnce(jsonRequest("/v1/uploads/abort", { uploadId })).catch(() => undefined);
+        throw uploadError;
+    }
+    receipts.sort((left, right) => left.partNumber - right.partNumber);
+    const completion = await sendWithRetries(() => jsonRequest("/v1/uploads/complete", { uploadId, parts: receipts }), (body) => ({
+        objectKey: typeof body.objectKey === "string" && body.objectKey ? body.objectKey : session.objectKey,
+        sizeBytes: typeof body.sizeBytes === "number" ? body.sizeBytes : sizeBytes,
+        etag: typeof body.etag === "string" ? body.etag : ""
+    }));
+    if (completion.sizeBytes !== sizeBytes) {
+        throw new errors_1.DiffioUploadError("upload/invalid-response", `The edge stored ${completion.sizeBytes} bytes but the file has ${sizeBytes} bytes.`);
+    }
+    return completion;
+}

package/dist/errors/index.d.ts

@@ -9,6 +9,23 @@ export declare class DiffioApiError extends DiffioError {
         responseBody?: unknown;
     });
 }
+/** Stable failure codes for uploads through the edge Worker, modeled on the Diffio web uploader's codes. */
+export type EdgeUploadErrorCode = "upload/too-large" | "upload/unauthorized" | "upload/rejected" | "upload/network" | "upload/server" | "upload/invalid-response" | "upload/canceled";
+/** A failed project media upload; `apiProjectId` names the project whose upload did not finish. */
+export declare class DiffioUploadError extends DiffioApiError {
+    uploadErrorCode: EdgeUploadErrorCode;
+    /** The edge's machine-readable `error.code`, such as `token_expired`, when it sent one. */
+    edgeErrorCode?: string;
+    retryable: boolean;
+    apiProjectId?: string;
+    constructor(uploadErrorCode: EdgeUploadErrorCode, message: string, options?: {
+        statusCode?: number;
+        responseBody?: unknown;
+        edgeErrorCode?: string;
+        retryable?: boolean;
+        apiProjectId?: string;
+    });
+}
 export declare class DiffioTimeoutError extends DiffioError {
     constructor(message: string);
 }

package/dist/errors/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiffioTimeoutError = exports.DiffioApiError = exports.DiffioError = void 0;
+exports.DiffioTimeoutError = exports.DiffioUploadError = exports.DiffioApiError = exports.DiffioError = void 0;
 class DiffioError extends Error {
     constructor(message) {
         super(message);
@@ -17,6 +17,18 @@ class DiffioApiError extends DiffioError {
     }
 }
 exports.DiffioApiError = DiffioApiError;
+/** A failed project media upload; `apiProjectId` names the project whose upload did not finish. */
+class DiffioUploadError extends DiffioApiError {
+    constructor(uploadErrorCode, message, options) {
+        super(message, { statusCode: options?.statusCode, responseBody: options?.responseBody });
+        this.name = "DiffioUploadError";
+        this.uploadErrorCode = uploadErrorCode;
+        this.edgeErrorCode = options?.edgeErrorCode;
+        this.retryable = options?.retryable ?? false;
+        this.apiProjectId = options?.apiProjectId;
+    }
+}
+exports.DiffioUploadError = DiffioUploadError;
 class DiffioTimeoutError extends DiffioError {
     constructor(message) {
         super(message);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const DIFFIO_SDK_VERSION = "0.1.111";
+export declare const DIFFIO_SDK_VERSION = "0.2.0";

package/dist/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DIFFIO_SDK_VERSION = void 0;
-exports.DIFFIO_SDK_VERSION = "0.1.111";
+exports.DIFFIO_SDK_VERSION = "0.2.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diffio",
-  "version": "0.1.111",
+  "version": "0.2.0",
   "description": "Diffio API client for Node.js",
   "repository": {
     "type": "git",