@treeseed/sdk 0.1.1 → 0.3.0

package/dist/remote.d.ts

@@ -0,0 +1,175 @@
+export declare const TREESEED_REMOTE_CONTRACT_VERSION = 1;
+export declare const TREESEED_REMOTE_CONTRACT_HEADER = "x-treeseed-remote-contract-version";
+export type ApiScope = string;
+export interface ApiPrincipal {
+    id: string;
+    displayName?: string;
+    scopes: ApiScope[];
+    metadata?: Record<string, unknown>;
+}
+export interface RemoteTreeseedHost {
+    id: string;
+    baseUrl: string;
+    label?: string;
+    official?: boolean;
+    priority?: number;
+}
+export interface RemoteTreeseedPoolOptions {
+    strategy?: 'active-first' | 'priority';
+    maxAttempts?: number;
+}
+export interface RemoteTreeseedConfig {
+    hosts: RemoteTreeseedHost[];
+    activeHostId: string;
+    executionMode?: 'prefer-local' | 'prefer-remote' | 'remote-only';
+    auth?: {
+        accessToken?: string;
+        refreshToken?: string;
+        expiresAt?: string;
+        principal?: ApiPrincipal | null;
+    };
+    pool?: RemoteTreeseedPoolOptions;
+}
+export interface DeviceCodeStartRequest {
+    clientName?: string;
+    scopes?: ApiScope[];
+}
+export interface DeviceCodeStartResponse {
+    ok: true;
+    deviceCode: string;
+    userCode: string;
+    verificationUri: string;
+    verificationUriComplete: string;
+    intervalSeconds: number;
+    expiresAt: string;
+    expiresInSeconds: number;
+}
+export type DeviceCodePollResponse = {
+    ok: true;
+    status: 'pending';
+    intervalSeconds: number;
+} | {
+    ok: true;
+    status: 'approved';
+    accessToken: string;
+    refreshToken: string;
+    tokenType: 'Bearer';
+    expiresAt: string;
+    expiresInSeconds: number;
+    principal: ApiPrincipal;
+} | {
+    ok: false;
+    status: 'expired' | 'invalid' | 'already_used';
+    error: string;
+};
+export interface DeviceCodePollRequest {
+    deviceCode: string;
+}
+export interface DeviceCodeApproveRequest {
+    userCode: string;
+    principalId: string;
+    displayName?: string;
+    scopes?: ApiScope[];
+    metadata?: Record<string, unknown>;
+}
+export interface TokenRefreshRequest {
+    refreshToken: string;
+}
+export interface TokenRefreshResponse {
+    ok: true;
+    accessToken: string;
+    refreshToken: string;
+    tokenType: 'Bearer';
+    expiresAt: string;
+    expiresInSeconds: number;
+    principal: ApiPrincipal;
+}
+export interface RemoteSdkOperationRequest {
+    input?: Record<string, unknown>;
+    repoRoot?: string;
+}
+export type RemoteSdkOperationResponse<T = unknown> = T;
+export interface RemoteGatewayRequest {
+    method?: 'GET' | 'POST';
+    body?: unknown;
+}
+export interface RemoteWorkflowOperationRequest {
+    input?: Record<string, unknown>;
+    cwd?: string;
+    env?: Record<string, string>;
+}
+export interface RemoteWorkflowNextStep {
+    operation: string;
+    reason?: string;
+    input?: Record<string, unknown>;
+}
+export interface RemoteWorkflowOperationResponse {
+    ok: boolean;
+    operation: string;
+    payload?: Record<string, unknown> | null;
+    nextSteps?: RemoteWorkflowNextStep[];
+}
+export declare class RemoteTreeseedClient {
+    readonly config: RemoteTreeseedConfig;
+    private readonly fetchImpl;
+    constructor(config: RemoteTreeseedConfig, options?: {
+        fetchImpl?: typeof fetch;
+    });
+    activeHost(): RemoteTreeseedHost;
+    requestJson<T>(path: string, options?: {
+        method?: 'GET' | 'POST';
+        body?: unknown;
+        headers?: Record<string, string>;
+        requireAuth?: boolean;
+    }): Promise<T>;
+}
+export declare class RemoteTreeseedAuthClient {
+    private readonly client;
+    constructor(client: RemoteTreeseedClient);
+    startDeviceFlow(request: DeviceCodeStartRequest): Promise<DeviceCodeStartResponse>;
+    pollDeviceFlow(request: DeviceCodePollRequest): Promise<DeviceCodePollResponse>;
+    refreshAccessToken(request: TokenRefreshRequest): Promise<TokenRefreshResponse>;
+    whoAmI(): Promise<{
+        ok: true;
+        payload: ApiPrincipal;
+    }>;
+}
+export declare class RemoteTreeseedSdkClient {
+    private readonly client;
+    constructor(client: RemoteTreeseedClient);
+    execute<T = unknown>(operation: string, request: RemoteSdkOperationRequest): Promise<T>;
+}
+export declare class TreeseedGatewayClient {
+    private readonly baseUrl;
+    private readonly token;
+    private readonly fetchImpl;
+    constructor(config: import('./sdk-types.ts').SdkGatewayClientConfig);
+    requestJson<T>(path: string, options?: RemoteGatewayRequest): Promise<T & {
+        error?: string;
+    }>;
+}
+export declare class CloudflareQueuePullClient {
+    private readonly baseUrl;
+    private readonly token;
+    private readonly fetchImpl;
+    constructor(config: import('./sdk-types.ts').SdkQueuePullClientConfig);
+    private request;
+    pull(request?: import('./sdk-types.ts').SdkQueuePullRequest): Promise<{
+        messages: {
+            leaseId: string;
+            attempts: number;
+            rawBody: string;
+            body: import("./sdk-types.ts").SdkQueueMessageEnvelope;
+        }[];
+    }>;
+    ack(acks: string[]): Promise<unknown>;
+    retry(retries: Array<{
+        leaseId: string;
+        delaySeconds?: number;
+    }>): Promise<unknown>;
+}
+export declare class RemoteTreeseedOperationsClient {
+    private readonly client;
+    constructor(client: RemoteTreeseedClient);
+    execute(operation: string, request: RemoteWorkflowOperationRequest): Promise<RemoteWorkflowOperationResponse>;
+}

