@treeseed/cli 0.1.1 → 0.4.2

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

@@ -1,212 +0,0 @@
-import assert from 'node:assert/strict';
-import { mkdirSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { setTimeout as delay } from 'node:timers/promises';
-import { prepareCloudflareLocalRuntime, spawnProcess, startWranglerDev } from './local-dev-lib.js';
-import { fixtureRoot, fixtureWranglerConfig } from './paths.js';
-const TEST_PORT = 8791;
-const BASE_URL = `http://127.0.0.1:${TEST_PORT}`;
-const RUN_ID = `${Date.now()}-${process.pid}`;
-const ipSeed = Date.now() + process.pid;
-const TEST_IP = `198.51.${(ipSeed >>> 8) % 250}.${ipSeed % 250}`;
-const TEST_EMAIL = `integration-subscriber-${RUN_ID}@localhost.test`;
-const PERSIST_TO = resolve(process.cwd(), '.local', 'cloudflare-integration', RUN_ID);
-const workerLogs = [];
-mkdirSync(PERSIST_TO, { recursive: true });
-function captureLogs(stream, label) {
-    if (!stream) {
-        return;
-    }
-    stream.setEncoding('utf8');
-    stream.on('data', (chunk) => {
-        workerLogs.push(`[${label}] ${chunk}`);
-        if (workerLogs.length > 40) {
-            workerLogs.shift();
-        }
-    });
-}
-function readBody(message) {
-    return new Promise((resolve) => {
-        let body = '';
-        message.setEncoding('utf8');
-        message.on('data', (chunk) => {
-            body += chunk;
-        });
-        message.on('end', () => resolve(body));
-    });
-}
-function extractSetCookie(response) {
-    if (typeof response.headers.getSetCookie === 'function') {
-        return response.headers.getSetCookie();
-    }
-    const cookie = response.headers.get('set-cookie');
-    return cookie ? [cookie] : [];
-}
-async function waitForWorker(worker) {
-    for (let attempt = 0; attempt < 60; attempt += 1) {
-        if (worker.exitCode !== null) {
-            throw new Error(`Wrangler exited before the worker became ready (exit ${worker.exitCode}).\n${workerLogs.join('')}`);
-        }
-        try {
-            const response = await fetch(`${BASE_URL}/api/form/submit?formType=subscribe`, {
-                signal: AbortSignal.timeout(5000),
-                headers: {
-                    'x-forwarded-for': TEST_IP,
-                },
-            });
-            if (response.ok) {
-                return;
-            }
-        }
-        catch {
-            // Keep polling until the local worker is ready.
-        }
-        await delay(1000);
-    }
-    throw new Error(`Timed out waiting for local Wrangler dev to start.\n${workerLogs.join('')}`);
-}
-async function issueToken() {
-    const response = await fetch(`${BASE_URL}/api/form/submit?formType=subscribe`, {
-        signal: AbortSignal.timeout(10000),
-        headers: {
-            'x-forwarded-for': TEST_IP,
-        },
-    });
-    assert.equal(response.status, 200, 'token endpoint should return HTTP 200');
-    const payload = await response.json();
-    const cookies = extractSetCookie(response);
-    assert.equal(payload.ok, true, 'token payload should be ok');
-    assert.ok(payload.formToken, 'token endpoint should return a form token');
-    assert.ok(payload.sessionId, 'token endpoint should return a session id');
-    assert.ok(cookies.length > 0, 'token endpoint should set a session cookie');
-    return {
-        formToken: payload.formToken,
-        sessionId: payload.sessionId,
-        cookieHeader: cookies.map((cookie) => cookie.split(';', 1)[0]).join('; '),
-    };
-}
-async function submitSubscribeForm({ formToken, sessionId, cookieHeader }, email = TEST_EMAIL) {
-    const form = new FormData();
-    form.set('formType', 'subscribe');
-    form.set('name', 'Integration Test');
-    form.set('email', email);
-    form.set('formToken', formToken);
-    form.set('formSession', sessionId);
-    form.set('redirectTo', '/');
-    return fetch(`${BASE_URL}/api/form/submit`, {
-        method: 'POST',
-        redirect: 'manual',
-        signal: AbortSignal.timeout(10000),
-        headers: {
-            cookie: cookieHeader,
-            origin: BASE_URL,
-            referer: `${BASE_URL}/`,
-            'x-forwarded-for': TEST_IP,
-        },
-        body: form,
-    });
-}
-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 child = spawnProcess('wrangler', [
-        'd1',
-        'execute',
-        'karyon-docs-site-data',
-        '--local',
-        '--config',
-        fixtureWranglerConfig,
-        '--persist-to',
-        PERSIST_TO,
-        '--json',
-        '--command',
-        query,
-    ], { stdio: ['ignore', 'pipe', 'inherit'], cwd: fixtureRoot });
-    const stdout = await readBody(child.stdout);
-    const exitCode = await new Promise((resolve) => {
-        child.on('exit', resolve);
-    });
-    assert.equal(exitCode, 0, 'local D1 query should succeed');
-    const parsed = JSON.parse(stdout);
-    const results = Array.isArray(parsed) ? parsed : [parsed];
-    const rows = results.flatMap((entry) => entry.results ?? []);
-    return rows;
-}
-async function main() {
-    prepareCloudflareLocalRuntime({
-        persistTo: PERSIST_TO,
-        envOverrides: {
-            TREESEED_LOCAL_DEV_MODE: 'cloudflare',
-            TREESEED_FORMS_LOCAL_BYPASS_TURNSTILE: 'true',
-            TREESEED_PUBLIC_FORMS_LOCAL_BYPASS_TURNSTILE: 'true',
-            TREESEED_FORMS_LOCAL_BYPASS_CLOUDFLARE_GUARDS: 'false',
-            TREESEED_FORMS_LOCAL_USE_MAILPIT: 'true',
-            TREESEED_MAILPIT_SMTP_HOST: '127.0.0.1',
-            TREESEED_MAILPIT_SMTP_PORT: '1025',
-        },
-    });
-    const worker = startWranglerDev(['--port', String(TEST_PORT), '--persist-to', PERSIST_TO], {
-        stdio: ['ignore', 'pipe', 'pipe'],
-    });
-    captureLogs(worker.stdout, 'stdout');
-    captureLogs(worker.stderr, 'stderr');
-    const teardown = async () => {
-        if (worker.exitCode === null && !worker.killed) {
-            worker.kill('SIGTERM');
-            await Promise.race([
-                new Promise((resolve) => worker.once('exit', resolve)),
-                delay(5000),
-            ]);
-            if (worker.exitCode === null && !worker.killed) {
-                worker.kill('SIGKILL');
-                await Promise.race([
-                    new Promise((resolve) => worker.once('exit', resolve)),
-                    delay(5000),
-                ]);
-            }
-        }
-    };
-    process.on('SIGINT', async () => {
-        await teardown();
-        process.exit(130);
-    });
-    process.on('SIGTERM', async () => {
-        await teardown();
-        process.exit(143);
-    });
-    let shouldQuerySubscribers = false;
-    try {
-        await waitForWorker(worker);
-        const firstToken = await issueToken();
-        const firstResponse = await submitSubscribeForm(firstToken);
-        assert.equal(firstResponse.status, 303, 'subscribe submit should redirect');
-        assert.match(firstResponse.headers.get('location') ?? '', /\/\?formStatus=success&formCode=success#site-subscribe$/, 'subscribe success redirect should include success markers');
-        shouldQuerySubscribers = true;
-        const replayResponse = await submitSubscribeForm(firstToken);
-        assert.equal(replayResponse.status, 303, 'replayed submit should still redirect');
-        assert.match(replayResponse.headers.get('location') ?? '', /\/\?formStatus=error&formCode=token_replayed#site-subscribe$/, 'replayed token should be rejected by KV-backed nonce storage');
-        for (let attempt = 0; attempt < 2; attempt += 1) {
-            const token = await issueToken();
-            const response = await submitSubscribeForm(token);
-            assert.equal(response.status, 303, 'pre-limit submissions should redirect');
-            assert.match(response.headers.get('location') ?? '', /\/\?formStatus=success&formCode=success#site-subscribe$/, 'pre-limit submissions should succeed');
-        }
-        const limitedToken = await issueToken();
-        const limitedResponse = await submitSubscribeForm(limitedToken);
-        assert.equal(limitedResponse.status, 303, 'rate-limited submit should redirect');
-        assert.match(limitedResponse.headers.get('location') ?? '', /\/\?formStatus=error&formCode=rate_limited#site-subscribe$/, 'local KV-backed rate limiting should reject the fourth submission');
-    }
-    finally {
-        await teardown();
-    }
-    if (shouldQuerySubscribers) {
-        const rows = await querySubscribers();
-        assert.equal(rows.length, 1, 'subscriber should be written to local D1');
-        assert.equal(rows[0].email, TEST_EMAIL, 'subscriber email should match the submitted address');
-        assert.equal(rows[0].status, 'active', 'subscriber should be active');
-        assert.equal(rows[0].source, 'footer', 'subscriber source should be tracked');
-    }
-}
-main().catch((error) => {
-    console.error(error);
-    process.exit(1);
-});

package/dist/scripts/test-scaffold.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/scripts/test-scaffold.js

@@ -1,297 +0,0 @@
-#!/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 './package-tools.js';
-import { validateAllTemplateDefinitions } from './template-registry-lib.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();
-        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`, () => {
-        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);
-    });
-}
-function scaffoldSite(siteRoot) {
-    validateAllTemplateDefinitions();
-    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}`);
-    withTiming('scaffold tenant generation', () => {
-        scaffoldSite(siteRoot);
-    });
-    rewriteScaffoldDependency(siteRoot, tarballPath, cliTarballPath);
-    logStep(`installing scaffolded tenant dependencies with checks: ${[...scaffoldChecks].join(', ') || 'none'}`);
-    withTiming('scaffold dependency install', () => {
-        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/treeseed.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/scripts/treeseed.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-import { runTreeseedCli } from '../cli/main.js';
-const exitCode = await runTreeseedCli(process.argv.slice(2));
-process.exit(exitCode);

package/dist/scripts/validate-templates.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/scripts/validate-templates.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-import { validateAllTemplateDefinitions } from './template-registry-lib.js';
-const definitions = validateAllTemplateDefinitions();
-console.log(`Validated ${definitions.length} template definition${definitions.length === 1 ? '' : 's'}.`);

package/dist/scripts/watch-dev-lib.d.ts

@@ -1,21 +0,0 @@
-export declare function isEditablePackageWorkspace(): boolean;
-export declare function workspaceSdkRoot(): string | null;
-export declare function writeDevReloadStamp(projectRoot: any): void;
-export declare function readDevReloadState(projectRoot: any): any;
-export declare function createTenantWatchEntries(tenantRoot: any): {
-    kind: string;
-    root: string;
-}[];
-export declare function startPollingWatch({ watchEntries, onChange }: {
-    watchEntries: any;
-    onChange: any;
-}): () => void;
-export declare function stopManagedProcess(child: any, signal?: string): Promise<void>;
-export declare function createWatchBuildPaths(projectRoot: any): {
-    watchRoot: string;
-    stagedDistRoot: string;
-    backupDistRoot: string;
-    liveDistRoot: string;
-};
-export declare function swapStagedBuildOutput(projectRoot: any): void;
-export declare function clearStagedBuildOutput(projectRoot: any): void;