@treeseed/core 0.4.1 → 0.4.4

package/dist/api/types.d.ts

@@ -0,0 +1,193 @@
+import type { AgentSdk, SdkQueueMessageEnvelope } from '@treeseed/sdk';
+import type { ApiPrincipal, ApiScope, DeviceCodeApproveRequest as SdkDeviceCodeApproveRequest, DeviceCodePollRequest, DeviceCodePollResponse, DeviceCodeStartRequest, DeviceCodeStartResponse, RemoteWorkflowOperationRequest as WorkflowHttpOperationRequest, RemoteWorkflowOperationResponse as ApiWorkflowOperationResponse, RemoteSdkOperationRequest as SdkHttpOperationRequest, TokenRefreshRequest, TokenRefreshResponse } from '@treeseed/sdk/remote';
+export type { ApiPrincipal, ApiScope, DeviceCodePollRequest, DeviceCodePollResponse, DeviceCodeStartRequest, DeviceCodeStartResponse, WorkflowHttpOperationRequest, ApiWorkflowOperationResponse, SdkHttpOperationRequest, TokenRefreshRequest, TokenRefreshResponse, };
+export type DeviceCodeApproveRequest = SdkDeviceCodeApproveRequest;
+export interface ApiAuthProvider {
+    readonly id: string;
+    startDeviceFlow(request: DeviceCodeStartRequest): Promise<DeviceCodeStartResponse>;
+    pollDeviceFlow(request: DeviceCodePollRequest): Promise<DeviceCodePollResponse>;
+    refreshAccessToken(request: TokenRefreshRequest): Promise<TokenRefreshResponse>;
+    approveDeviceFlow(request: DeviceCodeApproveRequest): Promise<{
+        ok: true;
+    }>;
+    authenticateBearerToken(token: string): Promise<{
+        principal: ApiPrincipal;
+        credential: ApiCredential;
+    } | null>;
+    authenticateServiceCredential(serviceId: string, secret: string): Promise<{
+        principal: ApiPrincipal;
+        credential: ApiCredential;
+    } | null>;
+    createPersonalAccessToken(userId: string, input: {
+        name: string;
+        scopes?: string[];
+        expiresAt?: string | null;
+    }): Promise<{
+        id: string;
+        token: string;
+        prefix: string;
+        name: string;
+        expiresAt: string | null;
+    }>;
+    listPersonalAccessTokens(userId: string): Promise<Array<{
+        id: string;
+        name: string;
+        token_prefix: string;
+        expires_at: string | null;
+        last_used_at: string | null;
+        revoked_at: string | null;
+        created_at: string;
+    }>>;
+    revokePersonalAccessToken(userId: string, tokenId: string): Promise<void>;
+    syncUserIdentity(identity: UserIdentityProfileInput): Promise<{
+        principal: ApiPrincipal;
+        userId: string;
+        identityId: string | null;
+    }>;
+    createServiceToken(input: {
+        serviceId: string;
+        name: string;
+        roles?: string[];
+        permissions?: string[];
+    }): Promise<{
+        id: string;
+        serviceId: string;
+        secret: string;
+    }>;
+    rotateServiceToken(serviceId: string): Promise<{
+        id: string;
+        serviceId: string;
+        secret: string;
+    }>;
+    createTrustedUserAssertion(claims: TrustedUserAssertionClaims): string;
+    verifyTrustedUserAssertion(assertion: string): TrustedUserAssertionClaims | null;
+    exchangeTrustedUserAssertion(claims: TrustedUserAssertionClaims): Promise<{
+        ok: true;
+        accessToken: string;
+        tokenType: 'Bearer';
+        expiresAt: string;
+        expiresInSeconds: number;
+        principal: ApiPrincipal;
+    }>;
+}
+export type ApiRuntimeProviderSelections = {
+    auth: string;
+    agents: {
+        execution: string;
+        queue: string;
+        notification: string;
+        repository: string;
+        verification: string;
+    };
+};
+export interface ApiConfig {
+    name: string;
+    host: string;
+    port: number;
+    baseUrl: string;
+    issuer: string;
+    repoRoot: string;
+    authSecret: string;
+    cloudflareAccountId?: string;
+    cloudflareApiToken?: string;
+    d1DatabaseId?: string;
+    d1DatabaseName?: string;
+    d1LocalPersistTo?: string;
+    webServiceId: string;
+    webServiceSecret: string;
+    webAssertionSecret: string;
+    webExchangeTtlSeconds: number;
+    bootstrapAdminAllowlist: string[];
+    accessTokenTtlSeconds: number;
+    refreshTokenTtlSeconds: number;
+    deviceCodeTtlSeconds: number;
+    deviceCodePollIntervalSeconds: number;
+    templateCatalogPath?: string;
+    providers: ApiRuntimeProviderSelections;
+}
+export interface AppVariables {
+    requestId: string;
+    config: ApiConfig;
+    principal: ApiPrincipal | null;
+    actingUser: ApiPrincipal | null;
+    credential: ApiCredential | null;
+    actorType: 'anonymous' | 'user' | 'service';
+    permissionGrants: string[];
+}
+export interface ApiCredential {
+    type: 'access_token' | 'personal_access_token' | 'service_secret' | 'service_token';
+    id: string;
+    label?: string;
+}
+export interface TrustedUserAssertionClaims {
+    userId: string;
+    sessionId: string;
+    identityId?: string | null;
+    authTime: string;
+    expiresAt: string;
+    nonce: string;
+}
+export interface UserIdentityProfileInput {
+    provider: string;
+    providerSubject: string;
+    email?: string | null;
+    emailVerified?: boolean;
+    displayName?: string | null;
+    profile?: Record<string, unknown>;
+}
+export type ApiProviderFactory<T> = (options: {
+    config: ApiConfig;
+}) => T;
+export interface ApiRuntimeProviders {
+    auth?: Record<string, ApiProviderFactory<ApiAuthProvider>>;
+    agentExecution?: Record<string, unknown>;
+    agentQueue?: Record<string, unknown>;
+    agentNotification?: Record<string, unknown>;
+    agentRepository?: Record<string, unknown>;
+    agentVerification?: Record<string, unknown>;
+}
+export interface ResolvedApiRuntimeProviders {
+    auth: ApiAuthProvider;
+    registries: {
+        auth: Map<string, ApiProviderFactory<ApiAuthProvider>>;
+        agentExecution: Map<string, unknown>;
+        agentQueue: Map<string, unknown>;
+        agentNotification: Map<string, unknown>;
+        agentRepository: Map<string, unknown>;
+        agentVerification: Map<string, unknown>;
+    };
+    selections: ApiRuntimeProviderSelections;
+}
+export interface ApiServerOptions {
+    config?: Partial<ApiConfig>;
+    runtimeProviders?: ApiRuntimeProviders;
+    sdk?: AgentSdk;
+    workflowExecutor?: (operation: string, request: WorkflowHttpOperationRequest) => Promise<ApiWorkflowOperationResponse>;
+    surfaces?: Partial<{
+        auth: boolean;
+        templates: boolean;
+        sdk: boolean;
+        agent: boolean;
+        operations: boolean;
+    }>;
+    scopes?: Partial<{
+        authMe: ApiScope;
+        sdk: ApiScope;
+        agent: ApiScope;
+        operations: ApiScope;
+    }>;
+    log?: (message: string, details?: Record<string, unknown>) => void;
+}
+export interface GatewayQueueProducer {
+    enqueue(request: {
+        queueName?: string;
+        message: SdkQueueMessageEnvelope;
+        delaySeconds?: number;
+    }): Promise<void>;
+}
+export interface GatewayServerOptions {
+    sdk: AgentSdk;
+    bearerToken: string;
+    queueProducer?: GatewayQueueProducer;
+    projectId?: string;
+}