package/dist/remote.js

@@ -0,0 +1,202 @@
+const TREESEED_REMOTE_CONTRACT_VERSION = 1;
+const TREESEED_REMOTE_CONTRACT_HEADER = "x-treeseed-remote-contract-version";
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+}
+function resolveActiveHost(config) {
+  const host = config.hosts.find((entry) => entry.id === config.activeHostId) ?? config.hosts[0];
+  if (!host) {
+    throw new Error("Remote Treeseed configuration is missing a usable host.");
+  }
+  return {
+    ...host,
+    baseUrl: normalizeBaseUrl(host.baseUrl)
+  };
+}
+class RemoteTreeseedClient {
+  config;
+  fetchImpl;
+  constructor(config, options = {}) {
+    this.config = config;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  activeHost() {
+    return resolveActiveHost(this.config);
+  }
+  async requestJson(path, options = {}) {
+    const host = this.activeHost();
+    const headers = {
+      accept: "application/json",
+      [TREESEED_REMOTE_CONTRACT_HEADER]: String(TREESEED_REMOTE_CONTRACT_VERSION),
+      ...options.headers ?? {}
+    };
+    if (options.body !== void 0) {
+      headers["content-type"] = "application/json";
+    }
+    if (options.requireAuth && this.config.auth?.accessToken) {
+      headers.authorization = `Bearer ${this.config.auth.accessToken}`;
+    }
+    const response = await this.fetchImpl(`${host.baseUrl}${path}`, {
+      method: options.method ?? "GET",
+      headers,
+      body: options.body === void 0 ? void 0 : JSON.stringify(options.body)
+    });
+    const contractVersion = response.headers.get(TREESEED_REMOTE_CONTRACT_HEADER);
+    if (contractVersion && Number(contractVersion) !== TREESEED_REMOTE_CONTRACT_VERSION) {
+      throw new Error(
+        `Remote Treeseed contract mismatch. Client=${TREESEED_REMOTE_CONTRACT_VERSION}, server=${contractVersion}.`
+      );
+    }
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      const message = typeof payload.error === "string" ? String(payload.error) : `Remote request failed with ${response.status}.`;
+      throw new Error(message);
+    }
+    return payload;
+  }
+}
+class RemoteTreeseedAuthClient {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  startDeviceFlow(request) {
+    return this.client.requestJson("/auth/device/start", {
+      method: "POST",
+      body: request
+    });
+  }
+  pollDeviceFlow(request) {
+    return this.client.requestJson("/auth/device/poll", {
+      method: "POST",
+      body: request
+    });
+  }
+  refreshAccessToken(request) {
+    return this.client.requestJson("/auth/token/refresh", {
+      method: "POST",
+      body: request
+    });
+  }
+  whoAmI() {
+    return this.client.requestJson("/auth/me", {
+      requireAuth: true
+    });
+  }
+}
+class RemoteTreeseedSdkClient {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  execute(operation, request) {
+    return this.client.requestJson(`/sdk/${encodeURIComponent(operation)}`, {
+      method: "POST",
+      body: request,
+      requireAuth: true
+    });
+  }
+}
+function normalizeExternalBaseUrl(baseUrl) {
+  return baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+}
+class TreeseedGatewayClient {
+  baseUrl;
+  token;
+  fetchImpl;
+  constructor(config) {
+    this.baseUrl = normalizeExternalBaseUrl(config.baseUrl);
+    this.token = config.bearerToken;
+    this.fetchImpl = config.fetchImpl ?? fetch;
+  }
+  async requestJson(path, options = {}) {
+    const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
+      method: options.method ?? "POST",
+      headers: {
+        accept: "application/json",
+        authorization: `Bearer ${this.token}`,
+        ...options.body === void 0 ? {} : { "content-type": "application/json" }
+      },
+      body: options.body === void 0 ? void 0 : JSON.stringify(options.body)
+    });
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      throw new Error(typeof payload.error === "string" ? payload.error : `Gateway request failed with ${response.status}.`);
+    }
+    return payload;
+  }
+}
+class CloudflareQueuePullClient {
+  baseUrl;
+  token;
+  fetchImpl;
+  constructor(config) {
+    const apiBaseUrl = config.apiBaseUrl ?? "https://api.cloudflare.com/client/v4/accounts";
+    this.baseUrl = `${normalizeExternalBaseUrl(apiBaseUrl)}/${config.accountId}/queues/${config.queueId}`;
+    this.token = config.token;
+    this.fetchImpl = config.fetchImpl ?? fetch;
+  }
+  async request(path, body) {
+    const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        accept: "application/json",
+        authorization: `Bearer ${this.token}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok || payload.success === false) {
+      throw new Error(payload.errors?.[0]?.message ?? `Queue request failed with ${response.status}.`);
+    }
+    return payload.result;
+  }
+  async pull(request = {}) {
+    const result = await this.request("/messages/pull", {
+      batch_size: request.batchSize ?? 1,
+      visibility_timeout_ms: request.visibilityTimeoutMs ?? 12e4
+    });
+    const messages = (result.messages ?? []).map((entry) => ({
+      leaseId: entry.lease_id,
+      attempts: Number(entry.attempts ?? 0),
+      rawBody: String(entry.body ?? "{}"),
+      body: JSON.parse(String(entry.body ?? "{}"))
+    }));
+    return { messages };
+  }
+  ack(acks) {
+    return this.request("/messages/ack", { acks });
+  }
+  retry(retries) {
+    return this.request("/messages/ack", {
+      retries: retries.map((entry) => ({
+        lease_id: entry.leaseId,
+        delay_secs: entry.delaySeconds ?? 0
+      }))
+    });
+  }
+}
+class RemoteTreeseedOperationsClient {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  execute(operation, request) {
+    return this.client.requestJson(`/operations/${encodeURIComponent(operation)}`, {
+      method: "POST",
+      body: request,
+      requireAuth: true
+    });
+  }
+}
+export {
+  CloudflareQueuePullClient,
+  RemoteTreeseedAuthClient,
+  RemoteTreeseedClient,
+  RemoteTreeseedOperationsClient,
+  RemoteTreeseedSdkClient,
+  TREESEED_REMOTE_CONTRACT_HEADER,
+  TREESEED_REMOTE_CONTRACT_VERSION,
+  TreeseedGatewayClient
+};

package/dist/runtime.js

@@ -1,10 +1,57 @@
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
+const DEFAULT_FIXTURE_ID = "treeseed-working-site";
+const runtimeFile = fileURLToPath(import.meta.url);
+const sdkPackageRoot = path.resolve(path.dirname(runtimeFile), "..");
+function fixtureRootCandidates(start) {
+  const candidates = [];
+  if (process.env.TREESEED_FIXTURES_ROOT) {
+    candidates.push(path.resolve(process.env.TREESEED_FIXTURES_ROOT));
+  }
+  candidates.push(path.join(sdkPackageRoot, ".fixtures", "treeseed-fixtures"));
+  candidates.push(path.join(start, ".fixtures", "treeseed-fixtures"));
+  return [...new Set(candidates)];
+}
+function resolveSharedFixtureRoot(start) {
+  const requestedFixtureId = process.env.TREESEED_FIXTURE_ID?.trim() || DEFAULT_FIXTURE_ID;
+  for (const fixturesRoot of fixtureRootCandidates(start)) {
+    const directRoot = path.join(fixturesRoot, "sites", "working-site");
+    const directManifestPath = path.join(directRoot, "fixture.manifest.json");
+    if (existsSync(path.join(directRoot, "src", "content")) && existsSync(directManifestPath)) {
+      return directRoot;
+    }
+    const sitesRoot = path.join(fixturesRoot, "sites");
+    if (!existsSync(sitesRoot)) {
+      continue;
+    }
+    for (const entry of readdirSync(sitesRoot, { withFileTypes: true }).filter((item) => item.isDirectory()).map((item) => item.name)) {
+      const fixtureRoot = path.join(sitesRoot, entry);
+      const manifestPath = path.join(fixtureRoot, "fixture.manifest.json");
+      if (!existsSync(manifestPath)) {
+        continue;
+      }
+      try {
+        const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+        if (manifest.id === requestedFixtureId) {
+          const root = path.resolve(fixtureRoot, manifest.root ?? ".");
+          if (existsSync(path.join(root, "src", "content"))) {
+            return root;
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  return null;
+}
 function findContentRoot(start) {
   let current = path.resolve(start);
   for (; ; ) {
-    if (existsSync(path.join(current, "fixture", "src", "content"))) {
-      return path.join(current, "fixture");
+    const sharedFixtureRoot = resolveSharedFixtureRoot(current);
+    if (sharedFixtureRoot) {
+      return sharedFixtureRoot;
     }
     if (existsSync(path.join(current, "src", "content"))) {
       return current;

package/dist/scripts/aggregate-book.js

@@ -0,0 +1,121 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { buildTenantBookRuntime } from '../platform/utils/books-data.js';
+import { loadTreeseedManifest } from '../platform/tenant/config.js';
+const PROJECT_TENANT = loadTreeseedManifest();
+const { BOOKS, TREESEED_LIBRARY_DOWNLOAD } = buildTenantBookRuntime(PROJECT_TENANT, {
+    projectRoot: PROJECT_TENANT.__tenantRoot ?? process.cwd(),
+    docsLibraryDownload: {
+        downloadFileName: 'karyon-knowledge.md',
+        downloadHref: '/books/karyon-knowledge.md',
+        downloadTitle: 'Karyon Knowledge Library',
+    },
+});
+const projectRoot = PROJECT_TENANT.__tenantRoot ?? process.cwd();
+const outputDir = path.join(projectRoot, 'public', 'books');
+const legacyOutputFile = path.join(projectRoot, 'public', 'book.md');
+function sortPaths(paths) {
+    return [...paths].sort((left, right) => left.localeCompare(right, undefined, { numeric: true, sensitivity: 'base' }));
+}
+function getSidebarOrder(filePath) {
+    const rawContent = fs.readFileSync(filePath, 'utf8');
+    const frontmatterMatch = rawContent.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!frontmatterMatch)
+        return Number.POSITIVE_INFINITY;
+    const orderMatch = frontmatterMatch[1].match(/^\s{2}order:\s*(\d+)\s*$/m);
+    return orderMatch ? Number.parseInt(orderMatch[1], 10) : Number.POSITIVE_INFINITY;
+}
+function collectMarkdownFiles(rootPath) {
+    if (!fs.existsSync(rootPath)) {
+        throw new Error(`Book export root not found: ${rootPath}`);
+    }
+    const stats = fs.statSync(rootPath);
+    if (stats.isFile()) {
+        return [rootPath];
+    }
+    const entries = fs.readdirSync(rootPath, { withFileTypes: true });
+    return sortPaths(entries.flatMap((entry) => {
+        const fullPath = path.join(rootPath, entry.name);
+        if (entry.isDirectory()) {
+            return collectMarkdownFiles(fullPath);
+        }
+        if (entry.isFile() && (entry.name.endsWith('.md') || entry.name.endsWith('.mdx'))) {
+            return [fullPath];
+        }
+        return [];
+    }));
+}
+function stripFrontmatter(content) {
+    return content.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, '').trim();
+}
+function stripMdxOnlySyntax(content) {
+    return content
+        .replace(/^import\s.+$/gm, '')
+        .replace(/^\s*<\/?[A-Z][^>]*>\s*$/gm, '')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
+function inferExportRootFromBasePath(book) {
+    const normalizedBasePath = String(book.basePath || '').trim();
+    const knowledgePrefix = '/knowledge/';
+    if (!normalizedBasePath.startsWith(knowledgePrefix)) {
+        throw new Error(`Book basePath must start with "${knowledgePrefix}" to infer exports: ${book.basePath}`);
+    }
+    const relativeKnowledgePath = normalizedBasePath
+        .slice(knowledgePrefix.length)
+        .replace(/^\/+|\/+$/g, '');
+    if (!relativeKnowledgePath) {
+        throw new Error(`Book basePath must identify a knowledge directory: ${book.basePath}`);
+    }
+    return path.join(PROJECT_TENANT.content.docs, relativeKnowledgePath);
+}
+function resolveExportRoots(book) {
+    if (Array.isArray(book.exportRoots) && book.exportRoots.length > 0) {
+        return book.exportRoots;
+    }
+    return [inferExportRootFromBasePath(book)];
+}
+function resolveBookFiles(book) {
+    const files = resolveExportRoots(book).flatMap((root) => collectMarkdownFiles(path.resolve(projectRoot, root)).sort((left, right) => {
+        const orderDelta = getSidebarOrder(left) - getSidebarOrder(right);
+        if (orderDelta !== 0)
+            return orderDelta;
+        return left.localeCompare(right, undefined, { numeric: true, sensitivity: 'base' });
+    }));
+    return Array.from(new Set(files));
+}
+function buildBookMarkdown(book) {
+    const sections = resolveBookFiles(book).map((filePath) => {
+        const rawContent = fs.readFileSync(filePath, 'utf8');
+        return stripMdxOnlySyntax(stripFrontmatter(rawContent));
+    });
+    return `# ${book.downloadTitle}\n\n> This document is auto-generated from the Karyon knowledge source.\n\n${sections.join('\n\n---\n\n')}\n`;
+}
+function ensureOutputDir() {
+    fs.mkdirSync(outputDir, { recursive: true });
+}
+function writeBookOutput(fileName, content) {
+    const outputPath = path.join(outputDir, fileName);
+    fs.writeFileSync(outputPath, content);
+    return outputPath;
+}
+function main() {
+    console.log('Generating contextual Karyon knowledge exports...');
+    ensureOutputDir();
+    const bookOutputs = BOOKS.map((book) => {
+        const content = buildBookMarkdown(book);
+        const outputPath = writeBookOutput(book.downloadFileName, content);
+        console.log(`Generated ${path.relative(projectRoot, outputPath)}`);
+        return { book, content };
+    });
+    const compositeContent = `# ${TREESEED_LIBRARY_DOWNLOAD.downloadTitle}\n\n> This document is auto-generated from the Karyon knowledge source.\n\n${bookOutputs
+        .map(({ content }) => content.trim())
+        .join('\n\n---\n\n')}\n`;
+    const compositeOutputPath = writeBookOutput(TREESEED_LIBRARY_DOWNLOAD.downloadFileName, compositeContent);
+    console.log(`Generated ${path.relative(projectRoot, compositeOutputPath)}`);
+    if (fs.existsSync(legacyOutputFile)) {
+        fs.rmSync(legacyOutputFile);
+        console.log(`Removed legacy export ${path.relative(projectRoot, legacyOutputFile)}`);
+    }
+}
+main();

package/dist/scripts/build-dist.js

@@ -1,12 +1,14 @@
 import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { dirname, extname, join, relative, resolve } from 'node:path';
+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 COPY_EXTENSIONS = new Set(['.d.js', '.json', '.md']);
+const treeseedTemplateCatalogSourceRoot = resolve(srcRoot, 'treeseed', 'template-catalog');
+const treeseedServicesSourceRoot = resolve(srcRoot, 'treeseed', 'services');
+const COPY_EXTENSIONS = new Set(['.json', '.md', '.js', '.d.js', '.yaml', '.yml']);
 function walkFiles(root) {
     const files = [];
     for (const entry of readdirSync(root, { withFileTypes: true })) {
@@ -25,6 +27,17 @@ function ensureDir(filePath) {
 function rewriteRuntimeSpecifiers(contents) {
     return contents.replace(/(['"`])(\.[^'"`\n]+)\.(mjs|ts)\1/g, '$1$2.js$1');
 }
+function rewriteScriptRuntimeSpecifiers(contents) {
+    return rewriteRuntimeSpecifiers(contents)
+        .replace(/(['"`])\.\.\/src\//g, '$1../')
+        .replace(/(['"`])\.\/src\//g, '$1./');
+}
+function isTypeScriptSource(filePath) {
+    return filePath.endsWith('.ts') && !filePath.endsWith('.d.js');
+}
+function isDeclarationAsset(filePath) {
+    return 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'));
@@ -44,14 +57,25 @@ function copyAsset(filePath, sourceRoot, outputRoot) {
     const outputFile = resolve(outputRoot, relative(sourceRoot, filePath));
     ensureDir(outputFile);
     copyFileSync(filePath, outputFile);
-    if (outputFile.endsWith('.d.js')) {
+    if (outputFile.endsWith('.d.js') || outputFile.endsWith('.js')) {
         const contents = readFileSync(outputFile, 'utf8');
         writeFileSync(outputFile, rewriteRuntimeSpecifiers(contents), '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);
+    if (relativePath === 'fixture-tools.ts') {
+        return;
+    }
     const outputFile = resolve(distRoot, 'scripts', relativePath.replace(/\.(mjs|ts)$/u, '.js'));
     const transformed = extname(filePath) === '.ts'
         ? ts.transpileModule(source, {
@@ -62,22 +86,24 @@ function transpileScript(filePath) {
         }).outputText
         : source;
     ensureDir(outputFile);
-    writeFileSync(outputFile, rewriteRuntimeSpecifiers(transformed), 'utf8');
+    writeFileSync(outputFile, rewriteScriptRuntimeSpecifiers(transformed), 'utf8');
 }
 function emitDeclarations() {
-    const configPath = ts.findConfigFile(packageRoot, ts.sys.fileExists, 'tsconfig.json');
-    if (!configPath) {
-        throw new Error('Unable to locate tsconfig.json for declaration build.');
-    }
-    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
-    const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, packageRoot);
+    const rootNames = walkFiles(srcRoot).filter(isTypeScriptSource);
     const program = ts.createProgram({
-        rootNames: parsed.fileNames,
+        rootNames,
         options: {
-            ...parsed.options,
+            allowImportingTsExtensions: true,
+            module: ts.ModuleKind.ESNext,
+            moduleResolution: ts.ModuleResolutionKind.Bundler,
+            target: ts.ScriptTarget.ES2022,
+            strict: true,
+            skipLibCheck: true,
+            types: ['node'],
             declaration: true,
             emitDeclarationOnly: true,
             declarationDir: distRoot,
+            rootDir: srcRoot,
             noEmit: false,
         },
     });
@@ -93,8 +119,15 @@ function emitDeclarations() {
 }
 rmSync(distRoot, { recursive: true, force: true });
 for (const filePath of walkFiles(srcRoot)) {
+    if (filePath.startsWith(`${treeseedTemplateCatalogSourceRoot}/`)) {
+        continue;
+    }
     const extension = extname(filePath);
-    if (extension === '.ts') {
+    if (isDeclarationAsset(filePath)) {
+        copyAsset(filePath, srcRoot, distRoot);
+        continue;
+    }
+    if (isTypeScriptSource(filePath)) {
         await compileModule(filePath, srcRoot, distRoot);
         continue;
     }
@@ -102,6 +135,12 @@ for (const filePath of walkFiles(srcRoot)) {
         copyAsset(filePath, srcRoot, distRoot);
     }
 }
+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') {
@@ -109,6 +148,11 @@ for (const filePath of walkFiles(scriptsRoot)) {
     }
 }
 emitDeclarations();
+for (const filePath of walkFiles(distRoot)) {
+    if (filePath.endsWith('.d.js')) {
+        rmSync(filePath, { force: true });
+    }
+}
 if (existsSync(resolve(packageRoot, 'README.md'))) {
     copyFileSync(resolve(packageRoot, 'README.md'), resolve(distRoot, '..', 'README.md'));
 }