@fern-api/fdr-sdk 1.2.115-60bc9699d1 → 1.2.116-4e00acf721

package/dist/js/orpc-client.mjs

@@ -5583,9 +5583,10 @@ import { OpenAPILink as OpenAPILink17 } from "@orpc/openapi-client/fetch";
 
 // src/orpc-client/mcp-hosting/contract.ts
 import { oc as oc15 } from "@orpc/contract";
+import * as z27 from "zod";
+
+// src/orpc-client/mcp-hosting/schemas.ts
 import * as z26 from "zod";
-var McpPathSegmentSchema = z26.string().min(1).max(30).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
-var McpDeploymentStatusSchema = z26.enum(["PUBLISHING", "SUCCEEDED", "FAILED"]);
 var McpAuthSchemeSchema = z26.discriminatedUnion("type", [
   z26.object({ type: z26.literal("bearer") }),
   z26.object({
@@ -5595,6 +5596,9 @@ var McpAuthSchemeSchema = z26.discriminatedUnion("type", [
   }),
   z26.object({ type: z26.literal("basic") })
 ]);
+var HttpUrlSchema = z26.string().url().refine((value) => /^https?:\/\//i.test(value), {
+  message: "must be an http(s) URL"
+});
 var McpMetadataSchema = z26.object({
   name: z26.string().min(1),
   toolsets: z26.record(z26.string(), z26.array(z26.string())),
@@ -5618,47 +5622,67 @@ var McpMetadataSchema = z26.object({
       required: z26.boolean()
     }).strict()
   ),
-  baseUrl: z26.string().url(),
+  baseUrl: HttpUrlSchema,
   followRedirects: z26.boolean(),
   maxRedirects: z26.number().int().nonnegative(),
   allowedRedirectHosts: z26.array(z26.string())
 }).passthrough();
