@dfosco/storyboard 0.5.0-alpha.9 → 0.5.0-beta.32

package/bin/storyboard-runtime.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { startDaemon } from '../dist/runtime/server/main.js'
+
+startDaemon().catch((err) => {
+  console.error('[storyboard-runtime] fatal:', err)
+  process.exit(1)
+})

package/commandpalette.config.json

@@ -58,14 +58,14 @@
           "label": "Devtools",
           "meta": { "strokeWeight": 1.6, "scale": 1.1 }
         },
+        {
+          "id": "see-deployed-branch",
+          "label": "See deployed branch"
+        },
         {
           "id": "feature-flags",
           "label": "Feature Flags",
           "meta": { "strokeWeight": 1.6, "scale": 1.1 }
-        },
-        {
-          "id": "autosync",
-          "label": "Auto Sync"
         }
       ]
     },
@@ -144,6 +144,7 @@
     "repository": "primer/mark-github",
     "docs": "primer/book",
     "devtools": "iconoir/wrench",
+    "see-deployed-branch": "primer/globe",
     "feature-flags": "iconoir/white-flag",
     "agent": "agents",
     "prompt": "primer/zap",

package/dist/runtime/api-Bbh7Mcv9.d.ts

@@ -0,0 +1,305 @@
+import { z } from 'zod';
+
+/**
+ * `POST /devserver/acquire` — request a devserver for a `(devDomain, worktree)` slot.
+ *
+ * If a devserver already exists for the slot, the runtime returns its existing
+ * lease (renewed). Otherwise it either rents a hot-pool member or spawns a new
+ * Vite process. The slot is locked for the duration of the call.
+ */
+declare const AcquireRequest: z.ZodObject<{
+    slot: z.ZodObject<{
+        devDomain: z.ZodBranded<z.ZodString, "DevDomain">;
+        worktree: z.ZodBranded<z.ZodString, "WorktreeName">;
+    }, "strip", z.ZodTypeAny, {
+        devDomain?: string & z.BRAND<"DevDomain">;
+        worktree?: string & z.BRAND<"WorktreeName">;
+    }, {
+        devDomain?: string;
+        worktree?: string;
+    }>;
+    /** Absolute path of the worktree directory; the runtime spawns Vite with `cwd: targetCwd`. */
+    targetCwd: z.ZodString;
+    /** Lease TTL in seconds. Defaults to 5 min; CLI clients renew on each command. */
+    ttlSeconds: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Escape hatch for the deprecated default devDomain `"storyboard"`. CI and
+     * one-off scripts may pass true; the CLI never does.
+     */
+    allowDefaultDomain: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    slot?: {
+        devDomain?: string & z.BRAND<"DevDomain">;
+        worktree?: string & z.BRAND<"WorktreeName">;
+    };
+    targetCwd?: string;
+    ttlSeconds?: number;
+    allowDefaultDomain?: boolean;
+}, {
+    slot?: {
+        devDomain?: string;
+        worktree?: string;
+    };
+    targetCwd?: string;
+    ttlSeconds?: number;
+    allowDefaultDomain?: boolean;
+}>;
+type AcquireRequest = z.infer<typeof AcquireRequest>;
+declare const AcquireResponse: z.ZodObject<{
+    lease: z.ZodObject<{
+        id: z.ZodString;
+        devServerId: z.ZodString;
+        slot: z.ZodObject<{
+            devDomain: z.ZodBranded<z.ZodString, "DevDomain">;
+            worktree: z.ZodBranded<z.ZodString, "WorktreeName">;
+        }, "strip", z.ZodTypeAny, {
+            devDomain?: string & z.BRAND<"DevDomain">;
+            worktree?: string & z.BRAND<"WorktreeName">;
+        }, {
+            devDomain?: string;
+            worktree?: string;
+        }>;
+        url: z.ZodString;
+        expiresAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        slot?: {
+            devDomain?: string & z.BRAND<"DevDomain">;
+            worktree?: string & z.BRAND<"WorktreeName">;
+        };
+        devServerId?: string;
+        url?: string;
+        expiresAt?: string;
+    }, {
+        id?: string;
+        slot?: {
+            devDomain?: string;
+            worktree?: string;
+        };
+        devServerId?: string;
+        url?: string;
+        expiresAt?: string;
+    }>;
+    devServer: z.ZodObject<{
+        id: z.ZodString;
+        pid: z.ZodNumber;
+        port: z.ZodBranded<z.ZodNumber, "Port">;
+        status: z.ZodEnum<["idle", "spawning", "ready", "draining", "stopped"]>;
+        slot: z.ZodNullable<z.ZodObject<{
+            devDomain: z.ZodBranded<z.ZodString, "DevDomain">;
+            worktree: z.ZodBranded<z.ZodString, "WorktreeName">;
+        }, "strip", z.ZodTypeAny, {
+            devDomain?: string & z.BRAND<"DevDomain">;
+            worktree?: string & z.BRAND<"WorktreeName">;
+        }, {
+            devDomain?: string;
+            worktree?: string;
+        }>>;
+        cwd: z.ZodNullable<z.ZodString>;
+        spawnedAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        status?: "idle" | "spawning" | "ready" | "draining" | "stopped";
+        id?: string;
+        pid?: number;
+        port?: number & z.BRAND<"Port">;
+        slot?: {
+            devDomain?: string & z.BRAND<"DevDomain">;
+            worktree?: string & z.BRAND<"WorktreeName">;
+        };
+        cwd?: string;
+        spawnedAt?: string;
+        updatedAt?: string;
+    }, {
+        status?: "idle" | "spawning" | "ready" | "draining" | "stopped";
+        id?: string;
+        pid?: number;
+        port?: number;
+        slot?: {
+            devDomain?: string;
+            worktree?: string;
+        };
+        cwd?: string;
+        spawnedAt?: string;
+        updatedAt?: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    lease?: {
+        id?: string;
+        slot?: {
+            devDomain?: string & z.BRAND<"DevDomain">;
+            worktree?: string & z.BRAND<"WorktreeName">;
+        };
+        devServerId?: string;
+        url?: string;
+        expiresAt?: string;
+    };
+    devServer?: {
+        status?: "idle" | "spawning" | "ready" | "draining" | "stopped";
+        id?: string;
+        pid?: number;
+        port?: number & z.BRAND<"Port">;
+        slot?: {
+            devDomain?: string & z.BRAND<"DevDomain">;
+            worktree?: string & z.BRAND<"WorktreeName">;
+        };
+        cwd?: string;
+        spawnedAt?: string;
+        updatedAt?: string;
+    };
+}, {
+    lease?: {
+        id?: string;
+        slot?: {
+            devDomain?: string;
+            worktree?: string;
+        };
+        devServerId?: string;
+        url?: string;
+        expiresAt?: string;
+    };
+    devServer?: {
+        status?: "idle" | "spawning" | "ready" | "draining" | "stopped";
+        id?: string;
+        pid?: number;
+        port?: number;
+        slot?: {
+            devDomain?: string;
+            worktree?: string;
+        };
+        cwd?: string;
+        spawnedAt?: string;
+        updatedAt?: string;
+    };
+}>;
+type AcquireResponse = z.infer<typeof AcquireResponse>;
+/** `POST /devserver/release` — relinquish the lease and trigger draining. */
+declare const ReleaseRequest: z.ZodObject<{
+    leaseId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    leaseId?: string;
+}, {
+    leaseId?: string;
+}>;
+type ReleaseRequest = z.infer<typeof ReleaseRequest>;
+/** `POST /devserver/renew` — extend the lease without changing devserver state. */
+declare const RenewRequest: z.ZodObject<{
+    leaseId: z.ZodString;
+    ttlSeconds: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    ttlSeconds?: number;
+    leaseId?: string;
+}, {
+    ttlSeconds?: number;
+    leaseId?: string;
+}>;
+type RenewRequest = z.infer<typeof RenewRequest>;
+/** `GET /proxy/state` — current routing table the runtime believes Caddy holds. */
+declare const ProxyState: z.ZodObject<{
+    routes: z.ZodArray<z.ZodObject<{
+        devDomain: z.ZodBranded<z.ZodString, "DevDomain">;
+        host: z.ZodString;
+        upstreams: z.ZodRecord<z.ZodString, z.ZodBranded<z.ZodNumber, "Port">>;
+    }, "strip", z.ZodTypeAny, {
+        devDomain?: string & z.BRAND<"DevDomain">;
+        host?: string;
+        upstreams?: Record<string, number & z.BRAND<"Port">>;
+    }, {
+        devDomain?: string;
+        host?: string;
+        upstreams?: Record<string, number>;
+    }>, "many">;
+    caddyReachable: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    routes?: {
+        devDomain?: string & z.BRAND<"DevDomain">;
+        host?: string;
+        upstreams?: Record<string, number & z.BRAND<"Port">>;
+    }[];
+    caddyReachable?: boolean;
+}, {
+    routes?: {
+        devDomain?: string;
+        host?: string;
+        upstreams?: Record<string, number>;
+    }[];
+    caddyReachable?: boolean;
+}>;
+type ProxyState = z.infer<typeof ProxyState>;
+/** `GET /pool/status` — hot-pool inventory. */
+declare const PoolStatus: z.ZodObject<{
+    warm: z.ZodNumber;
+    bound: z.ZodNumber;
+    capacity: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    warm?: number;
+    bound?: number;
+    capacity?: number;
+}, {
+    warm?: number;
+    bound?: number;
+    capacity?: number;
+}>;
+type PoolStatus = z.infer<typeof PoolStatus>;
+/** `POST /proxy/upsert` — bind (devDomain, worktree) → port in the proxy. */
+declare const ProxyUpsertRequest: z.ZodObject<{
+    devDomain: z.ZodString;
+    worktree: z.ZodString;
+    port: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    devDomain?: string;
+    worktree?: string;
+    port?: number;
+}, {
+    devDomain?: string;
+    worktree?: string;
+    port?: number;
+}>;
+type ProxyUpsertRequest = z.infer<typeof ProxyUpsertRequest>;
+/** `POST /proxy/remove` — drop a worktree's route from the proxy. */
+declare const ProxyRemoveRequest: z.ZodObject<{
+    devDomain: z.ZodString;
+    worktree: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    devDomain?: string;
+    worktree?: string;
+}, {
+    devDomain?: string;
+    worktree?: string;
+}>;
+type ProxyRemoveRequest = z.infer<typeof ProxyRemoveRequest>;
+/** `GET /health` — daemon liveness probe. */
+declare const Health: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    version: z.ZodString;
+    uptimeSeconds: z.ZodNumber;
+    port: z.ZodBranded<z.ZodNumber, "Port">;
+}, "strip", z.ZodTypeAny, {
+    port?: number & z.BRAND<"Port">;
+    ok?: true;
+    version?: string;
+    uptimeSeconds?: number;
+}, {
+    port?: number;
+    ok?: true;
+    version?: string;
+    uptimeSeconds?: number;
+}>;
+type Health = z.infer<typeof Health>;
+/** Runtime error envelope. All non-2xx responses share this shape. */
+declare const RuntimeError: z.ZodObject<{
+    error: z.ZodString;
+    code: z.ZodEnum<["NOT_IMPLEMENTED", "BAD_REQUEST", "CONFLICT", "NOT_FOUND", "FORBIDDEN_DEFAULT_DOMAIN", "INTERNAL", "CADDY_UNREACHABLE", "PORT_EXHAUSTED", "TIMEOUT"]>;
+    details: z.ZodOptional<z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    code?: "NOT_IMPLEMENTED" | "BAD_REQUEST" | "CONFLICT" | "NOT_FOUND" | "FORBIDDEN_DEFAULT_DOMAIN" | "INTERNAL" | "CADDY_UNREACHABLE" | "PORT_EXHAUSTED" | "TIMEOUT";
+    error?: string;
+    details?: unknown;
+}, {
+    code?: "NOT_IMPLEMENTED" | "BAD_REQUEST" | "CONFLICT" | "NOT_FOUND" | "FORBIDDEN_DEFAULT_DOMAIN" | "INTERNAL" | "CADDY_UNREACHABLE" | "PORT_EXHAUSTED" | "TIMEOUT";
+    error?: string;
+    details?: unknown;
+}>;
+type RuntimeError = z.infer<typeof RuntimeError>;
+
+export { AcquireRequest as A, Health as H, ProxyState as P, ReleaseRequest as R, AcquireResponse as a, RenewRequest as b, PoolStatus as c, ProxyUpsertRequest as d, ProxyRemoveRequest as e, RuntimeError as f };

