create-oke 0.2.6 → 0.2.8

package/examples/provisions/.env.example

@@ -0,0 +1,19 @@
+# Environment template — copy to `.env.local` for local overrides.
+# create-oke copies this file to `.env.local` when you scaffold a new project.
+#
+# Resolution order (first hit wins):
+#   process.env → .env.local → docker/.env.docker → vault driver → dev fallback
+#
+# --- Vault (app secrets) ---
+
+# STRIPE_KEY — Stripe secret API key for payments; from https://dashboard.stripe.com/apikeys (test keys start with sk_test_)
+STRIPE_KEY=
+
+# DATABASE_URL — primary Postgres URL (vault contract in src/vault.ts); from your host or `docker/.env.docker` after `oke dev --docker`
+DATABASE_URL=
+
+# --- Infrastructure (optional) ---
+# This app pins redis for prod kv in oke.config.ts (local dev uses in-memory kv).
+
+# REDIS_URL — Redis/Valkey connection for store.kv; from your host (Upstash, ElastiCache, …)
+# REDIS_URL=redis://:password@host:6379

package/examples/provisions/drizzle.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from "drizzle-kit";
+
+/** Domain schema sync for `oke db push|generate|migrate`. */
+export default defineConfig({
+  dialect: "sqlite",
+  schema: "./src/schema.ts",
+  out: "./drizzle",
+  dbCredentials: {
+    url: process.env.OKE_SQLITE_URL ?? "file:.oke/app.sqlite",
+  },
+});

package/examples/provisions/oke.config.ts

