@jsm-mit/sultana-assets-rust-package 0.1.0

package/dist/actors/admin-actor.js

@@ -0,0 +1,86 @@
+import { Principal } from "@icp-sdk/core/principal";
+import { ActorBase } from "../actor-base.js";
+import { mapWorkerView } from "../mappers.js";
+/**
+ * Administration of sultana-assets-rust. There is no admin identity on this canister:
+ * administration goes THROUGH sultana-core-motoko — core's superadmin calls proxy endpoints
+ * on core (setAssetWorkers, deleteAssetRaw) and core forwards them here. The core-only
+ * methods below therefore answer `false` (or trap) for every caller but the configured core
+ * canister; they are here for wiring scripts, tests and diagnosis.
+ */
+export class AssetsRustAdminActor extends ActorBase {
+    /**
+     * Claim-once bootstrap: while no core canister is configured anyone may set it (call it
+     * right after a deploy); afterwards only the current core canister may re-point it.
+     * @param corePrincipal - The sultana-core-motoko canister this canister trusts.
+     * @returns A Promise that resolves to `true` when set, `false` when the seat is taken by
+     *          another principal than the caller.
+     * @throws CanisterError - The canister trapped.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    async setCoreCanisterAsyncUnsafe(corePrincipal) {
+        return this.executeFunctionAsyncUnsafe(() => this.actor.set_core_canister(Principal.fromText(corePrincipal)));
+    }
+    /**
+     * @returns A Promise that resolves to the trusted core canister, or `null` when none is
+     *          configured yet (a fresh deploy).
+     * @throws CanisterError - The canister trapped.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    async getCoreCanisterAsyncUnsafe() {
+        const result = await this.executeFunctionAsyncUnsafe(() => this.actor.get_core_canister());
+        return result.length === 0 ? null : result[0].toText();
+    }
+    /**
+     * Core-canister only: replaces the transcoding-worker list. The real path is core's
+     * superadmin proxy (sultana-core-motoko-package `AdminActor.setAssetWorkersAsyncUnsafe`).
+     * @param workers - Each worker's identity and its FULL upload-endpoint URL.
+     * @returns A Promise that resolves to `true` when replaced, `false` when the caller is
+     *          not the core canister.
+     * @throws CanisterError - The canister trapped.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    async setWorkersAsyncUnsafe(workers) {
+        return this.executeFunctionAsyncUnsafe(() => this.actor.set_workers(workers.map((w) => ({ principal: Principal.fromText(w.principal), url: w.url }))));
+    }
+    /**
+     * @returns A Promise that resolves to the configured transcoding workers (empty on a
+     *          fresh deploy).
+     * @throws CanisterError - The canister trapped.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    async getWorkersAsyncUnsafe() {
+        const workers = await this.executeFunctionAsyncUnsafe(() => this.actor.get_workers());
+        return workers.map(mapWorkerView);
+    }
+    /**
+     * Core-canister only: raw removal of an asset's bytes (and its thumb or poster) with no
+     * core deregister — cleanup of orphaned bytes. The real path is core's superadmin proxy
+     * `deleteAssetRaw`.
+     * @param assetId - The asset to remove.
+     * @returns A Promise that resolves to `true` when removed, `false` when the caller is not
+     *          the core canister or the asset does not exist.
+     * @throws CanisterError - The canister trapped.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    async deleteAssetAsyncUnsafe(assetId) {
+        return this.executeFunctionAsyncUnsafe(() => this.actor.delete_asset(assetId));
+    }
+    /**
+     * Core-canister only: runs the stale-reservation sweep now (the canister also runs it
+     * every hour). Reservations older than `ttlMs` are marked failed in core and dropped.
+     * @param ttlMs - Age in milliseconds after which a reservation counts as stale.
+     * @returns A Promise that resolves to the number of reservations swept.
+     * @throws CanisterError - The canister trapped: "caller is not the core canister".
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    async runReservationSweepAsyncUnsafe(ttlMs) {
+        return this.executeFunctionAsyncUnsafe(() => this.actor.run_reservation_sweep(BigInt(ttlMs) * 1000000n));
+    }
+}

package/dist/actors/assets-actor.d.ts

@@ -0,0 +1,38 @@
+import { ActorBase } from "../actor-base.js";
+import type { AssetInfoView, HttpGetInput, HttpResponseView } from "../interfaces.js";
+/** Reads: what is stored and how it is served. All queries — anonymous callers are fine. */
+export declare class AssetsRustAssetsActor extends ActorBase {
+    /**
+     * @param assetId - The asset.
+     * @returns A Promise that resolves to the asset's description, or `null` when nothing is
+     *          stored under the id.
+     * @throws CanisterError - The canister trapped.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    getAssetInfoAsyncUnsafe(assetId: string): Promise<AssetInfoView | null>;
+    /**
+     * Every asset physically stored — the raw storage view, independent of any salon library:
+     * thumbnails, posters and orphans included.
+     * @returns A Promise that resolves to every stored asset.
+     * @throws CanisterError - The canister trapped.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    listAssetsAsyncUnsafe(): Promise<AssetInfoView[]>;
+    /**
+     * GET of an asset through the canister's `http_request` query — what the HTTP gateway
+     * calls, without the gateway: 200 with the whole file (certified; for a multi-chunk file
+     * only the first chunk, the rest streams), 206 for a Range header, 404 when not stored.
+     * @param assetId - The asset.
+     * @param input - Request headers, e.g. a Range.
+     * @returns A Promise that resolves to the response.
+     * @throws CanisterError - The canister trapped.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    httpRequestAsyncUnsafe(assetId: string, input?: HttpGetInput): Promise<HttpResponseView>;
+    /** The public URL of an asset on this canister (see {@link assetUrl}). */
+    assetUrl(assetId: string): string;
+}
+//# sourceMappingURL=assets-actor.d.ts.map

package/dist/actors/assets-actor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assets-actor.d.ts","sourceRoot":"","sources":["../../src/actors/assets-actor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAGtF,4FAA4F;AAC5F,qBAAa,qBAAsB,SAAQ,SAAS;IAChD;;;;;;;OAOG;IACU,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAKpF;;;;;;;OAOG;IACU,qBAAqB,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;IAK9D;;;;;;;;;;OAUG;IACU,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,YAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAYzG,0EAA0E;IACnE,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;CAG3C"}

package/dist/actors/assets-actor.js

@@ -0,0 +1,54 @@
+import { ActorBase } from "../actor-base.js";
+import { assetUrl } from "../constants.js";
+import { mapAssetInfoView, mapHttpResponseView } from "../mappers.js";
+/** Reads: what is stored and how it is served. All queries — anonymous callers are fine. */
+export class AssetsRustAssetsActor extends ActorBase {
+    /**
+     * @param assetId - The asset.
+     * @returns A Promise that resolves to the asset's description, or `null` when nothing is
+     *          stored under the id.
+     * @throws CanisterError - The canister trapped.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    async getAssetInfoAsyncUnsafe(assetId) {
+        const result = await this.executeFunctionAsyncUnsafe(() => this.actor.get_asset_info(assetId));
+        return result.length === 0 ? null : mapAssetInfoView(result[0]);
+    }
+    /**
+     * Every asset physically stored — the raw storage view, independent of any salon library:
+     * thumbnails, posters and orphans included.
+     * @returns A Promise that resolves to every stored asset.
+     * @throws CanisterError - The canister trapped.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    async listAssetsAsyncUnsafe() {
+        const assets = await this.executeFunctionAsyncUnsafe(() => this.actor.list_assets());
+        return assets.map(mapAssetInfoView);
+    }
+    /**
+     * GET of an asset through the canister's `http_request` query — what the HTTP gateway
+     * calls, without the gateway: 200 with the whole file (certified; for a multi-chunk file
+     * only the first chunk, the rest streams), 206 for a Range header, 404 when not stored.
+     * @param assetId - The asset.
+     * @param input - Request headers, e.g. a Range.
+     * @returns A Promise that resolves to the response.
+     * @throws CanisterError - The canister trapped.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    async httpRequestAsyncUnsafe(assetId, input = {}) {
+        const response = await this.executeFunctionAsyncUnsafe(() => this.actor.http_request({
+            method: "GET",
+            url: `/asset/${assetId}`,
+            headers: Object.entries(input.headers ?? {}),
+            body: new Uint8Array(),
+        }));
+        return mapHttpResponseView(response);
+    }
+    /** The public URL of an asset on this canister (see {@link assetUrl}). */
+    assetUrl(assetId) {
+        return assetUrl(this.canisterId, assetId);
+    }
+}

package/dist/actors/salon-actor.d.ts

@@ -0,0 +1,64 @@
+import { ActorBase } from "../actor-base.js";
+import type { ReservationView, ReserveRenderInput, ReserveTranscodingUploadInput, UploadImageInput } from "../interfaces.js";
+/**
+ * A salon owner's library on sultana-assets-rust. Every method here asks sultana-core-motoko
+ * first (inter-canister): core decides whether the caller is the salon's current owner and
+ * whether the salon's storage quota allows it, and core keeps the library entry. A refusal by
+ * core — or a core that cannot be reached — comes back as a trap.
+ */
+export declare class AssetsRustSalonActor extends ActorBase {
+    /**
+     * Single-shot image upload into the salon's library: core's canUploadAsset, a generated
+     * thumbnail, both stored, then core's registerAsset (both removed again when that fails).
+     * @param input - Salon, image and an optional service to attach it to.
+     * @returns A Promise that resolves to the image's asset id.
+     * @throws CanisterError - The canister trapped: anonymous caller, file too large, "upload
+     *         not authorized: …" (core refused or unreachable), "thumbnail generation failed:
+     *         …" (not an image), "register failed, rolled back: …".
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    uploadImageAsyncUnsafe(input: UploadImageInput): Promise<string>;
+    /**
+     * Deletes any asset of the salon's library (videos included), core first: core removes
+     * the library entry (blocked while a salon service still uses it), then the bytes and the
+     * thumb or poster go. An unfinished transcoding job's rabbit task is closed as cancelled.
+     * @param salonId - The salon.
+     * @param assetId - The asset.
+     * @returns A Promise that resolves to `true` when bytes were removed, `false` when core
+     *          allowed the delete but no bytes were stored under the id.
+     * @throws CanisterError - The canister trapped: anonymous caller, "deregister failed
+     *         (delete blocked): …" (core refused or unreachable).
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    deleteSalonAssetAsyncUnsafe(salonId: string, assetId: string): Promise<boolean>;
+    /**
+     * Reserves a transcoding job — nothing is stored yet. Core admits it (owner, quota hold)
+     * and gets a #Pending library entry; a rabbit task is enqueued. The caller then uploads the
+     * source straight to one of the returned worker URLs (sultana-core-motoko-package's
+     * VideoUploadClient does the whole flow).
+     * @param input - Salon, kind (default video) and the library name.
+     * @returns A Promise that resolves to the reserved id and the worker upload URLs.
+     * @throws CanisterError - The canister trapped: anonymous caller, "no transcoding workers
+     *         configured", "upload not authorized: …", "pending registration failed: …", a
+     *         rabbit failure.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    reserveTranscodingUploadAsyncUnsafe(input: ReserveTranscodingUploadInput): Promise<ReservationView>;
+    /**
+     * Reserves a promo render: a new video a worker makes from a stored picture or video and
+     * a stored music track. The inputs are checked here (stored, right content types, settings
+     * in range) before core is asked. The caller then asks a worker to start the render.
+     * @param input - Salon, the two stored inputs and the render settings.
+     * @returns A Promise that resolves to the reserved id and the worker URLs.
+     * @throws CanisterError - The canister trapped: anonymous caller, "no transcoding workers
+     *         configured", a bad id shape, an input that is not stored or of the wrong type,
+     *         a setting out of range, "upload not authorized: …", a rabbit failure.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    reserveRenderAsyncUnsafe(input: ReserveRenderInput): Promise<ReservationView>;
+}
+//# sourceMappingURL=salon-actor.d.ts.map

package/dist/actors/salon-actor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"salon-actor.d.ts","sourceRoot":"","sources":["../../src/actors/salon-actor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,6BAA6B,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAG7H;;;;;GAKG;AACH,qBAAa,oBAAqB,SAAQ,SAAS;IAC/C;;;;;;;;;;OAUG;IACU,sBAAsB,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC;IAY7E;;;;;;;;;;;;OAYG;IACU,2BAA2B,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAI5F;;;;;;;;;;;;OAYG;IACU,mCAAmC,CAAC,KAAK,EAAE,6BAA6B,GAAG,OAAO,CAAC,eAAe,CAAC;IAWhH;;;;;;;;;;;OAWG;IACU,wBAAwB,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,eAAe,CAAC;CAe7F"}

package/dist/actors/salon-actor.js

@@ -0,0 +1,92 @@
+import { ActorBase } from "../actor-base.js";
+import { mapReservationView, toCandidOpt, toCandidRenderMode, toCandidTranscodingKind } from "../mappers.js";
+/**
+ * A salon owner's library on sultana-assets-rust. Every method here asks sultana-core-motoko
+ * first (inter-canister): core decides whether the caller is the salon's current owner and
+ * whether the salon's storage quota allows it, and core keeps the library entry. A refusal by
+ * core — or a core that cannot be reached — comes back as a trap.
+ */
+export class AssetsRustSalonActor extends ActorBase {
+    /**
+     * Single-shot image upload into the salon's library: core's canUploadAsset, a generated
+     * thumbnail, both stored, then core's registerAsset (both removed again when that fails).
+     * @param input - Salon, image and an optional service to attach it to.
+     * @returns A Promise that resolves to the image's asset id.
+     * @throws CanisterError - The canister trapped: anonymous caller, file too large, "upload
+     *         not authorized: …" (core refused or unreachable), "thumbnail generation failed:
+     *         …" (not an image), "register failed, rolled back: …".
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    async uploadImageAsyncUnsafe(input) {
+        return this.executeFunctionAsyncUnsafe(() => this.actor.upload_image({
+            salonId: input.salonId,
+            name: input.name,
+            contentType: input.contentType,
+            data: input.data,
+            targetSalonServiceId: toCandidOpt(input.targetSalonServiceId),
+        }));
+    }
+    /**
+     * Deletes any asset of the salon's library (videos included), core first: core removes
+     * the library entry (blocked while a salon service still uses it), then the bytes and the
+     * thumb or poster go. An unfinished transcoding job's rabbit task is closed as cancelled.
+     * @param salonId - The salon.
+     * @param assetId - The asset.
+     * @returns A Promise that resolves to `true` when bytes were removed, `false` when core
+     *          allowed the delete but no bytes were stored under the id.
+     * @throws CanisterError - The canister trapped: anonymous caller, "deregister failed
+     *         (delete blocked): …" (core refused or unreachable).
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    async deleteSalonAssetAsyncUnsafe(salonId, assetId) {
+        return this.executeFunctionAsyncUnsafe(() => this.actor.delete_salon_asset({ salonId, id: assetId }));
+    }
+    /**
+     * Reserves a transcoding job — nothing is stored yet. Core admits it (owner, quota hold)
+     * and gets a #Pending library entry; a rabbit task is enqueued. The caller then uploads the
+     * source straight to one of the returned worker URLs (sultana-core-motoko-package's
+     * VideoUploadClient does the whole flow).
+     * @param input - Salon, kind (default video) and the library name.
+     * @returns A Promise that resolves to the reserved id and the worker upload URLs.
+     * @throws CanisterError - The canister trapped: anonymous caller, "no transcoding workers
+     *         configured", "upload not authorized: …", "pending registration failed: …", a
+     *         rabbit failure.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    async reserveTranscodingUploadAsyncUnsafe(input) {
+        const reservation = await this.executeFunctionAsyncUnsafe(() => this.actor.reserve_transcoding_upload({
+            salonId: input.salonId,
+            kind: input.kind === undefined ? [] : [toCandidTranscodingKind(input.kind)],
+            name: toCandidOpt(input.name),
+        }));
+        return mapReservationView(reservation);
+    }
+    /**
+     * Reserves a promo render: a new video a worker makes from a stored picture or video and
+     * a stored music track. The inputs are checked here (stored, right content types, settings
+     * in range) before core is asked. The caller then asks a worker to start the render.
+     * @param input - Salon, the two stored inputs and the render settings.
+     * @returns A Promise that resolves to the reserved id and the worker URLs.
+     * @throws CanisterError - The canister trapped: anonymous caller, "no transcoding workers
+     *         configured", a bad id shape, an input that is not stored or of the wrong type,
+     *         a setting out of range, "upload not authorized: …", a rabbit failure.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    async reserveRenderAsyncUnsafe(input) {
+        const reservation = await this.executeFunctionAsyncUnsafe(() => this.actor.reserve_render({
+            salonId: input.salonId,
+            sourceAssetId: input.sourceAssetId,
+            audioAssetId: input.audioAssetId,
+            mode: toCandidRenderMode(input.mode),
+            musicVolumePct: input.musicVolumePct,
+            musicStartSec: toCandidOpt(input.musicStartSec),
+            slideDurationSec: toCandidOpt(input.slideDurationSec),
+            name: toCandidOpt(input.name),
+        }));
+        return mapReservationView(reservation);
+    }
+}

package/dist/actors/uploads-actor.d.ts

@@ -0,0 +1,74 @@
+import { ActorBase } from "../actor-base.js";
+import type { ChunkedUploadOptions, StartUploadInput, UploadAssetInput } from "../interfaces.js";
+/**
+ * Generic uploads, not tied to a salon: a chunked session (start → chunks → finish) or a
+ * single-shot upload. Any signed-in caller may upload; the session belongs to its starter.
+ * Salon-library uploads go through {@link AssetsRustSalonActor} instead.
+ */
+export declare class AssetsRustUploadsActor extends ActorBase {
+    /**
+     * Opens a chunked upload session owned by the caller. An unfinished session is purged
+     * after 30 minutes.
+     * @param input - Name, content type and the number of chunks that will follow.
+     * @returns A Promise that resolves to the new asset id (the session id).
+     * @throws CanisterError - The canister trapped: anonymous caller, totalChunks 0.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    startUploadAsyncUnsafe(input: StartUploadInput): Promise<string>;
+    /**
+     * Stores one chunk of an open session (the caller's own session, or — for a worker — a
+     * system session it started). Re-sending an index overwrites it.
+     * @param assetId - The session id.
+     * @param index - 0-based chunk index, below the session's totalChunks.
+     * @param data - At most ASSETS_RUST_LIMITS.chunkSizeBytes.
+     * @throws CanisterError - The canister trapped: chunk too big, unknown session, not the
+     *         session owner, index out of range.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    uploadChunkAsyncUnsafe(assetId: string, index: number, data: Uint8Array): Promise<void>;
+    /**
+     * Assembles the session into a stored, certified asset.
+     * @param assetId - The session id.
+     * @returns A Promise that resolves to the asset id.
+     * @throws CanisterError - The canister trapped: unknown session, not the session owner,
+     *         not all chunks received.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    finishUploadAsyncUnsafe(assetId: string): Promise<string>;
+    /**
+     * Drops an open session and its chunks.
+     * @param assetId - The session id.
+     * @returns A Promise that resolves to `true` when dropped, `false` when there is no such
+     *          session (finished, aborted or purged).
+     * @throws CanisterError - The canister trapped: not the session owner.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    abortUploadAsyncUnsafe(assetId: string): Promise<boolean>;
+    /**
+     * Single-shot upload of a small file.
+     * @param input - Name, content type and at most ASSETS_RUST_LIMITS.chunkSizeBytes of data.
+     * @returns A Promise that resolves to the new asset id.
+     * @throws CanisterError - The canister trapped: anonymous caller, file too large.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    uploadAssetAsyncUnsafe(input: UploadAssetInput): Promise<string>;
+    /**
+     * Uploads `bytes` of any size as one asset: start, every chunk in order, finish. A failed
+     * chunk or finish aborts the session (best effort) before the error is re-thrown.
+     * @param name - The asset's name.
+     * @param contentType - The asset's content type (served as Content-Type).
+     * @param bytes - The file.
+     * @param options - Chunk size and a progress callback.
+     * @returns A Promise that resolves to the stored asset's id.
+     * @throws CanisterError - The canister trapped in one of the three steps.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    uploadBytesAsyncUnsafe(name: string, contentType: string, bytes: Uint8Array, options?: ChunkedUploadOptions): Promise<string>;
+}
+//# sourceMappingURL=uploads-actor.d.ts.map

package/dist/actors/uploads-actor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploads-actor.d.ts","sourceRoot":"","sources":["../../src/actors/uploads-actor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,KAAK,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEjG;;;;GAIG;AACH,qBAAa,sBAAuB,SAAQ,SAAS;IACjD;;;;;;;;OAQG;IACU,sBAAsB,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC;IAI7E;;;;;;;;;;OAUG;IACU,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAIpG;;;;;;;;OAQG;IACU,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAItE;;;;;;;;OAQG;IACU,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAItE;;;;;;;OAOG;IACU,sBAAsB,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC;IAI7E;;;;;;;;;;;OAWG;IACU,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAAC,MAAM,CAAC;CAgBjJ"}

package/dist/actors/uploads-actor.js

@@ -0,0 +1,97 @@
+import { ActorBase } from "../actor-base.js";
+import { splitIntoChunks } from "../constants.js";
+/**
+ * Generic uploads, not tied to a salon: a chunked session (start → chunks → finish) or a
+ * single-shot upload. Any signed-in caller may upload; the session belongs to its starter.
+ * Salon-library uploads go through {@link AssetsRustSalonActor} instead.
+ */
+export class AssetsRustUploadsActor extends ActorBase {
+    /**
+     * Opens a chunked upload session owned by the caller. An unfinished session is purged
+     * after 30 minutes.
+     * @param input - Name, content type and the number of chunks that will follow.
+     * @returns A Promise that resolves to the new asset id (the session id).
+     * @throws CanisterError - The canister trapped: anonymous caller, totalChunks 0.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    async startUploadAsyncUnsafe(input) {
+        return this.executeFunctionAsyncUnsafe(() => this.actor.start_upload({ name: input.name, contentType: input.contentType, totalChunks: input.totalChunks }));
+    }
+    /**
+     * Stores one chunk of an open session (the caller's own session, or — for a worker — a
+     * system session it started). Re-sending an index overwrites it.
+     * @param assetId - The session id.
+     * @param index - 0-based chunk index, below the session's totalChunks.
+     * @param data - At most ASSETS_RUST_LIMITS.chunkSizeBytes.
+     * @throws CanisterError - The canister trapped: chunk too big, unknown session, not the
+     *         session owner, index out of range.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    async uploadChunkAsyncUnsafe(assetId, index, data) {
+        await this.executeFunctionAsyncUnsafe(() => this.actor.upload_chunk(assetId, index, data));
+    }
+    /**
+     * Assembles the session into a stored, certified asset.
+     * @param assetId - The session id.
+     * @returns A Promise that resolves to the asset id.
+     * @throws CanisterError - The canister trapped: unknown session, not the session owner,
+     *         not all chunks received.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    async finishUploadAsyncUnsafe(assetId) {
+        return this.executeFunctionAsyncUnsafe(() => this.actor.finish_upload(assetId));
+    }
+    /**
+     * Drops an open session and its chunks.
+     * @param assetId - The session id.
+     * @returns A Promise that resolves to `true` when dropped, `false` when there is no such
+     *          session (finished, aborted or purged).
+     * @throws CanisterError - The canister trapped: not the session owner.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    async abortUploadAsyncUnsafe(assetId) {
+        return this.executeFunctionAsyncUnsafe(() => this.actor.abort_upload(assetId));
+    }
+    /**
+     * Single-shot upload of a small file.
+     * @param input - Name, content type and at most ASSETS_RUST_LIMITS.chunkSizeBytes of data.
+     * @returns A Promise that resolves to the new asset id.
+     * @throws CanisterError - The canister trapped: anonymous caller, file too large.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    async uploadAssetAsyncUnsafe(input) {
+        return this.executeFunctionAsyncUnsafe(() => this.actor.upload_asset({ name: input.name, contentType: input.contentType, data: input.data }));
+    }
+    /**
+     * Uploads `bytes` of any size as one asset: start, every chunk in order, finish. A failed
+     * chunk or finish aborts the session (best effort) before the error is re-thrown.
+     * @param name - The asset's name.
+     * @param contentType - The asset's content type (served as Content-Type).
+     * @param bytes - The file.
+     * @param options - Chunk size and a progress callback.
+     * @returns A Promise that resolves to the stored asset's id.
+     * @throws CanisterError - The canister trapped in one of the three steps.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    async uploadBytesAsyncUnsafe(name, contentType, bytes, options = {}) {
+        const chunks = splitIntoChunks(bytes, options.chunkSizeBytes);
+        const assetId = await this.startUploadAsyncUnsafe({ name, contentType, totalChunks: chunks.length });
+        try {
+            for (let index = 0; index < chunks.length; index++) {
+                await this.uploadChunkAsyncUnsafe(assetId, index, chunks[index]);
+                options.onProgress?.({ uploadedChunks: index + 1, totalChunks: chunks.length });
+            }
+            return await this.finishUploadAsyncUnsafe(assetId);
+        }
+        catch (err) {
+            await this.abortUploadAsyncUnsafe(assetId).catch(() => false);
+            throw err;
+        }
+    }
+}

package/dist/actors/worker-actor.d.ts

@@ -0,0 +1,72 @@
+import { ActorBase } from "../actor-base.js";
+import type { ChunkedUploadOptions, SystemStartUploadInput } from "../interfaces.js";
+/**
+ * The transcoding worker's side: it stores a finished result under the id the salon
+ * reserved. Every method traps unless the caller's principal is on the canister's worker list
+ * (`set_workers`, driven by core's superadmin).
+ */
+export declare class AssetsRustWorkerActor extends ActorBase {
+    /**
+     * Opens a chunked upload session under a reserved id.
+     * @param input - The reserved id, name, content type and number of chunks.
+     * @returns A Promise that resolves to the id.
+     * @throws CanisterError - The canister trapped: "caller is not a transcoding worker",
+     *         totalChunks 0, "asset already exists".
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    systemStartUploadAsyncUnsafe(input: SystemStartUploadInput): Promise<string>;
+    /**
+     * Stores one chunk of a session this worker started.
+     * @param assetId - The session id.
+     * @param index - 0-based chunk index.
+     * @param data - At most ASSETS_RUST_LIMITS.chunkSizeBytes.
+     * @throws CanisterError - The canister trapped: chunk too big, unknown session, not the
+     *         session owner, index out of range.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    uploadChunkAsyncUnsafe(assetId: string, index: number, data: Uint8Array): Promise<void>;
+    /**
+     * Opens a system session under `assetId` and sends every chunk of `bytes` — everything but
+     * the finish, because a video and its poster are finished together
+     * ({@link finishSystemUploadAsyncUnsafe}).
+     * @param assetId - The reserved id (or the poster's own id).
+     * @param name - The stored name.
+     * @param contentType - The stored content type.
+     * @param bytes - The file.
+     * @param options - Chunk size and a progress callback.
+     * @throws CanisterError - The canister trapped in start or in a chunk.
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    systemUploadBytesAsyncUnsafe(assetId: string, name: string, contentType: string, bytes: Uint8Array, options?: ChunkedUploadOptions): Promise<void>;
+    /**
+     * Finishes the result (and its poster session, when given) and — when the id was
+     * reserved by a salon — registers it in that salon's core library with the poster as its
+     * thumb. Safe to retry after a failed registration: stored bytes are not stored again.
+     * @param assetId - The reserved id.
+     * @param posterId - The poster frame's session id, uploaded alongside.
+     * @returns A Promise that resolves to the asset id.
+     * @throws CanisterError - The canister trapped: "caller is not a transcoding worker",
+     *         "posterId must differ from the video id", an incomplete session, "asset register
+     *         failed: …" (core refused or unreachable; the reservation is kept for a retry).
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    finishSystemUploadAsyncUnsafe(assetId: string, posterId?: string): Promise<string>;
+    /**
+     * Reports a failed transcode: the salon's #Pending library entry becomes #Failed(reason)
+     * and the reservation is dropped.
+     * @param assetId - The reserved id.
+     * @param reason - What went wrong (a JSON error payload the front translates).
+     * @returns A Promise that resolves to `true` when reported, `false` when there is no such
+     *          reservation (finished, deleted or swept).
+     * @throws CanisterError - The canister trapped: "caller is not a transcoding worker",
+     *         "markAssetFailed rejected: …" (the reservation is kept; the sweep retries).
+     * @throws CallRefusedAtInspectionStage - The call was refused at the inspect stage.
+     * @throws CriticalCanisterError - Transport failure or an unreachable canister.
+     */
+    failSystemUploadAsyncUnsafe(assetId: string, reason: string): Promise<boolean>;
+}
+//# sourceMappingURL=worker-actor.d.ts.map

package/dist/actors/worker-actor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-actor.d.ts","sourceRoot":"","sources":["../../src/actors/worker-actor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,KAAK,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAErF;;;;GAIG;AACH,qBAAa,qBAAsB,SAAQ,SAAS;IAChD;;;;;;;;OAQG;IACU,4BAA4B,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,MAAM,CAAC;IAIzF;;;;;;;;;OASG;IACU,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAIpG;;;;;;;;;;;;OAYG;IACU,4BAA4B,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;IAUnK;;;;;;;;;;;;OAYG;IACU,6BAA6B,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAI/F;;;;;;;;;;;OAWG;IACU,2BAA2B,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAG9F"}