@treeseed/sdk 0.4.8 → 0.4.10

package/dist/platform/environment.js

@@ -43,6 +43,27 @@ function railwayManagedEnabled(context) {
     (service) => service && service.enabled !== false && (service.provider ?? "railway") === "railway"
   );
 }
+function resolveHostingKind(context) {
+  return context.deployConfig.hosting?.kind ?? "self_hosted_project";
+}
+function resolveHostingRegistration(context) {
+  return context.deployConfig.hosting?.registration ?? "none";
+}
+function marketControlPlaneEnabled(context) {
+  return resolveHostingKind(context) === "market_control_plane";
+}
+function hostedProjectEnabled(context) {
+  return resolveHostingKind(context) === "hosted_project";
+}
+function selfHostedProjectEnabled(context) {
+  return resolveHostingKind(context) === "self_hosted_project";
+}
+function projectRegistrationEnabled(context) {
+  if (hostedProjectEnabled(context)) {
+    return true;
+  }
+  return selfHostedProjectEnabled(context) && resolveHostingRegistration(context) === "optional";
+}
 function generatedSecret(bytes = 24) {
   return randomBytes(bytes).toString("hex");
 }
@@ -102,20 +123,54 @@ function resolveWebServiceId(_values = {}) {
 function resolveApiWebServiceId(values = {}) {
   return values.TREESEED_WEB_SERVICE_ID?.trim() || "web";
 }
+function resolvePagesProjectName(context) {
+  return context.deployConfig.cloudflare.pages?.projectName?.trim() || context.deployConfig.slug;
+}
+function resolvePagesPreviewProjectName(context) {
+  return context.deployConfig.cloudflare.pages?.previewProjectName?.trim() || `${context.deployConfig.cloudflare.pages?.projectName?.trim() || context.deployConfig.slug}-staging`;
+}
+function resolveContentBucketName(context) {
+  return context.deployConfig.cloudflare.r2?.bucketName?.trim() || `${context.deployConfig.slug}-content`;
+}
+function resolveContentBucketBinding(context) {
+  return context.deployConfig.cloudflare.r2?.binding?.trim() || "TREESEED_CONTENT_BUCKET";
+}
+function resolveMarketBaseUrl(context) {
+  return context.deployConfig.hosting?.marketBaseUrl?.trim() || context.deployConfig.services?.api?.environments?.prod?.baseUrl?.trim() || context.deployConfig.services?.api?.publicBaseUrl?.trim() || "https://api.treeseed.ai";
+}
+function resolveHostedTeamId(context) {
+  return context.deployConfig.hosting?.teamId?.trim() || context.deployConfig.slug;
+}
+function resolveHostedProjectId(context) {
+  return context.deployConfig.hosting?.projectId?.trim() || context.deployConfig.slug;
+}
 const VALUE_RESOLVERS = {
   generatedSecret: () => generatedSecret(),
   localFormsBypassDefault: () => "true",
   projectDomainsDefault: (context) => primaryHostFromUrl(context.deployConfig.siteUrl),
   apiBaseUrlDefault: (context, scope, values) => resolveConfiguredApiBaseUrl(context, scope, values),
   webServiceIdDefault: (_context, _scope, values) => resolveWebServiceId(values),
-  apiWebServiceIdDefault: (_context, _scope, values) => resolveApiWebServiceId(values)
+  apiWebServiceIdDefault: (_context, _scope, values) => resolveApiWebServiceId(values),
+  pagesProjectNameDefault: (context) => resolvePagesProjectName(context),
+  pagesPreviewProjectNameDefault: (context) => resolvePagesPreviewProjectName(context),
+  contentBucketNameDefault: (context) => resolveContentBucketName(context),
+  contentBucketBindingDefault: (context) => resolveContentBucketBinding(context),
+  hostingKindDefault: (context) => resolveHostingKind(context),
+  hostingRegistrationDefault: (context) => resolveHostingRegistration(context),
+  marketBaseUrlDefault: (context) => resolveMarketBaseUrl(context),
+  hostingTeamIdDefault: (context) => resolveHostedTeamId(context),
+  hostingProjectIdDefault: (context) => resolveHostedProjectId(context)
 };
 const PREDICATES = {
   turnstileEnabled: (context) => turnstileEnabled(context),
   turnstileNonLocal: (context, scope) => turnstileEnabled(context) && scope !== "local",
   smtpEnabled: (context) => smtpEnabled(context),
   smtpNonLocal: (context, scope) => smtpEnabled(context) && scope !== "local",
-  railwayManagedEnabled: (context) => railwayManagedEnabled(context)
+  railwayManagedEnabled: (context) => railwayManagedEnabled(context),
+  marketControlPlaneEnabled: (context) => marketControlPlaneEnabled(context),
+  hostedProjectEnabled: (context) => hostedProjectEnabled(context),
+  selfHostedProjectEnabled: (context) => selfHostedProjectEnabled(context),
+  projectRegistrationEnabled: (context) => projectRegistrationEnabled(context)
 };
 function deepMerge(left, right) {
   if (Array.isArray(left) && Array.isArray(right)) {

package/dist/platform/plugin.d.ts

@@ -60,6 +60,9 @@ export type TreeseedPluginEnvironmentContext = {
     deployConfig?: TreeseedDeployConfig;
     pluginConfig: Record<string, unknown>;
 };
+export type TreeseedContentProviderContext = TreeseedPluginEnvironmentContext & {
+    tenantConfig: TreeseedTenantConfig;
+};
 export type TreeseedGraphRankingProviderContribution = SdkGraphRankingProvider | ((context: TreeseedPluginEnvironmentContext) => SdkGraphRankingProvider | undefined);
 export interface TreeseedPlugin {
     id?: string;
@@ -68,6 +71,11 @@ export interface TreeseedPlugin {
     };
     operationProviders?: Record<string, unknown>;
     siteProviders?: Record<string, TreeseedSiteExtensionContribution | ((context: TreeseedPluginSiteContext) => TreeseedSiteExtensionContribution)>;
+    contentProviders?: {
+        runtime?: Record<string, unknown>;
+        publish?: Record<string, unknown>;
+        docs?: Record<string, unknown>;
+    };
     siteHooks?: TreeseedSiteExtensionContribution | ((context: TreeseedPluginSiteContext) => TreeseedSiteExtensionContribution);
     siteLayers?: TreeseedSiteLayerDefinition[] | ((context: TreeseedPluginSiteContext) => TreeseedSiteLayerDefinition[] | undefined);
     platformProviders?: Record<TreeseedPlatformSurfaceName, Record<string, TreeseedPlatformExtensionContribution | ((context: TreeseedPluginPlatformContext) => TreeseedPlatformExtensionContribution)>>;

package/dist/platform/plugins/constants.d.ts

@@ -12,6 +12,8 @@ export declare const TREESEED_DEFAULT_PROVIDER_SELECTIONS: {
     };
     deploy: string;
     content: {
+        runtime: string;
+        publish: string;
         docs: string;
     };
     site: string;

package/dist/platform/plugins/constants.js

@@ -12,6 +12,8 @@ const TREESEED_DEFAULT_PROVIDER_SELECTIONS = {
   },
   deploy: "cloudflare",
   content: {
+    runtime: "team_scoped_r2_overlay",
+    publish: "team_scoped_r2_overlay",
     docs: "default"
   },
   site: "default"

package/dist/platform/plugins/runtime.d.ts

@@ -26,6 +26,8 @@ export declare function loadTreeseedPluginRuntime(config?: TreeseedDeployConfig)
         };
         deploy: Set<string>;
         content: {
+            runtime: Set<string>;
+            publish: Set<string>;
             docs: Set<string>;
         };
         site: Set<string>;

package/dist/platform/plugins/runtime.js

@@ -107,6 +107,8 @@ function collectProvidedIds(plugins) {
     },
     deploy: /* @__PURE__ */ new Set(),
     content: {
+      runtime: /* @__PURE__ */ new Set(),
+      publish: /* @__PURE__ */ new Set(),
       docs: /* @__PURE__ */ new Set()
     },
     site: /* @__PURE__ */ new Set()
@@ -122,6 +124,8 @@ function collectProvidedIds(plugins) {
     for (const id of plugin.provides?.agents?.research ?? []) provided.agents.research.add(id);
     for (const id of plugin.provides?.agents?.handlers ?? []) provided.agents.handlers.add(id);
     for (const id of plugin.provides?.deploy ?? []) provided.deploy.add(id);
+    for (const id of plugin.provides?.content?.runtime ?? []) provided.content.runtime.add(id);
+    for (const id of plugin.provides?.content?.publish ?? []) provided.content.publish.add(id);
     for (const id of plugin.provides?.content?.docs ?? []) provided.content.docs.add(id);
     for (const id of plugin.provides?.site ?? []) provided.site.add(id);
   }
@@ -148,7 +152,11 @@ function loadTreeseedPluginRuntime(config = loadTreeseedDeployConfig()) {
   assertSelectedProvider(provided.agents.notification, "agents.notification", providers.agents.notification);
   assertSelectedProvider(provided.agents.research, "agents.research", providers.agents.research);
   assertSelectedProvider(provided.deploy, "deploy", providers.deploy);
-  assertSelectedProvider(provided.content.docs, "content.docs", providers.content?.docs);
+  assertSelectedProvider(provided.content.runtime, "content.runtime", providers.content?.runtime);
+  assertSelectedProvider(provided.content.publish, "content.publish", providers.content?.publish);
+  if (providers.content?.docs) {
+    assertSelectedProvider(provided.content.docs, "content.docs", providers.content.docs);
+  }
   assertSelectedProvider(provided.site, "site", providers.site);
   return {
     config,

package/dist/platform/plugins.d.ts

@@ -1,5 +1,5 @@
 export { TREESEED_DEFAULT_PLUGIN_PACKAGE, TREESEED_DEFAULT_PLUGIN_REFERENCES, TREESEED_DEFAULT_PROVIDER_SELECTIONS, } from './plugins/constants.ts';
-export { getTreeseedAgentProviderSelections, getTreeseedDeployConfig, getTreeseedDeployProvider, getTreeseedDocsProvider, getTreeseedFormsProvider, getTreeseedOperationsProvider, getTreeseedSiteProvider, isTreeseedSmtpEnabled, isTreeseedTurnstileEnabled, resetTreeseedDeployConfigForTests, } from './deploy-runtime.ts';
+export { getTreeseedAgentProviderSelections, getTreeseedContentPublishProvider, getTreeseedContentRuntimeProvider, getTreeseedDeployConfig, getTreeseedDeployProvider, getTreeseedDocsProvider, getTreeseedFormsProvider, getTreeseedOperationsProvider, getTreeseedSiteProvider, isTreeseedSmtpEnabled, isTreeseedTurnstileEnabled, resetTreeseedDeployConfigForTests, } from './deploy-runtime.ts';
 export { defineTreeseedPlugin } from './plugin.ts';
 export type * from './plugin.ts';
 export { loadTreeseedPluginRuntime, loadTreeseedPlugins, resolveTreeseedGraphRankingProvider } from './plugins/runtime.ts';

package/dist/platform/plugins.js

@@ -5,6 +5,8 @@ import {
 } from "./plugins/constants.js";
 import {
   getTreeseedAgentProviderSelections,
+  getTreeseedContentPublishProvider,
+  getTreeseedContentRuntimeProvider,
   getTreeseedDeployConfig,
   getTreeseedDeployProvider,
   getTreeseedDocsProvider,
@@ -23,6 +25,8 @@ export {
   TREESEED_DEFAULT_PROVIDER_SELECTIONS,
   defineTreeseedPlugin,
   getTreeseedAgentProviderSelections,
+  getTreeseedContentPublishProvider,
+  getTreeseedContentRuntimeProvider,
   getTreeseedDeployConfig,
   getTreeseedDeployProvider,
   getTreeseedDocsProvider,

package/dist/platform/published-content-pipeline.d.ts

@@ -0,0 +1,84 @@
+import type { TreeseedDeployConfig, TreeseedTenantConfig } from './contracts.ts';
+import { type PublishContentObjectInput, type PublishedArtifactVersion, type PublishedCollectionIndex, type PublishedContentEntry, type PublishedContentManifest, type PublishedOverlayManifest, type PublishedRuntimePointers, type PublishedContentVisibility } from './published-content.ts';
+import type { CatalogIndexEntry } from './published-content.ts';
+export interface ContentSourceEntry {
+    model: string;
+    id: string;
+    slug: string;
+    title?: string;
+    summary?: string;
+    status?: string;
+    visibility?: PublishedContentVisibility;
+    frontmatter: Record<string, unknown>;
+    body: string;
+    relativePath: string;
+    filePath: string;
+    updatedAt: string;
+}
+export interface ContentSource {
+    listEntries(): Promise<ContentSourceEntry[]>;
+}
+export interface RenderedContentEntry {
+    entry: PublishedContentEntry;
+    objects: PublishContentObjectInput[];
+    searchText: string;
+}
+export interface EntryRenderer {
+    render(entry: ContentSourceEntry, context: PublishedContentPipelineContext): Promise<RenderedContentEntry>;
+}
+export interface CollectionIndexBuilder {
+    build(model: string, entries: PublishedContentEntry[], context: PublishedContentPipelineContext): Promise<{
+        index: PublishedCollectionIndex;
+        object: PublishContentObjectInput;
+    }>;
+}
+export interface RuntimeBundleBuilderResult {
+    runtime: PublishedRuntimePointers;
+    objects: PublishContentObjectInput[];
+}
+export interface RuntimeBundleBuilder {
+    build(context: PublishedContentPipelineContext, entries: PublishedContentEntry[]): Promise<RuntimeBundleBuilderResult>;
+}
+export interface ArtifactBuilderResult {
+    artifacts: PublishedArtifactVersion[];
+    objects: PublishContentObjectInput[];
+    catalog?: CatalogIndexEntry[];
+}
+export interface ArtifactBuilder {
+    build(context: PublishedContentPipelineContext, entries: PublishedContentEntry[]): Promise<ArtifactBuilderResult>;
+}
+export interface PublishedContentPipelineContext {
+    projectRoot: string;
+    siteConfig: TreeseedDeployConfig;
+    tenantConfig: TreeseedTenantConfig;
+    teamId: string;
+    generatedAt: string;
+    sourceCommit?: string | null;
+    sourceRef?: string | null;
+    previewId?: string | null;
+}
+export interface PublishedContentPipeline {
+    buildProductionRevision(options?: {
+        previousManifest?: PublishedContentManifest | null;
+    }): Promise<{
+        manifest: PublishedContentManifest;
+        objects: PublishContentObjectInput[];
+        catalog: CatalogIndexEntry[];
+    }>;
+    buildEditorialOverlay(options?: {
+        previousManifest?: PublishedContentManifest | null;
+        previewId: string;
+    }): Promise<{
+        overlay: PublishedOverlayManifest;
+        objects: PublishContentObjectInput[];
+        catalog: CatalogIndexEntry[];
+    }>;
+}
+export declare function createFilesystemContentSource(tenantConfig: TreeseedTenantConfig): ContentSource;
+export declare function createPublishedContentPipeline(context: PublishedContentPipelineContext, options?: {
+    contentSource?: ContentSource;
+    entryRenderer?: EntryRenderer;
+    collectionIndexBuilder?: CollectionIndexBuilder;
+    runtimeBundleBuilder?: RuntimeBundleBuilder;
+    artifactBuilder?: ArtifactBuilder;
+}): PublishedContentPipeline;