@@ -2,15 +2,17 @@ import { defineConfig } from "okengine/config";
 
 export default defineConfig({
   drivers: {
-    store: { sql: { dev: "sqlite", test: "memory", prod: "postgres" },
-             kv:  { dev: "memory", test: "memory", prod: "redis" } },
-    signal: { dev: "memory", test: "memory", prod: "postgres" },
-    clock:  { dev: "memory", test: "frozen", prod: "postgres" },
-    vault:  { dev: "dotenv", test: "memory", prod: "sops" },
+    store: {
+      sql: { local: "sqlite", test: "memory", prod: "postgres" },
+      kv: { local: "memory", test: "memory", prod: "redis" },
+    },
+    signal: { local: "memory", test: "memory", prod: "postgres" },
+    clock: { local: "memory", test: "frozen", prod: "postgres" },
+    vault: { local: "dotenv", test: "memory", prod: "sops" },
     channel: {
-      email: { dev: "console", test: "console", prod: "smtp" },
-      sms: { dev: "console", test: "console", prod: "unifonic" },
-      whatsapp: { dev: "console", test: "console", prod: "wa-cloud" },
+      email: { local: "console", test: "console", prod: "smtp" },
+      sms: { local: "console", test: "console", prod: "unifonic" },
+      whatsapp: { local: "console", test: "console", prod: "wa-cloud" },
     },
   },
   i18n: { locales: ["en", "ar"], default: "ar", dir: { ar: "rtl" } },

package/examples/provisions/package.json

@@ -3,13 +3,16 @@
   "version": "0.0.1",
   "private": true,
   "type": "module",
+  "scripts": {
+    "test": "bun test",
+    "dev": "oke dev"
+  },
   "dependencies": {
-    "okengine": "file:../..",
     "drizzle-orm": "^1.0.0-rc.4",
+    "okengine": "file:../..",
     "zod": "^4.4.3"
   },
-  "scripts": {
-    "test": "bun test",
-    "dev": "oke dev"
+  "devDependencies": {
+    "drizzle-kit": "^1.0.0-rc.4"
   }
 }

package/examples/provisions/src/app.ts

@@ -16,11 +16,11 @@ import * as notifications from "./flows/notifications";
 
 export const app = oke({ name: "provisions" })
   .adopt({ orders, payments, notifications })
-  .plug(auth())                       // zero ceremony: uses your configured store
-  .plug(audit)                        // app-wide
+  .plug(auth()) // zero ceremony: uses your configured store
+  .plug(audit) // app-wide
   .hook("onError", (ctx, err, fx) => fx.log.error(err));
 
-app.unit("orders").plug(rateLimit({ max: 30 }));  // this unit only
+app.unit("orders").plug(rateLimit({ max: 30 })); // this unit only
 
 export type App = typeof app;
 

package/examples/provisions/src/channels.ts

@@ -2,13 +2,14 @@ import { channel } from "okengine";
 import { z } from "zod";
 
 export const mail = channel.email({ from: "Provisions <no-reply@provisions.sa>" });
-export const sms  = channel.sms({ sender: "PROVISIONS" });
-export const wa   = channel.whatsapp();
+export const sms = channel.sms({ sender: "PROVISIONS" });
+export const wa = channel.whatsapp();
 
 export const orderConfirmed = mail.template("order-confirmed", {
   schema: z.object({ name: z.string(), orderId: z.string(), total: z.number() }),
 });
 
-export const otpCode = channel.template("otp-code", {   // medium-agnostic
+export const otpCode = channel.template("otp-code", {
+  // medium-agnostic
   schema: z.object({ code: z.string() }),
 });

package/examples/provisions/src/flows/notifications/index.ts

@@ -4,13 +4,19 @@ import { orderNews } from "../orders/signals";
 import { getOrder } from "../orders";
 import { orderConfirmed, otpCode, wa, sms } from "../../channels";
 
-on(orderNews, flow({
-  do: async ({ orderId, status }, fx) => {
-    if (status !== "confirmed") return;
-    const o = await fx.call(getOrder, { id: orderId });
-    await fx.send(orderConfirmed, { to: o.userId, data: { name: o.userName, orderId, total: o.total } });
-  },
-}));
+on(
+  orderNews,
+  flow({
+    do: async ({ orderId, status }, fx) => {
+      if (status !== "confirmed") return;
+      const o = await fx.call(getOrder, { id: orderId });
+      await fx.send(orderConfirmed, {
+        to: o.userId,
+        data: { name: o.userName, orderId, total: o.total },
+      });
+    },
+  }),
+);
 
 export const sendOtp = flow({
   in: z.object({ userId: z.string(), code: z.string() }),

package/examples/provisions/src/flows/orders/index.ts

@@ -9,31 +9,49 @@ import { orders, products } from "../../schema";
 
 const canOrder = gate.policy("order:create", ({ auth }) => auth.scopes.has("order:create"));
 
-export const create = on(http.post("/orders").gate(member, canOrder), flow({
-  in: NewOrder, out: OrderId, errors: { OutOfStock },
-  do: async (input, fx) => {
-    const [product] = await fx.store(db).select({ stock: products.stock })
-      .from(products).where(eq(products.sku, input.sku)).limit(1);
-    if (!product || product.stock < input.qty) return fx.fail("OutOfStock",
-      { left: product?.stock ?? 0 },
-      { message: fx.t("order.outOfStock", { left: product?.stock ?? 0 }) });
+export const create = on(
+  http.post("/orders").gate(member, canOrder),
+  flow({
+    in: NewOrder,
+    out: OrderId,
+    errors: { OutOfStock },
+    do: async (input, fx) => {
+      const [product] = await fx
+        .store(db)
+        .select({ stock: products.stock })
+        .from(products)
+        .where(eq(products.sku, input.sku))
+        .limit(1);
+      if (!product || product.stock < input.qty)
+        return fx.fail(
+          "OutOfStock",
+          { left: product?.stock ?? 0 },
+          { message: fx.t("order.outOfStock", { left: product?.stock ?? 0 }) },
+        );
 
-    const id = fx.id();
-    await fx.store(db).insert(orders).values(
-      { id, userId: fx.auth.userId, ...input, status: "pending", createdAt: Date.now() });
-    await fx.emit(orderPlaced, { orderId: id });
-    return { id };
-  },
-}));
+      const id = fx.id();
+      await fx
+        .store(db)
+        .insert(orders)
+        .values({ id, userId: fx.auth.userId, ...input, status: "pending", createdAt: Date.now() });
+      await fx.emit(orderPlaced, { orderId: id });
+      return { id };
+    },
+  }),
+);
 
 // LIVE QUERY — realtime and auto-caching from one flag
-export const mine = on(http.get("/orders").gate(member).live(), flow({
-  out: OrderRow.array(),
-  do: (_, fx) => fx.store(db).select().from(orders).where(eq(orders.userId, fx.auth.userId)),
-}));
+export const mine = on(
+  http.get("/orders").gate(member).live(),
+  flow({
+    out: OrderRow.array(),
+    do: (_, fx) => fx.store(db).select().from(orders).where(eq(orders.userId, fx.auth.userId)),
+  }),
+);
 
 export const getOrder = flow({
-  in: OrderId, out: OrderRow,
+  in: OrderId,
+  out: OrderRow,
   do: async ({ id }, fx) => {
     const [order] = await fx.store(db).select().from(orders).where(eq(orders.id, id)).limit(1);
     return order;
@@ -41,19 +59,28 @@ export const getOrder = flow({
 });
 
 // SIGNAL consumer
-on(orderPlaced, flow({
-  do: async ({ orderId }, fx) => {
-    const paid = await fx.call(chargeOrder, { orderId });
-    await fx.store(db).update(orders).set({ status: paid ? "confirmed" : "failed" })
-      .where(eq(orders.id, orderId));
-    await fx.emit(orderNews, { orderId, status: paid ? "confirmed" : "failed" });
-  },
-}));
+on(
+  orderPlaced,
+  flow({
+    do: async ({ orderId }, fx) => {
+      const paid = await fx.call(chargeOrder, { orderId });
+      await fx
+        .store(db)
+        .update(orders)
+        .set({ status: paid ? "confirmed" : "failed" })
+        .where(eq(orders.id, orderId));
+      await fx.emit(orderNews, { orderId, status: paid ? "confirmed" : "failed" });
+    },
+  }),
+);
 
 // CHANGE trigger — CDC, built in
-on(db.table(orders).changed("status"), flow({
-  do: ({ before, after }, fx) => fx.log.info("status", { from: before.status, to: after.status }),
-}));
+on(
+  db.table(orders).changed("status"),
+  flow({
+    do: ({ before, after }, fx) => fx.log.info("status", { from: before.status, to: after.status }),
+  }),
+);
 
 export { canOrder };
 

package/examples/provisions/src/flows/payments/index.ts

@@ -10,13 +10,16 @@ import { stripeKey } from "../../vault";
 import { OrderRef } from "./shapes";
 
 export const chargeOrder = flow({
-  durable: true,                    // every fx call below is journaled
-  in: OrderRef, out: z.boolean(),
+  durable: true, // every fx call below is journaled
+  in: OrderRef,
+  out: z.boolean(),
   do: async ({ orderId }, fx) => {
-    const intent = await fx.step("create-intent", () =>       // never re-runs on replay
-      stripe(fx.vault(stripeKey)).create(orderId));
+    const intent = await fx.step("create-intent", () =>
+      // never re-runs on replay
+      stripe(fx.vault(stripeKey)).create(orderId),
+    );
 
-    await fx.clock.sleep("verify-window", "2m");              // survives restart and deploy
+    await fx.clock.sleep("verify-window", "2m"); // survives restart and deploy
 
     return fx.step("confirm", () => stripe(fx.vault(stripeKey)).confirm(intent));
   },
@@ -27,7 +30,10 @@ const charged = chargeOrder.do;
 (chargeOrder as { do: typeof charged }).do = async (input, fx) => {
   const paid = await charged(input, fx);
   if (paid) {
-    await fx.store(db).update(orders).set({ status: "confirmed" })
+    await fx
+      .store(db)
+      .update(orders)
+      .set({ status: "confirmed" })
       .where(eq(orders.id, input.orderId));
     await fx.emit(orderNews, { orderId: input.orderId, status: "confirmed" });
   }

package/examples/provisions/src/schema.ts

@@ -1,16 +1,16 @@
 import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
 
 export const products = sqliteTable("products", {
-  sku:   text("sku").primaryKey(),
-  name:  text("name").notNull(),
+  sku: text("sku").primaryKey(),
+  name: text("name").notNull(),
   stock: integer("stock").notNull().default(0),
 });
 
 export const orders = sqliteTable("orders", {
-  id:        text("id").primaryKey(),
-  userId:    text("user_id").notNull(),
-  sku:       text("sku").notNull(),
-  qty:       integer("qty").notNull(),
-  status:    text("status").notNull().default("pending"),
+  id: text("id").primaryKey(),
+  userId: text("user_id").notNull(),
+  sku: text("sku").notNull(),
+  qty: integer("qty").notNull(),
+  status: text("status").notNull().default("pending"),
   createdAt: integer("created_at").notNull(),
 });

package/examples/provisions/src/vault.ts

@@ -2,7 +2,7 @@ import { vault } from "okengine";
 import { z } from "zod";
 
 // A declaration is a CONTRACT, not a value.
-// Resolution: process.env → .env.local → .env.stack → vault driver → dev fallback
+// Resolution: process.env → .env.local → docker/.env.docker → vault driver → dev fallback
 export const stripeKey = vault.secret("STRIPE_KEY", {
   schema: z.string().startsWith("sk_"),
   description: "Payments gateway key",
@@ -12,5 +12,5 @@ export const stripeKey = vault.secret("STRIPE_KEY", {
 
 export const dbUrl = vault.secret("DATABASE_URL", {
   schema: z.string().url(),
-  dev: vault.fromStack("store.sql"),     // generated by `oke dev --stack` — zero manual setup
+  dev: vault.fromDocker("store.sql"), // generated by `oke dev --docker` — zero manual setup
 });

package/examples/provisions/tests/orders.test.ts

@@ -3,16 +3,17 @@ import { createTestApp } from "okengine/test";
 import { app } from "../src/app";
 
 test("order → charge → notify", async () => {
-const t = await createTestApp(app);                 // memory drivers, frozen clock
-const u = await t.auth.loginAs({ scopes: ["order:create"] });
+  const t = await createTestApp(app); // memory drivers, frozen clock
+  const u = await t.auth.loginAs({ scopes: ["order:create"] });
 
-const { data } = await t.api.orders.create({ sku: "COFFEE", qty: 2 }, { as: u });
-await t.signals.drain();
-await t.clock.advance("2m");                        // the durable sleep elapses instantly
-await t.signals.drain();
+  const { data } = await t.api.orders.create({ sku: "COFFEE", qty: 2 }, { as: u });
+  await t.signals.drain();
+  await t.clock.advance("2m"); // the durable sleep elapses instantly
+  await t.signals.drain();
 
-expect(t.channels.sent()).toContainEqual(
-  expect.objectContaining({ template: "order-confirmed", to: u.id, locale: "ar" }));
+  expect(t.channels.sent()).toContainEqual(
+    expect.objectContaining({ template: "order-confirmed", to: u.id, locale: "ar" }),
+  );
   expect(data?.id).toBeDefined();
   await t.close();
 });

package/examples/skyport/.env.example

@@ -0,0 +1,34 @@
+# Environment template — copy to `.env.local` for local overrides.
+# create-oke copies this file to `.env.local` when you scaffold a new project.
+#
+# Resolution order (first hit wins):
+#   process.env → .env.local → docker/.env.docker → vault driver → dev fallback
+#
+# --- Vault (app secrets) ---
+
+# DATABASE_URL — primary Postgres URL (vault contract in src/vault.ts); from your host or `docker/.env.docker` after `oke dev --docker`
+DATABASE_URL=
+
+# DATABASE_REPLICA_1 — read-replica Postgres URL for read-only flow routing; from your host's replica endpoint
+DATABASE_REPLICA_1=
+
+# ANTHROPIC_KEY — Anthropic API key for prod AI driver; from https://console.anthropic.com/settings/keys
+ANTHROPIC_KEY=
+
+# STRIPE_KEY — Stripe secret API key for payments; from https://dashboard.stripe.com/apikeys (test keys start with sk_test_)
+STRIPE_KEY=
+
+# --- Infrastructure (optional) ---
+# Commented — this app pins redis (store.kv) and s3 (store.files) for prod in oke.config.ts.
+
+# REDIS_URL — Redis/Valkey connection for store.kv; from your host or `docker/.env.docker` after `oke dev --docker`
+# REDIS_URL=redis://:password@127.0.0.1:6379
+
+# AWS_ACCESS_KEY_ID — S3-compatible object storage access key; from AWS IAM, Cloudflare R2, or MinIO console
+# AWS_ACCESS_KEY_ID=
+
+# AWS_SECRET_ACCESS_KEY — matching secret for object storage; never commit real values
+# AWS_SECRET_ACCESS_KEY=
+
+# AWS_REGION — bucket region (e.g. us-east-1); from your object storage provider
+# AWS_REGION=us-east-1

package/examples/skyport/drizzle.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from "drizzle-kit";
+
+/** Domain schema sync for `oke db push|generate|migrate`. */
+export default defineConfig({
+  dialect: "sqlite",
+  schema: "./src/schema.ts",
+  out: "./drizzle",
+  dbCredentials: {
+    url: process.env.OKE_SQLITE_URL ?? "file:.oke/app.sqlite",
+  },
+});

package/examples/skyport/oke.config.ts

@@ -6,39 +6,42 @@ export default defineConfig({
   // (Bun.sql, bun:sqlite, Bun.redis, Bun.S3) — zero npm client dependencies.
   drivers: {
     store: {
-      sql: { dev: "sqlite", test: "memory",
-             prod: { driver: "postgres", url: dbUrl, pool: { max: 20 },
-                     replicas: [dbReplica1] } },      // read-only flows auto-route here
-      kv:    { dev: "memory",   test: "memory", prod: "redis" },   // Redis · Valkey · Dragonfly
-      files: { dev: "fs",       test: "memory", prod: "s3" },      // S3 · R2 · SeaweedFS · MinIO
-      index: { dev: "pgvector", test: "memory", prod: "pgvector" },
+      sql: {
+        local: "sqlite",
+        test: "memory",
+        prod: { driver: "postgres", url: dbUrl, pool: { max: 20 }, replicas: [dbReplica1] },
+      }, // read-only flows auto-route here
+      kv: { local: "memory", test: "memory", prod: "redis" }, // Redis · Valkey · Dragonfly
+      files: { local: "fs", test: "memory", prod: "s3" }, // S3 · R2 · SeaweedFS · MinIO
+      index: { local: "pgvector", test: "memory", prod: "pgvector" },
     },
-    signal:  { dev: "memory", test: "memory", prod: "postgres" },
-    clock:   { dev: "memory", test: "frozen", prod: "postgres" },
-    vault:   { dev: "dotenv", test: "memory", prod: "sops" },      // SOPS/age — committable
-    runs:    { dev: "files",  test: "memory", prod: "files" },     // Parquet + DuckDB
+    signal: { local: "memory", test: "memory", prod: "postgres" },
+    clock: { local: "memory", test: "frozen", prod: "postgres" },
+    vault: { local: "dotenv", test: "memory", prod: "sops" }, // SOPS/age — committable
+    runs: { local: "files", test: "memory", prod: "files" }, // Parquet + DuckDB
     channel: {
-      email:    { dev: "console", prod: "smtp" },
-      sms:      { dev: "console", prod: "unifonic" },
-      whatsapp: { dev: "console", prod: "wa-cloud" },
-      push:     { dev: "console", prod: "fcm" },
+      email: { local: "console", prod: "smtp" },
+      sms: { local: "console", prod: "unifonic" },
+      whatsapp: { local: "console", prod: "wa-cloud" },
+      push: { local: "console", prod: "fcm" },
     },
     ai: {
-      dev:  "mock",                                   // deterministic — tests never call out
+      local: "mock", // deterministic — tests never call out
       prod: { driver: "anthropic", key: anthropicKey },
       // no prod default: model choice is never guessed.
       // "openai-compatible" covers vLLM · Groq · Together · LM Studio · most self-hosted
     },
   },
 
-  images: {                                           // vendor choice, keyed by ROLE
+  images: {
+    // vendor choice, keyed by ROLE
     "store.sql": "pgvector/pgvector:pg17",
-    "store.kv":  "valkey/valkey:8-alpine",
+    "store.kv": "valkey/valkey:8-alpine",
   },
 
-  i18n:     { locales: ["en", "ar"], default: "ar", dir: { ar: "rtl" } },
-  tenancy:  { resolve: (ctx) => ctx.auth.orgId, isolation: "row" },
-  topology: "monolith",                               // flip to "services" — code unchanged
-  ports:    { app: 6530, console: 6533, mcp: 6535 },  // O·K·E = 6·5·3
-  console:  { prod: { enabled: true, auth: "required" } },
+  i18n: { locales: ["en", "ar"], default: "ar", dir: { ar: "rtl" } },
+  tenancy: { resolve: (ctx) => ctx.auth.orgId, isolation: "row" },
+  topology: "monolith", // flip to "services" — code unchanged
+  ports: { app: 6530, console: 6533, mcp: 6535 }, // O·K·E = 6·5·3
+  console: { prod: { enabled: true, auth: "required" } },
 });

package/examples/skyport/package.json

@@ -3,14 +3,17 @@
   "version": "0.0.1",
   "private": true,
   "type": "module",
-  "dependencies": {
-    "okengine": "file:../..",
-    "drizzle-orm": "^1.0.0-rc.4",
-    "zod": "^4.4.3"
-  },
   "scripts": {
     "test": "bun test",
     "dev": "oke dev",
     "docker": "oke docker"
+  },
+  "dependencies": {
+    "drizzle-orm": "^1.0.0-rc.4",
+    "okengine": "file:../..",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "drizzle-kit": "^1.0.0-rc.4"
   }
 }

package/examples/skyport/src/ai.ts

@@ -3,15 +3,15 @@ import { z } from "zod";
 import { getBooking, refundBooking } from "./flows/bookings";
 
 export const smart = ai.model("smart", { provider: "anthropic", tier: "opus" });
-export const fast  = ai.model("fast",  { provider: "anthropic", tier: "haiku" });
+export const fast = ai.model("fast", { provider: "anthropic", tier: "haiku" });
 
 // A prompt is a VERSIONED ARTIFACT with a validated output shape — not a string in a handler
 export const triage = smart.prompt("ticket-triage", {
-  in:  z.object({ subject: z.string(), body: z.string() }),
+  in: z.object({ subject: z.string(), body: z.string() }),
   out: z.object({ urgency: z.enum(["low", "high"]), team: z.string(), summary: z.string() }),
   version: 3,
-  evals: "./evals/triage.jsonl",          // regression-gated in CI via `oke eval`
-  budget: { maxCostPerCall: 0.02 },       // cost is a first-class dimension
+  evals: "./evals/triage.jsonl", // regression-gated in CI via `oke eval`
+  budget: { maxCostPerCall: 0.02 }, // cost is a first-class dimension
 });
 
 export const embed = ai.embed("docs", { model: fast, into: store.index("kb") });

package/examples/skyport/src/app.ts

@@ -1,20 +1,9 @@
 import { db } from "./core";
 import { member, fair } from "./gates";
-import {
-  dbUrl,
-  dbReplica1,
-  anthropicKey,
-  stripeKey,
-} from "./vault";
+import { dbUrl, dbReplica1, anthropicKey, stripeKey } from "./vault";
 import { bookingConfirmed } from "./channels";
 import { orderPlaced, seatFeed } from "./flows/bookings/signals";
-import {
-  smart,
-  fast,
-  triage,
-  embed,
-  support as supportAgentDecl,
-} from "./ai";
+import { smart, fast, triage, embed, support as supportAgentDecl } from "./ai";
 import { canBook } from "./flows/bookings";
 import "./journeys";
 import "./ai";

package/examples/skyport/src/flows/bookings/index.ts

@@ -6,32 +6,54 @@ import { orderPlaced, seatFeed } from "./signals";
 import { NewBooking, BookingId, BookingRow, FlightFull } from "./shapes";
 import { bookings, flights } from "../../schema";
 
-export const canBook = gate.policy("booking:create", ({ auth }) => auth.scopes.has("booking:create"));
+export const canBook = gate.policy("booking:create", ({ auth }) =>
+  auth.scopes.has("booking:create"),
+);
 
-export const create = on(http.post("/bookings").gate(member, canBook, fair), flow({
-  slo: { availability: "99.9%", latency: { p99: "200ms" } },
-  in: NewBooking, out: BookingId, errors: { FlightFull },
-  do: async ({ flightId, seats }, fx) => {
-    const [flight] = await fx.store(db).select().from(flights).where(eq(flights.id, flightId)).limit(1);
-    if (!flight || flight.seatsAvailable < seats)
-      return fx.fail("FlightFull", { seatsLeft: flight?.seatsAvailable ?? 0 });
+export const create = on(
+  http.post("/bookings").gate(member, canBook, fair),
+  flow({
+    slo: { availability: "99.9%", latency: { p99: "200ms" } },
+    in: NewBooking,
+    out: BookingId,
+    errors: { FlightFull },
+    do: async ({ flightId, seats }, fx) => {
+      const [flight] = await fx
+        .store(db)
+        .select()
+        .from(flights)
+        .where(eq(flights.id, flightId))
+        .limit(1);
+      if (!flight || flight.seatsAvailable < seats)
+        return fx.fail("FlightFull", { seatsLeft: flight?.seatsAvailable ?? 0 });
 
-    const id = fx.id();
-    await fx.store(db).insert(bookings).values(
-      { id, userId: fx.auth.userId, flightId, seats, status: "pending", createdAt: Date.now() });
-    await fx.emit(orderPlaced, { orderId: id });
-    await fx.emit(seatFeed, { flightId, left: flight.seatsAvailable - seats });
-    return { id };
-  },
-}));
+      const id = fx.id();
+      await fx.store(db).insert(bookings).values({
+        id,
+        userId: fx.auth.userId,
+        flightId,
+        seats,
+        status: "pending",
+        createdAt: Date.now(),
+      });
+      await fx.emit(orderPlaced, { orderId: id });
+      await fx.emit(seatFeed, { flightId, left: flight.seatsAvailable - seats });
+      return { id };
+    },
+  }),
+);
 
-export const mine = on(http.get("/bookings").gate(member).live(), flow({
-  out: BookingRow.array(),
-  do: (_, fx) => fx.store(db).select().from(bookings).where(eq(bookings.userId, fx.auth.userId)),
-}));
+export const mine = on(
+  http.get("/bookings").gate(member).live(),
+  flow({
+    out: BookingRow.array(),
+    do: (_, fx) => fx.store(db).select().from(bookings).where(eq(bookings.userId, fx.auth.userId)),
+  }),
+);
 
 export const getBooking = flow({
-  in: BookingId, out: BookingRow,
+  in: BookingId,
+  out: BookingRow,
   do: async ({ id }, fx) => {
     const [b] = await fx.store(db).select().from(bookings).where(eq(bookings.id, id)).limit(1);
     return b;
@@ -41,7 +63,8 @@ export const getBooking = flow({
 // The agent's second tool — refunding is a distinct, gated capability, never the same
 // permission as reading a booking, since the agent's tool list is exactly its authority.
 export const refundBooking = flow({
-  in: BookingId, out: BookingRow,
+  in: BookingId,
+  out: BookingRow,
   do: async ({ id }, fx) => {
     await fx.store(db).update(bookings).set({ status: "refunded" }).where(eq(bookings.id, id));
     const [b] = await fx.store(db).select().from(bookings).where(eq(bookings.id, id)).limit(1);

package/examples/skyport/src/flows/bookings/shapes.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-export const NewBooking  = z.object({ flightId: z.string(), seats: z.number().min(1).max(9) });
-export const BookingId   = z.object({ id: z.string() });
-export const BookingRow  = z.object({ id: z.string(), status: z.string(), seats: z.number() });
-export const FlightFull  = z.object({ seatsLeft: z.number() });
+export const NewBooking = z.object({ flightId: z.string(), seats: z.number().min(1).max(9) });
+export const BookingId = z.object({ id: z.string() });
+export const BookingRow = z.object({ id: z.string(), status: z.string(), seats: z.number() });
+export const FlightFull = z.object({ seatsLeft: z.number() });