@treeseed/sdk 0.13.0-rc.8 → 0.13.0-rc.80

package/dist/platform/deploy-config/parse-public-tree-dx-federation-config.js

@@ -1,217 +0,0 @@
-import { normalizeAliasedRecord } from "../../entrypoints/models/field-aliases.js";
-import { DEFAULT_SOURCE_PAGE_PURGE_PATHS, optionalBoolean, optionalEnum, optionalNonNegativeNumber, optionalPositiveNumber, optionalRecord, optionalString, optionalStringArray, processingFieldAliases, webCachePolicyFieldAliases, webSurfaceCacheFieldAliases } from "./deploy-config-field-aliases.js";
-import { parseLocalRuntimeConfig, parseManagedServiceConfig, parseServiceEnvironmentConfig } from "./normalize-planes-from-legacy-hosting.js";
-function optionalPositiveInteger(value, label) {
-  const parsed = optionalPositiveNumber(value, label);
-  if (parsed !== void 0 && !Number.isInteger(parsed)) {
-    throw new Error(`Invalid deploy config: expected ${label} to be a positive integer when provided.`);
-  }
-  return parsed;
-}
-function parsePublicTreeDxFederationConfig(value) {
-  const record = optionalRecord(value, "publicTreeDxFederation");
-  if (!record) {
-    return void 0;
-  }
-  const railway = optionalRecord(record.railway, "publicTreeDxFederation.railway") ?? {};
-  const nodePool = optionalRecord(railway.nodePool, "publicTreeDxFederation.railway.nodePool") ?? {};
-  const runtime = optionalRecord(railway.runtime, "publicTreeDxFederation.railway.runtime") ?? {};
-  const repositoryQueries = optionalRecord(railway.repositoryQueries, "publicTreeDxFederation.railway.repositoryQueries") ?? {};
-  const graphQueries = optionalRecord(railway.graphQueries, "publicTreeDxFederation.railway.graphQueries") ?? {};
-  const cacheMemoryFraction = optionalPositiveNumber(
-    runtime.cacheMemoryFraction,
-    "publicTreeDxFederation.railway.runtime.cacheMemoryFraction"
-  );
-  if (cacheMemoryFraction !== void 0 && cacheMemoryFraction > 1) {
-    throw new Error("Invalid deploy config: expected publicTreeDxFederation.railway.runtime.cacheMemoryFraction to be at most 1.");
-  }
-  return {
-    railway: {
-      nodePool: {
-        bootstrapCount: optionalPositiveNumber(
-          nodePool.bootstrapCount,
-          "publicTreeDxFederation.railway.nodePool.bootstrapCount"
-        ),
-        maxNodes: optionalPositiveNumber(
-          nodePool.maxNodes,
-          "publicTreeDxFederation.railway.nodePool.maxNodes"
-        )
-      },
-      runtime: {
-        cpuBudget: optionalPositiveInteger(runtime.cpuBudget, "publicTreeDxFederation.railway.runtime.cpuBudget"),
-        memoryBudgetMb: optionalPositiveInteger(runtime.memoryBudgetMb, "publicTreeDxFederation.railway.runtime.memoryBudgetMb"),
-        cacheMemoryFraction
-      },
-      repositoryQueries: {
-        poolSize: optionalPositiveInteger(repositoryQueries.poolSize, "publicTreeDxFederation.railway.repositoryQueries.poolSize"),
-        maxQueue: optionalPositiveInteger(repositoryQueries.maxQueue, "publicTreeDxFederation.railway.repositoryQueries.maxQueue"),
-        queueTimeoutMs: optionalPositiveInteger(repositoryQueries.queueTimeoutMs, "publicTreeDxFederation.railway.repositoryQueries.queueTimeoutMs")
-      },
-      graphQueries: {
-        poolSize: optionalPositiveInteger(graphQueries.poolSize, "publicTreeDxFederation.railway.graphQueries.poolSize"),
-        maxQueue: optionalPositiveInteger(graphQueries.maxQueue, "publicTreeDxFederation.railway.graphQueries.maxQueue"),
-        queueTimeoutMs: optionalPositiveInteger(graphQueries.queueTimeoutMs, "publicTreeDxFederation.railway.graphQueries.queueTimeoutMs")
-      }
-    }
-  };
-}
-function parseManagedServicesConfig(value) {
-  const record = optionalRecord(value, "services");
-  if (!record) {
-    return void 0;
-  }
-  return Object.fromEntries(
-    Object.entries(record).map(([serviceKey, serviceValue]) => [
-      serviceKey,
-      parseManagedServiceConfig(serviceValue, `services.${serviceKey}`)
-    ])
-  );
-}
-function parseProcessingConfig(value, services) {
-  const record = normalizeAliasedRecord(
-    processingFieldAliases,
-    optionalRecord(value, "processing") ?? {}
-  );
-  const hasProcessingServices = Object.entries(services ?? {}).some(
-    ([serviceKey, service]) => ["api", "manager", "worker", "workerRunner", "workdayStart", "workdayReport"].includes(serviceKey) && service && service.enabled !== false
-  );
-  return {
-    mode: optionalEnum(record.mode, "processing.mode", [
-      "market-assigned",
-      "team-owned",
-      "project-owned",
-      "local",
-      "none"
-    ]) ?? (hasProcessingServices ? "project-owned" : "market-assigned"),
-    providerRef: optionalString(record.providerRef),
-    requiredCapabilities: optionalStringArray(record.requiredCapabilities, "processing.requiredCapabilities")
-  };
-}
-function parseConnectionsConfig(value) {
-  const record = optionalRecord(value, "connections") ?? {};
-  const api = optionalRecord(record.api, "connections.api");
-  if (!api) {
-    return Object.keys(record).length > 0 ? record : void 0;
-  }
-  const environmentsRaw = optionalRecord(api.environments, "connections.api.environments") ?? {};
-  const environments = Object.fromEntries(
-    ["local", "staging", "prod"].map((scope) => {
-      const environment = optionalRecord(environmentsRaw[scope], `connections.api.environments.${scope}`);
-      return [scope, environment ? {
-        baseUrl: optionalString(environment.baseUrl),
-        domain: optionalString(environment.domain)
-      } : void 0];
-    }).filter(([, environment]) => environment)
-  );
-  return {
-    ...record,
-    api: {
-      proxyPrefix: optionalString(api.proxyPrefix),
-      localBaseUrl: optionalString(api.localBaseUrl),
-      environments
-    }
-  };
-}
-function inferManagedRuntimeFromServices(services) {
-  return Object.values(services ?? {}).some(
-    (service) => service && service.enabled !== false && (service.provider ?? "railway") === "railway"
-  );
-}
-function parsePlatformSurfaceConfig(value, label) {
-  const record = optionalRecord(value, label);
-  if (!record) {
-    return void 0;
-  }
-  return {
-    enabled: record.enabled === void 0 ? void 0 : optionalBoolean(record.enabled, `${label}.enabled`),
-    provider: optionalString(record.provider),
-    rootDir: optionalString(record.rootDir),
-    publicBaseUrl: optionalString(record.publicBaseUrl),
-    localBaseUrl: optionalString(record.localBaseUrl),
-    local: parseLocalRuntimeConfig(record.local, `${label}.local`),
-    environments: (() => {
-      const environments = optionalRecord(record.environments, `${label}.environments`);
-      if (!environments) {
-        return void 0;
-      }
-      return {
-        local: parseServiceEnvironmentConfig(environments.local, `${label}.environments.local`),
-        staging: parseServiceEnvironmentConfig(environments.staging, `${label}.environments.staging`),
-        prod: parseServiceEnvironmentConfig(environments.prod, `${label}.environments.prod`)
-      };
-    })(),
-    cache: parseWebSurfaceCacheConfig(record.cache, `${label}.cache`)
-  };
-}
-function parseWebSurfaceCacheConfig(value, label) {
-  const record = normalizeAliasedRecord(
-    webSurfaceCacheFieldAliases,
-    optionalRecord(value, label) ?? {}
-  );
-  if (!value || Object.keys(record).length === 0) {
-    return void 0;
-  }
-  return {
-    sourcePages: parseWebCachePolicyRecord(record.sourcePages, `${label}.sourcePages`, {
-      paths: DEFAULT_SOURCE_PAGE_PURGE_PATHS
-    }),
-    contentPages: parseWebCachePolicyRecord(record.contentPages, `${label}.contentPages`),
-    r2PublishedObjects: parseWebCachePolicyRecord(record.r2PublishedObjects, `${label}.r2PublishedObjects`)
-  };
-}
-function parseWebCachePolicyRecord(value, label, options = {}) {
-  const record = normalizeAliasedRecord(
-    webCachePolicyFieldAliases,
-    optionalRecord(value, label) ?? {}
-  );
-  if (!value || Object.keys(record).length === 0) {
-    return options.paths ? { paths: [...options.paths] } : void 0;
-  }
-  const parsed = {
-    browserTtlSeconds: optionalNonNegativeNumber(record.browserTtlSeconds, `${label}.browserTtlSeconds`),
-    edgeTtlSeconds: optionalNonNegativeNumber(record.edgeTtlSeconds, `${label}.edgeTtlSeconds`),
-    staleWhileRevalidateSeconds: optionalNonNegativeNumber(
-      record.staleWhileRevalidateSeconds,
-      `${label}.staleWhileRevalidateSeconds`
-    ),
-    staleIfErrorSeconds: optionalNonNegativeNumber(record.staleIfErrorSeconds, `${label}.staleIfErrorSeconds`)
-  };
-  if (options.paths) {
-    parsed.paths = [...new Set(optionalStringArray(record.paths, `${label}.paths`) ?? options.paths)];
-  }
-  return parsed;
-}
-function parsePlatformSurfacesConfig(value) {
-  const record = optionalRecord(value, "surfaces");
-  if (!record) {
-    return void 0;
-  }
-  return Object.fromEntries(
-    Object.entries(record).map(([surfaceKey, surfaceValue]) => [
-      surfaceKey,
-      parsePlatformSurfaceConfig(surfaceValue, `surfaces.${surfaceKey}`)
-    ])
-  );
-}
-function parseExportConfig(value) {
-  const record = optionalRecord(value, "export");
-  if (!record) {
-    return void 0;
-  }
-  return {
-    ignore: optionalStringArray(record.ignore, "export.ignore"),
-    bundledPaths: optionalStringArray(record.bundledPaths, "export.bundledPaths")
-  };
-}
-export {
-  inferManagedRuntimeFromServices,
-  parseConnectionsConfig,
-  parseExportConfig,
-  parseManagedServicesConfig,
-  parsePlatformSurfaceConfig,
-  parsePlatformSurfacesConfig,
-  parseProcessingConfig,
-  parsePublicTreeDxFederationConfig,
-  parseWebCachePolicyRecord,
-  parseWebSurfaceCacheConfig
-};

