@elytracms/core 0.0.6

package/dist/runtime-renderer/content-client.js

@@ -0,0 +1,37 @@
+'use client';
+import { createContext, createElement, useContext } from 'react';
+const ContentClientContext = createContext(null);
+/**
+ * Provide a `ContentClient` to the rendered subtree. The renderer wraps its public
+ * composite entry points (page/composition) in this when `ctx.content` is set; a
+ * host rendering nodes directly can wrap manually.
+ */
+export function ContentClientProvider({ client, children, }) {
+    return createElement(ContentClientContext.Provider, { value: client }, children);
+}
+/**
+ * Read the injected `ContentClient` inside a component implementation (EC-191).
+ * Returns `null` when none is provided (e.g. a pure-static render) — a self-fetching
+ * component must degrade visibly, never crash, when content access is absent.
+ */
+export function useContentClient() {
+    return useContext(ContentClientContext);
+}
+/**
+ * A deterministic, in-memory `ContentClient` over fixed documents + assets (EC-191).
+ * The studio preview and tests use it so a self-fetching component renders the same
+ * content every time. `limit` is the only query knob in v1.
+ */
+export function createFixtureContentClient(fixtures) {
+    const docs = fixtures.documents ?? [];
+    const assets = new Map((fixtures.assets ?? []).map((a) => [a.id, a]));
+    return {
+        getDocument: (collection, id) => docs.find((d) => d.collection === collection && d.id === id),
+        listDocuments: (query) => {
+            const matched = docs.filter((d) => d.collection === query.collection);
+            return query.limit === undefined ? matched : matched.slice(0, query.limit);
+        },
+        resolveAsset: (id) => assets.get(id),
+    };
+}
+//# sourceMappingURL=content-client.js.map

package/dist/runtime-renderer/content-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-client.js","sourceRoot":"","sources":["../../src/runtime-renderer/content-client.tsx"],"names":[],"mappings":"AAAA,YAAY,CAAA;AAEZ,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,OAAO,CAAA;AA4ChE,MAAM,oBAAoB,GAAG,aAAa,CAAuB,IAAI,CAAC,CAAA;AAEtE;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CAAC,EACpC,MAAM,EACN,QAAQ,GAIT;IACC,OAAO,aAAa,CAAC,oBAAoB,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,QAAQ,CAAC,CAAA;AAClF,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB;IAC9B,OAAO,UAAU,CAAC,oBAAoB,CAAC,CAAA;AACzC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,0BAA0B,CAAC,QAG1C;IACC,MAAM,IAAI,GAAG,QAAQ,CAAC,SAAS,IAAI,EAAE,CAAA;IACrC,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,CAAC,QAAQ,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;IACrE,OAAO;QACL,WAAW,EAAE,CAAC,UAAU,EAAE,EAAE,EAAE,EAAE,CAC9B,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,KAAK,UAAU,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC;QAC9D,aAAa,EAAE,CAAC,KAAK,EAAE,EAAE;YACvB,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,KAAK,KAAK,CAAC,UAAU,CAAC,CAAA;YACrE,OAAO,KAAK,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAA;QAC5E,CAAC;QACD,YAAY,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;KACrC,CAAA;AACH,CAAC"}

package/dist/runtime-renderer/context.d.ts

