@anvilkit/plugin-asset-manager 0.1.9 → 0.1.10

package/README.md

@@ -1,6 +1,6 @@
 # @anvilkit/plugin-asset-manager
 
-> **Alpha (`0.1.9`).** Public surface may still shift before `v1.0`. Bundle budgets enforced in CI: headless entry ≤ 8 KB gzip, UI subpath ≤ 12 KB gzip, Unsplash subpath ≤ 4 KB gzip.
+> **Alpha (`0.1.10`).** Public surface may still shift before `v1.0`. Bundle budgets enforced in CI: headless entry ≤ 8 KB gzip, UI subpath ≤ 12 KB gzip, Unsplash subpath ≤ 4 KB gzip.
 
 Headless asset manager plugin for Anvilkit Studio. The host provides the upload backend; the plugin handles validation, registration, search, IR-time resolution, CSP guidance, and (optionally) a React UI for the upload + browse experience. Designed for pluggable production backends (S3, GCS, custom HTTP) with strict trust-boundary enforcement on every adapter response.
 
@@ -10,7 +10,7 @@ Headless asset manager plugin for Anvilkit Studio. The host provides the upload
 pnpm add @anvilkit/plugin-asset-manager @anvilkit/core react react-dom @puckeditor/core
 ```
 
-Non-optional peers: `react >=19.0.0`, `react-dom >=19.0.0`, `@puckeditor/core ^0.21.3`.
+Non-optional peers: `react >=19.2.0`, `react-dom >=19.2.0`, `@puckeditor/core ^0.21.3`.
 
 Subpath imports:
 
@@ -48,6 +48,8 @@ For real uploads pass an `uploader`. `dataUrlUploader` is dev-only — files are
 - **IR-time resolution** — `createIRAssetResolver` + `resolveAssets` turn `asset://<id>` references into validated URLs at export / render time.
 - **CSP advisor** — `getRequiredCsp` computes the minimum `connect-src` / `img-src` / `media-src` directives the configured adapters need.
 - **Production-ready S3 adapter** — `s3PresignedAdapter` POST-then-PUT with exponential-backoff retry on 5xx + network failures (4xx fails fast).