package/dist/platform/desired-state/compile-desired-resource-graph.d.ts

@@ -1,13 +0,0 @@
-import type { DesiredUnit, ReconcileSelector, ReconcileTarget } from '../../reconcile/support/contracts/contracts.js';
-import { type LocalContentMode } from '../content/local-content-materialization.js';
-import { DesiredResource, DesiredResourceGraph } from './desired-environment.js';
-export declare function compileDesiredResourceGraph({ tenantRoot, target, localContent, capacityConfigPath, seedNames, }: {
-    tenantRoot?: string;
-    target: ReconcileTarget;
-    localContent?: LocalContentMode;
-    capacityConfigPath?: string;
-    seedNames?: string[];
-}): DesiredResourceGraph;
-export declare function selectDesiredResources(graph: DesiredResourceGraph, selector?: ReconcileSelector): DesiredResourceGraph;
-export declare function convertDesiredResourceToReconcileUnit(graph: DesiredResourceGraph, resource: DesiredResource): DesiredUnit | null;
-export declare function compileDesiredUnitsFromGraph(graph: DesiredResourceGraph, selector?: ReconcileSelector): DesiredUnit[];

package/dist/platform/desired-state/compile-desired-resource-graph.js

@@ -1,130 +0,0 @@
-import {
-  discoverPackageAdapters
-} from "../../operations/services/reconciliation/package-adapters.js";
-import {
-  checkedOutTemplateRepositories
-} from "../../operations/services/support/managed-repositories.js";
-import { workspaceRoot } from "../../operations/services/treedx/workspaces/workspace-tools.js";
-import { deriveDesiredUnits } from "../../reconcile/reconciliation/desired-state.js";
-import { environmentFromTarget, hashJson, packageUnitFromAdapter, reconcileIdentityForGraph, templateUnitFromRepository } from "./desired-environment.js";
-import { localDevelopmentResources } from "./local-development-resources.js";
-import { packageResources, templateResources } from "./package-resources.js";
-import { branchPreviewResources, releaseGateResources, resourceMatchesSelector } from "./release-gate-resources.js";
-import { resourceFromUnit } from "./safe-tree-dx-repository-name.js";
-function compileDesiredResourceGraph({
-  tenantRoot = workspaceRoot(),
-  target,
-  localContent = "auto",
-  capacityConfigPath,
-  seedNames
-}) {
-  const environment = environmentFromTarget(target);
-  const derived = deriveDesiredUnits({ tenantRoot, target });
-  const packageAdapters = discoverPackageAdapters(tenantRoot);
-  const packages = packageAdapters.map(packageUnitFromAdapter);
-  const templates = checkedOutTemplateRepositories(tenantRoot).map(templateUnitFromRepository);
-  const resources = [
-    ...derived.units.map((unit) => resourceFromUnit(unit, environment)),
-    ...packageAdapters.flatMap((adapter) => packageResources(adapter, environment)),
-    ...templateResources(templates, environment),
-    ...localDevelopmentResources(tenantRoot, environment, localContent, templates, capacityConfigPath, derived.deployConfig, seedNames),
-    ...branchPreviewResources(target, environment),
-    ...releaseGateResources(packages, templates, environment)
-  ];
-  const edges = resources.flatMap((resource) => resource.dependencies.map((dependency) => ({
-    from: dependency,
-    to: resource.id,
-    reason: "depends-on"
-  })));
-  const fingerprints = Object.fromEntries(resources.map((resource) => [resource.id, hashJson(resource)]));
-  return {
-    workspaceId: derived.deployConfig.slug,
-    environment,
-    packages,
-    templates,
-    resources,
-    edges,
-    fingerprints
-  };
-}
-function selectDesiredResources(graph, selector) {
-  if (!selector) return graph;
-  const selected = graph.resources.filter((resource) => resourceMatchesSelector(resource, selector));
-  const selectedIds = new Set(selected.map((resource) => resource.id));
-  const include = new Map(selected.map((resource) => [resource.id, resource]));
-  const byId = new Map(graph.resources.map((resource) => [resource.id, resource]));
-  const visit = (resource) => {
-    for (const dependencyId of resource.dependencies) {
-      const dependency = byId.get(dependencyId);
-      if (!dependency || include.has(dependency.id)) continue;
-      include.set(dependency.id, dependency);
-      visit(dependency);
-    }
-  };
-  for (const resource of selected) visit(resource);
-  const resources = graph.resources.filter((resource) => include.has(resource.id));
-  const resourceIds = new Set(resources.map((resource) => resource.id));
-  return {
-    ...graph,
-    resources,
-    edges: graph.edges.filter((edge) => resourceIds.has(edge.from) && resourceIds.has(edge.to)),
-    fingerprints: Object.fromEntries(Object.entries(graph.fingerprints).filter(([id]) => resourceIds.has(id))),
-    packages: graph.packages.filter((pkg) => resources.some((resource) => resource.packageId === pkg.id) || selectedIds.size === 0),
-    templates: graph.templates.filter((template) => resources.some((resource) => resource.packageId === template.id) || selectedIds.size === 0)
-  };
-}
-function convertDesiredResourceToReconcileUnit(graph, resource) {
-  const identity = reconcileIdentityForGraph(graph.workspaceId, graph.environment);
-  if (resource.source.type !== "reconcile-unit") {
-    const unitType2 = (() => {
-      if (resource.kind === "release-gate") return String(resource.spec.gateKind ?? "release-gate:verify");
-      if (resource.kind === "save-gate") return String(resource.spec.gateKind ?? "save-gate:promotion-readiness");
-      return resource.kind;
-    })();
-    return {
-      unitId: resource.id,
-      unitType: unitType2,
-      provider: resource.provider,
-      identity,
-      target: { kind: "persistent", scope: graph.environment },
-      logicalName: resource.logicalName,
-      dependencies: resource.dependencies,
-      spec: resource.spec,
-      secrets: {},
-      metadata: {
-        resourceKind: resource.kind,
-        packageId: resource.packageId,
-        serviceId: resource.serviceId,
-        source: resource.source
-      }
-    };
-  }
-  const spec = resource.spec;
-  const unitType = typeof spec.unitType === "string" ? spec.unitType : null;
-  const resourceIdentity = spec.identity && typeof spec.identity === "object" ? spec.identity : null;
-  const target = spec.target && typeof spec.target === "object" ? spec.target : { kind: "persistent", scope: graph.environment };
-  const unitSpec = spec.spec && typeof spec.spec === "object" ? spec.spec : {};
-  const metadata = spec.metadata && typeof spec.metadata === "object" ? spec.metadata : {};
-  if (!unitType || !resourceIdentity) return null;
-  return {
-    unitId: resource.source.id,
-    unitType,
-    provider: resource.provider,
-    identity: resourceIdentity,
-    target,
-    logicalName: resource.logicalName,
-    dependencies: resource.dependencies,
-    spec: unitSpec,
-    secrets: {},
-    metadata
-  };
-}
-function compileDesiredUnitsFromGraph(graph, selector) {
-  return selectDesiredResources(graph, selector).resources.map((resource) => convertDesiredResourceToReconcileUnit(graph, resource)).filter((unit) => Boolean(unit));
-}
-export {
-  compileDesiredResourceGraph,
-  compileDesiredUnitsFromGraph,
-  convertDesiredResourceToReconcileUnit,
-  selectDesiredResources
-};

