@gradial/aci 0.1.53-canary.693 → 0.1.53-canary.700

package/CHANGELOG.md

@@ -2,8 +2,87 @@
 
 ## Unreleased
 
+### Added
+
+- `AciRootProps` (the new name of `RootIdentityProps`, which stays as an
+  alias) and `aciRootAttrs(props)`, exported from `@gradial/aci`.
+- The `rootIdentity` check covers every file that calls `createRegistry(`,
+  renders a component no content places with props derived from its
+  contract's schema, and prints its coverage: components checked, and each
+  one not run with the reason.
+- Page `metadata.robots` accepts boolean `index` and `follow` directives.
+  Next and Astro emit the corresponding HTML tag. Publish excludes pages with
+  `index: false` from the release sitemap.
+
+### Migration required
+
+- **Block root identity: render the root on every render** (ADR 0051) — each
+  registered component must put `aciRootAttrs(props)` (or its rest props) on
+  its own root element, and must render that root even when its content is
+  empty; the `rootIdentity` conformance check now fails a component that
+  renders nothing. Runbook: `.agents/skills/authoring/references/sdk-migrations.md`,
+  section "Root identity (0.1.52-rc.24)".
+- **Migration required: test loader** — the `rootIdentity` check in
+  `@gradial/aci/testing` imports your component registry, so your test
+  process must be able to load TypeScript, JSX, and your `tsconfig` path
+  aliases. Run your test suite with the `tsx` loader, as the starters do:
+
+  ```json
+  "test": "node --import tsx --test tests/**/*.test.ts"
+  ```
+
+  A test process without the loader (for example `node --test` or
+  `node --test --experimental-strip-types`) now fails `npm test` with:
+
+  ```text
+  rootIdentity: cannot load src/cms/registry.ts: this test process cannot resolve the path alias "@/cms".
+    Run tests with:  node --import tsx --test
+    See the @gradial/aci CHANGELOG, "Migration required: test loader".
+  ```
+
+  If you turned the check off with `checks: { rootIdentity: false }` because
+  it could not load CSS modules or path aliases, remove that option: the
+  check now loads stylesheets, images, fonts, `next/image`, `next/link`, and
+  `next/font` as inert stubs, and reads every registry file in the site.
+
+  There is no build gate. `next build` and `astro build` do not run the
+  check. The local signal is `npm test`, where the conformance check renders
+  every registered component in isolation. A component it cannot load or
+  render is reported as not run, never as a failure.
+- Existing Astro sites must install `@gradial/aci/astro/Head` and pass resolved
+  metadata as one object through their route and layout. Next sites must upgrade
+  the SDK and rebuild. See [page metadata migration](./migrations/page-metadata-head.md).
+  Packed starter HTML checks in `make test-frontend-contract` verify the tags.
+  Sitemap exclusion can precede an SDK upgrade. Inspect the rendered preview
+  before telling an author that `noindex` is present. No platform test currently
+  enforces that check on older site builds.
+
+### Removed
+
+- `astroAuthoredBlocks` is no longer exported from `@gradial/aci/testing`:
+  the Astro `rootIdentity` check renders components instead of scanning
+  `dist/`. `findRootIdentityFailures` and `RootIdentityFailure` are no longer
+  exported either; `checkRootIdentity` and `formatRootIdentityFailures` stay.
+
 ### Changed
 
+- **`rootIdentity` reads every registry file again.** The `registry` option
+  introduced in 0.1.52-rc.33 is still accepted, but it is no longer required:
+  the check covers every file that calls `createRegistry(` (a main registry
+  and an error-page registry are both checked). Sites that added the option
+  for rc.33 need no change.
+- **Nested blocks carry their root identity in their props.** The renderers
+  now put `data-aci-block` and `data-aci-component` into the `props` of
+  every component block nested in a block's props, at any depth (a block
+  slot, or a list inside an item such as `tabs[].blocks`). A container that
+  renders child blocks from plain data with `<Component {...block.props} />`
+  now emits each child's identity on the child's root, so `rootIdentity`
+  passes for it without a site change. Containers that call
+  `renderChildren` are unchanged: the same values are applied once. A
+  container that rebuilds a child's props from selected fields (for example
+  `<Component text={block.props.text} />`) still drops the identity and is
+  still reported. The `props` of nested blocks now contain the two identity
+  keys at render time; the compiled content does not change.
 - Immutable code builds (`ACI_CODE_ARTIFACT_BUILD=1`) no longer read or compile
   authored error-page content. Native client error seats use the shipped
   default; publish resolves authored CDN error pages independently. Error

