@pithy-sh/core 0.9.0 → 0.11.0

package/src/text/literals.ts

@@ -0,0 +1,294 @@
+// SPDX-FileCopyrightText: 2026 Pithy
+// SPDX-License-Identifier: MIT
+
+/**
+ * **Every string a source file writes, as it reads at run time near enough to scan (#711)** — each quoted or
+ * template literal's text, quotes off, escapes resolved to the character they stand for, and every `${…}` blanked
+ * to `<x>`.
+ *
+ * Gates that read what the code *says* — `packages/cli/src/ci/runnableCommands.test.ts` reads every `pithy …` a
+ * line names — used one regular expression for "a string or template literal", and it has a measured false
+ * reading: a template whose interpolation holds a template of its own, `` `${path}${detail ? ` — ${detail}` :
+ * ""}` ``, closed at the inner backtick, and everything after it was read as a literal that opened there. The
+ * scan then reported text the file does not contain, and missed the text it does. So this walks the source and
+ * keeps a stack: a `${` opens an expression, whose own literals are read as literals in their turn, and its
+ * matching `}` resumes the template it interrupted.
+ *
+ * Comments must be blanked first (`./comments`), as every caller here already does. A regex literal is stepped
+ * over by the same rule `./comments` uses — a `/` where a value may begin opens one — so a quote inside a pattern
+ * does not open a string.
+ */
+export function literalTexts(source: string, options: LiteralOptions = {}): string[] {
+  return literalSpans(source, options).map((span) => span.text);
+}
+
+/** How a source is read. */
+export interface LiteralOptions {
+  /**
+   * The source is a `.tsx` file: an element's text and its attribute strings are read as literals too, and a
+   * `<` where a value may begin opens an element rather than comparing. A JSX text run is read with its
+   * whitespace collapsed, as React renders it; a `{…}` child is `<x>`.
+   */
+  readonly jsx?: boolean;
+}
+
+/** One literal: its text as {@link literalTexts} reads it, and the source range it spans, delimiters included. */
+export interface LiteralSpan {
+  readonly text: string;
+  readonly start: number;
+  readonly end: number;
+  /** A template's interpolations, each the range of the code between `${` and `}`. Absent for any other literal. */
+  readonly holes?: readonly (readonly [number, number])[];
+}
+
+/**
+ * {@link literalTexts}, with where each one sits — so a gate can read what is around a literal: a `+` beside it, or
+ * the array it is an element of being joined.
+ */
+export function literalSpans(source: string, options: LiteralOptions = {}): LiteralSpan[] {
+  const found: LiteralSpan[] = [];
+  walk(source, 0, found, false, options.jsx === true);
+  return found;
+}
+
+/** After one of these, a `/` opens a regex literal; after anything else it divides. */
+const VALUE_POSITION = new Set([
+  "",
+  "(",
+  ",",
+  "=",
+  ":",
+  "[",
+  "!",
+  "&",
+  "|",
+  "?",
+  "{",
+  "}",
+  ";",
+  "+",
+  "-",
+  "*",
+  "%",
+  "^",
+  "~",
+  "<",
+  ">",
+]);
+
+/**
+ * Walk code from `start`, pushing every literal it meets. Inside an interpolation (`nested`), an unmatched `}`
+ * closes it: the walk returns the index just past that brace.
+ */
+function walk(source: string, start: number, found: LiteralSpan[], nested: boolean, jsx: boolean): number {
+  let depth = 0;
+  let previous = "";
+  let index = start;
+  while (index < source.length) {
+    const char = source[index] as string;
+    if (char === '"' || char === "'") {
+      index = quoted(source, index, char, found);
+      previous = char;
+      continue;
+    }
+    if (char === "`") {
+      index = template(source, index, found, jsx);
+      previous = char;
+      continue;
+    }
+    if (jsx && char === "<" && opensElement(source, index, previous)) {
+      // An element is read whole, or — when it does not parse as one, as a generic arrow `<T,>` does not — the
+      // `<` is code after all, and what it read is put back.
+      const mark = found.length;
+      const end = element(source, index, found);
+      if (end !== null) {
+        index = end;
+        previous = ")";
+        continue;
+      }
+      found.length = mark;
+    }
+    if (char === "/" && VALUE_POSITION.has(previous)) {
+      index = endOfRegex(source, index);
+      previous = "/";
+      continue;
+    }
+    if (char === "{") depth += 1;
+    if (char === "}") {
+      if (depth === 0 && nested) return index + 1;
+      depth -= 1;
+    }
+    if (!/\s/.test(char)) previous = char;
+    index += 1;
+  }
+  return index;
+}
+
+/** One quoted string: its text pushed, the index past its closing quote returned. A newline ends it unclosed. */
+function quoted(source: string, start: number, quote: string, found: LiteralSpan[]): number {
+  let text = "";
+  for (let index = start + 1; index < source.length; index += 1) {
+    const char = source[index] as string;
+    if (char === "\\") {
+      text += source[index + 1] ?? "";
+      index += 1;
+      continue;
+    }
+    if (char === quote || char === "\n") {
+      const end = char === quote ? index + 1 : index;
+      found.push({ text, start, end });
+      return end;
+    }
+    text += char;
+  }
+  found.push({ text, start, end: source.length });
+  return source.length;
+}
+
+/**
+ * One template: its text pushed with each `${…}` as `<x>`, and every literal inside an interpolation pushed in
+ * its own right. Returns the index past the closing backtick.
+ */
+function template(source: string, start: number, found: LiteralSpan[], jsx: boolean): number {
+  let text = "";
+  const holes: [number, number][] = [];
+  const slot = found.length;
+  found.push({ text: "", start, end: start });
+  const close = (end: number): LiteralSpan => ({ text, start, end, ...(holes.length > 0 ? { holes } : {}) });
+  let index = start + 1;
+  while (index < source.length) {
+    const char = source[index] as string;
+    if (char === "\\") {
+      text += source[index + 1] ?? "";
+      index += 2;
+      continue;
+    }
+    if (char === "`") {
+      found[slot] = close(index + 1);
+      return index + 1;
+    }
+    if (char === "$" && source[index + 1] === "{") {
+      text += "<x>";
+      const from = index + 2;
+      index = walk(source, from, found, true, jsx);
+      // `walk` returns past the `}` that closed it; an unclosed one ran to the end.
+      holes.push([from, source[index - 1] === "}" ? index - 1 : index]);
+      continue;
+    }
+    text += char;
+    index += 1;
+  }
+  found[slot] = close(source.length);
+  return source.length;
+}
+
+/** After one of these words, as after a {@link VALUE_POSITION} character, a value begins. */
+const VALUE_WORDS = new Set(["return", "yield", "await", "default", "case", "else", "do"]);
+
+/**
+ * Whether the `<` at `index` opens a JSX element: where a value may begin — after an operator, a bracket, or a
+ * word such as `return` — and followed by a tag name or, for a fragment, `>`. After an identifier or a closing
+ * bracket it compares, or opens a type's arguments.
+ */
+function opensElement(source: string, index: number, previous: string): boolean {
+  if (!/[A-Za-z_$>]/.test(source[index + 1] ?? "")) return false;
+  if (VALUE_POSITION.has(previous)) return true;
+  const before = /([A-Za-z_$][\w$]*)\s*$/.exec(source.slice(Math.max(0, index - 32), index));
+  return before !== null && VALUE_WORDS.has(before[1] as string);
+}
+
+/** A JSX text run as React renders it: whitespace collapsed, and nothing pushed for a run that is only space. */
+function pushText(text: string, start: number, end: number, found: LiteralSpan[]): void {
+  const collapsed = text.replace(/\s+/g, " ").trim();
+  if (collapsed.length > 0) found.push({ text: collapsed, start, end });
+}
+
+/**
+ * One JSX element from its `<`: each attribute string and each text run pushed, every `{…}` walked as code. Returns
+ * the index past the element, or `null` when what follows the `<` is not an element — a generic arrow `<T,>(…)`,
+ * or a `<` that never closes — for the caller to read as code.
+ */
+function element(source: string, start: number, found: LiteralSpan[]): number | null {
+  let index = start + 1;
+  const name = /^[A-Za-z_$][\w$.:-]*/.exec(source.slice(index))?.[0] ?? "";
+  index += name.length;
+  // The attributes, up to `>` or `/>`.
+  for (;;) {
+    while (/\s/.test(source[index] ?? "")) index += 1;
+    const char = source[index];
+    if (char === undefined) return null;
+    if (char === "/" && source[index + 1] === ">") return index + 2;
+    if (char === ">") {
+      index += 1;
+      break;
+    }
+    if (char === "{") {
+      index = walk(source, index + 1, found, true, true);
+      continue;
+    }
+    const attribute = /^[A-Za-z_$][\w$:-]*/.exec(source.slice(index))?.[0];
+    if (attribute === undefined || name === "") return null;
+    index += attribute.length;
+    while (/\s/.test(source[index] ?? "")) index += 1;
+    if (source[index] !== "=") continue;
+    index += 1;
+    while (/\s/.test(source[index] ?? "")) index += 1;
+    const value = source[index];
+    if (value === "{") {
+      index = walk(source, index + 1, found, true, true);
+      continue;
+    }
+    if (value !== '"' && value !== "'") return null;
+    // A JSX attribute string has no escapes, and may run across lines.
+    const close = source.indexOf(value, index + 1);
+    if (close === -1) return null;
+    found.push({ text: source.slice(index + 1, close), start: index, end: close + 1 });
+    index = close + 1;
+  }
+  // The children, up to the closing tag.
+  let text = "";
+  let from = index;
+  while (index < source.length) {
+    const char = source[index] as string;
+    if (char === "{") {
+      text += "<x>";
+      index = walk(source, index + 1, found, true, true);
+      continue;
+    }
+    if (char === "<") {
+      const closing = /^<\s*\//.exec(source.slice(index));
+      if (closing !== null) {
+        pushText(text, from, index, found);
+        const end = source.indexOf(">", index);
+        return end === -1 ? null : end + 1;
+      }
+      pushText(text, from, index, found);
+      const end = element(source, index, found);
+      if (end === null) return null;
+      index = end;
+      text = "";
+      from = index;
+      continue;
+    }
+    text += char;
+    index += 1;
+  }
+  return null;
+}
+
+/** Where a regex literal ends. A `/` inside a character class does not close it; a newline does. */
+function endOfRegex(source: string, start: number): number {
+  let inClass = false;
+  for (let index = start + 1; index < source.length; index += 1) {
+    const char = source[index];
+    if (char === "\\") {
+      index += 1;
+      continue;
+    }
+    if (char === "\n") return index;
+    if (char === "[") inClass = true;
+    else if (char === "]") inClass = false;
+    else if (char === "/" && !inClass) return index + 1;
+  }
+  return source.length;
+}

