/**
 * Session sharing.
 *
 * The session JSON is gzipped and sealed with a fresh AES-256-GCM key
 * (`[12B IV][ciphertext+tag]`, same layout as collab frames), then pushed to
 * one of two stores, chosen by `share.store`:
 *
 *   1. The share server (default — `POST <serverUrl>` → `{"id":"…"}`), capped
 *      at 1 MB; oversized sessions are truncated (images first, then long
 *      strings, then oldest entries) until the sealed blob fits.
 *   2. A secret GitHub gist (`store: "gist"`, when an authenticated `gh`
 *      exists; falls back to the share server) holding base64 of the blob.
 *
 * Either way the link is `<serverUrl>/<id>#<base64url key>`. The viewer page
 * served there fetches the blob (gist ids are hex; server ids never are),
 * decrypts with the fragment key — which never leaves the browser — and
 * renders the same template as `/export`.
 */
import * as fs from "node:fs/promises";
import * as os from "node:os";
import * as path from "node:path";
import type { AgentMessage, AgentState } from "@oh-my-pi/pi-agent-core";
import type { AssistantMessage, ImageContent, TextContent } from "@oh-my-pi/pi-ai";
import { $which, logger } from "@oh-my-pi/pi-utils";
import { DEFAULT_SHARE_URL } from "@oh-my-pi/pi-wire";
import { $ } from "bun";
import { obfuscateToolArguments, type SecretObfuscator } from "../secrets/obfuscator";
import { type SessionEntry, type SessionHeader, TITLE_CHANGE_ENTRY_TYPE } from "../session/session-entries";
import type { SessionManager } from "../session/session-manager";
import type { OutputMeta } from "../tools/output-meta";
import { buildSessionData, type SessionData, type SubSession } from "./html";

export { DEFAULT_SHARE_URL };

/** Hard cap for blobs accepted by the share server (mirrors relay shareMaxBytes). */
export const SERVER_MAX_SEALED_BYTES = 1_000_000;
/** Gist raw fetches cap at 10 MB; keep base64 (×4/3) comfortably under it. */
const GIST_MAX_SEALED_BYTES = 5_000_000;

const IV_LENGTH = 12;
const SHARE_KEY_BYTES = 32;
/** The viewer picks the gist file by this suffix. */
const GIST_FILENAME = "session.ompshare.txt";
/** Gist ids are hex; the relay never issues pure-hex ids, so the viewer can route on shape. */
const GIST_ID_RE = /^[0-9a-f]{20,64}$/;

/** Progressively harsher per-string caps applied when the sealed blob is over budget. */
const TEXT_CAPS = [32_768, 8_192, 2_048, 512];
/** 1×1 transparent GIF; stands in for stripped data-URL images so <img> tags stay valid. */
const BLANK_IMAGE_DATA_URL = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==";
const IMAGE_OMITTED_TEXT = "[image omitted from share]";

export type ShareStore = "blob" | "gist";

export interface ShareSessionOptions {
	/** Share server/viewer base URL; defaults to {@link DEFAULT_SHARE_URL}. */
	serverUrl?: string;
	/**
	 * Where to upload the sealed blob. `"blob"` (default) posts to the share
	 * server; `"gist"` pushes to a secret GitHub gist first (needs an
	 * authenticated `gh`) and falls back to the server.
	 */
	store?: ShareStore;
	/** Agent state for system prompt + tool descriptions in the snapshot. */
	state?: AgentState;
	/**
	 * Redacts the snapshot before sealing via a typed, per-field walk over the
	 * session (header title/cwd, system prompt, tool descriptions, entry summaries,
	 * labels, and message text — including tool-result output and `@file` mentions),
	 * so secrets that landed in persisted entries (tool outputs reading .env, etc.)
	 * never leave the machine. Inline image bytes are preserved (size-trimmed
	 * separately); opaque provider-replay blobs (`providerPayload`,
	 * `redactedThinking`, `compaction.preserveData`) and untyped extension payloads
	 * (`details`/`data`/`outputSchema`) are dropped rather than walked. Pass
	 * undefined to skip redaction entirely.
	 */
	obfuscator?: SecretObfuscator;
}

