@gradial/aci 0.1.53-rc.2 → 0.1.53-rc.3

package/dist/platform-tests/sample-props.js

@@ -0,0 +1,82 @@
+/**
+ * Props for a component no content places, derived from its contract's Zod
+ * schema, so the rootIdentity check can render it without hand-written
+ * fixtures. The sample is the smallest value the schema accepts, with one
+ * item in every array so a component that reads `items[0]` still renders.
+ *
+ * Sound for rootIdentity only: the renderer injects the identity props after
+ * the content props, so whether they reach the root does not depend on what
+ * the content props are. A test about content must not use these.
+ */
+import { z } from 'zod';
+/** A props object the schema accepts, or undefined when it cannot be derived. */
+export function samplePropsFromSchema(schema) {
+    let json;
+    try {
+        json = z.toJSONSchema(schema, { target: 'draft-2020-12', unrepresentable: 'any' });
+    }
+    catch {
+        return undefined;
+    }
+    const value = sample(json, json, 0);
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+const MAX_DEPTH = 8;
+function sample(node, root, depth) {
+    if (depth > MAX_DEPTH)
+        return undefined;
+    if (node.$ref) {
+        const name = node.$ref.split('/').pop() ?? '';
+        return sample(root.$defs?.[name] ?? {}, root, depth + 1);
+    }
+    if (node.default !== undefined)
+        return node.default;
+    if (node.const !== undefined)
+        return node.const;
+    if (node.enum)
+        return node.enum[0];
+    const union = node.anyOf ?? node.oneOf;
+    if (union) {
+        // Prefer a branch that is not null, so an optional object still samples.
+        const branch = union.find((b) => b.type !== 'null') ?? union[0];
+        return sample(branch, root, depth + 1);
+    }
+    if (node.allOf)
+        return Object.assign({}, ...node.allOf.map((part) => sample(part, root, depth + 1) ?? {}));
+    const type = Array.isArray(node.type) ? node.type.find((t) => t !== 'null') : node.type;
+    switch (type) {
+        case 'string':
+            return 'sample';
+        case 'number':
+        case 'integer':
+            return 1;
+        case 'boolean':
+            return false;
+        case 'array': {
+            // A block slot renders other registered components; an empty slot is
+            // the honest sample, and the nested components are probed on their own.
+            if (!node.items || isBlockRef(node.items, root))
+                return [];
+            const item = sample(node.items, root, depth + 1);
+            return item === undefined ? [] : [item];
+        }
+        case 'object': {
+            if (isBlockRef(node, root))
+                return undefined;
+            const out = {};
+            for (const key of node.required ?? []) {
+                const value = sample(node.properties?.[key] ?? {}, root, depth + 1);
+                if (value !== undefined)
+                    out[key] = value;
+            }
+            return out;
+        }
+        default:
+            return undefined;
+    }
+}
+/** A nested block reference: an object carrying `component` and `props`. */
+function isBlockRef(node, root) {
+    const resolved = node.$ref ? root.$defs?.[node.$ref.split('/').pop() ?? ''] ?? {} : node;
+    return resolved.type === 'object' && !!resolved.properties?.component && !!resolved.properties?.props;
+}

package/dist/platform-tests/site-check.d.ts

@@ -0,0 +1,51 @@
+import type { KernelPageBlock } from '../content/types.js';
+import type { AdapterId, LoadedSite } from './adapters/types.js';
+/** A component, or a whole registry file, the isolated check could not look at. */
+export interface RootIdentityNotRun {
+    /** Component id, or the registry file when the file itself did not load. */
+    subject: string;
+    file?: string;
+    reason: string;
+}
+export interface RootIdentityFailure {
+    component: string;
+    file?: string;
+    /** What the isolated render showed. */
+    defect: string;
+    /** The fix for the site's framework. */
+    hint: string;
+}
+/** Open the site through its framework adapter, check every component, close. */
+export declare function checkSiteRootIdentity(framework: AdapterId, siteDir: string, options?: {
+    registryFiles?: readonly string[];
+}): Promise<{
+    components: number;
+    checked: number;
+    failures: RootIdentityFailure[];
+    notRun: RootIdentityNotRun[];
+}>;
+/**
+ * Render each content-backed block, then every registry entry no block
+ * covers, through the adapter, and run the rootIdentity test over each
+ * render. An entry no content places is rendered with props derived from
+ * its contract's schema (sample-props.ts), then with empty props if that
+ * render throws. One failure per component, so one per source file.
+ * Only a render that completed can fail: a component that renders without
+ * its identity is a failure; a component this isolated environment cannot
+ * render (it throws, on empty props or on real content) is not-run, because
+ * that says nothing about identity, and publish checks it in the real
+ * renderer. A render that returns empty output is a failure: a block renders
+ * its root on every render, empty content included (sdk I-31).
+ */
+export declare function findRootIdentityFailures(site: Pick<LoadedSite, 'adapter' | 'registry'>, blocks: readonly KernelPageBlock[]): Promise<{
+    failures: RootIdentityFailure[];
+    notRun: RootIdentityNotRun[];
+}>;
+/** One line of coverage, then one line per thing the check could not look at. */
+export declare function formatRootIdentityCoverage(result: {
+    components: number;
+    checked: number;
+    notRun: readonly RootIdentityNotRun[];
+}): string;
+/** The failure message: one line of what, one entry per source file, one line of why. */
+export declare function formatRootIdentityFailures(failures: readonly RootIdentityFailure[]): string;

package/dist/platform-tests/site-check.js

@@ -0,0 +1,193 @@
+/**
+ * The rootIdentity platform test over a site's registry, component by
+ * component: the conformance check calls this and hands each isolated render
+ * to the same verifier publish runs (ADR 0063 §One verifier).
+ */
+import path from 'node:path';
+import { fragmentToBlock } from '../content/resolve-slots.js';
+import { FileContentProvider } from '../providers/file.js';
+import { renderedAttributeValues, TESTS } from './index.js';
+import { samplePropsFromSchema } from './sample-props.js';
+/** Open the site through its framework adapter, check every component, close. */
+export async function checkSiteRootIdentity(framework, siteDir, options = {}) {
+    const site = framework === 'astro'
+        ? await (await import('./adapters/astro.js')).openAstroSite(siteDir, options.registryFiles)
+        : await (await import('./adapters/next.js')).openNextSite(siteDir, options.registryFiles);
+    try {
+        const { failures, notRun } = await findRootIdentityFailures(site, await compiledBlocks(siteDir));
+        const unloadable = site.unloadable.map((u) => ({ subject: u.file, file: u.file, reason: `registry did not load: ${u.reason}` }));
+        return {
+            components: site.registry.length,
+            checked: site.registry.length - notRun.length,
+            failures,
+            notRun: [...unloadable, ...notRun],
+        };
+    }
+    finally {
+        await site.close();
+    }
+}
+/**
+ * Render each content-backed block, then every registry entry no block
+ * covers, through the adapter, and run the rootIdentity test over each
+ * render. An entry no content places is rendered with props derived from
+ * its contract's schema (sample-props.ts), then with empty props if that
+ * render throws. One failure per component, so one per source file.
+ * Only a render that completed can fail: a component that renders without
+ * its identity is a failure; a component this isolated environment cannot
+ * render (it throws, on empty props or on real content) is not-run, because
+ * that says nothing about identity, and publish checks it in the real
+ * renderer. A render that returns empty output is a failure: a block renders
+ * its root on every render, empty content included (sdk I-31).
+ */
+export async function findRootIdentityFailures(site, blocks) {
+    const { adapter, registry } = site;
+    const failures = new Map();
+    const rendered = new Set();
+    const threw = new Map();
+    // Nested blocks a parent's render left without identity. Who is at fault
+    // is decided after every component has been probed on its own (below).
+    const nestedMisses = [];
+    const report = (component, defect, hint = FIX_HINTS[adapter.id]) => {
+        if (failures.has(component))
+            return;
+        const file = adapter.sourceFileFor(component);
+        failures.set(component, { component, ...(file ? { file } : {}), defect, hint });
+    };
+    const probe = async (block, propsFrom) => {
+        if (failures.has(block.component))
+            return true;
+        let html;
+        try {
+            html = await adapter.renderBlock(block);
+        }
+        catch (err) {
+            const reason = (err instanceof Error ? err.message : String(err)).split('\n')[0];
+            if (!threw.has(block.component))
+                threw.set(block.component, `render with ${PROPS_LABEL[propsFrom]} threw: ${reason}`);
+            return false;
+        }
+        rendered.add(block.component);
+        // The verifier publish runs also reports the blocks nested in this one;
+        // the root check below owns the probe's own block.
+        const outcome = TESTS.rootIdentity.run({ route: `probe:${block.id}`, payload: { blocks: [block] }, html });
+        for (const finding of outcome.findings) {
+            if (finding.blockId !== block.id)
+                nestedMisses.push({ parent: block.component, blockId: finding.blockId, component: finding.component });
+        }
+        // Locally the bar is higher than publish's substring test (sdk I-31): the
+        // component's own root element carries both identity attributes.
+        if (failures.has(block.component))
+            return true;
+        const root = rootElement(html);
+        if (!root || !attributeIs(root.attrs, 'data-aci-block', block.id)) {
+            if (root)
+                report(block.component, `data-aci-block is not on the root <${root.tag}>`);
+            else
+                report(block.component, 'renders no root element', EMPTY_RENDER_HINT);
+        }
+        else if (!attributeIs(root.attrs, 'data-aci-component', block.component)) {
+            report(block.component, `root <${root.tag}> lacks data-aci-component`);
+        }
+        return true;
+    };
+    const covered = new Set();
+    for (const block of blocks) {
+        if (!registry.some((entry) => entry.id === block.component))
+            continue;
+        covered.add(block.component);
+        await probe(block, 'content');
+    }
+    for (const entry of registry) {
+        if (covered.has(entry.id))
+            continue;
+        const blockWith = (props) => ({ $type: 'component', id: `probe-${entry.id}`, component: entry.id, props });
+        const sampled = samplePropsFromSchema(entry.contract?.props);
+        if (sampled && await probe(blockWith(sampled), 'schema'))
+            continue;
+        await probe(blockWith({}), 'empty');
+    }
+    // A nested block without identity has one of two causes. If the nested
+    // component fails its own probe, it drops the props it is given, and that
+    // failure already names it. Otherwise the component is fine and the parent
+    // rendered it without passing the identity props: the parent is at fault.
+    for (const miss of nestedMisses) {
+        if (failures.has(miss.component))
+            continue;
+        report(miss.parent, `renders its nested block "${miss.blockId}" (${miss.component}) without identity`, NESTED_HINT);
+    }
+    const notRun = [];
+    for (const [component, reason] of threw) {
+        if (rendered.has(component) || failures.has(component))
+            continue;
+        const file = adapter.sourceFileFor(component);
+        notRun.push({ subject: component, ...(file ? { file } : {}), reason });
+    }
+    return { failures: [...failures.values()], notRun };
+}
+/** One line of coverage, then one line per thing the check could not look at. */
+export function formatRootIdentityCoverage(result) {
+    const head = `rootIdentity: checked ${result.checked} of ${result.components} registered components`;
+    if (result.notRun.length === 0)
+        return head;
+    return [
+        `${head}; ${result.notRun.length} not run (publish checks them in the real renderer):`,
+        ...result.notRun.map((n) => `  ${n.file ?? n.subject}${n.file && n.file !== n.subject ? `  (${n.subject})` : ''}  ${n.reason}`),
+    ].join('\n');
+}
+/** The failure message: one line of what, one entry per source file, one line of why. */
+export function formatRootIdentityFailures(failures) {
+    const count = failures.length;
+    return [
+        `rootIdentity: ${count} component${count === 1 ? '' : 's'} do${count === 1 ? 'es' : ''} not render data-aci-block on the root element`,
+        '',
+        ...failures.flatMap((f) => [
+            `  ${f.file ?? f.component}  (${f.component})  ${f.defect}`,
+            `    ${f.hint === EMPTY_RENDER_HINT || f.hint === NESTED_HINT ? f.hint : `fix: ${f.hint}`}`,
+        ]),
+        '',
+        'A component extends AciRootProps from @gradial/aci and places {...aciRootAttrs(props)} (or its rest props) on its root element.',
+    ].join('\n');
+}
+function rootElement(html) {
+    // Hoisted resource hints (<link>, <meta>) and Astro's dev-mode markers are
+    // not the component's root element.
+    const body = html.trim().replace(/^(?:<(?:link|meta|style|script)\b[^>]*>(?:[^<]*<\/(?:style|script)>)?\s*)+/i, '');
+    const match = /^<([a-z][a-z0-9-]*)([^>]*)>/i.exec(body);
+    return match ? { tag: match[1], attrs: match[2] } : undefined;
+}
+function attributeIs(attrs, name, value) {
+    const written = new RegExp(`\\s${name}="([^"]*)"`).exec(attrs)?.[1];
+    return written !== undefined && renderedAttributeValues(value).includes(written);
+}
+const PROPS_LABEL = { content: 'its content props', schema: 'schema-derived props', empty: 'empty props' };
+const NESTED_HINT = 'this component renders its child blocks without passing them data-aci-block and data-aci-component; render children with the injected renderChildren, or spread the props of each child block onto its component (<Component {...block.props} />) so the identity the SDK put there reaches the child.';
+const EMPTY_RENDER_HINT = 'this block rendered nothing; a block must render its root element on every render, even when it has nothing to show (for example <div {...aciRootAttrs(props)} hidden />).';
+const FIX_HINTS = {
+    astro: 'put {...aciRootAttrs(Astro.props)} (or its rest props) on the root element',
+    next: 'put {...aciRootAttrs(props)} (or its rest props) on the root element',
+};
+/**
+ * Blocks from the site's compiled content, read through the manifest, when
+ * `npm run content:compile` has run. Without a manifest there are none.
+ */
+async function compiledBlocks(siteDir) {
+    const provider = new FileContentProvider(path.resolve(siteDir, process.env.ACI_CONTENT_ROOT || '.aci/compiled'));
+    let manifest;
+    try {
+        manifest = await provider.manifest();
+    }
+    catch {
+        return [];
+    }
+    const blocks = [];
+    for (const route of Object.values(manifest.routes)) {
+        const page = await provider.getPage(route.path);
+        for (const region of Object.values(page.regions ?? {}))
+            blocks.push(...region);
+    }
+    for (const id of Object.keys(manifest.fragments)) {
+        blocks.push(fragmentToBlock(await provider.getFragment(id), id));
+    }
+    return blocks;
+}

package/dist/registry.d.ts

@@ -8,7 +8,7 @@ export interface RegistryEntry {
 export type Registry = readonly RegistryEntry[];
 type ValidatedEntry<T> = T extends readonly [infer C extends ComponentContract, infer Comp] ? Comp extends (props: InferComponentProps<C>) => any ? RootIdentityChecked<C, Comp, T> : Comp extends (props: InferComponentProps<C> & infer _) => any ? RootIdentityChecked<C, Comp, T> : Comp extends new (props: InferComponentProps<C>, ...args: any[]) => any ? RootIdentityChecked<C, Comp, T> : Comp extends Record<string, any> ? T : never : never;
 type DeclaredProps<Comp> = Comp extends (props: infer P) => any ? P : Comp extends abstract new (props: infer P, ...args: any[]) => any ? P : Record<string, any>;
-type RootIdentityChecked<C extends ComponentContract, Comp, T> = 'data-aci-block' extends keyof DeclaredProps<Comp> ? 'data-aci-component' extends keyof DeclaredProps<Comp> ? T : `${ComponentContractID<C>}: props type must extend RootIdentityProps from @gradial/aci` : `${ComponentContractID<C>}: props type must extend RootIdentityProps from @gradial/aci`;
+type RootIdentityChecked<C extends ComponentContract, Comp, T> = 'data-aci-block' extends keyof DeclaredProps<Comp> ? 'data-aci-component' extends keyof DeclaredProps<Comp> ? T : `${ComponentContractID<C>}: props type must extend AciRootProps from @gradial/aci` : `${ComponentContractID<C>}: props type must extend AciRootProps from @gradial/aci`;
 type ValidatedEntries<T extends readonly (readonly [ComponentContract, AnyComponent])[]> = {
     [K in keyof T]: ValidatedEntry<T[K]>;
 };

package/dist/testing/conformance/index.d.ts

@@ -1,4 +1,5 @@
 export { conformancePreset, runConformanceChecks } from './preset.js';
 export { checkConfig, checkRegistry, checkPageEntry, checkMiddleware, checkNoFileContentProvider, checkNoCustomContent, checkNoRequestTimeAssetRoute, checkBuildSucceeds, checkContentCompile, checkSdkVersion, CHECK_REGISTRY, } from './checks.js';
-export { checkRootIdentity, findRootIdentityFailures, formatRootIdentityFailures, astroAuthoredBlocks, type RootIdentityFailure, } from './root-identity.js';
+export { checkRootIdentity } from './root-identity.js';
+export { formatRootIdentityFailures } from '../../platform-tests/site-check.js';
 export type { ConformanceFramework, ConformanceCheckName, ConformancePresetOptions, ConformanceCheckResult, ConformanceResult, ConformanceContext, ConformanceCheckFn, } from './types.js';

package/dist/testing/conformance/index.js

@@ -1,3 +1,4 @@
 export { conformancePreset, runConformanceChecks } from './preset.js';
 export { checkConfig, checkRegistry, checkPageEntry, checkMiddleware, checkNoFileContentProvider, checkNoCustomContent, checkNoRequestTimeAssetRoute, checkBuildSucceeds, checkContentCompile, checkSdkVersion, CHECK_REGISTRY, } from './checks.js';
-export { checkRootIdentity, findRootIdentityFailures, formatRootIdentityFailures, astroAuthoredBlocks, } from './root-identity.js';
+export { checkRootIdentity } from './root-identity.js';
+export { formatRootIdentityFailures } from '../../platform-tests/site-check.js';

package/dist/testing/conformance/next-stubs.d.ts

@@ -1,6 +1,15 @@
-export declare function resolve(specifier: string, context: unknown, nextResolve: (specifier: string, context: unknown) => Promise<{
-    url: string;
-}>): Promise<{
+type Resolved = {
     url: string;
     shortCircuit?: boolean;
-}>;
+    format?: string;
+};
+type Loaded = {
+    format: string;
+    source?: string;
+    shortCircuit?: boolean;
+};
+export declare function resolve(specifier: string, context: {
+    parentURL?: string;
+}, nextResolve: (specifier: string, context: unknown) => Promise<Resolved>): Promise<Resolved>;
+export declare function load(url: string, context: unknown, nextLoad: (url: string, context: unknown) => Promise<Loaded>): Promise<Loaded>;
+export {};

package/dist/testing/conformance/next-stubs.js

@@ -1,9 +1,81 @@
-// Node module customization hook for the rootIdentity check: outside Next's
-// bundler, `next/link` and `next/image` resolve to CommonJS interop objects
-// that react-dom/server cannot render. Swap them for plain-element stubs.
+// Node module customization hooks for the rootIdentity check. Outside Next's
+// bundler a real site's component graph does not load: `next/link` and
+// `next/image` resolve to CommonJS interop objects react-dom/server cannot
+// render, and stylesheets, images, fonts, and `next/font` are things only a
+// bundler understands. The check needs each component's markup, not its
+// styling, so every one of those becomes an inert module. This mirrors what
+// `next/jest` does for the same problem.
+import { existsSync, readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+const STYLE_RE = /\.(css|scss|sass|less|styl)(\?.*)?$/i;
+const ASSET_RE = /\.(png|jpe?g|gif|webp|avif|ico|bmp|svg|woff2?|ttf|otf|eot|mp4|webm|ogg|mp3|wav|pdf)(\?.*)?$/i;
+const FONT_SPECIFIERS = new Set(['next/font/google', 'next/font/local']);
+const STUB_SCHEME = 'aci-stub:';
 export async function resolve(specifier, context, nextResolve) {
     if (specifier === 'next/link' || specifier === 'next/image') {
-        return { url: new URL(`./stubs/${specifier.replace('/', '-')}.js`, import.meta.url).href, shortCircuit: true };
+        return { url: stubURL(specifier.replace('/', '-')), shortCircuit: true };
     }
+    if (FONT_SPECIFIERS.has(specifier)) {
+        // ESM named imports must exist statically, so the stub is generated with
+        // the names the importing file asks for.
+        const names = importedNames(context.parentURL, specifier);
+        return { url: `${STUB_SCHEME}font?names=${names.join(',')}`, shortCircuit: true };
+    }
+    if (STYLE_RE.test(specifier))
+        return { url: `${STUB_SCHEME}style`, shortCircuit: true };
+    if (ASSET_RE.test(specifier))
+        return { url: `${STUB_SCHEME}asset?path=${encodeURIComponent(specifier)}`, shortCircuit: true };
     return nextResolve(specifier, context);
 }
+export async function load(url, context, nextLoad) {
+    if (!url.startsWith(STUB_SCHEME))
+        return nextLoad(url, context);
+    const [kind, query = ''] = url.slice(STUB_SCHEME.length).split('?');
+    const params = new URLSearchParams(query);
+    if (kind === 'style') {
+        // A CSS module's default export maps class names to strings; any name
+        // resolves to itself. A plain stylesheet import ignores the export.
+        return module('export default new Proxy({}, { get: (_, key) => (typeof key === "string" ? key : undefined) });');
+    }
+    if (kind === 'asset') {
+        // Next's static image import shape, which also stringifies to a path.
+        const src = JSON.stringify(`/__aci_stub_asset/${params.get('path') ?? ''}`);
+        return module(`export default { src: ${src}, width: 1, height: 1, blurDataURL: '', toString() { return ${src}; } };`);
+    }
+    if (kind === 'font') {
+        const names = (params.get('names') ?? '').split(',').filter((n) => /^[A-Za-z_$][\w$]*$/.test(n));
+        const font = '() => ({ className: "", variable: "", style: {} })';
+        return module([`const font = ${font};`, 'export default font;', ...names.map((n) => `export const ${n} = font;`)].join('\n'));
+    }
+    return nextLoad(url, context);
+}
+/** A stub module: compiled `.js` in dist, `.ts` when the SDK runs from source. */
+function stubURL(name) {
+    const js = new URL(`./stubs/${name}.js`, import.meta.url);
+    return existsSync(fileURLToPath(js)) ? js.href : new URL(`./stubs/${name}.ts`, import.meta.url).href;
+}
+function module(source) {
+    return { format: 'module', source, shortCircuit: true };
+}
+/** The names `parentURL` imports from `specifier`, read from its source. */
+function importedNames(parentURL, specifier) {
+    if (!parentURL?.startsWith('file:'))
+        return [];
+    let source;
+    try {
+        source = readFileSync(fileURLToPath(parentURL), 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const names = new Set();
+    const escaped = specifier.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
+    for (const m of source.matchAll(new RegExp(`import\\s+(?:type\\s+)?(?:\\w+\\s*,\\s*)?\\{([^}]*)\\}\\s*from\\s*['"]${escaped}['"]`, 'g'))) {
+        for (const part of m[1].split(',')) {
+            const name = part.trim().split(/\s+as\s+/)[0].replace(/^type\s+/, '').trim();
+            if (name)
+                names.add(name);
+        }
+    }
+    return [...names];
+}

package/dist/testing/conformance/preset.js

@@ -30,8 +30,7 @@ const ALL_CHECKS = [
     'noCustomContent',
     'noRequestTimeAssetRoute',
     'sdkVersion',
-    // Renders every registered component (ADR 0051); on Astro it scans dist/,
-    // building first when absent.
+    // Renders every registered component in isolation (ADR 0063).
     'rootIdentity',
     // Expensive checks last — these shell out
     'contentCompile',

package/dist/testing/conformance/root-identity.d.ts

@@ -1,31 +1,2 @@
 import type { ConformanceCheckResult, ConformanceContext } from './types.js';
-import type { Registry } from '../../registry.js';
-import type { KernelPageBlock } from '../../content/types.js';
-export interface RootIdentityFailure {
-    component: string;
-    file?: string;
-    missing: string[];
-}
-/** Minimal React surface the renderer needs; injected so tests can pass fakes. */
-export interface ReactRuntime {
-    renderToStaticMarkup: (element: unknown) => string;
-}
-/**
- * Render each block through the SDK renderer and report every component
- * whose root element lacks the identity attributes. `blocks` are the blocks
- * to exercise; registry entries not covered by a block are probed with empty
- * props so an unused component cannot hide a forgotten spread.
- */
-export declare function findRootIdentityFailures(registry: Registry, blocks: readonly KernelPageBlock[], react: ReactRuntime, fileFor?: (component: string) => string | undefined): Promise<RootIdentityFailure[]>;
-/** The failure message: one line of what, the list, one line of fix. */
-export declare function formatRootIdentityFailures(failures: readonly RootIdentityFailure[], framework: 'next' | 'astro'): string;
 export declare function checkRootIdentity(ctx: ConformanceContext): Promise<ConformanceCheckResult[]>;
-/**
- * Every block the Astro scan must find in dist/: page blocks by their own id,
- * plus fragments (navbar, footer) by fragment id, which is the block id the
- * renderer synthesizes when a layout slot default places them.
- */
-export declare function astroAuthoredBlocks(contentDir: string): Array<{
-    id: string;
-    component: string;
-}>;