lemon-model 1.2.4 → 1.5.0

package/dist/upload/testing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.js","sourceRoot":"","sources":["../../src/upload/testing.ts"],"names":[],"mappings":";;;AASA,mCAA6E;AAE7E,kGAAkG;AACrF,QAAA,oBAAoB,GAAW;IACxC,EAAE,EAAE,QAAQ;IACZ,MAAM,EAAE,qBAAa,CAAC,MAAM;IAC5B,MAAM,EAAE,qBAAa,CAAC,KAAK;IAC3B,IAAI,EAAE,WAAW;IACjB,WAAW,EAAE,WAAW;IACxB,WAAW,EAAE,MAAM;IACnB,GAAG,EAAE,oCAAoC;IACzC,KAAK,EAAE,IAAI;IACX,MAAM,EAAE,GAAG;IACX,SAAS,EAAE,EAAE,GAAG,EAAE,0CAA0C,EAAE,WAAW,EAAE,YAAY,EAAE;CAC5F,CAAC;AAEF,gCAAgC;AACnB,QAAA,2BAA2B,GAAiB;IACrD,MAAM,EAAE;QACJ,EAAE,EAAE,QAAQ;QACZ,MAAM,EAAE,qBAAa,CAAC,OAAO;QAC7B,MAAM,EAAE,qBAAa,CAAC,KAAK;QAC3B,IAAI,EAAE,WAAW;QACjB,WAAW,EAAE,WAAW;QACxB,WAAW,EAAE,MAAM;KACtB;IACD,QAAQ,EAAE,EAAE,IAAI,EAAE,4BAAoB,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE;CACrE,CAAC;AAEF,uCAAuC;AAC1B,QAAA,8BAA8B,GAAiB;IACxD,MAAM,EAAE;QACJ,EAAE,EAAE,QAAQ;QACZ,MAAM,EAAE,qBAAa,CAAC,OAAO;QAC7B,MAAM,EAAE,qBAAa,CAAC,KAAK;QAC3B,IAAI,EAAE,WAAW;QACjB,WAAW,EAAE,WAAW;QACxB,WAAW,EAAE,MAAM;KACtB;IACD,QAAQ,EAAE;QACN,IAAI,EAAE,4BAAoB,CAAC,YAAY;QACvC,MAAM,EAAE,KAAK;QACb,GAAG,EAAE,2DAA2D;QAChE,OAAO,EAAE,EAAE,cAAc,EAAE,WAAW,EAAE,gBAAgB,EAAE,QAAQ,EAAE;QACpE,QAAQ,EAAE,QAAQ;QAClB,SAAS,EAAE,aAAa;KAC3B;CACJ,CAAC;AAEF;;;;GAIG;AACU,QAAA,mCAAmC,GAAiB;IAC7D,MAAM,EAAE;QACJ,EAAE,EAAE,QAAQ;QACZ,MAAM,EAAE,qBAAa,CAAC,MAAM;QAC5B,MAAM,EAAE,qBAAa,CAAC,KAAK;QAC3B,IAAI,EAAE,WAAW;QACjB,WAAW,EAAE,WAAW;QACxB,WAAW,EAAE,MAAM;QACnB,GAAG,EAAE,oCAAoC;KAC5C;IACD,iBAAiB,EAAE;QACf,IAAI,EAAE,4BAAoB,CAAC,YAAY;QACvC,MAAM,EAAE,KAAK;QACb,GAAG,EAAE,iEAAiE;QACtE,OAAO,EAAE,EAAE,cAAc,EAAE,YAAY,EAAE;QACzC,QAAQ,EAAE,MAAM;QAChB,SAAS,EAAE,aAAa;KAC3B;CACJ,CAAC;AAEF,gFAAgF;AACnE,QAAA,sBAAsB,GAAiB;IAChD,MAAM,EAAE;QACJ,MAAM,EAAE,qBAAa,CAAC,MAAM;QAC5B,IAAI,EAAE,SAAS;QACf,WAAW,EAAE,WAAW;QACxB,WAAW,EAAE,OAAO;QACpB,KAAK,EAAE,mCAAmC;KAC7C;CACJ,CAAC"}

package/dist/upload/types.d.ts

