@remnic/core 9.66.2 → 9.66.4

package/src/activity/vault-begin.test.ts

@@ -0,0 +1,20 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { isRegionBeginLine } from "./vault-begin.js";
+
+test("isRegionBeginLine matches a trimmed begin comment", () => {
+  assert.equal(isRegionBeginLine("<!-- remnic:begin timeline -->", "timeline"), true);
+  assert.equal(isRegionBeginLine("  <!-- remnic:begin timeline -->\t", "timeline"), true);
+});
+
+test("isRegionBeginLine rejects a mismatch", () => {
+  assert.equal(isRegionBeginLine("<!-- remnic:end timeline -->", "timeline"), false);
+  assert.equal(isRegionBeginLine("<!-- remnic:begin weekly -->", "timeline"), false);
+  assert.equal(isRegionBeginLine("<!-- remnic:timeline:start -->", "timeline"), false);
+  assert.equal(isRegionBeginLine("<!-- remnic:begin timeline --> extra", "timeline"), false);
+});
+
+test("isRegionBeginLine throws on an empty name", () => {
+  assert.throws(() => isRegionBeginLine("<!-- remnic:begin  -->", ""), /empty/i);
+});

package/src/activity/vault-begin.ts

@@ -0,0 +1,13 @@
+/**
+ * Match a managed-region begin marker line (issue #1985).
+ *
+ * True iff the trimmed line equals `<!-- remnic:begin NAME -->`.
+ * Empty name throws.
+ */
+
+export function isRegionBeginLine(line: string, name: string): boolean {
+  if (typeof name !== "string" || name.length === 0) {
+    throw new RangeError("Region name must be non-empty.");
+  }
+  return line.trim() === `<!-- remnic:begin ${name} -->`;
+}

package/src/activity/vault-end.test.ts

@@ -0,0 +1,20 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { isRegionEndLine } from "./vault-end.js";
+
+test("isRegionEndLine matches a trimmed end comment", () => {
+  assert.equal(isRegionEndLine("<!-- remnic:end timeline -->", "timeline"), true);
+  assert.equal(isRegionEndLine("  <!-- remnic:end timeline -->\t", "timeline"), true);
+});
+
+test("isRegionEndLine rejects a mismatch", () => {
+  assert.equal(isRegionEndLine("<!-- remnic:begin timeline -->", "timeline"), false);
+  assert.equal(isRegionEndLine("<!-- remnic:end weekly -->", "timeline"), false);
+  assert.equal(isRegionEndLine("<!-- remnic:timeline:end -->", "timeline"), false);
+  assert.equal(isRegionEndLine("<!-- remnic:end timeline --> extra", "timeline"), false);
+});
+
+test("isRegionEndLine throws on an empty name", () => {
+  assert.throws(() => isRegionEndLine("<!-- remnic:end  -->", ""), /empty/i);
+});

package/src/activity/vault-end.ts

@@ -0,0 +1,13 @@
+/**
+ * Match a managed-region end marker line (issue #1985).
+ *
+ * True iff the trimmed line equals `<!-- remnic:end NAME -->`.
+ * Empty name throws.
+ */
+
+export function isRegionEndLine(line: string, name: string): boolean {
+  if (typeof name !== "string" || name.length === 0) {
+    throw new RangeError("Region name must be non-empty.");
+  }
+  return line.trim() === `<!-- remnic:end ${name} -->`;
+}

package/src/activity/vault-frontmatter.test.ts

@@ -0,0 +1,28 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { applyVaultFrontmatter } from "./vault-frontmatter.js";
+
+test("applyVaultFrontmatter merges listed keys and sorts", () => {
+  const merged = applyVaultFrontmatter("zeta: old\nalpha: keep\n", {
+    zeta: "new",
+    remnic_cards: "3",
+  });
+  assert.equal(merged, "alpha: keep\nremnic_cards: 3\nzeta: new");
+});
+
+test("applyVaultFrontmatter rejects keys with newlines", () => {
+  assert.throws(
+    () => applyVaultFrontmatter("alpha: keep", { "bad\nkey": "1" }),
+    /newline/i,
+  );
+  assert.throws(
+    () => applyVaultFrontmatter("alpha: keep", { "bad\rkey": "1" }),
+    /newline/i,
+  );
+});
+
+test("applyVaultFrontmatter leaves the original body unchanged when updates are empty", () => {
+  const existing = "zeta: 1\n# comment stays\nalpha: 2\n";
+  assert.equal(applyVaultFrontmatter(existing, {}), existing);
+});

