npm - @seed-app-studio/cli - Versions diffs - 0.1.1-canary.0 - Mend

@seed-app-studio/cli 0.1.1-canary.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/dist/cli.d.mts +1 -0
package/dist/cli.mjs +10 -0
package/dist/commands-TM-KX_MV.mjs +972 -0
package/dist/index.d.mts +139 -0
package/dist/index.mjs +2 -0
package/examples/react-spa-stories/README.md +44 -0
package/examples/react-spa-stories/index.html +12 -0
package/examples/react-spa-stories/package.json +29 -0
package/examples/react-spa-stories/seed-app.json +74 -0
package/examples/react-spa-stories/src/App.tsx +440 -0
package/examples/react-spa-stories/src/main.tsx +10 -0
package/examples/react-spa-stories/src/replayFixture.ts +60 -0
package/examples/react-spa-stories/src/storyData.ts +661 -0
package/examples/react-spa-stories/src/styles.css +342 -0
package/examples/react-spa-stories/tsconfig.json +22 -0
package/examples/react-spa-stories/vite.config.ts +24 -0
package/package.json +49 -0

package/dist/commands-TM-KX_MV.mjs ADDED Viewed

@@ -0,0 +1,972 @@
+import { access, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createHash } from "node:crypto";
+import { validateSeedAppBundleManifest, validateSeedAppManifest } from "@seed-app-studio/protocol";
+//#region src/scaffold.ts
+async function initSeedAppProject(options) {
+	const rootDir = path.resolve(options.rootDir);
+	await assertCanWriteRoot(rootDir, options.force ?? false);
+	const files = createTemplateFiles(options);
+	await mkdir(path.join(rootDir, "src"), { recursive: true });
+	await Promise.all(files.map((file) => writeFile(path.join(rootDir, file.path), file.content, "utf8")));
+	return {
+		rootDir,
+		files: files.map((file) => file.path).toSorted()
+	};
+}
+async function assertCanWriteRoot(rootDir, force) {
+	await mkdir(rootDir, { recursive: true });
+	if ((await readdir(rootDir)).length > 0 && !force) throw new Error("Target directory is not empty. Pass --force to scaffold into it.");
+}
+function createTemplateFiles(options) {
+	const packageName = normalizePackageName(options.appId);
+	const manifest = {
+		schemaVersion: 1,
+		id: options.appId,
+		version: "0.1.0",
+		name: options.appName,
+		kind: "vertical-app",
+		entry: {
+			type: "iframe",
+			url: options.devUrl
+		},
+		contributes: { launcher: { label: options.appName } },
+		runtime: {
+			sdkVersion: "^0.1.0",
+			framework: "react"
+		},
+		capabilities: {
+			agent: ["run"],
+			memory: ["search"],
+			mcp: ["listTools", "callTool"],
+			workspace: ["write"]
+		},
+		grantDefaults: {
+			"agent.run": "enabled",
+			"memory.search": "enabled",
+			"mcp.listTools": "enabled",
+			"mcp.callTool": "ask",
+			"workspace.write": "ask"
+		},
+		userConfigurable: {
+			"mcp.listTools": true,
+			"mcp.callTool": true,
+			"workspace.write": true
+		}
+	};
+	return [
+		{
+			path: "package.json",
+			content: json({
+				name: packageName,
+				version: "0.1.0",
+				private: true,
+				type: "module",
+				scripts: {
+					dev: "vite --host 127.0.0.1",
+					build: "vite build",
+					typecheck: "tsc --noEmit"
+				},
+				dependencies: {
+					"@seed-app-studio/sdk": options.sdkDependency ?? "^0.1.0",
+					"@vitejs/plugin-react": "^5.0.0",
+					vite: "^7.0.0",
+					typescript: "^5.8.3",
+					react: "^19.0.0",
+					"react-dom": "^19.0.0"
+				},
+				devDependencies: {
+					"@types/react": "^19.0.0",
+					"@types/react-dom": "^19.0.0"
+				}
+			})
+		},
+		{
+			path: "index.html",
+			content: "<!doctype html>\n<html lang=\"en\">\n  <head>\n    <meta charset=\"UTF-8\" />\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\" />\n    <title>Seed App</title>\n  </head>\n  <body>\n    <div id=\"root\"></div>\n    <script type=\"module\" src=\"/src/main.tsx\"><\/script>\n  </body>\n</html>\n"
+		},
+		{
+			path: "src/main.tsx",
+			content: "import React from 'react';\nimport { createRoot } from 'react-dom/client';\nimport { App } from './App.js';\nimport './styles.css';\n\ncreateRoot(document.getElementById('root')!).render(\n  <React.StrictMode>\n    <App />\n  </React.StrictMode>\n);\n"
+		},
+		{
+			path: "src/App.tsx",
+			content: createAppSource(options.appId)
+		},
+		{
+			path: "src/styles.css",
+			content: "body {\n  margin: 0;\n  font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, \"Segoe UI\", sans-serif;\n  background: #f7f8fa;\n  color: #1d2129;\n}\n\nmain {\n  box-sizing: border-box;\n  min-height: 100vh;\n  padding: 32px;\n}\n\nbutton {\n  border: 0;\n  border-radius: 6px;\n  background: #165dff;\n  color: white;\n  cursor: pointer;\n  font: inherit;\n  padding: 10px 14px;\n}\n\npre {\n  overflow: auto;\n  border-radius: 6px;\n  background: white;\n  padding: 16px;\n}\n"
+		},
+		{
+			path: "seed-app.json",
+			content: json(manifest)
+		},
+		{
+			path: "tsconfig.json",
+			content: json({
+				compilerOptions: {
+					target: "ES2022",
+					useDefineForClassFields: true,
+					lib: [
+						"DOM",
+						"DOM.Iterable",
+						"ES2022"
+					],
+					allowJs: false,
+					skipLibCheck: true,
+					esModuleInterop: true,
+					allowSyntheticDefaultImports: true,
+					strict: true,
+					forceConsistentCasingInFileNames: true,
+					module: "ESNext",
+					moduleResolution: "Bundler",
+					resolveJsonModule: true,
+					isolatedModules: true,
+					noEmit: true,
+					jsx: "react-jsx"
+				},
+				include: ["src"]
+			})
+		},
+		{
+			path: "vite.config.ts",
+			content: "import { defineConfig } from 'vite';\nimport react from '@vitejs/plugin-react';\n\nexport default defineConfig({\n  plugins: [react()],\n  server: {\n    host: '127.0.0.1',\n    port: 5173,\n  },\n});\n"
+		}
+	];
+}
+function createAppSource(appId) {
+	return `import { useEffect, useState } from 'react';
+import { createSeedAppClient, createWindowSeedAppTransport, installSeedAppConsoleBridge, type SeedAppClient, type SeedAppHandshakeResult } from '@seed-app-studio/sdk';
+export function App() {
+  const [client, setClient] = useState<SeedAppClient>();
+  const [handshake, setHandshake] = useState<SeedAppHandshakeResult | null>(null);
+  const [agentResult, setAgentResult] = useState<unknown>(null);
+  const [error, setError] = useState<string | null>(null);
+  useEffect(() => {
+    const activeClient = createSeedAppClient({
+      transport: createWindowSeedAppTransport({ timeoutMs: 5000 }),
+    });
+    setClient(activeClient);
+    const consoleBridge = installSeedAppConsoleBridge();
+    console.log('[seed-app] initializing SDK handshake');
+    let cancelled = false;
+    activeClient
+      .handshake({ appId: '${appId}', sdkVersion: '0.1.0' })
+      .then((result) => {
+        console.info('[seed-app] handshake completed', result);
+        if (!cancelled) setHandshake(result);
+      })
+      .catch((reason: unknown) => {
+        console.warn('[seed-app] handshake failed', reason);
+        if (!cancelled) setError(reason instanceof Error ? reason.message : String(reason));
+      });
+    return () => {
+      cancelled = true;
+      consoleBridge.uninstall();
+      activeClient.close();
+    };
+  }, []);
+  const runAgent = async () => {
+    if (!client) return;
+    try {
+      console.log('[seed-app] running agent story');
+      const result = await client.agent.run({ input: 'Draft a short account plan.' });
+      console.info('[seed-app] agent story completed', result);
+      setAgentResult(result);
+    } catch (reason) {
+      console.error('[seed-app] agent story failed', reason);
+      setError(reason instanceof Error ? reason.message : String(reason));
+    }
+  };
+  return (
+    <main>
+      <h1>Seed App</h1>
+      <p>Handshake: {handshake ? 'connected' : 'waiting'}</p>
+      <button type="button" onClick={runAgent} disabled={!client}>
+        Run agent
+      </button>
+      {error ? <p role="alert">{error}</p> : null}
+      <pre>{JSON.stringify({ handshake, agentResult }, null, 2)}</pre>
+    </main>
+  );
+}
+`;
+}
+function normalizePackageName(appId) {
+	return appId.replace(/[^a-z0-9.-]/gi, "-").toLowerCase();
+}
+function json(value) {
+	return `${JSON.stringify(value, null, 2)}\n`;
+}
+//#endregion
+//#region src/zipWriter.ts
+const CRC32_TABLE = createCrc32Table();
+async function collectZipSourceFiles(rootDir) {
+	const files = [];
+	await collectFiles(rootDir, rootDir, files);
+	return files.toSorted((left, right) => left.archivePath.localeCompare(right.archivePath));
+}
+async function writeZipArchive(files, outFile) {
+	const chunks = [];
+	const entries = [];
+	let offset = 0;
+	const preparedFiles = await Promise.all(files.map(async (file) => ({
+		archivePath: normalizeArchivePath$1(file.archivePath),
+		data: typeof file.data === "string" ? Buffer.from(file.data) : file.data ?? await readFile(file.absolutePath)
+	})));
+	for (const file of preparedFiles) {
+		const { archivePath, data } = file;
+		const fileName = Buffer.from(archivePath);
+		const crc32 = computeCrc32(data);
+		const localHeader = createLocalFileHeader(fileName, crc32, data.length);
+		chunks.push(localHeader, fileName, data);
+		entries.push({
+			archivePath,
+			crc32,
+			size: data.length,
+			offset
+		});
+		offset += localHeader.length + fileName.length + data.length;
+	}
+	const centralDirectoryOffset = offset;
+	for (const entry of entries) {
+		const fileName = Buffer.from(entry.archivePath);
+		const centralHeader = createCentralDirectoryHeader(fileName, entry);
+		chunks.push(centralHeader, fileName);
+		offset += centralHeader.length + fileName.length;
+	}
+	chunks.push(createEndOfCentralDirectory(entries.length, offset - centralDirectoryOffset, centralDirectoryOffset));
+	await writeFile(outFile, Buffer.concat(chunks));
+}
+async function collectFiles(rootDir, currentDir, files) {
+	const entries = await readdir(currentDir, { withFileTypes: true });
+	await Promise.all(entries.map(async (entry) => {
+		const absolutePath = path.join(currentDir, entry.name);
+		if (entry.isDirectory()) {
+			await collectFiles(rootDir, absolutePath, files);
+			return;
+		}
+		if (entry.isFile()) files.push({
+			absolutePath,
+			archivePath: path.relative(rootDir, absolutePath)
+		});
+	}));
+}
+function createLocalFileHeader(fileName, crc32, size) {
+	const buffer = Buffer.alloc(30);
+	buffer.writeUInt32LE(67324752, 0);
+	buffer.writeUInt16LE(20, 4);
+	buffer.writeUInt16LE(0, 6);
+	buffer.writeUInt16LE(0, 8);
+	writeDosTimestamp(buffer, 10);
+	buffer.writeUInt32LE(crc32, 14);
+	buffer.writeUInt32LE(size, 18);
+	buffer.writeUInt32LE(size, 22);
+	buffer.writeUInt16LE(fileName.length, 26);
+	buffer.writeUInt16LE(0, 28);
+	return buffer;
+}
+function createCentralDirectoryHeader(fileName, entry) {
+	const buffer = Buffer.alloc(46);
+	buffer.writeUInt32LE(33639248, 0);
+	buffer.writeUInt16LE(20, 4);
+	buffer.writeUInt16LE(20, 6);
+	buffer.writeUInt16LE(0, 8);
+	buffer.writeUInt16LE(0, 10);
+	writeDosTimestamp(buffer, 12);
+	buffer.writeUInt32LE(entry.crc32, 16);
+	buffer.writeUInt32LE(entry.size, 20);
+	buffer.writeUInt32LE(entry.size, 24);
+	buffer.writeUInt16LE(fileName.length, 28);
+	buffer.writeUInt16LE(0, 30);
+	buffer.writeUInt16LE(0, 32);
+	buffer.writeUInt16LE(0, 34);
+	buffer.writeUInt16LE(0, 36);
+	buffer.writeUInt32LE(0, 38);
+	buffer.writeUInt32LE(entry.offset, 42);
+	return buffer;
+}
+function createEndOfCentralDirectory(entryCount, directorySize, directoryOffset) {
+	const buffer = Buffer.alloc(22);
+	buffer.writeUInt32LE(101010256, 0);
+	buffer.writeUInt16LE(0, 4);
+	buffer.writeUInt16LE(0, 6);
+	buffer.writeUInt16LE(entryCount, 8);
+	buffer.writeUInt16LE(entryCount, 10);
+	buffer.writeUInt32LE(directorySize, 12);
+	buffer.writeUInt32LE(directoryOffset, 16);
+	buffer.writeUInt16LE(0, 20);
+	return buffer;
+}
+function writeDosTimestamp(buffer, offset) {
+	const date = /* @__PURE__ */ new Date("2026-01-01T00:00:00Z");
+	const timeValue = date.getUTCHours() << 11 | date.getUTCMinutes() << 5 | Math.floor(date.getUTCSeconds() / 2);
+	const dateValue = date.getUTCFullYear() - 1980 << 9 | date.getUTCMonth() + 1 << 5 | date.getUTCDate();
+	buffer.writeUInt16LE(timeValue, offset);
+	buffer.writeUInt16LE(dateValue, offset + 2);
+}
+function computeCrc32(data) {
+	let crc = 4294967295;
+	for (const byte of data) crc = crc >>> 8 ^ CRC32_TABLE[(crc ^ byte) & 255];
+	return (crc ^ 4294967295) >>> 0;
+}
+function createCrc32Table() {
+	return Array.from({ length: 256 }, (_, index) => {
+		let value = index;
+		for (let bit = 0; bit < 8; bit += 1) value = value & 1 ? 3988292384 ^ value >>> 1 : value >>> 1;
+		return value >>> 0;
+	});
+}
+function normalizeArchivePath$1(input) {
+	return input.split(path.sep).join("/");
+}
+//#endregion
+//#region src/exampleArchive.ts
+const EXAMPLE_ID = "react-spa-stories";
+const DEFAULT_OUT_FILE = "seed-react-spa-stories.zip";
+async function writeSeedAppExampleArchive(options = {}) {
+	const exampleDir = await resolveExampleDir();
+	const outFile = path.resolve(options.outFile ?? DEFAULT_OUT_FILE);
+	const files = await prepareExampleFiles(exampleDir, options);
+	await writeZipArchive(files, outFile);
+	return {
+		exampleId: EXAMPLE_ID,
+		outFile,
+		files: files.map((file) => file.archivePath)
+	};
+}
+async function prepareExampleFiles(exampleDir, options) {
+	const files = await collectZipSourceFiles(exampleDir);
+	if (!options.sdkDependency && !options.cliDependency) return files;
+	const packageFile = files.find((file) => file.archivePath === "package.json");
+	if (!packageFile) throw new Error("Seed app example package.json was not found.");
+	const packageJson = JSON.parse(await readFile(packageFile.absolutePath, "utf8"));
+	if (options.sdkDependency) packageJson.dependencies = {
+		...packageJson.dependencies,
+		"@seed-app-studio/sdk": options.sdkDependency
+	};
+	if (options.cliDependency) packageJson.devDependencies = {
+		...packageJson.devDependencies,
+		"@seed-app-studio/cli": options.cliDependency
+	};
+	return files.map((file) => file.archivePath === "package.json" ? {
+		absolutePath: file.absolutePath,
+		archivePath: file.archivePath,
+		data: `${JSON.stringify(packageJson, null, 2)}\n`
+	} : file);
+}
+async function resolveExampleDir() {
+	const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+	const candidates = [path.resolve(moduleDir, "../examples", EXAMPLE_ID), path.resolve(moduleDir, "../../examples", EXAMPLE_ID)];
+	const exampleDir = (await Promise.all(candidates.map(async (candidate) => {
+		try {
+			await access(path.join(candidate, "seed-app.json"));
+			return candidate;
+		} catch {
+			return;
+		}
+	}))).find((candidate) => typeof candidate === "string");
+	if (exampleDir) return exampleDir;
+	throw new Error(`Seed app example "${EXAMPLE_ID}" was not found.`);
+}
+//#endregion
+//#region src/packageArchive.ts
+const DEFAULT_MANIFEST_PATH$1 = "seed-app.json";
+const DEFAULT_BUNDLE_PATH$1 = "seed-app.bundle.json";
+const DEFAULT_REPORT_PATH$1 = "seed-app.integrity-report.json";
+async function writeSeedAppPackageArchive(options) {
+	const rootDir = path.resolve(options.rootDir);
+	const outFile = path.resolve(rootDir, options.zipFile);
+	const manifestFile = toPackageSourceFile(rootDir, options.manifestPath ?? DEFAULT_MANIFEST_PATH$1);
+	const bundleFile = toPackageSourceFile(rootDir, options.bundlePath ?? DEFAULT_BUNDLE_PATH$1);
+	const files = dedupeArchiveFiles([
+		manifestFile,
+		bundleFile,
+		...(await readBundleManifest(bundleFile.absolutePath)).assets.map((asset) => toPackageSourceFile(rootDir, asset.path)),
+		reportSourceFile(rootDir, options.reportPath ?? DEFAULT_REPORT_PATH$1, options.report)
+	]).filter((file) => path.resolve(file.absolutePath) !== outFile);
+	await mkdir(path.dirname(outFile), { recursive: true });
+	await writeZipArchive(files, outFile);
+	return {
+		outFile,
+		files: files.map((file) => file.archivePath)
+	};
+}
+async function inspectSeedAppPackageArchive(options) {
+	const archiveFile = path.isAbsolute(options.zipFile) ? path.resolve(options.zipFile) : path.resolve(options.rootDir, options.zipFile);
+	const issues = [];
+	const entries = await readZipArchiveEntries(archiveFile, issues);
+	const entryMap = new Map(entries.map((entry) => [entry.archivePath, entry]));
+	const manifestEntry = requireArchiveEntry(entries, DEFAULT_MANIFEST_PATH$1, issues);
+	const bundleEntry = requireArchiveEntry(entries, DEFAULT_BUNDLE_PATH$1, issues);
+	const reportEntry = requireArchiveEntry(entries, DEFAULT_REPORT_PATH$1, issues);
+	const manifestInput = readJsonArchiveEntry(manifestEntry, issues);
+	const bundleInput = readJsonArchiveEntry(bundleEntry, issues);
+	const reportInput = readJsonArchiveEntry(reportEntry, issues);
+	const manifestResult = validateSeedAppManifest(manifestInput);
+	const bundleResult = validateSeedAppBundleManifest(bundleInput);
+	if (manifestEntry && !manifestResult.success) issues.push(...manifestResult.errors);
+	if (bundleEntry && !bundleResult.success) issues.push(...bundleResult.errors);
+	validateIntegrityReport(reportEntry, reportInput, issues);
+	if (bundleResult.success) validateArchiveAssets(entryMap, bundleResult.data, issues);
+	const expectedTextFound = options.expectedText ? hasExpectedText(entries, options.expectedText) : void 0;
+	if (options.expectedText && !expectedTextFound) issues.push({
+		path: "expectText",
+		message: "Expected text marker was not found in archive contents."
+	});
+	return {
+		ok: issues.length === 0,
+		archiveFile,
+		files: entries.map((entry) => entry.archivePath),
+		manifestPath: manifestEntry?.archivePath,
+		bundlePath: bundleEntry?.archivePath,
+		reportPath: reportEntry?.archivePath,
+		appId: manifestResult.success ? manifestResult.data.id : void 0,
+		version: manifestResult.success ? manifestResult.data.version : void 0,
+		assetCount: bundleResult.success ? bundleResult.data.assets.length : 0,
+		expectedText: options.expectedText,
+		expectedTextFound,
+		issues
+	};
+}
+async function readBundleManifest(bundlePath) {
+	const result = validateSeedAppBundleManifest(JSON.parse(await readFile(bundlePath, "utf8")));
+	if (!result.success) throw new Error("Cannot create a package archive from an invalid bundle manifest.");
+	return result.data;
+}
+function toPackageSourceFile(rootDir, inputPath) {
+	const archivePath = toArchivePath(rootDir, inputPath);
+	return {
+		absolutePath: path.join(rootDir, archivePath),
+		archivePath
+	};
+}
+function reportSourceFile(rootDir, inputPath, report) {
+	const archivePath = isInsideRoot(rootDir, path.resolve(rootDir, inputPath)) ? toArchivePath(rootDir, inputPath) : DEFAULT_REPORT_PATH$1;
+	return {
+		absolutePath: path.join(rootDir, archivePath),
+		archivePath,
+		data: `${JSON.stringify(report, null, 2)}\n`
+	};
+}
+function toArchivePath(rootDir, inputPath) {
+	const absolutePath = path.isAbsolute(inputPath) ? path.resolve(inputPath) : path.resolve(rootDir, inputPath);
+	if (!isInsideRoot(rootDir, absolutePath)) throw new Error(`Package archive path must stay inside the app root: ${inputPath}`);
+	return normalizeArchivePath(path.relative(rootDir, absolutePath));
+}
+function isInsideRoot(rootDir, absolutePath) {
+	const relativePath = path.relative(rootDir, absolutePath);
+	return relativePath === "" || !relativePath.startsWith("..") && !path.isAbsolute(relativePath);
+}
+function dedupeArchiveFiles(files) {
+	const seen = /* @__PURE__ */ new Set();
+	return files.filter((file) => {
+		if (seen.has(file.archivePath)) return false;
+		seen.add(file.archivePath);
+		return true;
+	});
+}
+function normalizeArchivePath(input) {
+	return input.split(path.sep).join("/");
+}
+async function readZipArchiveEntries(archiveFile, issues) {
+	try {
+		return parseZipArchiveEntries(await readFile(archiveFile));
+	} catch (error) {
+		issues.push({
+			path: archiveFile,
+			message: error instanceof Error ? error.message : "Archive is unreadable."
+		});
+		return [];
+	}
+}
+function parseZipArchiveEntries(archive) {
+	const entries = [];
+	let offset = 0;
+	while (offset + 4 <= archive.length) {
+		const signature = archive.readUInt32LE(offset);
+		if (signature === 33639248 || signature === 101010256) break;
+		if (signature !== 67324752) throw new Error(`Unsupported zip header at offset ${offset}.`);
+		if (offset + 30 > archive.length) throw new Error("Zip local file header is truncated.");
+		const compressionMethod = archive.readUInt16LE(offset + 8);
+		const compressedSize = archive.readUInt32LE(offset + 18);
+		const uncompressedSize = archive.readUInt32LE(offset + 22);
+		const fileNameLength = archive.readUInt16LE(offset + 26);
+		const extraFieldLength = archive.readUInt16LE(offset + 28);
+		const fileNameStart = offset + 30;
+		const dataStart = fileNameStart + fileNameLength + extraFieldLength;
+		const dataEnd = dataStart + compressedSize;
+		if (dataEnd > archive.length) throw new Error("Zip file entry data is truncated.");
+		const archivePath = normalizeArchivePath(archive.subarray(fileNameStart, fileNameStart + fileNameLength).toString("utf8"));
+		if (compressionMethod !== 0) throw new Error(`Unsupported compression method ${compressionMethod} for ${archivePath}.`);
+		if (compressedSize !== uncompressedSize) throw new Error(`Compressed entry size is unsupported for ${archivePath}.`);
+		entries.push({
+			archivePath,
+			data: Buffer.from(archive.subarray(dataStart, dataEnd)),
+			size: uncompressedSize
+		});
+		offset = dataEnd;
+	}
+	if (entries.length === 0) throw new Error("Archive does not contain local file entries.");
+	return entries;
+}
+function requireArchiveEntry(entries, fileName, issues) {
+	const entry = entries.find((candidate) => candidate.archivePath === fileName) ?? entries.find((candidate) => candidate.archivePath.endsWith(`/${fileName}`));
+	if (!entry) issues.push({
+		path: fileName,
+		message: `Archive must include ${fileName}.`
+	});
+	return entry;
+}
+function readJsonArchiveEntry(entry, issues) {
+	if (!entry) return void 0;
+	try {
+		return JSON.parse(entry.data.toString("utf8"));
+	} catch {
+		issues.push({
+			path: entry.archivePath,
+			message: "Archive entry must contain valid JSON."
+		});
+		return;
+	}
+}
+function validateIntegrityReport(reportEntry, reportInput, issues) {
+	if (!reportEntry) return;
+	if (!isRecord(reportInput)) {
+		issues.push({
+			path: reportEntry.archivePath,
+			message: "Integrity report must be an object."
+		});
+		return;
+	}
+	if (reportInput.ok !== true) issues.push({
+		path: `${reportEntry.archivePath}.ok`,
+		message: "Integrity report must be successful."
+	});
+}
+function validateArchiveAssets(entryMap, bundle, issues) {
+	for (const asset of bundle.assets) {
+		const archivePath = normalizeAssetPath$1(asset.path);
+		const entry = entryMap.get(archivePath);
+		if (!entry) {
+			issues.push({
+				path: `assets.${asset.path}`,
+				message: "Bundle asset is missing from archive."
+			});
+			continue;
+		}
+		if (sha256Digest$1(entry.data) !== asset.sha256) issues.push({
+			path: `assets.${asset.path}.sha256`,
+			message: "Archive asset sha256 does not match bundle manifest."
+		});
+		if (entry.size !== asset.size) issues.push({
+			path: `assets.${asset.path}.size`,
+			message: "Archive asset size does not match bundle manifest."
+		});
+	}
+	if (!entryMap.has(normalizeAssetPath$1(bundle.entryHtml))) issues.push({
+		path: "bundle.entryHtml",
+		message: "Archive must include bundle entryHtml."
+	});
+}
+function hasExpectedText(entries, expectedText) {
+	const marker = Buffer.from(expectedText);
+	return entries.some((entry) => entry.data.indexOf(marker) >= 0);
+}
+function sha256Digest$1(content) {
+	return `sha256:${createHash("sha256").update(content).digest("hex")}`;
+}
+function normalizeAssetPath$1(input) {
+	return normalizeArchivePath(input).replace(/^\/+/, "");
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/validator.ts
+const DEFAULT_MANIFEST_PATH = "seed-app.json";
+const DEFAULT_BUNDLE_PATH = "seed-app.bundle.json";
+const DEFAULT_REPORT_PATH = "seed-app.integrity-report.json";
+async function validateSeedAppPackage(options) {
+	const manifestPath = resolveInputPath(options.rootDir, options.manifestPath ?? DEFAULT_MANIFEST_PATH);
+	const bundlePath = resolveInputPath(options.rootDir, options.bundlePath ?? DEFAULT_BUNDLE_PATH);
+	const issues = [];
+	const manifestInput = await readJsonFile(manifestPath, "manifest", issues);
+	const bundleInput = await readJsonFile(bundlePath, "bundle", issues);
+	const manifestResult = validateSeedAppManifest(manifestInput);
+	const bundleResult = validateSeedAppBundleManifest(bundleInput);
+	if (!manifestResult.success) issues.push(...manifestResult.errors);
+	if (!bundleResult.success) issues.push(...bundleResult.errors);
+	const manifest = manifestResult.success ? manifestResult.data : void 0;
+	const bundle = bundleResult.success ? bundleResult.data : void 0;
+	const assetReports = bundle ? await validateAssets(options.rootDir, bundle, issues) : [];
+	const entryIntegrity = bundle ? await computeEntryIntegrity(options.rootDir, bundle, issues) : void 0;
+	const computedBundleChecksum = bundle ? computeBundleChecksum(bundle, assetReports) : void 0;
+	if (manifest && bundle) validateManifestBundle(manifest, bundle, computedBundleChecksum, entryIntegrity, options.gatewayChecksum, issues);
+	return {
+		ok: issues.length === 0,
+		appId: manifest?.id,
+		version: manifest?.version,
+		entryHtml: bundle?.entryHtml,
+		entryIntegrity,
+		computedBundleChecksum,
+		manifestPath,
+		bundlePath,
+		assets: assetReports,
+		issues
+	};
+}
+async function writeSeedAppPackageReport(options) {
+	await writeGeneratedBundleManifestIfMissing(options);
+	const report = await validateSeedAppPackage(options);
+	await writeFile(resolveInputPath(options.rootDir, options.outFile ?? DEFAULT_REPORT_PATH), `${JSON.stringify(report, null, 2)}\n`, "utf8");
+	return report;
+}
+async function writeGeneratedBundleManifestIfMissing(options) {
+	const rootDir = path.resolve(options.rootDir);
+	const bundlePath = resolveInputPath(rootDir, options.bundlePath ?? DEFAULT_BUNDLE_PATH);
+	if (await fileExists(bundlePath)) return;
+	const manifestPath = resolveInputPath(rootDir, options.manifestPath ?? DEFAULT_MANIFEST_PATH);
+	const manifestResult = validateSeedAppManifest(JSON.parse(await readFile(manifestPath, "utf8")));
+	if (!manifestResult.success) return;
+	const files = await collectBundleFiles(path.join(rootDir, "dist"), rootDir);
+	const indexFile = files.find((file) => normalizeAssetPath(file.relativePath) === "dist/index.html");
+	if (!indexFile) return;
+	const assets = await Promise.all(files.map(async (file) => {
+		const [content, fileStat] = await Promise.all([readFile(file.absolutePath), stat(file.absolutePath)]);
+		return {
+			path: normalizeAssetPath(file.relativePath),
+			sha256: sha256Digest(content),
+			size: fileStat.size,
+			contentType: contentTypeForPath(file.relativePath)
+		};
+	}));
+	const bundle = {
+		format: "static-spa",
+		entryHtml: normalizeAssetPath(indexFile.relativePath),
+		baseUrl: `seed-app://${manifestResult.data.id}/`,
+		assets
+	};
+	await writeFile(bundlePath, `${JSON.stringify(bundle, null, 2)}\n`, "utf8");
+}
+function validateManifestBundle(manifest, bundle, computedBundleChecksum, entryIntegrity, gatewayChecksum, issues) {
+	if (manifest.bundle?.entryHtml && manifest.bundle.entryHtml !== bundle.entryHtml) issues.push({
+		path: "manifest.bundle.entryHtml",
+		message: "Manifest bundle entryHtml does not match bundle manifest."
+	});
+	if (manifest.bundle?.integrity && entryIntegrity && manifest.bundle.integrity !== entryIntegrity) issues.push({
+		path: "manifest.bundle.integrity",
+		message: "Manifest bundle integrity does not match computed entry SRI."
+	});
+	if (bundle.integrity && entryIntegrity && bundle.integrity !== entryIntegrity) issues.push({
+		path: "bundle.integrity",
+		message: "Bundle manifest integrity does not match computed entry SRI."
+	});
+	if (manifest.bundle?.checksum && computedBundleChecksum && manifest.bundle.checksum !== computedBundleChecksum) issues.push({
+		path: "manifest.bundle.checksum",
+		message: "Manifest bundle checksum does not match computed bundle checksum."
+	});
+	if (gatewayChecksum && manifest.bundle?.checksum && gatewayChecksum !== manifest.bundle.checksum) issues.push({
+		path: "gatewayChecksum",
+		message: "Gateway checksum does not match manifest bundle checksum."
+	});
+}
+async function validateAssets(rootDir, bundle, issues) {
+	const reports = await Promise.all(bundle.assets.map(async (asset) => {
+		const assetPath = resolveInputPath(rootDir, asset.path);
+		try {
+			const [content, fileStat] = await Promise.all([readFile(assetPath), stat(assetPath)]);
+			const actualSha256 = sha256Digest(content);
+			const actualSize = fileStat.size;
+			const ok = actualSha256 === asset.sha256 && actualSize === asset.size;
+			if (actualSha256 !== asset.sha256) issues.push({
+				path: `assets.${asset.path}.sha256`,
+				message: "Asset sha256 does not match file content."
+			});
+			if (actualSize !== asset.size) issues.push({
+				path: `assets.${asset.path}.size`,
+				message: "Asset size does not match file size."
+			});
+			return {
+				path: asset.path,
+				expectedSha256: asset.sha256,
+				actualSha256,
+				expectedSize: asset.size,
+				actualSize,
+				ok
+			};
+		} catch {
+			issues.push({
+				path: `assets.${asset.path}`,
+				message: "Asset file is missing or unreadable."
+			});
+			return {
+				path: asset.path,
+				expectedSha256: asset.sha256,
+				expectedSize: asset.size,
+				ok: false
+			};
+		}
+	}));
+	if (!bundle.assets.some((asset) => normalizeAssetPath(asset.path) === normalizeAssetPath(bundle.entryHtml))) issues.push({
+		path: "bundle.entryHtml",
+		message: "entryHtml must exist in bundle assets."
+	});
+	return reports;
+}
+async function computeEntryIntegrity(rootDir, bundle, issues) {
+	const entryAsset = bundle.assets.find((asset) => normalizeAssetPath(asset.path) === normalizeAssetPath(bundle.entryHtml));
+	if (!entryAsset) return void 0;
+	try {
+		const content = await readFile(resolveInputPath(rootDir, entryAsset.path));
+		return `sha512-${createHash("sha512").update(content).digest("base64")}`;
+	} catch {
+		issues.push({
+			path: "bundle.entryHtml",
+			message: "entryHtml file is missing or unreadable."
+		});
+		return;
+	}
+}
+function computeBundleChecksum(bundle, assets) {
+	const payload = {
+		baseUrl: bundle.baseUrl,
+		entryHtml: bundle.entryHtml,
+		format: bundle.format,
+		integrity: bundle.integrity,
+		assets: assets.map((asset) => ({
+			path: normalizeAssetPath(asset.path),
+			sha256: asset.actualSha256 ?? asset.expectedSha256,
+			size: asset.actualSize ?? asset.expectedSize
+		})).toSorted((left, right) => left.path.localeCompare(right.path))
+	};
+	return sha256Digest(Buffer.from(JSON.stringify(payload)));
+}
+async function collectBundleFiles(currentDir, rootDir) {
+	const entries = await readdir(currentDir, { withFileTypes: true });
+	return (await Promise.all(entries.map(async (entry) => {
+		const absolutePath = path.join(currentDir, entry.name);
+		if (entry.isDirectory()) return collectBundleFiles(absolutePath, rootDir);
+		if (entry.isFile()) return [{
+			absolutePath,
+			relativePath: path.relative(rootDir, absolutePath)
+		}];
+		return [];
+	}))).flat().toSorted((left, right) => left.relativePath.localeCompare(right.relativePath));
+}
+async function fileExists(filePath) {
+	try {
+		await access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function contentTypeForPath(input) {
+	const extension = path.extname(input).toLowerCase();
+	if (extension === ".html") return "text/html";
+	if (extension === ".js" || extension === ".mjs") return "text/javascript";
+	if (extension === ".css") return "text/css";
+	if (extension === ".json") return "application/json";
+	if (extension === ".svg") return "image/svg+xml";
+	if (extension === ".png") return "image/png";
+	if (extension === ".jpg" || extension === ".jpeg") return "image/jpeg";
+	return "application/octet-stream";
+}
+async function readJsonFile(filePath, label, issues) {
+	try {
+		return JSON.parse(await readFile(filePath, "utf8"));
+	} catch {
+		issues.push({
+			path: label,
+			message: `${label} JSON is missing, unreadable, or invalid.`
+		});
+		return;
+	}
+}
+function sha256Digest(content) {
+	return `sha256:${createHash("sha256").update(content).digest("hex")}`;
+}
+function normalizeAssetPath(input) {
+	return input.replace(/^\/+/, "");
+}
+function resolveInputPath(rootDir, input) {
+	return path.isAbsolute(input) ? input : path.join(rootDir, input);
+}
+//#endregion
+//#region src/commands.ts
+function parseSeedAppCliArgs(args, cwd = process.cwd()) {
+	const [commandArg, ...rest] = args;
+	const command = commandArg === "init" || commandArg === "package" || commandArg === "validate" || commandArg === "example" || commandArg === "inspect-archive" ? commandArg : "help";
+	const invocation = {
+		command,
+		rootDir: cwd,
+		force: false,
+		json: false
+	};
+	if (command === "init" && rest[0] && !rest[0].startsWith("-")) invocation.rootDir = rest.shift() ?? cwd;
+	for (let index = 0; index < rest.length; index += 1) {
+		const arg = rest[index];
+		if (arg === "--root") invocation.rootDir = readOptionValue(rest, index += 1, "--root");
+		else if (arg === "--id") invocation.appId = readOptionValue(rest, index += 1, "--id");
+		else if (arg === "--name") invocation.appName = readOptionValue(rest, index += 1, "--name");
+		else if (arg === "--dev-url") invocation.devUrl = readOptionValue(rest, index += 1, "--dev-url");
+		else if (arg === "--manifest") invocation.manifestPath = readOptionValue(rest, index += 1, "--manifest");
+		else if (arg === "--bundle") invocation.bundlePath = readOptionValue(rest, index += 1, "--bundle");
+		else if (arg === "--gateway-checksum") invocation.gatewayChecksum = readOptionValue(rest, index += 1, "--gateway-checksum");
+		else if (arg === "--out") invocation.outFile = readOptionValue(rest, index += 1, "--out");
+		else if (arg === "--zip") invocation.zipFile = readOptionValue(rest, index += 1, "--zip");
+		else if (arg === "--expect-text") invocation.expectedText = readOptionValue(rest, index += 1, "--expect-text");
+		else if (arg === "--sdk-dependency") invocation.sdkDependency = readOptionValue(rest, index += 1, "--sdk-dependency");
+		else if (arg === "--cli-dependency") invocation.cliDependency = readOptionValue(rest, index += 1, "--cli-dependency");
+		else if (arg === "--force") invocation.force = true;
+		else if (arg === "--json") invocation.json = true;
+	}
+	return invocation;
+}
+async function runSeedAppCli(invocation) {
+	if (invocation.command === "help") return {
+		exitCode: 0,
+		stdout: usageText(),
+		stderr: ""
+	};
+	if (invocation.command === "init") {
+		const result = await initSeedAppProject(toInitOptions(invocation));
+		return {
+			exitCode: 0,
+			stdout: invocation.json ? `${JSON.stringify(result, null, 2)}\n` : `Seed app project created at ${result.rootDir}\n${result.files.map((file) => `- ${file}`).join("\n")}\n`,
+			stderr: ""
+		};
+	}
+	if (invocation.command === "example") {
+		const result = await writeSeedAppExampleArchive(toExampleOptions(invocation));
+		return {
+			exitCode: 0,
+			stdout: invocation.json ? `${JSON.stringify(result, null, 2)}\n` : `Seed app example archive written to ${result.outFile}\n${result.files.map((file) => `- ${file}`).join("\n")}\n`,
+			stderr: ""
+		};
+	}
+	if (invocation.command === "inspect-archive") {
+		const inspection = await inspectSeedAppPackageArchive(toArchiveInspectOptions(invocation));
+		const stdout = invocation.json ? `${JSON.stringify(inspection, null, 2)}\n` : formatArchiveInspection(inspection);
+		return {
+			exitCode: inspection.ok ? 0 : 1,
+			stdout,
+			stderr: ""
+		};
+	}
+	const options = {
+		rootDir: invocation.rootDir,
+		manifestPath: invocation.manifestPath,
+		bundlePath: invocation.bundlePath,
+		gatewayChecksum: invocation.gatewayChecksum
+	};
+	const report = invocation.command === "package" ? await runPackageCommand({
+		...options,
+		outFile: invocation.outFile,
+		zipFile: invocation.zipFile
+	}) : await validateSeedAppPackage(options);
+	const stdout = invocation.json ? `${JSON.stringify(report, null, 2)}\n` : formatReport(report);
+	return {
+		exitCode: report.ok ? 0 : 1,
+		stdout,
+		stderr: ""
+	};
+}
+async function runPackageCommand(options) {
+	const report = await writeSeedAppPackageReport(options);
+	if (!options.zipFile || !report.ok) return report;
+	const packageArchive = await writeSeedAppPackageArchive({
+		rootDir: options.rootDir,
+		manifestPath: options.manifestPath,
+		bundlePath: options.bundlePath,
+		reportPath: options.outFile,
+		report,
+		zipFile: options.zipFile
+	});
+	return {
+		...report,
+		packageArchive
+	};
+}
+function toArchiveInspectOptions(invocation) {
+	if (!invocation.zipFile) throw new Error("--zip requires a value.");
+	return {
+		rootDir: invocation.rootDir,
+		zipFile: invocation.zipFile,
+		expectedText: invocation.expectedText
+	};
+}
+function toExampleOptions(invocation) {
+	return {
+		outFile: invocation.outFile,
+		sdkDependency: invocation.sdkDependency,
+		cliDependency: invocation.cliDependency
+	};
+}
+function toInitOptions(invocation) {
+	if (!invocation.appId) throw new Error("--id requires a value.");
+	if (!invocation.appName) throw new Error("--name requires a value.");
+	return {
+		rootDir: invocation.rootDir,
+		appId: invocation.appId,
+		appName: invocation.appName,
+		devUrl: invocation.devUrl ?? "http://localhost:5173",
+		sdkDependency: invocation.sdkDependency,
+		force: invocation.force
+	};
+}
+function readOptionValue(args, index, option) {
+	const value = args[index];
+	if (!value) throw new Error(`${option} requires a value.`);
+	return value;
+}
+function formatReport(report) {
+	const lines = [
+		report.ok ? "Seed app validation passed." : "Seed app validation failed.",
+		`App: ${report.appId ?? "unknown"} ${report.version ?? ""}`.trim(),
+		`Manifest: ${report.manifestPath}`,
+		`Bundle: ${report.bundlePath}`
+	];
+	if (report.packageArchive) lines.push(`Archive: ${report.packageArchive.outFile}`);
+	if (report.computedBundleChecksum) lines.push(`Bundle checksum: ${report.computedBundleChecksum}`);
+	if (report.entryIntegrity) lines.push(`Entry integrity: ${report.entryIntegrity}`);
+	if (report.issues.length > 0) {
+		lines.push("Issues:");
+		report.issues.forEach((issue) => lines.push(`- ${issue.path}: ${issue.message}`));
+	}
+	return `${lines.join("\n")}\n`;
+}
+function formatArchiveInspection(inspection) {
+	const lines = [
+		inspection.ok ? "Seed app archive smoke passed." : "Seed app archive smoke failed.",
+		`Archive: ${inspection.archiveFile}`,
+		`App: ${inspection.appId ?? "unknown"} ${inspection.version ?? ""}`.trim(),
+		`Files: ${inspection.files.length}`,
+		`Assets: ${inspection.assetCount}`
+	];
+	if (inspection.expectedText) lines.push(`Expected text: ${inspection.expectedTextFound ? "found" : "missing"}`);
+	if (inspection.issues.length > 0) {
+		lines.push("Issues:");
+		inspection.issues.forEach((issue) => lines.push(`- ${issue.path}: ${issue.message}`));
+	}
+	return `${lines.join("\n")}\n`;
+}
+function usageText() {
+	return [
+		"Usage:",
+		"  seed-app init <dir> --id app.id --name \"App Name\" [--dev-url http://localhost:5173] [--sdk-dependency <specifier>] [--force] [--json]",
+		"  seed-app validate [--root dir] [--manifest seed-app.json] [--bundle seed-app.bundle.json] [--gateway-checksum sha256:...] [--json]",
+		"  seed-app package [--root dir] [--out seed-app.integrity-report.json] [--zip seed-app-package.zip] [--json]",
+		"  seed-app inspect-archive [--root dir] --zip seed-app-package.zip [--expect-text marker] [--json]",
+		"  seed-app example [--out seed-react-spa-stories.zip] [--sdk-dependency <specifier>] [--cli-dependency <specifier>] [--json]",
+		""
+	].join("\n");
+}
+//#endregion
+export { inspectSeedAppPackageArchive as a, initSeedAppProject as c, writeSeedAppPackageReport as i, runSeedAppCli as n, writeSeedAppPackageArchive as o, validateSeedAppPackage as r, writeSeedAppExampleArchive as s, parseSeedAppCliArgs as t };