@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/seeds/schema.js

@@ -1,893 +0,0 @@
-import { errorDiagnostic, warningDiagnostic } from "./errors.js";
-import {
-  SEED_CONTENT_PUBLISH_TARGETS,
-  SEED_CONTENT_RUNTIME_SOURCES,
-  SEED_ENVIRONMENTS,
-  SEED_LOCAL_CONTENT_MATERIALIZATIONS,
-  SEED_PROJECT_TOPOLOGIES
-} from "./types.js";
-const RESOURCE_BUCKETS = [
-  "teams",
-  "repositoryHosts",
-  "projects",
-  "hubRepositories",
-  "products",
-  "catalogArtifacts",
-  "capacityProviders",
-  "capacityGrants",
-  "workPolicies",
-  "agentPools"
-];
-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);
-}
-function asString(value) {
-  return typeof value === "string" ? value.trim() : "";
-}
-function parseEnvironments(value, path, diagnostics) {
-  if (value === void 0) return void 0;
-  if (!Array.isArray(value)) {
-    diagnostics.push(errorDiagnostic("seed.invalid_environments", "Expected an array of environments.", path));
-    return void 0;
-  }
-  const result = [];
-  for (let index = 0; index < value.length; index += 1) {
-    const environment = asString(value[index]);
-    if (!ALLOWED_ENVIRONMENTS.has(environment)) {
-      diagnostics.push(errorDiagnostic("seed.unknown_environment", `Unknown environment: ${environment || String(value[index])}.`, `${path}[${index}]`));
-      continue;
-    }
-    if (!result.includes(environment)) {
-      result.push(environment);
-    }
-  }
-  return result;
-}
-function requireString(record, field, path, diagnostics) {
-  const value = asString(record[field]);
-  if (!value) {
-    diagnostics.push(errorDiagnostic("seed.missing_field", `Missing required field: ${field}.`, `${path}.${field}`));
-  }
-  return value;
-}
-function numberField(record, field, path, diagnostics) {
-  const value = record[field];
-  if (value === void 0) return void 0;
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    diagnostics.push(errorDiagnostic("seed.invalid_number", `Expected ${field} to be a finite number.`, `${path}.${field}`));
-    return void 0;
-  }
-  return value;
-}
-function nonNegativeNumberField(record, field, path, diagnostics) {
-  const value = numberField(record, field, path, diagnostics);
-  if (value !== void 0 && value < 0) {
-    diagnostics.push(errorDiagnostic("seed.invalid_number", `Expected ${field} to be non-negative.`, `${path}.${field}`));
-    return void 0;
-  }
-  return value;
-}
-function objectField(record, field, path, diagnostics) {
-  const value = record[field];
-  if (value === void 0) return void 0;
-  if (!isRecord(value)) {
-    diagnostics.push(errorDiagnostic("seed.invalid_object", `Expected ${field} to be an object.`, `${path}.${field}`));
-    return void 0;
-  }
-  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;
-  if (!Array.isArray(value)) {
-    diagnostics.push(errorDiagnostic("seed.invalid_array", `Expected ${field} to be an array.`, `${path}.${field}`));
-    return void 0;
-  }
-  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);
-  return { key, ...environments ? { environments } : {} };
-}
-function parseTeam(value, path, diagnostics) {
-  if (!isRecord(value)) {
-    diagnostics.push(errorDiagnostic("seed.invalid_resource", "Expected team resource to be an object.", path));
-    return null;
-  }
-  return {
-    ...keyBase(value, path, diagnostics),
-    slug: requireString(value, "slug", path, diagnostics),
-    name: asString(value.name) || void 0,
-    displayName: asString(value.displayName) || void 0,
-    logoUrl: asString(value.logoUrl) || void 0,
-    profileSummary: asString(value.profileSummary) || void 0,
-    metadata: objectField(value, "metadata", path, diagnostics)
-  };
-}
-function parseRepository(value, path, diagnostics) {
-  if (!isRecord(value)) {
-    diagnostics.push(errorDiagnostic("seed.invalid_repository", "Expected repository to be an object.", path));
-    return { role: "", provider: "", owner: "", name: "", gitUrl: "" };
-  }
-  const repository = {
-    role: requireString(value, "role", path, diagnostics),
-    provider: requireString(value, "provider", path, diagnostics),
-    owner: requireString(value, "owner", path, diagnostics),
-    name: requireString(value, "name", path, diagnostics),
-    gitUrl: requireString(value, "gitUrl", path, diagnostics),
-    defaultBranch: asString(value.defaultBranch) || void 0,
-    checkoutPath: asString(value.checkoutPath) || void 0,
-    submodulePath: asString(value.submodulePath) || void 0,
-    webUrl: asString(value.webUrl) || void 0
-  };
-  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),
-    slug: requireString(value, "slug", path, diagnostics),
-    name: requireString(value, "name", path, diagnostics),
-    description: asString(value.description) || void 0,
-    kind: asString(value.kind) || void 0,
-    repository: parseRepository(value.repository, `${path}.repository`, 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) {
-  if (!isRecord(value)) {
-    diagnostics.push(errorDiagnostic("seed.invalid_resource", "Expected repository host resource to be an object.", path));
-    return null;
-  }
-  const credentialRef = asString(value.credentialRef) || void 0;
-  if (credentialRef && !CREDENTIAL_REF_PATTERN.test(credentialRef)) {
-    diagnostics.push(errorDiagnostic("seed.invalid_credential_ref", "Repository host credentialRef must be env:, secret:, or provider-session:.", `${path}.credentialRef`));
-  }
-  return {
-    ...keyBase(value, path, diagnostics),
-    team: requireString(value, "team", path, diagnostics),
-    provider: requireString(value, "provider", path, diagnostics),
-    name: requireString(value, "name", path, diagnostics),
-    ownership: asString(value.ownership) || void 0,
-    accountLabel: asString(value.accountLabel) || void 0,
-    organizationOrOwner: requireString(value, "organizationOrOwner", path, diagnostics),
-    defaultVisibility: asString(value.defaultVisibility) || void 0,
-    softwareRepositoryNameTemplate: asString(value.softwareRepositoryNameTemplate) || void 0,
-    contentRepositoryNameTemplate: asString(value.contentRepositoryNameTemplate) || void 0,
-    branchPolicy: objectField(value, "branchPolicy", path, diagnostics),
-    workflowPolicy: objectField(value, "workflowPolicy", path, diagnostics),
-    allowedProjectKinds: stringArrayField(value, "allowedProjectKinds", path, diagnostics),
-    status: asString(value.status) || void 0,
-    credentialRef,
-    metadata: objectField(value, "metadata", path, diagnostics)
-  };
-}
-function parseHubRepository(value, path, diagnostics) {
-  if (!isRecord(value)) {
-    diagnostics.push(errorDiagnostic("seed.invalid_resource", "Expected hub repository resource to be an object.", path));
-    return null;
-  }
-  const repository = {
-    ...keyBase(value, path, diagnostics),
-    project: requireString(value, "project", path, diagnostics),
-    role: requireString(value, "role", path, diagnostics),
-    repositoryHost: asString(value.repositoryHost) || void 0,
-    provider: requireString(value, "provider", path, diagnostics),
-    owner: requireString(value, "owner", path, diagnostics),
-    name: requireString(value, "name", path, diagnostics),
-    gitUrl: requireString(value, "gitUrl", path, diagnostics),
-    defaultBranch: asString(value.defaultBranch) || void 0,
-    currentBranch: asString(value.currentBranch) || void 0,
-    submodulePath: asString(value.submodulePath) || void 0,
-    status: asString(value.status) || void 0,
-    accessPolicy: objectField(value, "accessPolicy", path, diagnostics),
-    releasePolicy: objectField(value, "releasePolicy", path, diagnostics),
-    publishPolicy: objectField(value, "publishPolicy", path, diagnostics),
-    metadata: objectField(value, "metadata", path, diagnostics)
-  };
-  validateRepository({
-    role: repository.role,
-    provider: repository.provider,
-    owner: repository.owner,
-    name: repository.name,
-    gitUrl: repository.gitUrl,
-    defaultBranch: repository.defaultBranch,
-    submodulePath: repository.submodulePath
-  }, path, diagnostics);
-  return repository;
-}
-function parseProduct(value, path, diagnostics) {
-  if (!isRecord(value)) {
-    diagnostics.push(errorDiagnostic("seed.invalid_resource", "Expected product resource to be an object.", path));
-    return null;
-  }
-  return {
-    ...keyBase(value, path, diagnostics),
-    team: requireString(value, "team", path, diagnostics),
-    kind: requireString(value, "kind", path, diagnostics),
-    slug: requireString(value, "slug", path, diagnostics),
-    title: requireString(value, "title", path, diagnostics),
-    summary: asString(value.summary) || void 0,
-    visibility: asString(value.visibility) || void 0,
-    listingEnabled: typeof value.listingEnabled === "boolean" ? value.listingEnabled : void 0,
-    offerMode: asString(value.offerMode) || void 0,
-    manifestKey: asString(value.manifestKey) || void 0,
-    artifactKey: asString(value.artifactKey) || void 0,
-    searchText: asString(value.searchText) || void 0,
-    metadata: objectField(value, "metadata", path, diagnostics)
-  };
-}
-function parseCatalogArtifact(value, path, diagnostics) {
-  if (!isRecord(value)) {
-    diagnostics.push(errorDiagnostic("seed.invalid_resource", "Expected catalog artifact resource to be an object.", path));
-    return null;
-  }
-  if (value.content !== void 0 || value.bytes !== void 0 || value.data !== void 0) {
-    diagnostics.push(errorDiagnostic("seed.inline_artifact_content", "Catalog artifact resources must reference content keys, not inline bytes/content.", path));
-  }
-  return {
-    ...keyBase(value, path, diagnostics),
-    product: requireString(value, "product", path, diagnostics),
-    version: requireString(value, "version", path, diagnostics),
-    kind: requireString(value, "kind", path, diagnostics),
-    contentKey: requireString(value, "contentKey", path, diagnostics),
-    manifestKey: asString(value.manifestKey) || void 0,
-    publishedAt: asString(value.publishedAt) || void 0,
-    metadata: objectField(value, "metadata", path, diagnostics)
-  };
-}
-function parseLane(value, path, diagnostics) {
-  if (!isRecord(value)) {
-    diagnostics.push(errorDiagnostic("seed.invalid_resource", "Expected lane resource to be an object.", path));
-    return null;
-  }
-  return {
-    ...keyBase(value, path, diagnostics),
-    name: requireString(value, "name", path, diagnostics),
-    businessModel: asString(value.businessModel) || void 0,
-    modelFamily: asString(value.modelFamily) || void 0,
-    modelClass: asString(value.modelClass) || void 0,
-    regionPolicy: asString(value.regionPolicy) || void 0,
-    unit: asString(value.unit) || void 0,
-    scarcityLevel: asString(value.scarcityLevel) || void 0,
-    hardLimits: objectField(value, "hardLimits", path, diagnostics),
-    routingPolicy: objectField(value, "routingPolicy", path, diagnostics),
-    metadata: objectField(value, "metadata", path, diagnostics)
-  };
-}
-function parseProviderRegistration(value, path, diagnostics) {
-  if (value === void 0) return void 0;
-  if (!isRecord(value)) {
-    diagnostics.push(errorDiagnostic("seed.invalid_object", "Expected registration to be an object.", path));
-    return void 0;
-  }
-  const apiKeyValue = value.apiKey;
-  if (apiKeyValue === void 0) return {};
-  if (!isRecord(apiKeyValue)) {
-    diagnostics.push(errorDiagnostic("seed.invalid_object", "Expected registration.apiKey to be an object.", `${path}.apiKey`));
-    return {};
-  }
-  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,
-      plaintextKey: asString(apiKeyValue.plaintextKey) || void 0,
-      scopes,
-      expiresAt: asString(apiKeyValue.expiresAt) || void 0
-    }
-  };
-}
-function parseNativeLimit(value, path, diagnostics) {
-  if (!isRecord(value)) {
-    diagnostics.push(errorDiagnostic("seed.invalid_resource", "Expected native limit to be an object.", path));
-    return null;
-  }
-  const limitAmount = nonNegativeNumberField(value, "limitAmount", path, diagnostics);
-  if (limitAmount === void 0) {
-    diagnostics.push(errorDiagnostic("seed.missing_field", "Missing required field: limitAmount.", `${path}.limitAmount`));
-  }
-  return {
-    id: asString(value.id) || void 0,
-    scope: asString(value.scope) || void 0,
-    limitScope: asString(value.limitScope) || void 0,
-    nativeUnit: asString(value.nativeUnit) || void 0,
-    limitAmount: limitAmount ?? 0,
-    reserveBufferPercent: nonNegativeNumberField(value, "reserveBufferPercent", path, diagnostics),
-    resetCadence: asString(value.resetCadence) || void 0,
-    resetAt: asString(value.resetAt) || void 0,
-    confidence: asString(value.confidence) || void 0,
-    source: asString(value.source) || void 0,
-    metadata: objectField(value, "metadata", path, diagnostics)
-  };
-}
-function parseExecutionProvider(value, path, diagnostics) {
-  if (!isRecord(value)) {
-    diagnostics.push(errorDiagnostic("seed.invalid_resource", "Expected execution provider resource to be an object.", path));
-    return null;
-  }
-  const limitsValue = value.nativeLimits;
-  const nativeLimits = limitsValue === void 0 ? [] : Array.isArray(limitsValue) ? limitsValue.map((limit, index) => parseNativeLimit(limit, `${path}.nativeLimits[${index}]`, diagnostics)).filter((limit) => Boolean(limit)) : (diagnostics.push(errorDiagnostic("seed.invalid_native_limits", "Expected nativeLimits to be an array.", `${path}.nativeLimits`)), []);
-  return {
-    id: asString(value.id) || void 0,
-    name: requireString(value, "name", path, diagnostics),
-    kind: requireString(value, "kind", path, diagnostics),
-    status: asString(value.status) || void 0,
-    nativeUnit: requireString(value, "nativeUnit", path, diagnostics),
-    quotaVisibility: asString(value.quotaVisibility) || void 0,
-    maxConcurrentWorkers: nonNegativeNumberField(value, "maxConcurrentWorkers", path, diagnostics),
-    resetCadence: asString(value.resetCadence) || void 0,
-    config: objectField(value, "config", path, diagnostics),
-    metadata: objectField(value, "metadata", path, diagnostics),
-    nativeLimits
-  };
-}
-function parseProvider(value, path, diagnostics) {
-  if (!isRecord(value)) {
-    diagnostics.push(errorDiagnostic("seed.invalid_resource", "Expected capacity provider resource to be an object.", path));
-    return null;
-  }
-  const lanesValue = value.lanes;
-  const lanes = lanesValue === void 0 ? [] : Array.isArray(lanesValue) ? lanesValue.map((lane, index) => parseLane(lane, `${path}.lanes[${index}]`, diagnostics)).filter((lane) => Boolean(lane)) : (diagnostics.push(errorDiagnostic("seed.invalid_lanes", "Expected lanes to be an array.", `${path}.lanes`)), []);
-  const executionProvidersValue = value.executionProviders;
-  const executionProviders = executionProvidersValue === void 0 ? [] : Array.isArray(executionProvidersValue) ? executionProvidersValue.map((entry, index) => parseExecutionProvider(entry, `${path}.executionProviders[${index}]`, diagnostics)).filter((entry) => Boolean(entry)) : (diagnostics.push(errorDiagnostic("seed.invalid_execution_providers", "Expected executionProviders to be an array.", `${path}.executionProviders`)), []);
-  return {
-    ...keyBase(value, path, diagnostics),
-    team: requireString(value, "team", path, diagnostics),
-    name: requireString(value, "name", path, diagnostics),
-    kind: asString(value.kind) || void 0,
-    provider: requireString(value, "provider", path, diagnostics),
-    billingScope: asString(value.billingScope) || void 0,
-    creditBudgetMode: asString(value.creditBudgetMode) || void 0,
-    monthlyCreditBudget: numberField(value, "monthlyCreditBudget", path, diagnostics),
-    dailyCreditBudget: numberField(value, "dailyCreditBudget", path, diagnostics),
-    maxConcurrentWorkdays: numberField(value, "maxConcurrentWorkdays", path, diagnostics),
-    maxConcurrentWorkers: numberField(value, "maxConcurrentWorkers", path, diagnostics),
-    capacityModel: objectField(value, "capacityModel", path, diagnostics),
-    registration: parseProviderRegistration(value.registration, `${path}.registration`, diagnostics),
-    metadata: objectField(value, "metadata", path, diagnostics),
-    lanes,
-    executionProviders
-  };
-}
-function parseGrant(value, path, diagnostics) {
-  if (!isRecord(value)) {
-    diagnostics.push(errorDiagnostic("seed.invalid_resource", "Expected capacity grant resource to be an object.", path));
-    return null;
-  }
-  const environment = asString(value.environment);
-  if (environment && !ALLOWED_ENVIRONMENTS.has(environment)) {
-    diagnostics.push(errorDiagnostic("seed.unknown_environment", `Unknown grant environment: ${environment}.`, `${path}.environment`));
-  }
-  return {
-    ...keyBase(value, path, diagnostics),
-    provider: requireString(value, "provider", path, diagnostics),
-    lane: asString(value.lane) || void 0,
-    team: requireString(value, "team", path, diagnostics),
-    project: asString(value.project) || void 0,
-    environment: environment && ALLOWED_ENVIRONMENTS.has(environment) ? environment : void 0,
-    grantScope: asString(value.grantScope) || void 0,
-    dailyCreditLimit: numberField(value, "dailyCreditLimit", path, diagnostics),
-    weeklyCreditLimit: numberField(value, "weeklyCreditLimit", path, diagnostics),
-    monthlyCreditLimit: numberField(value, "monthlyCreditLimit", path, diagnostics),
-    dailyUsdLimit: numberField(value, "dailyUsdLimit", path, diagnostics),
-    weeklyQuotaMinutes: numberField(value, "weeklyQuotaMinutes", path, diagnostics),
-    monthlyProviderUnits: numberField(value, "monthlyProviderUnits", path, diagnostics),
-    portfolioAllocationPercent: numberField(value, "portfolioAllocationPercent", path, diagnostics),
-    reservePoolPercent: numberField(value, "reservePoolPercent", path, diagnostics),
-    maxDailyProjectCredits: numberField(value, "maxDailyProjectCredits", path, diagnostics),
-    emergencyOverride: typeof value.emergencyOverride === "boolean" ? value.emergencyOverride : void 0,
-    priorityWeight: numberField(value, "priorityWeight", path, diagnostics),
-    overflowPolicy: asString(value.overflowPolicy) || void 0,
-    state: asString(value.state) || void 0,
-    metadata: objectField(value, "metadata", path, diagnostics)
-  };
-}
-function parseWorkPolicy(value, path, diagnostics) {
-  if (!isRecord(value)) {
-    diagnostics.push(errorDiagnostic("seed.invalid_resource", "Expected work policy resource to be an object.", path));
-    return null;
-  }
-  const environment = requireString(value, "environment", path, diagnostics);
-  if (environment && !ALLOWED_ENVIRONMENTS.has(environment)) {
-    diagnostics.push(errorDiagnostic("seed.unknown_environment", `Unknown work policy environment: ${environment}.`, `${path}.environment`));
-  }
-  return {
-    ...keyBase(value, path, diagnostics),
-    project: requireString(value, "project", path, diagnostics),
-    environment: ALLOWED_ENVIRONMENTS.has(environment) ? environment : "local",
-    enabled: typeof value.enabled === "boolean" ? value.enabled : void 0,
-    startCron: asString(value.startCron) || void 0,
-    durationMinutes: numberField(value, "durationMinutes", path, diagnostics),
-    maxRunners: numberField(value, "maxRunners", path, diagnostics),
-    maxWorkersPerRunner: numberField(value, "maxWorkersPerRunner", path, diagnostics),
-    dailyCreditBudget: numberField(value, "dailyCreditBudget", path, diagnostics),
-    maxQueuedTasks: numberField(value, "maxQueuedTasks", path, diagnostics),
-    maxQueuedCredits: numberField(value, "maxQueuedCredits", path, diagnostics),
-    autoscale: objectField(value, "autoscale", path, diagnostics),
-    creditWeights: Array.isArray(value.creditWeights) ? value.creditWeights : void 0,
-    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)) {
-    diagnostics.push(errorDiagnostic("seed.invalid_git_url", "Project repository gitUrl must be a remote Git URL, not a local path.", `${path}.gitUrl`));
-    return;
-  }
-  if (repository.provider !== "github") return;
-  const parsed = parseGitHubRepository(repository.gitUrl);
-  if (!parsed) {
-    diagnostics.push(errorDiagnostic("seed.invalid_git_url", "GitHub repository gitUrl must identify an owner and repository.", `${path}.gitUrl`));
-    return;
-  }
-  if (parsed.owner !== repository.owner || parsed.name !== repository.name) {
-    diagnostics.push(errorDiagnostic(
-      "seed.repository_metadata_mismatch",
-      `gitUrl points to ${parsed.owner}/${parsed.name}, but owner/name are ${repository.owner}/${repository.name}.`,
-      path
-    ));
-  }
-}
-function parseGitHubRepository(gitUrl) {
-  const ssh = /^git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/u.exec(gitUrl);
-  if (ssh) return { owner: ssh[1], name: ssh[2] };
-  try {
-    const url = new URL(gitUrl);
-    if (url.hostname !== "github.com") return null;
-    const [owner, rawName] = url.pathname.replace(/^\/+/u, "").split("/");
-    if (!owner || !rawName) return null;
-    return { owner, name: rawName.replace(/\.git$/u, "") };
-  } catch {
-    return null;
-  }
-}
-function walkForSecrets(value, path, diagnostics) {
-  if (typeof value === "string") {
-    if (/(?:ghp_|github_pat_|sk-[A-Za-z0-9]|xox[baprs]-|-----BEGIN [A-Z ]*PRIVATE KEY-----)/u.test(value)) {
-      diagnostics.push(errorDiagnostic("seed.secret_value", "Manifest appears to contain a raw secret value.", path));
-    }
-    return;
-  }
-  if (Array.isArray(value)) {
-    value.forEach((entry, index) => walkForSecrets(entry, `${path}[${index}]`, diagnostics));
-    return;
-  }
-  if (!isRecord(value)) return;
-  for (const [key, entry] of Object.entries(value)) {
-    const nextPath = path ? `${path}.${key}` : key;
-    if (typeof entry === "string" && /(?:api[_-]?key|token|private[_-]?key|password|secret|credential)/iu.test(key)) {
-      if (!CREDENTIAL_REF_PATTERN.test(entry)) {
-        diagnostics.push(errorDiagnostic("seed.secret_field", `Field ${key} must use a credential reference, not an inline value.`, nextPath));
-      }
-    }
-    walkForSecrets(entry, nextPath, diagnostics);
-  }
-}
-function arrayBucket(resources, bucket, diagnostics) {
-  const value = resources[bucket];
-  if (value === void 0) return [];
-  if (!Array.isArray(value)) {
-    diagnostics.push(errorDiagnostic("seed.invalid_resource_bucket", `resources.${bucket} must be an array.`, `resources.${bucket}`));
-    return [];
-  }
-  if (!SUPPORTED_BUCKETS.has(bucket) && value.length > 0) {
-    diagnostics.push(errorDiagnostic("seed.unsupported_resource_kind", `resources.${bucket} is recognized but is not backed by seed reconciliation yet.`, `resources.${bucket}`));
-  }
-  return value;
-}
-function validateResourceKeys(manifest, diagnostics) {
-  const seen = /* @__PURE__ */ new Map();
-  const visit = (key, path) => {
-    if (!key) return;
-    const existingPath = seen.get(key);
-    if (existingPath) {
-      diagnostics.push(errorDiagnostic("seed.duplicate_key", `Duplicate resource key ${key}; first seen at ${existingPath}.`, path));
-      return;
-    }
-    seen.set(key, path);
-  };
-  manifest.resources.teams.forEach((team, index) => visit(team.key, `resources.teams[${index}].key`));
-  manifest.resources.repositoryHosts.forEach((host, index) => visit(host.key, `resources.repositoryHosts[${index}].key`));
-  manifest.resources.projects.forEach((project, index) => visit(project.key, `resources.projects[${index}].key`));
-  manifest.resources.hubRepositories.forEach((repository, index) => visit(repository.key, `resources.hubRepositories[${index}].key`));
-  manifest.resources.products.forEach((product, index) => visit(product.key, `resources.products[${index}].key`));
-  manifest.resources.catalogArtifacts.forEach((artifact, index) => visit(artifact.key, `resources.catalogArtifacts[${index}].key`));
-  manifest.resources.capacityProviders.forEach((provider, providerIndex) => {
-    visit(provider.key, `resources.capacityProviders[${providerIndex}].key`);
-    (provider.lanes ?? []).forEach((lane, laneIndex) => visit(lane.key, `resources.capacityProviders[${providerIndex}].lanes[${laneIndex}].key`));
-  });
-  manifest.resources.capacityGrants.forEach((grant, index) => visit(grant.key, `resources.capacityGrants[${index}].key`));
-  manifest.resources.workPolicies.forEach((policy, index) => visit(policy.key, `resources.workPolicies[${index}].key`));
-}
-function validateReferences(manifest, diagnostics) {
-  const teamKeys = new Set(manifest.resources.teams.map((team) => team.key));
-  const projectKeys = new Set(manifest.resources.projects.map((project) => project.key));
-  const repositoryHostKeys = new Set(manifest.resources.repositoryHosts.map((host) => host.key));
-  const productKeys = new Set(manifest.resources.products.map((product) => product.key));
-  const providerKeys = new Set(manifest.resources.capacityProviders.map((provider) => provider.key));
-  const laneKeys = new Set(manifest.resources.capacityProviders.flatMap((provider) => (provider.lanes ?? []).map((lane) => lane.key)));
-  manifest.resources.repositoryHosts.forEach((host, index) => {
-    if (!teamKeys.has(host.team)) diagnostics.push(errorDiagnostic("seed.invalid_reference", `Unknown team reference: ${host.team}.`, `resources.repositoryHosts[${index}].team`));
-  });
-  manifest.resources.projects.forEach((project, index) => {
-    if (!teamKeys.has(project.team)) diagnostics.push(errorDiagnostic("seed.invalid_reference", `Unknown team reference: ${project.team}.`, `resources.projects[${index}].team`));
-  });
-  manifest.resources.hubRepositories.forEach((repository, index) => {
-    if (!projectKeys.has(repository.project)) diagnostics.push(errorDiagnostic("seed.invalid_reference", `Unknown project reference: ${repository.project}.`, `resources.hubRepositories[${index}].project`));
-    if (repository.repositoryHost && !repositoryHostKeys.has(repository.repositoryHost)) diagnostics.push(errorDiagnostic("seed.invalid_reference", `Unknown repository host reference: ${repository.repositoryHost}.`, `resources.hubRepositories[${index}].repositoryHost`));
-  });
-  manifest.resources.products.forEach((product, index) => {
-    if (!teamKeys.has(product.team)) diagnostics.push(errorDiagnostic("seed.invalid_reference", `Unknown team reference: ${product.team}.`, `resources.products[${index}].team`));
-  });
-  manifest.resources.catalogArtifacts.forEach((artifact, index) => {
-    if (!productKeys.has(artifact.product)) diagnostics.push(errorDiagnostic("seed.invalid_reference", `Unknown product reference: ${artifact.product}.`, `resources.catalogArtifacts[${index}].product`));
-  });
-  manifest.resources.capacityProviders.forEach((provider, index) => {
-    if (!teamKeys.has(provider.team)) diagnostics.push(errorDiagnostic("seed.invalid_reference", `Unknown team reference: ${provider.team}.`, `resources.capacityProviders[${index}].team`));
-  });
-  manifest.resources.capacityGrants.forEach((grant, index) => {
-    if (!teamKeys.has(grant.team)) diagnostics.push(errorDiagnostic("seed.invalid_reference", `Unknown team reference: ${grant.team}.`, `resources.capacityGrants[${index}].team`));
-    if (!providerKeys.has(grant.provider)) diagnostics.push(errorDiagnostic("seed.invalid_reference", `Unknown capacity provider reference: ${grant.provider}.`, `resources.capacityGrants[${index}].provider`));
-    if (grant.lane && !laneKeys.has(grant.lane)) diagnostics.push(errorDiagnostic("seed.invalid_reference", `Unknown capacity lane reference: ${grant.lane}.`, `resources.capacityGrants[${index}].lane`));
-    if (grant.project && !projectKeys.has(grant.project)) diagnostics.push(errorDiagnostic("seed.invalid_reference", `Unknown project reference: ${grant.project}.`, `resources.capacityGrants[${index}].project`));
-  });
-  manifest.resources.workPolicies.forEach((policy, index) => {
-    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)) {
-    diagnostics.push(errorDiagnostic("seed.invalid_manifest", "Seed manifest must be an object.", "manifest"));
-    return null;
-  }
-  const name = requireString(value, "name", "manifest", diagnostics);
-  if (value.version !== 1) {
-    diagnostics.push(errorDiagnostic("seed.unsupported_version", `Unsupported seed manifest version: ${String(value.version)}.`, "version"));
-  }
-  const environments = parseEnvironments(value.environments, "environments", diagnostics) ?? [];
-  if (environments.length === 0) {
-    diagnostics.push(errorDiagnostic("seed.missing_environments", "Seed manifest must declare at least one environment.", "environments"));
-  }
-  const defaultEnvironments = parseEnvironments(value.defaultEnvironments, "defaultEnvironments", diagnostics);
-  for (const environment of defaultEnvironments ?? []) {
-    if (!environments.includes(environment)) {
-      diagnostics.push(errorDiagnostic("seed.default_environment_not_declared", `Default environment ${environment} is not declared in environments.`, "defaultEnvironments"));
-    }
-  }
-  const resourcesValue = value.resources;
-  if (!isRecord(resourcesValue)) {
-    diagnostics.push(errorDiagnostic("seed.invalid_resources", "Seed manifest resources must be an object.", "resources"));
-    return null;
-  }
-  for (const bucket of Object.keys(resourcesValue)) {
-    if (!RESOURCE_BUCKETS.includes(bucket)) {
-      diagnostics.push(errorDiagnostic("seed.unsupported_resource_kind", `Unsupported resource bucket: ${bucket}.`, `resources.${bucket}`));
-    }
-  }
-  const resources = {
-    teams: arrayBucket(resourcesValue, "teams", diagnostics).map((entry, index) => parseTeam(entry, `resources.teams[${index}]`, diagnostics)).filter((team) => Boolean(team)),
-    repositoryHosts: arrayBucket(resourcesValue, "repositoryHosts", diagnostics).map((entry, index) => parseRepositoryHost(entry, `resources.repositoryHosts[${index}]`, diagnostics)).filter((host) => Boolean(host)),
-    projects: arrayBucket(resourcesValue, "projects", diagnostics).map((entry, index) => parseProject(entry, `resources.projects[${index}]`, diagnostics)).filter((project) => Boolean(project)),
-    hubRepositories: arrayBucket(resourcesValue, "hubRepositories", diagnostics).map((entry, index) => parseHubRepository(entry, `resources.hubRepositories[${index}]`, diagnostics)).filter((repository) => Boolean(repository)),
-    products: arrayBucket(resourcesValue, "products", diagnostics).map((entry, index) => parseProduct(entry, `resources.products[${index}]`, diagnostics)).filter((product) => Boolean(product)),
-    catalogArtifacts: arrayBucket(resourcesValue, "catalogArtifacts", diagnostics).map((entry, index) => parseCatalogArtifact(entry, `resources.catalogArtifacts[${index}]`, diagnostics)).filter((artifact) => Boolean(artifact)),
-    capacityProviders: arrayBucket(resourcesValue, "capacityProviders", diagnostics).map((entry, index) => parseProvider(entry, `resources.capacityProviders[${index}]`, diagnostics)).filter((provider) => Boolean(provider)),
-    capacityGrants: arrayBucket(resourcesValue, "capacityGrants", diagnostics).map((entry, index) => parseGrant(entry, `resources.capacityGrants[${index}]`, diagnostics)).filter((grant) => Boolean(grant)),
-    workPolicies: arrayBucket(resourcesValue, "workPolicies", diagnostics).map((entry, index) => parseWorkPolicy(entry, `resources.workPolicies[${index}]`, diagnostics)).filter((policy) => Boolean(policy)),
-    agentPools: arrayBucket(resourcesValue, "agentPools", diagnostics)
-  };
-  const manifest = {
-    name,
-    version: 1,
-    description: asString(value.description) || void 0,
-    defaultEnvironments,
-    environments,
-    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"));
-  }
-  return manifest;
-}
-export {
-  parseSeedManifest
-};