package/dist/runtime/client/index.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { H as Health, A as AcquireRequest, a as AcquireResponse, R as ReleaseRequest, b as RenewRequest, P as ProxyState, d as ProxyUpsertRequest, e as ProxyRemoveRequest, c as PoolStatus, f as RuntimeError } from '../api-Bbh7Mcv9.js';
+
+interface RuntimeClientOptions {
+    /** Override base URL (mostly for tests). */
+    baseUrl?: string;
+    /** Auto-start the daemon if it isn't running. Default: true. */
+    autoStart?: boolean;
+}
+declare class RuntimeRequestError extends Error {
+    readonly status: number;
+    readonly code: z.infer<typeof RuntimeError>['code'];
+    readonly details?: unknown;
+    constructor(message: string, status: number, code: z.infer<typeof RuntimeError>['code'], details?: unknown);
+}
+declare class RuntimeClient {
+    readonly baseUrl: string;
+    readonly autoStart: boolean;
+    constructor(opts?: RuntimeClientOptions);
+    health(): Promise<Health>;
+    acquire(input: z.input<typeof AcquireRequest>): Promise<AcquireResponse>;
+    release(input: z.input<typeof ReleaseRequest>): Promise<void>;
+    renew(input: z.input<typeof RenewRequest>): Promise<void>;
+    proxyState(): Promise<ProxyState>;
+    proxyUpsert(input: z.input<typeof ProxyUpsertRequest>): Promise<ProxyState>;
+    proxyRemove(input: z.input<typeof ProxyRemoveRequest>): Promise<ProxyState>;
+    poolStatus(): Promise<PoolStatus>;
+}
+/** Default singleton client for casual callers. */
+declare const runtime: RuntimeClient;
+
+export { RuntimeClient, type RuntimeClientOptions, RuntimeRequestError, runtime };