@@ -0,0 +1,254 @@
+/**
+ * `upload/types.ts`
+ * - client <-> server contract for uploading files.
+ * - transport-neutral: the client always runs `start` -> transfer -> `complete`; whether the server
+ *   stores bytes inline (base64 in JSON) or hands out a presigned PUT only changes which
+ *   `UploadTransfer` variant it issues.
+ * - runtime-neutral like `socket/`: no Node, DOM, or AWS SDK types. Storage coordinates
+ *   (bucket, key, region) never appear here.
+ * - model-neutral: nothing here imports or names lemon-core's Model/View/Body/Head layers or the `$`
+ *   embed marker. two shapes carry the vocabulary instead — `UploadContent` (bytes as declared) and
+ *   `UploadResource` (bytes as stored, with an address). how a server maps them onto its own model
+ *   layer, and how it embeds an upload in another record, is the server's concern.
+ *
+ * @copyright (C) 2026 LemonCloud Co Ltd. - All Rights Reserved.
+ */
+/** kind of stored content */
+export declare const UPLOAD_STEREO: {
+    readonly image: "image";
+    readonly video: "video";
+    readonly sound: "sound";
+    readonly docs: "docs";
+};
+export declare type UploadStereo = typeof UPLOAD_STEREO[keyof typeof UPLOAD_STEREO];
+/** lifecycle of one upload as the client sees it. `url` is meaningful only when `stored` */
+export declare const UPLOAD_STATUS: {
+    /** ticket issued; bytes not confirmed by the server yet */
+    readonly pending: "pending";
+    /** bytes durable and `url` valid */
+    readonly stored: "stored";
+    /** terminal; `error` carries the server's detail */
+    readonly failed: "failed";
+};
+export declare type UploadStatus = typeof UPLOAD_STATUS[keyof typeof UPLOAD_STATUS];
+/** how bytes travel. a new transfer method arrives as a new kind; the flow around it does not change */
+export declare const UPLOAD_TRANSFER_KIND: {
+    /** base64 in a JSON body, through the `send` operation */
+    readonly inline: "inline";
+    /** HTTP PUT straight to storage, to a server-issued url with its headers */
+    readonly presignedPut: "presigned-put";
+};
+export declare type UploadTransferKind = typeof UPLOAD_TRANSFER_KIND[keyof typeof UPLOAD_TRANSFER_KIND];
+/**
+ * one payload of bytes as the client declares it. it has no identity and no address of its own.
+ * - `contentType` and `contentSize` are required: the server picks the transfer and validates limits
+ *   from them before any byte moves.
+ */
+export interface UploadContent {
+    contentType: string;
+    contentSize: number;
+    /** pixel size for image/video. declared by the client; the server does not verify it */
+    width?: number;
+    height?: number;
+    /**
+     * sha256 hex(64). optional forever: servers MUST accept uploads without it, MUST verify it when given.
+     * on a thumbnail the server MAY verify it the same way for that transfer; completion-time cross-check applies only to the original's hash.
+     */
+    hash?: string;
+}
+/**
+ * bytes the server holds, and where to fetch them.
+ * - `url` may be time-limited and re-issued on every read: use it when received, never persist it.
+ * - the content fields are what the server can vouch for, so every one is optional: a server that
+ *   only confirmed the object exists (a thumbnail) knows nothing beyond the address.
+ */
+export interface UploadResource extends Partial<UploadContent> {
+    url: string;
+}
+/**
+ * one upload intent: a slot of `start`.
+ * - `id` set = re-issue transfers for an existing upload. for a still-`pending` one (expired ticket)
+ *   that is both transfers; for a `stored` one it is `thumbnailTransfer` only, because stored bytes
+ *   are immutable.
+ */
+export interface UploadIntent extends UploadContent {
+    id?: string;
+    /** file name as the sender picked it */
+    name: string;
+    /** a preview the client made. the server stores it beside the original and never derives it */
+    thumbnail?: UploadContent;
+}
+/**
+ * one upload as the server reports it: the declaration, its lifecycle, and — once `stored` — its address.
+ * - the content fields echo the intent. `url` is present iff `status` is `stored` (see `UploadStored`).
+ * - a server may answer with more fields than these; a client relies on these only.
+ */
+export interface Upload extends Partial<UploadContent> {
+    /** absent only for a slot rejected at `start` validation: nothing was created */
+    id?: string;
+    status: UploadStatus;
+    /** human-readable detail when `failed`; the format is the server's. branch on `status`, not on this string */
+    error?: string;
+    stereo?: UploadStereo;
+    /** file name as the sender picked it */
+    name?: string;
+    /** url to serve; may be time-limited and re-issued on every read — do not persist it. present iff `stored` */
+    url?: string;
+    /** preview stored alongside the original: present only once the intent declared one and its bytes arrived */
+    thumbnail?: UploadResource;
+}
+/** an upload whose bytes are durable: it has an `id` and it is an `UploadResource` */
+export declare type UploadStored = Upload & UploadResource & {
+    id: string;
+};
+export declare const isUploadStored: (upload: Upload) => upload is UploadStored;
+/** transfer instruction: send base64 through `UploadSupportable.send()` */
+export interface UploadInlineTransfer {
+    kind: typeof UPLOAD_TRANSFER_KIND.inline;
+    /** max original bytes (before base64) this server accepts inline */
+    maxBytes: number;
+}
+/**
+ * transfer instruction: PUT the raw bytes to `url` with `headers` verbatim.
+ * - `url` is a credential. never log, persist, or put it in an error message.
+ * - `expiresAt` is an upper bound only (signing credentials may expire earlier). on 403 re-`start` with `id`.
+ */
+export interface UploadPresignedPutTransfer {
+    kind: typeof UPLOAD_TRANSFER_KIND.presignedPut;
+    method: 'PUT';
+    url: string;
+    /**
+     * every header the signature covers; send them unchanged.
+     * - EXCEPT the ones the user agent owns: `content-length` and `host`. `fetch` and
+     *   `XMLHttpRequest` forbid setting them and the UA fills them from the request itself,
+     *   so a shell adapter must drop them from this map before sending. The signature still
+     *   matches because the UA's value is the one that was signed.
+     */
+    headers: Record<string, string>;
+    maxBytes: number;
+    /** epoch-ms */
+    expiresAt?: number;
+}
+export declare type UploadTransfer = UploadInlineTransfer | UploadPresignedPutTransfer;
+/**
+ * a transfer that carries its own destination, so it can deliver any payload of an upload.
+ * - `inline` is not one: it goes through `send`, which addresses the whole upload, so a thumbnail
+ *   sent that way would overwrite the original.
+ * - a new kind is listed here explicitly, never by default.
+ */
+export declare type UploadDirectTransfer = UploadPresignedPutTransfer;
+/**
+ * one slot of `start`'s answer.
+ * - `upload` is safe to store and log. `transfer` and `thumbnailTransfer` are each consumed once by
+ *   the executor and dropped.
+ * - nothing to send at all = neither `transfer` nor `thumbnailTransfer`: already `stored` (dedup)
+ *   or `failed` at validation. `transfer` alone may be absent while `thumbnailTransfer` is present —
+ *   that is a `stored` upload getting a thumbnail added; its bytes are immutable.
+ */
+export interface UploadTicket {
+    upload: Upload;
+    transfer?: UploadTransfer;
+    /** the thumbnail's transfer, if the intent declared one and the server can issue it */
+    thumbnailTransfer?: UploadDirectTransfer;
+}
+/** request of the `start` operation */
+export interface UploadStartRequest {
+    list: UploadIntent[];
+    /** transfer kinds this client can execute, preferred first. absent = `['inline']` */
+    transfers?: UploadTransferKind[];
+}
+/** same length and order as `UploadStartRequest.list` */
+export interface UploadStartResult {
+    list: UploadTicket[];
+}
+/** request of the `send` operation (inline transfer only) */
+export interface UploadSendRequest {
+    /** base64 of the whole content; size must match the declared `contentSize` */
+    content: string;
+}
+/** who produced a failure */
+export declare const UPLOAD_FAILURE_SOURCE: {
+    /** the upload API answered with an error */
+    readonly api: "api";
+    /** the storage endpoint (presigned PUT) answered with an error */
+    readonly storage: "storage";
+    /** the client gave up before or without a response */
+    readonly client: "client";
+};
+export declare type UploadFailureSource = typeof UPLOAD_FAILURE_SOURCE[keyof typeof UPLOAD_FAILURE_SOURCE];
+/** normalized failure codes; the app branches on these, never on raw HTTP status */
+export declare const UPLOAD_FAILURE_CODE: {
+    readonly invalid: "invalid";
+    readonly tooLarge: "too-large";
+    readonly unsupported: "unsupported";
+    readonly notAcceptable: "not-acceptable";
+    readonly notFound: "not-found";
+    readonly conflict: "conflict";
+    readonly expired: "expired";
+    readonly signature: "signature";
+    readonly checksum: "checksum";
+    readonly network: "network";
+    readonly aborted: "aborted";
+    readonly unknown: "unknown";
+};
+export declare type UploadFailureCode = typeof UPLOAD_FAILURE_CODE[keyof typeof UPLOAD_FAILURE_CODE];
+/** failure as the client reports it (to the app, and to the server in `complete`) */
+export interface UploadFailure {
+    source: UploadFailureSource;
+    code: UploadFailureCode;
+    /** HTTP status as observed, if any */
+    status?: number;
+    /** origin code: S3 `<Code>` or the lemon-core LABEL */
+    reason?: string;
+    /** human detail. MUST NOT contain a transfer url */
+    message?: string;
+}
+/** one slot of `complete`'s request */
+export interface UploadCompleteItem {
+    id: string;
+    /** set when the transfer did not succeed; the server marks the upload `failed` */
+    failure?: UploadFailure;
+}
+/** request of the `complete` operation */
+export interface UploadCompleteRequest {
+    list: UploadCompleteItem[];
+}
+/** same length and order as `UploadCompleteRequest.list` */
+export interface UploadCompleteResult {
+    list: Upload[];
+}
+/**
+ * the four operations. a server exposes them over `UPLOAD_ROUTES`; a client adapter implements this to call them.
+ * - all four require the caller's normal API auth; a presigned url is the only unauthenticated hop.
+ */
+export interface UploadSupportable {
+    /** declare intents; get tickets. validation failures come back per slot as `failed`, never as HTTP 4xx */
+    start(body: UploadStartRequest): Promise<UploadStartResult>;
+    /** inline transfer: deliver the bytes of one pending upload */
+    send(id: string, body: UploadSendRequest): Promise<Upload>;
+    /** confirm; the server verifies what it cannot see (presigned) and settles `status`. idempotent */
+    complete(body: UploadCompleteRequest): Promise<UploadCompleteResult>;
+    /** re-read for the current state */
+    read(id: string): Promise<Upload>;
+}
+/** HTTP binding relative to the server's upload base path (lemon-core `/{type}/{id}/{cmd}` shape) */
+export declare const UPLOAD_ROUTES: {
+    readonly start: {
+        readonly method: "POST";
+        readonly path: "/start";
+    };
+    readonly send: {
+        readonly method: "POST";
+        readonly path: "/{id}/send";
+    };
+    readonly complete: {
+        readonly method: "POST";
+        readonly path: "/complete";
+    };
+    readonly read: {
+        readonly method: "GET";
+        readonly path: "/{id}";
+    };
+};
+/** shared stereo derivation so an optimistic client tile and the server agree */
+export declare const uploadStereoOf: (contentType: string) => UploadStereo | undefined;