package/dist/platform/desired-state/desired-environment.d.ts

@@ -1,79 +0,0 @@
-import { type PackageAdapter } from '../../operations/services/reconciliation/package-adapters.js';
-import { checkedOutTemplateRepositories, type TemplateRepositoryManifest } from '../../operations/services/support/managed-repositories.js';
-import type { DesiredUnit, ReconcileTarget } from '../../reconcile/support/contracts/contracts.js';
-export type DesiredEnvironment = 'local' | 'staging' | 'prod';
-export type PackageUnit = {
-    id: string;
-    name: string;
-    kind: string;
-    path: string;
-    version: string | null;
-    publishTarget: string | null;
-    manifestPath: string | null;
-    repository: string | null;
-    releaseCapability: 'npm' | 'image' | 'deploy-only' | 'none';
-    requiredSecrets: string[];
-    requiredVariables: string[];
-    githubEnvironments: string[];
-};
-export type TemplateUnit = {
-    id: string;
-    name: string;
-    category: string;
-    path: string;
-    version: string | null;
-    repository: string | null;
-    manifestPath: string | null;
-    releaseTag: string | null;
-    recordPath: string;
-};
-export type DesiredResourceKind = 'package-manifest' | 'template-manifest' | 'package-workflow' | 'package-image' | 'github-environment' | 'github-secret-binding' | 'github-variable-binding' | 'docker-image-build' | 'cloudflare-resource' | 'railway-project' | 'railway-environment' | 'railway-service' | 'railway-volume' | 'railway-domain' | 'local-process' | 'cloudflare-tunnel' | 'local-docker-compose' | 'local-treedx' | 'local-content-materialization' | 'local-seed-bootstrap' | 'capacity-provider' | 'branch-preview' | 'branch-preview-cleanup' | 'workflow-gate' | 'save-gate' | 'release-gate';
-export type DesiredResource = {
-    id: string;
-    kind: DesiredResourceKind;
-    provider: string;
-    environment: DesiredEnvironment;
-    packageId: string | null;
-    serviceId: string | null;
-    logicalName: string;
-    dependencies: string[];
-    spec: Record<string, unknown>;
-    source: {
-        type: 'reconcile-unit' | 'package-adapter';
-        id: string;
-    };
-};
-export declare function resolveLocalGitCommonDir(tenantRoot: string): string;
-export type DesiredResourceEdge = {
-    from: string;
-    to: string;
-    reason: 'depends-on' | 'releases' | 'hosts';
-};
-export type DesiredResourceGraph = {
-    workspaceId: string;
-    environment: DesiredEnvironment;
-    packages: PackageUnit[];
-    templates: TemplateUnit[];
-    resources: DesiredResource[];
-    edges: DesiredResourceEdge[];
-    fingerprints: Record<string, string>;
-};
-export declare const INTERNAL_PACKAGE_DEPENDENCY_FIELDS: readonly ["dependencies", "optionalDependencies", "peerDependencies", "devDependencies"];
-export declare function hashJson(value: unknown): string;
-export declare function reconcileIdentityForGraph(workspaceId: string, environment: DesiredEnvironment): DesiredUnit['identity'];
-export declare function environmentFromTarget(target: ReconcileTarget): DesiredEnvironment;
-export declare function packageReleaseCapability(adapter: PackageAdapter): PackageUnit['releaseCapability'];
-export declare function packageUnitFromAdapter(adapter: PackageAdapter): PackageUnit;
-export declare const PRODUCTION_ONLY_GITHUB_SECRET_NAMES: Set<string>;
-export declare function packageRequiredSecretsForGitHubEnvironment(adapter: PackageAdapter, environmentName: string): string[];
-export declare function packageRequiredVariablesForGitHubEnvironment(adapter: PackageAdapter, _environmentName: string): string[];
-export declare function packageUnitRequiredSecretsForGitHubEnvironment(pkg: PackageUnit, environmentName: string): string[];
-export declare function templateReleaseTag(manifest: TemplateRepositoryManifest): string | null;
-export declare function templateUnitFromRepository(repo: ReturnType<typeof checkedOutTemplateRepositories>[number]): TemplateUnit;
-export declare function stringRecord(value: unknown): Record<string, unknown>;
-export declare function stringArray(value: unknown): string[];
-export declare function workflowName(value: unknown, fallback: string): string;
-export declare function packageShortSha(adapter: PackageAdapter): string;
-export declare function materializeDockerImageTags(tags: string[], adapter: PackageAdapter, branch: string): string[];
-export declare function dockerPlatforms(artifactArchitectures: unknown, adapterArchitectures: unknown): string[];
-export declare function localDockerPlatform(): "linux/amd64" | "linux/arm64" | "linux/arm/v7";

