@texuli/blocks 0.0.0-stage → 0.1.0-next.0

package/dist/media/engine.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `@texuli/blocks/media/engine` — Svelte-free media family guards, labels and URL resolve.
+ */
+import type { Block, FieldIssue, FigureBlock, GalleryBlock, ImageBlock, VideoBlock } from '../core/index.js';
+import type { MediaBlockLabelOverrides } from './labels.js';
+export { checkMediaBlock, type MediaBlockCheck } from './check.js';
+export { DEFAULT_MEDIA_BLOCK_LABELS, type MediaBlockLabelOverrides, type MediaBlockLabels, resolveMediaBlockLabels, } from './labels.js';
+export { resolveBlockMediaSrc } from './resolve.js';
+export declare const MEDIA_BLOCK_TYPES: readonly ["image", "figure", "video", "gallery"];
+export type MediaFamilyBlockType = (typeof MEDIA_BLOCK_TYPES)[number];
+export type MediaFamilyBlock = ImageBlock | FigureBlock | VideoBlock | GalleryBlock;
+export declare function isMediaFamilyBlock(block: Block): block is MediaFamilyBlock;
+export interface MediaBlockViewProps {
+    block: unknown;
+    labels?: MediaBlockLabelOverrides;
+    resolveAvatar?: (id: string) => string | undefined;
+    oninvalid?: (issues: FieldIssue[]) => void;
+}

package/dist/media/engine.js

@@ -0,0 +1,10 @@
+/**
+ * `@texuli/blocks/media/engine` — Svelte-free media family guards, labels and URL resolve.
+ */
+export { checkMediaBlock } from "./check.js";
+export { DEFAULT_MEDIA_BLOCK_LABELS, resolveMediaBlockLabels, } from "./labels.js";
+export { resolveBlockMediaSrc } from "./resolve.js";
+export const MEDIA_BLOCK_TYPES = ['image', 'figure', 'video', 'gallery'];
+export function isMediaFamilyBlock(block) {
+    return MEDIA_BLOCK_TYPES.includes(block.type);
+}

package/dist/media/family.d.ts

@@ -0,0 +1,7 @@
+import type { Component } from 'svelte';
+import type { MediaBlockViewProps } from './engine.js';
+export { isMediaFamilyBlock, MEDIA_BLOCK_TYPES, type MediaBlockViewProps, type MediaFamilyBlock, type MediaFamilyBlockType, } from './engine.js';
+/** Lazily loads the media family renderer (its own chunk). */
+export declare function loadMediaFamily(): Promise<{
+    default: Component<MediaBlockViewProps>;
+}>;

package/dist/media/family.js

@@ -0,0 +1,5 @@
+export { isMediaFamilyBlock, MEDIA_BLOCK_TYPES, } from "./engine.js";
+/** Lazily loads the media family renderer (its own chunk). */
+export function loadMediaFamily() {
+    return import('./MediaBlockView.svelte');
+}

package/dist/media/index.d.ts

@@ -0,0 +1,11 @@
+/// <reference path="../css-modules.d.ts" />
+/**
+ * `@texuli/blocks` media family (T-blocks-media): image, figure, video and
+ * gallery. No Svelte is imported eagerly: renderers load through
+ * `loadMediaFamily()` (its own chunk) or directly from
+ * `@texuli/blocks/media/renderers`.
+ */
+export { checkMediaBlock, type MediaBlockCheck } from './check.js';
+export { isMediaFamilyBlock, loadMediaFamily, MEDIA_BLOCK_TYPES, type MediaBlockViewProps, type MediaFamilyBlock, type MediaFamilyBlockType, } from './family.js';
+export { DEFAULT_MEDIA_BLOCK_LABELS, type MediaBlockLabelOverrides, type MediaBlockLabels, resolveMediaBlockLabels, } from './labels.js';
+export { resolveBlockMediaSrc } from './resolve.js';

package/dist/media/index.js