package/src/activity/vault-frontmatter.ts

@@ -0,0 +1,39 @@
+/**
+ * Merge vault note frontmatter keys (issue #1985).
+ *
+ * Pure string helper. Empty updates leave the original YAML unchanged.
+ * Listed keys stay. Output keys are sorted. Keys with newlines are rejected.
+ */
+
+function assertNoNewlineKey(key: string): void {
+  if (key.includes("\n") || key.includes("\r")) {
+    throw new RangeError("Vault frontmatter keys must not contain newlines.");
+  }
+}
+
+export function applyVaultFrontmatter(
+  existingYaml: string,
+  updates: Readonly<Record<string, string>>,
+): string {
+  const entries = Object.entries(updates);
+  if (entries.length === 0) return existingYaml;
+
+  const merged = new Map<string, string>();
+  for (const line of existingYaml.split("\n")) {
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    const key = line.slice(0, idx).trim();
+    if (key.length === 0) continue;
+    assertNoNewlineKey(key);
+    merged.set(key, line.slice(idx + 1).trim());
+  }
+  for (const [key, value] of entries) {
+    assertNoNewlineKey(key);
+    merged.set(key, value);
+  }
+
+  return [...merged.keys()]
+    .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
+    .map((key) => `${key}: ${merged.get(key)}`)
+    .join("\n");
+}

package/src/activity/vault-join.test.ts

@@ -0,0 +1,21 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { joinVaultSegments } from "./vault-join.js";
+
+test("joinVaultSegments joins relative parts with /", () => {
+  assert.equal(
+    joinVaultSegments(["Daily Notes", "2026", "08", "2026-08-18.md"]),
+    "Daily Notes/2026/08/2026-08-18.md",
+  );
+});
+
+test("joinVaultSegments rejects ..", () => {
+  assert.throws(() => joinVaultSegments(["Daily Notes", "..", "secret"]), /\.\./);
+  assert.throws(() => joinVaultSegments(["foo/../bar"]), /\.\./);
+});
+
+test("joinVaultSegments rejects empty", () => {
+  assert.throws(() => joinVaultSegments([]), /empty/i);
+  assert.throws(() => joinVaultSegments(["Daily Notes", ""]), /empty/i);
+});

package/src/activity/vault-join.ts

@@ -0,0 +1,31 @@
+/**
+ * Join vault-relative path segments (issue #1985).
+ *
+ * Joins with `/`. Rejects an empty list, empty parts, `..`, absolute
+ * parts, backslash, and newline.
+ */
+import path from "node:path";
+
+export function joinVaultSegments(parts: readonly string[]): string {
+  if (parts.length === 0) {
+    throw new RangeError("Vault path parts must be a non-empty list.");
+  }
+  for (const part of parts) {
+    if (typeof part !== "string" || part.length === 0) {
+      throw new RangeError("Vault path part must be non-empty.");
+    }
+    if (part.includes("\\")) {
+      throw new RangeError("Vault path part must not contain a backslash.");
+    }
+    if (part.includes("\n") || part.includes("\r")) {
+      throw new RangeError("Vault path part must not contain a newline.");
+    }
+    if (path.posix.isAbsolute(part) || path.win32.isAbsolute(part)) {
+      throw new RangeError("Vault path part must be relative.");
+    }
+    if (part.split("/").includes("..")) {
+      throw new RangeError("Vault path part must not contain `..`.");
+    }
+  }
+  return parts.join("/");
+}

package/src/activity/vault-marker.test.ts

@@ -0,0 +1,23 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { formatRegionMarkers } from "./vault-marker.js";
+
+test("formatRegionMarkers returns begin and end HTML comments", () => {
+  assert.deepEqual(formatRegionMarkers("timeline"), {
+    begin: "<!-- remnic:begin timeline -->",
+    end: "<!-- remnic:end timeline -->",
+  });
+});
+
+test("formatRegionMarkers rejects an empty name", () => {
+  assert.throws(() => formatRegionMarkers(""), /empty/i);
+});
+
+test("formatRegionMarkers rejects a newline in the name", () => {
+  assert.throws(() => formatRegionMarkers("time\nline"), /newline/i);
+});
+
+test("formatRegionMarkers rejects marker text in the name", () => {
+  assert.throws(() => formatRegionMarkers("foo-->bar"), /-->/);
+});

package/src/activity/vault-marker.ts