package/src/version.generated.ts

@@ -13,4 +13,4 @@
 export const PACKAGE_NAME = "@pithy-sh/core";
 
 /** This package's version, stamped from its own package.json at generation time. */
-export const PACKAGE_VERSION = "0.9.0";
+export const PACKAGE_VERSION = "0.11.0";

package/src/worker/serviceLoopback.ts

@@ -0,0 +1,105 @@
+// SPDX-FileCopyrightText: 2026 Pithy
+// SPDX-License-Identifier: MIT
+
+import { z } from "zod";
+import { commandName } from "../cli/command";
+import { UpstreamError } from "../error/pithyError";
+import { ENVIRONMENT_VAR } from "./identity";
+
+/**
+ * **A service binding under `pithy dev`: the call reaches the local target on its pinned port (#617).**
+ *
+ * Deployed, `env.APP_B.fetch(request)` is a service binding: Cloudflare runs the call inside the runtime, into
+ * the script the binding names. Locally there is no such script. `wrangler dev` would look for one in its own
+ * cross-process registry — the one `pithy dev` never relies on — and a Worker started on its own with
+ * `pithy dev --app app-a` would find nothing there at all. What does exist is the target itself, on the port its
+ * feature pinned for it, and `pithy dev` knows that address before anything starts.
+ *
+ * So `pithy dev` publishes one var, {@link SERVICE_ORIGINS_VAR}: a JSON map from each service binding this
+ * Worker declares to its target's local origin. Under `dev`, and only there, each of those bindings is replaced
+ * with a stand-in whose `fetch` sends the same request to that origin. The call site is byte-identical either
+ * way. A target that is not running refuses the connection, so the call fails at once as
+ * `core/upstream_failed`, naming the binding and the address, rather than hanging on a registry lookup.
+ *
+ * **Only `dev`, and only what was published.** The var is written by `pithy dev` and by nothing else, and the
+ * gate reads `ENVIRONMENT` off the request env as the Workflow loopback does (`workflow/dispatch.ts`): a
+ * deployment that lost its `ENVIRONMENT` var never opens it.
+ */
+
+/** The var `pithy dev` publishes: each service binding's local target, as JSON. */
+export const SERVICE_ORIGINS_VAR = "PITHY_SERVICE_ORIGINS";
+
+/** The one environment the stand-in is made in. */
+const LOCAL = "dev";
+
+/** What the var carries: binding name to an `http(s)` origin. */
+const ServiceOrigins = z
+  .record(
+    z.string().describe("A service binding's name in the Worker env."),
+    z.url({ protocol: /^https?$/ }).describe("The local origin of the Worker it calls, as `pithy dev` pinned it."),
+  )
+  .describe("Each service binding's local target, published by `pithy dev`.");
+
+/** The transport. The runtime's `fetch`, or a test's. */
+export type ServiceLoopbackFetch = (request: Request) => Promise<Response>;
+
+/** A Fetcher's one method that a plain `fetch` target uses. */
+interface LocalService {
+  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+}
+
+/** A stand-in for one service binding: every request sent to `origin`, its path, method, headers and body kept. */
+function localService(binding: string, origin: string, send: ServiceLoopbackFetch): LocalService {
+  const target = new URL(origin);
+  return {
+    async fetch(input, init) {
+      const request = new Request(input, init);
+      const url = new URL(request.url);
+      url.protocol = target.protocol;
+      url.host = target.host;
+      try {
+        return await send(new Request(url, request));
+      } catch (cause) {
+        throw new UpstreamError(
+          {
+            message: `The Worker ${binding} calls is not answering.`,
+            action: `Check that it is running under ${commandName("dev")} at ${target.origin}.`,
+            detail: `${request.method} ${url.href} failed: ${String(cause)}`,
+          },
+          { cause },
+        );
+      }
+    },
+  };
+}
+
+/** Options for {@link withLocalServices}. */
+export interface LocalServicesOptions {
+  /** The transport. Defaults to the runtime's `fetch`. */
+  fetch?: ServiceLoopbackFetch;
+}
+
+/**
+ * The env a request runs with: under `pithy dev`, each published service binding replaced with its local
+ * stand-in; anywhere else, the env unchanged — the same object, so nothing outside `dev` pays for this.
+ */
+export function withLocalServices(
+  env: Record<string, unknown>,
+  options: LocalServicesOptions = {},
+): Record<string, unknown> {
+  if (env[ENVIRONMENT_VAR] !== LOCAL) return env;
+  const published = env[SERVICE_ORIGINS_VAR];
+  if (typeof published !== "string") return env;
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(published);
+  } catch {
+    return env;
+  }
+  const origins = ServiceOrigins.safeParse(parsed);
+  if (!origins.success || Object.keys(origins.data).length === 0) return env;
+  const send = options.fetch ?? ((request: Request) => fetch(request));
+  const local: Record<string, unknown> = { ...env };
+  for (const [binding, origin] of Object.entries(origins.data)) local[binding] = localService(binding, origin, send);
+  return local;
+}

