@keystrokehq/cli 0.0.1

package/dist/try-deploy.handler-DqybNhXx.mjs

@@ -0,0 +1,490 @@
+#!/usr/bin/env node
+
+import { n as __exportAll } from "./chunk-CH6r78ws.mjs";
+import { C as CliExitError, h as toErrorMessage, t as ui, w as InputValidationError } from "./keystroke.mjs";
+import { d as trackProject } from "./dist-CUK7yBM0.mjs";
+import { t as assertWorkflowProjectRoot } from "./project-config-D1qsQlO7.mjs";
+import { a as readManifestsFromOutDir, o as readWorkflowsFromDisk, s as uploadTestBundle } from "./dist-BkJUoBiG.mjs";
+import { t as requireWorkflowsDir } from "./resolve-project-DDJ29sCF.mjs";
+import { a as runWorkflowBuild, t as WorkflowNotFoundError } from "./workflow-build-DBQaBfnn.mjs";
+import { a as validateRequiredFields, n as formatValidationError, r as isUnknownSchema, t as formatMissingInputError } from "./schema-display-CgmeKigW.mjs";
+import { r as isLocalMode } from "./env-91KwMKov.mjs";
+import { i as requireClient, t as assertProjectConfigMatchesAuthenticatedOrg } from "./context-T7HZuB97.mjs";
+import { t as createBuildProgress } from "./build-progress-DgYKb4hB.mjs";
+import { t as withErrorBoundary } from "./error-boundary-VL-JLfIa.mjs";
+import { n as sleep, t as TERMINAL_STATUSES } from "./run-polling-CAgFRdK3.mjs";
+import * as fs from "node:fs/promises";
+import * as path$1 from "node:path";
+import { z } from "zod";
+//#region src/lib/format.ts
+function formatBytes(bytes) {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+	return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+//#endregion
+//#region ../../packages/utils/src/json-schema-validation.ts
+const SCHEMA_CACHE_LIMIT = 256;
+const schemaCache = /* @__PURE__ */ new Map();
+function isObjectRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toStableJson(value) {
+	if (Array.isArray(value)) return `[${value.map((item) => toStableJson(item)).join(",")}]`;
+	if (isObjectRecord(value)) return `{${Object.keys(value).sort((a, b) => a.localeCompare(b)).map((key) => `${JSON.stringify(key)}:${toStableJson(value[key])}`).join(",")}}`;
+	return JSON.stringify(value);
+}
+function normalizeIssues(error) {
+	return error.issues.map((issue) => ({
+		path: issue.path.length > 0 ? issue.path.map((segment) => String(segment)) : [""],
+		message: issue.message
+	}));
+}
+function getOrCompileSchema(jsonSchema) {
+	const cacheKey = toStableJson(jsonSchema);
+	const cached = schemaCache.get(cacheKey);
+	if (cached) {
+		schemaCache.delete(cacheKey);
+		schemaCache.set(cacheKey, cached);
+		return {
+			kind: "compiled",
+			schema: cached
+		};
+	}
+	try {
+		const compiled = z.fromJSONSchema(jsonSchema);
+		schemaCache.set(cacheKey, compiled);
+		if (schemaCache.size > SCHEMA_CACHE_LIMIT) {
+			const oldestKey = schemaCache.keys().next().value;
+			if (oldestKey) schemaCache.delete(oldestKey);
+		}
+		return {
+			kind: "compiled",
+			schema: compiled
+		};
+	} catch (error) {
+		return {
+			kind: "unsupported_schema",
+			reason: "from_json_schema_failed",
+			message: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+function compileJsonSchema(jsonSchema) {
+	if (!jsonSchema || typeof jsonSchema !== "object") return {
+		kind: "unknown_schema",
+		message: "Schema is null or undefined."
+	};
+	if (jsonSchema.type === "unknown") return {
+		kind: "unknown_schema",
+		message: "Schema is the unknown sentinel (`{ type: \"unknown\" }`)."
+	};
+	return getOrCompileSchema(jsonSchema);
+}
+/**
+* Validates an arbitrary payload against a JSON Schema via z.fromJSONSchema().
+*/
+function validateJsonSchemaPayload(params) {
+	const compiled = compileJsonSchema(params.jsonSchema);
+	if (compiled.kind === "unknown_schema" || compiled.kind === "unsupported_schema") return compiled;
+	if (compiled.kind !== "compiled") throw new Error(`Unhandled schema compilation result: ${JSON.stringify(compiled)}`);
+	const parsed = compiled.schema.safeParse(params.payload);
+	if (parsed.success) return {
+		kind: "valid",
+		validatedData: parsed.data
+	};
+	return {
+		kind: "invalid_payload",
+		issues: normalizeIssues(parsed.error)
+	};
+}
+//#endregion
+//#region src/commands/workflows/_shared/input.ts
+async function resolveInput(options) {
+	if (options.input && options.inputFile) {
+		ui.error("Cannot specify both --input and --input-file");
+		throw new InputValidationError("Cannot specify both --input and --input-file");
+	}
+	if (options.input) return parseJsonObjectInput(options.input, "--input flag");
+	if (options.inputFile) {
+		const filePath = path$1.resolve(options.inputFile);
+		try {
+			return parseJsonObjectInput(await fs.readFile(filePath, "utf-8"), `input file ${filePath}`);
+		} catch (error) {
+			const msg = `Failed to read input file: ${toErrorMessage(error)}`;
+			ui.error(msg);
+			throw new InputValidationError(msg);
+		}
+	}
+	return {};
+}
+function parseJsonObjectInput(raw, source) {
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		ui.error(`Invalid JSON in ${source}`);
+		throw new InputValidationError(`Invalid JSON in ${source}`);
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+		const msg = `Invalid input from ${source}: expected a JSON object (e.g. {"key": "value"}), got ${Array.isArray(parsed) ? "array" : parsed === null ? "null" : typeof parsed}`;
+		ui.error(msg);
+		throw new InputValidationError(msg);
+	}
+	return parsed;
+}
+/**
+* Validate workflow input in two layers:
+* 1. Required fields check (reliable)
+* 2. Full schema parse via shared JSON schema validator (best effort)
+*/
+function validateInputOrExit(workflowName, input, inputSchema) {
+	const { valid, missingRequired } = validateRequiredFields(input, inputSchema);
+	if (!valid) {
+		const msg = formatMissingInputError(workflowName, missingRequired, inputSchema);
+		ui.error(msg);
+		throw new InputValidationError(msg);
+	}
+	const result = validateJsonSchemaPayload({
+		jsonSchema: inputSchema,
+		payload: input
+	});
+	if (result.kind === "valid") return;
+	if (result.kind === "invalid_payload") {
+		const msg = formatValidationError(workflowName, result.issues, inputSchema);
+		ui.error(msg);
+		throw new InputValidationError(msg);
+	}
+	if (result.kind === "unsupported_schema") {
+		ui.warn(`Schema import failed for workflow "${workflowName}" (${result.message}). Required fields were checked, but full validation was skipped.`);
+		return;
+	}
+	if (result.kind === "unknown_schema") {
+		ui.warn(`Schema for workflow "${workflowName}" is unknown. Required fields were checked, but full validation was skipped.`);
+		return;
+	}
+	throw new Error(`Unhandled validation result: ${JSON.stringify(result)}`);
+}
+/**
+* Read input schema from an existing dist manifest for fast pre-build validation.
+*/
+async function tryReadExistingInputSchema(workflowsDir, workflowName) {
+	const match = (await readManifestsFromOutDir(workflowsDir, workflowName))[0];
+	if (!match) return null;
+	const schema = match.manifest.workflowSchemas.input;
+	if (schema && typeof schema === "object" && !Array.isArray(schema)) return schema;
+	return null;
+}
+//#endregion
+//#region src/commands/workflows/_shared/run-helpers.ts
+/**
+* Resolve input and validate against existing schema if available.
+* Returns input and workflowsDir for downstream use.
+*/
+async function resolveAndValidateInputForRun(options) {
+	const input = await resolveInput(options);
+	const workflowsDir = await requireWorkflowsDir(options.path);
+	trackProject(workflowsDir);
+	const existingSchema = await tryReadExistingInputSchema(workflowsDir, options.workflow);
+	if (existingSchema && !isUnknownSchema(existingSchema)) validateInputOrExit(options.workflow, input, existingSchema);
+	return {
+		input,
+		workflowsDir
+	};
+}
+/**
+* Build workflow(s) for run using the standard build pipeline, then read
+* prepared artifacts from disk filtered by workflow ref.
+*/
+async function buildWorkflowsForRun(options) {
+	const progress = createBuildProgress(options.workflow);
+	try {
+		const { result, outDir } = await runWorkflowBuild({
+			workflowsDir: options.workflowsDir,
+			workflowRef: options.workflow,
+			verbose: options.verbose,
+			onProgressEvent: progress.handleEvent
+		});
+		const filtered = (await readWorkflowsFromDisk(outDir)).filter((wf) => wf.manifestData.id === options.workflow || wf.name === options.workflow);
+		if (filtered.length === 0) {
+			const availableNames = result.artifacts.map((a) => a.manifest.name);
+			throw new WorkflowNotFoundError(options.workflow, availableNames);
+		}
+		return filtered;
+	} finally {
+		progress.stop();
+	}
+}
+/**
+* Validate input against the first build's input schema if available.
+*/
+function validateInputWithFirstBuild(options, input, builds) {
+	const inputSchema = builds[0]?.manifestData.workflowSchemas.input;
+	if (inputSchema && typeof inputSchema === "object" && !isUnknownSchema(inputSchema)) validateInputOrExit(options.workflow, input, inputSchema);
+}
+/**
+* Render success message after build.
+*/
+function renderBuildSuccessMessage(builds) {
+	const first = builds[0];
+	if (!first) return;
+	if (builds.length > 1) ui.success(`Built ${builds.length} workflow(s) with name "${first.name}"`);
+	else ui.success(`Built ${first.name} (${formatBytes(first.bundleSize)})`);
+}
+/**
+* Render completion success message (single or multi).
+*/
+function renderRunCompletionSuccessMessage(builds, elapsedSeconds) {
+	if (builds.length === 0) return;
+	if (builds.length > 1) ui.success(`All ${builds.length} workflow(s) completed in ${elapsedSeconds}s`);
+	else ui.success(`Workflow completed in ${elapsedSeconds}s`);
+}
+//#endregion
+//#region src/commands/workflows/try-deploy.handler/render.ts
+function createRuntimeRenderState() {
+	return {
+		seenEventIds: /* @__PURE__ */ new Set(),
+		seenLogIds: /* @__PURE__ */ new Set(),
+		stepStates: /* @__PURE__ */ new Map(),
+		lastStatus: void 0
+	};
+}
+function renderRunSnapshot(snapshot, state, verbose) {
+	if (snapshot.run.status !== state.lastStatus) {
+		ui.hint(`Run status: ${snapshot.run.status}`);
+		state.lastStatus = snapshot.run.status;
+	}
+	for (const log of snapshot.logs) {
+		if (state.seenLogIds.has(log.id)) continue;
+		state.seenLogIds.add(log.id);
+		renderRunLog(log, verbose);
+	}
+	for (const event of snapshot.events) {
+		if (state.seenEventIds.has(event.id)) continue;
+		state.seenEventIds.add(event.id);
+		renderRuntimeEvent(event, state.stepStates, verbose);
+	}
+}
+function renderRunLog(log, verbose) {
+	const message = `${`log[${log.source}:${log.level}]`} ${log.message}`;
+	ui.text(message);
+	if (verbose && log.metadata) ui.text(`  metadata: ${JSON.stringify(log.metadata, null, 2)}`);
+}
+function renderRuntimeEvent(event, stepStates, verbose) {
+	const eventData = toObject(event.eventData);
+	if (event.eventType === "stream_chunk") {
+		const chunkCandidate = eventData?.chunk ?? eventData?.content;
+		if (typeof chunkCandidate === "string" && chunkCandidate.length > 0) {
+			ui.text(`stream> ${chunkCandidate}`);
+			return;
+		}
+	}
+	if (event.eventType.startsWith("step_")) {
+		const stepName = typeof eventData?.stepName === "string" && eventData.stepName || stepStates.get(event.correlationId)?.name || event.correlationId;
+		const current = stepStates.get(event.correlationId) ?? {
+			name: stepName,
+			status: "pending",
+			attempts: 0
+		};
+		if (event.eventType === "step_created") {
+			const next = {
+				...current,
+				name: stepName,
+				status: "pending"
+			};
+			stepStates.set(event.correlationId, next);
+			ui.hint(`Step created: ${stepName}`);
+			return;
+		}
+		if (event.eventType === "step_started") {
+			const attempts = Number(eventData?.attempt) || current.attempts + 1;
+			const next = {
+				...current,
+				name: stepName,
+				attempts,
+				status: "running"
+			};
+			stepStates.set(event.correlationId, next);
+			ui.hint(`Step running: ${stepName} (attempt ${attempts})`);
+			return;
+		}
+		if (event.eventType === "step_retrying") {
+			const attempts = Number(eventData?.attempt) || current.attempts + 1;
+			const next = {
+				...current,
+				name: stepName,
+				attempts,
+				status: "retrying"
+			};
+			stepStates.set(event.correlationId, next);
+			ui.warn(`Step retrying: ${stepName} (attempt ${attempts})`);
+			if (verbose && typeof eventData?.error === "string" && eventData.error.length > 0) ui.hint(`  reason: ${eventData.error}`);
+			return;
+		}
+		if (event.eventType === "step_completed") {
+			const next = {
+				...current,
+				name: stepName,
+				status: "completed"
+			};
+			stepStates.set(event.correlationId, next);
+			ui.success(`Step completed: ${stepName}`);
+			if (verbose && "result" in (eventData ?? {})) ui.text(`  result: ${JSON.stringify(eventData?.result, null, 2)}`);
+			return;
+		}
+		if (event.eventType === "step_failed") {
+			const next = {
+				...current,
+				name: stepName,
+				status: "failed"
+			};
+			stepStates.set(event.correlationId, next);
+			const error = typeof eventData?.error === "string" && eventData.error.length > 0 ? eventData.error : "Unknown step error";
+			ui.error(`Step failed: ${stepName} - ${error}`);
+			return;
+		}
+	}
+	if (verbose) {
+		const label = event.eventType.replaceAll("_", " ");
+		ui.hint(`Event: ${label} (${event.correlationId})`);
+	}
+}
+function toObject(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	return value;
+}
+//#endregion
+//#region src/commands/workflows/try-deploy.handler/poll.ts
+const POLL_INTERVAL_MS = 1e3;
+async function pollForCompletion(client, runId, timeoutSeconds, verbose) {
+	const deadline = Date.now() + timeoutSeconds * 1e3;
+	const renderState = createRuntimeRenderState();
+	const runtimeState = {
+		hasWarnedEventsUnavailable: false,
+		hasWarnedLogsUnavailable: false
+	};
+	while (Date.now() < deadline) {
+		const snapshot = await getRunSnapshot(client, runId, runtimeState, verbose);
+		renderRunSnapshot(snapshot, renderState, verbose);
+		if (TERMINAL_STATUSES.has(snapshot.run.status)) return snapshot;
+		await sleep(POLL_INTERVAL_MS);
+	}
+	const snapshot = await getRunSnapshot(client, runId, runtimeState, verbose);
+	renderRunSnapshot(snapshot, renderState, verbose);
+	return snapshot;
+}
+async function getRunSnapshot(client, runId, runtimeState, verbose) {
+	const runResponse = await client.runs.getRun(runId);
+	let events = [];
+	let logs = [];
+	try {
+		events = (await client.runs.listEvents(runId)).events;
+	} catch (error) {
+		if (verbose && !runtimeState.hasWarnedEventsUnavailable) {
+			const message = toErrorMessage(error);
+			ui.hint("Event streaming is temporarily unavailable; continuing with status polling only.");
+			ui.hint(`  reason: ${message}`);
+			runtimeState.hasWarnedEventsUnavailable = true;
+		}
+	}
+	try {
+		logs = (await client.runs.listLogs(runId)).logs;
+	} catch (error) {
+		if (verbose && !runtimeState.hasWarnedLogsUnavailable) {
+			const message = toErrorMessage(error);
+			ui.hint("Log polling is temporarily unavailable; continuing with status/event polling.");
+			ui.hint(`  reason: ${message}`);
+			runtimeState.hasWarnedLogsUnavailable = true;
+		}
+	}
+	return {
+		run: runResponse.run,
+		events,
+		logs
+	};
+}
+//#endregion
+//#region src/commands/workflows/try-deploy.handler/index.ts
+var try_deploy_handler_exports = /* @__PURE__ */ __exportAll({ handleWorkflowsTryDeploy: () => handleWorkflowsTryDeploy });
+async function handleWorkflowsTryDeploy(options, ctx) {
+	return withErrorBoundary("Try-deploy", async () => {
+		const client = requireClient(ctx);
+		const startTime = Date.now();
+		const local = isLocalMode();
+		const { input, workflowsDir } = await resolveAndValidateInputForRun(options);
+		const storagePaths = [];
+		let runError;
+		try {
+			const builds = await buildWorkflowsForRun({
+				...options,
+				workflowsDir
+			});
+			renderBuildSuccessMessage(builds);
+			validateInputWithFirstBuild(options, input, builds);
+			const projectConfig = await assertWorkflowProjectRoot(workflowsDir);
+			await assertProjectConfigMatchesAuthenticatedOrg(client, projectConfig);
+			for (const [i, build] of builds.entries()) {
+				if (builds.length > 1) ui.header(`Running "${build.name}" (${i + 1}/${builds.length})...`);
+				let storagePath;
+				if (local) {
+					storagePath = build.bundlePath;
+					if (i === 0) ui.hint("Local mode: using bundle from build output (skipping upload)");
+				} else {
+					ui.header("Uploading test bundle...");
+					storagePath = (await uploadTestBundle(client, build, false)).storagePath;
+					storagePaths.push(storagePath);
+					ui.success("Upload complete");
+				}
+				ui.header("Executing workflow...");
+				const { runId } = await client.workflows.testById({
+					workflowName: build.name,
+					storagePath,
+					exportName: build.exportName,
+					manifest: build.manifestData,
+					flowJson: build.flowData,
+					triggers: build.triggers,
+					bundleHash: build.bundleHash,
+					bundleSize: build.bundleSize,
+					args: [input],
+					organizationId: projectConfig.organizationId,
+					projectId: projectConfig.projectId
+				});
+				ui.hint(`Run ID: ${runId}`);
+				const snapshot = await pollForCompletion(client, runId, options.timeout, options.verbose);
+				const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+				if (snapshot.run.status === "completed") {
+					if (snapshot.run.output !== void 0 && snapshot.run.output !== null) {
+						ui.br();
+						ui.header("Output:");
+						ui.text(JSON.stringify(snapshot.run.output, null, 2));
+					}
+					continue;
+				}
+				if (snapshot.run.status === "failed") {
+					ui.br();
+					ui.error(`Workflow failed after ${elapsed}s`);
+					if (snapshot.run.error) ui.error(toErrorMessage(snapshot.run.error));
+					runError = snapshot.run.error ?? /* @__PURE__ */ new Error("Workflow failed");
+					break;
+				}
+				ui.br();
+				ui.warn(`Workflow still ${snapshot.run.status} after ${elapsed}s (timeout: ${options.timeout}s)`);
+				ui.hint(`Check status: keystroke runs get ${runId}`);
+				runError = /* @__PURE__ */ new Error(`Workflow still ${snapshot.run.status} after timeout`);
+				break;
+			}
+			if (!runError) {
+				ui.br();
+				renderRunCompletionSuccessMessage(builds, ((Date.now() - startTime) / 1e3).toFixed(1));
+			}
+		} finally {
+			if (!local) for (const sp of storagePaths) try {
+				await client.workflows.deleteTestBundle({ storagePath: sp });
+				if (options.verbose) ui.hint("Test bundle cleaned up");
+			} catch {}
+		}
+		if (runError) throw new CliExitError("Workflow execution failed");
+	}, { json: ctx.jsonMode });
+}
+//#endregion
+export { validateInputOrExit as a, resolveInput as i, try_deploy_handler_exports as n, pollForCompletion as r, handleWorkflowsTryDeploy as t };

package/dist/upload-CkU--iDC.mjs

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+
+import { n as __exportAll } from "./chunk-CH6r78ws.mjs";
+import { createReadStream, promises } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import http from "node:http";
+import https from "node:https";
+//#region ../../packages/workflow-sdk/src/utils/pool.ts
+/**
+* Executes async operations with a concurrency limit.
+* Processes items in parallel, but never more than `limit` at a time.
+*/
+async function pool(items, limit, fn) {
+	if (items.length === 0) return [];
+	const effectiveLimit = Math.floor(limit);
+	if (effectiveLimit <= 0) throw new Error(`pool() limit must be a positive integer, got ${limit}`);
+	const results = [];
+	const inFlight = /* @__PURE__ */ new Set();
+	for (const item of items) {
+		const operation = fn(item).then((result) => {
+			results.push(result);
+			inFlight.delete(operation);
+		});
+		inFlight.add(operation);
+		if (inFlight.size >= effectiveLimit) await Promise.race(inFlight);
+	}
+	await Promise.all(inFlight);
+	return results;
+}
+//#endregion
+//#region ../../packages/workflow-sdk/src/utils/upload.ts
+/**
+* Presigned URL upload helpers with retry logic.
+*
+* Uses raw fetch (not ky) because presigned URLs bypass the API —
+* no auth headers or base URL prefix needed.
+*/
+var upload_exports = /* @__PURE__ */ __exportAll({
+	batchUpload: () => batchUpload,
+	uploadToPresignedUrl: () => uploadToPresignedUrl
+});
+/** HTTP status codes that are safe to retry (server errors + rate limiting) */
+const RETRYABLE_STATUS_CODES = new Set([
+	408,
+	429,
+	500,
+	502,
+	503,
+	504
+]);
+const DEFAULT_UPLOAD_RETRY = {
+	maxAttempts: 3,
+	baseDelayMs: 1e3,
+	maxDelayMs: 1e4
+};
+function resolveLocalUploadTarget(url) {
+	if (path.isAbsolute(url)) return url;
+	if (url.startsWith("file://")) return fileURLToPath(url);
+	return null;
+}
+function isRetryableStatus(status) {
+	return RETRYABLE_STATUS_CODES.has(status);
+}
+function isRetryableError(error) {
+	if (error instanceof TypeError) return true;
+	return false;
+}
+const DEFAULT_UPLOAD_CONCURRENCY = 5;
+/**
+* Uploads multiple bundles to presigned URLs in parallel with retry.
+*
+* This is the shared implementation behind `client.bundles.upload()`.
+* The resource call resolves presigned URLs, then passes URL map + items
+* here for the actual uploads.
+*/
+async function batchUpload(items, urls, options) {
+	const concurrency = options?.concurrency ?? DEFAULT_UPLOAD_CONCURRENCY;
+	const retryConfig = options?.retryConfig;
+	return { results: await pool(items, concurrency, async (item) => {
+		const urlInfo = urls[item.name];
+		if (!urlInfo) return {
+			kind: "failure",
+			name: item.name,
+			error: `No presigned URL returned for ${item.name}`
+		};
+		try {
+			await uploadToPresignedUrl(urlInfo.url, resolveUploadBody(item), retryConfig, urlInfo.contentType);
+			return {
+				kind: "success",
+				name: item.name,
+				storagePath: urlInfo.key
+			};
+		} catch (error) {
+			return {
+				kind: "failure",
+				name: item.name,
+				error: `Upload failed: ${error instanceof Error ? error.message : String(error)}`
+			};
+		}
+	}) };
+}
+/**
+* Uploads a bundle to a presigned URL with exponential backoff retry.
+* Retries on transient failures (5xx, 408, 429, network errors).
+* Non-retryable errors (4xx except 408/429) throw immediately.
+*/
+async function uploadToPresignedUrl(url, bundle, config = DEFAULT_UPLOAD_RETRY, contentType) {
+	const localUploadTarget = resolveLocalUploadTarget(url);
+	if (localUploadTarget) {
+		await promises.mkdir(path.dirname(localUploadTarget), { recursive: true });
+		if ("path" in bundle) await promises.copyFile(bundle.path, localUploadTarget);
+		else await promises.writeFile(localUploadTarget, bundle);
+		return;
+	}
+	const headers = await resolveUploadHeaders(bundle, contentType);
+	let lastError;
+	for (let attempt = 1; attempt <= config.maxAttempts; attempt++) {
+		try {
+			const response = await uploadRemoteBundle(url, bundle, headers);
+			if (response.ok) return;
+			const errorText = await response.text().catch(() => "");
+			const message = `Upload failed (${response.status}): ${errorText || response.statusText}`;
+			lastError = new Error(message);
+			if (!isRetryableStatus(response.status)) throw lastError;
+		} catch (error) {
+			if (!isRetryableError(error)) throw error;
+			lastError = error instanceof Error ? error : new Error(String(error));
+		}
+		if (attempt === config.maxAttempts) throw lastError ?? /* @__PURE__ */ new Error("Upload failed after retries");
+		const delay = Math.min(config.baseDelayMs * 2 ** (attempt - 1), config.maxDelayMs);
+		await new Promise((resolve) => setTimeout(resolve, delay));
+	}
+}
+async function resolveUploadHeaders(bundle, contentType) {
+	const contentLength = "path" in bundle ? (await promises.stat(bundle.path)).size : bundle.byteLength;
+	return {
+		...contentType ? { "Content-Type": contentType } : {},
+		"Content-Length": String(contentLength)
+	};
+}
+async function uploadRemoteBundle(url, bundle, headers) {
+	if ("path" in bundle) {
+		const bunFileBody = resolveBunFileBody(bundle.path);
+		if (bunFileBody) return fetch(url, {
+			method: "PUT",
+			body: bunFileBody,
+			headers
+		});
+		return uploadFileStreamToPresignedUrl(url, bundle.path, headers);
+	}
+	return await fetch(url, {
+		method: "PUT",
+		body: bundle,
+		headers
+	});
+}
+function resolveBunFileBody(filePath) {
+	const bun = globalThis.Bun;
+	return bun?.file ? bun.file(filePath) : void 0;
+}
+function uploadFileStreamToPresignedUrl(url, filePath, headers) {
+	return new Promise((resolve, reject) => {
+		const parsedUrl = new URL(url);
+		const client = parsedUrl.protocol === "http:" ? http : https;
+		let settled = false;
+		const settle = (fn) => {
+			if (settled) return;
+			settled = true;
+			fn();
+		};
+		const request = client.request(parsedUrl, {
+			method: "PUT",
+			headers
+		}, (response) => {
+			const chunks = [];
+			response.on("data", (chunk) => {
+				chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+			});
+			response.on("end", () => {
+				const body = Buffer.concat(chunks).toString("utf8");
+				settle(() => resolve({
+					ok: response.statusCode !== void 0 && response.statusCode >= 200 && response.statusCode < 300,
+					status: response.statusCode ?? 0,
+					statusText: response.statusMessage ?? "",
+					text: async () => body
+				}));
+			});
+		});
+		request.on("error", (error) => {
+			settle(() => reject(new TypeError(error.message)));
+		});
+		const stream = createReadStream(filePath);
+		stream.on("error", (error) => {
+			request.destroy(error);
+			settle(() => reject(error));
+		});
+		stream.pipe(request);
+	});
+}
+function resolveUploadBody(item) {
+	if (item.bundle) return item.bundle;
+	if (item.bundlePath) return { path: item.bundlePath };
+	throw new Error(`Upload item "${item.name}" did not include a bundle or bundlePath`);
+}
+//#endregion
+export { upload_exports as n, batchUpload as t };