@avocadostudio-ai/orchestrator-core 0.1.0

package/dist/migration/migration-prompt.d.ts

@@ -0,0 +1,7 @@
+/**
+ * System prompt for the migration agent (Claude Agent SDK version).
+ *
+ * Claude uses built-in Write/Edit/Bash tools to create block files directly,
+ * plus custom MCP tools for web scraping, design token extraction, and theming.
+ */
+export declare function buildMigrationSystemPrompt(): string;

package/dist/migration/migration-prompt.js

@@ -0,0 +1,197 @@
+/**
+ * System prompt for the migration agent (Claude Agent SDK version).
+ *
+ * Claude uses built-in Write/Edit/Bash tools to create block files directly,
+ * plus custom MCP tools for web scraping, design token extraction, and theming.
+ */
+import { getAllBlockMeta } from "@avocadostudio-ai/shared";
+export function buildMigrationSystemPrompt() {
+    // Build block catalog from registry
+    const allMeta = getAllBlockMeta();
+    const blockCatalog = Object.entries(allMeta)
+        .map(([type, meta]) => {
+        const category = meta.category ?? "content";
+        const chrome = meta.chrome ? " (chrome — structurally pinned)" : "";
+        const fields = Object.entries(meta.fields)
+            .map(([key, f]) => `    ${key}: ${f.kind}${f.label ? ` — ${f.label}` : ""}`)
+            .join("\n");
+        const lists = meta.listFields
+            ? Object.entries(meta.listFields)
+                .map(([key, l]) => {
+                const itemFields = Object.entries(l.itemFields)
+                    .map(([k, f]) => `      ${k}: ${f.kind}${f.label ? ` — ${f.label}` : ""}`)
+                    .join("\n");
+                return `    ${key} (list)${l.label ? ` — ${l.label}` : ""}:\n${itemFields}`;
+            })
+                .join("\n")
+            : "";
+        return `  ${type} [${category}]${chrome}\n${fields}${lists ? "\n" + lists : ""}`;
+    })
+        .join("\n\n");
+    return `You are a website migration agent. Your job is to analyze an external website and recreate it using a block-based site editor.
+
+You have both **custom migration tools** (for web scraping and design analysis) and **built-in file tools** (Read, Write, Edit, Bash, Glob) for creating block code directly.
+
+## Workflow
+
+Follow these steps in order:
+
+1. **Generate section specs** — Use \`generate_page_specs\` to scrape the source page and get detailed section-by-section specs with exact computed CSS styles, DOM structure, verbatim content, and design notes. This also returns design tokens and theme variables.
+
+2. **Analyze specs & plan** — Review each section spec:
+   - \`structure.pattern\` tells you the layout (e.g. "3-column grid of 4 items", "side-by-side layout")
+   - \`structure.interactionModel\` tells you if it's static, accordion, tabs, carousel, or scroll-driven
+   - \`styles\` gives you exact computed CSS for container, heading, body text, repeated items, and CTAs
+   - \`content\` has the verbatim text, images, and links
+   - \`suggestedBlockType\` is a heuristic hint — override it if the spec data suggests a better fit
+
+3. **Map to blocks or create custom** — For each section:
+   - If it clearly matches an existing block type → use it with props derived from \`content\`
+   - If the layout is unique or doesn't map well → **create a custom block** using the Write tool. Use the exact CSS from \`styles.container\`, \`styles.repeatedItem\`, etc. to reproduce the visual design faithfully.
+
+4. **Download key images** — Use \`download_remote_image\` for hero images, logos, and key visuals found in spec \`content.images\`.
+
+5. **Apply theme** — Use \`apply_theme\` with the \`themeVariables\` returned by \`generate_page_specs\`.
+
+6. **Summary** — Summarize what was migrated, which blocks were used or created, and any gaps.
+
+## Available Block Types
+
+${blockCatalog}
+
+## Section Spec Reference
+
+Each section spec from \`generate_page_specs\` contains:
+
+\`\`\`
+content:
+  headings[]       — h1-h6 text, verbatim
+  paragraphs[]     — paragraph text
+  images[]         — src, alt, isBackground
+  links[]          — href, text
+  lists[][]        — list items
+
+structure:
+  pattern          — "3-column grid of 4 items", "side-by-side layout", etc.
+  repeatCount      — number of repeated child elements
+  repeatSignature  — tag structure (e.g. "img + h3 + p + a")
+  elementCount     — total DOM elements
+  interactionModel — static | accordion | tabs | carousel | scroll-driven
+
+styles:
+  container        — section root computed CSS (backgroundColor, display, gap, padding, etc.)
+  heading          — first heading computed CSS (fontSize, fontWeight, fontFamily, color, etc.)
+  bodyText         — first paragraph computed CSS
+  repeatedItem     — first repeated child computed CSS (if repeatCount > 0)
+  cta              — first button/link with background computed CSS
+
+designNotes:
+  backgroundColor, textColor, headingFont, headingSize, layout,
+  hasGradient, hasShadow, borderRadius
+\`\`\`
+
+When creating custom blocks, use the exact CSS values from \`styles\` to match the source design.
+The \`styles.repeatedItem\` + \`structure.repeatSignature\` define the fields a custom block needs.
+
+**Important:** If a section doesn't map well to any existing block, create a new custom block rather than forcing a bad match. Use the computed CSS values from the spec to reproduce the visual design.
+
+## Creating Custom Blocks (Write Tool)
+
+When a section needs a custom block type, create it by writing files to \`apps/site/blocks/{kebab-name}/\`. Each block needs 3 files:
+
+### 1. Schema file: \`apps/site/blocks/{kebab-name}/schema.ts\`
+
+\`\`\`typescript
+import { z } from "zod"
+import { registerBlock } from "@avocadostudio-ai/shared"
+
+registerBlock("PascalName", {
+  schema: z.object({
+    title: z.string().min(1),
+    description: z.string().optional(),
+    // Use z.array(z.object({...})).min(1) for list fields
+  }),
+  meta: {
+    displayName: "Pascal Name",
+    description: "Block description.",
+    category: "content",  // content | media | layout | conversion
+    fields: {
+      title: { kind: "text", label: "Title" },
+      description: { kind: "text", label: "Description", multiline: true },
+    },
+    // For list fields:
+    // listFields: {
+    //   items: { label: "Items", itemFields: { title: { kind: "text", label: "Title" } } }
+    // }
+  }
+})
+
+export function pascalNameDefaultProps(): Record<string, unknown> {
+  return { title: "Default title", description: "Default description" }
+}
+\`\`\`
+
+### 2. Renderer file: \`apps/site/blocks/{kebab-name}/renderer.tsx\`
+
+\`\`\`tsx
+import type { JSX } from "react"
+
+export function PascalName(props: Record<string, unknown>): JSX.Element {
+  const title = String(props.title ?? "")
+  return (
+    <section className="kebab-name">
+      <div className="section__inner">
+        <h2 data-editable-target="title" data-editable-target-label="title" data-editable-label="title">
+          {title}
+        </h2>
+      </div>
+    </section>
+  )
+}
+\`\`\`
+
+### 3. Styles file: \`apps/site/blocks/{kebab-name}/styles.css\`
+
+Use CSS variables from the design system:
+- Colors: \`--brand\`, \`--heading\`, \`--body\`, \`--body-secondary\`, \`--text-200\`, \`--section-bg\`, \`--surface\`, \`--border\`
+- Use BEM-style class names: \`.kebab-name\`, \`.kebab-name__element\`
+- Include responsive breakpoint: \`@media (max-width: 900px)\`
+
+### 4. Update manifest: \`apps/site/blocks/index.ts\`
+
+After creating block files, update or create the manifest:
+
+\`\`\`typescript
+// Auto-generated by migration agent — do not edit manually
+import "./pricing-table/schema.ts"
+import "./team-grid/schema.ts"
+export { PricingTable } from "./pricing-table/renderer.tsx"
+export { TeamGrid } from "./team-grid/renderer.tsx"
+\`\`\`
+
+### 5. Verify
+
+After writing block files, run \`pnpm typecheck\` via Bash to verify the generated code compiles. If there are errors, use the Edit tool to fix them.
+
+## Reading Reference Blocks
+
+Before creating custom blocks, read an existing block as a reference pattern:
+- Schema: \`packages/shared/src/blocks/quote.ts\` or \`packages/shared/src/blocks/feature-grid.ts\` (for list-based blocks)
+- Renderer: \`packages/blocks/src/blocks/quote/renderer.tsx\` or \`packages/blocks/src/blocks/feature-grid/renderer.tsx\`
+- Styles: \`packages/blocks/src/blocks/quote/styles.css\`
+
+## Image Handling
+
+- Download important images (hero backgrounds, logos, product images) using \`download_remote_image\`.
+- Use the returned \`localUrl\` in block props instead of the original remote URL.
+- Skip small decorative images and icons.
+
+## Theme Matching
+
+After analyzing the source site's design tokens, use \`apply_theme\` to set CSS variable overrides. Focus on:
+- Brand/accent color → \`--brand\`
+- Background colors → \`--bg-0\`, \`--bg-100\`
+- Text colors → \`--text-100\`, \`--heading\`, \`--body\`
+- Font families (if distinctive)
+`;
+}

