@openparachute/vault 0.7.3-rc.13 → 0.7.3-rc.3

package/core/src/attachment-tickets-tool.test.ts

@@ -1,286 +0,0 @@
-/**
- * `request-attachment-upload` / `request-attachment-download` — the two
- * MCP mint tools generated by `generateMcpTools` (see mcp.ts's
- * `GenerateMcpToolsOpts.attachmentTickets`). Exercises the "tools omitted
- * when unwired" contract (D10) and the mint-time policy (note/attachment
- * resolution, tag-scope, size cap, extension blocklist) against a fake
- * in-memory `AttachmentTicketProvider` — the spend side (actually writing
- * bytes) is bun-only and covered in src/attachment-tickets.test.ts.
- */
-
-import { describe, test, expect, beforeEach } from "bun:test";
-import { Database } from "bun:sqlite";
-import { BunSqliteStore } from "./store.ts";
-import { generateMcpTools, type McpToolDef } from "./mcp.ts";
-import type { AttachmentTicket, AttachmentTicketProvider } from "./attachment/tickets.ts";
-import { MAX_TICKET_UPLOAD_BYTES } from "./attachment/tickets.ts";
-import type { Note } from "./types.ts";
-
-class FakeTicketProvider implements AttachmentTicketProvider {
-  tickets = new Map<string, AttachmentTicket>();
-  async put(t: AttachmentTicket): Promise<void> {
-    this.tickets.set(t.id, t);
-  }
-  async take(id: string): Promise<AttachmentTicket | null> {
-    const t = this.tickets.get(id);
-    if (!t) return null;
-    this.tickets.delete(id);
-    return t;
-  }
-}
-
-let store: BunSqliteStore;
-
-beforeEach(() => {
-  store = new BunSqliteStore(new Database(":memory:"));
-});
-
-function findTool(tools: McpToolDef[], name: string): McpToolDef {
-  const t = tools.find((x) => x.name === name);
-  if (!t) throw new Error(`tool "${name}" not found`);
-  return t;
-}
-
-async function callTool(tool: McpToolDef, params: Record<string, unknown>): Promise<any> {
-  return await tool.execute(params);
-}
-
-async function expectToolError(tool: McpToolDef, params: Record<string, unknown>): Promise<any> {
-  try {
-    await tool.execute(params);
-    throw new Error("expected the tool to throw");
-  } catch (err) {
-    return err as any;
-  }
-}
-
-describe("D10 — tools omitted when unwired", () => {
-  test("no attachmentTickets opt → neither ticket tool is generated", () => {
-    const tools = generateMcpTools(store);
-    expect(tools.find((t) => t.name === "request-attachment-upload")).toBeUndefined();
-    expect(tools.find((t) => t.name === "request-attachment-download")).toBeUndefined();
-  });
-
-  test("attachmentTickets opt provided → both ticket tools are generated with the right verbs", () => {
-    const provider = new FakeTicketProvider();
-    const tools = generateMcpTools(store, {
-      attachmentTickets: { provider, vaultName: "v1", urlBase: "https://host/vault/v1" },
-    });
-    const upload = findTool(tools, "request-attachment-upload");
-    const download = findTool(tools, "request-attachment-download");
-    expect(upload.requiredVerb).toBe("write");
-    expect(download.requiredVerb).toBe("read");
-  });
-});
-
-describe("request-attachment-upload — mint", () => {
-  test("happy path: returns the ticket envelope and stores a matching provider record", async () => {
-    const note = await store.createNote("# Target\n", { path: "target" });
-    const provider = new FakeTicketProvider();
-    const tools = generateMcpTools(store, {
-      attachmentTickets: { provider, vaultName: "v1", urlBase: "https://host/vault/v1" },
-    });
-    const tool = findTool(tools, "request-attachment-upload");
-
-    const before = Date.now();
-    const result = await callTool(tool, { note: note.id, filename: "photo.png", size_bytes: 1024 });
-    expect(result.method).toBe("PUT");
-    expect(result.url).toMatch(/^https:\/\/host\/vault\/v1\/tickets\/[0-9a-f]{64}$/);
-    expect(result.headers["content-type"]).toBe("image/png");
-    expect(result.max_bytes).toBe(1024);
-    expect(result.curl_example).toContain("curl -X PUT");
-    expect(result.curl_example).toContain(result.url);
-
-    const ticketId = result.url.split("/tickets/")[1] as string;
-    const stored = provider.tickets.get(ticketId)!;
-    expect(stored.kind).toBe("upload");
-    expect(stored.noteId).toBe(note.id);
-    expect(stored.filename).toBe("photo.png");
-    expect(stored.mimeType).toBe("image/png");
-    expect(stored.sizeBytes).toBe(1024);
-    expect(stored.vaultName).toBe("v1");
-    // TTL for a 1024-byte (<1 MiB) declared size is the 10-minute base.
-    expect(stored.expiresAt - before).toBeGreaterThanOrEqual(10 * 60 * 1000 - 1000);
-    expect(stored.expiresAt - before).toBeLessThanOrEqual(10 * 60 * 1000 + 5000);
-  });
-
-  test("mime_type is inferred from the filename extension when omitted", async () => {
-    const note = await store.createNote("# T\n", { path: "t2" });
-    const provider = new FakeTicketProvider();
-    const tools = generateMcpTools(store, {
-      attachmentTickets: { provider, vaultName: "v1", urlBase: "https://host/vault/v1" },
-    });
-    const result = await callTool(findTool(tools, "request-attachment-upload"), {
-      note: note.id,
-      filename: "notes.csv",
-      size_bytes: 10,
-    });
-    expect(result.headers["content-type"]).toBe("text/csv; charset=utf-8");
-  });
-
-  test("transcribe: true rides through to the stored ticket", async () => {
-    const note = await store.createNote("# T\n", { path: "t3" });
-    const provider = new FakeTicketProvider();
-    const tools = generateMcpTools(store, {
-      attachmentTickets: { provider, vaultName: "v1", urlBase: "https://host/vault/v1" },
-    });
-    const result = await callTool(findTool(tools, "request-attachment-upload"), {
-      note: note.id,
-      filename: "memo.wav",
-      size_bytes: 10,
-      transcribe: true,
-    });
-    const ticketId = result.url.split("/tickets/")[1] as string;
-    expect(provider.tickets.get(ticketId)!.transcribe).toBe(true);
-  });
-
-  test("missing note / filename / size_bytes → missing_required_field with how_to", async () => {
-    const provider = new FakeTicketProvider();
-    const tools = generateMcpTools(store, {
-      attachmentTickets: { provider, vaultName: "v1", urlBase: "https://host/vault/v1" },
-    });
-    const tool = findTool(tools, "request-attachment-upload");
-
-    const e1 = await expectToolError(tool, { filename: "a.png", size_bytes: 1 });
-    expect(e1.error_type).toBe("missing_required_field");
-    expect(e1.field).toBe("note");
-    expect(typeof e1.how_to).toBe("string");
-
-    const e2 = await expectToolError(tool, { note: "x", size_bytes: 1 });
-    expect(e2.error_type).toBe("missing_required_field");
-    expect(e2.field).toBe("filename");
-
-    const e3 = await expectToolError(tool, { note: "x", filename: "a.png" });
-    expect(e3.error_type).toBe("invalid_query");
-    expect(e3.field).toBe("size_bytes");
-  });
-
-  test("size_bytes over the 100 MiB cap → file_too_large with limit/got/how_to", async () => {
-    const note = await store.createNote("# T\n", { path: "t4" });
-    const provider = new FakeTicketProvider();
-    const tools = generateMcpTools(store, {
-      attachmentTickets: { provider, vaultName: "v1", urlBase: "https://host/vault/v1" },
-    });
-    const err = await expectToolError(findTool(tools, "request-attachment-upload"), {
-      note: note.id,
-      filename: "huge.zip",
-      size_bytes: MAX_TICKET_UPLOAD_BYTES + 1,
-    });
-    expect(err.error_type).toBe("file_too_large");
-    expect(err.limit).toBe(MAX_TICKET_UPLOAD_BYTES);
-    expect(err.got).toBe(MAX_TICKET_UPLOAD_BYTES + 1);
-    expect(typeof err.how_to).toBe("string");
-    expect(provider.tickets.size).toBe(0);
-  });
-
-  test("blocked (active-content) extension → blocked_upload_extension, no ticket minted", async () => {
-    const note = await store.createNote("# T\n", { path: "t5" });
-    const provider = new FakeTicketProvider();
-    const tools = generateMcpTools(store, {
-      attachmentTickets: { provider, vaultName: "v1", urlBase: "https://host/vault/v1" },
-    });
-    const err = await expectToolError(findTool(tools, "request-attachment-upload"), {
-      note: note.id,
-      filename: "evil.html",
-      size_bytes: 10,
-    });
-    expect(err.error_type).toBe("blocked_upload_extension");
-    expect(err.extension).toBe(".html");
-    expect(provider.tickets.size).toBe(0);
-  });
-
-  test("unknown note → not_found", async () => {
-    const provider = new FakeTicketProvider();
-    const tools = generateMcpTools(store, {
-      attachmentTickets: { provider, vaultName: "v1", urlBase: "https://host/vault/v1" },
-    });
-    const err = await expectToolError(findTool(tools, "request-attachment-upload"), {
-      note: "does-not-exist",
-      filename: "a.png",
-      size_bytes: 10,
-    });
-    expect(err.error_type).toBe("not_found");
-  });
-
-  test("tag-scoped noteVisible: false → uniform not_found (no existence oracle)", async () => {
-    const note = await store.createNote("# T\n", { path: "t6" });
-    const provider = new FakeTicketProvider();
-    const tools = generateMcpTools(store, {
-      attachmentTickets: {
-        provider,
-        vaultName: "v1",
-        urlBase: "https://host/vault/v1",
-        noteVisible: async (_n: Note) => false,
-      },
-    });
-    const err = await expectToolError(findTool(tools, "request-attachment-upload"), {
-      note: note.id,
-      filename: "a.png",
-      size_bytes: 10,
-    });
-    expect(err.error_type).toBe("not_found");
-    expect(provider.tickets.size).toBe(0);
-  });
-});
-
-describe("request-attachment-download — mint", () => {
-  test("happy path: returns the ticket envelope with mime_type + known size, stores a matching provider record", async () => {
-    const note = await store.createNote("# T\n", { path: "t7" });
-    const attachment = await store.addAttachment(note.id, "2026-07-17/x.png", "image/png", { size: 42 });
-    const provider = new FakeTicketProvider();
-    const tools = generateMcpTools(store, {
-      attachmentTickets: { provider, vaultName: "v1", urlBase: "https://host/vault/v1" },
-    });
-    const result = await callTool(findTool(tools, "request-attachment-download"), {
-      attachment_id: attachment.id,
-    });
-    expect(result.method).toBe("GET");
-    expect(result.mime_type).toBe("image/png");
-    expect(result.size_bytes).toBe(42);
-    expect(result.curl_example).toContain(result.url);
-
-    const ticketId = result.url.split("/tickets/")[1] as string;
-    const stored = provider.tickets.get(ticketId)!;
-    expect(stored.kind).toBe("download");
-    expect(stored.attachmentId).toBe(attachment.id);
-  });
-
-  test("missing attachment_id → missing_required_field", async () => {
-    const provider = new FakeTicketProvider();
-    const tools = generateMcpTools(store, {
-      attachmentTickets: { provider, vaultName: "v1", urlBase: "https://host/vault/v1" },
-    });
-    const err = await expectToolError(findTool(tools, "request-attachment-download"), {});
-    expect(err.error_type).toBe("missing_required_field");
-  });
-
-  test("unknown attachment → not_found", async () => {
-    const provider = new FakeTicketProvider();
-    const tools = generateMcpTools(store, {
-      attachmentTickets: { provider, vaultName: "v1", urlBase: "https://host/vault/v1" },
-    });
-    const err = await expectToolError(findTool(tools, "request-attachment-download"), {
-      attachment_id: "does-not-exist",
-    });
-    expect(err.error_type).toBe("not_found");
-  });
-
-  test("tag-scoped noteVisible: false on the owning note → not_found, same shape as unknown attachment", async () => {
-    const note = await store.createNote("# T\n", { path: "t8" });
-    const attachment = await store.addAttachment(note.id, "2026-07-17/y.png", "image/png");
-    const provider = new FakeTicketProvider();
-    const tools = generateMcpTools(store, {
-      attachmentTickets: {
-        provider,
-        vaultName: "v1",
-        urlBase: "https://host/vault/v1",
-        noteVisible: async (_n: Note) => false,
-      },
-    });
-    const err = await expectToolError(findTool(tools, "request-attachment-download"), {
-      attachment_id: attachment.id,
-    });
-    expect(err.error_type).toBe("not_found");
-    expect(provider.tickets.size).toBe(0);
-  });
-});

