@peripheries/renderer 0.1.0

package/dist/types/core/structure.d.ts

@@ -0,0 +1,72 @@
+import type { PageCell } from './types.js';
+import { SECTION_KINDS, type LayoutNode, type SectionKind, type SectionReference } from '@peripheries/runtime';
+export { SECTION_KINDS };
+export type { LayoutNode, SectionKind, SectionReference };
+export type ResolvedLayoutNode = Omit<LayoutNode, 'children'> & {
+    children?: ResolvedLayoutNode[];
+};
+/** The page's own document, which almost every page is. */
+export declare const PAGE_DOCUMENT = "__page__";
+/** A string child is sugar for `{ cellId }`. */
+export declare function normalizeStructure(nodes: ReadonlyArray<LayoutNode | string> | null | undefined): ResolvedLayoutNode[];
+/** Siblings by `order` (default 0), stable. */
+export declare const sortByOrder: <T extends {
+    order?: number;
+}>(nodes: readonly T[]) => T[];
+export declare const isSectionNode: (n: ResolvedLayoutNode) => boolean;
+export declare const isSectionKind: (v: unknown) => v is SectionKind;
+/** A section's anchor: its cell, else its section id (the same value `DocumentSection` and the contents use). */
+export declare const sectionAnchor: (n: Pick<ResolvedLayoutNode, "cellId" | "sectionId">) => string;
+/**
+ * Hierarchical rendering when the structure wants it: `type: 'document'`, or
+ * any top-level node naming a section or carrying children. A flat list of
+ * `{ cellId }` is only an ordering hint for print, and renders flat.
+ */
+export declare function usesStructureLayout(layout: Record<string, unknown> | null | undefined): boolean;
+export type DocumentNumbering = {
+    /** Only `kind: 'article'` sections are numbered, per document, prefixed by the parent trail. */
+    numbers: Record<string, number[]>;
+    /** Structural depth of each section. */
+    levels: Record<string, number>;
+    authoredLevels: Record<string, number>;
+    titles: Record<string, string>;
+    anchors: Record<string, string>;
+};
+export type SectionNumbering = {
+    byDocument: Record<string, DocumentNumbering>;
+    unknownKinds: Array<{
+        path: string;
+        sectionId?: string;
+        kind: string;
+    }>;
+};
+export declare const numberingFor: (numbering: SectionNumbering | undefined, documentId: string | undefined) => DocumentNumbering;
+export declare function deriveSectionNumbering(structure: ReadonlyArray<LayoutNode | string> | null | undefined): SectionNumbering;
+/** Per document: every target a cell in it may cite, by role (`residue`), `label:role`, or `role#clause`. */
+export type SectionReferences = Record<string, Record<string, SectionReference>>;
+type Documents = Record<string, {
+    label?: unknown;
+}> | null | undefined;
+/** Same-page section references: a document's own roles, plus `label:role` for every uniquely labelled document. */
+export declare function deriveSectionReferences(numbering: SectionNumbering, documents: Documents): SectionReferences;
+/**
+ * Clause citations (`role#clauseId`): each section's cells' resolved
+ * `props.blocks`, where a `clause` block's items carry ids. The item's index
+ * and the clause shape let a Reference render the clause's number.
+ */
+export declare function deriveElementReferences(structure: ReadonlyArray<LayoutNode | string> | null | undefined, blocksByCellId: Readonly<Record<string, unknown>>, documents: Documents): SectionReferences;
+/** Same-page references win over data-derived ones (clauses; cross-page arrive in R5). */
+export declare function mergeSectionReferences(samePage: SectionReferences, other: SectionReferences | undefined): SectionReferences;
+export declare const referencesFor: (refs: SectionReferences | undefined, documentId: string | undefined) => Record<string, SectionReference>;
+/** What stops a structure rendering: a node naming a missing cell, or an unknown section kind (a refusal, by design). */
+export declare function structureIssues(structure: ReadonlyArray<LayoutNode | string> | null | undefined, cells: PageCell[]): string[];
+/**
+ * A node's extrinsic pagination: a page break before, keep-with-previous
+ * (break-before: avoid), or avoid breaking inside. `breakInside: 'auto'` is
+ * dropped, so a node can't relax what a component declares; a break before
+ * wins over keep-with-previous. The component's own @printPolicy joins in R5.
+ */
+export declare function nodePrintStyle(node: Pick<LayoutNode, 'print'>): {
+    breakBefore?: 'page' | 'avoid';
+    breakInside?: 'avoid';
+} | undefined;