package/dist/upload/types.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * `upload/types.ts`
+ * - client <-> server contract for uploading files.
+ * - transport-neutral: the client always runs `start` -> transfer -> `complete`; whether the server
+ *   stores bytes inline (base64 in JSON) or hands out a presigned PUT only changes which
+ *   `UploadTransfer` variant it issues.
+ * - runtime-neutral like `socket/`: no Node, DOM, or AWS SDK types. Storage coordinates
+ *   (bucket, key, region) never appear here.
+ * - model-neutral: nothing here imports or names lemon-core's Model/View/Body/Head layers or the `$`
+ *   embed marker. two shapes carry the vocabulary instead — `UploadContent` (bytes as declared) and
+ *   `UploadResource` (bytes as stored, with an address). how a server maps them onto its own model
+ *   layer, and how it embeds an upload in another record, is the server's concern.
+ *
+ * @copyright (C) 2026 LemonCloud Co Ltd. - All Rights Reserved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadStereoOf = exports.UPLOAD_ROUTES = exports.UPLOAD_FAILURE_CODE = exports.UPLOAD_FAILURE_SOURCE = exports.isUploadStored = exports.UPLOAD_TRANSFER_KIND = exports.UPLOAD_STATUS = exports.UPLOAD_STEREO = void 0;
+/** kind of stored content */
+exports.UPLOAD_STEREO = {
+    image: 'image',
+    video: 'video',
+    sound: 'sound',
+    docs: 'docs',
+};
+/** lifecycle of one upload as the client sees it. `url` is meaningful only when `stored` */
+exports.UPLOAD_STATUS = {
+    /** ticket issued; bytes not confirmed by the server yet */
+    pending: 'pending',
+    /** bytes durable and `url` valid */
+    stored: 'stored',
+    /** terminal; `error` carries the server's detail */
+    failed: 'failed',
+};
+/** how bytes travel. a new transfer method arrives as a new kind; the flow around it does not change */
+exports.UPLOAD_TRANSFER_KIND = {
+    /** base64 in a JSON body, through the `send` operation */
+    inline: 'inline',
+    /** HTTP PUT straight to storage, to a server-issued url with its headers */
+    presignedPut: 'presigned-put',
+};
+const isUploadStored = (upload) => upload.status === exports.UPLOAD_STATUS.stored && typeof upload.id === 'string' && typeof upload.url === 'string';
+exports.isUploadStored = isUploadStored;
+/** who produced a failure */
+exports.UPLOAD_FAILURE_SOURCE = {
+    /** the upload API answered with an error */
+    api: 'api',
+    /** the storage endpoint (presigned PUT) answered with an error */
+    storage: 'storage',
+    /** the client gave up before or without a response */
+    client: 'client',
+};
+/** normalized failure codes; the app branches on these, never on raw HTTP status */
+exports.UPLOAD_FAILURE_CODE = {
+    invalid: 'invalid',
+    tooLarge: 'too-large',
+    unsupported: 'unsupported',
+    notAcceptable: 'not-acceptable',
+    notFound: 'not-found',
+    conflict: 'conflict',
+    expired: 'expired',
+    signature: 'signature',
+    checksum: 'checksum',
+    network: 'network',
+    aborted: 'aborted',
+    unknown: 'unknown',
+};
+/** HTTP binding relative to the server's upload base path (lemon-core `/{type}/{id}/{cmd}` shape) */
+exports.UPLOAD_ROUTES = {
+    start: { method: 'POST', path: '/start' },
+    send: { method: 'POST', path: '/{id}/send' },
+    complete: { method: 'POST', path: '/complete' },
+    read: { method: 'GET', path: '/{id}' },
+};
+/** shared stereo derivation so an optimistic client tile and the server agree */
+const uploadStereoOf = (contentType) => {
+    const type = contentType.toLowerCase().split(';')[0].trim();
+    if (type.startsWith('image/'))
+        return exports.UPLOAD_STEREO.image;
+    if (type.startsWith('video/'))
+        return exports.UPLOAD_STEREO.video;
+    if (type.startsWith('audio/'))
+        return exports.UPLOAD_STEREO.sound;
+    if (type === 'application/pdf')
+        return exports.UPLOAD_STEREO.docs;
+    return undefined;
+};
+exports.uploadStereoOf = uploadStereoOf;
+//# sourceMappingURL=types.js.map

