@joewinke/jatui 0.37.0 → 0.38.0

package/dist/artifact-blocks/blocks/diff-review/DiffReviewBlock.svelte.d.ts

@@ -0,0 +1,5 @@
+import type { BlockProps } from "../../types.js";
+import type { DiffReviewParams } from "./types.js";
+declare const DiffReviewBlock: import("svelte").Component<BlockProps<DiffReviewParams>, {}, "">;
+type DiffReviewBlock = ReturnType<typeof DiffReviewBlock>;
+export default DiffReviewBlock;

package/dist/artifact-blocks/blocks/diff-review/block.d.ts

@@ -0,0 +1,15 @@
+/**
+ * diff-review — per-section before/after diffs with accept / modify /
+ * reject, for contract and copy reviews (mos-a3ivi). Joe 2026-10-10: a BAA
+ * pass as a table is hard to review; each section should be a +/- diff with
+ * its own verdict, in the media-picker's review UX.
+ *
+ * Viewer decisions persist through ctx.saveState as
+ * `{ [itemId]: { verdict: "approve"|"modify"|"reject", note?, edited?, at,
+ * round?, history? } }` (decisions.ts) — the shape `mos-artifact feedback
+ * --json` hands back; the flat fields are the current round (mos-lsmve.6).
+ */
+import type { ArtifactBlockDef } from "../../types.js";
+import type { DiffReviewParams } from "./types.js";
+declare const diffReview: ArtifactBlockDef<DiffReviewParams>;
+export default diffReview;

package/dist/artifact-blocks/blocks/diff-review/block.js