export interface ShareSessionResult {
	/** Viewer link: `<serverUrl>/<id>#<key>`. */
	url: string;
	method: "gist" | "server";
	/** Underlying gist URL (gist method only). */
	gistUrl?: string;
	/** True when content was trimmed to fit the upload budget. */
	truncated: boolean;
	sealedBytes: number;
}

/** Build the snapshot that gets sealed and uploaded, redacted when an obfuscator is provided. */
export function buildShareSnapshot(sm: SessionManager, options?: ShareSessionOptions): SessionData {
	const data = buildSessionData(sm, options?.state);
	return options?.obfuscator?.hasSecrets() ? redactSessionDataForShare(options.obfuscator, data) : data;
}

/**
 * Redact secrets from a share snapshot. A share blob leaves the machine, so
 * every text-bearing field is rewritten through the obfuscator. The walk is
 * typed end-to-end (no generic object traversal): inline image bytes are left
 * intact (size-trimmed later by {@link stripImagePayloads}) and opaque,
 * untyped payloads we cannot redact field-by-field (`compaction.preserveData`,
 * extension `details`/`data`, `mode_change.data`, structured output schemas)
 * are dropped so they cannot leak.
 */
function collectShareRegexSecretValues(o: SecretObfuscator, data: SessionData): Set<string> {
	const values = new Set<string>();
	const add = (value: string | undefined): void => {
		if (value === undefined) return;
		for (const secretValue of o.collectRegexSecretValuesForObfuscation(value)) {
			values.add(secretValue);
		}
	};
	const addJsonStrings = (value: unknown): void => {
		if (typeof value === "string") {
			add(value);
			return;
		}
		if (Array.isArray(value)) {
			for (const item of value) addJsonStrings(item);
			return;
		}
		if (!isRecord(value)) return;
		for (const item of Object.values(value)) addJsonStrings(item);
	};
	const addContent = (content: string | (TextContent | ImageContent)[]): void => {
		if (typeof content === "string") {
			add(content);
			return;
		}
		for (const block of content) {
			if (block.type === "text") add(block.text);
		}
	};
	const addOutputMeta = (meta: OutputMeta | undefined): void => {
		if (!meta) return;
		add(meta.source?.value);
		if (!meta.diagnostics) return;
		add(meta.diagnostics.summary);
		for (const message of meta.diagnostics.messages) add(message);
	};
	const addMessage = (message: AgentMessage): void => {
		switch (message.role) {
			case "user":
			case "developer":
			case "custom":
			case "hookMessage":
			case "toolResult":
				addContent(message.content as string | (TextContent | ImageContent)[]);
				return;
			case "assistant":
				add(message.errorMessage);
				for (const block of message.content) {
					if (block.type === "text") add(block.text);
					else if (block.type === "thinking") add(block.thinking);
					else if (block.type === "toolCall") {
						addJsonStrings(block.arguments);
						add(block.intent);
						add(block.rawBlock);
					}
				}
				return;
			case "bashExecution":
				add(message.command);
				add(message.output);
				addOutputMeta(message.meta);
				return;
			case "pythonExecution":
				add(message.code);
				add(message.output);
				addOutputMeta(message.meta);
				return;
			case "branchSummary":
				add(message.summary);
				return;
			case "compactionSummary":
				add(message.summary);
				add(message.shortSummary);
				if (message.blocks) addContent(message.blocks);
				return;
			case "fileMention":
				for (const file of message.files) {
					add(file.path);
					add(file.content);
				}
				return;
			default:
				return;
		}
	};
	const addEntry = (entry: SessionEntry): void => {
		switch (entry.type) {
			case "message":
				addMessage(entry.message);
				return;
			case "compaction":
				add(entry.summary);
				add(entry.shortSummary);
				return;
			case "branch_summary":
				add(entry.summary);
				return;
			case "custom_message":
				addContent(entry.content);
				return;
			case "session_init":
				add(entry.systemPrompt);
				add(entry.task);
				return;
			case "label":
				add(entry.label);
				return;
			case TITLE_CHANGE_ENTRY_TYPE:
				add(entry.title);
				add(entry.previousTitle);
				add(entry.trigger);
				return;
			default:
				return;
		}
	};
	const addHeader = (header: SessionHeader | null): void => {
		if (!header) return;
		add(header.title);
		add(header.cwd);
	};

	addHeader(data.header);
	add(data.systemPrompt);
	for (const tool of data.tools ?? []) add(tool.description);
	for (const entry of data.entries) addEntry(entry);
	for (const sub of Object.values(data.subSessions ?? {})) {
		addHeader(sub.header);
		for (const entry of sub.entries) addEntry(entry);
	}
	return values;
}