package/dist/api.d.ts

@@ -0,0 +1 @@
+export * from './api/index';

package/dist/api.js

@@ -0,0 +1 @@
+export * from "./api/index.js";

package/dist/dev.d.ts

@@ -0,0 +1,41 @@
+import type { ChildProcess, SpawnOptions } from 'node:child_process';
+export declare const TREESEED_DEFAULT_WEB_HOST = "127.0.0.1";
+export declare const TREESEED_DEFAULT_WEB_PORT = 4321;
+export declare const TREESEED_DEFAULT_API_HOST = "127.0.0.1";
+export declare const TREESEED_DEFAULT_API_PORT = 3000;
+export type TreeseedIntegratedDevSurface = 'integrated' | 'web' | 'api';
+export type TreeseedIntegratedDevOptions = {
+    surface?: TreeseedIntegratedDevSurface;
+    watch?: boolean;
+    cwd?: string;
+    stdio?: SpawnOptions['stdio'];
+    env?: NodeJS.ProcessEnv;
+    webHost?: string;
+    webPort?: number;
+    apiHost?: string;
+    apiPort?: number;
+};
+export type TreeseedIntegratedDevCommand = {
+    id: 'web' | 'api';
+    label: string;
+    command: string;
+    args: string[];
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+};
+export type TreeseedIntegratedDevPlan = {
+    surface: TreeseedIntegratedDevSurface;
+    tenantRoot: string;
+    apiBaseUrl: string;
+    commands: TreeseedIntegratedDevCommand[];
+};
+type SpawnLike = (command: string, args: string[], options: SpawnOptions) => ChildProcess;
+type SignalRegistrar = (signal: NodeJS.Signals, handler: () => void) => () => void;
+type TreeseedIntegratedDevDependencies = {
+    spawn: SpawnLike;
+    onSignal: SignalRegistrar;
+    prepareEnvironment: (tenantRoot: string) => void;
+};
+export declare function createTreeseedIntegratedDevPlan(options?: TreeseedIntegratedDevOptions): TreeseedIntegratedDevPlan;
+export declare function runTreeseedIntegratedDev(options?: TreeseedIntegratedDevOptions, deps?: Partial<TreeseedIntegratedDevDependencies>): Promise<number>;
+export {};

