@treeseed/core 0.1.2

package/dist/scripts/patch-starlight-content-path.js

@@ -0,0 +1,172 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+import { packageRoot } from './paths.js';
+const legacyDocsRoot = path.resolve(packageRoot, '../..');
+const candidateStarlightRoots = [
+    path.join(process.cwd(), 'node_modules/@astrojs/starlight'),
+    path.join(packageRoot, 'node_modules/@astrojs/starlight'),
+    path.join(legacyDocsRoot, 'node_modules/@astrojs/starlight'),
+];
+const candidateCollectionFiles = [
+    path.join(process.cwd(), 'node_modules/@astrojs/starlight/utils/collection.ts'),
+    path.join(packageRoot, 'node_modules/@astrojs/starlight/utils/collection.ts'),
+    path.join(legacyDocsRoot, 'node_modules/@astrojs/starlight/utils/collection.ts'),
+];
+const originalSource = `export type StarlightCollection = 'docs' | 'i18n';
+
+/**
+ * We still rely on the content collection folder structure to be fixed for now:
+ *
+ * - At build time, if the feature is enabled, we get all the last commit dates for each file in
+ *   the docs folder ahead of time. In the current approach, we cannot know at this time the
+ *   user-defined content folder path in the integration context as this would only be available
+ *   from the loader. A potential solution could be to do that from a custom loader re-implementing
+ *   the glob loader or built on top of it. Although, we don't have access to the Starlight
+ *   configuration from the loader to even know we should do that.
+ * - Remark plugins get passed down an absolute path to a content file and we need to figure out
+ *   the language from that path. Without knowing the content folder path, we cannot reliably do
+ *   so.
+ *
+ * Below are various functions to easily get paths to these collections and avoid having to
+ * hardcode them throughout the codebase. When user-defined content folder locations are supported,
+ * these helper functions should be updated to reflect that in one place.
+ */
+
+export function getCollectionUrl(collection: StarlightCollection, srcDir: URL) {
+\treturn new URL(\`content/\${collection}/\`, srcDir);
+}
+
+export function getCollectionPathFromRoot(
+\tcollection: StarlightCollection,
+\t{ root, srcDir }: { root: URL | string; srcDir: URL | string }
+) {
+\treturn (
+\t\t(typeof srcDir === 'string' ? srcDir : srcDir.pathname).replace(
+\t\t\ttypeof root === 'string' ? root : root.pathname,
+\t\t\t''
+\t\t) +
+\t\t'content/' +
+\t\tcollection
+\t);
+}
+`;
+const patchedSource = `export type StarlightCollection = 'docs' | 'i18n';
+
+/**
+ * We still rely on the content collection folder structure to be fixed for now:
+ *
+ * - At build time, if the feature is enabled, we get all the last commit dates for each file in
+ *   the docs folder ahead of time. In the current approach, we cannot know at this time the
+ *   user-defined content folder path in the integration context as this would only be available
+ *   from the loader. A potential solution could be to do that from a custom loader re-implementing
+ *   the glob loader or built on top of it. Although, we don't have access to the Starlight
+ *   configuration from the loader to even know we should do that.
+ * - Remark plugins get passed down an absolute path to a content file and we need to figure out
+ *   the language from that path. Without knowing the content folder path, we cannot reliably do
+ *   so.
+ *
+ * Below are various functions to easily get paths to these collections and avoid having to
+ * hardcode them throughout the codebase. When user-defined content folder locations are supported,
+ * these helper functions should be updated to reflect that in one place.
+ */
+
+export function getCollectionUrl(collection: StarlightCollection, srcDir: URL) {
+\treturn new URL(\`content/\${getCollectionDir(collection)}/\`, srcDir);
+}
+
+function getCollectionDir(collection: StarlightCollection) {
+\treturn collection === 'docs' ? 'knowledge' : collection;
+}
+
+export function getCollectionPathFromRoot(
+\tcollection: StarlightCollection,
+\t{ root, srcDir }: { root: URL | string; srcDir: URL | string }
+) {
+\treturn (
+\t\t(typeof srcDir === 'string' ? srcDir : srcDir.pathname).replace(
+\t\t\ttypeof root === 'string' ? root : root.pathname,
+\t\t\t''
+\t\t) +
+\t\t'content/' +
+\t\tgetCollectionDir(collection)
+\t);
+}
+`;
+async function patchCollectionFile(collectionFile) {
+    const source = await fs.readFile(collectionFile, 'utf8');
+    if (source === patchedSource) {
+        return 'already';
+    }
+    if (source !== originalSource) {
+        throw new Error(`Unexpected Starlight collection helper format in ${collectionFile}`);
+    }
+    await fs.writeFile(collectionFile, patchedSource);
+    return 'patched';
+}
+async function copyVendoredTree(sourceRoot, targetRoot) {
+    const entries = await fs.readdir(sourceRoot, { withFileTypes: true });
+    for (const entry of entries) {
+        const sourcePath = path.join(sourceRoot, entry.name);
+        const targetPath = path.join(targetRoot, entry.name);
+        if (entry.isDirectory()) {
+            await fs.mkdir(targetPath, { recursive: true });
+            await copyVendoredTree(sourcePath, targetPath);
+            continue;
+        }
+        await fs.copyFile(sourcePath, targetPath);
+    }
+}
+async function patchStarlightPackageRoot(starlightRoot) {
+    const packageJsonPath = path.join(starlightRoot, 'package.json');
+    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+    const coreVendorRoot = path.join(path.dirname(path.dirname(starlightRoot)), '@treeseed/core/dist/vendor/starlight');
+    await copyVendoredTree(coreVendorRoot, starlightRoot);
+    packageJson.exports = {
+        ...packageJson.exports,
+        '.': './index.js',
+        './schema': './schema.js',
+        './loaders': './loaders.js',
+        './route-data': './route-data.js',
+        './internal': './internal.js',
+        './components': './components.js',
+    };
+    await fs.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, 'utf8');
+}
+async function run() {
+    const existingFiles = [];
+    for (const collectionFile of candidateCollectionFiles) {
+        try {
+            await fs.access(collectionFile);
+            existingFiles.push(collectionFile);
+        }
+        catch {
+            // Ignore missing dependency trees.
+        }
+    }
+    if (existingFiles.length === 0) {
+        throw new Error('Unable to find any Starlight collection helper files to patch.');
+    }
+    let patchedAny = false;
+    for (const collectionFile of existingFiles) {
+        const result = await patchCollectionFile(collectionFile);
+        patchedAny = patchedAny || result === 'patched';
+    }
+    for (const starlightRoot of candidateStarlightRoots) {
+        try {
+            await fs.access(path.join(starlightRoot, 'package.json'));
+            await patchStarlightPackageRoot(starlightRoot);
+            patchedAny = true;
+        }
+        catch {
+            // Ignore missing dependency trees.
+        }
+    }
+    console.log(patchedAny
+        ? 'Applied Starlight knowledge-path patch.'
+        : 'Starlight knowledge-path patch already applied.');
+}
+run().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/scripts/paths.js