function redactShareHeader(
	o: SecretObfuscator,
	header: SessionHeader | null,
	sharedRegexSecretValues: ReadonlySet<string>,
): SessionHeader | null {
	if (!header) return header;
	return {
		...header,
		title: header.title === undefined ? undefined : o.obfuscate(header.title, sharedRegexSecretValues),
		cwd: o.obfuscate(header.cwd, sharedRegexSecretValues),
	};
}

function redactSessionDataForShare(o: SecretObfuscator, data: SessionData): SessionData {
	const sharedRegexSecretValues = collectShareRegexSecretValues(o, data);
	return {
		...data,
		header: redactShareHeader(o, data.header, sharedRegexSecretValues),
		systemPrompt:
			data.systemPrompt === undefined ? undefined : o.obfuscate(data.systemPrompt, sharedRegexSecretValues),
		tools: data.tools?.map(tool => ({
			...tool,
			description: o.obfuscate(tool.description, sharedRegexSecretValues),
		})),
		entries: data.entries.map(entry => redactShareEntry(o, entry, sharedRegexSecretValues)),
		subSessions: data.subSessions
			? Object.fromEntries(
					Object.entries(data.subSessions).map(([key, sub]) => [
						key,
						redactShareSubSession(o, sub, sharedRegexSecretValues),
					]),
				)
			: data.subSessions,
	};
}

function redactShareSubSession(
	o: SecretObfuscator,
	sub: SubSession,
	sharedRegexSecretValues: ReadonlySet<string>,
): SubSession {
	return {
		...sub,
		header: redactShareHeader(o, sub.header, sharedRegexSecretValues),
		entries: sub.entries.map(entry => redactShareEntry(o, entry, sharedRegexSecretValues)),
	};
}

function redactShareEntry(
	o: SecretObfuscator,
	entry: SessionEntry,
	sharedRegexSecretValues: ReadonlySet<string>,
): SessionEntry {
	switch (entry.type) {
		case "message":
			return { ...entry, message: redactShareMessage(o, entry.message, sharedRegexSecretValues) };
		case "compaction":
			return {
				...entry,
				summary: o.obfuscate(entry.summary, sharedRegexSecretValues),
				shortSummary:
					entry.shortSummary === undefined ? undefined : o.obfuscate(entry.shortSummary, sharedRegexSecretValues),
				details: undefined,
				preserveData: undefined,
			};
		case "branch_summary":
			return { ...entry, summary: o.obfuscate(entry.summary, sharedRegexSecretValues), details: undefined };
		case "custom_message":
			return {
				...entry,
				content: redactShareContent(o, entry.content, sharedRegexSecretValues),
				details: undefined,
			};
		case "custom":
			return { ...entry, data: undefined };
		case "mode_change":
			return { ...entry, data: undefined };
		case "session_init":
			return {
				...entry,
				systemPrompt: o.obfuscate(entry.systemPrompt, sharedRegexSecretValues),
				task: o.obfuscate(entry.task, sharedRegexSecretValues),
				outputSchema: undefined,
			};
		case "label":
			return {
				...entry,
				label: entry.label === undefined ? undefined : o.obfuscate(entry.label, sharedRegexSecretValues),
			};
		case TITLE_CHANGE_ENTRY_TYPE:
			return {
				...entry,
				title: o.obfuscate(entry.title, sharedRegexSecretValues),
				previousTitle:
					entry.previousTitle === undefined
						? undefined
						: o.obfuscate(entry.previousTitle, sharedRegexSecretValues),
				trigger: entry.trigger === undefined ? undefined : o.obfuscate(entry.trigger, sharedRegexSecretValues),
			};
		default:
			return entry;
	}
}

function redactShareContent(
	o: SecretObfuscator,
	content: string | (TextContent | ImageContent)[],
	sharedRegexSecretValues: ReadonlySet<string>,
): string | (TextContent | ImageContent)[] {
	if (typeof content === "string") return o.obfuscate(content, sharedRegexSecretValues);
	return content.map(block =>
		block.type === "text" ? { ...block, text: o.obfuscate(block.text, sharedRegexSecretValues) } : block,
	);
}

