@openparachute/vault 0.7.3-rc.1 → 0.7.3-rc.11

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

@@ -0,0 +1,286 @@
+/**
+ * `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/conformance.ts

@@ -78,7 +78,8 @@ function toStrictSchemaField(spec: TagFieldSchema): SchemaField {
     spec.type === "integer" ||
     spec.type === "boolean" ||
     spec.type === "array" ||
-    spec.type === "object"
+    spec.type === "object" ||
+    spec.type === "date"
   ) {
     out.type = spec.type;
   }

package/core/src/content-range.test.ts

@@ -23,8 +23,13 @@ import {
   parseContentRange,
   sliceContentRange,
   applyContentRange,
+  parseAttachmentContentRange,
+  alignByteWindow,
   MIN_CONTENT_LENGTH,
+  DEFAULT_ATTACHMENT_WINDOW_BYTES,
+  MAX_ATTACHMENT_WINDOW_BYTES,
 } from "./content-range.js";
+import { QueryError } from "./query-operators.js";
 
 // ---------------------------------------------------------------------------
 // 1. parseContentRange
@@ -237,6 +242,128 @@ describe("content range — reassembly property", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// 2c. parseAttachmentContentRange + alignByteWindow (read-attachment)
+// ---------------------------------------------------------------------------
+
+describe("parseAttachmentContentRange", () => {
+  it("defaults offset=0, length=DEFAULT_ATTACHMENT_WINDOW_BYTES when both are omitted", () => {
+    expect(parseAttachmentContentRange(undefined, undefined)).toEqual({
+      offset: 0,
+      length: DEFAULT_ATTACHMENT_WINDOW_BYTES,
+    });
+  });
+
+  it("offset only → length still defaults (never 'read to end' — that's the query-notes shape, not this one)", () => {
+    expect(parseAttachmentContentRange(1000, undefined)).toEqual({
+      offset: 1000,
+      length: DEFAULT_ATTACHMENT_WINDOW_BYTES,
+    });
+  });
+
+  it("accepts an explicit length up to the max", () => {
+    expect(parseAttachmentContentRange(0, MAX_ATTACHMENT_WINDOW_BYTES)).toEqual({
+      offset: 0,
+      length: MAX_ATTACHMENT_WINDOW_BYTES,
+    });
+  });
+
+  it("rejects a length below MIN_CONTENT_LENGTH", () => {
+    expect(() => parseAttachmentContentRange(0, 2)).toThrow(QueryError);
+  });
+
+  it("rejects a length above MAX_ATTACHMENT_WINDOW_BYTES", () => {
+    expect(() => parseAttachmentContentRange(0, MAX_ATTACHMENT_WINDOW_BYTES + 1)).toThrow(QueryError);
+  });
+
+  it("rejects a negative offset", () => {
+    expect(() => parseAttachmentContentRange(-1, undefined)).toThrow(QueryError);
+  });
+});
+
+describe("alignByteWindow", () => {
+  /**
+   * Simulates the real caller: a BOUNDED positional read of
+   * `[max(0, offset-3), min(total, offset+length))` from `full`, THEN
+   * alignment — never handing the whole buffer to `alignByteWindow`, so a
+   * pass here proves the "never load the whole file" contract actually
+   * holds and isn't just true by accident of the test passing the full
+   * buffer.
+   */
+  function boundedRead(full: Buffer, offset: number, length: number): { raw: Uint8Array; rawStart: number } {
+    const total = full.byteLength;
+    const rawStart = Math.max(0, offset - 3);
+    // +1: alignByteWindow's end-boundary check reads the byte AT the
+    // (exclusive) window end to decide whether it's a continuation byte —
+    // that's one byte past `offset + length`, so the read must include it
+    // (see alignByteWindow's doc comment precondition).
+    const rawEnd = Math.min(total, offset + length + 1);
+    return { raw: full.subarray(rawStart, Math.max(rawStart, rawEnd)), rawStart };
+  }
+
+  it("offset past end → empty slice, complete (mirrors sliceContentRange)", () => {
+    const full = Buffer.from("abc", "utf8");
+    const { raw, rawStart } = boundedRead(full, 999, 16);
+    const r = alignByteWindow(raw, rawStart, { offset: 999, length: 16 }, full.byteLength);
+    expect(r.content).toBe("");
+    expect(r.content_offset).toBe(3);
+    expect(r.content_total_length).toBe(3);
+    expect(r.content_next_offset).toBeNull();
+  });
+
+  it("matches sliceContentRange byte-for-byte on a plain ASCII window", () => {
+    const s = "hello world";
+    const full = Buffer.from(s, "utf8");
+    const { raw, rawStart } = boundedRead(full, 0, 5);
+    const bounded = alignByteWindow(raw, rawStart, { offset: 0, length: 5 }, full.byteLength);
+    const whole = sliceContentRange(s, { offset: 0, length: 5 });
+    expect(bounded).toEqual(whole);
+  });
+
+  it("never splits a codepoint under a bounded read (matches sliceContentRange across a 4-byte emoji)", () => {
+    const s = "ab\u{1F600}cd"; // emoji occupies bytes 2..5 of 8
+    const full = Buffer.from(s, "utf8");
+    for (const [offset, length] of [
+      [0, 5], // budget cuts mid-emoji → backs off to byte 2
+      [2, 4], // exact emoji window
+      [4, 8], // offset lands mid-emoji → aligns down to byte 2
+      [6, 4], // final ASCII tail
+    ] as const) {
+      const { raw, rawStart } = boundedRead(full, offset, length);
+      const bounded = alignByteWindow(raw, rawStart, { offset, length }, full.byteLength);
+      const whole = sliceContentRange(s, { offset, length });
+      expect(bounded).toEqual(whole);
+    }
+  });
+
+  it("reassembly property: chaining content_next_offset through BOUNDED reads reproduces the full content", () => {
+    const rand = mulberry32(0xba5eba11);
+    const POOL = ["a", "Z", "9", " ", "\n", "é", "ψ", "你", "‱", "\u{1F600}", "\u{1D11E}"];
+    for (let iter = 0; iter < 40; iter++) {
+      const charCount = Math.floor(rand() * 100);
+      let content = "";
+      for (let i = 0; i < charCount; i++) content += POOL[Math.floor(rand() * POOL.length)]!;
+      const full = Buffer.from(content, "utf8");
+      const total = full.byteLength;
+      const budget = MIN_CONTENT_LENGTH + Math.floor(rand() * 13); // 4..16 bytes
+
+      let offset = 0;
+      let assembled = "";
+      for (let step = 0; step <= total + 2; step++) {
+        const { raw, rawStart } = boundedRead(full, offset, budget);
+        const slice = alignByteWindow(raw, rawStart, { offset, length: budget }, total);
+        expect(Buffer.byteLength(slice.content, "utf8")).toBeLessThanOrEqual(budget);
+        expect(slice.content_total_length).toBe(total);
+        assembled += slice.content;
+        if (slice.content_next_offset === null) break;
+        expect(slice.content_next_offset).toBeGreaterThan(offset);
+        offset = slice.content_next_offset;
+      }
+      expect(assembled).toBe(content);
+    }
+  });
+});
+
 // ---------------------------------------------------------------------------
 // 3. MCP face — query-notes
 // ---------------------------------------------------------------------------

