@treeseed/sdk 0.4.8 → 0.4.10

package/dist/platform/utils/site-config-schema.js

@@ -166,6 +166,108 @@ function parseTheme(value, path) {
 	};
 }
 
+function parseAccessRoles(value, path) {
+	const record = optionalRecord(value, path);
+	if (!record) {
+		return {};
+	}
+
+	return Object.fromEntries(
+		Object.entries(record).map(([roleId, rawRole]) => {
+			const parsedRole = expectRecord(rawRole, `${path}.${roleId}`);
+			return [
+				roleId,
+				{
+					grants: stringArray(parsedRole.grants, `${path}.${roleId}.grants`),
+				},
+			];
+		}),
+	);
+}
+
+function parseAccessPolicies(value, path) {
+	const record = optionalRecord(value, path);
+	if (!record) {
+		return {};
+	}
+
+	return Object.fromEntries(
+		Object.entries(record).map(([policyId, rawPolicy]) => {
+			const parsedPolicy = expectRecord(rawPolicy, `${path}.${policyId}`);
+			return [
+				policyId,
+				{
+					audience: optionalString(parsedPolicy.audience, `${path}.${policyId}.audience`),
+					entitlement: optionalString(parsedPolicy.entitlement, `${path}.${policyId}.entitlement`),
+					offer: optionalString(parsedPolicy.offer, `${path}.${policyId}.offer`),
+					visibility: optionalString(parsedPolicy.visibility, `${path}.${policyId}.visibility`),
+				},
+			];
+		}),
+	);
+}
+
+function parseAccessDefaults(value, path) {
+	const record = optionalRecord(value, path);
+	if (!record) {
+		return { models: {} };
+	}
+
+	const models = optionalRecord(record.models, `${path}.models`) ?? {};
+	return {
+		models: Object.fromEntries(
+			Object.entries(models).map(([modelId, rawSurfaces]) => {
+				const parsedSurfaces = expectRecord(rawSurfaces, `${path}.models.${modelId}`);
+				return [
+					modelId,
+					Object.fromEntries(
+						Object.entries(parsedSurfaces).map(([surfaceId, rawPolicy]) => [
+							surfaceId,
+							expectString(rawPolicy, `${path}.models.${modelId}.${surfaceId}`),
+						]),
+					),
+				];
+			}),
+		),
+	};
+}
+
+function parseAccessBootstrap(value, path) {
+	const record = optionalRecord(value, path);
+	if (!record) {
+		return {};
+	}
+
+	const owners = optionalRecord(record.owners, `${path}.owners`);
+	return {
+		owners: owners
+			? {
+				emails: stringArray(owners.emails, `${path}.owners.emails`),
+				roles: stringArray(owners.roles, `${path}.owners.roles`),
+			}
+			: undefined,
+	};
+}
+
+function parseAccess(value, path) {
+	const record = optionalRecord(value, path);
+	if (!record) {
+		return {
+			roles: {},
+			policies: {},
+			defaults: { models: {} },
+			bootstrap: {},
+		};
+	}
+
+	return {
+		roles: parseAccessRoles(record.roles, `${path}.roles`),
+		policies: parseAccessPolicies(record.policies, `${path}.policies`),
+		defaults: parseAccessDefaults(record.defaults, `${path}.defaults`),
+		bootstrap: parseAccessBootstrap(record.bootstrap, `${path}.bootstrap`),
+	};
+}
+
 /** @type {TreeseedFieldAliasRegistry} */
 const siteFieldAliases = {
 	siteUrl: { key: 'siteUrl', aliases: ['site_url'] },
@@ -228,6 +330,7 @@ export function parseSiteConfig(source) {
 		emailNotificationFieldAliases,
 		expectRecord(site.emailNotifications, 'site.emailNotifications'),
 	);
+	const access = parseAccess(parsed.access, 'access');
 
 	return {
 		site: {
@@ -317,5 +420,6 @@ export function parseSiteConfig(source) {
 				},
 			},
 		},
+		access,
 	};
 }

package/dist/plugin-default.d.ts

@@ -14,6 +14,8 @@ declare const _default: {
         };
         deploy: string[];
         content: {
+            runtime: string[];
+            publish: string[];
             docs: string[];
         };
         site: string[];