-var McpModuleSchema = z26.object({
-  name: z26.string().regex(/^[A-Za-z0-9._/-]+$/),
-  hash: z26.string().regex(/^[0-9a-f]{64}$/),
-  contentType: z26.string().min(1)
+var DeploymentConfigSchema = z26.object({
+  serverName: z26.string().min(1),
+  baseUrl: HttpUrlSchema,
+  /**
+   * Runtime rewrite of the upstream base URL. Part of the edge contract
+   * (the outbound worker honors it) but not yet written by FDR.
+   */
+  baseUrlOverride: HttpUrlSchema.optional(),
+  followRedirects: z26.boolean(),
+  maxRedirects: z26.number().int().nonnegative(),
+  allowedRedirectHosts: z26.array(z26.string()),
+  authSchemes: z26.array(McpAuthSchemeSchema),
+  authRequired: z26.boolean(),
+  toolsets: z26.record(z26.string(), z26.array(z26.string())),
+  toolsetMetadata: McpMetadataSchema.shape.toolsetMetadata
+});
+
+// src/orpc-client/mcp-hosting/contract.ts
+var McpPathSegmentSchema = z27.string().min(1).max(30).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
+var McpDeploymentStatusSchema = z27.enum(["PUBLISHING", "SUCCEEDED", "FAILED"]);
+var McpModuleSchema = z27.object({
+  name: z27.string().regex(/^[A-Za-z0-9._/-]+$/),
+  hash: z27.string().regex(/^[0-9a-f]{64}$/),
+  contentType: z27.string().min(1)
 }).strict();
-var McpGitInputSchema = z26.object({
-  repoUrl: z26.string(),
-  branch: z26.string(),
-  commitSha: z26.string().optional()
+var McpGitInputSchema = z27.object({
+  repoUrl: z27.string(),
+  branch: z27.string(),
+  commitSha: z27.string().optional()
 }).strict();
-var DeployMcpServerInputSchema = z26.object({
+var DeployMcpServerInputSchema = z27.object({
   orgId: McpPathSegmentSchema,
   slug: McpPathSegmentSchema,
-  mainModule: z26.string().min(1),
-  compatibilityDate: z26.string().regex(/^\d{4}-\d{2}-\d{2}$/),
-  compatibilityFlags: z26.array(z26.string()),
+  mainModule: z27.string().min(1),
+  compatibilityDate: z27.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  compatibilityFlags: z27.array(z27.string()),
   // Bounded so a single deploy request cannot fan out unbounded parallel
   // CAS lookups and S3 reads. Generated MCP workers are 1-2 modules;
   // 20 leaves room for wasm/sourcemap/chunk splitting.
-  modules: z26.array(McpModuleSchema).min(1).max(20),
+  modules: z27.array(McpModuleSchema).min(1).max(20),
   metadata: McpMetadataSchema,
   // Everything else in this schema is bounded; keep the opaque config
   // blob bounded too so it cannot balloon the JSONB row.
-  config: z26.unknown().optional().refine((value) => value === void 0 || (JSON.stringify(value)?.length ?? 0) <= 65536, {
+  config: z27.unknown().optional().refine((value) => value === void 0 || (JSON.stringify(value)?.length ?? 0) <= 65536, {
     message: "config must be at most 64KB serialized"
   }),
-  generatorName: z26.string().min(1),
-  generatorVersion: z26.string().min(1),
-  cliVersion: z26.string().optional(),
+  generatorName: z27.string().min(1),
+  generatorVersion: z27.string().min(1),
+  cliVersion: z27.string().optional(),
   git: McpGitInputSchema.optional()
 }).strict().superRefine((input, ctx) => {
   const names = /* @__PURE__ */ new Set();
   for (const module of input.modules) {
     if (names.has(module.name)) {
       ctx.addIssue({
-        code: z26.ZodIssueCode.custom,
+        code: z27.ZodIssueCode.custom,
         path: ["modules"],
         message: `duplicate module name: ${module.name}`
       });
@@ -5667,45 +5691,45 @@ var DeployMcpServerInputSchema = z26.object({
   }
   if (!names.has(input.mainModule)) {
     ctx.addIssue({
-      code: z26.ZodIssueCode.custom,
+      code: z27.ZodIssueCode.custom,
       path: ["mainModule"],
       message: `mainModule ${input.mainModule} is not among the submitted modules`
     });
   }
 });
-var GetMcpServerInputSchema = z26.object({
+var GetMcpServerInputSchema = z27.object({
   orgId: McpPathSegmentSchema,
   slug: McpPathSegmentSchema
 });
-var ListMcpServersInputSchema = z26.object({
-  orgId: z26.string()
+var ListMcpServersInputSchema = z27.object({
+  orgId: z27.string()
 });
 var ListMcpDeploymentsInputSchema = GetMcpServerInputSchema;
 var DeleteMcpServerInputSchema = GetMcpServerInputSchema;
-var McpDeploymentSummarySchema = z26.object({
-  id: z26.string(),
+var McpDeploymentSummarySchema = z27.object({
+  id: z27.string(),
   status: McpDeploymentStatusSchema,
   /** True when this deployment is the one the server currently serves. */
-  isActive: z26.boolean(),
-  generatorVersion: z26.string(),
-  createdAt: z26.string(),
-  createdBy: z26.string().nullish(),
-  error: z26.object({ name: z26.string(), message: z26.string() }).nullish()
-});
-var McpServerSchema = z26.object({
-  id: z26.string(),
-  orgId: z26.string(),
-  slug: z26.string(),
+  isActive: z27.boolean(),
+  generatorVersion: z27.string(),
+  createdAt: z27.string(),
+  createdBy: z27.string().nullish(),
+  error: z27.object({ name: z27.string(), message: z27.string() }).nullish()
+});
+var McpServerSchema = z27.object({
+  id: z27.string(),
+  orgId: z27.string(),
+  slug: z27.string(),
   /** The server is serving iff this is set; it names the serving deployment. */
-  activeDeploymentId: z26.string().nullish(),
+  activeDeploymentId: z27.string().nullish(),
   /** Most recent publication attempt — how the last deploy went. */
   latestDeployment: McpDeploymentSummarySchema.nullish(),
-  url: z26.string().url(),
-  createdAt: z26.string(),
-  updatedAt: z26.string()
+  url: z27.string().url(),
+  createdAt: z27.string(),
+  updatedAt: z27.string()
 });
-var ListMcpServersResponseSchema = z26.object({ servers: z26.array(McpServerSchema) });
-var ListMcpDeploymentsResponseSchema = z26.object({ deployments: z26.array(McpDeploymentSummarySchema) });
+var ListMcpServersResponseSchema = z27.object({ servers: z27.array(McpServerSchema) });
+var ListMcpDeploymentsResponseSchema = z27.object({ deployments: z27.array(McpDeploymentSummarySchema) });
 var mcpHostingContract = {
   deploy: oc15.route({ method: "POST", path: "/deploy" }).input(DeployMcpServerInputSchema).output(McpServerSchema),
   getServer: oc15.route({ method: "GET", path: "/servers/{slug}" }).input(GetMcpServerInputSchema).output(McpServerSchema),
@@ -5733,84 +5757,84 @@ import { OpenAPILink as OpenAPILink18 } from "@orpc/openapi-client/fetch";
 
 // src/orpc-client/pdf-export/contract.ts
 import { oc as oc16 } from "@orpc/contract";
-import * as z27 from "zod";
-var PdfExportScopeSchema = z27.object({
-  pageSlugs: z27.array(z27.string())
-});
-var PdfExportOptionsV1Schema = z27.object({
-  coverTitle: z27.string().nullish(),
-  coverSubtitle: z27.string().nullish(),
-  hideCoverFooter: z27.boolean().nullish(),
-  headerLeftTemplate: z27.string().nullish(),
-  headerRightTemplate: z27.string().nullish(),
-  footerLeftTemplate: z27.string().nullish(),
-  footerRightTemplate: z27.string().nullish(),
+import * as z28 from "zod";
+var PdfExportScopeSchema = z28.object({
+  pageSlugs: z28.array(z28.string())
+});
+var PdfExportOptionsV1Schema = z28.object({
+  coverTitle: z28.string().nullish(),
+  coverSubtitle: z28.string().nullish(),
+  hideCoverFooter: z28.boolean().nullish(),
+  headerLeftTemplate: z28.string().nullish(),
+  headerRightTemplate: z28.string().nullish(),
+  footerLeftTemplate: z28.string().nullish(),
+  footerRightTemplate: z28.string().nullish(),
   scope: PdfExportScopeSchema.nullish(),
-  hideCover: z27.boolean().nullish(),
-  hideToc: z27.boolean().nullish()
+  hideCover: z28.boolean().nullish(),
+  hideToc: z28.boolean().nullish()
 });
-var PdfExportOptionsSchema = z27.discriminatedUnion("version", [
-  z27.object({ version: z27.literal("v1") }).merge(PdfExportOptionsV1Schema)
+var PdfExportOptionsSchema = z28.discriminatedUnion("version", [
+  z28.object({ version: z28.literal("v1") }).merge(PdfExportOptionsV1Schema)
 ]);
-var PdfExportTaskStatusSchema = z27.enum(["PENDING", "RUNNING", "COMPLETED", "FAILED"]);
-var PdfExportTaskSchema = z27.object({
-  id: z27.string(),
-  orgId: z27.string(),
-  docsUrl: z27.string(),
-  productId: z27.string().nullish(),
-  versionId: z27.string().nullish(),
-  requesterName: z27.string().nullish(),
-  notifyEmails: z27.array(z27.string()).nullish(),
+var PdfExportTaskStatusSchema = z28.enum(["PENDING", "RUNNING", "COMPLETED", "FAILED"]);
+var PdfExportTaskSchema = z28.object({
+  id: z28.string(),
+  orgId: z28.string(),
+  docsUrl: z28.string(),
+  productId: z28.string().nullish(),
+  versionId: z28.string().nullish(),
+  requesterName: z28.string().nullish(),
+  notifyEmails: z28.array(z28.string()).nullish(),
   status: PdfExportTaskStatusSchema,
   options: PdfExportOptionsSchema.nullish(),
-  createdAt: z27.string(),
-  startedAt: z27.string().nullish(),
-  completedAt: z27.string().nullish(),
-  fileName: z27.string().nullish(),
-  sizeBytes: z27.number().nullish(),
-  errorMessage: z27.string().nullish()
-});
-var ListPdfExportTasksResponseSchema = z27.object({
-  tasks: z27.array(PdfExportTaskSchema)
-});
-var PdfExportDownloadResponseSchema = z27.object({
-  downloadUrl: z27.string(),
-  fileName: z27.string(),
-  sizeBytes: z27.number()
-});
-var CreatePdfExportTaskInputSchema = z27.object({
-  orgId: z27.string(),
-  docsUrl: z27.string(),
-  productId: z27.string().nullish(),
-  versionId: z27.string().nullish(),
-  requesterName: z27.string().nullish(),
+  createdAt: z28.string(),
+  startedAt: z28.string().nullish(),
+  completedAt: z28.string().nullish(),
+  fileName: z28.string().nullish(),
+  sizeBytes: z28.number().nullish(),
+  errorMessage: z28.string().nullish()
+});
+var ListPdfExportTasksResponseSchema = z28.object({
+  tasks: z28.array(PdfExportTaskSchema)
+});
+var PdfExportDownloadResponseSchema = z28.object({
+  downloadUrl: z28.string(),
+  fileName: z28.string(),
+  sizeBytes: z28.number()
+});
+var CreatePdfExportTaskInputSchema = z28.object({
+  orgId: z28.string(),
+  docsUrl: z28.string(),
+  productId: z28.string().nullish(),
+  versionId: z28.string().nullish(),
+  requesterName: z28.string().nullish(),
   options: PdfExportOptionsSchema.nullish()
 });
-var ListPdfExportTasksInputSchema = z27.object({
-  orgId: z27.string(),
-  docsUrl: z27.string(),
-  limit: z27.coerce.number().nullish()
+var ListPdfExportTasksInputSchema = z28.object({
+  orgId: z28.string(),
+  docsUrl: z28.string(),
+  limit: z28.coerce.number().nullish()
 });
-var GetPdfExportTaskInputSchema = z27.object({
-  taskId: z27.string()
+var GetPdfExportTaskInputSchema = z28.object({
+  taskId: z28.string()
 });
-var UpdatePdfExportTaskInputSchema = z27.object({
-  taskId: z27.string(),
+var UpdatePdfExportTaskInputSchema = z28.object({
+  taskId: z28.string(),
   status: PdfExportTaskStatusSchema,
-  startedAt: z27.string().nullish(),
-  completedAt: z27.string().nullish(),
-  s3Key: z27.string().nullish(),
-  fileName: z27.string().nullish(),
-  sizeBytes: z27.number().nullish(),
-  errorMessage: z27.string().nullish()
+  startedAt: z28.string().nullish(),
+  completedAt: z28.string().nullish(),
+  s3Key: z28.string().nullish(),
+  fileName: z28.string().nullish(),
+  sizeBytes: z28.number().nullish(),
+  errorMessage: z28.string().nullish()
 });
-var GetPdfExportDownloadUrlInputSchema = z27.object({
-  taskId: z27.string()
+var GetPdfExportDownloadUrlInputSchema = z28.object({
+  taskId: z28.string()
 });
-var CleanupPdfExportsResponseSchema = z27.object({
-  expiredTasksDeleted: z27.number(),
-  s3ObjectsDeleted: z27.number(),
-  timedOutTasksFailed: z27.number()
+var CleanupPdfExportsResponseSchema = z28.object({
+  expiredTasksDeleted: z28.number(),
+  s3ObjectsDeleted: z28.number(),
+  timedOutTasksFailed: z28.number()
 });
 var pdfExportContract = {
   createTask: oc16.route({ method: "POST", path: "/task" }).input(CreatePdfExportTaskInputSchema).output(PdfExportTaskSchema),
@@ -5840,8 +5864,8 @@ import { OpenAPILink as OpenAPILink19 } from "@orpc/openapi-client/fetch";
 
 // src/orpc-client/sdks/contract.ts
 import { oc as oc17 } from "@orpc/contract";
-import * as z28 from "zod";
-var LanguageEnumSchema = z28.enum([
+import * as z29 from "zod";
+var LanguageEnumSchema = z29.enum([
   "Go",
   "TypeScript",
   "Java",
@@ -5852,14 +5876,14 @@ var LanguageEnumSchema = z28.enum([
   "Swift",
   "Rust"
 ]);
-var VersionBumpEnumSchema = z28.enum(["MAJOR", "MINOR", "PATCH"]);
-var ComputeSemanticVersionInputSchema = z28.object({
-  package: z28.string(),
+var VersionBumpEnumSchema = z29.enum(["MAJOR", "MINOR", "PATCH"]);
+var ComputeSemanticVersionInputSchema = z29.object({
+  package: z29.string(),
   language: LanguageEnumSchema,
-  githubRepository: z28.string().nullish()
+  githubRepository: z29.string().nullish()
 });
-var ComputeSemanticVersionOutputSchema = z28.object({
-  version: z28.string(),
+var ComputeSemanticVersionOutputSchema = z29.object({
+  version: z29.string(),
   bump: VersionBumpEnumSchema
 });
 var sdksContract = {
@@ -5885,32 +5909,32 @@ import { OpenAPILink as OpenAPILink20 } from "@orpc/openapi-client/fetch";
 
 // src/orpc-client/slugs/contract.ts
 import { oc as oc18 } from "@orpc/contract";
-import * as z29 from "zod";
-var SlugsInputSchema = z29.object({
-  domain: z29.string(),
-  basepath: z29.string().optional().default("")
-});
-var SlugEntrySchema = z29.object({
-  orgId: z29.string(),
-  domain: z29.string(),
-  basepath: z29.string(),
-  slug: z29.string(),
-  lastUpdated: z29.string()
-});
-var MarkdownEntrySchema = z29.object({
-  orgId: z29.string(),
-  domain: z29.string(),
-  basepath: z29.string(),
-  pageId: z29.string(),
-  slug: z29.string(),
-  hash: z29.string(),
-  lastUpdated: z29.string()
-});
-var GetSlugEntriesResponseSchema = z29.object({
-  entries: z29.array(SlugEntrySchema)
-});
-var GetMarkdownEntriesResponseSchema = z29.object({
-  entries: z29.array(MarkdownEntrySchema)
+import * as z30 from "zod";
+var SlugsInputSchema = z30.object({
+  domain: z30.string(),
+  basepath: z30.string().optional().default("")
+});
+var SlugEntrySchema = z30.object({
+  orgId: z30.string(),
+  domain: z30.string(),
+  basepath: z30.string(),
+  slug: z30.string(),
+  lastUpdated: z30.string()
+});
+var MarkdownEntrySchema = z30.object({
+  orgId: z30.string(),
+  domain: z30.string(),
+  basepath: z30.string(),
+  pageId: z30.string(),
+  slug: z30.string(),
+  hash: z30.string(),
+  lastUpdated: z30.string()
+});
+var GetSlugEntriesResponseSchema = z30.object({
+  entries: z30.array(SlugEntrySchema)
+});
+var GetMarkdownEntriesResponseSchema = z30.object({
+  entries: z30.array(MarkdownEntrySchema)
 });
 var slugsContract = {
   getSlugEntries: oc18.route({ method: "POST", path: "/slugs" }).input(SlugsInputSchema).output(GetSlugEntriesResponseSchema),
@@ -5936,102 +5960,102 @@ import { OpenAPILink as OpenAPILink21 } from "@orpc/openapi-client/fetch";
 
 // src/orpc-client/snippets/contract.ts
 import { oc as oc19 } from "@orpc/contract";
-import * as z30 from "zod";
-var TypeScriptSdkSchema = z30.object({ package: z30.string(), version: z30.string() });
-var PythonSdkSchema = z30.object({ package: z30.string(), version: z30.string() });
-var GoSdkSchema = z30.object({ githubRepo: z30.string(), version: z30.string() });
-var RubySdkSchema = z30.object({ gem: z30.string(), version: z30.string() });
-var JavaSdkSchema = z30.object({ group: z30.string(), artifact: z30.string(), version: z30.string() });
-var CsharpSdkSchema = z30.object({ package: z30.string(), version: z30.string() });
-var BaseSnippetCreateSchema = z30.object({
+import * as z31 from "zod";
+var TypeScriptSdkSchema = z31.object({ package: z31.string(), version: z31.string() });
+var PythonSdkSchema = z31.object({ package: z31.string(), version: z31.string() });
+var GoSdkSchema = z31.object({ githubRepo: z31.string(), version: z31.string() });
+var RubySdkSchema = z31.object({ gem: z31.string(), version: z31.string() });
+var JavaSdkSchema = z31.object({ group: z31.string(), artifact: z31.string(), version: z31.string() });
+var CsharpSdkSchema = z31.object({ package: z31.string(), version: z31.string() });
+var BaseSnippetCreateSchema = z31.object({
   endpoint: EndpointIdentifierSchema,
-  exampleIdentifier: z30.string().nullish()
+  exampleIdentifier: z31.string().nullish()
 });
-var SdkSnippetsCreateSchema = z30.discriminatedUnion("type", [
-  z30.object({
-    type: z30.literal("typescript"),
+var SdkSnippetsCreateSchema = z31.discriminatedUnion("type", [
+  z31.object({
+    type: z31.literal("typescript"),
     sdk: TypeScriptSdkSchema,
-    snippets: z30.array(BaseSnippetCreateSchema.extend({ snippet: z30.object({ client: z30.string() }) }))
+    snippets: z31.array(BaseSnippetCreateSchema.extend({ snippet: z31.object({ client: z31.string() }) }))
   }),
-  z30.object({
-    type: z30.literal("python"),
+  z31.object({
+    type: z31.literal("python"),
     sdk: PythonSdkSchema,
-    snippets: z30.array(
+    snippets: z31.array(
       BaseSnippetCreateSchema.extend({
-        snippet: z30.object({ async_client: z30.string(), sync_client: z30.string() })
+        snippet: z31.object({ async_client: z31.string(), sync_client: z31.string() })
       })
     )
   }),
-  z30.object({
-    type: z30.literal("go"),
+  z31.object({
+    type: z31.literal("go"),
     sdk: GoSdkSchema,
-    snippets: z30.array(BaseSnippetCreateSchema.extend({ snippet: z30.object({ client: z30.string() }) }))
+    snippets: z31.array(BaseSnippetCreateSchema.extend({ snippet: z31.object({ client: z31.string() }) }))
   }),
-  z30.object({
-    type: z30.literal("java"),
+  z31.object({
+    type: z31.literal("java"),
     sdk: JavaSdkSchema,
-    snippets: z30.array(
+    snippets: z31.array(
       BaseSnippetCreateSchema.extend({
-        snippet: z30.object({ async_client: z30.string(), sync_client: z30.string() })
+        snippet: z31.object({ async_client: z31.string(), sync_client: z31.string() })
       })
     )
   }),
-  z30.object({
-    type: z30.literal("ruby"),
+  z31.object({
+    type: z31.literal("ruby"),
     sdk: RubySdkSchema,
-    snippets: z30.array(BaseSnippetCreateSchema.extend({ snippet: z30.object({ client: z30.string() }) }))
+    snippets: z31.array(BaseSnippetCreateSchema.extend({ snippet: z31.object({ client: z31.string() }) }))
   }),
-  z30.object({
-    type: z30.literal("csharp"),
+  z31.object({
+    type: z31.literal("csharp"),
     sdk: CsharpSdkSchema,
-    snippets: z30.array(BaseSnippetCreateSchema.extend({ snippet: z30.object({ client: z30.string() }) }))
+    snippets: z31.array(BaseSnippetCreateSchema.extend({ snippet: z31.object({ client: z31.string() }) }))
   })
 ]);
 var snippetsFactoryContract = {
   createSnippetsForSdk: oc19.route({ method: "POST", path: "/create" }).input(
-    z30.object({
-      orgId: z30.string(),
-      apiId: z30.string(),
+    z31.object({
+      orgId: z31.string(),
+      apiId: z31.string(),
       snippets: SdkSnippetsCreateSchema
     })
   )
 };
-var ParameterPayloadSchema = z30.object({
-  name: z30.string(),
-  value: z30.unknown()
+var ParameterPayloadSchema = z31.object({
+  name: z31.string(),
+  value: z31.unknown()
 });
-var AuthPayloadSchema = z30.discriminatedUnion("type", [
-  z30.object({ type: z30.literal("bearer"), token: z30.string() }),
-  z30.object({ type: z30.literal("basic"), username: z30.string(), password: z30.string() })
+var AuthPayloadSchema = z31.discriminatedUnion("type", [
+  z31.object({ type: z31.literal("bearer"), token: z31.string() }),
+  z31.object({ type: z31.literal("basic"), username: z31.string(), password: z31.string() })
 ]);
-var CustomSnippetPayloadSchema = z30.object({
-  headers: z30.array(ParameterPayloadSchema).nullish(),
-  pathParameters: z30.array(ParameterPayloadSchema).nullish(),
-  queryParameters: z30.array(ParameterPayloadSchema).nullish(),
-  requestBody: z30.unknown().nullish(),
+var CustomSnippetPayloadSchema = z31.object({
+  headers: z31.array(ParameterPayloadSchema).nullish(),
+  pathParameters: z31.array(ParameterPayloadSchema).nullish(),
+  queryParameters: z31.array(ParameterPayloadSchema).nullish(),
+  requestBody: z31.unknown().nullish(),
   auth: AuthPayloadSchema.nullish()
 });
 var snippetsContract = {
   get: oc19.route({ method: "POST", path: "/" }).input(
-    z30.object({
-      orgId: z30.string().nullish(),
-      apiId: z30.string().nullish(),
-      sdks: z30.array(SdkRequestSchema).nullish(),
+    z31.object({
+      orgId: z31.string().nullish(),
+      apiId: z31.string().nullish(),
+      sdks: z31.array(SdkRequestSchema).nullish(),
       endpoint: EndpointIdentifierSchema,
-      exampleIdentifier: z30.string().nullish(),
+      exampleIdentifier: z31.string().nullish(),
       payload: CustomSnippetPayloadSchema.nullish()
     })
-  ).output(z30.array(z30.unknown())),
+  ).output(z31.array(z31.unknown())),
   load: oc19.route({ method: "POST", path: "/load" }).input(
-    z30.object({
-      orgId: z30.string().nullish(),
-      apiId: z30.string().nullish(),
-      sdks: z30.array(SdkRequestSchema).nullish()
+    z31.object({
+      orgId: z31.string().nullish(),
+      apiId: z31.string().nullish(),
+      sdks: z31.array(SdkRequestSchema).nullish()
     })
   ).output(
-    z30.object({
-      next: z30.number().nullish(),
-      snippets: z30.record(z30.string(), z30.unknown())
+    z31.object({
+      next: z31.number().nullish(),
+      snippets: z31.record(z31.string(), z31.unknown())
     })
   )
 };
@@ -6066,44 +6090,44 @@ import { OpenAPILink as OpenAPILink22 } from "@orpc/openapi-client/fetch";
 
 // src/orpc-client/templates/contract.ts
 import { oc as oc20 } from "@orpc/contract";
-import * as z31 from "zod";
-var SnippetRegistryEntrySchema = z31.object({
+import * as z32 from "zod";
+var SnippetRegistryEntrySchema = z32.object({
   sdk: SdkSchema,
-  endpointId: z31.object({
-    path: z31.string(),
+  endpointId: z32.object({
+    path: z32.string(),
     method: HttpMethodSchema,
-    identifierOverride: z31.string().nullish()
+    identifierOverride: z32.string().nullish()
   }),
-  snippetTemplate: z31.object({
-    type: z31.literal("v1"),
-    functionInvocation: z31.unknown(),
-    clientInstantiation: z31.string()
+  snippetTemplate: z32.object({
+    type: z32.literal("v1"),
+    functionInvocation: z32.unknown(),
+    clientInstantiation: z32.string()
   }),
-  additionalTemplates: z31.record(z31.string(), z31.unknown()).nullish()
+  additionalTemplates: z32.record(z32.string(), z32.unknown()).nullish()
 });
-var RegisterInputSchema = z31.object({
-  orgId: z31.string(),
-  apiId: z31.string(),
-  apiDefinitionId: z31.string(),
+var RegisterInputSchema = z32.object({
+  orgId: z32.string(),
+  apiId: z32.string(),
+  apiDefinitionId: z32.string(),
   snippet: SnippetRegistryEntrySchema
 });
-var RegisterBatchInputSchema = z31.object({
-  orgId: z31.string(),
-  apiId: z31.string(),
-  apiDefinitionId: z31.string(),
-  snippets: z31.array(SnippetRegistryEntrySchema)
+var RegisterBatchInputSchema = z32.object({
+  orgId: z32.string(),
+  apiId: z32.string(),
+  apiDefinitionId: z32.string(),
+  snippets: z32.array(SnippetRegistryEntrySchema)
 });
-var GetInputSchema = z31.object({
-  orgId: z31.string(),
-  apiId: z31.string(),
+var GetInputSchema = z32.object({
+  orgId: z32.string(),
+  apiId: z32.string(),
   sdk: SdkSchema,
-  endpointId: z31.object({
-    path: z31.string(),
+  endpointId: z32.object({
+    path: z32.string(),
     method: HttpMethodSchema,
-    identifierOverride: z31.string().nullish()
+    identifierOverride: z32.string().nullish()
   })
 });
-var EndpointSnippetTemplateSchema = z31.record(z31.string(), z31.unknown());
+var EndpointSnippetTemplateSchema = z32.record(z32.string(), z32.unknown());
 var templatesContract = {
   register: oc20.route({ method: "POST", path: "/register" }).input(RegisterInputSchema),
   registerBatch: oc20.route({ method: "POST", path: "/register/batch" }).input(RegisterBatchInputSchema),
@@ -6130,18 +6154,18 @@ import { OpenAPILink as OpenAPILink23 } from "@orpc/openapi-client/fetch";
 
 // src/orpc-client/tokens/contract.ts
 import { oc as oc21 } from "@orpc/contract";
-import * as z32 from "zod";
-var GenerateTokenInputSchema = z32.object({
-  orgId: z32.string(),
-  scope: z32.string()
+import * as z33 from "zod";
+var GenerateTokenInputSchema = z33.object({
+  orgId: z33.string(),
+  scope: z33.string()
 });
-var RevokeTokenInputSchema = z32.object({
-  orgId: z32.string(),
-  tokenId: z32.string()
+var RevokeTokenInputSchema = z33.object({
+  orgId: z33.string(),
+  tokenId: z33.string()
 });
-var GenerateTokenOutputSchema = z32.object({
-  token: z32.string(),
-  id: z32.string()
+var GenerateTokenOutputSchema = z33.object({
+  token: z33.string(),
+  id: z33.string()
 });
 var tokensContract = {
   generate: oc21.route({ method: "POST", path: "/generate" }).input(GenerateTokenInputSchema).output(GenerateTokenOutputSchema),
@@ -6199,24 +6223,24 @@ import { OpenAPILink as OpenAPILink24 } from "@orpc/openapi-client/fetch";
 
 // src/orpc-client/docs/v1/write/contract.ts
 import { oc as oc22 } from "@orpc/contract";
-import * as z33 from "zod";
-var StartDocsRegisterV1InputSchema = z33.object({
-  orgId: z33.string(),
-  domain: z33.string(),
-  filepaths: z33.array(z33.string())
+import * as z34 from "zod";
+var StartDocsRegisterV1InputSchema = z34.object({
+  orgId: z34.string(),
+  domain: z34.string(),
+  filepaths: z34.array(z34.string())
 });
-var StartDocsRegisterV1ResponseSchema = z33.object({
-  docsRegistrationId: z33.string(),
-  uploadUrls: z33.record(z33.string(), FileS3UploadUrlSchema),
-  skippedFiles: z33.array(z33.string())
+var StartDocsRegisterV1ResponseSchema = z34.object({
+  docsRegistrationId: z34.string(),
+  uploadUrls: z34.record(z34.string(), FileS3UploadUrlSchema),
+  skippedFiles: z34.array(z34.string())
 });
-var FinishDocsRegisterV1InputSchema = z33.object({
-  docsRegistrationId: z33.string(),
-  docsDefinition: z33.unknown()
+var FinishDocsRegisterV1InputSchema = z34.object({
+  docsRegistrationId: z34.string(),
+  docsDefinition: z34.unknown()
 });
 var docsV1WriteContract = {
   startDocsRegister: oc22.route({ method: "POST", path: "/init" }).input(StartDocsRegisterV1InputSchema).output(StartDocsRegisterV1ResponseSchema),
-  finishDocsRegister: oc22.route({ method: "POST", path: "/register/{docsRegistrationId}" }).input(FinishDocsRegisterV1InputSchema).output(z33.void())
+  finishDocsRegister: oc22.route({ method: "POST", path: "/register/{docsRegistrationId}" }).input(FinishDocsRegisterV1InputSchema).output(z34.void())
 };
 
 // src/orpc-client/docs/v1/write/client.ts
@@ -6233,7 +6257,7 @@ function createDocsV1WriteClient(options) {
 }
 
 // src/orpc-client/docs-ledger/config-files.ts
-import * as z34 from "zod";
+import * as z35 from "zod";
 var PATH_OR_URL_METADATA_KEYS = [
   "og:image",
   "og:logo",
@@ -6241,57 +6265,57 @@ var PATH_OR_URL_METADATA_KEYS = [
   "og:background-image",
   "og:dynamic:background-image"
 ];
-var LogoViewSchema = z34.union([z34.string(), z34.object({ path: z34.string() }).transform((v) => v.path)]);
-var ThemeViewSchema = z34.object({
+var LogoViewSchema = z35.union([z35.string(), z35.object({ path: z35.string() }).transform((v) => v.path)]);
+var ThemeViewSchema = z35.object({
   logo: LogoViewSchema.optional().catch(void 0),
-  backgroundImage: z34.string().optional().catch(void 0)
+  backgroundImage: z35.string().optional().catch(void 0)
 });
-var ColorsViewSchema = z34.union([
-  z34.object({
-    type: z34.literal("darkAndLight"),
+var ColorsViewSchema = z35.union([
+  z35.object({
+    type: z35.literal("darkAndLight"),
     dark: ThemeViewSchema.optional().catch(void 0),
     light: ThemeViewSchema.optional().catch(void 0)
   }),
   ThemeViewSchema.transform((theme) => ({ type: "single", theme }))
 ]);
-var FontViewSchema = z34.object({
-  variants: z34.array(z34.object({ fontFile: z34.string().optional().catch(void 0) })).catch([])
+var FontViewSchema = z35.object({
+  variants: z35.array(z35.object({ fontFile: z35.string().optional().catch(void 0) })).catch([])
 });
-var TypographyViewSchema = z34.object({
+var TypographyViewSchema = z35.object({
   headingsFont: FontViewSchema.optional().catch(void 0),
   bodyFont: FontViewSchema.optional().catch(void 0),
   codeFont: FontViewSchema.optional().catch(void 0)
 });
-var JsFileViewSchema = z34.union([
-  z34.object({ path: z34.string() }).transform((v) => v.path),
-  z34.object({ fileId: z34.string() }).transform((v) => v.fileId)
+var JsFileViewSchema = z35.union([
+  z35.object({ path: z35.string() }).transform((v) => v.path),
+  z35.object({ fileId: z35.string() }).transform((v) => v.fileId)
 ]);
-var MetadataFileRefViewSchema = z34.object({
-  type: z34.enum(["path", "fileId"]),
-  value: z34.string()
+var MetadataFileRefViewSchema = z35.object({
+  type: z35.enum(["path", "fileId"]),
+  value: z35.string()
 });
-var ConfigViewSchema = z34.object({
-  favicon: z34.string().optional().catch(void 0),
+var ConfigViewSchema = z35.object({
+  favicon: z35.string().optional().catch(void 0),
   colorsV3: ColorsViewSchema.optional().catch(void 0),
   typographyV2: TypographyViewSchema.optional().catch(void 0),
-  js: z34.object({ files: z34.array(JsFileViewSchema.optional().catch(void 0)).catch([]) }).optional().catch(void 0),
-  metadata: z34.record(z34.string(), z34.unknown()).optional().catch(void 0)
+  js: z35.object({ files: z35.array(JsFileViewSchema.optional().catch(void 0)).catch([]) }).optional().catch(void 0),
+  metadata: z35.record(z35.string(), z35.unknown()).optional().catch(void 0)
 });
 function isDarkAndLight(colors) {
   return colors.type === "darkAndLight";
 }
 var NAV_ICON_FILE_PREFIX = "file:";
-var FileTokenTreeSchema = z34.lazy(
-  () => z34.union([
-    z34.string(),
-    z34.number(),
-    z34.boolean(),
-    z34.null(),
-    z34.array(FileTokenTreeSchema),
-    z34.record(z34.string(), FileTokenTreeSchema)
+var FileTokenTreeSchema = z35.lazy(
+  () => z35.union([
+    z35.string(),
+    z35.number(),
+    z35.boolean(),
+    z35.null(),
+    z35.array(FileTokenTreeSchema),
+    z35.record(z35.string(), FileTokenTreeSchema)
   ])
 );
-var ConfigFileTokenViewSchema = z34.object({
+var ConfigFileTokenViewSchema = z35.object({
   landingPage: FileTokenTreeSchema.optional().catch(void 0)
 });
 function addFileTokenPath(paths, value) {
@@ -6313,17 +6337,17 @@ function addFileTokenPath(paths, value) {
     }
   }
 }
-var SegmentDetailIconViewSchema = z34.object({
-  icon: z34.string().nullish().catch(void 0),
-  metadata: z34.object({
-    icon: z34.string().nullish().catch(void 0),
-    image: z34.string().nullish().catch(void 0)
+var SegmentDetailIconViewSchema = z35.object({
+  icon: z35.string().nullish().catch(void 0),
+  metadata: z35.object({
+    icon: z35.string().nullish().catch(void 0),
+    image: z35.string().nullish().catch(void 0)
   }).nullish().catch(void 0)
 });
-var SegmentIconViewSchema = z34.object({
-  metadata: z34.object({
-    icon: z34.string().nullish().catch(void 0),
-    image: z34.string().nullish().catch(void 0)
+var SegmentIconViewSchema = z35.object({
+  metadata: z35.object({
+    icon: z35.string().nullish().catch(void 0),
+    image: z35.string().nullish().catch(void 0)
   }).nullish().catch(void 0),
   product: SegmentDetailIconViewSchema.nullish().catch(void 0),
   version: SegmentDetailIconViewSchema.nullish().catch(void 0),
@@ -6407,22 +6431,22 @@ function collectConfigFilePaths(config) {
 }
 
 // src/orpc-client/docs-ledger/ledger-manifest.ts
-import * as z35 from "zod";
+import * as z36 from "zod";
 var LEDGER_MANIFEST_SCHEMA_VERSION = "docsledger/20260601";
 var LEDGER_SHARD_SCHEMA_VERSION = "docsledger/shard/20260601";
-var ManifestBlobRefSchema = z35.object({
-  hash: z35.string(),
-  contentType: z35.string()
+var ManifestBlobRefSchema = z36.object({
+  hash: z36.string(),
+  contentType: z36.string()
 });
-var ManifestSegmentSchema = z35.object({
+var ManifestSegmentSchema = z36.object({
   /** Synthetic stable id (= segmentHash). */
-  segmentId: z35.string(),
-  segmentHash: z35.string(),
-  section: z35.string(),
-  locale: z35.string(),
+  segmentId: z36.string(),
+  segmentHash: z36.string(),
+  section: z36.string(),
+  locale: z36.string(),
   /** Sidebar order across segments (docs_ledger_deployment_segments.sort_order). */
-  sortOrder: z35.number(),
-  hidden: z35.boolean(),
+  sortOrder: z36.number(),
+  hidden: z36.boolean(),
   /** Segment type descriptor: { type, title, icon, apiDefinitionId, overviewPageId, pointsTo, ... }. */
   metadata: LedgerSegmentMetadataSchema,
   product: SegmentDetailSchema.nullable(),
@@ -6471,23 +6495,23 @@ function selectLedgerSegmentsForLocale(segments, locale, defaultLocale) {
   return [...byIdentity.values()];
 }
 var ManifestNavRouteSchema = LedgerNavRouteSchema;
-var ManifestRouteBaseSchema = z35.object({
-  segmentHash: z35.string(),
+var ManifestRouteBaseSchema = z36.object({
+  segmentHash: z36.string(),
   /** Key into the containing route index's sidebars map. */
-  sidebarKey: z35.string().nullable(),
-  section: z35.string(),
-  locale: z35.string(),
-  artifactId: z35.string(),
-  pageId: z35.string().optional(),
+  sidebarKey: z36.string().nullable(),
+  section: z36.string(),
+  locale: z36.string(),
+  artifactId: z36.string(),
+  pageId: z36.string().optional(),
   /** CAS hash of the page content blob, or null for link/redirect artifacts. */
-  contentHash: z35.string().nullable(),
-  contentType: z35.string().nullable(),
+  contentHash: z36.string().nullable(),
+  contentType: z36.string().nullable(),
   /** ISO-8601 timestamp of when this artifact's content version was first created.
    *  Populated at publish time from `docs_ledger_artifacts.created_at`. Optional
    *  for backward compatibility with manifests built before this field existed. */
-  createdAt: z35.string().optional()
+  createdAt: z36.string().optional()
 });
-var ManifestRouteSchema = z35.discriminatedUnion("artifactType", [
+var ManifestRouteSchema = z36.discriminatedUnion("artifactType", [
   artifactTypeVariant(ManifestRouteBaseSchema, "markdown"),
   artifactTypeVariant(ManifestRouteBaseSchema, "page"),
   artifactTypeVariant(ManifestRouteBaseSchema, "rest"),
@@ -6502,60 +6526,60 @@ var ManifestRouteSchema = z35.discriminatedUnion("artifactType", [
   artifactTypeVariant(ManifestRouteBaseSchema, "image"),
   artifactTypeVariant(ManifestRouteBaseSchema, "redirect")
 ]);
-var ManifestPageSchema = z35.object({
-  fullPath: z35.string().nullable(),
-  segmentHash: z35.string(),
-  contentHash: z35.string(),
-  contentType: z35.string()
+var ManifestPageSchema = z36.object({
+  fullPath: z36.string().nullable(),
+  segmentHash: z36.string(),
+  contentHash: z36.string(),
+  contentType: z36.string()
 });
-var ManifestApiDefSchema = z35.object({
+var ManifestApiDefSchema = z36.object({
   /** CAS hash of the full API definition blob. */
-  hash: z35.string(),
-  contentType: z35.string(),
+  hash: z36.string(),
+  contentType: z36.string(),
   /** key = `${nodeType}:${nodeId}` (e.g. `endpoint:abc`) → pruned CAS blob. */
-  prunedHashes: z35.record(z35.string(), ManifestBlobRefSchema)
-});
-var ManifestFileSchema = z35.object({
-  type: z35.enum(["file", "image"]),
-  contentType: z35.string(),
-  contentLength: z35.number().optional(),
-  filename: z35.string(),
-  hash: z35.string(),
+  prunedHashes: z36.record(z36.string(), ManifestBlobRefSchema)
+});
+var ManifestFileSchema = z36.object({
+  type: z36.enum(["file", "image"]),
+  contentType: z36.string(),
+  contentLength: z36.number().optional(),
+  filename: z36.string(),
+  hash: z36.string(),
   /** Canonical fern domain the bytes were uploaded under (ADR 0010 file anchor). */
-  domain: z35.string(),
-  bucket: z35.enum(["public_docs", "private_docs"]),
-  width: z35.number().optional(),
-  height: z35.number().optional(),
-  blurDataURL: z35.string().optional()
+  domain: z36.string(),
+  bucket: z36.enum(["public_docs", "private_docs"]),
+  width: z36.number().optional(),
+  height: z36.number().optional(),
+  blurDataURL: z36.string().optional()
 });
-var LedgerShardFileSchema = z35.object({
+var LedgerShardFileSchema = z36.object({
   /** SHA-256 hex of the file bytes (docs-bucket key component). */
-  hash: z35.string(),
+  hash: z36.string(),
   /** Fern-host-relative path; equals the `file:<fullPath>` token's suffix. */
-  fullPath: z35.string(),
-  contentType: z35.string(),
-  contentLength: z35.number().optional(),
-  width: z35.number().optional(),
-  height: z35.number().optional(),
-  blurDataURL: z35.string().optional(),
+  fullPath: z36.string(),
+  contentType: z36.string(),
+  contentLength: z36.number().optional(),
+  width: z36.number().optional(),
+  height: z36.number().optional(),
+  blurDataURL: z36.string().optional(),
   /**
    * Per-file bucket override. Absent ⇒ derive from the pointer's `isPrivate`
    * (`private_docs` when private, else `public_docs`). Present only for the
    * rare file whose bucket diverges from the deployment default.
    */
-  bucket: z35.enum(["public_docs", "private_docs"]).optional()
-});
-var LedgerConfigBlobSchema = z35.object({
-  version: z35.string().nullable(),
-  git: z35.object({
-    repoUrl: z35.string(),
-    branch: z35.string(),
-    commitSha: z35.string().nullable().optional()
+  bucket: z36.enum(["public_docs", "private_docs"]).optional()
+});
+var LedgerConfigBlobSchema = z36.object({
+  version: z36.string().nullable(),
+  git: z36.object({
+    repoUrl: z36.string(),
+    branch: z36.string(),
+    commitSha: z36.string().nullable().optional()
   }).optional(),
   /** Structural config with hot-path chrome text inlined for ADR 0016 page reads. */
   config: LedgerConfigSchema.nullable(),
   /** Large or legacy extracted config blobs. New manifests inline header/footer/css.inline/js.inline. */
-  configRefs: z35.object({
+  configRefs: z36.object({
     header: ManifestBlobRefSchema.optional(),
     footer: ManifestBlobRefSchema.optional(),
     cssInline: ManifestBlobRefSchema.optional(),
@@ -6563,43 +6587,43 @@ var LedgerConfigBlobSchema = z35.object({
     jsFiles: ManifestBlobRefSchema.optional()
   })
 });
-var LedgerChromeBlobSchema = z35.object({
-  apiNameToId: z35.record(z35.string(), z35.string())
+var LedgerChromeBlobSchema = z36.object({
+  apiNameToId: z36.record(z36.string(), z36.string())
 });
-var LedgerSidebarBundleSchema = z35.object({
-  locale: z35.string(),
-  segmentHash: z35.string(),
-  routes: z35.array(ManifestNavRouteSchema)
+var LedgerSidebarBundleSchema = z36.object({
+  locale: z36.string(),
+  segmentHash: z36.string(),
+  routes: z36.array(ManifestNavRouteSchema)
 });
-var LedgerSidebarMapEntrySchema = z35.discriminatedUnion("strategy", [
+var LedgerSidebarMapEntrySchema = z36.discriminatedUnion("strategy", [
   LedgerSidebarBundleSchema.extend({
-    strategy: z35.literal("inline")
+    strategy: z36.literal("inline")
   }),
   ManifestBlobRefSchema.extend({
-    strategy: z35.literal("ref")
+    strategy: z36.literal("ref")
   })
 ]);
-var LedgerLocaleIndexSchema = z35.object({
-  locale: z35.string(),
-  segments: z35.array(ManifestSegmentSchema),
+var LedgerLocaleIndexSchema = z36.object({
+  locale: z36.string(),
+  segments: z36.array(ManifestSegmentSchema),
   /** sidebarKey → inline sidebar routes, or a CAS ref when over budget. */
-  sidebars: z35.record(z35.string(), LedgerSidebarMapEntrySchema),
+  sidebars: z36.record(z36.string(), LedgerSidebarMapEntrySchema),
   /** fullPath → route for this effective locale. */
-  routes: z35.record(z35.string(), ManifestRouteSchema),
+  routes: z36.record(z36.string(), ManifestRouteSchema),
   /** pageId → page content reference for this effective locale. */
-  pages: z35.record(z35.string(), ManifestPageSchema),
+  pages: z36.record(z36.string(), ManifestPageSchema),
   /** apiDefinitionId → full + pruned API definition blobs. */
-  apiDefs: z35.record(z35.string(), ManifestApiDefSchema),
+  apiDefs: z36.record(z36.string(), ManifestApiDefSchema),
   /** fullPath → file/image artifact metadata. */
-  files: z35.record(z35.string(), ManifestFileSchema)
+  files: z36.record(z36.string(), ManifestFileSchema)
 });
-var LedgerRouteShardSchema = z35.object({
-  schema: z35.literal(LEDGER_SHARD_SCHEMA_VERSION),
-  locale: z35.string(),
+var LedgerRouteShardSchema = z36.object({
+  schema: z36.literal(LEDGER_SHARD_SCHEMA_VERSION),
+  locale: z36.string(),
   /** fullPath → route for the scopes packed into this shard. */
-  routes: z35.record(z35.string(), ManifestRouteSchema),
+  routes: z36.record(z36.string(), ManifestRouteSchema),
   /** segmentHash → inline sidebar (or CAS ref) for every segment in this shard's scopes. */
-  sidebars: z35.record(z35.string(), LedgerSidebarMapEntrySchema),
+  sidebars: z36.record(z36.string(), LedgerSidebarMapEntrySchema),
   /**
    * fileFullPath → lean file identity for every file/image referenced by a
    * page routed into this shard (ADR 0016, "File metadata on the render
@@ -6608,32 +6632,32 @@ var LedgerRouteShardSchema = z35.object({
    * existed or with no embedded files; the bundle then falls back to the
    * pointer's `files` map (`fileMetadata`/`fileArtifact`).
    */
-  files: z35.record(z35.string(), LedgerShardFileSchema).optional()
+  files: z36.record(z36.string(), LedgerShardFileSchema).optional()
 });
-var LedgerPagesBlobSchema = z35.record(z35.string(), ManifestPageSchema);
+var LedgerPagesBlobSchema = z36.record(z36.string(), ManifestPageSchema);
 var LedgerPointerSegmentSchema = ManifestSegmentSchema.omit({ product: true, version: true }).extend({
   /** Index into the locale's `productCatalog`, or null when the segment has no product. */
-  productIdx: z35.number().nullable(),
+  productIdx: z36.number().nullable(),
   /** Index into the locale's `versionCatalog`, or null when the segment has no version. */
-  versionIdx: z35.number().nullable()
+  versionIdx: z36.number().nullable()
 });
-var LedgerLocaleRoutingSchema = z35.object({
+var LedgerLocaleRoutingSchema = z36.object({
   /** Compact segments catalog for the switcher chrome (product/version by index). */
-  segments: z35.array(LedgerPointerSegmentSchema),
+  segments: z36.array(LedgerPointerSegmentSchema),
   /** Deduplicated product details; `LedgerPointerSegment.productIdx` indexes into this. */
-  productCatalog: z35.array(SegmentDetailSchema),
+  productCatalog: z36.array(SegmentDetailSchema),
   /** Deduplicated version details; `LedgerPointerSegment.versionIdx` indexes into this. */
-  versionCatalog: z35.array(SegmentDetailSchema),
+  versionCatalog: z36.array(SegmentDetailSchema),
   /** fullPath → index into `shards`. */
-  routing: z35.record(z35.string(), z35.number()),
+  routing: z36.record(z36.string(), z36.number()),
   /** segmentHash → index into `shards`. */
-  segmentShard: z35.record(z35.string(), z35.number()),
+  segmentShard: z36.record(z36.string(), z36.number()),
   /** Ordered list of route shards; index matches `routing`/`segmentShard`. */
-  shards: z35.array(z35.object({ hash: z35.string() })),
+  shards: z36.array(z36.object({ hash: z36.string() })),
   /** versionId → first routable fullPath (version switcher). */
-  versionFirstRoute: z35.record(z35.string(), z35.string()),
+  versionFirstRoute: z36.record(z36.string(), z36.string()),
   /** CAS hash of the per-locale pages blob. */
-  pagesHash: z35.string(),
+  pagesHash: z36.string(),
   /**
    * fullPath → file/image artifact metadata for files NOT materialised into
    * a route shard (ADR 0016, "File metadata on the render path"): config
@@ -6642,26 +6666,26 @@ var LedgerLocaleRoutingSchema = z35.object({
    * Page-body images are pruned from here and live in their route shard's
    * `files` map instead. Read via `fileMetadata` / `fileArtifact`.
    */
-  files: z35.record(z35.string(), ManifestFileSchema),
+  files: z36.record(z36.string(), ManifestFileSchema),
   /** apiDefinitionId → full + pruned API definition blobs. */
-  apiDefs: z35.record(z35.string(), ManifestApiDefSchema)
+  apiDefs: z36.record(z36.string(), ManifestApiDefSchema)
 });
-var LedgerManifestSchema = z35.object({
-  schema: z35.literal(LEDGER_MANIFEST_SCHEMA_VERSION),
+var LedgerManifestSchema = z36.object({
+  schema: z36.literal(LEDGER_MANIFEST_SCHEMA_VERSION),
   // ── Pointer / current-version fields ──────────────────────────────
-  orgId: z35.string(),
-  domain: z35.string(),
-  basepath: z35.string(),
-  deploymentId: z35.string(),
-  deploymentHash: z35.string(),
-  siteId: z35.string(),
+  orgId: z36.string(),
+  domain: z36.string(),
+  basepath: z36.string(),
+  deploymentId: z36.string(),
+  deploymentHash: z36.string(),
+  siteId: z36.string(),
   /** ISO-8601 timestamp the publish became live (request time). */
-  assignedAt: z35.string(),
-  assignedBy: z35.string().nullable(),
-  isPreview: z35.boolean(),
-  isPrivate: z35.boolean(),
+  assignedAt: z36.string(),
+  assignedBy: z36.string().nullable(),
+  isPreview: z36.boolean(),
+  isPrivate: z36.boolean(),
   /** Default locale for the deployment — read-path fallback when a translation is absent. */
-  defaultLocale: z35.string(),
+  defaultLocale: z36.string(),
   /**
    * Canonical fern domain all file bytes are anchored under (ADR 0010). The
    * read client builds the public `/_files/{fileAnchorDomain}/{hash}/{fullPath}`
@@ -6670,19 +6694,19 @@ var LedgerManifestSchema = z35.object({
    * written before shard-side files; absent ⇒ the client falls back to the
    * pointer `files` map (which still carries per-file `domain`).
    */
-  fileAnchorDomain: z35.string().optional(),
+  fileAnchorDomain: z36.string().optional(),
   config: LedgerConfigBlobSchema,
   chrome: LedgerChromeBlobSchema,
-  locales: z35.record(z35.string(), LedgerLocaleRoutingSchema)
-});
-var LedgerSiteArtifactSchema = z35.union([
-  z35.object({
-    schema: z35.literal(LEDGER_MANIFEST_SCHEMA_VERSION),
-    unpublished: z35.literal(true),
-    orgId: z35.string(),
-    domain: z35.string(),
-    basepath: z35.string(),
-    isPreview: z35.boolean()
+  locales: z36.record(z36.string(), LedgerLocaleRoutingSchema)
+});
+var LedgerSiteArtifactSchema = z36.union([
+  z36.object({
+    schema: z36.literal(LEDGER_MANIFEST_SCHEMA_VERSION),
+    unpublished: z36.literal(true),
+    orgId: z36.string(),
+    domain: z36.string(),
+    basepath: z36.string(),
+    isPreview: z36.boolean()
   }),
   LedgerManifestSchema
 ]);
@@ -6699,26 +6723,26 @@ function stableStringify(value) {
 
 // src/orpc-client/files/contract.ts
 import { oc as oc23 } from "@orpc/contract";
-import * as z36 from "zod";
-var PutContentInputSchema = z36.object({
-  contentType: z36.string(),
-  contentLength: z36.number().int().positive()
+import * as z37 from "zod";
+var PutContentInputSchema = z37.object({
+  contentType: z37.string(),
+  contentLength: z37.number().int().positive()
 });
-var PutContentResponseSchema = z36.discriminatedUnion("status", [
+var PutContentResponseSchema = z37.discriminatedUnion("status", [
   /** Content already exists in storage — client can skip the S3 upload. */
-  z36.object({ status: z36.literal("exists") }),
+  z37.object({ status: z37.literal("exists") }),
   /** Content is new — client should PUT the file bytes to uploadUrl, then call PUT /files. */
-  z36.object({ status: z36.literal("upload_required"), uploadUrl: z36.string() })
+  z37.object({ status: z37.literal("upload_required"), uploadUrl: z37.string() })
 ]);
-var PutFileInputSchema = z36.object({
-  hash: z36.string(),
-  contentType: z36.string()
+var PutFileInputSchema = z37.object({
+  hash: z37.string(),
+  contentType: z37.string()
 });
-var FileResponseSchema = z36.object({
+var FileResponseSchema = z37.object({
   /** SHA-256 hex digest of the file content (64 characters). */
-  hash: z36.string(),
+  hash: z37.string(),
   /** Presigned S3 GET URL. TTL is configurable (default 3600 seconds). */
-  downloadUrl: z36.string()
+  downloadUrl: z37.string()
 });
 var contentContract = {
   /**
@@ -6740,24 +6764,58 @@ var filesContract = {
   getFile: oc23.route({ method: "GET", path: "/" }).output(FileResponseSchema)
 };
 
+// src/orpc-client/mcp-hosting/kv.ts
+function deploymentMetaFromParsed(parsed, deployedAt = /* @__PURE__ */ new Date()) {
+  return {
+    authSchemes: parsed.auth.schemes,
+    toolCount: new Set(Object.values(parsed.toolsets).flat()).size,
+    deployedAt: deployedAt.toISOString(),
+    requirements: parsed.environmentVariables.map((v) => ({
+      label: v.description,
+      envVar: v.name,
+      type: v.required ? "required" : "optional"
+    }))
+  };
+}
+function deploymentConfigFromParsed(parsed) {
+  return {
+    serverName: parsed.name,
+    baseUrl: parsed.baseUrl,
+    followRedirects: parsed.followRedirects,
+    maxRedirects: parsed.maxRedirects,
+    allowedRedirectHosts: parsed.allowedRedirectHosts,
+    authSchemes: parsed.auth.schemes,
+    authRequired: parsed.auth.required,
+    toolsets: parsed.toolsets,
+    toolsetMetadata: parsed.toolsetMetadata
+  };
+}
+function scriptNameFor(input) {
+  return `${input.orgId}--${input.slug}`;
+}
+var KV_KEY_PREFIX_ORG = "org:";
+var KV_KEY_PREFIX_CONFIG = "config:";
+var KV_KEY_PREFIX_META = "meta:";
+var KV_KEY_PREFIXES = [KV_KEY_PREFIX_ORG, KV_KEY_PREFIX_CONFIG, KV_KEY_PREFIX_META];
+
 // src/orpc-client/org-config/contract.ts
-import * as z37 from "zod";
+import * as z38 from "zod";
 var SEMVER_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-.]+)?(?:\+[0-9A-Za-z-.]+)?$/;
-var UpsertOrgConfigBodySchema = z37.object({
+var UpsertOrgConfigBodySchema = z38.object({
   // A semver string sets the bound; `null` clears it; omitting leaves it unchanged.
-  cliVersionMin: z37.union([z37.string().regex(SEMVER_RE, "cliVersionMin must be a valid semver (e.g. 5.45.0)"), z37.null()]).optional(),
-  cliVersionMax: z37.union([z37.string().regex(SEMVER_RE, "cliVersionMax must be a valid semver (e.g. 5.45.0)"), z37.null()]).optional()
+  cliVersionMin: z38.union([z38.string().regex(SEMVER_RE, "cliVersionMin must be a valid semver (e.g. 5.45.0)"), z38.null()]).optional(),
+  cliVersionMax: z38.union([z38.string().regex(SEMVER_RE, "cliVersionMax must be a valid semver (e.g. 5.45.0)"), z38.null()]).optional()
 });
-var OrgConfigResponseSchema = z37.object({
-  orgId: z37.string(),
-  cliVersionMin: z37.string().optional(),
-  cliVersionMax: z37.string().optional(),
+var OrgConfigResponseSchema = z38.object({
+  orgId: z38.string(),
+  cliVersionMin: z38.string().optional(),
+  cliVersionMax: z38.string().optional(),
   // Absent when no config has been stored for the org yet.
-  updatedAt: z37.string().optional()
+  updatedAt: z38.string().optional()
 });
 
 // src/orpc-client/themes/contract.ts
-import * as z38 from "zod";
+import * as z39 from "zod";
 var FERN_FILE_REF_KEY = "hash";
 var SHA256_RE = /^[0-9a-f]{64}$/;
 function isFernFileRef(value) {
@@ -6772,26 +6830,26 @@ function isFernFileRef(value) {
   return typeof hash === "string" && SHA256_RE.test(hash);
 }
 var THEME_NAME_RE = /^[a-zA-Z0-9_-]{1,64}$/;
-var ThemeResponseSchema = z38.object({
-  id: z38.string(),
-  orgId: z38.string(),
-  name: z38.string(),
-  config: z38.unknown(),
-  updatedAt: z38.string()
+var ThemeResponseSchema = z39.object({
+  id: z39.string(),
+  orgId: z39.string(),
+  name: z39.string(),
+  config: z39.unknown(),
+  updatedAt: z39.string()
   // ISO 8601 timestamp
 });
-var ThemeListItemSchema = z38.object({
-  id: z38.string(),
-  orgId: z38.string(),
-  name: z38.string(),
-  updatedAt: z38.string()
+var ThemeListItemSchema = z39.object({
+  id: z39.string(),
+  orgId: z39.string(),
+  name: z39.string(),
+  updatedAt: z39.string()
 });
-var ThemeListResponseSchema = z38.object({
-  themes: z38.array(ThemeListItemSchema)
+var ThemeListResponseSchema = z39.object({
+  themes: z39.array(ThemeListItemSchema)
 });
-var UpsertThemeBodySchema = z38.object({
-  name: z38.string().min(1).max(64).regex(THEME_NAME_RE, "Theme name may only contain letters, digits, hyphens, and underscores"),
-  config: z38.unknown()
+var UpsertThemeBodySchema = z39.object({
+  name: z39.string().min(1).max(64).regex(THEME_NAME_RE, "Theme name may only contain letters, digits, hyphens, and underscores"),
+  config: z39.unknown()
 });
 export {
   AlgoliaDomainInputSchema,
@@ -7044,6 +7102,10 @@ export {
   JavaCoordinateSchema,
   JqStringSchema,
   JsonBodyShapeSchema,
+  KV_KEY_PREFIXES,
+  KV_KEY_PREFIX_CONFIG,
+  KV_KEY_PREFIX_META,
+  KV_KEY_PREFIX_ORG,
   LEDGER_ARTIFACT_METADATA_SCHEMAS,
   LEDGER_MANIFEST_SCHEMA_VERSION,
   LEDGER_SHARD_SCHEMA_VERSION,
@@ -7445,6 +7507,8 @@ export {
   createTokensClient,
   dashboardAgentContract,
   dashboardContract,
+  deploymentConfigFromParsed,
+  deploymentMetaFromParsed,
   docsCacheContract,
   docsDeploymentContract,
   docsLedgerContract,
@@ -7467,6 +7531,7 @@ export {
   mcpHostingContract,
   organizationContract,
   pdfExportContract,
+  scriptNameFor,
   sdksContract,
   selectLedgerSegmentsForLocale,
   slugsContract,