package/dist/upload/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/upload/types.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAEH,6BAA6B;AAChB,QAAA,aAAa,GAAG;IACzB,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,MAAM;CACN,CAAC;AAGX,4FAA4F;AAC/E,QAAA,aAAa,GAAG;IACzB,2DAA2D;IAC3D,OAAO,EAAE,SAAS;IAClB,oCAAoC;IACpC,MAAM,EAAE,QAAQ;IAChB,oDAAoD;IACpD,MAAM,EAAE,QAAQ;CACV,CAAC;AAGX,wGAAwG;AAC3F,QAAA,oBAAoB,GAAG;IAChC,0DAA0D;IAC1D,MAAM,EAAE,QAAQ;IAChB,4EAA4E;IAC5E,YAAY,EAAE,eAAe;CACvB,CAAC;AAoEJ,MAAM,cAAc,GAAG,CAAC,MAAc,EAA0B,EAAE,CACrE,MAAM,CAAC,MAAM,KAAK,qBAAa,CAAC,MAAM,IAAI,OAAO,MAAM,CAAC,EAAE,KAAK,QAAQ,IAAI,OAAO,MAAM,CAAC,GAAG,KAAK,QAAQ,CAAC;AADjG,QAAA,cAAc,kBACmF;AA0E9G,6BAA6B;AAChB,QAAA,qBAAqB,GAAG;IACjC,4CAA4C;IAC5C,GAAG,EAAE,KAAK;IACV,kEAAkE;IAClE,OAAO,EAAE,SAAS;IAClB,sDAAsD;IACtD,MAAM,EAAE,QAAQ;CACV,CAAC;AAGX,oFAAoF;AACvE,QAAA,mBAAmB,GAAG;IAC/B,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,WAAW;IACrB,WAAW,EAAE,aAAa;IAC1B,aAAa,EAAE,gBAAgB;IAC/B,QAAQ,EAAE,WAAW;IACrB,QAAQ,EAAE,UAAU;IACpB,OAAO,EAAE,SAAS;IAClB,SAAS,EAAE,WAAW;IACtB,QAAQ,EAAE,UAAU;IACpB,OAAO,EAAE,SAAS;IAClB,OAAO,EAAE,SAAS;IAClB,OAAO,EAAE,SAAS;CACZ,CAAC;AA+CX,qGAAqG;AACxF,QAAA,aAAa,GAAG;IACzB,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE;IACzC,IAAI,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE;IAC5C,QAAQ,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE;IAC/C,IAAI,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE;CAChC,CAAC;AAEX,iFAAiF;AAC1E,MAAM,cAAc,GAAG,CAAC,WAAmB,EAA4B,EAAE;IAC5E,MAAM,IAAI,GAAG,WAAW,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IAC5D,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC;QAAE,OAAO,qBAAa,CAAC,KAAK,CAAC;IAC1D,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC;QAAE,OAAO,qBAAa,CAAC,KAAK,CAAC;IAC1D,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC;QAAE,OAAO,qBAAa,CAAC,KAAK,CAAC;IAC1D,IAAI,IAAI,KAAK,iBAAiB;QAAE,OAAO,qBAAa,CAAC,IAAI,CAAC;IAC1D,OAAO,SAAS,CAAC;AACrB,CAAC,CAAC;AAPW,QAAA,cAAc,kBAOzB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lemon-model",
-  "version": "1.2.4",
+  "version": "1.5.0",
   "description": "Common shared model definitions for Lemon Micro-Service Platform",
   "main": "dist/index.js",
   "module": "dist/esm/index.js",
