@treeseed/sdk 0.4.2 → 0.4.4

package/dist/d1-http.d.ts

@@ -0,0 +1,38 @@
+import type { D1DatabaseLike, D1PreparedStatementLike } from './types/cloudflare.ts';
+type D1QueryResult<T = Record<string, unknown>> = {
+    success?: boolean;
+    results?: T[];
+    meta?: Record<string, unknown>;
+};
+export interface CloudflareHttpD1DatabaseOptions {
+    accountId: string;
+    databaseId: string;
+    apiToken: string;
+    fetchImpl?: typeof fetch;
+}
+declare class CloudflareHttpD1PreparedStatement implements D1PreparedStatementLike {
+    private readonly endpoint;
+    private readonly apiToken;
+    private readonly fetchImpl;
+    private readonly query;
+    private bindings;
+    constructor(endpoint: string, apiToken: string, fetchImpl: typeof fetch, query: string);
+    bind(...values: unknown[]): this;
+    private execute;
+    run(): Promise<D1QueryResult<Record<string, unknown>>[]>;
+    all<T = Record<string, unknown>>(): Promise<{
+        results: T[];
+    }>;
+    first<T = Record<string, unknown>>(): Promise<NonNullable<T> | null>;
+    raw<T = unknown[]>(): Promise<T[]>;
+}
+export declare class CloudflareHttpD1Database implements D1DatabaseLike {
+    private readonly options;
+    private readonly endpoint;
+    private readonly fetchImpl;
+    constructor(options: CloudflareHttpD1DatabaseOptions);
+    prepare(query: string): CloudflareHttpD1PreparedStatement;
+    exec(query: string): Promise<D1QueryResult<Record<string, unknown>>[]>;
+}
+export declare function interpolateD1Query(query: string, bindings: unknown[]): string;
+export {};

package/dist/d1-http.js

