npm - @polderlabs/bizar - Versions diffs - 4.4.7 → 4.4.9 - Mend

@polderlabs/bizar 4.4.7 → 4.4.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/bizar-dash/dist/index.html CHANGED Viewed

@@ -29,8 +29,8 @@
         }
       })();
     </script>
-    <script type="module" crossorigin src="/assets/main-C4Dq4wTz.js"></script>
-    <link rel="modulepreload" crossorigin href="/assets/mobile-CaZ0gEeJ.js">
+    <script type="module" crossorigin src="/assets/main-CEazNxxy.js"></script>
+    <link rel="modulepreload" crossorigin href="/assets/mobile-Dl1q7Cyq.js">
     <link rel="stylesheet" crossorigin href="/assets/mobile-CsZQAswA.css">
     <link rel="stylesheet" crossorigin href="/assets/main-Nq8Dq3VR.css">
   </head>

package/bizar-dash/dist/mobile.html CHANGED Viewed

@@ -12,8 +12,8 @@
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link rel="stylesheet" href="https://rsms.me/inter/inter.css" />
-    <script type="module" crossorigin src="/assets/mobile-CQTXbuHq.js"></script>
-    <link rel="modulepreload" crossorigin href="/assets/mobile-CaZ0gEeJ.js">
+    <script type="module" crossorigin src="/assets/mobile-DSb-t42Y.js"></script>
+    <link rel="modulepreload" crossorigin href="/assets/mobile-Dl1q7Cyq.js">
     <link rel="stylesheet" crossorigin href="/assets/mobile-CsZQAswA.css">
   </head>
   <body>

package/bizar-dash/src/server/glyphs/mdx-compiler.mjs CHANGED Viewed

