@voithos-labs/aragonite 0.10.1

package/dist/plugins/mermaid/mermaid-kind.js

@@ -0,0 +1,176 @@
+/**
+ * The reference whole-block container, on public registration seams only: an opaque
+ * container with no children, its diagram code in typed metadata, so an
+ * `updateOwnMetadata({ code })` commit is the whole edit path. Uninstall safety is by
+ * construction: without this opener the same bytes parse as plain `fencedCode`.
+ */
+import { declarePluginKind, registerBlockKind, registerBlockOpener, registerBlockCommand, setPluginMetadata, getPluginMetadata, matchFenceOpen, matchFenceClose, escalatedFenceLength, OPENER_PRIORITIES } from '../../plugin';
+export const MERMAID = 'mermaid';
+// ── Fence grammar ─────────────────────────────────────────────────────────────
+// The barrel's built-in matcher, gated on the info string's first word, so the
+// CommonMark fence rules stay the editor's and never become a plugin copy.
+function matchMermaidFence(text) {
+    const fence = matchFenceOpen(text);
+    return fence && fence.info.split(/\s+/)[0] === MERMAID ? fence : null;
+}
+/**
+ * The edit textarea normalizes to LF, so a CRLF-authored diagram needs its authored
+ * ending put back on every body line. An emptied body commits as `''`, no stray line.
+ */
+export function joinMermaidBody(draft, lineEnding) {
+    if (draft.length === 0)
+        return '';
+    return draft.replaceAll('\n', lineEnding) + lineEnding;
+}
+/**
+ * The opener's inverse, and the byte path every code edit rides. The body is a metadata string
+ * this kind never re-parses, so the fence is sized against it here — a diagram line that reads as
+ * this block's closer would otherwise truncate the block on its next load.
+ */
+export function rebuildMermaidRaw(node) {
+    const meta = getPluginMetadata(node);
+    if (!meta)
+        return;
+    const marker = meta.fenceChar === '~' ? '~' : '`';
+    const fenceLength = escalatedFenceLength(meta.code, marker, meta.fenceLength);
+    node.raw =
+        meta.openerIndent +
+            marker.repeat(fenceLength) +
+            meta.infoRaw +
+            meta.openerLineEnding +
+            meta.code +
+            (fenceLength > meta.fenceLength
+                ? grownCloser(meta.closerRaw, marker, fenceLength)
+                : meta.closerRaw);
+}
+/**
+ * Grow a verbatim closer line's run to `length`, keeping its indent, trailing spaces and line
+ * ending. An unterminated block has no closer line and gains none: the parser reads it to the end
+ * of input either way.
+ */
+function grownCloser(closerRaw, marker, length) {
+    const match = /^( {0,3})([`~]+)([\s\S]*)$/.exec(closerRaw);
+    if (!match)
+        return closerRaw;
+    return match[1] + marker.repeat(Math.max(match[2].length, length)) + match[3];
+}
+// ── Registration ─────────────────────────────────────────────────────────────
+export function registerMermaidKind() {
+    const mermaid = declarePluginKind(MERMAID);
+    // No default chord: the edit affordance is the button, and this command exists for
+    // consumer keymap bindings.
+    registerBlockCommand(mermaid, 'mermaid.edit', (ctx) => {
+        const hooks = ctx.hooks;
+        if (!hooks)
+            return false;
+        hooks.openEdit();
+        return true;
+    });
+    const focusCommand = registerBlockCommand(mermaid, 'mermaid.focus', (ctx) => {
+        const hooks = ctx.hooks;
+        if (!hooks)
+            return false;
+        hooks.openFocusView();
+        return true;
+    });
+    registerBlockKind(mermaid, {
+        // Backspace from the block below must never merge text into a diagram.
+        mergeRole: 'not-mergeable',
+        editable: true,
+        supportsInline: false,
+        // ThematicBreak's focus-then-delete model: arrows stop on it, and a caret-adjacent
+        // Backspace focuses before a second press deletes.
+        blockFocus: 'whole-block',
+        // Leading edge only, for the same reason as thematicBreak: its focused Enter already
+        // inserts a paragraph below.
+        gapEdges: 'before',
+        container: {
+            // Raw is rebuilt from metadata alone, so it is exempt from the strip byte-check
+            // and guarded by the reparse + determinism probes instead.
+            contract: 'opaque',
+            rebuildRaw: rebuildMermaidRaw
+        },
+        // The char-based default would seed a rendered diagram at ~one line; the measured
+        // height supersedes this on mount.
+        estimateHeight: () => 320,
+        keymap: [{ chord: 'Mod+M', command: focusCommand }],
+        conformanceFixture: '```mermaid\ngraph TD\n```\n',
+        closure: {
+            roundTrip: {
+                mode: 'implemented',
+                via: 'container contract=opaque — rebuildMermaidRaw from metadata'
+            },
+            focus: {
+                mode: 'implemented',
+                via: 'blockFocus=whole-block — focus-then-delete; the component supplies the focus surface'
+            },
+            mergeBackspace: {
+                mode: 'implemented',
+                via: 'blockFocus=whole-block — caret-adjacent Backspace focuses, a second press deletes'
+            },
+            selectionPaint: { mode: 'implemented', via: 'whole-block cover rect via the container shim' },
+            searchPaint: {
+                mode: 'implemented',
+                via: 'raw scans as a leaf, painted via the container shim measurePartialRects; replace reparses the substituted bytes and applies when the kind survives'
+            },
+            reorder: {
+                mode: 'implemented',
+                via: 'Alt+ArrowUp/Down whole-block reorder (nudgeReorderUnit)'
+            },
+            undo: {
+                mode: 'implemented',
+                via: 'updateOwnMetadata — a code edit commits as one undoable metadataUpdate'
+            },
+            clipboard: {
+                mode: 'implemented',
+                via: 'focused-block Mod+C/Mod+X (handleWholeBlockKeys); a cross-block range carries the unit whole, per the kit byte-slice check'
+            },
+            simOracle: {
+                mode: 'implemented',
+                via: 'mermaid decoration/selection overlay e2e under the [invariant:] watcher'
+            }
+        }
+    });
+    registerBlockOpener(mermaid, {
+        // `fencedCode` accepts every fence, ```mermaid included, so this must price ahead
+        // of that superset matcher rather than slot into a gap between built-ins.
+        priority: OPENER_PRIORITIES.fencedCode - 5,
+        interruptsParagraph: (line) => matchMermaidFence(line) !== null,
+        tryOpen(ctx) {
+            const fence = matchMermaidFence(ctx.line.text);
+            if (!fence)
+                return null;
+            let closeIdx = -1;
+            for (let i = ctx.index + 1; i < ctx.end; i++) {
+                if (matchFenceClose(ctx.lines[i].text, fence.marker, fence.length)) {
+                    closeIdx = i;
+                    break;
+                }
+            }
+            // Unterminated consumes to end of input, like the built-in fence.
+            const codeEnd = closeIdx === -1 ? ctx.end : closeIdx;
+            const code = ctx.lines
+                .slice(ctx.index + 1, codeEnd)
+                .map((l) => l.raw)
+                .join('');
+            const node = {
+                kind: mermaid,
+                leadingTrivia: ctx.leadingTrivia,
+                raw: '',
+                children: []
+            };
+            setPluginMetadata(node, {
+                code,
+                openerIndent: fence.indent,
+                fenceChar: fence.marker,
+                fenceLength: fence.length,
+                infoRaw: fence.infoRaw,
+                openerLineEnding: ctx.line.lineEnding,
+                closerRaw: closeIdx === -1 ? '' : ctx.lines[closeIdx].raw
+            });
+            // Raw comes from the rebuild, so opener and rebuild agree by construction.
+            rebuildMermaidRaw(node);
+            return { node, consumed: (closeIdx === -1 ? ctx.end : closeIdx + 1) - ctx.index };
+        }
+    });
+}