@@ -0,0 +1,10 @@
+/**
+ * `@texuli/blocks` media family (T-blocks-media): image, figure, video and
+ * gallery. No Svelte is imported eagerly: renderers load through
+ * `loadMediaFamily()` (its own chunk) or directly from
+ * `@texuli/blocks/media/renderers`.
+ */
+export { checkMediaBlock } from "./check.js";
+export { isMediaFamilyBlock, loadMediaFamily, MEDIA_BLOCK_TYPES, } from "./family.js";
+export { DEFAULT_MEDIA_BLOCK_LABELS, resolveMediaBlockLabels, } from "./labels.js";
+export { resolveBlockMediaSrc } from "./resolve.js";

package/dist/media/labels.d.ts

@@ -0,0 +1,7 @@
+export type MediaBlockLabels = {
+    invalid: string;
+    galleryFallback: string;
+};
+export type MediaBlockLabelOverrides = Partial<MediaBlockLabels>;
+export declare const DEFAULT_MEDIA_BLOCK_LABELS: MediaBlockLabels;
+export declare function resolveMediaBlockLabels(overrides?: MediaBlockLabelOverrides): MediaBlockLabels;

package/dist/media/labels.js

@@ -0,0 +1,12 @@
+export const DEFAULT_MEDIA_BLOCK_LABELS = Object.freeze({
+    invalid: 'This media block could not be shown.',
+    galleryFallback: 'Image unavailable',
+});
+export function resolveMediaBlockLabels(overrides) {
+    if (!overrides)
+        return DEFAULT_MEDIA_BLOCK_LABELS;
+    return {
+        invalid: overrides.invalid ?? DEFAULT_MEDIA_BLOCK_LABELS.invalid,
+        galleryFallback: overrides.galleryFallback ?? DEFAULT_MEDIA_BLOCK_LABELS.galleryFallback,
+    };
+}

package/dist/media/renderers.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Eager entry for hosts that render media blocks on first paint. Most hosts
+ * should prefer `loadMediaFamily()` from `@texuli/blocks` (lazy chunk).
+ */
+export { default as MediaBlockView } from './MediaBlockView.svelte';

package/dist/media/renderers.js

@@ -0,0 +1,5 @@
+/**
+ * Eager entry for hosts that render media blocks on first paint. Most hosts
+ * should prefer `loadMediaFamily()` from `@texuli/blocks` (lazy chunk).
+ */
+export { default as MediaBlockView } from './MediaBlockView.svelte';

package/dist/media/resolve.d.ts

@@ -0,0 +1,6 @@
+import { type MediaKind } from '../core/safety.js';
+/**
+ * Resolve a block media `src` after schema validation. Avatars need a host
+ * adapter (not shipped here); data and relative sources pass through.
+ */
+export declare function resolveBlockMediaSrc(src: string, kind: MediaKind, resolveAvatar?: (id: string) => string | undefined): string | undefined;

package/dist/media/resolve.js

@@ -0,0 +1,15 @@
+import { classifyMediaSource } from "../core/safety.js";
+/**
+ * Resolve a block media `src` after schema validation. Avatars need a host
+ * adapter (not shipped here); data and relative sources pass through.
+ */
+export function resolveBlockMediaSrc(src, kind, resolveAvatar) {
+    const result = classifyMediaSource(src, kind);
+    if (!result.ok)
+        return undefined;
+    if (result.kind === 'avatar') {
+        const id = src.slice('avatar:'.length);
+        return resolveAvatar?.(id);
+    }
+    return src;
+}

package/dist/structure/NestedBlocks.svelte

