@treeseed/sdk 0.10.11 → 0.10.13

package/dist/operations/services/project-web-monitor.d.ts

@@ -0,0 +1,15 @@
+import { type GitHubApiClient } from './github-api.ts';
+import type { ProjectDeploymentEnvironment, ProjectWebMonitorResult } from '../../sdk-types.ts';
+export declare function buildProjectWebMonitorResult(input: {
+    environment: ProjectDeploymentEnvironment;
+    action?: string | null;
+    repository?: Record<string, unknown> | null;
+    workflowFile?: string | null;
+    target?: Record<string, unknown> | null;
+    externalWorkflow?: Record<string, unknown> | null;
+    workflowResult?: Record<string, any> | null;
+    githubClient?: GitHubApiClient | null;
+    fetchImpl?: typeof fetch | null;
+    mockExternal?: boolean;
+    dryRun?: boolean;
+}): Promise<ProjectWebMonitorResult>;

package/dist/operations/services/project-web-monitor.js

@@ -0,0 +1,260 @@
+import {
+  getGitHubWorkflowFileStatus,
+  getLatestGitHubWorkflowRun
+} from "./github-api.js";
+const FORBIDDEN_MONITOR_FIELDS = /* @__PURE__ */ new Set([
+  "capacityProviderId",
+  "laneId",
+  "grantId",
+  "workerPoolId",
+  "runtimeHostId",
+  "railwayServiceId",
+  "runnerToken"
+]);
+function text(value, fallback = "") {
+  return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+function objectValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function repositorySlug(repository) {
+  const record = objectValue(repository);
+  const owner = text(record.owner);
+  const name = text(record.name);
+  return owner && name ? `${owner}/${name}` : null;
+}
+function externalUrl(...values) {
+  for (const value of values) {
+    const raw = text(value);
+    if (!raw) continue;
+    try {
+      const url = new URL(raw);
+      if (url.protocol === "http:" || url.protocol === "https:") return url.href;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function redact(value) {
+  if (Array.isArray(value)) return value.map((entry) => redact(entry));
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(Object.entries(value).filter(([key]) => !FORBIDDEN_MONITOR_FIELDS.has(key)).filter(([key]) => !/(?:secret|token|password|apiKey|privateKey)/iu.test(key)).map(([key, entry]) => [key, redact(entry)]));
+}
+function check(input) {
+  return redact(input);
+}
+function workflowStatusFromConclusion(conclusion) {
+  if (conclusion === "success") return "passed";
+  if (conclusion === "cancelled" || conclusion === "failure" || conclusion === "timed_out") return "failed";
+  if (conclusion) return "warning";
+  return "warning";
+}
+function statusFromChecks(checks) {
+  if (checks.some((entry) => entry.status === "failed")) return "failed";
+  if (checks.some((entry) => entry.status === "warning")) return "degraded";
+  if (checks.some((entry) => entry.status === "passed")) return "healthy";
+  return "unknown";
+}
+function workflowRunCheck(input) {
+  const run = input.workflowResult?.runId ? input.workflowResult : input.latestWorkflowRun;
+  if (!run) {
+    return check({
+      key: "latest_workflow",
+      label: "Latest workflow",
+      status: "skipped",
+      source: "github",
+      summary: input.repository ? "No workflow run was recorded for this deployment yet." : "Repository is unavailable, so workflow state was skipped."
+    });
+  }
+  const conclusion = text(run.conclusion, "");
+  const runStatus = text(run.status, "");
+  const status = runStatus === "completed" ? workflowStatusFromConclusion(conclusion) : "warning";
+  const runId = Number(run.runId ?? run.id);
+  const inspectCommand = input.repository && Number.isFinite(runId) && runId > 0 ? `gh run view ${runId} --repo ${input.repository} --log-failed` : void 0;
+  return check({
+    key: "latest_workflow",
+    label: "Latest workflow",
+    status,
+    source: "github",
+    summary: status === "passed" ? `${input.workflowFile} completed successfully.` : runStatus === "completed" ? `${input.workflowFile} completed with conclusion ${conclusion || "unknown"}.` : `${input.workflowFile} is ${runStatus || "active"}.`,
+    url: externalUrl(run.url, run.runUrl),
+    ...inspectCommand ? { inspectCommand } : {}
+  });
+}
+async function workflowFileCheck(input) {
+  if (!input.repository) {
+    return check({
+      key: "workflow_file",
+      label: "Workflow file",
+      status: "failed",
+      source: "github",
+      summary: "GitHub repository is not configured."
+    });
+  }
+  if (input.mockExternal || input.dryRun) {
+    return check({
+      key: "workflow_file",
+      label: "Workflow file",
+      status: "passed",
+      source: "github",
+      summary: `${input.workflowFile} is assumed present in mock mode.`
+    });
+  }
+  if (!input.githubClient) {
+    return check({
+      key: "workflow_file",
+      label: "Workflow file",
+      status: "warning",
+      source: "github",
+      summary: "GitHub credentials are unavailable, so workflow file presence could not be verified."
+    });
+  }
+  const status = await getGitHubWorkflowFileStatus(input.repository, input.workflowFile, { client: input.githubClient }).catch((error) => ({
+    ok: false,
+    exists: null,
+    repository: input.repository,
+    workflow: input.workflowFile,
+    url: null,
+    message: error instanceof Error ? error.message : String(error)
+  }));
+  return check({
+    key: "workflow_file",
+    label: "Workflow file",
+    status: status.exists === true ? "passed" : status.exists === false ? "failed" : "warning",
+    source: "github",
+    summary: status.message,
+    ...status.url ? { url: status.url } : {}
+  });
+}
+async function fetchWithTimeout(fetchImpl, url, timeoutMs) {
+  if (typeof AbortSignal !== "undefined" && typeof AbortSignal.timeout === "function") {
+    return await fetchImpl(url, { method: "GET", signal: AbortSignal.timeout(timeoutMs) });
+  }
+  return await fetchImpl(url, { method: "GET" });
+}
+async function httpCheck(input) {
+  if (!input.url) {
+    return check({
+      key: "http_response",
+      label: "HTTP response",
+      status: "skipped",
+      source: "http",
+      summary: "No public URL is available for HTTP probing."
+    });
+  }
+  if (input.mockExternal || input.dryRun || !input.fetchImpl) {
+    return check({
+      key: "http_response",
+      label: "HTTP response",
+      status: input.mockExternal ? "passed" : "skipped",
+      source: "http",
+      url: input.url,
+      summary: input.mockExternal ? "Mock HTTP probe passed." : "HTTP probe skipped for this monitor run."
+    });
+  }
+  try {
+    const response = await fetchWithTimeout(input.fetchImpl, input.url, input.timeoutMs ?? 1e4);
+    const status = response.status >= 200 && response.status < 400 ? "passed" : response.status === 401 || response.status === 403 || response.status >= 500 ? "warning" : "failed";
+    return check({
+      key: "http_response",
+      label: "HTTP response",
+      status,
+      source: "http",
+      url: input.url,
+      summary: `HTTP probe returned ${response.status}.`
+    });
+  } catch (error) {
+    return check({
+      key: "http_response",
+      label: "HTTP response",
+      status: "failed",
+      source: "http",
+      url: input.url,
+      summary: error instanceof Error ? error.message : "HTTP probe failed."
+    });
+  }
+}
+async function buildProjectWebMonitorResult(input) {
+  const repository = repositorySlug(input.repository);
+  const workflowFile = text(input.workflowFile ?? input.repository?.workflowFile, "deploy-web.yml");
+  const target = objectValue(input.target);
+  const targetUrl = externalUrl(target.url, target.baseUrl, target.previewUrl, target.lastDeploymentUrl);
+  const latestWorkflowRun = !input.workflowResult && repository && input.githubClient ? await getLatestGitHubWorkflowRun(repository, {
+    client: input.githubClient,
+    workflow: workflowFile,
+    branch: text(input.repository?.branch, "") || null
+  }).catch(() => null) : null;
+  const checks = [
+    workflowRunCheck({
+      workflowResult: input.workflowResult ?? input.externalWorkflow ?? null,
+      latestWorkflowRun,
+      repository,
+      workflowFile
+    }),
+    await workflowFileCheck({
+      repository,
+      workflowFile,
+      githubClient: input.githubClient,
+      mockExternal: input.mockExternal,
+      dryRun: input.dryRun
+    }),
+    check({
+      key: "web_host",
+      label: "Web host",
+      status: Object.keys(target).length > 0 ? "passed" : "failed",
+      source: "market",
+      summary: Object.keys(target).length > 0 ? "Web host target is configured." : "Web host target is missing."
+    }),
+    check({
+      key: "target_url",
+      label: "Public URL",
+      status: targetUrl ? "passed" : "failed",
+      source: "market",
+      ...targetUrl ? { url: targetUrl } : {},
+      summary: targetUrl ? "Deployment target URL is recorded." : "Deployment target URL is missing."
+    }),
+    await httpCheck({
+      url: targetUrl,
+      fetchImpl: input.fetchImpl,
+      mockExternal: input.mockExternal,
+      dryRun: input.dryRun
+    }),
+    check({
+      key: "content_publish",
+      label: "Content publish",
+      status: input.action === "publish_content" ? "passed" : "skipped",
+      source: "sdk",
+      summary: input.action === "publish_content" ? "Content publish workflow completed." : "Content publish was not part of this action."
+    }),
+    check({
+      key: "d1_migration",
+      label: "D1 migration",
+      status: "skipped",
+      source: "sdk",
+      summary: "No D1 migration result was reported for this deployment."
+    }),
+    check({
+      key: "form_api_route",
+      label: "Form/API route",
+      status: "skipped",
+      source: "http",
+      summary: "No form/API route probe was configured for this project."
+    })
+  ];
+  const status = statusFromChecks(checks);
+  const warnings = checks.filter((entry) => entry.status === "warning").map((entry) => entry.summary);
+  const urls = [...new Set(checks.map((entry) => entry.url).filter((url) => Boolean(url)))];
+  const result = {
+    environment: input.environment,
+    status,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    checks,
+    urls,
+    warnings
+  };
+  return redact(result);
+}
+export {
+  buildProjectWebMonitorResult
+};

package/dist/operations/services/railway-api.js

@@ -283,8 +283,8 @@ async function railwayGraphqlRequest({
   apiToken,
   apiUrl,
   fetchImpl = fetch,
-  timeoutMs = 15e3,
-  retries = 5
+  timeoutMs = 3e4,
+  retries = 8
 }) {
   const token = apiToken || resolveRailwayApiToken(env);
   if (!token) {

package/dist/operations/services/release-candidate.js

@@ -543,30 +543,30 @@ async function configParityChecks(root, failures) {
   };
 }
 function migrationCompatibilityChecks(root, failures) {
-  if (!existsSync(resolve(root, "migrations"))) {
+  if (!existsSync(resolve(root, "packages/sdk/package.json"))) {
     return {
       name: "migration-compatibility",
       status: "skipped",
-      detail: "No migrations directory is present in this workspace."
+      detail: "No SDK package checkout is present in this workspace."
     };
   }
-  const requiredMigrations = [
-    "migrations/0007_site_web_sessions.sql",
-    "migrations/0014_better_auth_integer_timestamps.sql"
+  const requiredArtifacts = [
+    "packages/sdk/drizzle/d1/0000_treeseed_d1.sql",
+    "packages/sdk/drizzle/market/0000_market_control_plane.sql"
   ];
-  const missing = requiredMigrations.filter((path) => !existsSync(resolve(root, path)));
+  const missing = requiredArtifacts.filter((path) => !existsSync(resolve(root, path)));
   for (const path of missing) {
     addFailure(failures, {
-      code: "missing_migration_fixture",
+      code: "missing_drizzle_migration_artifact",
       scope: "@treeseed/market",
-      message: `Migration compatibility check is missing ${path}.`,
+      message: `Drizzle migration compatibility check is missing ${path}.`,
       details: { path }
     });
   }
   return {
     name: "migration-compatibility",
     status: missing.length > 0 ? "failed" : "passed",
-    detail: "Checked required legacy web session and Better Auth migration coverage."
+    detail: "Checked required Drizzle migration artifacts for Market PostgreSQL and SDK D1."
   };
 }
 async function runReleaseCandidateGate(input) {

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

@@ -11,7 +11,7 @@ export declare const servicesRoot: string;
 export declare const mailpitComposeFile: string;
 export declare const fixtureRoot: string;
 export declare const fixtureWranglerConfig: string;
-export declare const fixtureMigrationsRoot: string;
+export declare const sdkD1MigrationsRoot: string;
 export declare const fixtureSrcRoot: string;
 export declare const templateCatalogRoot: string;
 export declare const localTemplateArtifactsRoot: string;

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

@@ -25,7 +25,7 @@ const servicesRoot = resolve(cliRuntimeRoot, "services");
 const mailpitComposeFile = resolve(servicesRoot, "compose.yml");
 const fixtureRoot = resolve(corePackageRoot, "fixture");
 const fixtureWranglerConfig = resolve(fixtureRoot, "wrangler.toml");
-const fixtureMigrationsRoot = resolve(fixtureRoot, "migrations");
+const sdkD1MigrationsRoot = resolve(sdkPackageRoot, "drizzle", "d1");
 const fixtureSrcRoot = resolve(fixtureRoot, "src");
 const templateCatalogRoot = resolve(cliRuntimeRoot, "template-catalog");
 const localTemplateArtifactsRoot = resolve(templateCatalogRoot, "templates");
@@ -40,7 +40,6 @@ export {
   corePackageRoot,
   corePackageVersion,
   examplesRoot,
-  fixtureMigrationsRoot,
   fixtureRoot,
   fixtureSrcRoot,
   fixtureWranglerConfig,
@@ -49,6 +48,7 @@ export {
   mailpitComposeFile,
   packageRoot,
   referenceAppsRoot,
+  sdkD1MigrationsRoot,
   sdkPackageVersion,
   servicesRoot,
   templateCatalogRoot,

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

@@ -126,11 +126,20 @@ function runGit(commandArgs, cwd) {
     throw new Error(result.stderr?.trim() || result.stdout?.trim() || `git ${commandArgs.join(" ")} failed`);
   }
 }
+function readGitOutput(commandArgs, cwd) {
+  const result = spawnSync("git", commandArgs, {
+    cwd,
+    stdio: "pipe",
+    encoding: "utf8"
+  });
+  return result.status === 0 ? result.stdout.trim() : null;
+}
 function materializeGitTemplateSource(product, options) {
   const cacheRoot = resolveTemplateSourceCacheRoot(product, options);
   const repoRoot = resolve(cacheRoot, "repo");
   const source = product.fulfillment.source;
-  if (!existsSync(resolve(repoRoot, ".git"))) {
+  const cachedOrigin = existsSync(resolve(repoRoot, ".git")) ? readGitOutput(["config", "--get", "remote.origin.url"], repoRoot) : null;
+  if (cachedOrigin !== source.repoUrl) {
     rmSync(cacheRoot, { recursive: true, force: true });
     mkdirSync(cacheRoot, { recursive: true });
     runGit(["clone", "--no-checkout", source.repoUrl, repoRoot]);

package/dist/operations.d.ts

@@ -2,6 +2,7 @@ export { TRESEED_OPERATION_SPECS, findTreeseedOperation, listTreeseedOperationNa
 export { collectTreeseedConfigSeedValues } from './operations/services/config-runtime.ts';
 export { createKnowledgeHubRepositories, defaultHubContentResolutionPolicy, executeKnowledgeHubLaunch, normalizeKnowledgeHubLaunchIntent, planKnowledgeHubLaunch, planKnowledgeHubRepositories, validateRepositoryHost, } from './operations/services/hub-launch.ts';
 export { TreeseedOperationsSdk } from './operations/runtime.ts';
+export { cancelGitHubWorkflowRun, dispatchGitHubWorkflowRun, formatGitHubWorkflowFailure, waitForGitHubWorkflowRunCompletion, type GitHubWorkflowCancellationResult, type GitHubWorkflowDispatchResult, type GitHubWorkflowFailureSummary, type GitHubWorkflowFailureSummaryInput, type GitHubWorkflowProgressEvent, } from './operations/services/github-api.ts';
 export type { HubContentResolutionPolicy, KnowledgeHubLaunchIntent, KnowledgeHubLaunchPhase, KnowledgeHubLaunchPlan, KnowledgeHubLaunchResult, KnowledgeHubRepositoryPlan, RepositoryHost, } from './operations/services/hub-launch.ts';
 export type { TreeseedOperationContext, TreeseedOperationImplementation, TreeseedOperationId, TreeseedOperationMetadata, TreeseedOperationProvider, TreeseedOperationProviderId, TreeseedOperationRequest, TreeseedOperationResult, TreeseedOperationGroup, } from './operations-types.ts';
 export { TreeseedOperationError } from './operations-types.ts';

package/dist/operations.js

@@ -14,6 +14,12 @@ import {
   validateRepositoryHost
 } from "./operations/services/hub-launch.js";
 import { TreeseedOperationsSdk } from "./operations/runtime.js";
+import {
+  cancelGitHubWorkflowRun,
+  dispatchGitHubWorkflowRun,
+  formatGitHubWorkflowFailure,
+  waitForGitHubWorkflowRunCompletion
+} from "./operations/services/github-api.js";
 import { TreeseedOperationError } from "./operations-types.js";
 import {
   AGENT_OPERATION_MODES,
@@ -32,19 +38,23 @@ export {
   TreeseedOperationError,
   TreeseedOperationsSdk,
   TreeseedWorkflowSdk,
+  cancelGitHubWorkflowRun,
   collectTreeseedConfigSeedValues,
   createAgentOperationEvent,
   createKnowledgeHubRepositories,
   decideAgentOperationPermission,
   defaultHubContentResolutionPolicy,
   deniedAgentOperationResult,
+  dispatchGitHubWorkflowRun,
   executeKnowledgeHubLaunch,
   findTreeseedOperation,
+  formatGitHubWorkflowFailure,
   isAgentOperationName,
   listTreeseedOperationNames,
   normalizeKnowledgeHubLaunchIntent,
   planKnowledgeHubLaunch,
   planKnowledgeHubRepositories,
   resolveAgentOperationGrant,
-  validateRepositoryHost
+  validateRepositoryHost,
+  waitForGitHubWorkflowRunCompletion
 };

package/dist/platform-operation-store.d.ts

@@ -84,6 +84,10 @@ export declare class PlatformOperationStore {
         ok: true;
         operation: PlatformOperation;
     }>;
+    cancel(operationId: string, request: PlatformRunnerJobUpdateRequest): Promise<{
+        ok: true;
+        operation: PlatformOperation;
+    }>;
     private upsertRepositoryClaim;
     private renewRepositoryClaimsForRunner;
     private releaseRepositoryClaimsForRunner;

package/dist/platform-operation-store.js

@@ -131,6 +131,9 @@ function repositoryWorkspacePath(workspaceRoot, repository = {}) {
   const root = String(workspaceRoot ?? "/data").replace(/\/+$/u, "") || "/data";
   return `${root}/repositories/${repositoryKey(repository)}/repo`;
 }
+function normalizeOperationCapabilities(capabilities) {
+  return Array.isArray(capabilities) ? capabilities.map((entry) => String(entry ?? "").trim()).filter(Boolean) : [];
+}
 function convertQuestionPlaceholders(query) {
   let index = 0;
   return query.replace(/\?/gu, () => `$${++index}`);
@@ -311,20 +314,27 @@ class PlatformOperationStore {
     const leaseSeconds = Math.max(30, Math.min(Number(input.leaseSeconds ?? 300), 3600));
     const now = isoNow(this.now);
     const leaseExpiresAt = new Date(this.now().getTime() + leaseSeconds * 1e3).toISOString();
+    const capabilities = normalizeOperationCapabilities(input.capabilities);
+    const capabilityWhere = capabilities.length > 0 ? ` AND (${capabilities.map(() => `(namespace || ':' || operation) = ?`).join(" OR ")})` : "";
+    const capabilityParams = capabilities;
     const rows = input.operationId ? await this.database.all(
       `SELECT * FROM platform_operations
 				 WHERE id = ? AND (
 				    status = 'queued'
 				    OR (status = 'leased' AND lease_expires_at IS NOT NULL AND lease_expires_at < ?)
 				 )
+				 ${capabilityWhere}
 				 ORDER BY created_at ASC LIMIT 1`,
-      [input.operationId, now]
+      [input.operationId, now, ...capabilityParams]
     ) : await this.database.all(
       `SELECT * FROM platform_operations
-				 WHERE status = 'queued'
+				 WHERE (
+				    status = 'queued'
 				    OR (status = 'leased' AND lease_expires_at IS NOT NULL AND lease_expires_at < ?)
+				 )
+				 ${capabilityWhere}
 				 ORDER BY created_at ASC LIMIT 1`,
-      [now]
+      [now, ...capabilityParams]
     );
     const row = rows[0];
     if (!row) return { ok: true, operation: null };
@@ -424,6 +434,22 @@ class PlatformOperationStore {
     });
     return this.getOperation(operationId);
   }
+  async cancel(operationId, request) {
+    await this.assertRunnerUpdate(operationId, request.runnerId);
+    const timestamp = isoNow(this.now);
+    await this.database.run(
+      `UPDATE platform_operations
+			 SET status = 'cancelled', error_json = ?, lease_expires_at = NULL, cancelled_at = COALESCE(cancelled_at, ?), updated_at = ?, finished_at = COALESCE(finished_at, ?)
+			 WHERE id = ?`,
+      [JSON.stringify(request.error ?? { message: "Platform operation was cancelled." }), timestamp, timestamp, timestamp, operationId]
+    );
+    await this.appendPlatformOperationEvent(operationId, request.event?.kind ?? "runner.cancelled", request.event?.data ?? {});
+    await this.releaseRepositoryClaimsForRunner(request.runnerId, {
+      claimState: "released",
+      metadata: { operationId, status: "cancelled" }
+    });
+    return this.getOperation(operationId);
+  }
   async upsertRepositoryClaim(input) {
     const repositoryKeyValue = repositoryKey(input.repository);
     const timestamp = isoNow(this.now);

package/dist/platform-operations.d.ts

@@ -154,6 +154,10 @@ export interface PlatformOperationRunnerCoreClient {
         ok: true;
         operation: PlatformOperation;
     }>;
+    cancel?(operationId: string, request: PlatformRunnerJobUpdateRequest): Promise<{
+        ok: true;
+        operation: PlatformOperation;
+    }>;
 }
 export interface PlatformOperationRunnerCoreOptions {
     client: PlatformOperationRunnerCoreClient;
@@ -262,4 +266,8 @@ export declare class PlatformRunnerClient {
         ok: true;
         operation: PlatformOperation;
     }>;
+    cancel(operationId: string, request: PlatformRunnerJobUpdateRequest): Promise<{
+        ok: true;
+        operation: PlatformOperation;
+    }>;
 }

package/dist/platform-operations.js

@@ -190,6 +190,7 @@ async function runPlatformOperationOnce(options) {
   const claimed = await options.client.claimJob({
     runnerId: options.runnerId,
     operationId: options.operationId ?? void 0,
+    capabilities: registry.keys(),
     limit: options.limit ?? 1,
     leaseSeconds: options.leaseSeconds ?? 300
   });
@@ -259,6 +260,14 @@ async function runPlatformOperationOnce(options) {
       message: error instanceof Error ? error.message : String(error)
     };
     const eventKind = failure.message.toLowerCase().includes("cancel") ? "runner.cancelled" : "runner.retry_safe_failure";
+    if (eventKind === "runner.cancelled" && options.client.cancel) {
+      const cancelled = await options.client.cancel(operation.id, {
+        runnerId: options.runnerId,
+        error: failure,
+        event: { kind: eventKind, data: failure }
+      });
+      return { ok: false, claimed: true, operation: cancelled.operation, error: failure };
+    }
     if (eventKind === "runner.cancelled" && options.client.getOperation) {
       await options.client.appendEvent(operation.id, {
         runnerId: options.runnerId,
@@ -399,6 +408,16 @@ class PlatformRunnerClient {
       return response;
     });
   }
+  cancel(operationId, request) {
+    return this.requestJson(`${PLATFORM_OPERATION_ENDPOINTS.runnerJob(operationId)}/cancel`, {
+      method: "POST",
+      body: { ...request, marketId: this.marketId }
+    }).then((response) => {
+      assertPlatformOperationOkEnvelope(response, "Platform operation cancellation response");
+      assertPlatformOperation(response.operation);
+      return response;
+    });
+  }
 }
 export {
   PLATFORM_OPERATION_ENDPOINTS,

package/dist/remote.js

@@ -56,10 +56,10 @@ class RemoteTreeseedClient {
   }
 }
 class RemoteTreeseedAuthClient {
+  client;
   constructor(client) {
     this.client = client;
   }
-  client;
   startDeviceFlow(request) {
     return this.client.requestJson("/auth/device/start", {
       method: "POST",
@@ -85,10 +85,10 @@ class RemoteTreeseedAuthClient {
   }
 }
 class RemoteTreeseedSdkClient {
+  client;
   constructor(client) {
     this.client = client;
   }
-  client;
   execute(operation, request) {
     return this.client.requestJson(`/sdk/${encodeURIComponent(operation)}`, {
       method: "POST",
@@ -182,10 +182,10 @@ class CloudflareQueuePushClient {
   }
 }
 class RemoteTreeseedOperationsClient {
+  client;
   constructor(client) {
     this.client = client;
   }
-  client;
   execute(operation, request) {
     return this.client.requestJson(`/operations/${encodeURIComponent(operation)}`, {
       method: "POST",
@@ -195,10 +195,10 @@ class RemoteTreeseedOperationsClient {
   }
 }
 class RemoteTreeseedDispatchClient {
+  client;
   constructor(client) {
     this.client = client;
   }
-  client;
   dispatch(projectId, request) {
     return this.client.requestJson(`/v1/projects/${encodeURIComponent(projectId)}/dispatch`, {
       method: "POST",
@@ -208,10 +208,10 @@ class RemoteTreeseedDispatchClient {
   }
 }
 class RemoteTreeseedJobsClient {
+  client;
   constructor(client) {
     this.client = client;
   }
-  client;
   get(jobId) {
     return this.client.requestJson(`/v1/jobs/${encodeURIComponent(jobId)}`, {
       requireAuth: true
@@ -230,10 +230,10 @@ class RemoteTreeseedJobsClient {
   }
 }
 class RemoteTreeseedRunnerClient {
+  client;
   constructor(client) {
     this.client = client;
   }
-  client;
   pull(projectId, request = {}) {
     return this.client.requestJson(`/v1/projects/${encodeURIComponent(projectId)}/runner/jobs/pull`, {
       method: "POST",

package/dist/scripts/tenant-d1-migrate-local.js

@@ -1,8 +1,7 @@
-import { resolve } from 'node:path';
 import { runLocalD1Migrations } from '../operations/services/d1-migration.js';
 import { createPersistentDeployTarget, ensureGeneratedWranglerConfig } from '../operations/services/deploy.js';
+import { sdkD1MigrationsRoot } from '../operations/services/runtime-paths.js';
 const tenantRoot = process.cwd();
-const migrationsRoot = resolve(tenantRoot, 'migrations');
 const { wranglerPath: wranglerConfig } = ensureGeneratedWranglerConfig(tenantRoot, {
     target: createPersistentDeployTarget('local'),
     env: process.env,
@@ -10,7 +9,7 @@ const { wranglerPath: wranglerConfig } = ensureGeneratedWranglerConfig(tenantRoo
 runLocalD1Migrations({
     cwd: tenantRoot,
     wranglerConfig,
-    migrationsRoot,
+    migrationsRoot: sdkD1MigrationsRoot,
     persistTo: process.env.TREESEED_API_D1_LOCAL_PERSIST_TO?.trim() || undefined,
 });
 process.exit(0);

package/dist/scripts/test-cloudflare-local.js

@@ -111,7 +111,7 @@ async function querySubscribers() {
     const child = spawnProcess('wrangler', [
         'd1',
         'execute',
-        'karyon-docs-site-data',
+        'docs-site-data',
         '--local',
         '--config',
         fixtureWranglerConfig,