@agent-native/core 0.79.25 → 0.79.27

package/corpus/templates/content/app/blocks/BuilderDocsBlocks.tsx

@@ -0,0 +1,254 @@
+import type {
+  BlockEditProps,
+  BlockReadProps,
+  BlockSpec,
+} from "@agent-native/core/blocks";
+import {
+  builderCodeBlockConfig,
+  builderCodeSnippetsV2BlockConfig,
+  builderRawBlockConfig,
+  builderSymbolBlockConfig,
+  builderTabbedContentBlockConfig,
+  builderTextBlockConfig,
+  type BuilderCodeBlockData,
+  type BuilderCodeSnippetsV2Data,
+  type BuilderRawBlockData,
+  type BuilderSymbolData,
+  type BuilderTabbedContentData,
+  type BuilderTextData,
+} from "@shared/builder-docs-blocks";
+import {
+  IconBox,
+  IconCode,
+  IconFileText,
+  IconLayout,
+  IconPuzzle,
+} from "@tabler/icons-react";
+import { useState } from "react";
+
+function SidecarBadge({ rawRef }: { rawRef: string }) {
+  return (
+    <div className="mt-2 truncate text-[11px] text-muted-foreground">
+      {rawRef}
+    </div>
+  );
+}
+
+export function BuilderTextRead({
+  data,
+  blockId,
+  ctx,
+}: BlockReadProps<BuilderTextData>) {
+  return (
+    <section data-block-id={blockId} className="an-block builder-text-block">
+      {ctx.renderMarkdown?.(data.body) ?? (
+        <div className="whitespace-pre-wrap">{data.body}</div>
+      )}
+    </section>
+  );
+}
+
+export function BuilderTextEdit({
+  data,
+  onChange,
+  editable,
+  blockId,
+  ctx,
+}: BlockEditProps<BuilderTextData>) {
+  return (
+    <section data-block-id={blockId} className="an-block builder-text-block">
+      {ctx.renderMarkdownEditor?.({
+        value: data.body,
+        onChange: (body) => onChange({ ...data, body }),
+        editable,
+        blockId,
+      }) ?? (
+        <textarea
+          data-plan-interactive
+          className="min-h-[120px] w-full rounded-md border border-input bg-transparent px-3 py-2 text-sm leading-6 text-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring"
+          value={data.body}
+          disabled={!editable}
+          onChange={(event) =>
+            onChange({ ...data, body: event.currentTarget.value })
+          }
+        />
+      )}
+    </section>
+  );
+}
+
+export function BuilderCodeBlockRead({
+  data,
+  blockId,
+}: BlockReadProps<BuilderCodeBlockData>) {
+  return (
+    <section
+      data-block-id={blockId}
+      className="an-block overflow-hidden rounded-md border bg-muted/20"
+    >
+      <div className="flex min-h-9 items-center gap-2 border-b px-3 text-xs text-muted-foreground">
+        <IconCode className="size-4" />
+        <span className="truncate">
+          {data.filename || data.language || data.componentName || "Code block"}
+        </span>
+      </div>
+      <pre className="max-h-[520px] overflow-auto p-3 text-xs leading-5">
+        <code>{data.code}</code>
+      </pre>
+    </section>
+  );
+}
+
+export function BuilderCodeSnippetsV2Read({
+  data,
+  blockId,
+}: BlockReadProps<BuilderCodeSnippetsV2Data>) {
+  const tabCount = Object.values(data.customTabContent ?? {}).filter((value) =>
+    Array.isArray(value) ? value.length > 0 : Boolean(value),
+  ).length;
+  return (
+    <section
+      data-block-id={blockId}
+      className="an-block rounded-md border bg-muted/20 px-3 py-3"
+    >
+      <div className="flex items-center gap-2 text-sm font-medium">
+        <IconCode className="size-4" />
+        <span>CodeSnippetsV2</span>
+      </div>
+      <div className="mt-1 text-xs text-muted-foreground">
+        {data.modelName || "No model name"} / {data.modelType || "page"} /{" "}
+        {tabCount} custom tabs
+      </div>
+      <SidecarBadge rawRef={data.rawRef} />
+    </section>
+  );
+}
+
+export function BuilderTabbedContentRead({
+  data,
+  blockId,
+  ctx,
+}: BlockReadProps<BuilderTabbedContentData>) {
+  const [active, setActive] = useState(0);
+  const current =
+    data.tabs[Math.min(active, Math.max(data.tabs.length - 1, 0))];
+  return (
+    <section data-block-id={blockId} className="an-block rounded-md border p-3">
+      {data.title ? (
+        <div className="mb-2 text-sm font-medium">{data.title}</div>
+      ) : null}
+      <div className="flex max-w-full flex-wrap gap-1 border-b">
+        {data.tabs.map((tab, index) => (
+          <button
+            key={`${tab.label}-${index}`}
+            type="button"
+            data-plan-interactive
+            className={
+              active === index
+                ? "border-b-2 border-foreground px-2 py-1 text-xs font-medium"
+                : "px-2 py-1 text-xs text-muted-foreground hover:text-foreground"
+            }
+            onClick={() => setActive(index)}
+          >
+            {tab.label}
+          </button>
+        ))}
+      </div>
+      <div className="pt-3 text-sm">
+        {current
+          ? (ctx.renderMarkdown?.(current.body) ?? (
+              <div className="whitespace-pre-wrap">{current.body}</div>
+            ))
+          : null}
+      </div>
+    </section>
+  );
+}
+
+export function BuilderSymbolRead({
+  data,
+  blockId,
+}: BlockReadProps<BuilderSymbolData>) {
+  return (
+    <section
+      data-block-id={blockId}
+      className="an-block rounded-md border border-dashed bg-muted/20 px-3 py-3"
+    >
+      <div className="flex items-center gap-2 text-sm font-medium">
+        <IconPuzzle className="size-4" />
+        <span>Builder Symbol</span>
+      </div>
+      <div className="mt-1 text-xs text-muted-foreground">
+        {data.model || "model unknown"} / {data.entry || "entry unknown"}
+      </div>
+      <SidecarBadge rawRef={data.rawRef} />
+    </section>
+  );
+}
+
+export function BuilderRawBlockRead({
+  data,
+  blockId,
+}: BlockReadProps<BuilderRawBlockData>) {
+  return (
+    <section
+      data-block-id={blockId}
+      data-plan-interactive
+      className="an-block rounded-md border border-dashed bg-muted/20 px-3 py-3 text-sm text-muted-foreground"
+    >
+      <div className="flex items-center gap-2 font-medium text-foreground">
+        <IconBox className="size-4" />
+        <span>{data.componentName || "Raw Builder block"}</span>
+      </div>
+      {data.summary ? <div className="mt-1">{data.summary}</div> : null}
+      <SidecarBadge rawRef={data.rawRef} />
+    </section>
+  );
+}
+
+export const builderTextBlock: BlockSpec<BuilderTextData> = {
+  ...builderTextBlockConfig,
+  Read: BuilderTextRead,
+  Edit: BuilderTextEdit,
+  icon: IconFileText,
+};
+
+export const builderCodeBlock: BlockSpec<BuilderCodeBlockData> = {
+  ...builderCodeBlockConfig,
+  Read: BuilderCodeBlockRead,
+  icon: IconCode,
+};
+
+export const builderCodeSnippetsV2Block: BlockSpec<BuilderCodeSnippetsV2Data> =
+  {
+    ...builderCodeSnippetsV2BlockConfig,
+    Read: BuilderCodeSnippetsV2Read,
+    icon: IconCode,
+  };
+
+export const builderTabbedContentBlock: BlockSpec<BuilderTabbedContentData> = {
+  ...builderTabbedContentBlockConfig,
+  Read: BuilderTabbedContentRead,
+  icon: IconLayout,
+};
+
+export const builderSymbolBlock: BlockSpec<BuilderSymbolData> = {
+  ...builderSymbolBlockConfig,
+  Read: BuilderSymbolRead,
+  icon: IconPuzzle,
+};
+
+export const builderRawBlock: BlockSpec<BuilderRawBlockData> = {
+  ...builderRawBlockConfig,
+  Read: BuilderRawBlockRead,
+  icon: IconBox,
+};
+
+export const builderDocsBlocks: BlockSpec<any>[] = [
+  builderTextBlock,
+  builderCodeBlock,
+  builderCodeSnippetsV2Block,
+  builderTabbedContentBlock,
+  builderSymbolBlock,
+  builderRawBlock,
+];