package/core/src/content-range.ts

@@ -183,3 +183,103 @@ export function applyContentRange(
   result.content_total_length = fields.content_total_length;
   result.content_next_offset = fields.content_next_offset;
 }
+
+// ---------------------------------------------------------------------------
+// Attachment byte-window reads (`read-attachment`, Wave 2 model lane)
+// ---------------------------------------------------------------------------
+
+/** Default `read-attachment` text window when the caller omits `content_length` — small enough to never nuke a context budget. */
+export const DEFAULT_ATTACHMENT_WINDOW_BYTES = 65_536; // 64 KiB
+
+/** Hard per-call ceiling on `read-attachment`'s `content_length` — a deliberate-big-bite max, not a default. */
+export const MAX_ATTACHMENT_WINDOW_BYTES = 262_144; // 256 KiB
+
+/**
+ * Parse `read-attachment`'s `content_offset` / `content_length` pair.
+ * Unlike {@link parseContentRange} (query-notes: omitted params mean "range
+ * mode off, return everything"), a `read-attachment` call ALWAYS reads a
+ * bounded window — omitting `content_length` defaults it to
+ * {@link DEFAULT_ATTACHMENT_WINDOW_BYTES} rather than "the whole file" (an
+ * attachment can be arbitrarily large; a note can't cheaply be). Returns a
+ * fully-resolved `{offset, length}` (never the query-notes "null = off"
+ * shape). Throws `QueryError` (INVALID_QUERY) on a negative/non-integer
+ * value, a `content_length` below {@link MIN_CONTENT_LENGTH}, or one above
+ * {@link MAX_ATTACHMENT_WINDOW_BYTES}.
+ */
+export function parseAttachmentContentRange(
+  offsetRaw: unknown,
+  lengthRaw: unknown,
+): { offset: number; length: number } {
+  const offset = toNonNegativeInt(offsetRaw, "content_offset") ?? 0;
+  const length = toNonNegativeInt(lengthRaw, "content_length");
+  if (length !== undefined && length < MIN_CONTENT_LENGTH) {
+    throw new QueryError(
+      `invalid \`content_length\` value ${JSON.stringify(lengthRaw)} — must be at least ${MIN_CONTENT_LENGTH} bytes (the size of the largest UTF-8 codepoint, so every window makes progress).`,
+      "INVALID_QUERY",
+    );
+  }
+  if (length !== undefined && length > MAX_ATTACHMENT_WINDOW_BYTES) {
+    throw new QueryError(
+      `invalid \`content_length\` value ${JSON.stringify(lengthRaw)} — exceeds the ${MAX_ATTACHMENT_WINDOW_BYTES} byte (256 KiB) per-call max for read-attachment.`,
+      "INVALID_QUERY",
+    );
+  }
+  return { offset, length: length ?? DEFAULT_ATTACHMENT_WINDOW_BYTES };
+}
+
+/**
+ * Byte-level counterpart to {@link sliceContentRange} for `read-attachment`'s
+ * text path, where loading the WHOLE file into memory to slice a string
+ * (`sliceContentRange`'s approach) is exactly the thing a 500 MB attachment
+ * forbids. The caller does a BOUNDED positional read first — `raw` is
+ * whatever bytes it actually fetched, starting at file offset `rawStart`
+ * — and this function applies the identical alignment rules
+ * `sliceContentRange` applies to a full in-memory string, operating only on
+ * that window.
+ *
+ * Precondition (caller's responsibility, not re-validated here): `raw`
+ * covers at least `[max(0, range.offset - 3), min(total, range.offset +
+ * range.length) + 1)` — i.e. from 3 bytes before the requested offset
+ * through ONE byte past the requested end, clamped to `total`. The 3-byte
+ * lookback is enough to find the leading byte of any UTF-8 codepoint the
+ * requested `offset` might land inside (a codepoint is at most 4 bytes,
+ * i.e. at most 3 continuation bytes after its leading byte); the 1-byte
+ * lookahead is what the end-alignment check reads to decide whether the
+ * budget cut lands mid-codepoint (mirroring `sliceContentRange`, which
+ * checks `bytes[end]` — the byte AT the exclusive cut point).
+ */
+export function alignByteWindow(
+  raw: Uint8Array,
+  rawStart: number,
+  range: { offset: number; length: number },
+  total: number,
+): ContentRangeFields {
+  if (range.offset >= total) {
+    return {
+      content: "",
+      content_offset: total,
+      content_total_length: total,
+      content_next_offset: null,
+    };
+  }
+
+  const byteAt = (idx: number): number => raw[idx - rawStart]!;
+
+  // Align the start DOWN to the leading byte of the codepoint containing
+  // `offset` — same rule as sliceContentRange, bounded to what's in `raw`.
+  let start = range.offset;
+  while (start > rawStart && isContinuationByte(byteAt(start))) start--;
+
+  // Window end: budget capped at total, then clamped to what's actually in
+  // `raw` (defense-in-depth — a caller that under-read would otherwise
+  // index past the buffer). Aligned DOWN so the slice never ends mid-codepoint.
+  let end = Math.min(start + range.length, total, rawStart + raw.length);
+  while (end > start && end < total && isContinuationByte(byteAt(end))) end--;
+
+  return {
+    content: Buffer.from(raw.subarray(start - rawStart, end - rawStart)).toString("utf8"),
+    content_offset: start,
+    content_total_length: total,
+    content_next_offset: end >= total ? null : end,
+  };
+}

