@treeseed/sdk 0.10.28 → 0.12.4

package/dist/scripts/build-dist.js

@@ -1,13 +1,65 @@
-import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { basename, dirname, extname, join, relative, resolve } from 'node:path';
+import { chmodSync, copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, rmdirSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, extname, join, relative, resolve } from 'node:path';
 import { build } from 'esbuild';
 import ts from 'typescript';
 import { packageRoot } from './package-tools.js';
 const srcRoot = resolve(packageRoot, 'src');
 const scriptsRoot = resolve(packageRoot, 'scripts');
 const distRoot = resolve(packageRoot, 'dist');
+const distBuildRoot = resolve(packageRoot, `.treeseed-dist-build-${process.pid}`);
+const buildLockRoot = resolve(packageRoot, '.treeseed-build-dist.lock');
 const treeseedTemplateCatalogSourceRoot = resolve(srcRoot, 'treeseed', 'template-catalog');
 const treeseedServicesSourceRoot = resolve(srcRoot, 'treeseed', 'services');
+const BIN_ENTRYPOINTS = new Set(['verification.ts']);
+const BUILD_LOCK_TIMEOUT_MS = 15 * 60 * 1000;
+const BUILD_LOCK_STALE_MS = 20 * 60 * 1000;
+function sleep(ms) {
+    return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
+}
+function lockOwnerIsRunning() {
+    let owner;
+    try {
+        owner = JSON.parse(readFileSync(resolve(buildLockRoot, 'owner.json'), 'utf8'));
+    }
+    catch {
+        return false;
+    }
+    if (typeof owner.pid !== 'number') {
+        return false;
+    }
+    try {
+        process.kill(owner.pid, 0);
+        return true;
+    }
+    catch (error) {
+        const code = typeof error === 'object' && error && 'code' in error ? error.code : null;
+        return code === 'EPERM';
+    }
+}
+async function acquireBuildLock() {
+    const startedAt = Date.now();
+    while (true) {
+        try {
+            mkdirSync(buildLockRoot);
+            writeFileSync(resolve(buildLockRoot, 'owner.json'), JSON.stringify({
+                pid: process.pid,
+                startedAt: new Date().toISOString(),
+            }, null, 2));
+            return () => rmSync(buildLockRoot, { recursive: true, force: true });
+        }
+        catch (error) {
+            const ageMs = existsSync(buildLockRoot) ? Date.now() - statSync(buildLockRoot).mtimeMs : 0;
+            if (!lockOwnerIsRunning() || ageMs > BUILD_LOCK_STALE_MS) {
+                rmSync(buildLockRoot, { recursive: true, force: true });
+                continue;
+            }
+            if (Date.now() - startedAt > BUILD_LOCK_TIMEOUT_MS) {
+                throw new Error(`Timed out waiting for SDK dist build lock at ${buildLockRoot}.`);
+            }
+            await sleep(250);
+        }
+    }
+}
 const COPY_EXTENSIONS = new Set(['.json', '.md', '.js', '.d.js', '.yaml', '.yml']);
 function walkFiles(root) {
     const files = [];
@@ -40,7 +92,7 @@ function isDeclarationAsset(filePath) {
 }
 async function compileModule(filePath, sourceRoot, outputRoot) {
     const relativePath = relative(sourceRoot, filePath);
-    const outputFile = resolve(outputRoot, relativePath.replace(/\.(mjs|ts)$/u, '.js'));
+    const outputFile = resolve(outputRoot, relativePath.replace(/\.ts$/u, '.js'));
     ensureDir(outputFile);
     await build({
         entryPoints: [filePath],
@@ -51,7 +103,14 @@ async function compileModule(filePath, sourceRoot, outputRoot) {
         logLevel: 'silent',
     });
     const builtSource = readFileSync(outputFile, 'utf8');
-    writeFileSync(outputFile, rewriteRuntimeSpecifiers(builtSource), 'utf8');
+    const rewritten = rewriteRuntimeSpecifiers(builtSource);
+    const executableSource = BIN_ENTRYPOINTS.has(relativePath)
+        ? `${rewritten.startsWith('#!') ? '' : '#!/usr/bin/env node\n'}${rewritten}`
+        : rewritten;
+    writeFileSync(outputFile, executableSource, 'utf8');
+    if (BIN_ENTRYPOINTS.has(relativePath)) {
+        chmodSync(outputFile, 0o755);
+    }
 }
 function copyAsset(filePath, sourceRoot, outputRoot) {
     const outputFile = resolve(outputRoot, relative(sourceRoot, filePath));
@@ -67,16 +126,54 @@ function copyAssetTree(sourceRoot, outputRoot) {
         copyAsset(filePath, sourceRoot, outputRoot);
     }
 }
-function transpileScript(filePath) {
-    if (basename(filePath).startsWith('.ts-run-')) {
+function listRelativeFiles(root) {
+    if (!existsSync(root)) {
+        return [];
+    }
+    return walkFiles(root).map((filePath) => relative(root, filePath));
+}
+function removeEmptyDirectories(root) {
+    if (!existsSync(root)) {
+        return;
+    }
+    const entries = readdirSync(root, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        removeEmptyDirectories(resolve(root, entry.name));
+    }
+    if (root !== distRoot && readdirSync(root).length === 0) {
+        rmdirSync(root);
+    }
+}
+function publishDistBuild() {
+    if (!existsSync(distRoot)) {
+        renameSync(distBuildRoot, distRoot);
         return;
     }
+    const nextFiles = new Set(listRelativeFiles(distBuildRoot));
+    for (const relativeFile of nextFiles) {
+        const sourceFile = resolve(distBuildRoot, relativeFile);
+        const targetFile = resolve(distRoot, relativeFile);
+        ensureDir(targetFile);
+        renameSync(sourceFile, targetFile);
+    }
+    for (const relativeFile of listRelativeFiles(distRoot)) {
+        if (nextFiles.has(relativeFile)) {
+            continue;
+        }
+        rmSync(resolve(distRoot, relativeFile), { force: true });
+    }
+    removeEmptyDirectories(distRoot);
+}
+function transpileScript(filePath, outputRoot) {
     const source = readFileSync(filePath, 'utf8');
     const relativePath = relative(scriptsRoot, filePath);
     if (relativePath === 'fixture-tools.ts') {
         return;
     }
-    const outputFile = resolve(distRoot, 'scripts', relativePath.replace(/\.(mjs|ts)$/u, '.js'));
+    const outputFile = resolve(outputRoot, 'scripts', relativePath.replace(/\.ts$/u, '.js'));
     const transformed = extname(filePath) === '.ts'
         ? ts.transpileModule(source, {
             compilerOptions: {
@@ -88,7 +185,7 @@ function transpileScript(filePath) {
     ensureDir(outputFile);
     writeFileSync(outputFile, rewriteScriptRuntimeSpecifiers(transformed), 'utf8');
 }
-function emitDeclarations() {
+function emitDeclarations(outputRoot) {
     const rootNames = walkFiles(srcRoot).filter(isTypeScriptSource);
     const program = ts.createProgram({
         rootNames,
@@ -102,7 +199,7 @@ function emitDeclarations() {
             types: ['node'],
             declaration: true,
             emitDeclarationOnly: true,
-            declarationDir: distRoot,
+            declarationDir: outputRoot,
             rootDir: srcRoot,
             noEmit: false,
         },
@@ -117,42 +214,59 @@ function emitDeclarations() {
         throw new Error(`Declaration build failed.\n${diagnostics}`);
     }
 }
-rmSync(distRoot, { recursive: true, force: true });
-for (const filePath of walkFiles(srcRoot)) {
-    if (filePath.startsWith(`${treeseedTemplateCatalogSourceRoot}/`)) {
-        continue;
+function rewriteDeclarations(outputRoot) {
+    for (const filePath of walkFiles(outputRoot)) {
+        if (!filePath.endsWith('.d.js'))
+            continue;
+        const contents = readFileSync(filePath, 'utf8');
+        writeFileSync(filePath, rewriteRuntimeSpecifiers(contents), 'utf8');
     }
-    const extension = extname(filePath);
-    if (isDeclarationAsset(filePath)) {
-        copyAsset(filePath, srcRoot, distRoot);
-        continue;
+}
+const releaseBuildLock = await acquireBuildLock();
+try {
+    rmSync(distBuildRoot, { recursive: true, force: true });
+    for (const filePath of walkFiles(srcRoot)) {
+        if (filePath.startsWith(`${treeseedTemplateCatalogSourceRoot}/`)) {
+            continue;
+        }
+        const extension = extname(filePath);
+        if (isDeclarationAsset(filePath)) {
+            copyAsset(filePath, srcRoot, distBuildRoot);
+            continue;
+        }
+        if (isTypeScriptSource(filePath)) {
+            await compileModule(filePath, srcRoot, distBuildRoot);
+            continue;
+        }
+        if (COPY_EXTENSIONS.has(extension)) {
+            copyAsset(filePath, srcRoot, distBuildRoot);
+        }
     }
-    if (isTypeScriptSource(filePath)) {
-        await compileModule(filePath, srcRoot, distRoot);
-        continue;
+    if (existsSync(treeseedTemplateCatalogSourceRoot)) {
+        copyAssetTree(treeseedTemplateCatalogSourceRoot, resolve(distBuildRoot, 'treeseed', 'template-catalog'));
     }
-    if (COPY_EXTENSIONS.has(extension)) {
-        copyAsset(filePath, srcRoot, distRoot);
+    if (existsSync(treeseedServicesSourceRoot)) {
+        copyAssetTree(treeseedServicesSourceRoot, resolve(distBuildRoot, 'treeseed', 'services'));
     }
-}
-if (existsSync(treeseedTemplateCatalogSourceRoot)) {
-    copyAssetTree(treeseedTemplateCatalogSourceRoot, resolve(distRoot, 'treeseed', 'template-catalog'));
-}
-if (existsSync(treeseedServicesSourceRoot)) {
-    copyAssetTree(treeseedServicesSourceRoot, resolve(distRoot, 'treeseed', 'services'));
-}
-for (const filePath of walkFiles(scriptsRoot)) {
-    const extension = extname(filePath);
-    if (extension === '.ts' || extension === '.mjs') {
-        transpileScript(filePath);
+    for (const filePath of walkFiles(scriptsRoot)) {
+        const extension = extname(filePath);
+        if (extension === '.ts') {
+            transpileScript(filePath, distBuildRoot);
+        }
     }
-}
-emitDeclarations();
-for (const filePath of walkFiles(distRoot)) {
-    if (filePath.endsWith('.d.js')) {
-        rmSync(filePath, { force: true });
+    emitDeclarations(distBuildRoot);
+    rewriteDeclarations(distBuildRoot);
+    for (const filePath of walkFiles(distBuildRoot)) {
+        if (filePath.endsWith('.d.js')) {
+            rmSync(filePath, { force: true });
+        }
+    }
+    if (existsSync(resolve(packageRoot, 'README.md'))) {
+        copyFileSync(resolve(packageRoot, 'README.md'), resolve(distBuildRoot, '..', 'README.md'));
     }
+    publishDistBuild();
 }
-if (existsSync(resolve(packageRoot, 'README.md'))) {
-    copyFileSync(resolve(packageRoot, 'README.md'), resolve(distRoot, '..', 'README.md'));
+finally {
+    rmSync(distBuildRoot, { recursive: true, force: true });
+    releaseBuildLock();
 }

package/dist/scripts/check-build-warnings.js

@@ -1,62 +1,51 @@
 #!/usr/bin/env node
-
 import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import {
-	formatAllowedBuildWarnings,
-	scanBuildWarningText,
-} from '../operations/services/build-warning-policy.js';
-
-const args = process.argv.slice(2);
-const allowlisted = [];
-const files = [];
-let useDefaultPolicy = true;
-
-for (let index = 0; index < args.length; index += 1) {
-	const arg = args[index];
-	if (arg === '--no-default-policy') {
-		useDefaultPolicy = false;
-		continue;
-	}
-	if (arg === '--allow') {
-		const pattern = args[index + 1];
-		if (!pattern) {
-			throw new Error('Missing value for --allow.');
-		}
-		allowlisted.push(pattern);
-		index += 1;
-		continue;
-	}
-	files.push(arg);
+import { formatAllowedBuildWarnings, mergeAllowedBuildWarnings, scanBuildWarningText, } from '../operations/services/build-warning-policy.js';
+function parseArgs(argv) {
+    const files = [];
+    const allow = [];
+    let useDefaultPolicy = true;
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === '--allow') {
+            const pattern = argv[index + 1];
+            if (!pattern)
+                throw new Error('--allow requires a regular expression.');
+            allow.push(pattern);
+            index += 1;
+            continue;
+        }
+        if (arg === '--no-default-policy') {
+            useDefaultPolicy = false;
+            continue;
+        }
+        files.push(arg);
+    }
+    return { files, allow, useDefaultPolicy };
 }
-
-if (files.length === 0) {
-	throw new Error('Usage: node check-build-warnings.mjs <log-file> [<log-file> ...] [--allow <regex>] [--no-default-policy]');
+const args = parseArgs(process.argv.slice(2));
+if (args.files.length === 0) {
+    throw new Error('Usage: tsx scripts/check-build-warnings.ts <log-file> [<log-file> ...] [--allow <regex>] [--no-default-policy]');
 }
-
-const warningLines = [];
 const allowedWarnings = new Map();
-for (const file of files) {
-	const contents = readFileSync(resolve(process.cwd(), file), 'utf8');
-	const scan = scanBuildWarningText(contents, {
-		useDefaultPolicy,
-		allow: allowlisted,
-	});
-	for (const [label, count] of scan.allowedWarnings.entries()) {
-		allowedWarnings.set(label, (allowedWarnings.get(label) ?? 0) + count);
-	}
-	warningLines.push(...scan.unexpectedWarnings);
+const unexpectedWarnings = [];
+for (const file of args.files) {
+    const result = scanBuildWarningText(readFileSync(file, 'utf8'), {
+        allow: args.allow,
+        useDefaultPolicy: args.useDefaultPolicy,
+    });
+    mergeAllowedBuildWarnings(allowedWarnings, result.allowedWarnings);
+    unexpectedWarnings.push(...result.unexpectedWarnings);
 }
-
-if (warningLines.length > 0) {
-	console.error('Unexpected build warnings detected:');
-	for (const line of warningLines) {
-		console.error(`- ${line}`);
-	}
-	process.exit(1);
+const allowedLines = formatAllowedBuildWarnings(allowedWarnings);
+if (allowedLines.length > 0) {
+    console.log(allowedLines.join('\n'));
 }
-
-for (const line of formatAllowedBuildWarnings(allowedWarnings)) {
-	console.log(line);
+if (unexpectedWarnings.length > 0) {
+    console.error('Unexpected build warnings detected:');
+    for (const warning of unexpectedWarnings) {
+        console.error(`- ${warning}`);
+    }
+    process.exit(1);
 }
 console.log('No unexpected build warnings detected.');

package/dist/scripts/cleanup-markdown.js

@@ -314,7 +314,7 @@ function parseArgs(argv) {
     return args;
 }
 function printHelp() {
-    console.log(`Usage: node scripts/cleanup-markdown.mjs [--check|--write] [paths...]
+    console.log(`Usage: tsx scripts/cleanup-markdown.ts [--check|--write] [paths...]
 
 Normalizes Markdown/MDX files for public docs readability.
 

package/dist/scripts/cli-test-fixtures.js

@@ -3,46 +3,42 @@ import { spawnSync } from 'node:child_process';
 import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-
 const scriptsRoot = dirname(fileURLToPath(import.meta.url));
 const cliRoot = resolve(scriptsRoot, '..');
 const sharedFixtureRoot = resolve(cliRoot, '.fixtures', 'treeseed-fixtures', 'sites', 'working-site');
-
 export function makeWorkspaceRoot() {
-	const root = mkdtempSync(join(tmpdir(), 'treeseed-help-workspace-'));
-	writeFileSync(resolve(root, 'package.json'), JSON.stringify({
-		name: 'help-test',
-		private: true,
-		workspaces: ['packages/*'],
-	}, null, 2));
-	writeFileSync(resolve(root, 'treeseed.site.yaml'), `name: Help Test
+    const root = mkdtempSync(join(tmpdir(), 'treeseed-help-workspace-'));
+    writeFileSync(resolve(root, 'package.json'), JSON.stringify({
+        name: 'help-test',
+        private: true,
+        workspaces: ['packages/*'],
+    }, null, 2));
+    writeFileSync(resolve(root, 'treeseed.site.yaml'), `name: Help Test
 slug: help-test
 siteUrl: https://example.com
 contactEmail: hello@example.com
 cloudflare:
   accountId: account-123
 `, 'utf8');
-	return root;
+    return root;
 }
-
 export function makeTenantWorkspace(branch = 'staging') {
-	const root = makeWorkspaceRoot();
-	cpSync(sharedFixtureRoot, root, { recursive: true });
-	mkdirSync(resolve(root, 'packages', 'placeholder'), { recursive: true });
-	writeFileSync(resolve(root, 'packages', 'placeholder', 'package.json'), JSON.stringify({
-		name: '@test/placeholder',
-		version: '0.0.1',
-	}, null, 2));
-	spawnSync('git', ['init', '-b', branch], { cwd: root, stdio: 'ignore' });
-	spawnSync('git', ['config', 'user.name', 'Treeseed Test'], { cwd: root, stdio: 'ignore' });
-	spawnSync('git', ['config', 'user.email', 'treeseed@example.com'], { cwd: root, stdio: 'ignore' });
-	spawnSync('git', ['add', '-A'], { cwd: root, stdio: 'ignore' });
-	spawnSync('git', ['commit', '-m', 'init'], { cwd: root, stdio: 'ignore' });
-	return root;
+    const root = makeWorkspaceRoot();
+    cpSync(sharedFixtureRoot, root, { recursive: true });
+    mkdirSync(resolve(root, 'packages', 'placeholder'), { recursive: true });
+    writeFileSync(resolve(root, 'packages', 'placeholder', 'package.json'), JSON.stringify({
+        name: '@test/placeholder',
+        version: '0.0.1',
+    }, null, 2));
+    spawnSync('git', ['init', '-b', branch], { cwd: root, stdio: 'ignore' });
+    spawnSync('git', ['config', 'user.name', 'Treeseed Test'], { cwd: root, stdio: 'ignore' });
+    spawnSync('git', ['config', 'user.email', 'treeseed@example.com'], { cwd: root, stdio: 'ignore' });
+    spawnSync('git', ['add', '-A'], { cwd: root, stdio: 'ignore' });
+    spawnSync('git', ['commit', '-m', 'init'], { cwd: root, stdio: 'ignore' });
+    return root;
 }
-
 export function makeTenantRoot() {
-	const root = mkdtempSync(join(tmpdir(), 'treeseed-cli-test-'));
-	cpSync(sharedFixtureRoot, root, { recursive: true });
-	return root;
+    const root = mkdtempSync(join(tmpdir(), 'treeseed-cli-test-'));
+    cpSync(sharedFixtureRoot, root, { recursive: true });
+    return root;
 }

package/dist/scripts/deployment-readiness.js

@@ -0,0 +1,20 @@
+import { collectTreeseedDeploymentReadiness, formatTreeseedReadinessReport } from '../operations/services/deployment-readiness.js';
+function arg(name) {
+    const index = process.argv.indexOf(name);
+    return index >= 0 ? process.argv[index + 1] : null;
+}
+const environment = (arg('--environment') ?? 'staging');
+const strict = process.argv.includes('--strict');
+const report = collectTreeseedDeploymentReadiness({
+    tenantRoot: process.cwd(),
+    environment,
+});
+if (process.argv.includes('--json')) {
+    console.log(JSON.stringify(report, null, 2));
+}
+else {
+    console.log(formatTreeseedReadinessReport(report));
+}
+if (strict && !report.ok) {
+    process.exitCode = 1;
+}

package/dist/scripts/generate-treedx-openapi-types.js

@@ -0,0 +1,186 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parse, stringify } from 'yaml';
+const check = process.argv.includes('--check');
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const workspaceRoot = resolve(packageRoot, '../..');
+const workspaceOpenApiPath = resolve(workspaceRoot, 'docs/api/openapi.yaml');
+const packageOpenApiPath = resolve(packageRoot, 'docs/api/openapi.yaml');
+const openApiPath = existsSync(workspaceOpenApiPath) ? workspaceOpenApiPath : packageOpenApiPath;
+const workspaceOpenApiJsonPath = resolve(workspaceRoot, 'docs/api/openapi.json');
+const packageOpenApiJsonPath = resolve(packageRoot, 'docs/api/openapi.json');
+const outPath = resolve(packageRoot, 'src/treedx/generated/openapi-types.ts');
+const openApi = parse(readFileSync(openApiPath, 'utf8'));
+function refName(ref) {
+    return ref.split('/').pop() ?? ref;
+}
+function schemaRefType(ref) {
+    return `components['schemas']['${refName(ref)}']`;
+}
+function literal(value) {
+    return JSON.stringify(value);
+}
+function key(name) {
+    return /^[A-Za-z_$][\w$]*$/u.test(name) ? name : JSON.stringify(name);
+}
+function typeForSchema(schema) {
+    if (!schema || typeof schema !== 'object')
+        return 'unknown';
+    const s = schema;
+    if (typeof s.$ref === 'string')
+        return schemaRefType(s.$ref);
+    if ('const' in s)
+        return literal(s.const);
+    if (Array.isArray(s.enum))
+        return s.enum.map(literal).join(' | ') || 'never';
+    if (Array.isArray(s.oneOf))
+        return s.oneOf.map(typeForSchema).join(' | ') || 'unknown';
+    if (Array.isArray(s.anyOf))
+        return s.anyOf.map(typeForSchema).join(' | ') || 'unknown';
+    if (Array.isArray(s.allOf))
+        return s.allOf.map(typeForSchema).join(' & ') || 'unknown';
+    if (s.nullable === true)
+        return `${typeForSchema({ ...s, nullable: undefined })} | null`;
+    if (s.type === 'string')
+        return 'string';
+    if (s.type === 'integer' || s.type === 'number')
+        return 'number';
+    if (s.type === 'boolean')
+        return 'boolean';
+    if (s.type === 'null')
+        return 'null';
+    if (s.type === 'array')
+        return `${typeForSchema(s.items)}[]`;
+    if (s.type === 'object' || s.properties || s.additionalProperties !== undefined) {
+        const properties = (s.properties ?? {});
+        const required = new Set(Array.isArray(s.required) ? s.required.map(String) : []);
+        const parts = Object.entries(properties).map(([name, prop]) => {
+            const optional = required.has(name) ? '' : '?';
+            return `${key(name)}${optional}: ${typeForSchema(prop)};`;
+        });
+        if (s.additionalProperties === true) {
+            parts.push('[key: string]: unknown;');
+        }
+        else if (s.additionalProperties && typeof s.additionalProperties === 'object') {
+            parts.push(`[key: string]: ${typeForSchema(s.additionalProperties)};`);
+        }
+        return parts.length > 0 ? `{ ${parts.join(' ')} }` : 'Record<string, never>';
+    }
+    return 'unknown';
+}
+function parametersFor(operation, location) {
+    const params = Array.isArray(operation.parameters) ? operation.parameters : [];
+    const entries = params
+        .filter((param) => typeof param === 'object' && param !== null && param.in === location)
+        .map((param) => {
+        const name = String(param.name);
+        const optional = param.required === true ? '' : '?';
+        return `${key(name)}${optional}: ${typeForSchema(param.schema)};`;
+    });
+    return entries.length > 0 ? `{ ${entries.join(' ')} }` : 'never';
+}
+function requestBodyFor(operation) {
+    const body = operation.requestBody;
+    const content = body?.content ?? {};
+    const json = content['application/json']?.schema;
+    if (json)
+        return typeForSchema(json);
+    const octets = content['application/octet-stream']?.schema;
+    if (octets)
+        return 'ArrayBuffer | Uint8Array | Blob';
+    return 'never';
+}
+function responseFor(response) {
+    if (!response || typeof response !== 'object')
+        return 'unknown';
+    if (typeof response.$ref === 'string') {
+        const name = refName(response.$ref);
+        if (name === 'Error')
+            return "components['schemas']['TreeDxErrorEnvelope']";
+        if (name === 'Ok')
+            return "components['schemas']['TreeDxOkEnvelope']";
+    }
+    const r = response;
+    const content = r.content ?? {};
+    const json = content['application/json']?.schema;
+    if (json)
+        return typeForSchema(json);
+    const octets = content['application/octet-stream']?.schema;
+    if (octets)
+        return 'ArrayBuffer';
+    return 'unknown';
+}
+function operationType(operation) {
+    const responses = operation.responses ?? {};
+    const responseEntries = Object.entries(responses).map(([status, response]) => `${JSON.stringify(status)}: ${responseFor(response)};`);
+    return [
+        '{',
+        `parameters: { path: ${parametersFor(operation, 'path')}; query: ${parametersFor(operation, 'query')}; header: ${parametersFor(operation, 'header')}; };`,
+        `requestBody: ${requestBodyFor(operation)};`,
+        `responses: { ${responseEntries.join(' ')} };`,
+        '}',
+    ].join(' ');
+}
+const schemas = openApi.components?.schemas ?? {};
+const schemaLines = Object.entries(schemas)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([name, schema]) => `${key(name)}: ${typeForSchema(schema)};`);
+const operationEntries = [];
+const pathLines = [];
+for (const [path, methods] of Object.entries(openApi.paths ?? {}).sort(([a], [b]) => a.localeCompare(b))) {
+    const methodLines = [];
+    for (const [method, operation] of Object.entries(methods).sort(([a], [b]) => a.localeCompare(b))) {
+        if (!operation?.operationId)
+            continue;
+        operationEntries.push([operation.operationId, operation]);
+        methodLines.push(`${method}: operations['${operation.operationId}'];`);
+    }
+    pathLines.push(`${JSON.stringify(path)}: { ${methodLines.join(' ')} };`);
+}
+const operationLines = operationEntries
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([id, operation]) => `${key(id)}: ${operationType(operation)};`);
+const generated = `// Generated from docs/api/openapi.yaml. Do not edit by hand.
+
+export interface paths {
+${pathLines.map((line) => `\t${line}`).join('\n')}
+}
+
+export interface components {
+\tschemas: {
+${schemaLines.map((line) => `\t\t${line}`).join('\n')}
+\t};
+}
+
+export interface operations {
+${operationLines.map((line) => `\t${line}`).join('\n')}
+}
+`;
+const current = (() => {
+    try {
+        return readFileSync(outPath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+})();
+if (check && current !== generated) {
+    console.error(`${relative(process.cwd(), outPath)} is not up to date. Run npm run treedx:generate-types.`);
+    process.exit(1);
+}
+if (!check) {
+    mkdirSync(dirname(outPath), { recursive: true });
+    writeFileSync(outPath, generated, 'utf8');
+    for (const target of [workspaceOpenApiJsonPath, packageOpenApiJsonPath]) {
+        mkdirSync(dirname(target), { recursive: true });
+        writeFileSync(target, `${JSON.stringify(openApi, null, 2)}\n`, 'utf8');
+    }
+    if (openApiPath === workspaceOpenApiPath) {
+        mkdirSync(dirname(packageOpenApiPath), { recursive: true });
+        writeFileSync(packageOpenApiPath, stringify(openApi), 'utf8');
+    }
+    console.log(`Wrote ${relative(process.cwd(), outPath)}`);
+    console.log(`Wrote ${relative(process.cwd(), workspaceOpenApiJsonPath)}`);
+    console.log(`Wrote ${relative(process.cwd(), packageOpenApiJsonPath)}`);
+}