@@ -0,0 +1,64 @@
+import DiffReviewBlock from "./DiffReviewBlock.svelte";
+import { diffRounds } from "./decisions.js";
+import { itemLabelOf, itemsOf } from "../../review/itemReview.js";
+import { diffReviewSchema } from "./schema.js";
+const example = {
+    title: "BAA simplification — pass 1",
+    intro: "Each section shows the current text against the proposed rewrite. Accept, modify (edit the proposed text yourself), or reject to keep the current text. Press ? for the keyboard map.",
+    groups: [
+        { id: "obligations", title: "Business associate obligations" },
+        { id: "term", title: "Term and termination" },
+    ],
+    items: [
+        {
+            id: "s4-2-safeguards",
+            group: "obligations",
+            title: "§4.2 Safeguards",
+            before: "Business Associate shall use appropriate safeguards, and comply, where applicable, with Subpart C of 45 C.F.R. Part 164 with respect to electronic protected health information, to prevent use or disclosure of the protected health information other than as provided for by the Agreement.",
+            after: "Business Associate shall use appropriate safeguards, and comply with Subpart C of 45 C.F.R. Part 164 for electronic protected health information, to prevent any use or disclosure not permitted by this Agreement.",
+            rationale: "Same obligation in plain words; drops 'where applicable' (Subpart C always applies to ePHI).",
+            risk: "low",
+            tags: ["plain language"],
+        },
+        {
+            id: "s4-5-breach-notice",
+            group: "obligations",
+            title: "§4.5 Breach notification window",
+            before: "Business Associate shall report to Covered Entity any Breach of Unsecured Protected Health Information without unreasonable delay and in no case later than sixty (60) calendar days after discovery.",
+            after: "Business Associate shall report to Covered Entity any Breach of Unsecured Protected Health Information without unreasonable delay and in no case later than ten (10) business days after discovery.",
+            rationale: "60 days is the regulatory ceiling for the covered entity, not a sensible window for the BA; 10 business days leaves the CE time to meet its own deadline.",
+            risk: "medium",
+        },
+        {
+            id: "s7-3-return",
+            group: "term",
+            title: "§7.3 Return or destruction (new)",
+            before: "",
+            after: "On termination, Business Associate shall return or destroy all protected health information within thirty (30) days and certify the destruction in writing.",
+            rationale: "The current agreement is silent on what happens to PHI at termination.",
+            risk: "high",
+        },
+    ],
+};
+const diffReview = {
+    type: "diff-review",
+    title: "Diff review (accept / modify / reject)",
+    description: "Section-by-section review of proposed text changes (the Redline review view) — contracts (BAA, MSA), policies, site copy, prompts. Each item is one section: {id, title, before (current text, '' for a new section), after (proposed text, '' to delete the section), rationale? (why — plain text), risk? low|medium|high, tags?, group?, team?}, optionally grouped via groups[]. Every item renders as a +/- diff through jatui HunkDiffView (word-level highlights; side by side when wide, unified on a phone — force with layout: 'split' | 'unified'), and the human marks it Accept / Modify / Reject with an optional note (Modify and Reject open the note). Modify opens an inline editor seeded with the proposed text; the reviewer's rewrite saves as `edited`. ROUNDS: after revising a section, republish it with `team: {status: 'ready', readySince: <ISO>}` — the first verdict in that new round locks the previous verdict + note into the section's history and the round starts blank (the old rewrite too); `team: {status: 'in_progress'}` just shows the Team status. Keys (the shared review map): j/k move, a accept (moves on), x modify, r reject, u undo, n note, e or Enter edit, f next section that needs you, ? help; decided sections sort to the end; a progress bar and filter chips with live counts sit on top. BULK ACCEPT: beside the filter chips, 'Accept all remaining (N)' (Shift+A) and — when any item carries a risk — 'Accept all low-risk (n)' accept every undecided, non-retest section the active filter shows, after one confirm; each group heading has 'Accept section (n)'. A bulk never overwrites a decided section, saves once, and offers Undo. So mark risk honestly: low-risk is the reviewer's one-click lane. Decisions persist per viewer as {[itemId]: {verdict: 'approve'|'modify'|'reject', note?, edited?, at, round?, history?: [{round, verdict, note, at}]}} — the flat fields are the CURRENT round; read them back with `mos-artifact feedback --slug <s> --json` — apply `after` for approve, `edited` (falling back to `after` when absent) for modify, keep `before` for reject (an `edited` under any other verdict is an unapplied draft). Limits: 100 items, 20,000 chars per side; a viewer's saved state shares the 64KB feedback cap, so keep sections to a clause or article, not the whole contract. Tip: quote both sides verbatim and keep item ids stable across republishes — verdicts are keyed on them.",
+    schema: diffReviewSchema,
+    component: DiffReviewBlock,
+    // mos-8fvt9: the section's Listen + comment sit on the heading row.
+    hostsTools: (p) => Boolean(p.title),
+    example,
+    interactive: true,
+    itemReview: {
+        vocabulary: [
+            { id: "approve", label: "Accept", tone: "success" },
+            { id: "modify", label: "Modify", tone: "warning" },
+            { id: "reject", label: "Reject", tone: "error" },
+        ],
+        name: "Changes",
+        items: (params, state) => itemsOf("diff", diffRounds, params, state),
+        itemLabel: itemLabelOf,
+    },
+};
+export default diffReview;

