@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/remote.d.ts

@@ -1,244 +0,0 @@
-import type { RemoteJob, RemoteJobEvent, SdkDispatchRequest, SdkDispatchResult } from './sdk-types.js';
-export declare const TREESEED_REMOTE_CONTRACT_VERSION = 1;
-export declare const TREESEED_REMOTE_CONTRACT_HEADER = "x-treeseed-remote-contract-version";
-export type ApiScope = string;
-export interface ApiPrincipal {
-    id: string;
-    displayName?: string;
-    scopes: ApiScope[];
-    roles: string[];
-    permissions: string[];
-    metadata?: Record<string, unknown>;
-}
-export interface RemoteTreeseedHost {
-    id: string;
-    baseUrl: string;
-    label?: string;
-    official?: boolean;
-    priority?: number;
-}
-export interface RemoteTreeseedPoolOptions {
-    strategy?: 'active-first' | 'priority';
-    maxAttempts?: number;
-}
-export interface RemoteTreeseedConfig {
-    hosts: RemoteTreeseedHost[];
-    activeHostId: string;
-    executionMode?: 'prefer-local' | 'prefer-remote' | 'remote-only';
-    auth?: {
-        accessToken?: string;
-        refreshToken?: string;
-        expiresAt?: string;
-        principal?: ApiPrincipal | null;
-    };
-    pool?: RemoteTreeseedPoolOptions;
-}
-export interface DeviceCodeStartRequest {
-    clientName?: string;
-    scopes?: ApiScope[];
-}
-export interface DeviceCodeStartResponse {
-    ok: true;
-    deviceCode: string;
-    userCode: string;
-    verificationUri: string;
-    verificationUriComplete: string;
-    intervalSeconds: number;
-    expiresAt: string;
-    expiresInSeconds: number;
-}
-export type DeviceCodePollResponse = {
-    ok: true;
-    status: 'pending';
-    intervalSeconds: number;
-} | {
-    ok: true;
-    status: 'approved';
-    accessToken: string;
-    refreshToken: string;
-    tokenType: 'Bearer';
-    expiresAt: string;
-    expiresInSeconds: number;
-    principal: ApiPrincipal;
-} | {
-    ok: false;
-    status: 'expired' | 'invalid' | 'already_used';
-    error: string;
-};
-export interface DeviceCodePollRequest {
-    deviceCode: string;
-}
-export interface DeviceCodeApproveRequest {
-    userCode: string;
-    principalId: string;
-    displayName?: string;
-    scopes?: ApiScope[];
-    metadata?: Record<string, unknown>;
-}
-export interface TokenRefreshRequest {
-    refreshToken: string;
-}
-export interface TokenRefreshResponse {
-    ok: true;
-    accessToken: string;
-    refreshToken: string;
-    tokenType: 'Bearer';
-    expiresAt: string;
-    expiresInSeconds: number;
-    principal: ApiPrincipal;
-}
-export interface RemoteSdkOperationRequest {
-    input?: Record<string, unknown>;
-    repoRoot?: string;
-}
-export type RemoteSdkOperationResponse<T = unknown> = T;
-export interface RemoteGatewayRequest {
-    method?: 'GET' | 'POST';
-    body?: unknown;
-}
-export interface RemoteWorkflowOperationRequest {
-    input?: Record<string, unknown>;
-    cwd?: string;
-    env?: Record<string, string>;
-}
-export interface RemoteWorkflowNextStep {
-    operation: string;
-    reason?: string;
-    input?: Record<string, unknown>;
-}
-export interface RemoteWorkflowOperationResponse {
-    ok: boolean;
-    operation: string;
-    payload?: Record<string, unknown> | null;
-    nextSteps?: RemoteWorkflowNextStep[];
-}
-export interface RemoteJobPullRequest {
-    limit?: number;
-    runnerId?: string;
-}
-export interface RemoteJobPullResponse {
-    ok: true;
-    payload: RemoteJob[];
-}
-export interface RemoteJobProgressRequest {
-    summary?: string;
-    data?: Record<string, unknown>;
-}
-export interface RemoteJobCompletionRequest {
-    output?: unknown;
-}
-export interface RemoteJobFailureRequest {
-    code?: string;
-    message: string;
-}
-export declare class RemoteTreeseedClient {
-    readonly config: RemoteTreeseedConfig;
-    private readonly fetchImpl;
-    constructor(config: RemoteTreeseedConfig, options?: {
-        fetchImpl?: typeof fetch;
-    });
-    activeHost(): RemoteTreeseedHost;
-    requestJson<T>(path: string, options?: {
-        method?: 'GET' | 'POST';
-        body?: unknown;
-        headers?: Record<string, string>;
-        requireAuth?: boolean;
-    }): Promise<T>;
-}
-export declare class RemoteTreeseedAuthClient {
-    private readonly client;
-    constructor(client: RemoteTreeseedClient);
-    startDeviceFlow(request: DeviceCodeStartRequest): Promise<DeviceCodeStartResponse>;
-    pollDeviceFlow(request: DeviceCodePollRequest): Promise<DeviceCodePollResponse>;
-    refreshAccessToken(request: TokenRefreshRequest): Promise<TokenRefreshResponse>;
-    whoAmI(): Promise<{
-        ok: true;
-        payload: ApiPrincipal;
-    }>;
-}
-export declare class RemoteTreeseedSdkClient {
-    private readonly client;
-    constructor(client: RemoteTreeseedClient);
-    execute<T = unknown>(operation: string, request: RemoteSdkOperationRequest): Promise<T>;
-}
-export declare class CloudflareQueuePullClient {
-    private readonly baseUrl;
-    private readonly token;
-    private readonly fetchImpl;
-    constructor(config: import('./sdk-types.js').SdkQueuePullClientConfig);
-    private request;
-    pull(request?: import('./sdk-types.js').SdkQueuePullRequest): Promise<{
-        messages: {
-            leaseId: string;
-            attempts: number;
-            rawBody: string;
-            body: import("./sdk-types.js").SdkQueueMessageEnvelope;
-        }[];
-    }>;
-    ack(acks: string[]): Promise<unknown>;
-    retry(retries: Array<{
-        leaseId: string;
-        delaySeconds?: number;
-    }>): Promise<unknown>;
-}
-export declare class CloudflareQueuePushClient {
-    private readonly baseUrl;
-    private readonly token;
-    private readonly fetchImpl;
-    constructor(config: import('./sdk-types.js').SdkQueuePushClientConfig);
-    enqueue(request: import('./sdk-types.js').SdkQueuePushRequest): Promise<void>;
-}
-export declare class RemoteTreeseedOperationsClient {
-    private readonly client;
-    constructor(client: RemoteTreeseedClient);
-    execute(operation: string, request: RemoteWorkflowOperationRequest): Promise<RemoteWorkflowOperationResponse>;
-}
-export declare class RemoteTreeseedDispatchClient {
-    private readonly client;
-    constructor(client: RemoteTreeseedClient);
-    dispatch(projectId: string, request: SdkDispatchRequest): Promise<SdkDispatchResult>;
-}
-export declare class RemoteTreeseedJobsClient {
-    private readonly client;
-    constructor(client: RemoteTreeseedClient);
-    get(jobId: string): Promise<{
-        ok: true;
-        payload: RemoteJob;
-    }>;
-    cancel(jobId: string): Promise<{
-        ok: true;
-        payload: RemoteJob;
-    }>;
-    events(jobId: string): Promise<{
-        ok: true;
-        payload: RemoteJobEvent[];
-    }>;
-}
-export declare class RemoteTreeseedRunnerClient {
-    private readonly client;
-    constructor(client: RemoteTreeseedClient);
-    pull(projectId: string, request?: RemoteJobPullRequest): Promise<RemoteJobPullResponse>;
-    progress(jobId: string, request?: RemoteJobProgressRequest): Promise<{
-        ok: true;
-        payload: RemoteJob;
-    }>;
-    complete(jobId: string, request?: RemoteJobCompletionRequest): Promise<{
-        ok: true;
-        payload: RemoteJob;
-    }>;
-    fail(jobId: string, request: RemoteJobFailureRequest): Promise<{
-        ok: true;
-        payload: RemoteJob;
-    }>;
-    consumeCredentialSession(jobId: string, sessionId: string): Promise<{
-        ok: true;
-        payload: {
-            id: string;
-            hostKind: string;
-            hostId: string;
-            purpose: string;
-            provider?: string | null;
-            config: Record<string, string>;
-        };
-    }>;
-}

