@treeseed/sdk 0.11.0 → 0.12.4

package/dist/seeds/schema.js

@@ -1,6 +1,10 @@
 import { errorDiagnostic, warningDiagnostic } from "./errors.js";
 import {
-  SEED_ENVIRONMENTS
+  SEED_CONTENT_PUBLISH_TARGETS,
+  SEED_CONTENT_RUNTIME_SOURCES,
+  SEED_ENVIRONMENTS,
+  SEED_LOCAL_CONTENT_MATERIALIZATIONS,
+  SEED_PROJECT_TOPOLOGIES
 } from "./types.js";
 const RESOURCE_BUCKETS = [
   "teams",
@@ -16,6 +20,30 @@ const RESOURCE_BUCKETS = [
 ];
 const SUPPORTED_BUCKETS = /* @__PURE__ */ new Set(["teams", "repositoryHosts", "projects", "hubRepositories", "products", "catalogArtifacts", "capacityProviders", "capacityGrants", "workPolicies"]);
 const ALLOWED_ENVIRONMENTS = new Set(SEED_ENVIRONMENTS);
+const ALLOWED_PROJECT_TOPOLOGIES = new Set(SEED_PROJECT_TOPOLOGIES);
+const ALLOWED_CONTENT_RUNTIME_SOURCES = new Set(SEED_CONTENT_RUNTIME_SOURCES);
+const ALLOWED_LOCAL_CONTENT_MATERIALIZATIONS = new Set(SEED_LOCAL_CONTENT_MATERIALIZATIONS);
+const ALLOWED_CONTENT_PUBLISH_TARGETS = new Set(SEED_CONTENT_PUBLISH_TARGETS);
+const LEGACY_PROVIDER_TASK_SCOPE_PREFIX = "provider:tasks:";
+const ALLOWED_RECIPE_CHANNELS = /* @__PURE__ */ new Set(["cli", "ui", "api", "provider-runtime", "system-check"]);
+const ALLOWED_RECIPE_OPERATIONS = /* @__PURE__ */ new Set([
+  "navigate",
+  "seed.apply",
+  "seed.plan",
+  "verify.treedx",
+  "capacity-provider.create",
+  "capacity.up",
+  "capacity.status",
+  "capacity.allocate.portfolio",
+  "capacity.allocate.project",
+  "project.create",
+  "provider-runtime.launch",
+  "work.start",
+  "work.review-decision",
+  "knowledge.inspect-artifacts",
+  "knowledge.publish",
+  "system.health"
+]);
 const CREDENTIAL_REF_PATTERN = /^(?:env|secret|provider-session):[A-Za-z0-9_./:-]+$/u;
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -75,6 +103,15 @@ function objectField(record, field, path, diagnostics) {
   }
   return value;
 }
+function booleanField(record, field, path, diagnostics) {
+  const value = record[field];
+  if (value === void 0) return void 0;
+  if (typeof value !== "boolean") {
+    diagnostics.push(errorDiagnostic("seed.invalid_boolean", `Expected ${field} to be a boolean.`, `${path}.${field}`));
+    return void 0;
+  }
+  return value;
+}
 function stringArrayField(record, field, path, diagnostics) {
   const value = record[field];
   if (value === void 0) return void 0;
@@ -84,6 +121,23 @@ function stringArrayField(record, field, path, diagnostics) {
   }
   return value.map((entry) => asString(entry)).filter(Boolean);
 }