package/core/src/contract-typed-index.test.ts

@@ -220,14 +220,15 @@ describe("contract: typed indexes — Decision B: explicit-default-only enum bac
 });
 
 describe("contract: typed indexes — Decision C: honest type list (#553, flipped from todo)", () => {
-  it("the update-tag field-type description clarifies only string/integer/boolean/reference are indexable", () => {
+  it("the update-tag field-type description clarifies only string/integer/boolean/reference/date are indexable", () => {
     const updateTag = generateMcpTools(store).find((t) => t.name === "update-tag")!;
     const typeDesc = (updateTag.inputSchema as any).properties.fields.additionalProperties.properties.type.description as string;
     // Honest about the full storage/advisory vocabulary AND the indexable subset.
     expect(typeDesc).toContain("number");
     // vault#typed-reference-field: `reference` joined the indexable subset
-    // alongside string/integer/boolean.
-    expect(typeDesc).toContain("Only string/integer/boolean/reference are INDEXABLE");
+    // alongside string/integer/boolean. vault#date-field-type: `date` joined
+    // the same subset — it stores TEXT (ISO-8601), same as string/reference.
+    expect(typeDesc).toContain("Only string/integer/boolean/reference/date are INDEXABLE");
   });
 
   it("declaring indexed:true with an unindexable type (number) is rejected", async () => {