package/dist/plugins/mermaid/mermaid-renderer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The renderer-adapter seam: this module holds the injected renderer slot and the
+ * memo, never the engine, which is confined to the `/renderer` subpath so it never
+ * rides the core bundle. The engine travels by module because `MermaidBlock` mounts
+ * with standard block props. No default: absent a renderer the code renders statically.
+ */
+/** What the editor knows at render time that the diagram text does not carry. */
+export interface MermaidRenderContext {
+    /** The engine paints colors into the SVG, so a stylesheet cannot retheme a drawn
+     *  diagram: the renderer has to draw for the theme. */
+    theme: string;
+}
+/** Third parameter, so an existing `(code, id) => …` renderer stays assignable. */
+export type MermaidRenderer = (code: string, id: string, context: MermaidRenderContext) => Promise<string>;
+export interface MermaidRenderResult {
+    svg?: string;
+    error?: string;
+}
+/** Exported so the eviction test derives its churn count from the real bound. */
+export declare const MERMAID_MEMO_CAP = 256;
+export declare function setMermaidRenderer(renderer: MermaidRenderer | null): void;
+export declare function hasMermaidRenderer(): boolean;
+/**
+ * Theme belongs in the memo key rather than in a cache reset, so flipping back is a hit; an
+ * SVG string needs no per-caller clone. A parse failure resolves to an `error` and caches
+ * like a success. `theme` is required, so a caller cannot forget it and still compile.
+ */
+export declare function renderMermaid(code: string, theme: string): Promise<MermaidRenderResult>;