package/core/src/display-title.test.ts

@@ -1,190 +0,0 @@
-/**
- * Title axis (ratified 2026-07-17): a note's title IS its first line —
- * derived from content, never stored. This file covers:
- *   - `computeDisplayTitle` derivation (first non-empty line, heading
- *     markers stripped, truncation, null-on-empty);
- *   - `displayTitle` presence on the lean `NoteIndex` shape, both via the
- *     MCP `query-notes` list path and the REST `GET /notes` list path.
- *
- * The search title-BOOST (ranking notes whose first line matches query
- * terms above the rest) lives in `search-title-boost.test.ts` — a
- * different concern (ranking) from derivation (this file).
- */
-import { describe, it, expect, beforeEach } from "bun:test";
-import { Database } from "bun:sqlite";
-import { SqliteStore } from "./store.js";
-import { generateMcpTools } from "./mcp.js";
-import { computeDisplayTitle, toNoteIndex, DISPLAY_TITLE_MAX_LEN } from "./notes.js";
-import type { Note } from "./types.js";
-
-describe("computeDisplayTitle", () => {
-  it("returns the first line when content is a single line", () => {
-    expect(computeDisplayTitle("Grocery List")).toBe("Grocery List");
-  });
-
-  it("returns the first NON-EMPTY line, skipping leading blank lines", () => {
-    expect(computeDisplayTitle("\n\n  \nReal Title\nbody text")).toBe("Real Title");
-  });
-
-  it("strips a leading markdown heading marker + its whitespace", () => {
-    expect(computeDisplayTitle("# Grocery List\nmilk, eggs")).toBe("Grocery List");
-    expect(computeDisplayTitle("## Section Two\nbody")).toBe("Section Two");
-    expect(computeDisplayTitle("###### h6\nbody")).toBe("h6");
-  });
-
-  it("strips a heading marker with no space after it", () => {
-    expect(computeDisplayTitle("###Title\nbody")).toBe("Title");
-  });
-
-  it("treats a heading-marker-only line as blank and moves to the next line", () => {
-    expect(computeDisplayTitle("##\nReal Title")).toBe("Real Title");
-  });
-
-  it("does not strip markers past the first six (never a valid heading)", () => {
-    // 7 leading `#`s: the regex only matches 1-6, so the 7th `#` survives
-    // as ordinary content.
-    expect(computeDisplayTitle("####### Title")).toBe("# Title");
-  });
-
-  it("returns null for empty content", () => {
-    expect(computeDisplayTitle("")).toBeNull();
-  });
-
-  it("returns null for null/undefined content", () => {
-    expect(computeDisplayTitle(null)).toBeNull();
-    expect(computeDisplayTitle(undefined)).toBeNull();
-  });
-
-  it("returns null when content is whitespace-only", () => {
-    expect(computeDisplayTitle("   \n\t\n   ")).toBeNull();
-  });
-
-  it("returns null when every line is a bare heading marker", () => {
-    expect(computeDisplayTitle("#\n##\n### ")).toBeNull();
-  });
-
-  it("truncates to DISPLAY_TITLE_MAX_LEN code points", () => {
-    const longTitle = "a".repeat(200);
-    const result = computeDisplayTitle(longTitle)!;
-    expect(result.length).toBe(DISPLAY_TITLE_MAX_LEN);
-    expect(result).toBe("a".repeat(DISPLAY_TITLE_MAX_LEN));
-  });
-
-  it("does not truncate a title at or under the limit", () => {
-    const exact = "a".repeat(DISPLAY_TITLE_MAX_LEN);
-    expect(computeDisplayTitle(exact)).toBe(exact);
-    const short = "short title";
-    expect(computeDisplayTitle(short)).toBe(short);
-  });
-
-  it("truncates by Unicode code point, not UTF-16 code unit (no split surrogate pairs)", () => {
-    // Astral-plane emoji are 2 UTF-16 code units each but 1 code point.
-    const emojiTitle = "😀".repeat(150);
-    const result = computeDisplayTitle(emojiTitle)!;
-    expect(Array.from(result).length).toBe(DISPLAY_TITLE_MAX_LEN);
-  });
-
-  describe("leading frontmatter block (misuse path — direct create with raw frontmatter)", () => {
-    it("skips a closed frontmatter block and derives the first line of the DOCUMENT", () => {
-      expect(computeDisplayTitle("---\ntitle: X\n---\n# Real Title")).toBe("Real Title");
-    });
-
-    it("skips a closed frontmatter block with multiple fields + blank lines after", () => {
-      expect(
-        computeDisplayTitle("---\ntitle: X\ntags: [a, b]\n---\n\n\nReal Title\nbody"),
-      ).toBe("Real Title");
-    });
-
-    it("falls back to treating an UNTERMINATED opening `---` as ordinary content", () => {
-      // No closing fence anywhere in the content — a note whose real first
-      // line is literally "---" (e.g. a markdown horizontal rule opener)
-      // must not be mangled.
-      expect(computeDisplayTitle("---\nnot frontmatter, just a rule\nmore text")).toBe("---");
-    });
-
-    it("returns null when content is EXACTLY a closed frontmatter block (nothing after)", () => {
-      expect(computeDisplayTitle("---\ntitle: X\n---\n")).toBeNull();
-      expect(computeDisplayTitle("---\ntitle: X\n---")).toBeNull();
-    });
-
-    it("returns null when only blank lines follow a closed frontmatter block", () => {
-      expect(computeDisplayTitle("---\ntitle: X\n---\n\n  \n")).toBeNull();
-    });
-
-    it("does not treat a closing fence found past the bounded scan window as a frontmatter close", () => {
-      // Opening `---` with the closing fence past FRONTMATTER_SCAN_LINES
-      // (100): the scan gives up and falls back to ordinary-content
-      // behavior, deriving from line 0.
-      const filler = Array.from({ length: 150 }, (_, i) => `line ${i}`).join("\n");
-      expect(computeDisplayTitle(`---\n${filler}\n---\nReal Title`)).toBe("---");
-    });
-
-    it("normal content with no leading `---` is byte-identical to prior behavior", () => {
-      expect(computeDisplayTitle("# Grocery List\nmilk, eggs")).toBe("Grocery List");
-      expect(computeDisplayTitle("Just a note\nbody text")).toBe("Just a note");
-    });
-  });
-});
-
-describe("toNoteIndex — displayTitle wiring", () => {
-  const baseNote: Note = {
-    id: "n1",
-    content: "# Real Title\nbody",
-    createdAt: new Date().toISOString(),
-    tags: [],
-    metadata: {},
-  };
-
-  it("carries the computed display title onto the lean shape", () => {
-    const index = toNoteIndex(baseNote);
-    expect(index.displayTitle).toBe("Real Title");
-  });
-
-  it("is null when content is empty", () => {
-    const index = toNoteIndex({ ...baseNote, content: "" });
-    expect(index.displayTitle).toBeNull();
-  });
-
-  it("is null when content is missing entirely (defensive — matches preview's ?? \"\" fallback)", () => {
-    const { content: _drop, ...rest } = baseNote;
-    const index = toNoteIndex(rest as Note);
-    expect(index.displayTitle).toBeNull();
-  });
-});
-
-let store: SqliteStore;
-let db: Database;
-
-beforeEach(() => {
-  db = new Database(":memory:");
-  store = new SqliteStore(db);
-});
-
-describe("displayTitle — list-shape presence (MCP)", () => {
-  it("query-notes list mode (include_content default false) carries displayTitle", async () => {
-    await store.createNote("# Meeting Notes\nagenda: budget", { path: "a" });
-    const tools = generateMcpTools(store);
-    const queryNotes = tools.find((t) => t.name === "query-notes")!;
-    const result = await queryNotes.execute({}) as any[];
-    expect(result).toHaveLength(1);
-    expect(result[0].displayTitle).toBe("Meeting Notes");
-    expect(result[0].content).toBeUndefined();
-  });
-
-  it("query-notes include_content=true does NOT carry displayTitle (full Note shape, unchanged)", async () => {
-    await store.createNote("# Meeting Notes\nagenda: budget", { path: "a" });
-    const tools = generateMcpTools(store);
-    const queryNotes = tools.find((t) => t.name === "query-notes")!;
-    const result = await queryNotes.execute({ include_content: true }) as any[];
-    expect(result[0].content).toBeTruthy();
-    expect(result[0].displayTitle).toBeUndefined();
-  });
-
-  it("displayTitle is null on the lean shape for an empty note", async () => {
-    await store.createNote("", { path: "empty" });
-    const tools = generateMcpTools(store);
-    const queryNotes = tools.find((t) => t.name === "query-notes")!;
-    const result = await queryNotes.execute({}) as any[];
-    expect(result[0].displayTitle).toBeNull();
-  });
-});

