twentythree-cli 1.0.0

package/dist/commands/workspace/use.cjs

@@ -0,0 +1,52 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_auth_workspace_config = require("../../auth/workspace-config.cjs");
+const require_lib_base_command = require("../../lib/base-command.cjs");
+let _oclif_core = require("@oclif/core");
+let chalk = require("chalk");
+chalk = require_runtime.__toESM(chalk);
+let _clack_prompts = require("@clack/prompts");
+_clack_prompts = require_runtime.__toESM(_clack_prompts);
+//#region src/commands/workspace/use.ts
+var Use = class Use extends require_lib_base_command.BaseCommand {
+	static description = "Switch the active workspace";
+	static agentMetadata = {
+		api_endpoint: "local",
+		auth_scope: "none",
+		output_shape: { type: "none" },
+		side_effects: "updates"
+	};
+	static examples = ["<%= config.bin %> workspace use company.video23.com", "<%= config.bin %> workspace use \"Company Name\""];
+	static enableJsonFlag = true;
+	static args = { name: _oclif_core.Args.string({
+		description: "Workspace domain or display name",
+		required: true
+	}) };
+	async run() {
+		const { args } = await this.parse(Use);
+		const name = args.name;
+		const result = require_auth_workspace_config.findWorkspace(name, require_auth_workspace_config.getWorkspaces());
+		let workspace;
+		if (result === null) this.error(`No workspace matching '${name}' found. Run \`twentythree workspace list\` to see available workspaces.`, { exit: 1 });
+		else if (Array.isArray(result)) {
+			const chosen = await _clack_prompts.select({
+				message: `Multiple workspaces match '${name}'. Select one:`,
+				options: result.map((w) => ({
+					value: w.domain,
+					label: `${w.display_name} (${w.domain})`
+				}))
+			});
+			if (_clack_prompts.isCancel(chosen)) {
+				_clack_prompts.cancel("Cancelled");
+				return;
+			}
+			const found = result.find((w) => w.domain === chosen);
+			if (!found) this.error("Selected workspace not found", { exit: 1 });
+			workspace = found;
+		} else workspace = result;
+		require_auth_workspace_config.setActiveWorkspace(workspace.domain);
+		this.log(`Active workspace set to ${chalk.default.bold(workspace.domain)} (${workspace.display_name})`);
+		if (this.jsonEnabled()) return workspace;
+	}
+};
+//#endregion
+module.exports = Use;

package/dist/index.cjs

@@ -0,0 +1,6 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_lib_term_map = require("./lib/term-map.cjs");
+exports.TERM_MAP = require_lib_term_map.TERM_MAP;
+exports.applyCliTerms = require_lib_term_map.applyCliTerms;
+exports.toApiTerm = require_lib_term_map.toApiTerm;
+exports.toCliTerm = require_lib_term_map.toCliTerm;

package/dist/lib/analytics-flags.cjs

