@openrails/contentkit-ui 0.0.0-stage → 0.68.1

package/dist/client/media/client.d.ts

@@ -0,0 +1,247 @@
+import { CommitBody, Edit, FileInfo, Op, PresetRule, ReadResult, RefBody } from '../generated/wire.js';
+import { Http } from '../http.js';
+import { MediaApi, ReadOptions } from './api.js';
+import { Transport } from './transport.js';
+/** Upload tuning for the media module. */
+export interface MediaOptions {
+    /** Sends presigned PUTs. Default XMLHttpRequest (upload progress), else fetch. */
+    transport?: Transport;
+    /** Parallel parts per multipart upload (the pacer may run fewer). Default 4. */
+    concurrency?: number;
+    /** Retries per part and per idempotent API call. Default 5. */
+    retries?: number;
+    /** Delay before retry attempt (0-based); retryAfter is the server's hint in seconds. */
+    retryDelay?: (attempt: number, retryAfter?: number) => number;
+    /** Seconds one part should take. Default 30. */
+    targetPartSeconds?: number;
+}
+export interface Progress {
+    /** processing: committed, waiting for the worker (put). */
+    phase: "hashing" | "uploading" | "completing" | "processing";
+    loaded: number;
+    total: number;
+}
+export interface UploadOptions {
+    ref: RefBody;
+    /** The upload path: a literal ("cover") or under a pattern ("originals/001.png"); the server cleans it and adds the extension. */
+    path: string;
+    /** Content type; default the file's. */
+    type?: string;
+    /** Aborting pauses: a multipart upload stays resumable from the last state. */
+    signal?: AbortSignal;
+    onProgress?: (p: Progress) => void;
+    /** State saved from onState, to resume a multipart upload of the same file. */
+    resume?: UploadState;
+    /** Resumable state after every change; null once the upload completed. Persist it to survive a reload. */
+    onState?: (s: UploadState | null) => void;
+}
+/** An upload, ready for a put op. */
+export interface UploadedFile {
+    /** The path to commit: cleaned, with an extension, named by the server for a Named upload. */
+    path: string;
+    /**
+     * The name to commit: the folder's identical blob ("sha256-{hex}-{uuid}") when
+     * exists, else the staged upload ("u-{uuid}") the worker hashes and places
+     * after the commit.
+     */
+    blob: string;
+    type: string;
+    size: number;
+    /** The identical file was already in the item's folder; nothing was sent. */
+    exists: boolean;
+    /** The host processes files on upload: commit it unattached now (the queue does). */
+    processOnUpload?: boolean;
+}
+/** The put op's fields besides path and blob. */
+export interface PutOptions {
+    /** Refuse to replace an existing upload. Default false. */
+    createOnly?: boolean;
+    edit?: Edit | null;
+    meta?: Record<string, unknown>;
+    index?: number;
+    /** Wait until the worker processed the upload (waitFor). Default true. */
+    wait?: boolean;
+    /** How long to wait, ms. */
+    timeout?: number;
+    /** The upload, before the commit. */
+    onUploaded?: (up: UploadedFile) => void;
+}
+export interface WaitOptions {
+    signal?: AbortSignal;
+    /** Poll interval, ms. Default 1000. */
+    interval?: number;
+    /** ms; then render_timeout. Default 120000. */
+    timeout?: number;
+}
+export interface PlannedPart {
+    number: number;
+    offset: number;
+    size: number;
+    sha256?: string;
+}
+/** A multipart upload in flight; JSON-serializable. */
+export interface UploadState {
+    ticket: string;
+    path: string;
+    /** The staged upload ("u-{uuid}") the parts write. */
+    blob: string;
+    type: string;
+    size: number;
+    ref: RefBody;
+    file: {
+        name?: string;
+        lastModified?: number;
+        size: number;
+    };
+    limits: {
+        minPartSize: number;
+        maxPartSize: number;
+        maxParts: number;
+    };
+    parts: PlannedPart[];
+    processOnUpload?: boolean;
+}
+/** An upload to a server-named (Named) path: a post's or poll's image. */
+export interface NamedOptions {
+    /** The requested path; the server names the file. Default the file's name. */
+    path?: string;
+    signal?: AbortSignal;
+    onProgress?: (p: Progress) => void;
+    /** Wait until the worker processed it. Default true. */
+    wait?: boolean;
+    /** How long to wait, ms. */
+    timeout?: number;
+}
+/** An upload to a Named path, committed. */
+export interface NamedUpload {
+    /** The server's name for it ("i-{uuid}"), which content routes take. */
+    name: string;
+    path: string;
+    file: FileInfo;
+}
+/** The media kinds of post and poll folders (content.Media.PostKind and PollKind). */
+export interface ContentFolders {
+    /** Default "post". */
+    post?: string;
+    /** Default "poll". */
+    poll?: string;
+}
+/** A file to upload again when its blob is gone at commit; type defaults to the file's. */
+export type CommitSource = Blob | {
+    file: Blob;
+    type?: string;
+};
+export interface CommitOptions {
+    signal?: AbortSignal;
+    /** UUID for this complete batch. Keep it with unchanged ops for a later retry; default a new UUID. */
+    operationID?: string;
+    /** Persist the active batch before sending it, including any replacement after re-upload. Resume with its ops and operation_id. */
+    onState?: (batch: CommitBody) => void;
+    /** Blob ("sha256-…") → the file it was uploaded from. */
+    sources?: Record<string, CommitSource>;
+}
+type Uploadable = Blob & {
+    name?: string;
+    lastModified?: number;
+};
+/** A path names a file by its full path or, for an upload, its stem ("cover" for "cover.png"). */
+export declare const samePath: (file: string, path: string) => boolean;
+/** The path without its extension. */
+export declare const stem: (path: string) => string;
+/** The media module: uploads, commits, reads, frames and HLS. */
+export declare class MediaClient {
+    private readonly http;
+    readonly api: MediaApi;
+    private readonly transport;
+    private readonly concurrency;
+    private readonly retries;
+    private readonly delay;
+    private readonly targetSeconds;
+    private presetList?;
+    private readonly folders;
+    constructor(http: Http, o?: MediaOptions, folders?: ContentFolders);
+    /**
+     * Uploads file to the item's folder: it hashes the whole file (off the
+     * main thread) and presigns {path, type, size, sha256}, then sends nothing
+     * (the folder holds the identical blob), or stages it: one checksum-bound
+     * PUT up to 64 MiB, resumable multipart above. A refused presign throws
+     * before any bytes move. Commit the result with a put op (or use put());
+     * the worker then places a staged upload at the hash of its bytes.
+     */
+    upload(file: Uploadable, o: UploadOptions): Promise<UploadedFile>;
+    /**
+     * Uploads file and commits it as a put to its path (with edit, meta and
+     * index), then by default waits until the worker processed it; resolves
+     * with the upload as an editor reads it.
+     */
+    put(file: Uploadable, o: UploadOptions & PutOptions): Promise<FileInfo>;
+    /**
+     * Applies ops to the item in one conditional write; returns its uploads as
+     * an editor reads them. With sources (blob → the file uploaded as it), a
+     * not_uploaded refusal (the blob expired or is due for cleanup) uploads
+     * the affected files again and retries the commit once.
+     */
+    commit(ref: RefBody, ops: Op[], o?: CommitOptions): Promise<FileInfo[]>;
+    /** The read API: the item's files under prefix in manifest order, with signed URLs for what this viewer may have. */
+    read(ref: RefBody, o?: ReadOptions & {
+        signal?: AbortSignal;
+    }): Promise<ReadResult>;
+    /**
+     * Polls an editor read until the upload at path (or with that stem) is
+     * processed: placed (not staged), nothing pending and its blob present (a
+     * frame grabbed).
+     * Rejects with its failure, not_found once it is gone, too_large while the
+     * item is full (nothing is processed until uploads are removed),
+     * render_timeout after the timeout.
+     */
+    waitFor(ref: RefBody, path: string, o?: WaitOptions): Promise<FileInfo>;
+    /**
+     * The upload's editor view, for re-cropping: its URL and the upload's
+     * oriented size. Waits while it renders (an editor read asks for it);
+     * not_found when the path has no upload, render_timeout after the timeout
+     * (default 30 s).
+     */
+    editorView(ref: RefBody, path: string, o?: WaitOptions): Promise<{
+        url: string;
+        width: number;
+        height: number;
+        edit?: Edit;
+    }>;
+    /**
+     * Every kind's public presets, fetched once per client: crop bounds,
+     * widths and default images. An item's current image is in its read's
+     * `public`, never built from a preset. Shared by every caller, so it takes
+     * no signal; a failed fetch is retried on the next call.
+     */
+    presets(): Promise<PresetRule[]>;
+    /** A JPEG still of the video upload at path, t seconds in, w pixels wide (default the frame's). */
+    getFrame(ref: RefBody, path: string, t: number, w?: number, signal?: AbortSignal): Promise<Blob>;
+    /** The folder of an HLS ladder from a read's `hls`: `{media}/{kind}/{id}/hls/{dir}`; master.m3u8 and sprite.vtt resolve under it. */
+    hlsBase(ref: RefBody, dir: string): string;
+    /** hls.js `xhrSetup` for playlists on the API (the client's token and credentials); pass it to players as is. */
+    get xhrSetup(): (xhr: XMLHttpRequest, url: string) => Promise<void>;
+    /**
+     * Uploads an image to the item's server-named upload path and commits it
+     * (by default waiting until it is processed); resolves with the name content
+     * routes take: a poll or option image, a post cover.
+     */
+    uploadNamed(ref: RefBody, file: Uploadable, o?: NamedOptions): Promise<NamedUpload>;
+    /** An image for a post's rich-text body: uploaded to the post's folder; resolves with the URL to place in the body. */
+    uploadInline(post: string, file: Uploadable, o?: NamedOptions): Promise<NamedUpload & {
+        url: string;
+    }>;
+    /** The media folder of a post. */
+    postRef(id: string): RefBody;
+    /** The media folder of a poll. */
+    pollRef(id: string): RefBody;
+    /** Discards a paused multipart upload. */
+    discard(state: UploadState): Promise<void>;
+    private resumeMultipart;
+    private multipart;
+    private complete;
+    private retry;
+}
+/** Exponential backoff from 1 s to 30 s with jitter, or the server's Retry-After. */
+export declare function backoff(attempt: number, retryAfter?: number): number;
+export declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
+export {};

