@polderlabs/bizar 3.23.0 → 4.0.0

package/bizar-dash/tests/submit-feedback.test.mjs

@@ -0,0 +1,353 @@
+/**
+ * tests/submit-feedback.test.mjs
+ *
+ * Tests for `artifactsStore.submitFeedback()` + the
+ * `POST /api/artifacts/:slug/submit` route (v3.22.0).
+ *
+ * Run with:
+ *   node --test bizar-dash/tests/submit-feedback.test.mjs
+ *
+ * Covers:
+ *   - submitFeedback() creates feedback.md
+ *   - meta.json status is updated to 'review'
+ *   - meta.json lastEdited is updated
+ *   - commentCount / questionCount reflect on-disk state
+ *   - the API endpoint returns ok=true with counts
+ *   - 404 for nonexistent slug
+ *   - 400 for invalid slug
+ *   - feedback.md has YAML frontmatter + Free-placed comments + Open-question answers + Full MDX source sections
+ */
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  mkdtempSync,
+  writeFileSync,
+  existsSync,
+  readFileSync,
+  mkdirSync,
+  rmSync,
+} from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import express from 'express';
+import { createServer } from 'node:http';
+
+import { artifactsStore } from '../src/server/artifacts-store.mjs';
+import { createArtifactsRouter } from '../src/server/routes/artifacts.mjs';
+
+// ---------------------------------------------------------------------------
+// Per-test isolated projectRoot + helpers
+// ---------------------------------------------------------------------------
+
+function makeProjectRoot() {
+  return mkdtempSync(join(tmpdir(), 'submit-feedback-'));
+}
+
+function seedArtifact(projectRoot, slug, { comments = [], answers = [], status = 'draft' } = {}) {
+  const dir = join(projectRoot, 'artifacts', slug);
+  mkdirSync(dir, { recursive: true });
+  const meta = {
+    slug,
+    title: `Test ${slug}`,
+    status,
+    author: 'drb0rk',
+    created: '2026-01-01T00:00:00.000Z',
+    lastEdited: '2026-01-01T00:00:00.000Z',
+  };
+  writeFileSync(join(dir, 'meta.json'), JSON.stringify(meta, null, 2), 'utf8');
+  const canvas = {
+    schemaVersion: 2,
+    title: meta.title,
+    elements: [],
+    connections: [],
+    comments,
+    viewport: { x: 0, y: 0, zoom: 1 },
+  };
+  writeFileSync(join(dir, 'plan.json'), JSON.stringify(canvas, null, 2), 'utf8');
+  writeFileSync(join(dir, 'comments.json'), JSON.stringify(comments, null, 2), 'utf8');
+  writeFileSync(join(dir, 'artifact.mdx'), `---\ntitle: "${meta.title}"\nstatus: ${status}\n---\n\n# Test\n`, 'utf8');
+  return dir;
+}
+
+// ---------------------------------------------------------------------------
+// 1. submitFeedback() — core behavior
+// ---------------------------------------------------------------------------
+
+test('submitFeedback creates feedback.md', () => {
+  const root = makeProjectRoot();
+  try {
+    const slug = 'glyph-feedback-create';
+    seedArtifact(root, slug, {
+      comments: [{ id: 'c1', elementId: null, author: 'drb0rk', text: 'Fix the button', x: 100, y: 200, created: '2026-01-01T00:00:00Z', thread: [] }],
+    });
+    const result = artifactsStore.submitFeedback(slug, { answers: [] }, root);
+    assert.equal(result.ok, true);
+    assert.equal(result.slug, slug);
+    const feedbackPath = join(root, 'artifacts', slug, 'feedback.md');
+    assert.ok(existsSync(feedbackPath), 'feedback.md should be created');
+    const content = readFileSync(feedbackPath, 'utf8');
+    assert.ok(content.includes('glyph: ' + slug), 'frontmatter glyph line');
+    assert.ok(content.includes('commentCount: 1'), 'commentCount in frontmatter');
+    assert.ok(content.includes('## Free-placed comments'), 'has free-placed comments section');
+    assert.ok(content.includes('Fix the button'), 'has comment text');
+    assert.ok(content.includes('(100, 200)'), 'has (x, y) coordinates');
+    assert.ok(content.includes('## Open-question answers'), 'has open-question answers section');
+    assert.ok(content.includes('## Full MDX source'), 'has full MDX source section');
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('submitFeedback updates meta.json status to "review"', () => {
+  const root = makeProjectRoot();
+  try {
+    const slug = 'glyph-status-update';
+    seedArtifact(root, slug, { status: 'draft' });
+    const result = artifactsStore.submitFeedback(slug, { answers: [] }, root);
+    assert.equal(result.ok, true);
+    const meta = JSON.parse(readFileSync(join(root, 'artifacts', slug, 'meta.json'), 'utf8'));
+    assert.equal(meta.status, 'review', 'meta.status should be "review"');
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('submitFeedback updates meta.json lastEdited', () => {
+  const root = makeProjectRoot();
+  try {
+    const slug = 'glyph-lastedited-update';
+    seedArtifact(root, slug);
+    const before = Date.now();
+    const result = artifactsStore.submitFeedback(slug, { answers: [] }, root);
+    const after = Date.now();
+    assert.equal(result.ok, true);
+    const meta = JSON.parse(readFileSync(join(root, 'artifacts', slug, 'meta.json'), 'utf8'));
+    const ts = Date.parse(meta.lastEdited);
+    assert.ok(Number.isFinite(ts), 'lastEdited should be a parseable timestamp');
+    assert.ok(ts >= before && ts <= after, `lastEdited ${meta.lastEdited} should be in [${before}, ${after}]`);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('submitFeedback returns commentCount and questionCount', () => {
+  const root = makeProjectRoot();
+  try {
+    const slug = 'glyph-counts';
+    seedArtifact(root, slug, {
+      comments: [
+        { id: 'c1', elementId: null, author: 'drb0rk', text: 'Comment 1', x: 10, y: 20, created: '2026-01-01T00:00:00Z', thread: [] },
+        { id: 'c2', elementId: null, author: 'drb0rk', text: 'Comment 2', x: 30, y: 40, created: '2026-01-02T00:00:00Z', thread: [] },
+        { id: 'c3', elementId: null, author: 'drb0rk', text: 'Comment 3', x: 50, y: 60, created: '2026-01-03T00:00:00Z', thread: [] },
+      ],
+    });
+    const result = artifactsStore.submitFeedback(slug, {
+      answers: [
+        { questionId: 'q1', value: 'Answer 1' },
+        { questionId: 'q2', value: 'Answer 2' },
+      ],
+    }, root);
+    assert.equal(result.ok, true);
+    assert.equal(result.commentCount, 3);
+    assert.equal(result.questionCount, 2);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('submitFeedback returns ok:false for nonexistent slug', () => {
+  const root = makeProjectRoot();
+  try {
+    const result = artifactsStore.submitFeedback('does-not-exist', { answers: [] }, root);
+    assert.equal(result.ok, false);
+    assert.equal(result.error, 'not_found');
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('submitFeedback returns ok:false for invalid slug', () => {
+  const root = makeProjectRoot();
+  try {
+    const result = artifactsStore.submitFeedback('INVALID', { answers: [] }, root);
+    assert.equal(result.ok, false);
+    assert.equal(result.error, 'invalid_slug');
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('submitFeedback writes Q/A section for question answers', () => {
+  const root = makeProjectRoot();
+  try {
+    const slug = 'glyph-qa-section';
+    seedArtifact(root, slug);
+    const result = artifactsStore.submitFeedback(slug, {
+      answers: [
+        { questionId: 'q-color', value: 'blue' },
+        { questionId: 'q-size',  value: 'large' },
+      ],
+    }, root);
+    assert.equal(result.ok, true);
+    const content = readFileSync(result.feedbackFile, 'utf8');
+    assert.ok(content.includes('## Open-question answers'));
+    assert.ok(content.includes('q-color'), 'question id is in feedback file');
+    assert.ok(content.includes('A: blue'), 'answer value is in feedback file');
+    assert.ok(content.includes('q-size'));
+    assert.ok(content.includes('A: large'));
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('submitFeedback falls back to comments.json when canvas has none', () => {
+  const root = makeProjectRoot();
+  try {
+    const slug = 'glyph-comments-json-fallback';
+    // Seed canvas with empty comments array, comments.json with one comment.
+    seedArtifact(root, slug);
+    const dir = join(root, 'artifacts', slug);
+    // Replace plan.json with empty comments, populate comments.json.
+    const canvas = JSON.parse(readFileSync(join(dir, 'plan.json'), 'utf8'));
+    canvas.comments = [];
+    writeFileSync(join(dir, 'plan.json'), JSON.stringify(canvas, null, 2), 'utf8');
+    writeFileSync(
+      join(dir, 'comments.json'),
+      JSON.stringify([{ id: 'cx', elementId: null, author: 'drb0rk', text: 'fallback comment', x: 5, y: 6, created: '2026-01-01T00:00:00Z', thread: [] }]),
+      'utf8',
+    );
+    const result = artifactsStore.submitFeedback(slug, { answers: [] }, root);
+    assert.equal(result.ok, true);
+    assert.equal(result.commentCount, 1, 'should pick up the fallback comment');
+    const content = readFileSync(result.feedbackFile, 'utf8');
+    assert.ok(content.includes('fallback comment'));
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+// ---------------------------------------------------------------------------
+// 2. POST /api/artifacts/:slug/submit — HTTP layer
+// ---------------------------------------------------------------------------
+
+async function startServer(projectRoot) {
+  const app = express();
+  app.use(express.json({ limit: '2mb' }));
+  const router = createArtifactsRouter({
+    state: {},
+    broadcast: () => {},
+    projectRoot,
+  });
+  app.use('/api', router);
+  const server = createServer(app);
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const port = server.address().port;
+  return {
+    server,
+    baseUrl: `http://127.0.0.1:${port}`,
+    close: () => new Promise((resolve) => server.close(resolve)),
+  };
+}
+
+test('POST /api/artifacts/:slug/submit returns ok=true with counts', async () => {
+  const root = makeProjectRoot();
+  try {
+    const slug = 'glyph-http-ok';
+    seedArtifact(root, slug, {
+      comments: [
+        { id: 'c1', elementId: null, author: 'drb0rk', text: 'A', x: 1, y: 1, created: '2026-01-01T00:00:00Z', thread: [] },
+        { id: 'c2', elementId: null, author: 'drb0rk', text: 'B', x: 2, y: 2, created: '2026-01-02T00:00:00Z', thread: [] },
+      ],
+    });
+    const { baseUrl, close } = await startServer(root);
+    try {
+      const res = await fetch(`${baseUrl}/api/artifacts/${slug}/submit`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ answers: [] }),
+      });
+      assert.equal(res.status, 200, 'HTTP 200');
+      const body = await res.json();
+      assert.equal(body.ok, true);
+      assert.equal(body.slug, slug);
+      assert.equal(body.commentCount, 2);
+      assert.equal(body.questionCount, 0);
+      assert.ok(typeof body.feedbackFile === 'string');
+      assert.ok(existsSync(body.feedbackFile), 'feedbackFile path returned must exist');
+    } finally {
+      await close();
+    }
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('POST /api/artifacts/:slug/submit returns 404 for nonexistent slug', async () => {
+  const root = makeProjectRoot();
+  try {
+    const { baseUrl, close } = await startServer(root);
+    try {
+      const res = await fetch(`${baseUrl}/api/artifacts/does-not-exist/submit`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ answers: [] }),
+      });
+      assert.equal(res.status, 404);
+      const body = await res.json();
+      assert.equal(body.error, 'not_found');
+    } finally {
+      await close();
+    }
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('POST /api/artifacts/:slug/submit returns 400 for invalid slug', async () => {
+  const root = makeProjectRoot();
+  try {
+    const { baseUrl, close } = await startServer(root);
+    try {
+      const res = await fetch(`${baseUrl}/api/artifacts/INVALID/submit`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ answers: [] }),
+      });
+      assert.equal(res.status, 400);
+      const body = await res.json();
+      assert.equal(body.error, 'invalid_slug');
+    } finally {
+      await close();
+    }
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('POST /api/artifacts/:slug/submit persists feedback.md on disk', async () => {
+  const root = makeProjectRoot();
+  try {
+    const slug = 'glyph-http-disk';
+    seedArtifact(root, slug);
+    const { baseUrl, close } = await startServer(root);
+    try {
+      const res = await fetch(`${baseUrl}/api/artifacts/${slug}/submit`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ answers: [] }),
+      });
+      assert.equal(res.status, 200);
+      const feedbackPath = join(root, 'artifacts', slug, 'feedback.md');
+      assert.ok(existsSync(feedbackPath), 'feedback.md should exist on disk');
+      const content = readFileSync(feedbackPath, 'utf8');
+      assert.ok(content.startsWith('---'), 'starts with YAML frontmatter');
+      assert.ok(content.includes('## Full MDX source'), 'contains MDX source section');
+    } finally {
+      await close();
+    }
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});

package/bizar-dash/tests/tmux-wrap.test.mjs

@@ -0,0 +1,145 @@
+/**
+ * tests/tmux-wrap.test.mjs
+ *
+ * Regression tests for the bug where the dashboard's tmux wrap
+ * (`task-delegator.mjs:605`, `bg-retry.mjs:392`) tailed a phantom
+ * log file (`<worktree>/.bizar/opencode.log` or
+ * `<worktree>/.opencode/log/<id>.log`) — paths nothing in the
+ * system writes to.
+ *
+ * The fix uses `getActualBgLogPath()` (path-safe.mjs) which returns
+ * the path the plugin's `LogWriter` actually writes to:
+ * `~/.cache/bizar/logs/<sessionId>.log`.
+ *
+ * These tests assert the new behavior by simulating the dispatch
+ * code path against an injected log file. They do NOT spawn a real
+ * tmux session (the test environment may not have tmux).
+ *
+ * Run with: node --test tests/tmux-wrap.test.mjs
+ */
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, writeFileSync, existsSync, appendFileSync, readFileSync } from 'node:fs';
+import { join, resolve as pathResolve } from 'node:path';
+import { tmpdir } from 'node:os';
+import { spawnSync } from 'node:child_process';
+
+import { getActualBgLogPath } from '../src/server/lib/path-safe.mjs';
+
+const HAS_TMUX = (() => {
+  try {
+    const r = spawnSync('which', ['tmux'], { encoding: 'utf8' });
+    return r.status === 0 && r.stdout.trim().length > 0;
+  } catch {
+    return false;
+  }
+})();
+
+/**
+ * Simulate the tmux spawn exactly the way `background-store.mjs:278-310`
+ * does. Returns the spawned session name on success, or null.
+ */
+function spawnTmuxFor(sessionName, logFile, cwd) {
+  if (!HAS_TMUX) return null;
+  const tmuxArgs = [
+    'new-session', '-d', '-s', sessionName,
+    '-x', '220', '-y', '50',
+  ];
+  if (cwd) tmuxArgs.push('-c', cwd);
+  tmuxArgs.push('tail', '-n', '200', '-F', logFile);
+  const r = spawnSync('tmux', tmuxArgs, { stdio: 'pipe', timeout: 5_000 });
+  if (r.status !== 0) return null;
+  return sessionName;
+}
+
+function killTmuxSession(name) {
+  if (!HAS_TMUX) return;
+  spawnSync('tmux', ['kill-session', '-t', name], { stdio: 'pipe' });
+}
+
+test('tmux wrap points at the actual LogWriter path, not the phantom .bizar/opencode.log', () => {
+  const sessionId = 'ses_wrap_test';
+  // The dispatch code in task-delegator.mjs:605 calls
+  // getActualBgLogPath({ sessionId }) to get the tmux tail target.
+  const logFile = getActualBgLogPath({ sessionId });
+
+  // The historical phantom path (v3.11.0 and earlier):
+  const phantomPath = pathResolve(process.cwd(), '.bizar', 'opencode.log');
+
+  assert.notEqual(
+    logFile,
+    phantomPath,
+    'tmux wrap must NOT tail the phantom .bizar/opencode.log path',
+  );
+  // The actual path is the LogWriter's output.
+  assert.ok(
+    logFile.endsWith(`${sessionId}.log`),
+    `expected log file to be <sessionId>.log, got ${logFile}`,
+  );
+});
+
+test('tmux wrap tail target actually exists after LogWriter writes to it (end-to-end smoke)', { skip: !HAS_TMUX }, () => {
+  // Make a fake LogWriter output by directly writing to the path
+  // the tmux wrap tails. If the paths don't match, the tmux pane
+  // will show "No such file or directory" — same as the v3.11.0 bug.
+  const dir = mkdtempSync(join(tmpdir(), 'tmux-wrap-'));
+  try {
+    process.env.BIZAR_LOG_DIR = dir;
+    const sessionId = 'ses_e2e';
+    const logFile = getActualBgLogPath({ sessionId });
+    // Pre-create the log file with one line, then append another
+    // after tmux is watching. The capture-pane should reflect both.
+    writeFileSync(logFile, 'first line\n', 'utf8');
+
+    const sessionName = 'bgr_e2e_smoke';
+    const created = spawnTmuxFor(sessionName, logFile, dir);
+    if (!created) {
+      // tmux not present in this environment — skip the rest.
+      return;
+    }
+
+    try {
+      // Give tail a moment to start watching.
+      spawnSync('sleep', ['0.3']);
+      appendFileSync(logFile, 'second line after tmux is watching\n', 'utf8');
+      // Give tail a moment to pick it up.
+      spawnSync('sleep', ['0.3']);
+
+      const capture = spawnSync(
+        'tmux', ['capture-pane', '-t', sessionName, '-p', '-S', '-50'],
+        { encoding: 'utf8', timeout: 5_000 },
+      );
+      assert.equal(capture.status, 0, 'tmux capture-pane failed');
+      const out = capture.stdout || '';
+      // The pane must show at least one of the lines we wrote. The
+      // pre-fix phantom path would show "cannot open ... for reading".
+      assert.ok(
+        out.includes('first line') || out.includes('second line'),
+        `expected pane to show our log content, got: ${out}`,
+      );
+      assert.ok(
+        !out.includes('cannot open'),
+        `pane must not show phantom-file error, got: ${out}`,
+      );
+    } finally {
+      killTmuxSession(sessionName);
+    }
+  } finally {
+    delete process.env.BIZAR_LOG_DIR;
+  }
+});
+
+test('getActualBgLogPath falls back to ~/.cache/bizar/logs by default', () => {
+  // Important: when BIZAR_LOG_DIR is not set, the path must point
+  // at the same location the plugin's LogWriter (default logDir
+  // ~/.cache/bizar/logs) writes to. If these drift, the bug
+  // regresses silently.
+  const before = process.env.BIZAR_LOG_DIR;
+  delete process.env.BIZAR_LOG_DIR;
+  try {
+    const p = getActualBgLogPath({ sessionId: 'ses_default' });
+    assert.equal(p, pathResolve(process.env.HOME || '/tmp', '.cache', 'bizar', 'logs', 'ses_default.log'));
+  } finally {
+    if (before) process.env.BIZAR_LOG_DIR = before;
+  }
+});

package/bizar-dash/tests/yaml.test.mjs

@@ -0,0 +1,128 @@
+/**
+ * tests/yaml.test.mjs
+ *
+ * Tests for the YAML frontmatter parser.
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { parseFrontmatter, serializeFrontmatter, parseBlock, serializeBlock } from '../src/server/yaml.mjs';
+
+describe('parseFrontmatter', () => {
+  it('parses empty frontmatter', () => {
+    const { frontmatter, body } = parseFrontmatter('hello world');
+    assert.deepStrictEqual(frontmatter, {});
+    assert.strictEqual(body, 'hello world');
+  });
+
+  it('parses scalar fields', () => {
+    const raw = `---\ntitle: Test Note\ncount: 42\nactive: true\n---\n\nBody content`;
+    const { frontmatter, body } = parseFrontmatter(raw);
+    assert.strictEqual(frontmatter.title, 'Test Note');
+    assert.strictEqual(frontmatter.count, 42);
+    assert.strictEqual(frontmatter.active, true);
+    assert.strictEqual(body, 'Body content');
+  });
+
+  it('parses integer and float', () => {
+    const raw = `---\na: 42\nb: 3.14\n---\n`;
+    const { frontmatter } = parseFrontmatter(raw);
+    assert.strictEqual(frontmatter.a, 42);
+    assert.strictEqual(frontmatter.b, 3.14);
+  });
+
+  it('parses boolean values', () => {
+    const raw = `---\na: true\nb: false\nc: yes\nd: no\n---\n`;
+    const { frontmatter } = parseFrontmatter(raw);
+    assert.strictEqual(frontmatter.a, true);
+    assert.strictEqual(frontmatter.b, false);
+    assert.strictEqual(frontmatter.c, true);
+    assert.strictEqual(frontmatter.d, false);
+  });
+
+  it('parses inline list', () => {
+    const raw = `---\ntags: [memory, architecture, planning]\n---\n`;
+    const { frontmatter } = parseFrontmatter(raw);
+    assert.deepStrictEqual(frontmatter.tags, ['memory', 'architecture', 'planning']);
+  });
+
+  it('parses block list', () => {
+    const raw = `---\ntags:\n  - memory\n  - architecture\n  - planning\n---\n`;
+    const { frontmatter } = parseFrontmatter(raw);
+    assert.deepStrictEqual(frontmatter.tags, ['memory', 'architecture', 'planning']);
+  });
+
+  it('parses multi-line literal block', () => {
+    const raw = `---\nbody: |\n  line one\n  line two\n  line three\n---\n`;
+    const { frontmatter } = parseFrontmatter(raw);
+    assert.strictEqual(frontmatter.body, 'line one\nline two\nline three');
+  });
+
+  it('ignores comment lines', () => {
+    const raw = `---\n# this is a comment\ntitle: Test\n# another comment\n---\n`;
+    const { frontmatter } = parseFrontmatter(raw);
+    assert.strictEqual(frontmatter.title, 'Test');
+    assert(!('title # another comment' in frontmatter));
+  });
+
+  it('parses quoted strings', () => {
+    const raw = `---\ntitle: "Hello World"\nsubtitle: 'Subtitle Here'\n---\n`;
+    const { frontmatter } = parseFrontmatter(raw);
+    assert.strictEqual(frontmatter.title, 'Hello World');
+    assert.strictEqual(frontmatter.subtitle, 'Subtitle Here');
+  });
+
+  it('roundtrips through serialize + parse', () => {
+    const original = { title: 'Test', count: 42, tags: ['a', 'b'] };
+    const serialized = serializeBlock(original);
+    const reparsed = parseBlock(serialized);
+    assert.strictEqual(reparsed.title, 'Test');
+    assert.strictEqual(reparsed.count, 42);
+    assert.deepStrictEqual(reparsed.tags, ['a', 'b']);
+  });
+});
+
+describe('serializeFrontmatter', () => {
+  it('serializes scalars', () => {
+    const fm = { title: 'My Note', count: 10, active: true };
+    const out = serializeFrontmatter(fm);
+    assert.ok(out.includes('title: My Note'));
+    assert.ok(out.includes('count: 10'));
+    assert.ok(out.includes('active: true'));
+  });
+
+  it('serializes arrays as inline lists when possible', () => {
+    const fm = { tags: ['memory', 'arch'] };
+    const out = serializeFrontmatter(fm);
+    assert.ok(out.includes('tags: [memory, arch]'));
+  });
+
+  it('serializes multi-line strings as literal blocks', () => {
+    const fm = { body: 'line1\nline2\nline3' };
+    const out = serializeFrontmatter(fm);
+    assert.ok(out.includes('body: |'));
+    assert.ok(out.includes('  line1'));
+  });
+
+  it('empty frontmatter returns empty string', () => {
+    assert.strictEqual(serializeFrontmatter({}), '');
+  });
+});
+
+describe('parseBlock', () => {
+  it('parses a simple key-value block', () => {
+    const result = parseBlock('title: Hello\nstatus: active');
+    assert.strictEqual(result.title, 'Hello');
+    assert.strictEqual(result.status, 'active');
+  });
+
+  it('handles empty block', () => {
+    const result = parseBlock('');
+    assert.deepStrictEqual(result, {});
+  });
+
+  it('parses ISO date strings as-is', () => {
+    const result = parseBlock('created: 2026-01-15T10:30:00Z');
+    assert.strictEqual(result.created, '2026-01-15T10:30:00Z');
+  });
+});

package/bizar-dash/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noFallthroughCasesInSwitch": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "allowSyntheticDefaultImports": true,
+    "useDefineForClassFields": true,
+    "types": ["node"]
+  },
+  "include": ["src/web/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/bizar-dash/vite.config.ts

@@ -0,0 +1,27 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export default defineConfig({
+  plugins: [react()],
+  root: resolve(__dirname, 'src/web'),
+  base: '/',
+  build: {
+    outDir: resolve(__dirname, 'dist'),
+    emptyOutDir: true,
+    sourcemap: true,
+    rollupOptions: {
+      input: {
+        main: resolve(__dirname, 'src/web/index.html'),
+        mobile: resolve(__dirname, 'src/web/mobile.html'),
+      },
+    },
+  },
+  server: {
+    port: 5174,
+    strictPort: false,
+  },
+});