@@ -0,0 +1,60 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../_virtual/_rolldown/runtime.cjs");
+let _oclif_core = require("@oclif/core");
+//#region src/lib/analytics-flags.ts
+/**
+* Shared date filter flags for all analytics commands.
+* Supports explicit date ranges (date_start/date_end) or a predefined expression.
+*/
+const ANALYTICS_DATE_FLAGS = {
+	"date-start": _oclif_core.Flags.string({
+		description: "First date (YYYY-MM-DD)",
+		required: false
+	}),
+	"date-end": _oclif_core.Flags.string({
+		description: "Last date (YYYY-MM-DD)",
+		required: false
+	}),
+	"date-expression": _oclif_core.Flags.string({
+		description: "Predefined date range (e.g. thisweek, lastyear)",
+		required: false
+	})
+};
+/**
+* Pagination flags for analytics endpoints that support paging.
+*/
+const ANALYTICS_PAGINATION_FLAGS = {
+	page: _oclif_core.Flags.integer({
+		description: "Page number",
+		required: false
+	}),
+	size: _oclif_core.Flags.integer({
+		description: "Page size",
+		required: false
+	})
+};
+/**
+* Optional filter flags for analytics endpoints that support grouping and ordering.
+*/
+const ANALYTICS_FILTER_FLAGS = {
+	selection: _oclif_core.Flags.string({
+		description: "Scope to specific objects/types",
+		required: false
+	}),
+	groupby: _oclif_core.Flags.string({
+		description: "Group results by dimension",
+		required: false
+	}),
+	orderby: _oclif_core.Flags.string({
+		description: "Order results by field",
+		required: false
+	}),
+	order: _oclif_core.Flags.string({
+		description: "Sort direction (asc/desc)",
+		required: false
+	})
+};
+//#endregion
+exports.ANALYTICS_DATE_FLAGS = ANALYTICS_DATE_FLAGS;
+exports.ANALYTICS_FILTER_FLAGS = ANALYTICS_FILTER_FLAGS;
+exports.ANALYTICS_PAGINATION_FLAGS = ANALYTICS_PAGINATION_FLAGS;

package/dist/lib/audit.cjs

@@ -0,0 +1,44 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/lib/audit.ts
+/**
+* EXCLUDED_OPERATIONS — the authoritative list of spec endpoints that are intentionally
+* not implemented as CLI commands. Any spec endpoint not covered by a command file AND
+* not present in this list will be reported as a gap by scripts/audit-endpoints.mjs.
+*
+* Add entries here when an endpoint is confirmed to have no CLI use case, with a clear
+* reason and appropriate category.
+*/
+const EXCLUDED_OPERATIONS = [
+	{
+		endpoint: "GET /photo/get-upload-token",
+		reason: "Server-to-server token delegation for external upload flows; no CLI use case",
+		category: "internal"
+	},
+	{
+		endpoint: "GET /photo/get-replace-token",
+		reason: "Server-to-server token delegation for external replace flows; no CLI use case",
+		category: "internal"
+	},
+	{
+		endpoint: "GET /photo/get-update-token",
+		reason: "Server-to-server token delegation for external update flows; no CLI use case",
+		category: "internal"
+	},
+	{
+		endpoint: "POST /photo/delete-upload-token",
+		reason: "Counterpart to get-upload-token; server-to-server only",
+		category: "internal"
+	},
+	{
+		endpoint: "POST /photo/update-upload-token",
+		reason: "Update video metadata via upload token; server-to-server only",
+		category: "internal"
+	},
+	{
+		endpoint: "POST /photo/subtitle/archive/get-progress",
+		reason: "Covered by video subtitle archive --progress flag (dual-endpoint command)",
+		category: "non-standard"
+	}
+];
+//#endregion
+exports.EXCLUDED_OPERATIONS = EXCLUDED_OPERATIONS;

package/dist/lib/base-command.cjs