package/dist/client/media/client.js

@@ -0,0 +1,407 @@
+import { ContentKitError as e, aborted as t, failureError as n, throwIfAborted as r, toContentKitError as i } from "../errors.js";
+import { call as a } from "../route.js";
+import { MediaApi as o } from "./api.js";
+import { sha256Hex as s } from "./hash.js";
+import { Pacer as c } from "./pacer.js";
+import { defaultTransport as l } from "./transport.js";
+//#region src/client/media/client.ts
+var u = /^i-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/, d = (e, t) => e === t || f(e) === t, f = (e) => {
+	let t = e.lastIndexOf(".");
+	return t > e.lastIndexOf("/") + 1 ? e.slice(0, t) : e;
+}, p = class {
+	http;
+	api;
+	transport;
+	concurrency;
+	retries;
+	delay;
+	targetSeconds;
+	presetList;
+	folders;
+	constructor(e, t = {}, n = {}) {
+		this.http = e, this.folders = {
+			post: n.post ?? "post",
+			poll: n.poll ?? "poll"
+		}, this.api = new o(e), this.transport = t.transport ?? l, this.concurrency = t.concurrency ?? 4, this.retries = t.retries ?? 5, this.delay = t.retryDelay ?? h, this.targetSeconds = t.targetPartSeconds ?? 30;
+	}
+	async upload(t, n) {
+		let i = n.type || t.type;
+		if (!i) throw new e("invalid_request", "the file has no content type");
+		if (r(n.signal), n.resume) return this.resumeMultipart(t, n.resume, n);
+		let a = t.size, o = await s(t, {
+			signal: n.signal,
+			onProgress: (e) => n.onProgress?.({
+				phase: "hashing",
+				loaded: e,
+				total: a
+			})
+		}), c = () => this.api.presign({
+			ref: n.ref,
+			path: n.path,
+			type: i,
+			size: a,
+			sha256: o
+		}, n.signal), l = await c(), u = (e) => ({
+			path: e.path,
+			blob: e.blob,
+			type: i,
+			size: a,
+			exists: !!e.exists,
+			processOnUpload: !!e.process_on_upload
+		});
+		if (l.exists) return u(l);
+		if (l.multipart) {
+			let e = l.multipart, r = {
+				ticket: e.ticket,
+				path: l.path,
+				blob: l.blob,
+				type: i,
+				size: a,
+				ref: n.ref,
+				file: m(t),
+				limits: {
+					minPartSize: e.min_part_size,
+					maxPartSize: e.max_part_size,
+					maxParts: e.max_parts
+				},
+				parts: [],
+				processOnUpload: !!l.process_on_upload
+			};
+			return this.multipart(t, r, /* @__PURE__ */ new Set(), n);
+		}
+		return await this.retry(async () => {
+			l.exists || await this.transport(l.put, t, {
+				signal: n.signal,
+				onProgress: (e) => n.onProgress?.({
+					phase: "uploading",
+					loaded: e,
+					total: a
+				})
+			});
+		}, n.signal, async (e) => {
+			e.code === "storage" && e.status === 403 && (l = await c());
+		}), u(l);
+	}
+	async put(e, t) {
+		let n = await this.upload(e, t);
+		t.onUploaded?.(n);
+		let r = {
+			op: "put",
+			path: n.path,
+			blob: n.blob
+		};
+		t.createOnly && (r.create_id = crypto.randomUUID()), t.edit && (r.edit = t.edit), t.meta && (r.meta = t.meta), t.index !== void 0 && (r.index = t.index);
+		let i = await this.commit(t.ref, [r], {
+			signal: t.signal,
+			sources: { [n.blob]: {
+				file: e,
+				type: n.type
+			} }
+		});
+		return t.wait === !1 ? i.find((e) => e.path === n.path) ?? {
+			path: n.path,
+			type: n.type
+		} : (t.onProgress?.({
+			phase: "processing",
+			loaded: n.size,
+			total: n.size
+		}), this.waitFor(t.ref, n.path, {
+			signal: t.signal,
+			timeout: t.timeout
+		}));
+	}
+	async commit(t, n, r = {}) {
+		let i = this.http.captureChanges(), a = structuredClone({
+			ref: t,
+			ops: n,
+			operation_id: r.operationID ?? crypto.randomUUID()
+		});
+		r.onState?.(structuredClone(a));
+		let o;
+		try {
+			o = (await this.retry(() => this.api.commit(a, r.signal), r.signal)).files;
+		} catch (t) {
+			if (!(t instanceof e) || t.code !== "not_uploaded") throw t;
+			let n = r.sources ?? {}, i = a.ops.filter((e) => e.op === "put" && e.blob && e.blob in n), s = [...new Set(i.map((e) => e.blob))].filter((e) => !t.blobs || t.blobs.includes(e));
+			if (s.length === 0) throw t;
+			let c = /* @__PURE__ */ new Map();
+			for (let e of s) {
+				let t = n[e], o = t instanceof Blob ? t : t.file, s = t instanceof Blob ? void 0 : t.type, l = i.find((t) => t.blob === e);
+				c.set(e, (await this.upload(o, {
+					ref: a.ref,
+					path: l.path,
+					type: s,
+					signal: r.signal
+				})).blob);
+			}
+			let l = a.ops.map((e) => e.blob && c.has(e.blob) ? {
+				...e,
+				blob: c.get(e.blob)
+			} : e), u = {
+				ref: a.ref,
+				ops: l,
+				operation_id: crypto.randomUUID()
+			};
+			r.onState?.(structuredClone(u)), o = (await this.retry(() => this.api.commit(u, r.signal), r.signal)).files;
+		}
+		return i({
+			type: "media.committed",
+			ref: {
+				kind: t.kind,
+				id: t.id
+			},
+			files: o
+		}), o;
+	}
+	async read(e, t = {}) {
+		return this.api.itemURL(e), this.retry(() => this.api.read(e, t, t.signal), t.signal);
+	}
+	async waitFor(t, r, i = {}) {
+		let a = this.http.captureChanges(), o = Date.now() + (i.timeout ?? 12e4);
+		for (;;) {
+			let s = await this.read(t, {
+				editor: !0,
+				prefix: f(r),
+				signal: i.signal
+			}), c = s.files.find((e) => e.upload && d(e.path, r));
+			if (!c) throw new e("not_found", `no upload ${r}`, { status: 404 });
+			if (c.failed) throw n(c.failed);
+			if (!c.pending?.length && !c.staged && (c.size ?? 0) > 0) return a({
+				type: "media.processed",
+				ref: {
+					kind: t.kind,
+					id: t.id
+				},
+				file: c
+			}), c;
+			if (s.full) throw new e("too_large", `${r} waits: the item is full; remove uploads to process more`, { status: 413 });
+			if (Date.now() >= o) throw new e("render_timeout", `${r} is still processing`);
+			await g(i.interval ?? 1e3, i.signal);
+		}
+	}
+	async editorView(t, r, i = {}) {
+		let a = Date.now() + (i.timeout ?? 3e4);
+		for (;;) {
+			let o = (await this.read(t, {
+				editor: !0,
+				prefix: f(r),
+				signal: i.signal
+			})).files.find((e) => e.upload && d(e.path, r));
+			if (!o) throw new e("not_found", `no upload ${r}`, { status: 404 });
+			if (o.editor_url && o.w && o.h) return {
+				url: o.editor_url,
+				width: o.w,
+				height: o.h,
+				...o.edit ? { edit: o.edit } : {}
+			};
+			if (o.failed) throw n(o.failed);
+			if (Date.now() >= a) throw new e("render_timeout", `the editor view of ${r} is still rendering`);
+			await g(i.interval ?? 1e3, i.signal);
+		}
+	}
+	presets() {
+		return this.presetList ??= this.retry(() => this.api.presets()).catch((e) => {
+			throw this.presetList = void 0, e;
+		}), this.presetList;
+	}
+	getFrame(e, t, n, r, i) {
+		return this.retry(() => this.api.frame(e, t, n, r, i), i);
+	}
+	hlsBase(e, t) {
+		return `${this.api.itemURL(e)}/hls/${t}`;
+	}
+	get xhrSetup() {
+		return this.http.xhrSetup;
+	}
+	async uploadNamed(t, n, r = {}) {
+		let i = await this.put(n, {
+			ref: t,
+			path: r.path ?? (n.name || "image"),
+			signal: r.signal,
+			onProgress: r.onProgress,
+			wait: r.wait,
+			timeout: r.timeout
+		}), a = f(i.path.slice(i.path.lastIndexOf("/") + 1));
+		if (!u.test(a)) throw new e("invalid_request", `${i.path} is not a server-named upload path of ${t.kind}`);
+		return {
+			name: a,
+			path: i.path,
+			file: i
+		};
+	}
+	async uploadInline(e, t, n = {}) {
+		let r = await this.uploadNamed(this.postRef(e), t, n), i = await a(this.http, "POST", "/posts/{id}/images", {
+			params: { id: e },
+			body: { image: r.name },
+			signal: n.signal
+		});
+		return {
+			...r,
+			url: i.url
+		};
+	}
+	postRef(e) {
+		return {
+			kind: this.folders.post,
+			id: e
+		};
+	}
+	pollRef(e) {
+		return {
+			kind: this.folders.poll,
+			id: e
+		};
+	}
+	async discard(e) {
+		await this.api.abort(e.ref, { ticket: e.ticket });
+	}
+	async resumeMultipart(t, n, r) {
+		let i = m(t);
+		if (i.size !== n.size || i.name !== n.file.name || i.lastModified !== n.file.lastModified) throw new e("resume_mismatch", "the saved upload is for a different file");
+		let a;
+		try {
+			a = await this.retry(() => this.api.listParts(n.ref, { ticket: n.ticket }, r.signal), r.signal);
+		} catch (t) {
+			if (t instanceof e && t.code === "not_found") return this.complete(n, r);
+			throw t;
+		}
+		let o = /* @__PURE__ */ new Set();
+		for (let e of a.parts) {
+			let i = n.parts.find((t) => t.number === e.number);
+			if (!i || i.size !== e.size || e.sha256 && i.sha256 !== e.sha256) return await this.discard(n).catch(() => {}), r.onState?.(null), this.upload(t, {
+				...r,
+				resume: void 0
+			});
+			o.add(e.number);
+		}
+		return this.multipart(t, structuredClone(n), o, r);
+	}
+	async multipart(e, n, r, i) {
+		let a = new c({
+			...n.limits,
+			maxConcurrency: this.concurrency,
+			targetSeconds: this.targetSeconds
+		}), o = () => i.onState?.(structuredClone(n)), l = /* @__PURE__ */ new Map(), u = n.parts.filter((e) => r.has(e.number)).reduce((e, t) => e + t.size, 0), d = () => {
+			let e = u;
+			for (let t of l.values()) e += t;
+			i.onProgress?.({
+				phase: "uploading",
+				loaded: e,
+				total: n.size
+			});
+		}, f = n.parts.filter((e) => !r.has(e.number)), p = n.parts.reduce((e, t) => Math.max(e, t.offset + t.size), 0), m = () => {
+			let e = f.shift();
+			if (e || p >= n.size) return e;
+			let t = {
+				number: n.parts.length + 1,
+				offset: p,
+				size: Math.min(a.partSize(), n.size - p)
+			};
+			return p += t.size, n.parts.push(t), t;
+		}, h = new AbortController(), g = i.signal ? AbortSignal.any([i.signal, h.signal]) : h.signal, _ = 0, v = [], y = () => new Promise((e, n) => {
+			let r = () => {
+				g.removeEventListener("abort", i), _++, e();
+			}, i = () => {
+				v.splice(v.indexOf(r) >>> 0, 1), n(t(g));
+			};
+			if (_ < a.concurrency) return r();
+			if (g.aborted) return n(t(g));
+			g.addEventListener("abort", i, { once: !0 }), v.push(r);
+		}), b = () => {
+			for (_--; _ < a.concurrency && v.length;) v.shift()();
+		}, x = async (t) => {
+			let r = e.slice(t.offset, t.offset + t.size);
+			await this.retry(async () => {
+				t.sha256 || (t.sha256 = await s(r, { signal: g }), o());
+				let { parts: e } = await this.api.parts(n.ref, {
+					ticket: n.ticket,
+					parts: [{
+						number: t.number,
+						size: t.size,
+						sha256: t.sha256
+					}]
+				}, g), i = e[0]?.request;
+				await y();
+				let c = performance.now(), f = _;
+				try {
+					await this.transport(i, r, {
+						signal: g,
+						onProgress: (e) => {
+							l.set(t.number, e), d();
+						}
+					});
+				} finally {
+					l.delete(t.number), b();
+				}
+				a.record(t.size, performance.now() - c, f), u += t.size, d();
+			}, g);
+		};
+		o(), d();
+		let S = /* @__PURE__ */ new Set(), C;
+		for (;;) {
+			let e;
+			for (; C === void 0 && S.size < a.concurrency + 2 && (e = m());) {
+				o();
+				let t = x(e).then(() => void S.delete(t), (e) => {
+					S.delete(t), C === void 0 && (C = e, h.abort());
+				});
+				S.add(t);
+			}
+			if (S.size === 0) break;
+			await Promise.race(S);
+		}
+		if (C !== void 0) throw i.signal?.aborted ? t(i.signal) : C;
+		return this.complete(n, i);
+	}
+	async complete(e, t) {
+		t.onProgress?.({
+			phase: "completing",
+			loaded: e.size,
+			total: e.size
+		});
+		let n = await this.retry(() => this.api.complete(e.ref, { ticket: e.ticket }, t.signal), t.signal);
+		return t.onState?.(null), {
+			path: e.path,
+			blob: n.blob,
+			type: n.type,
+			size: n.size,
+			exists: !1,
+			processOnUpload: e.processOnUpload
+		};
+	}
+	async retry(e, n, r) {
+		for (let a = 0;; a++) try {
+			return await e();
+		} catch (e) {
+			let o = i(e);
+			if (n?.aborted) throw t(n);
+			if (!o.transient || a >= this.retries) throw o;
+			await g(this.delay(a, o.retryAfter), n), await r?.(o);
+		}
+	}
+};
+function m(e) {
+	return {
+		name: e.name,
+		lastModified: e.lastModified,
+		size: e.size
+	};
+}
+function h(e, t) {
+	return t ? t * 1e3 : Math.min(3e4, 1e3 * 2 ** e) * (.75 + Math.random() * .5);
+}
+function g(e, n) {
+	return new Promise((r, i) => {
+		if (n?.aborted) return i(t(n));
+		let a = setTimeout(() => {
+			n?.removeEventListener("abort", o), r();
+		}, e), o = () => {
+			clearTimeout(a), i(t(n));
+		};
+		n?.addEventListener("abort", o, { once: !0 });
+	});
+}
+//#endregion
+export { p as MediaClient, h as backoff, d as samePath, g as sleep, f as stem };
+
+//# sourceMappingURL=client.js.map