@@ -0,0 +1,11 @@
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { requireSharedFixtureRoot } from './fixture-tools.js';
+const packageCandidate = resolve(fileURLToPath(new URL('..', import.meta.url)));
+export const packageRoot = packageCandidate.endsWith('/dist')
+    ? resolve(packageCandidate, '..')
+    : packageCandidate;
+export const fixtureRoot = requireSharedFixtureRoot();
+export const fixtureWranglerConfig = resolve(fixtureRoot, 'wrangler.toml');
+export const fixtureMigrationsRoot = resolve(fixtureRoot, 'migrations');
+export const fixtureSrcRoot = resolve(fixtureRoot, 'src');

package/dist/scripts/publish-package.js

@@ -0,0 +1,20 @@
+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);

package/dist/scripts/release-verify.js

@@ -0,0 +1,52 @@
+import { readFileSync, readdirSync } from 'node:fs';
+import { extname, join, resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { packageRoot } from './package-tools.js';
+const textExtensions = new Set(['.js', '.ts', '.mjs', '.cjs', '.d.js', '.json', '.astro', '.css']);
+const forbiddenPatterns = [
+    /['"`]file:[^'"`\n]+['"`]/,
+    /['"`]workspace:[^'"`\n]+['"`]/,
+    /['"`](?:\.\.\/|\.\/)[^'"`\n]*src\/[^'"`\n]*\.(?:[cm]?js|ts|tsx|json|astro|css)['"`]/,
+    /['"`][^'"`\n]*\/packages\/[^'"`\n]*\/src\/[^'"`\n]*['"`]/,
+];
+function run(command, args) {
+    const result = spawnSync(command, args, {
+        cwd: packageRoot,
+        stdio: 'inherit',
+        env: process.env,
+    });
+    if (result.status !== 0) {
+        process.exit(result.status ?? 1);
+    }
+}
+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));
+            continue;
+        }
+        files.push(fullPath);
+    }
+    return files;
+}
+function scanDirectory(root) {
+    for (const filePath of walkFiles(root)) {
+        if (!textExtensions.has(extname(filePath)))
+            continue;
+        const source = readFileSync(filePath, 'utf8');
+        for (const pattern of forbiddenPatterns) {
+            if (pattern.test(source)) {
+                throw new Error(`${filePath} contains forbidden publish reference matching ${pattern}.`);
+            }
+        }
+    }
+}
+run('npm', ['run', 'fixtures:check']);
+run('npm', ['run', 'build:dist']);
+scanDirectory(resolve(packageRoot, 'dist'));
+run('npm', ['run', 'test:unit']);
+run('npm', ['run', 'check']);
+run('npm', ['run', 'build']);
+run('npm', ['run', 'test:smoke']);

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