package/README.md

@@ -1,6 +1,6 @@
 # Agentic Content Infrastructure SDK
 
-`@gradial/aci` `0.1.53-canary.693` is a pre-1.0 public-surface reset for the ACI
+`@gradial/aci` `0.1.53-canary.700` is a pre-1.0 public-surface reset for the ACI
 client SDK. Breaking changes from the old `0.1.x` accidental surface are
 intentional: the root import is framework-neutral, framework runtime behavior is
 behind explicit subpaths, and the first required customer path is React/Next.
@@ -8,7 +8,7 @@ behind explicit subpaths, and the first required customer path is React/Next.
 ## Install
 
 ```bash
-npm install @gradial/aci@0.1.53-canary.693 zod@^4
+npm install @gradial/aci@0.1.53-canary.700 zod@^4
 ```
 
 ## Root Import
@@ -137,13 +137,13 @@ host bundles select and serve immutable release artifacts.
 The first RC scaffold path is Next:
 
 ```bash
-npx @gradial/aci@0.1.53-canary.693 init my-site --template next-starter
+npx @gradial/aci@0.1.53-canary.700 init my-site --template next-starter
 ```
 
 List available templates:
 
 ```bash
-npx @gradial/aci@0.1.53-canary.693 init --list
+npx @gradial/aci@0.1.53-canary.700 init --list
 ```
 
 ## Personalization: The One-Tag Install

package/dist/astro/index.js

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { contentWatchPlugin, damAssetPlugin, devRefreshPort, } from '../dev/content-watch.js';
 import { createDevRefreshBrowserScript } from '../dev/index.js';
+import { withAciRootProps, withNestedAciRootProps } from '../internal/aci-root.js';
 // ---------------------------------------------------------------------------
 // Static paths helper — for Astro SSG
 // ---------------------------------------------------------------------------
@@ -57,14 +58,10 @@ export function createRenderChildren(registry) {
         return blocks.map((block) => {
             const entry = registry.find((r) => r.id === block.component);
             const hasBlockSlots = !!entry?.contract.blockSlots;
-            const props = { ...block.props };
+            const props = withAciRootProps(withNestedAciRootProps(block.props), block);
             if (hasBlockSlots) {
                 props.renderChildren = renderChildren;
             }
-            // sdk I-19 (ADR 0051): root identity props are applied last so content
-            // props cannot overwrite them. The template spreads them onto the root.
-            props['data-aci-block'] = block.id;
-            props['data-aci-component'] = block.component;
             return { Component: entry?.component, props };
         });
     }

package/dist/cli/compile-registry.mjs