package/dist/plugin-default.js

@@ -24,6 +24,8 @@ var plugin_default_default = defineTreeseedPlugin({
     },
     deploy: ["cloudflare"],
     content: {
+      runtime: ["filesystem", "team_scoped_r2_overlay"],
+      publish: ["filesystem", "team_scoped_r2_overlay"],
       docs: ["default"]
     },
     site: ["default"]

package/dist/remote.d.ts

@@ -1,3 +1,4 @@
+import type { RemoteJob, RemoteJobEvent, SdkDispatchRequest, SdkDispatchResult } from './sdk-types.ts';
 export declare const TREESEED_REMOTE_CONTRACT_VERSION = 1;
 export declare const TREESEED_REMOTE_CONTRACT_HEADER = "x-treeseed-remote-contract-version";
 export type ApiScope = string;
@@ -111,6 +112,25 @@ export interface RemoteWorkflowOperationResponse {
     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;
@@ -141,15 +161,6 @@ export declare class RemoteTreeseedSdkClient {
     constructor(client: RemoteTreeseedClient);
     execute<T = unknown>(operation: string, request: RemoteSdkOperationRequest): Promise<T>;
 }
-export declare class TreeseedGatewayClient {
-    private readonly baseUrl;
-    private readonly token;
-    private readonly fetchImpl;
-    constructor(config: import('./sdk-types.ts').SdkGatewayClientConfig);
-    requestJson<T>(path: string, options?: RemoteGatewayRequest): Promise<T & {
-        error?: string;
-    }>;
-}
 export declare class CloudflareQueuePullClient {
     private readonly baseUrl;
     private readonly token;
@@ -170,8 +181,53 @@ export declare class CloudflareQueuePullClient {
         delaySeconds?: number;
     }>): Promise<unknown>;
 }
+export declare class CloudflareQueuePushClient {
+    private readonly baseUrl;
+    private readonly token;
+    private readonly fetchImpl;
+    constructor(config: import('./sdk-types.ts').SdkQueuePushClientConfig);
+    enqueue(request: import('./sdk-types.ts').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;
+    }>;
+}

package/dist/remote.js

@@ -100,32 +100,6 @@ class RemoteTreeseedSdkClient {
 function normalizeExternalBaseUrl(baseUrl) {
   return baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
 }
-class TreeseedGatewayClient {
-  baseUrl;
-  token;
-  fetchImpl;
-  constructor(config) {
-    this.baseUrl = normalizeExternalBaseUrl(config.baseUrl);
-    this.token = config.bearerToken;
-    this.fetchImpl = config.fetchImpl ?? fetch;
-  }
-  async requestJson(path, options = {}) {
-    const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
-      method: options.method ?? "POST",
-      headers: {
-        accept: "application/json",
-        authorization: `Bearer ${this.token}`,
-        ...options.body === void 0 ? {} : { "content-type": "application/json" }
-      },
-      body: options.body === void 0 ? void 0 : JSON.stringify(options.body)
-    });
-    const payload = await response.json().catch(() => ({}));
-    if (!response.ok) {
-      throw new Error(typeof payload.error === "string" ? payload.error : `Gateway request failed with ${response.status}.`);
-    }
-    return payload;
-  }
-}
 class CloudflareQueuePullClient {
   baseUrl;
   token;
@@ -177,6 +151,36 @@ class CloudflareQueuePullClient {
     });
   }
 }
+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 {
   constructor(client) {
     this.client = client;
@@ -190,13 +194,85 @@ class RemoteTreeseedOperationsClient {
     });
   }
 }