+function recordArrayField(record, field, path, diagnostics) {
+  const value = record[field];
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) {
+    diagnostics.push(errorDiagnostic("seed.invalid_array", `Expected ${field} to be an array.`, `${path}.${field}`));
+    return [];
+  }
+  const result = [];
+  value.forEach((entry, index) => {
+    if (!isRecord(entry)) {
+      diagnostics.push(errorDiagnostic("seed.invalid_object", `Expected ${field} entry to be an object.`, `${path}.${field}[${index}]`));
+      return;
+    }
+    result.push(entry);
+  });
+  return result;
+}
 function keyBase(record, path, diagnostics) {
   const key = requireString(record, "key", path, diagnostics);
   const environments = parseEnvironments(record.environments, `${path}.environments`, diagnostics);
@@ -123,11 +177,87 @@ function parseRepository(value, path, diagnostics) {
   validateRepository(repository, path, diagnostics);
   return repository;
 }
+function parseProjectContentPublishTarget(value, path, diagnostics) {
+  if (value === void 0) return void 0;
+  if (!isRecord(value)) {
+    diagnostics.push(errorDiagnostic("seed.invalid_project_architecture", "Expected contentPublishTarget to be an object.", path));
+    return void 0;
+  }
+  const kind = requireString(value, "kind", path, diagnostics);
+  if (kind && !ALLOWED_CONTENT_PUBLISH_TARGETS.has(kind)) {
+    diagnostics.push(errorDiagnostic("seed.invalid_project_architecture", `Unsupported content publish target: ${kind}.`, `${path}.kind`));
+  }
+  return {
+    kind: ALLOWED_CONTENT_PUBLISH_TARGETS.has(kind) ? kind : "none",
+    bucket: asString(value.bucket) || void 0,
+    prefix: asString(value.prefix) || void 0,
+    manifestPath: asString(value.manifestPath) || void 0,
+    metadata: objectField(value, "metadata", path, diagnostics)
+  };
+}
+function parseProjectArchitecture(value, path, diagnostics) {
+  if (!isRecord(value)) {
+    diagnostics.push(errorDiagnostic("seed.missing_project_architecture", "Project resources must declare canonical architecture.", path));
+    return null;
+  }
+  const topology = requireString(value, "topology", path, diagnostics);
+  const contentRuntimeSource = requireString(value, "contentRuntimeSource", path, diagnostics);
+  const localContentMaterialization = requireString(value, "localContentMaterialization", path, diagnostics);
+  if (topology && !ALLOWED_PROJECT_TOPOLOGIES.has(topology)) {
+    diagnostics.push(errorDiagnostic("seed.invalid_project_architecture", `Unsupported project topology: ${topology}.`, `${path}.topology`));
+  }
+  if (contentRuntimeSource && !ALLOWED_CONTENT_RUNTIME_SOURCES.has(contentRuntimeSource)) {
+    diagnostics.push(errorDiagnostic("seed.invalid_project_architecture", `Unsupported content runtime source: ${contentRuntimeSource}.`, `${path}.contentRuntimeSource`));
+  }
+  if (localContentMaterialization && !ALLOWED_LOCAL_CONTENT_MATERIALIZATIONS.has(localContentMaterialization)) {
+    diagnostics.push(errorDiagnostic("seed.invalid_project_architecture", `Unsupported local content materialization: ${localContentMaterialization}.`, `${path}.localContentMaterialization`));
+  }
+  const architecture = {
+    topology: ALLOWED_PROJECT_TOPOLOGIES.has(topology) ? topology : "single_repository_site",
+    rootPath: asString(value.rootPath) || ".",
+    sitePath: requireString(value, "sitePath", path, diagnostics),
+    contentPath: asString(value.contentPath) || void 0,
+    contentRuntimeSource: ALLOWED_CONTENT_RUNTIME_SOURCES.has(contentRuntimeSource) ? contentRuntimeSource : "r2_published_manifest",
+    localContentMaterialization: ALLOWED_LOCAL_CONTENT_MATERIALIZATIONS.has(localContentMaterialization) ? localContentMaterialization : "none",
+    contentPublishTarget: parseProjectContentPublishTarget(value.contentPublishTarget, `${path}.contentPublishTarget`, diagnostics),
+    requiresLocalContentForCi: booleanField(value, "requiresLocalContentForCi", path, diagnostics),
+    requiresLocalContentForDeploy: booleanField(value, "requiresLocalContentForDeploy", path, diagnostics)
+  };
+  validateProjectArchitecture(architecture, path, diagnostics);
+  return architecture;
+}
+function validateProjectArchitecture(architecture, path, diagnostics) {
+  if (!architecture.sitePath) return;
+  if (architecture.topology === "single_repository_site" && architecture.rootPath === "" && architecture.sitePath === "") {
+    diagnostics.push(errorDiagnostic("seed.invalid_project_architecture", "single_repository_site projects must have repository-relative rootPath and sitePath values.", path));
+  }
+  if (architecture.topology === "split_site_content" && !architecture.contentPath && architecture.contentRuntimeSource === "local_directory") {
+    diagnostics.push(errorDiagnostic("seed.invalid_project_architecture", "split_site_content projects using local_directory content must declare contentPath.", `${path}.contentPath`));
+  }
+  if (!architecture.requiresLocalContentForCi && !architecture.requiresLocalContentForDeploy && architecture.contentRuntimeSource !== "local_directory" && ["managed_clone", "submodule"].includes(architecture.localContentMaterialization)) {
+    diagnostics.push(errorDiagnostic(
+      "seed.local_content_required_by_default",
+      "CI/deploy defaults must not require managed_clone or submodule content unless requiresLocalContentForCi or requiresLocalContentForDeploy is explicit.",
+      `${path}.localContentMaterialization`
+    ));
+  }
+  if (architecture.contentPublishTarget?.kind === "cloudflare_r2" && architecture.contentRuntimeSource === "local_directory" && !architecture.contentPath) {
+    diagnostics.push(errorDiagnostic("seed.invalid_project_architecture", "Cloudflare R2 content publish targets need a contentPath when runtime source is local_directory.", `${path}.contentPath`));
+  }
+}
 function parseProject(value, path, diagnostics) {
   if (!isRecord(value)) {
     diagnostics.push(errorDiagnostic("seed.invalid_resource", "Expected project resource to be an object.", path));
     return null;
   }
+  const metadata = objectField(value, "metadata", path, diagnostics);
+  if (metadata?.repositoryTopology !== void 0 || metadata?.contentRoot !== void 0 || metadata?.sitePath !== void 0 || metadata?.contentPath !== void 0) {
+    diagnostics.push(errorDiagnostic(
+      "seed.legacy_project_topology_metadata",
+      "Project topology must be declared in project.architecture, not metadata.",
+      `${path}.metadata`
+    ));
+  }
   return {
     ...keyBase(value, path, diagnostics),
     team: requireString(value, "team", path, diagnostics),
@@ -136,7 +266,14 @@ function parseProject(value, path, diagnostics) {
     description: asString(value.description) || void 0,
     kind: asString(value.kind) || void 0,
     repository: parseRepository(value.repository, `${path}.repository`, diagnostics),
-    metadata: objectField(value, "metadata", path, diagnostics)
+    architecture: parseProjectArchitecture(value.architecture, `${path}.architecture`, diagnostics) ?? {
+      topology: "single_repository_site",
+      rootPath: ".",
+      sitePath: "",
+      contentRuntimeSource: "r2_published_manifest",
+      localContentMaterialization: "none"
+    },
+    metadata
   };
 }
 function parseRepositoryHost(value, path, diagnostics) {
@@ -275,11 +412,22 @@ function parseProviderRegistration(value, path, diagnostics) {
   if (apiKeyValue.createIfMissing !== void 0 && typeof apiKeyValue.createIfMissing !== "boolean") {
     diagnostics.push(errorDiagnostic("seed.invalid_boolean", "Expected registration.apiKey.createIfMissing to be a boolean.", `${path}.apiKey.createIfMissing`));
   }
+  const scopes = stringArrayField(apiKeyValue, "scopes", `${path}.apiKey`, diagnostics);
+  scopes?.forEach((scope, index) => {
+    if (scope.startsWith(LEGACY_PROVIDER_TASK_SCOPE_PREFIX)) {
+      diagnostics.push(errorDiagnostic(
+        "seed.legacy_provider_task_scope",
+        `Legacy provider task scope ${scope} is not supported; use provider assignment scopes instead.`,
+        `${path}.apiKey.scopes[${index}]`
+      ));
+    }
+  });
   return {
     apiKey: {
       createIfMissing: typeof apiKeyValue.createIfMissing === "boolean" ? apiKeyValue.createIfMissing : void 0,
       name: asString(apiKeyValue.name) || void 0,
-      scopes: stringArrayField(apiKeyValue, "scopes", `${path}.apiKey`, diagnostics),
+      plaintextKey: asString(apiKeyValue.plaintextKey) || void 0,
+      scopes,
       expiresAt: asString(apiKeyValue.expiresAt) || void 0
     }
   };
@@ -415,6 +563,63 @@ function parseWorkPolicy(value, path, diagnostics) {
     metadata: objectField(value, "metadata", path, diagnostics)
   };
 }
+function parseRecipeCommand(value, path, diagnostics) {
+  if (value === void 0) return void 0;
+  if (!isRecord(value)) {
+    diagnostics.push(errorDiagnostic("seed.invalid_object", "Expected command to be an object.", path));
+    return void 0;
+  }
+  const argv = stringArrayField(value, "argv", path, diagnostics);
+  if (argv.length === 0) {
+    diagnostics.push(errorDiagnostic("seed.recipe_command_missing_argv", "Recipe command must include argv.", `${path}.argv`));
+  }
+  return { argv };
+}
+function parseRecipeStep(value, path, diagnostics) {
+  if (!isRecord(value)) {
+    diagnostics.push(errorDiagnostic("seed.invalid_recipe_step", "Expected operation recipe step to be an object.", path));
+    return null;
+  }
+  const channel = requireString(value, "channel", path, diagnostics);
+  if (channel && !ALLOWED_RECIPE_CHANNELS.has(channel)) {
+    diagnostics.push(errorDiagnostic("seed.recipe_unknown_channel", `Unsupported operation recipe channel: ${channel}.`, `${path}.channel`));
+  }
+  const operation = requireString(value, "operation", path, diagnostics);
+  if (operation && !ALLOWED_RECIPE_OPERATIONS.has(operation)) {
+    diagnostics.push(errorDiagnostic("seed.recipe_unknown_operation", `Unsupported operation recipe operation: ${operation}.`, `${path}.operation`));
+  }
+  return {
+    id: requireString(value, "id", path, diagnostics),
+    title: requireString(value, "title", path, diagnostics),
+    actor: asString(value.actor) || void 0,
+    channel: ALLOWED_RECIPE_CHANNELS.has(channel) ? channel : "system-check",
+    operation,
+    dependsOn: stringArrayField(value, "dependsOn", path, diagnostics) ?? [],
+    uses: stringArrayField(value, "uses", path, diagnostics) ?? [],
+    target: asString(value.target) || void 0,
+    command: parseRecipeCommand(value.command, `${path}.command`, diagnostics),
+    assertions: recordArrayField(value, "assertions", path, diagnostics),
+    artifacts: recordArrayField(value, "artifacts", path, diagnostics)
+  };
+}
+function parseOperationRecipe(value, path, diagnostics, manifestEnvironments) {
+  if (!isRecord(value)) {
+    diagnostics.push(errorDiagnostic("seed.invalid_recipe", "Expected operation recipe to be an object.", path));
+    return null;
+  }
+  const environments = parseEnvironments(value.environments, `${path}.environments`, diagnostics) ?? manifestEnvironments;
+  const recipe = {
+    id: requireString(value, "id", path, diagnostics),
+    title: requireString(value, "title", path, diagnostics),
+    environments,
+    entrypoints: stringArrayField(value, "entrypoints", path, diagnostics) ?? [],
+    steps: Array.isArray(value.steps) ? value.steps.map((step, index) => parseRecipeStep(step, `${path}.steps[${index}]`, diagnostics)).filter((step) => Boolean(step)) : []
+  };
+  if (!Array.isArray(value.steps)) {
+    diagnostics.push(errorDiagnostic("seed.invalid_recipe_steps", "Operation recipe steps must be an array.", `${path}.steps`));
+  }
+  return recipe;
+}
 function validateRepository(repository, path, diagnostics) {
   if (!repository.gitUrl) return;
   if (/^(?:\.{1,2}\/?|packages\/|\/)/u.test(repository.gitUrl) || !/(?:^[a-z][a-z0-9+.-]*:\/\/|^git@)/iu.test(repository.gitUrl)) {
@@ -542,6 +747,85 @@ function validateReferences(manifest, diagnostics) {
     if (!projectKeys.has(policy.project)) diagnostics.push(errorDiagnostic("seed.invalid_reference", `Unknown project reference: ${policy.project}.`, `resources.workPolicies[${index}].project`));
   });
 }
+function allResourceKeys(manifest) {
+  return /* @__PURE__ */ new Set([
+    ...manifest.resources.teams.map((team) => team.key),
+    ...manifest.resources.repositoryHosts.map((host) => host.key),
+    ...manifest.resources.projects.map((project) => project.key),
+    ...manifest.resources.hubRepositories.map((repository) => repository.key),
+    ...manifest.resources.products.map((product) => product.key),
+    ...manifest.resources.catalogArtifacts.map((artifact) => artifact.key),
+    ...manifest.resources.capacityProviders.flatMap((provider) => [provider.key, ...(provider.lanes ?? []).map((lane) => lane.key)]),
+    ...manifest.resources.capacityGrants.map((grant) => grant.key),
+    ...manifest.resources.workPolicies.map((policy) => policy.key)
+  ]);
+}
+function validateOperationRecipes(manifest, diagnostics) {
+  const recipeIds = /* @__PURE__ */ new Map();
+  const resourceKeys = allResourceKeys(manifest);
+  manifest.operationRecipes.forEach((recipe, recipeIndex) => {
+    const recipePath = `operationRecipes[${recipeIndex}]`;
+    const existingRecipePath = recipeIds.get(recipe.id);
+    if (recipe.id && existingRecipePath) {
+      diagnostics.push(errorDiagnostic("seed.recipe_duplicate_id", `Duplicate operation recipe id ${recipe.id}; first seen at ${existingRecipePath}.`, `${recipePath}.id`));
+    }
+    if (recipe.id) recipeIds.set(recipe.id, `${recipePath}.id`);
+    if (recipe.environments.length === 0) {
+      diagnostics.push(errorDiagnostic("seed.recipe_missing_environments", "Operation recipe must target at least one environment.", `${recipePath}.environments`));
+    }
+    for (const environment of recipe.environments) {
+      if (!manifest.environments.includes(environment)) {
+        diagnostics.push(errorDiagnostic("seed.recipe_environment_not_declared", `Recipe environment ${environment} is not declared in environments.`, `${recipePath}.environments`));
+      }
+    }
+    const steps = /* @__PURE__ */ new Map();
+    recipe.steps.forEach((step, stepIndex) => {
+      const stepPath = `${recipePath}.steps[${stepIndex}]`;
+      const existingStep = steps.get(step.id);
+      if (step.id && existingStep) {
+        diagnostics.push(errorDiagnostic("seed.recipe_duplicate_step_id", `Duplicate operation recipe step id ${step.id}.`, `${stepPath}.id`));
+      }
+      if (step.id) steps.set(step.id, step);
+      step.uses.forEach((resourceKey, useIndex) => {
+        if (!resourceKeys.has(resourceKey)) {
+          diagnostics.push(errorDiagnostic("seed.recipe_invalid_resource_reference", `Unknown recipe resource reference: ${resourceKey}.`, `${stepPath}.uses[${useIndex}]`));
+        }
+      });
+    });
+    recipe.entrypoints.forEach((entrypoint, entrypointIndex) => {
+      if (!steps.has(entrypoint)) {
+        diagnostics.push(errorDiagnostic("seed.recipe_invalid_entrypoint", `Unknown recipe entrypoint step: ${entrypoint}.`, `${recipePath}.entrypoints[${entrypointIndex}]`));
+      }
+    });
+    recipe.steps.forEach((step, stepIndex) => {
+      step.dependsOn.forEach((dependency, dependencyIndex) => {
+        if (!steps.has(dependency)) {
+          diagnostics.push(errorDiagnostic("seed.recipe_invalid_dependency", `Unknown recipe dependency step: ${dependency}.`, `${recipePath}.steps[${stepIndex}].dependsOn[${dependencyIndex}]`));
+        }
+      });
+    });
+    const visiting = /* @__PURE__ */ new Set();
+    const visited = /* @__PURE__ */ new Set();
+    const visit = (stepId, chain) => {
+      if (visited.has(stepId)) return;
+      if (visiting.has(stepId)) {
+        diagnostics.push(errorDiagnostic("seed.recipe_cycle", `Recipe dependency cycle detected: ${[...chain, stepId].join(" -> ")}.`, recipePath));
+        return;
+      }
+      const step = steps.get(stepId);
+      if (!step) return;
+      visiting.add(stepId);
+      for (const dependency of step.dependsOn) {
+        visit(dependency, [...chain, stepId]);
+      }
+      visiting.delete(stepId);
+      visited.add(stepId);
+    };
+    for (const step of recipe.steps) {
+      visit(step.id, []);
+    }
+  });
+}
 function parseSeedManifest(value, diagnostics) {
   walkForSecrets(value, "", diagnostics);
   if (!isRecord(value)) {
@@ -590,10 +874,15 @@ function parseSeedManifest(value, diagnostics) {
     description: asString(value.description) || void 0,
     defaultEnvironments,
     environments,
-    resources
+    resources,
+    operationRecipes: Array.isArray(value.operationRecipes) ? value.operationRecipes.map((recipe, index) => parseOperationRecipe(recipe, `operationRecipes[${index}]`, diagnostics, environments)).filter((recipe) => Boolean(recipe)) : []
   };
+  if (value.operationRecipes !== void 0 && !Array.isArray(value.operationRecipes)) {
+    diagnostics.push(errorDiagnostic("seed.invalid_operation_recipes", "operationRecipes must be an array.", "operationRecipes"));
+  }
   validateResourceKeys(manifest, diagnostics);
   validateReferences(manifest, diagnostics);
+  validateOperationRecipes(manifest, diagnostics);
   if (diagnostics.length === 0 && manifest.resources.projects.length === 0) {
     diagnostics.push(warningDiagnostic("seed.empty_projects", "Seed manifest does not define projects.", "resources.projects"));
   }

package/dist/seeds/types.d.ts

@@ -3,6 +3,7 @@ export type SeedEnvironment = typeof SEED_ENVIRONMENTS[number];
 export type SeedDiagnosticSeverity = 'error' | 'warning';
 export type SeedPlanActionType = 'create' | 'update' | 'unchanged' | 'skip' | 'delete' | 'error';
 export type SeedResourceKind = 'team' | 'repositoryHost' | 'project' | 'hubRepository' | 'capacityProvider' | 'capacityLane' | 'capacityGrant' | 'workPolicy' | 'product' | 'catalogArtifact';
+export type SeedOperationRecipeChannel = 'cli' | 'ui' | 'api' | 'provider-runtime' | 'system-check';
 export type SeedDiagnostic = {
     severity: SeedDiagnosticSeverity;
     code: string;
@@ -13,6 +14,32 @@ export type SeedResourceBase = {
     key: string;
     environments?: SeedEnvironment[];
 };
+export declare const SEED_PROJECT_TOPOLOGIES: readonly ["single_repository_site", "split_site_content", "parent_workspace"];
+export declare const SEED_CONTENT_RUNTIME_SOURCES: readonly ["local_directory", "treedx_snapshot", "r2_published_manifest", "r2_preview_overlay"];
+export declare const SEED_LOCAL_CONTENT_MATERIALIZATIONS: readonly ["none", "existing_path", "managed_clone", "submodule"];
+export declare const SEED_CONTENT_PUBLISH_TARGETS: readonly ["none", "cloudflare_r2"];
+export type SeedProjectTopology = typeof SEED_PROJECT_TOPOLOGIES[number];
+export type SeedContentRuntimeSource = typeof SEED_CONTENT_RUNTIME_SOURCES[number];
+export type SeedLocalContentMaterialization = typeof SEED_LOCAL_CONTENT_MATERIALIZATIONS[number];
+export type SeedContentPublishTargetKind = typeof SEED_CONTENT_PUBLISH_TARGETS[number];
+export type SeedProjectContentPublishTarget = {
+    kind: SeedContentPublishTargetKind;
+    bucket?: string;
+    prefix?: string;
+    manifestPath?: string;
+    metadata?: Record<string, unknown>;
+};
+export type SeedProjectArchitecture = {
+    topology: SeedProjectTopology;
+    rootPath: string;
+    sitePath: string;
+    contentPath?: string;
+    contentRuntimeSource: SeedContentRuntimeSource;
+    localContentMaterialization: SeedLocalContentMaterialization;
+    contentPublishTarget?: SeedProjectContentPublishTarget;
+    requiresLocalContentForCi?: boolean;
+    requiresLocalContentForDeploy?: boolean;
+};
 export type SeedManifest = {
     name: string;
     version: 1;
@@ -20,6 +47,7 @@ export type SeedManifest = {
     defaultEnvironments?: SeedEnvironment[];
     environments: SeedEnvironment[];
     resources: SeedManifestResources;
+    operationRecipes: SeedOperationRecipe[];
 };
 export type SeedManifestResources = {
     teams: SeedTeamResource[];
@@ -59,6 +87,7 @@ export type SeedProjectResource = SeedResourceBase & {
     description?: string;
     kind?: string;
     repository: SeedProjectRepository;
+    architecture: SeedProjectArchitecture;
     metadata?: Record<string, unknown>;
 };
 export type SeedRepositoryHostResource = SeedResourceBase & {
@@ -133,6 +162,7 @@ export type SeedCapacityLaneResource = SeedResourceBase & {
 export type SeedCapacityProviderRegistrationApiKey = {
     createIfMissing?: boolean;
     name?: string;
+    plaintextKey?: string;
     scopes?: string[];
     expiresAt?: string;
 };
@@ -219,6 +249,35 @@ export type SeedWorkPolicyResource = SeedResourceBase & {
     creditWeights?: unknown[];
     metadata?: Record<string, unknown>;
 };
+export type SeedOperationRecipeCommand = {
+    argv: string[];
+};
+export type SeedOperationRecipeAssertion = Record<string, unknown>;
+export type SeedOperationRecipeArtifact = Record<string, unknown>;
+export type SeedOperationRecipeStep = {
+    id: string;
+    title: string;
+    actor?: string;
+    channel: SeedOperationRecipeChannel;
+    operation: string;
+    dependsOn: string[];
+    uses: string[];
+    target?: string;
+    command?: SeedOperationRecipeCommand;
+    assertions: SeedOperationRecipeAssertion[];
+    artifacts: SeedOperationRecipeArtifact[];
+};
+export type SeedOperationRecipe = {
+    id: string;
+    title: string;
+    environments: SeedEnvironment[];
+    entrypoints: string[];
+    steps: SeedOperationRecipeStep[];
+};
+export type SeedOperationRecipePlan = SeedOperationRecipe & {
+    selected: boolean;
+    orderedSteps: SeedOperationRecipeStep[];
+};
 export type NormalizedSeedResource = {
     kind: SeedResourceKind;
     key: string;
@@ -247,6 +306,7 @@ export type SeedPlan = {
     environments: SeedEnvironment[];
     summary: SeedPlanSummary;
     actions: SeedPlanAction[];
+    recipes: SeedOperationRecipePlan[];
     diagnostics: SeedDiagnostic[];
     manifestPath: string;
 };

package/dist/seeds/types.js

@@ -1,4 +1,12 @@
 const SEED_ENVIRONMENTS = ["local", "staging", "prod"];
+const SEED_PROJECT_TOPOLOGIES = ["single_repository_site", "split_site_content", "parent_workspace"];
+const SEED_CONTENT_RUNTIME_SOURCES = ["local_directory", "treedx_snapshot", "r2_published_manifest", "r2_preview_overlay"];
+const SEED_LOCAL_CONTENT_MATERIALIZATIONS = ["none", "existing_path", "managed_clone", "submodule"];
+const SEED_CONTENT_PUBLISH_TARGETS = ["none", "cloudflare_r2"];
 export {
-  SEED_ENVIRONMENTS
+  SEED_CONTENT_PUBLISH_TARGETS,
+  SEED_CONTENT_RUNTIME_SOURCES,
+  SEED_ENVIRONMENTS,
+  SEED_LOCAL_CONTENT_MATERIALIZATIONS,
+  SEED_PROJECT_TOPOLOGIES
 };

package/dist/service-credentials.d.ts

@@ -0,0 +1,54 @@
+export declare const TREESEED_GITHUB_TOKEN_ENV = "TREESEED_GITHUB_TOKEN";
+export declare const TREESEED_GITHUB_COPILOT_TOKEN_ENV = "TREESEED_GITHUB_COPILOT_TOKEN";
+export declare const TREESEED_CLOUDFLARE_API_TOKEN_ENV = "TREESEED_CLOUDFLARE_API_TOKEN";
+export declare const TREESEED_CLOUDFLARE_ACCOUNT_ID_ENV = "TREESEED_CLOUDFLARE_ACCOUNT_ID";
+export declare const TREESEED_RAILWAY_API_TOKEN_ENV = "TREESEED_RAILWAY_API_TOKEN";
+export declare const TREESEED_RAILWAY_TOKEN_ENV = "TREESEED_RAILWAY_TOKEN";
+export declare const TREESEED_DOCKERHUB_TOKEN_ENV = "TREESEED_DOCKERHUB_TOKEN";
+export declare const TREESEED_DOCKERHUB_USERNAME_ENV = "TREESEED_DOCKERHUB_USERNAME";
+export declare const TREESEED_CODEX_API_KEY_ENV = "TREESEED_CODEX_API_KEY";
+type EnvLike = Record<string, string | undefined>;
+export declare function resolveTreeseedGitHubToken(env?: EnvLike): string;
+export declare function resolveTreeseedGitHubCopilotToken(env?: EnvLike): string;
+export declare function resolveTreeseedCloudflareApiToken(env?: EnvLike): string;
+export declare function resolveTreeseedCloudflareAccountId(env?: EnvLike): string;
+export declare function resolveTreeseedRailwayApiToken(env?: EnvLike): string;
+export declare function resolveTreeseedRailwayProjectToken(env?: EnvLike): string;
+export declare function resolveTreeseedDockerhubToken(env?: EnvLike): string;
+export declare function resolveTreeseedDockerhubUsername(env?: EnvLike): string;
+export declare function resolveTreeseedCodexApiKey(env?: EnvLike): string;
+export declare function withGitHubServiceCredentialEnv<TEnv extends EnvLike>(env: TEnv): TEnv & {
+    GH_TOKEN?: string;
+    GITHUB_TOKEN?: string;
+};
+export declare function withCloudflareServiceCredentialEnv<TEnv extends EnvLike>(env: TEnv): TEnv & {
+    CLOUDFLARE_API_TOKEN?: string;
+    CLOUDFLARE_ACCOUNT_ID?: string;
+};
+export declare function withRailwayServiceCredentialEnv<TEnv extends EnvLike>(env: TEnv): TEnv & {
+    RAILWAY_API_TOKEN?: string;
+    RAILWAY_TOKEN?: string;
+};
+export declare function withDockerhubServiceCredentialEnv<TEnv extends EnvLike>(env: TEnv): TEnv & {
+    DOCKERHUB_TOKEN?: string;
+    DOCKERHUB_USERNAME?: string;
+};
+export declare function withCodexServiceCredentialEnv<TEnv extends EnvLike>(env: TEnv): TEnv & {
+    CODEX_API_KEY?: string;
+};
+export declare function withTreeseedServiceCredentialEnv<TEnv extends EnvLike>(env: TEnv): TEnv & {
+    GH_TOKEN?: string;
+    GITHUB_TOKEN?: string;
+} & {
+    CLOUDFLARE_API_TOKEN?: string;
+    CLOUDFLARE_ACCOUNT_ID?: string;
+} & {
+    RAILWAY_API_TOKEN?: string;
+    RAILWAY_TOKEN?: string;
+} & {
+    DOCKERHUB_TOKEN?: string;
+    DOCKERHUB_USERNAME?: string;
+} & {
+    CODEX_API_KEY?: string;
+};
+export {};

package/dist/service-credentials.js

@@ -0,0 +1,112 @@
+const TREESEED_GITHUB_TOKEN_ENV = "TREESEED_GITHUB_TOKEN";
+const TREESEED_GITHUB_COPILOT_TOKEN_ENV = "TREESEED_GITHUB_COPILOT_TOKEN";
+const TREESEED_CLOUDFLARE_API_TOKEN_ENV = "TREESEED_CLOUDFLARE_API_TOKEN";
+const TREESEED_CLOUDFLARE_ACCOUNT_ID_ENV = "TREESEED_CLOUDFLARE_ACCOUNT_ID";
+const TREESEED_RAILWAY_API_TOKEN_ENV = "TREESEED_RAILWAY_API_TOKEN";
+const TREESEED_RAILWAY_TOKEN_ENV = "TREESEED_RAILWAY_TOKEN";
+const TREESEED_DOCKERHUB_TOKEN_ENV = "TREESEED_DOCKERHUB_TOKEN";
+const TREESEED_DOCKERHUB_USERNAME_ENV = "TREESEED_DOCKERHUB_USERNAME";
+const TREESEED_CODEX_API_KEY_ENV = "TREESEED_CODEX_API_KEY";
+function configuredValue(env, key) {
+  const value = env?.[key];
+  return typeof value === "string" && value.trim() ? value.trim() : "";
+}
+function resolveTreeseedGitHubToken(env = process.env) {
+  return configuredValue(env, TREESEED_GITHUB_TOKEN_ENV);
+}
+function resolveTreeseedGitHubCopilotToken(env = process.env) {
+  return configuredValue(env, TREESEED_GITHUB_COPILOT_TOKEN_ENV);
+}
+function resolveTreeseedCloudflareApiToken(env = process.env) {
+  return configuredValue(env, TREESEED_CLOUDFLARE_API_TOKEN_ENV);
+}
+function resolveTreeseedCloudflareAccountId(env = process.env) {
+  return configuredValue(env, TREESEED_CLOUDFLARE_ACCOUNT_ID_ENV);
+}
+function resolveTreeseedRailwayApiToken(env = process.env) {
+  return configuredValue(env, TREESEED_RAILWAY_API_TOKEN_ENV);
+}
+function resolveTreeseedRailwayProjectToken(env = process.env) {
+  return configuredValue(env, TREESEED_RAILWAY_TOKEN_ENV);
+}
+function resolveTreeseedDockerhubToken(env = process.env) {
+  return configuredValue(env, TREESEED_DOCKERHUB_TOKEN_ENV);
+}
+function resolveTreeseedDockerhubUsername(env = process.env) {
+  return configuredValue(env, TREESEED_DOCKERHUB_USERNAME_ENV);
+}
+function resolveTreeseedCodexApiKey(env = process.env) {
+  return configuredValue(env, TREESEED_CODEX_API_KEY_ENV);
+}
+function withGitHubServiceCredentialEnv(env) {
+  const token = resolveTreeseedGitHubToken(env);
+  return token ? { ...env, GH_TOKEN: token, GITHUB_TOKEN: token } : { ...env };
+}
+function withCloudflareServiceCredentialEnv(env) {
+  const token = resolveTreeseedCloudflareApiToken(env);
+  const accountId = resolveTreeseedCloudflareAccountId(env);
+  return {
+    ...env,
+    ...token ? { CLOUDFLARE_API_TOKEN: token } : {},
+    ...accountId ? { CLOUDFLARE_ACCOUNT_ID: accountId } : {}
+  };
+}
+function withRailwayServiceCredentialEnv(env) {
+  const token = resolveTreeseedRailwayApiToken(env);
+  const projectToken = resolveTreeseedRailwayProjectToken(env);
+  return {
+    ...env,
+    ...token ? { RAILWAY_API_TOKEN: token } : {},
+    ...projectToken ? { RAILWAY_TOKEN: projectToken } : {}
+  };
+}
+function withDockerhubServiceCredentialEnv(env) {
+  const token = resolveTreeseedDockerhubToken(env);
+  const username = resolveTreeseedDockerhubUsername(env);
+  return {
+    ...env,
+    ...token ? { DOCKERHUB_TOKEN: token } : {},
+    ...username ? { DOCKERHUB_USERNAME: username } : {}
+  };
+}
+function withCodexServiceCredentialEnv(env) {
+  const token = resolveTreeseedCodexApiKey(env);
+  return token ? { ...env, CODEX_API_KEY: token } : { ...env };
+}
+function withTreeseedServiceCredentialEnv(env) {
+  return withCodexServiceCredentialEnv(
+    withDockerhubServiceCredentialEnv(
+      withRailwayServiceCredentialEnv(
+        withCloudflareServiceCredentialEnv(
+          withGitHubServiceCredentialEnv(env)
+        )
+      )
+    )
+  );
+}
+export {
+  TREESEED_CLOUDFLARE_ACCOUNT_ID_ENV,
+  TREESEED_CLOUDFLARE_API_TOKEN_ENV,
+  TREESEED_CODEX_API_KEY_ENV,
+  TREESEED_DOCKERHUB_TOKEN_ENV,
+  TREESEED_DOCKERHUB_USERNAME_ENV,
+  TREESEED_GITHUB_COPILOT_TOKEN_ENV,
+  TREESEED_GITHUB_TOKEN_ENV,
+  TREESEED_RAILWAY_API_TOKEN_ENV,
+  TREESEED_RAILWAY_TOKEN_ENV,
+  resolveTreeseedCloudflareAccountId,
+  resolveTreeseedCloudflareApiToken,
+  resolveTreeseedCodexApiKey,
+  resolveTreeseedDockerhubToken,
+  resolveTreeseedDockerhubUsername,
+  resolveTreeseedGitHubCopilotToken,
+  resolveTreeseedGitHubToken,
+  resolveTreeseedRailwayApiToken,
+  resolveTreeseedRailwayProjectToken,
+  withCloudflareServiceCredentialEnv,
+  withCodexServiceCredentialEnv,
+  withDockerhubServiceCredentialEnv,
+  withGitHubServiceCredentialEnv,
+  withRailwayServiceCredentialEnv,
+  withTreeseedServiceCredentialEnv
+};

package/dist/stores/cursor-store.d.ts

@@ -1,5 +1,5 @@
-import type { SdkCursorEntity, SdkCursorRequest, SdkGetCursorRequest, SdkSearchRequest, SdkUpdateRequest } from '../sdk-types.ts';
-import { SqliteStoreBase } from './helpers.ts';
+import type { SdkCursorEntity, SdkCursorRequest, SdkGetCursorRequest, SdkSearchRequest, SdkUpdateRequest } from '../sdk-types.js';
+import { SqliteStoreBase } from './helpers.js';
 export declare class CursorStore extends SqliteStoreBase {
     private usesEnvelopeTable;
     getByKey(key: string): Promise<SdkCursorEntity | null>;