package/src/workflow/dispatchRoute.ts

@@ -1,19 +1,20 @@
 // SPDX-FileCopyrightText: 2026 Pithy
 // SPDX-License-Identifier: MIT
 
-import { zValidator } from "@hono/zod-validator";
 import type { Context, Hono, Next } from "hono";
 import type { PithyHonoEnv } from "../capability/capability";
+import { commandName } from "../cli/command";
 import { type AmbientEnv, ambientEnv, compositionEnvironment } from "../env/ambient";
 import { ForbiddenError, PithyError } from "../error/pithyError";
-import { validationHook } from "../http/validation";
+import { describeRoute } from "../http/routeSpec";
+import { validate } from "../http/validation";
 import type { VerificationStrategy } from "../http/verification";
 import { workflowBindingFor } from "./dispatch";
 import {
   WORKFLOW_DISPATCH_ROUTE,
   WorkflowDispatchParams,
   WorkflowDispatchRequest,
-  type WorkflowDispatchResponse,
+  WorkflowDispatchResponse,
 } from "./schemas";
 import type { RegisteredWorkflow, WorkflowRegistry } from "./spec";
 
@@ -104,7 +105,7 @@ function specForBinding(registry: WorkflowRegistry, binding: string): Registered
 function refuseOutsideDev(capability: string, environment: string | undefined): ForbiddenError {
   return new ForbiddenError({
     message: `Workflow dispatch over HTTP is served only in the ${DISPATCH_ENVIRONMENT} environment.`,
-    action: `Dispatch through the cross-script ${capability} Workflow binding, or run this host under pithy dev.`,
+    action: `Dispatch through the cross-script ${capability} Workflow binding, or run this host under ${commandName("dev")}.`,
     detail: `The composition's ENVIRONMENT is ${environment ?? "unstamped"}.`,
   });
 }
