okengine 0.18.4 → 0.19.0

package/src/kernel/live-http.test.ts

@@ -1,5 +1,5 @@
 /**
- * Live HTTP exposure uniqueness (OKE1013) and GET-only synthesis.
+ * Live HTTP exposure uniqueness (OKE1050) and GET-only synthesis.
  */
 
 import { describe, expect, test, beforeEach } from "bun:test";
@@ -17,8 +17,7 @@ const admin = gate.policy("admin", ({ auth }) => !!auth.verified);
 const partner = gate.policy("partner", ({ auth }) => !!auth.verified);
 
 const orderStatus = () =>
-  signal("order-status", {
-    delivery: "live",
+  signal.live("order-status", {
     optional: true,
     schema: z.object({
       orderId: z.string(),
@@ -51,22 +50,22 @@ describe("live HTTP uniqueness", () => {
     expect(() => oke({ name: "t", autoBoot: false })).not.toThrow();
   });
 
-  test("two member firehoses on different paths fail OKE1013", () => {
+  test("two member firehoses on different paths fail OKE1050", () => {
     const sig = orderStatus();
     const a = on(http.get("/feed-a").gate(member).live(sig));
     const b = on(http.get("/feed-b").gate(member).live(sig));
     stampFlowName(a, "orders.feedA");
     stampFlowName(b, "orders.feedB");
-    expect(() => oke({ name: "t", autoBoot: false })).toThrow(/OKE1013/);
+    expect(() => oke({ name: "t", autoBoot: false })).toThrow(/OKE1050/);
   });
 
-  test("duplicate GET path still OKE1011", () => {
+  test("duplicate GET path still OKE1041", () => {
     const sig = orderStatus();
     const a = on(http.get("/orders/:orderId/events").gate(member).live(sig));
     const b = on(http.get("/orders/:orderId/events").gate(admin).live(sig));
     stampFlowName(a, "orders.events");
     stampFlowName(b, "admin.events");
-    expect(() => oke({ name: "t", autoBoot: false })).toThrow(/OKE1011/);
+    expect(() => oke({ name: "t", autoBoot: false })).toThrow(/OKE1041/);
   });
 
   test("POST .live(signal) is rejected", () => {

package/src/kernel/live-http.ts

@@ -4,6 +4,7 @@
 
 import type { SignalDecl } from "../elements/signal/declare.ts";
 import type { SignalResourceRef } from "../manifest/types.ts";
+import { applyBoundaryContract, stampBoundaryContract } from "./boundary-contract.ts";
 import type { Fx } from "./fx.ts";
 import { flow, type AnyFlowDef } from "./flow.ts";
 import type { GateRef, SignalSource } from "./triggers.ts";
@@ -103,12 +104,15 @@ export function synthesizeLiveFlow(signal: SignalSource, path: string): AnyFlowD
   const fields = httpPathParams(path);
   const name = signal.name;
   const schema = "schema" in signal ? (signal as SignalDecl).schema : undefined;
-  return flow({
+  const def = flow({
     effects: { reads: [`signal:${name}` as SignalResourceRef] },
-    ...(schema !== undefined ? { out: schema } : {}),
     do: (input, fx: Fx) =>
       fx.live(signal, {
         match: (payload) => payloadAutoMatch(payload, input, fields),
       }),
   });
+  if (schema !== undefined) {
+    applyBoundaryContract(def, stampBoundaryContract({ out: schema as never }));
+  }
+  return def;
 }

package/src/kernel/live-resume.test.ts

@@ -24,7 +24,7 @@ describe("live Last-Event-ID resume", () => {
   });
 
   test("skips through Last-Event-ID and 410s a pruned cursor", async () => {
-    const orderStatus = signal("order-status", { delivery: "live", optional: true });
+    const orderStatus = signal.live("order-status", { optional: true });
     const feed = on(http.get("/feed").public().live(orderStatus));
     stampFlowName(feed, "orders.feed");
     on(

package/src/kernel/mcp-tool.test.ts

@@ -1,6 +1,6 @@
 /**
  * MCP tool trigger — name validation, gated registration lookup,
- * duplicate-name boot failure (OKE1018), gate posture, and Manifest stamping.
+ * duplicate-name boot failure (OKE1060), gate posture, and Manifest stamping.
  */
 
 import { describe, expect, test, beforeEach } from "bun:test";
@@ -47,7 +47,7 @@ describe("mcp.tool(name)", () => {
     expect(app.resolveMcpTool("other.action")).toBeUndefined();
   });
 
-  test("duplicate tool name fails OKE1018 at construction", () => {
+  test("duplicate tool name fails OKE1060 at construction", () => {
     on(
       mcp.tool("bookings.create").gate(member),
       flow("bookings.create", { plane: "user", do: () => ({ ok: true }) }),
@@ -56,7 +56,7 @@ describe("mcp.tool(name)", () => {
       mcp.tool("bookings.create").gate(member),
       flow("bookings.also", { plane: "user", do: () => ({ ok: true }) }),
     );
-    expect(() => oke({ name: "t", autoBoot: false })).toThrow(/OKE1018/);
+    expect(() => oke({ name: "t", autoBoot: false })).toThrow(/OKE1060/);
   });
 
   test("ungated mcp.tool passes on() but fails gate posture at boot", async () => {

package/src/kernel/on.ts

@@ -6,6 +6,8 @@
  * The return type carries the bound trigger so `typeof app` can derive REST.
  */
 
+import type { ClockDecl } from "../elements/clock/declare.ts";
+import type { InferBoundaryIn, InferBoundaryOut } from "./boundary-contract.ts";
 import { isFlow, type AnyFlowDef, type FlowDef, type FlowErrorMap } from "./flow.ts";
 import { lazyRequire } from "./lazy-require.ts";
 import {
@@ -15,8 +17,10 @@ import {
   type HttpMethod,
   type HttpTrigger,
   type LiveHttpTrigger,
+  type McpToolTrigger,
   type ResourceFlowBag,
   type ResourceMount,
+  type SignalAsTrigger,
   type SignalSource,
   type Trigger,
 } from "./triggers.ts";
@@ -38,15 +42,65 @@ export interface Binding {
 
 const bindings: Binding[] = [];
 
+/**
+ * Invoke-contract bag on an HTTP / MCP exposure (type parameter), if any.
+ *
+ * @typeParam T - Bound trigger
+ */
+type ExposureContractOf<T> =
+  BoundTriggerOf<T> extends HttpTrigger<HttpMethod, string, infer C>
+    ? C
+    : BoundTriggerOf<T> extends McpToolTrigger<infer C>
+      ? C
+      : undefined;
+
+/**
+ * Input type for `on(trigger, flow)` — exposure `in` wins over the handler.
+ *
+ * @typeParam T - Trigger argument
+ * @typeParam Fallback - FlowDef input from `flow()`
+ */
+type InferOnIn<T, Fallback> =
+  ExposureContractOf<T> extends { readonly in: unknown }
+    ? InferBoundaryIn<ExposureContractOf<T>>
+    : Fallback;
+
+/**
+ * Output type for `on(trigger, flow)` — exposure `out` wins over the handler.
+ *
+ * @typeParam T - Trigger argument
+ * @typeParam Fallback - FlowDef output from `flow()`
+ */
+type InferOnOut<T, Fallback> =
+  ExposureContractOf<T> extends { readonly out: unknown }
+    ? InferBoundaryOut<ExposureContractOf<T>>
+    : Fallback;
+
+/**
+ * Error map for `on(trigger, flow)` — exposure `errors` wins over Flow defaults.
+ *
+ * @typeParam T - Trigger argument
+ * @typeParam Fallback - FlowDef error map from `flow()`
+ */
+type InferOnErrors<T, Fallback extends FlowErrorMap> =
+  ExposureContractOf<T> extends {
+    readonly errors: infer E extends FlowErrorMap;
+  }
+    ? E
+    : Fallback;
+
 /**
  * Bind a trigger to a Flow. Returns the same Flow (one species) with the
  * trigger stamped into the type parameter for client route derivation.
+ * When the trigger carries an invoke contract (`http.*` / `mcp.tool` bag),
+ * `in` / `out` / `errors` are projected onto the returned {@link FlowDef}
+ * (same as {@link import("./call.ts").call}).
  *
- * @param trigger - HTTP, every, signal handle, CDC, or internal
+ * @param trigger - HTTP, named clock, signal handle, CDC, or internal
  * @param flowDef - Flow definition
  */
 export function on<
-  T extends Trigger | SignalSource,
+  T extends Trigger | SignalSource | ClockDecl,
   I = unknown,
   O = unknown,
   E extends FlowErrorMap = FlowErrorMap,
@@ -54,7 +108,7 @@ export function on<
 >(
   trigger: T,
   flowDef: FlowDef<I, O, E, D, Trigger | undefined>,
-): FlowDef<I, O, E, D, BoundTriggerOf<T>>;
+): FlowDef<InferOnIn<T, I>, InferOnOut<T, O>, InferOnErrors<T, E>, D, BoundTriggerOf<T>>;
 /**
  * Expose a live signal: `on(http.get(path).gate(g).live(signal))`.
  * Synthesizes the stream Flow (name stamped by `.adopt`).
@@ -73,7 +127,7 @@ export function on<T extends LiveHttpTrigger<HttpMethod, string>>(
  */
 export function on(mount: ResourceMount): ResourceFlowBag;
 export function on(
-  triggerOrMount: Trigger | SignalSource | ResourceMount,
+  triggerOrMount: Trigger | SignalSource | ClockDecl | ResourceMount,
   flowDef?: FlowDef<any, any, any, any, Trigger | undefined>,
 ): unknown {
   if (isResourceMount(triggerOrMount)) {
@@ -149,10 +203,50 @@ export function on(
   list.push(normalized);
   // Stamp runtime carrier for the first bound trigger (type follows BoundTriggerOf).
   (flowDef as { $trigger: Trigger }).$trigger = normalized;
+  stampExposureContract(flowDef as AnyFlowDef, normalized, triggerOrMount);
   bindings.push({ trigger: normalized, flow: flowDef as AnyFlowDef });
   return flowDef;
 }
 
+/**
+ * Project invoke / emit contract from the exposure onto the FlowDef for
+ * Manifest, validation, and typed client (flat `flows.*.in/out/errors`).
+ *
+ * Inlined so the edge profile does not pull `boundary-contract` helpers
+ * (`call()` / live-http / store.resource still import those from their graphs).
+ */
+function stampExposureContract(
+  flowDef: AnyFlowDef,
+  normalized: Trigger,
+  raw: Trigger | SignalSource | ClockDecl,
+): void {
+  if (normalized.kind === "http" || normalized.kind === "mcp") {
+    const bag = (normalized as HttpTrigger | McpToolTrigger).contract;
+    if (bag === undefined) return;
+    flowDef.in = bag.in as AnyFlowDef["in"];
+    flowDef.out = bag.out as AnyFlowDef["out"];
+    flowDef.errors = bag.errors as AnyFlowDef["errors"];
+    if (bag.breaking) flowDef.breaking = true;
+    return;
+  }
+  if (normalized.kind !== "signal") return;
+  const handle =
+    (normalized as SignalAsTrigger).signal ?? (isSignalSourceWithSchema(raw) ? raw : undefined);
+  const schema =
+    handle && typeof handle === "object" && "schema" in handle
+      ? (handle as { schema?: unknown }).schema
+      : undefined;
+  if (schema !== undefined && flowDef.in === undefined) {
+    flowDef.in = schema as AnyFlowDef["in"];
+    flowDef.out = undefined;
+    flowDef.errors = undefined;
+  }
+}
+
+function isSignalSourceWithSchema(value: unknown): value is SignalSource & { schema?: unknown } {
+  return typeof value === "object" && value !== null && "name" in value;
+}
+
 /**
  * Snapshot of all bindings registered since the last reset.
  */

package/src/kernel/pipeline.test.ts

@@ -79,10 +79,13 @@ describe("pipeline — Unauthorized for anonymous", () => {
     resetFlowSeq();
 
     on(
-      http.post("/orders").gate(member),
+      http
+        .post("/orders", {
+          in: z.object({ sku: z.string() }),
+          out: z.object({ id: z.string() }),
+        })
+        .gate(member),
       flow("orders.create", {
-        in: z.object({ sku: z.string() }),
-        out: z.object({ id: z.string() }),
         do: (_input, fx) => ({ id: fx.id() }),
       }),
     );
@@ -117,9 +120,8 @@ describe("pipeline — Unauthorized for anonymous", () => {
     resetFlowSeq();
 
     on(
-      http.post("/orders").gate(member, canOrder),
+      http.post("/orders", { in: z.object({ sku: z.string() }) }).gate(member, canOrder),
       flow("orders.create2", {
-        in: z.object({ sku: z.string() }),
         do: () => ({ ok: true }),
       }),
     );
@@ -154,9 +156,8 @@ describe("pipeline — Unauthorized for anonymous", () => {
 
     const write = gate.all(member, canOrder);
     on(
-      http.post("/orders").gate(write),
+      http.post("/orders", { in: z.object({ sku: z.string() }) }).gate(write),
       flow("orders.createAll", {
-        in: z.object({ sku: z.string() }),
         do: () => ({ ok: true }),
       }),
     );
@@ -201,9 +202,8 @@ describe("pipeline — evaluated gates on the run", () => {
     resetFlowSeq();
 
     on(
-      http.post("/orders").gate(member, canOrder),
+      http.post("/orders", { in: z.object({ sku: z.string() }) }).gate(member, canOrder),
       flow("orders.create3", {
-        in: z.object({ sku: z.string() }),
         do: () => ({ ok: true }),
       }),
     );
@@ -361,9 +361,8 @@ describe("pipeline — Bearer cryptographic verification", () => {
     resetFlowSeq();
 
     on(
-      http.post("/orders").gate(member),
+      http.post("/orders", { in: z.object({ sku: z.string() }) }).gate(member),
       flow("orders.inject", {
-        in: z.object({ sku: z.string() }),
         do: () => ({ ok: true }),
       }),
     );
@@ -413,9 +412,8 @@ describe("pipeline — Bearer cryptographic verification", () => {
     resetFlowSeq();
 
     on(
-      http.post("/orders").gate(member),
+      http.post("/orders", { in: z.object({ sku: z.string() }) }).gate(member),
       flow("orders.trusted", {
-        in: z.object({ sku: z.string() }),
         do: (_input, fx) => ({ userId: fx.auth.userId }),
       }),
     );
@@ -467,9 +465,8 @@ describe("pipeline — Bearer cryptographic verification", () => {
     resetFlowSeq();
 
     on(
-      http.post("/orders").gate(member),
+      http.post("/orders", { in: z.object({ sku: z.string() }) }).gate(member),
       flow("orders.bypass", {
-        in: z.object({ sku: z.string() }),
         do: (_input, fx) => ({ userId: fx.auth.userId }),
       }),
     );

package/src/kernel/plugin-elements.test.ts

@@ -21,7 +21,7 @@ describe("plugin element contributions", () => {
       dev: "test-otp-signing-key",
     });
     const expire = clock("expire-otp", { every: "1m" });
-    const bus = signal("otp.events", { delivery: "once" });
+    const bus = signal.once("otp.events");
     const member = gate.policy("plugin-member", ({ auth }) => !!auth.verified);
 
     const twoFactor = plugin("twoFactor-scaffold", { version: "0.0.1" })

package/src/kernel/stamp-http.test.ts

@@ -54,18 +54,18 @@ describe("stampFlowName", () => {
 describe("oke — unresolved sentinel and duplicate routes", () => {
   test("unresolved http.get() fails construction", () => {
     on(http.get().public(), flow("notes.get", { do: () => 1 }));
-    expect(() => oke({ name: "t", autoBoot: false })).toThrow(/OKE1010/);
+    expect(() => oke({ name: "t", autoBoot: false })).toThrow(/OKE1040/);
   });
 
   test("duplicate GET /notes fails construction", () => {
     on(http.get("/notes").public(), flow("notes.list", { do: () => 1 }));
     on(http.get("/notes").public(), flow("notes.also", { do: () => 1 }));
-    expect(() => oke({ name: "t", autoBoot: false })).toThrow(/OKE1011/);
+    expect(() => oke({ name: "t", autoBoot: false })).toThrow(/OKE1041/);
   });
 
   test("nameless HTTP flow fails construction", () => {
     on(http.get("/notes").public(), flow({ do: () => 1 }));
-    expect(() => oke({ name: "t", autoBoot: false })).toThrow(/OKE1012/);
+    expect(() => oke({ name: "t", autoBoot: false })).toThrow(/OKE1045/);
   });
 
   test("registerFlowUnits drains into $routes; registry ignore does not", () => {