okengine 0.2.6 → 0.3.2

package/src/client/notes-contract.test.ts

@@ -20,10 +20,7 @@ beforeEach(() => {
 });
 
 /** 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;
 
 const NoteId = z.object({ id: z.string() });
@@ -54,9 +51,7 @@ const get = on(
     out: Note,
     errors: { NotFound },
     do: ({ id }, fx) =>
-      id === "missing"
-        ? fx.fail("NotFound", {})
-        : { id, title: "First", body: "Hello" },
+      id === "missing" ? fx.fail("NotFound", {}) : { id, title: "First", body: "Hello" },
   }),
 );
 
@@ -121,9 +116,7 @@ describe("Notes — typeof app carries contracts", () => {
     {
       const { data, error } = await api.notes.get({ id: "n_1" });
       if (error?.code === "NotFound") {
-        type _Empty = Assert<
-          Eq<typeof error.data, Record<string, never>>
-        >;
+        type _Empty = Assert<Eq<typeof error.data, Record<string, never>>>;
         const keep: _Empty = true;
         expect(keep).toBe(true);
         throw new Error("unexpected NotFound");
@@ -244,9 +237,7 @@ describe("Notes — typeof app carries contracts", () => {
     type PartialClient = Client<typeof createOnly>;
 
     type FullHasGet = "get" extends keyof FullClient["notes"] ? true : false;
-    type PartialHasGet = "get" extends keyof PartialClient["notes"]
-      ? true
-      : false;
+    type PartialHasGet = "get" extends keyof PartialClient["notes"] ? true : false;
 
     type _Full = Assert<Eq<FullHasGet, true>>;
     type _Part = Assert<Eq<PartialHasGet, false>>;

package/src/client/transport.ts

@@ -24,12 +24,8 @@ export interface Transport {
  * @param base - Absolute origin (no trailing slash)
  * @param opts - Client options
  */