package/dist/runtime/client/index.js

@@ -0,0 +1,281 @@
+// src/runtime/client/index.ts
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+import { dirname, resolve } from "path";
+import { existsSync, readFileSync } from "fs";
+
+// src/runtime/schema/identity.ts
+import { z } from "zod";
+var DevDomain = z.string().min(1).max(32).regex(/^[a-z][a-z0-9-]*$/, "devDomain must match /^[a-z][a-z0-9-]*$/").brand();
+var WorktreeName = z.string().min(1).max(64).regex(/^[a-z0-9][a-z0-9._-]*$/i, "worktree name must be URL-safe").brand();
+var Port = z.number().int().min(1024).max(65535).brand();
+var DevServerSlot = z.object({
+  devDomain: DevDomain,
+  worktree: WorktreeName
+});
+
+// src/runtime/schema/devserver.ts
+import { z as z2 } from "zod";
+var DevServerStatus = z2.enum([
+  "idle",
+  // pre-warmed in the hot pool, no project bound yet
+  "spawning",
+  // process started, waiting for `ready in …` from Vite stdout
+  "ready",
+  // bound to a slot, accepting traffic via Caddy
+  "draining",
+  // releasing — finishing in-flight requests before kill
+  "stopped"
+  // process exited, slot freed, port returned to the pool
+]);
+var DevServer = z2.object({
+  id: z2.string().uuid(),
+  pid: z2.number().int().positive(),
+  port: Port,
+  status: DevServerStatus,
+  slot: DevServerSlot.nullable(),
+  /** Absolute path of the worktree directory once bound; null while in the pool. */
+  cwd: z2.string().nullable(),
+  /** ISO timestamp; immutable after spawn. */
+  spawnedAt: z2.string().datetime(),
+  /** ISO timestamp of last status change. */
+  updatedAt: z2.string().datetime()
+});
+var Lease = z2.object({
+  id: z2.string().uuid(),
+  devServerId: z2.string().uuid(),
+  slot: DevServerSlot,
+  /** Public proxy URL the client should print to the user. Authoritative. */
+  url: z2.string().url(),
+  /** Renew before this timestamp or the lease expires and the devserver drains. */
+  expiresAt: z2.string().datetime()
+});
+var ProxyRoute = z2.object({
+  devDomain: DevDomain,
+  host: z2.string(),
+  /** worktree name → upstream port. `main` is the host's catch-all. */
+  upstreams: z2.record(z2.string(), Port)
+});
+
+// src/runtime/schema/api.ts
+import { z as z3 } from "zod";
+var AcquireRequest = z3.object({
+  slot: DevServerSlot,
+  /** Absolute path of the worktree directory; the runtime spawns Vite with `cwd: targetCwd`. */
+  targetCwd: z3.string().min(1),
+  /** Lease TTL in seconds. Defaults to 5 min; CLI clients renew on each command. */
+  ttlSeconds: z3.number().int().min(30).max(60 * 60).default(300),
+  /**
+   * Escape hatch for the deprecated default devDomain `"storyboard"`. CI and
+   * one-off scripts may pass true; the CLI never does.
+   */
+  allowDefaultDomain: z3.boolean().default(false)
+});
+var AcquireResponse = z3.object({
+  lease: Lease,
+  devServer: DevServer
+});
+var ReleaseRequest = z3.object({
+  leaseId: z3.string().uuid()
+});
+var RenewRequest = z3.object({
+  leaseId: z3.string().uuid(),
+  ttlSeconds: z3.number().int().min(30).max(60 * 60).default(300)
+});
+var ProxyState = z3.object({
+  routes: z3.array(ProxyRoute),
+  caddyReachable: z3.boolean()
+});
+var PoolStatus = z3.object({
+  warm: z3.number().int().nonnegative(),
+  bound: z3.number().int().nonnegative(),
+  capacity: z3.number().int().nonnegative()
+});
+var ProxyUpsertRequest = z3.object({
+  devDomain: z3.string(),
+  worktree: z3.string(),
+  port: z3.number()
+});
+var ProxyRemoveRequest = z3.object({
+  devDomain: z3.string(),
+  worktree: z3.string()
+});
+var Health = z3.object({
+  ok: z3.literal(true),
+  version: z3.string(),
+  uptimeSeconds: z3.number().nonnegative(),
+  port: Port
+});
+var RuntimeError = z3.object({
+  error: z3.string(),
+  code: z3.enum([
+    "NOT_IMPLEMENTED",
+    "BAD_REQUEST",
+    "CONFLICT",
+    "NOT_FOUND",
+    "FORBIDDEN_DEFAULT_DOMAIN",
+    "INTERNAL",
+    "CADDY_UNREACHABLE",
+    "PORT_EXHAUSTED",
+    "TIMEOUT"
+  ]),
+  details: z3.unknown().optional()
+});
+
+// src/runtime/client/index.ts
+var RUNTIME_BASE = "http://127.0.0.1:4321";
+var RuntimeRequestError = class extends Error {
+  constructor(message, status, code, details) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.details = details;
+    this.name = "RuntimeRequestError";
+  }
+};
+async function request(baseUrl, method, path, body, responseSchema) {
+  const init = {
+    method,
+    headers: body !== void 0 ? { "Content-Type": "application/json" } : void 0,
+    body: body !== void 0 ? JSON.stringify(body) : void 0
+  };
+  let res;
+  try {
+    res = await fetch(`${baseUrl}${path}`, init);
+  } catch (err) {
+    throw new RuntimeRequestError(
+      `Cannot reach Storyboard Runtime at ${baseUrl} \u2014 is the daemon running? (${err.message})`,
+      0,
+      "INTERNAL"
+    );
+  }
+  const text = await res.text();
+  let parsed;
+  try {
+    parsed = text ? JSON.parse(text) : {};
+  } catch {
+    parsed = { error: text, code: "INTERNAL" };
+  }
+  if (!res.ok) {
+    const err = RuntimeError.safeParse(parsed);
+    if (err.success) {
+      throw new RuntimeRequestError(err.data.error, res.status, err.data.code, err.data.details);
+    }
+    throw new RuntimeRequestError(`HTTP ${res.status}`, res.status, "INTERNAL", parsed);
+  }
+  if (responseSchema === null) return void 0;
+  return responseSchema.parse(parsed);
+}
+async function spawnDaemon(baseUrl) {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const binPath = resolve(here, "..", "..", "..", "bin", "storyboard-runtime.js");
+  const child = spawn(process.execPath, [binPath], {
+    detached: true,
+    stdio: "ignore",
+    env: process.env
+  });
+  child.unref();
+  const deadline = Date.now() + 5e3;
+  while (Date.now() < deadline) {
+    try {
+      const r = await fetch(`${baseUrl}/health`);
+      if (r.ok) return;
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  throw new Error(
+    `Storyboard Runtime did not become ready within 5s (tried to spawn ${binPath})`
+  );
+}
+function readClientVersion() {
+  try {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+      resolve(here, "..", "..", "..", "package.json"),
+      resolve(here, "..", "..", "package.json")
+    ];
+    for (const p of candidates) {
+      if (existsSync(p)) {
+        const pkg = JSON.parse(readFileSync(p, "utf8"));
+        if (typeof pkg.version === "string") return pkg.version;
+      }
+    }
+  } catch {
+  }
+  return "0.0.0";
+}
+var CLIENT_VERSION = readClientVersion();
+function killExistingDaemon() {
+  try {
+    const pidPath = resolve(process.env.HOME || "", ".storyboard", "runtime.pid");
+    if (!existsSync(pidPath)) return;
+    const pid = Number(readFileSync(pidPath, "utf8").trim());
+    if (Number.isFinite(pid) && pid > 0) {
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+var RuntimeClient = class {
+  baseUrl;
+  autoStart;
+  constructor(opts = {}) {
+    this.baseUrl = opts.baseUrl ?? RUNTIME_BASE;
+    this.autoStart = opts.autoStart !== false;
+  }
+  async health() {
+    try {
+      const result = await request(this.baseUrl, "GET", "/health", void 0, Health);
+      if (this.autoStart && CLIENT_VERSION !== "0.0.0" && result.version !== "0.0.0" && result.version !== CLIENT_VERSION) {
+        killExistingDaemon();
+        await new Promise((r) => setTimeout(r, 250));
+        await spawnDaemon(this.baseUrl);
+        return request(this.baseUrl, "GET", "/health", void 0, Health);
+      }
+      return result;
+    } catch (err) {
+      if (this.autoStart && err instanceof RuntimeRequestError && err.status === 0) {
+        await spawnDaemon(this.baseUrl);
+        return request(this.baseUrl, "GET", "/health", void 0, Health);
+      }
+      throw err;
+    }
+  }
+  async acquire(input) {
+    const body = AcquireRequest.parse(input);
+    return request(this.baseUrl, "POST", "/devserver/acquire", body, AcquireResponse);
+  }
+  async release(input) {
+    const body = ReleaseRequest.parse(input);
+    await request(this.baseUrl, "POST", "/devserver/release", body, null);
+  }
+  async renew(input) {
+    const body = RenewRequest.parse(input);
+    await request(this.baseUrl, "POST", "/devserver/renew", body, null);
+  }
+  async proxyState() {
+    return request(this.baseUrl, "GET", "/proxy/state", void 0, ProxyState);
+  }
+  async proxyUpsert(input) {
+    const body = ProxyUpsertRequest.parse(input);
+    return request(this.baseUrl, "POST", "/proxy/upsert", body, ProxyState);
+  }
+  async proxyRemove(input) {
+    const body = ProxyRemoveRequest.parse(input);
+    return request(this.baseUrl, "POST", "/proxy/remove", body, ProxyState);
+  }
+  async poolStatus() {
+    return request(this.baseUrl, "GET", "/pool/status", void 0, PoolStatus);
+  }
+};
+var runtime = new RuntimeClient();
+export {
+  RuntimeClient,
+  RuntimeRequestError,
+  runtime
+};
+//# sourceMappingURL=index.js.map