@@ -503,6 +503,14 @@ async function generatePageSchema(schemaDir, componentEntries, outDir) {
                     title: { type: 'string', minLength: 1 },
                     description: { type: 'string' },
                     canonical: { type: 'string' },
+                    robots: {
+                        type: 'object',
+                        additionalProperties: false,
+                        properties: {
+                            index: { type: 'boolean' },
+                            follow: { type: 'boolean' },
+                        },
+                    },
                 },
             },
             regions: {

package/dist/content/component-block.d.ts

@@ -0,0 +1,17 @@
+export interface ComponentBlock {
+    id: string;
+    component: string;
+}
+/**
+ * The content compiler's block predicate (`compiler.IsComponentBlock`): an
+ * explicit `$type: "component"` marker, or a non-empty string `component`
+ * with an object `props`. The shared Go/TS vector
+ * `internal/domain/content/compiler/testdata/component-block-predicate.v1.json`
+ * pins both sides.
+ */
+export declare function isComponentBlock(node: Record<string, unknown>): boolean;
+/**
+ * Every component block in a compiled page payload that carries an id,
+ * parents before children, nested slots included.
+ */
+export declare function collectComponentBlocks(payload: unknown): ComponentBlock[];

package/dist/content/component-block.js

@@ -0,0 +1,40 @@
+// The content compiler's component-block rule, shared by rendering (root
+// identity, slot resolution) and the rootIdentity conformance check.
+/**
+ * The content compiler's block predicate (`compiler.IsComponentBlock`): an
+ * explicit `$type: "component"` marker, or a non-empty string `component`
+ * with an object `props`. The shared Go/TS vector
+ * `internal/domain/content/compiler/testdata/component-block-predicate.v1.json`
+ * pins both sides.
+ */
+export function isComponentBlock(node) {
+    if (node.$type === 'component')
+        return true;
+    const props = node.props;
+    return typeof node.component === 'string' && node.component !== ''
+        && typeof props === 'object' && props !== null && !Array.isArray(props);
+}
+/**
+ * Every component block in a compiled page payload that carries an id,
+ * parents before children, nested slots included.
+ */
+export function collectComponentBlocks(payload) {
+    const out = [];
+    const walk = (node) => {
+        if (Array.isArray(node)) {
+            for (const item of node)
+                walk(item);
+            return;
+        }
+        if (typeof node !== 'object' || node === null)
+            return;
+        const record = node;
+        if (isComponentBlock(record) && typeof record.id === 'string' && record.id !== '') {
+            out.push({ id: record.id, component: typeof record.component === 'string' ? record.component : '' });
+        }
+        for (const value of Object.values(record))
+            walk(value);
+    };
+    walk(payload);
+    return out;
+}

package/dist/content/provider.d.ts

@@ -1,4 +1,4 @@
-import type { KernelPage, KernelRouteMetadata, KernelSiteConfig, RenderInput } from './types.js';
+import type { KernelPage, KernelPageRobots, KernelRouteMetadata, KernelSiteConfig, RenderInput } from './types.js';
 export interface RouteEntry {
     slug: string;
     path: string;
@@ -78,3 +78,9 @@ export interface RenderInputOptions {
 }
 export declare function loadRenderInput(provider: ContentProvider, route: string | undefined, options: RenderInputOptions): Promise<RenderInput>;
 export declare function routeMetadataForContent(siteConfig: KernelSiteConfig, page: KernelPage | null): KernelRouteMetadata;
+/**
+ * Serializes page robots directives to a `<meta name="robots">` content
+ * value, matching what Next.js emits for the same object. Returns '' when
+ * no directive is set, so templates can skip the tag.
+ */
+export declare function robotsMetaContent(robots: KernelPageRobots | undefined): string;

package/dist/content/provider.js

@@ -53,6 +53,33 @@ export function routeMetadataForContent(siteConfig, page) {
         title,
         description,
         canonical: page?.metadata?.canonical,
+        robots: pageRobots(page?.metadata?.robots),
         siteName: siteConfig.seo?.siteName || siteConfig.title
     };
 }
+function pageRobots(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const { index, follow } = value;
+    const robots = {};
+    if (typeof index === 'boolean')
+        robots.index = index;
+    if (typeof follow === 'boolean')
+        robots.follow = follow;
+    return robots.index === undefined && robots.follow === undefined ? undefined : robots;
+}
+/**
+ * Serializes page robots directives to a `<meta name="robots">` content
+ * value, matching what Next.js emits for the same object. Returns '' when
+ * no directive is set, so templates can skip the tag.
+ */
+export function robotsMetaContent(robots) {
+    if (!robots)
+        return '';
+    const directives = [];
+    if (robots.index !== undefined)
+        directives.push(robots.index ? 'index' : 'noindex');
+    if (robots.follow !== undefined)
+        directives.push(robots.follow ? 'follow' : 'nofollow');
+    return directives.join(', ');
+}

package/dist/content/resolve-slots.js

@@ -1,3 +1,4 @@
+import { isComponentBlock } from './component-block.js';
 /**
  * Shared Go/TS limit contract (sdk I-21). These values are pinned against
  * internal/domain/content/compiler/testdata/limit-conformance.v1.json by
@@ -105,10 +106,7 @@ function* walkValue(value, ancestry, state) {
         const block = (yield* walkValue(fragmentToBlock(fragment, id), chain, state));
         return Object.defineProperty(block, fragmentRootScope, { value: true });
     }
-    const isBlock = node.$type === 'component'
-        || (typeof node.component === 'string' && node.component.length > 0
-            && node.props !== null && typeof node.props === 'object' && !Array.isArray(node.props));
-    if (isBlock && ++state.blocks > MAX_EXPANDED_BLOCKS) {
+    if (isComponentBlock(node) && ++state.blocks > MAX_EXPANDED_BLOCKS) {
         throw new FragmentResolutionError(`ACI rendered page exceeds ${MAX_EXPANDED_BLOCKS} component blocks`);
     }
     const result = {};

package/dist/content/types.d.ts

@@ -37,10 +37,20 @@ export interface SiteFooter {
 }
 export type KernelFooterGroup = FooterGroup;
 export type KernelFooterColumn = FooterColumn;
+/**
+ * Page-level search engine directives. `index: false` renders `noindex` and
+ * drops the page from the release sitemap; `follow: false` renders
+ * `nofollow`. Absent keys emit nothing (crawler default: index, follow).
+ */
+export interface KernelPageRobots {
+    index?: boolean;
+    follow?: boolean;
+}
 export interface KernelPageSeo {
     title?: string;
     description?: string;
     canonical?: string;
+    robots?: KernelPageRobots;
 }
 export interface KernelPageBlock {
     $type: 'component';
@@ -108,6 +118,7 @@ export interface KernelRouteMetadata {
     title: string;
     description: string;
     canonical?: string;
+    robots?: KernelPageRobots;
     siteName: string;
 }
 export interface RenderInput<TPage extends KernelPage = KernelPage, TSiteConfig extends KernelSiteConfig = KernelSiteConfig> {

package/dist/index.d.ts

@@ -3,7 +3,8 @@ export { createRegistry, registryLookup } from './registry.js';
 export type { Registry, RegistryEntry, AnyComponent } from './registry.js';
 export { blockRef, blockRefArray } from './types/block-ref.js';
 export type { BlockRef, BlockRefEntry, BlockRefMeta, BlockRefUnion } from './types/block-ref.js';
-export type { ComponentContract, ComponentContractID, ComponentContractValidator, ComponentRegistry, ComponentValidationContext, ComponentValidationIssue, InferComponentProps, RootIdentityProps, } from './types/component.js';
+export type { ComponentContract, ComponentContractID, ComponentContractValidator, ComponentRegistry, ComponentValidationContext, ComponentValidationIssue, InferComponentProps, AciRootProps, RootIdentityProps, } from './types/component.js';
+export { aciRootAttrs } from './types/component.js';
 export { ImageSchema, imageAttrs, primaryImageSource, type Image, type ImageSource, type ImageAttrs, type ImageSlotContract, type SlotOutput, } from './types/image.js';
 export { LinkSchema, type Link, type LinkTarget, type LinkResolverContext, resolveLink, resolveHref, assertSafeHref, normalizeLinkRel, } from './types/link.js';
 export { HeadingSchema, InlineContentSchema, RichTextValueSchema, type Heading, type InlineContent, type RichTextValue, } from './types/rich-text.js';

package/dist/index.js

@@ -1,6 +1,7 @@
 export { defineComponentContract } from './define-component.js';
 export { createRegistry, registryLookup } from './registry.js';
 export { blockRef, blockRefArray } from './types/block-ref.js';
+export { aciRootAttrs } from './types/component.js';
 export { ImageSchema, imageAttrs, primaryImageSource, } from './types/image.js';
 export { LinkSchema, resolveLink, resolveHref, assertSafeHref, normalizeLinkRel, } from './types/link.js';
 export { HeadingSchema, InlineContentSchema, RichTextValueSchema, } from './types/rich-text.js';

package/dist/internal/aci-root.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/internal/aci-root.js

@@ -0,0 +1,49 @@
+import { isComponentBlock } from '../content/component-block.js';
+/**
+ * The one place a renderer seam applies the block root identity (sdk I-31,
+ * ADR 0063 §One verifier). The identity props go last, so neither content
+ * props nor tenant slotProps can overwrite them.
+ *
+ * @internal
+ */
+export function withAciRootProps(props, block) {
+    return {
+        ...props,
+        'data-aci-block': block.id,
+        'data-aci-component': block.component,
+    };
+}
+/**
+ * A copy of a block's content props in which every nested component block
+ * (the `rootIdentity` predicate, at any depth: a block slot, or a list inside
+ * an item such as `tabs[].blocks`) carries its own identity in its `props`
+ * (sdk I-31). A container that renders a child with `{...child.props}` then
+ * emits the child's identity; one that calls `renderChildren` re-applies the
+ * same values, so nothing doubles. Walk only compiled content, never tenant
+ * slotProps: those can hold React elements.
+ *
+ * @internal
+ */
+export function withNestedAciRootProps(props) {
+    return stampNested(props);
+}
+function stampNested(value) {
+    if (Array.isArray(value))
+        return value.map(stampNested);
+    if (!isPlainObject(value))
+        return value;
+    const out = {};
+    for (const [key, child] of Object.entries(value))
+        out[key] = stampNested(child);
+    if (isComponentBlock(out) && typeof out.id === 'string' && out.id !== ''
+        && typeof out.component === 'string' && isPlainObject(out.props)) {
+        out.props = withAciRootProps(out.props, { id: out.id, component: out.component });
+    }
+    return out;
+}
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}

package/dist/next/error-seat.js

@@ -1,6 +1,7 @@
 'use client';
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { Component, Fragment } from 'react';
+import { withAciRootProps, withNestedAciRootProps } from '../internal/aci-root.js';
 import { ErrorPageInstrumentation } from './error-page-instrumentation.js';
 import { ErrorPageMarker } from './error-page-marker.js';
 /** The build-time serialized payload, or null when the define is absent. */
@@ -74,13 +75,11 @@ function renderClientBlocks(blocks, registry) {
         if (!entry)
             return null;
         const Component = entry.component;
-        const componentProps = { ...block.props };
+        // sdk I-31 (ADR 0051): the error seat is an injection seam too.
+        const componentProps = withAciRootProps(withNestedAciRootProps(block.props), block);
         if (entry.contract.blockSlots) {
             componentProps.renderChildren = (children) => renderClientBlocks(children, registry);
         }
-        // sdk I-19 (ADR 0051): the error seat is an injection seam too.
-        componentProps['data-aci-block'] = block.id;
-        componentProps['data-aci-component'] = block.component;
         // Index+id composite: a repeated fragment placement repeats its authored
         // id, and sibling keys must stay unique for React reconciliation.
         return _jsx(Component, { ...componentProps }, `${index}:${block.id}`);

package/dist/next/page.js

@@ -57,6 +57,7 @@ export function createPage(registry, options) {
             title: meta.title,
             description: meta.description,
             alternates: meta.canonical ? { canonical: meta.canonical } : undefined,
+            robots: meta.robots,
             openGraph: {
                 title: meta.title,
                 description: meta.description,

package/dist/next/render.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { withAciRootProps, withNestedAciRootProps } from '../internal/aci-root.js';
 export async function renderBlock(block, registry, key, extraProps) {
     const entry = registry.find((r) => r.id === block.component);
     if (!entry) {
@@ -6,14 +7,7 @@ export async function renderBlock(block, registry, key, extraProps) {
     }
     const Component = entry.component;
     const hasBlockSlots = !!entry.contract.blockSlots;
-    // sdk I-19 (ADR 0051): root identity props are applied last so neither
-    // content props nor tenant slotProps can overwrite them.
-    const componentProps = {
-        ...block.props,
-        ...extraProps,
-        'data-aci-block': block.id,
-        'data-aci-component': block.component,
-    };
+    const componentProps = withAciRootProps({ ...withNestedAciRootProps(block.props), ...extraProps }, block);
     if (hasBlockSlots) {
         componentProps.renderChildren = (blocks) => renderBlocks(blocks, registry, extraProps);
     }

package/dist/platform-tests/adapters/astro.d.ts

@@ -0,0 +1,2 @@
+import type { LoadedSite } from './types.js';
+export declare function openAstroSite(siteDir: string, explicit?: readonly string[]): Promise<LoadedSite>;

package/dist/platform-tests/adapters/astro.js

@@ -0,0 +1,101 @@
+/**
+ * Astro adapter: renders one registered component with the Astro Container
+ * API over a Vite server that Astro configures for the site
+ * (`getViteConfig`), the way Astro documents testing components. No site
+ * build and no emitted HTML, so static and server output are covered alike.
+ * astro, its container, and vite resolve from the site, never from the SDK.
+ */
+import { createRequire } from 'node:module';
+import { join, relative, sep } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { createRenderChildren } from '../../astro/index.js';
+import { classifyLoadError, findRegistryFiles, mergeRegistries, registryExport } from './site.js';
+export async function openAstroSite(siteDir, explicit = []) {
+    // Every file that calls createRegistry(, plus any registry the site names explicitly.
+    const registryFiles = [...new Set([...findRegistryFiles(siteDir), ...explicit])].sort();
+    if (registryFiles.length === 0)
+        throw new Error('no registry file imports createRegistry from @gradial/aci');
+    const fromSite = createRequire(join(siteDir, 'package.json'));
+    const importFrom = async (resolve, specifier) => (await import(pathToFileURL(resolve(specifier)).href));
+    const { getViteConfig } = await importFrom(fromSite.resolve, 'astro/config');
+    const { experimental_AstroContainer } = await importFrom(fromSite.resolve, 'astro/container');
+    const fromAstro = createRequire(fromSite.resolve('astro/package.json'));
+    const { createServer } = await importFrom(fromAstro.resolve, 'vite');
+    const vite = await withoutContentWatch(async () => {
+        // An isolated SSR render needs no client dependency optimizer and no dev
+        // toolbar; both would otherwise run in the background past close().
+        const config = await getViteConfig({
+            logLevel: 'silent',
+            optimizeDeps: { noDiscovery: true, include: [] },
+        }, { root: siteDir, logLevel: 'silent', devToolbar: { enabled: false } })({ mode: 'development', command: 'serve' });
+        const server = (config.server ?? {});
+        return createServer({
+            ...config,
+            server: { ...server, middlewareMode: true, hmr: false, ws: false, watch: null },
+            appType: 'custom',
+        });
+    });
+    try {
+        // Every registry file is loaded through Astro's own Vite pipeline; one
+        // that cannot load is reported and does not hide the others.
+        const registries = [];
+        const unloadable = [];
+        for (const registryFile of registryFiles) {
+            const rel = relative(siteDir, registryFile);
+            try {
+                const registry = registryExport(await vite.ssrLoadModule('/' + rel.split(sep).join('/')));
+                if (registry)
+                    registries.push(registry);
+                else
+                    unloadable.push({ file: rel, reason: 'does not export the createRegistry result' });
+            }
+            catch (err) {
+                unloadable.push({ file: rel, reason: classifyLoadError(err).reason });
+            }
+        }
+        const registry = mergeRegistries(registries);
+        const container = await experimental_AstroContainer.create();
+        return {
+            registry,
+            adapter: createAstroAdapter(registry, container, siteDir),
+            unloadable,
+            close: () => vite.close(),
+        };
+    }
+    catch (err) {
+        await vite.close();
+        throw err;
+    }
+}
+function createAstroAdapter(registry, container, siteDir) {
+    const renderChildren = createRenderChildren(registry);
+    return {
+        id: 'astro',
+        async renderBlock(block) {
+            const [{ Component, props }] = renderChildren([block]);
+            if (!Component)
+                throw new Error(`no registered component "${block.component}"`);
+            return container.renderToString(Component, { props });
+        },
+        sourceFileFor(componentId) {
+            // Astro's compiler stamps every component factory with its source path.
+            const component = registry.find((entry) => entry.id === componentId)?.component;
+            return typeof component?.moduleId === 'string' ? relative(siteDir, component.moduleId) : undefined;
+        },
+    };
+}
+// withAci() recompiles content when a dev server starts; an isolated render
+// needs neither the recompile nor the watcher.
+async function withoutContentWatch(fn) {
+    const previous = process.env.ACI_DISABLE_CONTENT_WATCH;
+    process.env.ACI_DISABLE_CONTENT_WATCH = '1';
+    try {
+        return await fn();
+    }
+    finally {
+        if (previous === undefined)
+            delete process.env.ACI_DISABLE_CONTENT_WATCH;
+        else
+            process.env.ACI_DISABLE_CONTENT_WATCH = previous;
+    }
+}

package/dist/platform-tests/adapters/next.d.ts

@@ -0,0 +1,9 @@
+import type { Registry } from '../../registry.js';
+import type { FrameworkAdapter, LoadedSite } from './types.js';
+/** The react-dom/server surface the adapter needs. */
+interface ReactRuntime {
+    renderToStaticMarkup(element: unknown): string;
+}
+export declare function openNextSite(siteDir: string, explicit?: readonly string[]): Promise<LoadedSite>;
+export declare function createNextAdapter(registry: Registry, react: ReactRuntime, sourceFileFor: (componentId: string) => string | undefined): FrameworkAdapter;
+export {};