+class RemoteTreeseedDispatchClient {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  dispatch(projectId, request) {
+    return this.client.requestJson(`/v1/projects/${encodeURIComponent(projectId)}/dispatch`, {
+      method: "POST",
+      body: request,
+      requireAuth: true
+    });
+  }
+}
+class RemoteTreeseedJobsClient {
+  constructor(client) {
+    this.client = 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 {
+  constructor(client) {
+    this.client = 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
+    });
+  }
+}
 export {
   CloudflareQueuePullClient,
+  CloudflareQueuePushClient,
   RemoteTreeseedAuthClient,
   RemoteTreeseedClient,
+  RemoteTreeseedDispatchClient,
+  RemoteTreeseedJobsClient,
   RemoteTreeseedOperationsClient,
+  RemoteTreeseedRunnerClient,
   RemoteTreeseedSdkClient,
   TREESEED_REMOTE_CONTRACT_HEADER,
-  TREESEED_REMOTE_CONTRACT_VERSION,
-  TreeseedGatewayClient
+  TREESEED_REMOTE_CONTRACT_VERSION
 };

package/dist/scripts/check-build-warnings.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+const args = process.argv.slice(2);
+const allowlisted = [];
+const files = [];
+
+for (let index = 0; index < args.length; index += 1) {
+	const arg = args[index];
+	if (arg === '--allow') {
+		const pattern = args[index + 1];
+		if (!pattern) {
+			throw new Error('Missing value for --allow.');
+		}
+		allowlisted.push(new RegExp(pattern));
+		index += 1;
+		continue;
+	}
+	files.push(arg);
+}
+
+if (files.length === 0) {
+	throw new Error('Usage: node check-build-warnings.mjs <log-file> [<log-file> ...] [--allow <regex>]');
+}
+
+const warningLines = [];
+for (const file of files) {
+	const contents = readFileSync(resolve(process.cwd(), file), 'utf8');
+	for (const line of contents.split(/\r?\n/u)) {
+		if (!line.includes('[WARN]')) {
+			continue;
+		}
+		if (allowlisted.some((pattern) => pattern.test(line))) {
+			continue;
+		}
+		warningLines.push(line);
+	}
+}
+
+if (warningLines.length > 0) {
+	console.error('Unexpected build warnings detected:');
+	for (const line of warningLines) {
+		console.error(`- ${line}`);
+	}
+	process.exit(1);
+}
+
+console.log('No unexpected build warnings detected.');

package/dist/scripts/config-treeseed.js

@@ -74,6 +74,13 @@ try {
         console.log(`Machine key: ${keyPath}`);
         console.log(`Updated values: ${applyResult.updated.length}`);
         console.log(`Initialized environments: ${result.initialized.length}`);
+        for (const scope of scopes) {
+            const readiness = result.readinessByScope?.[scope];
+            if (!readiness)
+                continue;
+            const status = readiness.deployable ? 'deployable' : readiness.provisioned ? 'provisioned' : readiness.configured ? 'configured' : 'pending';
+            console.log(`Readiness (${scope}): ${status}`);
+        }
         if (result.synced.github) {
             console.log(`GitHub sync: ${result.synced.github.secrets.length} secrets, ${result.synced.github.variables.length} variables (${result.synced.github.repository})`);
         }

package/dist/scripts/tenant-workflow-action.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import { resolveScope, runProjectPlatformAction, } from '../operations/services/project-platform.js';
+const tenantRoot = process.cwd();
+function parseArgs(argv) {
+    const parsed = {
+        action: 'deploy_code',
+        environment: null,
+        projectId: null,
+        previewId: null,
+        dryRun: false,
+    };
+    const rest = [...argv];
+    while (rest.length) {
+        const current = rest.shift();
+        if (!current)
+            continue;
+        if (current === '--action') {
+            parsed.action = (rest.shift() ?? parsed.action);
+            continue;
+        }
+        if (current.startsWith('--action=')) {
+            parsed.action = (current.split('=', 2)[1] ?? parsed.action);
+            continue;
+        }
+        if (current === '--environment') {
+            parsed.environment = rest.shift() ?? null;
+            continue;
+        }
+        if (current.startsWith('--environment=')) {
+            parsed.environment = current.split('=', 2)[1] ?? null;
+            continue;
+        }
+        if (current === '--project-id') {
+            parsed.projectId = rest.shift() ?? null;
+            continue;
+        }
+        if (current.startsWith('--project-id=')) {
+            parsed.projectId = current.split('=', 2)[1] ?? null;
+            continue;
+        }
+        if (current === '--preview-id') {
+            parsed.previewId = rest.shift() ?? null;
+            continue;
+        }
+        if (current.startsWith('--preview-id=')) {
+            parsed.previewId = current.split('=', 2)[1] ?? null;
+            continue;
+        }
+        if (current === '--dry-run') {
+            parsed.dryRun = true;
+            continue;
+        }
+        throw new Error(`Unknown workflow action argument: ${current}`);
+    }
+    return parsed;
+}
+async function main() {
+    const options = parseArgs(process.argv.slice(2));
+    const scope = resolveScope(options.environment);
+    const result = await runProjectPlatformAction(options.action, {
+        tenantRoot,
+        scope,
+        projectId: options.projectId ?? process.env.TREESEED_PROJECT_ID ?? null,
+        previewId: options.previewId,
+        dryRun: options.dryRun,
+    });
+    if (result !== undefined) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    }
+}
+await main();