@@ -0,0 +1,21 @@
+import { spawnSync } from 'node:child_process';
+import { fixtureRoot, packageRoot } from './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]');
+    process.exit(1);
+}
+const result = spawnSync('npx', ['astro', command, '--root', fixtureRoot, ...rest], {
+    cwd: packageRoot,
+    stdio: 'inherit',
+    env: {
+        ...process.env,
+        TREESEED_TENANT_ROOT: fixtureRoot,
+    },
+    shell: process.platform === 'win32',
+});
+if (result.error) {
+    console.error(result.error.message);
+    process.exit(1);
+}
+process.exit(result.status ?? 1);

package/dist/scripts/tenant-astro-command.js

@@ -0,0 +1,3 @@
+import { astroBin, runNodeBinary } from './package-tools.js';
+const args = process.argv.slice(2);
+runNodeBinary(astroBin, args, { cwd: process.cwd() });

package/dist/scripts/tenant-build.js

@@ -0,0 +1,16 @@
+import { astroBin, createProductionBuildEnv, packageScriptPath, runNodeBinary, runNodeScript } from './package-tools.js';
+process.env.TREESEED_LOCAL_DEV_MODE = process.env.TREESEED_LOCAL_DEV_MODE ?? 'cloudflare';
+runNodeScript(packageScriptPath('patch-starlight-content-path'), [], { cwd: process.cwd() });
+runNodeScript(packageScriptPath('aggregate-book'), [], { cwd: process.cwd() });
+runNodeBinary(astroBin, ['build'], {
+    cwd: process.cwd(),
+    env: createProductionBuildEnv({
+        TREESEED_LOCAL_DEV_MODE: process.env.TREESEED_LOCAL_DEV_MODE,
+    }),
+});
+runNodeScript(packageScriptPath('build-tenant-worker'), [], {
+    cwd: process.cwd(),
+    env: createProductionBuildEnv({
+        TREESEED_LOCAL_DEV_MODE: process.env.TREESEED_LOCAL_DEV_MODE,
+    }),
+});

package/dist/scripts/tenant-check.js

@@ -0,0 +1,7 @@
+import { createProductionBuildEnv, packageScriptPath, runNodeScript } from './package-tools.js';
+runNodeScript(packageScriptPath('patch-starlight-content-path'), [], { cwd: process.cwd() });
+runNodeScript(packageScriptPath('aggregate-book'), [], { cwd: process.cwd() });
+runNodeScript(packageScriptPath('tenant-build'), [], {
+    cwd: process.cwd(),
+    env: createProductionBuildEnv(),
+});

package/dist/scripts/test-smoke.js