package/dist/dev.js

@@ -0,0 +1,189 @@
+import { existsSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { applyTreeseedEnvironmentToProcess, assertTreeseedCommandEnvironment } from "@treeseed/sdk/workflow-support";
+const require2 = createRequire(import.meta.url);
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const TREESEED_DEFAULT_WEB_HOST = "127.0.0.1";
+const TREESEED_DEFAULT_WEB_PORT = 4321;
+const TREESEED_DEFAULT_API_HOST = "127.0.0.1";
+const TREESEED_DEFAULT_API_PORT = 3e3;
+function resolvePackageRoot(packageName, tenantRoot) {
+  const resolvedPath = require2.resolve(packageName, {
+    paths: [tenantRoot, packageRoot, process.cwd()]
+  });
+  let currentDir = dirname(resolvedPath);
+  while (!existsSync(resolve(currentDir, "package.json"))) {
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      throw new Error(`Unable to resolve package root for "${packageName}".`);
+    }
+    currentDir = parentDir;
+  }
+  return currentDir;
+}
+function resolveNodeEntrypoint(packageDir, sourceRelativePath, distRelativePath) {
+  const sourcePath = resolve(packageDir, sourceRelativePath);
+  const runTsPath = resolve(packageDir, "scripts", "run-ts.mjs");
+  if (existsSync(sourcePath) && existsSync(runTsPath)) {
+    return {
+      command: process.execPath,
+      args: [runTsPath, sourcePath]
+    };
+  }
+  return {
+    command: process.execPath,
+    args: [resolve(packageDir, distRelativePath)]
+  };
+}
+function withWatchArgs(args, watchPaths) {
+  return watchPaths.flatMap((watchPath) => ["--watch-path", watchPath]).concat(args);
+}
+function normalizePort(value, fallback) {
+  return Number.isInteger(value) && Number(value) > 0 ? Number(value) : fallback;
+}
+function createTreeseedIntegratedDevPlan(options = {}) {
+  const tenantRoot = resolve(options.cwd ?? process.cwd());
+  const surface = options.surface ?? "integrated";
+  const watch = options.watch === true;
+  const webHost = options.webHost ?? TREESEED_DEFAULT_WEB_HOST;
+  const webPort = normalizePort(options.webPort, TREESEED_DEFAULT_WEB_PORT);
+  const apiHost = options.apiHost ?? TREESEED_DEFAULT_API_HOST;
+  const apiPort = normalizePort(options.apiPort, TREESEED_DEFAULT_API_PORT);
+  const mergedEnv = { ...process.env, ...options.env ?? {} };
+  const apiBaseUrl = mergedEnv.TREESEED_API_BASE_URL?.trim() || `http://${apiHost}:${apiPort}`;
+  const sdkPackageRoot = resolvePackageRoot("@treeseed/sdk", tenantRoot);
+  const webEntrypoint = resolveNodeEntrypoint(
+    sdkPackageRoot,
+    "scripts/tenant-astro-command.ts",
+    "dist/scripts/tenant-astro-command.js"
+  );
+  const apiEntrypoint = resolveNodeEntrypoint(
+    packageRoot,
+    "src/api/server.ts",
+    "dist/api/server.js"
+  );
+  const watchPaths = [
+    resolve(packageRoot, existsSync(resolve(packageRoot, "src")) ? "src" : "dist"),
+    resolve(tenantRoot, "src"),
+    resolve(tenantRoot, "treeseed.site.yaml"),
+    resolve(tenantRoot, "astro.config.ts")
+  ];
+  const sharedEnv = {
+    ...mergedEnv,
+    TREESEED_LOCAL_DEV_MODE: mergedEnv.TREESEED_LOCAL_DEV_MODE ?? "cloudflare",
+    TREESEED_API_BASE_URL: apiBaseUrl
+  };
+  if (watch) {
+    sharedEnv.TREESEED_PUBLIC_DEV_WATCH_RELOAD = sharedEnv.TREESEED_PUBLIC_DEV_WATCH_RELOAD || "true";
+  }
+  const commands = [];
+  if (surface === "integrated" || surface === "web") {
+    commands.push({
+      id: "web",
+      label: "Astro UI",
+      command: webEntrypoint.command,
+      args: [...webEntrypoint.args, "dev", "--host", webHost, "--port", String(webPort)],
+      cwd: tenantRoot,
+      env: sharedEnv
+    });
+  }
+  if (surface === "integrated" || surface === "api") {
+    commands.push({
+      id: "api",
+      label: "Hono API",
+      command: apiEntrypoint.command,
+      args: watch ? withWatchArgs(apiEntrypoint.args, watchPaths) : apiEntrypoint.args,
+      cwd: tenantRoot,
+      env: {
+        ...sharedEnv,
+        PORT: sharedEnv.PORT ?? String(apiPort)
+      }
+    });
+  }
+  return {
+    surface,
+    tenantRoot,
+    apiBaseUrl,
+    commands
+  };
+}
+function defaultSignalRegistrar(signal, handler) {
+  process.on(signal, handler);
+  return () => {
+    process.off(signal, handler);
+  };
+}
+function defaultPrepareEnvironment(tenantRoot) {
+  applyTreeseedEnvironmentToProcess({ tenantRoot, scope: "local", override: true });
+  assertTreeseedCommandEnvironment({ tenantRoot, scope: "local", purpose: "dev" });
+}
+function stopChildProcess(child, signal = "SIGTERM") {
+  if (!child || typeof child.kill !== "function") {
+    return;
+  }
+  try {
+    child.kill(signal);
+  } catch {
+  }
+}
+async function runTreeseedIntegratedDev(options = {}, deps = {}) {
+  const tenantRoot = resolve(options.cwd ?? process.cwd());
+  const prepareEnvironment = deps.prepareEnvironment ?? defaultPrepareEnvironment;
+  prepareEnvironment(tenantRoot);
+  const plan = createTreeseedIntegratedDevPlan({
+    ...options,
+    cwd: tenantRoot,
+    env: {
+      ...process.env,
+      ...options.env ?? {}
+    }
+  });
+  const spawnProcess = deps.spawn ?? spawn;
+  const onSignal = deps.onSignal ?? defaultSignalRegistrar;
+  const children = /* @__PURE__ */ new Map();
+  let settled = false;
+  return await new Promise((resolveExitCode) => {
+    const disposers = [
+      onSignal("SIGINT", () => finalize(130)),
+      onSignal("SIGTERM", () => finalize(143))
+    ];
+    function finalize(exitCode, originId) {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      for (const [childId, child] of children.entries()) {
+        if (childId !== originId) {
+          stopChildProcess(child);
+        }
+      }
+      for (const dispose of disposers) {
+        dispose();
+      }
+      resolveExitCode(exitCode);
+    }
+    for (const command of plan.commands) {
+      const child = spawnProcess(command.command, command.args, {
+        cwd: command.cwd,
+        env: command.env,
+        stdio: options.stdio ?? "inherit"
+      });
+      children.set(command.id, child);
+      child.on("exit", (code, signal) => {
+        const exitCode = signal === "SIGINT" ? 130 : signal === "SIGTERM" ? 143 : code ?? 0;
+        finalize(exitCode, command.id);
+      });
+    }
+  });
+}
+export {
+  TREESEED_DEFAULT_API_HOST,
+  TREESEED_DEFAULT_API_PORT,
+  TREESEED_DEFAULT_WEB_HOST,
+  TREESEED_DEFAULT_WEB_PORT,
+  createTreeseedIntegratedDevPlan,
+  runTreeseedIntegratedDev
+};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { buildTreeseedSiteLayers, resolveTreeseedPageEntrypoint, resolveTreeseedSiteResource, resolveTreeseedStyleEntrypoint, TREESEED_SITE_RESOURCE_KINDS, } from './site-resources';
+export { buildTreeseedPlatformLayers, resolveTreeseedPlatformResource, TREESEED_PLATFORM_RESOURCE_KINDS, } from './platform-resources';
+export { parseSiteConfig } from './utils/site-config-schema.js';
+export { createTreeseedApiApp } from './api/app';
+export { createTreeseedGatewayApp } from './api/gateway';
+export { createRailwayTreeseedApiServer } from './api/railway';
+export { resolveApiConfig } from './api/config';
+export { createTreeseedIntegratedDevPlan, runTreeseedIntegratedDev, type TreeseedIntegratedDevCommand, type TreeseedIntegratedDevOptions, type TreeseedIntegratedDevPlan, type TreeseedIntegratedDevSurface, } from './dev';
+export type * from './api/types';

