@treeseed/sdk 0.4.6 → 0.4.8

package/dist/platform/book-export.js

@@ -0,0 +1,449 @@
+import { createHash } from "node:crypto";
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import path, { dirname, extname, relative, resolve } from "node:path";
+import { runDefaultAction, setLogLevel } from "repomix";
+import { parse as parseYaml } from "yaml";
+import { buildTenantBookRuntime } from "./books-data.js";
+import { loadTreeseedManifest } from "./tenant-config.js";
+const BOOK_EXPORT_PACKAGE_VERSION = 1;
+function sha1(value) {
+  return createHash("sha1").update(value).digest("hex");
+}
+function sortPaths(paths) {
+  return [...paths].sort((left, right) => left.localeCompare(right, void 0, { numeric: true, sensitivity: "base" }));
+}
+function collectMarkdownFiles(rootPath) {
+  if (!existsSync(rootPath)) {
+    throw new Error(`Book export root not found: ${rootPath}`);
+  }
+  const stats = statSync(rootPath);
+  if (stats.isFile()) {
+    return [rootPath];
+  }
+  return sortPaths(
+    readdirSync(rootPath, { withFileTypes: true }).flatMap((entry) => {
+      const fullPath = path.join(rootPath, entry.name);
+      if (entry.isDirectory()) {
+        return collectMarkdownFiles(fullPath);
+      }
+      if (entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".mdx"))) {
+        return [fullPath];
+      }
+      return [];
+    })
+  );
+}
+function frontmatter(filePath) {
+  const raw = readFileSync(filePath, "utf8");
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  return match ? parseYaml(match[1]) : {};
+}
+function frontmatterOrder(filePath) {
+  const order = frontmatter(filePath).order;
+  return typeof order === "number" && Number.isFinite(order) ? order : null;
+}
+function contentTypeFor(filePath) {
+  const extension = extname(filePath).toLowerCase();
+  if (extension === ".md") return "md";
+  if (extension === ".mdx") return "mdx";
+  return "text";
+}
+function inferExportRoots(book, tenantConfig) {
+  const knowledgePrefix = "/knowledge/";
+  const normalizedBasePath = String(book.basePath || "").trim();
+  if (!normalizedBasePath.startsWith(knowledgePrefix)) {
+    throw new Error(`Book basePath must start with "${knowledgePrefix}" to infer exports: ${book.basePath}`);
+  }
+  const relativeKnowledgePath = normalizedBasePath.slice(knowledgePrefix.length).replace(/^\/+|\/+$/g, "");
+  if (!relativeKnowledgePath) {
+    throw new Error(`Book basePath must identify a knowledge directory: ${book.basePath}`);
+  }
+  return [path.join(tenantConfig.content.docs, relativeKnowledgePath)];
+}
+function resolveBookRoots(book, projectRoot, tenantConfig) {
+  const configuredRoots = Array.isArray(book.exportRoots) && book.exportRoots.length > 0 ? book.exportRoots.map((entry) => resolve(projectRoot, entry)) : inferExportRoots(book, tenantConfig).map((entry) => resolve(entry));
+  return configuredRoots;
+}
+function rootKeyFor(book, rootPath, projectRoot, index, total) {
+  if (total === 1) {
+    return "";
+  }
+  const rel = relative(projectRoot, rootPath).replaceAll(path.sep, "/");
+  const cleaned = rel.replaceAll(/[^a-zA-Z0-9/_-]+/g, "-").replaceAll(/-+/g, "-").replace(/^\/+|\/+$/g, "");
+  return cleaned || `root-${String(index + 1).padStart(2, "0")}`;
+}
+function orderedBookFiles(book, tenantConfig, projectRoot) {
+  const resolvedRoots = resolveBookRoots(book, projectRoot, tenantConfig);
+  const seen = /* @__PURE__ */ new Set();
+  const files = resolvedRoots.flatMap(
+    (rootPath, rootIndex) => collectMarkdownFiles(rootPath).sort((left, right) => {
+      const orderDelta = (frontmatterOrder(left) ?? Number.POSITIVE_INFINITY) - (frontmatterOrder(right) ?? Number.POSITIVE_INFINITY);
+      if (orderDelta !== 0) {
+        return orderDelta;
+      }
+      return left.localeCompare(right, void 0, { numeric: true, sensitivity: "base" });
+    }).map((absolutePath) => {
+      if (seen.has(absolutePath)) {
+        return null;
+      }
+      seen.add(absolutePath);
+      const rootRelativePath = relative(rootPath, absolutePath).replaceAll(path.sep, "/");
+      const rootKey = rootKeyFor(book, rootPath, projectRoot, rootIndex, resolvedRoots.length);
+      const bookRelativePath = rootKey ? `${rootKey}/${rootRelativePath}` : rootRelativePath;
+      return {
+        absolutePath,
+        rootPath,
+        rootRelativePath,
+        bookRelativePath
+      };
+    }).filter(Boolean)
+  );
+  return {
+    resolvedRoots,
+    files: files.map((file, index) => {
+      const projectRelativePath = relative(projectRoot, file.absolutePath).replaceAll(path.sep, "/");
+      const markerId = `marker:${book.id}:${String(index + 1).padStart(4, "0")}`;
+      return {
+        fileId: sha1(`${book.id}:${projectRelativePath}`),
+        bookId: book.id ?? book.slug,
+        memberBookId: book.id ?? book.slug,
+        absolutePath: file.absolutePath,
+        projectRelativePath,
+        bookRelativePath: file.bookRelativePath,
+        rootRelativePath: file.rootRelativePath,
+        rootPath: file.rootPath,
+        ordinal: index + 1,
+        frontmatterOrder: frontmatterOrder(file.absolutePath),
+        sourceType: contentTypeFor(file.absolutePath),
+        chunkId: sha1(`chunk:${book.id}:${projectRelativePath}:${index + 1}`),
+        markerId
+      };
+    })
+  };
+}
+function loadTenant(projectRoot = process.cwd()) {
+  const manifestPath = resolve(projectRoot, "src", "manifest.yaml");
+  const tenantConfig = loadTreeseedManifest(manifestPath);
+  const runtime = buildTenantBookRuntime(tenantConfig, { projectRoot });
+  return {
+    projectRoot,
+    tenantConfig,
+    runtime
+  };
+}
+function findBookOrThrow(bookId, books) {
+  const book = books.find((entry) => entry.id === bookId || entry.slug === bookId);
+  if (!book) {
+    throw new Error(`Unknown book export target: ${bookId}`);
+  }
+  return book;
+}
+function buildBookManifestFromBook(book, tenantConfig, projectRoot) {
+  const ordered = orderedBookFiles(book, tenantConfig, projectRoot);
+  return {
+    packageKind: "book",
+    packageVersion: BOOK_EXPORT_PACKAGE_VERSION,
+    packageId: `book:${book.id}`,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    tenantRoot: projectRoot,
+    tenantId: tenantConfig.id,
+    book: {
+      id: book.id ?? book.slug,
+      slug: book.slug,
+      title: book.title,
+      order: book.order,
+      basePath: book.basePath,
+      downloadFileName: book.downloadFileName,
+      downloadHref: book.downloadHref,
+      downloadTitle: book.downloadTitle,
+      resolvedRoots: ordered.resolvedRoots.map((entry) => relative(projectRoot, entry).replaceAll(path.sep, "/"))
+    },
+    files: ordered.files
+  };
+}
+function buildBookExportManifest(bookId, options = {}) {
+  const { projectRoot, tenantConfig, runtime } = loadTenant(resolve(options.projectRoot ?? process.cwd()));
+  const book = findBookOrThrow(bookId, runtime.BOOKS);
+  return buildBookManifestFromBook(book, tenantConfig, projectRoot);
+}
+function stageManifest(manifest, stageRoot) {
+  rmSync(stageRoot, { recursive: true, force: true });
+  mkdirSync(resolve(stageRoot, "manifest"), { recursive: true });
+  mkdirSync(resolve(stageRoot, "content"), { recursive: true });
+  writeFileSync(resolve(stageRoot, "manifest", "book.json"), `${JSON.stringify({
+    packageKind: manifest.packageKind,
+    packageVersion: manifest.packageVersion,
+    packageId: manifest.packageId,
+    generatedAt: manifest.generatedAt,
+    book: manifest.book,
+    members: manifest.members ?? []
+  }, null, 2)}
+`, "utf8");
+  writeFileSync(resolve(stageRoot, "manifest", "files.json"), `${JSON.stringify(manifest.files, null, 2)}
+`, "utf8");
+  for (const file of manifest.files) {
+    const stagedPath = resolve(
+      stageRoot,
+      "content",
+      String(file.ordinal).padStart(4, "0"),
+      file.bookRelativePath
+    );
+    mkdirSync(dirname(stagedPath), { recursive: true });
+    copyFileSync(file.absolutePath, stagedPath);
+  }
+}
+async function withCleanNodeExecArgv(action) {
+  const previousExecArgv = [...process.execArgv];
+  process.execArgv = previousExecArgv.filter(
+    (arg) => !arg.startsWith("--test") && !arg.startsWith("--input-type") && !arg.startsWith("--experimental-test") && !arg.startsWith("--watch")
+  );
+  try {
+    return await action();
+  } finally {
+    process.execArgv = previousExecArgv;
+  }
+}
+async function renderRepomixMarkdown(stageRoot, outputPath) {
+  const options = {
+    output: outputPath,
+    style: "markdown",
+    ignore: "",
+    quiet: true,
+    skipLocalConfig: true,
+    copy: false,
+    stdout: false
+  };
+  setLogLevel(0);
+  const result = await withCleanNodeExecArgv(() => runDefaultAction(["."], stageRoot, options));
+  return {
+    markdown: readFileSync(outputPath, "utf8"),
+    packResult: result.packResult
+  };
+}
+function normalizePackResultOutputFiles(packResult, outputPath) {
+  return packResult.outputFiles && packResult.outputFiles.length > 0 ? packResult.outputFiles : [outputPath];
+}
+function jsonFence(value) {
+  return ["```json", JSON.stringify(value, null, 2), "```"].join("\n");
+}
+function renderBookPackageMarkdown(manifest, repomixMarkdown) {
+  const header = {
+    packageKind: manifest.packageKind,
+    packageVersion: manifest.packageVersion,
+    packageId: manifest.packageId,
+    book: manifest.book,
+    sourceFileCount: manifest.files.length
+  };
+  const fileIndex = manifest.files.map((file) => ({
+    fileId: file.fileId,
+    ordinal: file.ordinal,
+    projectRelativePath: file.projectRelativePath,
+    bookRelativePath: file.bookRelativePath,
+    sourceType: file.sourceType,
+    chunkId: file.chunkId,
+    markerId: file.markerId
+  }));
+  return [
+    `# ${manifest.book.downloadTitle}`,
+    "",
+    "> Auto-generated Treeseed AI package. Treeseed owns the manifest and file ordering; Repomix owns the content serialization payload.",
+    "",
+    "<!-- TRESEED_PACKAGE_HEADER_BEGIN -->",
+    jsonFence(header),
+    "<!-- TRESEED_PACKAGE_HEADER_END -->",
+    "",
+    "<!-- TRESEED_PACKAGE_MANIFEST_BEGIN -->",
+    jsonFence(manifest),
+    "<!-- TRESEED_PACKAGE_MANIFEST_END -->",
+    "",
+    "<!-- TRESEED_PACKAGE_FILE_INDEX_BEGIN -->",
+    jsonFence(fileIndex),
+    "<!-- TRESEED_PACKAGE_FILE_INDEX_END -->",
+    "",
+    "<!-- TRESEED_PACKAGE_CONTENT_BEGIN -->",
+    repomixMarkdown.trim(),
+    "<!-- TRESEED_PACKAGE_CONTENT_END -->",
+    ""
+  ].join("\n");
+}
+function buildBookIndexPayload(manifest, markdownPath) {
+  return {
+    packageKind: manifest.packageKind,
+    packageVersion: manifest.packageVersion,
+    packageId: manifest.packageId,
+    markdownPath,
+    book: manifest.book,
+    files: manifest.files.map((file) => ({
+      fileId: file.fileId,
+      memberBookId: file.memberBookId,
+      ordinal: file.ordinal,
+      projectRelativePath: file.projectRelativePath,
+      bookRelativePath: file.bookRelativePath,
+      rootRelativePath: file.rootRelativePath,
+      sourceType: file.sourceType,
+      chunkId: file.chunkId,
+      markerId: file.markerId,
+      relations: {
+        book: manifest.book.id,
+        nextFileId: manifest.files.find((candidate) => candidate.ordinal === file.ordinal + 1)?.fileId ?? null
+      }
+    }))
+  };
+}
+function booksOutputRoot(projectRoot) {
+  return resolve(projectRoot, "public", "books");
+}
+function sidecarIndexPath(markdownPath) {
+  return markdownPath.replace(/\.md$/u, ".json");
+}
+async function exportManifestPackage(manifest, markdownPath, indexPath) {
+  const tempRoot = resolve(manifest.tenantRoot, ".treeseed", "tmp", "book-exports", manifest.packageId.replaceAll(":", "-"));
+  const repomixOutputPath = resolve(tempRoot, "..", `${manifest.packageId.replaceAll(":", "-")}.repomix.md`);
+  stageManifest(manifest, tempRoot);
+  const { markdown: repomixMarkdown, packResult } = await renderRepomixMarkdown(tempRoot, repomixOutputPath);
+  const wrappedMarkdown = renderBookPackageMarkdown(manifest, repomixMarkdown);
+  mkdirSync(dirname(markdownPath), { recursive: true });
+  writeFileSync(markdownPath, wrappedMarkdown, "utf8");
+  writeFileSync(indexPath, `${JSON.stringify({
+    ...buildBookIndexPayload(manifest, markdownPath),
+    repomixSummary: {
+      totalFiles: packResult.totalFiles,
+      totalCharacters: packResult.totalCharacters,
+      totalTokens: packResult.totalTokens,
+      outputFiles: normalizePackResultOutputFiles(packResult, repomixOutputPath)
+    }
+  }, null, 2)}
+`, "utf8");
+  rmSync(tempRoot, { recursive: true, force: true });
+  rmSync(repomixOutputPath, { force: true });
+}
+async function exportBookPackage(bookId, options = {}) {
+  const manifest = buildBookExportManifest(bookId, options);
+  const markdownPath = resolve(booksOutputRoot(manifest.tenantRoot), manifest.book.downloadFileName);
+  const indexPath = sidecarIndexPath(markdownPath);
+  await exportManifestPackage(manifest, markdownPath, indexPath);
+  return {
+    manifest,
+    markdownPath,
+    indexPath,
+    sourceFileCount: manifest.files.length,
+    includedRoots: manifest.book.resolvedRoots
+  };
+}
+function renderLibraryMarkdown(manifest, memberPackages) {
+  return [
+    `# ${manifest.book.downloadTitle}`,
+    "",
+    "> Auto-generated Treeseed AI library package. Each member section embeds a reconstructable per-book package.",
+    "",
+    "<!-- TRESEED_LIBRARY_HEADER_BEGIN -->",
+    jsonFence({
+      packageKind: manifest.packageKind,
+      packageVersion: manifest.packageVersion,
+      packageId: manifest.packageId,
+      book: manifest.book,
+      memberCount: memberPackages.length
+    }),
+    "<!-- TRESEED_LIBRARY_HEADER_END -->",
+    "",
+    "<!-- TRESEED_LIBRARY_MANIFEST_BEGIN -->",
+    jsonFence(manifest),
+    "<!-- TRESEED_LIBRARY_MANIFEST_END -->",
+    "",
+    ...memberPackages.flatMap((member) => [
+      `<!-- TRESEED_AGGREGATE_MEMBER_BEGIN ${member.manifest.book.id} -->`,
+      readFileSync(member.markdownPath, "utf8").trim(),
+      `<!-- TRESEED_AGGREGATE_MEMBER_END ${member.manifest.book.id} -->`,
+      ""
+    ])
+  ].join("\n");
+}
+async function exportBookLibrary(options = {}) {
+  const { projectRoot, tenantConfig, runtime } = loadTenant(resolve(options.projectRoot ?? process.cwd()));
+  const memberPackages = [];
+  for (const book of runtime.BOOKS) {
+    memberPackages.push(await exportBookPackage(book.id ?? book.slug, { projectRoot }));
+  }
+  const files = memberPackages.flatMap((entry) => entry.manifest.files);
+  const manifest = {
+    packageKind: "library",
+    packageVersion: BOOK_EXPORT_PACKAGE_VERSION,
+    packageId: "library:books",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    tenantRoot: projectRoot,
+    tenantId: tenantConfig.id,
+    book: {
+      id: "library",
+      slug: "library",
+      title: runtime.TREESEED_LIBRARY_DOWNLOAD.downloadTitle,
+      order: 0,
+      basePath: "/books/",
+      downloadFileName: runtime.TREESEED_LIBRARY_DOWNLOAD.downloadFileName,
+      downloadHref: runtime.TREESEED_LIBRARY_DOWNLOAD.downloadHref,
+      downloadTitle: runtime.TREESEED_LIBRARY_DOWNLOAD.downloadTitle,
+      resolvedRoots: Array.from(new Set(memberPackages.flatMap((entry) => entry.includedRoots))).sort((left, right) => left.localeCompare(right))
+    },
+    files,
+    members: memberPackages.map((entry) => ({
+      bookId: entry.manifest.book.id,
+      slug: entry.manifest.book.slug,
+      title: entry.manifest.book.title,
+      order: entry.manifest.book.order,
+      downloadFileName: entry.manifest.book.downloadFileName,
+      downloadHref: entry.manifest.book.downloadHref,
+      sourceFileCount: entry.sourceFileCount,
+      markdownPath: entry.markdownPath,
+      indexPath: entry.indexPath
+    }))
+  };
+  const markdownPath = resolve(booksOutputRoot(projectRoot), runtime.TREESEED_LIBRARY_DOWNLOAD.downloadFileName);
+  const indexPath = sidecarIndexPath(markdownPath);
+  mkdirSync(dirname(markdownPath), { recursive: true });
+  writeFileSync(markdownPath, renderLibraryMarkdown(manifest, memberPackages), "utf8");
+  writeFileSync(indexPath, `${JSON.stringify({
+    packageKind: manifest.packageKind,
+    packageVersion: manifest.packageVersion,
+    packageId: manifest.packageId,
+    markdownPath,
+    book: manifest.book,
+    members: manifest.members,
+    files: buildBookIndexPayload(manifest, markdownPath).files
+  }, null, 2)}
+`, "utf8");
+  return {
+    manifest,
+    markdownPath,
+    indexPath,
+    memberPackages,
+    sourceFileCount: files.length,
+    includedRoots: manifest.book.resolvedRoots
+  };
+}
+async function exportTenantBookPackages(options = {}) {
+  const { projectRoot } = loadTenant(resolve(options.projectRoot ?? process.cwd()));
+  const libraryPackage = await exportBookLibrary({ projectRoot });
+  const legacyOutputFile = resolve(projectRoot, "public", "book.md");
+  if (existsSync(legacyOutputFile)) {
+    rmSync(legacyOutputFile, { force: true });
+  }
+  return {
+    projectRoot,
+    bookPackages: libraryPackage.memberPackages,
+    libraryPackage
+  };
+}
+export {
+  buildBookExportManifest,
+  exportBookLibrary,
+  exportBookPackage,
+  exportTenantBookPackages
+};