@@ -0,0 +1,105 @@
+import { existsSync, mkdirSync, readdirSync, 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 { createRequire } from 'node:module';
+import { packageRoot } from './package-tools.js';
+const require = createRequire(import.meta.url);
+const sdkPackageRoot = resolve(dirname(require.resolve('@treeseed/sdk')), '..');
+function run(command, args, cwd = packageRoot, capture = false) {
+    const result = spawnSync(command, args, {
+        cwd,
+        stdio: capture ? 'pipe' : 'inherit',
+        encoding: 'utf8',
+        env: process.env,
+    });
+    if (result.status !== 0) {
+        throw new Error(result.stderr?.trim() || result.stdout?.trim() || `${command} ${args.join(' ')} failed`);
+    }
+    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;
+        }
+        catch {
+        }
+        const parent = resolve(current, '..');
+        if (parent === current)
+            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') {
+            continue;
+        }
+        const targetPath = resolve(tempRoot, 'node_modules', entry.name);
+        mkdirSync(dirname(targetPath), { recursive: true });
+        symlinkSync(resolve(sharedNodeModules, entry.name), targetPath, 'dir');
+    }
+}
+function pack(root, outputRoot, fallbackName) {
+    const bundledTarball = readdirSync(root, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.tgz'))
+        .map((entry) => resolve(root, entry.name))
+        .sort((left, right) => left.localeCompare(right, undefined, { numeric: true, sensitivity: 'base' }))
+        .at(-1);
+    if (bundledTarball && !existsSync(resolve(root, 'scripts', 'run-ts.mjs'))) {
+        return bundledTarball;
+    }
+    mkdirSync(outputRoot, { recursive: true });
+    const output = run('npm', ['pack', '--silent', '--ignore-scripts', '--pack-destination', outputRoot], root, true);
+    const filename = output
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .at(-1) ?? fallbackName;
+    return resolve(outputRoot, filename);
+}
+function installPackageDirectory(tempRoot, packageRoot, folderName) {
+    mkdirSync(resolve(tempRoot, 'node_modules', '@treeseed'), { recursive: true });
+    run('cp', ['-R', packageRoot, resolve(tempRoot, 'node_modules', '@treeseed', folderName)]);
+}
+function installPackagedPackage(extractRoot, tempRoot, packageName, folderName) {
+    mkdirSync(resolve(tempRoot, 'node_modules', '@treeseed'), { recursive: true });
+    run('tar', ['-xzf', packageName, '-C', extractRoot]);
+    run('cp', ['-R', resolve(extractRoot, 'package'), resolve(tempRoot, 'node_modules', '@treeseed', folderName)]);
+    rmSync(resolve(extractRoot, 'package'), { recursive: true, force: true });
+}
+const stageRoot = mkdtempSync(join(tmpdir(), 'treeseed-core-smoke-'));
+const packRoot = resolve(stageRoot, 'pack');
+const extractRoot = resolve(stageRoot, 'extract');
+const installRoot = resolve(stageRoot, 'install');
+try {
+    mkdirSync(packRoot, { recursive: true });
+    mkdirSync(extractRoot, { recursive: true });
+    const coreTarball = pack(packageRoot, packRoot, 'treeseed-core.tgz');
+    if (existsSync(resolve(sdkPackageRoot, 'scripts', 'run-ts.mjs'))) {
+        const sdkTarball = pack(sdkPackageRoot, packRoot, 'treeseed-sdk.tgz');
+        installPackagedPackage(extractRoot, installRoot, sdkTarball, 'sdk');
+    }
+    else {
+        installPackageDirectory(installRoot, sdkPackageRoot, 'sdk');
+    }
+    installPackagedPackage(extractRoot, installRoot, coreTarball, 'core');
+    mirrorDependencies(installRoot);
+    writeFileSync(resolve(installRoot, 'package.json'), `${JSON.stringify({ name: 'treeseed-core-smoke', private: true, type: 'module' }, null, 2)}\n`, 'utf8');
+    run(process.execPath, ['--input-type=module', '-e', 'await import("@treeseed/core");'], installRoot);
+    console.log('Core packed-install smoke passed.');
+}
+finally {
+    rmSync(stageRoot, { recursive: true, force: true });
+}

package/dist/server.js

@@ -0,0 +1,53 @@
+import { AstroError } from "astro/errors";
+import { AstroJSX, jsx } from "astro/jsx-runtime";
+import { renderJSX } from "astro/runtime/server/index.js";
+const slotName = (str) => str.trim().replace(/[-_]([a-z])/g, (_, w) => w.toUpperCase());
+async function check(Component, props, { default: children = null, ...slotted } = {}) {
+  if (typeof Component !== "function") return false;
+  const slots = {};
+  for (const [key, value] of Object.entries(slotted)) {
+    const name = slotName(key);
+    slots[name] = value;
+  }
+  try {
+    const result = await Component({ ...props, ...slots, children });
+    return result[AstroJSX];
+  } catch (e) {
+    throwEnhancedErrorIfMdxComponent(e, Component);
+  }
+  return false;
+}
+async function renderToStaticMarkup(Component, props = {}, { default: children = null, ...slotted } = {}) {
+  const slots = {};
+  for (const [key, value] of Object.entries(slotted)) {
+    const name = slotName(key);
+    slots[name] = value;
+  }
+  const { result } = this;
+  try {
+    const html = await renderJSX(result, jsx(Component, { ...props, ...slots, children }));
+    return { html };
+  } catch (e) {
+    throwEnhancedErrorIfMdxComponent(e, Component);
+    throw e;
+  }
+}
+function throwEnhancedErrorIfMdxComponent(error, Component) {
+  if (Component[Symbol.for("mdx-component")]) {
+    if (AstroError.is(error)) return;
+    error.title = error.name;
+    error.hint = `This issue often occurs when your MDX component encounters runtime errors.`;
+    throw error;
+  }
+}
+const renderer = {
+  name: "astro:jsx",
+  check,
+  renderToStaticMarkup
+};
+var server_default = renderer;
+export {
+  check,
+  server_default as default,
+  renderToStaticMarkup
+};

package/dist/site-resources.d.ts

@@ -0,0 +1,29 @@
+import type { TreeseedDeployConfig, TreeseedTenantConfig } from './contracts';
+import type { LoadedTreeseedPluginEntry } from './plugins/runtime';
+export declare const TREESEED_SITE_RESOURCE_KINDS: readonly ["pages", "styles", "components"];
+export type TreeseedSiteResourceKind = (typeof TREESEED_SITE_RESOURCE_KINDS)[number];
+export type TreeseedSiteLayerDefinition = {
+    root: string;
+    kinds?: TreeseedSiteResourceKind[];
+};
+export type TreeseedSiteLayer = {
+    owner: string;
+    root: string;
+    kinds: TreeseedSiteResourceKind[];
+};
+type SiteLayerBuildContext = {
+    projectRoot: string;
+    tenantConfig: TreeseedTenantConfig;
+    siteConfig?: unknown;
+    deployConfig?: TreeseedDeployConfig;
+};
+type SiteLayerRuntime = {
+    plugins: LoadedTreeseedPluginEntry[];
+};
+export declare function buildTreeseedSiteLayers(pluginRuntime: SiteLayerRuntime, context: SiteLayerBuildContext & {
+    coreRoot: string;
+}): TreeseedSiteLayer[];
+export declare function resolveTreeseedSiteResource(layers: TreeseedSiteLayer[], kind: TreeseedSiteResourceKind, resourcePath: string): string;
+export declare function resolveTreeseedPageEntrypoint(layers: TreeseedSiteLayer[], resourcePath: string): string;
+export declare function resolveTreeseedStyleEntrypoint(layers: TreeseedSiteLayer[], resourcePath: string): string;
+export {};

package/dist/site-resources.js

@@ -0,0 +1,127 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+const TREESEED_SITE_RESOURCE_KINDS = ["pages", "styles", "components"];
+const SITE_RESOURCE_KIND_SET = new Set(TREESEED_SITE_RESOURCE_KINDS);
+function normalizeKinds(kinds) {
+  if (!kinds || kinds.length === 0) {
+    return [...TREESEED_SITE_RESOURCE_KINDS];
+  }
+  const normalized = [...new Set(kinds)];
+  for (const kind of normalized) {
+    if (!SITE_RESOURCE_KIND_SET.has(kind)) {
+      throw new Error(`Unknown Treeseed site resource kind "${kind}".`);
+    }
+  }
+  return normalized;
+}
+function normalizeResourcePath(kind, resourcePath) {
+  const normalized = resourcePath.replace(/\\/g, "/").replace(/^\/+/, "");
+  return normalized.startsWith(`${kind}/`) ? normalized : `${kind}/${normalized}`;
+}
+function isKindSupported(layer, kind) {
+  return layer.kinds.includes(kind);
+}
+function getTenantRoot(tenantConfig, projectRoot) {
+  return tenantConfig.__tenantRoot ?? projectRoot;
+}
+function normalizeLayerDefinition(owner, baseRoot, layer) {
+  const kinds = normalizeKinds(layer.kinds);
+  const root = resolve(baseRoot, layer.root);
+  return {
+    owner,
+    root,
+    kinds
+  };
+}
+function getPluginLayers(entry, context) {
+  const plugin = entry.plugin;
+  const rawLayers = typeof plugin.siteLayers === "function" ? plugin.siteLayers({ ...context, pluginConfig: entry.config ?? {} }) : plugin.siteLayers;
+  if (!rawLayers?.length) {
+    return [];
+  }
+  return rawLayers.map((layer) => normalizeLayerDefinition(entry.package, entry.baseDir, layer));
+}
+function getTenantLayers(context) {
+  const tenantRoot = getTenantRoot(context.tenantConfig, context.projectRoot);
+  const overrides = context.tenantConfig.overrides;
+  if (!overrides) {
+    return [];
+  }
+  const layers = [];
+  if (overrides.pagesRoot) {
+    layers.push({
+      owner: "tenant",
+      root: resolve(tenantRoot, overrides.pagesRoot),
+      kinds: ["pages"]
+    });
+  }
+  if (overrides.stylesRoot) {
+    layers.push({
+      owner: "tenant",
+      root: resolve(tenantRoot, overrides.stylesRoot),
+      kinds: ["styles"]
+    });
+  }
+  if (overrides.componentsRoot) {
+    layers.push({
+      owner: "tenant",
+      root: resolve(tenantRoot, overrides.componentsRoot),
+      kinds: ["components"]
+    });
+  }
+  return layers;
+}
+function buildTreeseedSiteLayers(pluginRuntime, context) {
+  const layers = [
+    {
+      owner: "@treeseed/core",
+      root: context.coreRoot,
+      kinds: [...TREESEED_SITE_RESOURCE_KINDS]
+    }
+  ];
+  for (const entry of pluginRuntime.plugins) {
+    layers.push(...getPluginLayers(entry, context));
+  }
+  layers.push(...getTenantLayers(context));
+  return layers;
+}
+function resolveTreeseedSiteResource(layers, kind, resourcePath) {
+  const normalizedPath = normalizeResourcePath(kind, resourcePath);
+  for (let index = layers.length - 1; index >= 0; index -= 1) {
+    const layer = layers[index];
+    if (!layer || !isKindSupported(layer, kind)) {
+      continue;
+    }
+    const candidate = resolve(layer.root, normalizedPath);
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveTreeseedPageEntrypoint(layers, resourcePath) {
+  const hasExplicitExtension = /\.[A-Za-z0-9]+$/u.test(resourcePath);
+  const candidates = hasExplicitExtension ? [resourcePath, `${resourcePath}.astro`, `${resourcePath}.ts`, `${resourcePath}.js`, `${resourcePath}.mjs`] : [resourcePath, `${resourcePath}.astro`, `${resourcePath}.ts`, `${resourcePath}.js`, `${resourcePath}.mjs`];
+  for (const candidate of candidates) {
+    const resolved = resolveTreeseedSiteResource(layers, "pages", candidate);
+    if (resolved) {
+      return resolved;
+    }
+  }
+  const normalized = hasExplicitExtension ? normalizeResourcePath("pages", resourcePath) : normalizeResourcePath("pages", `${resourcePath}.astro`);
+  throw new Error(`Unable to resolve Treeseed page resource "${normalized}".`);
+}
+function resolveTreeseedStyleEntrypoint(layers, resourcePath) {
+  const resolved = resolveTreeseedSiteResource(layers, "styles", resourcePath);
+  if (!resolved) {
+    throw new Error(`Unable to resolve Treeseed style resource "${normalizeResourcePath("styles", resourcePath)}".`);
+  }
+  return resolved;
+}
+export {
+  TREESEED_SITE_RESOURCE_KINDS,
+  buildTreeseedSiteLayers,
+  resolveTreeseedPageEntrypoint,
+  resolveTreeseedSiteResource,
+  resolveTreeseedStyleEntrypoint
+};