@joewinke/jatui 0.37.0 → 0.38.0

package/dist/artifact-blocks/blocks/transcript/TranscriptBlock.svelte

@@ -0,0 +1,169 @@
+<script lang="ts">
+  /**
+   * TranscriptBlock — a call recording + its timed speaker transcript,
+   * block type "transcript". Built for voice-call review (soak calls).
+   *
+   * Renders through jatui's VideoPlayer, which owns the hard parts: the
+   * timeline band with diarized speaker colouring, click-to-seek transcript
+   * rows with active-line autoscroll, chapter flags, and the keyboard map.
+   * This block contributes the review layer on top:
+   *
+   *   - flagged segments (`flag: {label, tone}`) become comment dots on the
+   *     band — hover shows the flag label, clicking seeks to that instant —
+   *     AND a "Flagged moments" list below the player whose rows seek the
+   *     player to the line, so a reviewer can work the flags without
+   *     scrubbing. (VideoPlayer's transcript pane has no per-row hook, so
+   *     in-pane highlighting is not possible; the dots + the list are the
+   *     highlight surface.)
+   *   - ONE timeline: the band transport (`transport="band"`) carries
+   *     play/pause, time, speed and volume, so the native control bar (a
+   *     second timeline) never renders. Audio has no stage at all
+   *     (`kind="audio"`); video keeps its stage at its intrinsic ratio.
+   *   - resumeKey ties "continue where you left off" to this artifact block,
+   *     so a review round survives closing the tab.
+   *
+   * Every string is rendered as text (the player's rows included); media is
+   * by URL (https:// or root-relative, validated by urlSchema).
+   */
+  import VideoPlayer from "../../../components/VideoPlayer.svelte"
+  import type { BlockProps } from "../../types.js"
+  import {
+    FLAG_DOT,
+    flagToneOf,
+    formatClock,
+    toFlagMarkers,
+    toVideoChapters,
+    toVideoSegments,
+    transcriptSchema,
+    type TranscriptParams,
+    type TranscriptSegment,
+  } from "./schema.js"
+  import SectionTools from "../../SectionTools.svelte"
+
+  let { params: rawParams, ctx }: BlockProps<TranscriptParams> = $props()
+
+  /** Parsed params (defaults filled); corrupt params → empty state. The host
+   * validates at publish, so this is belt-and-braces for direct mounts. */
+  const EMPTY_PARAMS: TranscriptParams = {
+    media: { src: "https://example.invalid/none.mp3", type: "audio" },
+    segments: [],
+  }
+  const parsed = $derived(transcriptSchema.safeParse(rawParams))
+  const params = $derived(parsed.success ? parsed.data : EMPTY_PARAMS)
+
+  const playable = $derived(params.segments.length > 0)
+  const isVideo = $derived(params.media.type === "video")
+  const vSegments = $derived(toVideoSegments(params.segments))
+  const vMarkers = $derived(toFlagMarkers(params.segments))
+  const vChapters = $derived(toVideoChapters(params.chapters))
+  const flagged = $derived(
+    params.segments
+      .filter((s) => s.flag != null)
+      .slice()
+      .sort((a, b) => a.start - b.start),
+  )
+  /** One voice: the flagged rows need no speaker name either. */
+  const multiSpeaker = $derived(
+    new Set(params.segments.map((s) => s.speaker)).size > 1,
+  )
+  const hasSrc = $derived(params.media.src !== "" && playable)
+
+  const resumeKey = $derived(`artifact:${ctx.artifactId}:${ctx.blockId}`)
+
+  /** The player instance (seekToTime is an export). */
+  let player: ReturnType<typeof VideoPlayer> | null = $state(null)
+
+  function jumpTo(seg: TranscriptSegment) {
+    player?.seekToTime?.(seg.start)
+  }
+</script>
+
+<section class="artifact-transcript w-full">
+  {#if params.title || params.note}
+    <header class="mb-3">
+      {#if params.title}
+        <div class="flex items-center gap-2">
+          <h2 class="min-w-0 text-base font-semibold text-base-content">
+            {params.title}
+          </h2>
+          <SectionTools {ctx} inline />
+        </div>
+      {/if}
+      {#if params.note}
+        <p class="mt-1 max-w-prose text-sm text-base-content/70">
+          {params.note}
+        </p>
+      {/if}
+    </header>
+  {/if}
+
+  {#if hasSrc}
+    <VideoPlayer
+      bind:this={player}
+      src={params.media.src}
+      kind={isVideo ? "video" : "audio"}
+      transport="band"
+      poster={params.media.poster || null}
+      aspect={null}
+      transcript={vSegments}
+      chapters={vChapters}
+      markers={vMarkers}
+      transcriptPosition={isVideo ? "side" : "below"}
+      transcriptMaxHeight="24rem"
+      {resumeKey}
+    />
+  {:else if !playable}
+    <p class="text-sm text-base-content/60">
+      No transcript segments published for this block.
+    </p>
+  {/if}
+
+  {#if flagged.length > 0}
+    <section class="mt-5" aria-labelledby="{ctx.blockId}-flags">
+      <h3
+        id="{ctx.blockId}-flags"
+        class="flex items-baseline gap-2 text-sm font-semibold text-base-content"
+      >
+        Flagged moments
+        <span class="text-xs font-normal tabular-nums text-base-content/60"
+          >{flagged.length}</span
+        >
+      </h3>
+      <ul class="mt-2 divide-y divide-base-content/10">
+        {#each flagged as f, i (i)}
+          <li>
+            <button
+              type="button"
+              class="transcript-flag flex w-full items-start gap-3 rounded-field px-2 py-2.5 text-left hover:bg-base-content/5 focus-visible:outline-2 focus-visible:outline-offset-1 focus-visible:outline-primary"
+              disabled={!hasSrc}
+              onclick={() => jumpTo(f)}
+            >
+              <span
+                class="mt-1.5 size-2 shrink-0 rounded-full {FLAG_DOT[
+                  flagToneOf(f)
+                ]}"
+                aria-hidden="true"
+              ></span>
+              <span class="min-w-0 flex-1">
+                <span class="flex flex-wrap items-baseline gap-x-2">
+                  <span class="text-sm font-medium text-base-content"
+                    >{f.flag!.label}</span
+                  >
+                  <span class="text-xs tabular-nums text-base-content/60"
+                    >{formatClock(f.start)}{multiSpeaker
+                      ? ` · ${f.speaker}`
+                      : ""}</span
+                  >
+                </span>
+                <span
+                  class="mt-0.5 line-clamp-2 block max-w-prose text-sm text-base-content/70"
+                  title={f.text}>{f.text}</span
+                >
+              </span>
+            </button>
+          </li>
+        {/each}
+      </ul>
+    </section>
+  {/if}
+</section>

package/dist/artifact-blocks/blocks/transcript/TranscriptBlock.svelte.d.ts

@@ -0,0 +1,26 @@
+import type { BlockProps } from "../../types.js";
+declare const TranscriptBlock: import("svelte").Component<BlockProps<{
+    media: {
+        src: string;
+        type?: "audio" | "video" | undefined;
+        poster?: string | undefined;
+    };
+    segments: {
+        start: number;
+        end: number;
+        speaker: string;
+        text: string;
+        flag?: {
+            label: string;
+            tone?: "error" | "warning" | "info" | "success" | "primary" | "secondary" | "neutral" | "accent" | undefined;
+        } | undefined;
+    }[];
+    title?: string | undefined;
+    note?: string | undefined;
+    chapters?: {
+        start: number;
+        title: string;
+    }[] | undefined;
+}>, {}, "">;
+type TranscriptBlock = ReturnType<typeof TranscriptBlock>;
+export default TranscriptBlock;

package/dist/artifact-blocks/blocks/transcript/block.d.ts

@@ -0,0 +1,9 @@
+/**
+ * transcript block — a call recording (audio or video) with its timed
+ * speaker transcript: speaker colours, click-to-seek rows, chapters, and
+ * flagged review moments. Built for voice-call review (soak calls).
+ */
+import type { ArtifactBlockDef } from "../../types.js";
+import { type TranscriptParams } from "./schema.js";
+declare const def: ArtifactBlockDef<TranscriptParams>;
+export default def;

package/dist/artifact-blocks/blocks/transcript/block.js

@@ -0,0 +1,86 @@
+import TranscriptBlock from "./TranscriptBlock.svelte";
+import { transcriptSchema } from "./schema.js";
+const EXAMPLE = {
+    title: "Soak call: Ruby, day 6 (afternoon run)",
+    note: "Voice agent 'Ruby' calling the Cedar Park list. Reviewer: review the flagged moments first, then the full transcript.",
+    media: {
+        // A stable public sample so the catalog example is playable/demonstrable
+        // as published; real transcripts point at the tenant's own media URLs.
+        src: "https://upload.wikimedia.org/wikipedia/commons/c/c8/Example.ogg",
+        type: "audio",
+    },
+    chapters: [
+        { start: 0, title: "Opening + consent" },
+        { start: 64, title: "Address confirm loop" },
+        { start: 182, title: "Spellback + close" },
+    ],
+    segments: [
+        {
+            start: 0.4,
+            end: 5.1,
+            speaker: "Ruby",
+            text: "Hi, this is Ruby calling from Plumbers & Sons about your upcoming service visit. Is now a good time?",
+        },
+        {
+            start: 5.6,
+            end: 9.2,
+            speaker: "Customer",
+            text: "Uh, sure, what's this about?",
+        },
+        {
+            start: 9.6,
+            end: 18.4,
+            speaker: "Ruby",
+            text: "You're on the schedule for Thursday between ten and noon. I just need to confirm the service address.",
+        },
+        {
+            start: 19.0,
+            end: 27.3,
+            speaker: "Customer",
+            text: "It's fourteen twelve Coyote Lane, Round Rock.",
+        },
+        {
+            start: 28.0,
+            end: 41.5,
+            speaker: "Ruby",
+            text: "Got it, fourteen twelve Coyote Lane. And can I confirm the best number for a reminder text?",
+            flag: {
+                label: "Re-asked the address the customer already gave",
+                tone: "warning",
+            },
+        },
+        {
+            start: 42.1,
+            end: 46.0,
+            speaker: "Customer",
+            text: "That's the number you're calling, so yes.",
+        },
+        {
+            start: 47.0,
+            end: 59.9,
+            speaker: "Ruby",
+            text: "Perfect. You're all set for Thursday. Anything else I can help with today?",
+            flag: {
+                label: "Never confirmed the spellback it claimed",
+                tone: "error",
+            },
+        },
+        {
+            start: 60.2,
+            end: 63.5,
+            speaker: "Customer",
+            text: "No, that's it. Thanks.",
+        },
+    ],
+};
+const def = {
+    type: "transcript",
+    title: "Transcript (media + speakers)",
+    description: "A call recording with its timed speaker transcript — the review surface for voice calls (soak calls, dispatch QA, interview reels). media: {src (https:// or root-relative URL — MOS storage or external), type 'audio'|'video' (default audio), poster? for video}. segments: [{start, end (seconds, floats fine; end > start), speaker (name — drives the player's colour palette), text, flag?}] in any order (1–3000 lines, text ≤ 2000 chars). flag: {label, tone info|success|warning|error (default warning)} marks a reviewer-relevant line: it becomes a click-to-seek dot on the timeline (hover shows the label) AND a row in the 'Flagged moments' list under the player — that list is the review entry point, so flag sparse and specific ('Re-asked the address', 'Hallucinated a med name'), not every hesitation. chapters: [{start, title}] render as timeline flags for navigation. Speaker colours, click-to-seek transcript rows with active-line autoscroll, keyboard map and resume-where-you-left-off are all built in (jatui VideoPlayer) — do NOT add your own player or waveform. Tip: lead with title + note (who was called, what to listen for), flag 3–8 moments per call, and put the verdict in a callout block after this one.",
+    schema: transcriptSchema,
+    component: TranscriptBlock,
+    // mos-8fvt9: the section's Listen + comment sit on the heading row.
+    hostsTools: (p) => Boolean(p.title),
+    example: EXAMPLE,
+};
+export default def;

package/dist/artifact-blocks/blocks/transcript/schema.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Params schema for the transcript block (media + timed speaker segments).
+ * Imported by block.ts (def), TranscriptBlock.svelte (props typing) and the
+ * tests — keeps them cycle-free.
+ *
+ * The mapping helpers here are pure and unit-tested: they turn block params
+ * into the jatui VideoPlayer contracts (VideoTranscriptSegment, comment
+ * markers for flagged lines, chapters).
+ */
+import { z } from "zod";
+import type { VideoChapter, VideoMarker, VideoTranscriptSegment } from "../../../components/VideoPlayer.svelte";
+import type { ToneToken } from "../../params.js";
+export type FlagTone = ToneToken;
+declare const segmentFlagSchema: z.ZodObject<{
+    label: z.ZodString;
+    tone: z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+        info: "info";
+        success: "success";
+        primary: "primary";
+        secondary: "secondary";
+        neutral: "neutral";
+        accent: "accent";
+    }>>;
+}, z.core.$strip>;
+declare const segmentSchema: z.ZodObject<{
+    start: z.ZodNumber;
+    end: z.ZodNumber;
+    speaker: z.ZodString;
+    text: z.ZodString;
+    flag: z.ZodOptional<z.ZodObject<{
+        label: z.ZodString;
+        tone: z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            warning: "warning";
+            info: "info";
+            success: "success";
+            primary: "primary";
+            secondary: "secondary";
+            neutral: "neutral";
+            accent: "accent";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const chapterSchema: z.ZodObject<{
+    start: z.ZodNumber;
+    title: z.ZodString;
+}, z.core.$strip>;
+declare const mediaSchema: z.ZodObject<{
+    src: z.ZodString;
+    type: z.ZodOptional<z.ZodEnum<{
+        audio: "audio";
+        video: "video";
+    }>>;
+    poster: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+}, z.core.$strip>;
+export declare const transcriptSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    note: z.ZodOptional<z.ZodString>;
+    media: z.ZodObject<{
+        src: z.ZodString;
+        type: z.ZodOptional<z.ZodEnum<{
+            audio: "audio";
+            video: "video";
+        }>>;
+        poster: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    }, z.core.$strip>;
+    segments: z.ZodArray<z.ZodObject<{
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+        speaker: z.ZodString;
+        text: z.ZodString;
+        flag: z.ZodOptional<z.ZodObject<{
+            label: z.ZodString;
+            tone: z.ZodOptional<z.ZodEnum<{
+                error: "error";
+                warning: "warning";
+                info: "info";
+                success: "success";
+                primary: "primary";
+                secondary: "secondary";
+                neutral: "neutral";
+                accent: "accent";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    chapters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        start: z.ZodNumber;
+        title: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type SegmentFlag = z.infer<typeof segmentFlagSchema>;
+export type TranscriptSegment = z.infer<typeof segmentSchema>;
+export type TranscriptChapter = z.infer<typeof chapterSchema>;
+export type TranscriptMedia = z.infer<typeof mediaSchema>;
+export type TranscriptParams = z.infer<typeof transcriptSchema>;
+/** Flag tone with default filled. */
+export declare function flagToneOf(s: TranscriptSegment): FlagTone;
+/** Dot classes for flag tones. The flagged list carries the tone as a small
+ * dot next to the label (the label itself is body text), so the list reads
+ * as a quiet index of moments, not a wall of solid chips. */
+export declare const FLAG_DOT: Record<FlagTone, string>;
+/** Segments → VideoTranscriptSegment[] (speaker doubles as identity so the
+ * player's palette stays stable per name). */
+export declare function toVideoSegments(segments: TranscriptSegment[]): VideoTranscriptSegment[];
+/** Flagged segments → comment dots on the player timeline: hover shows the
+ * flag label, clicking seeks to the line's start. */
+export declare function toFlagMarkers(segments: TranscriptSegment[]): VideoMarker[];
+/** Chapters → VideoChapter[], sorted by start (the band draws them in order). */
+export declare function toVideoChapters(chapters: TranscriptChapter[] | undefined): VideoChapter[];
+/** m:ss (h:mm:ss past an hour), for the flagged list and time captions. */
+export declare function formatClock(sec: number): string;
+export {};

package/dist/artifact-blocks/blocks/transcript/schema.js

@@ -0,0 +1,126 @@
+/**
+ * Params schema for the transcript block (media + timed speaker segments).
+ * Imported by block.ts (def), TranscriptBlock.svelte (props typing) and the
+ * tests — keeps them cycle-free.
+ *
+ * The mapping helpers here are pure and unit-tested: they turn block params
+ * into the jatui VideoPlayer contracts (VideoTranscriptSegment, comment
+ * markers for flagged lines, chapters).
+ */
+import { z } from "zod";
+import { toneSchema, urlSchema, optionalUrlSchema } from "../../params.js";
+const SEGMENTS_MAX = 3000;
+const CHAPTERS_MAX = 50;
+const TEXT_MAX = 2000;
+const segmentFlagSchema = z.object({
+    /** Short flag label shown as a chip and as the timeline dot hover text. */
+    label: z.string().min(1, "flag label is required").max(120),
+    /** Chip tone — any theme token; default "warning". */
+    tone: toneSchema.optional(),
+});
+const segmentSchema = z
+    .object({
+    /** Segment start, seconds from media start (floats fine). */
+    start: z.number().min(0),
+    /** Segment end, seconds — must be greater than start. */
+    end: z.number().min(0),
+    /** Speaker name as shown in the transcript pane (drives its palette). */
+    speaker: z.string().min(1, "speaker is required").max(80),
+    /** What was said (rendered as text — never HTML). */
+    text: z.string().min(1, "segment text is required").max(TEXT_MAX),
+    /** Reviewer-relevant moment: rendered as a chip in the flagged list and
+     * as a click-to-seek dot on the player timeline. */
+    flag: segmentFlagSchema.optional(),
+})
+    .refine((s) => s.end > s.start, {
+    message: "segment end must be greater than start",
+    path: ["end"],
+});
+const chapterSchema = z.object({
+    /** Chapter start, seconds from media start. */
+    start: z.number().min(0),
+    /** Chapter title (also the timeline flag hover text). */
+    title: z.string().min(1, "chapter title is required").max(120),
+});
+const mediaSchema = z.object({
+    /** https:// or root-relative media URL (MOS storage or external). */
+    src: urlSchema,
+    /** "audio" (voice call) or "video" (screen recording). Default "audio". */
+    type: z.enum(["audio", "video"]).optional(),
+    /** Poster image for video (unused for audio). */
+    poster: optionalUrlSchema,
+});
+export const transcriptSchema = z.object({
+    /** Optional heading above the player. */
+    title: z.string().max(120).optional(),
+    /** One-line context under the title, e.g. who was on the call. */
+    note: z.string().max(500).optional(),
+    media: mediaSchema,
+    segments: z
+        .array(segmentSchema)
+        .min(1, "at least one segment")
+        .max(SEGMENTS_MAX),
+    chapters: z.array(chapterSchema).max(CHAPTERS_MAX).optional(),
+});
+/** Flag tone with default filled. */
+export function flagToneOf(s) {
+    return s.flag?.tone ?? "warning";
+}
+/** Dot classes for flag tones. The flagged list carries the tone as a small
+ * dot next to the label (the label itself is body text), so the list reads
+ * as a quiet index of moments, not a wall of solid chips. */
+export const FLAG_DOT = {
+    primary: "bg-primary",
+    secondary: "bg-secondary",
+    accent: "bg-accent",
+    neutral: "bg-neutral",
+    info: "bg-info",
+    success: "bg-success",
+    warning: "bg-warning",
+    error: "bg-error",
+};
+// ── mapping to the jatui VideoPlayer contracts ─────────────────────────────
+/** Segments → VideoTranscriptSegment[] (speaker doubles as identity so the
+ * player's palette stays stable per name). */
+export function toVideoSegments(segments) {
+    return segments.map((s, i) => ({
+        id: `seg-${i}`,
+        startSec: s.start,
+        endSec: s.end,
+        speakerIdentity: s.speaker,
+        speakerName: s.speaker,
+        text: s.text,
+    }));
+}
+/** Flagged segments → comment dots on the player timeline: hover shows the
+ * flag label, clicking seeks to the line's start. */
+export function toFlagMarkers(segments) {
+    return segments
+        .map((s, i) => ({ s, i }))
+        .filter(({ s }) => s.flag != null)
+        .map(({ s, i }) => ({
+        atSec: s.start,
+        kind: "comment",
+        id: `flag-${i}`,
+        text: s.flag.label,
+    }));
+}
+/** Chapters → VideoChapter[], sorted by start (the band draws them in order). */
+export function toVideoChapters(chapters) {
+    return (chapters ?? [])
+        .slice()
+        .sort((a, b) => a.start - b.start)
+        .map((c) => ({ startSec: c.start, title: c.title }));
+}
+/** m:ss (h:mm:ss past an hour), for the flagged list and time captions. */
+export function formatClock(sec) {
+    if (!Number.isFinite(sec) || sec < 0)
+        return "0:00";
+    const total = Math.floor(sec);
+    const h = Math.floor(total / 3600);
+    const m = Math.floor((total % 3600) / 60);
+    const s = total % 60;
+    const mm = h > 0 ? String(m).padStart(2, "0") : String(m);
+    const ss = String(s).padStart(2, "0");
+    return h > 0 ? `${h}:${mm}:${ss}` : `${mm}:${ss}`;
+}

package/dist/artifact-blocks/builtins.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The blocks jatui ships (jatui-vsuzi): the core's markdown block plus the
+ * four group barrels, one per block task. A block task edits ONLY its own
+ * barrel (blocks/group-<group>.ts) — never this file — so the four tasks
+ * never collide on a shared list.
+ */
+import type { ArtifactBlockDef } from "./types.js";
+/** The groups, in showcase order (each also has a /showcase subpage). */
+export declare const BLOCK_GROUPS: readonly [{
+    readonly BLOCKS: ArtifactBlockDef<any>[];
+    readonly PENDING: readonly string[];
+    readonly id: "data";
+    readonly title: "Data";
+    readonly task: "jatui-d4lyd";
+}, {
+    readonly BLOCKS: ArtifactBlockDef<any>[];
+    readonly PENDING: readonly string[];
+    readonly id: "content";
+    readonly title: "Content";
+    readonly task: "jatui-zy9n5";
+}, {
+    readonly BLOCKS: ArtifactBlockDef<any>[];
+    readonly PENDING: readonly string[];
+    readonly id: "visual";
+    readonly title: "Visual";
+    readonly task: "jatui-399p2";
+}, {
+    readonly BLOCKS: ArtifactBlockDef<any>[];
+    readonly PENDING: readonly string[];
+    readonly id: "review";
+    readonly title: "Review / interactive";
+    readonly task: "jatui-n5z1x";
+}];
+export declare const BUILTIN_BLOCKS: ArtifactBlockDef<any>[];
+/**
+ * MOS block types still being ported (epic jatui-936iz). A spec naming one
+ * renders the renderer's "not in this renderer yet" card instead of the
+ * generic unknown-type one.
+ */
+export declare const PENDING_BLOCK_TYPES: readonly string[];

package/dist/artifact-blocks/builtins.js

@@ -0,0 +1,22 @@
+import markdown from "./blocks/markdown/block.js";
+import * as data from "./blocks/group-data.js";
+import * as content from "./blocks/group-content.js";
+import * as visual from "./blocks/group-visual.js";
+import * as review from "./blocks/group-review.js";
+/** The groups, in showcase order (each also has a /showcase subpage). */
+export const BLOCK_GROUPS = [
+    { id: "data", title: "Data", task: "jatui-d4lyd", ...data },
+    { id: "content", title: "Content", task: "jatui-zy9n5", ...content },
+    { id: "visual", title: "Visual", task: "jatui-399p2", ...visual },
+    { id: "review", title: "Review / interactive", task: "jatui-n5z1x", ...review },
+];
+export const BUILTIN_BLOCKS = [
+    markdown,
+    ...BLOCK_GROUPS.flatMap((g) => g.BLOCKS),
+];
+/**
+ * MOS block types still being ported (epic jatui-936iz). A spec naming one
+ * renders the renderer's "not in this renderer yet" card instead of the
+ * generic unknown-type one.
+ */
+export const PENDING_BLOCK_TYPES = BLOCK_GROUPS.flatMap((g) => [...g.PENDING]);