/** Redact freeform strings in tool output metadata (source path/URL, diagnostics); numeric truncation info is preserved. */
function redactShareOutputMeta(
	o: SecretObfuscator,
	meta: OutputMeta | undefined,
	sharedRegexSecretValues: ReadonlySet<string>,
): OutputMeta | undefined {
	if (!meta) return meta;
	return {
		...meta,
		source: meta.source
			? { ...meta.source, value: o.obfuscate(meta.source.value, sharedRegexSecretValues) }
			: meta.source,
		diagnostics: meta.diagnostics
			? {
					summary: o.obfuscate(meta.diagnostics.summary, sharedRegexSecretValues),
					messages: meta.diagnostics.messages.map(message => o.obfuscate(message, sharedRegexSecretValues)),
				}
			: meta.diagnostics,
	};
}

function redactShareMessage(
	o: SecretObfuscator,
	message: AgentMessage,
	sharedRegexSecretValues: ReadonlySet<string>,
): AgentMessage {
	switch (message.role) {
		case "user":
		case "developer":
			return {
				...message,
				providerPayload: undefined,
				content: redactShareContent(o, message.content, sharedRegexSecretValues),
			} as AgentMessage;
		case "custom":
		case "hookMessage":
			return {
				...message,
				details: undefined,
				content: redactShareContent(o, message.content, sharedRegexSecretValues),
			} as AgentMessage;
		case "toolResult":
			return {
				...message,
				details: undefined,
				content: redactShareContent(o, message.content, sharedRegexSecretValues) as (TextContent | ImageContent)[],
			};
		case "assistant":
			// Drop opaque provider-replay state (encrypted reasoning / native history) the viewer
			// never reads and we cannot redact field-by-field: `providerPayload`, any
			// `redactedThinking` blocks, and native Anthropic server-tool blocks
			// (`server_tool_use` input / `web_search_tool_result` encrypted_content).
			return {
				...message,
				providerPayload: undefined,
				errorMessage:
					message.errorMessage === undefined
						? undefined
						: o.obfuscate(message.errorMessage, sharedRegexSecretValues),
				content: message.content.flatMap((block): AssistantMessage["content"] => {
					if (block.type === "redactedThinking" || block.type === "anthropicServerTool") return [];
					if (block.type === "text") return [{ ...block, text: o.obfuscate(block.text, sharedRegexSecretValues) }];
					if (block.type === "thinking") {
						return [{ ...block, thinking: o.obfuscate(block.thinking, sharedRegexSecretValues) }];
					}
					if (block.type === "toolCall") {
						return [
							{
								...block,
								arguments: obfuscateToolArguments(o, block.arguments, sharedRegexSecretValues),
								intent:
									block.intent === undefined ? undefined : o.obfuscate(block.intent, sharedRegexSecretValues),
								rawBlock:
									block.rawBlock === undefined
										? undefined
										: o.obfuscate(block.rawBlock, sharedRegexSecretValues),
							},
						];
					}
					return [block];
				}),
			};
		case "bashExecution":
			return {
				...message,
				command: o.obfuscate(message.command, sharedRegexSecretValues),
				output: o.obfuscate(message.output, sharedRegexSecretValues),
				meta: redactShareOutputMeta(o, message.meta, sharedRegexSecretValues),
			};
		case "pythonExecution":
			return {
				...message,
				code: o.obfuscate(message.code, sharedRegexSecretValues),
				output: o.obfuscate(message.output, sharedRegexSecretValues),
				meta: redactShareOutputMeta(o, message.meta, sharedRegexSecretValues),
			};
		case "branchSummary":
			return { ...message, summary: o.obfuscate(message.summary, sharedRegexSecretValues) };
		case "compactionSummary":
			return {
				...message,
				providerPayload: undefined,
				summary: o.obfuscate(message.summary, sharedRegexSecretValues),
				shortSummary:
					message.shortSummary === undefined
						? undefined
						: o.obfuscate(message.shortSummary, sharedRegexSecretValues),
				blocks:
					message.blocks === undefined
						? undefined
						: (redactShareContent(o, message.blocks, sharedRegexSecretValues) as (TextContent | ImageContent)[]),
			};
		case "fileMention":
			return {
				...message,
				files: message.files.map(file => ({
					...file,
					path: o.obfuscate(file.path, sharedRegexSecretValues),
					content: o.obfuscate(file.content, sharedRegexSecretValues),
				})),
			};
		default:
			return message;
	}
}