@@ -0,0 +1,185 @@
+import type { ComponentType, ReactNode } from 'react';
+import type { BindingReference, ComponentNode } from '@elytracms/core/project-graph';
+import type { ComponentRegistry } from '@elytracms/core/component-registry';
+import type { ContentClient } from './content-client';
+/**
+ * A single repeater item scope. When set, `repeaterItem`-mode bindings resolve against
+ * `item` rather than the root data source (brief §4.6 — uniform binding model).
+ */
+export interface ItemContext {
+    item: unknown;
+    index: number;
+}
+/**
+ * Resolves a binding to a runtime value. INJECTED by the host (builder preview, export
+ * runtime, tests) so the renderer never imports `@elytracms/core/data-binding`. When an
+ * `ItemContext` is active, it is passed through so `repeaterItem` bindings resolve
+ * relative to the current item.
+ */
+export type ResolveBinding = (ref: BindingReference, item?: ItemContext) => unknown;
+/**
+ * A resolved asset, ready to hand to an image implementation (EC-195). The
+ * delivery-shaped subset of `@elytracms/core/content`'s `ResolvedAsset` the renderer
+ * needs — kept minimal so the renderer takes no dependency on the content or
+ * persistence packages. `width`/`height` are intrinsic dimensions (so the host
+ * can reserve space and `next/image` can size variants); `null` when unknown.
+ */
+export interface RenderAsset {
+    url: string;
+    width: number | null;
+    height: number | null;
+    alt: string | null;
+    /**
+     * Normalized focal point `{ x, y }` in 0–1 (EC-230) → CSS `object-position` so
+     * an art-directed image keeps its subject in frame when cropped; `null` when
+     * none. Kept as a plain pair so the renderer stays free of content/persistence.
+     */
+    focalPoint: {
+        x: number;
+        y: number;
+    } | null;
+}
+/**
+ * Resolves a stored asset id to a usable asset (EC-195), or `null` when the
+ * asset is missing (the renderer then shows the EC-015 visible fallback rather
+ * than crashing). INJECTED by the host/studio exactly like {@link ResolveBinding},
+ * so the renderer never imports the asset store or content packages.
+ */
+export type ResolveAsset = (assetId: string) => RenderAsset | null;
+/**
+ * A relation target populated to delivery shape (EC-254): identity plus the
+ * target document's resolved fields (relations inside stay `{ id, collection }`
+ * stubs at depth-1; assets inside resolve to objects). Opaque to the renderer —
+ * the host's content layer produces it, the component implementation reads its
+ * fields. The minimal structural face is `{ id, collection }`.
+ */
+export type RelationTarget = {
+    id: string;
+    collection: string;
+} & Record<string, unknown>;
+/**
+ * Resolves a composition-node `relation` PROP's stored reference to its populated
+ * target (EC-254), or `null` when the target is missing or not visible in the
+ * delivery perspective — the prop is then omitted (`one`) or dropped from the
+ * array (`many`), the same graceful degradation as a missing {@link ResolveAsset}.
+ *
+ * INJECTED by the host/studio exactly like {@link ResolveAsset}, wired to
+ * `@elytracms/core/content`'s depth-1 population (`ContentClient.resolveRelation`), so
+ * the renderer never imports the content/persistence packages. This populates the
+ * relation props of the nodes INSIDE a page's `blocks` composition — which
+ * document resolution leaves raw, never descending into a composition value.
+ */
+export type ResolveRelation = (ref: {
+    collection: string;
+    id: string;
+}) => RelationTarget | null;
+/**
+ * A resolved listing query (EC-255): the collection to list plus a closed,
+ * AND-only filter (`field → required scalar`, a relation field reduced to its
+ * target id — the v1 AD-3 vocabulary), with optional single-field sort and
+ * limit. Built by {@link listingQueryOf} from a node's `listing` manifest and
+ * its filter-source prop pick. Plain & serializable — primitives only, no
+ * content/query-package types — so a host can key a baked result by it and the
+ * renderer stays free of the content/persistence packages.
+ */
+export interface ListingQuery {
+    collection: string;
+    /** Field → required scalar; every entry must hold (AND). Empty matches all. */
+    where: Record<string, string | number | boolean>;
+    sort?: {
+        field: string;
+        direction?: 'asc' | 'desc';
+    };
+    limit?: number;
+}
+/**
+ * Resolves a {@link ListingQuery} to its matching documents in depth-1 delivery
+ * shape (EC-255), or `null` when no resolver is wired / the query is unresolvable.
+ * The first un-parked **listing binding** (AD-9): a block renders documents from a
+ * live query, not a static pick. INJECTED by the host exactly like
+ * {@link ResolveRelation} — the Next host bakes a serialized-query→docs map and
+ * the studio runs the query live — so the renderer never imports the content/query
+ * packages. A `null`/absent result degrades to the block's own empty state, the
+ * same graceful degradation as a missing relation target.
+ */
+export type ResolveListing = (query: ListingQuery) => RelationTarget[] | null;
+/**
+ * A composition renderer injected as a PROP (EC-254 transclusion) into any
+ * component that declares a `relation` prop — server-safe like the EC-189 embed
+ * renderer (a function cannot cross the RSC boundary through a `'use client'`
+ * context provider). The implementation calls it on a populated relation target's
+ * `blocks`-typed field value (e.g. `project.Reusable` rendering the referenced
+ * `reusable`'s `content`), so a referenced document's sub-blocks compose inline.
+ */
+export type RenderBlocks = (value: unknown) => ReactNode;
+/**
+ * Maps namespaced component ids to their React implementations. Implementations receive
+ * resolved props plus rendered slot children: the default slot `children` maps to React
+ * `children`, and every other named slot is passed as a prop named after the slot.
+ */
+export type ComponentImplementations = Record<string, ComponentType<Record<string, unknown>>> | Map<string, ComponentType<Record<string, unknown>>>;
+/** Everything the renderer needs to turn a node into React, with no builder-only imports. */
+export interface RenderContext {
+    /** Source of component manifests (prop schemas, slots, iterate specs). */
+    registry: ComponentRegistry;
+    /** React implementations keyed by component id. */
+    implementations: ComponentImplementations;
+    /** Injected binding resolver — the renderer's only link to data. */
+    resolveBinding: ResolveBinding;
+    /**
+     * Injected asset resolver (EC-195). When set, a static `asset`-typed prop
+     * holding an asset id resolves to a {@link RenderAsset} (url + intrinsic
+     * dimensions + alt) before reaching the implementation — so an uploaded image
+     * placed on a page renders optimized on the host. Unset → asset-typed props
+     * pass through unresolved (raw value), the same graceful degradation as a
+     * missing binding resolver.
+     */
+    resolveAsset?: ResolveAsset;
+    /**
+     * Injected relation resolver (EC-254). When set, a static `relation`-typed prop
+     * holding a `{ collection, id }` ref (the editor's document pick on a block,
+     * e.g. a ProductGrid's `products`) is populated to its depth-1 delivery shape
+     * before reaching the implementation — so a block reads `product.title` /
+     * `product.gallery[0].url`, not a raw ref. Unset → relation props pass through
+     * unresolved (raw ref), the same graceful degradation as a missing asset
+     * resolver. Wired by the host to `ContentClient.resolveRelation`.
+     */
+    resolveRelation?: ResolveRelation;
+    /**
+     * Injected listing resolver (EC-255). When set, a component whose manifest
+     * declares a `listing` (e.g. a ProductGrid keyed to a picked `category`) has
+     * its declared listing prop populated with the documents the query matches —
+     * a live, dynamic grid, not a hand-maintained static relation. Built from the
+     * node's filter-source prop via {@link listingQueryOf}; the host runs the query
+     * (Next bakes it, the studio runs it live). Unset → the listing prop is an empty
+     * array (the block shows its empty state), the same graceful degradation as a
+     * missing relation resolver. Wired by the host to `ContentClient.listDocuments`.
+     */
+    resolveListing?: ResolveListing;
+    /**
+     * Read-content client for self-fetching components (EC-191). When set, the
+     * renderer's composite entry points wrap the output in a `ContentClientProvider`
+     * so components reach it via `useContentClient()`. Host-injected (live), studio
+     * (read), or fixture-backed (tests) — components render real data uniformly.
+     */
+    content?: ContentClient;
+    /**
+     * The chain of relation-target keys (`collection:id`) currently being
+     * TRANSCLUDED through {@link RenderBlocks} (EC-254). Extended each time a
+     * component transcludes a populated relation target's blocks; a relation prop
+     * whose ref is already in this chain is NOT re-populated, breaking reference
+     * cycles (a `reusable` that transitively references itself) without looping.
+     * Empty/absent on an ordinary page render — no relation is ever skipped.
+     */
+    transcludePath?: readonly string[];
+    /** Active repeater item scope, when rendering inside a repeater item slot. */
+    item?: ItemContext;
+    /**
+     * Optional per-node decorator (brief §8.2). When set, the renderer wraps every
+     * rendered node so a host (the Builder) can attach selection markers/overlays.
+     * Unset for export/preview — zero overhead and identical output.
+     */
+    decorateNode?: (node: ComponentNode, rendered: ReactNode) => ReactNode;
+}
+/** Read an implementation regardless of whether implementations is a Map or a record. */
+export declare function getImplementation(implementations: ComponentImplementations, id: string): ComponentType<Record<string, unknown>> | undefined;