@@ -0,0 +1,27 @@
+/**
+ * Format managed-region HTML comment markers (issue #1985).
+ *
+ * Rejects empty names, newlines, and `-->` so the closer cannot leak
+ * out of `<!-- remnic:begin NAME -->`.
+ */
+
+export type RegionMarkers = {
+  begin: string;
+  end: string;
+};
+
+export function formatRegionMarkers(name: string): RegionMarkers {
+  if (typeof name !== "string" || name.length === 0) {
+    throw new RangeError("Region name must be non-empty.");
+  }
+  if (name.includes("\n") || name.includes("\r")) {
+    throw new RangeError("Region name must not contain a newline.");
+  }
+  if (name.includes("-->")) {
+    throw new RangeError("Region name must not contain -->.");
+  }
+  return {
+    begin: `<!-- remnic:begin ${name} -->`,
+    end: `<!-- remnic:end ${name} -->`,
+  };
+}

package/src/activity/vault-name-trim.test.ts

@@ -0,0 +1,22 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { trimRegionName } from "./vault-name-trim.js";
+
+test("trimRegionName accepts a name", () => {
+  assert.equal(trimRegionName("timeline"), "timeline");
+});
+
+test("trimRegionName rejects an empty name", () => {
+  assert.throws(() => trimRegionName(""), /empty/i);
+  assert.throws(() => trimRegionName("   "), /empty/i);
+});
+
+test("trimRegionName rejects a newline in the name", () => {
+  assert.throws(() => trimRegionName("time\nline"), /newline/i);
+  assert.throws(() => trimRegionName("time\rline"), /newline/i);
+});
+
+test("trimRegionName trims surrounding whitespace", () => {
+  assert.equal(trimRegionName("  timeline  "), "timeline");
+});

package/src/activity/vault-name-trim.ts

@@ -0,0 +1,16 @@
+/**
+ * Trim a managed-region name (issue #1985).
+ *
+ * Empty after trim throws. Newline throws. Else the trimmed string.
+ */
+
+export function trimRegionName(value: string): string {
+  const name = value.trim();
+  if (name.length === 0) {
+    throw new RangeError("Region name must be non-empty.");
+  }
+  if (name.includes("\n") || name.includes("\r")) {
+    throw new RangeError("Region name must not contain a newline.");
+  }
+  return name;
+}

package/src/activity/vault-region-pair.test.ts

@@ -0,0 +1,26 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { assertBeginEndPair } from "./vault-region-pair.js";
+
+test("assertBeginEndPair accepts a matching pair", () => {
+  assert.deepEqual(assertBeginEndPair({ beginName: "timeline", endName: "timeline" }), { ok: true });
+  assert.deepEqual(assertBeginEndPair({ beginName: "  timeline  ", endName: "timeline" }), {
+    ok: true,
+  });
+  assert.deepEqual(assertBeginEndPair({ beginName: "timeline", endName: "  timeline  " }), {
+    ok: true,
+  });
+});
+
+test("assertBeginEndPair rejects a name mismatch", () => {
+  assert.deepEqual(assertBeginEndPair({ beginName: "timeline", endName: "weekly" }), {
+    ok: false,
+    error: "name_mismatch",
+  });
+});
+
+test("assertBeginEndPair throws on an empty name", () => {
+  assert.throws(() => assertBeginEndPair({ beginName: "", endName: "timeline" }), /empty/i);
+  assert.throws(() => assertBeginEndPair({ beginName: "timeline", endName: "   " }), /empty/i);
+});

package/src/activity/vault-region-pair.ts

@@ -0,0 +1,24 @@
+/**
+ * Assert a managed-region begin/end name pair (issue #1985).
+ *
+ * Trim both names. Empty throws. Mismatch is name_mismatch. Else ok.
+ */
+
+export type BeginEndPairInput = {
+  beginName: string;
+  endName: string;
+};
+
+export type BeginEndPairResult = { ok: true } | { ok: false; error: "name_mismatch" };
+
+export function assertBeginEndPair({ beginName, endName }: BeginEndPairInput): BeginEndPairResult {
+  const begin = beginName.trim();
+  const end = endName.trim();
+  if (begin.length === 0 || end.length === 0) {
+    throw new RangeError("Region name must be non-empty.");
+  }
+  if (begin !== end) {
+    return { ok: false, error: "name_mismatch" };
+  }
+  return { ok: true };
+}

package/src/activity/vault-region.test.ts