package/dist/artifact-blocks/blocks/diff-review/decisions.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Viewer decisions for the diff-review block (mos-a3ivi).
+ *
+ * Saved shape (the feedback channel's contract, read back by agents with
+ * `mos-artifact feedback --json`):
+ *
+ *   { [itemId]: { verdict?: "approve" | "modify" | "reject",
+ *                 note?: string,
+ *                 edited?: string } }
+ *
+ * `edited` is the reviewer's own rewrite of the proposed text. It is only
+ * authoritative when verdict is "modify"; under any other verdict it is a
+ * kept draft (an Undo or a change of mind never throws typing away).
+ *
+ * Rounds (mos-lsmve.6): the flat fields are the CURRENT round. When the team
+ * marks a section ready again (`team.readySince`) the first save locks the
+ * previous {verdict, note, at} into `history[]` and the round starts blank —
+ * `edited` too, since the proposal it rewrote has moved on
+ * (../../review/rounds.ts). `at` / `round` / `history` are optional; an entry
+ * saved before rounds existed reads exactly as it always did.
+ */
+import { type RoundLine } from "../../review/rounds.js";
+import { type NoteAttachment } from "../../review/attachments.js";
+export type DiffVerdict = "approve" | "modify" | "reject";
+export type DiffDecision = {
+    verdict?: DiffVerdict;
+    note?: string;
+    /** The note's voice/video/screen/file attachments (mos-rccb5). */
+    attachments?: NoteAttachment[];
+    edited?: string;
+    /** When this round was last saved (ISO). */
+    at?: string;
+    /** The round the flat fields answer (a team readySince). */
+    round?: string;
+    /** Locked earlier rounds, newest first. */
+    history?: RoundLine[];
+};
+export declare const diffRounds: {
+    roundOf: (entry: unknown) => string | null;
+    roundLabel: (round: string | null | undefined) => string;
+    sameRound: (a: string | null | undefined, b: string | null | undefined) => boolean;
+    isStale: (entry: unknown, current: string | null | undefined) => boolean;
+    parseHistory: (raw: unknown) => RoundLine[];
+    view: (raw: unknown, current: string | null | undefined, publisherHistory?: unknown) => import("../../review/rounds.js").RoundView;
+    save: (stored: unknown, patch: Record<string, unknown>, current: string | null | undefined) => Record<string, unknown>;
+};
+/** Cap on a saved rewrite — matches the schema's per-side cap. */
+export declare const EDITED_MAX_CHARS = 20000;
+/** Defensively validate one saved-state entry (untrusted stored JSON). */
+export declare function parseDecision(raw: unknown): DiffDecision | null;
+/** Parse the whole saved-state blob into decisions for this block. */
+export declare function parseDecisions(state: Record<string, unknown> | null): Record<string, DiffDecision>;
+/** True when a decision carries nothing worth saving. Locked history
+ * counts: an Undo in a new round must never drop the rounds before it. A
+ * note's attachments count as content too (a photo-only note is a real
+ * answer, mos-rccb5). */
+export declare function isEmptyDecision(d: DiffDecision | null | undefined): boolean;

package/dist/artifact-blocks/blocks/diff-review/decisions.js

@@ -0,0 +1,80 @@
+/**
+ * Viewer decisions for the diff-review block (mos-a3ivi).
+ *
+ * Saved shape (the feedback channel's contract, read back by agents with
+ * `mos-artifact feedback --json`):
+ *
+ *   { [itemId]: { verdict?: "approve" | "modify" | "reject",
+ *                 note?: string,
+ *                 edited?: string } }
+ *
+ * `edited` is the reviewer's own rewrite of the proposed text. It is only
+ * authoritative when verdict is "modify"; under any other verdict it is a
+ * kept draft (an Undo or a change of mind never throws typing away).
+ *
+ * Rounds (mos-lsmve.6): the flat fields are the CURRENT round. When the team
+ * marks a section ready again (`team.readySince`) the first save locks the
+ * previous {verdict, note, at} into `history[]` and the round starts blank —
+ * `edited` too, since the proposal it rewrote has moved on
+ * (../../review/rounds.ts). `at` / `round` / `history` are optional; an entry
+ * saved before rounds existed reads exactly as it always did.
+ */
+import { useRounds } from "../../review/rounds.js";
+import { readNoteAttachments, } from "../../review/attachments.js";
+const VERDICTS = ["approve", "modify", "reject"];
+export const diffRounds = useRounds({
+    verdictKey: "verdict",
+    verdicts: VERDICTS,
+    roundFields: ["edited"],
+});
+/** Cap on a saved rewrite — matches the schema's per-side cap. */
+export const EDITED_MAX_CHARS = 20_000;
+/** Defensively validate one saved-state entry (untrusted stored JSON). */
+export function parseDecision(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+        return null;
+    const r = raw;
+    const out = {};
+    if (typeof r.verdict === "string" &&
+        VERDICTS.includes(r.verdict))
+        out.verdict = r.verdict;
+    if (typeof r.note === "string" && r.note)
+        out.note = r.note;
+    const attachments = readNoteAttachments(r.attachments);
+    if (attachments)
+        out.attachments = attachments;
+    if (typeof r.edited === "string")
+        out.edited = r.edited.slice(0, EDITED_MAX_CHARS);
+    if (typeof r.at === "string" && r.at)
+        out.at = r.at.slice(0, 64);
+    if (typeof r.round === "string" && r.round)
+        out.round = r.round.slice(0, 200);
+    const history = diffRounds.parseHistory(r.history);
+    if (history.length > 0)
+        out.history = history;
+    return isEmptyDecision(out) ? null : out;
+}
+/** Parse the whole saved-state blob into decisions for this block. */
+export function parseDecisions(state) {
+    const out = {};
+    if (!state)
+        return out;
+    for (const [id, raw] of Object.entries(state)) {
+        const d = parseDecision(raw);
+        if (d)
+            out[id] = d;
+    }
+    return out;
+}
+/** True when a decision carries nothing worth saving. Locked history
+ * counts: an Undo in a new round must never drop the rounds before it. A
+ * note's attachments count as content too (a photo-only note is a real
+ * answer, mos-rccb5). */
+export function isEmptyDecision(d) {
+    return (!d ||
+        (!d.verdict &&
+            !d.note &&
+            !d.attachments?.length &&
+            d.edited === undefined &&
+            !d.history?.length));
+}