@@ -0,0 +1,95 @@
+function toSqlValue(value) {
+  if (value === null || value === void 0) {
+    return "NULL";
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  if (typeof value === "boolean") {
+    return value ? "1" : "0";
+  }
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+function interpolateBindings(query, values) {
+  let result = query;
+  for (const value of values) {
+    result = result.replace(/\?/, toSqlValue(value));
+  }
+  return result;
+}
+class CloudflareHttpD1PreparedStatement {
+  constructor(endpoint, apiToken, fetchImpl, query) {
+    this.endpoint = endpoint;
+    this.apiToken = apiToken;
+    this.fetchImpl = fetchImpl;
+    this.query = query;
+  }
+  endpoint;
+  apiToken;
+  fetchImpl;
+  query;
+  bindings = [];
+  bind(...values) {
+    this.bindings = values;
+    return this;
+  }
+  async execute() {
+    const response = await this.fetchImpl(this.endpoint, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${this.apiToken}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        sql: this.query,
+        params: this.bindings
+      })
+    });
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok || payload.success === false || payload.errors?.length) {
+      const message = payload.errors?.[0]?.message || `Cloudflare D1 request failed with ${response.status}.`;
+      throw new Error(message);
+    }
+    return payload.result ?? [];
+  }
+  async run() {
+    return this.execute();
+  }
+  async all() {
+    const result = await this.execute();
+    return {
+      results: result.flatMap((entry) => entry.results ?? [])
+    };
+  }
+  async first() {
+    const { results } = await this.all();
+    return results[0] ?? null;
+  }
+  async raw() {
+    const { results } = await this.all();
+    return results.map((entry) => Object.values(entry));
+  }
+}
+class CloudflareHttpD1Database {
+  constructor(options) {
+    this.options = options;
+    this.endpoint = `https://api.cloudflare.com/client/v4/accounts/${options.accountId}/d1/database/${options.databaseId}/query`;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  options;
+  endpoint;
+  fetchImpl;
+  prepare(query) {
+    return new CloudflareHttpD1PreparedStatement(this.endpoint, this.options.apiToken, this.fetchImpl, query);
+  }
+  async exec(query) {
+    return this.prepare(query).run();
+  }
+}
+function interpolateD1Query(query, bindings) {
+  return interpolateBindings(query, bindings);
+}
+export {
+  CloudflareHttpD1Database,
+  interpolateD1Query
+};

package/dist/index.d.ts

@@ -19,4 +19,5 @@ export type * from './operations-types.ts';
 export type * from './workflow.ts';
 export type { AgentDatabase } from './d1-store.ts';
 export type { D1DatabaseLike, D1PreparedStatementLike } from './types/cloudflare.ts';
+export { CloudflareHttpD1Database } from './d1-http.ts';
 export type * from './remote.ts';

package/dist/index.js

@@ -47,9 +47,11 @@ import {
 import { TreeseedOperationsSdk } from "./operations/runtime.js";
 import { TreeseedWorkflowSdk } from "./workflow.js";
 import { getTreeseedVerifyDriverStatus, runTreeseedVerifyDriver } from "./verification.js";
+import { CloudflareHttpD1Database } from "./d1-http.js";
 export {
   AgentSdk,
   BUILTIN_MODEL_REGISTRY,
+  CloudflareHttpD1Database,
   CloudflareQueuePullClient,
   ContentGraphRuntime,
   DEFAULT_GRAPH_RANKING_PROVIDER,

package/dist/operations/services/config-runtime.js

@@ -1064,7 +1064,7 @@ function syncTreeseedRailwayEnvironment({ tenantRoot, scope = "prod", dryRun = f
     }
     const environment = service.environments?.[scope];
     const fallbackServiceName = serviceKey === "api" ? config.settings.services.railway.apiServiceName : serviceKey === "agents" ? config.settings.services.railway.agentsServiceName : "";
-    const defaultRootDir = serviceKey === "api" ? "packages/api" : "packages/agent";
+    const defaultRootDir = serviceKey === "api" ? "." : "packages/agent";
     return {
       service: serviceKey,
       projectName: service.railway?.projectName ?? config.settings.services.railway.projectName,

package/dist/operations/services/railway-deploy.js

@@ -26,7 +26,7 @@ function configuredRailwayServices(tenantRoot, scope) {
     if (!service || service.enabled === false || (service.provider ?? "railway") !== "railway") {
       return null;
     }
-    const defaultRootDir = serviceKey === "api" ? "packages/api" : "packages/agent";
+    const defaultRootDir = serviceKey === "api" ? "." : "packages/agent";
     const serviceRoot = resolve(tenantRoot, service.railway?.rootDir ?? service.rootDir ?? defaultRootDir);
     const railwayEnvironment = service.environments?.[normalizedScope]?.railwayEnvironment ?? normalizedScope;
     const publicBaseUrl = service.environments?.[normalizedScope]?.baseUrl ?? service.publicBaseUrl ?? null;

package/dist/operations/services/runtime-tools.js

@@ -31,7 +31,7 @@ const TREESEED_DEFAULT_PROVIDER_SELECTIONS = {
   site: "default"
 };
 const TRESEED_MANAGED_SERVICE_KEYS = ["api", "agents", "gateway", "manager", "worker", "workdayStart", "workdayReport"];
-const TRESEED_WORKSPACE_PACKAGE_DIRS = ["sdk", "core", "cli", "agent", "api"];
+const TRESEED_WORKSPACE_PACKAGE_DIRS = ["sdk", "core", "cli", "agent"];
 const CLOUDFLARE_ACCOUNT_ID_PLACEHOLDER = "replace-with-cloudflare-account-id";
 function parseServiceEnvironmentConfig(value) {
   const record = optionalRecord(value, "service environment") ?? {};

package/dist/platform/contracts.d.ts

@@ -83,6 +83,28 @@ export interface TreeseedPluginReference {
     enabled?: boolean;
     config?: Record<string, unknown>;
 }
+export type TreeseedPlatformSurfaceName = 'web' | 'api' | 'gateway' | (string & {});
+export type TreeseedPlatformResourceKind = 'pages' | 'styles' | 'components' | 'routes' | 'middleware' | 'handlers' | 'config';
+export interface TreeseedPlatformLayerDefinition {
+    root: string;
+    kinds?: TreeseedPlatformResourceKind[];
+}
+export interface TreeseedTenantSurfaceOverride {
+    layers?: TreeseedPlatformLayerDefinition[];
+}
+export interface TreeseedTenantOverrides {
+    pagesRoot?: string;
+    stylesRoot?: string;
+    componentsRoot?: string;
+    surfaces?: Partial<Record<TreeseedPlatformSurfaceName, TreeseedTenantSurfaceOverride>>;
+}
+export interface TreeseedPlatformSurfaceConfig {
+    enabled?: boolean;
+    provider?: string;
+    rootDir?: string;
+    publicBaseUrl?: string;
+    localBaseUrl?: string;
+}
 export interface TreeseedManagedServiceEnvironmentConfig {
     baseUrl?: string;
     domain?: string;
@@ -108,6 +130,13 @@ export interface TreeseedManagedServiceConfig {
 export interface TreeseedManagedServicesConfig {
     api?: TreeseedManagedServiceConfig;
     agents?: TreeseedManagedServiceConfig;
+    [key: string]: TreeseedManagedServiceConfig | undefined;
+}
+export interface TreeseedPlatformSurfacesConfig {
+    web?: TreeseedPlatformSurfaceConfig;
+    api?: TreeseedPlatformSurfaceConfig;
+    gateway?: TreeseedPlatformSurfaceConfig;
+    [key: string]: TreeseedPlatformSurfaceConfig | undefined;
 }
 export interface TreeseedProviderSelections {
     forms: string;
@@ -137,6 +166,7 @@ export interface TreeseedDeployConfig {
     };
     plugins: TreeseedPluginReference[];
     providers: TreeseedProviderSelections;
+    surfaces?: TreeseedPlatformSurfacesConfig;
     services?: TreeseedManagedServicesConfig;
     smtp?: {
         enabled?: boolean;
@@ -150,9 +180,5 @@ export interface TreeseedTenantConfig {
     siteConfigPath: string;
     content: TreeseedContentMap;
     features: TreeseedFeatureModules;
-    overrides?: {
-        pagesRoot?: string;
-        stylesRoot?: string;
-        componentsRoot?: string;
-    };
+    overrides?: TreeseedTenantOverrides;
 }

package/dist/platform/deploy-config.js

@@ -153,11 +153,38 @@ function parseManagedServicesConfig(value) {
   if (!record) {
     return void 0;
   }
+  return Object.fromEntries(
+    Object.entries(record).map(([serviceKey, serviceValue]) => [
+      serviceKey,
+      parseManagedServiceConfig(serviceValue, `services.${serviceKey}`)
+    ])
+  );
+}
+function parsePlatformSurfaceConfig(value, label) {
+  const record = optionalRecord(value, label);
+  if (!record) {
+    return void 0;
+  }
   return {
-    api: parseManagedServiceConfig(record.api, "services.api"),
-    agents: parseManagedServiceConfig(record.agents, "services.agents")
+    enabled: record.enabled === void 0 ? void 0 : optionalBoolean(record.enabled, `${label}.enabled`),
+    provider: optionalString(record.provider),
+    rootDir: optionalString(record.rootDir),
+    publicBaseUrl: optionalString(record.publicBaseUrl),
+    localBaseUrl: optionalString(record.localBaseUrl)
   };
 }
+function parsePlatformSurfacesConfig(value) {
+  const record = optionalRecord(value, "surfaces");
+  if (!record) {
+    return void 0;
+  }
+  return Object.fromEntries(
+    Object.entries(record).map(([surfaceKey, surfaceValue]) => [
+      surfaceKey,
+      parsePlatformSurfaceConfig(surfaceValue, `surfaces.${surfaceKey}`)
+    ])
+  );
+}
 function parseDeployConfig(raw) {
   const parsed = normalizeAliasedRecord(
     deployConfigFieldAliases,
@@ -181,6 +208,7 @@ function parseDeployConfig(raw) {
     },
     plugins: parsePluginReferences(parsed.plugins),
     providers: parseProviderSelections(parsed.providers),
+    surfaces: parsePlatformSurfacesConfig(parsed.surfaces),
     services: parseManagedServicesConfig(parsed.services),
     smtp: {
       enabled: optionalBoolean(smtp.enabled, "smtp.enabled")

package/dist/platform/environment.d.ts

@@ -2,7 +2,7 @@ import type { TreeseedDeployConfig, TreeseedTenantConfig } from './contracts.ts'
 import { type LoadedTreeseedPluginEntry } from './plugins.ts';
 export declare const TREESEED_ENVIRONMENT_SCOPES: readonly ["local", "staging", "prod"];
 export declare const TREESEED_ENVIRONMENT_REQUIREMENTS: readonly ["required", "conditional", "optional"];
-export declare const TREESEED_ENVIRONMENT_TARGETS: readonly ["local-file", "wrangler-dev-vars", "github-secret", "github-variable", "cloudflare-secret", "cloudflare-var", "railway-secret", "config-file"];
+export declare const TREESEED_ENVIRONMENT_TARGETS: readonly ["local-file", "wrangler-dev-vars", "github-secret", "github-variable", "cloudflare-secret", "cloudflare-var", "railway-secret", "railway-var", "config-file"];
 export declare const TREESEED_ENVIRONMENT_PURPOSES: readonly ["dev", "save", "deploy", "destroy", "config"];
 export declare const TREESEED_ENVIRONMENT_SENSITIVITY: readonly ["secret", "plain", "derived"];
 export type TreeseedEnvironmentScope = (typeof TREESEED_ENVIRONMENT_SCOPES)[number];

package/dist/platform/environment.js

@@ -16,6 +16,7 @@ const TREESEED_ENVIRONMENT_TARGETS = [
   "cloudflare-secret",
   "cloudflare-var",
   "railway-secret",
+  "railway-var",
   "config-file"
 ];
 const TREESEED_ENVIRONMENT_PURPOSES = ["dev", "save", "deploy", "destroy", "config"];

package/dist/platform/plugin.d.ts

@@ -1,8 +1,7 @@
-import type { TreeseedDeployConfig, TreeseedTenantConfig } from './contracts.ts';
+import type { TreeseedDeployConfig, TreeseedPlatformLayerDefinition, TreeseedPlatformResourceKind, TreeseedPlatformSurfaceName, TreeseedTenantConfig } from './contracts.ts';
 import type { TreeseedEnvironmentRegistryOverlay } from './environment.ts';
 import type { SdkGraphRankingProvider } from '../sdk-types.ts';
-export type TreeseedSiteLayerDefinition = {
-    root: string;
+export type TreeseedSiteLayerDefinition = TreeseedPlatformLayerDefinition & {
     kinds?: Array<'pages' | 'styles' | 'components'>;
 };
 export type TreeseedSiteRouteContribution = {
@@ -10,6 +9,12 @@ export type TreeseedSiteRouteContribution = {
     entrypoint?: string;
     resourcePath?: string;
 };
+export type TreeseedPlatformRouteContribution = {
+    pattern: string;
+    entrypoint?: string;
+    resourcePath?: string;
+    methods?: string[];
+};
 export type TreeseedSiteExtensionContribution = {
     routes?: TreeseedSiteRouteContribution[];
     starlightComponents?: Record<string, string>;
@@ -21,6 +26,20 @@ export type TreeseedSiteExtensionContribution = {
     integrations?: unknown[];
     routeMiddleware?: unknown[];
 };
+export type TreeseedPlatformExtensionContribution = {
+    routes?: TreeseedPlatformRouteContribution[];
+    middleware?: unknown[];
+    handlers?: Record<string, unknown>;
+    config?: Record<string, unknown>;
+    envSchema?: Record<string, unknown>;
+    vitePlugins?: unknown[];
+    integrations?: unknown[];
+    customCss?: string[];
+    remarkPlugins?: unknown[];
+    rehypePlugins?: unknown[];
+    routeMiddleware?: unknown[];
+    starlightComponents?: Record<string, string>;
+};
 export type TreeseedPluginSiteContext = {
     projectRoot: string;
     tenantConfig: TreeseedTenantConfig;
@@ -28,6 +47,13 @@ export type TreeseedPluginSiteContext = {
     deployConfig?: TreeseedDeployConfig;
     pluginConfig: Record<string, unknown>;
 };
+export type TreeseedPluginPlatformContext = TreeseedPluginSiteContext & {
+    surface: TreeseedPlatformSurfaceName;
+};
+export type TreeseedPlatformLayerContribution = TreeseedPlatformLayerDefinition & {
+    surface?: TreeseedPlatformSurfaceName;
+    kinds?: TreeseedPlatformResourceKind[];
+};
 export type TreeseedPluginEnvironmentContext = {
     projectRoot: string;
     tenantConfig?: TreeseedTenantConfig;
@@ -44,6 +70,9 @@ export interface TreeseedPlugin {
     siteProviders?: Record<string, TreeseedSiteExtensionContribution | ((context: TreeseedPluginSiteContext) => TreeseedSiteExtensionContribution)>;
     siteHooks?: TreeseedSiteExtensionContribution | ((context: TreeseedPluginSiteContext) => TreeseedSiteExtensionContribution);
     siteLayers?: TreeseedSiteLayerDefinition[] | ((context: TreeseedPluginSiteContext) => TreeseedSiteLayerDefinition[] | undefined);
+    platformProviders?: Record<TreeseedPlatformSurfaceName, Record<string, TreeseedPlatformExtensionContribution | ((context: TreeseedPluginPlatformContext) => TreeseedPlatformExtensionContribution)>>;
+    platformHooks?: Partial<Record<TreeseedPlatformSurfaceName, TreeseedPlatformExtensionContribution>> | ((context: TreeseedPluginPlatformContext) => TreeseedPlatformExtensionContribution | undefined);
+    platformLayers?: TreeseedPlatformLayerContribution[] | ((context: TreeseedPluginPlatformContext) => TreeseedPlatformLayerContribution[] | undefined);
     environmentRegistry?: TreeseedEnvironmentRegistryOverlay | ((context: TreeseedPluginEnvironmentContext) => TreeseedEnvironmentRegistryOverlay | undefined);
     graphRankingProviders?: Record<string, TreeseedGraphRankingProviderContribution>;
     [key: string]: unknown;

package/dist/platform/tenant-config.js

@@ -111,6 +111,22 @@ function loadTreeseedManifest(manifestPath = "./src/manifest.yaml") {
     manifestOverrideFieldAliases,
     parsed.overrides
   ) : void 0;
+  const normalizedSurfaceOverrides = Object.fromEntries(
+    Object.entries(overrides?.surfaces ?? {}).map(([surface, definition]) => [
+      surface,
+      {
+        layers: (definition?.layers ?? []).map((layer) => ({
+          root: resolve(tenantRoot, layer.root),
+          kinds: layer.kinds
+        }))
+      }
+    ])
+  );
+  const legacyWebLayers = [
+    overrides?.pagesRoot ? { root: resolve(tenantRoot, overrides.pagesRoot), kinds: ["pages"] } : null,
+    overrides?.stylesRoot ? { root: resolve(tenantRoot, overrides.stylesRoot), kinds: ["styles"] } : null,
+    overrides?.componentsRoot ? { root: resolve(tenantRoot, overrides.componentsRoot), kinds: ["components"] } : null
+  ].filter(Boolean);
   const tenantConfig = defineTreeseedTenant({
     ...parsed,
     siteConfigPath: resolve(tenantRoot, parsed.siteConfigPath),
@@ -123,7 +139,16 @@ function loadTreeseedManifest(manifestPath = "./src/manifest.yaml") {
     overrides: overrides ? {
       pagesRoot: overrides.pagesRoot ? resolve(tenantRoot, overrides.pagesRoot) : void 0,
       stylesRoot: overrides.stylesRoot ? resolve(tenantRoot, overrides.stylesRoot) : void 0,
-      componentsRoot: overrides.componentsRoot ? resolve(tenantRoot, overrides.componentsRoot) : void 0
+      componentsRoot: overrides.componentsRoot ? resolve(tenantRoot, overrides.componentsRoot) : void 0,
+      surfaces: {
+        ...normalizedSurfaceOverrides,
+        web: {
+          layers: [
+            ...normalizedSurfaceOverrides.web?.layers ?? [],
+            ...legacyWebLayers
+          ]
+        }
+      }
     } : void 0
   });
   Object.defineProperty(tenantConfig, "__tenantRoot", {

package/dist/scripts/aggregate-book.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { buildTenantBookRuntime } from '../platform/utils/books-data.js';
+import { buildTenantBookRuntime } from '../platform/books-data.js';
 import { loadTreeseedManifest } from '../platform/tenant-config.js';
 const PROJECT_TENANT = loadTreeseedManifest();
 const { BOOKS, TREESEED_LIBRARY_DOWNLOAD } = buildTenantBookRuntime(PROJECT_TENANT, {

package/dist/treeseed/template-catalog/templates/starter-basic/template/astro.config.d.ts

@@ -1,2 +1,3 @@
-declare const _default: any;
-export default _default;
+import type { AstroUserConfig } from 'astro/config';
+declare const config: AstroUserConfig;
+export default config;

package/dist/treeseed/template-catalog/templates/starter-basic/template/astro.config.ts

@@ -1,3 +1,6 @@
 import { createTreeseedTenantSite } from '@treeseed/core/config';
+import type { AstroUserConfig } from 'astro/config';
 
-export default createTreeseedTenantSite();
+const config: AstroUserConfig = createTreeseedTenantSite();
+
+export default config;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/sdk",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Shared Treeseed SDK for content-backed and D1-backed object models.",
   "license": "AGPL-3.0-only",
   "repository": {
@@ -196,6 +196,10 @@
       "types": "./dist/wrangler-d1.d.ts",
       "default": "./dist/wrangler-d1.js"
     },
+    "./d1-http": {
+      "types": "./dist/d1-http.d.ts",
+      "default": "./dist/d1-http.js"
+    },
     "./stores/cursor-store": {
       "types": "./dist/stores/cursor-store.d.ts",
       "default": "./dist/stores/cursor-store.js"