package/dist/types/core/types.d.ts

@@ -0,0 +1,30 @@
+import type { DeclaredBinding, PageCell } from '@peripheries/runtime';
+/** One source in a DataContext: the value and its state. */
+export type DataEntry = {
+    data: unknown;
+    isLoading: boolean;
+    error: Error | null;
+};
+export type DataContext = Record<string, DataEntry>;
+export type { CellData, CellLayout, DeclaredBinding, PageCell, ResponsiveBucket } from '@peripheries/runtime';
+export type PageContent = {
+    cells?: PageCell[];
+    data?: {
+        static?: Record<string, unknown>;
+        queries?: Record<string, DeclaredBinding>;
+    };
+};
+export type ProjectPage = {
+    id: string;
+    name: string | null;
+    org_id: string | null;
+    project_id: string | null;
+    process_id: string | null;
+    graph_node_id: string | null;
+    page_type: string | null;
+    status: string | null;
+    is_template: boolean | null;
+    content: PageContent | null;
+    layout: Record<string, unknown> | null;
+    metadata: Record<string, unknown> | null;
+};

package/dist/types/core/validate.d.ts

@@ -0,0 +1,14 @@
+import type { Diagnostic } from './graph.js';
+import type { PageCell, ProjectPage } from './types.js';
+/** What validation knows about the components in scope. Stream 3 fills it from the catalog. */
+export type Catalog = {
+    components: Record<string, {
+        props_schema?: {
+            required?: readonly string[];
+        } | null;
+    } | undefined>;
+};
+/** One cell's configuration. `ids` are the page's cell ids, for `children`. */
+export declare function validateCell(cell: PageCell, catalog?: Catalog, path?: string, ids?: ReadonlySet<string>): Diagnostic[];
+/** A whole page: every cell, the page's own declarations, unique cell ids, and its document structure. */
+export declare function validatePage(page: Pick<ProjectPage, 'content' | 'layout'>, catalog?: Catalog): Diagnostic[];

package/dist/types/react/cell-states.d.ts

