@treeseed/sdk 0.10.28 → 0.12.4

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/operations-runner-smoke.js

@@ -0,0 +1,16 @@
+import { runTreeseedOperationsRunnerSmoke } from '../operations/services/operations-runner-smoke.js';
+function arg(name) {
+    const index = process.argv.indexOf(name);
+    return index >= 0 ? process.argv[index + 1] : null;
+}
+const environment = (arg('--environment') ?? 'staging') === 'prod' ? 'prod' : 'staging';
+const report = await runTreeseedOperationsRunnerSmoke({
+    tenantRoot: process.cwd(),
+    environment,
+    baseUrl: arg('--base-url'),
+    timeoutMs: arg('--timeout-ms') ? Number(arg('--timeout-ms')) : undefined,
+});
+console.log(JSON.stringify(report, null, 2));
+if (!report.ok) {
+    process.exitCode = 1;
+}

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}`);
         }
@@ -101,5 +98,8 @@ assertNoLocalDependencyLinks();
 run('npm', ['run', 'lint']);
 scanDirectory(resolve(packageRoot, 'dist'));
 assertCleanDistArtifacts();
-run('npm', ['run', 'test:unit']);
+run('npm', ['run', 'test:release']);
+if (process.env.TREESEED_SDK_VERIFY_WORKFLOW_LIFECYCLE === '1') {
+    run('npm', ['run', 'test:workflow:lifecycle']);
+}
 run('npm', ['run', 'test:smoke']);

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], {

package/dist/scripts/template-catalog.test.js

@@ -4,97 +4,83 @@ import { mkdtempSync, mkdirSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { listTemplateProducts, resolveTemplateDefinition } from '../dist/scripts/template-registry-lib.js';
-
 function makeMachineConfigRoot(endpoint) {
-	const root = mkdtempSync(join(tmpdir(), 'treeseed-cli-template-catalog-'));
-	const configDir = resolve(root, '.treeseed', 'config');
-	mkdirSync(configDir, { recursive: true });
-	writeFileSync(resolve(configDir, 'machine.yaml'), [
-		'version: 1',
-		'settings:',
-		'  templates:',
-		`    catalogEndpoint: ${endpoint}`,
-		'',
-	].join('\n'), 'utf8');
-	return root;
+    const root = mkdtempSync(join(tmpdir(), 'treeseed-cli-template-catalog-'));
+    const configDir = resolve(root, '.treeseed', 'config');
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(resolve(configDir, 'machine.yaml'), [
+        'version: 1',
+        'settings:',
+        '  templates:',
+        `    catalogEndpoint: ${endpoint}`,
+        '',
+    ].join('\n'), 'utf8');
+    return root;
 }
-
 function writeCatalogFixture(root, fileName, items) {
-	const fixturePath = resolve(root, fileName);
-	writeFileSync(fixturePath, JSON.stringify({ items }, null, 2), 'utf8');
-	return fixturePath;
+    const fixturePath = resolve(root, fileName);
+    writeFileSync(fixturePath, JSON.stringify({ items }, null, 2), 'utf8');
+    return fixturePath;
 }
-
 function writeCatalogCache(root, endpoint, items) {
-	const cacheDir = resolve(root, '.treeseed', 'cache');
-	mkdirSync(cacheDir, { recursive: true });
-	writeFileSync(resolve(cacheDir, 'template-catalog.json'), JSON.stringify({
-		endpoint,
-		fetchedAt: '2026-04-08T00:00:00.000Z',
-		items,
-	}, null, 2), 'utf8');
+    const cacheDir = resolve(root, '.treeseed', 'cache');
+    mkdirSync(cacheDir, { recursive: true });
+    writeFileSync(resolve(cacheDir, 'template-catalog.json'), JSON.stringify({
+        endpoint,
+        fetchedAt: '2026-04-08T00:00:00.000Z',
+        items,
+    }, null, 2), 'utf8');
 }
-
 const starterTemplate = {
-	id: 'fixture-template',
-	displayName: 'Fixture Template',
-	description: 'Starter',
-	summary: 'Starter summary',
-	status: 'live',
-	category: 'starter',
-	publisher: {
-		id: 'treeseed',
-		name: 'TreeSeed',
-	},
-	templateVersion: '1.0.0',
-	templateApiVersion: 1,
-	minCliVersion: '0.1.1',
-	minCoreVersion: '0.1.2',
-	fulfillment: {
-		source: {
-			repoUrl: 'https://example.com/repo.git',
-			directory: 'templates/fixture-template',
-			ref: 'main',
-		},
-		hooksPolicy: 'builtin_only',
-		supportsReconcile: true,
-	},
+    id: 'fixture-template',
+    displayName: 'Fixture Template',
+    description: 'Starter',
+    summary: 'Starter summary',
+    status: 'live',
+    category: 'starter',
+    publisher: {
+        id: 'treeseed',
+        name: 'TreeSeed',
+    },
+    templateVersion: '1.0.0',
+    templateApiVersion: 1,
+    minCliVersion: '0.1.1',
+    minCoreVersion: '0.1.2',
+    fulfillment: {
+        source: {
+            repoUrl: 'https://example.com/repo.git',
+            directory: 'templates/fixture-template',
+            ref: 'main',
+        },
+        hooksPolicy: 'builtin_only',
+        supportsReconcile: true,
+    },
 };
-
 test('template registry reads the remote catalog from a configured file endpoint and falls back to cache', async () => {
-	const root = mkdtempSync(join(tmpdir(), 'treeseed-cli-template-catalog-fixture-'));
-	const fixturePath = writeCatalogFixture(root, 'catalog.json', [starterTemplate]);
-	const fallbackEndpoint = 'https://127.0.0.1:9/search/templates';
-	const cwd = makeMachineConfigRoot(`file:${fixturePath}`);
-
-	const remoteProducts = await listTemplateProducts({ cwd, env: {} });
-	assert.equal(remoteProducts.length, 1);
-	assert.equal(remoteProducts[0]?.id, 'fixture-template');
-
-	writeCatalogCache(cwd, fallbackEndpoint, [starterTemplate]);
-
-	const warnings = [];
-	const cachedProducts = await listTemplateProducts({
-		cwd,
-		env: {
-			TREESEED_TEMPLATE_CATALOG_URL: fallbackEndpoint,
-		},
-		writeWarning: (message) => warnings.push(message),
-	});
-
-	assert.equal(cachedProducts.length, 1);
-	assert.equal(cachedProducts[0]?.id, 'fixture-template');
-	assert.equal(warnings.length, 1);
-	assert.match(warnings[0], /Using cached template catalog/);
+    const root = mkdtempSync(join(tmpdir(), 'treeseed-cli-template-catalog-fixture-'));
+    const fixturePath = writeCatalogFixture(root, 'catalog.json', [starterTemplate]);
+    const fallbackEndpoint = 'https://127.0.0.1:9/search/templates';
+    const cwd = makeMachineConfigRoot(`file:${fixturePath}`);
+    const remoteProducts = await listTemplateProducts({ cwd, env: {} });
+    assert.equal(remoteProducts.length, 1);
+    assert.equal(remoteProducts[0]?.id, 'fixture-template');
+    writeCatalogCache(cwd, fallbackEndpoint, [starterTemplate]);
+    const warnings = [];
+    const cachedProducts = await listTemplateProducts({
+        cwd,
+        env: {
+            TREESEED_TEMPLATE_CATALOG_URL: fallbackEndpoint,
+        },
+        writeWarning: (message) => warnings.push(message),
+    });
+    assert.equal(cachedProducts.length, 1);
+    assert.equal(cachedProducts[0]?.id, 'fixture-template');
+    assert.equal(warnings.length, 1);
+    assert.match(warnings[0], /Using cached template catalog/);
 });
-
 test('template definition resolution rejects templates missing from the remote catalog', async () => {
-	const root = mkdtempSync(join(tmpdir(), 'treeseed-cli-template-catalog-empty-'));
-	const fixturePath = writeCatalogFixture(root, 'empty.json', []);
-	const cwd = makeMachineConfigRoot(`file:${fixturePath}`);
-
-	await assert.rejects(
-		() => resolveTemplateDefinition('fixture-template', { cwd, env: {} }),
-		/Unable to resolve remote template product "fixture-template"\./,
-	);
+    const root = mkdtempSync(join(tmpdir(), 'treeseed-cli-template-catalog-empty-'));
+    const fixturePath = writeCatalogFixture(root, 'empty.json', []);
+    const cwd = makeMachineConfigRoot(`file:${fixturePath}`);
+    await assert.rejects(() => resolveTemplateDefinition('fixture-template', { cwd, env: {} }), /Unable to resolve remote template product "fixture-template"\./);
 });

package/dist/scripts/tenant-dev.js

@@ -2,7 +2,6 @@ import { spawnSync } from 'node:child_process';
 import { corePackageRoot, packageScriptPath, spawnNodeBinary, resolveWranglerBin } from '../operations/services/runtime-tools.js';
 import { applyTreeseedEnvironmentToProcess, assertTreeseedCommandEnvironment } from '../operations/services/config-runtime.js';
 import { ensureGeneratedWranglerConfig } from '../operations/services/deploy.js';
-import { loadTreeseedDeployConfig } from '../platform/deploy-config.js';
 import { createTenantWatchEntries, isEditablePackageWorkspace, startPollingWatch, stopManagedProcess, writeDevReloadStamp, workspaceSdkRoot, } from '../operations/services/watch-dev.js';
 const tenantRoot = process.cwd();
 const cliArgs = process.argv.slice(2);
@@ -12,12 +11,6 @@ let wranglerChild = null;
 let stopWatching = null;
 let isStoppingForRebuild = false;
 let shuttingDown = false;
-function shouldEnsureMailpit() {
-    if (process.env.TREESEED_DEV_FORCE_MAILPIT === '1') {
-        return true;
-    }
-    return loadTreeseedDeployConfig().smtp?.enabled === true;
-}
 function runStep(command, args, { cwd = tenantRoot, env = {}, fatal = true } = {}) {
     const result = spawnSync(command, args, {
         stdio: 'inherit',
@@ -63,9 +56,6 @@ function runTenantBuildCycle({ includePackageBuild = false, includeSdkBuild = fa
         ['aggregate-book', []],
         ['tenant-d1-migrate-local', []],
     ];
-    if (shouldEnsureMailpit()) {
-        buildScripts.splice(2, 0, ['ensure-mailpit', []]);
-    }
     for (const [scriptName, args] of buildScripts) {
         const ok = runNodeScript(packageScriptPath(scriptName), args, { fatal });
         if (!ok) {

package/dist/scripts/tenant-workflow-action.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 import { pathToFileURL } from 'node:url';
-import { resolveScope, runProjectPlatformAction, } from '../operations/services/project-platform.js';
 const tenantRoot = process.cwd();
+function writeStatus(message) {
+    process.stderr.write(`[tenant-workflow-action] ${message}\n`);
+}
 function parseArgs(argv) {
     const parsed = {
         action: 'deploy_web',
@@ -65,17 +67,24 @@ async function main() {
     const options = parseArgs(process.argv.slice(2));
     process.env.TREESEED_WORKFLOW_ACTION = options.action;
     process.env.TREESEED_WORKFLOW_PLANE ||= 'web';
+    writeStatus(`start action=${options.action} environment=${options.environment ?? '(auto)'}`);
+    writeStatus('loading project platform module...');
+    const { resolveScope, runProjectPlatformAction } = await import('../operations/services/project-platform.js');
+    writeStatus('project platform module loaded.');
     const scope = resolveScope(options.environment);
+    writeStatus(`resolved scope=${scope}; running action...`);
     const result = await runProjectPlatformAction(options.action, {
         tenantRoot,
         scope,
         projectId: options.projectId ?? process.env.TREESEED_PROJECT_ID ?? null,
         previewId: options.previewId,
         dryRun: options.dryRun,
+        write: (line) => writeStatus(line),
     });
     if (result !== undefined) {
         process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
     }
+    writeStatus('complete.');
 }
 function isCliEntrypoint() {
     if (!process.argv[1]) {

package/dist/scripts/test-cloudflare-local.js

@@ -107,7 +107,7 @@ async function submitSubscribeForm({ formToken, sessionId, cookieHeader }, email
     });
 }
 async function querySubscribers() {
-    const query = `SELECT lookup_key AS email, status, json_extract(payload_json, '$.source') AS source FROM runtime_records WHERE record_type = 'subscription' AND lookup_key = '${TEST_EMAIL}'`;
+    const query = `SELECT email, created_at FROM subscribers WHERE email = '${TEST_EMAIL}'`;
     const child = spawnProcess('wrangler', [
         'd1',
         'execute',

package/dist/scripts/test-scaffold.js

@@ -173,7 +173,6 @@ function linkTreeseedBins(siteRoot) {
     for (const [name, relativeTarget] of [
         ['treeseed', '../@treeseed/cli/dist/cli/main.js'],
         ['treeseed-agents', '../@treeseed/agent/dist/agents/cli.js'],
-        ['treeseed-agent-api', '../@treeseed/agent/dist/scripts/treeseed-agent-api.js'],
         ['treeseed-agent-service', '../@treeseed/agent/dist/scripts/treeseed-agent-service.js'],
     ]) {
         symlinkSync(relativeTarget, resolve(binRoot, name));

package/dist/scripts/test-smoke.js

@@ -123,9 +123,9 @@ try {
         private: true,
         type: 'module',
         scripts: {
-            'verify:direct': 'node --input-type=module -e "console.log(\'treeseed-sdk-smoke-verify\')"',
-            'verify:local': 'node --input-type=module -e "process.env.TREESEED_VERIFY_DRIVER=\'direct\'; console.log(\'treeseed-sdk-smoke-verify-local\')"',
-            'verify:action': 'node --input-type=module -e "process.env.TREESEED_VERIFY_DRIVER=\'act\'; console.log(\'treeseed-sdk-smoke-verify-action\')"',
+            'verify:direct': 'tsx -e "console.log(\'treeseed-sdk-smoke-verify\')"',
+            'verify:local': 'tsx -e "process.env.TREESEED_VERIFY_DRIVER=\'direct\'; console.log(\'treeseed-sdk-smoke-verify-local\')"',
+            'verify:action': 'tsx -e "process.env.TREESEED_VERIFY_DRIVER=\'act\'; console.log(\'treeseed-sdk-smoke-verify-action\')"',
         },
     }, null, 2)}\n`, 'utf8');
     run(process.execPath, ['--input-type=module', '-e', 'await import("@treeseed/sdk/verification");'], installRoot);