@@ -0,0 +1,156 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_api_client = require("../api/client.cjs");
+const require_auth_workspace_config = require("../auth/workspace-config.cjs");
+const require_auth_token_refresh = require("../auth/token-refresh.cjs");
+let _oclif_core = require("@oclif/core");
+let chalk = require("chalk");
+chalk = require_runtime.__toESM(chalk);
+let _clack_prompts = require("@clack/prompts");
+//#region src/lib/base-command.ts
+var BaseCommand = class extends _oclif_core.Command {
+	static enableJsonFlag = true;
+	static baseFlags = {
+		workspace: _oclif_core.Flags.string({
+			char: "w",
+			summary: "Workspace domain or display name to use for this invocation.",
+			helpGroup: "GLOBAL"
+		}),
+		agent: _oclif_core.Flags.boolean({
+			description: "Output machine-readable command metadata for AI agent consumption",
+			helpGroup: "GLOBAL",
+			hidden: true
+		})
+	};
+	flags;
+	activeWorkspace;
+	/** Base URL with /api/2/ appended — use this when constructing URLs outside of openapi-fetch (e.g. chunked upload) */
+	apiBaseUrl;
+	apiClient;
+	async init() {
+		await super.init();
+		if (process.argv.includes("--agent")) {
+			const ctor = this.ctor;
+			const flagDefs = ctor.flags ?? {};
+			const agentMeta = ctor.agentMetadata;
+			const flagsArr = Object.entries(flagDefs).filter(([name]) => ![
+				"workspace",
+				"agent",
+				"json"
+			].includes(name)).map(([name, def]) => ({
+				name,
+				type: def.type ?? "string",
+				required: def.required ?? false,
+				default: def.default ?? null,
+				description: def.description ?? def.summary ?? ""
+			}));
+			const output = {
+				command: this.id,
+				description: ctor.description ?? "",
+				flags: flagsArr,
+				examples: (ctor.examples ?? []).map((e) => typeof e === "string" ? e : e?.command ?? String(e)),
+				api_endpoint: agentMeta?.api_endpoint ?? null,
+				auth_scope: agentMeta?.auth_scope ?? "read",
+				output_shape: agentMeta?.output_shape ?? { type: "none" },
+				side_effects: agentMeta?.side_effects ?? "none"
+			};
+			process.stdout.write(JSON.stringify(output, null, 2) + "\n");
+			process.exit(0);
+		}
+		const { flags } = await this.parse({
+			flags: this.ctor.flags,
+			baseFlags: super.ctor.baseFlags,
+			enableJsonFlag: this.ctor.enableJsonFlag,
+			args: this.ctor.args,
+			strict: this.ctor.strict
+		});
+		this.flags = flags;
+		const workspaceFlagValue = flags.workspace;
+		let resolved = null;
+		if (workspaceFlagValue) {
+			const result = require_auth_workspace_config.findWorkspace(workspaceFlagValue, require_auth_workspace_config.getWorkspaces());
+			if (result === null) this.error(`No workspace matching '${workspaceFlagValue}' found — run \`twentythree workspace list\` to see available workspaces`, { exit: 1 });
+			else if (Array.isArray(result)) {
+				const chosen = await (0, _clack_prompts.select)({
+					message: `Multiple workspaces match '${workspaceFlagValue}'. Select one:`,
+					options: result.map((w) => ({
+						value: w.domain,
+						label: `${w.display_name} (${w.domain})`
+					}))
+				});
+				if (typeof chosen === "symbol") this.error("Workspace selection cancelled", { exit: 1 });
+				resolved = require_auth_workspace_config.getWorkspaceForDomain(chosen);
+			} else resolved = result;
+		} else {
+			const activeDomain = require_auth_workspace_config.getActiveWorkspace();
+			if (activeDomain) resolved = require_auth_workspace_config.getWorkspaceForDomain(activeDomain);
+		}
+		if (!resolved) this.error("No workspace configured — run `twentythree auth credentials` to set up", { exit: 1 });
+		this.activeWorkspace = resolved;
+		if (resolved.bearer_token) {
+			const freshToken = await require_auth_token_refresh.ensureFreshToken(resolved.domain);
+			if (freshToken) this.activeWorkspace = {
+				...resolved,
+				bearer_token: freshToken
+			};
+		}
+		this.apiBaseUrl = this.activeWorkspace.api_base_url.replace(/\/?$/, "/") + "api/2/";
+		this.apiClient = require_api_client.createApiClient({
+			baseUrl: this.apiBaseUrl,
+			token: this.activeWorkspace.bearer_token || void 0
+		});
+	}
+	/**
+	* Print the [domain] workspace header in dim style.
+	* Call at the top of every command's run() method (AUTH-04).
+	*/
+	printWorkspaceHeader() {
+		this.log(chalk.default.dim(`[${this.activeWorkspace.domain}]`));
+	}
+};
+/**
+* AuthenticatedCommand extends BaseCommand with an auth guard.
+* Commands requiring a bearer token extend this class instead of BaseCommand.
+* Commands for anonymous-scope endpoints extend BaseCommand directly.
+*
+* Rejects execution with exact AUTH-10 error message when no token is configured.
+*/
+var AuthenticatedCommand = class extends BaseCommand {
+	async init() {
+		await super.init();
+		if (!this.activeWorkspace.bearer_token) this.error("This command requires authentication — run `twentythree auth credentials` to add a bearer token", { exit: 1 });
+	}
+	/**
+	* Fetch the API token for a video by ID.
+	* Required by endpoints (e.g. section/list, subtitle/list) that demand a real token param.
+	* Throws a user-friendly error if the video is not found.
+	*/
+	async fetchVideoToken(videoId) {
+		const { data, error } = await this.apiClient.GET("/photo/list", { params: { query: {
+			photo_id: Number(videoId),
+			include_unpublished_p: 1
+		} } });
+		if (error) this.error(`Could not look up video ${videoId}: ${error}`, { exit: 1 });
+		const resp = data;
+		const video = Array.isArray(resp?.data) ? resp.data[0] : resp?.data;
+		if (!video?.token) this.error(`Video ${videoId} not found or has no token`, { exit: 1 });
+		return video.token;
+	}
+	/**
+	* Fetch the API token for a webinar by ID.
+	* Required by Phase 5 webinar endpoints that demand a real token param.
+	* Mirrors fetchVideoToken but calls /live/list instead of /photo/list.
+	* Throws a user-friendly error if the webinar is not found.
+	*/
+	async fetchWebinarToken(webinarId) {
+		const { data, error } = await this.apiClient.GET("/live/list", { params: { query: { live_id: Number(webinarId) } } });
+		if (error) this.error(`Could not look up webinar ${webinarId}: ${error}`, { exit: 1 });
+		const resp = data;
+		const webinar = Array.isArray(resp?.data) ? resp.data[0] : resp?.data;
+		if (!webinar?.token) this.error(`Webinar ${webinarId} not found or has no token`, { exit: 1 });
+		return webinar.token;
+	}
+};
+//#endregion
+exports.AuthenticatedCommand = AuthenticatedCommand;
+exports.BaseCommand = BaseCommand;