-export function createTransport(
-  base: string,
-  opts: ClientOptions = {},
-): Transport {
-  const fetchFn: ClientFetch =
-    opts.fetch ?? globalThis.fetch.bind(globalThis);
+export function createTransport(base: string, opts: ClientOptions = {}): Transport {
+  const fetchFn: ClientFetch = opts.fetch ?? globalThis.fetch.bind(globalThis);
   const retries = opts.retry?.retries ?? 0;
   const delay0 = opts.retry?.delay ?? 50;
   const backoff = opts.retry?.backoff ?? 2;
@@ -94,10 +90,7 @@ async function once(
     : rpcRequest(base, key, input);
 
   const headers = new Headers();
-  const extra =
-    typeof opts.headers === "function"
-      ? await opts.headers()
-      : opts.headers;
+  const extra = typeof opts.headers === "function" ? await opts.headers() : opts.headers;
   if (Array.isArray(extra)) {
     for (const [k, v] of extra) headers.set(k, v);
   } else if (extra) {
@@ -114,9 +107,7 @@ async function once(
 
   const ctrl = opts.timeout !== undefined ? new AbortController() : undefined;
   const timer =
-    ctrl && opts.timeout !== undefined
-      ? setTimeout(() => ctrl.abort(), opts.timeout)
-      : undefined;
+    ctrl && opts.timeout !== undefined ? setTimeout(() => ctrl.abort(), opts.timeout) : undefined;
 
   try {
     const res = await fetchFn(url, {
@@ -140,8 +131,7 @@ function rpcRequest(
   input: unknown,
 ): { url: string; method: string; body: string | undefined } {
   const url = `${base}/_oke/${key}`;
-  const body =
-    input === undefined ? undefined : JSON.stringify(input ?? {});
+  const body = input === undefined ? undefined : JSON.stringify(input ?? {});
   return { url, method: "POST", body };
 }
 
@@ -152,9 +142,7 @@ function restRequest(
   input: unknown,
 ): { url: string; method: string; body: string | undefined } {
   const params =
-    input !== null && typeof input === "object"
-      ? (input as Record<string, unknown>)
-      : {};
+    input !== null && typeof input === "object" ? (input as Record<string, unknown>) : {};
   let pathOut = path;
   const query: string[] = [];
   const rest: Record<string, unknown> = {};
@@ -173,15 +161,11 @@ function restRequest(
   if (upper === "GET" || upper === "HEAD") {
     for (const [k, v] of Object.entries(rest)) {
       if (v !== undefined) {
-        query.push(
-          `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`,
-        );
+        query.push(`${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);
       }
     }
   } else if (Object.keys(rest).length > 0 || path === pathOut) {
-    body = JSON.stringify(
-      Object.keys(rest).length > 0 ? rest : (input ?? {}),
-    );
+    body = JSON.stringify(Object.keys(rest).length > 0 ? rest : (input ?? {}));
   }
 
   const qs = query.length ? `?${query.join("&")}` : "";
@@ -221,12 +205,7 @@ async function decode(res: Response): Promise<ClientResult> {
     };
   }
 
-  if (
-    json !== null &&
-    typeof json === "object" &&
-    "data" in json &&
-    "error" in json
-  ) {
+  if (json !== null && typeof json === "object" && "data" in json && "error" in json) {
     return json as ClientResult;
   }
 

package/src/client/types.ts

@@ -88,9 +88,7 @@ export type RoutesOf<App> = App extends { readonly $routes: infer R }
       ? R
       : {
           [U in keyof R]: {
-            [F in keyof R[U]]: R[U][F] extends FlowContract
-              ? R[U][F]
-              : FlowContract;
+            [F in keyof R[U]]: R[U][F] extends FlowContract ? R[U][F] : FlowContract;
           };
         }
   : App extends ClientRouteMap
@@ -102,9 +100,7 @@ export type RoutesOf<App> = App extends { readonly $routes: infer R }
  *
  * @typeParam E - Error code → data map
  */
-export type ClientError<
-  E extends Record<string, unknown> = Record<string, unknown>,
-> = {
+export type ClientError<E extends Record<string, unknown> = Record<string, unknown>> = {
   [K in keyof E & string]: {
     readonly code: K;
     readonly data: E[K];
@@ -126,6 +122,8 @@ export interface TransportError {
 
 /**
  * Client call result — errors are values, never thrown for flow failures.
+ * Success may carry an optional top-level `meta` (Stripe-style envelope,
+ * e.g. paginated lists).
  *
  * @typeParam O - Success data
  * @typeParam E - Declared error map
@@ -134,14 +132,15 @@ export type ClientResult<
   O = unknown,
   E extends Record<string, unknown> = Record<string, unknown>,
 > =
-  | { readonly data: O; readonly error: null }
+  | {
+      readonly data: O;
+      readonly error: null;
+      readonly meta?: Record<string, unknown>;
+    }
   | { readonly data: null; readonly error: ClientError<E> | TransportError };
 
 /** Minimal fetch signature (avoids DOM `HeadersInit` / `preconnect` coupling). */
-export type ClientFetch = (
-  input: string | URL | Request,
-  init?: RequestInit,
-) => Promise<Response>;
+export type ClientFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
 
 /** Header bag accepted by the client. */
 export type ClientHeaders = Record<string, string> | [string, string][];
@@ -153,9 +152,7 @@ export interface ClientOptions {
   /** Override `globalThis.fetch`. */
   readonly fetch?: ClientFetch;
   /** Static headers, or a getter invoked per request. */
-  readonly headers?:
-    | ClientHeaders
-    | (() => ClientHeaders | Promise<ClientHeaders>);
+  readonly headers?: ClientHeaders | (() => ClientHeaders | Promise<ClientHeaders>);
   /** Abort the request after this many milliseconds. */
   readonly timeout?: number;
   /** Retry transient failures (network / 5xx). */
@@ -173,11 +170,7 @@ export interface ClientOptions {
    */
   readonly auth?: {
     /** Current access token (Bearer), or null. */
-    readonly getToken: () =>
-      | string
-      | null
-      | undefined
-      | Promise<string | null | undefined>;
+    readonly getToken: () => string | null | undefined | Promise<string | null | undefined>;
     /** Obtain a new access token after 401. */
     readonly refresh: () => Promise<string | null | undefined>;
   };
@@ -186,9 +179,7 @@ export interface ClientOptions {
    * When absent, the client uses `POST /_oke/{unit}/{flow}` unless
    * {@link ClientOptions.$routes} supplies HTTP method/path from adopt.
    */
-  readonly routes?: Readonly<
-    Record<string, { readonly method: string; readonly path: string }>
-  >;
+  readonly routes?: Readonly<Record<string, { readonly method: string; readonly path: string }>>;
   /**
    * Runtime route map from `app.$routes` (typed adopt). HTTP triggers become
    * REST; flows without method/path fall back to RPC.
@@ -203,11 +194,7 @@ export interface ClientOptions {
  * @typeParam O - Output
  * @typeParam E - Errors
  */
-export type ClientCall<
-  I,
-  O,
-  E extends Record<string, unknown>,
-> = [I] extends [void]
+export type ClientCall<I, O, E extends Record<string, unknown>> = [I] extends [void]
   ? () => Promise<ClientResult<O, E>>
   : Partial<I> extends I
     ? (input?: I) => Promise<ClientResult<O, E>>
@@ -223,9 +210,7 @@ type ContractIn<C> = "in" extends keyof C
   : void;
 
 /** Pull output from a contract shape. */
-type ContractOut<C> = "out" extends keyof C
-  ? NonNullable<C["out"]>
-  : unknown;
+type ContractOut<C> = "out" extends keyof C ? NonNullable<C["out"]> : unknown;
 
 /** Pull error map from a contract shape. */
 type ContractErrors<C> = "errors" extends keyof C

package/src/compiler/aot.test.ts

@@ -30,11 +30,7 @@ describe("sucrose — context inference", () => {
 
   test("detects context.body / query / headers access", () => {
     const inference = sucrose({
-      handler: ((ctx: {
-        body: unknown;
-        query: unknown;
-        headers: unknown;
-      }) => ({
+      handler: ((ctx: { body: unknown; query: unknown; headers: unknown }) => ({
         body: ctx.body,
         q: ctx.query,
         h: ctx.headers,
@@ -191,10 +187,7 @@ describe("AoT throughput ≥ 1.5× dynamic", () => {
       seats: z.number().int().min(1).max(9),
       note: z.string().max(200).optional(),
     });
-    const handler = ((input: {
-      flightId: string;
-      seats: number;
-    }) => input) as never;
+    const handler = ((input: { flightId: string; seats: number }) => input) as never;
 
     const aot = compileAot({
       method: "POST",

package/src/compiler/aot.ts

@@ -7,10 +7,7 @@
  */
 
 import type { FlowFailure } from "../kernel/errors.ts";
-import {
-  validate,
-  type SchemaInput,
-} from "../validation/standard-schema.ts";
+import { validate, type SchemaInput } from "../validation/standard-schema.ts";
 import {
   assembleInput,
   extractParts,

package/src/compiler/differential.test.ts

@@ -49,11 +49,7 @@ function generateContracts(count: number, seed = 42): GeneratedContract[] {
         method: "POST",
         path,
         schema,
-        handler: ((input: {
-          flightId: string;
-          seats: number;
-          cabin?: string;
-        }) => ({
+        handler: ((input: { flightId: string; seats: number; cabin?: string }) => ({
           ok: true,
           flightId: input.flightId,
           seats: input.seats,
@@ -140,10 +136,7 @@ function generateContracts(count: number, seed = 42): GeneratedContract[] {
         method: "POST",
         path,
         schema,
-        handler: ((input: {
-          tags: string[];
-          meta: { source: string; n: number };
-        }) => ({
+        handler: ((input: { tags: string[]; meta: { source: string; n: number } }) => ({
           count: input.tags.length,
           source: input.meta.source,
           n: input.meta.n,
@@ -188,8 +181,7 @@ async function runSample(
     request: Request,
     params: Readonly<Record<string, string>>,
   ) => Promise<
-    | { ok: true; input: unknown }
-    | { ok: false; failure: import("../kernel/errors.ts").FlowFailure }
+    { ok: true; input: unknown } | { ok: false; failure: import("../kernel/errors.ts").FlowFailure }
   >,
   handler: (...args: never[]) => unknown,
   sample: GeneratedContract["samples"][number],

package/src/compiler/dynamic.ts

@@ -37,10 +37,7 @@ export function compileDynamic(options: CompileRouteOptions): CompiledRoute {
  * @param options - Route metadata
  * @param aot - When `false`, force the dynamic path
  */
-export function compileRoute(
-  options: CompileRouteOptions,
-  aot: boolean = true,
-): CompiledRoute {
+export function compileRoute(options: CompileRouteOptions, aot: boolean = true): CompiledRoute {
   if (!aot) return compileDynamic(options);
   return compileAot(options);
 }

package/src/compiler/effects-infer.ts

@@ -105,15 +105,7 @@ const READ_METHODS = new Set([
   "find",
 ]);
 
-const WRITE_METHODS = new Set([
-  "insert",
-  "set",
-  "delete",
-  "increment",
-  "update",
-  "upsert",
-  "log",
-]);
+const WRITE_METHODS = new Set(["insert", "set", "delete", "increment", "update", "upsert", "log"]);
 
 /** Methods whose first argument is a table / collection identifier. */
 const TABLE_ARG_METHODS = new Set([
@@ -204,19 +196,13 @@ export function inferEffects(options: InferEffectsOptions): InferredEffects {
       // the sibling call that carries the table arg records the real resource.
       const leaf = resolved.methods[resolved.methods.length - 1]!;
       const hasTable = tableFromStoreChain(call) !== undefined;
-      if (
-        !hasTable &&
-        (leaf === "select" || leaf === "insert" || leaf === "update")
-      ) {
+      if (!hasTable && (leaf === "select" || leaf === "insert" || leaf === "update")) {
         continue;
       }
       // Intermediate chain links that only forward (where/values/returning)
       // still carry read/write from earlier methods — record once we have a table
       // or a terminal key-based op.
-      if (
-        !hasTable &&
-        (leaf === "where" || leaf === "values" || leaf === "returning")
-      ) {
+      if (!hasTable && (leaf === "where" || leaf === "values" || leaf === "returning")) {
         continue;
       }
       if (op === "read" || op === "both") reads.add(resolved.resource);
@@ -306,10 +292,7 @@ export function fxMemberChain(call: CallExpression): FxChain | null {
     const prop = (member.property as Identifier).name;
     methods.unshift(prop);
 
-    if (
-      member.object.type === "Identifier" &&
-      (member.object as Identifier).name === "fx"
-    ) {
+    if (member.object.type === "Identifier" && (member.object as Identifier).name === "fx") {
       rootCall = current;
       rootMethod = prop;
       break;
@@ -377,9 +360,7 @@ export function storeResourceFromCall(
   const literal = stringArg(storeArg);
   if (literal) {
     return {
-      resource: (literal.includes(":")
-        ? literal
-        : `${facet}:${literal}`) as ResourceRef,
+      resource: (literal.includes(":") ? literal : `${facet}:${literal}`) as ResourceRef,
       methods: chain.methods,
     };
   }
@@ -418,9 +399,7 @@ function tableFromStoreChain(call: CallExpression): string | undefined {
   return undefined;
 }
 
-function classifyStoreMethods(
-  methods: string[],
-): "read" | "write" | "both" | "none" {
+function classifyStoreMethods(methods: string[]): "read" | "write" | "both" | "none" {
   const ops = methods.slice(1);
   let read = false;
   let write = false;
@@ -490,9 +469,7 @@ export function stringArg(node: AstNode | undefined): string | undefined {
     const quasis = (node as AstNode & { quasis?: AstNode[] }).quasis;
     const exprs = (node as AstNode & { expressions?: AstNode[] }).expressions;
     if (quasis?.length === 1 && (exprs?.length ?? 0) === 0) {
-      const cooked = (
-        quasis[0] as AstNode & { value?: { cooked?: string } }
-      ).value?.cooked;
+      const cooked = (quasis[0] as AstNode & { value?: { cooked?: string } }).value?.cooked;
       if (typeof cooked === "string") return cooked;
     }
   }
@@ -530,10 +507,7 @@ function containsAuthUserId(root: AstNode): boolean {
     };
     if (auth.property.type !== "Identifier") return;
     if ((auth.property as Identifier).name !== "auth") return;
-    if (
-      auth.object.type === "Identifier" &&
-      (auth.object as Identifier).name === "fx"
-    ) {
+    if (auth.object.type === "Identifier" && (auth.object as Identifier).name === "fx") {
       found = true;
     }
   });

package/src/compiler/emit.ts

@@ -22,9 +22,7 @@ export interface EmitManifestOptions {
  * @param options - Path and document
  * @returns Absolute path written
  */
-export async function emitManifest(
-  options: EmitManifestOptions,
-): Promise<string> {
+export async function emitManifest(options: EmitManifestOptions): Promise<string> {
   const text = serializeManifest(options.manifest);
   await Bun.write(options.path, text);
   return options.path;

package/src/compiler/extract.test.ts

@@ -1,24 +1,15 @@
 import { describe, expect, test } from "bun:test";
 
-import {
-  deepMatch,
-  extractFromSources,
-  extractManifest,
-} from "./extract.ts";
+import { deepMatch, extractFromSources, extractManifest } from "./extract.ts";
 import { emitManifest, manifestPathIn } from "./emit.ts";
 import { serializeManifest } from "../manifest/validate.ts";
 import type { Manifest } from "../manifest/types.ts";
 
 const skyportRoot = new URL("./fixtures/skyport/", import.meta.url).pathname;
 const goldenUrl = new URL("./fixtures/skyport.expected.json", import.meta.url);
-const excerptUrl = new URL(
-  "../manifest/fixtures/skyport.excerpt.json",
-  import.meta.url,
-);
+const excerptUrl = new URL("../manifest/fixtures/skyport.excerpt.json", import.meta.url);
 
-async function loadSkyportFiles(): Promise<
-  { path: string; source: string }[]
-> {
+async function loadSkyportFiles(): Promise<{ path: string; source: string }[]> {
   const glob = new Bun.Glob("**/*.{ts,tsx}");
   const files: { path: string; source: string }[] = [];
   for await (const path of glob.scan({ cwd: skyportRoot, onlyFiles: true })) {
@@ -71,33 +62,23 @@ describe("extractManifest — five trigger types", () => {
     expect(manifest.flows?.["triggers.http"]?.trigger).toEqual({
       http: { method: "POST", path: "/orders" },
     });
-    expect(manifest.flows?.["triggers.http"]?.effects?.writes).toEqual([
-      "sql:orders",
-    ]);
+    expect(manifest.flows?.["triggers.http"]?.effects?.writes).toEqual(["sql:orders"]);
 
     expect(manifest.flows?.["triggers.every"]?.trigger).toEqual({
       every: "10m",
     });
-    expect(manifest.flows?.["triggers.every"]?.effects?.writes).toEqual([
-      "sql:links",
-    ]);
+    expect(manifest.flows?.["triggers.every"]?.effects?.writes).toEqual(["sql:links"]);
 
     expect(manifest.flows?.["triggers.signal"]?.trigger).toEqual({
       signal: "link-clicked",
     });
-    expect(manifest.flows?.["triggers.signal"]?.effects?.writes).toContain(
-      "sql:links",
-    );
-    expect(manifest.flows?.["triggers.signal"]?.effects?.emits).toContain(
-      "link-clicked",
-    );
+    expect(manifest.flows?.["triggers.signal"]?.effects?.writes).toContain("sql:links");
+    expect(manifest.flows?.["triggers.signal"]?.effects?.emits).toContain("link-clicked");
 
     expect(manifest.flows?.["triggers.cdc"]?.trigger).toEqual({
       cdc: { table: "orders", column: "status" },
     });
-    expect(manifest.flows?.["triggers.cdc"]?.effects?.writes).toEqual([
-      "sql:orders",
-    ]);
+    expect(manifest.flows?.["triggers.cdc"]?.effects?.writes).toEqual(["sql:orders"]);
 
     // internal trigger → no trigger key (call-only), or empty trigger object
     const internal = manifest.flows?.["triggers.internal"];
@@ -119,9 +100,7 @@ describe("extractManifest — fx.raw", () => {
 
     expect(manifest.flows?.["raw.unannotated"]?.cache).toBe(false);
     expect(manifest.flows?.["raw.annotated"]?.cache).toBeUndefined();
-    expect(manifest.flows?.["raw.annotated"]?.effects?.reads).toEqual([
-      "sql:orders",
-    ]);
+    expect(manifest.flows?.["raw.annotated"]?.effects?.reads).toEqual(["sql:orders"]);
   });
 });
 
@@ -175,3 +154,130 @@ describe("serializeManifest stability", () => {
     expect(again).toEqual(manifest);
   });
 });
+
+describe("extractManifest — relational with: is never expanded (path b)", () => {
+  test("findMany({ with: { daily: true } }) records no related-table effects", async () => {
+    const source = `
+import { on, flow, http, store } from "okengine";
+
+export const db = store.sql("db");
+export const links = { name: "links" };
+export const daily = { name: "daily" };
+
+export const listLinks = on(
+  http.get("/links"),
+  flow({
+    name: "rel.root",
+    do: async (_input, fx) => {
+      return fx.store(db).select().from(links);
+    },
+  }),
+);
+
+// Hypothetical RQB-shaped call. inferEffects never consults schema
+// relations, so the related table must NOT appear in effects.
+export const withDaily = on(
+  http.get("/links/with-daily"),
+  flow({
+    name: "rel.with",
+    do: async (_input, fx) => {
+      return fx.store(db).findMany({ with: { daily: true } });
+    },
+  }),
+);
+`;
+    const manifest = await extractFromSources({ "src/flows/rel.ts": source });
+
+    // Root-table read stays exact.
+    expect(manifest.flows?.["rel.root"]?.effects?.reads).toEqual(["sql:links"]);
+
+    // The with: argument is not walked — falls back to the store-level
+    // resource, never the relation target.
+    expect(manifest.flows?.["rel.with"]?.effects?.reads).toEqual(["sql:db"]);
+
+    const allEffects = Object.values(manifest.flows ?? {}).flatMap((f) => [
+      ...(f.effects?.reads ?? []),
+      ...(f.effects?.writes ?? []),
+    ]);
+    expect(allEffects).not.toContain("sql:daily");
+  });
+});
+
+describe("extractManifest — store.schema.table", () => {
+  test("extracts DeclaredColumn with PII into manifest stores", async () => {
+    const source = `
+import { store, field, id, now } from "okengine";
+
+export const notes = store.schema.table("notes", {
+  id: field.text().primaryKey().defaultFn(id),
+  title: field.text().notNull(),
+  body: field.text().notNull().pii(),
+  createdAt: field.integer().notNull().defaultFn(now),
+});
+
+export const db = store.sql("app", { schema: { notes } });
+`;
+    const manifest = await extractFromSources({
+      "src/schema.decl.ts": source,
+    });
+
+    expect(manifest.stores?.app?.facet).toBe("sql");
+    const cols = manifest.stores?.app?.tables?.notes?.columns;
+    expect(cols?.body).toMatchObject({
+      type: "text",
+      pii: true,
+      nullable: false,
+      sqlName: "body",
+    });
+    expect(cols?.createdAt).toMatchObject({
+      type: "integer",
+      sqlName: "created_at",
+      nullable: false,
+    });
+    expect(cols?.id).toMatchObject({
+      type: "text",
+      primaryKey: true,
+      sqlName: "id",
+    });
+  });
+});
+
+describe("extractManifest — on(http.resource(...))", () => {
+  test("expands the mount into five CRUD bindings with store effects", async () => {
+    const source = `
+import { on, http, store } from "okengine";
+
+export const db = store.sql("notes", { schema: {} });
+
+const notesR = store.resource(db, {}, { unit: "notes", breaking: true });
+
+const mounted = on(http.resource("/notes", notesR.all()));
+
+export const list = mounted.list;
+export const create = mounted.create;
+export const get = mounted.get;
+export const update = mounted.update;
+export const remove = mounted.remove;
+`;
+    const manifest = await extractFromSources({ "src/flows/notes.ts": source });
+
+    expect(manifest.flows?.list?.trigger).toEqual({
+      http: { method: "GET", path: "/notes" },
+    });
+    expect(manifest.flows?.create?.trigger).toEqual({
+      http: { method: "POST", path: "/notes" },
+    });
+    expect(manifest.flows?.get?.trigger).toEqual({
+      http: { method: "GET", path: "/notes/:id" },
+    });
+    expect(manifest.flows?.update?.trigger).toEqual({
+      http: { method: "PATCH", path: "/notes/:id" },
+    });
+    expect(manifest.flows?.remove?.trigger).toEqual({
+      http: { method: "DELETE", path: "/notes/:id" },
+    });
+    expect(manifest.flows?.list?.effects?.reads).toEqual(["sql:notes"]);
+    expect(manifest.flows?.create?.effects?.writes).toEqual(["sql:notes"]);
+    expect(manifest.flows?.list?.breaking).toBe(true);
+  });
+});