okengine 0.2.6 → 0.3.2

package/src/cli/ports.ts

@@ -48,13 +48,11 @@ export async function findFreePort(
     if (occupied.has(port)) continue;
     if (!(await probe(port))) return port;
   }
-  throw new Error(
-    `oke: no free port near ${preferred} after ${MAX_PORT_ATTEMPTS} attempts`,
-  );
+  throw new Error(`oke: no free port near ${preferred} after ${MAX_PORT_ATTEMPTS} attempts`);
 }
 
 /**
- * Resolve distinct free ports for app · Console · MCP (dev only).
+ * Resolve distinct free ports for app · Console · MCP · docs MCP (dev only).
  *
  * @param preferred - Preferred ports
  * @param probe - Injectable busy check (tests)
@@ -64,12 +62,14 @@ export async function resolveDevPorts(
     readonly app: number;
     readonly console: number;
     readonly mcp: number;
+    readonly docsMcp: number;
   },
   probe: (port: number) => Promise<boolean> = isPortInUse,
 ): Promise<{
   readonly app: number;
   readonly console: number;
   readonly mcp: number;
+  readonly docsMcp: number;
 }> {
   const occupied = new Set<number>();
   const app = await findFreePort(preferred.app, occupied, probe);
@@ -77,5 +77,7 @@ export async function resolveDevPorts(
   const consolePort = await findFreePort(preferred.console, occupied, probe);
   if (consolePort !== 0) occupied.add(consolePort);
   const mcp = await findFreePort(preferred.mcp, occupied, probe);
-  return { app, console: consolePort, mcp };
+  if (mcp !== 0) occupied.add(mcp);
+  const docsMcp = await findFreePort(preferred.docsMcp, occupied, probe);
+  return { app, console: consolePort, mcp, docsMcp };
 }

package/src/cli/privacy-erase.ts

@@ -24,9 +24,7 @@ export interface RunPrivacyEraseOptions {
  *
  * @param options - Subject + vault
  */