@@ -0,0 +1,24 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { validateRegionName } from "./vault-region.js";
+
+test("validateRegionName trims a valid name", () => {
+  assert.deepEqual(validateRegionName("timeline"), { ok: true, name: "timeline" });
+  assert.deepEqual(validateRegionName("  weekly  "), { ok: true, name: "weekly" });
+});
+
+test("validateRegionName rejects empty and whitespace-only names", () => {
+  assert.deepEqual(validateRegionName(""), { ok: false, error: "invalid_name" });
+  assert.deepEqual(validateRegionName("   "), { ok: false, error: "invalid_name" });
+});
+
+test("validateRegionName rejects names with newlines", () => {
+  assert.deepEqual(validateRegionName("time\nline"), { ok: false, error: "invalid_name" });
+  assert.deepEqual(validateRegionName("time\rline"), { ok: false, error: "invalid_name" });
+});
+
+test("validateRegionName rejects the HTML comment closer", () => {
+  assert.deepEqual(validateRegionName("foo-->bar"), { ok: false, error: "invalid_name" });
+  assert.deepEqual(validateRegionName("timeline-->"), { ok: false, error: "invalid_name" });
+});

package/src/activity/vault-region.ts

@@ -0,0 +1,24 @@
+/**
+ * Validate a managed-region name for vault markers (issue #1985).
+ *
+ * Empty, whitespace-only, newline, and `-->` names are rejected so they
+ * cannot break `<!-- remnic:<name>:start -->` markers.
+ */
+
+export type ValidateRegionNameResult =
+  | { ok: true; name: string }
+  | { ok: false; error: "invalid_name" };
+
+export function validateRegionName(name: string): ValidateRegionNameResult {
+  if (typeof name !== "string") {
+    return { ok: false, error: "invalid_name" };
+  }
+  if (name.includes("\n") || name.includes("\r") || name.includes("-->")) {
+    return { ok: false, error: "invalid_name" };
+  }
+  const trimmed = name.trim();
+  if (trimmed.length === 0) {
+    return { ok: false, error: "invalid_name" };
+  }
+  return { ok: true, name: trimmed };
+}

package/src/activity/vault-suffix.test.ts

@@ -0,0 +1,20 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { stripVaultMdSuffix } from "./vault-suffix.js";
+
+test("stripVaultMdSuffix drops a trailing .md", () => {
+  assert.equal(stripVaultMdSuffix("Daily Notes/2026-08-18.md"), "Daily Notes/2026-08-18");
+});
+
+test("stripVaultMdSuffix leaves a path with no suffix unchanged", () => {
+  assert.equal(stripVaultMdSuffix("Daily Notes/2026-08-18"), "Daily Notes/2026-08-18");
+});
+
+test("stripVaultMdSuffix throws on empty input", () => {
+  assert.throws(() => stripVaultMdSuffix(""), /empty/i);
+});
+
+test("stripVaultMdSuffix does not strip .markdown", () => {
+  assert.equal(stripVaultMdSuffix("Daily Notes/2026-08-18.markdown"), "Daily Notes/2026-08-18.markdown");
+});

package/src/activity/vault-suffix.ts

@@ -0,0 +1,12 @@
+/**
+ * Strip a trailing `.md` suffix from a vault note path (issue #1985).
+ *
+ * Case-sensitive. Does not strip `.markdown`. Empty input is rejected.
+ */
+
+export function stripVaultMdSuffix(notePath: string): string {
+  if (typeof notePath !== "string" || notePath.length === 0) {
+    throw new RangeError("Vault path must be non-empty.");
+  }
+  return notePath.endsWith(".md") ? notePath.slice(0, -3) : notePath;
+}

package/src/activity/vault-wikilink.test.ts

