@pome-sh/cli 0.21.13 → 0.21.15

package/dist/{src-5RPY72NF.js → src-GIKWIJM2.js}

@@ -1,6 +1,7 @@
 import './chunk-FKZZWWYC.js';
 import { defaultSeedState, parseSeed } from './chunk-SGDUD7KK.js';
 export { defaultSeedState, parseSeed, seedSchema } from './chunk-SGDUD7KK.js';
+import { integerInput, declareRouteInputs, mountDeclaredRoute, UndeclaredInputError, MalformedBodyError } from './chunk-4MQULI7E.js';
 import { loadMcpToolFixture, defineTwin, twinBuildInfo, deriveMcpToolTable, UnknownToolError, openTwinDatabase, createApp } from './chunk-TV5S6WQV.js';
 import './chunk-VBATFCWR.js';
 import './chunk-SG6ZTIMT.js';
@@ -3851,6 +3852,550 @@ var GitHubDomain = class {
     this.db.prepare("INSERT INTO audit_log (ts, action, repo_full_name, payload_json) VALUES (?, ?, ?, ?)").run(nowIso(), action, repoFullName, JSON.stringify(payload));
   }
 };
+var repoParams = { owner: z.string().min(1), repo: z.string().min(1) };
+var numberParam = integerInput({ min: 1 });
+var pageQuery = {
+  page: integerInput({ min: 1 }).optional(),
+  per_page: integerInput({ min: 1 }).optional()
+};
+var stateFilter = z.enum(["open", "closed", "all"]).optional();
+var stateWrite = z.enum(["open", "closed"]).optional();
+var repositoryBody = {
+  name: z.string().min(1),
+  description: z.string().optional(),
+  private: z.boolean().optional()
+};
+var commentBody = { body: z.string().min(1) };
+var GITHUB_ROUTES = {
+  // ----- search -----
+  searchRepositories: declareRouteInputs({
+    method: "GET",
+    path: "/search/repositories",
+    query: { q: z.string().optional(), ...pageQuery }
+  }),
+  searchCode: declareRouteInputs({
+    method: "GET",
+    path: "/search/code",
+    query: {
+      q: z.string().optional(),
+      owner: z.string().optional(),
+      repo: z.string().optional(),
+      ...pageQuery
+    }
+  }),
+  searchIssues: declareRouteInputs({
+    method: "GET",
+    path: "/search/issues",
+    query: {
+      q: z.string().optional(),
+      owner: z.string().optional(),
+      repo: z.string().optional(),
+      state: stateFilter,
+      ...pageQuery
+    }
+  }),
+  searchUsers: declareRouteInputs({
+    method: "GET",
+    path: "/search/users",
+    query: { q: z.string().optional(), ...pageQuery }
+  }),
+  searchCommits: declareRouteInputs({
+    method: "GET",
+    path: "/search/commits",
+    query: {
+      q: z.string().optional(),
+      owner: z.string().optional(),
+      repo: z.string().optional(),
+      ...pageQuery
+    }
+  }),
+  // ----- repositories -----
+  getRepository: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo",
+    pathParams: { ...repoParams }
+  }),
+  createUserRepository: declareRouteInputs({
+    method: "POST",
+    path: "/user/repos",
+    bodyEncoding: "json",
+    body: { ...repositoryBody, owner: z.string().min(1).optional() }
+  }),
+  // `owner` is declared in BOTH locations, because the twin accepts it in both.
+  //
+  // The handler spreads the body schema and then overwrites `owner` with the
+  // path value, so the body copy is read and discarded. Declaring only the path
+  // one would turn that into a 422 for a request the twin has always accepted —
+  // a divergence this ticket invented rather than found. The declaration records
+  // what is true: two locations, one of which the handler ignores.
+  createOrgRepository: declareRouteInputs({
+    method: "POST",
+    path: "/orgs/:owner/repos",
+    pathParams: { owner: repoParams.owner },
+    bodyEncoding: "json",
+    body: { ...repositoryBody, owner: z.string().min(1).optional() }
+  }),
+  forkRepository: declareRouteInputs({
+    method: "POST",
+    path: "/repos/:owner/:repo/forks",
+    pathParams: { ...repoParams },
+    bodyEncoding: "json-optional",
+    body: { organization: z.string().optional() }
+  }),
+  // ----- contents & commits -----
+  getRepositoryRootContents: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/contents",
+    pathParams: { ...repoParams },
+    query: { ref: z.string().optional() }
+  }),
+  getFileContents: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/contents/*",
+    pathParams: { ...repoParams, path: z.string().min(1) },
+    query: { ref: z.string().optional() }
+  }),
+  createOrUpdateFile: declareRouteInputs({
+    method: "PUT",
+    path: "/repos/:owner/:repo/contents/*",
+    pathParams: { ...repoParams, path: z.string().min(1) },
+    bodyEncoding: "json",
+    body: {
+      message: z.string().min(1),
+      content: z.string(),
+      branch: z.string().optional(),
+      sha: z.string().optional(),
+      encoding: z.enum(["utf-8", "base64"]).optional()
+    }
+  }),
+  listCommits: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/commits",
+    pathParams: { ...repoParams },
+    query: { sha: z.string().optional(), ...pageQuery }
+  }),
+  createRef: declareRouteInputs({
+    method: "POST",
+    path: "/repos/:owner/:repo/git/refs",
+    pathParams: { ...repoParams },
+    bodyEncoding: "json",
+    body: { ref: z.string().min(1), sha: z.string().optional() }
+  }),
+  // ----- issues -----
+  listIssues: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/issues",
+    pathParams: { ...repoParams },
+    query: {
+      state: stateFilter,
+      labels: z.string().optional(),
+      assignee: z.string().optional(),
+      ...pageQuery
+    }
+  }),
+  createIssue: declareRouteInputs({
+    method: "POST",
+    path: "/repos/:owner/:repo/issues",
+    pathParams: { ...repoParams },
+    bodyEncoding: "json",
+    body: {
+      title: z.string().min(1),
+      body: z.string().optional(),
+      labels: z.array(z.string()).optional(),
+      assignees: z.array(z.string()).optional()
+    }
+  }),
+  getIssue: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/issues/:number",
+    pathParams: { ...repoParams, number: numberParam }
+  }),
+  updateIssue: declareRouteInputs({
+    method: "PATCH",
+    path: "/repos/:owner/:repo/issues/:number",
+    pathParams: { ...repoParams, number: numberParam },
+    bodyEncoding: "json",
+    body: {
+      title: z.string().optional(),
+      body: z.string().optional(),
+      state: stateWrite,
+      labels: z.array(z.string()).optional(),
+      assignees: z.array(z.string()).optional()
+    }
+  }),
+  listIssueComments: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/issues/:number/comments",
+    pathParams: { ...repoParams, number: numberParam },
+    query: { ...pageQuery }
+  }),
+  addIssueComment: declareRouteInputs({
+    method: "POST",
+    path: "/repos/:owner/:repo/issues/:number/comments",
+    pathParams: { ...repoParams, number: numberParam },
+    bodyEncoding: "json",
+    body: { ...commentBody }
+  }),
+  listRepositoryLabels: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/labels",
+    pathParams: { ...repoParams }
+  }),
+  createRepositoryLabel: declareRouteInputs({
+    method: "POST",
+    path: "/repos/:owner/:repo/labels",
+    pathParams: { ...repoParams },
+    bodyEncoding: "json",
+    body: {
+      name: z.string().min(1),
+      color: z.string().default("ededed"),
+      description: z.string().default("")
+    }
+  }),
+  listIssueLabels: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/issues/:number/labels",
+    pathParams: { ...repoParams, number: numberParam }
+  }),
+  addIssueLabels: declareRouteInputs({
+    method: "POST",
+    path: "/repos/:owner/:repo/issues/:number/labels",
+    pathParams: { ...repoParams, number: numberParam },
+    bodyEncoding: "json",
+    body: { labels: z.array(z.string().min(1)).min(1) }
+  }),
+  deleteIssueLabel: declareRouteInputs({
+    method: "DELETE",
+    path: "/repos/:owner/:repo/issues/:number/labels/:name",
+    pathParams: { ...repoParams, number: numberParam, name: z.string().min(1) }
+  }),
+  listCollaborators: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/collaborators",
+    pathParams: { ...repoParams }
+  }),
+  checkCollaborator: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/collaborators/:username",
+    pathParams: { ...repoParams, username: z.string().min(1) }
+  }),
+  addAssignees: declareRouteInputs({
+    method: "POST",
+    path: "/repos/:owner/:repo/issues/:number/assignees",
+    pathParams: { ...repoParams, number: numberParam },
+    bodyEncoding: "json",
+    body: { assignees: z.array(z.string().min(1)).min(1) }
+  }),
+  // ----- pull requests -----
+  listPullRequests: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/pulls",
+    pathParams: { ...repoParams },
+    query: { state: stateFilter, ...pageQuery }
+  }),
+  createPullRequest: declareRouteInputs({
+    method: "POST",
+    path: "/repos/:owner/:repo/pulls",
+    pathParams: { ...repoParams },
+    bodyEncoding: "json",
+    body: {
+      title: z.string().min(1),
+      body: z.string().optional(),
+      head: z.string().min(1),
+      base: z.string().optional()
+    }
+  }),
+  getPullRequest: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/pulls/:number",
+    pathParams: { ...repoParams, number: numberParam }
+  }),
+  listPullRequestFiles: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/pulls/:number/files",
+    pathParams: { ...repoParams, number: numberParam },
+    query: { ...pageQuery }
+  }),
+  listPullRequestReviews: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/pulls/:number/reviews",
+    pathParams: { ...repoParams, number: numberParam },
+    query: { ...pageQuery }
+  }),
+  createPullRequestReview: declareRouteInputs({
+    method: "POST",
+    path: "/repos/:owner/:repo/pulls/:number/reviews",
+    pathParams: { ...repoParams, number: numberParam },
+    bodyEncoding: "json",
+    body: {
+      event: z.enum(["APPROVE", "REQUEST_CHANGES", "COMMENT"]),
+      body: z.string().optional()
+    }
+  }),
+  listPullRequestComments: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/pulls/:number/comments",
+    pathParams: { ...repoParams, number: numberParam },
+    query: { ...pageQuery }
+  }),
+  getPullRequestStatus: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/pulls/:number/status",
+    pathParams: { ...repoParams, number: numberParam }
+  }),
+  mergePullRequest: declareRouteInputs({
+    method: "PUT",
+    path: "/repos/:owner/:repo/pulls/:number/merge",
+    pathParams: { ...repoParams, number: numberParam },
+    bodyEncoding: "json-optional",
+    body: { commit_title: z.string().optional(), commit_message: z.string().optional() }
+  }),
+  updatePullRequestBranch: declareRouteInputs({
+    method: "PUT",
+    path: "/repos/:owner/:repo/pulls/:number/update-branch",
+    pathParams: { ...repoParams, number: numberParam },
+    bodyEncoding: "json-optional",
+    body: { expected_head_sha: z.string().optional() }
+  }),
+  // ----- v2 cluster A — branches & files -----
+  listBranches: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/branches",
+    pathParams: { ...repoParams },
+    query: { ...pageQuery }
+  }),
+  // `branch` is the wildcard: a branch name may contain `/`, so the tail is the
+  // whole remainder of the path. The mechanism reads and URL-decodes it.
+  getBranch: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/branches/*",
+    pathParams: { ...repoParams, branch: z.string().min(1) }
+  }),
+  deleteBranch: declareRouteInputs({
+    method: "DELETE",
+    path: "/repos/:owner/:repo/git/refs/heads/*",
+    pathParams: { ...repoParams, branch: z.string().min(1) }
+  }),
+  deleteFile: declareRouteInputs({
+    method: "DELETE",
+    path: "/repos/:owner/:repo/contents/*",
+    pathParams: { ...repoParams, path: z.string().min(1) },
+    bodyEncoding: "json",
+    body: {
+      message: z.string().min(1),
+      sha: z.string().min(1),
+      branch: z.string().optional()
+    }
+  }),
+  // ----- v2 cluster B — commits & diffs -----
+  getCommit: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/commits/:ref",
+    pathParams: { ...repoParams, ref: z.string().min(1) }
+  }),
+  // `:basehead{.+}` is a NAMED param with a regex tail, not a wildcard; the
+  // handler is what splits `base...head` out of it.
+  compareCommits: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/compare/:basehead{.+}",
+    pathParams: { ...repoParams, basehead: z.string().min(1) }
+  }),
+  getPullRequestDiff: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/pulls/:number/diff",
+    pathParams: { ...repoParams, number: numberParam }
+  }),
+  // ----- v2 cluster C — pull requests deeper -----
+  updatePullRequest: declareRouteInputs({
+    method: "PATCH",
+    path: "/repos/:owner/:repo/pulls/:number",
+    pathParams: { ...repoParams, number: numberParam },
+    bodyEncoding: "json",
+    body: {
+      title: z.string().optional(),
+      body: z.string().optional(),
+      state: stateWrite,
+      base: z.string().optional()
+    }
+  }),
+  listPullRequestCommits: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/pulls/:number/commits",
+    pathParams: { ...repoParams, number: numberParam },
+    query: { ...pageQuery }
+  }),
+  createPullRequestReviewComment: declareRouteInputs({
+    method: "POST",
+    path: "/repos/:owner/:repo/pulls/:number/comments",
+    pathParams: { ...repoParams, number: numberParam },
+    bodyEncoding: "json",
+    body: {
+      body: z.string().min(1),
+      path: z.string().min(1),
+      line: integerInput({ min: 1 }),
+      side: z.enum(["LEFT", "RIGHT"]).optional(),
+      commit_id: z.string().optional()
+    }
+  }),
+  replyToPullRequestReviewComment: declareRouteInputs({
+    method: "POST",
+    path: "/repos/:owner/:repo/pulls/:number/comments/:comment_id/replies",
+    pathParams: { ...repoParams, number: numberParam, comment_id: numberParam },
+    bodyEncoding: "json",
+    body: { ...commentBody }
+  }),
+  // ----- v2 cluster D — issue comments deeper -----
+  updateIssueComment: declareRouteInputs({
+    method: "PATCH",
+    path: "/repos/:owner/:repo/issues/comments/:comment_id",
+    pathParams: { ...repoParams, comment_id: numberParam },
+    bodyEncoding: "json",
+    body: { ...commentBody }
+  }),
+  deleteIssueComment: declareRouteInputs({
+    method: "DELETE",
+    path: "/repos/:owner/:repo/issues/comments/:comment_id",
+    pathParams: { ...repoParams, comment_id: numberParam }
+  }),
+  // ----- v2 cluster E — milestones -----
+  listMilestones: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/milestones",
+    pathParams: { ...repoParams },
+    query: { state: stateFilter, ...pageQuery }
+  }),
+  createMilestone: declareRouteInputs({
+    method: "POST",
+    path: "/repos/:owner/:repo/milestones",
+    pathParams: { ...repoParams },
+    bodyEncoding: "json",
+    body: {
+      title: z.string().min(1),
+      description: z.string().optional(),
+      due_on: z.string().optional(),
+      state: stateWrite
+    }
+  }),
+  updateMilestone: declareRouteInputs({
+    method: "PATCH",
+    path: "/repos/:owner/:repo/milestones/:number",
+    pathParams: { ...repoParams, number: numberParam },
+    bodyEncoding: "json",
+    body: {
+      title: z.string().optional(),
+      description: z.string().optional(),
+      due_on: z.string().optional(),
+      state: stateWrite
+    }
+  }),
+  deleteMilestone: declareRouteInputs({
+    method: "DELETE",
+    path: "/repos/:owner/:repo/milestones/:number",
+    pathParams: { ...repoParams, number: numberParam }
+  }),
+  // ----- v2 cluster F — commit status + checks -----
+  createCommitStatus: declareRouteInputs({
+    method: "POST",
+    path: "/repos/:owner/:repo/statuses/:sha",
+    pathParams: { ...repoParams, sha: z.string().min(1) },
+    bodyEncoding: "json",
+    body: {
+      state: z.enum(["error", "failure", "pending", "success"]),
+      context: z.string().optional(),
+      description: z.string().optional(),
+      target_url: z.string().optional()
+    }
+  }),
+  getCombinedStatusForRef: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/commits/:ref/status",
+    pathParams: { ...repoParams, ref: z.string().min(1) }
+  }),
+  createCheckRun: declareRouteInputs({
+    method: "POST",
+    path: "/repos/:owner/:repo/check-runs",
+    pathParams: { ...repoParams },
+    bodyEncoding: "json",
+    body: {
+      name: z.string().min(1),
+      head_sha: z.string().min(1),
+      status: z.enum(["queued", "in_progress", "completed"]).optional(),
+      conclusion: z.enum([
+        "success",
+        "failure",
+        "neutral",
+        "cancelled",
+        "timed_out",
+        "action_required",
+        "skipped",
+        "stale"
+      ]).optional(),
+      details_url: z.string().optional(),
+      external_id: z.string().optional(),
+      output: z.object({ title: z.string().optional(), summary: z.string().optional() }).optional(),
+      started_at: z.string().optional(),
+      completed_at: z.string().optional()
+    }
+  }),
+  listCheckRunsForRef: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/commits/:ref/check-runs",
+    pathParams: { ...repoParams, ref: z.string().min(1) },
+    query: { ...pageQuery }
+  }),
+  // ----- v2 cluster G — tags & releases -----
+  listTags: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/tags",
+    pathParams: { ...repoParams },
+    query: { ...pageQuery }
+  }),
+  listReleases: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/releases",
+    pathParams: { ...repoParams },
+    query: { ...pageQuery }
+  }),
+  getLatestRelease: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/releases/latest",
+    pathParams: { ...repoParams }
+  }),
+  getReleaseByTag: declareRouteInputs({
+    method: "GET",
+    path: "/repos/:owner/:repo/releases/tags/*",
+    pathParams: { ...repoParams, tag: z.string().min(1) }
+  }),
+  createRelease: declareRouteInputs({
+    method: "POST",
+    path: "/repos/:owner/:repo/releases",
+    pathParams: { ...repoParams },
+    bodyEncoding: "json",
+    body: {
+      tag_name: z.string().min(1),
+      target_commitish: z.string().optional(),
+      name: z.string().optional(),
+      body: z.string().optional(),
+      draft: z.boolean().optional(),
+      prerelease: z.boolean().optional()
+    }
+  }),
+  // ----- v2 cluster H — identity & collaborators -----
+  // The authenticated login comes from the session claim, not from a request
+  // input, so this surface declares nothing.
+  getAuthenticatedUser: declareRouteInputs({ method: "GET", path: "/user" }),
+  addCollaborator: declareRouteInputs({
+    method: "PUT",
+    path: "/repos/:owner/:repo/collaborators/:username",
+    pathParams: { ...repoParams, username: z.string().min(1) },
+    bodyEncoding: "json-optional",
+    body: {
+      permission: z.enum(["pull", "push", "admin", "maintain", "triage"]).optional()
+    }
+  })
+};
+
+// ../packages/twin-github/dist/src/routes.js
 function captureDelta(fn) {
   let delta = null;
   const value = fn((d) => {
@@ -3858,272 +4403,218 @@ function captureDelta(fn) {
   });
   return { value, delta };
 }
-var createRepoSchema = z.object({ name: z.string().min(1), owner: z.string().min(1).optional(), description: z.string().optional(), private: z.boolean().optional() });
-var contentSchema = z.object({ message: z.string().min(1), content: z.string(), branch: z.string().optional(), sha: z.string().optional(), encoding: z.enum(["utf-8", "base64"]).optional() });
-var createIssueSchema = z.object({ title: z.string().min(1), body: z.string().optional(), labels: z.array(z.string()).optional(), assignees: z.array(z.string()).optional() });
-var updateIssueSchema = z.object({ title: z.string().optional(), body: z.string().optional(), state: z.enum(["open", "closed"]).optional(), labels: z.array(z.string()).optional(), assignees: z.array(z.string()).optional() });
-var commentSchema = z.object({ body: z.string().min(1) });
-var labelSchema = z.object({ name: z.string().min(1), color: z.string().default("ededed"), description: z.string().default("") });
-var labelsSchema = z.object({ labels: z.array(z.string().min(1)).min(1) });
-var assigneesSchema = z.object({ assignees: z.array(z.string().min(1)).min(1) });
-var createPullSchema = z.object({ title: z.string().min(1), body: z.string().optional(), head: z.string().min(1), base: z.string().optional() });
-var reviewSchema = z.object({ event: z.enum(["APPROVE", "REQUEST_CHANGES", "COMMENT"]), body: z.string().optional() });
-var mergeSchema = z.object({ commit_title: z.string().optional(), commit_message: z.string().optional() });
-var updateBranchSchema = z.object({ expected_head_sha: z.string().optional() });
-var deleteFileSchema = z.object({ message: z.string().min(1), sha: z.string().min(1), branch: z.string().optional() });
-var updatePrSchema = z.object({ title: z.string().optional(), body: z.string().optional(), state: z.enum(["open", "closed"]).optional(), base: z.string().optional() });
-var reviewCommentSchema = z.object({ body: z.string().min(1), path: z.string().min(1), line: z.coerce.number().int().positive(), side: z.enum(["LEFT", "RIGHT"]).optional(), commit_id: z.string().optional() });
-var replyCommentSchema = z.object({ body: z.string().min(1) });
-var updateCommentSchema = z.object({ body: z.string().min(1) });
-var milestoneSchema = z.object({ title: z.string().min(1), description: z.string().optional(), due_on: z.string().optional(), state: z.enum(["open", "closed"]).optional() });
-var updateMilestoneSchema = z.object({ title: z.string().optional(), description: z.string().optional(), due_on: z.string().optional(), state: z.enum(["open", "closed"]).optional() });
-var createStatusSchema = z.object({ state: z.enum(["error", "failure", "pending", "success"]), context: z.string().optional(), description: z.string().optional(), target_url: z.string().optional() });
-var createCheckRunSchema = z.object({
-  name: z.string().min(1),
-  head_sha: z.string().min(1),
-  status: z.enum(["queued", "in_progress", "completed"]).optional(),
-  conclusion: z.enum(["success", "failure", "neutral", "cancelled", "timed_out", "action_required", "skipped", "stale"]).optional(),
-  details_url: z.string().optional(),
-  external_id: z.string().optional(),
-  output: z.object({ title: z.string().optional(), summary: z.string().optional() }).optional(),
-  started_at: z.string().optional(),
-  completed_at: z.string().optional()
-});
-var createReleaseSchema = z.object({
-  tag_name: z.string().min(1),
-  target_commitish: z.string().optional(),
-  name: z.string().optional(),
-  body: z.string().optional(),
-  draft: z.boolean().optional(),
-  prerelease: z.boolean().optional()
-});
-var addCollaboratorSchema = z.object({ permission: z.enum(["pull", "push", "admin", "maintain", "triage"]).optional() });
 function registerGitHubRoutes(session, { domain, recorder }) {
-  const handle = (fn) => recorder.handle({ mutation: false }, async (c) => {
-    const result = await fn(c);
-    return { status: result.status, body: result.body, mutation: result.mutation ?? false, delta: result.delta ?? null };
-  });
-  const handleAs = (tool, fn) => recorder.handle({ mutation: false, tool }, async (c) => {
-    const result = await fn(c);
-    return { status: result.status, body: result.body, mutation: result.mutation ?? false, delta: result.delta ?? null };
-  });
-  session.get("/search/repositories", handle((c) => ok(domain.searchRepositories({ q: c.req.query("q"), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
-  session.get("/search/code", handle((c) => ok(domain.searchCode({ q: c.req.query("q"), owner: c.req.query("owner"), repo: c.req.query("repo"), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
-  session.get("/search/issues", handle((c) => ok(domain.searchIssues({ q: c.req.query("q"), owner: c.req.query("owner"), repo: c.req.query("repo"), state: stateQuery(c), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
-  session.get("/search/users", handle((c) => ok(domain.searchUsers({ q: c.req.query("q"), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
-  session.get("/search/commits", handle((c) => ok(domain.searchCommits({ q: c.req.query("q"), owner: c.req.query("owner"), repo: c.req.query("repo"), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
-  session.get("/repos/:owner/:repo", handle((c) => ok(domain.getRepository(params(c)))));
-  session.post("/user/repos", handle(async (c) => {
-    const args = createRepoSchema.parse(await readJson(c));
-    const { value, delta } = captureDelta((onDelta) => domain.createRepository(args, onDelta));
+  const route = (declaration, handler, tool) => {
+    mountDeclaredRoute(session, declaration, recorder.handle({ mutation: false, ...tool ? { tool } : {} }, async (c) => {
+      const input = await parseDeclared(declaration, c);
+      const result = await handler(input, c);
+      return {
+        status: result.status,
+        body: result.body,
+        mutation: result.mutation ?? false,
+        delta: result.delta ?? null
+      };
+    }));
+  };
+  route(GITHUB_ROUTES.searchRepositories, ({ query }) => ok(domain.searchRepositories(query)));
+  route(GITHUB_ROUTES.searchCode, ({ query }) => ok(domain.searchCode(query)));
+  route(GITHUB_ROUTES.searchIssues, ({ query }) => ok(domain.searchIssues(query)));
+  route(GITHUB_ROUTES.searchUsers, ({ query }) => ok(domain.searchUsers(query)));
+  route(GITHUB_ROUTES.searchCommits, ({ query }) => ok(domain.searchCommits(query)));
+  route(GITHUB_ROUTES.getRepository, ({ path }) => ok(domain.getRepository(path)));
+  route(GITHUB_ROUTES.createUserRepository, ({ body }) => {
+    const { value, delta } = captureDelta((onDelta) => domain.createRepository(body, onDelta));
     return created(value, delta);
-  }));
-  session.post("/orgs/:owner/repos", handle(async (c) => {
-    const args = { ...createRepoSchema.parse(await readJson(c)), owner: c.req.param("owner") };
-    const { value, delta } = captureDelta((onDelta) => domain.createRepository(args, onDelta));
+  });
+  route(GITHUB_ROUTES.createOrgRepository, ({ path, body }) => {
+    const { value, delta } = captureDelta((onDelta) => domain.createRepository({ ...body, owner: path.owner }, onDelta));
     return created(value, delta);
-  }));
-  session.post("/repos/:owner/:repo/forks", handle(async (c) => {
-    const organization = (await maybeJson(c)).organization;
-    const { value, delta } = captureDelta((onDelta) => domain.forkRepository({ ...params(c), organization }, onDelta));
+  });
+  route(GITHUB_ROUTES.forkRepository, ({ path, body }) => {
+    const { value, delta } = captureDelta((onDelta) => domain.forkRepository({ ...path, ...body }, onDelta));
     return created(value, delta);
-  }));
-  session.get("/repos/:owner/:repo/contents", handle((c) => ok(domain.getFileContents({ ...params(c), path: "", ref: c.req.query("ref") }))));
-  session.get("/repos/:owner/:repo/contents/*", handle((c) => ok(domain.getFileContents({ ...params(c), path: contentPath(c), ref: c.req.query("ref") }))));
-  session.put("/repos/:owner/:repo/contents/*", handle(async (c) => {
-    const body = contentSchema.parse(await readJson(c));
-    const args = { ...params(c), path: contentPath(c), ...body };
-    const actor = sessionLogin(c);
-    const { value, delta } = captureDelta((onDelta) => domain.createOrUpdateFile(args, { actor }, onDelta));
+  });
+  route(GITHUB_ROUTES.getRepositoryRootContents, ({ path, query }) => ok(domain.getFileContents({ owner: path.owner, repo: path.repo, path: "", ref: query.ref })));
+  route(GITHUB_ROUTES.getFileContents, ({ path, query }) => ok(domain.getFileContents({ ...path, ref: query.ref })));
+  route(GITHUB_ROUTES.createOrUpdateFile, ({ path, body }, c) => {
+    const { value, delta } = captureDelta((onDelta) => domain.createOrUpdateFile({ ...path, ...body }, { actor: sessionLogin(c) }, onDelta));
     const status = delta !== null && delta.before === null ? 201 : 200;
     return { status, body: value, mutation: true, delta };
-  }));
-  session.get("/repos/:owner/:repo/commits", handle((c) => ok(domain.listCommits({ ...params(c), sha: c.req.query("sha"), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
-  session.post("/repos/:owner/:repo/git/refs", handle(async (c) => {
-    const body = z.object({ ref: z.string().min(1), sha: z.string().optional() }).parse(await readJson(c));
+  });
+  route(GITHUB_ROUTES.listCommits, ({ path, query }) => ok(domain.listCommits({ ...path, ...query })));
+  route(GITHUB_ROUTES.createRef, ({ path, body }) => {
     const branch = body.ref.replace(/^refs\/heads\//, "");
-    const { value, delta } = captureDelta((onDelta) => domain.createBranch({ ...params(c), branch, sha: body.sha }, onDelta));
+    const { value, delta } = captureDelta((onDelta) => domain.createBranch({ ...path, branch, sha: body.sha }, onDelta));
     return created(value, delta);
-  }));
-  session.get("/repos/:owner/:repo/issues", handle((c) => ok(domain.listIssues({ ...params(c), state: stateQuery(c), labels: c.req.query("labels"), assignee: c.req.query("assignee"), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
-  session.post("/repos/:owner/:repo/issues", handle(async (c) => {
-    const args = { ...params(c), ...createIssueSchema.parse(await readJson(c)) };
-    const { value, delta } = captureDelta((onDelta) => domain.createIssue(args, onDelta));
+  });
+  route(GITHUB_ROUTES.listIssues, ({ path, query }) => ok(domain.listIssues({ ...path, ...query })));
+  route(GITHUB_ROUTES.createIssue, ({ path, body }) => {
+    const { value, delta } = captureDelta((onDelta) => domain.createIssue({ ...path, ...body }, onDelta));
     return created(value, delta);
-  }));
-  session.get("/repos/:owner/:repo/issues/:number", handle((c) => ok(domain.getIssue({ ...params(c), issue_number: numberParam(c, "number") }))));
-  session.patch("/repos/:owner/:repo/issues/:number", handle(async (c) => {
-    const args = { ...params(c), issue_number: numberParam(c, "number"), ...updateIssueSchema.parse(await readJson(c)) };
-    const { value, delta } = captureDelta((onDelta) => domain.updateIssue(args, onDelta));
+  });
+  route(GITHUB_ROUTES.getIssue, ({ path }) => ok(domain.getIssue(issueRef(path))));
+  route(GITHUB_ROUTES.updateIssue, ({ path, body }) => {
+    const { value, delta } = captureDelta((onDelta) => domain.updateIssue({ ...issueRef(path), ...body }, onDelta));
     return ok(value, true, delta);
-  }));
-  session.get("/repos/:owner/:repo/issues/:number/comments", handle((c) => ok(domain.listIssueComments({ ...params(c), issue_number: numberParam(c, "number"), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
-  session.post("/repos/:owner/:repo/issues/:number/comments", handle(async (c) => {
-    const args = { ...params(c), issue_number: numberParam(c, "number"), ...commentSchema.parse(await readJson(c)) };
-    const { value, delta } = captureDelta((onDelta) => domain.addIssueComment(args, onDelta));
+  });
+  route(GITHUB_ROUTES.listIssueComments, ({ path, query }) => ok(domain.listIssueComments({ ...issueRef(path), ...query })));
+  route(GITHUB_ROUTES.addIssueComment, ({ path, body }) => {
+    const { value, delta } = captureDelta((onDelta) => domain.addIssueComment({ ...issueRef(path), ...body }, onDelta));
     return created(value, delta);
-  }));
-  session.get("/repos/:owner/:repo/labels", handle((c) => ok(domain.listRepositoryLabels(params(c)))));
-  session.post("/repos/:owner/:repo/labels", handle(async (c) => {
-    const args = { ...params(c), ...labelSchema.parse(await readJson(c)) };
-    const { value, delta } = captureDelta((onDelta) => domain.createRepositoryLabel(args, onDelta));
+  });
+  route(GITHUB_ROUTES.listRepositoryLabels, ({ path }) => ok(domain.listRepositoryLabels(path)));
+  route(GITHUB_ROUTES.createRepositoryLabel, ({ path, body }) => {
+    const { value, delta } = captureDelta((onDelta) => domain.createRepositoryLabel({ ...path, ...body }, onDelta));
     return created(value, delta);
-  }));
-  session.get("/repos/:owner/:repo/issues/:number/labels", handle((c) => ok(domain.listIssueLabelsForIssue({ ...params(c), issue_number: numberParam(c, "number") }))));
-  session.post("/repos/:owner/:repo/issues/:number/labels", handle(async (c) => {
-    const args = { ...params(c), issue_number: numberParam(c, "number"), ...labelsSchema.parse(await readJson(c)) };
-    const { value, delta } = captureDelta((onDelta) => domain.addIssueLabels(args, onDelta));
+  });
+  route(GITHUB_ROUTES.listIssueLabels, ({ path }) => ok(domain.listIssueLabelsForIssue(issueRef(path))));
+  route(GITHUB_ROUTES.addIssueLabels, ({ path, body }) => {
+    const { value, delta } = captureDelta((onDelta) => domain.addIssueLabels({ ...issueRef(path), ...body }, onDelta));
     return ok(value, true, delta);
-  }));
-  session.delete("/repos/:owner/:repo/issues/:number/labels/:name", handle((c) => {
-    const args = { ...params(c), issue_number: numberParam(c, "number"), label: requireParam(c, "name") };
-    const { value, delta } = captureDelta((onDelta) => domain.deleteIssueLabel(args, onDelta));
+  });
+  route(GITHUB_ROUTES.deleteIssueLabel, ({ path }) => {
+    const { value, delta } = captureDelta((onDelta) => domain.deleteIssueLabel({ ...issueRef(path), label: path.name }, onDelta));
     return ok(value, true, delta);
-  }));
-  session.get("/repos/:owner/:repo/collaborators", handle((c) => ok(domain.listCollaborators(params(c)))));
-  session.get("/repos/:owner/:repo/collaborators/:username", handle((c) => {
-    const found = domain.isCollaborator({ ...params(c), username: requireParam(c, "username") });
-    if (!found)
+  });
+  route(GITHUB_ROUTES.listCollaborators, ({ path }) => ok(domain.listCollaborators(path)));
+  route(GITHUB_ROUTES.checkCollaborator, ({ path }) => {
+    if (!domain.isCollaborator(path))
       throw new TwinError("Not Found", 404);
     return { status: 204, body: null, mutation: false };
-  }));
-  session.post("/repos/:owner/:repo/issues/:number/assignees", handle(async (c) => {
-    const args = { ...params(c), issue_number: numberParam(c, "number"), ...assigneesSchema.parse(await readJson(c)) };
-    const { value, delta } = captureDelta((onDelta) => domain.addAssignees(args, onDelta));
+  });
+  route(GITHUB_ROUTES.addAssignees, ({ path, body }) => {
+    const { value, delta } = captureDelta((onDelta) => domain.addAssignees({ ...issueRef(path), ...body }, onDelta));
     return created(value, delta);
-  }));
-  session.get("/repos/:owner/:repo/pulls", handle((c) => ok(domain.listPullRequests({ ...params(c), state: stateQuery(c), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
-  session.post("/repos/:owner/:repo/pulls", handle(async (c) => {
-    const actor = sessionLogin(c);
-    const args = { ...params(c), ...createPullSchema.parse(await readJson(c)), actor };
+  });
+  route(GITHUB_ROUTES.listPullRequests, ({ path, query }) => ok(domain.listPullRequests({ ...path, ...query })));
+  route(GITHUB_ROUTES.createPullRequest, ({ path, body }, c) => {
+    const args = { ...path, ...body, actor: sessionLogin(c) };
     const { value, delta } = captureDelta((onDelta) => domain.createPullRequest(args, onDelta));
     return created(value, delta);
-  }));
-  session.get("/repos/:owner/:repo/pulls/:number", handle((c) => ok(domain.getPullRequest({ ...params(c), pull_number: numberParam(c, "number") }))));
-  session.get("/repos/:owner/:repo/pulls/:number/files", handle((c) => ok(domain.getPullRequestFiles({ ...params(c), pull_number: numberParam(c, "number"), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
-  session.get("/repos/:owner/:repo/pulls/:number/reviews", handle((c) => ok(domain.getPullRequestReviews({ ...params(c), pull_number: numberParam(c, "number"), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
-  session.post("/repos/:owner/:repo/pulls/:number/reviews", handle(async (c) => {
-    const args = { ...params(c), pull_number: numberParam(c, "number"), ...reviewSchema.parse(await readJson(c)) };
-    const { value, delta } = captureDelta((onDelta) => domain.createPullRequestReview(args, onDelta));
+  });
+  route(GITHUB_ROUTES.getPullRequest, ({ path }) => ok(domain.getPullRequest(pullRef(path))));
+  route(GITHUB_ROUTES.listPullRequestFiles, ({ path, query }) => ok(domain.getPullRequestFiles({ ...pullRef(path), ...query })));
+  route(GITHUB_ROUTES.listPullRequestReviews, ({ path, query }) => ok(domain.getPullRequestReviews({ ...pullRef(path), ...query })));
+  route(GITHUB_ROUTES.createPullRequestReview, ({ path, body }) => {
+    const { value, delta } = captureDelta((onDelta) => domain.createPullRequestReview({ ...pullRef(path), ...body }, onDelta));
     return created(value, delta);
-  }));
-  session.get("/repos/:owner/:repo/pulls/:number/comments", handle((c) => ok(domain.getPullRequestComments({ ...params(c), pull_number: numberParam(c, "number"), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
-  session.get("/repos/:owner/:repo/pulls/:number/status", handle((c) => ok(domain.getPullRequestStatus({ ...params(c), pull_number: numberParam(c, "number") }))));
-  session.put("/repos/:owner/:repo/pulls/:number/merge", handle(async (c) => {
-    const args = { ...params(c), pull_number: numberParam(c, "number"), ...mergeSchema.parse(await maybeJson(c)) };
+  });
+  route(GITHUB_ROUTES.listPullRequestComments, ({ path, query }) => ok(domain.getPullRequestComments({ ...pullRef(path), ...query })));
+  route(GITHUB_ROUTES.getPullRequestStatus, ({ path }) => ok(domain.getPullRequestStatus(pullRef(path))));
+  route(GITHUB_ROUTES.mergePullRequest, ({ path, body }, c) => {
+    const args = { ...pullRef(path), ...body };
     const actor = sessionLogin(c);
-    if (!actor || !domain.hasRepositoryPermission({ owner: args.owner, repo: args.repo, username: actor, permissions: ["push", "maintain", "admin"] })) {
+    if (!actor || !domain.hasRepositoryPermission({
+      owner: args.owner,
+      repo: args.repo,
+      username: actor,
+      permissions: ["push", "maintain", "admin"]
+    })) {
       throw new TwinError("Must have push access to the repository to merge pull requests.", 403);
     }
     const { value, delta } = captureDelta((onDelta) => domain.mergePullRequest(args, onDelta));
     return ok(value, true, delta);
-  }));
-  session.put("/repos/:owner/:repo/pulls/:number/update-branch", handle(async (c) => {
-    const args = { ...params(c), pull_number: numberParam(c, "number"), ...updateBranchSchema.parse(await maybeJson(c)) };
-    const { value, delta } = captureDelta((onDelta) => domain.updatePullRequestBranch(args, onDelta));
+  });
+  route(GITHUB_ROUTES.updatePullRequestBranch, ({ path, body }) => {
+    const { value, delta } = captureDelta((onDelta) => domain.updatePullRequestBranch({ ...pullRef(path), ...body }, onDelta));
     return ok(value, true, delta);
-  }));
-  session.get("/repos/:owner/:repo/branches", handle((c) => ok(domain.listBranchesForRepo({ ...params(c), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
-  session.get("/repos/:owner/:repo/branches/*", handle((c) => ok(domain.getBranchByName({ ...params(c), branch: routeTail(c, "branches/") }))));
-  session.delete("/repos/:owner/:repo/git/refs/heads/*", handle((c) => {
-    const args = { ...params(c), branch: routeTail(c, "git/refs/heads/") };
-    const { delta } = captureDelta((onDelta) => domain.deleteBranch(args, onDelta));
+  });
+  route(GITHUB_ROUTES.listBranches, ({ path, query }) => ok(domain.listBranchesForRepo({ ...path, ...query })));
+  route(GITHUB_ROUTES.getBranch, ({ path }) => ok(domain.getBranchByName(path)));
+  route(GITHUB_ROUTES.deleteBranch, ({ path }) => {
+    const { delta } = captureDelta((onDelta) => domain.deleteBranch(path, onDelta));
     return { status: 204, body: null, mutation: true, delta };
-  }));
-  session.delete("/repos/:owner/:repo/contents/*", handle(async (c) => {
-    const body = deleteFileSchema.parse(await readJson(c));
-    const args = { ...params(c), path: contentPath(c), ...body };
-    const actor = sessionLogin(c);
-    const { value, delta } = captureDelta((onDelta) => domain.deleteFile(args, { actor }, onDelta));
+  });
+  route(GITHUB_ROUTES.deleteFile, ({ path, body }, c) => {
+    const { value, delta } = captureDelta((onDelta) => domain.deleteFile({ ...path, ...body }, { actor: sessionLogin(c) }, onDelta));
     return ok(value, true, delta);
-  }));
-  session.get("/repos/:owner/:repo/commits/:ref", handle((c) => ok(domain.getCommitWithFiles({ ...params(c), ref: requireParam(c, "ref") }))));
-  session.get("/repos/:owner/:repo/compare/:basehead{.+}", handle((c) => {
-    const basehead = requireParam(c, "basehead");
-    const parts = basehead.split("...");
+  });
+  route(GITHUB_ROUTES.getCommit, ({ path }) => ok(domain.getCommitWithFiles(path)));
+  route(GITHUB_ROUTES.compareCommits, ({ path }) => {
+    const parts = path.basehead.split("...");
     if (parts.length !== 2 || !parts[0] || !parts[1]) {
       throw new TwinError("Invalid compare ref. Expected 'base...head'.", 422);
     }
-    return ok(domain.compareCommits({ ...params(c), base: parts[0], head: parts[1] }));
-  }));
-  session.get("/repos/:owner/:repo/pulls/:number/diff", handle((c) => ok(domain.getPullRequestDiff({ ...params(c), pull_number: numberParam(c, "number") }))));
-  session.patch("/repos/:owner/:repo/pulls/:number", handle(async (c) => {
-    const args = { ...params(c), pull_number: numberParam(c, "number"), ...updatePrSchema.parse(await readJson(c)) };
-    const { value, delta } = captureDelta((onDelta) => domain.updatePullRequest(args, onDelta));
+    return ok(domain.compareCommits({ owner: path.owner, repo: path.repo, base: parts[0], head: parts[1] }));
+  });
+  route(GITHUB_ROUTES.getPullRequestDiff, ({ path }) => ok(domain.getPullRequestDiff(pullRef(path))));
+  route(GITHUB_ROUTES.updatePullRequest, ({ path, body }) => {
+    const { value, delta } = captureDelta((onDelta) => domain.updatePullRequest({ ...pullRef(path), ...body }, onDelta));
     return ok(value, true, delta);
-  }));
-  session.get("/repos/:owner/:repo/pulls/:number/commits", handle((c) => ok(domain.getPullRequestCommits({ ...params(c), pull_number: numberParam(c, "number"), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
-  session.post("/repos/:owner/:repo/pulls/:number/comments", handle(async (c) => {
-    const args = { ...params(c), pull_number: numberParam(c, "number"), ...reviewCommentSchema.parse(await readJson(c)) };
-    const actor = sessionLogin(c);
-    const { value, delta } = captureDelta((onDelta) => domain.createPullRequestReviewComment(args, { actor }, onDelta));
+  });
+  route(GITHUB_ROUTES.listPullRequestCommits, ({ path, query }) => ok(domain.getPullRequestCommits({ ...pullRef(path), ...query })));
+  route(GITHUB_ROUTES.createPullRequestReviewComment, ({ path, body }, c) => {
+    const { value, delta } = captureDelta((onDelta) => domain.createPullRequestReviewComment({ ...pullRef(path), ...body }, { actor: sessionLogin(c) }, onDelta));
     return created(value, delta);
-  }));
-  session.post("/repos/:owner/:repo/pulls/:number/comments/:comment_id/replies", handle(async (c) => {
-    const args = { ...params(c), pull_number: numberParam(c, "number"), comment_id: numberParam(c, "comment_id"), ...replyCommentSchema.parse(await readJson(c)) };
-    const actor = sessionLogin(c);
-    const { value, delta } = captureDelta((onDelta) => domain.addReplyToPullRequestComment(args, { actor }, onDelta));
+  });
+  route(GITHUB_ROUTES.replyToPullRequestReviewComment, ({ path, body }, c) => {
+    const { value, delta } = captureDelta((onDelta) => domain.addReplyToPullRequestComment({ ...pullRef(path), comment_id: path.comment_id, ...body }, { actor: sessionLogin(c) }, onDelta));
     return created(value, delta);
-  }));
-  session.patch("/repos/:owner/:repo/issues/comments/:comment_id", handle(async (c) => {
-    const args = { ...params(c), comment_id: numberParam(c, "comment_id"), ...updateCommentSchema.parse(await readJson(c)) };
-    const { value, delta } = captureDelta((onDelta) => domain.updateIssueComment(args, onDelta));
+  });
+  route(GITHUB_ROUTES.updateIssueComment, ({ path, body }) => {
+    const { value, delta } = captureDelta((onDelta) => domain.updateIssueComment({ ...path, ...body }, onDelta));
     return ok(value, true, delta);
-  }));
-  session.delete("/repos/:owner/:repo/issues/comments/:comment_id", handle((c) => {
-    const args = { ...params(c), comment_id: numberParam(c, "comment_id") };
-    const { delta } = captureDelta((onDelta) => domain.deleteIssueComment(args, onDelta));
+  });
+  route(GITHUB_ROUTES.deleteIssueComment, ({ path }) => {
+    const { delta } = captureDelta((onDelta) => domain.deleteIssueComment(path, onDelta));
     return { status: 204, body: null, mutation: true, delta };
-  }));
-  session.get("/repos/:owner/:repo/milestones", handle((c) => ok(domain.listMilestones({ ...params(c), state: stateQuery(c), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
-  session.post("/repos/:owner/:repo/milestones", handle(async (c) => {
-    const args = { ...params(c), ...milestoneSchema.parse(await readJson(c)) };
-    const { value, delta } = captureDelta((onDelta) => domain.createMilestone(args, onDelta));
+  });
+  route(GITHUB_ROUTES.listMilestones, ({ path, query }) => ok(domain.listMilestones({ ...path, ...query })));
+  route(GITHUB_ROUTES.createMilestone, ({ path, body }) => {
+    const { value, delta } = captureDelta((onDelta) => domain.createMilestone({ ...path, ...body }, onDelta));
     return created(value, delta);
-  }));
-  session.patch("/repos/:owner/:repo/milestones/:number", handle(async (c) => {
-    const args = { ...params(c), milestone_number: numberParam(c, "number"), ...updateMilestoneSchema.parse(await readJson(c)) };
-    const { value, delta } = captureDelta((onDelta) => domain.updateMilestone(args, onDelta));
+  });
+  route(GITHUB_ROUTES.updateMilestone, ({ path, body }) => {
+    const { value, delta } = captureDelta((onDelta) => domain.updateMilestone({ ...milestoneRef(path), ...body }, onDelta));
     return ok(value, true, delta);
-  }));
-  session.delete("/repos/:owner/:repo/milestones/:number", handle((c) => {
-    const args = { ...params(c), milestone_number: numberParam(c, "number") };
-    const { delta } = captureDelta((onDelta) => domain.deleteMilestone(args, onDelta));
+  });
+  route(GITHUB_ROUTES.deleteMilestone, ({ path }) => {
+    const { delta } = captureDelta((onDelta) => domain.deleteMilestone(milestoneRef(path), onDelta));
     return { status: 204, body: null, mutation: true, delta };
-  }));
-  session.post("/repos/:owner/:repo/statuses/:sha", handleAs("create_commit_status", async (c) => {
-    const args = { ...params(c), sha: requireParam(c, "sha"), ...createStatusSchema.parse(await readJson(c)) };
-    const { value, delta } = captureDelta((onDelta) => domain.createCommitStatus(args, onDelta));
+  });
+  route(GITHUB_ROUTES.createCommitStatus, ({ path, body }) => {
+    const { value, delta } = captureDelta((onDelta) => domain.createCommitStatus({ ...path, ...body }, onDelta));
     return created(value, delta);
-  }));
-  session.get("/repos/:owner/:repo/commits/:ref/status", handle((c) => ok(domain.getCombinedStatusForRef({ ...params(c), ref: requireParam(c, "ref") }))));
-  session.post("/repos/:owner/:repo/check-runs", handleAs("create_check_run", async (c) => {
-    const args = { ...params(c), ...createCheckRunSchema.parse(await readJson(c)) };
-    const { value, delta } = captureDelta((onDelta) => domain.createCheckRun(args, onDelta));
+  }, "create_commit_status");
+  route(GITHUB_ROUTES.getCombinedStatusForRef, ({ path }) => ok(domain.getCombinedStatusForRef(path)));
+  route(GITHUB_ROUTES.createCheckRun, ({ path, body }) => {
+    const { value, delta } = captureDelta((onDelta) => domain.createCheckRun({ ...path, ...body }, onDelta));
     return created(value, delta);
-  }));
-  session.get("/repos/:owner/:repo/commits/:ref/check-runs", handle((c) => ok(domain.listCheckRunsForRef({ ...params(c), ref: requireParam(c, "ref"), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
-  session.get("/repos/:owner/:repo/tags", handle((c) => ok(domain.listTags({ ...params(c), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
-  session.get("/repos/:owner/:repo/releases", handle((c) => ok(domain.listReleases({ ...params(c), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
-  session.get("/repos/:owner/:repo/releases/latest", handle((c) => ok(domain.getLatestRelease(params(c)))));
-  session.get("/repos/:owner/:repo/releases/tags/*", handle((c) => ok(domain.getReleaseByTag({ ...params(c), tag: routeTail(c, "releases/tags/") }))));
-  session.post("/repos/:owner/:repo/releases", handle(async (c) => {
-    const args = { ...params(c), ...createReleaseSchema.parse(await readJson(c)) };
-    const actor = sessionLogin(c);
-    const { value, delta } = captureDelta((onDelta) => domain.createRelease(args, { actor }, onDelta));
+  }, "create_check_run");
+  route(GITHUB_ROUTES.listCheckRunsForRef, ({ path, query }) => ok(domain.listCheckRunsForRef({ ...path, ...query })));
+  route(GITHUB_ROUTES.listTags, ({ path, query }) => ok(domain.listTags({ ...path, ...query })));
+  route(GITHUB_ROUTES.listReleases, ({ path, query }) => ok(domain.listReleases({ ...path, ...query })));
+  route(GITHUB_ROUTES.getLatestRelease, ({ path }) => ok(domain.getLatestRelease(path)));
+  route(GITHUB_ROUTES.getReleaseByTag, ({ path }) => ok(domain.getReleaseByTag(path)));
+  route(GITHUB_ROUTES.createRelease, ({ path, body }, c) => {
+    const { value, delta } = captureDelta((onDelta) => domain.createRelease({ ...path, ...body }, { actor: sessionLogin(c) }, onDelta));
     return created(value, delta);
-  }));
-  session.get("/user", handle((c) => ok(domain.getMe({ actor: sessionLogin(c) }))));
-  session.put("/repos/:owner/:repo/collaborators/:username", handle(async (c) => {
-    const body = addCollaboratorSchema.parse(await maybeJson(c));
+  });
+  route(GITHUB_ROUTES.getAuthenticatedUser, (_input, c) => ok(domain.getMe({ actor: sessionLogin(c) })));
+  route(GITHUB_ROUTES.addCollaborator, ({ path, body }, c) => {
     const actor = sessionLogin(c);
-    if (!actor || !domain.hasRepositoryPermission({ ...params(c), username: actor, permissions: ["push", "maintain", "admin"] })) {
+    if (!actor || !domain.hasRepositoryPermission({
+      owner: path.owner,
+      repo: path.repo,
+      username: actor,
+      permissions: ["push", "maintain", "admin"]
+    })) {
       throw new TwinError("Must have push access to the repository to add collaborators.", 403);
     }
-    const args = { ...params(c), username: requireParam(c, "username"), permission: body.permission };
-    const { value, delta } = captureDelta((onDelta) => domain.addCollaboratorAction({ ...args, actor }, onDelta));
+    const { value, delta } = captureDelta((onDelta) => domain.addCollaboratorAction({ ...path, permission: body.permission, actor }, onDelta));
     return { status: value.status, body: value.body, mutation: true, delta };
-  }));
+  });
+}
+async function parseDeclared(declaration, c) {
+  try {
+    return await declaration.parse(c.req);
+  } catch (error) {
+    if (error instanceof UndeclaredInputError)
+      validationFailed(error.first, "invalid");
+    if (error instanceof MalformedBodyError)
+      throw new SyntaxError("Problems parsing JSON");
+    throw error;
+  }
 }
 function ok(body, mutation = false, delta = null) {
   return { status: 200, body, mutation, delta };
@@ -4131,59 +4622,18 @@ function ok(body, mutation = false, delta = null) {
 function created(body, delta = null) {
   return { status: 201, body, mutation: true, delta };
 }
-async function readJson(c) {
-  try {
-    return await c.req.json();
-  } catch {
-    throw new SyntaxError("Problems parsing JSON");
-  }
-}
-async function maybeJson(c) {
-  try {
-    return await c.req.json();
-  } catch {
-    return {};
-  }
-}
-function params(c) {
-  return { owner: requireParam(c, "owner"), repo: requireParam(c, "repo") };
-}
 function sessionLogin(c) {
   const session = c.get("session");
   return typeof session?.login === "string" ? session.login : void 0;
 }
-function numberParam(c, name) {
-  const value = Number(c.req.param(name));
-  if (!Number.isInteger(value) || value < 1)
-    validationFailed(name, "invalid", c.req.param(name));
-  return value;
-}
-function requireParam(c, name) {
-  const value = c.req.param(name);
-  if (!value)
-    throw new TwinError(`Missing route parameter: ${name}`, 400);
-  return value;
-}
-function contentPath(c) {
-  return routeTail(c, "contents/");
-}
-function routeTail(c, marker) {
-  const { owner, repo } = params(c);
-  const pathname = new URL(c.req.url).pathname;
-  const sid = pathname.match(/^\/s\/([^/]+)\//)?.[1] ?? "";
-  const prefix = `/s/${sid}/repos/${owner}/${repo}/${marker}`;
-  const value = decodeURIComponent(pathname.startsWith(prefix) ? pathname.slice(prefix.length) : "");
-  if (!value)
-    throw new TwinError(`Missing route path after ${marker}`, 400);
-  return value;
-}
-function numberQuery(c, name) {
-  const value = c.req.query(name);
-  return value ? Number(value) : void 0;
-}
-function stateQuery(c) {
-  const state = c.req.query("state");
-  return state === "open" || state === "closed" || state === "all" ? state : void 0;
+function issueRef(path) {
+  return { owner: path.owner, repo: path.repo, issue_number: path.number };
+}
+function pullRef(path) {
+  return { owner: path.owner, repo: path.repo, pull_number: path.number };
+}
+function milestoneRef(path) {
+  return { owner: path.owner, repo: path.repo, milestone_number: path.number };
 }
 
 // ../packages/twin-github/dist/src/unsupported-envelope.js