package/corpus/templates/content/app/blocks/contentBlockRegistry.tsx

@@ -20,6 +20,7 @@ import {
 } from "@/components/ui/popover";
 import { cn } from "@/lib/utils";
 
+import { builderDocsBlocks } from "./BuilderDocsBlocks";
 import {
   ContentBlockMarkdown,
   ContentBlockMarkdownEditor,
@@ -54,6 +55,9 @@ export const contentBlockRegistry = new BlockRegistry();
 registerLibraryBlocks(contentBlockRegistry, {
   overrides: { table: { type: "table-block" } },
 });
+for (const block of builderDocsBlocks) {
+  contentBlockRegistry.register(block);
+}
 contentBlockRegistry.register(inlineDatabaseBlock);
 
 type ContentBlockRenderContext = BlockRenderContext & {

package/corpus/templates/content/server/db/schema.ts

@@ -78,6 +78,18 @@ export const documentSyncLinks = table("document_sync_links", {
   updatedAt: text("updated_at").notNull().default(now()),
 });
 
+export const builderDocSidecars = table("builder_doc_sidecars", {
+  id: text("id").primaryKey(),
+  ownerEmail: text("owner_email").notNull().default("local@localhost"),
+  orgId: text("org_id"),
+  documentId: text("document_id").notNull(),
+  path: text("path").notNull(),
+  content: text("content").notNull(),
+  contentHash: text("content_hash").notNull(),
+  createdAt: text("created_at").notNull().default(now()),
+  updatedAt: text("updated_at").notNull().default(now()),
+});
+
 export const documentPropertyDefinitions = table(
   "document_property_definitions",
   {

package/corpus/templates/content/server/plugins/db.ts

@@ -512,6 +512,29 @@ const runContentMigrations = runMigrations(
       version: 55,
       sql: `ALTER TABLE content_databases ADD COLUMN IF NOT EXISTS deleted_at TEXT`,
     },
+    // v56-v57: DB-backed Builder MDX documents keep their raw sidecar files in a
+    // document-scoped cache. Local-file Builder MDX still uses in-repo sidecars
+    // as the portable source of truth; these rows only make pulled SQL documents
+    // round-trip through the visual editor and push validator.
+    {
+      version: 56,
+      sql: `CREATE TABLE IF NOT EXISTS builder_doc_sidecars (
+      id TEXT PRIMARY KEY,
+      owner_email TEXT NOT NULL DEFAULT 'local@localhost',
+      org_id TEXT,
+      document_id TEXT NOT NULL,
+      path TEXT NOT NULL,
+      content TEXT NOT NULL,
+      content_hash TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )`,
+    },
+    {
+      version: 57,
+      sql: `CREATE INDEX IF NOT EXISTS builder_doc_sidecars_document_idx ON builder_doc_sidecars (document_id);
+        CREATE UNIQUE INDEX IF NOT EXISTS builder_doc_sidecars_doc_path_idx ON builder_doc_sidecars (document_id, path)`,
+    },
   ],
   { table: "content_migrations" },
 );

package/corpus/templates/content/shared/api.ts

@@ -38,6 +38,7 @@ export interface DocumentSourceInfo {
   absolutePath?: string;
   rootName?: string;
   rootPath?: string;
+  profile?: string;
   hash?: string;
   contentType?: string;
   sizeBytes?: number;

package/corpus/templates/content/shared/builder-docs-blocks.ts

@@ -0,0 +1,361 @@
+import {
+  defineBlock,
+  markdown,
+  type BlockMdxConfig,
+  type BlockSpec,
+} from "@agent-native/core/blocks/server";
+import { z } from "zod";
+
+export const BUILDER_DOCS_MDX_SOURCE_MODE = "builder-mdx";
+export const BUILDER_DOCS_SOURCE_KIND_PREFIX = "builder-cms:";
+
+export interface BuilderRawRefData {
+  rawRef: string;
+  rawHash: string;
+  componentName?: string;
+}
+
+export interface BuilderTextData extends BuilderRawRefData {
+  body: string;
+}
+
+export interface BuilderCodeBlockData extends BuilderRawRefData {
+  code: string;
+  language?: string;
+  filename?: string;
+  dark?: boolean;
+  url?: string;
+}
+
+export interface BuilderCodeSnippetsV2Data extends BuilderRawRefData {
+  modelName?: string;
+  modelType?: string;
+  customTabContent?: Record<string, unknown>;
+  reuseRemixContentForHydrogen?: boolean;
+  convenientEditingMode?: boolean;
+  simple?: boolean;
+}
+
+export interface BuilderTabbedContentTab {
+  label: string;
+  body: string;
+}
+
+export interface BuilderTabbedContentData extends BuilderRawRefData {
+  title?: string;
+  tabs: BuilderTabbedContentTab[];
+}
+
+export interface BuilderSymbolData extends BuilderRawRefData {
+  entry?: string;
+  model?: string;
+  data?: Record<string, unknown>;
+}
+
+export interface BuilderRawBlockData extends BuilderRawRefData {
+  summary?: string;
+}
+
+const rawRefSchema = {
+  rawRef: z.string().trim().min(1),
+  rawHash: z.string().trim().min(1),
+  componentName: z.string().trim().max(120).optional(),
+};
+
+export const builderTextSchema = z.object({
+  ...rawRefSchema,
+  body: markdown(z.string().max(100_000)) as z.ZodType<string>,
+}) as unknown as z.ZodType<BuilderTextData>;
+
+export const builderCodeBlockSchema = z.object({
+  ...rawRefSchema,
+  code: z.string().max(200_000),
+  language: z.string().trim().max(80).optional(),
+  filename: z.string().trim().max(400).optional(),
+  dark: z.boolean().optional(),
+  url: z.string().trim().max(2_000).optional(),
+}) as unknown as z.ZodType<BuilderCodeBlockData>;
+
+export const builderCodeSnippetsV2Schema = z.object({
+  ...rawRefSchema,
+  modelName: z.string().trim().max(120).optional(),
+  modelType: z.string().trim().max(40).optional(),
+  customTabContent: z.record(z.string(), z.unknown()).optional(),
+  reuseRemixContentForHydrogen: z.boolean().optional(),
+  convenientEditingMode: z.boolean().optional(),
+  simple: z.boolean().optional(),
+}) as unknown as z.ZodType<BuilderCodeSnippetsV2Data>;
+
+export const builderTabbedContentSchema = z.object({
+  ...rawRefSchema,
+  title: z.string().trim().max(200).optional(),
+  tabs: z
+    .array(
+      z.object({
+        label: z.string().trim().min(1).max(120),
+        body: markdown(z.string().max(100_000)) as z.ZodType<string>,
+      }),
+    )
+    .min(1)
+    .max(20),
+}) as unknown as z.ZodType<BuilderTabbedContentData>;
+
+export const builderSymbolSchema = z.object({
+  ...rawRefSchema,
+  entry: z.string().trim().max(240).optional(),
+  model: z.string().trim().max(120).optional(),
+  data: z.record(z.string(), z.unknown()).optional(),
+}) as unknown as z.ZodType<BuilderSymbolData>;
+
+export const builderRawBlockSchema = z.object({
+  ...rawRefSchema,
+  summary: z.string().trim().max(500).optional(),
+}) as unknown as z.ZodType<BuilderRawBlockData>;
+
+function rawRefAttrs(data: BuilderRawRefData) {
+  return {
+    rawRef: data.rawRef,
+    rawHash: data.rawHash,
+    componentName: data.componentName,
+  };
+}
+
+export const builderTextMdx: BlockMdxConfig<BuilderTextData> = {
+  tag: "BuilderText",
+  childrenField: "body",
+  toAttrs: rawRefAttrs,
+  fromAttrs: (attrs, children) => ({
+    rawRef: attrs.string("rawRef") ?? "",
+    rawHash: attrs.string("rawHash") ?? "",
+    componentName: attrs.string("componentName"),
+    body: children,
+  }),
+};
+
+export const builderCodeBlockMdx: BlockMdxConfig<BuilderCodeBlockData> = {
+  tag: "BuilderCodeBlock",
+  toAttrs: (data) => ({
+    ...rawRefAttrs(data),
+    code: data.code,
+    language: data.language,
+    filename: data.filename,
+    dark: data.dark,
+    url: data.url,
+  }),
+  fromAttrs: (attrs) => ({
+    rawRef: attrs.string("rawRef") ?? "",
+    rawHash: attrs.string("rawHash") ?? "",
+    componentName: attrs.string("componentName"),
+    code: attrs.string("code") ?? "",
+    language: attrs.string("language"),
+    filename: attrs.string("filename"),
+    dark: attrs.bool("dark"),
+    url: attrs.string("url"),
+  }),
+};
+
+export const builderCodeSnippetsV2Mdx: BlockMdxConfig<BuilderCodeSnippetsV2Data> =
+  {
+    tag: "BuilderCodeSnippetsV2",
+    toAttrs: (data) => ({
+      ...rawRefAttrs(data),
+      modelName: data.modelName,
+      modelType: data.modelType,
+      customTabContent: data.customTabContent,
+      reuseRemixContentForHydrogen: data.reuseRemixContentForHydrogen,
+      convenientEditingMode: data.convenientEditingMode,
+      simple: data.simple,
+    }),
+    fromAttrs: (attrs) => ({
+      rawRef: attrs.string("rawRef") ?? "",
+      rawHash: attrs.string("rawHash") ?? "",
+      componentName: attrs.string("componentName"),
+      modelName: attrs.string("modelName"),
+      modelType: attrs.string("modelType"),
+      customTabContent:
+        attrs.object<Record<string, unknown>>("customTabContent"),
+      reuseRemixContentForHydrogen: attrs.bool("reuseRemixContentForHydrogen"),
+      convenientEditingMode: attrs.bool("convenientEditingMode"),
+      simple: attrs.bool("simple"),
+    }),
+  };
+
+export const builderTabbedContentMdx: BlockMdxConfig<BuilderTabbedContentData> =
+  {
+    tag: "BuilderTabbedContent",
+    toAttrs: (data) => ({
+      ...rawRefAttrs(data),
+      title: data.title,
+      tabs: data.tabs,
+    }),
+    fromAttrs: (attrs) => ({
+      rawRef: attrs.string("rawRef") ?? "",
+      rawHash: attrs.string("rawHash") ?? "",
+      componentName: attrs.string("componentName"),
+      title: attrs.string("title"),
+      tabs: attrs.array<BuilderTabbedContentTab>("tabs") ?? [],
+    }),
+  };
+
+export const builderSymbolMdx: BlockMdxConfig<BuilderSymbolData> = {
+  tag: "BuilderSymbol",
+  toAttrs: (data) => ({
+    ...rawRefAttrs(data),
+    entry: data.entry,
+    model: data.model,
+    data: data.data,
+  }),
+  fromAttrs: (attrs) => ({
+    rawRef: attrs.string("rawRef") ?? "",
+    rawHash: attrs.string("rawHash") ?? "",
+    componentName: attrs.string("componentName"),
+    entry: attrs.string("entry"),
+    model: attrs.string("model"),
+    data: attrs.object<Record<string, unknown>>("data"),
+  }),
+};
+
+export const builderRawBlockMdx: BlockMdxConfig<BuilderRawBlockData> = {
+  tag: "BuilderRawBlock",
+  toAttrs: (data) => ({
+    ...rawRefAttrs(data),
+    summary: data.summary,
+  }),
+  fromAttrs: (attrs) => ({
+    rawRef: attrs.string("rawRef") ?? "",
+    rawHash: attrs.string("rawHash") ?? "",
+    componentName: attrs.string("componentName"),
+    summary: attrs.string("summary"),
+  }),
+};
+
+const ServerReadStub = () => null;
+
+export const builderTextBlockConfig: BlockSpec<BuilderTextData> =
+  defineBlock<BuilderTextData>({
+    type: "builder-text",
+    schema: builderTextSchema,
+    mdx: builderTextMdx,
+    Read: ServerReadStub,
+    placement: ["block"],
+    editSurface: "inline",
+    label: "Builder Text",
+    description:
+      "Builder Text block backed by a raw sidecar so text edits preserve Builder metadata.",
+  });
+
+export const builderCodeBlockConfig: BlockSpec<BuilderCodeBlockData> =
+  defineBlock<BuilderCodeBlockData>({
+    type: "builder-code-block",
+    schema: builderCodeBlockSchema,
+    mdx: builderCodeBlockMdx,
+    Read: ServerReadStub,
+    placement: ["block"],
+    editSurface: "panel",
+    label: "Builder Code Block",
+    description:
+      "Builder docs/blog code block with editable code props and raw sidecar preservation.",
+  });
+
+export const builderCodeSnippetsV2BlockConfig: BlockSpec<BuilderCodeSnippetsV2Data> =
+  defineBlock<BuilderCodeSnippetsV2Data>({
+    type: "builder-code-snippets-v2",
+    schema: builderCodeSnippetsV2Schema,
+    mdx: builderCodeSnippetsV2Mdx,
+    Read: ServerReadStub,
+    placement: ["block"],
+    editSurface: "panel",
+    label: "Builder CodeSnippetsV2",
+    description:
+      "Builder.io docs CodeSnippetsV2 component with schema-based prop editing.",
+  });
+
+export const builderTabbedContentBlockConfig: BlockSpec<BuilderTabbedContentData> =
+  defineBlock<BuilderTabbedContentData>({
+    type: "builder-tabbed-content",
+    schema: builderTabbedContentSchema,
+    mdx: builderTabbedContentMdx,
+    Read: ServerReadStub,
+    placement: ["block"],
+    editSurface: "panel",
+    label: "Builder Tabbed Content",
+    description:
+      "Builder.io docs Tabbed Content component with markdown tab bodies and raw sidecar preservation.",
+  });
+
+export const builderSymbolBlockConfig: BlockSpec<BuilderSymbolData> =
+  defineBlock<BuilderSymbolData>({
+    type: "builder-symbol",
+    schema: builderSymbolSchema,
+    mdx: builderSymbolMdx,
+    Read: ServerReadStub,
+    placement: ["block"],
+    editSurface: "panel",
+    label: "Builder Symbol",
+    description:
+      "Builder Symbol reference. The symbol stays linked by default instead of being detached.",
+  });
+
+export const builderRawBlockConfig: BlockSpec<BuilderRawBlockData> =
+  defineBlock<BuilderRawBlockData>({
+    type: "builder-raw-block",
+    schema: builderRawBlockSchema,
+    mdx: builderRawBlockMdx,
+    Read: ServerReadStub,
+    placement: ["block"],
+    editSurface: "none",
+    label: "Builder Raw Block",
+    description:
+      "Unmodeled Builder block stored in a hash-checked raw JSON sidecar.",
+  });
+
+export const builderDocsBlockConfigs: BlockSpec<any>[] = [
+  builderTextBlockConfig,
+  builderCodeBlockConfig,
+  builderCodeSnippetsV2BlockConfig,
+  builderTabbedContentBlockConfig,
+  builderSymbolBlockConfig,
+  builderRawBlockConfig,
+];
+
+export function builderSourceKindForModel(model: string) {
+  return `${BUILDER_DOCS_SOURCE_KIND_PREFIX}${model}`;
+}
+
+export function builderSourceRootPath(args: {
+  entryId: string;
+  sourceHash: string;
+  blocksHash: string;
+}) {
+  return `${args.entryId}#${args.sourceHash}#${args.blocksHash}`;
+}
+
+export function parseBuilderSourceRootPath(
+  sourceRootPath: string | null | undefined,
+) {
+  if (!sourceRootPath) return null;
+  const parts = sourceRootPath.split("#");
+  if (parts.length >= 3) {
+    const blocksHash = parts.pop();
+    const sourceHash = parts.pop();
+    const entryId = parts.join("#");
+    if (!entryId || !sourceHash || !blocksHash) return null;
+    return { entryId, sourceHash, blocksHash };
+  }
+  const hashIndex = sourceRootPath.lastIndexOf("#");
+  if (hashIndex <= 0 || hashIndex === sourceRootPath.length - 1) return null;
+  return {
+    entryId: sourceRootPath.slice(0, hashIndex),
+    sourceHash: sourceRootPath.slice(hashIndex + 1),
+    blocksHash: undefined,
+  };
+}
+
+export function modelFromBuilderSourceKind(
+  sourceKind: string | null | undefined,
+) {
+  if (!sourceKind?.startsWith(BUILDER_DOCS_SOURCE_KIND_PREFIX)) {
+    return null;
+  }
+  return sourceKind.slice(BUILDER_DOCS_SOURCE_KIND_PREFIX.length) || null;
+}