package/dist/remote.js

@@ -1,284 +0,0 @@
-const TREESEED_REMOTE_CONTRACT_VERSION = 1;
-const TREESEED_REMOTE_CONTRACT_HEADER = "x-treeseed-remote-contract-version";
-function normalizeBaseUrl(baseUrl) {
-  return baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
-}
-function resolveActiveHost(config) {
-  const host = config.hosts.find((entry) => entry.id === config.activeHostId) ?? config.hosts[0];
-  if (!host) {
-    throw new Error("Remote Treeseed configuration is missing a usable host.");
-  }
-  return {
-    ...host,
-    baseUrl: normalizeBaseUrl(host.baseUrl)
-  };
-}
-class RemoteTreeseedClient {
-  config;
-  fetchImpl;
-  constructor(config, options = {}) {
-    this.config = config;
-    this.fetchImpl = options.fetchImpl ?? fetch;
-  }
-  activeHost() {
-    return resolveActiveHost(this.config);
-  }
-  async requestJson(path, options = {}) {
-    const host = this.activeHost();
-    const headers = {
-      accept: "application/json",
-      [TREESEED_REMOTE_CONTRACT_HEADER]: String(TREESEED_REMOTE_CONTRACT_VERSION),
-      ...options.headers ?? {}
-    };
-    if (options.body !== void 0) {
-      headers["content-type"] = "application/json";
-    }
-    if (options.requireAuth && this.config.auth?.accessToken) {
-      headers.authorization = `Bearer ${this.config.auth.accessToken}`;
-    }
-    const response = await this.fetchImpl(`${host.baseUrl}${path}`, {
-      method: options.method ?? "GET",
-      headers,
-      body: options.body === void 0 ? void 0 : JSON.stringify(options.body)
-    });
-    const contractVersion = response.headers.get(TREESEED_REMOTE_CONTRACT_HEADER);
-    if (contractVersion && Number(contractVersion) !== TREESEED_REMOTE_CONTRACT_VERSION) {
-      throw new Error(
-        `Remote Treeseed contract mismatch. Client=${TREESEED_REMOTE_CONTRACT_VERSION}, server=${contractVersion}.`
-      );
-    }
-    const payload = await response.json().catch(() => ({}));
-    if (!response.ok) {
-      const message = typeof payload.error === "string" ? String(payload.error) : `Remote request failed with ${response.status}.`;
-      throw new Error(message);
-    }
-    return payload;
-  }
-}
-class RemoteTreeseedAuthClient {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  startDeviceFlow(request) {
-    return this.client.requestJson("/auth/device/start", {
-      method: "POST",
-      body: request
-    });
-  }
-  pollDeviceFlow(request) {
-    return this.client.requestJson("/auth/device/poll", {
-      method: "POST",
-      body: request
-    });
-  }
-  refreshAccessToken(request) {
-    return this.client.requestJson("/auth/token/refresh", {
-      method: "POST",
-      body: request
-    });
-  }
-  whoAmI() {
-    return this.client.requestJson("/auth/me", {
-      requireAuth: true
-    });
-  }
-}
-class RemoteTreeseedSdkClient {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  execute(operation, request) {
-    return this.client.requestJson(`/sdk/${encodeURIComponent(operation)}`, {
-      method: "POST",
-      body: request,
-      requireAuth: true
-    });
-  }
-}
-function normalizeExternalBaseUrl(baseUrl) {
-  return baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
-}
-class CloudflareQueuePullClient {
-  baseUrl;
-  token;
-  fetchImpl;
-  constructor(config) {
-    const apiBaseUrl = config.apiBaseUrl ?? "https://api.cloudflare.com/client/v4/accounts";
-    this.baseUrl = `${normalizeExternalBaseUrl(apiBaseUrl)}/${config.accountId}/queues/${config.queueId}`;
-    this.token = config.token;
-    this.fetchImpl = config.fetchImpl ?? fetch;
-  }
-  async request(path, body) {
-    const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
-      method: "POST",
-      headers: {
-        accept: "application/json",
-        authorization: `Bearer ${this.token}`,
-        "content-type": "application/json"
-      },
-      body: JSON.stringify(body)
-    });
-    const payload = await response.json().catch(() => ({}));
-    if (!response.ok || payload.success === false) {
-      throw new Error(payload.errors?.[0]?.message ?? `Queue request failed with ${response.status}.`);
-    }
-    return payload.result;
-  }
-  async pull(request = {}) {
-    const result = await this.request("/messages/pull", {
-      batch_size: request.batchSize ?? 1,
-      visibility_timeout_ms: request.visibilityTimeoutMs ?? 12e4
-    });
-    const messages = (result.messages ?? []).map((entry) => ({
-      leaseId: entry.lease_id,
-      attempts: Number(entry.attempts ?? 0),
-      rawBody: String(entry.body ?? "{}"),
-      body: JSON.parse(String(entry.body ?? "{}"))
-    }));
-    return { messages };
-  }
-  ack(acks) {
-    return this.request("/messages/ack", { acks });
-  }
-  retry(retries) {
-    return this.request("/messages/ack", {
-      retries: retries.map((entry) => ({
-        lease_id: entry.leaseId,
-        delay_secs: entry.delaySeconds ?? 0
-      }))
-    });
-  }
-}
-class CloudflareQueuePushClient {
-  baseUrl;
-  token;
-  fetchImpl;
-  constructor(config) {
-    const apiBaseUrl = config.apiBaseUrl ?? "https://api.cloudflare.com/client/v4/accounts";
-    this.baseUrl = `${normalizeExternalBaseUrl(apiBaseUrl)}/${config.accountId}/queues/${config.queueId}`;
-    this.token = config.token;
-    this.fetchImpl = config.fetchImpl ?? fetch;
-  }
-  async enqueue(request) {
-    const response = await this.fetchImpl(`${this.baseUrl}/messages`, {
-      method: "POST",
-      headers: {
-        accept: "application/json",
-        authorization: `Bearer ${this.token}`,
-        "content-type": "application/json"
-      },
-      body: JSON.stringify({
-        body: request.message,
-        content_type: "json",
-        delay_seconds: request.delaySeconds ?? 0
-      })
-    });
-    const payload = await response.json().catch(() => ({}));
-    if (!response.ok || payload.success === false) {
-      throw new Error(payload.errors?.[0]?.message ?? `Queue request failed with ${response.status}.`);
-    }
-  }
-}
-class RemoteTreeseedOperationsClient {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  execute(operation, request) {
-    return this.client.requestJson(`/operations/${encodeURIComponent(operation)}`, {
-      method: "POST",
-      body: request,
-      requireAuth: true
-    });
-  }
-}
-class RemoteTreeseedDispatchClient {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  dispatch(projectId, request) {
-    return this.client.requestJson(`/v1/projects/${encodeURIComponent(projectId)}/dispatch`, {
-      method: "POST",
-      body: request,
-      requireAuth: true
-    });
-  }
-}
-class RemoteTreeseedJobsClient {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  get(jobId) {
-    return this.client.requestJson(`/v1/jobs/${encodeURIComponent(jobId)}`, {
-      requireAuth: true
-    });
-  }
-  cancel(jobId) {
-    return this.client.requestJson(`/v1/jobs/${encodeURIComponent(jobId)}/cancel`, {
-      method: "POST",
-      requireAuth: true
-    });
-  }
-  events(jobId) {
-    return this.client.requestJson(`/v1/jobs/${encodeURIComponent(jobId)}/events`, {
-      requireAuth: true
-    });
-  }
-}
-class RemoteTreeseedRunnerClient {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  pull(projectId, request = {}) {
-    return this.client.requestJson(`/v1/projects/${encodeURIComponent(projectId)}/runner/jobs/pull`, {
-      method: "POST",
-      body: request,
-      requireAuth: true
-    });
-  }
-  progress(jobId, request = {}) {
-    return this.client.requestJson(`/v1/jobs/${encodeURIComponent(jobId)}/progress`, {
-      method: "POST",
-      body: request,
-      requireAuth: true
-    });
-  }
-  complete(jobId, request = {}) {
-    return this.client.requestJson(`/v1/jobs/${encodeURIComponent(jobId)}/complete`, {
-      method: "POST",
-      body: request,
-      requireAuth: true
-    });
-  }
-  fail(jobId, request) {
-    return this.client.requestJson(`/v1/jobs/${encodeURIComponent(jobId)}/fail`, {
-      method: "POST",
-      body: request,
-      requireAuth: true
-    });
-  }
-  consumeCredentialSession(jobId, sessionId) {
-    return this.client.requestJson(`/v1/jobs/${encodeURIComponent(jobId)}/provider-credential-sessions/${encodeURIComponent(sessionId)}/consume`, {
-      method: "POST",
-      requireAuth: true
-    });
-  }
-}
-export {
-  CloudflareQueuePullClient,
-  CloudflareQueuePushClient,
-  RemoteTreeseedAuthClient,
-  RemoteTreeseedClient,
-  RemoteTreeseedDispatchClient,
-  RemoteTreeseedJobsClient,
-  RemoteTreeseedOperationsClient,
-  RemoteTreeseedRunnerClient,
-  RemoteTreeseedSdkClient,
-  TREESEED_REMOTE_CONTRACT_HEADER,
-  TREESEED_REMOTE_CONTRACT_VERSION
-};