package/dist/index.js

@@ -5,12 +5,34 @@ import {
   resolveTreeseedStyleEntrypoint,
   TREESEED_SITE_RESOURCE_KINDS
 } from "./site-resources.js";
+import {
+  buildTreeseedPlatformLayers,
+  resolveTreeseedPlatformResource,
+  TREESEED_PLATFORM_RESOURCE_KINDS
+} from "./platform-resources.js";
 import { parseSiteConfig } from "./utils/site-config-schema.js";
+import { createTreeseedApiApp } from "./api/app.js";
+import { createTreeseedGatewayApp } from "./api/gateway.js";
+import { createRailwayTreeseedApiServer } from "./api/railway.js";
+import { resolveApiConfig } from "./api/config.js";
+import {
+  createTreeseedIntegratedDevPlan,
+  runTreeseedIntegratedDev
+} from "./dev.js";
 export {
+  TREESEED_PLATFORM_RESOURCE_KINDS,
   TREESEED_SITE_RESOURCE_KINDS,
+  buildTreeseedPlatformLayers,
   buildTreeseedSiteLayers,
+  createRailwayTreeseedApiServer,
+  createTreeseedApiApp,
+  createTreeseedGatewayApp,
+  createTreeseedIntegratedDevPlan,
   parseSiteConfig,
+  resolveApiConfig,
   resolveTreeseedPageEntrypoint,
+  resolveTreeseedPlatformResource,
   resolveTreeseedSiteResource,
-  resolveTreeseedStyleEntrypoint
+  resolveTreeseedStyleEntrypoint,
+  runTreeseedIntegratedDev
 };