@@ -0,0 +1,27 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { formatVaultWikilink } from "./vault-wikilink.js";
+
+test("formatVaultWikilink returns a wikilink without the .md suffix", () => {
+  assert.equal(formatVaultWikilink("Daily Notes/2026-08-18.md"), "[[Daily Notes/2026-08-18]]");
+  assert.equal(formatVaultWikilink("Places/ACME Office"), "[[Places/ACME Office]]");
+});
+
+test("formatVaultWikilink rejects absolute paths", () => {
+  assert.throws(() => formatVaultWikilink("/abs/note.md"), /absolute/i);
+  assert.throws(() => formatVaultWikilink("C:/vault/note.md"), /absolute/i);
+});
+
+test("formatVaultWikilink rejects parent segments", () => {
+  assert.throws(() => formatVaultWikilink("../outside.md"), /\.\./);
+  assert.throws(() => formatVaultWikilink("notes/../../secret.md"), /\.\./);
+});
+
+test("formatVaultWikilink rejects empty and newline paths", () => {
+  assert.throws(() => formatVaultWikilink(""), /empty/i);
+  assert.throws(() => formatVaultWikilink("   "), /empty/i);
+  assert.throws(() => formatVaultWikilink(".md"), /empty/i);
+  assert.throws(() => formatVaultWikilink("foo\nbar.md"), /newline/i);
+  assert.throws(() => formatVaultWikilink("foo\rbar.md"), /newline/i);
+});

package/src/activity/vault-wikilink.ts

@@ -0,0 +1,28 @@
+/**
+ * Format a vault-relative note path as an Obsidian wikilink (issue #1985).
+ *
+ * Relative paths only. Rejects absolute paths, `..` segments, empty input,
+ * and newlines. Strips a trailing `.md` suffix.
+ */
+import path from "node:path";
+
+export function formatVaultWikilink(notePath: string): string {
+  if (typeof notePath !== "string" || notePath.trim().length === 0) {
+    throw new RangeError("Vault wikilink path must be a non-empty relative path.");
+  }
+  if (notePath.includes("\n") || notePath.includes("\r")) {
+    throw new RangeError("Vault wikilink path must not contain newlines.");
+  }
+  if (path.posix.isAbsolute(notePath) || path.win32.isAbsolute(notePath)) {
+    throw new RangeError("Vault wikilink path must be relative; absolute paths are rejected.");
+  }
+  if (notePath.split(/[\\/]/).some((segment) => segment === "..")) {
+    throw new RangeError("Vault wikilink path must not contain `..` segments.");
+  }
+
+  const stripped = notePath.endsWith(".md") ? notePath.slice(0, -3) : notePath;
+  if (stripped.length === 0) {
+    throw new RangeError("Vault wikilink path must be a non-empty relative path.");
+  }
+  return `[[${stripped}]]`;
+}

package/src/activity/window-order.test.ts

@@ -0,0 +1,27 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { assertHalfOpenWindow } from "./window-order.js";
+
+test("ordered window is ok", () => {
+  assert.deepEqual(assertHalfOpenWindow({ fromMs: 0, toMs: 1 }), { ok: true });
+});
+
+test("equal bounds are empty_window", () => {
+  assert.deepEqual(assertHalfOpenWindow({ fromMs: 10, toMs: 10 }), {
+    ok: false,
+    error: "empty_window",
+  });
+});
+
+test("inverted bounds are empty_window", () => {
+  assert.deepEqual(assertHalfOpenWindow({ fromMs: 20, toMs: 10 }), {
+    ok: false,
+    error: "empty_window",
+  });
+});
+
+test("NaN bounds throw", () => {
+  assert.throws(() => assertHalfOpenWindow({ fromMs: Number.NaN, toMs: 1 }), /finite/);
+  assert.throws(() => assertHalfOpenWindow({ fromMs: 0, toMs: Number.NaN }), /finite/);
+});

package/src/activity/window-order.ts

@@ -0,0 +1,24 @@
+/**
+ * Assert a half-open activity window [fromMs, toMs) (issue #2053 leftover).
+ *
+ * Non-finite bounds throw. `toMs <= fromMs` is empty_window.
+ */
+
+export type AssertHalfOpenWindowResult =
+  | { ok: true }
+  | { ok: false; error: "empty_window" };
+
+/** Validate `[fromMs, toMs)`. Empty or inverted windows fail closed. */
+export function assertHalfOpenWindow(window: {
+  fromMs: number;
+  toMs: number;
+}): AssertHalfOpenWindowResult {
+  const { fromMs, toMs } = window;
+  if (!Number.isFinite(fromMs) || !Number.isFinite(toMs)) {
+    throw new RangeError(
+      `activity window bounds must be finite; got fromMs=${fromMs} toMs=${toMs}`,
+    );
+  }
+  if (toMs <= fromMs) return { ok: false, error: "empty_window" };
+  return { ok: true };
+}

package/src/dedup/merge-count.test.ts