package/dist/platform/contracts.d.ts

@@ -155,6 +155,10 @@ export interface TreeseedProviderSelections {
     };
     site?: string;
 }
+export interface TreeseedExportConfig {
+    ignore?: string[];
+    bundledPaths?: string[];
+}
 export interface TreeseedDeployConfig {
     name: string;
     slug: string;
@@ -174,6 +178,7 @@ export interface TreeseedDeployConfig {
     turnstile?: {
         enabled?: boolean;
     };
+    export?: TreeseedExportConfig;
 }
 export interface TreeseedTenantConfig {
     id: string;

package/dist/platform/deploy-config.d.ts

@@ -1,4 +1,6 @@
 import type { TreeseedDeployConfig } from './contracts.ts';
 export declare function resolveTreeseedDeployConfigPath(configPath?: string): string;
+export declare function resolveTreeseedDeployConfigPathFromRoot(tenantRoot: string, configPath?: string): string;
 export declare function deriveCloudflareWorkerName(config: TreeseedDeployConfig): string;
 export declare function loadTreeseedDeployConfig(configPath?: string): TreeseedDeployConfig;
+export declare function loadTreeseedDeployConfigFromPath(resolvedConfigPath: string): TreeseedDeployConfig;

package/dist/platform/deploy-config.js

@@ -41,6 +41,15 @@ function optionalBoolean(value, label) {
   }
   return value;
 }
+function optionalStringArray(value, label) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    throw new Error(`Invalid deploy config: expected ${label} to be an array of strings when provided.`);
+  }
+  return value.map((entry, index) => expectString(entry, `${label}[${index}]`)).filter(Boolean);
+}
 function optionalRecord(value, label) {
   if (value === void 0 || value === null) {
     return void 0;
@@ -185,6 +194,16 @@ function parsePlatformSurfacesConfig(value) {
     ])
   );
 }