@@ -129,9 +130,15 @@ export function registerWorkflowDispatchRoute(app: Hono<PithyHonoEnv>, options:
 
   app.post(
     WORKFLOW_DISPATCH_ROUTE,
+    describeRoute({
+      summary: "Start a Workflow instance on this host, in dev only.",
+      description: "Refused outside a `dev` composition. Deployed Workers dispatch through a Workflow binding instead.",
+      verification: WORKFLOW_DISPATCH_VERIFICATION,
+      responses: { 202: WorkflowDispatchResponse },
+    }),
     guard,
-    zValidator("param", WorkflowDispatchParams, validationHook),
-    zValidator("json", WorkflowDispatchRequest, validationHook),
+    validate("param", WorkflowDispatchParams),
+    validate("json", WorkflowDispatchRequest),
     async (c) => {
       const { binding } = c.req.valid("param");
       const { id, params } = c.req.valid("json");

package/src/workflow/faults.ts

@@ -192,6 +192,27 @@ export interface DurableStepLike extends WorkflowStepLike {
   sleep(name: string, durationMs: number): Promise<void>;
 }
 
+/**
+ * The platform step's configured `do`: a retry policy ahead of the body. Every `WorkflowStep` has it; a
+ * test double that only takes two arguments does not, which is why {@link ClassifiedSteps.once} is the one
+ * place it is reached for.
+ */
+interface ConfiguredStepLike {
+  do<T>(name: string, config: { retries: { limit: number; delay: number } }, fn: () => Promise<T>): Promise<T>;
+}
+
+/** What {@link classifiedSteps} hands back: a pausing runner, and a step that runs exactly once. */
+export interface ClassifiedSteps extends DurableStepLike {
+  /**
+   * Run a named step with **no retries**, still classified (pithy-sh/pithy#602).
+   *
+   * For a body that mutates somebody else's system — a provider roll — where a platform re-running the
+   * step after an eviction would do it twice. The classification still decides what the instance's
+   * failure says; it can no longer decide on a retry, because there is none to give.
+   */
+  once<T>(name: string, fn: () => Promise<T>): Promise<T>;
+}
+
 /**
  * The platform's terminal-error class — `NonRetryableError` from `cloudflare:workflows`, taken as a
  * parameter.
@@ -222,31 +243,37 @@ export function classifiedSteps(
   step: WorkflowStepLike,
   policy: WorkflowRetryPolicy,
   terminalError: TerminalErrorConstructor,
-): DurableStepLike {
-  const runner: DurableStepLike = {
+): ClassifiedSteps {
+  const classify =
+    <T>(fn: () => Promise<T>) =>
+    async (): Promise<T> => {
+      try {
+        return await fn();
+      } catch (error) {
+        const fault = classifyWorkflowFault(error, policy);
+        if (fault.disposition === "retry") throw error;
+        // The one sanctioned non-`PithyError` throw in the kit: a platform contract, at the durable
+        // boundary, carrying the `PithyError` it replaced as its `cause` so nothing is lost in this
+        // process. Across the boundary the text is the whole channel — the engine records it and
+        // discards the throw — so what an operator is owed is encoded into it, at one stated site,
+        // and read back at one (./stepMessage). The `cause` does not travel; `detail` never did.
+        const terminal = new terminalError(
+          encodeWorkflowStepMessage({
+            code: fault.code,
+            message: messageOf(error),
+            action: pithyActionOf(error),
+          }),
+        );
+        terminal.cause = error;
+        throw terminal;
+      }
+    };
+  const runner: ClassifiedSteps = {
     do<T>(name: string, fn: () => Promise<T>): Promise<T> {
-      return step.do(name, async () => {
-        try {
-          return await fn();
-        } catch (error) {
-          const fault = classifyWorkflowFault(error, policy);
-          if (fault.disposition === "retry") throw error;
-          // The one sanctioned non-`PithyError` throw in the kit: a platform contract, at the durable
-          // boundary, carrying the `PithyError` it replaced as its `cause` so nothing is lost in this
-          // process. Across the boundary the text is the whole channel — the engine records it and
-          // discards the throw — so what an operator is owed is encoded into it, at one stated site,
-          // and read back at one (./stepMessage). The `cause` does not travel; `detail` never did.
-          const terminal = new terminalError(
-            encodeWorkflowStepMessage({
-              code: fault.code,
-              message: messageOf(error),
-              action: pithyActionOf(error),
-            }),
-          );
-          terminal.cause = error;
-          throw terminal;
-        }
-      });
+      return step.do(name, classify(fn));
+    },
+    once<T>(name: string, fn: () => Promise<T>): Promise<T> {
+      return (step as unknown as ConfiguredStepLike).do(name, { retries: { limit: 0, delay: 0 } }, classify(fn));
     },
     /**
      * Forwarded, and deliberately unclassified. A pause raises no fault of the capability's — the
@@ -259,8 +286,10 @@ export function classifiedSteps(
      * answer that cannot change.
      */
     sleep(name: string, durationMs: number): Promise<void> {
-      const pause = step.sleep;
-      if (pause === undefined) {
+      // Read to test for presence, then called off `step` itself. On Cloudflare the step is an RPC
+      // stub, where a property read is another stub: `.call` on it is a remote call to a method named
+      // `call`, which the receiver does not implement.
+      if (step.sleep === undefined) {
         return runner.do<void>(`${name}/cannot-pause`, async () => {
           throw new InternalError({
             message: "This Workflow step runner cannot pause.",
@@ -269,7 +298,7 @@ export function classifiedSteps(
           });
         });
       }
-      return pause.call(step, name, durationMs);
+      return step.sleep(name, durationMs);
     },
   };
   return runner;

package/src/workflow/hostEnv.ts

@@ -59,6 +59,13 @@ export const HostEnvProvider = z
       .min(1)
       .optional()
       .describe("The `pithy` command that fills it, where one does. Rendered as the report's action line."),
+    decision: z
+      .string()
+      .min(1)
+      .optional()
+      .describe(
+        "What fills it when only a person may run the command that does — one that touches production — said as their decision. Rendered in place of `command`.",
+      ),
   })
   .describe("What fills one field of a host worker's env, so a failure names the thing an operator changes.");
 export type HostEnvProvider = z.infer<typeof HostEnvProvider>;
@@ -170,7 +177,8 @@ export function hostEnvProviderSentence(provider: HostEnvProvider): string {
         : provider.kind === "secret"
           ? `Secret ${provider.name}, read through @pithy-sh/secrets.`
           : `Config key ${provider.name}.`;
-  return provider.command ? `${where} Run ${provider.command}.` : where;
+  if (provider.command) return `${where} Run ${provider.command}.`;
+  return provider.decision ? `${where} ${provider.decision}` : where;
 }
 
 /**

package/src/workflow/loopback.ts

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: 2026 Pithy
 // SPDX-License-Identifier: MIT
 
+import { commandName } from "../cli/command";
 import { UpstreamError, UpstreamTimeoutError } from "../error/pithyError";
 import { type WorkflowDispatchRequest, workflowDispatchPath } from "./schemas";
 import type { WorkflowBinding } from "./spec";
@@ -84,7 +85,7 @@ export function loopbackWorkflowBinding(options: LoopbackWorkflowOptions): Workf
   const owner = options.capability ?? options.binding;
   const send = options.fetch ?? ((target: string, init: RequestInit) => fetch(target, init));
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const running = `Check that the ${owner} host is running under pithy dev at ${origin}.`;
+  const running = `Check that the ${owner} host is running under ${commandName("dev")} at ${origin}.`;
 
   return {
     async create(instance?: { id?: string; params?: unknown }): Promise<unknown> {