@treeseed/sdk 0.1.1 → 0.3.0

package/dist/scripts/test-scaffold.js

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { agentPackageRoot, corePackageRoot, packageRoot, packageScriptPath, sdkPackageRoot } from '../operations/services/runtime-tools.js';
+import { listTemplateProducts, validateTemplateProduct } from '../operations/services/template-registry.js';
+const npmCacheDir = process.env.TREESEED_SCAFFOLD_NPM_CACHE_DIR
+    ? resolve(process.env.TREESEED_SCAFFOLD_NPM_CACHE_DIR)
+    : resolve(tmpdir(), 'treeseed-npm-cache');
+const packageJson = JSON.parse(readFileSync(resolve(corePackageRoot, 'package.json'), 'utf8'));
+const sdkPackageJson = JSON.parse(readFileSync(resolve(sdkPackageRoot, 'package.json'), 'utf8'));
+const cliPackageJson = JSON.parse(readFileSync(resolve(packageRoot, 'package.json'), 'utf8'));
+const agentPackageJson = JSON.parse(readFileSync(resolve(agentPackageRoot, 'package.json'), 'utf8'));
+const workspaceTarballs = (() => {
+    try {
+        return JSON.parse(process.env.TREESEED_WORKSPACE_TARBALLS ?? '{}');
+    }
+    catch {
+        return {};
+    }
+})();
+const externalCoreTarball = process.env.TREESEED_SCAFFOLD_CORE_TARBALL
+    ? resolve(process.env.TREESEED_SCAFFOLD_CORE_TARBALL)
+    : typeof workspaceTarballs['@treeseed/core'] === 'string'
+        ? resolve(workspaceTarballs['@treeseed/core'])
+        : null;
+const externalSdkTarball = process.env.TREESEED_SCAFFOLD_SDK_TARBALL
+    ? resolve(process.env.TREESEED_SCAFFOLD_SDK_TARBALL)
+    : typeof workspaceTarballs['@treeseed/sdk'] === 'string'
+        ? resolve(workspaceTarballs['@treeseed/sdk'])
+        : null;
+const externalCliTarball = process.env.TREESEED_SCAFFOLD_CLI_TARBALL
+    ? resolve(process.env.TREESEED_SCAFFOLD_CLI_TARBALL)
+    : typeof workspaceTarballs['@treeseed/cli'] === 'string'
+        ? resolve(workspaceTarballs['@treeseed/cli'])
+        : null;
+const externalAgentTarball = process.env.TREESEED_SCAFFOLD_AGENT_TARBALL
+    ? resolve(process.env.TREESEED_SCAFFOLD_AGENT_TARBALL)
+    : typeof workspaceTarballs['@treeseed/agent'] === 'string'
+        ? resolve(workspaceTarballs['@treeseed/agent'])
+        : null;
+const reusesExternalTarballs = Boolean(externalCoreTarball || externalSdkTarball || externalCliTarball || externalAgentTarball);
+const scaffoldChecks = new Set((process.env.TREESEED_SCAFFOLD_CHECKS ?? 'build,deploy')
+    .split(',')
+    .map((value) => value.trim())
+    .filter(Boolean));
+const timings = [];
+const resetScaffoldCache = process.env.TREESEED_SCAFFOLD_RESET_CACHE === '1';
+const scaffoldTempRoot = resolve(process.env.TREESEED_SCAFFOLD_TEMP_ROOT ?? resolve(packageRoot, '.local', 'tmp'));
+mkdirSync(scaffoldTempRoot, { recursive: true });
+function logStep(message) {
+    console.log(`[treeseed:test-scaffold] ${message}`);
+}
+function withTiming(label, action) {
+    const startedAt = Date.now();
+    logStep(`${label} started`);
+    try {
+        const result = action();
+        if (result && typeof result.then === 'function') {
+            return result.then((resolved) => {
+                const durationMs = Date.now() - startedAt;
+                timings.push({ label, durationMs, status: 'completed' });
+                logStep(`${label} completed in ${(durationMs / 1000).toFixed(1)}s`);
+                return resolved;
+            }).catch((error) => {
+                const durationMs = Date.now() - startedAt;
+                timings.push({ label, durationMs, status: 'failed' });
+                logStep(`${label} failed in ${(durationMs / 1000).toFixed(1)}s`);
+                throw error;
+            });
+        }
+        const durationMs = Date.now() - startedAt;
+        timings.push({ label, durationMs, status: 'completed' });
+        logStep(`${label} completed in ${(durationMs / 1000).toFixed(1)}s`);
+        return result;
+    }
+    catch (error) {
+        const durationMs = Date.now() - startedAt;
+        timings.push({ label, durationMs, status: 'failed' });
+        logStep(`${label} failed in ${(durationMs / 1000).toFixed(1)}s`);
+        throw error;
+    }
+}
+function printSummary() {
+    if (timings.length === 0) {
+        return;
+    }
+    console.log('[treeseed:test-scaffold] Stage summary');
+    for (const entry of timings) {
+        console.log(`[treeseed:test-scaffold] ${entry.status === 'completed' ? 'ok  ' : 'fail'} ${entry.label} (${(entry.durationMs / 1000).toFixed(1)}s)`);
+    }
+}
+function resetNpmCache() {
+    rmSync(npmCacheDir, { recursive: true, force: true });
+}
+function runStep(command, args, { cwd = packageRoot, env = {}, capture = false } = {}) {
+    const result = spawnSync(command, args, {
+        cwd,
+        env: { ...process.env, ...env },
+        stdio: capture ? 'pipe' : 'inherit',
+        encoding: 'utf8',
+    });
+    if (result.status !== 0) {
+        const message = capture ? (result.stderr?.trim() || result.stdout?.trim() || `${command} ${args.join(' ')} failed`) : `${command} ${args.join(' ')} failed`;
+        throw new Error(message);
+    }
+    return result;
+}
+function createTempSiteRoot() {
+    return mkdtempSync(join(scaffoldTempRoot, 'treeseed-scaffold-'));
+}
+function rewriteScaffoldDependency(siteRoot, tarballPath, cliTarballPath) {
+    const packageJsonPath = resolve(siteRoot, 'package.json');
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+    packageJson.dependencies = packageJson.dependencies ?? {};
+    packageJson.dependencies['@treeseed/core'] = tarballPath;
+    packageJson.dependencies['@treeseed/cli'] = cliTarballPath;
+    writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, 'utf8');
+}
+function installManualPackageTarball(siteRoot, tarballPath, packageName) {
+    const extractRoot = mkdtempSync(join(scaffoldTempRoot, 'treeseed-scaffold-package-'));
+    try {
+        runStep('tar', ['-xzf', tarballPath, '-C', extractRoot]);
+        const scopeRoot = resolve(siteRoot, 'node_modules', '@treeseed');
+        mkdirSync(scopeRoot, { recursive: true });
+        cpSync(resolve(extractRoot, 'package'), resolve(scopeRoot, packageName.split('/')[1]), { recursive: true });
+    }
+    finally {
+        rmSync(extractRoot, { recursive: true, force: true });
+    }
+}
+function linkWorkspacePackage(siteRoot, packageName, sourceRoot) {
+    const scopeRoot = resolve(siteRoot, 'node_modules', '@treeseed');
+    mkdirSync(scopeRoot, { recursive: true });
+    symlinkSync(sourceRoot, resolve(scopeRoot, packageName.split('/')[1]), 'dir');
+}
+function resolveSharedNodeModulesRoot() {
+    let current = packageRoot;
+    while (true) {
+        const candidate = resolve(current, 'node_modules');
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+        const parent = resolve(current, '..');
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    throw new Error(`Unable to locate a shared node_modules directory for ${packageRoot}.`);
+}
+function mirrorSharedNodeModules(siteRoot) {
+    const sharedNodeModules = resolveSharedNodeModulesRoot();
+    for (const entry of readdirSync(sharedNodeModules, { withFileTypes: true })) {
+        if (entry.name === '.bin' || entry.name === '@treeseed' || entry.name === '@astrojs') {
+            continue;
+        }
+        const sourcePath = resolve(sharedNodeModules, entry.name);
+        const targetPath = resolve(siteRoot, 'node_modules', entry.name);
+        mkdirSync(dirname(targetPath), { recursive: true });
+        if (entry.name === 'astro') {
+            cpSync(sourcePath, targetPath, { recursive: true });
+            continue;
+        }
+        symlinkSync(sourcePath, targetPath, 'dir');
+    }
+    const sharedAstroScope = resolve(sharedNodeModules, '@astrojs');
+    const targetAstroScope = resolve(siteRoot, 'node_modules', '@astrojs');
+    mkdirSync(targetAstroScope, { recursive: true });
+    for (const packageName of ['cloudflare', 'mdx', 'sitemap', 'starlight']) {
+        cpSync(resolve(sharedAstroScope, packageName), resolve(targetAstroScope, packageName), { recursive: true });
+    }
+}
+function linkTreeseedBins(siteRoot) {
+    const binRoot = resolve(siteRoot, 'node_modules', '.bin');
+    mkdirSync(binRoot, { recursive: true });
+    for (const [name, relativeTarget] of [
+        ['treeseed', '../@treeseed/cli/dist/cli/main.js'],
+        ['treeseed-agents', '../@treeseed/agent/dist/scripts/treeseed-agents.js'],
+    ]) {
+        symlinkSync(relativeTarget, resolve(binRoot, name));
+    }
+}
+function createTarball(root, pkg) {
+    return withTiming(`${pkg.name} build+pack`, () => {
+        if (typeof pkg.scripts?.['build:dist'] === 'string') {
+            runStep('npm', ['run', 'build:dist'], { cwd: root });
+        }
+        const output = runStep('npm', ['pack', '--silent', '--ignore-scripts', '--cache', npmCacheDir], {
+            cwd: root,
+            capture: true,
+            env: {
+                npm_config_cache: npmCacheDir,
+                NPM_CONFIG_CACHE: npmCacheDir,
+            },
+        });
+        const filename = output.stdout
+            .split('\n')
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .at(-1)
+            || `${pkg.name.replace(/^@/, '').replaceAll('/', '-')}-${pkg.version}.tgz`;
+        return resolve(root, filename);
+    });
+}
+async function scaffoldSite(siteRoot) {
+    for (const definition of await listTemplateProducts({ writeWarning: (message) => console.warn(message) })) {
+        await validateTemplateProduct(definition, { writeWarning: (message) => console.warn(message) });
+    }
+    runStep(process.execPath, [packageScriptPath('scaffold-site'), siteRoot, '--template', 'starter-basic', '--name', 'Smoke Site', '--site-url', 'https://smoke.example.com', '--contact-email', 'hello@example.com']);
+}
+function installScaffold(siteRoot, { coreTarballPath, sdkTarballPath, cliTarballPath, agentTarballPath }) {
+    if (coreTarballPath && sdkTarballPath && cliTarballPath && agentTarballPath) {
+        linkWorkspacePackage(siteRoot, sdkPackageJson.name, sdkPackageRoot);
+        linkWorkspacePackage(siteRoot, packageJson.name, corePackageRoot);
+        linkWorkspacePackage(siteRoot, cliPackageJson.name, packageRoot);
+        linkWorkspacePackage(siteRoot, agentPackageJson.name, agentPackageRoot);
+        mirrorSharedNodeModules(siteRoot);
+        linkTreeseedBins(siteRoot);
+        return;
+    }
+    runStep('npm', ['install', '--cache', npmCacheDir, '--prefer-offline', '--no-audit', '--no-fund'], {
+        cwd: siteRoot,
+        env: {
+            npm_config_cache: npmCacheDir,
+            NPM_CONFIG_CACHE: npmCacheDir,
+            npm_config_prefer_offline: 'true',
+            npm_config_audit: 'false',
+            npm_config_fund: 'false',
+        },
+    });
+}
+function runScaffoldChecks(siteRoot) {
+    if (scaffoldChecks.has('build')) {
+        withTiming('scaffold build', () => {
+            runStep('npm', ['run', 'build'], { cwd: siteRoot });
+        });
+    }
+    if (scaffoldChecks.has('deploy')) {
+        withTiming('scaffold deploy dry-run', () => {
+            runStep('npm', ['run', 'deploy', '--', '--dry-run'], { cwd: siteRoot });
+        });
+    }
+}
+const siteRoot = createTempSiteRoot();
+let tarballPath = externalCoreTarball;
+let sdkTarballPath = externalSdkTarball;
+let cliTarballPath = externalCliTarball;
+let agentTarballPath = externalAgentTarball;
+try {
+    if (!reusesExternalTarballs && resetScaffoldCache) {
+        logStep(`resetting npm cache at ${npmCacheDir}`);
+        resetNpmCache();
+    }
+    if (!sdkTarballPath) {
+        logStep('building and packing @treeseed/sdk');
+        sdkTarballPath = createTarball(sdkPackageRoot, sdkPackageJson);
+    }
+    else {
+        logStep(`reusing provided @treeseed/sdk tarball: ${sdkTarballPath}`);
+    }
+    if (!tarballPath) {
+        logStep('building and packing @treeseed/core');
+        tarballPath = createTarball(corePackageRoot, packageJson);
+    }
+    else {
+        logStep(`reusing provided @treeseed/core tarball: ${tarballPath}`);
+    }
+    if (!agentTarballPath) {
+        logStep('building and packing @treeseed/agent');
+        agentTarballPath = createTarball(agentPackageRoot, agentPackageJson);
+    }
+    else {
+        logStep(`reusing provided @treeseed/agent tarball: ${agentTarballPath}`);
+    }
+    if (!cliTarballPath) {
+        logStep('building and packing @treeseed/cli');
+        cliTarballPath = createTarball(packageRoot, cliPackageJson);
+    }
+    else {
+        logStep(`reusing provided @treeseed/cli tarball: ${cliTarballPath}`);
+    }
+    logStep(`scaffolding temporary tenant at ${siteRoot}`);
+    await withTiming('scaffold tenant generation', async () => {
+        await scaffoldSite(siteRoot);
+    });
+    rewriteScaffoldDependency(siteRoot, tarballPath, cliTarballPath);
+    logStep(`installing scaffolded tenant dependencies with checks: ${[...scaffoldChecks].join(', ') || 'none'}`);
+    await withTiming('scaffold dependency install', async () => {
+        installScaffold(siteRoot, {
+            coreTarballPath: tarballPath,
+            sdkTarballPath,
+            cliTarballPath,
+            agentTarballPath,
+        });
+    });
+    logStep('running scaffold smoke checks');
+    runScaffoldChecks(siteRoot);
+    console.log(`Scaffold smoke test passed in ${dirname(siteRoot) ? siteRoot : '.'}`);
+}
+finally {
+    printSummary();
+    rmSync(siteRoot, { recursive: true, force: true });
+    if (sdkTarballPath && !externalSdkTarball) {
+        rmSync(sdkTarballPath, { force: true });
+    }
+    if (tarballPath && !externalCoreTarball) {
+        rmSync(tarballPath, { force: true });
+    }
+    if (!reusesExternalTarballs && resetScaffoldCache) {
+        resetNpmCache();
+    }
+}

package/dist/scripts/test-smoke.js

@@ -1,15 +1,21 @@
-import { mkdirSync, readdirSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
 import { mkdtempSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { packageRoot } from './package-tools.js';
-function run(command, args, cwd = packageRoot, capture = false) {
+const npmCacheDir = resolve(tmpdir(), 'treeseed-npm-cache');
+function run(command, args, cwd = packageRoot, capture = false, extraEnv = {}) {
     const result = spawnSync(command, args, {
         cwd,
         stdio: capture ? 'pipe' : 'inherit',
         encoding: 'utf8',
-        env: process.env,
+        env: {
+            ...process.env,
+            ...extraEnv,
+            npm_config_cache: npmCacheDir,
+            NPM_CONFIG_CACHE: npmCacheDir,
+        },
     });
     if (result.status !== 0) {
         throw new Error(result.stderr?.trim() || result.stdout?.trim() || `${command} ${args.join(' ')} failed`);
@@ -17,13 +23,12 @@ function run(command, args, cwd = packageRoot, capture = false) {
     return (result.stdout ?? '').trim();
 }
 function resolveNodeModulesRoot() {
-    let lastCandidate = null;
     let current = packageRoot;
     while (true) {
         const candidate = resolve(current, 'node_modules');
         try {
             readdirSync(candidate);
-            lastCandidate = candidate;
+            return candidate;
         }
         catch {
         }
@@ -32,15 +37,25 @@ function resolveNodeModulesRoot() {
             break;
         current = parent;
     }
-    if (lastCandidate) {
-        return lastCandidate;
-    }
     throw new Error(`Unable to locate node_modules for ${packageRoot}.`);
 }
 function mirrorDependencies(tempRoot) {
     const sharedNodeModules = resolveNodeModulesRoot();
     for (const entry of readdirSync(sharedNodeModules, { withFileTypes: true })) {
-        if (entry.name === '.bin' || entry.name === '@treeseed') {
+        if (entry.name === '.bin') {
+            continue;
+        }
+        if (entry.name === '@treeseed') {
+            const sourceScopeRoot = resolve(sharedNodeModules, entry.name);
+            const targetScopeRoot = resolve(tempRoot, 'node_modules', entry.name);
+            mkdirSync(targetScopeRoot, { recursive: true });
+            for (const scopedEntry of readdirSync(sourceScopeRoot, { withFileTypes: true })) {
+                if (scopedEntry.name === 'sdk') {
+                    continue;
+                }
+                const targetPath = resolve(targetScopeRoot, scopedEntry.name);
+                symlinkSync(resolve(sourceScopeRoot, scopedEntry.name), targetPath, scopedEntry.isDirectory() ? 'dir' : 'file');
+            }
             continue;
         }
         const targetPath = resolve(tempRoot, 'node_modules', entry.name);
@@ -48,6 +63,34 @@ function mirrorDependencies(tempRoot) {
         symlinkSync(resolve(sharedNodeModules, entry.name), targetPath, 'dir');
     }
 }
+function resolveInstalledSdkRoot(installRoot) {
+    const directRoot = resolve(installRoot, 'node_modules', '@treeseed', 'sdk');
+    const nestedRoot = resolve(directRoot, 'package');
+    if (existsSync(resolve(directRoot, 'package.json'))) {
+        return directRoot;
+    }
+    if (existsSync(resolve(nestedRoot, 'package.json'))) {
+        return nestedRoot;
+    }
+    throw new Error('Unable to locate installed SDK package root in smoke test.');
+}
+function loadPackedSdkPackageJson(installRoot) {
+    return JSON.parse(readFileSync(resolve(resolveInstalledSdkRoot(installRoot), 'package.json'), 'utf8'));
+}
+function wireSdkBin(installRoot) {
+    const packageJson = loadPackedSdkPackageJson(installRoot);
+    const relativeBinPath = packageJson.bin?.['treeseed-sdk-verify'];
+    if (!relativeBinPath) {
+        throw new Error('Packed SDK is missing treeseed-sdk-verify bin metadata.');
+    }
+    const binRoot = resolve(installRoot, 'node_modules', '.bin');
+    const target = resolve(resolveInstalledSdkRoot(installRoot), relativeBinPath);
+    const linkPath = resolve(binRoot, 'treeseed-sdk-verify');
+    mkdirSync(binRoot, { recursive: true });
+    symlinkSync(target, linkPath);
+    chmodSync(target, 0o755);
+    return linkPath;
+}
 const stageRoot = mkdtempSync(join(tmpdir(), 'treeseed-sdk-smoke-'));
 const packRoot = resolve(stageRoot, 'pack');
 const extractRoot = resolve(stageRoot, 'extract');
@@ -55,11 +98,17 @@ const installRoot = resolve(stageRoot, 'install');
 try {
     mkdirSync(packRoot, { recursive: true });
     mkdirSync(extractRoot, { recursive: true });
-    const filename = run('npm', ['pack', '--silent', '--ignore-scripts', '--pack-destination', packRoot], packageRoot, true)
+    const packOutput = run('npm', ['pack', '--ignore-scripts', '--cache', npmCacheDir, '--pack-destination', packRoot], packageRoot, true);
+    const filename = packOutput
         .split('\n')
         .map((line) => line.trim())
         .filter(Boolean)
-        .at(-1);
+        .at(-1)
+        ?? readdirSync(packRoot, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.tgz'))
+            .map((entry) => entry.name)
+            .sort((left, right) => left.localeCompare(right, undefined, { numeric: true, sensitivity: 'base' }))
+            .at(-1);
     if (!filename) {
         throw new Error('Unable to determine packed SDK tarball name.');
     }
@@ -68,8 +117,17 @@ try {
     mkdirSync(resolve(installRoot, 'node_modules', '@treeseed'), { recursive: true });
     run('cp', ['-R', resolve(extractRoot, 'package'), resolve(installRoot, 'node_modules', '@treeseed', 'sdk')]);
     mirrorDependencies(installRoot);
-    writeFileSync(resolve(installRoot, 'package.json'), `${JSON.stringify({ name: 'treeseed-sdk-smoke', private: true, type: 'module' }, null, 2)}\n`, 'utf8');
-    run(process.execPath, ['--input-type=module', '-e', 'await import("@treeseed/sdk");'], installRoot);
+    const verifyBin = wireSdkBin(installRoot);
+    writeFileSync(resolve(installRoot, 'package.json'), `${JSON.stringify({
+        name: 'treeseed-sdk-smoke',
+        private: true,
+        type: 'module',
+        scripts: {
+            'verify:direct': 'node --input-type=module -e "console.log(\'treeseed-sdk-smoke-verify\')"',
+        },
+    }, null, 2)}\n`, 'utf8');
+    run(process.execPath, ['--input-type=module', '-e', 'await import("@treeseed/sdk/verification");'], installRoot);
+    run(verifyBin, [], installRoot, false, { TREESEED_VERIFY_DRIVER: 'direct' });
     console.log('SDK packed-install smoke passed.');
 }
 finally {

package/dist/scripts/treeseed-assert-release-tag-version.js

@@ -0,0 +1,21 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const packageRoot = resolve(fileURLToPath(new URL('..', import.meta.url)));
+const packageJson = JSON.parse(readFileSync(resolve(packageRoot, 'package.json'), 'utf8'));
+const packageVersion = packageJson.version;
+const tagName = process.argv[2] || process.env.GITHUB_REF_NAME;
+if (!tagName) {
+    console.error('Release tag validation requires a tag name argument or GITHUB_REF_NAME.');
+    process.exit(1);
+}
+if (!/^\d+\.\d+\.\d+$/.test(tagName)) {
+    console.error(`Release tag "${tagName}" must use plain semver format "x.y.z".`);
+    process.exit(1);
+}
+const taggedVersion = tagName;
+if (taggedVersion !== packageVersion) {
+    console.error(`Release tag version "${taggedVersion}" does not match @treeseed/cli version "${packageVersion}".`);
+    process.exit(1);
+}
+console.log(`Release tag "${tagName}" matches @treeseed/cli version "${packageVersion}".`);

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

@@ -0,0 +1,134 @@
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, chmodSync } from 'node:fs';
+import { basename, 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 templateCatalogSourceRoot = resolve(srcRoot, 'template-catalog');
+const COPY_EXTENSIONS = new Set(['.json', '.md']);
+function walkFiles(root) {
+    const files = [];
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        const fullPath = join(root, entry.name);
+        if (entry.isDirectory())
+            files.push(...walkFiles(fullPath));
+        else
+            files.push(fullPath);
+    }
+    return files;
+}
+function ensureDir(filePath) {
+    mkdirSync(dirname(filePath), { recursive: true });
+}
+function rewriteRuntimeSpecifiers(contents, outputFile = null) {
+    let rewritten = contents
+        .replace(/(['"`])(\.[^'"`\n]+)\.(mjs|ts)\1/g, '$1$2.js$1')
+        .replace(/(['"`])\.\.\/src\//g, '$1../');
+    if (!outputFile || outputFile.includes(`${resolve(distRoot, 'scripts')}`)) {
+        return rewritten;
+    }
+    rewritten = rewritten.replace(/(['"`])((?:\.\.\/)+scripts\/([^'"`\n]+))\1/g, (_match, quote, _specifier, scriptPath) => {
+        const targetPath = resolve(distRoot, 'scripts', scriptPath);
+        let relativeSpecifier = relative(dirname(outputFile), targetPath).replaceAll('\\', '/');
+        if (!relativeSpecifier.startsWith('.')) {
+            relativeSpecifier = `./${relativeSpecifier}`;
+        }
+        return `${quote}${relativeSpecifier}${quote}`;
+    });
+    return rewritten;
+}
+function isTypeScriptSource(filePath) {
+    return filePath.endsWith('.ts') && !filePath.endsWith('.d.js');
+}
+async function compileModule(filePath, sourceRoot, outputRoot) {
+    const relativePath = relative(sourceRoot, filePath);
+    const outputFile = resolve(outputRoot, relativePath.replace(/\.(mjs|ts)$/u, '.js'));
+    ensureDir(outputFile);
+    await build({
+        entryPoints: [filePath],
+        outfile: outputFile,
+        platform: 'node',
+        format: 'esm',
+        bundle: false,
+        logLevel: 'silent',
+    });
+    const builtSource = readFileSync(outputFile, 'utf8');
+    writeFileSync(outputFile, rewriteRuntimeSpecifiers(builtSource, outputFile), 'utf8');
+}
+function copyAsset(filePath, sourceRoot, outputRoot) {
+    const outputFile = resolve(outputRoot, relative(sourceRoot, filePath));
+    ensureDir(outputFile);
+    copyFileSync(filePath, outputFile);
+    if (outputFile.endsWith('.d.js')) {
+        writeFileSync(outputFile, rewriteRuntimeSpecifiers(readFileSync(outputFile, 'utf8')), 'utf8');
+    }
+}
+function copyAssetTree(sourceRoot, outputRoot) {
+    for (const filePath of walkFiles(sourceRoot)) {
+        copyAsset(filePath, 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 transformed = extname(filePath) === '.ts'
+        ? ts.transpileModule(source, {
+            compilerOptions: { module: ts.ModuleKind.ESNext, target: ts.ScriptTarget.ES2022 },
+        }).outputText
+        : source;
+    ensureDir(outputFile);
+    writeFileSync(outputFile, rewriteRuntimeSpecifiers(transformed, outputFile), 'utf8');
+    chmodSync(outputFile, 0o755);
+}
+function emitDeclarations() {
+    const rootNames = walkFiles(srcRoot).filter(isTypeScriptSource);
+    const program = ts.createProgram({
+        rootNames,
+        options: {
+            allowImportingTsExtensions: true,
+            target: ts.ScriptTarget.ES2022,
+            module: ts.ModuleKind.ESNext,
+            moduleResolution: ts.ModuleResolutionKind.Bundler,
+            strict: true,
+            types: ['node'],
+            declaration: true,
+            emitDeclarationOnly: true,
+            declarationDir: distRoot,
+            rootDir: srcRoot,
+            noEmit: false,
+        },
+    });
+    const result = program.emit();
+    if (result.emitSkipped) {
+        throw new Error('Declaration build failed.');
+    }
+}
+rmSync(distRoot, { recursive: true, force: true });
+for (const filePath of walkFiles(srcRoot)) {
+    if (filePath.startsWith(`${templateCatalogSourceRoot}/`)) {
+        continue;
+    }
+    const extension = extname(filePath);
+    if (isTypeScriptSource(filePath))
+        await compileModule(filePath, srcRoot, distRoot);
+    else if (COPY_EXTENSIONS.has(extension))
+        copyAsset(filePath, srcRoot, distRoot);
+}
+if (existsSync(templateCatalogSourceRoot)) {
+    copyAssetTree(templateCatalogSourceRoot, resolve(distRoot, 'template-catalog'));
+}
+for (const filePath of walkFiles(scriptsRoot)) {
+    const extension = extname(filePath);
+    if (extension === '.ts' || extension === '.mjs')
+        transpileScript(filePath);
+}
+emitDeclarations();
+if (existsSync(resolve(packageRoot, 'README.md'))) {
+    copyFileSync(resolve(packageRoot, 'README.md'), resolve(distRoot, '..', 'README.md'));
+}

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

@@ -0,0 +1,19 @@
+import { spawnSync } from 'node:child_process';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const packageRoot = resolve(fileURLToPath(new URL('..', import.meta.url)));
+const extraArgs = process.argv.slice(2);
+const npmArgs = ['publish', '.', '--access', 'public'];
+if (process.env.GITHUB_ACTIONS === 'true')
+    npmArgs.push('--provenance');
+npmArgs.push(...extraArgs);
+const result = spawnSync('npm', npmArgs, {
+    cwd: packageRoot,
+    stdio: 'inherit',
+    env: process.env,
+});
+if (result.error) {
+    console.error(result.error.message);
+    process.exit(1);
+}
+process.exit(result.status ?? 1);