package/dist/lib/output.cjs

@@ -0,0 +1,82 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_lib_term_map = require("./term-map.cjs");
+let cli_table3 = require("cli-table3");
+cli_table3 = require_runtime.__toESM(cli_table3);
+//#region src/lib/output.ts
+const EXIT_SUCCESS = 0;
+const EXIT_ERROR = 1;
+const EXIT_CANCELLED = 2;
+/**
+* Format a CLI-01-compliant JSON output object.
+*
+* When ok=false, applies applyCliTerms() to the summary to prevent leaking
+* internal API field names (e.g. "photo" → "video") to the user (T-03-01 mitigation).
+*/
+function formatJsonOutput(params) {
+	const ok = params.ok !== false;
+	const summary = ok ? params.summary : require_lib_term_map.applyCliTerms(params.summary);
+	return {
+		ok,
+		data: params.data,
+		summary,
+		breadcrumbs: params.breadcrumbs
+	};
+}
+/**
+* Create a cli-table3 Table instance with the given headers and rows.
+* Headers are styled in cyan.
+*/
+function renderTable(headers, rows) {
+	const table = new cli_table3.default({
+		head: headers,
+		style: { head: ["cyan"] }
+	});
+	for (const row of rows) table.push(row);
+	return table;
+}
+/**
+* Format a byte count as a human-readable string.
+* Examples: "512 B", "45 KB", "300 MB", "1.5 GB"
+*/
+function formatBytes(bytes) {
+	if (bytes === 0) return "0 B";
+	const KB = 1024;
+	const MB = 1024 * KB;
+	const GB = 1024 * MB;
+	if (bytes >= GB) {
+		const value = bytes / GB;
+		return `${Number(value.toFixed(1))} GB`;
+	}
+	if (bytes >= MB) {
+		const value = bytes / MB;
+		return `${Number(value.toFixed(1))} MB`;
+	}
+	if (bytes >= KB) {
+		const value = bytes / KB;
+		return `${Number(value.toFixed(1))} KB`;
+	}
+	return `${bytes} B`;
+}
+/**
+* Resolve a potentially relative URL to an absolute URL using the workspace domain.
+*
+* - If url is undefined or empty, return it unchanged.
+* - If url already starts with http:// or https://, return it unchanged.
+* - Otherwise, construct a full URL using new URL(url, baseUrl).
+*
+* The baseUrl is the workspace's api_base_url (e.g. "https://video.company.com/").
+*/
+function resolveUrl(url, baseUrl) {
+	if (!url) return url;
+	if (url.startsWith("http://") || url.startsWith("https://")) return url;
+	return new URL(url, baseUrl).toString();
+}
+//#endregion
+exports.EXIT_CANCELLED = EXIT_CANCELLED;
+exports.EXIT_ERROR = EXIT_ERROR;
+exports.EXIT_SUCCESS = EXIT_SUCCESS;
+exports.formatBytes = formatBytes;
+exports.formatJsonOutput = formatJsonOutput;
+exports.renderTable = renderTable;
+exports.resolveUrl = resolveUrl;

