@fern-api/fdr-sdk 1.2.36-eaea1f74f7 → 1.2.37-94cc3f83f5

package/dist/js/orpc-client.mjs

@@ -3763,7 +3763,17 @@ var PageBlobRefSchema = z22.object({
   /** SHA-256 hex of the page content bytes. */
   hash: z22.string(),
   contentType: z22.string().default("text/markdown"),
-  contentLength: z22.number()
+  contentLength: z22.number(),
+  /**
+   * Bare `fullPath`s of the file/image artifacts this page's rendered
+   * markdown references (the `<fullPath>` of each `file:<fullPath>` token).
+   * Captured CLI-side from the already-rewritten page markdown (same `file:`
+   * regex the bundle serializer uses) so FDR can materialise the page→file
+   * join into the route shards without re-fetching or re-parsing content
+   * (ADR 0016, "File metadata on the render path"). Optional — older CLIs
+   * omit it and the page simply contributes no shard-side file identities.
+   */
+  referencedFiles: z22.array(z22.string()).optional()
 });
 var FileManifestEntrySchema = z22.object({
   /** SHA-256 hex of the file bytes (= CAS content hash). */
@@ -3793,6 +3803,21 @@ var BackgroundColorSchema = z22.discriminatedUnion("type", [
   z22.object({ type: z22.literal("solid"), ...RgbaSchema.shape }),
   z22.object({ type: z22.literal("gradient") })
 ]);
+var ACCENT_SCALE_KEYS = [
+  "accent1",
+  "accent2",
+  "accent3",
+  "accent4",
+  "accent5",
+  "accent6",
+  "accent7",
+  "accent8",
+  "accent9",
+  "accent10",
+  "accent11",
+  "accent12"
+];
+var accentScaleShape = Object.fromEntries(ACCENT_SCALE_KEYS.map((key) => [key, RgbaSchema.optional()]));
 var LedgerThemeConfigSchema = z22.object({
   logo: ImageRefSchema.optional(),
   backgroundImage: z22.string().optional(),
@@ -3802,18 +3827,7 @@ var LedgerThemeConfigSchema = z22.object({
   sidebarBackground: RgbaSchema.optional(),
   headerBackground: RgbaSchema.optional(),
   cardBackground: RgbaSchema.optional(),
-  accent1: RgbaSchema.optional(),
-  accent2: RgbaSchema.optional(),
-  accent3: RgbaSchema.optional(),
-  accent4: RgbaSchema.optional(),
-  accent5: RgbaSchema.optional(),
-  accent6: RgbaSchema.optional(),
-  accent7: RgbaSchema.optional(),
-  accent8: RgbaSchema.optional(),
-  accent9: RgbaSchema.optional(),
-  accent10: RgbaSchema.optional(),
-  accent11: RgbaSchema.optional(),
-  accent12: RgbaSchema.optional()
+  ...accentScaleShape
 });
 var LedgerColorsConfigSchema = z22.discriminatedUnion("type", [
   z22.object({ type: z22.literal("dark"), ...LedgerThemeConfigSchema.shape }),
@@ -3867,6 +3881,14 @@ var LedgerMetadataConfigSchema = z22.record(z22.string(), z22.unknown()).and(
     "og:dynamic:background-image": PathOrUrlSchema.optional()
   })
 );
+var NavbarLinksFieldSchema = z22.array(NavbarLinkSchema);
+var FooterLinksFieldSchema = z22.array(FooterLinkSchema);
+var LayoutFieldSchema = DocsLayoutConfigSchema;
+var ThemeFieldSchema = DocsThemeConfigSchema;
+var SettingsFieldSchema = DocsSettingsConfigSchema;
+var AnalyticsFieldSchema = AnalyticsConfigSchema;
+var AIChatFieldSchema = AIChatConfigSchema;
+var PageActionsFieldSchema = PageActionsConfigSchema;
 var LedgerAgentsConfigSchema = z22.object({
   pageDirective: z22.string().optional(),
   pageDescriptionSource: z22.enum(["description", "subtitle"]).optional(),
@@ -3880,31 +3902,272 @@ var LedgerConfigSchema = z22.object({
     translations: z22.array(z22.string()).optional()
   }).optional(),
   announcement: z22.object({ text: z22.string() }).optional(),
-  navbarLinks: z22.array(z22.unknown()).optional(),
-  footerLinks: z22.array(z22.unknown()).optional(),
+  navbarLinks: NavbarLinksFieldSchema.optional(),
+  footerLinks: FooterLinksFieldSchema.optional(),
   logoHeight: z22.number().optional(),
   logoHref: z22.string().optional(),
   logoRightText: z22.string().optional(),
+  /** fullPath of the favicon file artifact (any extension: .svg/.png/.ico). */
+  favicon: z22.string().nullish(),
   agents: LedgerAgentsConfigSchema.optional(),
   metadata: LedgerMetadataConfigSchema.optional(),
   redirects: z22.array(z22.object({ source: z22.string(), destination: z22.string(), permanent: z22.boolean().optional() })).optional(),
   colorsV3: LedgerColorsConfigSchema.optional(),
-  layout: z22.record(z22.string(), z22.unknown()).optional(),
-  theme: z22.record(z22.string(), z22.unknown()).optional(),
-  settings: z22.record(z22.string(), z22.unknown()).optional(),
+  layout: LayoutFieldSchema.optional(),
+  theme: ThemeFieldSchema.optional(),
+  settings: SettingsFieldSchema.optional(),
   typographyV2: LedgerTypographySchema.optional(),
-  analyticsConfig: z22.record(z22.string(), z22.unknown()).optional(),
+  analyticsConfig: AnalyticsFieldSchema.optional(),
   integrations: z22.object({
     intercom: z22.string().optional()
   }).optional(),
   css: z22.object({ inline: z22.array(z22.string()).optional() }).optional(),
   js: LedgerJsConfigSchema.optional(),
-  aiChatConfig: z22.record(z22.string(), z22.unknown()).optional(),
-  pageActions: z22.record(z22.string(), z22.unknown()).optional(),
+  aiChatConfig: AIChatFieldSchema.optional(),
+  pageActions: PageActionsFieldSchema.optional(),
   editThisPageLaunch: z22.enum(["github", "dashboard"]).optional(),
   header: z22.string().optional(),
   footer: z22.string().optional()
 });
+var MetadataStringArraySchema = z22.array(z22.string());
+var FeatureFlagMetadataSchema = z22.array(
+  z22.union([
+    z22.string(),
+    z22.object({
+      flag: z22.string(),
+      fallbackValue: z22.unknown().optional(),
+      match: z22.unknown().optional()
+    })
+  ])
+);
+var LinkTargetSchema2 = z22.enum(["_blank", "_self", "_parent", "_top"]);
+var CollapsedSchema = z22.union([z22.boolean(), z22.literal("open-by-default")]);
+var LedgerAvailabilitySchema = z22.union([
+  AvailabilitySchema,
+  z22.enum([
+    "alpha",
+    "stable",
+    "generally-available",
+    "in-development",
+    "pre-release",
+    "beta",
+    "preview",
+    "deprecated",
+    "legacy"
+  ])
+]);
+var LedgerArtifactTypeSchema = z22.enum([
+  "markdown",
+  "page",
+  "rest",
+  "asyncapi",
+  "webhook",
+  "grpc",
+  "graphql",
+  "changelog",
+  "link",
+  "file",
+  "image",
+  "redirect"
+]);
+var LedgerMetadataBaseSchema = z22.object({}).passthrough();
+var NodeMetadataFields = {
+  title: z22.string().optional(),
+  slug: z22.string().optional(),
+  icon: z22.string().optional(),
+  viewers: MetadataStringArraySchema.optional(),
+  orphaned: z22.boolean().optional(),
+  featureFlags: FeatureFlagMetadataSchema.optional()
+};
+var ApiNodeMetadataFields = {
+  ...NodeMetadataFields,
+  apiDefinitionId: z22.string(),
+  availability: LedgerAvailabilitySchema.optional()
+};
+var LedgerSegmentDetailMetadataObjectSchema = LedgerMetadataBaseSchema.extend({
+  slug: z22.string().optional(),
+  default: z22.boolean().optional(),
+  subtitle: z22.string().optional(),
+  href: z22.string().optional(),
+  url: z22.string().optional(),
+  target: LinkTargetSchema2.optional(),
+  image: z22.string().optional(),
+  pointsTo: z22.string().optional(),
+  availability: LedgerAvailabilitySchema.optional(),
+  tab_type: z22.enum(["tab", "link", "changelog"]).optional()
+});
+var LedgerSegmentDetailMetadataSchema = LedgerSegmentDetailMetadataObjectSchema.nullable();
+var LedgerSegmentMetadataObjectSchema = z22.discriminatedUnion("type", [
+  LedgerMetadataBaseSchema.extend({
+    type: z22.literal("tabRoot")
+  }),
+  LedgerMetadataBaseSchema.extend({
+    type: z22.literal("section"),
+    title: z22.string().optional(),
+    icon: z22.string().optional(),
+    collapsed: CollapsedSchema.optional(),
+    collapsible: z22.boolean().optional(),
+    collapsedByDefault: z22.boolean().optional(),
+    availability: LedgerAvailabilitySchema.optional(),
+    overviewPageId: z22.string().optional(),
+    pointsTo: z22.string().optional(),
+    viewers: MetadataStringArraySchema.optional()
+  }),
+  LedgerMetadataBaseSchema.extend({
+    type: z22.literal("apiReference"),
+    title: z22.string().optional(),
+    icon: z22.string().optional(),
+    apiDefinitionId: z22.string().optional(),
+    overviewPageId: z22.string().optional(),
+    availability: LedgerAvailabilitySchema.optional(),
+    pointsTo: z22.string().optional(),
+    paginated: z22.boolean().optional(),
+    showErrors: z22.boolean().optional(),
+    hideTitle: z22.boolean().optional(),
+    viewers: MetadataStringArraySchema.optional()
+  }),
+  LedgerMetadataBaseSchema.extend({
+    type: z22.literal("apiPackage"),
+    title: z22.string().optional(),
+    icon: z22.string().optional(),
+    apiDefinitionId: z22.string().optional(),
+    overviewPageId: z22.string().optional(),
+    availability: LedgerAvailabilitySchema.optional(),
+    pointsTo: z22.string().optional(),
+    viewers: MetadataStringArraySchema.optional()
+  }),
+  LedgerMetadataBaseSchema.extend({
+    type: z22.literal("changelog"),
+    title: z22.string().optional(),
+    icon: z22.string().optional(),
+    overviewPageId: z22.string().optional(),
+    apiDefinitionId: z22.string().optional(),
+    viewers: MetadataStringArraySchema.optional()
+  }),
+  LedgerMetadataBaseSchema.extend({
+    type: z22.literal("files")
+  }),
+  LedgerMetadataBaseSchema.extend({
+    type: z22.literal("redirects")
+  })
+]);
+var LedgerSegmentMetadataSchema = LedgerSegmentMetadataObjectSchema;
+var LedgerMarkdownMetadataSchema = LedgerMetadataBaseSchema.extend({
+  ...NodeMetadataFields,
+  pageId: z22.string().optional(),
+  isOverview: z22.boolean().optional(),
+  noindex: z22.boolean().optional()
+});
+var LedgerRestMetadataSchema = LedgerMetadataBaseSchema.extend({
+  ...ApiNodeMetadataFields,
+  endpointId: z22.string(),
+  method: HttpMethodSchema,
+  isResponseStream: z22.boolean().optional(),
+  endpointPairKey: z22.string().optional()
+});
+var LedgerWebSocketMetadataSchema = LedgerMetadataBaseSchema.extend({
+  ...ApiNodeMetadataFields,
+  webSocketId: z22.string()
+});
+var LedgerWebhookMetadataSchema = LedgerMetadataBaseSchema.extend({
+  ...ApiNodeMetadataFields,
+  webhookId: z22.string(),
+  // V1.WebhookNode carries the full HttpMethod union, so the read model must accept it too.
+  method: HttpMethodSchema
+});
+var LedgerGrpcMetadataSchema = LedgerMetadataBaseSchema.extend({
+  ...ApiNodeMetadataFields,
+  grpcId: z22.string(),
+  method: GrpcMethodSchema
+});
+var LedgerGraphQlMetadataSchema = LedgerMetadataBaseSchema.extend({
+  ...ApiNodeMetadataFields,
+  graphqlOperationId: z22.string(),
+  operationType: GraphQlOperationTypeSchema
+});
+var LedgerChangelogEntryMetadataSchema = LedgerMetadataBaseSchema.extend({
+  title: z22.string().optional(),
+  slug: z22.string().optional(),
+  icon: z22.string().optional(),
+  pageId: z22.string(),
+  date: z22.string().optional(),
+  tags: MetadataStringArraySchema.optional()
+});
+var LedgerLinkMetadataSchema = LedgerMetadataBaseSchema.extend({
+  title: z22.string().optional(),
+  slug: z22.string().optional(),
+  icon: z22.string().optional(),
+  url: z22.string(),
+  target: LinkTargetSchema2.optional()
+});
+var LedgerFileArtifactMetadataSchema = LedgerMetadataBaseSchema.extend({
+  contentType: z22.string(),
+  filename: z22.string(),
+  width: z22.number().optional(),
+  height: z22.number().optional(),
+  blurDataURL: z22.string().optional()
+});
+var LedgerRedirectMetadataSchema = LedgerMetadataBaseSchema.extend({
+  href: z22.string().optional()
+});
+var LedgerArtifactMetadataSchema = z22.union([
+  LedgerMarkdownMetadataSchema,
+  LedgerRestMetadataSchema,
+  LedgerWebSocketMetadataSchema,
+  LedgerWebhookMetadataSchema,
+  LedgerGrpcMetadataSchema,
+  LedgerGraphQlMetadataSchema,
+  LedgerChangelogEntryMetadataSchema,
+  LedgerLinkMetadataSchema,
+  LedgerFileArtifactMetadataSchema,
+  LedgerRedirectMetadataSchema
+]);
+var LEDGER_ARTIFACT_METADATA_SCHEMAS = {
+  markdown: LedgerMarkdownMetadataSchema,
+  page: LedgerMarkdownMetadataSchema,
+  rest: LedgerRestMetadataSchema,
+  asyncapi: LedgerWebSocketMetadataSchema,
+  webhook: LedgerWebhookMetadataSchema,
+  grpc: LedgerGrpcMetadataSchema,
+  graphql: LedgerGraphQlMetadataSchema,
+  changelog: LedgerChangelogEntryMetadataSchema,
+  link: LedgerLinkMetadataSchema,
+  file: LedgerFileArtifactMetadataSchema,
+  image: LedgerFileArtifactMetadataSchema,
+  redirect: LedgerRedirectMetadataSchema
+};
+function artifactTypeVariant(base, type) {
+  return base.extend({
+    artifactType: z22.literal(type),
+    artifactMetadata: LEDGER_ARTIFACT_METADATA_SCHEMAS[type]
+  });
+}
+var NavRouteBaseSchema = z22.object({
+  fullPath: z22.string().nullable(),
+  artifactId: z22.string(),
+  hidden: z22.boolean(),
+  displaySortOrder: z22.number().nullable().optional()
+});
+function navRouteVariant(type) {
+  return NavRouteBaseSchema.extend({
+    type: z22.literal(type),
+    metadata: LEDGER_ARTIFACT_METADATA_SCHEMAS[type]
+  });
+}
+var LedgerNavRouteSchema = z22.discriminatedUnion("type", [
+  navRouteVariant("markdown"),
+  navRouteVariant("page"),
+  navRouteVariant("rest"),
+  navRouteVariant("asyncapi"),
+  navRouteVariant("webhook"),
+  navRouteVariant("grpc"),
+  navRouteVariant("graphql"),
+  navRouteVariant("changelog"),
+  navRouteVariant("link"),
+  navRouteVariant("file"),
+  navRouteVariant("image"),
+  navRouteVariant("redirect")
+]);
 var DocsPublishGitInputSchema = z22.object({
   /** Full HTTPS URL of the repo (e.g. `https://github.com/acme/docs`). */
   repoUrl: z22.string(),
@@ -3942,11 +4205,12 @@ var DocsContentFieldsSchema = z22.object({
    */
   git: DocsPublishGitInputSchema.optional()
 });
-var LocaleEntrySchema = DocsContentFieldsSchema.extend({
+var LocaleEntrySchemaInternal = DocsContentFieldsSchema.extend({
   /** Locale identifier (e.g. "en", "es", "ja"). Required — no default. */
   locale: z22.string()
 });
-var DocsPublishInputSchema = z22.object({
+var LocaleEntrySchema = LocaleEntrySchemaInternal;
+var DocsPublishInputSchemaInternal = z22.object({
   orgId: z22.string(),
   domain: z22.string(),
   basepath: z22.string().default(""),
@@ -3973,7 +4237,8 @@ var DocsPublishInputSchema = z22.object({
   message: "defaultLocale must match one of the locales in the locales array",
   path: ["defaultLocale"]
 });
-var LedgerPreviewRegisterInputSchema = DocsContentFieldsSchema.extend({
+var DocsPublishInputSchema = DocsPublishInputSchemaInternal;
+var LedgerPreviewRegisterInputSchemaInternal = DocsContentFieldsSchema.extend({
   orgId: z22.string(),
   /**
    * Optional caller-supplied identifier for the preview hostname. Sanitized
@@ -3990,6 +4255,7 @@ var LedgerPreviewRegisterInputSchema = DocsContentFieldsSchema.extend({
    */
   basePath: z22.string().default("")
 });
+var LedgerPreviewRegisterInputSchema = LedgerPreviewRegisterInputSchemaInternal;
 var LedgerPreviewRegisterResponseSchema = z22.object({
   deploymentHash: z22.string(),
   missingContent: z22.array(MissingContentSchema),
@@ -4041,7 +4307,7 @@ var SegmentDetailSchema = z22.object({
   orphaned: z22.boolean(),
   featureFlags: z22.array(z22.string()),
   /** Type-specific fields: slug, default, subtitle, href, target, image, availability, pointsTo, tab_type. */
-  metadata: z22.unknown()
+  metadata: LedgerSegmentDetailMetadataSchema
 });
 var SegmentSchema = z22.object({
   segmentId: z22.string(),
@@ -4053,7 +4319,7 @@ var SegmentSchema = z22.object({
   /** Whether the segment is hidden from the sidebar. */
   hidden: z22.boolean(),
   /** Segment type descriptor (seg.metadata): { type, title, icon, apiDefinitionId, overviewPageId, pointsTo, ... }. */
-  metadata: z22.unknown(),
+  metadata: LedgerSegmentMetadataSchema,
   /** Full product/version/variant/tab detail metadata, or null when the dimension is absent. */
   product: SegmentDetailSchema.nullable(),
   version: SegmentDetailSchema.nullable(),
@@ -4122,16 +4388,19 @@ var VersionMetadataResponseSchema = z22.object({
 var PageContentInputSchema = z22.object({
   deploymentId: z22.string(),
   fullPath: z22.string().optional(),
-  pageId: z22.string().optional()
+  pageId: z22.string().optional(),
+  locale: z22.string().optional()
 });
 var PageContentResponseSchema = z22.object({
   s3Key: z22.string(),
   segmentHash: z22.string(),
-  url: z22.string()
+  url: z22.string(),
+  pageId: z22.string().optional()
 });
 var BatchPageContentInputSchema = z22.object({
   deploymentId: z22.string(),
-  pageIds: z22.array(z22.string()).min(1).max(2e3)
+  pageIds: z22.array(z22.string()).min(1).max(2e3),
+  locale: z22.string().optional()
 });
 var BatchPageContentItemSchema = z22.object({
   pageId: z22.string(),
@@ -4144,32 +4413,21 @@ var BatchPageContentResponseSchema = z22.object({
 var NavInputSchema = z22.object({
   segmentHash: z22.string()
 });
-var NavRouteSchema = z22.object({
-  fullPath: z22.string().nullable(),
-  artifactId: z22.string(),
-  type: z22.string(),
-  /** Whether the artifact is hidden from the sidebar. */
-  hidden: z22.boolean(),
-  metadata: z22.unknown()
-});
 var NavResponseSchema = z22.object({
-  routes: z22.array(NavRouteSchema)
+  routes: z22.array(LedgerNavRouteSchema)
 });
 var RouteContextInputSchema = z22.object({
   deploymentId: z22.string(),
   fullPath: z22.string(),
   locale: z22.string().optional()
 });
-var RouteContextResponseSchema = z22.object({
+var RouteContextResponseBaseSchema = z22.object({
+  artifactId: z22.string(),
   /** Hash of the segment that owns the matched route — feed to `nav`. */
   segmentHash: z22.string(),
   /** Section path of the owning segment (e.g. "models/command"). */
   section: z22.string(),
   locale: z22.string(),
-  /** The artifact matched at `fullPath`. */
-  artifactId: z22.string(),
-  artifactType: z22.string(),
-  artifactMetadata: z22.unknown(),
   /**
    * Page content reference, or null for non-page artifacts (links/redirects)
    * and route-only aliases that carry no content blob.
@@ -4184,6 +4442,20 @@ var RouteContextResponseSchema = z22.object({
   variant: SegmentDetailSchema.nullable(),
   tab: SegmentDetailSchema.nullable()
 });
+var RouteContextResponseSchema = z22.discriminatedUnion("artifactType", [
+  artifactTypeVariant(RouteContextResponseBaseSchema, "markdown"),
+  artifactTypeVariant(RouteContextResponseBaseSchema, "page"),
+  artifactTypeVariant(RouteContextResponseBaseSchema, "rest"),
+  artifactTypeVariant(RouteContextResponseBaseSchema, "asyncapi"),
+  artifactTypeVariant(RouteContextResponseBaseSchema, "webhook"),
+  artifactTypeVariant(RouteContextResponseBaseSchema, "grpc"),
+  artifactTypeVariant(RouteContextResponseBaseSchema, "graphql"),
+  artifactTypeVariant(RouteContextResponseBaseSchema, "changelog"),
+  artifactTypeVariant(RouteContextResponseBaseSchema, "link"),
+  artifactTypeVariant(RouteContextResponseBaseSchema, "file"),
+  artifactTypeVariant(RouteContextResponseBaseSchema, "image"),
+  artifactTypeVariant(RouteContextResponseBaseSchema, "redirect")
+]);
 var TopLevelNavigationInputSchema = z22.object({
   deploymentId: z22.string(),
   locale: z22.string().optional()
@@ -4300,17 +4572,6 @@ function createDocsLedgerClient(options) {
   });
   return createORPCClient11(link);
 }
-function createDocsLedgerReadClient(options) {
-  const baseUrl = options.baseUrl.replace(/\/+$/, "");
-  const link = new OpenAPILink11(docsLedgerReadContract, {
-    url: `${baseUrl}/docs-ledger`,
-    headers: () => ({
-      Authorization: `Bearer ${options.token}`,
-      ...options.headers
-    })
-  });
-  return createORPCClient11(link);
-}
 
 // src/orpc-client/editor-snapshot/client.ts
 import { createORPCClient as createORPCClient12 } from "@orpc/client";
@@ -5209,7 +5470,6 @@ function createFdrORPCClient(options) {
     docsCache: createDocsCacheClient(normalizedOptions),
     docsDeployment: createDocsDeploymentClient(normalizedOptions),
     docsLedger: createDocsLedgerClient(normalizedOptions),
-    docsLedgerRead: createDocsLedgerReadClient(normalizedOptions),
     editorSnapshot: createEditorSnapshotClient(normalizedOptions),
     generators: {
       root: createGeneratorsRootClient(normalizedOptions),
@@ -5227,28 +5487,358 @@ function createFdrORPCClient(options) {
   };
 }
 
+// src/orpc-client/docs-ledger/config-files.ts
+import * as z32 from "zod";
+var PATH_OR_URL_METADATA_KEYS = [
+  "og:image",
+  "og:logo",
+  "twitter:image",
+  "og:background-image",
+  "og:dynamic:background-image"
+];
+var LogoViewSchema = z32.union([z32.string(), z32.object({ path: z32.string() }).transform((v) => v.path)]);
+var ThemeViewSchema = z32.object({
+  logo: LogoViewSchema.optional().catch(void 0),
+  backgroundImage: z32.string().optional().catch(void 0)
+});
+var ColorsViewSchema = z32.union([
+  z32.object({
+    type: z32.literal("darkAndLight"),
+    dark: ThemeViewSchema.optional().catch(void 0),
+    light: ThemeViewSchema.optional().catch(void 0)
+  }),
+  ThemeViewSchema.transform((theme) => ({ type: "single", theme }))
+]);
+var FontViewSchema = z32.object({
+  variants: z32.array(z32.object({ fontFile: z32.string().optional().catch(void 0) })).catch([])
+});
+var TypographyViewSchema = z32.object({
+  headingsFont: FontViewSchema.optional().catch(void 0),
+  bodyFont: FontViewSchema.optional().catch(void 0),
+  codeFont: FontViewSchema.optional().catch(void 0)
+});
+var JsFileViewSchema = z32.union([
+  z32.object({ path: z32.string() }).transform((v) => v.path),
+  z32.object({ fileId: z32.string() }).transform((v) => v.fileId)
+]);
+var MetadataFileRefViewSchema = z32.object({
+  type: z32.enum(["path", "fileId"]),
+  value: z32.string()
+});
+var ConfigViewSchema = z32.object({
+  favicon: z32.string().optional().catch(void 0),
+  colorsV3: ColorsViewSchema.optional().catch(void 0),
+  typographyV2: TypographyViewSchema.optional().catch(void 0),
+  js: z32.object({ files: z32.array(JsFileViewSchema.optional().catch(void 0)).catch([]) }).optional().catch(void 0),
+  metadata: z32.record(z32.string(), z32.unknown()).optional().catch(void 0)
+});
+function isDarkAndLight(colors) {
+  return colors.type === "darkAndLight";
+}
+function collectConfigFilePaths(config) {
+  const paths = /* @__PURE__ */ new Set();
+  const view = ConfigViewSchema.parse(config);
+  if (view.favicon != null) {
+    paths.add(view.favicon);
+  }
+  if (view.colorsV3 != null) {
+    const themes = isDarkAndLight(view.colorsV3) ? [view.colorsV3.dark, view.colorsV3.light] : [view.colorsV3.theme];
+    for (const theme of themes) {
+      if (theme == null) {
+        continue;
+      }
+      if (theme.logo != null) {
+        paths.add(theme.logo);
+      }
+      if (theme.backgroundImage != null) {
+        paths.add(theme.backgroundImage);
+      }
+    }
+  }
+  if (view.typographyV2 != null) {
+    for (const font of [view.typographyV2.headingsFont, view.typographyV2.bodyFont, view.typographyV2.codeFont]) {
+      for (const variant of font?.variants ?? []) {
+        if (variant.fontFile != null) {
+          paths.add(variant.fontFile);
+        }
+      }
+    }
+  }
+  for (const file of view.js?.files ?? []) {
+    if (file != null) {
+      paths.add(file);
+    }
+  }
+  if (view.metadata != null) {
+    for (const key of PATH_OR_URL_METADATA_KEYS) {
+      const parsed = MetadataFileRefViewSchema.optional().catch(void 0).parse(view.metadata[key]);
+      if (parsed != null) {
+        paths.add(parsed.value);
+      }
+    }
+  }
+  return [...paths];
+}
+
+// src/orpc-client/docs-ledger/ledger-manifest.ts
+import * as z33 from "zod";
+var LEDGER_MANIFEST_SCHEMA_VERSION = "docsledger/20260601";
+var LEDGER_SHARD_SCHEMA_VERSION = "docsledger/shard/20260601";
+var ManifestBlobRefSchema = z33.object({
+  hash: z33.string(),
+  contentType: z33.string()
+});
+var ManifestSegmentSchema = z33.object({
+  /** Synthetic stable id (= segmentHash). */
+  segmentId: z33.string(),
+  segmentHash: z33.string(),
+  section: z33.string(),
+  locale: z33.string(),
+  /** Sidebar order across segments (docs_ledger_deployment_segments.sort_order). */
+  sortOrder: z33.number(),
+  hidden: z33.boolean(),
+  /** Segment type descriptor: { type, title, icon, apiDefinitionId, overviewPageId, pointsTo, ... }. */
+  metadata: LedgerSegmentMetadataSchema,
+  product: SegmentDetailSchema.nullable(),
+  version: SegmentDetailSchema.nullable(),
+  variant: SegmentDetailSchema.nullable(),
+  tab: SegmentDetailSchema.nullable()
+});
+var ManifestNavRouteSchema = LedgerNavRouteSchema;
+var ManifestRouteBaseSchema = z33.object({
+  segmentHash: z33.string(),
+  /** Key into the containing route index's sidebars map. */
+  sidebarKey: z33.string().nullable(),
+  section: z33.string(),
+  locale: z33.string(),
+  artifactId: z33.string(),
+  pageId: z33.string().optional(),
+  /** CAS hash of the page content blob, or null for link/redirect artifacts. */
+  contentHash: z33.string().nullable(),
+  contentType: z33.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: z33.string().optional()
+});
+var ManifestRouteSchema = z33.discriminatedUnion("artifactType", [
+  artifactTypeVariant(ManifestRouteBaseSchema, "markdown"),
+  artifactTypeVariant(ManifestRouteBaseSchema, "page"),
+  artifactTypeVariant(ManifestRouteBaseSchema, "rest"),
+  artifactTypeVariant(ManifestRouteBaseSchema, "asyncapi"),
+  artifactTypeVariant(ManifestRouteBaseSchema, "webhook"),
+  artifactTypeVariant(ManifestRouteBaseSchema, "grpc"),
+  artifactTypeVariant(ManifestRouteBaseSchema, "graphql"),
+  artifactTypeVariant(ManifestRouteBaseSchema, "changelog"),
+  artifactTypeVariant(ManifestRouteBaseSchema, "link"),
+  artifactTypeVariant(ManifestRouteBaseSchema, "file"),
+  artifactTypeVariant(ManifestRouteBaseSchema, "image"),
+  artifactTypeVariant(ManifestRouteBaseSchema, "redirect")
+]);
+var ManifestPageSchema = z33.object({
+  fullPath: z33.string().nullable(),
+  segmentHash: z33.string(),
+  contentHash: z33.string(),
+  contentType: z33.string()
+});
+var ManifestApiDefSchema = z33.object({
+  /** CAS hash of the full API definition blob. */
+  hash: z33.string(),
+  contentType: z33.string(),
+  /** key = `${nodeType}:${nodeId}` (e.g. `endpoint:abc`) → pruned CAS blob. */
+  prunedHashes: z33.record(z33.string(), ManifestBlobRefSchema)
+});
+var ManifestFileSchema = z33.object({
+  type: z33.enum(["file", "image"]),
+  contentType: z33.string(),
+  filename: z33.string(),
+  hash: z33.string(),
+  /** Canonical fern domain the bytes were uploaded under (ADR 0010 file anchor). */
+  domain: z33.string(),
+  bucket: z33.enum(["public_docs", "private_docs"]),
+  width: z33.number().optional(),
+  height: z33.number().optional(),
+  blurDataURL: z33.string().optional()
+});
+var LedgerShardFileSchema = z33.object({
+  /** SHA-256 hex of the file bytes (docs-bucket key component). */
+  hash: z33.string(),
+  /** Fern-host-relative path; equals the `file:<fullPath>` token's suffix. */
+  fullPath: z33.string(),
+  contentType: z33.string(),
+  width: z33.number().optional(),
+  height: z33.number().optional(),
+  blurDataURL: z33.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: z33.enum(["public_docs", "private_docs"]).optional()
+});
+var LedgerConfigBlobSchema = z33.object({
+  version: z33.string().nullable(),
+  git: z33.object({
+    repoUrl: z33.string(),
+    branch: z33.string(),
+    commitSha: z33.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: z33.object({
+    header: ManifestBlobRefSchema.optional(),
+    footer: ManifestBlobRefSchema.optional(),
+    cssInline: ManifestBlobRefSchema.optional(),
+    jsInline: ManifestBlobRefSchema.optional(),
+    jsFiles: ManifestBlobRefSchema.optional()
+  })
+});
+var LedgerChromeBlobSchema = z33.object({
+  apiNameToId: z33.record(z33.string(), z33.string())
+});
+var LedgerSidebarBundleSchema = z33.object({
+  locale: z33.string(),
+  segmentHash: z33.string(),
+  routes: z33.array(ManifestNavRouteSchema)
+});
+var LedgerSidebarMapEntrySchema = z33.discriminatedUnion("strategy", [
+  LedgerSidebarBundleSchema.extend({
+    strategy: z33.literal("inline")
+  }),
+  ManifestBlobRefSchema.extend({
+    strategy: z33.literal("ref")
+  })
+]);
+var LedgerLocaleIndexSchema = z33.object({
+  locale: z33.string(),
+  segments: z33.array(ManifestSegmentSchema),
+  /** sidebarKey → inline sidebar routes, or a CAS ref when over budget. */
+  sidebars: z33.record(z33.string(), LedgerSidebarMapEntrySchema),
+  /** fullPath → route for this effective locale. */
+  routes: z33.record(z33.string(), ManifestRouteSchema),
+  /** pageId → page content reference for this effective locale. */
+  pages: z33.record(z33.string(), ManifestPageSchema),
+  /** apiDefinitionId → full + pruned API definition blobs. */
+  apiDefs: z33.record(z33.string(), ManifestApiDefSchema),
+  /** fullPath → file/image artifact metadata. */
+  files: z33.record(z33.string(), ManifestFileSchema)
+});
+var LedgerRouteShardSchema = z33.object({
+  schema: z33.literal(LEDGER_SHARD_SCHEMA_VERSION),
+  locale: z33.string(),
+  /** fullPath → route for the scopes packed into this shard. */
+  routes: z33.record(z33.string(), ManifestRouteSchema),
+  /** segmentHash → inline sidebar (or CAS ref) for every segment in this shard's scopes. */
+  sidebars: z33.record(z33.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
+   * path"). The union of identities for this shard's routes'
+   * `referencedFiles`. Optional — absent on shards built before this field
+   * existed or with no embedded files; the bundle then falls back to the
+   * pointer's `files` map (`fileMetadata`/`fileArtifact`).
+   */
+  files: z33.record(z33.string(), LedgerShardFileSchema).optional()
+});
+var LedgerPagesBlobSchema = z33.record(z33.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: z33.number().nullable(),
+  /** Index into the locale's `versionCatalog`, or null when the segment has no version. */
+  versionIdx: z33.number().nullable()
+});
+var LedgerLocaleRoutingSchema = z33.object({
+  /** Compact segments catalog for the switcher chrome (product/version by index). */
+  segments: z33.array(LedgerPointerSegmentSchema),
+  /** Deduplicated product details; `LedgerPointerSegment.productIdx` indexes into this. */
+  productCatalog: z33.array(SegmentDetailSchema),
+  /** Deduplicated version details; `LedgerPointerSegment.versionIdx` indexes into this. */
+  versionCatalog: z33.array(SegmentDetailSchema),
+  /** fullPath → index into `shards`. */
+  routing: z33.record(z33.string(), z33.number()),
+  /** segmentHash → index into `shards`. */
+  segmentShard: z33.record(z33.string(), z33.number()),
+  /** Ordered list of route shards; index matches `routing`/`segmentShard`. */
+  shards: z33.array(z33.object({ hash: z33.string() })),
+  /** versionId → first routable fullPath (version switcher). */
+  versionFirstRoute: z33.record(z33.string(), z33.string()),
+  /** CAS hash of the per-locale pages blob. */
+  pagesHash: z33.string(),
+  /**
+   * fullPath → file/image artifact metadata for files NOT materialised into
+   * a route shard (ADR 0016, "File metadata on the render path"): config
+   * files (logo/fonts/OG), well-known files (favicon/robots/context7),
+   * API-description-embedded images, and any other non-page-referenced file.
+   * Page-body images are pruned from here and live in their route shard's
+   * `files` map instead. Read via `fileMetadata` / `fileArtifact`.
+   */
+  files: z33.record(z33.string(), ManifestFileSchema),
+  /** apiDefinitionId → full + pruned API definition blobs. */
+  apiDefs: z33.record(z33.string(), ManifestApiDefSchema)
+});
+var LedgerManifestSchema = z33.object({
+  schema: z33.literal(LEDGER_MANIFEST_SCHEMA_VERSION),
+  // ── Pointer / current-version fields ──────────────────────────────
+  orgId: z33.string(),
+  domain: z33.string(),
+  basepath: z33.string(),
+  deploymentId: z33.string(),
+  deploymentHash: z33.string(),
+  siteId: z33.string(),
+  /** ISO-8601 timestamp the publish became live (request time). */
+  assignedAt: z33.string(),
+  assignedBy: z33.string().nullable(),
+  isPreview: z33.boolean(),
+  isPrivate: z33.boolean(),
+  /** Default locale for the deployment — read-path fallback when a translation is absent. */
+  defaultLocale: z33.string(),
+  /**
+   * Canonical fern domain all file bytes are anchored under (ADR 0010). The
+   * read client builds the public `/_files/{fileAnchorDomain}/{hash}/{fullPath}`
+   * URL (or presigns the private bucket) for the lean {@link LedgerShardFile}
+   * entries, which omit `domain`. Optional for back-compat with pointers
+   * written before shard-side files; absent ⇒ the client falls back to the
+   * pointer `files` map (which still carries per-file `domain`).
+   */
+  fileAnchorDomain: z33.string().optional(),
+  config: LedgerConfigBlobSchema,
+  chrome: LedgerChromeBlobSchema,
+  locales: z33.record(z33.string(), LedgerLocaleRoutingSchema)
+});
+
+// src/orpc-client/docs-ledger/stable-stringify.ts
+function stableStringify(value) {
+  return JSON.stringify(value, (_key, val) => {
+    if (val != null && typeof val === "object" && !Array.isArray(val)) {
+      return Object.fromEntries(Object.entries(val).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
+    }
+    return val;
+  });
+}
+
 // src/orpc-client/files/contract.ts
 import { oc as oc21 } from "@orpc/contract";
-import * as z32 from "zod";
-var PutContentInputSchema = z32.object({
-  contentType: z32.string(),
-  contentLength: z32.number().int().positive()
+import * as z34 from "zod";
+var PutContentInputSchema = z34.object({
+  contentType: z34.string(),
+  contentLength: z34.number().int().positive()
 });
-var PutContentResponseSchema = z32.discriminatedUnion("status", [
+var PutContentResponseSchema = z34.discriminatedUnion("status", [
   /** Content already exists in storage — client can skip the S3 upload. */
-  z32.object({ status: z32.literal("exists") }),
+  z34.object({ status: z34.literal("exists") }),
   /** Content is new — client should PUT the file bytes to uploadUrl, then call PUT /files. */
-  z32.object({ status: z32.literal("upload_required"), uploadUrl: z32.string() })
+  z34.object({ status: z34.literal("upload_required"), uploadUrl: z34.string() })
 ]);
-var PutFileInputSchema = z32.object({
-  hash: z32.string(),
-  contentType: z32.string()
+var PutFileInputSchema = z34.object({
+  hash: z34.string(),
+  contentType: z34.string()
 });
-var FileResponseSchema = z32.object({
+var FileResponseSchema = z34.object({
   /** SHA-256 hex digest of the file content (64 characters). */
-  hash: z32.string(),
+  hash: z34.string(),
   /** Presigned S3 GET URL. TTL is configurable (default 3600 seconds). */
-  downloadUrl: z32.string()
+  downloadUrl: z34.string()
 });
 var contentContract = {
   /**
@@ -5271,7 +5861,7 @@ var filesContract = {
 };
 
 // src/orpc-client/themes/contract.ts
-import * as z33 from "zod";
+import * as z35 from "zod";
 var FERN_FILE_REF_KEY = "hash";
 var SHA256_RE = /^[0-9a-f]{64}$/;
 function isFernFileRef(value) {
@@ -5286,26 +5876,26 @@ function isFernFileRef(value) {
   return typeof hash === "string" && SHA256_RE.test(hash);
 }
 var THEME_NAME_RE = /^[a-zA-Z0-9_-]{1,64}$/;
-var ThemeResponseSchema = z33.object({
-  id: z33.string(),
-  orgId: z33.string(),
-  name: z33.string(),
-  config: z33.unknown(),
-  updatedAt: z33.string()
+var ThemeResponseSchema = z35.object({
+  id: z35.string(),
+  orgId: z35.string(),
+  name: z35.string(),
+  config: z35.unknown(),
+  updatedAt: z35.string()
   // ISO 8601 timestamp
 });
-var ThemeListItemSchema = z33.object({
-  id: z33.string(),
-  orgId: z33.string(),
-  name: z33.string(),
-  updatedAt: z33.string()
+var ThemeListItemSchema = z35.object({
+  id: z35.string(),
+  orgId: z35.string(),
+  name: z35.string(),
+  updatedAt: z35.string()
 });
-var ThemeListResponseSchema = z33.object({
-  themes: z33.array(ThemeListItemSchema)
+var ThemeListResponseSchema = z35.object({
+  themes: z35.array(ThemeListItemSchema)
 });
-var UpsertThemeBodySchema = z33.object({
-  name: z33.string().min(1).max(64).regex(THEME_NAME_RE, "Theme name may only contain letters, digits, hyphens, and underscores"),
-  config: z33.unknown()
+var UpsertThemeBodySchema = z35.object({
+  name: z35.string().min(1).max(64).regex(THEME_NAME_RE, "Theme name may only contain letters, digits, hyphens, and underscores"),
+  config: z35.unknown()
 });
 export {
   AlgoliaDomainInputSchema,
@@ -5535,6 +6125,9 @@ export {
   JavaCoordinateSchema,
   JqStringSchema,
   JsonBodyShapeSchema,
+  LEDGER_ARTIFACT_METADATA_SCHEMAS,
+  LEDGER_MANIFEST_SCHEMA_VERSION,
+  LEDGER_SHARD_SCHEMA_VERSION,
   LanguageEnumSchema,
   LatestApiDefinitionSchema,
   LatestAuthSchemeSchema,
@@ -5592,9 +6185,35 @@ export {
   LatestWebhookDefinitionSchema,
   LatestWebhookPayloadSchema,
   LatestWebhookPayloadShapeSchema,
+  LedgerArtifactMetadataSchema,
+  LedgerArtifactTypeSchema,
+  LedgerChangelogEntryMetadataSchema,
+  LedgerChromeBlobSchema,
+  LedgerConfigBlobSchema,
   LedgerConfigSchema,
+  LedgerFileArtifactMetadataSchema,
+  LedgerGraphQlMetadataSchema,
+  LedgerGrpcMetadataSchema,
+  LedgerLinkMetadataSchema,
+  LedgerLocaleIndexSchema,
+  LedgerLocaleRoutingSchema,
+  LedgerManifestSchema,
+  LedgerMarkdownMetadataSchema,
+  LedgerNavRouteSchema,
+  LedgerPagesBlobSchema,
+  LedgerPointerSegmentSchema,
   LedgerPreviewRegisterInputSchema,
   LedgerPreviewRegisterResponseSchema,
+  LedgerRedirectMetadataSchema,
+  LedgerRestMetadataSchema,
+  LedgerRouteShardSchema,
+  LedgerSegmentDetailMetadataSchema,
+  LedgerSegmentMetadataSchema,
+  LedgerShardFileSchema,
+  LedgerSidebarBundleSchema,
+  LedgerSidebarMapEntrySchema,
+  LedgerWebSocketMetadataSchema,
+  LedgerWebhookMetadataSchema,
   LibraryDocsBaseConfigSchema,
   LibraryDocsGenerationStatusSchema,
   LibraryDocsResultSchema,
@@ -5616,6 +6235,13 @@ export {
   LoadDocsForUrlResponseSchema,
   LocaleEntrySchema,
   LongTypeSchema,
+  ManifestApiDefSchema,
+  ManifestBlobRefSchema,
+  ManifestFileSchema,
+  ManifestNavRouteSchema,
+  ManifestPageSchema,
+  ManifestRouteSchema,
+  ManifestSegmentSchema,
   MarkdownEntrySchema,
   MissingContentSchema,
   MultipleAuthTypeSchema,
@@ -5632,6 +6258,7 @@ export {
   OpenRpcProtocolSchema,
   OrgId,
   OrgIdSchema,
+  PATH_OR_URL_METADATA_KEYS,
   PageBlobRefSchema,
   PageContentInputSchema,
   PageContentResponseSchema,
@@ -5827,6 +6454,8 @@ export {
   WithDescriptionSchema,
   WithNamespaceSchema,
   YankSchema,
+  artifactTypeVariant,
+  collectConfigFilePaths,
   contentContract,
   createApiClient,
   createDashboardClient,
@@ -5834,7 +6463,6 @@ export {
   createDocsClient,
   createDocsDeploymentClient,
   createDocsLedgerClient,
-  createDocsLedgerReadClient,
   createDocsV1ReadClient,
   createDocsV1WriteClient,
   createDocsV2ReadClient,
@@ -5878,6 +6506,7 @@ export {
   slugsContract,
   snippetsContract,
   snippetsFactoryContract,
+  stableStringify,
   templatesContract,
   tokensContract
 };