@tooldeck/plugin-package 0.1.0

package/dist/index.js

@@ -0,0 +1,710 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, readdir, realpath, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { strFromU8, strToU8, unzipSync, zipSync } from "fflate";
+import { manifestV1Schema } from "@tooldeck/protocol";
+import Ajv from "ajv";
+//#region src/constants.ts
+var TOOLDECK_PACKAGE_EXTENSION = ".tdplugin";
+var TOOLDECK_PACKAGE_MANIFEST_PATH = "tooldeck-package.json";
+var TOOLDECK_PLUGIN_MANIFEST_PATH = "manifest.json";
+var TOOLDECK_PACKAGE_FORMAT_VERSION = "1.0";
+var DEFAULT_PACKAGE_LIMITS = {
+	maxPackageSizeBytes: 50 * 1024 * 1024,
+	maxUncompressedSizeBytes: 50 * 1024 * 1024,
+	maxRegularFileCount: 1e3
+};
+var DEFAULT_PACKAGE_INCLUDE_DIRS = ["dist", "assets"];
+//#endregion
+//#region src/errors.ts
+var TooldeckPackageError = class extends Error {
+	code;
+	context;
+	constructor(code, message, context = {}) {
+		super(message);
+		this.name = "TooldeckPackageError";
+		this.code = code;
+		this.context = context;
+	}
+};
+function packageError(code, message, context = {}) {
+	return new TooldeckPackageError(code, message, context);
+}
+//#endregion
+//#region src/paths.ts
+function normalizePackagePath(input) {
+	const collapsed = input.replace(/\\/g, "/").trim().replace(/^\.\/+/, "").replace(/\/+/g, "/");
+	return collapsed.endsWith("/") ? collapsed.slice(0, -1) : collapsed;
+}
+function assertSafePackagePath(input, fieldPath) {
+	const normalized = normalizePackagePath(input);
+	if (normalized.length === 0) throw packageError("INVALID_PACKAGE_PATH", "Package path must not be empty.", {
+		entryPath: input,
+		fieldPath,
+		reason: "empty path"
+	});
+	if (normalized.startsWith("/") || normalized.startsWith("//")) throw packageError("INVALID_PACKAGE_PATH", "Package path must be relative.", {
+		entryPath: input,
+		fieldPath,
+		reason: "absolute path"
+	});
+	if (/^[A-Za-z]:\//.test(normalized)) throw packageError("INVALID_PACKAGE_PATH", "Package path must not include a drive prefix.", {
+		entryPath: input,
+		fieldPath,
+		reason: "drive-prefixed path"
+	});
+	if (normalized.split("/").some((segment) => segment === "." || segment === ".." || segment.length === 0)) throw packageError("INVALID_PACKAGE_PATH", "Package path must not contain traversal segments.", {
+		entryPath: input,
+		fieldPath,
+		reason: "path traversal"
+	});
+	if (isNodeModulesPath(normalized)) throw packageError("NODE_MODULES_NOT_ALLOWED", "Package must not contain node_modules.", {
+		entryPath: input,
+		fieldPath,
+		reason: "node_modules is not allowed"
+	});
+	return normalized;
+}
+function isNodeModulesPath(input) {
+	return normalizePackagePath(input).split("/").some((segment) => segment === "node_modules");
+}
+function dedupeAndSortPackagePaths(paths) {
+	return Array.from(new Set(Array.from(paths, (path) => assertSafePackagePath(path)))).sort(comparePackagePaths);
+}
+function comparePackagePaths(a, b) {
+	return a.localeCompare(b, "en", { sensitivity: "variant" });
+}
+function packagePathStartsWith(path, directory) {
+	const normalizedPath = normalizePackagePath(path);
+	const normalizedDirectory = normalizePackagePath(directory);
+	return normalizedPath === normalizedDirectory || normalizedPath.startsWith(`${normalizedDirectory}/`);
+}
+//#endregion
+//#region src/utils.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/package-manifest.ts
+function createTooldeckPackageManifest(options) {
+	const files = dedupeAndSortPackagePaths([
+		TOOLDECK_PLUGIN_MANIFEST_PATH,
+		TOOLDECK_PACKAGE_MANIFEST_PATH,
+		...options.files
+	]);
+	return {
+		formatVersion: "1.0",
+		manifestPath: TOOLDECK_PLUGIN_MANIFEST_PATH,
+		createdAt: (options.createdAt ?? /* @__PURE__ */ new Date()).toISOString(),
+		files
+	};
+}
+function validateTooldeckPackageManifest(value) {
+	if (!isRecord(value)) throw packageError("INVALID_PACKAGE_METADATA", "tooldeck-package.json must be an object.", { manifestPath: TOOLDECK_PACKAGE_MANIFEST_PATH });
+	if (value.formatVersion !== "1.0") throw packageError("INVALID_PACKAGE_MANIFEST", "Unsupported Tooldeck package format version.", {
+		manifestPath: TOOLDECK_PACKAGE_MANIFEST_PATH,
+		fieldPath: "formatVersion",
+		reason: `expected 1.0`
+	});
+	if (value.manifestPath !== "manifest.json") throw packageError("INVALID_PACKAGE_MANIFEST", "Package manifestPath must be manifest.json.", {
+		manifestPath: TOOLDECK_PACKAGE_MANIFEST_PATH,
+		fieldPath: "manifestPath",
+		reason: "1.3 only supports a root manifest.json"
+	});
+	if (typeof value.createdAt !== "string" || Number.isNaN(Date.parse(value.createdAt))) throw packageError("INVALID_PACKAGE_MANIFEST", "Package createdAt must be an ISO date string.", {
+		manifestPath: TOOLDECK_PACKAGE_MANIFEST_PATH,
+		fieldPath: "createdAt"
+	});
+	if (!Array.isArray(value.files) || !value.files.every((file) => typeof file === "string")) throw packageError("INVALID_PACKAGE_MANIFEST", "Package files must be a string array.", {
+		manifestPath: TOOLDECK_PACKAGE_MANIFEST_PATH,
+		fieldPath: "files"
+	});
+	const normalizedFiles = value.files.map((file) => assertSafePackagePath(file));
+	const files = dedupeAndSortPackagePaths(normalizedFiles);
+	if (files.length !== value.files.length) throw packageError("DUPLICATE_FILE_LIST_ENTRY", "Package files must not contain duplicates.", {
+		manifestPath: TOOLDECK_PACKAGE_MANIFEST_PATH,
+		fieldPath: "files"
+	});
+	for (let index = 0; index < files.length; index += 1) if (normalizedFiles[index] !== files[index]) throw packageError("UNSORTED_FILE_LIST", "Package files must be sorted.", {
+		manifestPath: TOOLDECK_PACKAGE_MANIFEST_PATH,
+		fieldPath: "files",
+		reason: `expected ${files[index]} at index ${index}`
+	});
+	for (const requiredPath of [TOOLDECK_PLUGIN_MANIFEST_PATH, TOOLDECK_PACKAGE_MANIFEST_PATH]) {
+		assertSafePackagePath(requiredPath);
+		if (!files.includes(requiredPath)) throw packageError("INVALID_PACKAGE_MANIFEST", "Package files is missing a required file.", {
+			manifestPath: TOOLDECK_PACKAGE_MANIFEST_PATH,
+			fieldPath: "files",
+			entryPath: requiredPath
+		});
+	}
+	return {
+		formatVersion: "1.0",
+		manifestPath: TOOLDECK_PLUGIN_MANIFEST_PATH,
+		createdAt: value.createdAt,
+		files
+	};
+}
+function assertPackageFileListMatches(options) {
+	const declaredFiles = dedupeAndSortPackagePaths(options.declaredFiles);
+	const actualFiles = dedupeAndSortPackagePaths(options.actualFiles);
+	if (declaredFiles.length !== actualFiles.length) throw packageError("FILE_LIST_MISMATCH", "Package file list does not match ZIP entries.", {
+		manifestPath: TOOLDECK_PACKAGE_MANIFEST_PATH,
+		fieldPath: "files",
+		reason: "file count mismatch"
+	});
+	for (let index = 0; index < declaredFiles.length; index += 1) if (declaredFiles[index] !== actualFiles[index]) throw packageError("FILE_LIST_MISMATCH", "Package file list does not match ZIP entries.", {
+		manifestPath: TOOLDECK_PACKAGE_MANIFEST_PATH,
+		fieldPath: "files",
+		reason: `expected ${declaredFiles[index]}, got ${actualFiles[index]}`
+	});
+	return declaredFiles;
+}
+//#endregion
+//#region src/digest.ts
+async function computePackageDigest(packagePath) {
+	const data = await readFile(packagePath);
+	return createHash("sha256").update(data).digest("hex");
+}
+//#endregion
+//#region src/zip-central-directory.ts
+var EOCD_SIGNATURE = 101010256;
+var ZIP64_EOCD_LOCATOR_SIGNATURE = 117853008;
+var CENTRAL_DIRECTORY_SIGNATURE = 33639248;
+var EOCD_FIXED_SIZE = 22;
+var CENTRAL_DIRECTORY_HEADER_SIZE = 46;
+var ZIP64_SENTINEL_16 = 65535;
+var ZIP64_SENTINEL_32 = 4294967295;
+function parseCentralDirectory(data) {
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const eocdOffset = findEndOfCentralDirectory(view);
+	if (eocdOffset < 0) throw packageError("INVALID_ZIP", "ZIP end of central directory was not found.");
+	if (hasZip64Locator(view, eocdOffset)) throw packageError("UNSUPPORTED_ZIP64", "ZIP64 packages are not supported.");
+	const diskNumber = view.getUint16(eocdOffset + 4, true);
+	const centralDirectoryDisk = view.getUint16(eocdOffset + 6, true);
+	const entriesOnDisk = view.getUint16(eocdOffset + 8, true);
+	const entryCount = view.getUint16(eocdOffset + 10, true);
+	const centralDirectorySize = view.getUint32(eocdOffset + 12, true);
+	const centralDirectoryOffset = view.getUint32(eocdOffset + 16, true);
+	if (diskNumber !== 0 || centralDirectoryDisk !== 0 || entriesOnDisk !== entryCount) throw packageError("UNSUPPORTED_ZIP_ENTRY", "Multi-disk ZIP packages are not supported.");
+	if (entryCount === ZIP64_SENTINEL_16 || centralDirectorySize === ZIP64_SENTINEL_32 || centralDirectoryOffset === ZIP64_SENTINEL_32) throw packageError("UNSUPPORTED_ZIP64", "ZIP64 packages are not supported.");
+	const endOffset = centralDirectoryOffset + centralDirectorySize;
+	if (endOffset !== eocdOffset || centralDirectoryOffset > endOffset) throw packageError("INVALID_ZIP", "ZIP central directory range is invalid.");
+	const entries = [];
+	const entryPaths = /* @__PURE__ */ new Set();
+	let offset = centralDirectoryOffset;
+	while (offset < endOffset) {
+		assertAvailableRange(view, offset, CENTRAL_DIRECTORY_HEADER_SIZE, "ZIP central directory entry");
+		if (view.getUint32(offset, true) !== CENTRAL_DIRECTORY_SIGNATURE) throw packageError("INVALID_ZIP", "Invalid ZIP central directory entry.");
+		const generalPurposeFlag = view.getUint16(offset + 8, true);
+		const compression = view.getUint16(offset + 10, true);
+		const compressedSize = view.getUint32(offset + 20, true);
+		const uncompressedSize = view.getUint32(offset + 24, true);
+		const fileNameLength = view.getUint16(offset + 28, true);
+		const extraFieldLength = view.getUint16(offset + 30, true);
+		const fileCommentLength = view.getUint16(offset + 32, true);
+		const externalAttributes = view.getUint32(offset + 38, true);
+		const entrySize = CENTRAL_DIRECTORY_HEADER_SIZE + fileNameLength + extraFieldLength + fileCommentLength;
+		assertAvailableRange(view, offset, entrySize, "ZIP central directory entry data");
+		if (offset + entrySize > endOffset) throw packageError("INVALID_ZIP", "ZIP central directory entry exceeds its declared range.");
+		const fileNameOffset = offset + CENTRAL_DIRECTORY_HEADER_SIZE;
+		const rawEntryPath = strFromU8(data.subarray(fileNameOffset, fileNameOffset + fileNameLength));
+		const entryPath = normalizePackagePath(rawEntryPath);
+		if (entryPaths.has(entryPath)) throw packageError("DUPLICATE_FILE_LIST_ENTRY", "ZIP entries must not contain duplicate paths.", { entryPath });
+		entryPaths.add(entryPath);
+		if (compressedSize === ZIP64_SENTINEL_32 || uncompressedSize === ZIP64_SENTINEL_32) throw packageError("UNSUPPORTED_ZIP64", "ZIP64 packages are not supported.", { entryPath });
+		entries.push({
+			path: entryPath,
+			kind: classifyEntry(rawEntryPath, externalAttributes),
+			compression,
+			encrypted: (generalPurposeFlag & 1) === 1,
+			compressedSizeBytes: compressedSize,
+			uncompressedSizeBytes: uncompressedSize
+		});
+		offset += entrySize;
+	}
+	if (offset !== endOffset || entries.length !== entryCount) throw packageError("INVALID_ZIP", "ZIP central directory entry count does not match EOCD.");
+	return entries;
+}
+function findEndOfCentralDirectory(view) {
+	const minOffset = Math.max(0, view.byteLength - 65557);
+	for (let offset = view.byteLength - EOCD_FIXED_SIZE; offset >= minOffset; offset -= 1) {
+		if (view.getUint32(offset, true) !== EOCD_SIGNATURE) continue;
+		const commentLength = view.getUint16(offset + 20, true);
+		if (offset + EOCD_FIXED_SIZE + commentLength === view.byteLength) return offset;
+	}
+	return -1;
+}
+function hasZip64Locator(view, eocdOffset) {
+	const locatorOffset = eocdOffset - 20;
+	return locatorOffset >= 0 && view.getUint32(locatorOffset, true) === ZIP64_EOCD_LOCATOR_SIGNATURE;
+}
+function classifyEntry(rawEntryPath, externalAttributes) {
+	if (rawEntryPath.replaceAll("\\", "/").endsWith("/")) return "directory";
+	const unixType = externalAttributes >>> 16 & 61440;
+	if (unixType === 16384) return "directory";
+	if (unixType === 40960) return "symlink";
+	if (unixType !== 0 && unixType !== 32768) return "special";
+	if ((externalAttributes & 16) === 16) return "directory";
+	return "file";
+}
+function assertAvailableRange(view, offset, length, description) {
+	if (offset < 0 || length < 0 || offset > view.byteLength - length) throw packageError("INVALID_ZIP", `${description} is truncated.`);
+}
+//#endregion
+//#region src/zip-entry-policy.ts
+function validateZipEntries(entries, limits) {
+	let regularFileCount = 0;
+	let uncompressedSizeBytes = 0;
+	for (const entry of entries) {
+		assertSafePackagePath(entry.path);
+		if (entry.encrypted) throw packageError("UNSUPPORTED_ENCRYPTED_ZIP", "Encrypted ZIP entries are not supported.", { entryPath: entry.path });
+		if (entry.compression !== 0 && entry.compression !== 8) throw packageError("UNSUPPORTED_ZIP_ENTRY", "Unsupported ZIP compression method.", {
+			entryPath: entry.path,
+			reason: `compression method ${entry.compression}`
+		});
+		if (entry.kind !== "file" && entry.kind !== "directory") throw packageError("UNSUPPORTED_ZIP_ENTRY", "Only regular files are supported in packages.", {
+			entryPath: entry.path,
+			reason: entry.kind
+		});
+		if (entry.kind === "file") {
+			regularFileCount += 1;
+			uncompressedSizeBytes += entry.uncompressedSizeBytes ?? 0;
+		}
+	}
+	if (regularFileCount > limits.maxRegularFileCount) throw packageError("TOO_MANY_FILES", "Tooldeck package contains too many files.", { reason: `${regularFileCount} > ${limits.maxRegularFileCount}` });
+	if (uncompressedSizeBytes > limits.maxUncompressedSizeBytes) throw packageError("UNCOMPRESSED_SIZE_TOO_LARGE", "Tooldeck package is too large after unzip.", { reason: `${uncompressedSizeBytes} > ${limits.maxUncompressedSizeBytes}` });
+}
+//#endregion
+//#region src/fflate-zip-adapter.ts
+var FflateZipAdapter = class {
+	async readArchive(archivePath, limits) {
+		await assertPackageFileSize(archivePath, limits);
+		const data = await readPackageFile(archivePath);
+		const entries = parseCentralDirectory(data);
+		validateZipEntries(entries, limits);
+		return {
+			entries,
+			readFile: async (entryPath) => {
+				const normalizedPath = assertSafePackagePath(entryPath);
+				const file = unzipSingleFile(data, normalizedPath);
+				if (!file) throw packageError("FILE_LIST_MISMATCH", "ZIP entry does not exist.", {
+					packagePath: archivePath,
+					entryPath: normalizedPath
+				});
+				return file;
+			}
+		};
+	}
+	async writeArchive(archivePath, entries) {
+		const zippable = {};
+		for (const entry of entries) {
+			const normalizedPath = assertSafePackagePath(entry.path);
+			zippable[normalizedPath] = [entry.data, { level: 6 }];
+		}
+		let data;
+		try {
+			data = zipSync(zippable);
+		} catch (error) {
+			throw packageError("PACKAGE_WRITE_FAILED", "Tooldeck package could not be created.", {
+				packagePath: archivePath,
+				reason: formatUnknownError(error)
+			});
+		}
+		await writePackageFile(archivePath, data);
+	}
+	async extractArchive(options) {
+		await assertPackageFileSize(options.archivePath, options.limits);
+		const data = await readPackageFile(options.archivePath);
+		const entries = parseCentralDirectory(data);
+		validateZipEntries(entries, options.limits);
+		const files = unzipArchive(data, options.archivePath);
+		const destinationDir = path.resolve(options.destinationDir);
+		await createExtractionDirectory(destinationDir, options.archivePath);
+		const resolvedDestinationDir = path.resolve(destinationDir);
+		const destinationRealpath = await getExtractionRealpath(destinationDir, options.archivePath, "<destination>");
+		for (const entry of entries) {
+			if (entry.kind !== "file") continue;
+			const normalizedPath = assertSafePackagePath(entry.path);
+			const fileData = files.get(normalizedPath);
+			if (!fileData) throw packageError("FILE_LIST_MISMATCH", "ZIP entry was not extracted.", {
+				packagePath: options.archivePath,
+				entryPath: normalizedPath
+			});
+			const outputPath = path.resolve(destinationDir, ...normalizedPath.split("/"));
+			assertContainedPath(resolvedDestinationDir, outputPath, normalizedPath);
+			await createExtractionDirectory(path.dirname(outputPath), options.archivePath, normalizedPath);
+			await writeExtractedFile(outputPath, fileData, options.archivePath, normalizedPath);
+			assertContainedPath(destinationRealpath, await getExtractionRealpath(outputPath, options.archivePath, normalizedPath), normalizedPath);
+		}
+	}
+};
+function unzipSingleFile(data, entryPath) {
+	try {
+		const files = unzipSync(data, { filter: (file) => normalizePackagePath(file.name) === entryPath });
+		return Object.entries(files).find(([path]) => normalizePackagePath(path) === entryPath)?.[1];
+	} catch (error) {
+		throw mapFflateError(error);
+	}
+}
+function unzipArchive(data, archivePath) {
+	try {
+		return new Map(Object.entries(unzipSync(data)).map(([entryPath, fileData]) => [normalizePackagePath(entryPath), fileData]));
+	} catch (error) {
+		throw packageError("PACKAGE_EXTRACT_FAILED", "Tooldeck package could not be extracted.", {
+			packagePath: archivePath,
+			reason: formatUnknownError(error)
+		});
+	}
+}
+async function assertPackageFileSize(archivePath, limits) {
+	let archiveStat;
+	try {
+		archiveStat = await stat(archivePath);
+	} catch (error) {
+		throw packageError("PACKAGE_READ_FAILED", "Tooldeck package file could not be inspected.", {
+			packagePath: archivePath,
+			reason: formatUnknownError(error)
+		});
+	}
+	if (archiveStat.size > limits.maxPackageSizeBytes) throw packageError("PACKAGE_TOO_LARGE", "Tooldeck package file is too large.", {
+		packagePath: archivePath,
+		reason: `${archiveStat.size} > ${limits.maxPackageSizeBytes}`
+	});
+}
+async function readPackageFile(archivePath) {
+	try {
+		return await readFile(archivePath);
+	} catch (error) {
+		throw packageError("PACKAGE_READ_FAILED", "Tooldeck package could not be read.", {
+			packagePath: archivePath,
+			reason: formatUnknownError(error)
+		});
+	}
+}
+async function writePackageFile(archivePath, data) {
+	try {
+		await mkdir(path.dirname(archivePath), { recursive: true });
+		await writeFile(archivePath, data);
+	} catch (error) {
+		throw packageError("PACKAGE_WRITE_FAILED", "Tooldeck package could not be written.", {
+			packagePath: archivePath,
+			reason: formatUnknownError(error)
+		});
+	}
+}
+async function createExtractionDirectory(directoryPath, archivePath, entryPath) {
+	try {
+		await mkdir(directoryPath, { recursive: true });
+	} catch (error) {
+		throw packageError("PACKAGE_EXTRACT_FAILED", "Package extraction directory could not be created.", {
+			packagePath: archivePath,
+			entryPath,
+			reason: formatUnknownError(error)
+		});
+	}
+}
+async function writeExtractedFile(outputPath, data, archivePath, entryPath) {
+	try {
+		await writeFile(outputPath, data);
+	} catch (error) {
+		throw packageError("PACKAGE_EXTRACT_FAILED", "Package entry could not be extracted.", {
+			packagePath: archivePath,
+			entryPath,
+			reason: formatUnknownError(error)
+		});
+	}
+}
+async function getExtractionRealpath(targetPath, archivePath, entryPath) {
+	try {
+		return await realpath(targetPath);
+	} catch (error) {
+		throw packageError("PACKAGE_EXTRACT_FAILED", "Extracted path could not be resolved.", {
+			packagePath: archivePath,
+			entryPath,
+			reason: formatUnknownError(error)
+		});
+	}
+}
+function assertContainedPath(root, target, entryPath) {
+	const relative = path.relative(root, target);
+	if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) throw packageError("EXTRACTION_ESCAPE", "Package extraction escaped the destination directory.", {
+		entryPath,
+		reason: target
+	});
+}
+function mapFflateError(error) {
+	if (isFlateError(error) && error.code === 14) throw packageError("UNSUPPORTED_ZIP_ENTRY", "Unsupported ZIP compression method.", { reason: error.message });
+	throw packageError("INVALID_ZIP", "ZIP could not be read.", { reason: formatUnknownError(error) });
+}
+function isFlateError(error) {
+	return error instanceof Error && typeof error.code === "number";
+}
+function formatUnknownError(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function textToBytes(text) {
+	return strToU8(text);
+}
+function bytesToText(data) {
+	return strFromU8(data);
+}
+//#endregion
+//#region src/manifest.ts
+var validatePackageManifestSchema = new Ajv({
+	allErrors: true,
+	strict: false,
+	validateSchema: false
+}).compile(createPackageManifestSchema());
+function parsePluginManifestText(text, manifestPath) {
+	let value;
+	try {
+		value = JSON.parse(text);
+	} catch (error) {
+		throw packageError("INVALID_PLUGIN_MANIFEST", "Plugin manifest is not valid JSON.", {
+			manifestPath,
+			reason: error instanceof Error ? error.message : String(error)
+		});
+	}
+	return validatePluginManifestShape(value, manifestPath);
+}
+function validatePluginManifestShape(value, manifestPath) {
+	if (!isRecord(value)) throw packageError("INVALID_PLUGIN_MANIFEST", "Plugin manifest must be an object.", { manifestPath });
+	if (!validatePackageManifestSchema(value)) throw formatManifestSchemaError(validatePackageManifestSchema.errors ?? [], manifestPath);
+	assertSafePackagePath(value.runtime.entry, "runtime.entry");
+	assertLocalePaths(value, manifestPath);
+	return value;
+}
+function createPackageManifestSchema() {
+	const schema = structuredClone(manifestV1Schema);
+	if (schema.definitions?.runtime?.properties) schema.definitions.runtime.properties.kind = {
+		type: "string",
+		minLength: 1
+	};
+	if (schema.definitions) {
+		schema.definitions.tooldeckInputJsonSchema = {
+			type: "object",
+			description: "A command input JSON Schema object. Full JSON Schema validation is deferred to command input handling."
+		};
+		schema.definitions.tooldeckJsonSchema = {
+			type: "object",
+			description: "A JSON Schema object. Full JSON Schema validation is deferred to command input handling."
+		};
+	}
+	return schema;
+}
+function formatManifestSchemaError(errors, manifestPath) {
+	const error = errors[0];
+	return packageError("INVALID_PLUGIN_MANIFEST", error?.message ? `Plugin manifest schema violation: ${error.message}.` : "Plugin manifest does not match the protocol schema.", {
+		manifestPath,
+		fieldPath: error ? formatAjvFieldPath(error) : void 0,
+		reason: error?.keyword
+	});
+}
+function formatAjvFieldPath(error) {
+	const path = pointerToFieldPath(error.instancePath);
+	if (error.keyword === "required") return joinFieldPath(path, getStringParam(error.params, "missingProperty"));
+	if (error.keyword === "additionalProperties") return joinFieldPath(path, getStringParam(error.params, "additionalProperty"));
+	return path;
+}
+function pointerToFieldPath(pointer) {
+	if (!pointer) return;
+	return pointer.slice(1).split("/").map((segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~")).map((segment, index) => /^\d+$/.test(segment) ? `[${segment}]` : `${index === 0 ? "" : "."}${segment}`).join("");
+}
+function joinFieldPath(base, property) {
+	if (!property) return base;
+	return base ? `${base}.${property}` : property;
+}
+function getStringParam(params, name) {
+	const value = params[name];
+	return typeof value === "string" ? value : void 0;
+}
+function assertLocalePaths(value, manifestPath) {
+	if (value.locales === void 0) return;
+	if (!isRecord(value.locales)) throw packageError("INVALID_PLUGIN_MANIFEST", "Plugin manifest locales must be an object.", {
+		manifestPath,
+		fieldPath: "locales"
+	});
+	for (const [locale, localePath] of Object.entries(value.locales)) {
+		if (typeof localePath !== "string") throw packageError("INVALID_PLUGIN_MANIFEST", "Plugin locale path must be a string.", {
+			manifestPath,
+			fieldPath: `locales.${locale}`
+		});
+		assertSafePackagePath(localePath, `locales.${locale}`);
+	}
+}
+//#endregion
+//#region src/package-reader.ts
+var defaultZipAdapter$1 = new FflateZipAdapter();
+async function readTooldeckPackage(options, zipAdapter = defaultZipAdapter$1) {
+	assertTooldeckPackageExtension(options.packagePath);
+	const limits = resolvePackageLimits(options.limits);
+	const archive = await zipAdapter.readArchive(options.packagePath, limits);
+	const actualFiles = archive.entries.filter((entry) => entry.kind === "file").map((entry) => assertSafePackagePath(entry.path));
+	if (!actualFiles.includes("tooldeck-package.json")) throw packageError("MISSING_PACKAGE_MANIFEST", "Package is missing tooldeck-package.json.", {
+		packagePath: options.packagePath,
+		entryPath: TOOLDECK_PACKAGE_MANIFEST_PATH
+	});
+	if (!actualFiles.includes("manifest.json")) throw packageError("MISSING_PLUGIN_MANIFEST", "Package is missing root manifest.json.", {
+		packagePath: options.packagePath,
+		entryPath: TOOLDECK_PLUGIN_MANIFEST_PATH
+	});
+	const packageManifest = validateTooldeckPackageManifest(parseJson(bytesToText(await archive.readFile(TOOLDECK_PACKAGE_MANIFEST_PATH)), TOOLDECK_PACKAGE_MANIFEST_PATH));
+	const files = assertPackageFileListMatches({
+		declaredFiles: packageManifest.files,
+		actualFiles
+	});
+	const pluginManifest = parsePluginManifestText(bytesToText(await archive.readFile(TOOLDECK_PLUGIN_MANIFEST_PATH)), TOOLDECK_PLUGIN_MANIFEST_PATH);
+	const runtimeEntry = assertSafePackagePath(pluginManifest.runtime.entry, "runtime.entry");
+	if (!files.includes(runtimeEntry)) throw packageError("MISSING_RUNTIME_ENTRY", "Package is missing manifest runtime entry.", {
+		packagePath: options.packagePath,
+		entryPath: runtimeEntry,
+		fieldPath: "runtime.entry"
+	});
+	const archiveStat = await stat(options.packagePath);
+	const packageDigest = await computePackageDigest(options.packagePath);
+	const uncompressedSizeBytes = archive.entries.filter((entry) => entry.kind === "file").reduce((sum, entry) => sum + (entry.uncompressedSizeBytes ?? 0), 0);
+	return {
+		packagePath: options.packagePath,
+		packageDigest,
+		packageSizeBytes: archiveStat.size,
+		packageManifest,
+		pluginManifest,
+		files,
+		uncompressedSizeBytes
+	};
+}
+async function validateTooldeckPackage(options, zipAdapter) {
+	return readTooldeckPackage(options, zipAdapter);
+}
+async function unpackTooldeckPackage(options, zipAdapter = defaultZipAdapter$1) {
+	const summary = await readTooldeckPackage(options, zipAdapter);
+	await zipAdapter.extractArchive({
+		archivePath: options.packagePath,
+		destinationDir: options.destinationDir,
+		limits: resolvePackageLimits(options.limits)
+	});
+	return summary;
+}
+function resolvePackageLimits(limits) {
+	return {
+		...DEFAULT_PACKAGE_LIMITS,
+		...limits
+	};
+}
+function assertTooldeckPackageExtension(packagePath) {
+	if (path.extname(packagePath) !== ".tdplugin") throw packageError("INVALID_PACKAGE_EXTENSION", "Tooldeck packages must use .tdplugin.", {
+		packagePath,
+		reason: `got ${path.extname(packagePath) || "<none>"}`
+	});
+}
+function parseJson(text, manifestPath) {
+	try {
+		return JSON.parse(text);
+	} catch (error) {
+		throw packageError("INVALID_PACKAGE_METADATA", "Package manifest is not valid JSON.", {
+			manifestPath,
+			reason: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+//#endregion
+//#region src/pack.ts
+var defaultZipAdapter = new FflateZipAdapter();
+async function packTooldeckPlugin(options, zipAdapter = defaultZipAdapter) {
+	const manifestFile = path.resolve(options.manifestPath ?? path.join(options.projectDir ?? process.cwd(), "manifest.json"));
+	const projectDir = path.resolve(options.projectDir ?? path.dirname(manifestFile));
+	const manifestText = await readFile(manifestFile, "utf8");
+	const pluginManifest = parsePluginManifestText(manifestText, TOOLDECK_PLUGIN_MANIFEST_PATH);
+	const outputPath = options.outputPath ?? path.join(projectDir, `${pluginManifest.id}-${pluginManifest.version}.tdplugin`);
+	const files = await collectTooldeckPackageFiles(projectDir, pluginManifest, manifestText);
+	const packageManifest = createTooldeckPackageManifest({
+		createdAt: options.createdAt,
+		files: files.map((file) => file.path)
+	});
+	const entries = [...files, {
+		path: TOOLDECK_PACKAGE_MANIFEST_PATH,
+		data: textToBytes(`${JSON.stringify(packageManifest, null, 2)}\n`)
+	}];
+	await zipAdapter.writeArchive(outputPath, entries);
+	const summary = await readTooldeckPackage({
+		packagePath: outputPath,
+		limits: options.limits
+	}, zipAdapter);
+	return {
+		packagePath: outputPath,
+		packageManifest: summary.packageManifest,
+		pluginManifest,
+		files: summary.files,
+		packageDigest: await computePackageDigest(outputPath),
+		packageSizeBytes: summary.packageSizeBytes
+	};
+}
+async function collectTooldeckPackageFiles(projectDir, pluginManifest, manifestText) {
+	const packagePaths = dedupeAndSortPackagePaths([
+		TOOLDECK_PLUGIN_MANIFEST_PATH,
+		pluginManifest.runtime.entry,
+		...Object.values(pluginManifest.locales ?? {}).filter((localePath) => typeof localePath === "string"),
+		...await collectDefaultDirectoryPackagePaths(projectDir)
+	]);
+	const files = [];
+	for (const packagePath of packagePaths) {
+		if (packagePath === "tooldeck-package.json") continue;
+		if (packagePath === "manifest.json" && manifestText !== void 0) files.push({
+			path: packagePath,
+			data: textToBytes(manifestText.endsWith("\n") ? manifestText : `${manifestText}\n`)
+		});
+		else {
+			const absolutePath = resolveProjectPackagePath(projectDir, packagePath);
+			files.push({
+				path: packagePath,
+				data: await readFile(absolutePath)
+			});
+		}
+	}
+	return files;
+}
+async function collectDefaultDirectoryPackagePaths(projectDir) {
+	const paths = [];
+	for (const directory of DEFAULT_PACKAGE_INCLUDE_DIRS) {
+		const absoluteDirectory = path.join(projectDir, directory);
+		if (!await isDirectory(absoluteDirectory)) continue;
+		paths.push(...await collectRegularFiles(projectDir, absoluteDirectory));
+	}
+	return paths;
+}
+async function collectRegularFiles(projectDir, directory) {
+	const entries = await readdir(directory, { withFileTypes: true });
+	const files = [];
+	for (const entry of entries) {
+		const absolutePath = path.join(directory, entry.name);
+		if (entry.isDirectory()) {
+			files.push(...await collectRegularFiles(projectDir, absolutePath));
+			continue;
+		}
+		if (!entry.isFile()) continue;
+		files.push(toPackagePath(projectDir, absolutePath));
+	}
+	return files;
+}
+function resolveProjectPackagePath(projectDir, packagePath) {
+	const normalizedPath = assertSafePackagePath(packagePath);
+	const absolutePath = path.resolve(projectDir, ...normalizedPath.split("/"));
+	const relative = path.relative(projectDir, absolutePath);
+	if (relative.startsWith("..") || path.isAbsolute(relative)) throw new Error(`Package path escapes the project directory: ${packagePath}`);
+	return absolutePath;
+}
+function toPackagePath(projectDir, absolutePath) {
+	return assertSafePackagePath(path.relative(projectDir, absolutePath).replaceAll(path.sep, "/"));
+}
+async function isDirectory(filePath) {
+	try {
+		return (await stat(filePath)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { DEFAULT_PACKAGE_INCLUDE_DIRS, DEFAULT_PACKAGE_LIMITS, FflateZipAdapter, TOOLDECK_PACKAGE_EXTENSION, TOOLDECK_PACKAGE_FORMAT_VERSION, TOOLDECK_PACKAGE_MANIFEST_PATH, TOOLDECK_PLUGIN_MANIFEST_PATH, TooldeckPackageError, assertPackageFileListMatches, assertSafePackagePath, assertTooldeckPackageExtension, collectTooldeckPackageFiles, comparePackagePaths, computePackageDigest, createTooldeckPackageManifest, dedupeAndSortPackagePaths, isNodeModulesPath, normalizePackagePath, packTooldeckPlugin, packageError, packagePathStartsWith, parsePluginManifestText, readTooldeckPackage, resolvePackageLimits, unpackTooldeckPackage, validatePluginManifestShape, validateTooldeckPackage, validateTooldeckPackageManifest };
+
+//# sourceMappingURL=index.js.map