package/dist/platform/desired-state/desired-environment.js

@@ -1,162 +0,0 @@
-import { createHash } from "node:crypto";
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { dirname, resolve as resolvePath } from "node:path";
-function resolveLocalGitCommonDir(tenantRoot) {
-  const dotGitPath = resolvePath(tenantRoot, ".git");
-  if (!existsSync(dotGitPath)) return "";
-  try {
-    if (statSync(dotGitPath).isDirectory()) return dotGitPath;
-    const stat = readFileSync(dotGitPath, "utf8");
-    const match = /^gitdir:\s*(.+)\s*$/imu.exec(stat);
-    if (!match?.[1]) return dotGitPath;
-    const gitDir = resolvePath(tenantRoot, match[1].trim());
-    const commonDirPath = resolvePath(gitDir, "commondir");
-    if (existsSync(commonDirPath)) {
-      const commonDir = readFileSync(commonDirPath, "utf8").trim();
-      if (commonDir) return resolvePath(gitDir, commonDir);
-    }
-    const marker = `${resolvePath("/").replace(/\/$/u, "")}.git/worktrees/`;
-    const normalized = gitDir.replace(/\\/gu, "/");
-    const markerIndex = normalized.indexOf("/.git/worktrees/");
-    if (markerIndex >= 0) return normalized.slice(0, markerIndex + "/.git".length);
-    if (normalized.includes(marker)) return normalized.slice(0, normalized.indexOf(marker) + "/.git".length);
-    return dirname(gitDir);
-  } catch {
-    return "";
-  }
-}
-const INTERNAL_PACKAGE_DEPENDENCY_FIELDS = [
-  "dependencies",
-  "optionalDependencies",
-  "peerDependencies",
-  "devDependencies"
-];
-function hashJson(value) {
-  return createHash("sha256").update(JSON.stringify(value)).digest("hex");
-}
-function reconcileIdentityForGraph(workspaceId, environment) {
-  return {
-    teamId: workspaceId,
-    projectId: workspaceId,
-    slug: workspaceId,
-    environment,
-    deploymentKey: `${workspaceId}:${environment}`,
-    environmentKey: environment
-  };
-}
-function environmentFromTarget(target) {
-  if (target.kind === "persistent") return target.scope;
-  return "staging";
-}
-function packageReleaseCapability(adapter) {
-  if (!adapter.capabilities.publish) return adapter.releaseChecks.length > 0 ? "deploy-only" : "none";
-  if (adapter.artifacts.some((artifact) => artifact.provider === "docker")) return "image";
-  if (adapter.artifacts.some((artifact) => artifact.provider === "npm")) return "npm";
-  if (adapter.releaseChecks.length > 0) return "deploy-only";
-  return "none";
-}
-function packageUnitFromAdapter(adapter) {
-  return {
-    id: adapter.id,
-    name: adapter.name,
-    kind: adapter.kind,
-    path: adapter.relativeDir,
-    version: adapter.version,
-    publishTarget: adapter.publishTarget,
-    manifestPath: adapter.manifestPath,
-    repository: typeof adapter.metadata.repository === "string" ? adapter.metadata.repository : null,
-    releaseCapability: packageReleaseCapability(adapter),
-    requiredSecrets: Array.isArray(adapter.metadata.requiredSecrets) ? adapter.metadata.requiredSecrets : [],
-    requiredVariables: Array.isArray(adapter.metadata.requiredVariables) ? adapter.metadata.requiredVariables : [],
-    githubEnvironments: Array.isArray(adapter.metadata.githubEnvironments) ? adapter.metadata.githubEnvironments : []
-  };
-}
-const PRODUCTION_ONLY_GITHUB_SECRET_NAMES = /* @__PURE__ */ new Set([
-  "NPM_TOKEN",
-  "PYPI_API_TOKEN",
-  "CARGO_REGISTRY_TOKEN",
-  "HEX_API_KEY"
-]);
-function packageRequiredSecretsForGitHubEnvironment(adapter, environmentName) {
-  const requiredSecrets = Array.isArray(adapter.metadata.requiredSecrets) ? adapter.metadata.requiredSecrets : [];
-  const isProduction = environmentName === "production";
-  return requiredSecrets.filter((secretName) => {
-    if (typeof secretName !== "string" || !secretName.trim()) return false;
-    return isProduction || !PRODUCTION_ONLY_GITHUB_SECRET_NAMES.has(secretName);
-  });
-}
-function packageRequiredVariablesForGitHubEnvironment(adapter, _environmentName) {
-  return (Array.isArray(adapter.metadata.requiredVariables) ? adapter.metadata.requiredVariables : []).filter((variableName) => typeof variableName === "string" && Boolean(variableName.trim()));
-}
-function packageUnitRequiredSecretsForGitHubEnvironment(pkg, environmentName) {
-  const isProduction = environmentName === "production";
-  return pkg.requiredSecrets.filter((secretName) => isProduction || !PRODUCTION_ONLY_GITHUB_SECRET_NAMES.has(secretName));
-}
-function templateReleaseTag(manifest) {
-  return manifest.version ? `${manifest.release.tagPrefix}${manifest.id}/v${manifest.version}` : null;
-}
-function templateUnitFromRepository(repo) {
-  const manifest = repo.templateManifest;
-  return {
-    id: manifest.id,
-    name: manifest.name,
-    category: manifest.category,
-    path: repo.relativeDir,
-    version: manifest.version,
-    repository: manifest.repository,
-    manifestPath: manifest.manifestPath,
-    releaseTag: templateReleaseTag(manifest),
-    recordPath: manifest.release.recordPath
-  };
-}
-function stringRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function stringArray(value) {
-  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [];
-}
-function workflowName(value, fallback) {
-  return (typeof value === "string" && value.trim() ? value.trim() : fallback).replace(/^\.github\/workflows\//u, "");
-}
-function packageShortSha(adapter) {
-  const envSha = process.env.GITHUB_SHA;
-  if (typeof envSha === "string" && /^[a-f0-9]{7,40}$/iu.test(envSha)) return envSha.slice(0, 12).toLowerCase();
-  return createHash("sha256").update(`${adapter.id}:${adapter.dir}:${adapter.version ?? ""}`).digest("hex").slice(0, 12);
-}
-function materializeDockerImageTags(tags, adapter, branch) {
-  const shortSha = packageShortSha(adapter);
-  const branchSlug = branch.replace(/[^A-Za-z0-9_.-]+/gu, "-").replace(/^-+|-+$/gu, "") || "branch";
-  return tags.map((tag) => tag.replace(/<short-sha>/gu, shortSha).replace(/<branch-slug>/gu, branchSlug).replace(/<branch>/gu, branchSlug).replace(/<version>/gu, String(adapter.version ?? "latest").replace(/[^A-Za-z0-9_.-]+/gu, "-")));
-}
-function dockerPlatforms(artifactArchitectures, adapterArchitectures) {
-  const architectures = stringArray(artifactArchitectures).length > 0 ? stringArray(artifactArchitectures) : stringArray(adapterArchitectures);
-  const normalized = architectures.length > 0 ? architectures : ["amd64", "arm64"];
-  return normalized.map((arch) => arch.startsWith("linux/") ? arch : `linux/${arch}`);
-}
-function localDockerPlatform() {
-  if (process.arch === "arm64") return "linux/arm64";
-  if (process.arch === "arm") return "linux/arm/v7";
-  return "linux/amd64";
-}
-export {
-  INTERNAL_PACKAGE_DEPENDENCY_FIELDS,
-  PRODUCTION_ONLY_GITHUB_SECRET_NAMES,
-  dockerPlatforms,
-  environmentFromTarget,
-  hashJson,
-  localDockerPlatform,
-  materializeDockerImageTags,
-  packageReleaseCapability,
-  packageRequiredSecretsForGitHubEnvironment,
-  packageRequiredVariablesForGitHubEnvironment,
-  packageShortSha,
-  packageUnitFromAdapter,
-  packageUnitRequiredSecretsForGitHubEnvironment,
-  reconcileIdentityForGraph,
-  resolveLocalGitCommonDir,
-  stringArray,
-  stringRecord,
-  templateReleaseTag,
-  templateUnitFromRepository,
-  workflowName
-};

package/dist/platform/desired-state/docker-source-closure.d.ts

@@ -1 +0,0 @@
-export declare function dockerSourceClosureDigest(packageRoot: string, packageId: string): string;

package/dist/platform/desired-state/docker-source-closure.js

@@ -1,33 +0,0 @@
-import { createHash } from "node:crypto";
-import { existsSync, lstatSync, readdirSync, readFileSync } from "node:fs";
-import { relative, resolve } from "node:path";
-const PACKAGE_INPUTS = ["Dockerfile", "src", "scripts", "templates", "docs", "package.json", "package-lock.json"];
-const AGENT_SDK_INPUTS = ["../sdk/src", "../sdk/package.json", "../sdk/package-lock.json"];
-function files(path) {
-  if (!existsSync(path)) return [];
-  const stat = lstatSync(path);
-  if (stat.isSymbolicLink()) return [];
-  if (stat.isFile()) return [path];
-  if (!stat.isDirectory()) return [];
-  return readdirSync(path).sort().flatMap((entry) => files(resolve(path, entry)));
-}
-function dockerSourceClosureDigest(packageRoot, packageId) {
-  const inputs = packageId === "@treeseed/agent" ? [...PACKAGE_INPUTS, ...AGENT_SDK_INPUTS] : [...PACKAGE_INPUTS];
-  const hash = createHash("sha256");
-  for (const input of inputs) {
-    const matches = files(resolve(packageRoot, input));
-    hash.update(input);
-    hash.update("\0");
-    if (matches.length === 0) hash.update("<missing>\0");
-    for (const file of matches) {
-      hash.update(relative(packageRoot, file));
-      hash.update("\0");
-      hash.update(readFileSync(file));
-      hash.update("\0");
-    }
-  }
-  return hash.digest("hex");
-}
-export {
-  dockerSourceClosureDigest
-};

package/dist/platform/desired-state/local-development-resources.d.ts

@@ -1,4 +0,0 @@
-import { type LocalContentMode } from '../content/local-content-materialization.js';
-import { DesiredEnvironment, DesiredResource, TemplateUnit } from './desired-environment.js';
-import type { DeployConfig } from '../support/contracts.js';
-export declare function localDevelopmentResources(tenantRoot: string, environment: DesiredEnvironment, localContent: LocalContentMode, templates: TemplateUnit[], capacityConfigPath?: string, deployConfig?: DeployConfig, seedNames?: string[]): DesiredResource[];