+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")
+  };
+}
 function parseDeployConfig(raw) {
   const parsed = normalizeAliasedRecord(
     deployConfigFieldAliases,
@@ -215,11 +234,15 @@ function parseDeployConfig(raw) {
     },
     turnstile: {
       enabled: true
-    }
+    },
+    export: parseExportConfig(parsed.export)
   };
 }
 function resolveTreeseedDeployConfigPath(configPath = "treeseed.site.yaml") {
   const tenantRoot = resolveTreeseedTenantRoot();
+  return resolveTreeseedDeployConfigPathFromRoot(tenantRoot, configPath);
+}
+function resolveTreeseedDeployConfigPathFromRoot(tenantRoot, configPath = "treeseed.site.yaml") {
   const candidate = resolve(tenantRoot, configPath);
   if (!existsSync(candidate)) {
     throw new Error(`Unable to resolve Treeseed deploy config at "${candidate}".`);
@@ -231,6 +254,9 @@ function deriveCloudflareWorkerName(config) {
 }
 function loadTreeseedDeployConfig(configPath = "treeseed.site.yaml") {
   const resolvedConfigPath = resolveTreeseedDeployConfigPath(configPath);
+  return loadTreeseedDeployConfigFromPath(resolvedConfigPath);
+}
+function loadTreeseedDeployConfigFromPath(resolvedConfigPath) {
   const tenantRoot = dirname(resolvedConfigPath);
   const parsed = parseDeployConfig(readFileSync(resolvedConfigPath, "utf8"));
   Object.defineProperty(parsed, "__tenantRoot", {
@@ -246,5 +272,7 @@ function loadTreeseedDeployConfig(configPath = "treeseed.site.yaml") {
 export {
   deriveCloudflareWorkerName,
   loadTreeseedDeployConfig,
-  resolveTreeseedDeployConfigPath
+  loadTreeseedDeployConfigFromPath,
+  resolveTreeseedDeployConfigPath,
+  resolveTreeseedDeployConfigPathFromRoot
 };

package/dist/platform/env.yaml

@@ -12,6 +12,7 @@ entries:
       - local
       - staging
       - prod
+    storage: shared
     requirement: required
     purposes:
       - save
@@ -34,6 +35,7 @@ entries:
       - local
       - staging
       - prod
+    storage: shared
     requirement: required
     purposes:
       - save
@@ -58,6 +60,7 @@ entries:
       - local
       - staging
       - prod
+    storage: shared
     requirement: conditional
     purposes:
       - deploy
@@ -83,6 +86,7 @@ entries:
       - local
       - staging
       - prod
+    storage: shared
     requirement: optional
     purposes:
       - deploy
@@ -107,6 +111,7 @@ entries:
     scopes:
       - staging
       - prod
+    storage: shared
     requirement: required
     purposes:
       - save

package/dist/platform/environment.d.ts

@@ -5,18 +5,20 @@ export declare const TREESEED_ENVIRONMENT_REQUIREMENTS: readonly ["required", "c
 export declare const TREESEED_ENVIRONMENT_TARGETS: readonly ["local-file", "wrangler-dev-vars", "github-secret", "github-variable", "cloudflare-secret", "cloudflare-var", "railway-secret", "railway-var", "config-file"];
 export declare const TREESEED_ENVIRONMENT_PURPOSES: readonly ["dev", "save", "deploy", "destroy", "config"];
 export declare const TREESEED_ENVIRONMENT_SENSITIVITY: readonly ["secret", "plain", "derived"];
+export declare const TREESEED_ENVIRONMENT_STORAGE: readonly ["scoped", "shared"];
 export type TreeseedEnvironmentScope = (typeof TREESEED_ENVIRONMENT_SCOPES)[number];
 export type TreeseedEnvironmentRequirement = (typeof TREESEED_ENVIRONMENT_REQUIREMENTS)[number];
 export type TreeseedEnvironmentTarget = (typeof TREESEED_ENVIRONMENT_TARGETS)[number];
 export type TreeseedEnvironmentPurpose = (typeof TREESEED_ENVIRONMENT_PURPOSES)[number];
 export type TreeseedEnvironmentSensitivity = (typeof TREESEED_ENVIRONMENT_SENSITIVITY)[number];
+export type TreeseedEnvironmentStorage = (typeof TREESEED_ENVIRONMENT_STORAGE)[number];
 export type TreeseedEnvironmentValidation = {
     kind: 'string' | 'nonempty' | 'boolean' | 'number' | 'url' | 'email';
 } | {
     kind: 'enum';
     values: string[];
 };
-export type TreeseedEnvironmentValueResolver = string | ((context: TreeseedEnvironmentContext, scope: TreeseedEnvironmentScope) => string);
+export type TreeseedEnvironmentValueResolver = string | ((context: TreeseedEnvironmentContext, scope: TreeseedEnvironmentScope, values?: Record<string, string | undefined>) => string | undefined);
 export type TreeseedMachineSecretPayload = {
     algorithm: 'aes-256-gcm';
     iv: string;
@@ -39,6 +41,10 @@ export type TreeseedMachineConfig = {
             cloudflare: boolean;
         };
     };
+    shared: {
+        values: Record<string, string>;
+        secrets: Record<string, TreeseedMachineSecretPayload>;
+    };
     environments: Record<TreeseedEnvironmentScope, {
         values: Record<string, string>;
         secrets: Record<string, TreeseedMachineSecretPayload>;
@@ -61,6 +67,7 @@ export type TreeseedEnvironmentEntry = {
     scopes: TreeseedEnvironmentScope[];
     requirement: TreeseedEnvironmentRequirement;
     purposes: TreeseedEnvironmentPurpose[];
+    storage?: TreeseedEnvironmentStorage;
     validation?: TreeseedEnvironmentValidation;
     sourcePriority?: string[];
     defaultValue?: TreeseedEnvironmentValueResolver;
@@ -119,7 +126,9 @@ export declare function getTreeseedEnvironmentSuggestedValues(options: {
     deployConfig?: TreeseedDeployConfig;
     tenantConfig?: TreeseedTenantConfig;
     plugins?: LoadedTreeseedPluginEntry[];
+    values?: Record<string, string | undefined>;
 }): Record<string, string>;
+export declare function isTreeseedEnvironmentEntryRequired(entry: TreeseedEnvironmentEntry, context: TreeseedEnvironmentContext, scope: TreeseedEnvironmentScope, purpose?: TreeseedEnvironmentPurpose): boolean;
 export declare function validateTreeseedEnvironmentValues(options: {
     values: Record<string, string | undefined>;
     scope: TreeseedEnvironmentScope;