pi-tldraw 0.1.0

package/scripts/assemble-mcp-app.mjs

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+import { createHash } from 'node:crypto'
+import { existsSync } from 'node:fs'
+import { cp, mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { spawnSync } from 'node:child_process'
+
+const args = new Set(process.argv.slice(2))
+const usePinnedSource = args.has('--pinned')
+const skipBuild = args.has('--skip-build')
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..')
+const manifestPath = resolve(root, 'mcp-app-source.json')
+const manifest = existsSync(manifestPath) ? JSON.parse(await readText(manifestPath)) : null
+const defaultSource = resolve(root, '../tldraw/apps/mcp-app')
+const targetDir = resolve(root, 'mcp-app')
+const sourceDir = usePinnedSource
+	? await preparePinnedSource()
+	: resolve(process.env.TLDRAW_MCP_APP_SOURCE_DIR || defaultSource)
+
+const requiredFiles = [
+	'package.json',
+	'wrangler.toml',
+	'src/worker.ts',
+	'src/register-tools.ts',
+	'dist/mcp-app.html',
+	'dist/editor-api.json',
+	'dist/method-map.json',
+]
+
+function sha256(value) {
+	return createHash('sha256').update(value).digest('hex')
+}
+
+async function readText(path) {
+	return readFile(path, 'utf8')
+}
+
+function run(command, commandArgs, opts = {}) {
+	const result = spawnSync(command, commandArgs, { encoding: 'utf8', stdio: 'pipe', ...opts })
+	if (result.status !== 0) {
+		throw new Error(
+			[
+				`Command failed: ${command} ${commandArgs.join(' ')}`,
+				result.stdout?.trim(),
+				result.stderr?.trim(),
+			]
+				.filter(Boolean)
+				.join('\n')
+		)
+	}
+	return result.stdout.trim()
+}
+
+function git(cwd, gitArgs) {
+	const result = spawnSync('git', gitArgs, { cwd, encoding: 'utf8' })
+	return result.status === 0 ? result.stdout.trim() : ''
+}
+
+function shell(cwd, command) {
+	const result = spawnSync(command, { cwd, encoding: 'utf8', stdio: 'inherit', shell: true })
+	if (result.status !== 0) throw new Error(`Command failed in ${cwd}: ${command}`)
+}
+
+function findGitRoot(path) {
+	const result = spawnSync('git', ['rev-parse', '--show-toplevel'], { cwd: path, encoding: 'utf8' })
+	return result.status === 0 ? result.stdout.trim() : undefined
+}
+
+async function patchMetadata() {
+	if (!manifest?.patches?.length) return []
+	return Promise.all(
+		manifest.patches.map(async (patchPath) => {
+			const absolutePath = resolve(root, patchPath)
+			const body = await readText(absolutePath)
+			return { path: patchPath, sha256: sha256(body) }
+		})
+	)
+}
+
+async function preparePinnedSource() {
+	if (!manifest) throw new Error(`Missing ${manifestPath}; cannot assemble pinned mcp-app source`)
+	const buildRoot = resolve(process.env.TLDRAW_MCP_APP_BUILD_DIR || resolve(root, '.pi/build/tldraw-mcp-source'))
+	await rm(buildRoot, { recursive: true, force: true })
+	await mkdir(dirname(buildRoot), { recursive: true })
+
+	console.log(`cloning ${manifest.repo} -> ${buildRoot}`)
+	run('git', ['clone', manifest.repo, buildRoot], { cwd: root })
+	run('git', ['checkout', manifest.commit], { cwd: buildRoot })
+
+	for (const patchPath of manifest.patches ?? []) {
+		const absolutePatch = resolve(root, patchPath)
+		console.log(`applying ${patchPath}`)
+		run('git', ['apply', absolutePatch], { cwd: buildRoot })
+	}
+
+	if (!skipBuild) {
+		for (const step of manifest.build ?? []) {
+			const cwd = resolve(buildRoot, step.cwd ?? '.')
+			console.log(`building in ${cwd}: ${step.command}`)
+			shell(cwd, step.command)
+		}
+	} else {
+		console.warn('skipping pinned source build because --skip-build was passed')
+	}
+
+	return resolve(buildRoot, manifest.appPath)
+}
+
+async function copyIfExists(relativePath) {
+	const src = resolve(sourceDir, relativePath)
+	if (!existsSync(src)) return false
+	const dest = resolve(targetDir, relativePath)
+	await mkdir(dirname(dest), { recursive: true })
+	await cp(src, dest, { recursive: true })
+	return true
+}
+
+for (const file of requiredFiles) {
+	if (!existsSync(resolve(sourceDir, file))) {
+		throw new Error(
+			`Missing ${file} in ${sourceDir}. Build the tldraw MCP app first, e.g. cd ${sourceDir} && yarn build`
+		)
+	}
+}
+
+await rm(targetDir, { recursive: true, force: true })
+await mkdir(targetDir, { recursive: true })
+
+for (const path of manifest?.assembledFiles ?? [
+	'LICENSE.md',
+	'README.md',
+	'package.json',
+	'server.json',
+	'tsconfig.json',
+	'vite.config.ts',
+	'wrangler.toml',
+	'dev-tunnel.sh',
+	'src',
+	'scripts',
+	'plugins',
+	'dist',
+]) {
+	await copyIfExists(path.replace(/\/$/, ''))
+}
+
+const pkgPath = resolve(targetDir, 'package.json')
+const pkg = JSON.parse(await readText(pkgPath))
+pkg.private = true
+pkg.scripts = {
+	...pkg.scripts,
+	// Runtime packages ship prebuilt dist assets. Do not rebuild tldraw on user machines.
+	dev: 'yarn dev:http',
+	'dev:http': 'node ../scripts/run-mcp-app-dev.mjs',
+	build: 'node -e "const fs=require(\'fs\'); for (const f of [\'dist/mcp-app.html\',\'dist/editor-api.json\',\'dist/method-map.json\']) if (!fs.existsSync(f)) throw new Error(`Missing ${f}`); console.log(\'prebuilt mcp-app dist is present\')"',
+}
+await writeFile(pkgPath, `${JSON.stringify(pkg, null, '\t')}\n`, 'utf8')
+
+const gitRoot = findGitRoot(sourceDir)
+const patches = await patchMetadata()
+const sourceGitCommit = gitRoot ? git(gitRoot, ['rev-parse', 'HEAD']) : undefined
+const sourceGitStatus = gitRoot ? git(gitRoot, ['status', '--short', '--', manifest?.appPath ?? 'apps/mcp-app']) : undefined
+const provenance = {
+	artifact: 'mcp-app/',
+	builder: 'scripts/assemble-mcp-app.mjs',
+	source: {
+		mode: usePinnedSource ? 'pinned' : 'local',
+		repo: manifest?.repo,
+		commit: manifest?.commit,
+		appPath: manifest?.appPath,
+		patches,
+		build: manifest?.build,
+		sourceGitCommit,
+		...(process.env.PI_TLDRAW_INCLUDE_LOCAL_PROVENANCE === 'true'
+			? { sourceDir, sourceGitRoot: gitRoot, sourceGitStatus }
+			: {}),
+	},
+	dist: {
+		'mcp-app.html': sha256(await readText(resolve(targetDir, 'dist/mcp-app.html'))),
+		'editor-api.json': sha256(await readText(resolve(targetDir, 'dist/editor-api.json'))),
+		'method-map.json': sha256(await readText(resolve(targetDir, 'dist/method-map.json'))),
+	},
+}
+await writeFile(resolve(targetDir, 'PI_TLDRAW_PROVENANCE.json'), `${JSON.stringify(provenance, null, 2)}\n`, 'utf8')
+await writeFile(resolve(targetDir, '.npmignore'), '.wrangler/\nnode_modules/\n*.log\n', 'utf8')
+
+console.log(`assembled ${targetDir}`)
+console.log(`source: ${sourceDir}`)
+if (sourceGitStatus) {
+	console.warn('source has mcp-app changes:')
+	console.warn(sourceGitStatus)
+}

package/scripts/build-bridge.mjs

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import { createHash } from 'node:crypto'
+import { readFile, writeFile, mkdir } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import * as esbuild from 'esbuild'
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..')
+const entry = resolve(root, 'bridge/app-bridge-entry.js')
+const outfile = resolve(root, 'static/app-bridge-bundle.js')
+const metafile = resolve(root, 'static/app-bridge-bundle.meta.json')
+const lockfile = resolve(root, 'package-lock.json')
+
+function sha256(value) {
+	return createHash('sha256').update(value).digest('hex')
+}
+
+async function readText(path) {
+	return readFile(path, 'utf8')
+}
+
+function packageVersionFromLock(lock, packageName) {
+	const entry = lock.packages?.[`node_modules/${packageName}`]
+	if (!entry?.version) throw new Error(`Could not find ${packageName} in package-lock.json`)
+	return entry.version
+}
+
+await mkdir(dirname(outfile), { recursive: true })
+
+const result = await esbuild.build({
+	entryPoints: [entry],
+	bundle: true,
+	outfile,
+	format: 'iife',
+	platform: 'browser',
+	target: ['es2020'],
+	charset: 'utf8',
+	legalComments: 'inline',
+	minify: false,
+	metafile: true,
+	logLevel: 'info',
+})
+
+const [entryText, lockText, bundleText] = await Promise.all([
+	readText(entry),
+	readText(lockfile),
+	readText(outfile),
+])
+const lock = JSON.parse(lockText)
+
+const metadata = {
+	artifact: 'static/app-bridge-bundle.js',
+	builder: 'scripts/build-bridge.mjs',
+	entry: 'bridge/app-bridge-entry.js',
+	format: 'iife',
+	platform: 'browser',
+	target: 'es2020',
+	dependencies: {
+		'@modelcontextprotocol/ext-apps': packageVersionFromLock(lock, '@modelcontextprotocol/ext-apps'),
+		'@modelcontextprotocol/sdk': packageVersionFromLock(lock, '@modelcontextprotocol/sdk'),
+		zod: packageVersionFromLock(lock, 'zod'),
+		esbuild: packageVersionFromLock(lock, 'esbuild'),
+	},
+	hashes: {
+		entrySha256: sha256(entryText),
+		packageLockSha256: sha256(lockText),
+		bundleSha256: sha256(bundleText),
+	},
+	inputs: Object.keys(result.metafile.inputs).sort(),
+}
+
+await writeFile(metafile, `${JSON.stringify(metadata, null, 2)}\n`, 'utf8')
+console.log(`built ${outfile}`)
+console.log(`wrote ${metafile}`)

package/scripts/e2e-mcp.mjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+const endpoint = process.env.TLDRAW_MCP_URL || 'http://127.0.0.1:8787/mcp'
+const resourceUri = process.env.TLDRAW_MCP_RESOURCE_URI || 'ui://show-canvas/mcp-app.html'
+let nextId = 1
+let sessionId = null
+
+function parseMcpResponse(text) {
+	const trimmed = text.trim()
+	if (!trimmed) return undefined
+	if (trimmed.startsWith('{') || trimmed.startsWith('[')) return JSON.parse(trimmed)
+	for (const line of trimmed.split(/\r?\n/)) {
+		if (line.startsWith('data:')) return JSON.parse(line.slice(5).trim())
+	}
+	throw new Error(`Could not parse MCP response: ${trimmed.slice(0, 200)}`)
+}
+
+async function post(body) {
+	const headers = {
+		'content-type': 'application/json',
+		accept: 'application/json, text/event-stream',
+	}
+	if (sessionId) headers['mcp-session-id'] = sessionId
+	const response = await fetch(endpoint, { method: 'POST', headers, body: JSON.stringify(body) })
+	const text = await response.text()
+	if (!response.ok) throw new Error(`MCP HTTP ${response.status}: ${text}`)
+	return { response, payload: parseMcpResponse(text) }
+}
+
+async function request(method, params = {}) {
+	const { payload } = await post({ jsonrpc: '2.0', id: nextId++, method, params })
+	if (payload?.error) throw new Error(payload.error.message)
+	return payload?.result
+}
+
+console.log(`checking ${endpoint}`)
+const init = await post({
+	jsonrpc: '2.0',
+	id: nextId++,
+	method: 'initialize',
+	params: {
+		protocolVersion: '2025-06-18',
+		capabilities: {},
+		clientInfo: { name: 'pi-tldraw-e2e', version: '0.0.1' },
+	},
+})
+sessionId = init.response.headers.get('mcp-session-id')
+if (!sessionId) throw new Error('missing mcp-session-id')
+if (init.payload?.error) throw new Error(init.payload.error.message)
+await post({ jsonrpc: '2.0', method: 'notifications/initialized' })
+
+const [{ tools = [] }, { resources = [] }] = await Promise.all([
+	request('tools/list'),
+	request('resources/list'),
+])
+const toolNames = new Set(tools.map((tool) => tool.name))
+for (const required of ['search', 'exec']) {
+	if (!toolNames.has(required)) throw new Error(`missing required tool: ${required}`)
+}
+if (!resources.some((resource) => resource.uri === resourceUri)) {
+	throw new Error(`missing canvas resource: ${resourceUri}`)
+}
+
+const resource = await request('resources/read', { uri: resourceUri })
+const html = resource?.contents?.[0]?.text
+if (typeof html !== 'string' || !html.includes('<')) {
+	throw new Error('canvas resource did not return HTML text')
+}
+
+console.log(`ok: ${tools.length} tool(s), ${resources.length} resource(s), canvas html ${html.length} byte(s)`)

package/scripts/e2e-packaged-mcp-app.mjs

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process'
+import { createServer } from 'node:net'
+
+async function getFreePort() {
+	return new Promise((resolve, reject) => {
+		const server = createServer()
+		server.once('error', reject)
+		server.listen(0, '127.0.0.1', () => {
+			const address = server.address()
+			server.close(() => {
+				if (!address || typeof address === 'string') reject(new Error('Could not allocate port'))
+				else resolve(address.port)
+			})
+		})
+	})
+}
+
+function run(command, args, opts = {}) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, args, { stdio: 'inherit', ...opts })
+		child.on('error', reject)
+		child.on('exit', (code) => {
+			if (code === 0) resolve()
+			else reject(new Error(`${command} ${args.join(' ')} exited with ${code}`))
+		})
+	})
+}
+
+function waitForExit(child, timeoutMs = 5000) {
+	if (child.exitCode !== null || child.signalCode !== null) return Promise.resolve()
+	return new Promise((resolve) => {
+		const timer = setTimeout(resolve, timeoutMs)
+		child.once('exit', () => {
+			clearTimeout(timer)
+			resolve()
+		})
+	})
+}
+
+async function waitForOptions(url, child) {
+	for (let i = 0; i < 120; i++) {
+		if (child.exitCode !== null) throw new Error(`packaged mcp-app exited with ${child.exitCode}`)
+		try {
+			const response = await fetch(url, { method: 'OPTIONS' })
+			if (response.ok || response.status === 204) return
+		} catch {}
+		await new Promise((resolve) => setTimeout(resolve, 500))
+	}
+	throw new Error(`packaged mcp-app did not become reachable: ${url}`)
+}
+
+const port = await getFreePort()
+const endpoint = `http://127.0.0.1:${port}/mcp`
+const app = spawn('yarn', ['-s', 'dev'], {
+	cwd: 'mcp-app',
+	stdio: 'inherit',
+	detached: true,
+	env: {
+		...process.env,
+		TLDRAW_MCP_APP_PORT: String(port),
+		TLDRAW_MCP_URL: endpoint,
+	},
+})
+
+try {
+	await waitForOptions(endpoint, app)
+	await run(process.execPath, ['scripts/e2e-mcp.mjs'], {
+		env: { ...process.env, TLDRAW_MCP_URL: endpoint },
+	})
+} finally {
+	try {
+		if (app.pid) process.kill(-app.pid, 'SIGTERM')
+		else app.kill('SIGTERM')
+	} catch {
+		app.kill('SIGTERM')
+	}
+	await waitForExit(app)
+}

