@treeseed/sdk 0.3.4 → 0.4.1

package/README.md

@@ -41,7 +41,7 @@ Consumer contract:
 ## Quickstart
 
 ```ts
-import { AgentSdk } from '@treeseed/sdk';
+import { AgentSdk } from '@treeseed/sdk/sdk';
 
 const sdk = new AgentSdk({
   repoRoot: '/absolute/path/to/your-site',
@@ -51,7 +51,7 @@ const sdk = new AgentSdk({
 Use `AgentSdk.createLocal()` when you want a local Wrangler-backed D1 database:
 
 ```ts
-import { AgentSdk } from '@treeseed/sdk';
+import { AgentSdk } from '@treeseed/sdk/sdk';
 
 const sdk = AgentSdk.createLocal({
   repoRoot: '/absolute/path/to/your-site',
@@ -71,7 +71,7 @@ The preferred graph API for new integrations is:
 Example:
 
 ```ts
-import { AgentSdk } from '@treeseed/sdk';
+import { AgentSdk } from '@treeseed/sdk/sdk';
 
 const sdk = new AgentSdk();
 const parsed = await sdk.parseGraphDsl(
@@ -102,6 +102,19 @@ ctx <target>
 
 The old `key=value` graph DSL is no longer supported.
 
+## Shared Fixture Support
+
+SDK also owns the shared fixture support model used across the Treeseed workspace.
+
+That support layer is responsible for:
+
+- resolving the canonical shared fixture in `.fixtures/treeseed-fixtures`
+- preparing fixture-local package visibility for package-scoped verification
+- linking real workspace or installed packages into the fixture runtime when available
+- providing the canonical `contracts-only` Agent shim used by packages such as `core` during isolated verification
+
+The shared fixture is an integrated Treeseed project, but package verification remains package-scoped. SDK owns the tooling that lets other packages validate their own slice of that project without mutating the fixture itself.
+
 ## Advanced Graph Methods
 
 The SDK also exposes lower-level graph primitives such as:
@@ -166,3 +179,9 @@ npm install
 npm run build
 npm test
 ```
+
+For fixture-specific work:
+
+```bash
+npm run fixtures:check
+```

package/dist/fixture-support.d.ts

@@ -0,0 +1,24 @@
+export type FixtureInjectionMode = 'workspace-link' | 'installed-link' | 'contracts-only';
+export type FixtureSupportDeclaration = {
+    packageName: string;
+    modes: readonly FixtureInjectionMode[];
+    workspaceDirName?: string;
+    entrySpecifier?: string;
+    contractsShim?: 'agent';
+};
+export type ResolveSharedFixtureOptions = {
+    packageRoot?: string;
+    requiredPaths?: string[];
+};
+export type PrepareFixturePackagesOptions = {
+    fixtureRoot: string;
+    packageRoot?: string;
+    declarations: readonly FixtureSupportDeclaration[];
+};
+export declare const DEFAULT_FIXTURE_ID = "treeseed-working-site";
+export declare function resolveRequestedFixtureId(): string;
+export declare function resolveFixturesRepoRoot(options?: ResolveSharedFixtureOptions): string;
+export declare function resolveSharedFixtureRoot(options?: ResolveSharedFixtureOptions): string | null;
+export declare function requireSharedFixtureRoot(options?: ResolveSharedFixtureOptions): string;
+export declare function checkSharedFixture(options?: ResolveSharedFixtureOptions): string;
+export declare function prepareFixturePackages(options: PrepareFixturePackagesOptions): void;

package/dist/fixture-support.js

@@ -0,0 +1,337 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const require2 = createRequire(import.meta.url);
+const sdkPackageRoot = resolve(fileURLToPath(new URL("..", import.meta.url)));
+const DEFAULT_FIXTURE_ID = "treeseed-working-site";
+function currentPackageRoot(packageRoot) {
+  return packageRoot ? resolve(packageRoot) : sdkPackageRoot;
+}
+function requiredFixturePaths(requiredPaths) {
+  return requiredPaths && requiredPaths.length > 0 ? requiredPaths : ["src/manifest.yaml", "src/content"];
+}
+function resolveRequestedFixtureId() {
+  return process.env.TREESEED_FIXTURE_ID?.trim() || DEFAULT_FIXTURE_ID;
+}
+function resolveFixturesRepoRoot(options = {}) {
+  if (process.env.TREESEED_FIXTURES_ROOT?.trim()) {
+    return resolve(process.env.TREESEED_FIXTURES_ROOT);
+  }
+  return resolve(currentPackageRoot(options.packageRoot), ".fixtures", "treeseed-fixtures");
+}
+function fixtureSatisfiesRequiredPaths(root, requiredPaths) {
+  return requiredFixturePaths(requiredPaths).every((relativePath) => existsSync(join(root, relativePath)));
+}
+function resolveSharedFixtureRoot(options = {}) {
+  const fixturesRepoRoot = resolveFixturesRepoRoot(options);
+  const sitesRoot = join(fixturesRepoRoot, "sites");
+  if (!existsSync(sitesRoot)) {
+    return null;
+  }
+  const requestedFixtureId = resolveRequestedFixtureId();
+  for (const entry of readdirSync(sitesRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const fixtureRoot = join(sitesRoot, entry.name);
+    const manifestPath = join(fixtureRoot, "fixture.manifest.json");
+    if (!existsSync(manifestPath)) {
+      continue;
+    }
+    try {
+      const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+      if (manifest.id !== requestedFixtureId) {
+        continue;
+      }
+      const root = resolve(fixtureRoot, manifest.root ?? ".");
+      if (fixtureSatisfiesRequiredPaths(root, options.requiredPaths)) {
+        return root;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function requireSharedFixtureRoot(options = {}) {
+  const fixtureRoot = resolveSharedFixtureRoot(options);
+  if (!fixtureRoot) {
+    throw new Error(
+      `Unable to resolve shared fixture "${resolveRequestedFixtureId()}". Initialize the submodule with "git submodule update --init --recursive".`
+    );
+  }
+  return fixtureRoot;
+}
+function checkSharedFixture(options = {}) {
+  const fixtureRoot = requireSharedFixtureRoot(options);
+  const missing = requiredFixturePaths(options.requiredPaths).filter((relativePath) => !existsSync(join(fixtureRoot, relativePath)));
+  if (missing.length > 0) {
+    throw new Error(`Shared fixture is missing required paths at ${fixtureRoot}: ${missing.join(", ")}.`);
+  }
+  return fixtureRoot;
+}
+function resolveInstalledPackageRoot(packageName, entrySpecifier) {
+  const candidates = [
+    `${packageName}/package.json`,
+    entrySpecifier ?? packageName,
+    packageName
+  ];
+  for (const candidate of candidates) {
+    try {
+      const resolvedEntry = require2.resolve(candidate);
+      let currentDir = dirname(resolvedEntry);
+      while (currentDir !== dirname(currentDir)) {
+        if (existsSync(resolve(currentDir, "package.json"))) {
+          return currentDir;
+        }
+        currentDir = dirname(currentDir);
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function resolveWorkspacePackageRoot(packageRoot, workspaceDirName) {
+  if (!workspaceDirName) {
+    return null;
+  }
+  const candidate = resolve(packageRoot, "..", workspaceDirName);
+  return existsSync(resolve(candidate, "package.json")) ? candidate : null;
+}
+function ensureFixtureLinkedPackage(fixtureRoot, packageName, resolvedPackageRoot) {
+  const packageDir = resolve(fixtureRoot, "node_modules", ...packageName.split("/"));
+  mkdirSync(dirname(packageDir), { recursive: true });
+  rmSync(packageDir, { recursive: true, force: true });
+  symlinkSync(resolvedPackageRoot, packageDir, "dir");
+}
+function buildAgentContractsShimPackage(fixtureRoot) {
+  const packageDir = resolve(fixtureRoot, "node_modules", "@treeseed", "agent");
+  rmSync(packageDir, { recursive: true, force: true });
+  mkdirSync(resolve(packageDir, "contracts"), { recursive: true });
+  writeFileSync(
+    resolve(packageDir, "package.json"),
+    JSON.stringify(
+      {
+        name: "@treeseed/agent",
+        type: "module",
+        exports: {
+          "./runtime-types": {
+            types: "./runtime-types.d.js",
+            default: "./runtime-types.js"
+          },
+          "./contracts/messages": {
+            types: "./contracts/messages.d.js",
+            default: "./contracts/messages.js"
+          },
+          "./contracts/run": {
+            types: "./contracts/run.d.js",
+            default: "./contracts/run.js"
+          }
+        }
+      },
+      null,
+      2
+    ),
+    "utf8"
+  );
+  writeFileSync(resolve(packageDir, "runtime-types.js"), "export {};\n", "utf8");
+  writeFileSync(
+    resolve(packageDir, "runtime-types.d.ts"),
+    [
+      "import type { AgentHandlerKind, AgentRunStatus } from '@treeseed/sdk/types/agents';",
+      "export interface AgentTriggerInvocation {",
+      "	kind: 'startup' | 'schedule' | 'message' | 'manual' | 'follow';",
+      "	source: string;",
+      "	message?: { id?: string | number; type?: string; payloadJson?: string | null } | null;",
+      "}",
+      "export interface AgentExecutionResult {",
+      "	status: AgentRunStatus;",
+      "	summary: string;",
+      "	stdout?: string;",
+      "	stderr?: string;",
+      "	errorCategory?: import('./contracts/run').AgentErrorCategory | null;",
+      "	metadata?: Record<string, unknown>;",
+      "}",
+      "export interface AgentContext {",
+      "	runId: string;",
+      "	repoRoot: string;",
+      "	agent: any;",
+      "	sdk: any;",
+      "	trigger: AgentTriggerInvocation;",
+      "	execution: any;",
+      "	mutations: any;",
+      "	repository: any;",
+      "	verification: any;",
+      "	notifications: any;",
+      "	research: any;",
+      "}",
+      "export interface AgentHandler<TInputs = unknown, TResult = unknown> {",
+      "	kind: AgentHandlerKind;",
+      "	resolveInputs(context: AgentContext): Promise<TInputs>;",
+      "	execute(context: AgentContext, inputs: TInputs): Promise<TResult>;",
+      "	emitOutputs(context: AgentContext, result: TResult): Promise<AgentExecutionResult>;",
+      "}",
+      ""
+    ].join("\n"),
+    "utf8"
+  );
+  writeFileSync(
+    resolve(packageDir, "contracts", "messages.js"),
+    [
+      "export const AGENT_MESSAGE_TYPES = [];",
+      "export function parseAgentMessagePayload(_type, payloadJson) {",
+      "	return JSON.parse(payloadJson);",
+      "}",
+      ""
+    ].join("\n"),
+    "utf8"
+  );
+  writeFileSync(
+    resolve(packageDir, "contracts", "messages.d.ts"),
+    [
+      "export interface QuestionPriorityUpdatedMessage {",
+      "	questionId: string;",
+      "	reason: string;",
+      "	plannerRunId: string;",
+      "}",
+      "export interface ObjectivePriorityUpdatedMessage {",
+      "	objectiveId: string;",
+      "	reason: string;",
+      "	plannerRunId: string;",
+      "}",
+      "export interface ArchitectureUpdatedMessage {",
+      "	objectiveId: string;",
+      "	knowledgeId: string;",
+      "	architectRunId: string;",
+      "}",
+      "export interface SubscriberNotifiedMessage {",
+      "	email: string;",
+      "	itemCount: number;",
+      "	notifierRunId: string;",
+      "}",
+      "export interface ResearchStartedMessage {",
+      "	questionId: string;",
+      "	researcherRunId: string;",
+      "}",
+      "export interface ResearchCompletedMessage {",
+      "	questionId: string;",
+      "	knowledgeId: string | null;",
+      "	researcherRunId: string;",
+      "}",
+      "export interface TaskCompleteMessage {",
+      "	branchName: string | null;",
+      "	changedTargets: string[];",
+      "	engineerRunId: string;",
+      "}",
+      "export interface TaskWaitingMessage {",
+      "	blockingReason: string;",
+      "	engineerRunId: string;",
+      "}",
+      "export interface TaskFailedMessage {",
+      "	failureSummary: string;",
+      "	engineerRunId: string;",
+      "}",
+      "export interface TaskVerifiedMessage {",
+      "	branchName: string | null;",
+      "	reviewerRunId: string;",
+      "}",
+      "export interface ReviewFailedMessage {",
+      "	failureSummary: string;",
+      "	reviewerRunId: string;",
+      "}",
+      "export interface ReviewWaitingMessage {",
+      "	blockingReason: string;",
+      "	reviewerRunId: string;",
+      "}",
+      "export interface ReleaseStartedMessage {",
+      "	taskRunId: string | null;",
+      "	releaserRunId: string;",
+      "}",
+      "export interface ReleaseCompletedMessage {",
+      "	releaseSummary: string;",
+      "	releaserRunId: string;",
+      "}",
+      "export interface ReleaseFailedMessage {",
+      "	failureSummary: string;",
+      "	releaserRunId: string;",
+      "}",
+      "export interface AgentMessageContracts {",
+      "	question_priority_updated: QuestionPriorityUpdatedMessage;",
+      "	objective_priority_updated: ObjectivePriorityUpdatedMessage;",
+      "	architecture_updated: ArchitectureUpdatedMessage;",
+      "	subscriber_notified: SubscriberNotifiedMessage;",
+      "	research_started: ResearchStartedMessage;",
+      "	research_completed: ResearchCompletedMessage;",
+      "	task_complete: TaskCompleteMessage;",
+      "	task_waiting: TaskWaitingMessage;",
+      "	task_failed: TaskFailedMessage;",
+      "	task_verified: TaskVerifiedMessage;",
+      "	review_failed: ReviewFailedMessage;",
+      "	review_waiting: ReviewWaitingMessage;",
+      "	release_started: ReleaseStartedMessage;",
+      "	release_completed: ReleaseCompletedMessage;",
+      "	release_failed: ReleaseFailedMessage;",
+      "}",
+      "export type AgentMessageType = keyof AgentMessageContracts;",
+      "export type AgentMessagePayload<TType extends AgentMessageType> = AgentMessageContracts[TType];",
+      "export declare const AGENT_MESSAGE_TYPES: readonly AgentMessageType[];",
+      "export declare function parseAgentMessagePayload<TType extends AgentMessageType>(_type: TType, payloadJson: string): AgentMessagePayload<TType>;",
+      ""
+    ].join("\n"),
+    "utf8"
+  );
+  writeFileSync(resolve(packageDir, "contracts", "run.js"), "export {};\n", "utf8");
+  writeFileSync(
+    resolve(packageDir, "contracts", "run.d.ts"),
+    [
+      "export type AgentErrorCategory = 'execution_error' | 'mutation_error' | 'verification_error' | 'notification_error' | 'research_error' | 'sdk_error' | 'unknown';",
+      ""
+    ].join("\n"),
+    "utf8"
+  );
+}
+function prepareFixturePackages(options) {
+  const packageRoot = currentPackageRoot(options.packageRoot);
+  for (const declaration of options.declarations) {
+    let satisfied = false;
+    for (const mode of declaration.modes) {
+      if (mode === "workspace-link") {
+        const workspaceRoot = resolveWorkspacePackageRoot(packageRoot, declaration.workspaceDirName);
+        if (!workspaceRoot) {
+          continue;
+        }
+        ensureFixtureLinkedPackage(options.fixtureRoot, declaration.packageName, workspaceRoot);
+        satisfied = true;
+        break;
+      }
+      if (mode === "installed-link") {
+        const installedRoot = resolveInstalledPackageRoot(declaration.packageName, declaration.entrySpecifier);
+        if (!installedRoot) {
+          continue;
+        }
+        ensureFixtureLinkedPackage(options.fixtureRoot, declaration.packageName, installedRoot);
+        satisfied = true;
+        break;
+      }
+      if (mode === "contracts-only" && declaration.contractsShim === "agent") {
+        buildAgentContractsShimPackage(options.fixtureRoot);
+        satisfied = true;
+        break;
+      }
+    }
+    if (!satisfied) {
+      throw new Error(`Unable to prepare fixture package "${declaration.packageName}" using modes ${declaration.modes.join(", ")}.`);
+    }
+  }
+}
+export {
+  DEFAULT_FIXTURE_ID,
+  checkSharedFixture,
+  prepareFixturePackages,
+  requireSharedFixtureRoot,
+  resolveFixturesRepoRoot,
+  resolveRequestedFixtureId,
+  resolveSharedFixtureRoot
+};

package/dist/index.d.ts

@@ -13,15 +13,9 @@ export { TRESEED_OPERATION_SPECS, findTreeseedOperation, listTreeseedOperationNa
 export { TreeseedOperationsSdk } from './operations/runtime.ts';
 export { TreeseedWorkflowSdk } from './workflow.ts';
 export { getTreeseedVerifyDriverStatus, runTreeseedVerifyDriver } from './verification.ts';
-export * from './platform/contracts.ts';
-export * from './platform/tenant-config.ts';
-export * from './platform/deploy-config.ts';
-export * from './platform/deploy-runtime.ts';
-export * from './platform/environment.ts';
-export * from './platform/plugins.ts';
 export type { SdkContentEntry, SdkCursorEntity, SdkFilterCondition, SdkFollowRequest, SdkGraphEdge, SdkGraphEdgeType, SdkGraphDslRelation, SdkGraphDslParseResult, SdkGraphModelConfig, SdkGraphNode, SdkGraphNodeType, SdkGraphPathExplanation, SdkGraphQueryStage, SdkGraphQueryView, SdkGraphQueryOptions, SdkGraphQueryRequest, SdkGraphQueryResult, SdkGraphRankingBuildInput, SdkGraphRankingDiagnostics, SdkGraphRankingIndex, SdkGraphRankingNodeResult, SdkGraphRankingProvider, SdkGraphRankingQueryRequest, SdkGraphRankingQueryResult, SdkGraphRankingSearchRequest, SdkGraphRefreshPayload, SdkGraphRefreshRequest, SdkGraphSearchOptions, SdkGraphSearchResult, SdkGraphSeed, SdkGraphSeedResolution, SdkGraphTraversalResult, SdkGraphWhereFilter, SdkContextPack, SdkContextPackRequest, SdkGetRequest, SdkJsonEnvelope, SdkLeaseEntity, SdkManagerContextPayload, SdkMessageEntity, SdkModelFieldBinding, SdkModelDefinition, SdkModelRegistry, SdkModelName, SdkMutationRequest, SdkOperation, SdkPickRequest, SdkPickResult, SdkQueueMessageEnvelope, SdkRunEntity, SdkSearchRequest, SdkTaskEntity, SdkTaskEventEntity, SdkTaskOutputEntity, SdkWorkDayEntity, SdkGraphRunEntity, SdkReportEntity, SdkSubscriptionEntity, SdkTemplateCatalogEntry, SdkTemplateCatalogPublisher, SdkTemplateCatalogResponse, SdkTemplateCatalogSource, SdkUpdateRequest, } from './sdk-types.ts';
 export type { TreeseedFieldAliasBinding, TreeseedFieldAliasRegistry, } from './field-aliases.ts';
-export type { TreeseedOperationContext, TreeseedOperationGroup, TreeseedOperationImplementation, TreeseedOperationId, TreeseedOperationMetadata, TreeseedOperationProvider, TreeseedOperationProviderId, TreeseedOperationRequest, TreeseedOperationResult, } from './operations-types.ts';
+export type * from './operations-types.ts';
 export type * from './workflow.ts';
 export type { AgentDatabase } from './d1-store.ts';
 export type { D1DatabaseLike, D1PreparedStatementLike } from './types/cloudflare.ts';

package/dist/index.js

@@ -47,12 +47,6 @@ import {
 import { TreeseedOperationsSdk } from "./operations/runtime.js";
 import { TreeseedWorkflowSdk } from "./workflow.js";
 import { getTreeseedVerifyDriverStatus, runTreeseedVerifyDriver } from "./verification.js";
-export * from "./platform/contracts.js";
-export * from "./platform/tenant-config.js";
-export * from "./platform/deploy-config.js";
-export * from "./platform/deploy-runtime.js";
-export * from "./platform/environment.js";
-export * from "./platform/plugins.js";
 export {
   AgentSdk,
   BUILTIN_MODEL_REGISTRY,

package/dist/operations/runtime.js

@@ -1,4 +1,4 @@
-import { loadTreeseedDeployConfig } from "../platform/deploy/config.js";
+import { loadTreeseedDeployConfig } from "../platform/deploy-config.js";
 import { createDefaultTreeseedOperationsProvider } from "./providers/default.js";
 import { withProcessCwd } from "../operations/services/runtime-tools.js";
 import {

package/dist/operations/services/config-runtime.d.ts

@@ -115,7 +115,7 @@ export declare function resolveTreeseedTemplateCatalogCachePath(startRoot?: stri
 export declare function ensureTreeseedGitignoreEntries(tenantRoot: any): string;
 export declare function resolveTreeseedMachineEnvironmentValues(tenantRoot: any, scope: any): any;
 export declare function setTreeseedMachineEnvironmentValue(tenantRoot: any, scope: any, entry: any, value: any): any;
-export declare function collectTreeseedEnvironmentContext(tenantRoot: any): import("../../index.ts").TreeseedResolvedEnvironmentRegistry;
+export declare function collectTreeseedEnvironmentContext(tenantRoot: any): import("../../platform/environment.ts").TreeseedResolvedEnvironmentRegistry;
 export declare function collectTreeseedConfigSeedValues(tenantRoot: any, scope: any, env?: NodeJS.ProcessEnv): any;
 export declare function formatTreeseedConfigEnvironmentReport({ tenantRoot, scope, env, revealSecrets }: {
     tenantRoot: any;
@@ -133,18 +133,18 @@ export declare function validateTreeseedCommandEnvironment({ tenantRoot, scope,
     scope: any;
     purpose: any;
 }): {
-    registry: import("../../index.ts").TreeseedResolvedEnvironmentRegistry;
+    registry: import("../../platform/environment.ts").TreeseedResolvedEnvironmentRegistry;
     values: any;
-    validation: import("../../index.ts").TreeseedEnvironmentValidationResult;
+    validation: import("../../platform/environment.ts").TreeseedEnvironmentValidationResult;
 };
 export declare function assertTreeseedCommandEnvironment({ tenantRoot, scope, purpose }: {
     tenantRoot: any;
     scope: any;
     purpose: any;
 }): {
-    registry: import("../../index.ts").TreeseedResolvedEnvironmentRegistry;
+    registry: import("../../platform/environment.ts").TreeseedResolvedEnvironmentRegistry;
     values: any;
-    validation: import("../../index.ts").TreeseedEnvironmentValidationResult;
+    validation: import("../../platform/environment.ts").TreeseedEnvironmentValidationResult;
 };
 export declare function writeTreeseedLocalEnvironmentFiles(tenantRoot: any): {
     envLocalPath: string;

package/dist/operations/services/config-runtime.js

@@ -10,7 +10,7 @@ import {
   TREESEED_ENVIRONMENT_SCOPES,
   validateTreeseedEnvironmentValues
 } from "../../platform/environment.js";
-import { loadTreeseedManifest } from "../../platform/tenant/config.js";
+import { loadTreeseedManifest } from "../../platform/tenant-config.js";
 import {
   createPersistentDeployTarget,
   ensureGeneratedWranglerConfig,

package/dist/operations/services/deploy.js

@@ -3,7 +3,7 @@ import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node
 import { dirname, relative, resolve } from "node:path";
 import { spawnSync } from "node:child_process";
 import { createInterface } from "node:readline/promises";
-import { deriveCloudflareWorkerName } from "../../platform/deploy/config.js";
+import { deriveCloudflareWorkerName } from "../../platform/deploy-config.js";
 import { loadCliDeployConfig, resolveWranglerBin } from "./runtime-tools.js";
 const DEFAULT_COMPATIBILITY_DATE = "2026-04-05";
 const DEFAULT_COMPATIBILITY_FLAGS = ["nodejs_compat"];

package/dist/operations/services/runtime-paths.d.ts

@@ -17,3 +17,4 @@ export declare const templateCatalogRoot: string;
 export declare const localTemplateArtifactsRoot: string;
 export declare const cliPackageVersion: any;
 export declare const corePackageVersion: any;
+export declare const sdkPackageVersion: any;

package/dist/operations/services/runtime-paths.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { corePackageRoot, packageRoot, runtimeRoot } from "./runtime-tools.js";
+import { corePackageRoot, packageRoot, runtimeRoot, sdkPackageRoot } from "./runtime-tools.js";
 const pathsRuntimeRoot = resolve(fileURLToPath(new URL("..", import.meta.url)));
 const cliPackageRoot = packageRoot;
 const cliRuntimeRoot = runtimeRoot ?? pathsRuntimeRoot;
@@ -31,6 +31,7 @@ const templateCatalogRoot = resolve(cliRuntimeRoot, "template-catalog");
 const localTemplateArtifactsRoot = resolve(templateCatalogRoot, "templates");
 const cliPackageVersion = readPackageVersion(cliPackageRoot);
 const corePackageVersion = readPackageVersion(corePackageRoot);
+const sdkPackageVersion = readPackageVersion(sdkPackageRoot);
 export {
   cliPackageRoot,
   cliPackageVersion,
@@ -46,6 +47,7 @@ export {
   mailpitComposeFile,
   packageRoot,
   referenceAppsRoot,
+  sdkPackageVersion,
   servicesRoot,
   templateCatalogRoot,
   templatesRoot,

package/dist/operations/services/runtime-tools.js

@@ -10,7 +10,7 @@ const packageRootFromSource = resolve(scriptRoot, "..", "..", "..");
 const treeseedRuntimeRoot = resolve(packageRootFromSource, "src", "treeseed");
 const TREESEED_DEFAULT_PLUGIN_REFERENCES = [
   {
-    package: "@treeseed/core/plugin-default",
+    package: "@treeseed/sdk/plugin-default",
     enabled: true
   }
 ];

package/dist/operations/services/template-registry.d.ts

@@ -1,4 +1,4 @@
-import { type SdkTemplateCatalogEntry } from '@treeseed/sdk';
+import { type SdkTemplateCatalogEntry } from '../../sdk-types.ts';
 export declare const TEMPLATE_CATEGORIES: readonly ["starter", "example", "fixture", "reference-app"];
 export type TemplateCategory = (typeof TEMPLATE_CATEGORIES)[number];
 export interface TemplateVariableDefinition {
@@ -77,12 +77,12 @@ export declare function serializeTemplateRegistryEntry(product: Pick<TemplatePro
     featured: boolean;
     category: import("../../sdk-types.ts").SdkTemplateCategory;
     tags: string[];
-    publisher: import("@treeseed/sdk").SdkTemplateCatalogPublisher;
+    publisher: import("../../sdk-types.ts").SdkTemplateCatalogPublisher;
     templateVersion: string;
     templateApiVersion: number;
     minCliVersion: string;
     minCoreVersion: string | undefined;
-    source: import("@treeseed/sdk").SdkTemplateCatalogSource;
+    source: import("../../sdk-types.ts").SdkTemplateCatalogSource;
 };
 export declare function exportTemplateCatalogYaml(options?: TemplateCatalogOptions): Promise<string>;
 export {};

package/dist/operations/services/template-registry.js

@@ -1,8 +1,6 @@
 import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, relative, resolve } from "node:path";
-import {
-  RemoteTemplateCatalogClient
-} from "@treeseed/sdk";
+import { RemoteTemplateCatalogClient } from "../../template-catalog.js";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 import {
   resolveTreeseedTemplateCatalogCachePath,
@@ -11,7 +9,8 @@ import {
 import {
   cliPackageVersion,
   corePackageVersion,
-  localTemplateArtifactsRoot
+  localTemplateArtifactsRoot,
+  sdkPackageVersion
 } from "./runtime-paths.js";
 const TEMPLATE_CATEGORIES = ["starter", "example", "fixture", "reference-app"];
 function loadJsonFile(filePath) {
@@ -189,6 +188,8 @@ function resolveVariableValue(variable, input) {
       return `^${cliPackageVersion}`;
     case "coreVersion":
       return `^${corePackageVersion}`;
+    case "sdkVersion":
+      return `^${sdkPackageVersion}`;
     default:
       return variable.default ?? "";
   }

package/dist/platform/books-data.d.ts

@@ -1 +1,29 @@
-export * from './utils/books-data.ts';
+import type { TreeseedBookDefinition, TreeseedTenantConfig } from './contracts.ts';
+interface DocsLibraryDownload {
+    downloadFileName: string;
+    downloadHref: string;
+    downloadTitle: string;
+}
+interface TenantBookRuntime {
+    BOOKS: TreeseedBookDefinition[];
+    BOOKS_LINK: {
+        label: string;
+        link: string;
+    };
+    TREESEED_LINKS: {
+        home: string;
+    };
+    TREESEED_LIBRARY_DOWNLOAD: DocsLibraryDownload;
+}
+export declare function buildTenantBookRuntime(tenantConfig: Pick<TreeseedTenantConfig, 'content'>, options?: {
+    projectRoot?: string;
+    docsHomePath?: string;
+    docsLibraryDownload?: DocsLibraryDownload;
+}): TenantBookRuntime;
+export declare const BOOKS: TreeseedBookDefinition[], BOOKS_LINK: {
+    label: string;
+    link: string;
+}, TREESEED_LINKS: {
+    home: string;
+}, TREESEED_LIBRARY_DOWNLOAD: DocsLibraryDownload;
+export {};