okengine 0.10.3 → 0.11.1

package/src/kernel/boot-bind/clock.ts

@@ -79,8 +79,8 @@ export async function bindClock(
     const url = process.env.DATABASE_URL ?? process.env.OKE_STORE_SQL_URL ?? undefined;
     if (!url) {
       throw new Error(
-        env === "docker"
-          ? 'oke boot: clock driver "postgres" needs DATABASE_URL (did `oke dev -d` write docker/.env.docker?)'
+        env === "dev"
+          ? 'oke boot: clock driver "postgres" needs DATABASE_URL (did `oke dev` write docker/.env.docker?)'
           : 'oke boot: clock driver "postgres" needs DATABASE_URL',
       );
     }

package/src/kernel/boot-bind/gate.ts

@@ -3,7 +3,7 @@
  */
 
 import { resolveDriverId, type ConfigEnv } from "../../config/index.ts";
-import { dockerFlagDefaults, STORE_KV_DEFAULTS } from "../../config/driver-defaults.ts";
+import { STORE_KV_DEFAULTS } from "../../config/driver-defaults.ts";
 import { memoryDrivers } from "../../drivers/memory.ts";
 import { redisDriver } from "../../drivers/redis.ts";
 import type { KvClientLike } from "../../drivers/types.ts";
@@ -28,11 +28,7 @@ export function resolveGateKvDriverId(
   const fromEnv = process.env.OKE_KV_DRIVER?.trim();
   if (docker && fromEnv === "redis") return "redis";
   if (docker && fromEnv === "memory") return "memory";
-  const resolved = resolveDriverId(
-    options.config?.drivers?.store?.kv,
-    env,
-    dockerFlagDefaults(STORE_KV_DEFAULTS, docker),
-  );
+  const resolved = resolveDriverId(options.config?.drivers?.store?.kv, env, STORE_KV_DEFAULTS);
   return resolved === "redis" ? "redis" : "memory";
 }
 
@@ -41,8 +37,8 @@ function kvUrlFor(docker: boolean): string {
   if (!url) {
     throw new Error(
       docker
-        ? "oke boot: gate redis kv needs REDIS_URL (did `oke dev -d` write docker/.env.docker?)"
-        : "oke boot: gate redis kv needs REDIS_URL — declare drivers.store.kv memory for local, or set REDIS_URL",
+        ? "oke boot: gate redis kv needs REDIS_URL (did `oke dev` write docker/.env.docker?)"
+        : "oke boot: gate redis kv needs REDIS_URL — declare drivers.store.kv memory for test, or set REDIS_URL",
     );
   }
   return url;
@@ -59,7 +55,7 @@ function kvUrlFor(docker: boolean): string {
 export async function bindGate(
   options: BootOptions,
   now: () => number,
-  env: ConfigEnv = "local",
+  env: ConfigEnv = "test",
   docker = false,
 ): Promise<GateRuntime> {
   const kvId = resolveGateKvDriverId(options, env, docker);

package/src/kernel/boot-bind/honor-config.test.ts

@@ -37,11 +37,11 @@ describe("boot binders honour drivers.* config", () => {
     process.env.APP_NAME = "honor-config";
     try {
       const result = await bootApplication({
-        env: "local",
+        env: "test",
         secrets: [vault.config("APP_NAME", { description: "app" })],
         config: {
           drivers: {
-            vault: { local: "env", docker: "openbao", test: "memory", prod: "openbao" },
+            vault: { test: "env" },
           },
         },
       });
@@ -58,21 +58,17 @@ describe("boot binders honour drivers.* config", () => {
     }
   });
 
-  test("vault: drivers.vault openbao with credentials selects openbao layer", () => {
-    process.env.OKE_VAULT_URL = "http://127.0.0.1:8200";
-    process.env.OKE_VAULT_TOKEN = "test-token";
+  test("vault: drivers.vault vault selects built-in layer behind env", () => {
     const chain = buildVaultBootChain({
-      driverId: "openbao",
-      env: "local",
-      missingOpenbao: "throw",
+      driverId: "vault",
+      env: "test",
     });
-    expect(chain.map((l) => l.driver.id)).toContain("openbao");
+    expect(chain.map((l) => l.driver.id)).toContain("vault");
     expect(chain.map((l) => l.driver.id)).toContain("env");
   });
 
-  test("vault: openbao without credentials fails loud in prod", async () => {
-    delete process.env.OKE_VAULT_URL;
-    delete process.env.OKE_VAULT_TOKEN;
+  test("vault: unknown driver id fails loud at boot", async () => {
+    const removed = ["open", "bao"].join("");
     await expect(
       bootApplication({
         env: "prod",
@@ -80,21 +76,23 @@ describe("boot binders honour drivers.* config", () => {
         vault: { allowDevFallbacks: true },
         config: {
           drivers: {
-            vault: { prod: "openbao" },
+            vault: { prod: removed },
           },
         },
       }),
-    ).rejects.toThrow(/openbao.*OKE_VAULT_URL/);
+    ).rejects.toThrow(/unknown vault driver/);
   });
 
   test("clock: drivers.clock memory binds memory CronStore", async () => {
+    // `test` env always forces frozen — pin under `dev` to honour memory.
     const result = await bootApplication({
-      env: "local",
+      env: "dev",
       startScheduler: false,
       clocks: [clock("tick", { every: "1h" })],
       config: {
         drivers: {
-          clock: { local: "memory", docker: "file", test: "frozen", prod: "file" },
+          clock: { dev: "memory" },
+          store: { sql: { dev: "memory" }, kv: { dev: "memory" } },
         },
       },
     });
@@ -110,12 +108,13 @@ describe("boot binders honour drivers.* config", () => {
     tmp = await mkdtemp(join(tmpdir(), "oke-clock-file-"));
     process.chdir(tmp);
     const result = await bootApplication({
-      env: "local",
+      env: "dev",
       startScheduler: false,
       clocks: [clock("tick", { every: "1h" })],
       config: {
         drivers: {
-          clock: { local: "file", docker: "file", test: "frozen", prod: "file" },
+          clock: { dev: "file" },
+          store: { sql: { dev: "memory" }, kv: { dev: "memory" } },
         },
       },
     });
@@ -135,12 +134,13 @@ describe("boot binders honour drivers.* config", () => {
     try {
       await expect(
         bootApplication({
-          env: "local",
+          env: "dev",
           startScheduler: false,
           clocks: [clock("tick", { every: "1h" })],
           config: {
             drivers: {
-              clock: { local: "postgres" },
+              clock: { dev: "postgres" },
+              store: { sql: { dev: "memory" }, kv: { dev: "memory" } },
             },
           },
         }),
@@ -155,7 +155,7 @@ describe("boot binders honour drivers.* config", () => {
 
   test("journal: durable flow binds memory journal by default", async () => {
     const result = await bootApplication({
-      env: "local",
+      env: "test",
       startScheduler: false,
       flows: [flow("charge", { durable: true, do: () => ({ ok: true }) })],
     });
@@ -170,7 +170,7 @@ describe("boot binders honour drivers.* config", () => {
 
   test("journal: no durable flow → no journal runtime", async () => {
     const result = await bootApplication({
-      env: "local",
+      env: "test",
       startScheduler: false,
       flows: [flow("plain", { do: () => ({ ok: true }) })],
     });
@@ -185,12 +185,12 @@ describe("boot binders honour drivers.* config", () => {
     tmp = await mkdtemp(join(tmpdir(), "oke-journal-file-"));
     process.chdir(tmp);
     const result = await bootApplication({
-      env: "local",
+      env: "test",
       startScheduler: false,
       flows: [flow("charge", { durable: true, do: () => ({ ok: true }) })],
       config: {
         drivers: {
-          journal: { local: "file", docker: "postgres", test: "memory", prod: "postgres" },
+          journal: { test: "file" },
         },
       },
     });
@@ -209,12 +209,12 @@ describe("boot binders honour drivers.* config", () => {
     try {
       await expect(
         bootApplication({
-          env: "local",
+          env: "test",
           startScheduler: false,
           flows: [flow("charge", { durable: true, do: () => ({ ok: true }) })],
           config: {
             drivers: {
-              journal: { local: "postgres" },
+              journal: { test: "postgres" },
             },
           },
         }),
@@ -230,12 +230,12 @@ describe("boot binders honour drivers.* config", () => {
   test("journal: unknown driver fails loud", async () => {
     await expect(
       bootApplication({
-        env: "local",
+        env: "test",
         startScheduler: false,
         flows: [flow("charge", { durable: true, do: () => ({ ok: true }) })],
         config: {
           drivers: {
-            journal: { local: "neon" },
+            journal: { test: "neon" },
           },
         },
       }),
@@ -245,13 +245,13 @@ describe("boot binders honour drivers.* config", () => {
   test("gate: drivers.store.kv redis opens redis-backed oke:gates", async () => {
     const fake = createRedisFakeClient();
     const result = await bootApplication({
-      env: "local",
+      env: "test",
       gates: [gate.rate({ max: 10, per: "1m" })],
       clients: { kv: fake },
       config: {
         drivers: {
           store: {
-            kv: { local: "redis", docker: "redis", prod: "redis" },
+            kv: { test: "redis", dev: "redis", prod: "redis" },
           },
         },
       },
@@ -268,12 +268,12 @@ describe("boot binders honour drivers.* config", () => {
     delete process.env.OKE_STORE_KV_URL;
     await expect(
       bootApplication({
-        env: "local",
+        env: "test",
         gates: [gate.rate({ max: 10, per: "1m" })],
         config: {
           drivers: {
             store: {
-              kv: { local: "redis", docker: "redis", prod: "redis" },
+              kv: { test: "redis", dev: "redis", prod: "redis" },
             },
           },
         },
@@ -283,12 +283,12 @@ describe("boot binders honour drivers.* config", () => {
 
   test("gate: drivers.store.kv memory keeps memory oke:gates", async () => {
     const result = await bootApplication({
-      env: "local",
+      env: "test",
       gates: [gate.rate({ max: 10, per: "1m" })],
       config: {
         drivers: {
           store: {
-            kv: { local: "memory", docker: "redis", prod: "redis" },
+            kv: { dev: "redis", test: "memory", prod: "redis" },
           },
         },
       },
@@ -302,11 +302,11 @@ describe("boot binders honour drivers.* config", () => {
 
   test("signal: drivers.signal memory binds memory", async () => {
     const result = await bootApplication({
-      env: "local",
+      env: "test",
       signals: [signal("ping", { delivery: "once" })],
       config: {
         drivers: {
-          signal: { local: "memory", docker: "redis", prod: "redis" },
+          signal: { dev: "redis", test: "memory", prod: "redis" },
         },
       },
     });
@@ -320,12 +320,12 @@ describe("boot binders honour drivers.* config", () => {
   test("signal: drivers.signal redis binds redis", async () => {
     const fake = createSignalRedisFake();
     const result = await bootApplication({
-      env: "local",
+      env: "test",
       signals: [signal("ping", { delivery: "once" })],
       clients: { signalRedis: fake },
       config: {
         drivers: {
-          signal: { local: "redis", docker: "redis", prod: "redis" },
+          signal: { test: "redis", dev: "redis", prod: "redis" },
         },
       },
     });
@@ -339,11 +339,11 @@ describe("boot binders honour drivers.* config", () => {
   test("signal: drivers.signal postgres fails loud (never silent memory)", async () => {
     await expect(
       bootApplication({
-        env: "local",
+        env: "test",
         signals: [signal("ping", { delivery: "once" })],
         config: {
           drivers: {
-            signal: { local: "postgres" },
+            signal: { test: "postgres" },
           },
         },
       }),
@@ -353,11 +353,11 @@ describe("boot binders honour drivers.* config", () => {
   test("signal: drivers.signal nats fails loud", async () => {
     await expect(
       bootApplication({
-        env: "local",
+        env: "test",
         signals: [signal("ping", { delivery: "once" })],
         config: {
           drivers: {
-            signal: { local: "nats" },
+            signal: { test: "nats" },
           },
         },
       }),

package/src/kernel/boot-bind/journal.ts

@@ -66,8 +66,8 @@ export async function bindJournal(
     const url = process.env.DATABASE_URL ?? process.env.OKE_STORE_SQL_URL ?? undefined;
     if (!url) {
       throw new Error(
-        env === "docker"
-          ? 'oke boot: journal driver "postgres" needs DATABASE_URL (did `oke dev -d` write docker/.env.docker?)'
+        env === "dev"
+          ? 'oke boot: journal driver "postgres" needs DATABASE_URL (did `oke dev` write docker/.env.docker?)'
           : 'oke boot: journal driver "postgres" needs DATABASE_URL',
       );
     }

package/src/kernel/boot-bind/store.test.ts

@@ -36,66 +36,65 @@ describe("bindStore driver resolution", () => {
     else process.env.OKE_INDEX_DRIVER = prev.index;
   });
 
-  test("local env keeps sqlite / memory from config", () => {
+  test("test env keeps pglite / memory / fs from config", () => {
     const options = {
       config: {
         drivers: {
           store: {
-            sql: { local: "sqlite", docker: "postgres", prod: "postgres" },
-            kv: { local: "memory", docker: "redis", prod: "redis" },
-            files: { local: "fs", docker: "s3", prod: "s3" },
+            sql: { dev: "postgres", test: "pglite", prod: "postgres" },
+            kv: { dev: "redis", test: "memory", prod: "redis" },
+            files: { dev: "s3", test: "fs", prod: "s3" },
           },
         },
       },
     };
-    expect(resolveSqlDriverId(options, "local", false)).toBe("sqlite");
-    expect(resolveKvDriverId(options, "local", false)).toBe("memory");
-    expect(resolveFilesDriverId(options, "local", false)).toBe("fs");
+    expect(resolveSqlDriverId(options, "test", false)).toBe("pglite");
+    expect(resolveKvDriverId(options, "test", false)).toBe("memory");
+    expect(resolveFilesDriverId(options, "test", false)).toBe("fs");
   });
 
-  test("docker env uses docker profile (falls back to prod)", () => {
+  test("dev env uses compose profile (falls back to prod)", () => {
     const options = {
       config: {
         drivers: {
           store: {
-            sql: { local: "sqlite", docker: "postgres", prod: "postgres" },
-            kv: { local: "memory", prod: "redis" },
-            files: { local: "fs", prod: "s3" },
+            sql: { dev: "postgres", test: "pglite", prod: "postgres" },
+            kv: { dev: "redis", test: "memory", prod: "redis" },
+            files: { dev: "s3", test: "fs", prod: "s3" },
           },
         },
       },
     };
-    expect(resolveSqlDriverId(options, "docker", true)).toBe("postgres");
-    expect(resolveKvDriverId(options, "docker", true)).toBe("redis");
-    expect(resolveFilesDriverId(options, "docker", true)).toBe("s3");
+    expect(resolveSqlDriverId(options, "dev", true)).toBe("postgres");
+    expect(resolveKvDriverId(options, "dev", true)).toBe("redis");
+    expect(resolveFilesDriverId(options, "dev", true)).toBe("s3");
   });
 
   test("docker mode honours OKE_*_DRIVER overrides", () => {
     process.env.OKE_SQL_DRIVER = "postgres";
     process.env.OKE_KV_DRIVER = "redis";
     process.env.OKE_FILES_DRIVER = "s3";
-    expect(resolveSqlDriverId({}, "docker", true)).toBe("postgres");
-    expect(resolveKvDriverId({}, "docker", true)).toBe("redis");
-    expect(resolveFilesDriverId({}, "docker", true)).toBe("s3");
+    expect(resolveSqlDriverId({}, "dev", true)).toBe("postgres");
+    expect(resolveKvDriverId({}, "dev", true)).toBe("redis");
+    expect(resolveFilesDriverId({}, "dev", true)).toBe("s3");
   });
 
-  test("pinning only `local` never leaks into docker/test/prod — each keeps its real default", () => {
+  test("pinning only `test` never leaks into dev/prod — each keeps its real default", () => {
     const options = {
       config: {
         drivers: {
           store: {
-            sql: { local: "pglite" },
+            sql: { test: "pglite" },
           },
         },
       },
     };
-    expect(resolveSqlDriverId(options, "local", false)).toBe("pglite");
-    expect(resolveSqlDriverId(options, "docker", true)).toBe("postgres");
-    expect(resolveSqlDriverId(options, "test", false)).toBe("memory");
+    expect(resolveSqlDriverId(options, "test", false)).toBe("pglite");
+    expect(resolveSqlDriverId(options, "dev", true)).toBe("postgres");
     expect(resolveSqlDriverId(options, "prod", true)).toBe("postgres");
     // kv / files are untouched by the sql-only override.
-    expect(resolveKvDriverId(options, "local", false)).toBe("memory");
-    expect(resolveKvDriverId(options, "docker", true)).toBe("redis");
+    expect(resolveKvDriverId(options, "test", false)).toBe("memory");
+    expect(resolveKvDriverId(options, "dev", true)).toBe("redis");
   });
 });
 
@@ -118,12 +117,12 @@ describe("bindStore files fs multi-instance warn", () => {
           config: {
             drivers: {
               store: {
-                files: { local: "fs", docker: "s3", prod: "s3" },
+                files: { dev: "s3", test: "fs", prod: "s3" },
               },
             },
           },
         },
-        "local",
+        "test",
         () => Date.now(),
         false,
       );
@@ -133,12 +132,12 @@ describe("bindStore files fs multi-instance warn", () => {
           config: {
             drivers: {
               store: {
-                files: { local: "fs", docker: "s3", prod: "s3" },
+                files: { dev: "s3", test: "fs", prod: "s3" },
               },
             },
           },
         },
-        "local",
+        "test",
         () => Date.now(),
         false,
       );
@@ -162,12 +161,12 @@ describe("bindStore files fs multi-instance warn", () => {
           config: {
             drivers: {
               store: {
-                files: { local: "memory", docker: "s3", prod: "s3" },
+                files: { dev: "s3", test: "memory", prod: "s3" },
               },
             },
           },
         },
-        "local",
+        "test",
         () => Date.now(),
         false,
       );
@@ -187,8 +186,8 @@ describe("bindStore index driver resolution", () => {
   });
 
   test("defaults to memory when no index driver is configured", () => {
-    expect(resolveIndexDriverId({}, "local", false)).toBe("memory");
-    expect(resolveIndexDriverId({}, "docker", true)).toBe("memory");
+    expect(resolveIndexDriverId({}, "test", false)).toBe("memory");
+    expect(resolveIndexDriverId({}, "dev", true)).toBe("memory");
     expect(indexDriverFor("memory").id).toBe("memory");
   });
 
@@ -197,37 +196,37 @@ describe("bindStore index driver resolution", () => {
       config: {
         drivers: {
           store: {
-            index: { local: "memory", docker: "pgvector", prod: "pgvector" },
+            index: { dev: "pgvector", test: "memory", prod: "pgvector" },
           },
         },
       },
     };
-    expect(resolveIndexDriverId(options, "local", false)).toBe("memory");
-    expect(resolveIndexDriverId(options, "docker", true)).toBe("pgvector");
+    expect(resolveIndexDriverId(options, "test", false)).toBe("memory");
+    expect(resolveIndexDriverId(options, "dev", true)).toBe("pgvector");
     expect(resolveIndexDriverId(options, "prod", false)).toBe("pgvector");
   });
 
-  test("libsql resolves from config", () => {
+  test("pgvector resolves from config", () => {
     const options = {
-      config: { drivers: { store: { index: { local: "libsql" } } } },
+      config: { drivers: { store: { index: { test: "pgvector" } } } },
     };
-    expect(resolveIndexDriverId(options, "local", false)).toBe("libsql");
-    expect(indexDriverFor("libsql").id).toBe("libsql");
+    expect(resolveIndexDriverId(options, "test", false)).toBe("pgvector");
+    expect(indexDriverFor("pgvector").id).toBe("pgvector");
   });
 
   test("meilisearch resolves from config as a fourth id", () => {
     const options = {
-      config: { drivers: { store: { index: { local: "meilisearch", docker: "meilisearch" } } } },
+      config: { drivers: { store: { index: { dev: "meilisearch", test: "meilisearch" } } } },
     };
-    expect(resolveIndexDriverId(options, "local", false)).toBe("meilisearch");
-    expect(resolveIndexDriverId(options, "docker", true)).toBe("meilisearch");
+    expect(resolveIndexDriverId(options, "test", false)).toBe("meilisearch");
+    expect(resolveIndexDriverId(options, "dev", true)).toBe("meilisearch");
     expect(indexDriverFor("meilisearch").id).toBe("meilisearch");
   });
 
   test("docker mode honours OKE_INDEX_DRIVER override", () => {
     process.env.OKE_INDEX_DRIVER = "pgvector";
-    expect(resolveIndexDriverId({}, "docker", true)).toBe("pgvector");
-    expect(resolveIndexDriverId({}, "local", false)).toBe("memory");
+    expect(resolveIndexDriverId({}, "dev", true)).toBe("pgvector");
+    expect(resolveIndexDriverId({}, "test", false)).toBe("memory");
   });
 
   test("indexDriverFor returns the configured driver and throws on unknown ids", () => {