package/dist/sdk-dispatch.d.ts

@@ -0,0 +1,12 @@
+import type { AgentSdk } from './sdk.ts';
+type JsonRecord = Record<string, unknown>;
+type SdkOperationHandler = (sdk: AgentSdk, input: JsonRecord) => Promise<unknown> | unknown;
+interface SdkOperationSpec {
+    name: string;
+    aliases?: string[];
+    handler: SdkOperationHandler;
+}
+export declare function listSdkOperationNames(): string[];
+export declare function findSdkOperation(name: string): SdkOperationSpec | null;
+export declare function executeSdkOperation(sdk: AgentSdk, operationName: string, input: JsonRecord): Promise<unknown>;
+export {};

package/dist/sdk-dispatch.js

@@ -0,0 +1,142 @@
+function passthrough(methodName) {
+  return (sdk, input) => sdk[methodName](input);
+}
+const SDK_OPERATION_SPECS = [
+  { name: "get", handler: passthrough("get") },
+  { name: "read", handler: passthrough("read") },
+  { name: "search", handler: passthrough("search") },
+  { name: "follow", handler: passthrough("follow") },
+  { name: "pick", handler: passthrough("pick") },
+  { name: "create", handler: passthrough("create") },
+  { name: "update", handler: passthrough("update") },
+  { name: "claimMessage", aliases: ["claim-message"], handler: passthrough("claimMessage") },
+  { name: "ackMessage", aliases: ["ack-message"], handler: passthrough("ackMessage") },
+  { name: "createMessage", aliases: ["create-message"], handler: passthrough("createMessage") },
+  { name: "recordRun", aliases: ["record-run"], handler: passthrough("recordRun") },
+  { name: "getCursor", aliases: ["get-cursor"], handler: passthrough("getCursor") },
+  { name: "upsertCursor", aliases: ["upsert-cursor"], handler: passthrough("upsertCursor") },
+  { name: "releaseLease", aliases: ["release-lease"], handler: passthrough("releaseLease") },
+  {
+    name: "releaseAllLeases",
+    aliases: ["release-all-leases"],
+    handler: (sdk) => sdk.releaseAllLeases()
+  },
+  { name: "startWorkDay", aliases: ["start-work-day"], handler: passthrough("startWorkDay") },
+  { name: "closeWorkDay", aliases: ["close-work-day"], handler: passthrough("closeWorkDay") },
+  { name: "createTask", aliases: ["create-task"], handler: passthrough("createTask") },
+  { name: "claimTask", aliases: ["claim-task"], handler: passthrough("claimTask") },
+  {
+    name: "recordTaskProgress",
+    aliases: ["record-task-progress"],
+    handler: passthrough("recordTaskProgress")
+  },
+  { name: "completeTask", aliases: ["complete-task"], handler: passthrough("completeTask") },
+  { name: "failTask", aliases: ["fail-task"], handler: passthrough("failTask") },
+  { name: "appendTaskEvent", aliases: ["append-task-event"], handler: passthrough("appendTaskEvent") },
+  { name: "searchTasks", aliases: ["search-tasks"], handler: passthrough("searchTasks") },
+  {
+    name: "getManagerContext",
+    aliases: ["get-manager-context"],
+    handler: (sdk, input) => sdk.getManagerContext(String(input.taskId ?? input.id ?? ""))
+  },
+  { name: "createReport", aliases: ["create-report"], handler: passthrough("createReport") },
+  {
+    name: "listAgentSpecs",
+    aliases: ["list-agent-specs"],
+    handler: (sdk, input) => sdk.listAgentSpecs(input)
+  },
+  {
+    name: "listRawAgentSpecs",
+    aliases: ["list-raw-agent-specs"],
+    handler: (sdk, input) => sdk.listRawAgentSpecs(input)
+  },
+  { name: "refreshGraph", aliases: ["refresh-graph"], handler: passthrough("refreshGraph") },
+  {
+    name: "searchFiles",
+    aliases: ["search-files"],
+    handler: (sdk, input) => sdk.searchFiles(String(input.query ?? ""), input.options)
+  },
+  {
+    name: "searchSections",
+    aliases: ["search-sections"],
+    handler: (sdk, input) => sdk.searchSections(String(input.query ?? ""), input.options)
+  },
+  {
+    name: "searchEntities",
+    aliases: ["search-entities"],
+    handler: (sdk, input) => sdk.searchEntities(String(input.query ?? ""), input.options)
+  },
+  {
+    name: "getGraphNode",
+    aliases: ["get-graph-node"],
+    handler: (sdk, input) => sdk.getGraphNode(String(input.id ?? ""))
+  },
+  {
+    name: "getNeighbors",
+    aliases: ["get-neighbors"],
+    handler: (sdk, input) => sdk.getNeighbors(String(input.id ?? ""), input.options)
+  },
+  {
+    name: "followReferences",
+    aliases: ["follow-references"],
+    handler: (sdk, input) => sdk.followReferences(String(input.id ?? ""), input.options)
+  },
+  {
+    name: "getBacklinks",
+    aliases: ["get-backlinks"],
+    handler: (sdk, input) => sdk.getBacklinks(String(input.id ?? ""), input.options)
+  },
+  {
+    name: "getRelated",
+    aliases: ["get-related"],
+    handler: (sdk, input) => sdk.getRelated(String(input.id ?? ""), input.options)
+  },
+  {
+    name: "getSubgraph",
+    aliases: ["get-subgraph"],
+    handler: (sdk, input) => sdk.getSubgraph(Array.isArray(input.seedIds) ? input.seedIds.map(String) : [], input.options)
+  },
+  { name: "resolveSeeds", aliases: ["resolve-seeds"], handler: passthrough("resolveSeeds") },
+  { name: "queryGraph", aliases: ["query-graph"], handler: passthrough("queryGraph") },
+  { name: "buildContextPack", aliases: ["build-context-pack"], handler: passthrough("buildContextPack") },
+  {
+    name: "parseGraphDsl",
+    aliases: ["parse-graph-dsl"],
+    handler: (sdk, input) => sdk.parseGraphDsl(String(input.source ?? input.query ?? ""))
+  },
+  {
+    name: "resolveReference",
+    aliases: ["resolve-reference"],
+    handler: (sdk, input) => sdk.resolveReference(String(input.reference ?? ""), input.options)
+  },
+  {
+    name: "explainReferenceChain",
+    aliases: ["explain-reference-chain"],
+    handler: (sdk, input) => sdk.explainReferenceChain(String(input.fromId ?? ""), String(input.toId ?? ""))
+  }
+];
+const SDK_OPERATION_INDEX = /* @__PURE__ */ new Map();
+for (const spec of SDK_OPERATION_SPECS) {
+  SDK_OPERATION_INDEX.set(spec.name, spec);
+  for (const alias of spec.aliases ?? []) {
+    SDK_OPERATION_INDEX.set(alias, spec);
+  }
+}
+function listSdkOperationNames() {
+  return [...new Set(SDK_OPERATION_SPECS.map((entry) => entry.name))];
+}
+function findSdkOperation(name) {
+  return SDK_OPERATION_INDEX.get(name) ?? null;
+}
+async function executeSdkOperation(sdk, operationName, input) {
+  const spec = findSdkOperation(operationName);
+  if (!spec) {
+    throw new Error(`Unknown SDK operation "${operationName}".`);
+  }
+  return await spec.handler(sdk, input);
+}
+export {
+  executeSdkOperation,
+  findSdkOperation,
+  listSdkOperationNames
+};