package/dist/scripts/treeseed-build-dist.js

@@ -1,5 +1,5 @@
 import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, chmodSync } from 'node:fs';
-import { basename, dirname, extname, join, relative, resolve } from 'node:path';
+import { dirname, extname, join, relative, resolve } from 'node:path';
 import { build } from 'esbuild';
 import ts from 'typescript';
 import { packageRoot } from './package-tools.js';
@@ -44,7 +44,7 @@ function isTypeScriptSource(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],
@@ -71,12 +71,9 @@ function copyAssetTree(sourceRoot, outputRoot) {
     }
 }
 function transpileScript(filePath) {
-    if (basename(filePath).startsWith('.ts-run-')) {
-        return;
-    }
     const source = readFileSync(filePath, 'utf8');
     const relativePath = relative(scriptsRoot, filePath);
-    const outputFile = resolve(distRoot, 'scripts', relativePath.replace(/\.(mjs|ts)$/u, '.js'));
+    const outputFile = resolve(distRoot, 'scripts', relativePath.replace(/\.ts$/u, '.js'));
     const transformed = extname(filePath) === '.ts'
         ? ts.transpileModule(source, {
             compilerOptions: { module: ts.ModuleKind.ESNext, target: ts.ScriptTarget.ES2022 },
@@ -125,7 +122,7 @@ if (existsSync(templateCatalogSourceRoot)) {
 }
 for (const filePath of walkFiles(scriptsRoot)) {
     const extension = extname(filePath);
-    if (extension === '.ts' || extension === '.mjs')
+    if (extension === '.ts')
         transpileScript(filePath);
 }
 emitDeclarations();

package/dist/scripts/treeseed-release-verify.js

@@ -4,7 +4,7 @@ import { tmpdir } from 'node:os';
 import { dirname, extname, join, resolve } from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { corePackageRoot, packageRoot, sdkPackageRoot } from '../operations/services/runtime-tools.js';
-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)['"`]/,

package/dist/scripts/verify-driver.js

@@ -1,36 +1,45 @@
 #!/usr/bin/env node
-
 import { existsSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import { dirname, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
 import { fileURLToPath } from 'node:url';
-
 const scriptRoot = dirname(fileURLToPath(import.meta.url));
 const packageRoot = resolve(scriptRoot, '..');
-const sourceRunner = resolve(packageRoot, 'scripts', 'run-ts.mjs');
 const sourceEntry = resolve(packageRoot, 'src', 'verification.ts');
 const publishedEntry = resolve(packageRoot, 'dist', 'verification.js');
 const entrypointCheckOnly = process.env.TREESEED_VERIFY_ENTRYPOINT_CHECK === 'true';
-
-if (existsSync(sourceRunner) && existsSync(sourceEntry)) {
-	if (entrypointCheckOnly) {
-		process.exit(0);
-	}
-	const result = spawnSync(process.execPath, [sourceRunner, sourceEntry], {
-		cwd: process.cwd(),
-		env: process.env,
-		stdio: 'inherit',
-	});
-	process.exit(result.status ?? 1);
+function withShortTempEnv() {
+    if (process.platform === 'win32') {
+        return process.env;
+    }
+    const env = { ...process.env };
+    const shortTemp = tmpdir();
+    for (const key of ['TMPDIR', 'TMP', 'TEMP']) {
+        const value = env[key];
+        if (value && value.length > shortTemp.length) {
+            env[key] = shortTemp;
+        }
+    }
+    return env;
+}
+if (existsSync(sourceEntry)) {
+    if (entrypointCheckOnly) {
+        process.exit(0);
+    }
+    const result = spawnSync('tsx', [sourceEntry], {
+        cwd: process.cwd(),
+        env: withShortTempEnv(),
+        stdio: 'inherit',
+    });
+    process.exit(result.status ?? 1);
 }
-
 if (existsSync(publishedEntry)) {
-	if (entrypointCheckOnly) {
-		process.exit(0);
-	}
-	const { runTreeseedVerifyDriver } = await import('../dist/verification.js');
-	process.exit(runTreeseedVerifyDriver({ packageRoot: process.cwd() }));
+    if (entrypointCheckOnly) {
+        process.exit(0);
+    }
+    const { runTreeseedVerifyDriver } = await import('../dist/verification.js');
+    process.exit(runTreeseedVerifyDriver({ packageRoot: process.cwd() }));
 }
-
 process.stderr.write(`Unable to locate Treeseed SDK verification runtime from ${packageRoot}.\n`);
 process.exit(1);