package/dist/runtime-renderer/context.js

@@ -0,0 +1,7 @@
+/** Read an implementation regardless of whether implementations is a Map or a record. */
+export function getImplementation(implementations, id) {
+    if (implementations instanceof Map)
+        return implementations.get(id);
+    return implementations[id];
+}
+//# sourceMappingURL=context.js.map

package/dist/runtime-renderer/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../../src/runtime-renderer/context.ts"],"names":[],"mappings":"AAyLA,yFAAyF;AACzF,MAAM,UAAU,iBAAiB,CAC/B,eAAyC,EACzC,EAAU;IAEV,IAAI,eAAe,YAAY,GAAG;QAAE,OAAO,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;IAClE,OAAO,eAAe,CAAC,EAAE,CAAC,CAAA;AAC5B,CAAC"}

package/dist/runtime-renderer/fallback.d.ts

@@ -0,0 +1,39 @@
+import { Component } from 'react';
+import type { ErrorInfo, ReactNode } from 'react';
+/**
+ * Visible fallback for a node whose component has no manifest or no implementation.
+ * Renders instead of throwing so a single bad reference never blanks the page (brief §4.11).
+ */
+export declare function MissingComponentFallback(props: {
+    nodeId: string;
+    componentId: string;
+}): ReactNode;
+/** Visible placeholder rendered in the position of a required slot that has no children. */
+export declare function MissingSlotPlaceholder(props: {
+    nodeId: string;
+    slot: string;
+}): ReactNode;
+/** Visible fallback for a node that threw while resolving props/bindings or while rendering. */
+export declare function RenderErrorFallback(props: {
+    nodeId: string;
+    message?: string;
+}): ReactNode;
+interface ErrorBoundaryProps {
+    nodeId: string;
+    children: ReactNode;
+}
+interface ErrorBoundaryState {
+    error: Error | null;
+}
+/**
+ * Client-side error boundary: when a descendant component throws during render, this swaps
+ * in a visible fallback rather than unmounting the whole tree. Server rendering cannot use
+ * boundaries to recover, so the renderer additionally wraps resolution in try/catch.
+ */
+export declare class RenderErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+    componentDidCatch(_error: Error, _info: ErrorInfo): void;
+    render(): ReactNode;
+}
+export {};

