@danypops/tickets 0.4.5 → 0.4.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/tickets",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "description": "Unified CLI, daemon, and TypeScript library for issue tracking across GitHub, GitLab, and Jira.",
   "type": "module",
   "license": "MIT",
@@ -24,7 +24,9 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@danypops/daemon-kit": "^0.3.0",
+    "@danypops/vehicle-core": "^0.1.1",
+    "@danypops/vehicle-server": "^0.1.1",
+    "@danypops/vehicle-client": "^0.1.1",
     "@danypops/enigma-client": "^0.3.0",
     "@gitbeaker/rest": "^43.8.0",
     "commander": "^12.1.0",

package/src/auth/token-store.ts

@@ -1,9 +1,9 @@
 /**
  * Local, per-backend persistence for delegated OAuth tokens — separate from
- * daemon-kit's own daemon-auth token (paths.token, which authenticates RPC
+ * vehicle-server's own daemon-auth token (paths.token, which authenticates RPC
  * callers to the daemon). This one holds what the daemon uses to authenticate
  * *to* GitHub/GitLab/Jira on the user's behalf. Same security posture as
- * daemon-kit's ensureAuthToken: 0700 directory, 0600 files, atomic write.
+ * vehicle-server's ensureAuthToken: 0700 directory, 0600 files, atomic write.
  */
 import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";

package/src/client/tickets-client.ts

@@ -7,9 +7,9 @@
 import { spawn } from "node:child_process";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import type { DaemonHandle } from "@danypops/daemon-kit/paths";
-import { ensureAuthToken, readDaemonHandle, resolveDaemonPaths } from "@danypops/daemon-kit/paths";
-import { AuthenticatedRpcClient } from "@danypops/daemon-kit/rpc-client";
+import type { DaemonHandle } from "@danypops/vehicle-server/paths";
+import { ensureAuthToken, readDaemonHandle, resolveDaemonPaths } from "@danypops/vehicle-server/paths";
+import { AuthenticatedRpcClient } from "@danypops/vehicle-client/rpc-client";
 import { packageRoot } from "../util/package-root.js";
 import { TICKETS_DAEMON_NAMES, type TicketOpInputs, type TicketOperation, type TicketOpOutputs } from "../daemon/ops.js";
 
@@ -83,6 +83,32 @@ export async function ensureDaemonRunning(
   return { baseUrl: `http://${handle.host}:${handle.port}`, token };
 }
 