/** Share the session; uploads to the share server unless `options.store` is `"gist"`. */
export async function shareSession(sm: SessionManager, options?: ShareSessionOptions): Promise<ShareSessionResult> {
	const data = buildShareSnapshot(sm, options);
	const keyBytes = new Uint8Array(SHARE_KEY_BYTES);
	crypto.getRandomValues(keyBytes);
	const key = await crypto.subtle.importKey("raw", keyBytes, "AES-GCM", false, ["encrypt"]);
	const keyText = Buffer.from(keyBytes).toString("base64url");
	const base = normalizeShareServerUrl(options?.serverUrl);

	if (options?.store === "gist") {
		const forGist = await sealToFit(key, data, GIST_MAX_SEALED_BYTES);
		const gist = await tryCreateGist(forGist.sealed);
		if (gist) {
			return {
				url: `${base}/${gist.id}#${keyText}`,
				method: "gist",
				gistUrl: gist.url,
				truncated: forGist.truncated,
				sealedBytes: forGist.sealed.byteLength,
			};
		}
		// gh unusable or gist creation failed — fall back to the share server.
		return shareViaServer(key, data, base, keyText, forGist);
	}

	return shareViaServer(key, data, base, keyText);
}

/** Strip trailing slashes so `<base>/<id>` composes cleanly. */
export function normalizeShareServerUrl(serverUrl?: string): string {
	const base = (serverUrl ?? DEFAULT_SHARE_URL).trim().replace(/\/+$/, "");
	return base || DEFAULT_SHARE_URL;
}

interface SealedSession {
	sealed: Uint8Array<ArrayBuffer>;
	truncated: boolean;
}

/** Seal `data`, trimming content until the sealed blob fits `maxBytes`. Exported for tests. */
export async function sealToFit(key: CryptoKey, data: SessionData, maxBytes: number): Promise<SealedSession> {
	let sealed = await sealSessionData(key, data);
	if (sealed.byteLength <= maxBytes) return { sealed, truncated: false };

	// Work on a deep copy; the caller may re-fit the original at another budget.
	const working = structuredClone(data);
	stripImagePayloads(working);
	sealed = await sealSessionData(key, working);
	if (sealed.byteLength <= maxBytes) return { sealed, truncated: true };

	for (const cap of TEXT_CAPS) {
		capLongStrings(working, cap);
		sealed = await sealSessionData(key, working);
		if (sealed.byteLength <= maxBytes) return { sealed, truncated: true };
	}

	// Last resort: drop oldest entries (orphaned children render as roots).
	while (working.entries.length > 4) {
		working.entries = working.entries.slice(Math.ceil(working.entries.length / 2));
		sealed = await sealSessionData(key, working);
		if (sealed.byteLength <= maxBytes) return { sealed, truncated: true };
	}

	throw new Error(`Session too large to share: ${sealed.byteLength} bytes sealed exceeds the ${maxBytes} byte limit`);
}

/** `[12B IV][AES-256-GCM(gzip(JSON))]` — decrypted and gunzipped by share-loader.js. */
async function sealSessionData(key: CryptoKey, data: SessionData): Promise<Uint8Array<ArrayBuffer>> {
	const compressed = Bun.gzipSync(new TextEncoder().encode(JSON.stringify(data)));
	const iv = new Uint8Array(IV_LENGTH);
	crypto.getRandomValues(iv);
	const ciphertext = new Uint8Array(await crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, compressed));
	const out = new Uint8Array(IV_LENGTH + ciphertext.byteLength);
	out.set(iv, 0);
	out.set(ciphertext, IV_LENGTH);
	return out;
}

function isRecord(value: unknown): value is Record<string, unknown> {
	return typeof value === "object" && value !== null;
}