package/dist/runtime-renderer/fallback.js

@@ -0,0 +1,45 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Component } from 'react';
+/**
+ * Visible fallback for a node whose component has no manifest or no implementation.
+ * Renders instead of throwing so a single bad reference never blanks the page (brief §4.11).
+ */
+export function MissingComponentFallback(props) {
+    return (_jsx("div", { "data-ec-fallback": "missing-component", "data-ec-node-id": props.nodeId, "data-ec-component-id": props.componentId, children: `Missing component "${props.componentId}" (node ${props.nodeId})` }));
+}
+/** Visible placeholder rendered in the position of a required slot that has no children. */
+export function MissingSlotPlaceholder(props) {
+    return (_jsx("div", { "data-ec-fallback": "missing-slot", "data-ec-node-id": props.nodeId, "data-ec-slot": props.slot, children: `Missing required slot "${props.slot}" (node ${props.nodeId})` }));
+}
+/** Visible fallback for a node that threw while resolving props/bindings or while rendering. */
+export function RenderErrorFallback(props) {
+    return (_jsx("div", { "data-ec-fallback": "render-error", "data-ec-node-id": props.nodeId, children: props.message
+            ? `Render error in node ${props.nodeId}: ${props.message}`
+            : `Render error in node ${props.nodeId}` }));
+}
+/**
+ * Client-side error boundary: when a descendant component throws during render, this swaps
+ * in a visible fallback rather than unmounting the whole tree. Server rendering cannot use
+ * boundaries to recover, so the renderer additionally wraps resolution in try/catch.
+ */
+export class RenderErrorBoundary extends Component {
+    constructor(props) {
+        super(props);
+        this.state = { error: null };
+    }
+    static getDerivedStateFromError(error) {
+        return { error };
+    }
+    componentDidCatch(_error, _info) {
+        // Intentionally swallowed: the fallback is the user-visible signal. Hosts may add
+        // their own logging by wrapping this boundary.
+    }
+    render() {
+        if (this.state.error) {
+            return _jsx(RenderErrorFallback, { nodeId: this.props.nodeId, message: this.state.error.message });
+        }
+        return this.props.children;
+    }
+}
+//# sourceMappingURL=fallback.js.map