@@ -0,0 +1,65 @@
+<script lang="ts">
+import type { Component } from 'svelte';
+import type { Block } from '../core/index.js';
+import type { StructureBlockLabels } from './labels.js';
+
+/**
+ * Nested child blocks inside columns or tab panels. Dynamically imports the
+ * matching family renderer so the structure chunk can finish loading without a
+ * hard cycle through every other family.
+ */
+let {
+  blocks,
+  labels,
+}: {
+  blocks: readonly Block[];
+  labels: StructureBlockLabels;
+} = $props();
+
+const TEXT_TYPES = new Set(['heading', 'text', 'list', 'quote', 'callout']);
+const STRUCTURE_TYPES = new Set([
+  'columns',
+  'grid',
+  'tabs',
+  'accordion',
+  'cards',
+  'divider',
+  'cta',
+]);
+
+type View = Component<{ block: unknown; labels?: unknown; oninvalid?: unknown }>;
+
+async function loadView(type: string): Promise<View | null> {
+  if (TEXT_TYPES.has(type)) {
+    const mod = await import('../text/TextBlockView.svelte');
+    return mod.default as View;
+  }
+  if (STRUCTURE_TYPES.has(type)) {
+    const mod = await import('./StructureFamily.svelte');
+    return mod.default as View;
+  }
+  return null;
+}
+</script>
+
+{#if blocks.length === 0}
+  <p class="tx-structure-empty" role="note">{labels.emptyPanel}</p>
+{:else}
+  <div class="tx-structure-nested">
+    {#each blocks as child, i (i)}
+      {#await loadView(child.type)}
+        <p class="tx-structure-loading" role="status">…</p>
+      {:then View}
+        {#if View}
+          <View block={child} />
+        {:else}
+          <p class="tx-structure-empty" role="note" data-tx-nested-unsupported={child.type}>
+            {labels.invalid}
+          </p>
+        {/if}
+      {:catch}
+        <p class="tx-structure-empty" role="note">{labels.invalid}</p>
+      {/await}
+    {/each}
+  </div>
+{/if}

package/dist/structure/NestedBlocks.svelte.d.ts

@@ -0,0 +1,11 @@
+/// <reference path="../css-modules.d.ts" />
+import type { Component } from 'svelte';
+import type { Block } from '../core/index.js';
+import type { StructureBlockLabels } from './labels.js';
+type $$ComponentProps = {
+    blocks: readonly Block[];
+    labels: StructureBlockLabels;
+};
+declare const NestedBlocks: Component<$$ComponentProps, {}, "">;
+type NestedBlocks = ReturnType<typeof NestedBlocks>;
+export default NestedBlocks;

package/dist/structure/SafeBody.svelte

@@ -0,0 +1,13 @@
+<script lang="ts">
+import { DEFAULT_TEXT_BLOCK_LABELS } from '../text/labels.js';
+import RichText from '../text/RichText.svelte';
+
+/**
+ * Renders a short markdown body through the owned closed subset. No HTML sink.
+ */
+let { text }: { text: string } = $props();
+</script>
+
+<div class="tx-structure-body">
+  <RichText source={text} labels={DEFAULT_TEXT_BLOCK_LABELS} />
+</div>

package/dist/structure/SafeBody.svelte.d.ts

@@ -0,0 +1,7 @@
+/// <reference path="../css-modules.d.ts" />
+type $$ComponentProps = {
+    text: string;
+};
+declare const SafeBody: import("svelte").Component<$$ComponentProps, {}, "">;
+type SafeBody = ReturnType<typeof SafeBody>;
+export default SafeBody;

package/dist/structure/StructureFamily.svelte

@@ -0,0 +1,157 @@
+<script lang="ts">
+import { Card, CardContent, CardHeader, CardTitle } from 'texuli/card';
+import { Accordion, Tabs } from 'texuli/tabs-accordion';
+import { checkStructureBlock } from './check.js';
+import type { StructureBlockViewProps } from './family.js';
+import { resolveStructureBlockLabels } from './labels.js';
+import NestedBlocks from './NestedBlocks.svelte';
+import SafeBody from './SafeBody.svelte';
+import './structure.css';
+
+/**
+ * Structure family renderer: columns, grid, tabs, accordion, cards, divider
+ * and cta. Untrusted data is validated before anything paints.
+ */
+let { block, labels, oninvalid }: StructureBlockViewProps = $props();
+
+const check = $derived(checkStructureBlock(block));
+const text = $derived(resolveStructureBlockLabels(labels));
+
+$effect(() => {
+  if (!check.ok) oninvalid?.(check.issues);
+});
+
+function colsAttr(n: number | undefined, fallback: number): string {
+  return String(n ?? fallback);
+}
+</script>
+
+{#if !check.ok}
+  <p class="tx-block-invalid" role="note" data-tx-block="invalid">{text.invalid}</p>
+{:else}
+  {@const b = check.block}
+  {#if b.type === 'columns'}
+    <div
+      class="tx-structure-columns"
+      data-tx-block="columns"
+      data-cols={colsAttr(b.columns.length, 2)}
+      data-tone={b.tone}
+      role="group"
+      aria-label={text.columnsLabel}
+    >
+      {#each b.columns as column, c (c)}
+        <div class="tx-structure-column" data-column={c}>
+          <NestedBlocks blocks={column} labels={text} />
+        </div>
+      {/each}
+    </div>
+  {:else if b.type === 'grid'}
+    <section
+      class="tx-block"
+      data-tx-block="grid"
+      data-tone={b.tone}
+      aria-label={b.title ?? text.gridLabel}
+    >
+      {#if b.title}
+        <h3 class="tx-structure-section-title">{b.title}</h3>
+      {/if}
+      <div class="tx-structure-grid" data-cols={colsAttr(b.columns, 3)}>
+        {#each b.cells as cell, i (i)}
+          <article class="tx-structure-cell" data-tone={cell.tone}>
+            {#if cell.title}
+              <h4 class="tx-structure-cell-title">{cell.title}</h4>
+            {/if}
+            {#if cell.body}
+              <div class="tx-structure-cell-body"><SafeBody text={cell.body} /></div>
+            {/if}
+          </article>
+        {/each}
+      </div>
+    </section>
+  {:else if b.type === 'tabs'}
+    {@const items = b.panels.map((panel) => ({ value: panel.id, label: panel.label }))}
+    {@const initial = b.defaultPanel ?? b.panels[0]?.id ?? ''}
+    <div class="tx-structure-tabs" data-tx-block="tabs" data-tone={b.tone} data-block-id={b.id}>
+      <Tabs items={items} value={initial} label={b.label} variant="line">
+        {#snippet content(item)}
+          {@const panel = b.panels.find((p) => p.id === item.value)}
+          {#if panel}
+            <div class="tx-structure-panel">
+              <NestedBlocks blocks={panel.blocks} labels={text} />
+            </div>
+          {/if}
+        {/snippet}
+      </Tabs>
+    </div>
+  {:else if b.type === 'accordion'}
+    {@const items = b.items.map((item) => ({
+      value: item.id,
+      title: item.title,
+      content: item.body,
+    }))}
+    <div
+      class="tx-structure-accordion"
+      data-tx-block="accordion"
+      data-tone={b.tone}
+      data-block-id={b.id}
+      role="group"
+      aria-label={b.label}
+    >
+      <Accordion items={items} type={b.mode === 'multiple' ? 'multiple' : 'single'} variant="default">
+        {#snippet content(item)}
+          {@const source = b.items.find((i) => i.id === item.value)}
+          {#if source?.body}
+            <SafeBody text={source.body} />
+          {/if}
+        {/snippet}
+      </Accordion>
+    </div>
+  {:else if b.type === 'cards'}
+    <section
+      class="tx-block"
+      data-tx-block="cards"
+      data-tone={b.tone}
+      aria-label={b.title ?? text.cardsLabel}
+    >
+      {#if b.title}
+        <h3 class="tx-structure-section-title">{b.title}</h3>
+      {/if}
+      <ul class="tx-structure-cards" data-cols={colsAttr(b.columns, 3)}>
+        {#each b.items as card, i (i)}
+          <li>
+            <Card
+              variant="flat"
+              href={card.href}
+              hrefTrust="untrusted"
+            >
+              <CardHeader>
+                {#if card.eyebrow}
+                  <p class="tx-structure-card-eyebrow">{card.eyebrow}</p>
+                {/if}
+                <CardTitle level={4}>{card.title}</CardTitle>
+              </CardHeader>
+              {#if card.body}
+                <CardContent>
+                  <SafeBody text={card.body} />
+                </CardContent>
+              {/if}
+            </Card>
+          </li>
+        {/each}
+      </ul>
+    </section>
+  {:else if b.type === 'divider'}
+    <hr class="tx-structure-divider" data-tx-block="divider" data-tone={b.tone} />
+  {:else if b.type === 'cta'}
+    <nav
+      class="tx-structure-cta"
+      data-tx-block="cta"
+      data-tone={b.tone}
+      aria-label={text.ctaLabel}
+    >
+      {#each b.actions as action, i (i)}
+        <a href={action.href}>{action.label}</a>
+      {/each}
+    </nav>
+  {/if}
+{/if}

package/dist/structure/StructureFamily.svelte.d.ts

@@ -0,0 +1,5 @@
+/// <reference path="../css-modules.d.ts" />
+import type { StructureBlockViewProps } from './family.js';
+declare const StructureFamily: import("svelte").Component<StructureBlockViewProps, {}, "">;
+type StructureFamily = ReturnType<typeof StructureFamily>;
+export default StructureFamily;

package/dist/structure/check.d.ts

@@ -0,0 +1,14 @@
+import type { FieldIssue } from '../core/schema/primitives.js';
+import type { StructureFamilyBlock } from './engine.js';
+export type StructureBlockCheck = {
+    ok: true;
+    block: StructureFamilyBlock;
+} | {
+    ok: false;
+    issues: FieldIssue[];
+};
+/**
+ * The only way data reaches a structure renderer: untrusted input runs through
+ * the block schemas, then must be one of the structure family types.
+ */
+export declare function checkStructureBlock(value: unknown): StructureBlockCheck;

package/dist/structure/check.js

@@ -0,0 +1,27 @@
+// Structure blocks nest any block, so they need the full multi-family parser.
+import { safeParseBlock } from "../core/schema/blocks.js";
+const STRUCTURE_TYPES = new Set([
+    'columns',
+    'grid',
+    'tabs',
+    'accordion',
+    'cards',
+    'divider',
+    'cta',
+]);
+/**
+ * The only way data reaches a structure renderer: untrusted input runs through
+ * the block schemas, then must be one of the structure family types.
+ */
+export function checkStructureBlock(value) {
+    const parsed = safeParseBlock(value);
+    if (!parsed.success)
+        return { ok: false, issues: parsed.issues };
+    if (!STRUCTURE_TYPES.has(parsed.data.type)) {
+        return {
+            ok: false,
+            issues: [{ path: ['type'], message: `"${parsed.data.type}" is not a structure block` }],
+        };
+    }
+    return { ok: true, block: parsed.data };
+}

package/dist/structure/engine.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `@texuli/blocks/structure/engine` — Svelte-free structure parsers, guards and labels.
+ */
+import type { Block, ColumnsBlock, CtaBlock, DividerBlock, FieldIssue } from '../core/index.js';
+import type { StructureBlockLabelOverrides } from './labels.js';
+import type { AccordionBlock, CardsBlock, GridBlock, TabsBlock } from './schema.js';
+export { checkStructureBlock, type StructureBlockCheck } from './check.js';
+export { DEFAULT_STRUCTURE_BLOCK_LABELS, resolveStructureBlockLabels, type StructureBlockLabelOverrides, type StructureBlockLabels, } from './labels.js';
+export { type AccordionBlock, type AccordionItem, type CardItem, type CardsBlock, type GridBlock, type GridCell, parseAccordionBlock, parseCardsBlock, parseGridBlock, parseStructureBlock, parseTabsBlock, STRUCTURE_OWNED_TYPES, type StructureChildParser, type StructureOwnedBlock, type StructureOwnedBlockType, type TabsBlock, type TabsPanel, } from './schema.js';
+export declare const STRUCTURE_BLOCK_TYPES: readonly ["columns", "grid", "tabs", "accordion", "cards", "divider", "cta"];
+export type StructureFamilyBlockType = (typeof STRUCTURE_BLOCK_TYPES)[number];
+export type StructureFamilyBlock = ColumnsBlock | GridBlock | TabsBlock | AccordionBlock | CardsBlock | DividerBlock | CtaBlock;
+export declare function isStructureFamilyBlock(block: Block): block is StructureFamilyBlock;
+export interface StructureBlockViewProps {
+    block: unknown;
+    labels?: StructureBlockLabelOverrides;
+    oninvalid?: (issues: FieldIssue[]) => void;
+}

package/dist/structure/engine.js

@@ -0,0 +1,18 @@
+/**
+ * `@texuli/blocks/structure/engine` — Svelte-free structure parsers, guards and labels.
+ */
+export { checkStructureBlock } from "./check.js";
+export { DEFAULT_STRUCTURE_BLOCK_LABELS, resolveStructureBlockLabels, } from "./labels.js";
+export { parseAccordionBlock, parseCardsBlock, parseGridBlock, parseStructureBlock, parseTabsBlock, STRUCTURE_OWNED_TYPES, } from "./schema.js";
+export const STRUCTURE_BLOCK_TYPES = [
+    'columns',
+    'grid',
+    'tabs',
+    'accordion',
+    'cards',
+    'divider',
+    'cta',
+];
+export function isStructureFamilyBlock(block) {
+    return STRUCTURE_BLOCK_TYPES.includes(block.type);
+}

package/dist/structure/family.d.ts

@@ -0,0 +1,7 @@
+import type { Component } from 'svelte';
+import type { StructureBlockViewProps } from './engine.js';
+export { isStructureFamilyBlock, STRUCTURE_BLOCK_TYPES, type StructureBlockViewProps, type StructureFamilyBlock, type StructureFamilyBlockType, } from './engine.js';
+/** Lazily loads the structure family renderer (its own chunk). */
+export declare function loadStructureFamily(): Promise<{
+    default: Component<StructureBlockViewProps>;
+}>;

package/dist/structure/family.js

@@ -0,0 +1,5 @@
+export { isStructureFamilyBlock, STRUCTURE_BLOCK_TYPES, } from "./engine.js";
+/** Lazily loads the structure family renderer (its own chunk). */
+export function loadStructureFamily() {
+    return import('./StructureFamily.svelte');
+}

package/dist/structure/index.d.ts

@@ -0,0 +1,11 @@
+/// <reference path="../css-modules.d.ts" />
+/**
+ * `@texuli/blocks` structure family (T-blocks-structure): columns, grid, tabs,
+ * accordion, cards, divider and cta. No Svelte is imported eagerly: renderers
+ * load through `loadStructureFamily()` (its own chunk) or directly from
+ * `@texuli/blocks/structure/renderers`.
+ */
+export { checkStructureBlock, type StructureBlockCheck } from './check.js';
+export { isStructureFamilyBlock, loadStructureFamily, STRUCTURE_BLOCK_TYPES, type StructureBlockViewProps, type StructureFamilyBlock, type StructureFamilyBlockType, } from './family.js';
+export { DEFAULT_STRUCTURE_BLOCK_LABELS, resolveStructureBlockLabels, type StructureBlockLabelOverrides, type StructureBlockLabels, } from './labels.js';
+export { type AccordionBlock, type AccordionItem, type CardItem, type CardsBlock, type GridBlock, type GridCell, parseAccordionBlock, parseCardsBlock, parseGridBlock, parseStructureBlock, parseTabsBlock, STRUCTURE_OWNED_TYPES, type StructureChildParser, type StructureOwnedBlock, type StructureOwnedBlockType, type TabsBlock, type TabsPanel, } from './schema.js';

package/dist/structure/index.js

@@ -0,0 +1,10 @@
+/**
+ * `@texuli/blocks` structure family (T-blocks-structure): columns, grid, tabs,
+ * accordion, cards, divider and cta. No Svelte is imported eagerly: renderers
+ * load through `loadStructureFamily()` (its own chunk) or directly from
+ * `@texuli/blocks/structure/renderers`.
+ */
+export { checkStructureBlock } from "./check.js";
+export { isStructureFamilyBlock, loadStructureFamily, STRUCTURE_BLOCK_TYPES, } from "./family.js";
+export { DEFAULT_STRUCTURE_BLOCK_LABELS, resolveStructureBlockLabels, } from "./labels.js";
+export { parseAccordionBlock, parseCardsBlock, parseGridBlock, parseStructureBlock, parseTabsBlock, STRUCTURE_OWNED_TYPES, } from "./schema.js";

package/dist/structure/labels.d.ts

@@ -0,0 +1,11 @@
+export interface StructureBlockLabels {
+    invalid: string;
+    emptyPanel: string;
+    cardsLabel: string;
+    gridLabel: string;
+    columnsLabel: string;
+    ctaLabel: string;
+}
+export type StructureBlockLabelOverrides = Partial<StructureBlockLabels>;
+export declare const DEFAULT_STRUCTURE_BLOCK_LABELS: StructureBlockLabels;
+export declare function resolveStructureBlockLabels(overrides?: StructureBlockLabelOverrides): StructureBlockLabels;

package/dist/structure/labels.js

@@ -0,0 +1,11 @@
+export const DEFAULT_STRUCTURE_BLOCK_LABELS = {
+    invalid: 'This block could not be shown.',
+    emptyPanel: 'This panel is empty.',
+    cardsLabel: 'Cards',
+    gridLabel: 'Grid',
+    columnsLabel: 'Columns',
+    ctaLabel: 'Actions',
+};
+export function resolveStructureBlockLabels(overrides) {
+    return { ...DEFAULT_STRUCTURE_BLOCK_LABELS, ...overrides };
+}

package/dist/structure/renderers.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Eager structure family renderers. Prefer `loadStructureFamily()` from
+ * `@texuli/blocks/structure` (lazy chunk) in app code.
+ */
+export { default as StructureFamily } from './StructureFamily.svelte';

package/dist/structure/renderers.js

@@ -0,0 +1,5 @@
+/**
+ * Eager structure family renderers. Prefer `loadStructureFamily()` from
+ * `@texuli/blocks/structure` (lazy chunk) in app code.
+ */
+export { default as StructureFamily } from './StructureFamily.svelte';

package/dist/structure/schema.d.ts

@@ -0,0 +1,71 @@
+import type { Block } from '../core/schema/blocks.js';
+import { type BlockBase, type ParseResult } from '../core/schema/primitives.js';
+import { type BlockTone } from '../core/schema/vocabulary.js';
+export type StructureChildParser = (value: unknown, path: (string | number)[], containerDepth: number) => ParseResult<Block[]>;
+export type TabsPanel = {
+    id: string;
+    label: string;
+    blocks: Block[];
+};
+export type TabsBlock = BlockBase & {
+    type: 'tabs';
+    /** Stable id for the tab list (deep links and state). */
+    id: string;
+    /** Accessible name of the tab list. */
+    label: string;
+    panels: TabsPanel[];
+    defaultPanel?: string;
+};
+export type AccordionItem = {
+    id: string;
+    title: string;
+    /** Markdown body (closed subset via RichText). */
+    body?: string;
+};
+export type AccordionBlock = BlockBase & {
+    type: 'accordion';
+    id?: string;
+    /** Accessible name for the accordion group. */
+    label?: string;
+    /** single (default) or multiple open items. */
+    mode?: 'single' | 'multiple';
+    items: AccordionItem[];
+};
+export type CardItem = {
+    title: string;
+    eyebrow?: string;
+    body?: string;
+    href?: string;
+    tone?: BlockTone;
+};
+export type CardsBlock = BlockBase & {
+    type: 'cards';
+    title?: string;
+    /** Preferred column count on wide viewports (2–4). */
+    columns?: 2 | 3 | 4;
+    items: CardItem[];
+};
+export type GridCell = {
+    title?: string;
+    body?: string;
+    tone?: BlockTone;
+};
+export type GridBlock = BlockBase & {
+    type: 'grid';
+    title?: string;
+    /** Preferred column count on wide viewports (2–4). */
+    columns?: 2 | 3 | 4;
+    cells: GridCell[];
+};
+export type StructureOwnedBlock = TabsBlock | AccordionBlock | CardsBlock | GridBlock;
+export type StructureOwnedBlockType = StructureOwnedBlock['type'];
+export declare const STRUCTURE_OWNED_TYPES: readonly ["tabs", "accordion", "cards", "grid"];
+export declare function parseTabsBlock(record: Record<string, unknown>, path: (string | number)[], base: BlockBase, containerDepth: number, parseChildren: StructureChildParser): ParseResult<TabsBlock>;
+export declare function parseAccordionBlock(record: Record<string, unknown>, path: (string | number)[], base: BlockBase): ParseResult<AccordionBlock>;
+export declare function parseCardsBlock(record: Record<string, unknown>, path: (string | number)[], base: BlockBase): ParseResult<CardsBlock>;
+export declare function parseGridBlock(record: Record<string, unknown>, path: (string | number)[], base: BlockBase): ParseResult<GridBlock>;
+/**
+ * Dispatch for structure-owned types. Returns null when `type` is not owned
+ * here (core handles columns/divider/cta).
+ */
+export declare function parseStructureBlock(type: string, record: Record<string, unknown>, path: (string | number)[], base: BlockBase, containerDepth: number, parseChildren: StructureChildParser): ParseResult<StructureOwnedBlock> | null;