@joewinke/jatui 0.36.3 → 0.38.0

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

@@ -0,0 +1,123 @@
+/**
+ * Params schema for the map block (Google map of markers + optional routes).
+ * Imported by block.ts (def), MapBlock.svelte (props typing) and the tests —
+ * keeps them cycle-free.
+ *
+ * Tone is a THEME token (never a color literal): the component resolves it
+ * against the live theme's CSS vars at render, because Google's canvas sits
+ * outside the DOM cascade and cannot read `var(--color-*)` directly.
+ */
+import { z } from "zod";
+declare const mapMarkerSchema: z.ZodObject<{
+    label: z.ZodString;
+    lat: z.ZodNumber;
+    lng: z.ZodNumber;
+    tone: z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+        info: "info";
+        success: "success";
+        primary: "primary";
+        secondary: "secondary";
+        neutral: "neutral";
+        accent: "accent";
+    }>>;
+    popup: z.ZodOptional<z.ZodString>;
+    address: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const mapRouteSchema: z.ZodObject<{
+    label: z.ZodOptional<z.ZodString>;
+    tone: z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+        info: "info";
+        success: "success";
+        primary: "primary";
+        secondary: "secondary";
+        neutral: "neutral";
+        accent: "accent";
+    }>>;
+    points: z.ZodArray<z.ZodObject<{
+        lat: z.ZodNumber;
+        lng: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const mapSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    height: z.ZodOptional<z.ZodNumber>;
+    center: z.ZodOptional<z.ZodObject<{
+        lat: z.ZodNumber;
+        lng: z.ZodNumber;
+    }, z.core.$strip>>;
+    zoom: z.ZodOptional<z.ZodNumber>;
+    fit: z.ZodOptional<z.ZodBoolean>;
+    markers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        lat: z.ZodNumber;
+        lng: z.ZodNumber;
+        tone: z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            warning: "warning";
+            info: "info";
+            success: "success";
+            primary: "primary";
+            secondary: "secondary";
+            neutral: "neutral";
+            accent: "accent";
+        }>>;
+        popup: z.ZodOptional<z.ZodString>;
+        address: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    routes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodOptional<z.ZodString>;
+        tone: z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            warning: "warning";
+            info: "info";
+            success: "success";
+            primary: "primary";
+            secondary: "secondary";
+            neutral: "neutral";
+            accent: "accent";
+        }>>;
+        points: z.ZodArray<z.ZodObject<{
+            lat: z.ZodNumber;
+            lng: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type MapMarker = z.infer<typeof mapMarkerSchema>;
+export type MapRoute = z.infer<typeof mapRouteSchema>;
+export type MapParams = z.infer<typeof mapSchema>;
+/** Defaults applied at render (the host stores what was published verbatim). */
+export declare const MAP_DEFAULTS: {
+    readonly height: 420;
+    readonly zoom: 12;
+    readonly fit: true;
+    readonly markerTone: "primary";
+    readonly routeTone: "info";
+};
+/** Normalized params with every default applied. */
+export declare function normalizeMap(params: MapParams): Required<Pick<MapParams, "height" | "zoom" | "fit">> & {
+    markers: MapMarker[];
+    routes: MapRoute[];
+    center: MapParams["center"];
+    title: MapParams["title"];
+};
+/** Marker tone with default filled. */
+export declare function toneOfMarker(m: MapMarker): string;
+/** Route tone with default filled. */
+export declare function toneOfRoute(r: MapRoute): string;
+/** Coordinate caption for the list fallback: "30.2672, -97.7431". */
+export declare function coordCaption(lat: number, lng: number): string;
+/**
+ * Bounds of every marker + route point — the fallback "area" caption and the
+ * test hook for fit behaviour. Null when there is nothing to fit.
+ */
+export declare function boundsOf(markers: MapMarker[], routes: MapRoute[]): {
+    minLat: number;
+    maxLat: number;
+    minLng: number;
+    maxLng: number;
+} | null;
+export {};

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

@@ -0,0 +1,113 @@
+/**
+ * Params schema for the map block (Google map of markers + optional routes).
+ * Imported by block.ts (def), MapBlock.svelte (props typing) and the tests —
+ * keeps them cycle-free.
+ *
+ * Tone is a THEME token (never a color literal): the component resolves it
+ * against the live theme's CSS vars at render, because Google's canvas sits
+ * outside the DOM cascade and cannot read `var(--color-*)` directly.
+ */
+import { z } from "zod";
+import { shortTextSchema, toneSchema } from "../../params";
+/** WGS-84 latitude. */
+const latSchema = z.number().min(-90).max(90);
+/** WGS-84 longitude. */
+const lngSchema = z.number().min(-180).max(180);
+const MARKERS_MAX = 50;
+const ROUTES_MAX = 10;
+const ROUTE_POINTS_MAX = 500;
+const mapMarkerSchema = z.object({
+    /** Pin label — the click-popup title and the list fallback row. */
+    label: z.string().min(1, "marker label is required").max(120),
+    lat: latSchema,
+    lng: lngSchema,
+    /** Theme tone for the pin. Default "primary". */
+    tone: toneSchema.optional(),
+    /** Popup body text (rendered as text — never HTML). */
+    popup: shortTextSchema.optional(),
+    /** Second popup line, e.g. a street address. */
+    address: shortTextSchema.optional(),
+});
+const mapRouteSchema = z.object({
+    /** Route name for the legend / list fallback. */
+    label: shortTextSchema.optional(),
+    /** Theme tone for the polyline. Default "info". */
+    tone: toneSchema.optional(),
+    /** Polyline vertices, in draw order. */
+    points: z
+        .array(z.object({ lat: latSchema, lng: lngSchema }))
+        .min(2, "a route needs at least 2 points")
+        .max(ROUTE_POINTS_MAX),
+});
+export const mapSchema = z.object({
+    /** Optional heading above the map / list. */
+    title: z.string().max(120).optional(),
+    /** Map height in px (220–800). Default 420. */
+    height: z.number().int().min(220).max(800).optional(),
+    /** Manual center, used when fit is false (or there is nothing to fit). */
+    center: z.object({ lat: latSchema, lng: lngSchema }).optional(),
+    /** Manual zoom 1–20, used when fit is false (or nothing to fit). Default 12. */
+    zoom: z.number().int().min(1).max(20).optional(),
+    /** Fit the view to every marker + route point. Default true. */
+    fit: z.boolean().optional(),
+    markers: z.array(mapMarkerSchema).max(MARKERS_MAX).optional(),
+    routes: z.array(mapRouteSchema).max(ROUTES_MAX).optional(),
+});
+/** Defaults applied at render (the host stores what was published verbatim). */
+export const MAP_DEFAULTS = {
+    height: 420,
+    zoom: 12,
+    fit: true,
+    markerTone: "primary",
+    routeTone: "info",
+};
+/** Normalized params with every default applied. */
+export function normalizeMap(params) {
+    return {
+        title: params.title,
+        height: params.height ?? MAP_DEFAULTS.height,
+        zoom: params.zoom ?? MAP_DEFAULTS.zoom,
+        fit: params.fit ?? MAP_DEFAULTS.fit,
+        markers: params.markers ?? [],
+        routes: params.routes ?? [],
+        center: params.center,
+    };
+}
+/** Marker tone with default filled. */
+export function toneOfMarker(m) {
+    return m.tone ?? MAP_DEFAULTS.markerTone;
+}
+/** Route tone with default filled. */
+export function toneOfRoute(r) {
+    return r.tone ?? MAP_DEFAULTS.routeTone;
+}
+/** Coordinate caption for the list fallback: "30.2672, -97.7431". */
+export function coordCaption(lat, lng) {
+    return `${lat.toFixed(4)}, ${lng.toFixed(4)}`;
+}
+/**
+ * Bounds of every marker + route point — the fallback "area" caption and the
+ * test hook for fit behaviour. Null when there is nothing to fit.
+ */
+export function boundsOf(markers, routes) {
+    let minLat = Infinity;
+    let maxLat = -Infinity;
+    let minLng = Infinity;
+    let maxLng = -Infinity;
+    for (const m of markers) {
+        minLat = Math.min(minLat, m.lat);
+        maxLat = Math.max(maxLat, m.lat);
+        minLng = Math.min(minLng, m.lng);
+        maxLng = Math.max(maxLng, m.lng);
+    }
+    for (const r of routes)
+        for (const p of r.points) {
+            minLat = Math.min(minLat, p.lat);
+            maxLat = Math.max(maxLat, p.lat);
+            minLng = Math.min(minLng, p.lng);
+            maxLng = Math.max(maxLng, p.lng);
+        }
+    if (!Number.isFinite(minLat))
+        return null;
+    return { minLat, maxLat, minLng, maxLng };
+}

package/dist/artifact-blocks/blocks/map/thumb.d.ts

@@ -0,0 +1,2 @@
+import { type ThumbPalette } from "../../thumb-kit.js";
+export declare function drawMapThumb(raw: unknown, palette: ThumbPalette): string | null;

package/dist/artifact-blocks/blocks/map/thumb.js

@@ -0,0 +1,69 @@
+/**
+ * Map block thumbnail composer (mos-qkpva).
+ *
+ * A map cannot render server-side (the real block draws Google's canvas), so
+ * the thumbnail is the block's own data as a simplified pin map: markers
+ * plotted with an equirectangular fit over the plotted set, routes as tone
+ * polylines, no labels (they are dust at cell size) and never a tile fetch —
+ * the same "never a fake screenshot" rule the component's fallback list
+ * follows, drawn as a map because that is the SHAPE the thumbnail exists to
+ * communicate.
+ */
+import { mapSchema, normalizeMap } from "./schema.js";
+import { r1, thumbText, thumbTruncate, toneColor, } from "../../thumb-kit.js";
+const W = 480;
+const H = 300;
+const PAD = 18;
+export function drawMapThumb(raw, palette) {
+    const parsed = mapSchema.safeParse(raw);
+    if (!parsed.success)
+        return null;
+    const norm = normalizeMap(parsed.data);
+    const points = [
+        ...norm.markers.map((m) => ({ lat: m.lat, lng: m.lng })),
+        ...norm.routes.flatMap((r) => r.points),
+    ];
+    if (points.length === 0)
+        return null;
+    const lats = points.map((p) => p.lat);
+    const lngs = points.map((p) => p.lng);
+    const latMin = Math.min(...lats);
+    const latMax = Math.max(...lats);
+    const lngMin = Math.min(...lngs);
+    const lngMax = Math.max(...lngs);
+    // Pad the fit slightly so edge pins aren't clipped by their own radius.
+    const latPad = Math.max((latMax - latMin) * 0.08, 0.004);
+    const lngPad = Math.max((lngMax - lngMin) * 0.08, 0.004);
+    const spanLat = Math.max(latMax - latMin + latPad * 2, 1e-9);
+    const spanLng = Math.max(lngMax - lngMin + lngPad * 2, 1e-9);
+    const px = (lng) => PAD + ((lng - lngMin + lngPad) / spanLng) * (W - PAD * 2);
+    const py = (lat) => H - PAD - ((lat - latMin + latPad) / spanLat) * (H - PAD * 2);
+    const out = [];
+    // routes under pins
+    for (const route of norm.routes) {
+        const color = toneColor(palette, route.tone ?? "info");
+        const d = route.points
+            .map((p, i) => `${i ? "L" : "M"} ${r1(px(p.lng))} ${r1(py(p.lat))}`)
+            .join(" ");
+        out.push(`<path d="${d}" fill="none" stroke="${color}" stroke-opacity="0.7" stroke-width="2"/>`);
+    }
+    // a soft ground so the pins read as "on a map"
+    out.unshift(`<rect x="${r1(PAD / 2)}" y="${r1(PAD / 2)}" width="${r1(W - PAD)}" height="${r1(H - PAD)}" rx="10" fill="${palette.ink}" fill-opacity="0.05"/>`);
+    for (const m of norm.markers) {
+        const color = toneColor(palette, m.tone ?? "primary");
+        const cx = r1(px(m.lng));
+        const cy = r1(py(m.lat));
+        // pin: a circle with a bg-colored core — a map pin silhouette
+        out.push(`<circle cx="${cx}" cy="${cy}" r="7" fill="${color}"/>`);
+        out.push(`<circle cx="${cx}" cy="${cy}" r="2.5" fill="${palette.bg}"/>`);
+    }
+    // One title line when present (the fallback list leads with it too).
+    if (norm.title)
+        out.push(thumbText(PAD, PAD + 8, thumbTruncate(norm.title, 40), {
+            size: 12,
+            fill: palette.ink,
+            opacity: 0.75,
+            weight: 600,
+        }));
+    return `<svg viewBox="0 0 ${W} ${H}">${out.join("")}</svg>`;
+}

package/dist/artifact-blocks/blocks/markdown/MarkdownBlock.svelte

@@ -0,0 +1,33 @@
+<script lang="ts">
+  /**
+   * markdown block — prose (headings, lists, tables, code, links) through the
+   * shared sanitized renderer, drawn by the shared <Markdown> prose surface.
+   *
+   * The block's own Listen control floats at its top-right (SectionTools)
+   * and reads THIS block's paragraphs only — named for the block's first
+   * heading, so the button says what it will read.
+   */
+  import type { BlockProps } from "../../types.js"
+  import type { MarkdownParams } from "./schema.js"
+  import Markdown from "../../Markdown.svelte"
+  import SectionTools from "../../SectionTools.svelte"
+
+  let { params, ctx }: BlockProps<MarkdownParams> = $props()
+
+  /** The container's name for its Listen control: the first markdown
+   * heading ("Listen to: What this page is"), else a quiet generic. */
+  const listenLabel = $derived.by(() => {
+    const md = params?.markdown ?? ""
+    const heading = md.match(/^#{1,6}\s+(.+)$/m)?.[1] ?? ""
+    const clean = heading.replace(/[*_`]/g, "").trim()
+    return clean || "this section"
+  })
+</script>
+
+<!-- flow-root (inside <Markdown>) contains the Listen control's float so it
+     can never overhang into the next block. -->
+<article data-block-markdown>
+  <Markdown source={params?.markdown}>
+    <SectionTools {ctx} {listenLabel} />
+  </Markdown>
+</article>

package/dist/artifact-blocks/blocks/markdown/MarkdownBlock.svelte.d.ts

@@ -0,0 +1,15 @@
+/**
+   * markdown block — prose (headings, lists, tables, code, links) through the
+   * shared sanitized renderer, drawn by the shared <Markdown> prose surface.
+   *
+   * The block's own Listen control floats at its top-right (SectionTools)
+   * and reads THIS block's paragraphs only — named for the block's first
+   * heading, so the button says what it will read.
+   */
+import type { BlockProps } from "../../types.js";
+declare const MarkdownBlock: import("svelte").Component<BlockProps<{
+    markdown: string;
+    reviewable?: boolean | undefined;
+}>, {}, "">;
+type MarkdownBlock = ReturnType<typeof MarkdownBlock>;
+export default MarkdownBlock;

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

@@ -0,0 +1,7 @@
+/**
+ * markdown block — sanitized prose (headings, lists, tables, code, links).
+ */
+import type { ArtifactBlockDef } from "../../types.js";
+import { type MarkdownParams } from "./schema.js";
+declare const def: ArtifactBlockDef<MarkdownParams>;
+export default def;

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

@@ -0,0 +1,28 @@
+import MarkdownBlock from "./MarkdownBlock.svelte";
+import { markdownSchema } from "./schema.js";
+const EXAMPLE = `## Q3 pipeline review
+
+Coverage improved across **all three regions**, driven by the renewals push:
+
+1. Enterprise: 92%
+2. Mid-market: 84%
+3. SMB: 71%
+
+| Region | Coverage | Δ |
+| ------ | -------: | ----: |
+| EMEA   | 91.2%    | +3.1  |
+| AMER   | 88.4%    | +2.6  |
+
+Run \`npm run audit\` to regenerate the numbers. Full notes in the
+[launch doc](https://example.com/launch).`;
+const def = {
+    type: "markdown",
+    title: "Markdown",
+    description: "Prose written in markdown: headings, lists, tables, fenced code, bold/italic and links render through the shared sanitized renderer (render.ts, exported for other blocks); a bare https:// URL becomes a link. Use it for narrative sections, summaries, instructions and any text you would otherwise hand-write in HTML. Source is rendered as markdown — raw HTML in it is stripped, links must be http(s):// or root-relative and image URLs https:// or root-relative, and the body is capped at 50,000 characters (params budget ~256KB/block). Tip: keep one topic per block so sections can be reordered independently.",
+    schema: markdownSchema,
+    component: MarkdownBlock,
+    // The section's Listen + comment sit on the heading row.
+    hostsTools: () => true,
+    example: { markdown: EXAMPLE },
+};
+export default def;

package/dist/artifact-blocks/blocks/markdown/render.d.ts

@@ -0,0 +1,17 @@
+/** Markdown → sanitized HTML for `{@html}`. "" for empty input. */
+export declare function renderBlockMarkdown(markdown: string | null | undefined): string;
+/**
+ * Inline-only markdown: bold/emphasis/code/links for short authored
+ * strings (labels, option details) — no block structure, so a label can't
+ * grow paragraphs or headings. Same sanitize pass and URL policy.
+ */
+export declare function renderBlockMarkdownInline(text: string | null | undefined): string;
+/**
+ * Does this text carry OBVIOUS markdown syntax? The gate for "render rich or
+ * keep plain" on fields that were historically plain text: plain text must
+ * render unchanged — whitespace and line breaks exactly as authored — while
+ * authored markdown renders rich. Conservative on purpose: only
+ * unambiguous, line-anchored or paired syntax counts. Snake_case stays
+ * snake_case; `a - b` mid-line stays a dash.
+ */
+export declare function looksLikeMarkdown(text: string | null | undefined): boolean;

package/dist/artifact-blocks/blocks/markdown/render.js

@@ -0,0 +1,115 @@
+/**
+ * The SHARED sanitized markdown renderer for artifact blocks.
+ *
+ * The blocks contract (../../CONTRACT.md) allows exactly one {@html} path:
+ * markdown rendered through THIS function. Any block (markdown itself, the
+ * callout body and sections, future blocks with rich prose) imports from
+ * here — or renders `<Markdown>` (../../Markdown.svelte), which wraps it
+ * with the shared prose styles — never marked/DOMPurify directly.
+ *
+ * Pipeline (MOS #lib/utils/markdown + blocks/markdown/render.ts, folded
+ * into one module for jatui-vsuzi):
+ *
+ *   marked (GFM: tables, fenced code, strikethrough, and AUTOLINKS — a bare
+ *   `https://…` in prose becomes a link, PARAMS-SPEC §4's renderer floor)
+ *   → DOMPurify html profile, with one afterSanitizeAttributes hook:
+ *
+ *   - `href` must be a navigation link: `http(s)://…`, root-relative `/…`
+ *     or `#fragment` (params.ts isSafeLinkUrl); `src` must be a resource:
+ *     `https://…` or root-relative (isSafeResourceUrl). Anything else
+ *     (javascript:, data:, protocol-relative //host, bare-relative) has the
+ *     attribute stripped, so the element renders as inert text.
+ *   - absolute http(s) anchors get target=_blank + rel=noopener noreferrer
+ *     (root-relative links stay in-app, no target). Added INSIDE the
+ *     sanitize pass, so they cannot be re-validated away.
+ *   - style/iframe/object/embed/form are forbidden outright.
+ *
+ * SSR-safe: isomorphic-dompurify works in node (publish-time validation,
+ * server render) and the browser. The hook is added/removed synchronously
+ * around the synchronous sanitize call — hooks are global on the instance.
+ */
+import DOMPurify from "isomorphic-dompurify";
+import { marked } from "marked";
+import { isSafeLinkUrl, isSafeResourceUrl } from "../../params.js";
+function blockSanitizeHook(node) {
+    const href = node.getAttribute("href");
+    if (href !== null && !isSafeLinkUrl(href.trim()))
+        node.removeAttribute("href");
+    const src = node.getAttribute("src");
+    if (src !== null && !isSafeResourceUrl(src.trim()))
+        node.removeAttribute("src");
+    if (node.tagName === "A") {
+        const kept = node.getAttribute("href") ?? "";
+        if (/^https?:\/\//i.test(kept)) {
+            node.setAttribute("target", "_blank");
+            node.setAttribute("rel", "noopener noreferrer");
+        }
+    }
+}
+/**
+ * Wrap every table in a horizontal scroller so a wide GFM table scrolls
+ * inside its block instead of pushing the page wider than a phone. Runs on
+ * the SANITIZED output (the wrapper is our own markup, never user input).
+ */
+function wrapTables(html) {
+    return html
+        .replace(/<table(\s[^>]*)?>/g, (m) => `<div class="md-table" data-md-table>${m}`)
+        .replace(/<\/table>/g, "</table></div>");
+}
+/** Markdown → sanitized HTML for `{@html}`. "" for empty input. */
+export function renderBlockMarkdown(markdown) {
+    if (typeof markdown !== "string" || !markdown.trim())
+        return "";
+    const raw = marked.parse(markdown, { async: false, gfm: true });
+    DOMPurify.addHook("afterSanitizeAttributes", blockSanitizeHook);
+    try {
+        return wrapTables(DOMPurify.sanitize(raw, {
+            USE_PROFILES: { html: true },
+            FORBID_TAGS: ["style", "iframe", "object", "embed", "form"],
+        }));
+    }
+    finally {
+        DOMPurify.removeHook("afterSanitizeAttributes", blockSanitizeHook);
+    }
+}
+/**
+ * Inline-only markdown: bold/emphasis/code/links for short authored
+ * strings (labels, option details) — no block structure, so a label can't
+ * grow paragraphs or headings. Same sanitize pass and URL policy.
+ */
+export function renderBlockMarkdownInline(text) {
+    if (typeof text !== "string" || !text)
+        return "";
+    const raw = marked.parseInline(text, { async: false, gfm: true });
+    DOMPurify.addHook("afterSanitizeAttributes", blockSanitizeHook);
+    try {
+        return DOMPurify.sanitize(raw, {
+            USE_PROFILES: { html: true },
+            FORBID_TAGS: ["style", "iframe", "object", "embed", "form"],
+        });
+    }
+    finally {
+        DOMPurify.removeHook("afterSanitizeAttributes", blockSanitizeHook);
+    }
+}
+/**
+ * Does this text carry OBVIOUS markdown syntax? The gate for "render rich or
+ * keep plain" on fields that were historically plain text: plain text must
+ * render unchanged — whitespace and line breaks exactly as authored — while
+ * authored markdown renders rich. Conservative on purpose: only
+ * unambiguous, line-anchored or paired syntax counts. Snake_case stays
+ * snake_case; `a - b` mid-line stays a dash.
+ */
+export function looksLikeMarkdown(text) {
+    if (typeof text !== "string" || !text.trim())
+        return false;
+    return (/(^|\n)\s*#{1,6}\s+\S/.test(text) || // heading
+        /(^|\n)\s*[-*+]\s+\S/.test(text) || // unordered list
+        /(^|\n)\s*\d+[.)]\s+\S/.test(text) || // ordered list
+        /(^|\n)\s*>\s?\S/.test(text) || // blockquote
+        /(^|\n)\s*([-*_])\s*\1\s*\1[-*_\s]*$/.test(text) || // horizontal rule
+        /\*\*[^*\n]+\*\*/.test(text) || // bold
+        /`[^`\n]+`/.test(text) || // inline code
+        /\[[^\]\n]+\]\([^)\n]+\)/.test(text) // link
+    );
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Params schema for the markdown block. Imported by block.ts (def),
+ * MarkdownBlock.svelte (props typing) and the tests — keeps them cycle-free.
+ */
+import { z } from "zod";
+export declare const markdownSchema: z.ZodObject<{
+    reviewable: z.ZodOptional<z.ZodBoolean>;
+    markdown: z.ZodString;
+}, z.core.$strip>;
+export type MarkdownParams = z.infer<typeof markdownSchema>;

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

@@ -0,0 +1,23 @@
+/**
+ * Params schema for the markdown block. Imported by block.ts (def),
+ * MarkdownBlock.svelte (props typing) and the tests — keeps them cycle-free.
+ */
+import { z } from "zod";
+/**
+ * 50,000 chars ≈ ≤200KB of UTF-8, inside the contract's ~256KB per-block
+ * params budget with headroom for the rest of the block object.
+ */
+const MARKDOWN_MAX_CHARS = 50_000;
+export const markdownSchema = z.object({
+    /**
+     * Opt in/out of the per-block approve / needs-a-pass strip. Markdown is
+     * information, so it takes none by default; a page intro states
+     * `reviewable: false` explicitly (PARAMS-SPEC §3).
+     */
+    reviewable: z.boolean().optional(),
+    markdown: z
+        .string()
+        .min(1, "markdown is required")
+        .max(MARKDOWN_MAX_CHARS, `keep markdown under ${MARKDOWN_MAX_CHARS} characters (per-block params budget ~256KB)`)
+        .refine((s) => s.trim().length > 0, "markdown is required"),
+});