package/dist/plugins/mermaid/mermaid-renderer.js

@@ -0,0 +1,35 @@
+/**
+ * The renderer-adapter seam: this module holds the injected renderer slot and the
+ * memo, never the engine, which is confined to the `/renderer` subpath so it never
+ * rides the core bundle. The engine travels by module because `MermaidBlock` mounts
+ * with standard block props. No default: absent a renderer the code renders statically.
+ */
+import { createBoundedMemo } from '../../plugin';
+/** Exported so the eviction test derives its churn count from the real bound. */
+export const MERMAID_MEMO_CAP = 256;
+const newMemo = () => createBoundedMemo({ cap: MERMAID_MEMO_CAP });
+let activeRenderer = null;
+// The primitive owns no reset, so re-instantiation is how a renderer swap clears it.
+let memo = newMemo();
+let renderSeq = 0;
+export function setMermaidRenderer(renderer) {
+    activeRenderer = renderer;
+    memo = newMemo();
+}
+export function hasMermaidRenderer() {
+    return activeRenderer !== null;
+}
+/**
+ * Theme belongs in the memo key rather than in a cache reset, so flipping back is a hit; an
+ * SVG string needs no per-caller clone. A parse failure resolves to an `error` and caches
+ * like a success. `theme` is required, so a caller cannot forget it and still compile.
+ */
+export function renderMermaid(code, theme) {
+    // NUL-joined so no (theme, code) pair can concatenate into another's key.
+    return memo(`${theme}\0${code}`, () => {
+        const renderer = activeRenderer;
+        return renderer
+            ? renderer(code, `aragonite-mermaid-${renderSeq++}`, { theme }).then((svg) => ({ svg }), (reason) => ({ error: reason instanceof Error ? reason.message : String(reason) }))
+            : Promise.resolve({ error: 'renderer not configured' });
+    });
+}

package/dist/plugins/mermaid/register.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The renderer is injected because the engine is the consumer's dependency; absent
+ * one the block renders its code statically. The plugin unit installs this setup once
+ * per process, so it runs unguarded.
+ */
+import { type EditorPlugin } from '../../plugin';
+import { type MermaidRenderer } from './mermaid-renderer';
+export declare function mermaidPlugin(options?: {
+    renderer?: MermaidRenderer;
+}): EditorPlugin;

package/dist/plugins/mermaid/register.js

@@ -0,0 +1,20 @@
+/**
+ * The renderer is injected because the engine is the consumer's dependency; absent
+ * one the block renders its code statically. The plugin unit installs this setup once
+ * per process, so it runs unguarded.
+ */
+import { definePluginBlock } from '../../plugin';
+import { registerMermaidKind, MERMAID } from './mermaid-kind';
+import { setMermaidRenderer } from './mermaid-renderer';
+import MermaidBlock from './MermaidBlock.svelte';
+export function mermaidPlugin(options) {
+    return definePluginBlock({
+        name: 'mermaid',
+        kind: MERMAID,
+        component: MermaidBlock,
+        register() {
+            setMermaidRenderer(options?.renderer ?? null);
+            registerMermaidKind();
+        }
+    });
+}