package/scripts/run-mcp-app-dev.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process'
+import { createRequire } from 'node:module'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const require = createRequire(import.meta.url)
+const wranglerPkgPath = require.resolve('wrangler/package.json')
+const wranglerPkg = require(wranglerPkgPath)
+const wranglerBin = resolve(dirname(wranglerPkgPath), wranglerPkg.bin?.wrangler || './bin/wrangler.js')
+
+const endpoint = new URL(process.env.TLDRAW_MCP_URL || 'http://127.0.0.1:8787/mcp')
+const port = process.env.TLDRAW_MCP_APP_PORT || endpoint.port || '8787'
+const origin = process.env.TLDRAW_MCP_WORKER_ORIGIN || `${endpoint.protocol}//${endpoint.hostname}:${port}`
+
+const args = [
+	wranglerBin,
+	'dev',
+	'--var',
+	'MCP_IS_DEV:true',
+	'--var',
+	`WORKER_ORIGIN:${origin}`,
+	...process.argv.slice(2),
+]
+
+if (process.env.TLDRAW_MCP_APP_PORT && !args.includes('--port')) {
+	args.splice(2, 0, '--port', port)
+}
+
+const child = spawn(process.execPath, args, {
+	cwd: process.cwd(),
+	stdio: 'inherit',
+	env: process.env,
+})
+
+for (const signal of ['SIGINT', 'SIGTERM']) {
+	process.on(signal, () => {
+		child.kill(signal)
+	})
+}
+
+child.on('exit', (code) => {
+	process.exit(code ?? 0)
+})

