@treeseed/sdk 0.11.0 → 0.12.5

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/migrate-journey-csv-to-guarantees.js

@@ -0,0 +1,140 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { stringify as stringifyYaml } from 'yaml';
+import { normalizeTreeseedGuaranteeTaxonomy, slugifyTreeseedGuaranteeJourney, } from '../guarantees/index.js';
+function argValue(name) {
+    const index = process.argv.indexOf(name);
+    return index >= 0 ? process.argv[index + 1] : undefined;
+}
+function hasArg(name) {
+    return process.argv.includes(name);
+}
+function parseCsv(source) {
+    const rows = [];
+    let row = [];
+    let field = '';
+    let quoted = false;
+    for (let index = 0; index < source.length; index += 1) {
+        const char = source[index];
+        const next = source[index + 1];
+        if (quoted) {
+            if (char === '"' && next === '"') {
+                field += '"';
+                index += 1;
+            }
+            else if (char === '"')
+                quoted = false;
+            else
+                field += char;
+        }
+        else if (char === '"')
+            quoted = true;
+        else if (char === ',') {
+            row.push(field);
+            field = '';
+        }
+        else if (char === '\n') {
+            row.push(field.replace(/\r$/u, ''));
+            rows.push(row);
+            row = [];
+            field = '';
+        }
+        else
+            field += char;
+    }
+    if (field || row.length > 0) {
+        row.push(field.replace(/\r$/u, ''));
+        rows.push(row);
+    }
+    return rows.filter((entry) => entry.some(Boolean));
+}
+function ownerPackage(type, subtype) {
+    if (['marketplace', 'checkout', 'service', 'capacity-discovery', 'feedback', 'commons', 'public-profile'].includes(type))
+        return '@treeseed/market';
+    if (type === 'marketplace-seller')
+        return '@treeseed/admin';
+    if (type === 'host' && subtype === 'reconciliation')
+        return '@treeseed/api';
+    if (type === 'capacity' && ['assignment', 'usage', 'provider'].includes(subtype))
+        return '@treeseed/api';
+    if (type === 'project' && subtype === 'treedx')
+        return '@treeseed/api';
+    if (type === 'workday' && ['diagnostics', 'artifacts', 'decision'].includes(subtype))
+        return '@treeseed/api';
+    return '@treeseed/admin';
+}
+function ownerRoot(workspace, owner) {
+    return owner === '@treeseed/market' ? workspace : resolve(workspace, 'packages', owner.replace('@treeseed/', ''));
+}
+function guaranteeId(type, subtype, journey, index) {
+    return `guarantee.${type}.${subtype}.${slugifyTreeseedGuaranteeJourney(journey)}.${String(index).padStart(3, '0')}`;
+}
+const csv = argValue('--csv');
+const workspace = resolve(argValue('--workspace') ?? process.cwd());
+const writePlan = argValue('--write-plan');
+const write = hasArg('--write');
+if (!csv) {
+    console.error('Usage: node --import tsx packages/sdk/scripts/migrate-journey-csv-to-guarantees.ts --csv <path> [--workspace <root>] [--write-plan <path>] [--write]');
+    process.exit(1);
+}
+const rows = parseCsv(readFileSync(csv, 'utf8'));
+const header = rows[0] ?? [];
+const records = rows.slice(1).map((row) => Object.fromEntries(header.map((key, index) => [key, row[index] ?? ''])));
+const indexed = new Map(records.map((record) => [Number(record.Index), record]));
+const outputs = records.map((record) => {
+    const index = Number(record.Index);
+    const type = normalizeTreeseedGuaranteeTaxonomy(String(record.Type));
+    const subtype = normalizeTreeseedGuaranteeTaxonomy(String(record['Sub-Type']));
+    const journey = String(record.Journey);
+    const owner = ownerPackage(type, subtype);
+    const journeySlug = slugifyTreeseedGuaranteeJourney(journey);
+    const dependencies = String(record.Dependencies ?? '').split(/[;, ]+/u).filter(Boolean).map(Number);
+    const dependencyGuarantees = dependencies.map((dependency) => {
+        const dep = indexed.get(dependency);
+        if (!dep)
+            return null;
+        return guaranteeId(normalizeTreeseedGuaranteeTaxonomy(String(dep.Type)), normalizeTreeseedGuaranteeTaxonomy(String(dep['Sub-Type'])), String(dep.Journey), dependency);
+    }).filter(Boolean);
+    const packageRoot = ownerRoot(workspace, owner);
+    const guaranteePath = resolve(packageRoot, 'guarantees', type, subtype, `${journeySlug}.guarantee.yaml`);
+    const manifest = {
+        schemaVersion: 'treeseed.guarantee/v1',
+        id: guaranteeId(type, subtype, journey, index),
+        journeyIndex: index,
+        type,
+        subtype,
+        journey,
+        ownerPackage: owner,
+        summary: String(record.Notes || `Guarantee migrated from journey ${index}.`),
+        status: 'planned',
+        dependencies: { journeys: dependencies, guarantees: dependencyGuarantees },
+        actors: { allowed: ['owner'], forbidden: ['unauthorized_user'] },
+        devices: { required: ['desktop_chromium'] },
+        gates: ['core', 'release'],
+        preconditions: { fixtures: [] },
+        scene: { required: true, manifest: `./scenes/${journeySlug}.scene.yaml` },
+        api: { required: true, verifierRefs: [`todo.${type}.${subtype}.${journeySlug}.api`] },
+        evidence: { required: ['playwright_trace', 'api_verification_log'] },
+        notes: [String(record.Notes || '').trim()].filter(Boolean),
+    };
+    return { index, type, subtype, journey, ownerPackage: owner, guaranteePath, manifest };
+});
+const plan = {
+    schemaVersion: 'treeseed.guarantee-migration-plan/v1',
+    sourceCsv: resolve(csv),
+    workspace,
+    count: outputs.length,
+    outputs: outputs.map(({ manifest, ...entry }) => ({ ...entry, id: manifest.id })),
+};
+if (writePlan) {
+    const target = resolve(writePlan);
+    mkdirSync(dirname(target), { recursive: true });
+    writeFileSync(target, `${JSON.stringify(plan, null, 2)}\n`);
+}
+if (write) {
+    for (const output of outputs) {
+        mkdirSync(dirname(output.guaranteePath), { recursive: true });
+        writeFileSync(output.guaranteePath, stringifyYaml(output.manifest, { lineWidth: 0 }));
+    }
+}
+console.log(JSON.stringify(plan, null, 2));