+- **Resumable / multipart upload** — opt-in `resumable` option chunks large media, retries per part, and resumes interrupted uploads after a reload; `s3MultipartAdapter` ships in-box (`./adapters/s3-multipart`). See [Resumable / multipart upload](#resumable--multipart-upload).
+- **Asset transformations** — processing-free transform seam: a declarative `AssetTransform` rides on the `asset://<id>?w=…&fm=…` reference and a host `transformResolver` maps it to a derivative URL (your image CDN); `createQueryParamTransformResolver` ships in-box (`./transform`). See [Asset transformations / variants](#asset-transformations--variants).
 - **Optional React UI** — `UploadButton`, `AssetBrowser`, `AssetCommandPalette`, `MetadataPanel`, `ReplaceAssetDialog`, `DeleteAssetDialog`, and the composite `AssetManagerUI`.
 - **Batch upload control** — `StudioAssetSource.upload(files)` honors `maxConcurrentUploads` (default 3) and `AbortSignal`.
 
@@ -62,6 +64,7 @@ function createAssetManagerPlugin(options: AssetManagerOptions): StudioPlugin;
 | Field                       | Type                                           | Default   | Purpose                                                                      |
 | --------------------------- | ---------------------------------------------- | --------- | ---------------------------------------------------------------------------- |
 | `uploader`                  | `UploadAdapter`                                | in-memory | Binary ingest backend (optional; defaults to an in-memory uploader).         |
+| `resumable`                 | `ResumableUploadConfig`                        | none      | Opt-in chunked/resumable upload for large files (`{ adapter, partSize?, threshold?, sessionStore? }`). |
 | `dataSource`                | `AssetDataSource`                              | in-memory | Host-backed catalog (list / remove / replace / rename / move + folders).     |
 | `folders`                   | `boolean \| FolderOptions`                     | `true`    | Folder management; `false` for a flat library, or `{ maxDepth, allowMove }`. |
 | `providers`                 | `readonly AssetSourceProvider[]`               | `[]`      | Extra read-only sources, federated alongside the local library.              |
@@ -70,9 +73,14 @@ function createAssetManagerPlugin(options: AssetManagerOptions): StudioPlugin;
 | `facets`                    | `readonly AssetFacetDefinition[]`              | none      | Custom faceted filters (local `valueOf` or remote).                          |
 | `maxFileSize`               | `number`                                       | none      | Bytes. Enforced before the adapter runs.                                     |
 | `acceptedMimeTypes`         | `readonly string[]`                            | none      | Allowlist. Enforced before the adapter runs.                                 |
+| `acceptedFileExtensions`    | `readonly string[]`                            | none      | Extension allowlist (`".png"` or `"png"`). Enforced before the adapter runs. |
 | `dataUrlAllowlistOptIn`     | `boolean`                                      | `false`   | When `true`, `data:` URLs are valid output.                                  |
 | `allowMixedScriptHostnames` | `boolean`                                      | `false`   | When `true`, hostnames mixing Latin with a confusable script are allowed.    |
 | `getThumbnail`              | `(entry: UploadResult) => string \| undefined` | none      | Optional override for the displayed thumbnail.                               |
+| `transformResolver`         | `TransformResolver`                            | none      | Map an `AssetTransform` to a derivative URL (your image CDN). See [Asset transformations](#asset-transformations--variants). |
+| `dedupe`                    | `boolean`                                      | `false`   | When `true`, hash uploads (SHA-256) and reuse an existing asset with the same content instead of re-uploading. |
+| `sniffContent`              | `boolean`                                      | `false`   | When `true`, reject a file whose magic-byte content contradicts its declared `file.type` (defense-in-depth beyond MIME/extension). |
+| `onAssetDeleted`            | `(asset: UploadResult) => void \| Promise<void>` | none    | Lifecycle hook fired when an asset is deleted via the default source; release backend objects here (`blob:` URLs are auto-revoked). |
 
 ### Imperative API on the plugin context
 
@@ -82,6 +90,13 @@ function createAssetManagerPlugin(options: AssetManagerOptions): StudioPlugin;
 | `getAssetRegistry`     | `(ctx) => AssetRegistry \| undefined`           | Read the runtime registry after `onInit`.                  |
 | `createAssetReference` | `(id) => string`                                | Produce a stable `asset://<id>` reference for IR.          |
 
+Runtime events:
+
+| Event constant | Event name | Payload |
+| -------------- | ---------- | ------- |
+| `ASSET_MANAGER_UPLOADED_EVENT` | `asset-manager:uploaded` | `AssetManagerUploadedEvent` — `{ asset, reference }` after validation and registry insertion. |
+| `ASSET_MANAGER_ERROR_EVENT` | `asset-manager:error` | `AssetManagerErrorEvent` — `{ code, message }` for upload validation or adapter failures. |
+
 ### `UploadAdapter`
 
 ```ts
@@ -119,6 +134,49 @@ interface UploadResult {
 | `headers`         | none                  | Extra headers on the presign POST (e.g., auth).                |
 | `idGenerator`     | `crypto.randomUUID()` | Asset id override.                                             |
 
+### Resumable / multipart upload
+
+Large media can upload in parts, retry per part, and resume after an interruption (refresh, network drop). Opt in with the `resumable` option; files at or above the threshold take the resumable path, everything else stays single-shot.
+
+```ts
+import { createAssetManagerPlugin } from "@anvilkit/plugin-asset-manager";
+import { s3PresignedAdapter } from "@anvilkit/plugin-asset-manager/adapters/s3";
+import { s3MultipartAdapter } from "@anvilkit/plugin-asset-manager/adapters/s3-multipart";
+
+createAssetManagerPlugin({
+	uploader: s3PresignedAdapter({ presignEndpoint: "/api/sign" }), // small files
+	resumable: {
+		adapter: s3MultipartAdapter({ endpoint: "/api/s3-multipart" }),
+		partSize: 8 * 1024 * 1024, // bytes/part (clamped up to S3's 5 MiB min)
+		threshold: 16 * 1024 * 1024, // route files ≥ this through multipart
+		// sessionStore defaults to localStorage (in-memory fallback)
+	},
+});
+```
+
+`ResumableUploadConfig`:
+
+| Field          | Default            | Purpose                                                                                  |
+| -------------- | ------------------ | ---------------------------------------------------------------------------------------- |
+| `adapter`      | _required_         | A `ResumableUploadAdapter` (`begin` / `uploadPart` / `complete` / `abort`).              |
+| `partSize`     | 8 MiB              | Bytes per part.                                                                          |
+| `threshold`    | `partSize`         | Minimum file size routed through the resumable path; smaller files use `uploader`.       |
+| `sessionStore` | localStorage store | Where in-progress sessions persist (`createUploadSessionStore`, or a custom one).        |
+
+**Resume is automatic** when a persistent session store is available. Progress is persisted (keyed by a stable file fingerprint of name + size + last-modified) via the session store; re-selecting the same interrupted file reconciles against the backend and skips the parts already accepted — no explicit "resume" action is needed. The default store uses `localStorage`; where that is unavailable (SSR, private mode) it falls back to an in-memory store, so resume then holds only within the same page session.
+
+**`s3MultipartAdapter` (`./adapters/s3-multipart`)** is dependency-free — like `s3PresignedAdapter`, it never bundles the AWS SDK. It brokers every S3 operation through one host `endpoint` POSTed JSON discriminated by `action`:
+
+| `action`     | Host runs                  | Returns                          |
+| ------------ | -------------------------- | -------------------------------- |
+| `create`     | `CreateMultipartUpload`    | `{ uploadId, key?, partSize? }`  |
+| `sign-part`  | presign one `UploadPart`   | `{ url, headers? }`              |
+| `complete`   | `CompleteMultipartUpload`  | `{ url, publicUrl?, id? }`       |
+| `abort`      | `AbortMultipartUpload`     | —                                |
+| `list-parts` | `ListParts` (resume)       | `{ parts, key? }` (404 ⇒ gone)   |
+
+The part PUT must expose its `ETag` to the browser — set S3 CORS `ExposeHeaders: ["ETag"]`. For CSP, pass `s3Multipart: { endpoint, bucketHost, publicHost? }` to `getRequiredCsp`.
+
 ### `AssetRegistry`
 
 ```ts
@@ -183,9 +241,38 @@ interface CreateIRAssetResolverOptions {
   readonly registry: AssetRegistry;
   readonly dataUrlAllowlistOptIn?: boolean;
   readonly allowMixedScriptHostnames?: boolean;
+  readonly transformResolver?: TransformResolver; // see Asset transformations
 }
 ```
 
+### Asset transformations / variants
+
+Request derivative renditions (resize / crop / format / quality) without the plugin processing any bytes — a transform is a declarative `AssetTransform` carried on the reference (`asset://<id>?w=800&fm=webp`), and a host `transformResolver` maps it to a derivative URL produced by your image CDN / service. The IR resolver applies it at export / render time and **re-validates the derivative URL** through the same trust boundary as any asset URL (a hostile derivative is rejected). When no transform is requested, or the resolver returns `undefined`, the original URL is used.
+
+```ts
+import { createAssetManagerPlugin, createAssetReference } from "@anvilkit/plugin-asset-manager";
+import { createQueryParamTransformResolver } from "@anvilkit/plugin-asset-manager/transform";
+
+createAssetManagerPlugin({
+  // Built-in query-param mapping (imgix-style w/h/fit/fm/q/dpr by default;
+  // param names + fit/format vocab are configurable for other CDNs).
+  transformResolver: createQueryParamTransformResolver(),
+});
+
+// A component stores a transform-bearing reference:
+createAssetReference("asset-1", { width: 800, format: "webp" });
+// → "asset://asset-1?w=800&fm=webp"  → resolves to e.g. "https://cdn/asset-1.png?w=800&fm=webp"
+```
+
+`AssetTransform` fields: `width` / `height` (positive integers), `fit` (`cover` \| `contain` \| `fill` \| `inside` \| `outside`), `format` (`webp` \| `avif` \| `jpeg` \| `png` \| `auto`), `quality` (1–100), `dpr`.
+
+| Export (`./transform`)                | Purpose                                                                 |
+| ------------------------------------- | ----------------------------------------------------------------------- |
+| `createQueryParamTransformResolver`   | Build a `TransformResolver` that appends query params to the asset URL. |
+| `deriveVariantUrl(asset, t, resolver)`| Resolve a derivative URL live (non-IR), falling back to the original.   |
+
+A derivative's dimensional metadata is host-owned, so the resolver drops stale `width`/`height`/`size` from the resolution while preserving `attribution` (a required credit survives a resize).
+
 ### Validation & security
 
 ```ts
@@ -202,6 +289,8 @@ Throws `AssetValidationError` on bad input. Always enforces:
 - Path traversal: `../` and percent-encoded variants (`%2e%2e/`, `%2e%2e%2f`) rejected on `http`/`https`/`blob` URLs.
 - IDN homoglyph: hostnames mixing Latin with Cyrillic or Greek are rejected unless `allowMixedScriptHostnames: true`. Single-script IDN hosts (`münchen.de`, `日本.jp`, `россия.рф`) are always allowed.
 
+Selected files are checked against `maxFileSize`, `acceptedMimeTypes`, and `acceptedFileExtensions` before the adapter runs. Because browser `file.type` is host-set and often empty or spoofable, **`sniffContent: true`** adds magic-byte inspection: a file whose detected type contradicts its declared, specific `file.type` is rejected (`CONTENT_TYPE_MISMATCH`). It's defense-in-depth — unsignable types and generic declarations pass, and the backend should still validate independently.
+
 ### CSP advisor
 
 ```ts
@@ -213,6 +302,9 @@ function getRequiredCsp(options: RequiredCspOptions): RequiredCsp;
 | `dataUrlUploader`    | _(none)_                      | `data:`                 | `data:`                 |
 | `inMemoryUploader`   | _(none)_                      | `blob:`                 | `blob:`                 |
 | `s3PresignedAdapter` | presign origin + `publicHost` | `publicHost` ?? presign | `publicHost` ?? presign |
+| `s3MultipartAdapter` | `endpoint` + `bucketHost` + `publicHost` | `publicHost` ?? `bucketHost` | `publicHost` ?? `bucketHost` |
+
+Pass `s3Multipart: { endpoint, bucketHost?, publicHost? }` (single or array) alongside `dataUrl` / `inMemory` / `s3`.
 
 ### React UI (`./ui`)
 
@@ -260,6 +352,7 @@ Full-jitter exponential backoff; the optional `retryAfterMs` on a `RetryableErro
 | ------------------------------ | --------------------------- |
 | `FILE_TOO_LARGE`               | pre-upload file validation  |
 | `UNSUPPORTED_MIME_TYPE`        | pre-upload file validation  |
+| `UNSUPPORTED_FILE_EXTENSION`   | pre-upload file validation  |
 | `INVALID_UPLOAD_ID`            | `validateUploadResult`      |
 | `EMPTY_UPLOAD_URL`             | `validateUploadResult`      |
 | `UNSCHEMED_UPLOAD_URL`         | `validateUploadResult`      |
@@ -418,7 +511,7 @@ Only `name`, `size`, and `mimeType` are considered safe to log. If your host end
 3. **Wire CSP.** Call `getRequiredCsp(...)` and merge the result into your `connect-src` / `img-src` / `media-src` builder. Re-run when you add or remove an adapter.
 4. **Choose a persistence story.** Plugin state is in-memory; host stores `publicUrl`s server-side and re-seeds on boot.
 5. **Monitor.** Subscribe to `asset-manager:error` event bus envelopes for upload failures, and log `AssetResolutionError.code` from your export pipeline so `ASSET_NOT_FOUND` / `ASSET_URL_REJECTED` / `ASSET_VALIDATION_FAILED` get separate alerts.
-6. **Lock down the bundle.** `.size-limit.json` keeps the headless entry under 6 KB gzip and the UI subpath under 12 KB. CI gates both.
+6. **Lock down the bundle.** `.size-limit.json` keeps the headless entry under 8 KB gzip and the UI subpath under 12 KB. CI gates both.
 
 ### Optional UI is a separate entry
 

package/dist/adapters/data-url.d.cts

@@ -1,4 +1,5 @@
 import type { UploadAdapter } from "../types/types.js";
+/** Options for the development-only data URL uploader. */
 export interface DataUrlUploaderOptions {
     /**
      * Maximum **raw file size** in bytes (default 1 MB). This bounds the input

package/dist/adapters/data-url.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"data-url.d.cts","sourceRoot":"","sources":["../../src/adapters/data-url.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAgB,MAAM,mBAAmB,CAAC;AAIrE,MAAM,WAAW,sBAAsB;IACtC;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC3B;AAID;;;;;GAKG;AACH,wBAAgB,eAAe,CAC9B,OAAO,GAAE,sBAA2B,GAClC,aAAa,CA+Bf"}
+{"version":3,"file":"data-url.d.cts","sourceRoot":"","sources":["../../src/adapters/data-url.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAgB,MAAM,mBAAmB,CAAC;AAIrE,0DAA0D;AAC1D,MAAM,WAAW,sBAAsB;IACtC;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC3B;AAID;;;;;GAKG;AACH,wBAAgB,eAAe,CAC9B,OAAO,GAAE,sBAA2B,GAClC,aAAa,CA+Bf"}

package/dist/adapters/data-url.d.ts

@@ -1,4 +1,5 @@
 import type { UploadAdapter } from "../types/types.js";
+/** Options for the development-only data URL uploader. */
 export interface DataUrlUploaderOptions {
     /**
      * Maximum **raw file size** in bytes (default 1 MB). This bounds the input

package/dist/adapters/data-url.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"data-url.d.ts","sourceRoot":"","sources":["../../src/adapters/data-url.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAgB,MAAM,mBAAmB,CAAC;AAIrE,MAAM,WAAW,sBAAsB;IACtC;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC3B;AAID;;;;;GAKG;AACH,wBAAgB,eAAe,CAC9B,OAAO,GAAE,sBAA2B,GAClC,aAAa,CA+Bf"}
+{"version":3,"file":"data-url.d.ts","sourceRoot":"","sources":["../../src/adapters/data-url.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAgB,MAAM,mBAAmB,CAAC;AAIrE,0DAA0D;AAC1D,MAAM,WAAW,sBAAsB;IACtC;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC3B;AAID;;;;;GAKG;AACH,wBAAgB,eAAe,CAC9B,OAAO,GAAE,sBAA2B,GAClC,aAAa,CA+Bf"}

package/dist/adapters/s3-multipart.cjs

@@ -0,0 +1,425 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    s3MultipartAdapter: ()=>s3MultipartAdapter
+});
+const errors_cjs_namespaceObject = require("../utils/errors.cjs");
+const retry_cjs_namespaceObject = require("../utils/retry.cjs");
+const DEFAULT_PART_SIZE = 8388608;
+const S3_MIN_PART_SIZE = 5242880;
+function s3MultipartAdapter(options) {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    if ("function" != typeof fetchImpl) throw new Error("s3MultipartAdapter: no `fetch` implementation available. Pass `options.fetch`.");
+    const generateId = options.idGenerator ?? defaultIdGenerator;
+    const partSize = Math.max(options.partSize ?? DEFAULT_PART_SIZE, S3_MIN_PART_SIZE);
+    const endpoint = "string" == typeof options.endpoint ? options.endpoint : options.endpoint.toString();
+    const retry = options.retry ?? {};
+    const keyOf = (session)=>"string" == typeof session.meta?.key ? session.meta.key : void 0;
+    return {
+        async begin (file, resume, callOptions) {
+            const { signal, dispose } = combineSignals(options.signal, callOptions?.signal);
+            try {
+                if (resume) {
+                    const resumeKey = "string" == typeof resume.meta?.key ? resume.meta.key : void 0;
+                    const listed = await (0, retry_cjs_namespaceObject.withRetry)(()=>listParts(endpoint, fetchImpl, options.headers, resume.uploadId, resumeKey, signal), {
+                        ...retry,
+                        ...signal ? {
+                            signal
+                        } : {}
+                    });
+                    if (void 0 !== listed) {
+                        const key = resumeKey ?? listed.key;
+                        return {
+                            uploadId: resume.uploadId,
+                            parts: listed.parts,
+                            partSize: resume.partSize,
+                            meta: buildMeta(key, resume.meta)
+                        };
+                    }
+                }
+                const created = await (0, retry_cjs_namespaceObject.withRetry)(()=>createSession(endpoint, fetchImpl, options.headers, file, partSize, signal), {
+                    ...retry,
+                    ...signal ? {
+                        signal
+                    } : {}
+                });
+                return {
+                    uploadId: created.uploadId,
+                    parts: [],
+                    partSize: clampPartSize(created.partSize) ?? partSize,
+                    meta: buildMeta(created.key, fileMeta(file))
+                };
+            } finally{
+                dispose();
+            }
+        },
+        async uploadPart (session, part, callOptions) {
+            const { signal, dispose } = combineSignals(options.signal, callOptions?.signal);
+            try {
+                const signed = await signPart(endpoint, fetchImpl, options.headers, session.uploadId, keyOf(session), part.partNumber, signal);
+                const etag = await putPart(fetchImpl, signed, part, signal);
+                return {
+                    partNumber: part.partNumber,
+                    etag
+                };
+            } finally{
+                dispose();
+            }
+        },
+        async complete (session, parts, callOptions) {
+            const { signal, dispose } = combineSignals(options.signal, callOptions?.signal);
+            try {
+                const completed = await (0, retry_cjs_namespaceObject.withRetry)(()=>completeSession(endpoint, fetchImpl, options.headers, session.uploadId, keyOf(session), parts, signal), {
+                    ...retry,
+                    ...signal ? {
+                        signal
+                    } : {}
+                });
+                const id = completed.id ?? generateId();
+                const url = completed.publicUrl ?? stripQueryAndFragment(completed.url);
+                return buildResult(id, url, session.meta);
+            } finally{
+                dispose();
+            }
+        },
+        async abort (session, callOptions) {
+            const { signal, dispose } = combineSignals(options.signal, callOptions?.signal);
+            try {
+                await (0, retry_cjs_namespaceObject.withRetry)(()=>abortSession(endpoint, fetchImpl, options.headers, session.uploadId, keyOf(session), signal), {
+                    ...retry,
+                    ...signal ? {
+                        signal
+                    } : {}
+                });
+            } finally{
+                dispose();
+            }
+        }
+    };
+}
+async function createSession(endpoint, fetchImpl, headers, file, partSize, signal) {
+    const payload = await postAction(endpoint, fetchImpl, headers, {
+        action: "create",
+        name: file.name,
+        type: file.type,
+        size: file.size,
+        partSize
+    }, signal);
+    if (!isObject(payload) || "string" != typeof payload.uploadId || "" === payload.uploadId) throw new errors_cjs_namespaceObject.AssetValidationError("UPLOAD_FAILED", "s3MultipartAdapter: create response missing `uploadId`.");
+    if (!isOptionalString(payload.key)) throw badShape("create", "`key` must be a string");
+    if (void 0 !== payload.partSize && !isPositiveSafeInteger(payload.partSize)) throw badShape("create", "`partSize` must be a positive integer");
+    return {
+        uploadId: payload.uploadId,
+        ...void 0 !== payload.key ? {
+            key: payload.key
+        } : {},
+        ...void 0 !== payload.partSize ? {
+            partSize: payload.partSize
+        } : {}
+    };
+}
+async function signPart(endpoint, fetchImpl, headers, uploadId, key, partNumber, signal) {
+    const payload = await postAction(endpoint, fetchImpl, headers, {
+        action: "sign-part",
+        uploadId,
+        key,
+        partNumber
+    }, signal);
+    if (!isObject(payload) || "string" != typeof payload.url || "" === payload.url) throw new errors_cjs_namespaceObject.AssetValidationError("UPLOAD_FAILED", "s3MultipartAdapter: sign-part response missing `url`.");
+    if (void 0 !== payload.headers && !isStringRecord(payload.headers)) throw badShape("sign-part", "`headers` must be a string map");
+    return {
+        url: payload.url,
+        ...void 0 !== payload.headers ? {
+            headers: payload.headers
+        } : {}
+    };
+}
+async function completeSession(endpoint, fetchImpl, headers, uploadId, key, parts, signal) {
+    const payload = await postAction(endpoint, fetchImpl, headers, {
+        action: "complete",
+        uploadId,
+        key,
+        parts
+    }, signal);
+    if (!isObject(payload) || "string" != typeof payload.url || "" === payload.url) throw new errors_cjs_namespaceObject.AssetValidationError("UPLOAD_FAILED", "s3MultipartAdapter: complete response missing `url`.");
+    if (!isOptionalString(payload.publicUrl)) throw badShape("complete", "`publicUrl` must be a string");
+    if (!isOptionalString(payload.id)) throw badShape("complete", "`id` must be a string");
+    return {
+        url: payload.url,
+        ...void 0 !== payload.publicUrl ? {
+            publicUrl: payload.publicUrl
+        } : {},
+        ...void 0 !== payload.id ? {
+            id: payload.id
+        } : {}
+    };
+}
+function abortSession(endpoint, fetchImpl, headers, uploadId, key, signal) {
+    return postAction(endpoint, fetchImpl, headers, {
+        action: "abort",
+        uploadId,
+        key
+    }, signal);
+}
+async function listParts(endpoint, fetchImpl, headers, uploadId, key, signal) {
+    let response;
+    try {
+        response = await fetchImpl(endpoint, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...headers ?? {}
+            },
+            body: JSON.stringify({
+                action: "list-parts",
+                uploadId,
+                key
+            }),
+            ...signal ? {
+                signal
+            } : {}
+        });
+    } catch (cause) {
+        throw new retry_cjs_namespaceObject.RetryableError(`s3MultipartAdapter: list-parts request failed (${describeError(cause)}).`, {
+            cause
+        });
+    }
+    if (404 === response.status) return;
+    if (response.status >= 500) throw new retry_cjs_namespaceObject.RetryableError(`s3MultipartAdapter: list-parts returned ${response.status}.`, {
+        retryAfterMs: parseRetryAfter(response.headers.get("retry-after"))
+    });
+    if (!response.ok) throw new errors_cjs_namespaceObject.AssetValidationError("UPLOAD_FAILED", `s3MultipartAdapter: list-parts returned ${response.status}.`);
+    const payload = await parseJson(response, "list-parts");
+    if (!isObject(payload) || !isPartTagArray(payload.parts)) throw new errors_cjs_namespaceObject.AssetValidationError("UPLOAD_FAILED", "s3MultipartAdapter: list-parts response has a missing or malformed `parts` array.");
+    if (!isOptionalString(payload.key)) throw badShape("list-parts", "`key` must be a string");
+    return {
+        parts: payload.parts,
+        ...void 0 !== payload.key ? {
+            key: payload.key
+        } : {}
+    };
+}
+async function putPart(fetchImpl, signed, part, signal) {
+    let response;
+    try {
+        response = await fetchImpl(signed.url, {
+            method: "PUT",
+            body: part.blob,
+            ...signed.headers ? {
+                headers: signed.headers
+            } : {},
+            ...signal ? {
+                signal
+            } : {}
+        });
+    } catch (cause) {
+        throw new retry_cjs_namespaceObject.RetryableError(`s3MultipartAdapter: part ${part.partNumber} PUT failed (${describeError(cause)}).`, {
+            cause
+        });
+    }
+    if (response.status >= 500) throw new retry_cjs_namespaceObject.RetryableError(`s3MultipartAdapter: part ${part.partNumber} PUT returned ${response.status}.`, {
+        retryAfterMs: parseRetryAfter(response.headers.get("retry-after"))
+    });
+    if (!response.ok) throw new errors_cjs_namespaceObject.AssetValidationError("UPLOAD_FAILED", `s3MultipartAdapter: part ${part.partNumber} PUT returned ${response.status}.`);
+    const etag = response.headers.get("etag");
+    if (null === etag || "" === etag) throw new errors_cjs_namespaceObject.AssetValidationError("UPLOAD_FAILED", `s3MultipartAdapter: part ${part.partNumber} PUT returned no ETag header. Expose it via S3 CORS \`ExposeHeaders: ["ETag"]\`.`);
+    return etag;
+}
+async function postAction(endpoint, fetchImpl, headers, body, signal) {
+    let response;
+    try {
+        response = await fetchImpl(endpoint, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...headers ?? {}
+            },
+            body: JSON.stringify(body),
+            ...signal ? {
+                signal
+            } : {}
+        });
+    } catch (cause) {
+        throw new retry_cjs_namespaceObject.RetryableError(`s3MultipartAdapter: ${String(body.action)} request failed (${describeError(cause)}).`, {
+            cause
+        });
+    }
+    if (response.status >= 500) throw new retry_cjs_namespaceObject.RetryableError(`s3MultipartAdapter: ${String(body.action)} returned ${response.status}.`, {
+        retryAfterMs: parseRetryAfter(response.headers.get("retry-after"))
+    });
+    if (!response.ok) throw new errors_cjs_namespaceObject.AssetValidationError("UPLOAD_FAILED", `s3MultipartAdapter: ${String(body.action)} returned ${response.status}.`);
+    if ("abort" === body.action) return;
+    return parseJson(response, String(body.action));
+}
+async function parseJson(response, action) {
+    try {
+        return await response.json();
+    } catch (cause) {
+        throw new errors_cjs_namespaceObject.AssetValidationError("UPLOAD_FAILED", `s3MultipartAdapter: ${action} response was not JSON.`, {
+            cause
+        });
+    }
+}
+function fileMeta(file) {
+    return {
+        name: file.name,
+        size: file.size,
+        ...file.type ? {
+            type: file.type
+        } : {}
+    };
+}
+function buildMeta(key, base) {
+    return Object.freeze({
+        ...base ?? {},
+        ...void 0 !== key ? {
+            key
+        } : {}
+    });
+}
+function buildResult(id, url, meta) {
+    const name = "string" == typeof meta?.name ? meta.name : void 0;
+    const size = "number" == typeof meta?.size ? meta.size : void 0;
+    const type = "string" == typeof meta?.type ? meta.type : void 0;
+    const resultMeta = void 0 !== size || void 0 !== type ? {
+        ...void 0 !== size ? {
+            size
+        } : {},
+        ...void 0 !== type ? {
+            mimeType: type
+        } : {}
+    } : void 0;
+    return {
+        id,
+        url,
+        ...name ? {
+            name
+        } : {},
+        ...resultMeta ? {
+            meta: resultMeta
+        } : {}
+    };
+}
+function clampPartSize(value) {
+    if ("number" != typeof value || !Number.isSafeInteger(value) || value <= 0) return;
+    return Math.max(value, S3_MIN_PART_SIZE);
+}
+function isObject(value) {
+    return null !== value && "object" == typeof value && !Array.isArray(value);
+}
+function isOptionalString(value) {
+    return void 0 === value || "string" == typeof value;
+}
+function isPositiveSafeInteger(value) {
+    return "number" == typeof value && Number.isSafeInteger(value) && value > 0;
+}
+function isStringRecord(value) {
+    return isObject(value) && Object.values(value).every((v)=>"string" == typeof v);
+}
+function isPartTagArray(value) {
+    return Array.isArray(value) && value.every((p)=>isObject(p) && "number" == typeof p.partNumber && Number.isInteger(p.partNumber) && p.partNumber >= 1 && "string" == typeof p.etag);
+}
+function badShape(action, detail) {
+    return new errors_cjs_namespaceObject.AssetValidationError("UPLOAD_FAILED", `s3MultipartAdapter: ${action} response has an invalid shape — ${detail}.`);
+}
+function stripQueryAndFragment(url) {
+    const cuts = [
+        url.indexOf("?"),
+        url.indexOf("#")
+    ].filter((i)=>-1 !== i);
+    return 0 === cuts.length ? url : url.slice(0, Math.min(...cuts));
+}
+function parseRetryAfter(header) {
+    if (null === header) return;
+    const seconds = Number(header);
+    if (Number.isFinite(seconds) && seconds >= 0) return 1000 * seconds;
+    const date = Date.parse(header);
+    if (!Number.isNaN(date)) return Math.max(0, date - Date.now());
+}
+function describeError(error) {
+    if (error instanceof Error) return error.message || error.name;
+    return String(error);
+}
+function defaultIdGenerator() {
+    if (void 0 !== globalThis.crypto && "function" == typeof globalThis.crypto.randomUUID) return globalThis.crypto.randomUUID();
+    return `asset-${Math.random().toString(36).slice(2)}-${Date.now()}`;
+}
+const NOOP_DISPOSE = ()=>void 0;
+function combineSignals(a, b) {
+    if (!a) return {
+        signal: b,
+        dispose: NOOP_DISPOSE
+    };
+    if (!b) return {
+        signal: a,
+        dispose: NOOP_DISPOSE
+    };
+    if (a === b) return {
+        signal: a,
+        dispose: NOOP_DISPOSE
+    };
+    const anyImpl = AbortSignal.any;
+    if ("function" == typeof anyImpl) return {
+        signal: anyImpl([
+            a,
+            b
+        ]),
+        dispose: NOOP_DISPOSE
+    };
+    const controller = new AbortController();
+    const onAbortA = ()=>{
+        if (!controller.signal.aborted) controller.abort(a.reason);
+    };
+    const onAbortB = ()=>{
+        if (!controller.signal.aborted) controller.abort(b.reason);
+    };
+    if (a.aborted) onAbortA();
+    else a.addEventListener("abort", onAbortA, {
+        once: true
+    });
+    if (b.aborted) onAbortB();
+    else b.addEventListener("abort", onAbortB, {
+        once: true
+    });
+    return {
+        signal: controller.signal,
+        dispose: ()=>{
+            a.removeEventListener("abort", onAbortA);
+            b.removeEventListener("abort", onAbortB);
+        }
+    };
+}
+exports.s3MultipartAdapter = __webpack_exports__.s3MultipartAdapter;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "s3MultipartAdapter"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});