@jr2/orchestrator 0.5.1 → 0.7.0

package/src/http-effect.ts

@@ -50,6 +50,7 @@ import type {
   EffectLogic,
   EffectMarker,
   EffectRow,
+  EffectParts,
   EffectSnapshot,
   HttpParts,
   OpenHttpParts,
@@ -77,6 +78,7 @@ import {
   type WireBody,
 } from "./effector-wire.ts";
 import { boundRun, type AnyActorSystem } from "./registration.ts";
+import type { AnyWorktreePath } from "./worktree.ts";
 import { open } from "./open.ts";
 import { effectBindingShape, openEffectLogic, openPartsOf, type OpenOf } from "./open-effect.ts";
 import { httpFileWith, sandboxEffectorPort } from "./sandbox-effect.ts";
@@ -105,9 +107,9 @@ declare const openSecretMark: unique symbol;
  */
 export type OpenSecretMark = { readonly [openSecretMark]: true };
 
-/** A named secret, never `secret(open)`: where a definition's Open part is a whole that holds a
- * secret — a dispatch's target (ADR-0071) — the secret is bound with it, to a name, so the mark
- * `secret(open)` carries may not be present. One type for the definition and the binding. */
+/** A secret bound to a name, never `secret(open)`. Where a definition's Open part is a whole that
+ * holds a secret — a dispatch's target (ADR-0071) — the secret is bound with it, to a name, so the
+ * mark `secret(open)` carries may not be present. One type for the definition and the binding. */
 export type NamedSecret = Secret & { readonly [K in keyof OpenSecretMark]?: never };
 
 /** `secret(open)`: a secret a packaged Machine names in its auth, a header or a command's env, and
@@ -169,13 +171,25 @@ const openSecretOf = new WeakMap<object, object>();
  *
  * @example
  * ```ts
- * import { command, fail, jr2Setup, secret, workspace, type Workspaced } from "@jr2/orchestrator";
+ * import {
+ *   command,
+ *   fail,
+ *   isReady,
+ *   jr2Setup,
+ *   secret,
+ *   workspace,
+ *   worktree,
+ *   type Workspaced,
+ * } from "@jr2/orchestrator";
  *
  * type Input = Workspaced<{}, "app">;
  *
+ * const deployTree = (context: Input) => `${context.workspace.repos.app}/deploy` as const;
+ *
  * const body = jr2Setup({
  *   types: {} as { context: Input; input: Input },
  *   actors: {
+ *     cut: worktree(),
  *     // The command reads the file at $KUBECONFIG. The Agent never reads the secret.
  *     deploy: command(["kubectl", "apply", "-f", "k8s/"], {
  *       env: { KUBECONFIG: secret("kube").path },
@@ -186,17 +200,26 @@ const openSecretOf = new WeakMap<object, object>();
  *   id: "deploy",
  *   context: ({ input }) => input,
  *   on: { "workspace.lost": ".lost" },
- *   initial: "deploying",
+ *   initial: "cutting",
  *   states: {
- *     deploying: { invoke: { src: "deploy", onDone: "done" } },
+ *     cutting: {
+ *       invoke: {
+ *         src: "cut",
+ *         input: ({ context }) => ({ path: deployTree(context), branch: "deploy" }),
+ *         onDone: [{ guard: ({ event }) => isReady(event.output), target: "deploying" }, { target: "notCut" }],
+ *       },
+ *     },
+ *     deploying: {
+ *       invoke: { src: "deploy", input: ({ context }) => ({ worktree: deployTree(context) }), onDone: "done" },
+ *     },
  *     done: { type: "final" },
+ *     notCut: { invoke: { src: "fail", input: { reason: "the Worktree was not cut" } } },
  *     lost: { invoke: { src: "fail", input: { reason: "the Sandbox is gone" } } },
  *   },
  * });
  *
  * export const machine = workspace(body, {
  *   repos: { app: { url: "https://github.com/you/app.git" } },
- *   spec: () => ({ branch: "deploy" }),
  * });
  * ```
  *
@@ -501,15 +524,12 @@ function asText(v: string | Secret | Text): Text {
 /** A value of a file body's part: as written, or from the Effect's input. */
 export type FromInput<S, T> = T | ((input: S extends z.ZodType ? z.infer<S> : void) => T);
 
-/** `file(path, { slot?, segments?, contentType? })`: a Worktree file as an `http` body. */
+/** `file(path, { segments?, contentType? })`: a Worktree file as an `http` body. */
 export type FileBody<S extends z.ZodType | undefined = undefined> = {
   readonly file: {
-    /** The file, relative to the Repo Slot's Worktree, or to `/work` in a Workspace with no Repo
-     * Slot. */
+    /** The file, relative to the Worktree that `worktree` of the Effect's input names, or to `/work`
+     * in a Workspace with no Repo Slot. */
     readonly path: FromInput<S, string>;
-    /** The Repo Slot whose Worktree holds it. Write it only when the Workspace has more than one.
-     */
-    readonly slot?: string;
     /** Path segments that jr2 adds to the end of the url, as `path` of `request` does for a json
      * or text body. */
     readonly segments?: FromInput<S, readonly string[]>;
@@ -521,14 +541,18 @@ export type FileBody<S extends z.ZodType | undefined = undefined> = {
 
 /**
  * Make a Worktree file the body of an `http` Effect: `body: file("dist/report.pdf")`. The Effect
- * then runs in the Sandbox Effector of the Workspace whose body invokes it. That Effector opens the
- * file in the Worktree and sends it. In a Workspace with no Repo Slot, the path is relative to
+ * then runs in the Sandbox Effector of the Workspace whose body invokes it. Under a Workspace with
+ * Repo Slots, the invoke's input names the Worktree: `input: { worktree: "/work/app/fix" }`. It is a
+ * Worktree that a cut of this run made. That Effector opens the file in that Worktree and sends it.
+ * In a Workspace with no Repo Slot, the input names no `worktree`, and the path is relative to
  * `/work`, the folder that its steps share. Use it with `PUT`, `POST` or `PATCH`. `path` and
  * `segments` can be functions of the input of the Effect.
  *
- * Some paths and files give the output `refused`, and then nothing is sent. The path has a symlink
- * in it, has `..`, or is absolute. Or the file is a FIFO, a directory, or a file with more than one
- * link.
+ * Some inputs, paths and files give the output `refused`, and then nothing is sent. The `worktree`
+ * has no cut in this Sandbox: `no cut made <path> in this Sandbox: cut it with worktree(); nothing
+ * was sent`. Or the input names a `worktree` in a Workspace with no Repo Slot. Or the path has a
+ * symlink in it, has `..`, or is absolute. Or the file is a FIFO, a directory, or a file with more
+ * than one link.
  *
  * It refuses, when you call it:
  * - a path that is not a string or a function: `file(path): the path is a string, or a function of
@@ -548,8 +572,13 @@ export type FileBody<S extends z.ZodType | undefined = undefined> = {
  * there is no Worktree to read; invoke it from a workspace()'s body, or send a json or text body
  * (ADR-0068)`.
  *
- * @param path - The file, relative to the Worktree of the Repo Slot, or to `/work` in a Workspace
- *   with no Repo Slot: a string, or a function of the input of the Effect that gives one.
+ * And when it starts, under a Workspace with Repo Slots, an input with no `worktree`: ``http
+ * "<slot>" reads a Worktree file, under a Workspace with Repo Slots, and its input names no
+ * `worktree` ``.
+ *
+ * @param path - The file, relative to the Worktree that `worktree` of the input names, or to
+ *   `/work` in a Workspace with no Repo Slot: a string, or a function of the input of the Effect
+ *   that gives one.
  * @param options - Optional. Each field says what it does.
  * @returns The `body` of an `http` Effect.
  *
@@ -561,17 +590,22 @@ export type FileBody<S extends z.ZodType | undefined = undefined> = {
  *   fail,
  *   file,
  *   http,
+ *   isReady,
  *   jr2Setup,
  *   secret,
  *   workspace,
+ *   worktree,
  *   type Workspaced,
  * } from "@jr2/orchestrator";
  *
  * type Input = Workspaced<{}, "app">;
  *
+ * const reportTree = (context: Input) => `${context.workspace.repos.app}/report` as const;
+ *
  * const body = jr2Setup({
  *   types: {} as { context: Input; input: Input },
  *   actors: {
+ *     cut: worktree(),
  *     build: command(["npm", "run", "report"]),
  *     upload: http({
  *       method: "PUT",
@@ -588,18 +622,29 @@ export type FileBody<S extends z.ZodType | undefined = undefined> = {
  *   id: "report",
  *   context: ({ input }) => input,
  *   on: { "workspace.lost": ".lost" },
- *   initial: "building",
+ *   initial: "cutting",
  *   states: {
- *     building: { invoke: { src: "build", onDone: "uploading" } },
- *     uploading: { invoke: { src: "upload", onDone: "done" } },
+ *     cutting: {
+ *       invoke: {
+ *         src: "cut",
+ *         input: ({ context }) => ({ path: reportTree(context), branch: "report" }),
+ *         onDone: [{ guard: ({ event }) => isReady(event.output), target: "building" }, { target: "notCut" }],
+ *       },
+ *     },
+ *     building: {
+ *       invoke: { src: "build", input: ({ context }) => ({ worktree: reportTree(context) }), onDone: "uploading" },
+ *     },
+ *     uploading: {
+ *       invoke: { src: "upload", input: ({ context }) => ({ worktree: reportTree(context) }), onDone: "done" },
+ *     },
  *     done: { type: "final" },
+ *     notCut: { invoke: { src: "fail", input: { reason: "the Worktree was not cut" } } },
  *     lost: { invoke: { src: "fail", input: { reason: "the Sandbox is gone" } } },
  *   },
  * });
  *
  * export const machine = workspace(body, {
  *   repos: { app: { url: "https://github.com/you/app.git" } },
- *   spec: () => ({ branch: "report" }),
  * });
  * ```
  *
@@ -610,9 +655,6 @@ export type FileBody<S extends z.ZodType | undefined = undefined> = {
 export function file<S extends z.ZodType | undefined = undefined>(
   path: FromInput<S, string>,
   options: {
-    /** The Repo Slot whose Worktree holds the file. Write it only when the Workspace has more than
-     * one. */
-    slot?: string;
     /**
      * Path segments that jr2 adds to the end of the url, as `path` does in `request` for a json or
      * text body. A list of strings, or a function of the input of the Effect that gives one.
@@ -633,7 +675,6 @@ export function file<S extends z.ZodType | undefined = undefined>(
   return {
     file: {
       path,
-      ...(options.slot !== undefined ? { slot: options.slot } : {}),
       ...(options.segments !== undefined ? { segments: options.segments } : {}),
       ...(options.contentType !== undefined ? { contentType: options.contentType } : {}),
     },
@@ -723,10 +764,13 @@ export type HttpDefinition<S extends z.ZodType | undefined = undefined> = {
   request?: (input: S extends z.ZodType ? z.infer<S> : void) => HttpRequestParts;
   // A file body is an ADR-0067 Effect: the Sandbox Effector of the Workspace sends it.
   /**
-   * A Worktree file as the body: `file(path, { slot?, segments?, contentType? })`. The Effect then
-   * runs in the Sandbox Effector of its Workspace. Do not write `request` beside it: the `segments`
+   * A Worktree file as the body: `file(path, { segments?, contentType? })`. The Effect then
+   * runs in the Sandbox Effector of its Workspace. Under a Workspace with Repo Slots, the invoke's
+   * input names a Worktree that a cut of this run made, in `worktree`; with none, it refuses when
+   * it starts: ``http "<slot>" reads a Worktree file, under a Workspace with Repo Slots, and its
+   * input names no `worktree` ``. Do not write `request` beside it: the `segments`
    * of `file` are the path. It refuses another body: ``http({ body }): a body is file(path, {
-   * slot?, segments?, contentType? }) — json and text come from `request` ``.
+   * segments?, contentType? }) — json and text come from `request` ``.
    */
   body?: FileBody<S>;
   /**
@@ -755,6 +799,11 @@ export type HttpDefinition<S extends z.ZodType | undefined = undefined> = {
 /** @internal */
 export type HttpInput<S> = S extends z.ZodType ? z.infer<S> : void;
 
+/** The input of an `http` Effect with a Worktree file as its body. Under a Workspace with Repo
+ * Slots, `worktree` names the Worktree. In a Workspace with no Repo Slot, the input has no
+ * `worktree`, and the path is relative to `/work`. */
+export type HttpFileInput<S> = (S extends z.ZodType ? z.infer<S> : unknown) & { worktree?: AnyWorktreePath };
+
 const DEFAULT_TIMEOUT_MS = 30_000;
 const DEFAULT_MAX_BODY = 65_536;
 /** How long a re-asked request waits, at most, after a transport failure. */
@@ -830,7 +879,7 @@ export function httpParts<S extends z.ZodType | undefined>(def: HttpDefinition<S
   const body = def.body?.file;
   if (def.body !== undefined && (typeof body !== "object" || body === null)) {
     throw new Error(
-      "http({ body }): a body is file(path, { slot?, segments?, contentType? }) — json and text come from `request`",
+      "http({ body }): a body is file(path, { segments?, contentType? }) — json and text come from `request`",
     );
   }
   if (body && !FILE_METHODS.includes(def.method)) {
@@ -866,7 +915,6 @@ export function httpParts<S extends z.ZodType | undefined>(def: HttpDefinition<S
     ...(body
       ? {
           file: {
-            ...(body.slot !== undefined ? { slot: body.slot } : {}),
             ...(body.contentType !== undefined ? { contentType: body.contentType } : {}),
           },
         }
@@ -1020,8 +1068,58 @@ export function httpWith<S extends z.ZodType | undefined = undefined>(
   const unbound = openHttpOf(def, (bound) => httpWith(portFactory, bound));
   if (unbound) return unbound as EffectLogic<HttpInput<S>, HttpOutput>;
   const parts = httpParts(def);
-  type I = HttpInput<S>;
-  type O = HttpOutput;
+  return instanceEffectLogic<HttpInput<S>, HttpOutput>(
+    parts,
+    {
+      kind: "http",
+      idempotent: parts.idempotent,
+      label: `${parts.method} ${hostText(parts)}`,
+      request: (input, slot) => {
+        if (def.input !== undefined) {
+          const parsed = def.input.safeParse(input);
+          if (!parsed.success) {
+            throw new Error(
+              `http "${slot}": its input does not match the definition's input schema — ` +
+                parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; "),
+            );
+          }
+          input = parsed.data;
+        }
+        const runParts = def.request ? (def.request as (i: unknown) => HttpRequestParts)(input) : {};
+        return startRequestOf(parts, runParts ?? {});
+      },
+    },
+    portFactory,
+  );
+}
+
+/**
+ * What the Instance Effector's driver needs of one kind that runs there and has no stop: `http`
+ * and `mcp` (ADR-0068, ADR-0079). The driver is the same for both: the write-ahead intent row, the
+ * restore rule, a forged answer, and D1.
+ */
+export type InstanceKind = {
+  readonly kind: "http" | "mcp";
+  /** The author's mark: a restore that finds no replica that holds it sends it again. */
+  readonly idempotent: boolean;
+  /** What the `started` marker says: `POST https://host`, `mcp slack-acme/post_message`. */
+  readonly label: string;
+  /** The run's start, from the invoke's input. It throws on a defect of the Machine, and then
+   * nothing is sent. */
+  readonly request: (input: unknown, slot: string) => StartRequest;
+};
+
+/**
+ * The slot logic of an Effect that the Instance Effector runs, over an injected port factory: the
+ * seam `httpWith` and `mcpWith` share.
+ *
+ * @internal
+ */
+export function instanceEffectLogic<I, O>(
+  parts: EffectParts,
+  spec: InstanceKind,
+  portFactory: EffectorPortFactory,
+): EffectLogic<I, O> {
   const logic: ActorLogic<EffectSnapshot<O, I>, EventObject, I> = {
     getInitialSnapshot: (_scope, input) => ({
       status: "active",
@@ -1039,7 +1137,7 @@ export function httpWith<S extends z.ZodType | undefined = undefined>(
         return { ...snapshot, status: "error", error: (event as Fault).error, input: undefined };
       }
       if (event.type === "xstate.stop") {
-        stopped(self, system, snapshot.effectId);
+        stopped(self, system, snapshot.effectId, spec.kind);
         return { ...snapshot, status: "stopped", input: undefined };
       }
       return snapshot;
@@ -1048,7 +1146,7 @@ export function httpWith<S extends z.ZodType | undefined = undefined>(
       if (snapshot.status !== "active") return;
       const run: Running = { controller: new AbortController() };
       running.set(self, run);
-      void drive(self, system, snapshot, parts, def, portFactory, run).catch((error: unknown) => {
+      void drive(self, system, snapshot, spec, portFactory, run).catch((error: unknown) => {
         if (run.controller.signal.aborted) return;
         if (self.getSnapshot().status === "active") self.send({ type: "jr2.effect.error", error } as Fault);
       });
@@ -1064,8 +1162,7 @@ async function drive<I, O>(
   self: AnyActorRef,
   system: AnyActorSystem,
   snapshot: EffectSnapshot<O, I>,
-  parts: HttpParts,
-  def: HttpDefinition<z.ZodType | undefined>,
+  spec: InstanceKind,
   portFactory: EffectorPortFactory,
   run: Running,
 ): Promise<void> {
@@ -1076,11 +1173,11 @@ async function drive<I, O>(
   const now = (): string => new Date().toISOString();
   const mark = (marker: Omit<EffectMarker, "kind" | "slot" | "effect">): void =>
     binding?.marker?.({ kind: "effect", slot, effect: id, ...marker });
-  const settle = (output: HttpOutput): void => {
+  const settle = (output: NonNullable<EffectMarker["output"]>): void => {
     if (signal.aborted || self.getSnapshot().status !== "active") return;
     // The settled row first, saved at the write: a restart before the transition is saved delivers
     // this output, and sends nothing.
-    binding?.recordEffect?.(id, { state: "settled", kind: "http", slot, output, at: now() });
+    binding?.recordEffect?.(id, { state: "settled", kind: spec.kind, slot, output, at: now() });
     mark({ stage: "settled", output });
     self.send({ type: "jr2.effect.settle", output } satisfies Settle);
   };
@@ -1102,8 +1199,8 @@ async function drive<I, O>(
   const target = binding?.effector?.("instance");
   if (!target) {
     throw new Error(
-      `http "${slot}" runs in the Instance Effector, and this Orchestrator knows none — \`jr2 up\` converges it ` +
-        "when a registered Machine carries an http Effect (ADR-0068)",
+      `${spec.kind} "${slot}" runs in the Instance Effector, and this Orchestrator knows none — \`jr2 up\` ` +
+        `converges it when a registered Machine carries an ${spec.kind} Effect (ADR-0068)`,
     );
   }
   const port = portFactory(target);
@@ -1133,7 +1230,7 @@ async function drive<I, O>(
       await follow(found);
       return;
     }
-    if (!parts.idempotent) {
+    if (!spec.idempotent) {
       settle(
         unknown(
           "it was in flight when the Orchestrator restarted, and no Effector replica holds it; not sent again " +
@@ -1142,7 +1239,7 @@ async function drive<I, O>(
       );
       return;
     }
-    mark({ stage: "started", text: `${parts.method} ${hostText(parts)} (sent again: it is idempotent)` });
+    mark({ stage: "started", text: `${spec.label} (sent again: it is idempotent)` });
     await send(requestFor());
     return;
   }
@@ -1160,29 +1257,17 @@ async function drive<I, O>(
   // request leaves.
   binding?.recordEffect?.(id, {
     state: "intent",
-    kind: "http",
+    kind: spec.kind,
     slot,
     placement: "instance",
-    idempotent: parts.idempotent,
+    idempotent: spec.idempotent,
     at: now(),
   });
-  mark({ stage: "started", text: `${parts.method} ${hostText(parts)}` });
+  mark({ stage: "started", text: spec.label });
   await send(req);
 
   function requestFor(): StartRequest {
-    let input: unknown = snapshot.input;
-    if (def.input !== undefined) {
-      const parsed = def.input.safeParse(input);
-      if (!parsed.success) {
-        throw new Error(
-          `http "${slot}": its input does not match the definition's input schema — ` +
-            parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; "),
-        );
-      }
-      input = parsed.data;
-    }
-    const runParts = def.request ? (def.request as (i: unknown) => HttpRequestParts)(input) : {};
-    return startRequestOf(parts, runParts ?? {});
+    return spec.request(snapshot.input, slot);
   }
 
   /** Send the start, and follow it. A start that never reached a replica is sent again; one whose
@@ -1209,7 +1294,7 @@ async function drive<I, O>(
             await follow(found);
             return;
           }
-          if (!parts.idempotent) {
+          if (!spec.idempotent) {
             settle(unknown("its start may have reached the Effector, and no replica holds it now; not sent again"));
             return;
           }
@@ -1230,7 +1315,7 @@ async function drive<I, O>(
     let replica: Replica = first.replica;
     for (;;) {
       if (state.state === "settled" && state.output) {
-        settle(state.output as HttpOutput);
+        settle(state.output as NonNullable<EffectMarker["output"]>);
         return;
       }
       if (state.state === "unknown") {
@@ -1238,7 +1323,7 @@ async function drive<I, O>(
         if (!asked || signal.aborted) return;
         const { found } = asked;
         if (!found) {
-          if (parts.idempotent) {
+          if (spec.idempotent) {
             await send(requestFor());
             return;
           }
@@ -1269,15 +1354,15 @@ async function drive<I, O>(
  * unknown": an http Effect has no stop route, so the Effector finishes the call and drops an
  * outcome nobody reads. The Machine never hears it.
  */
-function stopped(self: AnyActorRef, system: AnyActorSystem, effectId: string): void {
+function stopped(self: AnyActorRef, system: AnyActorSystem, effectId: string, kind: "http" | "mcp"): void {
   const run = running.get(self);
   running.delete(self);
   run?.controller.abort();
   const binding = boundRun(system);
   if (binding?.hostStopping) return;
   const row = binding?.effectRow?.(effectId);
-  if (row?.state !== "intent" || row.kind !== "http") return;
-  const aborted: EffectRow = { state: "aborted", kind: "http", slot: row.slot, at: new Date().toISOString() };
+  if (row?.state !== "intent" || row.kind !== kind) return;
+  const aborted: EffectRow = { state: "aborted", kind, slot: row.slot, at: new Date().toISOString() };
   binding?.recordEffect?.(effectId, aborted, "with-transition");
   binding?.marker?.({
     kind: "effect",
@@ -1290,7 +1375,7 @@ function stopped(self: AnyActorRef, system: AnyActorSystem, effectId: string): v
 
 /** A start over the bytes the Effector reads is output `refused` (ADR-0068): the Effector could not
  * verify it, and a body built from context or a pick's param can reach the bound. */
-function tooLarge(req: StartRequest): HttpOutput | undefined {
+function tooLarge(req: StartRequest): { outcome: "refused"; reason: string } | undefined {
   const bytes = Buffer.byteLength(JSON.stringify(req), "utf8");
   if (bytes <= MAX_START_BYTES) return undefined;
   return {
@@ -1347,8 +1432,9 @@ function parseDuration(d: Duration): number {
  * src: "comment" }`.
  *
  * It runs in the Instance Effector, which `jr2 up` deploys when a Machine has an `http` Effect.
- * With `body: file(...)`, it runs in the Sandbox Effector of the Workspace whose body invokes it.
- * The Effector makes the call. The Orchestrator holds no secret.
+ * With `body: file(...)`, it runs in the Sandbox Effector of the Workspace whose body invokes it,
+ * and under Repo Slots its input names the Worktree in `worktree`. The Effector makes the call. The
+ * Orchestrator holds no secret.
  *
  * Every outcome is output (`HttpOutput`): `response`, `unreachable`, `refused` or `unknown`. A 4xx
  * or 5xx status is output too. jr2 sends the call at most one time, unless you mark it
@@ -1402,6 +1488,14 @@ function parseDuration(d: Duration): number {
  * @see docs/reference/decisions/0068-an-effector-holds-an-effects-secrets-and-signs-its-wire.md
  * @see docs/reference/decisions/0067-an-effect-is-an-actor-slot-and-runs-at-most-once-unless-marked-idempotent.md
  */
+export function http<
+  S extends z.ZodType | undefined = undefined,
+  const U extends HttpDefinition<S>["url"] = string,
+  const A extends HttpDefinition<S>["auth"] = undefined,
+  const H extends HttpDefinition<S>["headers"] = undefined,
+>(
+  def: HttpDefinition<S> & { url: U; auth?: A; headers?: H; body: FileBody<S> },
+): EffectLogic<HttpFileInput<S>, HttpOutput> & OpenOf<HttpOpenParts<U, A, H>>;
 export function http<
   S extends z.ZodType | undefined = undefined,
   const U extends HttpDefinition<S>["url"] = string,