package/scripts/verify-bundle.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import { readFile } from 'node:fs/promises'
+import { createHash } from 'node:crypto'
+import { resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const root = resolve(fileURLToPath(new URL('..', import.meta.url)))
+const bundlePath = resolve(root, 'static/app-bridge-bundle.js')
+const metaPath = resolve(root, 'static/app-bridge-bundle.meta.json')
+
+function sha256(value) {
+	return createHash('sha256').update(value).digest('hex')
+}
+
+const [bundle, rawMeta] = await Promise.all([
+	readFile(bundlePath, 'utf8'),
+	readFile(metaPath, 'utf8'),
+])
+const meta = JSON.parse(rawMeta)
+
+const requiredSnippets = [
+	'AppBridge',
+	'PostMessageTransport',
+	'McpAppsBridge',
+]
+
+for (const snippet of requiredSnippets) {
+	if (!bundle.includes(snippet)) {
+		throw new Error(`Bridge bundle does not contain required snippet: ${snippet}`)
+	}
+}
+
+if (meta?.artifact !== 'static/app-bridge-bundle.js') {
+	throw new Error('Bridge bundle metadata has unexpected artifact path')
+}
+
+if (meta?.hashes?.bundleSha256 !== sha256(bundle)) {
+	throw new Error('Bridge bundle hash does not match metadata; run npm run build:bridge')
+}
+
+console.log('bridge bundle verified')

package/scripts/verify-mcp-app-source.mjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import { createHash } from 'node:crypto'
+import { readFile } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const root = resolve(fileURLToPath(new URL('..', import.meta.url)))
+const manifestPath = resolve(root, 'mcp-app-source.json')
+const provenancePath = resolve(root, 'mcp-app/PI_TLDRAW_PROVENANCE.json')
+
+function sha256(value) {
+	return createHash('sha256').update(value).digest('hex')
+}
+
+async function readJson(path) {
+	return JSON.parse(await readFile(path, 'utf8'))
+}
+
+if (!existsSync(manifestPath)) throw new Error('Missing mcp-app-source.json')
+if (!existsSync(provenancePath)) throw new Error('Missing mcp-app/PI_TLDRAW_PROVENANCE.json')
+
+const manifest = await readJson(manifestPath)
+const provenance = await readJson(provenancePath)
+const source = provenance.source ?? {}
+
+for (const field of ['repo', 'commit', 'appPath']) {
+	if (!manifest[field]) throw new Error(`mcp-app-source.json missing ${field}`)
+	if (source[field] !== manifest[field]) {
+		throw new Error(`mcp-app provenance ${field} does not match manifest`)
+	}
+}
+
+const expectedPatches = []
+for (const patchPath of manifest.patches ?? []) {
+	const absolutePath = resolve(root, patchPath)
+	if (!existsSync(absolutePath)) throw new Error(`Manifest patch does not exist: ${patchPath}`)
+	const body = await readFile(absolutePath, 'utf8')
+	expectedPatches.push({ path: patchPath, sha256: sha256(body) })
+}
+
+const actualPatches = source.patches ?? []
+if (JSON.stringify(actualPatches) !== JSON.stringify(expectedPatches)) {
+	throw new Error('mcp-app provenance patches do not match manifest patch hashes')
+}
+
+for (const file of ['mcp-app.html', 'editor-api.json', 'method-map.json']) {
+	if (!provenance.dist?.[file]) throw new Error(`mcp-app provenance missing dist hash for ${file}`)
+}
+
+console.log('mcp-app source provenance verified')

package/scripts/verify-mcp-app.mjs

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { existsSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const root = resolve(fileURLToPath(new URL('..', import.meta.url)))
+const appDir = resolve(root, 'mcp-app')
+
+const requiredFiles = [
+	'package.json',
+	'wrangler.toml',
+	'src/worker.ts',
+	'src/register-tools.ts',
+	'dist/mcp-app.html',
+	'dist/editor-api.json',
+	'dist/method-map.json',
+	'PI_TLDRAW_PROVENANCE.json',
+]
+
+for (const file of requiredFiles) {
+	if (!existsSync(resolve(appDir, file))) {
+		throw new Error(`Packaged mcp-app is missing ${file}; run npm run assemble:mcp-app`)
+	}
+}
+
+const pkg = JSON.parse(await readFile(resolve(appDir, 'package.json'), 'utf8'))
+const devScript = pkg.scripts?.['dev:http'] || ''
+if (devScript.includes('yarn build') || devScript.includes('vite build')) {
+	throw new Error('Packaged mcp-app dev script must use prebuilt dist assets, not rebuild on user machines')
+}
+
+const html = await readFile(resolve(appDir, 'dist/mcp-app.html'), 'utf8')
+if (!html.includes('<html') && !html.includes('<!doctype html')) {
+	throw new Error('Packaged mcp-app dist/mcp-app.html does not look like HTML')
+}
+
+console.log('packaged mcp-app verified')

package/scripts/verify-package-files.mjs

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process'
+
+const required = [
+	'bridge/app-bridge-entry.js',
+	'static/app-bridge-bundle.js',
+	'static/app-bridge-bundle.meta.json',
+	'mcp-app-source.json',
+	'patches/tldraw-mcp-app/001-pi-runtime.patch',
+	'mcp-app/PI_TLDRAW_PROVENANCE.json',
+	'mcp-app/package.json',
+	'mcp-app/wrangler.toml',
+	'mcp-app/src/worker.ts',
+	'mcp-app/src/register-tools.ts',
+	'mcp-app/dist/mcp-app.html',
+	'mcp-app/dist/editor-api.json',
+	'mcp-app/dist/method-map.json',
+	'scripts/run-mcp-app-dev.mjs',
+]
+
+const forbiddenPrefixes = [
+	'node_modules/',
+	'mcp-app/node_modules/',
+	'mcp-app/.wrangler/',
+	'.pi/',
+]
+
+const result = spawnSync('npm', ['pack', '--dry-run', '--json'], {
+	encoding: 'utf8',
+	stdio: ['ignore', 'pipe', 'pipe'],
+})
+
+if (result.status !== 0) {
+	throw new Error(`npm pack --dry-run --json failed\n${result.stdout}\n${result.stderr}`)
+}
+
+const packs = JSON.parse(result.stdout)
+const files = new Set((packs[0]?.files ?? []).map((file) => file.path))
+
+const missing = required.filter((path) => !files.has(path))
+if (missing.length > 0) {
+	throw new Error(`Package tarball is missing required file(s):\n${missing.join('\n')}`)
+}
+
+const forbidden = [...files].filter((path) => forbiddenPrefixes.some((prefix) => path.startsWith(prefix)))
+if (forbidden.length > 0) {
+	throw new Error(`Package tarball contains forbidden file(s):\n${forbidden.join('\n')}`)
+}
+
+console.log(`package files verified (${files.size} files)`)