/** Replace inline image payloads (image blocks + data: URLs) with tiny placeholders, in place. */
function stripImagePayloads(value: unknown): void {
	if (Array.isArray(value)) {
		for (let i = 0; i < value.length; i++) {
			const item: unknown = value[i];
			if (isRecord(item) && item.type === "image" && typeof item.data === "string" && item.data.length > 1024) {
				value[i] = { type: "text", text: IMAGE_OMITTED_TEXT };
				continue;
			}
			stripImagePayloads(item);
		}
		return;
	}
	if (!isRecord(value)) return;
	for (const k in value) {
		const v = value[k];
		if (typeof v === "string") {
			if (v.length > 1024 && v.startsWith("data:")) value[k] = BLANK_IMAGE_DATA_URL;
			continue;
		}
		stripImagePayloads(v);
	}
}

/** Truncate every string longer than `cap`, in place. */
function capLongStrings(value: unknown, cap: number): void {
	if (Array.isArray(value)) {
		for (let i = 0; i < value.length; i++) {
			const item: unknown = value[i];
			if (typeof item === "string" && item.length > cap) value[i] = `${item.slice(0, cap)}\n…[truncated for share]`;
			else capLongStrings(item, cap);
		}
		return;
	}
	if (!isRecord(value)) return;
	for (const k in value) {
		const v = value[k];
		if (typeof v === "string") {
			if (v.length > cap) value[k] = `${v.slice(0, cap)}\n…[truncated for share]`;
			continue;
		}
		capLongStrings(v, cap);
	}
}

/** Create a secret gist holding base64 of the sealed blob; null when `gh` is unusable. */
async function tryCreateGist(sealed: Uint8Array): Promise<{ id: string; url: string } | null> {
	if (!$which("gh")) return null;
	const auth = await $`gh auth status`.quiet().nothrow();
	if (auth.exitCode !== 0) {
		logger.debug("share: gh present but not authenticated; falling back to share server");
		return null;
	}

	const dir = await fs.mkdtemp(path.join(os.tmpdir(), "omp-share-"));
	try {
		const file = path.join(dir, GIST_FILENAME);
		await Bun.write(file, Buffer.from(sealed).toString("base64"));
		const result = await $`gh gist create --public=false ${file}`.quiet().nothrow();
		if (result.exitCode !== 0) {
			logger.warn("share: gist creation failed; falling back to share server", {
				stderr: result.stderr.toString("utf-8").trim().slice(0, 500),
			});
			return null;
		}
		const url = result.text().trim().split("\n").pop()?.trim() ?? "";
		const id = url.split("/").pop() ?? "";
		if (!GIST_ID_RE.test(id)) {
			logger.warn("share: could not parse gist id from gh output", { url });
			return null;
		}
		return { id, url };
	} finally {
		await fs.rm(dir, { recursive: true, force: true });
	}
}

/** Seal to the server cap (reusing `preFit` when it already fits) and upload. */
async function shareViaServer(
	key: CryptoKey,
	data: SessionData,
	base: string,
	keyText: string,
	preFit?: SealedSession,
): Promise<ShareSessionResult> {
	const forServer =
		preFit && preFit.sealed.byteLength <= SERVER_MAX_SEALED_BYTES
			? preFit
			: await sealToFit(key, data, SERVER_MAX_SEALED_BYTES);
	const id = await uploadToServer(forServer.sealed, base);
	return {
		url: `${base}/${id}#${keyText}`,
		method: "server",
		truncated: forServer.truncated,
		sealedBytes: forServer.sealed.byteLength,
	};
}

/** POST the sealed blob to the share server; returns the assigned id. */
async function uploadToServer(sealed: Uint8Array, base: string): Promise<string> {
	let res: Response;
	try {
		res = await fetch(base, {
			method: "POST",
			headers: { "Content-Type": "application/octet-stream" },
			body: sealed,
		});
	} catch (err) {
		throw new Error(`Share upload to ${base} failed: ${err instanceof Error ? err.message : String(err)}`);
	}
	if (!res.ok) {
		const detail = (await res.text().catch(() => "")).trim().slice(0, 200);
		throw new Error(`Share upload to ${base} failed: HTTP ${res.status}${detail ? ` (${detail})` : ""}`);
	}
	const body = (await res.json().catch(() => null)) as { id?: unknown } | null;
	const id = body && typeof body.id === "string" ? body.id : "";
	if (!/^[A-Za-z0-9_-]{10,64}$/.test(id)) {
		throw new Error(`Share upload to ${base} failed: server returned no usable id`);
	}
	return id;
}