package/dist/platform-resources.d.ts

@@ -0,0 +1,37 @@
+import type { TreeseedDeployConfig, TreeseedPlatformLayerDefinition, TreeseedPlatformResourceKind, TreeseedPlatformSurfaceName, TreeseedTenantConfig } from '@treeseed/sdk/platform/contracts';
+import type { LoadedTreeseedPluginEntry } from '@treeseed/sdk/platform/plugins';
+export declare const TREESEED_PLATFORM_RESOURCE_KINDS: readonly ["pages", "styles", "components", "routes", "middleware", "handlers", "config"];
+export declare const TREESEED_SITE_RESOURCE_KINDS: readonly ["pages", "styles", "components"];
+export type TreeseedSiteResourceKind = (typeof TREESEED_SITE_RESOURCE_KINDS)[number];
+export type TreeseedPlatformLayer = {
+    owner: string;
+    surface: TreeseedPlatformSurfaceName;
+    root: string;
+    kinds: TreeseedPlatformResourceKind[];
+};
+export type TreeseedSiteLayerDefinition = TreeseedPlatformLayerDefinition & {
+    kinds?: TreeseedSiteResourceKind[];
+};
+export type TreeseedSiteLayer = TreeseedPlatformLayer & {
+    kinds: TreeseedSiteResourceKind[];
+    surface: 'web';
+};
+type PlatformLayerBuildContext = {
+    projectRoot: string;
+    tenantConfig: TreeseedTenantConfig;
+    siteConfig?: unknown;
+    deployConfig?: TreeseedDeployConfig;
+    coreRoot: string;
+    surface: TreeseedPlatformSurfaceName;
+    defaultKinds: TreeseedPlatformResourceKind[];
+};
+type PlatformLayerRuntime = {
+    plugins: LoadedTreeseedPluginEntry[];
+};
+export declare function buildTreeseedPlatformLayers(pluginRuntime: PlatformLayerRuntime, context: PlatformLayerBuildContext): TreeseedPlatformLayer[];
+export declare function resolveTreeseedPlatformResource(layers: TreeseedPlatformLayer[], kind: TreeseedPlatformResourceKind, resourcePath: string): string;
+export declare function buildTreeseedSiteLayers(pluginRuntime: PlatformLayerRuntime, context: Omit<PlatformLayerBuildContext, 'surface' | 'defaultKinds'>): 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/platform-resources.js