package/dist/migration/migration-tools.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Migration tools for the sites-agent — higher-level alternatives to scrape_url
+ * that include computed style extraction and section spec generation.
+ *
+ * These give the LLM rich, block-type-agnostic data so it can decide:
+ * use an existing block type OR spawn block-coder for a custom one.
+ */
+import { z } from "zod";
+export declare const MIGRATION_DEBUG_DIR: string;
+/** Save a base64 screenshot to disk for post-run analysis. */
+export declare function saveScreenshot(label: string, base64: string, url: string): Promise<string>;
+/** Save full scrape debug data (specs, tokens, nav) to JSON for analysis. */
+export declare function saveScrapeDebug(url: string, data: Record<string, unknown>): Promise<string>;
+/** Returns all migration tools for the sites-agent MCP server. */
+export declare function createMigrationTools(): import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
+    url: z.ZodString;
+}>[];

package/dist/migration/migration-tools.js

@@ -0,0 +1,159 @@
+/**
+ * Migration tools for the sites-agent — higher-level alternatives to scrape_url
+ * that include computed style extraction and section spec generation.
+ *
+ * These give the LLM rich, block-type-agnostic data so it can decide:
+ * use an existing block type OR spawn block-coder for a custom one.
+ */
+import { tool } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+import { writeFile, mkdir } from "node:fs/promises";
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+import { scrapeFullPage, buildPageSpecs, extractDesignTokens, mapToThemeVariables, augmentThemeFromComputedStyles, } from "@avocadostudio-ai/migration-sdk";
+import { getCachedScrape, setCachedScrape } from "./scrape-cache.js";
+export const MIGRATION_DEBUG_DIR = resolve(homedir(), ".data/migration-debug");
+function debugFilename(url, suffix) {
+    const slug = url.replace(/https?:\/\//, "").replace(/[^a-z0-9]+/gi, "-").slice(0, 60);
+    const ts = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    return `${ts}_${slug}_${suffix}`;
+}
+/** Save a base64 screenshot to disk for post-run analysis. */
+export async function saveScreenshot(label, base64, url) {
+    await mkdir(MIGRATION_DEBUG_DIR, { recursive: true });
+    const filepath = resolve(MIGRATION_DEBUG_DIR, debugFilename(url, `${label}.jpg`));
+    await writeFile(filepath, Buffer.from(base64, "base64"));
+    return filepath;
+}
+/** Save full scrape debug data (specs, tokens, nav) to JSON for analysis. */
+export async function saveScrapeDebug(url, data) {
+    await mkdir(MIGRATION_DEBUG_DIR, { recursive: true });
+    const filepath = resolve(MIGRATION_DEBUG_DIR, debugFilename(url, "specs.json"));
+    await writeFile(filepath, JSON.stringify(data, null, 2), "utf-8");
+    return filepath;
+}
+/**
+ * Primary migration tool: scrape a URL and generate block-type-agnostic
+ * section specs with exact computed CSS styles, DOM structure, content,
+ * and design notes.
+ */
+const generatePageSpecsTool = tool("generate_page_specs", `Scrape a URL and generate detailed section specs with exact computed CSS styles, DOM structure, content, and design notes.
+Returns block-type-agnostic specs — use them to decide which sections map to existing blocks and which need custom blocks via block-coder.
+
+Each spec contains:
+- content: verbatim text, images, links from the source section
+- structure: layout pattern, repeat count/signature, interaction model (static/accordion/tabs/carousel)
+- styles: exact computed CSS for container, heading, body text, repeated items, CTA buttons
+- designNotes: colors, fonts, layout summary, gradients, shadows
+- suggestedBlockType: heuristic hint (not authoritative — you decide)
+
+Also returns designTokens (colors, fonts, radii) and themeVariables (CSS custom property mapping).`, { url: z.string().url().describe("The URL to scrape and analyze") }, async ({ url }) => {
+    try {
+        const cached = !!getCachedScrape(url);
+        const t0 = Date.now();
+        let scrape = getCachedScrape(url);
+        if (!scrape) {
+            console.log(`[generate_page_specs] Scraping ${url}...`);
+            scrape = await scrapeFullPage(url);
+            setCachedScrape(url, scrape);
+        }
+        const scrapeMs = Date.now() - t0;
+        const specs = buildPageSpecs(scrape);
+        const tokens = extractDesignTokens(scrape.content.css, scrape.resolvedCssVars);
+        let theme = mapToThemeVariables(tokens);
+        // Augment theme with actual computed CSS values from section specs.
+        // Computed styles (getComputedStyle) are far more reliable than CSS regex,
+        // especially for CMS sites using CSS variables, inline styles, or shadow DOM.
+        const sectionStyleData = specs
+            .filter(s => Object.keys(s.styles.container).length > 0)
+            .map(s => s.styles);
+        if (sectionStyleData.length > 0) {
+            // Collect hover states from interaction sweep for brand-hover extraction
+            const hoverStates = scrape.interactionStates
+                ?.flatMap(is => is.states)
+                .filter(s => s.trigger === "hover")
+                .map(s => ({ triggerTarget: s.triggerTarget, changedStyles: s.changedStyles }));
+            theme = augmentThemeFromComputedStyles(theme, sectionStyleData, hoverStates);
+        }
+        // Override fonts with computed values (more reliable than CSS regex)
+        if (scrape.computedFonts) {
+            if (scrape.computedFonts.heading)
+                theme["--font-heading"] = scrape.computedFonts.heading + ", sans-serif";
+            if (scrape.computedFonts.body)
+                theme["--font-body"] = scrape.computedFonts.body + ", sans-serif";
+        }
+        const totalMs = Date.now() - t0;
+        // Log summary
+        console.log(`[generate_page_specs] ${url} → ${specs.length} sections, ` +
+            `${tokens.colors.length} colors, ${tokens.fonts.length} fonts | ` +
+            `${cached ? "cached" : `scraped in ${scrapeMs}ms`} | total ${totalMs}ms`);
+        for (const spec of specs) {
+            const blockHint = spec.suggestedBlockType ?? "unknown";
+            const conf = spec.suggestedConfidence.toFixed(2);
+            const pattern = spec.structure.pattern;
+            const repeat = spec.structure.repeatCount > 0 ? ` (${spec.structure.repeatCount}x ${spec.structure.repeatSignature ?? "?"})` : "";
+            const headings = spec.content.headings.map(h => h.text).join(", ").slice(0, 80);
+            console.log(`  [${spec.sectionIndex}] ${blockHint} (${conf}) — ${pattern}${repeat}` +
+                (headings ? ` — "${headings}"` : ""));
+        }
+        // Save debug artifacts to ~/.data/migration-debug/
+        const debugData = {
+            url,
+            scrapedAt: new Date().toISOString(),
+            scrapeMs,
+            totalMs,
+            cached,
+            pageTitle: scrape.content.title,
+            pageDescription: scrape.content.metaDescription,
+            sectionCount: specs.length,
+            visualSectionCount: scrape.visualSections?.length ?? 0,
+            specs,
+            designTokens: tokens,
+            themeVariables: theme,
+            nav: scrape.nav,
+            embeds: scrape.embeds,
+            videos: scrape.videos,
+            imageCompositions: scrape.imageCompositions?.length ? scrape.imageCompositions : undefined,
+            computedFonts: scrape.computedFonts,
+        };
+        // Fire-and-forget debug artifact saves — non-critical, don't block tool return
+        const debugWrites = [];
+        if (scrape.screenshot)
+            debugWrites.push(saveScreenshot("desktop", scrape.screenshot.base64, url));
+        if (scrape.mobileScreenshot)
+            debugWrites.push(saveScreenshot("mobile", scrape.mobileScreenshot.base64, url));
+        debugWrites.push(saveScrapeDebug(url, debugData));
+        Promise.all(debugWrites)
+            .then(files => console.log(`[generate_page_specs] Debug artifacts saved: ${files.map(f => f.split("/").pop()).join(", ")}`))
+            .catch(e => console.warn(`[generate_page_specs] Failed to save debug artifacts: ${e instanceof Error ? e.message : String(e)}`));
+        const result = {
+            pageTitle: scrape.content.title,
+            pageDescription: scrape.content.metaDescription,
+            sectionCount: specs.length,
+            specs,
+            designTokens: tokens,
+            themeVariables: theme,
+            nav: scrape.nav,
+        };
+        const content = [
+            { type: "text", text: JSON.stringify(result, null, 2) },
+        ];
+        // Include screenshots so the LLM can visually analyze sections
+        if (scrape.screenshot)
+            content.push({ type: "image", data: scrape.screenshot.base64, mimeType: "image/jpeg" });
+        if (scrape.mobileScreenshot)
+            content.push({ type: "image", data: scrape.mobileScreenshot.base64, mimeType: "image/jpeg" });
+        return { content };
+    }
+    catch (e) {
+        console.error(`[generate_page_specs] ERROR for ${url}:`, e instanceof Error ? e.message : String(e));
+        return {
+            content: [{ type: "text", text: `Error generating page specs: ${e instanceof Error ? e.message : String(e)}` }],
+            isError: true,
+        };
+    }
+}, { annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true } });
+/** Returns all migration tools for the sites-agent MCP server. */
+export function createMigrationTools() {
+    return [generatePageSpecsTool];
+}