package/dist/lib/pagination.cjs

@@ -0,0 +1,36 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/lib/pagination.ts
+/**
+* Generic auto-pagination helper (CLI-02).
+*
+* Fetches all pages from a paginated API endpoint by calling fetchPage
+* repeatedly until all items have been retrieved or an empty page is returned.
+*/
+const PAGE_SIZE = 100;
+/**
+* Fetch all pages from a paginated API endpoint.
+*
+* @param fetchPage - Function that takes (page: number, size: number) and returns
+*   a promise resolving to { data?: T[], total_count?: number }
+* @returns Concatenated array of all items across all pages
+*/
+async function fetchAllPages(fetchPage) {
+	const allItems = [];
+	let page = 1;
+	while (true) {
+		const response = await fetchPage(page, PAGE_SIZE);
+		const items = response.data ?? [];
+		if (items.length === 0) break;
+		allItems.push(...items);
+		const totalCount = response.total_count ?? 0;
+		if (totalCount > 0 && allItems.length >= totalCount) break;
+		if (totalCount === 0) {
+			page++;
+			continue;
+		}
+		page++;
+	}
+	return allItems;
+}
+//#endregion
+exports.fetchAllPages = fetchAllPages;

package/dist/lib/term-map.cjs

@@ -0,0 +1,48 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/lib/term-map.ts
+/**
+* Bidirectional terminology translation between API legacy terms and CLI modern terms.
+*
+* The TwentyThree API uses legacy terms (photo, album, live).
+* The CLI uses modern terms (video, category, webinar).
+* This module translates between them.
+*/
+const API_TO_CLI = {
+	photo: "video",
+	album: "category",
+	live: "webinar"
+};
+const CLI_TO_API = Object.fromEntries(Object.entries(API_TO_CLI).map(([k, v]) => [v, k]));
+/**
+* Convert an API legacy term to the modern CLI term.
+* Unknown terms are returned unchanged.
+*/
+function toCliTerm(apiTerm) {
+	return API_TO_CLI[apiTerm.toLowerCase()] ?? apiTerm;
+}
+/**
+* Convert a CLI modern term back to the API legacy term.
+* Unknown terms are returned unchanged.
+*/
+function toApiTerm(cliTerm) {
+	return CLI_TO_API[cliTerm.toLowerCase()] ?? cliTerm;
+}
+/**
+* Apply term mapping to an entire string, replacing all occurrences
+* of API legacy terms with CLI modern terms.
+* Used for mapping error message bodies and API response text.
+*/
+function applyCliTerms(text) {
+	let result = text;
+	for (const [apiTerm, cliTerm] of Object.entries(API_TO_CLI)) result = result.replace(new RegExp(`(?<![a-zA-Z])${apiTerm}(?![a-zA-Z])`, "gi"), cliTerm);
+	return result;
+}
+const TERM_MAP = {
+	API_TO_CLI,
+	CLI_TO_API
+};
+//#endregion
+exports.TERM_MAP = TERM_MAP;
+exports.applyCliTerms = applyCliTerms;
+exports.toApiTerm = toApiTerm;
+exports.toCliTerm = toCliTerm;

