@treeseed/sdk 0.10.6 → 0.10.8

package/dist/platform-operations.d.ts

@@ -0,0 +1,265 @@
+export declare const PLATFORM_OPERATION_ENDPOINTS: {
+    readonly operations: "/v1/platform/operations";
+    readonly operation: (operationId: string) => string;
+    readonly operationEvents: (operationId: string) => string;
+    readonly cancelOperation: (operationId: string) => string;
+    readonly retryOperation: (operationId: string) => string;
+    readonly registerRunner: "/v1/platform/runners/register";
+    readonly heartbeatRunner: "/v1/platform/runners/heartbeat";
+    readonly claimJob: "/v1/platform/runners/jobs/claim";
+    readonly runnerJob: (operationId: string) => string;
+    readonly jobEvents: (operationId: string) => string;
+    readonly renewLeaseJob: (operationId: string) => string;
+    readonly checkpointJob: (operationId: string) => string;
+    readonly completeJob: (operationId: string) => string;
+    readonly failJob: (operationId: string) => string;
+};
+export declare const PLATFORM_OPERATION_SCOPES: readonly ["platform:runners:register", "platform:runners:claim", "platform:runners:update", "platform:operations:create", "platform:operations:read", "platform:operations:cancel", "platform:operations:retry", "platform:repository:write", "platform:deploy:write", "platform:database:migrate"];
+export declare const PLATFORM_OPERATION_NAMESPACES: readonly ["market", "repository", "deploy", "database", "seed", "infrastructure", "catalog"];
+export declare const PLATFORM_OPERATION_STATUSES: readonly ["queued", "leased", "running", "waiting_for_approval", "succeeded", "failed", "cancelled"];
+export declare const PLATFORM_OPERATION_TARGETS: readonly ["market_operations_runner", "github_actions", "cli", "railway_job"];
+export type PlatformOperationScope = (typeof PLATFORM_OPERATION_SCOPES)[number];
+export type PlatformOperationNamespace = (typeof PLATFORM_OPERATION_NAMESPACES)[number] | string;
+export type PlatformOperationStatus = (typeof PLATFORM_OPERATION_STATUSES)[number] | string;
+export type PlatformOperationTarget = (typeof PLATFORM_OPERATION_TARGETS)[number] | string;
+export interface PlatformOperationRequestedBy {
+    type: 'user' | 'service' | 'team_api_key' | 'platform_runner' | string;
+    id?: string | null;
+}
+export interface PlatformOperation {
+    id: string;
+    namespace: PlatformOperationNamespace;
+    operation: string;
+    status: PlatformOperationStatus;
+    target: PlatformOperationTarget;
+    idempotencyKey?: string | null;
+    input: Record<string, unknown>;
+    output?: unknown;
+    error?: unknown;
+    requestedByType: string;
+    requestedById?: string | null;
+    assignedRunnerId?: string | null;
+    leaseExpiresAt?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    startedAt?: string | null;
+    finishedAt?: string | null;
+    cancelledAt?: string | null;
+}
+export interface PlatformOperationEvent {
+    id: string;
+    operationId: string;
+    seq: number;
+    kind: string;
+    data: Record<string, unknown>;
+    createdAt: string;
+}
+export interface PlatformOperationInput {
+    namespace: PlatformOperationNamespace;
+    operation: string;
+    target?: PlatformOperationTarget;
+    idempotencyKey?: string | null;
+    input?: Record<string, unknown>;
+    requestedBy?: PlatformOperationRequestedBy;
+    status?: PlatformOperationStatus;
+}
+export interface PlatformOperationEventInput {
+    kind: string;
+    data?: Record<string, unknown>;
+}
+export interface PlatformRunnerRegistrationRequest {
+    runnerId: string;
+    runnerKey?: string;
+    name?: string;
+    environment: string;
+    version?: string;
+    capabilities?: string[];
+    maxConcurrentJobs?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface PlatformRunnerHeartbeatRequest {
+    runnerId: string;
+    status?: 'online' | 'offline' | 'degraded' | string;
+    activeJobCount?: number;
+    maxConcurrentJobs?: number;
+    capabilities?: string[];
+    metadata?: Record<string, unknown>;
+    version?: string;
+    environment?: string;
+}
+export interface PlatformRunnerClaimRequest {
+    runnerId: string;
+    limit?: number;
+    leaseSeconds?: number;
+    operationId?: string;
+    namespaces?: string[];
+    capabilities?: string[];
+}
+export interface PlatformRunnerJobUpdateRequest {
+    runnerId: string;
+    output?: unknown;
+    error?: unknown;
+    event?: PlatformOperationEventInput;
+}
+export interface PlatformRunnerClientOptions {
+    marketUrl: string;
+    marketId: string;
+    runnerSecret: string;
+    fetchImpl?: typeof fetch;
+    userAgent?: string;
+}
+export interface PlatformOperationExecutorContext {
+    operation: PlatformOperation;
+    operationId: string;
+    workspaceRoot: string;
+    environment: string;
+    emit(event: PlatformOperationEventInput): Promise<void>;
+    checkpoint(output: unknown, event?: PlatformOperationEventInput): Promise<void>;
+    renewLease(leaseSeconds?: number): Promise<PlatformOperation>;
+    throwIfCancelled(): Promise<void>;
+}
+export interface PlatformOperationExecutor<TInput = Record<string, unknown>, TOutput = unknown> {
+    namespace: PlatformOperationNamespace;
+    operation: string;
+    run(input: TInput, context: PlatformOperationExecutorContext): Promise<TOutput>;
+}
+export interface PlatformOperationRunnerCoreClient {
+    claimJob(request: PlatformRunnerClaimRequest): Promise<{
+        ok: true;
+        operation: PlatformOperation | null;
+    }>;
+    getOperation?(operationId: string): Promise<{
+        ok: true;
+        operation: PlatformOperation;
+    }>;
+    appendEvent(operationId: string, request: PlatformRunnerJobUpdateRequest): Promise<{
+        ok: true;
+        event: PlatformOperationEvent;
+    }>;
+    renewLease?(operationId: string, request: PlatformRunnerJobUpdateRequest & {
+        leaseSeconds?: number;
+    }): Promise<{
+        ok: true;
+        operation: PlatformOperation;
+    }>;
+    checkpoint(operationId: string, request: PlatformRunnerJobUpdateRequest): Promise<{
+        ok: true;
+        operation: PlatformOperation;
+    }>;
+    complete(operationId: string, request: PlatformRunnerJobUpdateRequest): Promise<{
+        ok: true;
+        operation: PlatformOperation;
+    }>;
+    fail(operationId: string, request: PlatformRunnerJobUpdateRequest): Promise<{
+        ok: true;
+        operation: PlatformOperation;
+    }>;
+}
+export interface PlatformOperationRunnerCoreOptions {
+    client: PlatformOperationRunnerCoreClient;
+    runnerId: string;
+    workspaceRoot: string;
+    environment: string;
+    executors: PlatformOperationExecutor[];
+    operationId?: string | null;
+    leaseSeconds?: number;
+    limit?: number;
+    throwIfCancelled?: (operation: PlatformOperation) => Promise<void>;
+}
+export interface PlatformOperationRunOnceResult {
+    ok: boolean;
+    claimed: boolean;
+    operation: PlatformOperation | null;
+    output?: unknown;
+    error?: unknown;
+}
+export interface PlatformOperationNavigationResult {
+    href: string | null;
+    changedPaths: string[];
+    branch: string | null;
+    commitSha: string | null;
+}
+export interface PlatformOperationPollOptions {
+    operationId: string;
+    fetchOperation(operationId: string): Promise<PlatformOperation>;
+    fetchEvents?(operationId: string): Promise<PlatformOperationEvent[]>;
+    onUpdate?(snapshot: {
+        operation: PlatformOperation;
+        events: PlatformOperationEvent[];
+        terminal: boolean;
+    }): void | Promise<void>;
+    intervalMs?: number;
+    timeoutMs?: number;
+    sleep?(ms: number): Promise<void>;
+}
+export interface PlatformOperationPollResult {
+    operation: PlatformOperation;
+    events: PlatformOperationEvent[];
+    terminal: boolean;
+    navigation: PlatformOperationNavigationResult;
+}
+export declare function buildPlatformRunnerAuthHeaders(secret: string): Record<string, string>;
+export declare function isPlatformOperationTerminal(operation: Pick<PlatformOperation, 'status'> | null | undefined): boolean;
+export declare function isPlatformOperationSuccessful(operation: Pick<PlatformOperation, 'status'> | null | undefined): boolean;
+export declare function derivePlatformOperationNavigation(operation: PlatformOperation): PlatformOperationNavigationResult;
+export declare function pollPlatformOperation(options: PlatformOperationPollOptions): Promise<PlatformOperationPollResult>;
+export declare class PlatformOperationApiError extends Error {
+    readonly status: number;
+    readonly payload: unknown;
+    constructor(message: string, status: number, payload: unknown);
+}
+export declare function assertPlatformOperationOkEnvelope(value: unknown, label?: string): void;
+export declare function assertPlatformOperation(value: unknown, label?: string): asserts value is PlatformOperation;
+export declare function assertPlatformOperationEvent(value: unknown, label?: string): asserts value is PlatformOperationEvent;
+export declare function createPlatformOperationExecutorRegistry(executors: PlatformOperationExecutor[]): {
+    get(operation: PlatformOperation): PlatformOperationExecutor<Record<string, unknown>, unknown> | null;
+    keys(): string[];
+};
+export declare function runPlatformOperationOnce(options: PlatformOperationRunnerCoreOptions): Promise<PlatformOperationRunOnceResult>;
+export declare class PlatformRunnerClient {
+    private readonly marketUrl;
+    private readonly marketId;
+    private readonly runnerSecret;
+    private readonly fetchImpl;
+    private readonly userAgent?;
+    constructor(options: PlatformRunnerClientOptions);
+    private requestJson;
+    register(request: PlatformRunnerRegistrationRequest): Promise<{
+        ok: true;
+        runner: Record<string, unknown>;
+    }>;
+    heartbeat(request: PlatformRunnerHeartbeatRequest): Promise<{
+        ok: true;
+        runner: Record<string, unknown>;
+    }>;
+    claimJob(request: PlatformRunnerClaimRequest): Promise<{
+        ok: true;
+        operation: PlatformOperation | null;
+    }>;
+    getOperation(operationId: string): Promise<{
+        ok: true;
+        operation: PlatformOperation;
+    }>;
+    appendEvent(operationId: string, request: PlatformRunnerJobUpdateRequest): Promise<{
+        ok: true;
+        event: PlatformOperationEvent;
+    }>;
+    renewLease(operationId: string, request: PlatformRunnerJobUpdateRequest & {
+        leaseSeconds?: number;
+    }): Promise<{
+        ok: true;
+        operation: PlatformOperation;
+    }>;
+    checkpoint(operationId: string, request: PlatformRunnerJobUpdateRequest): Promise<{
+        ok: true;
+        operation: PlatformOperation;
+    }>;
+    complete(operationId: string, request: PlatformRunnerJobUpdateRequest): Promise<{
+        ok: true;
+        operation: PlatformOperation;
+    }>;
+    fail(operationId: string, request: PlatformRunnerJobUpdateRequest): Promise<{
+        ok: true;
+        operation: PlatformOperation;
+    }>;
+}

package/dist/platform-operations.js

@@ -0,0 +1,421 @@
+import {
+  TREESEED_REMOTE_CONTRACT_HEADER,
+  TREESEED_REMOTE_CONTRACT_VERSION
+} from "./remote.js";
+const PLATFORM_OPERATION_ENDPOINTS = {
+  operations: "/v1/platform/operations",
+  operation: (operationId) => `/v1/platform/operations/${encodeURIComponent(operationId)}`,
+  operationEvents: (operationId) => `/v1/platform/operations/${encodeURIComponent(operationId)}/events`,
+  cancelOperation: (operationId) => `/v1/platform/operations/${encodeURIComponent(operationId)}/cancel`,
+  retryOperation: (operationId) => `/v1/platform/operations/${encodeURIComponent(operationId)}/retry`,
+  registerRunner: "/v1/platform/runners/register",
+  heartbeatRunner: "/v1/platform/runners/heartbeat",
+  claimJob: "/v1/platform/runners/jobs/claim",
+  runnerJob: (operationId) => `/v1/platform/runners/jobs/${encodeURIComponent(operationId)}`,
+  jobEvents: (operationId) => `/v1/platform/runners/jobs/${encodeURIComponent(operationId)}/events`,
+  renewLeaseJob: (operationId) => `/v1/platform/runners/jobs/${encodeURIComponent(operationId)}/renew-lease`,
+  checkpointJob: (operationId) => `/v1/platform/runners/jobs/${encodeURIComponent(operationId)}/checkpoint`,
+  completeJob: (operationId) => `/v1/platform/runners/jobs/${encodeURIComponent(operationId)}/complete`,
+  failJob: (operationId) => `/v1/platform/runners/jobs/${encodeURIComponent(operationId)}/fail`
+};
+const PLATFORM_OPERATION_SCOPES = [
+  "platform:runners:register",
+  "platform:runners:claim",
+  "platform:runners:update",
+  "platform:operations:create",
+  "platform:operations:read",
+  "platform:operations:cancel",
+  "platform:operations:retry",
+  "platform:repository:write",
+  "platform:deploy:write",
+  "platform:database:migrate"
+];
+const PLATFORM_OPERATION_NAMESPACES = [
+  "market",
+  "repository",
+  "deploy",
+  "database",
+  "seed",
+  "infrastructure",
+  "catalog"
+];
+const PLATFORM_OPERATION_STATUSES = [
+  "queued",
+  "leased",
+  "running",
+  "waiting_for_approval",
+  "succeeded",
+  "failed",
+  "cancelled"
+];
+const PLATFORM_OPERATION_TARGETS = [
+  "market_operations_runner",
+  "github_actions",
+  "cli",
+  "railway_job"
+];
+function buildPlatformRunnerAuthHeaders(secret) {
+  return {
+    authorization: `Bearer ${secret}`
+  };
+}
+function isPlatformOperationTerminal(operation) {
+  return ["succeeded", "failed", "cancelled"].includes(String(operation?.status ?? ""));
+}
+function isPlatformOperationSuccessful(operation) {
+  return String(operation?.status ?? "") === "succeeded";
+}
+function nestedRecord(value, keys) {
+  let current = value;
+  for (const key of keys) {
+    if (!isRecord(current)) return null;
+    current = current[key];
+  }
+  return isRecord(current) ? current : null;
+}
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return null;
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.map((entry) => String(entry).trim()).filter(Boolean) : [];
+}
+function derivePlatformOperationNavigation(operation) {
+  const output = isRecord(operation.output) ? operation.output : {};
+  const nestedOutput = nestedRecord(output, ["output"]) ?? {};
+  const record = nestedRecord(output, ["record"]) ?? nestedRecord(nestedOutput, ["record"]);
+  const child = nestedRecord(output, ["child"]) ?? nestedRecord(nestedOutput, ["child"]);
+  const decision = nestedRecord(output, ["decision"]) ?? nestedRecord(nestedOutput, ["decision"]);
+  const changedPaths = [
+    ...stringArray(output.changedPaths),
+    ...stringArray(nestedOutput.changedPaths)
+  ];
+  return {
+    href: firstString(output.href, nestedOutput.href, record?.href, child?.href, decision?.href),
+    changedPaths: [...new Set(changedPaths)],
+    branch: firstString(output.branch, nestedOutput.branch),
+    commitSha: firstString(output.commitSha, nestedOutput.commitSha)
+  };
+}
+async function pollPlatformOperation(options) {
+  const intervalMs = Math.max(0, options.intervalMs ?? 1e3);
+  const timeoutMs = Math.max(intervalMs, options.timeoutMs ?? 12e4);
+  const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const startedAt = Date.now();
+  let latestOperation = null;
+  let latestEvents = [];
+  while (Date.now() - startedAt <= timeoutMs) {
+    latestOperation = await options.fetchOperation(options.operationId);
+    latestEvents = options.fetchEvents ? await options.fetchEvents(options.operationId) : [];
+    const terminal = isPlatformOperationTerminal(latestOperation);
+    await options.onUpdate?.({ operation: latestOperation, events: latestEvents, terminal });
+    if (terminal) {
+      return {
+        operation: latestOperation,
+        events: latestEvents,
+        terminal,
+        navigation: derivePlatformOperationNavigation(latestOperation)
+      };
+    }
+    await sleep(intervalMs);
+  }
+  if (!latestOperation) {
+    throw new Error(`Platform operation "${options.operationId}" was not found before polling timed out.`);
+  }
+  return {
+    operation: latestOperation,
+    events: latestEvents,
+    terminal: false,
+    navigation: derivePlatformOperationNavigation(latestOperation)
+  };
+}
+function normalizeBaseUrl(value) {
+  return value.trim().replace(/\/+$/u, "");
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+class PlatformOperationApiError extends Error {
+  status;
+  payload;
+  constructor(message, status, payload) {
+    super(message);
+    this.name = "PlatformOperationApiError";
+    this.status = status;
+    this.payload = payload;
+  }
+}
+function assertPlatformOperationOkEnvelope(value, label = "Platform operation response") {
+  if (!isRecord(value) || value.ok !== true) {
+    throw new Error(`${label} is missing ok: true.`);
+  }
+}
+function assertPlatformOperation(value, label = "Platform operation") {
+  if (!isRecord(value)) throw new Error(`${label} must be an object.`);
+  for (const key of ["id", "namespace", "operation", "status", "target", "createdAt", "updatedAt"]) {
+    if (typeof value[key] !== "string" || !String(value[key]).trim()) {
+      throw new Error(`${label} is missing ${key}.`);
+    }
+  }
+  if (!isRecord(value.input)) throw new Error(`${label} is missing input.`);
+}
+function assertPlatformOperationEvent(value, label = "Platform operation event") {
+  if (!isRecord(value)) throw new Error(`${label} must be an object.`);
+  for (const key of ["id", "operationId", "kind", "createdAt"]) {
+    if (typeof value[key] !== "string" || !String(value[key]).trim()) {
+      throw new Error(`${label} is missing ${key}.`);
+    }
+  }
+  if (!Number.isFinite(Number(value.seq))) throw new Error(`${label} is missing seq.`);
+  if (!isRecord(value.data)) throw new Error(`${label} is missing data.`);
+}
+function createPlatformOperationExecutorRegistry(executors) {
+  const registry = /* @__PURE__ */ new Map();
+  for (const executor of executors) {
+    registry.set(`${executor.namespace}:${executor.operation}`, executor);
+  }
+  return {
+    get(operation) {
+      return registry.get(`${operation.namespace}:${operation.operation}`) ?? null;
+    },
+    keys() {
+      return [...registry.keys()];
+    }
+  };
+}
+async function runPlatformOperationOnce(options) {
+  const registry = createPlatformOperationExecutorRegistry(options.executors);
+  const claimed = await options.client.claimJob({
+    runnerId: options.runnerId,
+    operationId: options.operationId ?? void 0,
+    limit: options.limit ?? 1,
+    leaseSeconds: options.leaseSeconds ?? 300
+  });
+  let operation = claimed.operation;
+  if (!operation) {
+    return { ok: true, claimed: false, operation: null };
+  }
+  const executor = registry.get(operation);
+  if (!executor) {
+    const message = `No executor registered for platform operation "${operation.namespace}:${operation.operation}".`;
+    const failed = await options.client.fail(operation.id, {
+      runnerId: options.runnerId,
+      error: { message },
+      event: { kind: "runner.executor_missing", data: { namespace: operation.namespace, operation: operation.operation } }
+    });
+    return { ok: false, claimed: true, operation: failed.operation, error: { message } };
+  }
+  const context = {
+    operation,
+    operationId: operation.id,
+    workspaceRoot: options.workspaceRoot,
+    environment: options.environment,
+    emit: async (event) => {
+      await options.client.appendEvent(operation.id, {
+        runnerId: options.runnerId,
+        event
+      });
+    },
+    checkpoint: async (output, event) => {
+      await context.throwIfCancelled();
+      await options.client.checkpoint(operation.id, {
+        runnerId: options.runnerId,
+        output,
+        event
+      });
+    },
+    renewLease: async (leaseSeconds) => {
+      if (!options.client.renewLease) return operation;
+      const renewed = await options.client.renewLease(operation.id, {
+        runnerId: options.runnerId,
+        leaseSeconds,
+        event: { kind: "runner.lease_renewed", data: { leaseSeconds: leaseSeconds ?? options.leaseSeconds ?? 300 } }
+      });
+      operation = renewed.operation;
+      return renewed.operation;
+    },
+    throwIfCancelled: async () => {
+      const latest = options.client.getOperation ? (await options.client.getOperation(operation.id)).operation : operation;
+      operation = latest;
+      if (latest.status === "cancelled") throw new Error("Platform operation was cancelled.");
+      await options.throwIfCancelled?.(operation);
+    }
+  };
+  try {
+    await context.emit({ kind: "runner.started", data: { namespace: operation.namespace, operation: operation.operation } });
+    await context.throwIfCancelled();
+    await context.renewLease(options.leaseSeconds);
+    const output = await executor.run(operation.input, context);
+    await context.throwIfCancelled();
+    const completed = await options.client.complete(operation.id, {
+      runnerId: options.runnerId,
+      output
+    });
+    return { ok: true, claimed: true, operation: completed.operation, output };
+  } catch (error) {
+    const failure = {
+      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.getOperation) {
+      await options.client.appendEvent(operation.id, {
+        runnerId: options.runnerId,
+        event: { kind: eventKind, data: failure }
+      }).catch(() => {
+      });
+      const latest = await options.client.getOperation(operation.id);
+      return { ok: false, claimed: true, operation: latest.operation, error: failure };
+    }
+    const failed = await options.client.fail(operation.id, {
+      runnerId: options.runnerId,
+      error: failure,
+      event: { kind: eventKind, data: failure }
+    });
+    return { ok: false, claimed: true, operation: failed.operation, error: failure };
+  }
+}
+class PlatformRunnerClient {
+  marketUrl;
+  marketId;
+  runnerSecret;
+  fetchImpl;
+  userAgent;
+  constructor(options) {
+    this.marketUrl = normalizeBaseUrl(options.marketUrl);
+    this.marketId = options.marketId.trim();
+    this.runnerSecret = options.runnerSecret.trim();
+    if (!this.marketUrl) throw new Error("Market API URL is required.");
+    if (!this.marketId) throw new Error("Market ID is required.");
+    if (!this.runnerSecret) throw new Error("Platform runner secret is required.");
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.userAgent = options.userAgent;
+  }
+  async requestJson(path, options = {}) {
+    const headers = {
+      accept: "application/json",
+      [TREESEED_REMOTE_CONTRACT_HEADER]: String(TREESEED_REMOTE_CONTRACT_VERSION),
+      ...buildPlatformRunnerAuthHeaders(this.runnerSecret)
+    };
+    if (this.userAgent) headers["user-agent"] = this.userAgent;
+    if (options.body !== void 0) headers["content-type"] = "application/json";
+    const response = await this.fetchImpl(`${this.marketUrl}${path}`, {
+      method: options.method ?? "GET",
+      headers,
+      body: options.body === void 0 ? void 0 : JSON.stringify(options.body)
+    });
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      const message = isRecord(payload) && typeof payload.error === "string" ? payload.error : `Platform operation request failed with ${response.status}.`;
+      throw new PlatformOperationApiError(message, response.status, payload);
+    }
+    return payload;
+  }
+  register(request) {
+    return this.requestJson(PLATFORM_OPERATION_ENDPOINTS.registerRunner, {
+      method: "POST",
+      body: { ...request, marketId: this.marketId }
+    }).then((response) => {
+      assertPlatformOperationOkEnvelope(response, "Platform runner registration response");
+      return response;
+    });
+  }
+  heartbeat(request) {
+    return this.requestJson(PLATFORM_OPERATION_ENDPOINTS.heartbeatRunner, {
+      method: "POST",
+      body: { ...request, marketId: this.marketId }
+    }).then((response) => {
+      assertPlatformOperationOkEnvelope(response, "Platform runner heartbeat response");
+      return response;
+    });
+  }
+  claimJob(request) {
+    return this.requestJson(PLATFORM_OPERATION_ENDPOINTS.claimJob, {
+      method: "POST",
+      body: { ...request, marketId: this.marketId }
+    }).then((response) => {
+      assertPlatformOperationOkEnvelope(response, "Platform runner claim response");
+      if (response.operation !== null) assertPlatformOperation(response.operation, "Claimed platform operation");
+      return response;
+    });
+  }
+  getOperation(operationId) {
+    return this.requestJson(PLATFORM_OPERATION_ENDPOINTS.runnerJob(operationId), {
+      method: "GET"
+    }).then((response) => {
+      assertPlatformOperationOkEnvelope(response, "Platform operation response");
+      assertPlatformOperation(response.operation);
+      return response;
+    });
+  }
+  appendEvent(operationId, request) {
+    return this.requestJson(PLATFORM_OPERATION_ENDPOINTS.jobEvents(operationId), {
+      method: "POST",
+      body: { ...request, marketId: this.marketId }
+    }).then((response) => {
+      assertPlatformOperationOkEnvelope(response, "Platform operation event response");
+      assertPlatformOperationEvent(response.event);
+      return response;
+    });
+  }
+  renewLease(operationId, request) {
+    return this.requestJson(PLATFORM_OPERATION_ENDPOINTS.renewLeaseJob(operationId), {
+      method: "POST",
+      body: { ...request, marketId: this.marketId }
+    }).then((response) => {
+      assertPlatformOperationOkEnvelope(response, "Platform operation lease renewal response");
+      assertPlatformOperation(response.operation);
+      return response;
+    });
+  }
+  checkpoint(operationId, request) {
+    return this.requestJson(PLATFORM_OPERATION_ENDPOINTS.checkpointJob(operationId), {
+      method: "POST",
+      body: { ...request, marketId: this.marketId }
+    }).then((response) => {
+      assertPlatformOperationOkEnvelope(response, "Platform operation checkpoint response");
+      assertPlatformOperation(response.operation);
+      return response;
+    });
+  }
+  complete(operationId, request) {
+    return this.requestJson(PLATFORM_OPERATION_ENDPOINTS.completeJob(operationId), {
+      method: "POST",
+      body: { ...request, marketId: this.marketId }
+    }).then((response) => {
+      assertPlatformOperationOkEnvelope(response, "Platform operation completion response");
+      assertPlatformOperation(response.operation);
+      return response;
+    });
+  }
+  fail(operationId, request) {
+    return this.requestJson(PLATFORM_OPERATION_ENDPOINTS.failJob(operationId), {
+      method: "POST",
+      body: { ...request, marketId: this.marketId }
+    }).then((response) => {
+      assertPlatformOperationOkEnvelope(response, "Platform operation failure response");
+      assertPlatformOperation(response.operation);
+      return response;
+    });
+  }
+}
+export {
+  PLATFORM_OPERATION_ENDPOINTS,
+  PLATFORM_OPERATION_NAMESPACES,
+  PLATFORM_OPERATION_SCOPES,
+  PLATFORM_OPERATION_STATUSES,
+  PLATFORM_OPERATION_TARGETS,
+  PlatformOperationApiError,
+  PlatformRunnerClient,
+  assertPlatformOperation,
+  assertPlatformOperationEvent,
+  assertPlatformOperationOkEnvelope,
+  buildPlatformRunnerAuthHeaders,
+  createPlatformOperationExecutorRegistry,
+  derivePlatformOperationNavigation,
+  isPlatformOperationSuccessful,
+  isPlatformOperationTerminal,
+  pollPlatformOperation,
+  runPlatformOperationOnce
+};