package/dist/migration/scrape-cache.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Shared scrape cache — avoids redundant Playwright launches (~5-15s each)
+ * when both scrape_url and generate_page_specs tools are called for the same URL.
+ *
+ * Capped at 10 entries with LRU eviction — each FullPageScrape can be several MB.
+ */
+import type { FullPageScrape } from "@avocadostudio-ai/migration-sdk";
+export declare function getCachedScrape(url: string): FullPageScrape | undefined;
+export declare function setCachedScrape(url: string, scrape: FullPageScrape): void;

package/dist/migration/scrape-cache.js

@@ -0,0 +1,19 @@
+/**
+ * Shared scrape cache — avoids redundant Playwright launches (~5-15s each)
+ * when both scrape_url and generate_page_specs tools are called for the same URL.
+ *
+ * Capped at 10 entries with LRU eviction — each FullPageScrape can be several MB.
+ */
+const MAX_ENTRIES = 10;
+const cache = new Map();
+export function getCachedScrape(url) {
+    return cache.get(url);
+}
+export function setCachedScrape(url, scrape) {
+    if (cache.size >= MAX_ENTRIES) {
+        const oldest = cache.keys().next().value;
+        if (oldest)
+            cache.delete(oldest);
+    }
+    cache.set(url, scrape);
+}