package/dist/artifact-blocks/blocks/diff-review/schema.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Params schema for the diff-review block (per-section before/after diffs
+ * with accept / modify / reject). Imported by block.ts and the tests.
+ *
+ * Untrusted input (CONTRACT.md): every string renders as text — the diffs go
+ * through jatui HunkDiffView's own DOM, never {@html}.
+ */
+import { z } from "zod";
+import type { DiffReviewParams } from "./types.js";
+/** One side of one section. 20k chars is a long contract article; 100
+ * sections at a realistic ~1–2k per side stay inside the ~256KB budget. */
+export declare const SIDE_MAX_CHARS = 20000;
+export declare const diffReviewSchema: z.ZodType<DiffReviewParams>;

package/dist/artifact-blocks/blocks/diff-review/schema.js

@@ -0,0 +1,84 @@
+/**
+ * Params schema for the diff-review block (per-section before/after diffs
+ * with accept / modify / reject). Imported by block.ts and the tests.
+ *
+ * Untrusted input (CONTRACT.md): every string renders as text — the diffs go
+ * through jatui HunkDiffView's own DOM, never {@html}.
+ */
+import { z } from "zod";
+import { itemTeamSchema } from "../../review/team.js";
+const ID_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+const idSchema = z
+    .string()
+    .regex(ID_RE, "id must be lowercase a-z0-9_- (max 64, leading a-z0-9)");
+/** One side of one section. 20k chars is a long contract article; 100
+ * sections at a realistic ~1–2k per side stay inside the ~256KB budget. */
+export const SIDE_MAX_CHARS = 20_000;
+const itemSchema = z
+    .object({
+    id: idSchema,
+    title: z.string().min(1, "title is required").max(200),
+    group: idSchema.optional(),
+    before: z.string().max(SIDE_MAX_CHARS),
+    after: z.string().max(SIDE_MAX_CHARS),
+    rationale: z.string().max(2000).optional(),
+    risk: z.enum(["low", "medium", "high"]).optional(),
+    tags: z.array(z.string().max(40)).max(8).optional(),
+    /** Team status: in_progress, or ready + readySince (opens a new round). */
+    team: itemTeamSchema.optional(),
+})
+    .check((ctx) => {
+    if (!ctx.value.before && !ctx.value.after)
+        ctx.issues.push({
+            code: "custom",
+            input: ctx.value,
+            path: ["after"],
+            message: "at least one of before / after must be non-empty",
+        });
+});
+const groupSchema = z.object({
+    id: idSchema,
+    title: z.string().min(1).max(120),
+});
+export const diffReviewSchema = z
+    .object({
+    title: z.string().max(200).optional(),
+    intro: z.string().max(2000).optional(),
+    groups: z.array(groupSchema).max(20).optional(),
+    items: z.array(itemSchema).max(100),
+    layout: z.enum(["auto", "split", "unified"]).optional(),
+})
+    .check((ctx) => {
+    // Cross-array rules: unique item ids (state keys on them), unique group
+    // ids, and every item's group exists in groups[] (or is omitted).
+    const value = ctx.value;
+    const itemIds = new Set();
+    value.items.forEach((it, i) => {
+        if (itemIds.has(it.id))
+            ctx.issues.push({
+                code: "custom",
+                input: it,
+                path: ["items", i, "id"],
+                message: `duplicate item id "${it.id}"`,
+            });
+        itemIds.add(it.id);
+        if (it.group && !value.groups?.some((g) => g.id === it.group))
+            ctx.issues.push({
+                code: "custom",
+                input: it,
+                path: ["items", i, "group"],
+                message: `group "${it.group}" is not in groups[]`,
+            });
+    });
+    const groupIds = new Set();
+    value.groups?.forEach((g, i) => {
+        if (groupIds.has(g.id))
+            ctx.issues.push({
+                code: "custom",
+                input: g,
+                path: ["groups", i, "id"],
+                message: `duplicate group id "${g.id}"`,
+            });
+        groupIds.add(g.id);
+    });
+});