package/dist/runtime-renderer/fallback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fallback.js","sourceRoot":"","sources":["../../src/runtime-renderer/fallback.tsx"],"names":[],"mappings":"AAAA,YAAY,CAAA;;AAEZ,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAGjC;;;GAGG;AACH,MAAM,UAAU,wBAAwB,CAAC,KAGxC;IACC,OAAO,CACL,kCACmB,mBAAmB,qBACnB,KAAK,CAAC,MAAM,0BACP,KAAK,CAAC,WAAW,YAEtC,sBAAsB,KAAK,CAAC,WAAW,WAAW,KAAK,CAAC,MAAM,GAAG,GAC9D,CACP,CAAA;AACH,CAAC;AAED,4FAA4F;AAC5F,MAAM,UAAU,sBAAsB,CAAC,KAAuC;IAC5E,OAAO,CACL,kCAAsB,cAAc,qBAAkB,KAAK,CAAC,MAAM,kBAAgB,KAAK,CAAC,IAAI,YACzF,0BAA0B,KAAK,CAAC,IAAI,WAAW,KAAK,CAAC,MAAM,GAAG,GAC3D,CACP,CAAA;AACH,CAAC;AAED,gGAAgG;AAChG,MAAM,UAAU,mBAAmB,CAAC,KAA2C;IAC7E,OAAO,CACL,kCAAsB,cAAc,qBAAkB,KAAK,CAAC,MAAM,YAC/D,KAAK,CAAC,OAAO;YACZ,CAAC,CAAC,wBAAwB,KAAK,CAAC,MAAM,KAAK,KAAK,CAAC,OAAO,EAAE;YAC1D,CAAC,CAAC,wBAAwB,KAAK,CAAC,MAAM,EAAE,GACtC,CACP,CAAA;AACH,CAAC;AAWD;;;;GAIG;AACH,MAAM,OAAO,mBAAoB,SAAQ,SAAiD;IACxF,YAAY,KAAyB;QACnC,KAAK,CAAC,KAAK,CAAC,CAAA;QACZ,IAAI,CAAC,KAAK,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,CAAA;IAC9B,CAAC;IAED,MAAM,CAAC,wBAAwB,CAAC,KAAY;QAC1C,OAAO,EAAE,KAAK,EAAE,CAAA;IAClB,CAAC;IAEQ,iBAAiB,CAAC,MAAa,EAAE,KAAgB;QACxD,kFAAkF;QAClF,+CAA+C;IACjD,CAAC;IAEQ,MAAM;QACb,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;YACrB,OAAO,KAAC,mBAAmB,IAAC,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,GAAI,CAAA;QAC9F,CAAC;QACD,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAA;IAC5B,CAAC;CACF"}

package/dist/runtime-renderer/index.d.ts

@@ -0,0 +1,13 @@
+export declare const PACKAGE = "@elytracms/core/runtime-renderer";
+export type { ComponentImplementations, ItemContext, ListingQuery, RelationTarget, RenderAsset, RenderBlocks, RenderContext, ResolveAsset, ResolveBinding, ResolveListing, ResolveRelation, } from './context';
+export { getImplementation } from './context';
+export { evaluateCondition } from './condition';
+export { renderNode, renderComposition, renderCompositionInLayout, createEmbedRenderer, createBlocksRenderer, collectReferencedAssetIds, collectReferencedRelations, collectReferencedListings, listingQueryOf, serializeListingQuery, } from './render';
+export type { ContentClient, ContentDocumentView, ContentAssetView, ContentQuery, } from './content-client';
+export { ContentClientProvider, useContentClient, createFixtureContentClient, } from './content-client';
+export { MissingComponentFallback, MissingSlotPlaceholder, RenderErrorFallback, RenderErrorBoundary, } from './fallback';
+export type { BasePrimitives, ImageSource } from './primitives';
+export { basePrimitives, createPrimitiveRegistry, normalizeImageSource } from './primitives';
+export { GRID_MOBILE_BREAKPOINT_PX, GRID_STACK_CSS } from './primitives';
+export { Container, Stack, Grid, Text, Heading, Image, Button, Repeater, Switch, ContainerManifest, StackManifest, GridManifest, TextManifest, HeadingManifest, ImageManifest, ButtonManifest, RepeaterManifest, SwitchManifest, } from './primitives';
+export { RichText, RichTextManifest, RICH_TEXT_DEFAULT_VALUE, richTextPrimitiveRegistry, } from './rich-text';