@@ -0,0 +1,133 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+const TREESEED_PLATFORM_RESOURCE_KINDS = [
+  "pages",
+  "styles",
+  "components",
+  "routes",
+  "middleware",
+  "handlers",
+  "config"
+];
+const TREESEED_SITE_RESOURCE_KINDS = ["pages", "styles", "components"];
+const PLATFORM_RESOURCE_KIND_SET = new Set(TREESEED_PLATFORM_RESOURCE_KINDS);
+function normalizeKinds(kinds, fallbackKinds) {
+  const normalized = kinds?.length ? [...new Set(kinds)] : [...fallbackKinds];
+  for (const kind of normalized) {
+    if (!PLATFORM_RESOURCE_KIND_SET.has(kind)) {
+      throw new Error(`Unknown Treeseed platform 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, context) {
+  return {
+    owner,
+    surface: context.surface,
+    root: resolve(baseRoot, layer.root),
+    kinds: normalizeKinds(layer.kinds, context.defaultKinds)
+  };
+}
+function getPluginLayers(entry, context) {
+  const plugin = entry.plugin;
+  const platformLayers = typeof plugin.platformLayers === "function" ? plugin.platformLayers({ ...context, pluginConfig: entry.config ?? {} }) : plugin.platformLayers;
+  const surfaceLayers = (platformLayers ?? []).filter((layer) => !layer.surface || layer.surface === context.surface).map((layer) => normalizeLayerDefinition(entry.package, entry.baseDir, layer, context));
+  if (context.surface !== "web") {
+    return surfaceLayers;
+  }
+  const legacySiteLayers = typeof plugin.siteLayers === "function" ? plugin.siteLayers({ ...context, pluginConfig: entry.config ?? {} }) : plugin.siteLayers;
+  return [
+    ...surfaceLayers,
+    ...(legacySiteLayers ?? []).map((layer) => normalizeLayerDefinition(entry.package, entry.baseDir, layer, context))
+  ];
+}
+function getTenantLayers(context) {
+  const tenantRoot = getTenantRoot(context.tenantConfig, context.projectRoot);
+  const surfaceOverrides = context.tenantConfig.overrides?.surfaces?.[context.surface];
+  const legacyWebLayers = context.surface === "web" ? [
+    context.tenantConfig.overrides?.pagesRoot ? { root: context.tenantConfig.overrides.pagesRoot, kinds: ["pages"] } : null,
+    context.tenantConfig.overrides?.stylesRoot ? { root: context.tenantConfig.overrides.stylesRoot, kinds: ["styles"] } : null,
+    context.tenantConfig.overrides?.componentsRoot ? { root: context.tenantConfig.overrides.componentsRoot, kinds: ["components"] } : null
+  ].filter(Boolean) : [];
+  return [...surfaceOverrides?.layers ?? [], ...legacyWebLayers].map(
+    (layer) => normalizeLayerDefinition("tenant", tenantRoot, layer, context)
+  );
+}
+function buildTreeseedPlatformLayers(pluginRuntime, context) {
+  const layers = [
+    {
+      owner: "@treeseed/core",
+      surface: context.surface,
+      root: context.coreRoot,
+      kinds: [...context.defaultKinds]
+    }
+  ];
+  for (const entry of pluginRuntime.plugins) {
+    layers.push(...getPluginLayers(entry, context));
+  }
+  layers.push(...getTenantLayers(context));
+  return layers;
+}
+function resolveTreeseedPlatformResource(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 buildTreeseedSiteLayers(pluginRuntime, context) {
+  return buildTreeseedPlatformLayers(pluginRuntime, {
+    ...context,
+    surface: "web",
+    defaultKinds: [...TREESEED_SITE_RESOURCE_KINDS]
+  });
+}
+function resolveTreeseedSiteResource(layers, kind, resourcePath) {
+  return resolveTreeseedPlatformResource(layers, kind, resourcePath);
+}
+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_PLATFORM_RESOURCE_KINDS,
+  TREESEED_SITE_RESOURCE_KINDS,
+  buildTreeseedPlatformLayers,
+  buildTreeseedSiteLayers,
+  resolveTreeseedPageEntrypoint,
+  resolveTreeseedPlatformResource,
+  resolveTreeseedSiteResource,
+  resolveTreeseedStyleEntrypoint
+};

package/dist/platform.d.ts

@@ -0,0 +1,2 @@
+export { buildTreeseedPlatformLayers, resolveTreeseedPlatformResource, TREESEED_PLATFORM_RESOURCE_KINDS, type TreeseedPlatformLayer, } from './platform-resources';
+export { createTreeseedIntegratedDevPlan, runTreeseedIntegratedDev, type TreeseedIntegratedDevCommand, type TreeseedIntegratedDevOptions, type TreeseedIntegratedDevPlan, type TreeseedIntegratedDevSurface, } from './dev';

package/dist/platform.js

@@ -0,0 +1,16 @@
+import {
+  buildTreeseedPlatformLayers,
+  resolveTreeseedPlatformResource,
+  TREESEED_PLATFORM_RESOURCE_KINDS
+} from "./platform-resources.js";
+import {
+  createTreeseedIntegratedDevPlan,
+  runTreeseedIntegratedDev
+} from "./dev.js";
+export {
+  TREESEED_PLATFORM_RESOURCE_KINDS,
+  buildTreeseedPlatformLayers,
+  createTreeseedIntegratedDevPlan,
+  resolveTreeseedPlatformResource,
+  runTreeseedIntegratedDev
+};

package/dist/plugin-default.d.ts

@@ -0,0 +1 @@
+export { default } from '@treeseed/sdk/plugin-default';

package/dist/plugin-default.js

@@ -0,0 +1,4 @@
+import { default as default2 } from "@treeseed/sdk/plugin-default";
+export {
+  default2 as default
+};

package/dist/railway.d.ts

@@ -0,0 +1 @@
+export { createRailwayTreeseedApiServer } from './api/railway';