@@ -0,0 +1,19 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { countMergeCandidates } from "./merge-count.js";
+
+test("empty list is 0", () => {
+  assert.equal(countMergeCandidates([]), 0);
+});
+
+test("counts unique ids", () => {
+  assert.equal(countMergeCandidates(["alpha", "beta", "alpha"]), 2);
+  assert.equal(countMergeCandidates(["alpha", "beta", "gamma"]), 3);
+});
+
+test("drops empty strings and does not mutate", () => {
+  const ids = ["alpha", "", "beta", "", "alpha"];
+  assert.equal(countMergeCandidates(ids), 2);
+  assert.deepEqual(ids, ["alpha", "", "beta", "", "alpha"]);
+});

package/src/dedup/merge-count.ts

@@ -0,0 +1,13 @@
+/**
+ * Merge-candidate counter (issue #2330 leftover).
+ *
+ * Unique ids after dropping empty strings. Does not mutate input.
+ */
+
+export function countMergeCandidates(ids: readonly string[]): number {
+  const unique = new Set<string>();
+  for (const id of ids) {
+    if (id !== "") unique.add(id);
+  }
+  return unique.size;
+}

package/src/dedup/merge-dup.test.ts

@@ -0,0 +1,21 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { hasDuplicateMergeIds } from "./merge-dup.js";
+
+test("none is false", () => {
+  assert.equal(hasDuplicateMergeIds([]), false);
+  assert.equal(hasDuplicateMergeIds(["alpha"]), false);
+  assert.equal(hasDuplicateMergeIds(["alpha", "beta"]), false);
+});
+
+test("duplicate non-empty id is true", () => {
+  assert.equal(hasDuplicateMergeIds(["alpha", "beta", "alpha"]), true);
+});
+
+test("empty strings are ignored and input is not mutated", () => {
+  const ids = ["alpha", "", "", "beta"];
+  assert.equal(hasDuplicateMergeIds(ids), false);
+  assert.equal(hasDuplicateMergeIds(["", "", "alpha", "", "alpha"]), true);
+  assert.deepEqual(ids, ["alpha", "", "", "beta"]);
+});

package/src/dedup/merge-dup.ts

@@ -0,0 +1,16 @@
+/**
+ * Merge-id duplicate detector (issue #2330 leftover).
+ *
+ * True if any non-empty id appears twice. Empty strings are ignored.
+ * Does not mutate the input list.
+ */
+
+export function hasDuplicateMergeIds(ids: readonly string[]): boolean {
+  const seen = new Set<string>();
+  for (const id of ids) {
+    if (id === "") continue;
+    if (seen.has(id)) return true;
+    seen.add(id);
+  }
+  return false;
+}

package/src/dedup/merge-empty.test.ts

@@ -0,0 +1,22 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { rejectEmptyMergeIds } from "./merge-empty.js";
+
+test("empty set is empty_set", () => {
+  assert.deepEqual(rejectEmptyMergeIds([]), { ok: false, error: "empty_set" });
+});
+
+test("empty id is empty_id", () => {
+  assert.deepEqual(rejectEmptyMergeIds([""]), { ok: false, error: "empty_id" });
+  assert.deepEqual(rejectEmptyMergeIds(["alpha", ""]), { ok: false, error: "empty_id" });
+  assert.deepEqual(rejectEmptyMergeIds(["", "alpha"]), { ok: false, error: "empty_id" });
+});
+
+test("ok returns the same ids in order and does not mutate", () => {
+  const ids = ["zeta", "alpha", "beta"];
+  const result = rejectEmptyMergeIds(ids);
+  assert.deepEqual(result, { ok: true, ids: ["zeta", "alpha", "beta"] });
+  assert.equal(result.ok && result.ids, ids);
+  assert.deepEqual(ids, ["zeta", "alpha", "beta"]);
+});

package/src/dedup/merge-empty.ts

@@ -0,0 +1,18 @@
+/**
+ * Merge-id empty-set guard (issue #2330 leftover).
+ *
+ * Empty list → empty_set. Any empty string → empty_id.
+ * Otherwise returns the same ids in order. Does not mutate input.
+ */
+
+export type RejectEmptyMergeIdsResult =
+  | { ok: true; ids: readonly string[] }
+  | { ok: false; error: "empty_set" | "empty_id" };
+
+export function rejectEmptyMergeIds(ids: readonly string[]): RejectEmptyMergeIdsResult {
+  if (ids.length === 0) return { ok: false, error: "empty_set" };
+  for (const id of ids) {
+    if (id === "") return { ok: false, error: "empty_id" };
+  }
+  return { ok: true, ids };
+}