package/dist/runtime-renderer/index.js

@@ -0,0 +1,13 @@
+export const PACKAGE = '@elytracms/core/runtime-renderer';
+export { getImplementation } from './context';
+export { evaluateCondition } from './condition';
+export { renderNode, renderComposition, renderCompositionInLayout, createEmbedRenderer, createBlocksRenderer, collectReferencedAssetIds, collectReferencedRelations, collectReferencedListings, listingQueryOf, serializeListingQuery, } from './render';
+export { ContentClientProvider, useContentClient, createFixtureContentClient, } from './content-client';
+export { MissingComponentFallback, MissingSlotPlaceholder, RenderErrorFallback, RenderErrorBoundary, } from './fallback';
+export { basePrimitives, createPrimitiveRegistry, normalizeImageSource } from './primitives';
+// Responsive defaults (EC-163): the stack-on-mobile breakpoint + emitted rule.
+export { GRID_MOBILE_BREAKPOINT_PX, GRID_STACK_CSS } from './primitives';
+export { Container, Stack, Grid, Text, Heading, Image, Button, Repeater, Switch, ContainerManifest, StackManifest, GridManifest, TextManifest, HeadingManifest, ImageManifest, ButtonManifest, RepeaterManifest, SwitchManifest, } from './primitives';
+// Rich-text content primitive (EC-159).
+export { RichText, RichTextManifest, RICH_TEXT_DEFAULT_VALUE, richTextPrimitiveRegistry, } from './rich-text';
+//# sourceMappingURL=index.js.map

package/dist/runtime-renderer/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/runtime-renderer/index.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,OAAO,GAAG,kCAAkC,CAAA;AAezD,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAE7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAE/C,OAAO,EACL,UAAU,EACV,iBAAiB,EACjB,yBAAyB,EACzB,mBAAmB,EACnB,oBAAoB,EACpB,yBAAyB,EACzB,0BAA0B,EAC1B,yBAAyB,EACzB,cAAc,EACd,qBAAqB,GACtB,MAAM,UAAU,CAAA;AASjB,OAAO,EACL,qBAAqB,EACrB,gBAAgB,EAChB,0BAA0B,GAC3B,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EACL,wBAAwB,EACxB,sBAAsB,EACtB,mBAAmB,EACnB,mBAAmB,GACpB,MAAM,YAAY,CAAA;AAGnB,OAAO,EAAE,cAAc,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AAC5F,+EAA+E;AAC/E,OAAO,EAAE,yBAAyB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AACxE,OAAO,EACL,SAAS,EACT,KAAK,EACL,IAAI,EACJ,IAAI,EACJ,OAAO,EACP,KAAK,EACL,MAAM,EACN,QAAQ,EACR,MAAM,EACN,iBAAiB,EACjB,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,aAAa,EACb,cAAc,EACd,gBAAgB,EAChB,cAAc,GACf,MAAM,cAAc,CAAA;AAErB,wCAAwC;AACxC,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,uBAAuB,EACvB,yBAAyB,GAC1B,MAAM,aAAa,CAAA"}

package/dist/runtime-renderer/primitives.d.ts