+export interface VehicleClientTarget {
+  /** Base URL for tickets' VehicleRegistry (see ../vehicle/tickets-vehicle.ts) -- @danypops/vehicle-client's RemoteVehicleClient mounts its own /vehicle/manifest, /vehicle/invoke, /vehicle/cancel routes under this. */
+  baseUrl: string;
+  token: string;
+}
+
+/**
+ * Narrow, side-effect-free surface for a Vehicle-projected domain consumer --
+ * same daemon, same handle file, same Bearer token every other tickets RPC
+ * call already uses (see daemon/server.ts's buildApp, which mounts the
+ * Vehicle HTTP app at /vehicle/* on this same port). Deliberately does NOT
+ * call ensureDaemonRunning: that spawns the daemon and mints a fresh auth
+ * token file as a side effect, which is wrong to do just from a Pi
+ * extension loading and registering its tool schemas -- only reads the
+ * handle if the daemon has already started, mirroring how Papyrus's own
+ * resolveVehicleClientTarget() tolerates "never started" by returning
+ * undefined rather than throwing or spawning.
+ */
+export function resolveVehicleClientTarget(env?: Record<string, string | undefined>): VehicleClientTarget | undefined {
+  const paths = ticketsPaths(env);
+  const handle = readDaemonHandle(paths.handle);
+  if (!handle) return undefined;
+  const token = ensureAuthToken(paths.token, "Tickets");
+  return { baseUrl: `http://${handle.host}:${handle.port}`, token };
+}
+
 export type TicketsRpcClient = AuthenticatedRpcClient<TicketOperation, TicketOpInputs, TicketOpOutputs>;
 
 export async function createTicketsClient(opts: EnsureDaemonOptions = {}): Promise<TicketsRpcClient> {

package/src/config/config.ts

@@ -7,8 +7,8 @@ import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { parse as parseYaml } from "yaml";
-import type { MaintenanceTask } from "@danypops/daemon-kit/daemon";
-import type { Logger } from "@danypops/daemon-kit/logging";
+import type { MaintenanceTask } from "@danypops/vehicle-server/daemon";
+import type { Logger } from "@danypops/vehicle-server/logging";
 import { GitHubRepository } from "../adapters/github.js";
 import { GitLabRepository } from "../adapters/gitlab.js";
 import { JiraRepository } from "../adapters/jira.js";

package/src/daemon/bootstrap.ts

@@ -1,23 +1,24 @@
 /**
  * Composition root for the tickets daemon: wires paths, auth token, ledger
  * storage, real backend repositories, and the sync poller into the options
- * daemon-kit's startDaemon()/runDaemonProcess() expect. Everything here is
+ * vehicle-server's startDaemon()/runDaemonProcess() expect. Everything here is
  * injectable so tests can substitute fake repositories and a scratch XDG
  * root instead of hitting real GitHub/GitLab/Jira or the real home directory.
  */
 import type { Database } from "bun:sqlite";
-import { createLogger, type Logger } from "@danypops/daemon-kit/logging";
-import { ensureAuthToken, type PathEnvironment, resolveDaemonPaths } from "@danypops/daemon-kit/paths";
-import { checkpoint, openSqliteWithPragmas } from "@danypops/daemon-kit/storage";
-import type { StartDaemonOptions } from "@danypops/daemon-kit/daemon";
+import { createLogger, type Logger } from "@danypops/vehicle-server/logging";
+import { ensureAuthToken, type PathEnvironment, resolveDaemonPaths } from "@danypops/vehicle-server/paths";
+import { checkpoint, openSqliteWithPragmas } from "@danypops/vehicle-server/storage";
+import type { StartDaemonOptions } from "@danypops/vehicle-server/daemon";
 import { TicketService } from "../application/service.js";
 import { buildRepositories, type BuildRepositories, type Config, createBackendRefreshTask, loadConfig } from "../config/config.js";
 import type { IssueRepository } from "../ports/repository.js";
 import { FOCUS_MIGRATIONS, FocusStore } from "./focus.js";
 import { Ledger, LEDGER_MIGRATIONS } from "./ledger.js";
 import { TICKETS_DAEMON_NAMES } from "./ops.js";
-import { buildApp } from "./server.js";
+import { buildApp, type TicketsAppDeps } from "./server.js";
 import { createSyncTask } from "./poller.js";
+import { createTicketsVehicleRegistry } from "../vehicle/tickets-vehicle.js";
 
 export interface BootstrapOptions {
   pathEnv?: PathEnvironment;
@@ -38,7 +39,7 @@ export interface BootstrapOptions {
   backendRefreshIntervalMs?: number;
   /**
    * Overrides the daemon.shutdown op's effect. Defaults to sending this
-   * process SIGTERM, which daemon-kit's runDaemonProcess already handles
+   * process SIGTERM, which vehicle-server's runDaemonProcess already handles
    * with a tested graceful stop (see main.ts). Tests override this instead
    * of self-signaling the test runner's own process.
    */
@@ -69,6 +70,13 @@ export async function bootstrap(opts: BootstrapOptions = {}): Promise<Bootstrapp
   const repos = opts.repos ?? (await buildRepos(config));
   const service = new TicketService(repos);
   const version = opts.version ?? "0.0.0-dev";
+  const onShutdownRequested = opts.onShutdownRequested ?? (() => process.kill(process.pid, "SIGTERM"));
+
+  // Built from the same base deps buildApp's TicketsAppDeps describes, minus
+  // the registry field itself -- createTicketsVehicleRegistry never reads
+  // deps.vehicleRegistry, so this ordering is safe (see server.ts's own
+  // comment on why the registry is built outside it, not imported into it).
+  const vehicleRegistry = createTicketsVehicleRegistry({ service, ledger, focusStore, token, version, logger, onShutdownRequested } as TicketsAppDeps);
 
   const options: StartDaemonOptions = {
     daemonLabel: "Tickets",
@@ -95,7 +103,8 @@ export async function bootstrap(opts: BootstrapOptions = {}): Promise<Bootstrapp
         token,
         version,
         logger,
-        onShutdownRequested: opts.onShutdownRequested ?? (() => process.kill(process.pid, "SIGTERM")),
+        onShutdownRequested,
+        vehicleRegistry,
       }),
     onShutdown: () => {
       db.close();

package/src/daemon/focus.ts

@@ -9,7 +9,7 @@
  * ticket in real life replaces what you were just looking at.
  */
 import type { Database } from "bun:sqlite";
-import type { Migration } from "@danypops/daemon-kit/storage";
+import type { Migration } from "@danypops/vehicle-server/storage";
 
 export const FOCUS_MIGRATIONS: Migration[] = [
   {

package/src/daemon/ledger.ts

@@ -7,7 +7,7 @@
  * of any live upstream call.
  */
 import type { Database } from "bun:sqlite";
-import type { Migration } from "@danypops/daemon-kit/storage";
+import type { Migration } from "@danypops/vehicle-server/storage";
 import type { Issue } from "../domain/issue.js";
 
 export const LEDGER_MIGRATIONS: Migration[] = [

package/src/daemon/main.ts

@@ -1,12 +1,12 @@
 #!/usr/bin/env bun
 /**
  * The real tickets-daemon binary. Requires Bun (bun:sqlite, Bun.serve via
- * daemon-kit). Everything else in this package (the library, the CLI, the
+ * vehicle-server). Everything else in this package (the library, the CLI, the
  * pi-tickets extension) is plain Node-compatible TypeScript and talks to
  * this process only over the loopback HTTP RPC surface — see client.ts.
  */
-import { runDaemonProcess } from "@danypops/daemon-kit/daemon";
-import { readPackageVersion } from "@danypops/daemon-kit/version";
+import { runDaemonProcess } from "@danypops/vehicle-server/daemon";
+import { readPackageVersion } from "@danypops/vehicle-server/version";
 import { bootstrap } from "./bootstrap.js";
 
 const version = readPackageVersion(new URL("../../package.json", import.meta.url), "Tickets");

package/src/daemon/poller.ts

@@ -5,8 +5,8 @@
  * network, bad creds) is logged and skipped; it never crashes the daemon
  * and never blocks other backends' syncs.
  */
-import type { Logger } from "@danypops/daemon-kit/logging";
-import type { MaintenanceTask } from "@danypops/daemon-kit/daemon";
+import type { Logger } from "@danypops/vehicle-server/logging";
+import type { MaintenanceTask } from "@danypops/vehicle-server/daemon";
 import type { TicketService } from "../application/service.js";
 import type { Ledger } from "./ledger.js";
 

package/src/daemon/server.ts

@@ -1,11 +1,15 @@
 /**
- * Daemon HTTP surface: Bearer-token auth, /health, /ready, and a single
- * dispatch endpoint (/api/v1/ops) per daemon-kit's http.ts convention.
- * Every operation here has a CLI command (cli/index.ts) and a pi-tickets
- * tool action — no operation exists only for one caller.
+ * Daemon HTTP surface: Bearer-token auth, /health, /ready, a single
+ * dispatch endpoint (/api/v1/ops) per vehicle-server's http.ts convention,
+ * and a VehicleRegistry (see ../vehicle/tickets-vehicle.ts) mounted at
+ * /vehicle/* -- same daemon, same auth, same port, not a second service to
+ * stand up. Every operation here has a CLI command (cli/index.ts) and a
+ * pi-tickets tool action — no operation exists only for one caller.
  */
-import { errorResponse, healthResponse, jsonResponse, readyResponse, requireBearerToken } from "@danypops/daemon-kit/http";
-import type { Logger } from "@danypops/daemon-kit/logging";
+import { errorResponse, healthResponse, jsonResponse, readyResponse, requireBearerToken } from "@danypops/vehicle-server/rpc-http";
+import type { Logger } from "@danypops/vehicle-server/logging";
+import { createVehicleHttpApp } from "@danypops/vehicle-server/http";
+import type { VehicleRegistry } from "@danypops/vehicle-server";
 import { AuthRequiredError, IssueNotFoundError } from "../adapters/errors.js";
 import { NotSupportedError, type TicketService, UnknownBackendError } from "../application/service.js";
 import { parseRef } from "../domain/issue.js";
@@ -23,19 +27,36 @@ export interface TicketsAppDeps {
   /**
    * Invoked by the `daemon.shutdown` op, after the HTTP response is already
    * queued to flush. Defaults set by bootstrap.ts self-signal the process so
-   * the same tested SIGINT/SIGTERM path (daemon-kit's runDaemonProcess) does
+   * the same tested SIGINT/SIGTERM path (vehicle-server's runDaemonProcess) does
    * the actual graceful stop — this hook only ever *requests* shutdown, it
    * never calls process.exit directly.
    */
   onShutdownRequested?: () => void;
+  /**
+   * Built by ../vehicle/tickets-vehicle.ts's createTicketsVehicleRegistry,
+   * from the same base deps this interface describes -- passed in rather
+   * than built here to avoid a server.ts <-> tickets-vehicle.ts import cycle
+   * (tickets-vehicle.ts already imports TICKET_OP_HANDLERS and this type
+   * from this file).
+   */
+  vehicleRegistry: VehicleRegistry;
 }
 
-type Handler<Op extends TicketOperation> = (
-  deps: TicketsAppDeps,
+// Narrower than TicketsAppDeps on purpose: no real handler reads
+// deps.vehicleRegistry, and vehicle/tickets-vehicle.ts's own registry
+// builder needs to call these before a registry exists to put there.
+export type Handler<Op extends TicketOperation> = (
+  deps: Omit<TicketsAppDeps, "vehicleRegistry">,
   input: TicketOpInputs[Op],
 ) => Promise<TicketOpOutputs[Op]>;
 
-const handlers: { [Op in TicketOperation]: Handler<Op> } = {
+/**
+ * The one real implementation of every ticket operation, shared verbatim by
+ * the hand-rolled /api/v1/ops dispatch below and vehicle/tickets-vehicle.ts's
+ * VehicleRegistry projection -- never reimplemented a second time for the
+ * newer surface.
+ */
+export const TICKET_OP_HANDLERS: { [Op in TicketOperation]: Handler<Op> } = {
   "backends.list": async (deps) => ({ backends: deps.service.backends() }),
   "issue.list": async (deps, input) => ({ issues: await deps.service.list(input.backend, input.filter) }),
   "issue.get": async (deps, input) => ({ issue: await deps.service.get(input.ref) }),
@@ -88,11 +109,17 @@ function statusFor(error: unknown): number {
 }
 
 export function buildApp(deps: TicketsAppDeps): { fetch(request: Request): Promise<Response> } {
+  // Same Bearer token as the rest of this API -- the Vehicle-projected
+  // domain (see ../vehicle/tickets-vehicle.ts) rides the same daemon, same
+  // auth, same port; it is not a second service to stand up or
+  // authenticate against separately.
+  const vehicleApp = createVehicleHttpApp({ registry: deps.vehicleRegistry, token: deps.token });
   return {
     async fetch(request: Request): Promise<Response> {
       const url = new URL(request.url);
 
       if (!requireBearerToken(request, deps.token)) return errorResponse("unauthorized", 401);
+      if (url.pathname.startsWith("/vehicle/")) return vehicleApp.fetch(request);
       if (request.method === "GET" && url.pathname === "/health") return healthResponse(deps.version);
       if (request.method === "GET" && url.pathname === "/ready") return readyResponse(true);
 
@@ -106,7 +133,7 @@ export function buildApp(deps: TicketsAppDeps): { fetch(request: Request): Promi
             return errorResponse("invalid JSON body", 400);
           }
           if (!isTicketOperation(body.op)) return errorResponse(`unknown op: ${String(body.op)}`, 400);
-          const handler = handlers[body.op] as Handler<TicketOperation>;
+          const handler = TICKET_OP_HANDLERS[body.op] as Handler<TicketOperation>;
           try {
             const result = await handler(deps, (body.input ?? {}) as never);
             return jsonResponse({ result });

package/src/index.ts

@@ -18,9 +18,11 @@ export type { FocusStatus, TicketFocusState } from "./daemon/focus.js";
 export {
   createTicketsClient,
   ensureDaemonRunning,
+  resolveVehicleClientTarget,
   ticketsPaths,
   type EnsureDaemonOptions,
   type TicketsRpcClient,
+  type VehicleClientTarget,
 } from "./client/tickets-client.js";
 
 // Delegated OAuth (device flow for GitHub/GitLab, authorization code for Jira)

package/src/vehicle/tickets-vehicle.ts

@@ -0,0 +1,141 @@
+/**
+ * Every real ticket operation projected as its own VehicleRegistry entry,
+ * one per TicketOperation, instead of pi-tickets' hand-rolled
+ * `tickets(action=X)` mega-tool. Operation names are already dotted
+ * (issue.list, focus.set, discover.fields, ...) in daemon/ops.ts -- Vehicle's
+ * tool-name projection turns each into its own Pi tool (issue_list,
+ * focus_set, discover_fields, ...) with zero renaming needed.
+ *
+ * Delegates every operation to daemon/server.ts's TICKET_OP_HANDLERS, the
+ * exact same implementation the existing /api/v1/ops dispatch calls -- this
+ * is a projection/contract layer on top of the existing application logic,
+ * not a second copy of it.
+ *
+ * daemon.shutdown is deliberately excluded: it's an admin/lifecycle
+ * operation, not something an agent should be able to call as a tool.
+ */
+import { bindVehicleOperation, defineLooseObjectSchema, defineVehicleOperation, passthroughVehicleSchema, type VehicleEffect, type LooseObjectProperty } from "@danypops/vehicle-core";
+import { VehicleRegistry } from "@danypops/vehicle-server";
+import { TICKET_OP_HANDLERS, type TicketsAppDeps } from "../daemon/server.js";
+import type { TicketOperation } from "../daemon/ops.js";
+
+const OWNER = "tickets";
+
+const LIMITS = { defaultTimeoutMs: 10_000, maxTimeoutMs: 30_000, maxRequestBytes: 65_536, maxResponseBytes: 262_144 };
+
+const stringProp: LooseObjectProperty = { type: "string" };
+const numberProp: LooseObjectProperty = { type: "number" };
+
+interface OperationSpec {
+  readonly action: TicketOperation;
+  readonly description: string;
+  readonly effect: VehicleEffect;
+  readonly properties: Record<string, LooseObjectProperty>;
+  readonly required: readonly string[];
+  /**
+   * Reshapes the flat tool-facing input into whatever TICKET_OP_HANDLERS
+   * expects, for the one operation where those differ: issue.list flattens
+   * project/status/assignee/labels/limit as top-level tool properties
+   * (matching issue.search's own flat convention, and pi-stef/atlassian's
+   * jira_search_issues/jira_get_project_issues -- every filter param is its
+   * own top-level property there too, never an opaque nested bag), while
+   * the RPC/CLI-level handler contract keeps its existing nested
+   * `filter: ListFilter` shape. Identity by default.
+   */
+  readonly mapInput?: (input: Record<string, unknown>) => Record<string, unknown>;
+}
+
+const stringArrayProp: LooseObjectProperty = { type: "array" };
+
+function definedEntriesOnly(input: Record<string, unknown>): Record<string, unknown> {
+  return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
+}
+
+const OPERATIONS: readonly OperationSpec[] = [
+  { action: "backends.list", description: "Lists every configured backend name (github, gitlab, jira, ...).", effect: "read", properties: {}, required: [] },
+  {
+    action: "issue.list",
+    description: "Lists issues from one backend, optionally filtered.",
+    effect: "read",
+    properties: { backend: stringProp, project: stringProp, status: stringProp, assignee: stringProp, labels: stringArrayProp, limit: numberProp },
+    required: ["backend"],
+    mapInput: ({ backend, project, status, assignee, labels, limit }) => ({
+      backend,
+      filter: definedEntriesOnly({ project, status, assignee, labels, limit }),
+    }),
+  },
+  { action: "issue.get", description: "Gets one issue by its ref (e.g. \"github:#42\").", effect: "read", properties: { ref: stringProp }, required: ["ref"] },
+  {
+    action: "issue.create",
+    description: "Creates a new issue on a live backend -- a real, externally visible write, not a local draft.",
+    effect: "external-write",
+    properties: { backend: stringProp, input: { type: "object" } },
+    required: ["backend", "input"],
+  },
+  {
+    action: "issue.update",
+    description: "Updates an existing issue on its live backend -- a real, externally visible write.",
+    effect: "external-write",
+    properties: { ref: stringProp, input: { type: "object" } },
+    required: ["ref", "input"],
+  },
+  { action: "issue.search", description: "Searches one backend's issues by text query.", effect: "read", properties: { backend: stringProp, query: stringProp, limit: numberProp, project: stringProp }, required: ["backend", "query"] },
+  { action: "issue.children", description: "Lists an issue's child issues.", effect: "read", properties: { ref: stringProp }, required: ["ref"] },
+  { action: "issue.comments", description: "Lists an issue's comments.", effect: "read", properties: { ref: stringProp }, required: ["ref"] },
+  {
+    action: "issue.comment_add",
+    description: "Adds a comment to an issue on its live backend -- a real, externally visible write.",
+    effect: "external-write",
+    properties: { ref: stringProp, body: stringProp },
+    required: ["ref", "body"],
+  },
+  { action: "ledger.search", description: "Searches the local pooled-issue ledger (no live backend call).", effect: "read", properties: { query: stringProp, limit: numberProp }, required: ["query"] },
+  { action: "ledger.stats", description: "Per-backend counts of issues pooled into the local ledger.", effect: "read", properties: {}, required: [] },
+  { action: "focus.set", description: "Sets the currently focused issue, by ref.", effect: "local-write", properties: { ref: stringProp }, required: ["ref"] },
+  { action: "focus.get", description: "Gets the currently focused issue, if any.", effect: "read", properties: {}, required: [] },
+  { action: "focus.pause", description: "Pauses focus with an optional reason, without clearing it.", effect: "local-write", properties: { reason: stringProp }, required: [] },
+  { action: "focus.unpause", description: "Resumes a paused focus.", effect: "local-write", properties: {}, required: [] },
+  { action: "focus.clear", description: "Clears the currently focused issue.", effect: "local-write", properties: {}, required: [] },
+  { action: "discover.fields", description: "Discovers a backend's custom field display names and IDs (Jira).", effect: "read", properties: { backend: stringProp }, required: ["backend"] },
+  { action: "discover.statuses", description: "Discovers a backend's real status names.", effect: "read", properties: { backend: stringProp }, required: ["backend"] },
+  {
+    action: "discover.template",
+    description: "Samples recent issues for a project/issueType and extracts a reusable description template (Jira).",
+    effect: "read",
+    properties: { backend: stringProp, project: stringProp, issueType: stringProp, sampleSize: numberProp },
+    required: ["backend", "project", "issueType"],
+  },
+];
+
+/**
+ * Builds a VehicleRegistry exposing every real ticket operation, backed by
+ * the exact same deps shape the daemon's own hand-rolled dispatch already
+ * uses -- minus vehicleRegistry itself, which doesn't exist yet while this
+ * is being built (bootstrap.ts constructs the full TicketsAppDeps by adding
+ * this registry to the same base object afterward).
+ */
+export function createTicketsVehicleRegistry(deps: Omit<TicketsAppDeps, "vehicleRegistry">): VehicleRegistry {
+  const registry = new VehicleRegistry({ name: "tickets", version: "1.0.0", description: "Unified issue tracking across GitHub, GitLab, and Jira." });
+
+  for (const spec of OPERATIONS) {
+    const operation = defineVehicleOperation({
+      name: spec.action,
+      version: 1,
+      description: spec.description,
+      input: defineLooseObjectSchema(spec.properties, spec.required),
+      output: passthroughVehicleSchema,
+      permissions: ["tickets:read", "tickets:write"],
+      effect: spec.effect,
+      idempotency: { mode: spec.effect === "read" ? "safe" : "unsafe" },
+      limits: LIMITS,
+    });
+    const handler = TICKET_OP_HANDLERS[spec.action];
+    const mapInput = spec.mapInput ?? ((input: Record<string, unknown>) => input);
+    registry.register(
+      OWNER,
+      bindVehicleOperation(operation, () => async (context) => handler(deps, mapInput(context.input as Record<string, unknown>) as never)),
+    );
+  }
+
+  return registry;
+}