package/dist/artifact-blocks/blocks/diff-review/types.d.ts

@@ -0,0 +1,35 @@
+/**
+ * diff-review param types (mos-a3ivi) — the hand-written mirror of the zod
+ * schema in schema.ts. The schema is annotated `z.ZodType<DiffReviewParams>`,
+ * so drift is a compile error, and the component imports types WITHOUT the
+ * def module (block.ts imports the component; the edge stays one-way).
+ */
+import type { ItemTeam } from "../../review/team.js";
+export type DiffReviewRisk = "low" | "medium" | "high";
+export type DiffReviewItem = {
+    id: string;
+    title: string;
+    group?: string | undefined;
+    /** Current text ("" = a section the proposal adds). */
+    before: string;
+    /** Proposed text ("" = a section the proposal deletes). */
+    after: string;
+    /** Why the change is proposed (plain text). */
+    rationale?: string | undefined;
+    risk?: DiffReviewRisk | undefined;
+    tags?: string[] | undefined;
+    /** Team status (D7): `ready` + readySince opens a new review round. */
+    team?: ItemTeam | undefined;
+};
+export type DiffReviewGroup = {
+    id: string;
+    title: string;
+};
+export type DiffReviewParams = {
+    title?: string | undefined;
+    intro?: string | undefined;
+    groups?: DiffReviewGroup[] | undefined;
+    items: DiffReviewItem[];
+    /** auto (default): side by side when the block is wide, unified on a phone. */
+    layout?: "auto" | "split" | "unified" | undefined;
+};

package/dist/artifact-blocks/blocks/diff-review/types.js

@@ -0,0 +1 @@
+export {};

package/dist/artifact-blocks/blocks/explainer/ExplainerBlock.svelte