@@ -199,6 +199,19 @@ function parseJsxValue(src) {
       }
       while (i < len) {
         skipWs();
+        // v4.4.8 — After consuming a comma + whitespace, check for the
+        // closer before recursing. Without this, an array like `[a, b, ]`
+        // would call parseValue on `]`, which falls through to the
+        // bareword-identifier branch and returns `{__ident: ''}` as a
+        // phantom element. The trailing-comma-then-closer case was the
+        // user-visible bug in the v3-to-v4-consolidation glyph: the
+        // FileTree's last entry was the bareword phantom, which then
+        // crashed the React renderer (components.tsx:609 tried to read
+        // `t.bg` on undefined).
+        if (arr && src[i] === closer) {
+          i += 1;
+          return items;
+        }
         if (arr) {
           items.push(parseValue());
         } else {

package/bizar-dash/src/web/views/glyphs/GlyphRenderer.tsx CHANGED Viewed

@@ -49,6 +49,142 @@ import {
   Mockup,
 } from './components';
+// ---------------------------------------------------------------------------
+// BlockErrorBoundary — v4.4.8
+//
+// A single broken block (e.g. a FileTree whose `data.entries` ended up
+// not being an array because the parser silently produced a phantom
+// bareword entry) used to throw inside React, which propagated up and
+// blanked the whole canvas. The boundary catches throws per-block and
+// renders an inline error card instead. The boundary also exposes its
+// errors via a callback so we can surface them in the top-of-page
+// "render errors" banner.
+// ---------------------------------------------------------------------------
+interface BlockErrorBoundaryProps {
+  blockId: string;
+  blockType: string;
+  children: React.ReactNode;
+  onError: (blockId: string, blockType: string, err: Error, info: React.ErrorInfo) => void;
+}
+interface BlockErrorBoundaryState {
+  err: Error | null;
+}
+class BlockErrorBoundary extends React.Component<BlockErrorBoundaryProps, BlockErrorBoundaryState> {
+  state: BlockErrorBoundaryState = { err: null };
+  static getDerivedStateFromError(err: Error): BlockErrorBoundaryState {
+    return { err };
+  }
+  componentDidCatch(err: Error, info: React.ErrorInfo): void {
+    try {
+      this.props.onError(this.props.blockId, this.props.blockType, err, info);
+    } catch {
+      /* ignore — the boundary itself must not throw */
+    }
+  }
+  render(): React.ReactNode {
+    if (this.state.err) {
+      return (
+        <div
+          className="glyph-block-error"
+          role="alert"
+          style={{
+            border: '1px solid var(--error, #f85149)',
+            background: 'rgba(248, 81, 73, 0.06)',
+            borderRadius: 8,
+            padding: '12px 14px',
+            margin: '12px 0',
+            color: 'var(--text)',
+            fontFamily: 'var(--font-mono, ui-monospace, monospace)',
+            fontSize: 12,
+            lineHeight: 1.55,
+          }}
+        >
+          <strong style={{ color: 'var(--error, #f85149)', fontFamily: 'var(--font-sans, system-ui, sans-serif)', display: 'block', marginBottom: 4 }}>
+            {this.props.blockType} block crashed
+          </strong>
+          <div style={{ color: 'var(--text-muted)', marginBottom: 6 }}>
+            block id: <code>{this.props.blockId}</code>
+          </div>
+          <pre style={{ margin: 0, whiteSpace: 'pre-wrap', wordBreak: 'break-word', color: 'var(--text)' }}>
+            {this.state.err.message}
+          </pre>
+        </div>
+      );
+    }
+    return this.props.children;
+  }
+}
+// ---------------------------------------------------------------------------
+// Block validation — v4.4.8
+//
+// Before handing block data to the component switch, verify that the
+// shape matches the prop contract. Returns `{ ok: true }` when the
+// block can be rendered, or `{ ok: false, error }` when a field is
+// missing or wrong type. The renderer uses the error to skip the
+// component and surface an inline message instead of throwing.
+// ---------------------------------------------------------------------------
+function validateBlock(b: Block): { ok: true } | { ok: false; error: string } {
+  const data = (b.data ?? {}) as Record<string, unknown>;
+  switch (b.type) {
+    case 'RichText':
+      return { ok: true };
+    case 'Callout':
+      return { ok: true };
+    case 'Checklist':
+      if (!Array.isArray(data.items)) return { ok: false, error: 'Checklist requires data.items to be an array' };
+      return { ok: true };
+    case 'Table':
+      if (!Array.isArray(data.columns)) return { ok: false, error: 'Table requires data.columns to be an array' };
+      if (!Array.isArray(data.rows)) return { ok: false, error: 'Table requires data.rows to be an array' };
+      if (data.rows.length > 0 && !Array.isArray(data.rows[0])) return { ok: false, error: 'Table.data.rows[0] must be an array (cell array)' };
+      return { ok: true };
+    case 'CodeTabs':
+      if (!Array.isArray(data.tabs)) return { ok: false, error: 'CodeTabs requires data.tabs to be an array' };
+      return { ok: true };
+    case 'Decision':
+      if (!Array.isArray(data.options)) return { ok: false, error: 'Decision requires data.options to be an array' };
+      return { ok: true };
+    case 'OpenQuestions':
+      if (!Array.isArray(data.questions)) return { ok: false, error: 'OpenQuestions requires data.questions to be an array' };
+      return { ok: true };
+    case 'FileTree':
+      if (!Array.isArray(data.entries)) return { ok: false, error: 'FileTree requires data.entries to be an array' };
+      // v4.4.8 — also catch the phantom bareword entry the parser used
+      // to emit (the v3-to-v4-consolidation glyph crash). An entry that
+      // is not an object means the parser miscounted braces.
+      for (const e of data.entries) {
+        if (e === null || typeof e !== 'object' || Array.isArray(e)) {
+          return { ok: false, error: `FileTree contains a malformed entry: ${JSON.stringify(e)}` };
+        }
+      }
+      return { ok: true };
+    case 'Diff':
+      if (typeof data.before !== 'string') return { ok: false, error: 'Diff requires data.before to be a string' };
+      if (typeof data.after !== 'string') return { ok: false, error: 'Diff requires data.after to be a string' };
+      return { ok: true };
+    case 'Stat':
+      if (data.label === undefined || data.label === null) return { ok: false, error: 'Stat requires data.label' };
+      if (data.value === undefined || data.value === null) return { ok: false, error: 'Stat requires data.value' };
+      return { ok: true };
+    case 'Workflow':
+      if (!Array.isArray(data.steps)) return { ok: false, error: 'Workflow requires data.steps to be an array' };
+      return { ok: true };
+    case 'Mockup':
+      if (typeof data.html !== 'string') return { ok: false, error: 'Mockup requires data.html to be a string' };
+      return { ok: true };
+    case 'Diagram':
+      if (typeof data.dataHtml !== 'string') return { ok: false, error: 'Diagram requires data.dataHtml to be a string' };
+      return { ok: true };
+    default:
+      return { ok: false, error: `Unknown block type: ${(b as { type: string }).type}` };
+  }
+}
 // ---------------------------------------------------------------------------
 // Types — match the server compiler output
 // ---------------------------------------------------------------------------
@@ -72,7 +208,7 @@ interface CompiledGlyph {
   slug: string;
   frontmatter: Record<string, unknown>;
   blocks: Block[];
-  errors: string[];
+  errors: Array<{ line?: number; message: string }>;
   compiledAt: string;
 }
@@ -162,6 +298,25 @@ export function GlyphRenderer({ slug, onClose, onCommentAdded }: Props) {
   // Active pin (expanded thread view)
   const [activePin, setActivePin] = useState<string | null>(null);
+  // v4.4.8 — Per-block render errors caught by BlockErrorBoundary. The
+  // boundary calls onError(err) which pushes into this array. We render
+  // the array at the top of the canvas in a prominent red banner so the
+  // user isn't left staring at a blank screen wondering what happened.
+  const [blockErrors, setBlockErrors] = useState<
+    Array<{ blockId: string; blockType: string; message: string }>
+  >([]);
+  const reportBlockError = React.useCallback(
+    (blockId: string, blockType: string, err: Error) => {
+      setBlockErrors((prev) => {
+        // dedupe by blockId so the same block crashing twice doesn't
+        // duplicate the entry
+        if (prev.some((e) => e.blockId === blockId)) return prev;
+        return [...prev, { blockId, blockType, message: err.message || String(err) }];
+      });
+    },
+    [],
+  );
   const canvasRef = useRef<HTMLDivElement>(null);
   // Section grouping — memoized so we don't re-walk the block array on every render
@@ -289,10 +444,58 @@ export function GlyphRenderer({ slug, onClose, onCommentAdded }: Props) {
     setFullscreen((v) => !v);
   }
-  // Render a single block
+  // Render a single block — wrapped in a BlockErrorBoundary so a single
+// broken block (e.g. wrong data shape from a parser bug) shows an inline
+// error card instead of blanking the whole canvas.
   const renderBlock = (b: Block) => {
     const id = b.id;
     const data = (b.data ?? {}) as Record<string, unknown>;
+    // Validate data shape BEFORE handing to the component switch. A
+    // validation failure shows an inline error card immediately, no
+    // need for the boundary to catch it.
+    const validation = validateBlock(b);
+    if (!validation.ok) {
+      return (
+        <div
+          key={id}
+          id={id}
+          className="glyph-block-error"
+          role="alert"
+          style={{
+            border: '1px solid var(--error, #f85149)',
+            background: 'rgba(248, 81, 73, 0.06)',
+            borderRadius: 8,
+            padding: '12px 14px',
+            margin: '12px 0',
+            color: 'var(--text)',
+            fontFamily: 'var(--font-mono, ui-monospace, monospace)',
+            fontSize: 12,
+            lineHeight: 1.55,
+          }}
+        >
+          <strong style={{ color: 'var(--error, #f85149)', fontFamily: 'var(--font-sans, system-ui, sans-serif)', display: 'block', marginBottom: 4 }}>
+            {b.type} block invalid
+          </strong>
+          <div style={{ color: 'var(--text-muted)', marginBottom: 6 }}>
+            block id: <code>{id}</code>
+          </div>
+          <pre style={{ margin: 0, whiteSpace: 'pre-wrap', wordBreak: 'break-word' }}>{validation.error}</pre>
+        </div>
+      );
+    }
+    // Wrap the actual render in an error boundary so even runtime
+    // errors (bad component props, undefined data, etc.) don't crash
+    // the whole canvas.
+    return (
+      <BlockErrorBoundary key={id} blockId={id} blockType={b.type} onError={reportBlockError}>
+        {renderBlockInner(b, id, data)}
+      </BlockErrorBoundary>
+    );
+  };
+  // Inner renderer — split out so the outer renderBlock can validate +
+  // wrap in an error boundary without nesting the switch in the JSX tree.
+  const renderBlockInner = (b: Block, id: string, data: Record<string, unknown>) => {
     switch (b.type) {
       case 'RichText':
         return <RichText key={id} id={id}>{b.childrenMarkdown ?? ''}</RichText>;
@@ -506,13 +709,41 @@ export function GlyphRenderer({ slug, onClose, onCommentAdded }: Props) {
           </div>
         </header>
-        {/* Compiler warnings */}
-        {compiled.errors?.length > 0 && (
-          <div className="glyph-errors">
-            <strong>Compiler warnings:</strong>
-            <ul>
-              {compiled.errors.map((e, i) => (
-                <li key={i}>{e}</li>
+        {/* v4.4.8 — Render errors banner. Two layers:
+              1. Compiler warnings from the MDX parser (e.g. unknown
+                 tag, unclosed block). Lightweight, yellow border.
+              2. Block render errors caught by BlockErrorBoundary. These
+                 are the "one block crashed but the rest still rendered"
+                 cases. Red border, prominent, listed first so the user
+                 sees them before scrolling. */}
+        {(blockErrors.length > 0 || compiled.errors?.length > 0) && (
+          <div
+            className="glyph-render-errors"
+            role="alert"
+            style={{
+              border: '1px solid var(--error, #f85149)',
+              background: 'rgba(248, 81, 73, 0.08)',
+              borderRadius: 8,
+              padding: '12px 16px',
+              margin: '0 0 16px 0',
+              color: 'var(--text)',
+            }}
+          >
+            <strong style={{ color: 'var(--error, #f85149)', display: 'block', marginBottom: 8 }}>
+              {blockErrors.length > 0
+                ? `${blockErrors.length} block${blockErrors.length === 1 ? '' : 's'} failed to render`
+                : 'Compiler warnings'}
+            </strong>
+            <ul style={{ margin: 0, paddingLeft: 20, fontFamily: 'var(--font-mono, ui-monospace, monospace)', fontSize: 12, lineHeight: 1.6 }}>
+              {blockErrors.map((e, i) => (
+                <li key={`be-${i}`}>
+                  <strong>{e.blockType}</strong> (<code>{e.blockId}</code>): {e.message}
+                </li>
+              ))}
+              {compiled.errors?.map((e, i) => (
+                <li key={`ce-${i}`}>
+                  {e.line ? `line ${e.line}: ` : ''}{e.message}
+                </li>
               ))}
             </ul>
           </div>

package/config/skills/glyph/SKILL.md CHANGED Viewed

@@ -1,174 +1,147 @@
 ---
 name: glyph
-description: Create and consume Bizar glyphs — visual plan/recap artifacts in `artifacts/<slug>/`. Glyphs are MDX files with frontmatter and a block vocabulary. Use for design proposals, decision recaps, and postmortems.
-version: 1
+description: Create and consume Bizar glyphs — visual artifacts at `artifacts/<slug>/`. Use for plans, recaps, design proposals, postmortems, handoffs. Quick reference for the block vocabulary and the 5 things that actually break a glyph.
+version: 3
 ---
-# Glyphs — Visual Plan Artifacts
+# Glyphs
-A **glyph** is a visual artifact used for plans, recaps, and design proposals. It's an MDX file in `artifacts/<slug>/artifact.mdx` that the dashboard renders with comment pin overlay and right-click context menu.
-## When to create a glyph
-- **Design proposal** — you're proposing a new component, system, or workflow
-- **Decision recap** — multiple options were considered; one was chosen; the reasoning matters
-- **Postmortem** — something broke; here's the timeline and root cause
-- **Implementation plan** — breaking down a non-trivial feature into phases
-- **Handoff** — work moving from one agent to another
-If it's a one-line fix, don't make a glyph. If it's a 5-minute edit, don't make a glyph. Glyphs are for work that needs visible structure.
-## File structure
+A **glyph** is an MDX file the dashboard renders with a comment-pin overlay and right-click menu. Three files per glyph:
 ```
 artifacts/<slug>/
-├── meta.json          # title, slug, status, author, created
-├── artifact.mdx       # ← source of truth (git-tracked, diff-friendly)
-└── comments.json      # ← free-placed pins (mutable)
+├── meta.json          ← title, status, author, created
+├── artifact.mdx       ← source of truth
+└── comments.json      ← free-placed pins (mutable)
 ```
-The `meta.json` is metadata, `artifact.mdx` is the content, `comments.json` is the only mutable side-channel.
+Two locations are scanned: `<projectRoot>/.bizar/artifacts/` (preferred) and `~/.config/opencode/artifacts/` (global).
 ## Frontmatter
 ```yaml
 ---
 title: "Short, action-oriented title"
-brief: "One sentence: what this glyph is about."
+brief: "One sentence."
 status: draft | review | shipped | archived
 kind: plan | postmortem | recap | design
 ---
 ```
-## Block vocabulary
+## The blocks at a glance
-```mdx
-<RichText id="...">markdown content (headings, lists, code blocks, etc.)</RichText>
+| Block | What it shows | Required `data` |
+| --- | --- | --- |
+| `<RichText>` | Prose, lists, code blocks | none — body is markdown |
+| `<Callout tone="info\|warn\|success\|danger">` | Boxed callout | none (tone defaults to info) |
+| `<Stat label value trend hint />` | Big number with trend | `label`, `value` |
+| `<Checklist items={[...]} />` | Checkbox list | `items: [{id,label,checked}]` |
+| `<Table columns rows />` | Tabular data | `columns: []`, `rows: [[]]` |
+| `<CodeTabs tabs />` | Tabbed code blocks | `tabs: [{id,label,language,code}]` |
+| `<Decision title question options />` | Multi-option choice | `options: [{id,label,detail,recommended?}]` |
+| `<OpenQuestions questions />` | Unanswered questions | `questions: [{id,label,kind,options?}]` |
+| `<FileTree title entries />` | File-by-file change list | `entries: [{path,change,note?}]` |
+| `<Diff before after filename language mode />` | Before/after diff | `before`, `after` |
+| `<Workflow steps connections />` | Node graph | `steps: [{id,label,type}]` |
+| `<Mockup title x y w h html />` | Inline UI mockup | `html` |
+| `<Diagram title dataHtml dataCss />` | Inline SVG | `dataHtml` |
-<Callout id="..." tone="info|warn|success|danger">markdown content</Callout>
+Every block needs a unique `id`. `RichText` and `Callout` use open/close tags with markdown children; everything else is self-closing.
-<Stat id="..." label="..." value="..." trend="up|down|flat" hint="..." />
+## Skeleton
-<Checklist
-  id="..."
-  items={[
-    { id: "i1", label: "...", checked: true },
-    { id: "i2", label: "...", checked: false }
-  ]}
-/>
-<Table
-  id="..."
-  columns={["A", "B"]}
-  rows={[["x", "y"], ["p", "q"]]}
-/>
+```mdx
+<RichText id="overview">
+## What this covers
-<CodeTabs
-  id="..."
-  tabs={[
-    { id: "t1", label: "file.ts", language: "typescript", code: "...", caption: "..." }
-  ]}
-/>
+A one-paragraph summary.
+</RichText>
-<Decision
-  id="..."
-  title="..."
-  question="..."
-  options={[
-    { id: "a", label: "...", detail: "...", recommended: true }
-  ]}
-/>
+<Stat id="headline" label="X" value="7" trend="flat" />
-<OpenQuestions
-  id="..."
-  questions={[
-    { id: "q1", label: "...", kind: "choice|text|multi", options: ["A", "B"] }
-  ]}
-/>
+<Callout id="warning" tone="warn">
+One important thing.
+</Callout>
 <FileTree
-  id="..."
-  title="..."
+  id="files"
+  title="Files changed"
   entries={[
-    { path: "src/foo.ts", change: "added|modified|removed|renamed", note: "..." }
+    { path: "src/foo.ts", change: "modified", note: "why" },
+    { path: "src/bar.ts", change: "added" },
   ]}
 />
 <Workflow
-  id="..."
+  id="flow"
   steps={[
-    { id: "s1", label: "...", type: "task|decision|note" }
+    { id: "s1", label: "Step 1", type: "task" },
+    { id: "s2", label: "Step 2", type: "task" },
   ]}
   connections={[
-    { from: "s1", to: "s2", label: "yes" }
+    { from: "s1", to: "s2" },
   ]}
 />
-<Mockup
-  id="..."
-  title="..."
-  x={40} y={120} w={280} h={180}
-  html="<div class='mockup-card'>...</div>"
-/>
-<Diagram
-  id="..."
-  title="..."
-  dataHtml="<svg>...</svg>"
-  dataCss=".diagram-node { fill: var(--bg-1); }"
-/>
 ```
-## Common pitfalls
+## The 5 things that break a glyph
-### FileTree `change` field
+Read this BEFORE writing. Each one is a real bug we've shipped.
-`change` must be exactly one of: `added`, `modified`, `removed`, `renamed`. Use the `note` field for nuance ("rewritten from scratch", "kept as-is", "deprecated").
+### 1. Backticks inside attribute strings
-```mdx
-<FileTree
-  entries={[
-    { path: "src/chat/Composer.tsx", change: "modified", note: "rewritten as pill composer" }
-  ]}
-/>
+The parser scans for `` ` `` to delimit template literals. A literal backtick inside a string — even inside double-quotes — closes the surrounding context and breaks parsing.
+```
+WRONG: Run `bizar install` to bootstrap.
+RIGHT: Run 'bizar install' to bootstrap.
+RIGHT: Run the installer to bootstrap.
 ```
-### MDX heading with `<N`
+### 2. The parser doesn't track strings when counting braces
-A heading like `## Mobile (under 768px)` is fine. But `## Mobile <768px` breaks the MDX validator because `<7` looks like a malformed JSX tag. Always escape or rephrase.
+`{` and `}` inside string values still increment the brace depth walker. With brace-laden strings the walker terminates at the wrong closing brace and the value gets truncated.
-### Block IDs must be unique within a glyph
+**Rule:** keep string values brace-free. If you must use `{...}` in a note, escape or rephrase.
-If you copy a `<RichText>` block, change its `id`. The compiler may warn but won't fail.
+### 3. `FileTree` `change` field must be exact
-### Children vs self-closing
+`change` must be `added` | `modified` | `removed` | `renamed`. Anything else (empty string, `null`, typo) makes the renderer crash on `t.bg`.
-Blocks with content (RichText, Callout) use open/close tags with children. Blocks with only data (Stat, Table, FileTree, Decision, etc.) are self-closing.
+```
+WRONG: change: null, change: "", change: "Modified"
+RIGHT: change: "modified"
+```
+When in doubt, use `modified` with a `note` that explains why.
+### 4. Two blocks with the same id
-## meta.json example
+Comment pins and error reporting are keyed by block id. Duplicates collide. Each `id` must be unique within a glyph.
-```json
-{
-  "title": "Chat UI — Complete Rewrite (Gemini-Inspired)",
-  "slug": "chat-ui-rewrite",
-  "status": "draft",
-  "author": "drb0rk",
-  "created": "2026-06-26T20:30:00.000Z",
-  "lastEdited": "2026-06-26T20:30:00.000Z"
-}
+### 5. MDX heading with `<N`
+```
+WRONG: ## Mobile <768px         ← <7 looks like a malformed tag
+RIGHT: ## Mobile (under 768px)
+RIGHT: ## Mobile: under 768px
 ```
-## How to view in the dashboard
+## Validate before shipping
+```bash
+node -e "import('./bizar-dash/src/server/glyphs/mdx-compiler.mjs').then(m => { \
+  const fs = require('node:fs'); \
+  const out = m.compileGlyphMdxSync(fs.readFileSync('artifacts/<slug>/artifact.mdx','utf8')); \
+  console.log('blocks:', out.blocks.length, 'errors:', out.errors.length); \
+  out.errors.forEach(e => console.error('  line', e.line, ':', e.message)); \
+})"
+```
-Glyphs are rendered at `/artifacts/<slug>`. The dashboard shows them with:
-- Section grouping (by block id prefix: `overview`, `implementation`, `questions`)
-- Comment pin overlay (right-click to add)
-- Floating toolbar (Send to agent, share)
-- Read-only by default; `status: shipped` locks editing
+If errors > 0, fix the MDX before opening the glyph in the browser. When a block DOES fail in the browser, v4.4.8+ shows a red banner with block id + error message — no more blank screen.
 ## See also
-- `bizar-dash/src/web/views/glyphs/components.tsx` — block component implementations
-- `bizar-dash/src/server/glyphs/mdx-compiler.mjs` — MDX parser
-- `artifacts/sample-plan-login/` — a complete worked example
-- The user's Obsidian vault for the project's design notes
+- `bizar-dash/src/server/glyphs/mdx-compiler.mjs` — parser
+- `bizar-dash/src/web/views/glyphs/GlyphRenderer.tsx` — React renderer (has the error banner)
+- `bizar-dash/src/web/views/glyphs/components.tsx` — block component implementations

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar",
-  "version": "4.4.7",
+  "version": "4.4.9",
   "description": "Norse-pantheon multi-agent system for opencode — 13 agents across 4 cost tiers with cost-aware routing, plans, and a configurable agent harness. v4 ships as a single npm package bundling the dashboard server, opencode plugin, and typed SDK.",
   "type": "module",
   "bin": {