package/dist/nlp/deterministic-planner-context.d.ts

@@ -0,0 +1,141 @@
+import type { PageDoc } from "@avocadostudio-ai/shared";
+import type { ChatAttachment } from "./intent-detection.ts";
+export declare function readPathValue(root: unknown, path: string): unknown;
+/**
+ * Given block props and an editablePath targeting an alt-text field,
+ * resolve the companion image URL for vision-powered alt text generation.
+ *
+ * Examples:
+ *  - "imageAlt"           → props.imageUrl
+ *  - "cards[2].imageAlt"  → props.cards[2].imageUrl
+ *  - "items[0].image.alt" → props.items[0].image.src
+ */
+export declare function resolveImageUrlForAltField(blockProps: Record<string, unknown>, editablePath: string): string | undefined;
+/**
+ * Fetch an image URL and return base64 + media type.
+ * For localhost URLs the AI APIs can't reach, we fetch locally.
+ * For remote URLs, returns null so the caller can use the URL directly.
+ */
+export declare function fetchImageAsBase64(url: string): Promise<{
+    base64: string;
+    mediaType: string;
+} | null>;
+export type ResolvedLlmAttachment = {
+    kind: "image" | "pdf";
+    mediaType: string;
+    base64: string;
+    name?: string;
+};
+/**
+ * Fetch each chat attachment's bytes and return base64 + media type for the
+ * planner to embed as native multimodal content blocks. We always base64 the
+ * bytes (rather than pass a URL) so all three providers behave uniformly —
+ * OpenAI's `file` part requires inline data, and dev URLs (localhost) aren't
+ * reachable by the model APIs anyway. URLs are SSRF-allowlisted, fetches are
+ * bounded by a timeout and a byte cap, and anything that fails is skipped.
+ */
+export declare function resolveAttachmentsForLlm(attachments: ChatAttachment[] | undefined): Promise<ResolvedLlmAttachment[]>;
+export declare function selectedBlockSnapshot(args: {
+    currentPage: PageDoc;
+    activeBlockId?: string;
+    activeEditablePath?: string;
+}): {
+    id: string;
+    type: import("@avocadostudio-ai/shared").BlockType;
+    props: Record<string, unknown>;
+    selectedEditablePath: string | null;
+    selectedEditableValue: {} | null;
+} | null;
+export declare function arrayPropLengths(props: Record<string, unknown>): Record<string, {
+    length: number;
+    labels?: string[];
+}>;
+export declare function pageIntentSummary(args: {
+    slug: string;
+    currentPage: PageDoc;
+}): string;
+export declare function plannerContextPack(args: {
+    session: string;
+    slug: string;
+    message: string;
+    currentPage: PageDoc;
+    activeBlockId?: string;
+    activeBlockType?: string;
+    activeEditablePath?: string;
+    includeFullProps?: boolean;
+    attachments?: ChatAttachment[];
+}): {
+    selected: {
+        blockId: string | null;
+        blockType: string | null;
+        editablePath: string | null;
+        block: {
+            id: string;
+            type: import("@avocadostudio-ai/shared").BlockType;
+            props: Record<string, unknown>;
+            selectedEditablePath: string | null;
+            selectedEditableValue: {} | null;
+        } | null;
+        imageUrlForVision: string | null;
+    };
+    neighbors: {
+        previous: {
+            id: string;
+            type: import("@avocadostudio-ai/shared").BlockType;
+        } | null;
+        next: {
+            id: string;
+            type: import("@avocadostudio-ai/shared").BlockType;
+        } | null;
+    };
+    pageOutline: {
+        id: string;
+        type: import("@avocadostudio-ai/shared").BlockType;
+        props: Record<string, unknown>;
+        arrayProps: Record<string, {
+            length: number;
+            labels?: string[];
+        }>;
+    }[];
+    pageMeta: import("@avocadostudio-ai/shared").PageMeta | null;
+    pageIntent: string;
+    recentSuccessfulEdits: {
+        at: string;
+        summary: string;
+        ops: ("update_props" | "create_page" | "add_block" | "remove_block" | "move_block" | "duplicate_block" | "add_item" | "update_item" | "remove_item" | "move_item" | "reorder_items" | "reorder_blocks" | "rename_page" | "remove_page" | "move_page" | "duplicate_page" | "update_page_meta" | "update_site_config" | "update_theme")[];
+    }[];
+    resolvedReferences: {
+        target: {
+            id: string;
+            type: import("@avocadostudio-ai/shared").BlockType;
+        } | null;
+        anchor: {
+            id: string;
+            type: import("@avocadostudio-ai/shared").BlockType;
+        } | null;
+        mentionedBlocks: {
+            id: string;
+            type: import("@avocadostudio-ai/shared").BlockType;
+            reason: string;
+        }[];
+    };
+    siteConfig: {
+        name: string | null;
+        logo: string | null;
+        navLabels: Record<string, string>;
+        navGroups: Record<string, string[]>;
+        defaultNavLabels: Record<string, string>;
+        editPath: string;
+    };
+    attachments?: {
+        id: string;
+        kind: "image" | "pdf";
+        url: string;
+        mimeType: string;
+        name?: string | undefined;
+        bytes?: number | undefined;
+    }[] | undefined;
+    route: string;
+    pageRoutes: string[];
+    blockCount: number;
+};