package/dist/scenes/artifacts.d.ts

@@ -1,16 +0,0 @@
-import type { TreeseedSceneArtifactPathPlan, TreeseedSceneManifest, TreeseedScenePlanReport, TreeseedSceneRunArtifacts, TreeseedSceneRunReport, TreeseedSceneTimelineEvent } from './types.js';
-export declare function ensureTreeseedSceneRunDirectories(paths: TreeseedSceneArtifactPathPlan): void;
-export declare function createTreeseedSceneRunArtifacts(input: {
-    paths: TreeseedSceneArtifactPathPlan;
-    playwrightTracePath?: string | null;
-    screenshotPaths?: string[];
-    viewportScreenshotPaths?: string[];
-    videoPaths?: string[];
-}): TreeseedSceneRunArtifacts;
-export declare function appendTreeseedSceneJsonl(path: string, value: unknown): void;
-export declare function writeTreeseedSceneRunArtifacts(input: {
-    scene: TreeseedSceneManifest;
-    plan: TreeseedScenePlanReport;
-    report: TreeseedSceneRunReport;
-    timeline: TreeseedSceneTimelineEvent[];
-}): void;

package/dist/scenes/artifacts.js

@@ -1,61 +0,0 @@
-import { mkdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-function writeJson(path, value) {
-  writeFileSync(path, `${JSON.stringify(value, null, 2)}
-`, "utf8");
-}
-function ensureTreeseedSceneRunDirectories(paths) {
-  mkdirSync(paths.runRoot, { recursive: true });
-  mkdirSync(paths.playwrightRoot, { recursive: true });
-  mkdirSync(join(paths.playwrightRoot, "screenshots"), { recursive: true });
-  mkdirSync(join(paths.playwrightRoot, "screenshots", "viewport"), { recursive: true });
-  mkdirSync(join(paths.playwrightRoot, "videos"), { recursive: true });
-  mkdirSync(paths.logsRoot, { recursive: true });
-  mkdirSync(paths.segmentsRoot, { recursive: true });
-  mkdirSync(paths.checkpointsRoot, { recursive: true });
-  mkdirSync(paths.renderRoot, { recursive: true });
-  mkdirSync(paths.evidenceRoot, { recursive: true });
-  mkdirSync(paths.publishRoot, { recursive: true });
-}
-function createTreeseedSceneRunArtifacts(input) {
-  return {
-    runRoot: input.paths.runRoot,
-    normalizedScenePath: input.paths.normalizedScenePath,
-    planPath: input.paths.planPath,
-    runPath: input.paths.runPath,
-    timelinePath: input.paths.timelinePath,
-    markdownReportPath: input.paths.markdownReportPath,
-    playwrightTracePath: input.playwrightTracePath ?? null,
-    screenshotPaths: input.screenshotPaths ?? [],
-    viewportScreenshotPaths: input.viewportScreenshotPaths ?? [],
-    videoPaths: input.videoPaths ?? [],
-    consoleLogPath: join(input.paths.playwrightRoot, "console.jsonl"),
-    networkLogPath: join(input.paths.playwrightRoot, "network.jsonl"),
-    errorsLogPath: join(input.paths.playwrightRoot, "errors.jsonl"),
-    setupPath: join(input.paths.runRoot, "setup.json"),
-    devLogPath: join(input.paths.logsRoot, "dev.jsonl"),
-    apiLogPath: join(input.paths.logsRoot, "api.jsonl"),
-    operationsRunnerLogPath: join(input.paths.logsRoot, "operations-runner.jsonl"),
-    progressPath: input.paths.progressPath,
-    checkpointsRoot: input.paths.checkpointsRoot
-  };
-}
-function appendTreeseedSceneJsonl(path, value) {
-  writeFileSync(path, `${JSON.stringify(value)}
-`, { encoding: "utf8", flag: "a" });
-}
-function writeTreeseedSceneRunArtifacts(input) {
-  const artifacts = input.report.artifacts;
-  if (!artifacts) return;
-  writeJson(artifacts.normalizedScenePath, input.scene);
-  writeJson(artifacts.planPath, input.plan);
-  if (artifacts.setupPath) writeJson(artifacts.setupPath, input.report.setup);
-  writeJson(artifacts.timelinePath, input.timeline);
-  writeJson(artifacts.runPath, input.report);
-}
-export {
-  appendTreeseedSceneJsonl,
-  createTreeseedSceneRunArtifacts,
-  ensureTreeseedSceneRunDirectories,
-  writeTreeseedSceneRunArtifacts
-};

package/dist/scenes/auth.d.ts

@@ -1,2 +0,0 @@
-import type { TreeseedSceneAuthReport, TreeseedSceneAuthResolveOptions } from './types.js';
-export declare function resolveTreeseedSceneAuth(input: TreeseedSceneAuthResolveOptions): TreeseedSceneAuthReport;

package/dist/scenes/auth.js

@@ -1,28 +0,0 @@
-import { homedir } from "node:os";
-import { resolve } from "node:path";
-import { resolveMarketProfile, resolveMarketSession } from "../market-client.js";
-import { findNearestTreeseedRoot } from "../workflow-support.js";
-import { sceneErrorDiagnostic } from "./diagnostics.js";
-function resolveTreeseedSceneAuth(input) {
-  const required = input.scene.setup.auth?.required === true;
-  const role = input.scene.setup.auth?.role?.trim();
-  const selector = input.scene.setup.auth?.profile ?? (input.environment === "local" ? "local" : null);
-  const profile = resolveMarketProfile(selector);
-  const authRoot = findNearestTreeseedRoot(input.projectRoot) ?? resolve(process.env.HOME || homedir());
-  const session = resolveMarketSession(authRoot, profile.id);
-  const diagnostics = [];
-  if (required && !session?.accessToken && (!role || role === "anonymous")) {
-    diagnostics.push(sceneErrorDiagnostic("scene.auth_required", `Not logged in to market "${profile.id}". Run treeseed auth:login --market ${profile.id}.`, "setup.auth"));
-  }
-  return {
-    ok: diagnostics.length === 0,
-    required,
-    profileId: profile.id,
-    authRoot,
-    hasSession: Boolean(session?.accessToken),
-    diagnostics
-  };
-}
-export {
-  resolveTreeseedSceneAuth
-};

package/dist/scenes/base-url.d.ts

@@ -1,12 +0,0 @@
-import type { TreeseedSceneBaseUrlResolution, TreeseedSceneEnvironment, TreeseedSceneEnvironmentPrepareReport, TreeseedSceneManifest } from './types.js';
-export declare function resolveTreeseedSceneBaseUrl(input: {
-    projectRoot: string;
-    scene: TreeseedSceneManifest;
-    environment: TreeseedSceneEnvironment;
-    environmentReport?: TreeseedSceneEnvironmentPrepareReport | null;
-}): TreeseedSceneBaseUrlResolution;
-export declare function resolveTreeseedSceneApiBaseUrl(input: {
-    projectRoot: string;
-    environment: TreeseedSceneEnvironment | string;
-    webBaseUrl: string;
-}): string;