package/dist/plugins/mermaid/renderer.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The engine adapter behind the `@voithos-labs/aragonite/plugins/mermaid/renderer` subpath, the
+ * consumer half of the injection seam. The dynamic import keeps the engine off module
+ * eval, so nothing touches `document` until a diagram actually renders.
+ */
+import type { MermaidRenderer } from './mermaid-renderer';
+/**
+ * Chained, not concurrent: the site config is process-global, so two renders straddling a
+ * theme flip would interleave and one diagram would come back half-themed.
+ */
+export declare const mermaidRenderer: MermaidRenderer;

package/dist/plugins/mermaid/renderer.js

@@ -0,0 +1,53 @@
+/**
+ * The engine adapter behind the `@voithos-labs/aragonite/plugins/mermaid/renderer` subpath, the
+ * consumer half of the injection seam. The dynamic import keeps the engine off module
+ * eval, so nothing touches `document` until a diagram actually renders.
+ */
+/** Respread on every re-initialize, because mermaid's `initialize` replaces the site
+ *  config rather than patching it. */
+const BASE_CONFIG = {
+    startOnLoad: false,
+    securityLevel: 'strict',
+    // A parse failure must reject the promise so the plugin renders the legible error,
+    // rather than inject mermaid's own error SVG into the DOM.
+    suppressErrorRendering: true
+};
+const MERMAID_THEMES = new Set(['default', 'base', 'dark', 'forest', 'neutral']);
+/**
+ * Mermaid's own names pass through, so a consumer can name its editor theme `'forest'` and
+ * get it; anything else falls to mermaid's light palette. Wrapping this injected renderer to
+ * rewrite `context.theme` is how a custom theme maps.
+ */
+function toMermaidTheme(editorTheme) {
+    return (MERMAID_THEMES.has(editorTheme) ? editorTheme : 'default');
+}
+let engine = null;
+let configuredTheme = null;
+let queue = Promise.resolve();
+function loadMermaid() {
+    if (!engine)
+        engine = import('mermaid').then(({ default: mermaid }) => mermaid);
+    return engine;
+}
+async function renderThemed(code, id, theme) {
+    const mermaid = await loadMermaid();
+    // `render(id, text)` takes no config argument, so re-initializing is the only way a theme
+    // reaches a render without prepending `%%{init}%%`, which front matter forbids.
+    if (theme !== configuredTheme) {
+        mermaid.initialize({ ...BASE_CONFIG, theme });
+        configuredTheme = theme;
+    }
+    const { svg } = await mermaid.render(id, code);
+    return svg;
+}
+/**
+ * Chained, not concurrent: the site config is process-global, so two renders straddling a
+ * theme flip would interleave and one diagram would come back half-themed.
+ */
+export const mermaidRenderer = (code, id, context) => {
+    const theme = toMermaidTheme(context?.theme ?? 'dark');
+    const svg = queue.then(() => renderThemed(code, id, theme));
+    // The chain must survive a rejection, or one bad diagram strands every later render.
+    queue = svg.then(() => { }, () => { });
+    return svg;
+};

package/dist/plugins/parrot/ParrotBlock.svelte