@@ -42,8 +42,33 @@
       "require": "./dist/logtrace/testing.js",
       "default": "./dist/logtrace/testing.js"
     },
+    "./upload": {
+      "types": "./dist/upload/index.d.ts",
+      "import": "./dist/esm/upload/index.js",
+      "require": "./dist/upload/index.js",
+      "default": "./dist/upload/index.js"
+    },
+    "./upload/testing": {
+      "types": "./dist/upload/testing.d.ts",
+      "import": "./dist/esm/upload/testing.js",
+      "require": "./dist/upload/testing.js",
+      "default": "./dist/upload/testing.js"
+    },
+    "./upload/engine": {
+      "types": "./dist/upload/engine/index.d.ts",
+      "import": "./dist/esm/upload/engine/index.js",
+      "require": "./dist/upload/engine/index.js",
+      "default": "./dist/upload/engine/index.js"
+    },
     "./package.json": "./package.json"
   },
+  "typesVersions": {
+    "*": {
+      "upload": ["dist/upload/index.d.ts"],
+      "upload/testing": ["dist/upload/testing.d.ts"],
+      "upload/engine": ["dist/upload/engine/index.d.ts"]
+    }
+  },
   "scripts": {
     "build": "npm run build-ts && npm run build-esm",
     "build-ts": "tsc -v && tsc",