@@ -0,0 +1,25 @@
+import { Component, type ReactNode } from 'react';
+/** A placeholder the size of the cell's slot, so the page doesn't shift when components arrive. */
+export declare function CellPlaceholder({ state }: {
+    state: 'loading' | 'pending';
+}): import("react").JSX.Element;
+export declare function CellNotice({ state, children }: {
+    state: 'not-found' | 'error';
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** One cell's crash stays in that cell. */
+export declare class CellErrorBoundary extends Component<{
+    cellId: string;
+    children: ReactNode;
+}, {
+    error: Error | null;
+}> {
+    state: {
+        error: Error | null;
+    };
+    static getDerivedStateFromError(error: Error): {
+        error: Error;
+    };
+    componentDidCatch(error: Error): void;
+    render(): string | number | bigint | boolean | import("react").JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null | undefined;
+}

package/dist/types/react/cell-view.d.ts

@@ -0,0 +1,31 @@
+import type { LoadedBundle } from '../core/bundles/load.js';
+import { type CoreRegistry } from '../core/bundles/resolve.js';
+import type { CellData } from '../core/load-page.js';
+import { type ResolutionContext } from '../core/references.js';
+import type { StackStoreApi } from '../core/store/create-store.js';
+import type { ScopeContext } from '../core/store/scope-keys.js';
+import type { PageCell } from '../core/types.js';
+export type CellEnvironment = {
+    cellsById: Map<string, PageCell>;
+    page: ResolutionContext;
+    baseProps: unknown;
+    /** null while the page's bundles are loading (and always on the server). */
+    bundles: LoadedBundle[] | null;
+    bundleFor: (cell: PageCell) => LoadedBundle | null;
+    core: CoreRegistry;
+    navigate: (to: string) => void;
+    store: StackStoreApi;
+    scope: ScopeContext;
+    context: Record<string, unknown>;
+    /** Each cell's own data, by cell id (loadPageData). */
+    cellData?: Record<string, CellData>;
+    /** Labels the page declares, which no walk's label replaces. */
+    declared?: ReadonlySet<string>;
+};
+export declare function CellView({ cell, env, nested, injectedProps, }: {
+    cell: PageCell;
+    env: CellEnvironment;
+    nested?: boolean;
+    /** Host-derived facts merged over the resolved props (a structure's numbering, anchors, references). */
+    injectedProps?: Record<string, unknown>;
+}): import("react").JSX.Element | null;

package/dist/types/react/index.d.ts

@@ -0,0 +1,6 @@
+export { CellErrorBoundary, CellNotice, CellPlaceholder } from './cell-states.js';
+export { CellView, type CellEnvironment } from './cell-view.js';
+export { PageRenderer, type PageRendererProps, type RendererEnvironment } from './page-renderer.js';
+export { StructureView, useStructureFacts } from './structure-view.js';
+export { useCellStore } from './use-cell-store.js';
+export { useContainerSize, type Size } from './use-container-size.js';

package/dist/types/react/page-renderer.d.ts

@@ -0,0 +1,30 @@
+import type { PageBundles } from '../core/bundles/page-bundles.js';
+import { type CoreRegistry } from '../core/bundles/resolve.js';
+import type { Diagnostic } from '../core/graph.js';
+import type { PageRuntime } from '../core/load-page.js';
+import type { StackStoreApi } from '../core/store/create-store.js';
+/** What differs between the host, the component repos' harness and the agency's preview (design/renderer.md §6). */
+export type RendererEnvironment = {
+    /** Default components: what a name resolves to when no bundle in scope exports it. */
+    core: CoreRegistry;
+    navigate: (to: string) => void;
+    /** The shared store the cells' selections, viewState and live read. */
+    store: StackStoreApi;
+    /** A page configuration problem, for whoever is building the page. Default: a console warning. */
+    onDiagnostic?: (d: Diagnostic) => void;
+};
+export type PageRendererProps = {
+    runtime: PageRuntime;
+    bundles: PageBundles;
+    params: Record<string, unknown>;
+    baseProps: unknown;
+    context: Record<string, unknown>;
+    environment: RendererEnvironment;
+};
+/**
+ * One page, one renderer (design/core.md §3, stages 4–5). It fetches nothing:
+ * the page's data comes in `runtime` (loadPageData) and its bundles in
+ * `bundles`. On the server the bundles haven't imported, so each cell renders
+ * as a placeholder sized by its layout.
+ */
+export declare function PageRenderer({ runtime, bundles, params, baseProps, context, environment }: PageRendererProps): import("react").JSX.Element;

package/dist/types/react/structure-view.d.ts

@@ -0,0 +1,30 @@
+import { type LayoutNode, type ResolvedLayoutNode, type SectionNumbering, type SectionReferences } from '../core/structure.js';
+import type { PageCell } from '../core/types.js';
+import { type CellEnvironment } from './cell-view.js';
+type Derived = {
+    numbering: SectionNumbering;
+    references: SectionReferences;
+};
+/**
+ * Numbering and references for the whole page, derived once: a nested
+ * renderer that re-derived them from its subtree would number the same
+ * section differently. Clause citations read each cell's resolved `props.blocks`.
+ */
+export declare function useStructureFacts(structure: LayoutNode[], cells: PageCell[], env: CellEnvironment, documents: Record<string, {
+    label?: unknown;
+}> | undefined): Derived;
+/**
+ * The document renderer (the PWA's StructureRenderer). A node naming a cell
+ * renders it with the whole document's numbering, levels, titles, anchors and
+ * references for the node's own document, and with the node's children as the
+ * cell's child cells. A section node is a real `<section>` with a heading; a
+ * container section with no cell renders its children itself.
+ */
+export declare function StructureView({ nodes, env, facts, level, documentId, }: {
+    nodes: Array<LayoutNode | string> | ResolvedLayoutNode[];
+    env: CellEnvironment;
+    facts: Derived;
+    level?: number;
+    documentId?: string;
+}): import("react").JSX.Element;
+export {};

package/dist/types/react/use-cell-store.d.ts

@@ -0,0 +1,13 @@
+import type { StackStoreApi } from '../core/store/create-store.js';
+import type { ScopeContext } from '../core/store/scope-keys.js';
+import type { PageCell } from '../core/types.js';
+/**
+ * A cell's `selections`, `viewState` and `live` props from the shared store.
+ * The selector returns values only, compared shallowly, so a cell re-renders
+ * only when one of its own channels changes; setters are attached after.
+ */
+export declare function useCellStore(cell: PageCell, scope: ScopeContext, api: StackStoreApi): {
+    selections: import("../core/index.js").ProjectedBundle | undefined;
+    viewState: import("../core/index.js").ProjectedBundle | undefined;
+    live: import("../core/index.js").ProjectedBundle | undefined;
+};

package/dist/types/react/use-container-size.d.ts

@@ -0,0 +1,11 @@
+import { type RefObject } from 'react';
+export type Size = {
+    width: number;
+    height: number;
+};
+/**
+ * The element's measured size, in whole pixels, updated at most once per
+ * frame (design/core.md §4). Only for components that declare they need it:
+ * CSS container queries cover the rest for free.
+ */
+export declare function useContainerSize(ref: RefObject<HTMLElement | null>, enabled: boolean): Size | undefined;

package/dist/types/runtime/boot.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A classic inline script that must run before any module: it creates the
+ * promise every shim awaits. `installRuntime` resolves it.
+ */
+export declare const RUNTIME_BOOT_SCRIPT: string;
+/** The import map, serialised for `<script type="importmap">`. */
+export declare const IMPORT_MAP_JSON: string;

package/dist/types/runtime/index.d.ts

@@ -0,0 +1,4 @@
+export { IMPORT_MAP_JSON, RUNTIME_BOOT_SCRIPT } from './boot.js';
+export { buildRuntime, installRuntime, runtimeReady, type StackRuntime } from './install.js';
+export { renderShim, shimFileName } from './shims.js';
+export { getStackStore, selectors, useStackStore } from './store-export.js';

package/dist/types/runtime/install.d.ts

@@ -0,0 +1,21 @@
+import { LEGACY_RUNTIME_GLOBAL, READY_GLOBAL, RESOLVE_GLOBAL, RUNTIME_GLOBAL, type RuntimeSpecifier } from '@peripheries/runtime';
+export type StackRuntime = Record<RuntimeSpecifier, unknown> & Record<string, unknown>;
+type RuntimeGlobals = {
+    [RUNTIME_GLOBAL]?: StackRuntime;
+    [LEGACY_RUNTIME_GLOBAL]?: StackRuntime;
+    [READY_GLOBAL]?: Promise<void>;
+    [RESOLVE_GLOBAL]?: () => void;
+    require?: (specifier: string) => unknown;
+};
+export declare function buildRuntime(): StackRuntime;
+/**
+ * Puts the host's module instances where the `/_shared/*.js` shims look for
+ * them, and releases every shim waiting on the boot promise. Idempotent.
+ *
+ * Also installs a `globalThis.require` for Rolldown's CJS interop: bundles
+ * built with Vite 8 call `require('react')` from transitive CJS dependencies
+ * at module init, which throws in a browser without it. The runtime modules
+ * are already loaded, so it answers synchronously.
+ */
+export declare function installRuntime(g?: RuntimeGlobals): StackRuntime;
+export { runtimeReady } from '../core/bundles/load.js';

package/dist/types/runtime/shims.d.ts

@@ -0,0 +1,11 @@
+import { type RuntimeSpecifier } from '@peripheries/runtime';
+/** Output file name, taken from the URL the import map advertises, so the two can't disagree. */
+export declare function shimFileName(specifier: RuntimeSpecifier): string;
+/**
+ * An ESM module that forwards `specifier` to the host's instance.
+ *
+ * It awaits the ready promise the boot script creates, so a bundle imported
+ * before the host has installed its runtime waits instead of failing: the
+ * "Failed to resolve module specifier" race cannot happen (channel-06 #10).
+ */
+export declare function renderShim(specifier: RuntimeSpecifier, names: string[], hasDefault: boolean): string;

package/dist/types/runtime/store-export.d.ts

@@ -0,0 +1,18 @@
+import { type StackStoreApi } from '../core/store/create-store.js';
+import type { LiveEntry, ScopeId, StackStoreState } from '../core/store/types.js';
+export declare function getStackStore(): StackStoreApi;
+/** Subscribe a component to a slice of the shared store. */
+export declare function useStackStore<T>(selector: (state: StackStoreState) => T): T;
+export declare const selectors: {
+    selection: (scope: ScopeId, channel: string) => (s: StackStoreState) => unknown;
+    viewState: (scope: ScopeId, key: string) => (s: StackStoreState) => unknown;
+    live: <T = unknown>(channel: string) => (s: StackStoreState) => LiveEntry<T> | undefined;
+};
+export interface StoreRuntime {
+    useStore: typeof useStackStore;
+    /** The PWA's name, kept while bundles migrate. */
+    useOAStore: typeof useStackStore;
+    getStore: typeof getStackStore;
+    selectors: typeof selectors;
+}
+export declare function buildStoreRuntime(): StoreRuntime;

package/dist/types/testing/base-props.d.ts

@@ -0,0 +1,3 @@
+import type { BaseProps } from '@peripheries/runtime';
+/** What every cell gets as `baseProps` on a golden page: a synthetic viewer of the example client org. */
+export declare const FIXTURE_BASE_PROPS: BaseProps;

package/dist/types/testing/components.d.ts

@@ -0,0 +1,51 @@
+type Props = Record<string, unknown>;
+type SectionMaps = {
+    sectionNumbers?: Record<string, number[]>;
+    sectionAnchors?: Record<string, string>;
+    sectionReferences?: Record<string, {
+        number?: number[];
+        title?: string;
+        href?: string;
+        element?: {
+            index: number;
+        };
+    }>;
+};
+export declare function Masthead({ title, subtitle }: Props): import("react").JSX.Element;
+/** Authored text arrives as `children` unless the cell has child cells. */
+export declare function Prose({ children }: Props): import("react").JSX.Element;
+/** A section body in the style of acrc's DocumentSection: it owns its section's anchor. */
+export declare function DocumentSection({ sectionId, title, body, blocks, children, sectionNumbers, sectionAnchors }: Props & SectionMaps): import("react").JSX.Element;
+/** A same-page citation: `§<number> <title>`, plus the clause's letter when it names one. */
+export declare function SectionReference({ to, sectionReferences }: Props & SectionMaps): import("react").JSX.Element;
+export declare function KpiCard({ label, value, data, status }: Props): import("react").JSX.Element;
+/** Writes a shared selection. */
+export declare function OptionList({ options, selections }: Props): import("react").JSX.Element;
+/** Reads the same selection. */
+export declare function SelectionEcho({ selections }: Props): import("react").JSX.Element;
+export declare function Boom(): never;
+/** Lists a walk's nodes with their plan and data states, as a backlog or flow cell would. */
+export declare function FlowList({ nodes, edges }: Props): import("react").JSX.Element;
+export declare function Badge({ text }: Props): import("react").JSX.Element;
+export declare function ThemeProvider({ children }: {
+    children?: unknown;
+}): import("react").JSX.Element;
+/** The example client org's main lineage. */
+export declare const clientKit: {
+    Masthead: typeof Masthead;
+    Prose: typeof Prose;
+    DocumentSection: typeof DocumentSection;
+    SectionReference: typeof SectionReference;
+    KpiCard: typeof KpiCard;
+    OptionList: typeof OptionList;
+    SelectionEcho: typeof SelectionEcho;
+    FlowList: typeof FlowList;
+    Boom: typeof Boom;
+    ThemeProvider: typeof ThemeProvider;
+};
+/** The advisor org's main lineage: its own Prose (which the client's shadows) and a Badge only it has. */
+export declare const advisorKit: {
+    Prose: ({ children }: Props) => import("react").JSX.Element;
+    Badge: typeof Badge;
+};
+export {};

package/dist/types/testing/golden.d.ts

@@ -0,0 +1,51 @@
+import type { BundleRow } from '../core/bundles/load.js';
+import type { RawWalk } from '../core/graph.js';
+import type { ProjectPage } from '../core/types.js';
+export type GoldenBundle = {
+    row: Omit<BundleRow, 'components'>;
+    module: Record<string, unknown>;
+    contracts?: Record<string, unknown>;
+};
+export type GoldenPage = {
+    name: string;
+    /** What it proves, in one line. */
+    purpose: string;
+    page: ProjectPage;
+    /** The process row: its id and its `<tier>_<role>_system_id` columns. */
+    process?: {
+        id: string;
+    } & Record<string, string | null>;
+    /** walk_graph's answers, by start node (and depth, when two walks share a start); states keyed by system id. */
+    walks?: Array<{
+        start: string;
+        maxDepth?: number;
+        result: RawWalk;
+    }>;
+    /** Newest `page_cell_config` per cell node (cell_config_latest). */
+    configs?: Array<{
+        system_id: string;
+        graph_node_id: string;
+        config: Record<string, unknown>;
+    }>;
+    /** Newest state per node (node_state_latest). */
+    states?: Array<{
+        system_id: string;
+        graph_node_id: string;
+        data: unknown;
+    }>;
+    /** Live bundles the viewer can see; the page's scope picks among them. */
+    bundles: GoldenBundle[];
+    /** The org template's advisor org, whose main lineage is in scope after the page's own org. */
+    advisorOrgId?: string;
+};
+/** An SCG document: a frame cell, then sections numbered through a transparent container, a clause citation and child cells. */
+export declare const documentPage: GoldenPage;
+/** A grid dashboard fed by declared producers, with conditions, a crash, a missing component and a shared selection. */
+export declare const dashboardPage: GoldenPage;
+/** A legacy page of thin refs: configs from the cells' DSNS, their declarations hoisted, one config missing. */
+export declare const thinRefPage: GoldenPage;
+/** Every cell form on one page: inline, refs (one with a config, one falling back), a legacy thin ref, form 4, and a cross-org bundle. */
+export declare const mixedPage: GoldenPage;
+/** Walks from the page node: @_traversal with two systems, walk labels scoped to their cell, declarations winning, walks skipped when not needed. */
+export declare const walkPage: GoldenPage;
+export declare const GOLDEN_PAGES: GoldenPage[];

package/dist/types/testing/ids.d.ts

@@ -0,0 +1,14 @@
+/** A synthetic UUID: `fixtureId(7)` → `00000000-0000-4000-8000-000000000007`. */
+export declare const fixtureId: (n: number) => string;
+export declare const FIXTURE_ID: RegExp;
+/** The only org slugs and email domain a fixture may use. */
+export declare const FIXTURE_ORG_SLUGS: readonly ["example-client", "example-advisor"];
+export declare const FIXTURE_EMAIL_DOMAIN = "example.test";
+export declare const CLIENT_ORG: {
+    readonly id: string;
+    readonly slug: "example-client";
+};
+export declare const ADVISOR_ORG: {
+    readonly id: string;
+    readonly slug: "example-advisor";
+};

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

@@ -0,0 +1,5 @@
+export { FIXTURE_BASE_PROPS } from './base-props.js';
+export * as fixtureComponents from './components.js';
+export { dashboardPage, documentPage, GOLDEN_PAGES, mixedPage, thinRefPage, walkPage, type GoldenBundle, type GoldenPage } from './golden.js';
+export { ADVISOR_ORG, CLIENT_ORG, FIXTURE_EMAIL_DOMAIN, FIXTURE_ID, FIXTURE_ORG_SLUGS, fixtureId } from './ids.js';
+export { goldenBundleRow, goldenBundles, goldenGraphSource, goldenScope, type SourceCall } from './sources.js';

package/dist/types/testing/sources.d.ts

@@ -0,0 +1,25 @@
+import { type BundleRow } from '../core/bundles/load.js';
+import { type PageBundles } from '../core/bundles/page-bundles.js';
+import { type LineageRef } from '../core/bundles/refs.js';
+import type { GraphSource } from '../core/load-page.js';
+import type { PageCell } from '../core/types.js';
+import type { GoldenBundle, GoldenPage } from './golden.js';
+export type SourceCall = {
+    method: keyof GraphSource;
+    args: unknown[];
+};
+/** A GraphSource over a golden page's process, configs, states and walks. */
+export declare function goldenGraphSource(g: GoldenPage): GraphSource & {
+    calls: SourceCall[];
+};
+/** A golden bundle's registry row: every export but the bundle-level ones, under its own name. */
+export declare function goldenBundleRow(b: GoldenBundle): BundleRow;
+/** The page's bundle scope, nearest first: its own refs, then its org's main lineage, then the advisor org's. */
+export declare function goldenScope(g: GoldenPage): LineageRef[];
+/**
+ * The page's bundles, "imported" from the golden modules. `loaded: false` gives
+ * what the server renders with: the rows, and no bundle yet.
+ */
+export declare function goldenBundles(g: GoldenPage, cells: PageCell[], { loaded }?: {
+    loaded?: boolean | undefined;
+}): PageBundles;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@peripheries/renderer",
+  "version": "0.1.0",
+  "description": "The one renderer for pages of federated component bundles: a framework-free core, a React renderer, the runtime a page boots with, and golden pages for testing.",
+  "type": "module",
+  "sideEffects": [
+    "*.css"
+  ],
+  "exports": {
+    "./core": {
+      "types": "./dist/types/core/index.d.ts",
+      "default": "./dist/core.js"
+    },
+    "./react": {
+      "types": "./dist/types/react/index.d.ts",
+      "default": "./dist/react.js"
+    },
+    "./runtime": {
+      "types": "./dist/types/runtime/index.d.ts",
+      "default": "./dist/runtime.js"
+    },
+    "./testing": {
+      "types": "./dist/types/testing/index.d.ts",
+      "default": "./dist/testing.js"
+    },
+    "./styles.css": "./dist/styles.css"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@peripheries/runtime": "0.1.0"
+  },
+  "peerDependencies": {
+    "@tanstack/react-store": "0.11.1",
+    "@tanstack/store": "0.11.1",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "zustand": "^5.0.0"
+  },
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/peripheries-clients/peripheries-stack.git",
+    "directory": "packages/renderer"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}