@@ -0,0 +1,342 @@
+<!-- ParrotBlock.svelte -->
+<script lang="ts">
+	import { createEditableLeaf, type NodeView } from '../../plugin';
+
+	let { node, index, myPath = [] }: { node: NodeView; index: number; myPath?: number[] } = $props();
+	let sourceEl: HTMLDivElement | undefined = $state();
+	let revealed = $state(false);
+
+	const leaf = createEditableLeaf({
+		getNode: () => node,
+		getIndex: () => index,
+		getPath: () => myPath,
+		getEl: () => sourceEl ?? null,
+		mode: 'render-primary',
+		singleLine: true,
+		isRevealed: () => revealed,
+		setRevealed: (next) => (revealed = next)
+	});
+
+	// The canonical ten, via terminal-parrot (MIT).
+	const FRAMES = [
+		String.raw`
+                         .cccc;;cc;';c.
+                      .,:dkdc:;;:c:,:d:.
+                     .loc'.,cc::c:::,..;:.
+                   .cl;....;dkdccc::,...c;
+                  .c:,';:'..ckc',;::;....;c.
+                .c:'.,dkkoc:ok:;llllc,,c,';:.
+               .;c,';okkkkkkkk:;lllll,:kd;.;:,.
+               co..:kkkkkkkkkk:;llllc':kkc..oNc
+             .cl;.,oxkkkkkkkkkc,:cll;,okkc'.cO;
+             ;k:..ckkkkkkkkkkkl..,;,.;xkko:',l'
+            .,...';dkkkkkkkkkkd;.....ckkkl'.cO;
+         .,,:,.;oo:ckkkkkkkkkkkdoc;;cdkkkc..cd,
+      .cclo;,ccdkkl;llccdkkkkkkkkkkkkkkkd,.c;
+     .lol:;;okkkkkxooc::coodkkkkkkkkkkkko'.oc
+   .c:'..lkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkd,.oc
+  .lo;,:cdkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkd,.c;
+,dx:..;lllllllllllllllllllllllllllllllllc'...
+cNO;........................................
+`,
+		String.raw`
+                .ckx;'........':c.
+             .,:c:::::oxxocoo::::,',.
+            .odc'..:lkkoolllllo;..;d,
+            ;c..:o:..;:..',;'.......;.
+           ,c..:0Xx::o:.,cllc:,'::,.,c.
+           ;c;lkXKXXXXl.;lllll;lKXOo;':c.
+         ,dc.oXXXXXXXXl.,lllll;lXXXXx,c0:
+         ;Oc.oXXXXXXXXo.':ll:;'oXXXXO;,l'
+         'l;;kXXXXXXXXd'.'::'..dXXXXO;,l'
+         'l;:0XXXXXXXX0x:...,:o0XXXXx,:x,
+         'l;;kXXXXXXXXXKkol;oXXXXXXXO;oNc
+        ,c'..ckk0XXXXXXXXXX00XXXXXXX0:;o:.
+      .':;..:do::ooookXXXXXXXXXXXXXXXo..c;
+    .',',:co0XX0kkkxxOXXXXXXXXXXXXXXXOc..;l.
+  .:;'..oXXXXXXXXXXXXXXXXXXXXXXXXXXXXXko;';:.
+.ldc..:oOXKXXXXXXKXXKXXXXXXXXXXXXXXXXXXXo..oc
+:0o...:dxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxo,.:,
+cNo........................................;'
+`,
+		String.raw`
+            .cc;.  ...  .;c.
+         .,,cc:cc:lxxxl:ccc:;,.
+        .lo;...lKKklllookl..cO;
+      .cl;.,:'.okl;..''.;,..';:.
+     .:o;;dkd,.ll..,cc::,..,'.;:,.
+     co..lKKKkokl.':lloo;''ol..;dl.
+   .,c;.,xKKKKKKo.':llll;.'oOxl,.cl,.
+   cNo..lKKKKKKKo'';llll;;okKKKl..oNc
+   cNo..lKKKKKKKko;':c:,'lKKKKKo'.oNc
+   cNo..lKKKKKKKKKl.....'dKKKKKxc,l0:
+   .c:'.lKKKKKKKKKk;....lKKKKKKo'.oNc
+     ,:.'oxOKKKKKKKOxxxxOKKKKKKxc,;ol:.
+     ;c..'':oookKKKKKKKKKKKKKKKKKk:.'clc.
+   ,xl'.,oxo;'';oxOKKKKKKKKKKKKKKKOxxl:::;,.
+  .dOc..lKKKkoooookKKKKKKKKKKKKKKKKKKKxl,;ol.
+  cx,';okKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKl..;lc.
+  co..:dddddddddddddddddddddddddddddddddl::',::.
+  co...........................................
+`,
+		String.raw`
+           .ccccccc.
+      .,,,;cooolccoo;;,,.
+     .dOx;..;lllll;..;xOd.
+   .cdo;',loOXXXXXkll;';odc.
+  ,ol:;c,':oko:cccccc,...ckl.
+  ;c.;kXo..::..;c::'.......oc
+,dc..oXX0kk0o.':lll;..cxxc.,ld,
+kNo.'oXXXXXXo',:lll;..oXXOo;cOd.
+KOc;oOXXXXXXo.':lol;..dXXXXl';xc
+Ol,:k0XXXXXX0c.,clc'.:0XXXXx,.oc
+KOc;dOXXXXXXXl..';'..lXXXXXo..oc
+dNo..oXXXXXXXOx:..'lxOXXXXXk,.:; ..
+cNo..lXXXXXXXXXOolkXXXXXXXXXkl,..;:';.
+.,;'.,dkkkkk0XXXXXXXXXXXXXXXXXOxxl;,;,;l:.
+  ;c.;:''''':doOXXXXXXXXXXXXXXXXXXOdo;';clc.
+  ;c.lOdood:'''oXXXXXXXXXXXXXXXXXXXXXk,..;ol.
+  ';.:xxxxxocccoxxxxxxxxxxxxxxxxxxxxxxl::'.';;.
+  ';........................................;l'
+`,
+		String.raw`
+
+        .;:;;,.,;;::,.
+     .;':;........'co:.
+   .clc;'':cllllc::,.':c.
+  .lo;;o:coxdllllllc;''::,,.
+.c:'.,cl,.'l:',,;;'......cO;
+do;';oxoc;:l;;llllc'.';;'.,;.
+c..ckkkkkkkd,;llllc'.:kkd;.':c.
+'.,okkkkkkkkc;lllll,.:kkkdl,cO;
+..;xkkkkkkkkc,ccll:,;okkkkk:,co,
+..,dkkkkkkkkc..,;,'ckkkkkkkc;ll.
+..'okkkkkkkko,....'okkkkkkkc,:c.
+c..ckkkkkkkkkdl;,:okkkkkkkkd,.',';.
+d..':lxkkkkkkkkxxkkkkkkkkkkkdoc;,;'..'.,.
+o...'';llllldkkkkkkkkkkkkkkkkkkdll;..'cdo.
+o..,l;'''''';dkkkkkkkkkkkkkkkkkkkkdlc,..;lc.
+o..;lc;;;;;;,,;clllllllllllllllllllllc'..,:c.
+o..........................................;'
+`,
+		String.raw`
+
+           .,,,,,,,,,.
+         .ckKxodooxOOdcc.
+      .cclooc'....';;cool.
+     .loc;;;;clllllc;;;;;:;,.
+   .c:'.,okd;;cdo:::::cl,..oc
+  .:o;';okkx;';;,';::;'....,:,.
+  co..ckkkkkddkc,cclll;.,c:,:o:.
+  co..ckkkkkkkk:,cllll;.:kkd,.':c.
+.,:;.,okkkkkkkk:,cclll;.ckkkdl;;o:.
+cNo..ckkkkkkkkko,.;loc,.ckkkkkc..oc
+,dd;.:kkkkkkkkkx;..;:,.'lkkkkko,.:,
+  ;:.ckkkkkkkkkkc.....;ldkkkkkk:.,'
+,dc..'okkkkkkkkkxoc;;cxkkkkkkkkc..,;,.
+kNo..':lllllldkkkkkkkkkkkkkkkkkdcc,.;l.
+KOc,c;''''''';lldkkkkkkkkkkkkkkkkkc..;lc.
+xx:':;;;;,.,,...,;;cllllllllllllllc;'.;od,
+cNo.....................................oc
+`,
+		String.raw`
+
+
+                   .ccccccc.
+               .ccckNKOOOOkdcc.
+            .;;cc:ccccccc:,:c::,,.
+         .c;:;.,cccllxOOOxlllc,;ol.
+        .lkc,coxo:;oOOxooooooo;..:,
+      .cdc.,dOOOc..cOd,.',,;'....':l.
+      cNx'.lOOOOxlldOc..;lll;.....cO;
+     ,do;,:dOOOOOOOOOl'':lll;..:d:''c,
+     co..lOOOOOOOOOOOl'':lll;.'lOd,.cd.
+     co.'dOOOOOOOOOOOo,.;llc,.,dOOc..dc
+     co..lOOOOOOOOOOOOc.';:,..cOOOl..oc
+   .,:;.'::lxOOOOOOOOOo:'...,:oOOOc.'dc
+   ;Oc..cl'':lldOOOOOOOOdcclxOOOOx,.cd.
+  .:;';lxl''''':lldOOOOOOOOOOOOOOc..oc
+,dl,.'cooc:::,....,::coooooooooooc'.c:
+cNo.................................oc
+`,
+		String.raw`
+
+
+
+                        .cccccccc.
+                  .,,,;;cc:cccccc:;;,.
+                .cdxo;..,::cccc::,..;l.
+               ,do:,,:c:coxxdllll:;,';:,.
+             .cl;.,oxxc'.,cc,.';;;'...oNc
+             ;Oc..cxxxc'.,c;..;lll;...cO;
+           .;;',:ldxxxdoldxc..;lll:'...'c,
+           ;c..cxxxxkxxkxxxc'.;lll:'','.cdc.
+         .c;.;odxxxxxxxxxxxd;.,cll;.,l:.'dNc
+        .:,''ccoxkxxkxxxxxxx:..,:;'.:xc..oNc
+      .lc,.'lc':dxxxkxxxxxxxol,...',lx:..dNc
+     .:,',coxoc;;ccccoxxxxxxxxo:::oxxo,.cdc.
+  .;':;.'oxxxxxc''''';cccoxxxxxxxxxxxc..oc
+,do:'..,:llllll:;;;;;;,..,;:lllllllll;..oc
+cNo.....................................oc
+`,
+		String.raw`
+
+
+                              .ccccc.
+                         .cc;'coooxkl;.
+                     .:c:::c:,,,,,;c;;,.'.
+                   .clc,',:,..:xxocc;'..c;
+                  .c:,';:ox:..:c,,,,,,...cd,
+                .c:'.,oxxxxl::l:.,loll;..;ol.
+                ;Oc..:xxxxxxxxx:.,llll,....oc
+             .,;,',:loxxxxxxxxx:.,llll;.,,.'ld,
+            .lo;..:xxxxxxxxxxxx:.'cllc,.:l:'cO;
+           .:;...'cxxxxxxxxxxxxoc;,::,..cdl;;l'
+         .cl;':,'';oxxxxxxdxxxxxx:....,cooc,cO;
+     .,,,::;,lxoc:,,:lxxxxxxxxxxxo:,,;lxxl;'oNc
+   .cdxo;':lxxxxxxc'';cccccoxxxxxxxxxxxxo,.;lc.
+  .loc'.'lxxxxxxxxocc;''''';ccoxxxxxxxxx:..oc
+olc,..',:cccccccccccc:;;;;;;;;:ccccccccc,.'c,
+Ol;......................................;l'
+`,
+		String.raw`
+
+                              ,ddoodd,
+                         .cc' ,ooccoo,'cc.
+                      .ccldo;...',,...;oxdc.
+                   .,,:cc;.,'..;lol;;,'..lkl.
+                  .dOc';:ccl;..;dl,.''.....oc
+                .,lc',cdddddlccld;.,;c::'..,cc:.
+                cNo..:ddddddddddd;':clll;,c,';xc
+               .lo;,clddddddddddd;':clll;:kc..;'
+             .,c;..:ddddddddddddd:';clll,;ll,..
+             ;Oc..';:ldddddddddddl,.,c:;';dd;..
+           .''',:c:,'cdddddddddddo:,''..'cdd;..
+         .cdc';lddd:';lddddddddddddd;.';lddl,..
+      .,;::;,cdddddol;;lllllodddddddlcldddd:.'l;
+     .dOc..,lddddddddlcc:;'';cclddddddddddd;;ll.
+   .coc,;::ldddddddddddddlcccc:ldddddddddl:,cO;
+,xl::,..,cccccccccccccccccccccccccccccccc:;':xx,
+cNd.........................................;lOc
+`
+	];
+	// One strip the CSS scrolls a frame at a time. The closing newline is load-bearing: a `pre`
+	// drops a trailing blank line, and a strip a row short steps a fraction off every frame.
+	const REEL = FRAMES.join('\n') + '\n';
+	// The clip window's height, which is why every frame has to be the same number of rows.
+	const FRAME_ROWS = FRAMES[0].split('\n').length;
+
+	const caption = $derived(node.raw.slice('%%parrot'.length).trim());
+
+	export const editable = true;
+	export const focusable = true;
+	export const focus = leaf.focus;
+	export const getCursorOffset = leaf.getCursorOffset;
+	export const parkCaret = leaf.parkCaret;
+	export const focusAtColumn = leaf.focusAtColumn;
+	export const getSelectedText = leaf.getSelectedText;
+	export const setSelection = leaf.setSelection;
+	export const measurePartialRects = leaf.measurePartialRects;
+	export const runCommand = leaf.runCommand;
+	export const insertMarkdown = leaf.insertMarkdown;
+</script>
+
+<div
+	class="parrot-block"
+	{...leaf.renderProps}
+	style:--parrot-rows={FRAME_ROWS}
+	style:--parrot-frames={FRAMES.length}
+>
+	<div class="parrot" aria-hidden="true"><pre class="parrot-reel">{REEL}</pre></div>
+	{#if revealed}
+		<div
+			bind:this={sourceEl}
+			{...leaf.surfaceProps}
+			class="parrot-source"
+			aria-label="Party parrot source"
+		></div>
+	{:else}
+		<div
+			class="parrot-caption"
+			role="button"
+			tabindex="-1"
+			aria-label="Party parrot caption (click to edit)"
+		>
+			{caption}
+		</div>
+	{/if}
+</div>
+
+<style>
+	.parrot {
+		/* a terminal cell is about twice as tall as it is wide; prose line-height stretches the bird */
+		font-size: 1.1em;
+		line-height: 1.1;
+		letter-spacing: 0.05em;
+		/* one frame tall, in the reel's own rows so a step lands on the next frame exactly */
+		height: calc(var(--parrot-rows) * 1lh);
+		/* wider than a phone column, and the editor root pans if it isn't contained; the bar
+		   would sit across the bird, which is decoration rather than a pane to scroll */
+		overflow-x: auto;
+		overflow-y: hidden;
+		scrollbar-width: none;
+		/* chrome, not content: every frame is in the DOM and none of them belong in a copy */
+		user-select: none;
+		animation: parrot-hue 0.49s step-end infinite;
+	}
+	.parrot-reel {
+		/* type and rhythm come from the box above, so its `lh` is this reel's row exactly */
+		margin: 0;
+		animation-name: parrot-reel;
+		animation-duration: calc(var(--parrot-frames) * 70ms);
+		animation-timing-function: steps(var(--parrot-frames));
+		animation-iteration-count: infinite;
+	}
+	@keyframes parrot-reel {
+		to {
+			transform: translateY(-100%);
+		}
+	}
+	/* parrot.live's seven, stepped rather than blended so every run of the dance looks the same */
+	@keyframes parrot-hue {
+		0% {
+			color: #ff5f5f;
+		}
+		14.286% {
+			color: #ffc83d;
+		}
+		28.571% {
+			color: #3fd97a;
+		}
+		42.857% {
+			color: #5aa9ff;
+		}
+		57.143% {
+			color: #ff6ad5;
+		}
+		71.429% {
+			color: #3fd3d3;
+		}
+		85.714% {
+			color: var(--color-text-primary, #ffffff);
+		}
+	}
+	@media (prefers-reduced-motion: reduce) {
+		.parrot,
+		.parrot-reel {
+			animation: none;
+		}
+	}
+	.parrot-caption {
+		margin: 0.25em 0 0;
+		font-weight: 700;
+		cursor: text;
+	}
+	.parrot-source {
+		/* the bytes, dimmed the way the editor dims a marker */
+		opacity: 0.55;
+		font-family: monospace;
+		font-size: 0.9em;
+		outline: none;
+	}
+</style>