@ai-gui/plugin-artifact 0.4.0

package/dist/index.js

@@ -0,0 +1,1010 @@
+//#region src/index.ts
+const CREATE_KEYS = new Set([
+	"version",
+	"operationId",
+	"artifact"
+]);
+const ARTIFACT_KEYS = new Set([
+	"id",
+	"title",
+	"filename",
+	"kind",
+	"language",
+	"content"
+]);
+const UPDATE_KEYS = new Set([
+	"version",
+	"operationId",
+	"id",
+	"baseRevision",
+	"content",
+	"title",
+	"filename",
+	"language"
+]);
+const RECORD_KEYS = new Set([
+	"id",
+	"title",
+	"filename",
+	"kind",
+	"language",
+	"content",
+	"revision"
+]);
+const SNAPSHOT_KEYS = new Set([
+	"version",
+	"records",
+	"receipts"
+]);
+const RECEIPT_SNAPSHOT_KEYS = new Set([
+	"operationId",
+	"canonical",
+	"receipt"
+]);
+const RECEIPT_KEYS = new Set([
+	"operationId",
+	"command",
+	"record"
+]);
+const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+const SAFE_OPERATION_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+const KINDS = new Set([
+	"text",
+	"code",
+	"markdown",
+	"json"
+]);
+const DANGEROUS_KEYS = new Set([
+	"__proto__",
+	"prototype",
+	"constructor"
+]);
+const MAX_SOURCE_BYTES = 1024 * 1024;
+const DEFAULT_MAX_ARTIFACTS = 100;
+const DEFAULT_MAX_ARTIFACT_BYTES = 512 * 1024;
+const DEFAULT_MAX_TOTAL_BYTES = 4 * 1024 * 1024;
+const MAX_TITLE_LENGTH = 256;
+const MAX_FILENAME_LENGTH = 180;
+const MAX_LANGUAGE_LENGTH = 64;
+const MAX_JSON_PREVIEW_CHARS = 256 * 1024;
+var ArtifactError = class extends Error {};
+var ArtifactValidationError = class extends ArtifactError {};
+var ArtifactLimitError = class extends ArtifactError {};
+var ArtifactNotFoundError = class extends ArtifactError {};
+var ArtifactConflictError = class extends ArtifactError {};
+var ArtifactOperationConflictError = class extends ArtifactError {};
+var ArtifactSnapshotError = class extends ArtifactError {};
+var ArtifactStore = class {
+	records = new Map();
+	receipts = new Map();
+	listeners = new Map();
+	allListeners = new Set();
+	epoch = 0;
+	limits;
+	constructor(options = {}) {
+		assertPlainOptions(options);
+		this.limits = {
+			maxArtifacts: readPositiveLimit(options.maxArtifacts, DEFAULT_MAX_ARTIFACTS, "maxArtifacts", DEFAULT_MAX_ARTIFACTS),
+			maxArtifactBytes: readPositiveLimit(options.maxArtifactBytes, DEFAULT_MAX_ARTIFACT_BYTES, "maxArtifactBytes", DEFAULT_MAX_ARTIFACT_BYTES),
+			maxTotalBytes: readPositiveLimit(options.maxTotalBytes, DEFAULT_MAX_TOTAL_BYTES, "maxTotalBytes", DEFAULT_MAX_TOTAL_BYTES)
+		};
+	}
+	create(command) {
+		const parsed = validateCreateValue(command);
+		if (!parsed.valid) throw new ArtifactValidationError(parsed.issues.join(" "));
+		const canonical = canonicalCreate(parsed.data);
+		const prior = this.checkReceipt(parsed.data.operationId, canonical);
+		if (prior) return prior;
+		if (this.records.has(parsed.data.artifact.id)) throw new ArtifactConflictError("Artifact already exists.");
+		const record = freezeRecord({
+			...parsed.data.artifact,
+			revision: 0
+		});
+		this.assertCapacity(record);
+		this.records.set(record.id, record);
+		const receipt = freezeReceipt({
+			operationId: parsed.data.operationId,
+			command: "create",
+			record
+		});
+		this.receipts.set(receipt.operationId, {
+			canonical,
+			receipt
+		});
+		this.mutated(record.id);
+		return receipt;
+	}
+	update(command) {
+		const parsed = validateUpdateValue(command);
+		if (!parsed.valid) throw new ArtifactValidationError(parsed.issues.join(" "));
+		const canonical = canonicalUpdate(parsed.data);
+		const prior = this.checkReceipt(parsed.data.operationId, canonical);
+		if (prior) return prior;
+		const current = this.records.get(parsed.data.id);
+		if (!current) throw new ArtifactNotFoundError("Artifact does not exist.");
+		if (current.revision !== parsed.data.baseRevision) throw new ArtifactConflictError("Artifact revision conflict.");
+		if (parsed.data.language !== void 0 && current.kind !== "code") throw new ArtifactValidationError("Language can be updated only for code artifacts.");
+		const record = freezeRecord({
+			...current,
+			content: parsed.data.content,
+			title: parsed.data.title ?? current.title,
+			filename: parsed.data.filename ?? current.filename,
+			...current.language === void 0 ? {} : { language: current.language },
+			...parsed.data.language === void 0 ? {} : { language: parsed.data.language },
+			revision: current.revision + 1
+		});
+		this.assertCapacity(record, current.id);
+		this.records.set(record.id, record);
+		const receipt = freezeReceipt({
+			operationId: parsed.data.operationId,
+			command: "update",
+			record
+		});
+		this.receipts.set(receipt.operationId, {
+			canonical,
+			receipt
+		});
+		this.mutated(record.id);
+		return receipt;
+	}
+	get(id) {
+		return this.records.get(id);
+	}
+	list() {
+		return Object.freeze([...this.records.values()]);
+	}
+	subscribe(id, listener) {
+		if (typeof listener !== "function") throw new TypeError("Artifact listener must be a function.");
+		let listeners = this.listeners.get(id);
+		if (!listeners) this.listeners.set(id, listeners = new Set());
+		listeners.add(listener);
+		let active = true;
+		return () => {
+			if (!active) return;
+			active = false;
+			listeners?.delete(listener);
+			if (listeners?.size === 0) this.listeners.delete(id);
+		};
+	}
+	subscribeAll(listener) {
+		if (typeof listener !== "function") throw new TypeError("Artifact listener must be a function.");
+		this.allListeners.add(listener);
+		let active = true;
+		return () => {
+			if (!active) return;
+			active = false;
+			this.allListeners.delete(listener);
+		};
+	}
+	delete(id) {
+		if (!this.records.delete(id)) return false;
+		this.mutated(id);
+		return true;
+	}
+	clear() {
+		if (this.records.size === 0 && this.receipts.size === 0) return;
+		const ids = [...this.records.keys()];
+		this.records.clear();
+		this.receipts.clear();
+		this.epoch++;
+		for (const id of ids) this.notifyOne(id);
+		this.notifyAll();
+	}
+	snapshot() {
+		return deepFreeze({
+			version: 1,
+			records: [...this.records.values()].map((record) => ({ ...record })),
+			receipts: [...this.receipts.entries()].map(([operationId, entry]) => ({
+				operationId,
+				canonical: entry.canonical,
+				receipt: {
+					...entry.receipt,
+					record: { ...entry.receipt.record }
+				}
+			}))
+		});
+	}
+	restore(snapshot) {
+		let restored;
+		try {
+			restored = validateSnapshot(snapshot, this.limits);
+		} catch (error) {
+			throw new ArtifactSnapshotError(error instanceof Error ? error.message : "Invalid artifact snapshot.");
+		}
+		const oldIds = new Set(this.records.keys());
+		this.records = restored.records;
+		this.receipts = restored.receipts;
+		this.epoch++;
+		for (const id of this.records.keys()) oldIds.add(id);
+		for (const id of oldIds) this.notifyOne(id);
+		this.notifyAll();
+	}
+	captureMutationEpoch() {
+		return this.epoch;
+	}
+	checkReceipt(operationId, canonical) {
+		const prior = this.receipts.get(operationId);
+		if (!prior) return void 0;
+		if (prior.canonical !== canonical) throw new ArtifactOperationConflictError("Operation ID was already used for another command.");
+		return prior.receipt;
+	}
+	assertCapacity(next, replacingId) {
+		if (!replacingId && this.records.size >= this.limits.maxArtifacts) throw new ArtifactLimitError("Artifact count limit exceeded.");
+		const bytes = utf8Bytes(next.content);
+		if (bytes > this.limits.maxArtifactBytes) throw new ArtifactLimitError("Artifact size limit exceeded.");
+		let total = bytes;
+		for (const record of this.records.values()) if (record.id !== replacingId) total += utf8Bytes(record.content);
+		if (total > this.limits.maxTotalBytes) throw new ArtifactLimitError("Artifact total size limit exceeded.");
+	}
+	mutated(id) {
+		this.epoch++;
+		this.notifyOne(id);
+		this.notifyAll();
+	}
+	notifyOne(id) {
+		const record = this.records.get(id);
+		for (const listener of [...this.listeners.get(id) ?? []]) safeCall(listener, record);
+	}
+	notifyAll() {
+		const records = this.list();
+		for (const listener of [...this.allListeners]) safeCall(listener, records);
+	}
+};
+function parseArtifactCreate(source) {
+	return parseCommand(source, validateCreateValue, "Artifact create command");
+}
+function parseArtifactUpdate(source) {
+	return parseCommand(source, validateUpdateValue, "Artifact update command");
+}
+function serializeArtifactCreate(command) {
+	const parsed = validateCreateValue(command);
+	if (!parsed.valid) throw new ArtifactValidationError(parsed.issues.join(" "));
+	return `\`\`\`artifact-create\n${JSON.stringify(parsed.data, null, 2)}\n\`\`\``;
+}
+function serializeArtifactUpdate(command) {
+	const parsed = validateUpdateValue(command);
+	if (!parsed.valid) throw new ArtifactValidationError(parsed.issues.join(" "));
+	return `\`\`\`artifact-update\n${JSON.stringify(parsed.data, null, 2)}\n\`\`\``;
+}
+function artifactPromptSpec(store) {
+	const records = store?.list() ?? [];
+	const current = records.length === 0 ? "Current artifacts: none." : `Current artifacts:\n${records.map((record) => `- ${record.id}: ${record.kind}, revision ${record.revision}, title ${JSON.stringify(record.title)}`).join("\n")}`;
+	return [
+		"Artifacts use only fenced JSON commands named exactly ```artifact-create and ```artifact-update.",
+		"Create schema: {version:1, operationId, artifact:{id,title,filename,kind:text|code|markdown|json,language?,content}}. Do not send a create revision.",
+		"Update schema: {version:1, operationId,id,baseRevision,content,title?,filename?,language?}. Updates replace full content; kind is immutable. There is no model delete command.",
+		"Use a new safe operationId for each intended mutation. Never claim success; the application commits commands only after validation.",
+		"Never emit HTML, scripts, executable URLs, actions, components, network requests, or other fence types. Markdown artifact content may contain Markdown and HTTPS links, but raw HTML never executes.",
+		current
+	].join("\n");
+}
+function artifact(options = {}) {
+	if (!isPlainObject(options)) throw new TypeError("artifact() options must be a plain object.");
+	rejectDangerousObjectKeys(options, "artifact options");
+	for (const key of Object.keys(options)) if (key !== "store") throw new TypeError(`Unknown artifact option: ${key}`);
+	const store = options.store ?? new ArtifactStore();
+	if (!(store instanceof ArtifactStore)) throw new TypeError("artifact store must be an ArtifactStore.");
+	const status = new WeakMap();
+	const outputs = new WeakMap();
+	let anchor;
+	const render = (node) => {
+		const cached = outputs.get(node);
+		if (cached) return cached;
+		const state = status.get(node) ?? (node.complete ? "rejected" : "loading");
+		let output;
+		if (node === anchor && state === "accepted") output = {
+			kind: "mount",
+			mount: (host) => mountArtifactWorkspace(host, store)
+		};
+		else if (state === "loading") output = {
+			kind: "element",
+			tag: "div",
+			props: {
+				"data-aigui-block-loading": "",
+				"data-block-type": node.type
+			},
+			children: []
+		};
+		else output = statusOutput(state === "accepted");
+		outputs.set(node, output);
+		return output;
+	};
+	return {
+		name: "artifact",
+		nodeRenderers: {
+			"artifact-create": render,
+			"artifact-update": render
+		},
+		onASTCommit: (nodes, context) => {
+			anchor = void 0;
+			for (const node of nodes) {
+				if (node.type !== "artifact-create" && node.type !== "artifact-update") continue;
+				if (!node.complete) {
+					status.set(node, "loading");
+					continue;
+				}
+				try {
+					if (node.type === "artifact-create") {
+						const parsed = parseArtifactCreate(node.content ?? "");
+						if (!parsed.valid) throw new ArtifactValidationError("Invalid command.");
+						store.create(parsed.data);
+						status.set(node, "accepted");
+						if (!anchor) anchor = node;
+					} else {
+						const parsed = parseArtifactUpdate(node.content ?? "");
+						if (!parsed.valid) throw new ArtifactValidationError("Invalid command.");
+						store.update(parsed.data);
+						status.set(node, "accepted");
+					}
+					context.emitDebug("artifact-command-committed", {
+						nodeType: node.type,
+						nodeKey: node.key
+					});
+				} catch (error) {
+					status.set(node, "rejected");
+					context.emitDebug("artifact-command-rejected", {
+						nodeType: node.type,
+						nodeKey: node.key,
+						errorName: error instanceof Error ? error.name : "Error"
+					});
+				}
+			}
+		},
+		promptSpec: () => artifactPromptSpec(store),
+		css: artifactCss
+	};
+}
+function mountArtifactWorkspace(host, store) {
+	if (!host || typeof host.replaceChildren !== "function") throw new TypeError("Artifact workspace requires an HTMLElement host.");
+	if (!(store instanceof ArtifactStore)) throw new TypeError("Artifact workspace requires an ArtifactStore.");
+	let selectedId;
+	let activeTab = "preview";
+	let disposed = false;
+	const objectUrls = new Set();
+	const timers = new Set();
+	const render = () => {
+		if (disposed) return;
+		const records = store.list();
+		if (!selectedId || !records.some((record) => record.id === selectedId)) selectedId = records[0]?.id;
+		const selected = selectedId ? store.get(selectedId) : void 0;
+		const root = element("section", {
+			"data-aigui-artifact-workspace": "",
+			"aria-label": "Artifact workspace"
+		});
+		const sidebar = element("nav", {
+			"data-artifact-list": "",
+			"aria-label": "Artifacts"
+		});
+		const list = element("ul");
+		for (const record of records) {
+			const item = element("li");
+			const button = element("button", {
+				type: "button",
+				"data-artifact-id": record.id,
+				"data-artifact-selected": String(record.id === selectedId),
+				"aria-current": record.id === selectedId ? "true" : "false"
+			}, record.title);
+			button.addEventListener("click", () => {
+				selectedId = record.id;
+				render();
+			});
+			item.append(button);
+			list.append(item);
+		}
+		sidebar.append(list);
+		const main = element("div", { "data-artifact-main": "" });
+		if (selected) {
+			const header = element("header", { "data-artifact-header": "" });
+			const identity = element("div", { "data-artifact-identity": "" });
+			identity.append(element("h2", void 0, selected.title));
+			identity.append(element("p", { "data-artifact-meta": "" }, `${selected.filename} · ${selected.kind} · revision ${selected.revision}`));
+			header.append(identity);
+			const actions = element("div", { "data-artifact-actions": "" });
+			const copy = element("button", {
+				type: "button",
+				"data-artifact-copy": ""
+			}, "Copy");
+			copy.addEventListener("click", () => {
+				copyText(selected.content);
+			});
+			const download = element("button", {
+				type: "button",
+				"data-artifact-download": ""
+			}, "Download");
+			download.addEventListener("click", () => downloadRecord(selected, objectUrls, timers));
+			actions.append(copy, download);
+			header.append(actions);
+			main.append(header);
+			const tabs = element("div", {
+				role: "tablist",
+				"aria-label": "Artifact view",
+				"data-artifact-tabs": ""
+			});
+			const previewTab = tabButton("preview", activeTab, () => {
+				activeTab = "preview";
+				render();
+			});
+			const sourceTab = tabButton("source", activeTab, () => {
+				activeTab = "source";
+				render();
+			});
+			const onTabKey = (event) => {
+				if (event.key !== "ArrowLeft" && event.key !== "ArrowRight" && event.key !== "Home" && event.key !== "End") return;
+				event.preventDefault();
+				activeTab = event.key === "ArrowLeft" || event.key === "Home" ? "preview" : "source";
+				render();
+				host.querySelector(`[data-artifact-tab="${activeTab}"]`)?.focus();
+			};
+			previewTab.addEventListener("keydown", onTabKey);
+			sourceTab.addEventListener("keydown", onTabKey);
+			tabs.append(previewTab, sourceTab);
+			main.append(tabs);
+			const panel = element("div", {
+				role: "tabpanel",
+				"data-artifact-panel": "",
+				tabindex: "0"
+			});
+			if (activeTab === "source") panel.append(sourceView(selected.content));
+			else panel.append(previewRecord(selected));
+			main.append(panel);
+		} else main.append(element("p", { "data-artifact-empty": "" }, "No artifacts available."));
+		root.append(sidebar, main);
+		host.replaceChildren(root);
+	};
+	const unsubscribe = store.subscribeAll(render);
+	render();
+	return () => {
+		if (disposed) return;
+		disposed = true;
+		unsubscribe();
+		for (const timer of timers) clearTimeout(timer);
+		timers.clear();
+		for (const url of objectUrls) URL.revokeObjectURL(url);
+		objectUrls.clear();
+		host.replaceChildren();
+	};
+}
+const artifactCss = `
+[data-aigui-artifact-workspace]{display:grid;grid-template-columns:minmax(10rem,15rem) minmax(0,1fr);border:1px solid #d7dce2;border-radius:.75rem;overflow:hidden;background:#fff;color:#17202a;min-height:20rem}
+[data-artifact-list]{border-right:1px solid #d7dce2;padding:.75rem;overflow:auto}[data-artifact-list] ul{list-style:none;margin:0;padding:0;display:grid;gap:.25rem}
+[data-artifact-list] button{width:100%;text-align:left;border:0;border-radius:.4rem;padding:.55rem .65rem;background:transparent;color:inherit}[data-artifact-selected="true"]{background:#eef3f8!important;font-weight:600}
+[data-artifact-main]{min-width:0;padding:1rem}[data-artifact-header]{display:flex;align-items:center;justify-content:space-between;gap:1rem}[data-artifact-header] h2{margin:0;font-size:1rem;overflow-wrap:anywhere}
+[data-artifact-meta]{margin:.25rem 0 0;color:#66707a;font:12px/1.4 ui-monospace,monospace;overflow-wrap:anywhere}
+[data-artifact-actions],[data-artifact-tabs]{display:flex;gap:.5rem}[data-artifact-tabs]{margin:.85rem 0;border-bottom:1px solid #d7dce2}[data-artifact-tabs] button{border:0;background:transparent;padding:.5rem .2rem}[data-artifact-tabs] [aria-selected="true"]{border-bottom:2px solid currentColor;font-weight:600}
+[data-artifact-preview],[data-artifact-source]{white-space:pre-wrap;overflow-wrap:anywhere;max-width:100%;overflow:auto}[data-artifact-preview] pre,[data-artifact-source]{padding:.8rem;border-radius:.5rem;background:#f5f7f9}
+@media(max-width:640px){[data-aigui-artifact-workspace]{grid-template-columns:1fr}[data-artifact-list]{border-right:0;border-bottom:1px solid #d7dce2;max-height:9rem}[data-artifact-header]{align-items:flex-start;flex-direction:column}}
+`.trim();
+function parseCommand(source, validate, label) {
+	if (typeof source !== "string") return {
+		valid: false,
+		issues: [`${label} must be JSON text.`]
+	};
+	if (utf8Bytes(source) > MAX_SOURCE_BYTES) return {
+		valid: false,
+		issues: [`${label} is too large.`]
+	};
+	let value;
+	try {
+		value = JSON.parse(source);
+	} catch {
+		return {
+			valid: false,
+			issues: [`${label} must be valid JSON.`]
+		};
+	}
+	return validate(value);
+}
+function validateCreateValue(value) {
+	const issues = [];
+	if (!isPlainObject(value)) return {
+		valid: false,
+		issues: ["$ must be a plain object."]
+	};
+	inspectObject(value, CREATE_KEYS, "$", issues);
+	if (value.version !== 1) issues.push("$.version must equal 1.");
+	const operationId = readSafeString(value.operationId, "$.operationId", issues, SAFE_OPERATION_ID, 128);
+	const artifact$1 = validateArtifact(value.artifact, "$.artifact", issues);
+	if (issues.length || !operationId || !artifact$1) return {
+		valid: false,
+		issues
+	};
+	return {
+		valid: true,
+		data: {
+			version: 1,
+			operationId,
+			artifact: artifact$1
+		}
+	};
+}
+function validateUpdateValue(value) {
+	const issues = [];
+	if (!isPlainObject(value)) return {
+		valid: false,
+		issues: ["$ must be a plain object."]
+	};
+	inspectObject(value, UPDATE_KEYS, "$", issues);
+	if (value.version !== 1) issues.push("$.version must equal 1.");
+	const operationId = readSafeString(value.operationId, "$.operationId", issues, SAFE_OPERATION_ID, 128);
+	const id = readSafeString(value.id, "$.id", issues, SAFE_ID, 128);
+	const baseRevision = readRevision(value.baseRevision, "$.baseRevision", issues);
+	const content = readString(value.content, "$.content", issues);
+	const title = value.title === void 0 ? void 0 : readBoundedString(value.title, "$.title", issues, MAX_TITLE_LENGTH);
+	const filename = value.filename === void 0 ? void 0 : readFilename(value.filename, "$.filename", issues);
+	const language = value.language === void 0 ? void 0 : readLanguage(value.language, "$.language", issues);
+	if (issues.length || !operationId || !id || baseRevision === void 0 || content === void 0) return {
+		valid: false,
+		issues
+	};
+	return {
+		valid: true,
+		data: {
+			version: 1,
+			operationId,
+			id,
+			baseRevision,
+			content,
+			...title === void 0 ? {} : { title },
+			...filename === void 0 ? {} : { filename },
+			...language === void 0 ? {} : { language }
+		}
+	};
+}
+function validateArtifact(value, path, issues) {
+	if (!isPlainObject(value)) {
+		issues.push(`${path} must be a plain object.`);
+		return void 0;
+	}
+	inspectObject(value, ARTIFACT_KEYS, path, issues);
+	const id = readSafeString(value.id, `${path}.id`, issues, SAFE_ID, 128);
+	const title = readBoundedString(value.title, `${path}.title`, issues, MAX_TITLE_LENGTH);
+	const filename = readFilename(value.filename, `${path}.filename`, issues);
+	const kindValue = readBoundedString(value.kind, `${path}.kind`, issues, 16);
+	const kind = kindValue && KINDS.has(kindValue) ? kindValue : void 0;
+	if (kindValue && !kind) issues.push(`${path}.kind is not supported.`);
+	const language = value.language === void 0 ? void 0 : readLanguage(value.language, `${path}.language`, issues);
+	const content = readString(value.content, `${path}.content`, issues);
+	if (language !== void 0 && kind !== "code") issues.push(`${path}.language is supported only for code artifacts.`);
+	if (!id || title === void 0 || !filename || !kind || content === void 0) return void 0;
+	return {
+		id,
+		title,
+		filename,
+		kind,
+		...language === void 0 ? {} : { language },
+		content
+	};
+}
+function validateRecord(value, path, issues) {
+	if (!isPlainObject(value)) {
+		issues.push(`${path} must be a plain object.`);
+		return void 0;
+	}
+	inspectObject(value, RECORD_KEYS, path, issues);
+	const artifact$1 = validateArtifactKeys(value, path, issues);
+	const revision = readRevision(value.revision, `${path}.revision`, issues);
+	if (!artifact$1 || revision === void 0) return void 0;
+	return freezeRecord({
+		...artifact$1,
+		revision
+	});
+}
+function validateArtifactKeys(value, path, issues) {
+	const id = readSafeString(value.id, `${path}.id`, issues, SAFE_ID, 128);
+	const title = readBoundedString(value.title, `${path}.title`, issues, MAX_TITLE_LENGTH);
+	const filename = readFilename(value.filename, `${path}.filename`, issues);
+	const kindValue = readBoundedString(value.kind, `${path}.kind`, issues, 16);
+	const kind = kindValue && KINDS.has(kindValue) ? kindValue : void 0;
+	if (kindValue && !kind) issues.push(`${path}.kind is not supported.`);
+	const language = value.language === void 0 ? void 0 : readLanguage(value.language, `${path}.language`, issues);
+	const content = readString(value.content, `${path}.content`, issues);
+	if (language !== void 0 && kind !== "code") issues.push(`${path}.language is supported only for code artifacts.`);
+	if (!id || title === void 0 || !filename || !kind || content === void 0) return void 0;
+	return {
+		id,
+		title,
+		filename,
+		kind,
+		...language === void 0 ? {} : { language },
+		content
+	};
+}
+function validateSnapshot(snapshot, limits) {
+	assertAcyclicPlainJSON(snapshot);
+	if (!isPlainObject(snapshot)) throw new Error("Snapshot must be a plain object.");
+	const issues = [];
+	inspectObject(snapshot, SNAPSHOT_KEYS, "$", issues);
+	if (snapshot.version !== 1) issues.push("$.version must equal 1.");
+	if (!Array.isArray(snapshot.records)) issues.push("$.records must be an array.");
+	if (!Array.isArray(snapshot.receipts)) issues.push("$.receipts must be an array.");
+	const records = new Map();
+	let total = 0;
+	if (Array.isArray(snapshot.records)) {
+		if (snapshot.records.length > limits.maxArtifacts) issues.push("Snapshot artifact count limit exceeded.");
+		snapshot.records.forEach((value, index) => {
+			const record = validateRecord(value, `$.records[${index}]`, issues);
+			if (!record) return;
+			if (records.has(record.id)) issues.push(`Duplicate artifact ID at $.records[${index}].`);
+			const bytes = utf8Bytes(record.content);
+			if (bytes > limits.maxArtifactBytes) issues.push(`Artifact size limit exceeded at $.records[${index}].`);
+			total += bytes;
+			records.set(record.id, record);
+		});
+	}
+	if (total > limits.maxTotalBytes) issues.push("Snapshot total size limit exceeded.");
+	const receipts = new Map();
+	if (Array.isArray(snapshot.receipts)) snapshot.receipts.forEach((value, index) => {
+		const path = `$.receipts[${index}]`;
+		if (!isPlainObject(value)) {
+			issues.push(`${path} must be a plain object.`);
+			return;
+		}
+		inspectObject(value, RECEIPT_SNAPSHOT_KEYS, path, issues);
+		const operationId = readSafeString(value.operationId, `${path}.operationId`, issues, SAFE_OPERATION_ID, 128);
+		const canonical = readString(value.canonical, `${path}.canonical`, issues);
+		const receipt = validateReceipt(value.receipt, `${path}.receipt`, issues);
+		if (!operationId || canonical === void 0 || !receipt) return;
+		if (receipt.operationId !== operationId) issues.push(`${path} operation IDs must match.`);
+		if (receipts.has(operationId)) issues.push(`${path}.operationId must be unique.`);
+		let parsedCanonical;
+		try {
+			const parsed = JSON.parse(canonical);
+			parsedCanonical = receipt.command === "create" ? validateCreateValue(parsed) : validateUpdateValue(parsed);
+		} catch {
+			parsedCanonical = {
+				valid: false,
+				issues: ["Invalid canonical command."]
+			};
+		}
+		if (!parsedCanonical.valid || (receipt.command === "create" ? canonicalCreate(parsedCanonical.data) : canonicalUpdate(parsedCanonical.data)) !== canonical) issues.push(`${path}.canonical is invalid.`);
+		else if (!receiptMatchesCommand(receipt, parsedCanonical.data)) issues.push(`${path}.receipt does not match its canonical command.`);
+		receipts.set(operationId, {
+			canonical,
+			receipt
+		});
+	});
+	if (issues.length) throw new Error(issues.join(" "));
+	return {
+		records,
+		receipts
+	};
+}
+function validateReceipt(value, path, issues) {
+	if (!isPlainObject(value)) {
+		issues.push(`${path} must be a plain object.`);
+		return void 0;
+	}
+	inspectObject(value, RECEIPT_KEYS, path, issues);
+	const operationId = readSafeString(value.operationId, `${path}.operationId`, issues, SAFE_OPERATION_ID, 128);
+	const command = value.command === "create" || value.command === "update" ? value.command : void 0;
+	if (!command) issues.push(`${path}.command is invalid.`);
+	const record = validateRecord(value.record, `${path}.record`, issues);
+	if (!operationId || !command || !record) return void 0;
+	return freezeReceipt({
+		operationId,
+		command,
+		record
+	});
+}
+function canonicalCreate(command) {
+	return JSON.stringify({
+		version: 1,
+		operationId: command.operationId,
+		artifact: {
+			id: command.artifact.id,
+			title: command.artifact.title,
+			filename: command.artifact.filename,
+			kind: command.artifact.kind,
+			...command.artifact.language === void 0 ? {} : { language: command.artifact.language },
+			content: command.artifact.content
+		}
+	});
+}
+function canonicalUpdate(command) {
+	return JSON.stringify({
+		version: 1,
+		operationId: command.operationId,
+		id: command.id,
+		baseRevision: command.baseRevision,
+		content: command.content,
+		...command.title === void 0 ? {} : { title: command.title },
+		...command.filename === void 0 ? {} : { filename: command.filename },
+		...command.language === void 0 ? {} : { language: command.language }
+	});
+}
+function receiptMatchesCommand(receipt, command) {
+	if (receipt.operationId !== command.operationId) return false;
+	if (receipt.command === "create") {
+		if (!("artifact" in command) || receipt.record.revision !== 0) return false;
+		return sameArtifact(receipt.record, command.artifact);
+	}
+	if (!("id" in command)) return false;
+	if (receipt.record.id !== command.id || receipt.record.revision !== command.baseRevision + 1 || receipt.record.content !== command.content) return false;
+	if (command.title !== void 0 && receipt.record.title !== command.title) return false;
+	if (command.filename !== void 0 && receipt.record.filename !== command.filename) return false;
+	return command.language === void 0 || receipt.record.language === command.language;
+}
+function sameArtifact(record, artifact$1) {
+	return record.id === artifact$1.id && record.title === artifact$1.title && record.filename === artifact$1.filename && record.kind === artifact$1.kind && record.language === artifact$1.language && record.content === artifact$1.content;
+}
+function statusOutput(success) {
+	return {
+		kind: "element",
+		tag: "div",
+		props: {
+			"data-aigui-artifact-command": success ? "accepted" : "rejected",
+			role: "status"
+		},
+		children: [{
+			kind: "element",
+			tag: "span",
+			children: [{
+				kind: "html",
+				html: success ? "Artifact command accepted." : "Artifact command could not be applied."
+			}]
+		}]
+	};
+}
+function previewRecord(record) {
+	const container = element("div", {
+		"data-artifact-preview": "",
+		"data-artifact-kind": record.kind
+	});
+	if (record.kind === "markdown") container.append(renderMarkdown(record.content));
+	else if (record.kind === "json") container.append(renderJson(record.content));
+	else {
+		const pre = element("pre");
+		const code = element("code", record.kind === "code" && record.language ? { "data-language": record.language } : void 0);
+		code.textContent = record.content;
+		pre.append(code);
+		container.append(pre);
+	}
+	return container;
+}
+function sourceView(content) {
+	const pre = element("pre", { "data-artifact-source": "" });
+	const code = element("code");
+	code.textContent = content;
+	pre.append(code);
+	return pre;
+}
+function renderJson(content) {
+	const pre = element("pre");
+	const code = element("code");
+	try {
+		code.textContent = JSON.stringify(JSON.parse(content), null, 2);
+	} catch {
+		code.textContent = content;
+	}
+	pre.append(code);
+	return pre;
+}
+function renderMarkdown(content) {
+	const root = element("div", { "data-artifact-markdown": "" });
+	const lines = content.split(/\r\n|\r|\n/);
+	let paragraph = [];
+	let code;
+	const flushParagraph = () => {
+		if (!paragraph.length) return;
+		const p = element("p");
+		appendInlineMarkdown(p, paragraph.join(" "));
+		root.append(p);
+		paragraph = [];
+	};
+	const flushCode = () => {
+		if (!code) return;
+		const pre = element("pre");
+		const child = element("code");
+		child.textContent = code.join("\n");
+		pre.append(child);
+		root.append(pre);
+		code = void 0;
+	};
+	for (const line of lines) {
+		if (line.startsWith("```")) {
+			if (code) flushCode();
+			else {
+				flushParagraph();
+				code = [];
+			}
+			continue;
+		}
+		if (code) {
+			code.push(line);
+			continue;
+		}
+		const heading = /^(#{1,6})\s+(.*)$/.exec(line);
+		if (heading) {
+			flushParagraph();
+			const h = element(`h${heading[1].length}`);
+			appendInlineMarkdown(h, heading[2]);
+			root.append(h);
+			continue;
+		}
+		if (/^\s*[-*+]\s+/.test(line)) {
+			flushParagraph();
+			const ul = root.lastElementChild?.tagName === "UL" ? root.lastElementChild : element("ul");
+			if (!ul.parentNode) root.append(ul);
+			const li = element("li");
+			appendInlineMarkdown(li, line.replace(/^\s*[-*+]\s+/, ""));
+			ul.append(li);
+			continue;
+		}
+		if (line.trim() === "") {
+			flushParagraph();
+			continue;
+		}
+		paragraph.push(line);
+	}
+	flushParagraph();
+	flushCode();
+	return root;
+}
+function appendInlineMarkdown(parent, text) {
+	const pattern = /\[([^\]\n]{1,512})\]\(([^)\s]{1,2048})\)/g;
+	let offset = 0;
+	for (const match of text.matchAll(pattern)) {
+		const index = match.index ?? 0;
+		parent.append(document.createTextNode(text.slice(offset, index)));
+		const href = safeHttpsUrl(match[2]);
+		if (href) {
+			const link = element("a", {
+				href,
+				rel: "noreferrer noopener",
+				target: "_blank"
+			}, match[1]);
+			parent.append(link);
+		} else parent.append(document.createTextNode(match[0]));
+		offset = index + match[0].length;
+	}
+	parent.append(document.createTextNode(text.slice(offset)));
+}
+function safeHttpsUrl(value) {
+	try {
+		const url = new URL(value);
+		return url.protocol === "https:" && !url.username && !url.password ? url.href : void 0;
+	} catch {
+		return void 0;
+	}
+}
+function tabButton(tab, active, activate) {
+	const button = element("button", {
+		type: "button",
+		role: "tab",
+		"data-artifact-tab": tab,
+		"aria-selected": String(tab === active),
+		tabindex: tab === active ? "0" : "-1"
+	}, tab === "preview" ? "Preview" : "Source");
+	button.addEventListener("click", activate);
+	return button;
+}
+async function copyText(content) {
+	try {
+		await navigator.clipboard?.writeText(content);
+	} catch {}
+}
+function downloadRecord(record, urls, timers) {
+	const blob = new Blob([record.content], { type: artifactMime(record) });
+	const url = URL.createObjectURL(blob);
+	urls.add(url);
+	const link = document.createElement("a");
+	link.href = url;
+	link.download = record.filename;
+	link.rel = "noopener";
+	link.click();
+	const timer = setTimeout(() => {
+		timers.delete(timer);
+		urls.delete(url);
+		URL.revokeObjectURL(url);
+	}, 0);
+	timers.add(timer);
+}
+function artifactMime(record) {
+	if (record.kind === "markdown") return "text/markdown;charset=utf-8";
+	if (record.kind === "json") return "application/json;charset=utf-8";
+	if (record.kind === "code") return "text/plain;charset=utf-8";
+	return "text/plain;charset=utf-8";
+}
+function element(tag, attrs, text) {
+	const node = document.createElement(tag);
+	for (const [key, value] of Object.entries(attrs ?? {})) node.setAttribute(key, value);
+	if (text !== void 0) node.textContent = text;
+	return node;
+}
+function inspectObject(value, allowed, path, issues) {
+	for (const key of Object.keys(value)) if (DANGEROUS_KEYS.has(key)) issues.push(`${path} contains a dangerous key.`);
+	else if (!allowed.has(key)) issues.push(`${path}.${key} is not allowed.`);
+}
+function readSafeString(value, path, issues, pattern, max) {
+	const string = readBoundedString(value, path, issues, max);
+	if (string !== void 0 && !pattern.test(string)) issues.push(`${path} is not safe.`);
+	return string;
+}
+function readBoundedString(value, path, issues, max) {
+	const string = readString(value, path, issues);
+	if (string !== void 0 && (string.length === 0 || string.length > max)) issues.push(`${path} must contain 1 to ${max} characters.`);
+	return string;
+}
+function readString(value, path, issues) {
+	if (typeof value !== "string") {
+		issues.push(`${path} must be a string.`);
+		return void 0;
+	}
+	return value;
+}
+function readFilename(value, path, issues) {
+	const filename = readBoundedString(value, path, issues, MAX_FILENAME_LENGTH);
+	if (filename !== void 0 && (filename === "." || filename === ".." || /[\\/\u0000-\u001f\u007f]/.test(filename))) issues.push(`${path} is not a safe filename.`);
+	return filename;
+}
+function readLanguage(value, path, issues) {
+	const language = readBoundedString(value, path, issues, MAX_LANGUAGE_LENGTH);
+	if (language !== void 0 && !/^[A-Za-z0-9][A-Za-z0-9_+.-]{0,63}$/.test(language)) issues.push(`${path} is not a safe language name.`);
+	return language;
+}
+function readRevision(value, path, issues) {
+	if (!Number.isSafeInteger(value) || value < 0) {
+		issues.push(`${path} must be a non-negative safe integer.`);
+		return void 0;
+	}
+	return value;
+}
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+function assertPlainOptions(options) {
+	if (!isPlainObject(options)) throw new TypeError("ArtifactStore options must be a plain object.");
+	rejectDangerousObjectKeys(options, "ArtifactStore options");
+	for (const key of Object.keys(options)) if (key !== "maxArtifacts" && key !== "maxArtifactBytes" && key !== "maxTotalBytes") throw new TypeError(`Unknown ArtifactStore option: ${key}`);
+}
+function rejectDangerousObjectKeys(value, label) {
+	for (const key of Object.keys(value)) if (DANGEROUS_KEYS.has(key)) throw new TypeError(`${label} contains a dangerous key.`);
+}
+function readPositiveLimit(value, fallback, name, maximum) {
+	if (value === void 0) return fallback;
+	if (!Number.isSafeInteger(value) || value <= 0 || value > maximum) throw new TypeError(`${name} must be a positive safe integer no greater than ${maximum}.`);
+	return value;
+}
+function assertAcyclicPlainJSON(value, seen = new Set()) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new Error("Snapshot contains a non-finite number.");
+		return;
+	}
+	if (typeof value !== "object") throw new Error("Snapshot contains an unsupported value.");
+	if (seen.has(value)) throw new Error("Snapshot contains a cycle.");
+	seen.add(value);
+	if (Array.isArray(value)) for (const item of value) assertAcyclicPlainJSON(item, seen);
+	else {
+		if (!isPlainObject(value)) throw new Error("Snapshot contains a class instance.");
+		rejectDangerousObjectKeys(value, "Snapshot");
+		for (const item of Object.values(value)) assertAcyclicPlainJSON(item, seen);
+	}
+	seen.delete(value);
+}
+function utf8Bytes(value) {
+	return new TextEncoder().encode(value).byteLength;
+}
+function freezeRecord(record) {
+	return Object.freeze(record);
+}
+function freezeReceipt(receipt) {
+	return Object.freeze(receipt);
+}
+function deepFreeze(value) {
+	if (value && typeof value === "object") {
+		for (const child of Object.values(value)) deepFreeze(child);
+		Object.freeze(value);
+	}
+	return value;
+}
+function safeCall(listener, value) {
+	try {
+		listener(value);
+	} catch {}
+}
+
+//#endregion
+export { ArtifactConflictError, ArtifactError, ArtifactLimitError, ArtifactNotFoundError, ArtifactOperationConflictError, ArtifactSnapshotError, ArtifactStore, ArtifactValidationError, artifact, artifactCss, artifactPromptSpec, mountArtifactWorkspace, parseArtifactCreate, parseArtifactUpdate, serializeArtifactCreate, serializeArtifactUpdate };