package/dist/upload/chunk-pool.cjs

@@ -0,0 +1,47 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/upload/chunk-pool.ts
+/**
+* Default exponential backoff delay: min(1000 * 2^attempt, 30000) ms
+*/
+function defaultDelay(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* Upload chunks concurrently in windows of `concurrency` size.
+* Retries each failed chunk up to maxRetries times with exponential backoff.
+* Aborts immediately on 500. Skips already-completed chunks.
+*/
+async function uploadChunkPool(params) {
+	const { chunks, uploadFn, concurrency, maxRetries, onChunkComplete, delayFn = defaultDelay, completed = /* @__PURE__ */ new Set() } = params;
+	let finalResponse;
+	/**
+	* Upload a single chunk with retry and exponential backoff.
+	*/
+	async function uploadWithRetry(chunk) {
+		if (completed.has(chunk.number)) return;
+		let attempt = 0;
+		while (true) {
+			const response = await uploadFn(chunk);
+			if (response.status === 200) {
+				completed.add(chunk.number);
+				finalResponse = response.data;
+				onChunkComplete?.(chunk, response);
+				return;
+			}
+			if (response.status === 500) throw new Error("Unsupported file format — upload aborted");
+			if (attempt >= maxRetries) throw new Error(`Chunk ${chunk.number} failed after ${maxRetries} retries`);
+			await delayFn(Math.min(1e3 * Math.pow(2, attempt), 3e4));
+			attempt++;
+		}
+	}
+	for (let i = 0; i < chunks.length; i += concurrency) {
+		const window = chunks.slice(i, i + concurrency);
+		await Promise.all(window.map((chunk) => uploadWithRetry(chunk)));
+	}
+	return {
+		completedChunks: completed.size,
+		finalResponse
+	};
+}
+//#endregion
+exports.uploadChunkPool = uploadChunkPool;

package/dist/upload/chunked-upload.cjs

@@ -0,0 +1,131 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_upload_chunk_pool = require("./chunk-pool.cjs");
+const require_upload_types = require("./types.cjs");
+let node_fs_promises = require("node:fs/promises");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+//#region src/upload/chunked-upload.ts
+/**
+* Chunked upload engine — splits a file into chunks and uploads them via the
+* TwentyThree resumable.js protocol.
+*
+* This module is display-agnostic: it reports progress via an onProgress
+* callback and has zero imports of chalk, ora, or cli-progress.
+*
+* Threat mitigations implemented here:
+*   T-03-02: uploadUrl must use https:// (validated before first request)
+*   T-03-03: upload_token is never logged; onProgress reports byte counts only
+*/
+/**
+* Read a file slice into a Buffer by collecting stream chunks.
+*/
+async function readSlice(filePath, start, end) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		const stream = (0, node_fs.createReadStream)(filePath, {
+			start,
+			end: end - 1
+		});
+		stream.on("data", (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+		stream.on("end", () => resolve(Buffer.concat(chunks)));
+		stream.on("error", reject);
+	});
+}
+/**
+* Main chunked upload function. Splits the file into chunks and uploads them
+* concurrently via uploadChunkPool with retry and progress tracking.
+*
+* @throws Error if file is not found
+* @throws Error if uploadUrl is not https://
+*/
+async function uploadChunked(params) {
+	const { filePath, uploadToken, uploadUrl, tokenFieldName = "upload_token", bearerToken, chunkSize = require_upload_types.DEFAULT_CHUNK_SIZE, concurrency = 5, maxRetries = 5, onProgress, extraFields } = params;
+	if (!uploadUrl.startsWith("https://")) throw new Error(`uploadUrl must use https:// — insecure upload URLs are not allowed: ${uploadUrl}`);
+	let totalSize;
+	try {
+		totalSize = (await (0, node_fs_promises.stat)(filePath)).size;
+	} catch (err) {
+		if (err?.code === "ENOENT") throw new Error(`File not found: ${filePath}`);
+		throw err;
+	}
+	const totalChunks = Math.max(1, Math.floor(totalSize / chunkSize));
+	const chunks = Array.from({ length: totalChunks }, (_, i) => {
+		const start = i * chunkSize;
+		const end = i < totalChunks - 1 ? start + chunkSize : totalSize;
+		return {
+			number: i + 1,
+			start,
+			end,
+			size: end - start
+		};
+	});
+	const filename = node_path.basename(filePath);
+	const resumableIdentifier = filename;
+	let bytesUploaded = 0;
+	/**
+	* Upload function for a single chunk — builds FormData and POSTs via native fetch.
+	* Returns { status, data } for the pool to handle retry/abort logic.
+	*/
+	async function uploadFn(chunk) {
+		try {
+			const sliceBuffer = await readSlice(filePath, chunk.start, chunk.end);
+			const blob = new Blob([sliceBuffer]);
+			const formData = new FormData();
+			formData.append(tokenFieldName, uploadToken);
+			formData.append("file", blob, filename);
+			formData.append("resumableChunkNumber", String(chunk.number));
+			formData.append("resumableChunkSize", String(chunkSize));
+			formData.append("resumableTotalSize", String(totalSize));
+			formData.append("resumableIdentifier", resumableIdentifier);
+			formData.append("resumableFilename", filename);
+			formData.append("resumableTotalChunks", String(totalChunks));
+			if (extraFields) for (const [key, value] of Object.entries(extraFields)) formData.append(key, value);
+			const headers = {};
+			if (bearerToken) headers["Authorization"] = `Bearer ${bearerToken}`;
+			const response = await fetch(uploadUrl, {
+				method: "POST",
+				headers,
+				body: formData
+			});
+			let data;
+			try {
+				const buf = await response.arrayBuffer();
+				const text = Buffer.from(buf).toString("utf-8");
+				try {
+					data = JSON.parse(text);
+				} catch {
+					data = text || void 0;
+				}
+			} catch {
+				data = void 0;
+			}
+			return {
+				status: response.status,
+				data
+			};
+		} catch (err) {
+			return { status: 0 };
+		}
+	}
+	/**
+	* Callback fired after each chunk completes successfully.
+	* Accumulates bytesUploaded and fires onProgress.
+	*/
+	function onChunkComplete(chunk) {
+		bytesUploaded += chunk.size;
+		onProgress?.(bytesUploaded, totalSize);
+	}
+	const raw = (await require_upload_chunk_pool.uploadChunkPool({
+		chunks,
+		uploadFn,
+		concurrency,
+		maxRetries,
+		onChunkComplete: (chunk) => onChunkComplete(chunk)
+	})).finalResponse;
+	if (typeof raw === "number") return { photo_id: raw };
+	return raw ?? {};
+}
+//#endregion
+exports.uploadChunked = uploadChunked;

package/dist/upload/types.cjs

@@ -0,0 +1,9 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/upload/types.ts
+const DEFAULT_CHUNK_SIZE = 5 * 1024 * 1024;
+const DEFAULT_CONCURRENCY = 5;
+const DEFAULT_MAX_RETRIES = 5;
+//#endregion
+exports.DEFAULT_CHUNK_SIZE = DEFAULT_CHUNK_SIZE;
+exports.DEFAULT_CONCURRENCY = DEFAULT_CONCURRENCY;
+exports.DEFAULT_MAX_RETRIES = DEFAULT_MAX_RETRIES;