@@ -0,0 +1,145 @@
+<script lang="ts">
+  /**
+   * explainer block — embeds an existing 3D explainer (the explorer3d
+   * engine) by NAME (a shipped spec id under static/explorers/) or by URL.
+   *
+   * The 3D shell is the HOST's (`ctx.services.explorer3d`, MOS's Explorer3D;
+   * jatui ships no three.js). The block fetches the JSON spec client-side
+   * (the same contract as the explorer_3d site section), validates it with
+   * the host's `services.parseExplorerSpec` when given, and hands the result
+   * to the shell as `{ spec, poster, posterAlt, height, booking: false }` —
+   * which brings the whole v2 story with
+   * it: chapters (chip dock, play/pause, scrubber) and the narration toggle
+   * (mos-489bj: muted by default, captions always, respects the sound store
+   * and reduced motion). No three.js is imported until the canvas scrolls
+   * near the viewport on a WebGL-capable device; without WebGL the poster,
+   * parts list and tour still teach the model.
+   *
+   * Fails soft: no shell on this host, an unreachable URL or an invalid spec
+   * shows the poster (when given) and a quiet "not available" line — never a
+   * broken page, matching
+   * the site section's contract. Read-only safe: nothing here saves state.
+   *
+   * "Book this fix" is off here (mos-cui3c.1): an artifact page has no
+   * booking panel and no tenant /book to fall back to; the spec's plain
+   * `cta` links still render.
+   */
+  import { onMount } from "svelte"
+  import type { Component } from "svelte"
+  import type { BlockProps } from "../../types"
+  import { resolveModelUrl, type ExplainerParams } from "./schema"
+  import SectionTools from "../../SectionTools.svelte"
+
+  let { params, ctx }: BlockProps<ExplainerParams> = $props()
+
+  /** What the host's spec parser returns (MOS parseExplorerSpec's shape). */
+  type SpecResult =
+    | { ok: true; spec: unknown }
+    | { ok: false; errors: string[] }
+
+  // The host's 3D shell + optional parser (HostAdapter.services). No shell →
+  // the poster and a "not available here" line; nothing is fetched.
+  const Explorer3D = $derived(
+    ctx?.services?.explorer3d as Component<Record<string, unknown>> | undefined,
+  )
+  const parseSpec = $derived(
+    ctx?.services?.parseExplorerSpec as
+      | ((json: unknown) => SpecResult)
+      | undefined,
+  )
+
+  const url = $derived(resolveModelUrl(params ?? {}))
+  let fetched = $state<SpecResult | null>(null)
+
+  onMount(() => {
+    if (!url || !Explorer3D) return
+    const parse = parseSpec
+    const ctrl = new AbortController()
+    fetch(url, { signal: ctrl.signal })
+      .then((r) => {
+        if (!r.ok) throw new Error(`HTTP ${r.status}`)
+        return r.json()
+      })
+      .then((json) => {
+        let result: SpecResult
+        try {
+          result = parse ? parse(json) : { ok: true, spec: json }
+        } catch (e) {
+          result = {
+            ok: false,
+            errors: [e instanceof Error ? e.message : "invalid spec"],
+          }
+        }
+        if (!result.ok) console.warn("[explainer] invalid spec", result.errors)
+        fetched = result
+      })
+      .catch((e: unknown) => {
+        if (ctrl.signal.aborted) return
+        fetched = {
+          ok: false,
+          errors: [e instanceof Error ? e.message : "failed to load"],
+        }
+      })
+    return () => ctrl.abort()
+  })
+
+  const height = $derived(`${params?.heightPx ?? 520}px`)
+</script>
+
+<figure class="artifact-explainer w-full">
+  {#if params?.title}
+    <figcaption
+      class="mb-2 flex items-center gap-2 text-sm font-medium text-base-content/70"
+    >
+      <span class="min-w-0">{params.title}</span>
+      <SectionTools {ctx} inline />
+    </figcaption>
+  {/if}
+
+  {#if fetched?.ok && Explorer3D}
+    <Explorer3D
+      spec={fetched.spec}
+      poster={params?.poster ?? ""}
+      posterAlt={params?.posterAlt ?? ""}
+      {height}
+      booking={false}
+    />
+  {:else if fetched || !Explorer3D}
+    <!-- Invalid spec or unreachable URL: the poster still teaches, the page
+         stands. The parse errors go to the console (the site section's rule). -->
+    {#if params?.poster}
+      <img
+        src={params.poster}
+        alt={params.posterAlt ?? ""}
+        class="max-h-[70vh] rounded-box"
+        loading="lazy"
+        decoding="async"
+      />
+    {/if}
+    <p class="mt-3 text-sm text-base-content/60">
+      {Explorer3D
+        ? "The interactive model is not available right now."
+        : "The interactive 3D model is not available here."}
+    </p>
+  {:else}
+    <div
+      class="grid min-h-64 place-items-center rounded-box border border-base-content/10 bg-base-200/50"
+    >
+      {#if params?.poster}
+        <img
+          src={params.poster}
+          alt={params.posterAlt ?? ""}
+          class="max-h-[60vh] rounded-box"
+          loading="lazy"
+          decoding="async"
+        />
+      {:else}
+        <p class="text-sm text-base-content/60">Loading the model</p>
+      {/if}
+    </div>
+  {/if}
+
+  {#if params?.caption}
+    <p class="mt-3 text-sm text-base-content/60">{params.caption}</p>
+  {/if}
+</figure>

package/dist/artifact-blocks/blocks/explainer/ExplainerBlock.svelte.d.ts

@@ -0,0 +1,5 @@
+import type { Component } from "svelte";
+import type { BlockProps } from "../../types";
+declare const ExplainerBlock: Component<BlockProps<ExplainerParams>, {}, "">;
+type ExplainerBlock = ReturnType<typeof ExplainerBlock>;
+export default ExplainerBlock;

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

@@ -0,0 +1,8 @@
+/**
+ * explainer block — embeds an existing 3D explainer by id or URL through the
+ * Explorer3D shell (chapters + the narration toggle come with the shell).
+ */
+import type { ArtifactBlockDef } from "../../types";
+import { type ExplainerParams } from "./schema";
+declare const def: ArtifactBlockDef<ExplainerParams>;
+export default def;

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

@@ -0,0 +1,21 @@
+import ExplainerBlock from "./ExplainerBlock.svelte";
+import { explainerSchema } from "./schema";
+const EXAMPLE = {
+    model: "water-heater",
+    title: "Inside your tank water heater",
+    caption: "Turn it, open the cutaway and play the story: sediment builds, the anode sacrifices itself, and a flush resets the clock.",
+    poster: "https://example.com/explorers/edu-inside-your-water-heater.webp",
+    posterAlt: "Labeled diagram of a tank water heater",
+    heightPx: 520,
+};
+const def = {
+    type: "explainer",
+    title: "3D explainer",
+    description: 'Embeds an existing 3D explainer — the interactive cutaway/exploded-view models shipped as JSON specs — by NAME or URL: model is a shipped explainer id ("water-heater", "burst-pipe", "drain-trap", "tankless", … — the specs under static/explorers/, resolved to /explorers/<id>.json on the host origin) and modelUrl is an explicit https:// or root-relative spec URL; set exactly one. The shell brings the whole experience: turn/zoom, cutaway, part cards, and for version-2 specs the chapter story (chip dock with play/pause and a scrubber) plus the narration toggle — muted by default, captions always visible, honors the viewer\'s sound settings and reduced motion. Optional title and caption frame it; poster/posterAlt (poster requires posterAlt) show a labeled still until 3D loads and forever without WebGL; heightPx is the stage height (default 520). The 3D shell is a host service (HostAdapter services.explorer3d, optional services.parseExplorerSpec); on a host without one the block shows the poster and a "not available here" notice. An unreachable or invalid spec fails soft to the poster and a quiet notice — never a broken page. Tip: let the spec tell the story — don\'t duplicate its chapter text in surrounding blocks; link to the service page the spec\'s CTA points at.',
+    schema: explainerSchema,
+    component: ExplainerBlock,
+    // 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/explainer/schema.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Params schema for the explainer block (embeds an existing 3D explainer
+ * spec through the Explorer3D shell). Imported by block.ts (def),
+ * ExplainerBlock.svelte (props typing) and the tests — keeps them cycle-free.
+ *
+ * Untrusted input rules (CONTRACT.md): the model reference is either a
+ * KNOWN explainer id (resolved to the root-relative /explorers/<id>.json
+ * the shell serves) or an explicit https:// / root-relative URL via the
+ * shared urlSchema — never any other scheme, never a data: blob. Text
+ * fields are length-capped; height is a validated number, not a CSS string.
+ */
+import { z } from "zod";
+export declare const explainerSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    modelUrl: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    title: z.ZodOptional<z.ZodString>;
+    caption: z.ZodOptional<z.ZodString>;
+    poster: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    posterAlt: z.ZodOptional<z.ZodString>;
+    heightPx: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+/** The URL an explainer reference resolves to. */
+export declare function resolveModelUrl(params: {
+    model?: string;
+    modelUrl?: string;
+}): string | null;

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

@@ -0,0 +1,69 @@
+/**
+ * Params schema for the explainer block (embeds an existing 3D explainer
+ * spec through the Explorer3D shell). Imported by block.ts (def),
+ * ExplainerBlock.svelte (props typing) and the tests — keeps them cycle-free.
+ *
+ * Untrusted input rules (CONTRACT.md): the model reference is either a
+ * KNOWN explainer id (resolved to the root-relative /explorers/<id>.json
+ * the shell serves) or an explicit https:// / root-relative URL via the
+ * shared urlSchema — never any other scheme, never a data: blob. Text
+ * fields are length-capped; height is a validated number, not a CSS string.
+ */
+import { z } from "zod";
+import { optionalUrlSchema, shortTextSchema } from "../../params";
+/** Explainer ids are kebab-case (static/explorers/<id>.json). */
+const EXPLAINER_ID_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
+export const explainerSchema = z
+    .object({
+    /**
+     * A shipped explainer's id — resolves to /explorers/<id>.json on the MOS
+     * origin (e.g. "water-heater", "burst-pipe"). Exactly one of this or
+     * modelUrl.
+     */
+    model: z
+        .string()
+        .regex(EXPLAINER_ID_RE, "explainer id must be lowercase a-z0-9-")
+        .optional(),
+    /** An explicit spec URL (https:// or root-relative). Exactly one. */
+    modelUrl: optionalUrlSchema,
+    /** Optional heading above the explorer. */
+    title: shortTextSchema.optional(),
+    /** Optional line under the explorer. */
+    caption: shortTextSchema.optional(),
+    /** Poster shown until 3D loads (and without WebGL) — an image URL. */
+    poster: optionalUrlSchema,
+    /** Alt text for the poster (required when a poster is set). */
+    posterAlt: shortTextSchema.optional(),
+    /** Stage height in px (default 520). */
+    heightPx: z.number().int().min(320).max(900).default(520),
+})
+    .superRefine((v, ctx) => {
+    const both = v.model !== undefined && v.modelUrl !== undefined;
+    const neither = v.model === undefined && v.modelUrl === undefined;
+    if (both)
+        ctx.addIssue({
+            code: "custom",
+            path: ["model"],
+            message: "set either model or modelUrl, not both",
+        });
+    if (neither)
+        ctx.addIssue({
+            code: "custom",
+            path: ["model"],
+            message: "set model (a shipped explainer id) or modelUrl",
+        });
+    if (v.poster && !v.posterAlt)
+        ctx.addIssue({
+            code: "custom",
+            path: ["posterAlt"],
+            message: "a poster requires posterAlt (it is the fallback's alt text)",
+        });
+});
+/** The URL an explainer reference resolves to. */
+export function resolveModelUrl(params) {
+    if (params.model)
+        return `/explorers/${params.model}.json`;
+    if (params.modelUrl)
+        return params.modelUrl;
+    return null;
+}

package/dist/artifact-blocks/blocks/group-content.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The content blocks (block task jatui-zy9n5). This barrel is the ONLY shared
+ * file that task edits: add a block by importing its def and appending it to
+ * BLOCKS, and remove its type from PENDING in the same change. builtins.ts
+ * concatenates the four group barrels; nothing else lists blocks.
+ */
+import type { ArtifactBlockDef } from "../types.js";
+export declare const BLOCKS: ArtifactBlockDef<any>[];
+/** This group's MOS block types still being ported. */
+export declare const PENDING: readonly string[];