package/dist/scripts/package-tools.js

@@ -43,7 +43,7 @@ export function packageScriptPath(scriptName) {
     if (extname(scriptName)) {
         return resolve(packageScriptRoot, scriptName);
     }
-    for (const extension of ['.js', '.ts', '.mjs']) {
+    for (const extension of ['.ts', '.js']) {
         const candidate = resolve(packageScriptRoot, `${scriptName}${extension}`);
         if (existsSync(candidate)) {
             return candidate;
@@ -62,6 +62,17 @@ export function runNodeBinary(binPath, args, options = {}) {
     }
 }
 export function runNodeScript(scriptPath, args = [], options = {}) {
+    if (scriptPath.endsWith('.ts')) {
+        const result = spawnSync('tsx', [scriptPath, ...args], {
+            stdio: options.stdio ?? 'inherit',
+            cwd: options.cwd ?? process.cwd(),
+            env: { ...process.env, ...(options.env ?? {}) },
+        });
+        if (result.status !== 0) {
+            process.exit(result.status ?? 1);
+        }
+        return;
+    }
     return runNodeBinary(scriptPath, args, options);
 }
 export function spawnNodeBinary(binPath, args, options = {}) {

package/dist/scripts/prepare.js

@@ -1,14 +1,10 @@
 #!/usr/bin/env node
-
 import { spawnSync } from 'node:child_process';
-
 if (process.env.TREESEED_SKIP_PACKAGE_PREPARE === '1') {
-	process.exit(0);
+    process.exit(0);
 }
-
 const result = spawnSync('npm', ['run', 'build:dist'], {
-	stdio: 'inherit',
-	shell: process.platform === 'win32',
+    stdio: 'inherit',
+    shell: process.platform === 'win32',
 });
-
 process.exit(result.status ?? 1);

package/dist/scripts/release-verify.js

@@ -1,10 +1,10 @@
 import { existsSync, mkdtempSync, readFileSync, readdirSync } from 'node:fs';
-import { basename, extname, join, resolve } from 'node:path';
+import { extname, join, resolve } from 'node:path';
 import { tmpdir } from 'node:os';
 import { spawnSync } from 'node:child_process';
 import { packageRoot } from './package-tools.js';
 const npmCacheDir = mkdtempSync(join(tmpdir(), 'treeseed-sdk-npm-cache-'));
-const textExtensions = new Set(['.js', '.ts', '.mjs', '.cjs', '.d.js', '.json', '.md']);
+const textExtensions = new Set(['.js', '.ts', '.d.js', '.json', '.md']);
 const forbiddenPatterns = [
     /['"`]workspace:[^'"`\n]+['"`]/,
     /['"`](?:\.\.\/|\.\/)[^'"`\n]*src\/[^'"`\n]*\.(?:[cm]?js|ts|tsx|json|astro|css)['"`]/,
@@ -89,9 +89,6 @@ function assertCleanDistArtifacts() {
         if (filePath.endsWith('.d.js')) {
             throw new Error(`Unexpected generated declaration runtime artifact: ${filePath}`);
         }
-        if (basename(filePath).startsWith('.ts-run-')) {
-            throw new Error(`Unexpected temporary runtime artifact: ${filePath}`);
-        }
         if (filePath.includes('/dist/scripts/') && filePath.endsWith('.d.js')) {
             throw new Error(`Unexpected script declaration artifact: ${filePath}`);
         }

package/dist/scripts/run-fixture-astro-command.js

@@ -2,7 +2,7 @@ import { spawnSync } from 'node:child_process';
 import { corePackageRoot, fixtureRoot } from '../operations/services/runtime-paths.js';
 const [command, ...rest] = process.argv.slice(2);
 if (!command) {
-    console.error('Usage: node ./scripts/run-fixture-astro-command.mjs <check|build|preview|dev> [...args]');
+    console.error('Usage: tsx ./scripts/run-fixture-astro-command.ts <check|build|preview|dev> [...args]');
     process.exit(1);
 }
 const result = spawnSync('npx', ['astro', command, '--root', fixtureRoot, ...rest], {