@@ -0,0 +1,85 @@
+import type { ReactNode } from 'react';
+import type { ComponentManifest } from '@elytracms/core/component-registry';
+import { ComponentRegistry } from '@elytracms/core/component-registry';
+import type { ComponentImplementations } from './context';
+/**
+ * Common shape for primitive implementations: resolved props (arbitrary keys) plus React
+ * children for the default slot and any named-slot props.
+ */
+type PrimitiveProps = Record<string, unknown> & {
+    children?: ReactNode;
+};
+declare function Container(props: PrimitiveProps): ReactNode;
+declare const ContainerManifest: ComponentManifest;
+declare function Stack(props: PrimitiveProps): ReactNode;
+declare const StackManifest: ComponentManifest;
+/**
+ * Responsive defaults (EC-163): below this viewport width a Grid's columns
+ * stack into one. 640px (the Tailwind `sm` boundary) sits between the
+ * builder's deterministic preview widths — phone (390px) stacks, tablet
+ * (768px) keeps columns.
+ */
+export declare const GRID_MOBILE_BREAKPOINT_PX = 640;
+/**
+ * The stack-on-mobile rule a stacking Grid carries with it. A **viewport media
+ * query** (not a container query), deliberately: the builder canvas renders
+ * into an iframe — a true viewport — so constraining the iframe to the phone
+ * width makes this exact rule fire in the preview; and the identical markup
+ * server-renders in `@elytracms/next` (App Router SSR) with no client JS, no
+ * extra stylesheet wiring, and no `container-type` context that every consumer
+ * would otherwise have to guarantee around every grid. The rule is emitted as
+ * an inline `<style>` child of the grid itself (style elements generate no
+ * grid item), so the behavior is self-contained wherever the implementation
+ * renders — canvas iframe portal, static markup, or RSC payload — and the
+ * `!important` lets the stylesheet rule beat the grid's own inline column
+ * template. Opted-out grids (`stackOnMobile: false`) carry neither the
+ * attribute nor the rule.
+ */
+export declare const GRID_STACK_CSS = "@media (max-width: 640px){[data-ec-grid-stack]{grid-template-columns:minmax(0,1fr) !important}}";
+declare function Grid(props: PrimitiveProps): ReactNode;
+declare const GridManifest: ComponentManifest;
+declare function Text(props: PrimitiveProps): ReactNode;
+declare const TextManifest: ComponentManifest;
+declare function Heading(props: PrimitiveProps): ReactNode;
+declare const HeadingManifest: ComponentManifest;
+/**
+ * The Image `src` may be a resolved asset (EC-195: an `asset`-typed prop the
+ * renderer resolved from an asset id) or a plain URL string. Normalize to
+ * `{ url, width, height, alt }`, letting the asset's intrinsic dimensions/alt
+ * fill in when the explicit props are unset — so an uploaded image reserves the
+ * right box (no layout shift) and carries its alt text by default.
+ */
+export interface ImageSource {
+    url: string;
+    width: number | undefined;
+    height: number | undefined;
+    alt: string;
+    /** Normalized focal point `{ x, y }` 0–1 (EC-230) → CSS object-position; null when none. */
+    focalPoint: {
+        x: number;
+        y: number;
+    } | null;
+}
+export declare function normalizeImageSource(props: PrimitiveProps): ImageSource;
+/** EC-230: a focal point becomes a CSS `object-position` string (percent of each axis). */
+export declare function focalPointObjectPosition(focalPoint: {
+    x: number;
+    y: number;
+} | null): string | undefined;
+declare function Image(props: PrimitiveProps): ReactNode;
+declare const ImageManifest: ComponentManifest;
+declare function Button(props: PrimitiveProps): ReactNode;
+declare const ButtonManifest: ComponentManifest;
+declare function Repeater(props: PrimitiveProps): ReactNode;
+declare const RepeaterManifest: ComponentManifest;
+declare function Switch(props: PrimitiveProps): ReactNode;
+declare const SwitchManifest: ComponentManifest;
+export interface BasePrimitives {
+    manifests: ComponentManifest[];
+    implementations: ComponentImplementations;
+}
+/** The platform starter components: every `base.primitives.*` manifest + implementation. */
+export declare function basePrimitives(): BasePrimitives;
+/** A `ComponentRegistry` preloaded with the primitive manifests. */
+export declare function createPrimitiveRegistry(): ComponentRegistry;
+export { Container, Stack, Grid, Text, Heading, Image, Button, Repeater, Switch, ContainerManifest, StackManifest, GridManifest, TextManifest, HeadingManifest, ImageManifest, ButtonManifest, RepeaterManifest, SwitchManifest, };