package/core/src/lede.test.ts

@@ -1,96 +0,0 @@
-/**
- * `computeLede` — the first non-empty paragraph AFTER a note's title line,
- * used by `expand_mode: "summary"` (core/src/expand.ts) as a fallback when
- * `metadata.summary` is absent (summaries-as-content, 2026-07-17 dialogue).
- *
- * Shares its title-line rule (including the leading-frontmatter skip) with
- * `computeDisplayTitle` — see `display-title.test.ts` for that function's
- * own coverage. This file covers only the lede-specific behavior: where the
- * paragraph starts, how it's collapsed, the length cap, and the
- * title-only/no-content null cases.
- */
-import { describe, it, expect } from "bun:test";
-import { computeLede, LEDE_MAX_LEN } from "./notes.js";
-
-describe("computeLede", () => {
-  it("returns the first paragraph after a heading title, blank-line separated", () => {
-    expect(
-      computeLede("# Title\n\nThis is the lede paragraph.\n\nSecond paragraph — not the lede."),
-    ).toBe("This is the lede paragraph.");
-  });
-
-  it("joins a multi-line paragraph into one collapsed line", () => {
-    expect(
-      computeLede("# Title\n\nThis lede paragraph\nspans two lines.\n\nSecond paragraph."),
-    ).toBe("This lede paragraph spans two lines.");
-  });
-
-  it("treats text immediately following the title (no blank line) as the lede", () => {
-    expect(computeLede("Grocery List\nmilk, eggs\ncheese")).toBe("milk, eggs cheese");
-  });
-
-  it("collapses internal whitespace runs to single spaces", () => {
-    expect(computeLede("Title\n\nLine one   with    extra   spaces.")).toBe(
-      "Line one with extra spaces.",
-    );
-  });
-
-  it("returns null for a title-only note (does not repeat the title)", () => {
-    expect(computeLede("Just a title")).toBeNull();
-    expect(computeLede("# Just a title")).toBeNull();
-  });
-
-  it("returns null when only blank lines follow the title", () => {
-    expect(computeLede("# Title\n\n\n   \n")).toBeNull();
-  });
-
-  it("returns null for empty, null, or undefined content", () => {
-    expect(computeLede("")).toBeNull();
-    expect(computeLede(null)).toBeNull();
-    expect(computeLede(undefined)).toBeNull();
-  });
-
-  it("returns null when content is whitespace-only (no title at all)", () => {
-    expect(computeLede("   \n\t\n   ")).toBeNull();
-  });
-
-  describe("leading frontmatter block", () => {
-    it("finds the lede after a closed frontmatter block AND its title line", () => {
-      expect(
-        computeLede("---\ntitle: X\n---\n# Real Title\n\nThe lede text."),
-      ).toBe("The lede text.");
-    });
-
-    it("finds the lede when the title immediately follows frontmatter with no blank line", () => {
-      expect(
-        computeLede("---\ntitle: X\n---\nReal Title\nlede text right after."),
-      ).toBe("lede text right after.");
-    });
-
-    it("returns null for a frontmatter-only note with no body after the title", () => {
-      expect(computeLede("---\ntitle: X\n---\nReal Title")).toBeNull();
-    });
-  });
-
-  describe("length cap", () => {
-    it("truncates to LEDE_MAX_LEN code points", () => {
-      const longParagraph = "a".repeat(1000);
-      const result = computeLede(`# Title\n\n${longParagraph}`)!;
-      expect(result.length).toBe(LEDE_MAX_LEN);
-      expect(result).toBe("a".repeat(LEDE_MAX_LEN));
-    });
-
-    it("does not truncate a lede at or under the cap", () => {
-      const exact = "a".repeat(LEDE_MAX_LEN);
-      expect(computeLede(`# Title\n\n${exact}`)).toBe(exact);
-      const short = "short lede";
-      expect(computeLede(`# Title\n\n${short}`)).toBe(short);
-    });
-
-    it("truncates by Unicode code point, not UTF-16 code unit (no split surrogate pairs)", () => {
-      const emojiParagraph = "😀".repeat(500);
-      const result = computeLede(`# Title\n\n${emojiParagraph}`)!;
-      expect(Array.from(result).length).toBe(LEDE_MAX_LEN);
-    });
-  });
-});