-export function runPrivacyErase(
-  options: RunPrivacyEraseOptions,
-): PrivacyEraseResult {
+export function runPrivacyErase(options: RunPrivacyEraseOptions): PrivacyEraseResult {
   const keys = options.subjectKeys ?? createMemorySubjectKeys();
   return privacyErase({
     subjectId: options.subjectId,

package/src/cli/registry.ts

@@ -6,7 +6,7 @@
 
 /** One CLI flag (long form is canonical; short is convenience only). */
 export interface CliFlag {
-  /** Canonical long form including leading dashes (e.g. `--stack`). */
+  /** Canonical long form including leading dashes (e.g. `--docker`). */
   readonly long: string;
   /** Optional short form including leading dash (e.g. `-s`). */
   readonly short?: string;
@@ -97,16 +97,31 @@ export const OKE_COMMANDS: readonly CliCommand[] = [
     leaf: true,
     flags: [
       {
-        long: "--stack",
-        short: "-s",
+        long: "--local",
+        short: "-l",
+        summary: "Session-only local mode (in-memory; no compose)",
+      },
+      {
+        long: "--docker",
+        short: "-d",
         takesValue: true,
         valueName: "roles",
-        summary: "Boot generated compose (optional role list)",
+        summary: "Session-only docker compose (optional role list)",
+      },
+      {
+        long: "--no-db-push",
+        summary: "Disable auto `oke db push` on schema change (local)",
       },
       ENTRY,
       HELP,
     ],
   },
+  {
+    name: "mode",
+    summary: "get/set default oke dev mode (local|docker)",
+    leaf: true,
+    flags: [HELP],
+  },
   {
     name: "start",
     summary: "production entry (Docker CMD)",
@@ -125,7 +140,7 @@ export const OKE_COMMANDS: readonly CliCommand[] = [
   },
   {
     name: "doctor",
-    summary: "secrets · ports · schema drift",
+    summary: "secrets · ports · stub/domain schema drift",
     leaf: true,
     flags: [
       MANIFEST,
@@ -185,6 +200,54 @@ export const OKE_COMMANDS: readonly CliCommand[] = [
       },
     ],
   },
+  {
+    name: "db",
+    summary: "domain schema — push · generate · migrate",
+    subcommands: [
+      {
+        name: "push",
+        summary: "Sync schema.ts to the live local DB (dev)",
+        flags: [
+          {
+            long: "--config",
+            short: "-c",
+            takesValue: true,
+            valueName: "path",
+            summary: "drizzle.config.ts path",
+          },
+          HELP,
+        ],
+      },
+      {
+        name: "generate",
+        summary: "Write versioned SQL under drizzle/",
+        flags: [
+          {
+            long: "--config",
+            short: "-c",
+            takesValue: true,
+            valueName: "path",
+            summary: "drizzle.config.ts path",
+          },
+          HELP,
+        ],
+      },
+      {
+        name: "migrate",
+        summary: "Apply generated migrations (explicit)",
+        flags: [
+          {
+            long: "--config",
+            short: "-c",
+            takesValue: true,
+            valueName: "path",
+            summary: "drizzle.config.ts path",
+          },
+          HELP,
+        ],
+      },
+    ],
+  },
   {
     name: "client",
     summary: "ambient types for a separate frontend repo",
@@ -358,18 +421,12 @@ export const OKE_COMMANDS: readonly CliCommand[] = [
  * @returns Help text (no trailing exit-code block)
  */
 export function formatOkeHelp(): string {
-  const lines = [
-    "oke — okengine CLI",
-    "",
-    "Commands:",
-  ];
+  const lines = ["oke — okengine CLI", "", "Commands:"];
   for (const cmd of OKE_COMMANDS) {
     const usage = formatCommandUsage(cmd);
     lines.push(`  ${pad(usage, 34)} ${cmd.summary}`);
     if (cmd.name === "doctor") {
-      lines.push(
-        `  ${pad("oke doctor --diff|-d", 34)} CI gate: undeclared contract breaks`,
-      );
+      lines.push(`  ${pad("oke doctor --diff|-d", 34)} CI gate: undeclared contract breaks`);
     }
   }
   lines.push("");
@@ -379,9 +436,7 @@ export function formatOkeHelp(): string {
 /**
  * Collect every top-level command name (for completion / tests).
  */
-export function commandNames(
-  commands: readonly CliCommand[] = OKE_COMMANDS,
-): readonly string[] {
+export function commandNames(commands: readonly CliCommand[] = OKE_COMMANDS): readonly string[] {
   return commands.map((c) => c.name);
 }
 
@@ -391,10 +446,7 @@ export function commandNames(
  * @param command - Top-level command
  * @param sub - Optional subcommand name
  */
-export function flagTokensFor(
-  command: CliCommand,
-  sub?: string,
-): readonly string[] {
+export function flagTokensFor(command: CliCommand, sub?: string): readonly string[] {
   const flags = sub
     ? (command.subcommands?.find((s) => s.name === sub)?.flags ?? [])
     : (command.flags ?? []);
@@ -420,9 +472,7 @@ function formatCommandUsage(cmd: CliCommand): string {
   if (cmd.subcommands && cmd.subcommands.length > 1) {
     const subs = cmd.subcommands.map((s) => s.name).join("|");
     // Prefer shared JSON flag hint when every list-like sub supports it.
-    const jsonHint = cmd.subcommands.some((s) =>
-      s.flags?.some((f) => f.long === "--json"),
-    )
+    const jsonHint = cmd.subcommands.some((s) => s.flags?.some((f) => f.long === "--json"))
       ? " [--json|-j]"
       : "";
     return `oke ${cmd.name} ${subs}${jsonHint}`;
@@ -439,8 +489,8 @@ function formatCommandUsage(cmd: CliCommand): string {
 function formatFlagHint(f: CliFlag): string {
   const name = f.short ? `${f.long}|${f.short}` : f.long;
   if (f.takesValue) {
-    // Optional value (e.g. --stack [roles]) when valueName is roles-like.
-    if (f.long === "--stack") return `[${name} [${f.valueName}]]`;
+    // Optional value (e.g. --docker [roles]) when valueName is roles-like.
+    if (f.long === "--docker") return `[${name} [${f.valueName}]]`;
     return `[${name} ${f.valueName}]`;
   }
   return `[${name}]`;

package/src/cli/resolve-dev-sql-env.test.ts

@@ -0,0 +1,48 @@
+/**
+ * Active SQL env resolution from `.oke/mode` / session overrides.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { writeDevMode } from "./dev-mode.ts";
+import { resolveDevSqlEnv } from "./resolve-dev-sql-env.ts";
+
+const dirs: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(dirs.splice(0).map((d) => rm(d, { recursive: true, force: true })));
+});
+
+async function tempDir(): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), "oke-sqlenv-"));
+  dirs.push(dir);
+  return dir;
+}
+
+describe("resolveDevSqlEnv", () => {
+  test("defaults to local when nothing set", async () => {
+    const dir = await tempDir();
+    expect(await resolveDevSqlEnv(dir)).toBe("local");
+  });
+
+  test("explicit env override wins", async () => {
+    const dir = await tempDir();
+    await writeDevMode(dir, "local");
+    expect(await resolveDevSqlEnv(dir, { env: "docker" })).toBe("docker");
+  });
+
+  test("session docker flag wins over saved mode", async () => {
+    const dir = await tempDir();
+    await writeDevMode(dir, "local");
+    expect(await resolveDevSqlEnv(dir, { docker: true })).toBe("docker");
+    expect(await resolveDevSqlEnv(dir, { docker: false })).toBe("local");
+  });
+
+  test("reads saved .oke/mode", async () => {
+    const dir = await tempDir();
+    await writeDevMode(dir, "docker");
+    expect(await resolveDevSqlEnv(dir)).toBe("docker");
+  });
+});

package/src/cli/resolve-dev-sql-env.ts

@@ -0,0 +1,42 @@
+/**
+ * Resolve the active SQL env for schema tooling (`oke db`, `oke mode`,
+ * `oke dev` one-shot sync) from session overrides and the saved dev mode.
+ */
+
+import type { ConfigEnv } from "../config/index.ts";
+import { readDevMode } from "./dev-mode.ts";
+
+/** Options for {@link resolveDevSqlEnv}. */
+export interface ResolveDevSqlEnvOptions {
+  /**
+   * Session override — `true` means docker (e.g. `OKE_DOCKER=1` or
+   * `oke dev --docker`). `false` means local. `undefined` → auto-resolve.
+   */
+  readonly docker?: boolean;
+  /**
+   * Explicit env override (e.g. `oke db --env docker`). Wins over `.oke/mode`.
+   */
+  readonly env?: ConfigEnv;
+}
+
+/**
+ * Resolve the SQL env (`local` | `docker` for dev tooling) without prompting.
+ *
+ * Order:
+ * 1. Explicit `options.env` (CLI flag)
+ * 2. Session docker flag (`options.docker`)
+ * 3. `.oke/mode` persisted preference
+ * 4. Default `local`
+ *
+ * @param cwd - Project root
+ * @param options - Session / CLI overrides
+ */
+export async function resolveDevSqlEnv(
+  cwd: string,
+  options: ResolveDevSqlEnvOptions = {},
+): Promise<ConfigEnv> {
+  if (options.env !== undefined) return options.env;
+  if (options.docker !== undefined) return options.docker ? "docker" : "local";
+  const saved = await readDevMode(cwd);
+  return saved ?? "local";
+}

package/src/cli/schema.ts

@@ -32,9 +32,7 @@ export interface SchemaGenerateOptions {
  *
  * @param options - Manifest / check flag
  */
-export async function runSchemaGenerate(
-  options: SchemaGenerateOptions = {},
-): Promise<number> {
+export async function runSchemaGenerate(options: SchemaGenerateOptions = {}): Promise<number> {
   const write = options.write ?? ((t) => process.stdout.write(t));
   const cwd = options.cwd ?? process.cwd();
   let manifest = options.manifest;
@@ -92,10 +90,7 @@ export async function runSchemaGenerate(
  * @param cwd - Project root
  * @param manifest - Optional manifest
  */
-export async function schemaFingerprint(
-  cwd: string,
-  manifest?: Manifest,
-): Promise<string> {
+export async function schemaFingerprint(cwd: string, manifest?: Manifest): Promise<string> {
   const tables = new Set<string>([
     "oke_roles",
     "oke_role_grants",
@@ -123,9 +118,7 @@ export async function schemaFingerprint(
  *
  * @param cwd - Project root
  */
-export async function readSchemaFingerprint(
-  cwd: string,
-): Promise<string | null> {
+export async function readSchemaFingerprint(cwd: string): Promise<string | null> {
   const fpFile = Bun.file(resolve(cwd, SCHEMA_FINGERPRINT_FILE));
   if (await fpFile.exists()) {
     return (await fpFile.text()).trim();

package/src/cli/stack.ts

@@ -2,7 +2,7 @@
  * `oke stack` — preview resolved images/tags/ports (writes nothing).
  */
 
-import { formatStackPreview, resolveStack } from "../docker/index.ts";
+import { formatStackPreview, resolveStack, stackInstanceId } from "../docker/index.ts";
 import { wantsJson } from "./args.ts";
 import { EXIT_OK, EXIT_RUNTIME } from "./exit.ts";
 import { loadOkeConfig, resolveImages } from "./load-config.ts";
@@ -22,19 +22,15 @@ export interface StackCliOptions {
  *
  * @param options - Config / images
  */
-export async function runStackPreview(
-  options: StackCliOptions = {},
-): Promise<number> {
+export async function runStackPreview(options: StackCliOptions = {}): Promise<number> {
   const write = options.write ?? ((t) => process.stdout.write(t));
   const writeErr = options.writeErr ?? ((t) => process.stderr.write(t));
   const json = options.json ?? false;
+  const cwd = options.cwd ?? process.cwd();
   let images = options.images;
   if (!images) {
     try {
-      const loaded = await loadOkeConfig(
-        options.cwd ?? process.cwd(),
-        options.configPath,
-      );
+      const loaded = await loadOkeConfig(cwd, options.configPath);
       images = resolveImages(loaded.config);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -46,7 +42,8 @@ export async function runStackPreview(
       return EXIT_RUNTIME;
     }
   }
-  const rows = resolveStack({ images });
+  // Match `oke dev --docker` host ports (stable per-project offsets).
+  const rows = resolveStack({ images, instanceId: stackInstanceId(cwd) });
   if (json) {
     write(`${JSON.stringify({ ok: true, rows }, null, 2)}\n`);
     if (rows.length === 0) {
@@ -72,7 +69,8 @@ export async function stackCli(args: readonly string[]): Promise<number> {
     else if (a === "--help" || a === "-h") {
       console.log(`oke stack [--config|-c oke.config.ts] [--json|-j]
 
-Preview resolved images, recipes, and ports. Writes nothing.
+Preview resolved images, recipes, and ports (same per-project host ports as
+oke dev --docker). Writes nothing.
 --json  Machine-parseable JSON on stdout; hints on stderr.
 `);
       return EXIT_OK;

package/src/cli/start.ts

@@ -17,10 +17,7 @@ export interface StartOptions {
    * @param entry - Absolute entry path
    * @param env - Process env overlay
    */
-  readonly runEntry?: (
-    entry: string,
-    env: Record<string, string>,
-  ) => Promise<void>;
+  readonly runEntry?: (entry: string, env: Record<string, string>) => Promise<void>;
 }
 
 /**
@@ -29,10 +26,7 @@ export interface StartOptions {
  * @param cwd - Project root
  * @param explicit - Optional `--entry`
  */
-export async function resolveStartEntry(
-  cwd: string,
-  explicit?: string,
-): Promise<string> {
+export async function resolveStartEntry(cwd: string, explicit?: string): Promise<string> {
   if (explicit) return resolve(cwd, explicit);
   const pkgPath = resolve(cwd, "package.json");
   if (await Bun.file(pkgPath).exists()) {
@@ -47,9 +41,7 @@ export async function resolveStartEntry(
     const path = resolve(cwd, candidate);
     if (await Bun.file(path).exists()) return path;
   }
-  throw new Error(
-    "oke start: no entry found — set package.json okengine.entry or pass --entry",
-  );
+  throw new Error("oke start: no entry found — set package.json okengine.entry or pass --entry");
 }
 
 /**
@@ -63,10 +55,7 @@ export async function runStart(options: StartOptions = {}): Promise<number> {
   try {
     const entry = await resolveStartEntry(cwd, options.entry);
     const port = String(options.port ?? Number(Bun.env.PORT ?? APP_PORT));
-    const env = { ...process.env, NODE_ENV: "production", PORT: port } as Record<
-      string,
-      string
-    >;
+    const env = { ...process.env, NODE_ENV: "production", PORT: port } as Record<string, string>;
     write(`oke start: ${entry} (port ${port})\n`);
     if (options.runEntry) {
       await options.runEntry(entry, env);

package/src/cli/upgrade.ts

@@ -2,10 +2,7 @@
  * `oke upgrade` — run codemods for a breaking change, print the diff.
  */
 
-import {
-  runCodemods,
-  type CodemodChange,
-} from "../upgrade/codemods.ts";
+import { runCodemods, type CodemodChange } from "../upgrade/codemods.ts";
 
 /** One file rewrite produced by a codemod. */
 export type UpgradeChange = CodemodChange;

package/src/cli/vault-cmd.ts

@@ -2,9 +2,43 @@
  * `oke vault` — set · list · import · key rotate.
  */
 
+import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { parseDotenv, formatDotenv } from "../drivers/vault-dotenv-parse.ts";
 
+/** Resolved OpenBao target for direct API writes (docker / prod vault). */
+interface OpenBaoTarget {
+  readonly url: string;
+  readonly token: string;
+  readonly mount: string;
+}
+
+/**
+ * Resolve a live OpenBao target when the active vault is OpenBao.
+ *
+ * Sources, in order: `OKE_VAULT_*` env · persisted `.oke/openbao/` host
+ * material + `docker/.env.docker` URL. Returns `null` when neither resolves
+ * (local dotenv loop) so `oke vault set` keeps the file path.
+ *
+ * @param cwd - Project root
+ */
+export async function resolveOpenBaoTarget(cwd: string): Promise<OpenBaoTarget | null> {
+  const mount = process.env.OKE_VAULT_MOUNT ?? "secret";
+  const envUrl = process.env.OKE_VAULT_URL;
+  const envToken = process.env.OKE_VAULT_TOKEN;
+  if (envUrl && envToken) {
+    return { url: envUrl.replace(/\/$/, ""), token: envToken, mount };
+  }
+  const appTokenPath = resolve(cwd, ".oke/openbao/app.token");
+  const composeEnvPath = resolve(cwd, "docker/.env.docker");
+  if (!existsSync(appTokenPath) || !existsSync(composeEnvPath)) return null;
+  const envFile = parseDotenv(readFileSync(composeEnvPath, "utf8"));
+  const url = envFile.get("OKE_VAULT_URL");
+  const token = readFileSync(appTokenPath, "utf8").trim();
+  if (!url || !token) return null;
+  return { url: url.replace(/\/$/, ""), token, mount };
+}
+
 /** In-memory / file-backed vault bag for CLI (dotenv-shaped). */
 export interface VaultCliStore {
   get(name: string): string | undefined;
@@ -78,6 +112,35 @@ oke vault key rotate
       console.error("Usage: oke vault set <NAME> [value]");
       return 1;
     }
+    const ob = await resolveOpenBaoTarget(cwd);
+    if (ob && !options.store && !options.envFile) {
+      let value = rest[1];
+      if (value === undefined) {
+        const read =
+          options.readLine ??
+          (async () => {
+            write(`Enter value for ${name}: `);
+            const chunks: Buffer[] = [];
+            for await (const chunk of Bun.stdin.stream()) {
+              chunks.push(Buffer.from(chunk));
+              if (Buffer.concat(chunks).includes(0x0a)) break;
+            }
+            return Buffer.concat(chunks).toString("utf8").trim();
+          });
+        value = await read(`Enter value for ${name}: `);
+      }
+      const res = await fetch(`${ob.url}/v1/${ob.mount}/data/${encodeURIComponent(name)}`, {
+        method: "POST",
+        headers: { "X-Vault-Token": ob.token, "content-type": "application/json" },
+        body: JSON.stringify({ data: { value } }),
+      });
+      if (!res.ok) {
+        console.error(`oke vault: OpenBao write failed (${res.status}) — sealed / unauthorized?`);
+        return 1;
+      }
+      write(`oke vault: set ${name} (openbao)\n`);
+      return 0;
+    }
     let value = rest[1];
     if (value === undefined) {
       const read =

package/src/client/budget-entry.ts

@@ -4,12 +4,7 @@
  */
 
 import { createClient } from "./create.ts";
-import {
-  isErrorCode,
-  isFail,
-  isOk,
-  isTransportError,
-} from "./errors.ts";
+import { isErrorCode, isFail, isOk, isTransportError } from "./errors.ts";
 import { createTransport } from "./transport.ts";
 
 /**

package/src/client/create.test.ts

@@ -26,10 +26,7 @@ type BookingsApp = AppOf<{
 }>;
 
 /** Compile-time equality. */
-type Eq<A, B> =
-  (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2
-    ? true
-    : false;
+type Eq<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
 type Assert<T extends true> = T;
 
 describe("createClient — same-repo <App>", () => {
@@ -73,9 +70,7 @@ describe("createClient — same-repo <App>", () => {
     if (error?.code === "FlightFull") {
       // Runtime + type-level: seatsLeft is number, not unknown.
       expect(error.data.seatsLeft).toBe(2);
-      type _Narrow = Assert<
-        Eq<typeof error.data, { seatsLeft: number }>
-      >;
+      type _Narrow = Assert<Eq<typeof error.data, { seatsLeft: number }>>;
       const _keep: _Narrow = true;
       expect(_keep).toBe(true);
     } else {
@@ -135,11 +130,10 @@ describe("createClient — type helpers", () => {
     const ok: _Codes = true;
     expect(ok).toBe(true);
 
-    const sample: ClientResult<{ id: string }, { FlightFull: { seatsLeft: number } }> =
-      {
-        data: null,
-        error: { code: "FlightFull", data: { seatsLeft: 0 } },
-      };
+    const sample: ClientResult<{ id: string }, { FlightFull: { seatsLeft: number } }> = {
+      data: null,
+      error: { code: "FlightFull", data: { seatsLeft: 0 } },
+    };
     if (sample.error?.code === "FlightFull") {
       type _D = Assert<Eq<typeof sample.error.data, { seatsLeft: number }>>;
       const d: _D = true;

package/src/client/create.ts

@@ -13,12 +13,7 @@
  */
 
 import { createTransport, type Transport } from "./transport.ts";
-import type {
-  Client,
-  ClientOptions,
-  ClientRouteMap,
-  ResolveApp,
-} from "./types.ts";
+import type { Client, ClientOptions, ClientRouteMap, ResolveApp } from "./types.ts";
 
 /** App-shaped value that carries a runtime `$routes` table from typed adopt. */
 export interface AppWithRoutes {
@@ -98,8 +93,7 @@ export function flattenRoutes(
   $routes: ClientRouteMap | undefined,
 ): ClientOptions["routes"] | undefined {
   if (!$routes) return undefined;
-  const out: Record<string, { readonly method: string; readonly path: string }> =
-    {};
+  const out: Record<string, { readonly method: string; readonly path: string }> = {};
   for (const [unit, flows] of Object.entries($routes)) {
     if (!flows || typeof flows !== "object") continue;
     for (const [flow, contract] of Object.entries(flows)) {

package/src/client/errors.ts

@@ -30,10 +30,7 @@ export function isTransportError(
 export function isErrorCode<
   Err extends { readonly code: string; readonly data: unknown },
   C extends Err["code"],
->(
-  error: Err | null | undefined,
-  code: C,
-): error is Extract<Err, { readonly code: C }> {
+>(error: Err | null | undefined, code: C): error is Extract<Err, { readonly code: C }> {
   return error != null && error.code === code;
 }
 

package/src/client/index.ts

@@ -7,12 +7,7 @@
 
 export { createClient, flattenRoutes } from "./create.ts";
 export type { AppWithRoutes } from "./create.ts";
-export {
-  isErrorCode,
-  isFail,
-  isOk,
-  isTransportError,
-} from "./errors.ts";
+export { isErrorCode, isFail, isOk, isTransportError } from "./errors.ts";
 export { createTransport } from "./transport.ts";
 export type { Transport } from "./transport.ts";
 export type {