@arbidocs/react 0.5.111 → 0.5.113

package/dist/annotations/merge.js

@@ -0,0 +1,53 @@
+const time = (iso) => {
+  const t = Date.parse(iso);
+  return Number.isNaN(t) ? 0 : t;
+};
+function mergeReplies(a, b) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const r of [...a, ...b]) if (!byId.has(r.id)) byId.set(r.id, r);
+  return [...byId.values()].sort((x, y) => time(x.createdAt) - time(y.createdAt));
+}
+function newer(mine, theirs) {
+  const winner = time(theirs.updatedAt) > time(mine.updatedAt) ? theirs : mine;
+  if (mine.kind === "comment" && theirs.kind === "comment" && winner.kind === "comment") {
+    const replies = mergeReplies(mine.replies, theirs.replies);
+    if (replies.length !== winner.replies.length) return { ...winner, replies };
+  }
+  return winner;
+}
+function mergeLayers({ base, mine, theirs, deleted }) {
+  const baseById = new Map((base?.annotations ?? []).map((a) => [a.id, a]));
+  const theirsById = new Map(theirs.annotations.map((a) => [a.id, a]));
+  const mineIds = new Set(mine.annotations.map((a) => a.id));
+  const out = [];
+  for (const m of mine.annotations) {
+    if (deleted?.has(m.id)) continue;
+    const t = theirsById.get(m.id);
+    if (t) {
+      out.push(newer(m, t));
+      continue;
+    }
+    const b = baseById.get(m.id);
+    if (b && time(m.updatedAt) <= time(b.updatedAt)) continue;
+    out.push(m);
+  }
+  for (const t of theirs.annotations) {
+    if (mineIds.has(t.id) || deleted?.has(t.id)) continue;
+    if (baseById.has(t.id)) continue;
+    out.push(t);
+  }
+  const updatedAt = time(theirs.updatedAt) > time(mine.updatedAt) ? theirs.updatedAt : mine.updatedAt;
+  return { ...mine, annotations: out, updatedAt };
+}
+function sameMarks(a, b) {
+  if (a.annotations.length !== b.annotations.length) return false;
+  const byId = new Map(a.annotations.map((m) => [m.id, m.updatedAt]));
+  return b.annotations.every(
+    (m) => byId.get(m.id) === m.updatedAt && (m.kind !== "comment" || a.annotations.find((x) => x.id === m.id).replies.length === m.replies.length)
+  );
+}
+export {
+  mergeLayers,
+  sameMarks
+};
+//# sourceMappingURL=merge.js.map

package/dist/annotations/merge.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/annotations/merge.ts"],
+  "sourcesContent": ["/**\n * Merging two writers' versions of one layer, by annotation id (a PDF annotation's `/NM`).\n *\n * Used when a save is refused because someone saved first (HTTP 409): the client re-reads the\n * latest layer (\"theirs\") and merges it with its own (\"mine\"), relative to the layer both started\n * from (\"base\"). Nobody's marks are lost:\n *\n * - a mark only one side has is kept, unless that side never had it and the other deleted it:\n *   a mark in `base` that `mine` no longer has was deleted here and stays deleted, and one that\n *   `theirs` no longer has was deleted there and stays deleted unless it was edited here since;\n * - a mark both sides have: the later edit (`updatedAt`) wins as a whole; a comment additionally\n *   keeps every reply either side added;\n * - `deleted` (the ids this session removed, its tombstones) always wins: a concurrent edit\n *   elsewhere does not resurrect a mark deleted here, even one `base` never saw.\n */\n\nimport type { Annotation, AnnotationLayer, CommentAnnotation, CommentReply } from './model'\n\nexport interface MergeInput {\n  /** The layer both sides started from (the last one this client saved or loaded). */\n  base: AnnotationLayer | null\n  mine: AnnotationLayer\n  theirs: AnnotationLayer\n  /** Ids this session deleted. */\n  deleted?: ReadonlySet<string>\n}\n\nconst time = (iso: string) => {\n  const t = Date.parse(iso)\n  return Number.isNaN(t) ? 0 : t\n}\n\nfunction mergeReplies(a: CommentReply[], b: CommentReply[]): CommentReply[] {\n  const byId = new Map<string, CommentReply>()\n  for (const r of [...a, ...b]) if (!byId.has(r.id)) byId.set(r.id, r)\n  return [...byId.values()].sort((x, y) => time(x.createdAt) - time(y.createdAt))\n}\n\n/** The newer of two versions of one mark (ties go to `mine`); comments keep both sides' replies. */\nfunction newer(mine: Annotation, theirs: Annotation): Annotation {\n  const winner = time(theirs.updatedAt) > time(mine.updatedAt) ? theirs : mine\n  if (mine.kind === 'comment' && theirs.kind === 'comment' && winner.kind === 'comment') {\n    const replies = mergeReplies(mine.replies, theirs.replies)\n    if (replies.length !== winner.replies.length) return { ...winner, replies } as CommentAnnotation\n  }\n  return winner\n}\n\n/** Merge two versions of a layer; the result keeps `mine`'s order, then marks only `theirs` has. */\nexport function mergeLayers({ base, mine, theirs, deleted }: MergeInput): AnnotationLayer {\n  const baseById = new Map((base?.annotations ?? []).map((a) => [a.id, a]))\n  const theirsById = new Map(theirs.annotations.map((a) => [a.id, a]))\n  const mineIds = new Set(mine.annotations.map((a) => a.id))\n  const out: Annotation[] = []\n\n  for (const m of mine.annotations) {\n    if (deleted?.has(m.id)) continue\n    const t = theirsById.get(m.id)\n    if (t) {\n      out.push(newer(m, t))\n      continue\n    }\n    const b = baseById.get(m.id)\n    // They deleted it. Keep it only if it was edited here after the version they deleted.\n    if (b && time(m.updatedAt) <= time(b.updatedAt)) continue\n    out.push(m)\n  }\n  for (const t of theirs.annotations) {\n    if (mineIds.has(t.id) || deleted?.has(t.id)) continue\n    // Deleted here (it was in the base and is gone from mine): stays deleted.\n    if (baseById.has(t.id)) continue\n    out.push(t)\n  }\n\n  const updatedAt =\n    time(theirs.updatedAt) > time(mine.updatedAt) ? theirs.updatedAt : mine.updatedAt\n  return { ...mine, annotations: out, updatedAt }\n}\n\n/** True when two layers hold the same marks (by id and last edit), whatever their order. */\nexport function sameMarks(a: AnnotationLayer, b: AnnotationLayer): boolean {\n  if (a.annotations.length !== b.annotations.length) return false\n  const byId = new Map(a.annotations.map((m) => [m.id, m.updatedAt]))\n  return b.annotations.every(\n    (m) =>\n      byId.get(m.id) === m.updatedAt &&\n      (m.kind !== 'comment' ||\n        (a.annotations.find((x) => x.id === m.id) as CommentAnnotation).replies.length ===\n          m.replies.length)\n  )\n}\n"],
+  "mappings": "AA2BA,MAAM,OAAO,CAAC,QAAgB;AAC5B,QAAM,IAAI,KAAK,MAAM,GAAG;AACxB,SAAO,OAAO,MAAM,CAAC,IAAI,IAAI;AAC/B;AAEA,SAAS,aAAa,GAAmB,GAAmC;AAC1E,QAAM,OAAO,oBAAI,IAA0B;AAC3C,aAAW,KAAK,CAAC,GAAG,GAAG,GAAG,CAAC,EAAG,KAAI,CAAC,KAAK,IAAI,EAAE,EAAE,EAAG,MAAK,IAAI,EAAE,IAAI,CAAC;AACnE,SAAO,CAAC,GAAG,KAAK,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG,MAAM,KAAK,EAAE,SAAS,IAAI,KAAK,EAAE,SAAS,CAAC;AAChF;AAGA,SAAS,MAAM,MAAkB,QAAgC;AAC/D,QAAM,SAAS,KAAK,OAAO,SAAS,IAAI,KAAK,KAAK,SAAS,IAAI,SAAS;AACxE,MAAI,KAAK,SAAS,aAAa,OAAO,SAAS,aAAa,OAAO,SAAS,WAAW;AACrF,UAAM,UAAU,aAAa,KAAK,SAAS,OAAO,OAAO;AACzD,QAAI,QAAQ,WAAW,OAAO,QAAQ,OAAQ,QAAO,EAAE,GAAG,QAAQ,QAAQ;AAAA,EAC5E;AACA,SAAO;AACT;AAGO,SAAS,YAAY,EAAE,MAAM,MAAM,QAAQ,QAAQ,GAAgC;AACxF,QAAM,WAAW,IAAI,KAAK,MAAM,eAAe,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;AACxE,QAAM,aAAa,IAAI,IAAI,OAAO,YAAY,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;AACnE,QAAM,UAAU,IAAI,IAAI,KAAK,YAAY,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;AACzD,QAAM,MAAoB,CAAC;AAE3B,aAAW,KAAK,KAAK,aAAa;AAChC,QAAI,SAAS,IAAI,EAAE,EAAE,EAAG;AACxB,UAAM,IAAI,WAAW,IAAI,EAAE,EAAE;AAC7B,QAAI,GAAG;AACL,UAAI,KAAK,MAAM,GAAG,CAAC,CAAC;AACpB;AAAA,IACF;AACA,UAAM,IAAI,SAAS,IAAI,EAAE,EAAE;AAE3B,QAAI,KAAK,KAAK,EAAE,SAAS,KAAK,KAAK,EAAE,SAAS,EAAG;AACjD,QAAI,KAAK,CAAC;AAAA,EACZ;AACA,aAAW,KAAK,OAAO,aAAa;AAClC,QAAI,QAAQ,IAAI,EAAE,EAAE,KAAK,SAAS,IAAI,EAAE,EAAE,EAAG;AAE7C,QAAI,SAAS,IAAI,EAAE,EAAE,EAAG;AACxB,QAAI,KAAK,CAAC;AAAA,EACZ;AAEA,QAAM,YACJ,KAAK,OAAO,SAAS,IAAI,KAAK,KAAK,SAAS,IAAI,OAAO,YAAY,KAAK;AAC1E,SAAO,EAAE,GAAG,MAAM,aAAa,KAAK,UAAU;AAChD;AAGO,SAAS,UAAU,GAAoB,GAA6B;AACzE,MAAI,EAAE,YAAY,WAAW,EAAE,YAAY,OAAQ,QAAO;AAC1D,QAAM,OAAO,IAAI,IAAI,EAAE,YAAY,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC;AAClE,SAAO,EAAE,YAAY;AAAA,IACnB,CAAC,MACC,KAAK,IAAI,EAAE,EAAE,MAAM,EAAE,cACpB,EAAE,SAAS,aACT,EAAE,YAAY,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,EAAwB,QAAQ,WACtE,EAAE,QAAQ;AAAA,EAClB;AACF;",
+  "names": []
+}

package/dist/{chunk-T3USOSVN.js → annotations/model.js}

@@ -1,22 +1,21 @@
-// src/annotations/model.ts
-var LAYER_SCHEMA_VERSION = 1;
-var MAX_TEXT_LENGTH = 2e4;
-var MAX_ANNOTATIONS = 2e4;
-var MAX_RECTS_PER_MARK = 2e3;
-var HEX_COLOR = /^#[0-9a-fA-F]{6}$/;
-var KINDS = ["highlight", "box", "comment", "stamp", "redaction"];
-var REDACTION_STATUSES = ["pending", "approved", "rejected"];
-var EDGE_EPSILON = 1e-6;
-var AnnotationLayerError = class extends Error {
+const LAYER_SCHEMA_VERSION = 1;
+const MAX_TEXT_LENGTH = 2e4;
+const MAX_ANNOTATIONS = 2e4;
+const MAX_RECTS_PER_MARK = 2e3;
+const HEX_COLOR = /^#[0-9a-fA-F]{6}$/;
+const KINDS = ["highlight", "box", "comment", "stamp", "redaction"];
+const REDACTION_STATUSES = ["pending", "approved", "rejected"];
+const EDGE_EPSILON = 1e-6;
+class AnnotationLayerError extends Error {
   constructor(message) {
     super(message);
     this.name = "AnnotationLayerError";
   }
-};
+}
 function emptyLayer(documentId, now) {
   return { schema: LAYER_SCHEMA_VERSION, documentId, annotations: [], updatedAt: now };
 }
-var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 function fail(path, problem) {
   throw new AnnotationLayerError(`${path}: ${problem}`);
 }
@@ -180,7 +179,15 @@ function annotationRects(a) {
 function isEffectiveRedaction(a) {
   return a.kind === "redaction" && a.status !== "rejected";
 }
-
-export { AnnotationLayerError, LAYER_SCHEMA_VERSION, annotationRects, clampRect, emptyLayer, isEffectiveRedaction, parseAnnotation, parseLayer };
-//# sourceMappingURL=chunk-T3USOSVN.js.map
-//# sourceMappingURL=chunk-T3USOSVN.js.map
+export {
+  AnnotationLayerError,
+  LAYER_SCHEMA_VERSION,
+  MAX_RECTS_PER_MARK,
+  annotationRects,
+  clampRect,
+  emptyLayer,
+  isEffectiveRedaction,
+  parseAnnotation,
+  parseLayer
+};
+//# sourceMappingURL=model.js.map

package/dist/annotations/model.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/annotations/model.ts"],
+  "sourcesContent": ["/**\n * Annotation layer data model.\n *\n * A layer is plain JSON that sits NEXT TO an immutable document: the original file is never\n * touched, marks are drawn over it, and \"freezing\" (see `freeze.ts`) derives a new document.\n *\n * Geometry is stored as fractions (0..1) of the page as DISPLAYED (after rotation and crop),\n * origin top-left. That makes a mark independent of zoom, device pixel ratio and PDF units, and\n * because the original never changes the coordinates never drift.\n *\n * A redaction mark carries the matched text so a reviewer (or an agent) can see what it hides.\n * That text is sensitive: the layer must never travel with a frozen copy.\n */\n\nexport const LAYER_SCHEMA_VERSION = 1\n\nexport type AnnotationKind = 'highlight' | 'box' | 'comment' | 'stamp' | 'redaction'\nexport type RedactionStatus = 'pending' | 'approved' | 'rejected'\n\n/** Fractions of the displayed page, origin top-left. */\nexport interface NormRect {\n  x: number\n  y: number\n  w: number\n  h: number\n}\n\nexport interface CommentReply {\n  id: string\n  author: string\n  createdAt: string\n  body: string\n}\n\ninterface AnnotationBase {\n  id: string\n  /** 1-based page number. */\n  page: number\n  author: string\n  createdAt: string\n  updatedAt: string\n}\n\nexport interface HighlightAnnotation extends AnnotationBase {\n  kind: 'highlight'\n  rects: NormRect[]\n  color: string\n  /** The highlighted text, when it came from a text selection. */\n  text?: string\n}\n\nexport interface BoxAnnotation extends AnnotationBase {\n  kind: 'box'\n  rect: NormRect\n  color: string\n  /** Outline width in PDF points at 100%. */\n  strokeWidth: number\n}\n\nexport interface CommentAnnotation extends AnnotationBase {\n  kind: 'comment'\n  /** Anchor box; the note icon is drawn at its top-left corner. */\n  rect: NormRect\n  body: string\n  replies: CommentReply[]\n  resolved: boolean\n}\n\nexport interface StampAnnotation extends AnnotationBase {\n  kind: 'stamp'\n  rect: NormRect\n  label: string\n  color: string\n  /**\n   * A picture stamp: one's saved signature or initials placed on the page (base64 PNG), drawn in\n   * the box in place of the framed label (which then only names it).\n   */\n  image?: string\n}\n\nexport interface RedactionAnnotation extends AnnotationBase {\n  kind: 'redaction'\n  rects: NormRect[]\n  /** The review reason (e.g. \"Privileged\"). Kept separately from the printed [REDACTED] label. */\n  reason: string\n  /** The text under the mark. Sensitive: stays in the layer, never in a frozen document. */\n  text?: string\n  status: RedactionStatus\n  /** Who last approved or rejected it, and when (absent while pending). For the redaction log. */\n  reviewedBy?: string\n  reviewedAt?: string\n}\n\nexport type Annotation =\n  HighlightAnnotation | BoxAnnotation | CommentAnnotation | StampAnnotation | RedactionAnnotation\n\nexport interface AnnotationLayer {\n  schema: typeof LAYER_SCHEMA_VERSION\n  /** External id of the immutable document the layer annotates. */\n  documentId: string\n  /** Optional content hash of the original, so a layer can be checked against the file it marks. */\n  documentHash?: string\n  annotations: Annotation[]\n  updatedAt: string\n}\n\nconst MAX_TEXT_LENGTH = 20_000\nconst MAX_ANNOTATIONS = 20_000\nexport const MAX_RECTS_PER_MARK = 2_000\n\nconst HEX_COLOR = /^#[0-9a-fA-F]{6}$/\nconst KINDS: readonly AnnotationKind[] = ['highlight', 'box', 'comment', 'stamp', 'redaction']\nconst REDACTION_STATUSES: readonly RedactionStatus[] = ['pending', 'approved', 'rejected']\n/** Tolerance for rects that overshoot the page edge by floating-point noise. */\nconst EDGE_EPSILON = 1e-6\n\nexport class AnnotationLayerError extends Error {\n  constructor(message: string) {\n    super(message)\n    this.name = 'AnnotationLayerError'\n  }\n}\n\nexport function emptyLayer(documentId: string, now: string): AnnotationLayer {\n  return { schema: LAYER_SCHEMA_VERSION, documentId, annotations: [], updatedAt: now }\n}\n\nconst isRecord = (v: unknown): v is Record<string, unknown> =>\n  typeof v === 'object' && v !== null && !Array.isArray(v)\n\nfunction fail(path: string, problem: string): never {\n  throw new AnnotationLayerError(`${path}: ${problem}`)\n}\n\nfunction str(v: unknown, path: string, max = MAX_TEXT_LENGTH): string {\n  if (typeof v !== 'string') fail(path, 'expected a string')\n  if (v.length > max) fail(path, `longer than ${max} characters`)\n  return v\n}\n\nfunction optStr(v: unknown, path: string): string | undefined {\n  return v === undefined ? undefined : str(v, path)\n}\n\nfunction iso(v: unknown, path: string): string {\n  const s = str(v, path, 64)\n  if (Number.isNaN(Date.parse(s))) fail(path, 'expected an ISO date')\n  return s\n}\n\nfunction color(v: unknown, path: string): string {\n  const s = str(v, path, 16)\n  if (!HEX_COLOR.test(s)) fail(path, 'expected a #rrggbb colour')\n  return s\n}\n\nfunction bool(v: unknown, path: string): boolean {\n  if (typeof v !== 'boolean') fail(path, 'expected a boolean')\n  return v\n}\n\nfunction rect(v: unknown, path: string): NormRect {\n  if (!isRecord(v)) fail(path, 'expected a rectangle')\n  const out = { x: v.x, y: v.y, w: v.w, h: v.h }\n  for (const [key, n] of Object.entries(out)) {\n    if (typeof n !== 'number' || !Number.isFinite(n)) fail(`${path}.${key}`, 'expected a number')\n  }\n  const r = out as NormRect\n  if (r.w < 0 || r.h < 0) fail(path, 'negative size')\n  if (r.x < -EDGE_EPSILON || r.y < -EDGE_EPSILON) fail(path, 'outside the page')\n  if (r.x + r.w > 1 + EDGE_EPSILON || r.y + r.h > 1 + EDGE_EPSILON) fail(path, 'outside the page')\n  return clampRect(r)\n}\n\nfunction rects(v: unknown, path: string): NormRect[] {\n  if (!Array.isArray(v)) fail(path, 'expected a list of rectangles')\n  if (v.length === 0) fail(path, 'needs at least one rectangle')\n  if (v.length > MAX_RECTS_PER_MARK) fail(path, `more than ${MAX_RECTS_PER_MARK} rectangles`)\n  return v.map((r, i) => rect(r, `${path}[${i}]`))\n}\n\nfunction reply(v: unknown, path: string): CommentReply {\n  if (!isRecord(v)) fail(path, 'expected a reply')\n  return {\n    id: str(v.id, `${path}.id`, 128),\n    author: str(v.author, `${path}.author`, 256),\n    createdAt: iso(v.createdAt, `${path}.createdAt`),\n    body: str(v.body, `${path}.body`),\n  }\n}\n\nexport function clampRect(r: NormRect): NormRect {\n  const x = Math.min(1, Math.max(0, r.x))\n  const y = Math.min(1, Math.max(0, r.y))\n  return { x, y, w: Math.min(r.w, 1 - x), h: Math.min(r.h, 1 - y) }\n}\n\n/** Validate one annotation from untrusted JSON. Throws `AnnotationLayerError`. */\nexport function parseAnnotation(v: unknown, path = 'annotation'): Annotation {\n  if (!isRecord(v)) fail(path, 'expected an object')\n  const kind = v.kind\n  if (typeof kind !== 'string' || !KINDS.includes(kind as AnnotationKind)) {\n    fail(`${path}.kind`, 'unknown annotation kind')\n  }\n  const page = v.page\n  if (typeof page !== 'number' || !Number.isInteger(page) || page < 1) {\n    fail(`${path}.page`, 'expected a page number of 1 or more')\n  }\n  const base: AnnotationBase = {\n    id: str(v.id, `${path}.id`, 128),\n    page,\n    author: str(v.author, `${path}.author`, 256),\n    createdAt: iso(v.createdAt, `${path}.createdAt`),\n    updatedAt: iso(v.updatedAt, `${path}.updatedAt`),\n  }\n  if (!base.id) fail(`${path}.id`, 'empty id')\n\n  switch (kind as AnnotationKind) {\n    case 'highlight':\n      return {\n        ...base,\n        kind: 'highlight',\n        rects: rects(v.rects, `${path}.rects`),\n        color: color(v.color, `${path}.color`),\n        text: optStr(v.text, `${path}.text`),\n      }\n    case 'box': {\n      const strokeWidth = v.strokeWidth\n      if (typeof strokeWidth !== 'number' || !(strokeWidth > 0) || strokeWidth > 50) {\n        fail(`${path}.strokeWidth`, 'expected a width between 0 and 50')\n      }\n      return {\n        ...base,\n        kind: 'box',\n        rect: rect(v.rect, `${path}.rect`),\n        color: color(v.color, `${path}.color`),\n        strokeWidth,\n      }\n    }\n    case 'comment': {\n      if (!Array.isArray(v.replies)) fail(`${path}.replies`, 'expected a list')\n      return {\n        ...base,\n        kind: 'comment',\n        rect: rect(v.rect, `${path}.rect`),\n        body: str(v.body, `${path}.body`),\n        replies: v.replies.map((r, i) => reply(r, `${path}.replies[${i}]`)),\n        resolved: bool(v.resolved, `${path}.resolved`),\n      }\n    }\n    case 'stamp':\n      return {\n        ...base,\n        kind: 'stamp',\n        rect: rect(v.rect, `${path}.rect`),\n        label: str(v.label, `${path}.label`, 200),\n        color: color(v.color, `${path}.color`),\n        ...(v.image === undefined || v.image === null\n          ? {}\n          : { image: str(v.image, `${path}.image`, 600_000) }),\n      }\n    case 'redaction': {\n      const status = v.status\n      if (typeof status !== 'string' || !REDACTION_STATUSES.includes(status as RedactionStatus)) {\n        fail(`${path}.status`, 'unknown redaction status')\n      }\n      return {\n        ...base,\n        kind: 'redaction',\n        rects: rects(v.rects, `${path}.rects`),\n        reason: str(v.reason, `${path}.reason`, 200),\n        text: optStr(v.text, `${path}.text`),\n        status: status as RedactionStatus,\n        ...(v.reviewedBy === undefined\n          ? {}\n          : { reviewedBy: str(v.reviewedBy, `${path}.reviewedBy`, 256) }),\n        ...(v.reviewedAt === undefined\n          ? {}\n          : { reviewedAt: iso(v.reviewedAt, `${path}.reviewedAt`) }),\n      }\n    }\n  }\n}\n\n/** Validate a whole layer from untrusted JSON (storage, network, an agent). */\nexport function parseLayer(v: unknown): AnnotationLayer {\n  if (!isRecord(v)) fail('layer', 'expected an object')\n  if (v.schema !== LAYER_SCHEMA_VERSION)\n    fail('layer.schema', `expected schema ${LAYER_SCHEMA_VERSION}`)\n  if (!Array.isArray(v.annotations)) fail('layer.annotations', 'expected a list')\n  if (v.annotations.length > MAX_ANNOTATIONS) {\n    fail('layer.annotations', `more than ${MAX_ANNOTATIONS} annotations`)\n  }\n  const annotations = v.annotations.map((a, i) => parseAnnotation(a, `layer.annotations[${i}]`))\n  const seen = new Set<string>()\n  for (const a of annotations) {\n    if (seen.has(a.id)) fail('layer.annotations', `duplicate id ${a.id}`)\n    seen.add(a.id)\n  }\n  return {\n    schema: LAYER_SCHEMA_VERSION,\n    documentId: str(v.documentId, 'layer.documentId', 256),\n    documentHash: optStr(v.documentHash, 'layer.documentHash'),\n    annotations,\n    updatedAt: iso(v.updatedAt, 'layer.updatedAt'),\n  }\n}\n\n/** The rectangles a mark covers, whatever its kind. */\nexport function annotationRects(a: Annotation): NormRect[] {\n  return a.kind === 'highlight' || a.kind === 'redaction' ? a.rects : [a.rect]\n}\n\n/**\n * True when a redaction mark will be burned into a frozen copy. Fails closed: only an explicit\n * rejection leaves content visible, so a mark nobody reviewed is never silently skipped.\n */\nexport function isEffectiveRedaction(a: Annotation): a is RedactionAnnotation {\n  return a.kind === 'redaction' && a.status !== 'rejected'\n}\n"],
+  "mappings": "AAcO,MAAM,uBAAuB;AA4FpC,MAAM,kBAAkB;AACxB,MAAM,kBAAkB;AACjB,MAAM,qBAAqB;AAElC,MAAM,YAAY;AAClB,MAAM,QAAmC,CAAC,aAAa,OAAO,WAAW,SAAS,WAAW;AAC7F,MAAM,qBAAiD,CAAC,WAAW,YAAY,UAAU;AAEzF,MAAM,eAAe;AAEd,MAAM,6BAA6B,MAAM;AAAA,EAC9C,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAEO,SAAS,WAAW,YAAoB,KAA8B;AAC3E,SAAO,EAAE,QAAQ,sBAAsB,YAAY,aAAa,CAAC,GAAG,WAAW,IAAI;AACrF;AAEA,MAAM,WAAW,CAAC,MAChB,OAAO,MAAM,YAAY,MAAM,QAAQ,CAAC,MAAM,QAAQ,CAAC;AAEzD,SAAS,KAAK,MAAc,SAAwB;AAClD,QAAM,IAAI,qBAAqB,GAAG,IAAI,KAAK,OAAO,EAAE;AACtD;AAEA,SAAS,IAAI,GAAY,MAAc,MAAM,iBAAyB;AACpE,MAAI,OAAO,MAAM,SAAU,MAAK,MAAM,mBAAmB;AACzD,MAAI,EAAE,SAAS,IAAK,MAAK,MAAM,eAAe,GAAG,aAAa;AAC9D,SAAO;AACT;AAEA,SAAS,OAAO,GAAY,MAAkC;AAC5D,SAAO,MAAM,SAAY,SAAY,IAAI,GAAG,IAAI;AAClD;AAEA,SAAS,IAAI,GAAY,MAAsB;AAC7C,QAAM,IAAI,IAAI,GAAG,MAAM,EAAE;AACzB,MAAI,OAAO,MAAM,KAAK,MAAM,CAAC,CAAC,EAAG,MAAK,MAAM,sBAAsB;AAClE,SAAO;AACT;AAEA,SAAS,MAAM,GAAY,MAAsB;AAC/C,QAAM,IAAI,IAAI,GAAG,MAAM,EAAE;AACzB,MAAI,CAAC,UAAU,KAAK,CAAC,EAAG,MAAK,MAAM,2BAA2B;AAC9D,SAAO;AACT;AAEA,SAAS,KAAK,GAAY,MAAuB;AAC/C,MAAI,OAAO,MAAM,UAAW,MAAK,MAAM,oBAAoB;AAC3D,SAAO;AACT;AAEA,SAAS,KAAK,GAAY,MAAwB;AAChD,MAAI,CAAC,SAAS,CAAC,EAAG,MAAK,MAAM,sBAAsB;AACnD,QAAM,MAAM,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,GAAG,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE;AAC7C,aAAW,CAAC,KAAK,CAAC,KAAK,OAAO,QAAQ,GAAG,GAAG;AAC1C,QAAI,OAAO,MAAM,YAAY,CAAC,OAAO,SAAS,CAAC,EAAG,MAAK,GAAG,IAAI,IAAI,GAAG,IAAI,mBAAmB;AAAA,EAC9F;AACA,QAAM,IAAI;AACV,MAAI,EAAE,IAAI,KAAK,EAAE,IAAI,EAAG,MAAK,MAAM,eAAe;AAClD,MAAI,EAAE,IAAI,CAAC,gBAAgB,EAAE,IAAI,CAAC,aAAc,MAAK,MAAM,kBAAkB;AAC7E,MAAI,EAAE,IAAI,EAAE,IAAI,IAAI,gBAAgB,EAAE,IAAI,EAAE,IAAI,IAAI,aAAc,MAAK,MAAM,kBAAkB;AAC/F,SAAO,UAAU,CAAC;AACpB;AAEA,SAAS,MAAM,GAAY,MAA0B;AACnD,MAAI,CAAC,MAAM,QAAQ,CAAC,EAAG,MAAK,MAAM,+BAA+B;AACjE,MAAI,EAAE,WAAW,EAAG,MAAK,MAAM,8BAA8B;AAC7D,MAAI,EAAE,SAAS,mBAAoB,MAAK,MAAM,aAAa,kBAAkB,aAAa;AAC1F,SAAO,EAAE,IAAI,CAAC,GAAG,MAAM,KAAK,GAAG,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC;AACjD;AAEA,SAAS,MAAM,GAAY,MAA4B;AACrD,MAAI,CAAC,SAAS,CAAC,EAAG,MAAK,MAAM,kBAAkB;AAC/C,SAAO;AAAA,IACL,IAAI,IAAI,EAAE,IAAI,GAAG,IAAI,OAAO,GAAG;AAAA,IAC/B,QAAQ,IAAI,EAAE,QAAQ,GAAG,IAAI,WAAW,GAAG;AAAA,IAC3C,WAAW,IAAI,EAAE,WAAW,GAAG,IAAI,YAAY;AAAA,IAC/C,MAAM,IAAI,EAAE,MAAM,GAAG,IAAI,OAAO;AAAA,EAClC;AACF;AAEO,SAAS,UAAU,GAAuB;AAC/C,QAAM,IAAI,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,EAAE,CAAC,CAAC;AACtC,QAAM,IAAI,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,EAAE,CAAC,CAAC;AACtC,SAAO,EAAE,GAAG,GAAG,GAAG,KAAK,IAAI,EAAE,GAAG,IAAI,CAAC,GAAG,GAAG,KAAK,IAAI,EAAE,GAAG,IAAI,CAAC,EAAE;AAClE;AAGO,SAAS,gBAAgB,GAAY,OAAO,cAA0B;AAC3E,MAAI,CAAC,SAAS,CAAC,EAAG,MAAK,MAAM,oBAAoB;AACjD,QAAM,OAAO,EAAE;AACf,MAAI,OAAO,SAAS,YAAY,CAAC,MAAM,SAAS,IAAsB,GAAG;AACvE,SAAK,GAAG,IAAI,SAAS,yBAAyB;AAAA,EAChD;AACA,QAAM,OAAO,EAAE;AACf,MAAI,OAAO,SAAS,YAAY,CAAC,OAAO,UAAU,IAAI,KAAK,OAAO,GAAG;AACnE,SAAK,GAAG,IAAI,SAAS,qCAAqC;AAAA,EAC5D;AACA,QAAM,OAAuB;AAAA,IAC3B,IAAI,IAAI,EAAE,IAAI,GAAG,IAAI,OAAO,GAAG;AAAA,IAC/B;AAAA,IACA,QAAQ,IAAI,EAAE,QAAQ,GAAG,IAAI,WAAW,GAAG;AAAA,IAC3C,WAAW,IAAI,EAAE,WAAW,GAAG,IAAI,YAAY;AAAA,IAC/C,WAAW,IAAI,EAAE,WAAW,GAAG,IAAI,YAAY;AAAA,EACjD;AACA,MAAI,CAAC,KAAK,GAAI,MAAK,GAAG,IAAI,OAAO,UAAU;AAE3C,UAAQ,MAAwB;AAAA,IAC9B,KAAK;AACH,aAAO;AAAA,QACL,GAAG;AAAA,QACH,MAAM;AAAA,QACN,OAAO,MAAM,EAAE,OAAO,GAAG,IAAI,QAAQ;AAAA,QACrC,OAAO,MAAM,EAAE,OAAO,GAAG,IAAI,QAAQ;AAAA,QACrC,MAAM,OAAO,EAAE,MAAM,GAAG,IAAI,OAAO;AAAA,MACrC;AAAA,IACF,KAAK,OAAO;AACV,YAAM,cAAc,EAAE;AACtB,UAAI,OAAO,gBAAgB,YAAY,EAAE,cAAc,MAAM,cAAc,IAAI;AAC7E,aAAK,GAAG,IAAI,gBAAgB,mCAAmC;AAAA,MACjE;AACA,aAAO;AAAA,QACL,GAAG;AAAA,QACH,MAAM;AAAA,QACN,MAAM,KAAK,EAAE,MAAM,GAAG,IAAI,OAAO;AAAA,QACjC,OAAO,MAAM,EAAE,OAAO,GAAG,IAAI,QAAQ;AAAA,QACrC;AAAA,MACF;AAAA,IACF;AAAA,IACA,KAAK,WAAW;AACd,UAAI,CAAC,MAAM,QAAQ,EAAE,OAAO,EAAG,MAAK,GAAG,IAAI,YAAY,iBAAiB;AACxE,aAAO;AAAA,QACL,GAAG;AAAA,QACH,MAAM;AAAA,QACN,MAAM,KAAK,EAAE,MAAM,GAAG,IAAI,OAAO;AAAA,QACjC,MAAM,IAAI,EAAE,MAAM,GAAG,IAAI,OAAO;AAAA,QAChC,SAAS,EAAE,QAAQ,IAAI,CAAC,GAAG,MAAM,MAAM,GAAG,GAAG,IAAI,YAAY,CAAC,GAAG,CAAC;AAAA,QAClE,UAAU,KAAK,EAAE,UAAU,GAAG,IAAI,WAAW;AAAA,MAC/C;AAAA,IACF;AAAA,IACA,KAAK;AACH,aAAO;AAAA,QACL,GAAG;AAAA,QACH,MAAM;AAAA,QACN,MAAM,KAAK,EAAE,MAAM,GAAG,IAAI,OAAO;AAAA,QACjC,OAAO,IAAI,EAAE,OAAO,GAAG,IAAI,UAAU,GAAG;AAAA,QACxC,OAAO,MAAM,EAAE,OAAO,GAAG,IAAI,QAAQ;AAAA,QACrC,GAAI,EAAE,UAAU,UAAa,EAAE,UAAU,OACrC,CAAC,IACD,EAAE,OAAO,IAAI,EAAE,OAAO,GAAG,IAAI,UAAU,GAAO,EAAE;AAAA,MACtD;AAAA,IACF,KAAK,aAAa;AAChB,YAAM,SAAS,EAAE;AACjB,UAAI,OAAO,WAAW,YAAY,CAAC,mBAAmB,SAAS,MAAyB,GAAG;AACzF,aAAK,GAAG,IAAI,WAAW,0BAA0B;AAAA,MACnD;AACA,aAAO;AAAA,QACL,GAAG;AAAA,QACH,MAAM;AAAA,QACN,OAAO,MAAM,EAAE,OAAO,GAAG,IAAI,QAAQ;AAAA,QACrC,QAAQ,IAAI,EAAE,QAAQ,GAAG,IAAI,WAAW,GAAG;AAAA,QAC3C,MAAM,OAAO,EAAE,MAAM,GAAG,IAAI,OAAO;AAAA,QACnC;AAAA,QACA,GAAI,EAAE,eAAe,SACjB,CAAC,IACD,EAAE,YAAY,IAAI,EAAE,YAAY,GAAG,IAAI,eAAe,GAAG,EAAE;AAAA,QAC/D,GAAI,EAAE,eAAe,SACjB,CAAC,IACD,EAAE,YAAY,IAAI,EAAE,YAAY,GAAG,IAAI,aAAa,EAAE;AAAA,MAC5D;AAAA,IACF;AAAA,EACF;AACF;AAGO,SAAS,WAAW,GAA6B;AACtD,MAAI,CAAC,SAAS,CAAC,EAAG,MAAK,SAAS,oBAAoB;AACpD,MAAI,EAAE,WAAW;AACf,SAAK,gBAAgB,mBAAmB,oBAAoB,EAAE;AAChE,MAAI,CAAC,MAAM,QAAQ,EAAE,WAAW,EAAG,MAAK,qBAAqB,iBAAiB;AAC9E,MAAI,EAAE,YAAY,SAAS,iBAAiB;AAC1C,SAAK,qBAAqB,aAAa,eAAe,cAAc;AAAA,EACtE;AACA,QAAM,cAAc,EAAE,YAAY,IAAI,CAAC,GAAG,MAAM,gBAAgB,GAAG,qBAAqB,CAAC,GAAG,CAAC;AAC7F,QAAM,OAAO,oBAAI,IAAY;AAC7B,aAAW,KAAK,aAAa;AAC3B,QAAI,KAAK,IAAI,EAAE,EAAE,EAAG,MAAK,qBAAqB,gBAAgB,EAAE,EAAE,EAAE;AACpE,SAAK,IAAI,EAAE,EAAE;AAAA,EACf;AACA,SAAO;AAAA,IACL,QAAQ;AAAA,IACR,YAAY,IAAI,EAAE,YAAY,oBAAoB,GAAG;AAAA,IACrD,cAAc,OAAO,EAAE,cAAc,oBAAoB;AAAA,IACzD;AAAA,IACA,WAAW,IAAI,EAAE,WAAW,iBAAiB;AAAA,EAC/C;AACF;AAGO,SAAS,gBAAgB,GAA2B;AACzD,SAAO,EAAE,SAAS,eAAe,EAAE,SAAS,cAAc,EAAE,QAAQ,CAAC,EAAE,IAAI;AAC7E;AAMO,SAAS,qBAAqB,GAAyC;AAC5E,SAAO,EAAE,SAAS,eAAe,EAAE,WAAW;AAChD;",
+  "names": []
+}

package/dist/annotations/overlay-geometry.js

@@ -0,0 +1,41 @@
+import { clampRect } from "./model.js";
+const MIN_MARK = 0.01;
+function singleRect(a) {
+  if (a.kind === "box" || a.kind === "stamp" || a.kind === "comment") return a.rect;
+  if (a.kind === "redaction" && a.rects.length === 1) return a.rects[0];
+  return null;
+}
+const patchForRect = (a, rect) => a.kind === "redaction" ? { rects: [rect] } : { rect };
+function dragRect(origin, mode, dx, dy) {
+  if (mode === "move") {
+    return {
+      ...origin,
+      x: Math.min(Math.max(origin.x + dx, 0), 1 - origin.w),
+      y: Math.min(Math.max(origin.y + dy, 0), 1 - origin.h)
+    };
+  }
+  let left = origin.x;
+  let right = origin.x + origin.w;
+  let top = origin.y;
+  let bottom = origin.y + origin.h;
+  if (mode.includes("w")) left += dx;
+  else right += dx;
+  if (mode.includes("n")) top += dy;
+  else bottom += dy;
+  const x1 = Math.min(Math.max(Math.min(left, right), 0), 1);
+  const x2 = Math.min(Math.max(Math.max(left, right), 0), 1);
+  const y1 = Math.min(Math.max(Math.min(top, bottom), 0), 1);
+  const y2 = Math.min(Math.max(Math.max(top, bottom), 0), 1);
+  return clampRect({
+    x: x1,
+    y: y1,
+    w: Math.max(x2 - x1, MIN_MARK),
+    h: Math.max(y2 - y1, MIN_MARK)
+  });
+}
+export {
+  dragRect,
+  patchForRect,
+  singleRect
+};
+//# sourceMappingURL=overlay-geometry.js.map

package/dist/annotations/overlay-geometry.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/annotations/overlay-geometry.ts"],
+  "sourcesContent": ["/**\n * Pure geometry for moving and resizing a single-rectangle mark. Kept out of the component file so\n * it can be tested and reused without a renderer.\n */\n\nimport { clampRect, type Annotation, type NormRect } from './model'\n\nconst MIN_MARK = 0.01\n\nexport type DragMode = 'move' | 'nw' | 'ne' | 'sw' | 'se'\n\n/** The single rectangle of a mark that can be moved and resized, or null for multi-rect marks. */\nexport function singleRect(a: Annotation): NormRect | null {\n  if (a.kind === 'box' || a.kind === 'stamp' || a.kind === 'comment') return a.rect\n  if (a.kind === 'redaction' && a.rects.length === 1) return a.rects[0]\n  return null\n}\n\nexport const patchForRect = (a: Annotation, rect: NormRect) =>\n  a.kind === 'redaction' ? { rects: [rect] } : { rect }\n\n/** Move or resize `origin` by a pointer delta given as fractions of the page. */\nexport function dragRect(origin: NormRect, mode: DragMode, dx: number, dy: number): NormRect {\n  if (mode === 'move') {\n    return {\n      ...origin,\n      x: Math.min(Math.max(origin.x + dx, 0), 1 - origin.w),\n      y: Math.min(Math.max(origin.y + dy, 0), 1 - origin.h),\n    }\n  }\n  let left = origin.x\n  let right = origin.x + origin.w\n  let top = origin.y\n  let bottom = origin.y + origin.h\n  if (mode.includes('w')) left += dx\n  else right += dx\n  if (mode.includes('n')) top += dy\n  else bottom += dy\n  const x1 = Math.min(Math.max(Math.min(left, right), 0), 1)\n  const x2 = Math.min(Math.max(Math.max(left, right), 0), 1)\n  const y1 = Math.min(Math.max(Math.min(top, bottom), 0), 1)\n  const y2 = Math.min(Math.max(Math.max(top, bottom), 0), 1)\n  return clampRect({\n    x: x1,\n    y: y1,\n    w: Math.max(x2 - x1, MIN_MARK),\n    h: Math.max(y2 - y1, MIN_MARK),\n  })\n}\n"],
+  "mappings": "AAKA,SAAS,iBAAiD;AAE1D,MAAM,WAAW;AAKV,SAAS,WAAW,GAAgC;AACzD,MAAI,EAAE,SAAS,SAAS,EAAE,SAAS,WAAW,EAAE,SAAS,UAAW,QAAO,EAAE;AAC7E,MAAI,EAAE,SAAS,eAAe,EAAE,MAAM,WAAW,EAAG,QAAO,EAAE,MAAM,CAAC;AACpE,SAAO;AACT;AAEO,MAAM,eAAe,CAAC,GAAe,SAC1C,EAAE,SAAS,cAAc,EAAE,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK;AAG/C,SAAS,SAAS,QAAkB,MAAgB,IAAY,IAAsB;AAC3F,MAAI,SAAS,QAAQ;AACnB,WAAO;AAAA,MACL,GAAG;AAAA,MACH,GAAG,KAAK,IAAI,KAAK,IAAI,OAAO,IAAI,IAAI,CAAC,GAAG,IAAI,OAAO,CAAC;AAAA,MACpD,GAAG,KAAK,IAAI,KAAK,IAAI,OAAO,IAAI,IAAI,CAAC,GAAG,IAAI,OAAO,CAAC;AAAA,IACtD;AAAA,EACF;AACA,MAAI,OAAO,OAAO;AAClB,MAAI,QAAQ,OAAO,IAAI,OAAO;AAC9B,MAAI,MAAM,OAAO;AACjB,MAAI,SAAS,OAAO,IAAI,OAAO;AAC/B,MAAI,KAAK,SAAS,GAAG,EAAG,SAAQ;AAAA,MAC3B,UAAS;AACd,MAAI,KAAK,SAAS,GAAG,EAAG,QAAO;AAAA,MAC1B,WAAU;AACf,QAAM,KAAK,KAAK,IAAI,KAAK,IAAI,KAAK,IAAI,MAAM,KAAK,GAAG,CAAC,GAAG,CAAC;AACzD,QAAM,KAAK,KAAK,IAAI,KAAK,IAAI,KAAK,IAAI,MAAM,KAAK,GAAG,CAAC,GAAG,CAAC;AACzD,QAAM,KAAK,KAAK,IAAI,KAAK,IAAI,KAAK,IAAI,KAAK,MAAM,GAAG,CAAC,GAAG,CAAC;AACzD,QAAM,KAAK,KAAK,IAAI,KAAK,IAAI,KAAK,IAAI,KAAK,MAAM,GAAG,CAAC,GAAG,CAAC;AACzD,SAAO,UAAU;AAAA,IACf,GAAG;AAAA,IACH,GAAG;AAAA,IACH,GAAG,KAAK,IAAI,KAAK,IAAI,QAAQ;AAAA,IAC7B,GAAG,KAAK,IAAI,KAAK,IAAI,QAAQ;AAAA,EAC/B,CAAC;AACH;",
+  "names": []
+}

package/dist/annotations/redaction-log.js

@@ -0,0 +1,33 @@
+const REDACTION_LOG_COLUMNS = ["page", "reason", "status", "approved_by", "time"];
+const STATUS = {
+  approved: "redacted (approved)",
+  pending: "redacted (not reviewed)",
+  rejected: "not redacted (rejected)"
+};
+const top = (a) => Math.min(...a.rects.map((r) => r.y));
+const left = (a) => Math.min(...a.rects.map((r) => r.x));
+function redactionLogRows(layer) {
+  return layer.annotations.filter((a) => a.kind === "redaction").sort((a, b) => a.page - b.page || top(a) - top(b) || left(a) - left(b)).map((a) => ({
+    page: a.page,
+    reason: a.reason,
+    status: STATUS[a.status],
+    approvedBy: a.status === "approved" ? a.reviewedBy ?? "" : "",
+    time: a.reviewedAt ?? a.createdAt
+  }));
+}
+const cell = (value) => {
+  const text = String(value);
+  return `"${(/^[=+\-@]/.test(text) ? `'${text}` : text).replace(/"/g, '""')}"`;
+};
+function redactionLogCsv(layer) {
+  const rows = redactionLogRows(layer).map(
+    (r) => [r.page, r.reason, r.status, r.approvedBy, r.time].map(cell).join(",")
+  );
+  return [REDACTION_LOG_COLUMNS.join(","), ...rows].join("\r\n") + "\r\n";
+}
+export {
+  REDACTION_LOG_COLUMNS,
+  redactionLogCsv,
+  redactionLogRows
+};
+//# sourceMappingURL=redaction-log.js.map

package/dist/annotations/redaction-log.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/annotations/redaction-log.ts"],
+  "sourcesContent": ["/**\n * The redaction log of a layer: one CSV row per redaction mark (page, reason, status, who approved\n * it and when), the record a privilege or redaction log is built from.\n *\n * It never carries the redacted text: the log travels with the redacted copy, so it must not undo\n * it. Rows are in reading order (page, then top to bottom, then left to right).\n */\n\nimport type { AnnotationLayer, RedactionAnnotation } from './model'\n\nexport const REDACTION_LOG_COLUMNS = ['page', 'reason', 'status', 'approved_by', 'time'] as const\n\nexport interface RedactionLogRow {\n  page: number\n  reason: string\n  /** What the frozen copy shows for this mark. */\n  status: 'redacted (approved)' | 'redacted (not reviewed)' | 'not redacted (rejected)'\n  /** Who approved it; empty when it was not approved. */\n  approvedBy: string\n  /** When it was reviewed, or when it was made if nobody reviewed it (ISO). */\n  time: string\n}\n\nconst STATUS: Record<RedactionAnnotation['status'], RedactionLogRow['status']> = {\n  approved: 'redacted (approved)',\n  pending: 'redacted (not reviewed)',\n  rejected: 'not redacted (rejected)',\n}\n\nconst top = (a: RedactionAnnotation) => Math.min(...a.rects.map((r) => r.y))\nconst left = (a: RedactionAnnotation) => Math.min(...a.rects.map((r) => r.x))\n\nexport function redactionLogRows(layer: AnnotationLayer): RedactionLogRow[] {\n  return layer.annotations\n    .filter((a): a is RedactionAnnotation => a.kind === 'redaction')\n    .sort((a, b) => a.page - b.page || top(a) - top(b) || left(a) - left(b))\n    .map((a) => ({\n      page: a.page,\n      reason: a.reason,\n      status: STATUS[a.status],\n      approvedBy: a.status === 'approved' ? (a.reviewedBy ?? '') : '',\n      time: a.reviewedAt ?? a.createdAt,\n    }))\n}\n\n// Quote every cell; a leading =, +, - or @ would run as a formula in a spreadsheet.\nconst cell = (value: string | number) => {\n  const text = String(value)\n  return `\"${(/^[=+\\-@]/.test(text) ? `'${text}` : text).replace(/\"/g, '\"\"')}\"`\n}\n\n/** The log as CSV text (header row first, CRLF line ends as RFC 4180 has them). */\nexport function redactionLogCsv(layer: AnnotationLayer): string {\n  const rows = redactionLogRows(layer).map((r) =>\n    [r.page, r.reason, r.status, r.approvedBy, r.time].map(cell).join(',')\n  )\n  return [REDACTION_LOG_COLUMNS.join(','), ...rows].join('\\r\\n') + '\\r\\n'\n}\n"],
+  "mappings": "AAUO,MAAM,wBAAwB,CAAC,QAAQ,UAAU,UAAU,eAAe,MAAM;AAavF,MAAM,SAA2E;AAAA,EAC/E,UAAU;AAAA,EACV,SAAS;AAAA,EACT,UAAU;AACZ;AAEA,MAAM,MAAM,CAAC,MAA2B,KAAK,IAAI,GAAG,EAAE,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;AAC3E,MAAM,OAAO,CAAC,MAA2B,KAAK,IAAI,GAAG,EAAE,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;AAErE,SAAS,iBAAiB,OAA2C;AAC1E,SAAO,MAAM,YACV,OAAO,CAAC,MAAgC,EAAE,SAAS,WAAW,EAC9D,KAAK,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,QAAQ,IAAI,CAAC,IAAI,IAAI,CAAC,KAAK,KAAK,CAAC,IAAI,KAAK,CAAC,CAAC,EACtE,IAAI,CAAC,OAAO;AAAA,IACX,MAAM,EAAE;AAAA,IACR,QAAQ,EAAE;AAAA,IACV,QAAQ,OAAO,EAAE,MAAM;AAAA,IACvB,YAAY,EAAE,WAAW,aAAc,EAAE,cAAc,KAAM;AAAA,IAC7D,MAAM,EAAE,cAAc,EAAE;AAAA,EAC1B,EAAE;AACN;AAGA,MAAM,OAAO,CAAC,UAA2B;AACvC,QAAM,OAAO,OAAO,KAAK;AACzB,SAAO,KAAK,WAAW,KAAK,IAAI,IAAI,IAAI,IAAI,KAAK,MAAM,QAAQ,MAAM,IAAI,CAAC;AAC5E;AAGO,SAAS,gBAAgB,OAAgC;AAC9D,QAAM,OAAO,iBAAiB,KAAK,EAAE;AAAA,IAAI,CAAC,MACxC,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,IAAI,IAAI,EAAE,KAAK,GAAG;AAAA,EACvE;AACA,SAAO,CAAC,sBAAsB,KAAK,GAAG,GAAG,GAAG,IAAI,EAAE,KAAK,MAAM,IAAI;AACnE;",
+  "names": []
+}

package/dist/annotations/selection-marks.js

@@ -0,0 +1,122 @@
+import { mergeLineRects, toNorm } from "./geometry.js";
+const MIN_RECT_PX = 1;
+function selectionToPageMarks(pages) {
+  const out = [];
+  for (const p of pages) {
+    if (!(p.box.width > 0) || !(p.box.height > 0)) continue;
+    const local = p.rects.filter((r) => r.width >= MIN_RECT_PX && r.height >= MIN_RECT_PX).map((r) => ({ x: r.x - p.box.x, y: r.y - p.box.y, width: r.width, height: r.height })).filter(
+      (r) => r.x + r.width > 0 && r.y + r.height > 0 && r.x < p.box.width && r.y < p.box.height
+    );
+    const lines = mergeLineRects(local);
+    if (lines.length === 0) continue;
+    out.push({
+      page: p.page,
+      rects: lines.map((r) => toNorm(r, { width: p.box.width, height: p.box.height })),
+      text: p.text.replace(/\s+/g, " ").trim()
+    });
+  }
+  return out;
+}
+const PAGE_ATTRIBUTE = "data-annotation-page";
+const ownerDocument = (node) => node.ownerDocument ?? document;
+const toPixelRect = (r) => ({
+  x: r.left,
+  y: r.top,
+  width: r.width,
+  height: r.height
+});
+function clipRange(range, container) {
+  if (!range.intersectsNode(container)) return null;
+  const bounds = ownerDocument(container).createRange();
+  bounds.selectNodeContents(container);
+  const clipped = range.cloneRange();
+  if (clipped.compareBoundaryPoints(Range.START_TO_START, bounds) < 0) {
+    clipped.setStart(bounds.startContainer, bounds.startOffset);
+  }
+  if (clipped.compareBoundaryPoints(Range.END_TO_END, bounds) > 0) {
+    clipped.setEnd(bounds.endContainer, bounds.endOffset);
+  }
+  return clipped;
+}
+function textClientRects(range, container) {
+  const doc = ownerDocument(container);
+  const walker = doc.createTreeWalker(container, NodeFilter.SHOW_TEXT);
+  const rects = [];
+  for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+    if (!node.textContent?.trim() || !range.intersectsNode(node)) continue;
+    const part = doc.createRange();
+    part.selectNodeContents(node);
+    if (node === range.startContainer) part.setStart(node, range.startOffset);
+    if (node === range.endContainer) part.setEnd(node, range.endOffset);
+    rects.push(...Array.from(part.getClientRects()));
+  }
+  return rects;
+}
+function firstTextAt(container, offset) {
+  if (container.nodeType === Node.TEXT_NODE) return { node: container, offset };
+  const child = container.childNodes[offset];
+  if (!child) return null;
+  if (child.nodeType === Node.TEXT_NODE) return { node: child, offset: 0 };
+  const first = ownerDocument(child).createTreeWalker(child, NodeFilter.SHOW_TEXT).nextNode();
+  return first ? { node: first, offset: 0 } : null;
+}
+function extendFocusToPointer(selection, point) {
+  if (selection.rangeCount === 0 || selection.isCollapsed) return;
+  const range = selection.getRangeAt(0);
+  if (selection.focusNode !== range.endContainer || selection.focusOffset !== range.endOffset)
+    return;
+  const start = firstTextAt(range.endContainer, range.endOffset);
+  if (!start) return;
+  const doc = ownerDocument(start.node);
+  const walker = doc.createTreeWalker(doc.body, NodeFilter.SHOW_TEXT);
+  walker.currentNode = start.node;
+  const glyph = doc.createRange();
+  let end = null;
+  let node = start.node;
+  let offset = start.offset;
+  let passed = false;
+  while (node && !passed) {
+    const text = node.textContent ?? "";
+    for (let i = offset; i < text.length && !passed; i++) {
+      glyph.setStart(node, i);
+      glyph.setEnd(node, i + 1);
+      const r = glyph.getBoundingClientRect();
+      if (r.height === 0) continue;
+      const mid = r.top + r.height / 2;
+      if (mid > point.y + r.height / 2) passed = true;
+      else if (Math.abs(mid - point.y) > r.height / 2) continue;
+      else if (r.right > point.x + 0.5) passed = true;
+      else end = { node, offset: i + 1 };
+    }
+    node = walker.nextNode();
+    offset = 0;
+  }
+  if (end) selection.extend(end.node, end.offset);
+}
+function readSelection(selection, root = document) {
+  if (selection.rangeCount === 0 || selection.isCollapsed) return [];
+  const range = selection.getRangeAt(0);
+  const pages = [];
+  root.querySelectorAll(`[${PAGE_ATTRIBUTE}]`).forEach((overlay) => {
+    const page = Number(overlay.getAttribute(PAGE_ATTRIBUTE));
+    const container = overlay.parentElement;
+    if (!container || !Number.isInteger(page)) return;
+    const clipped = clipRange(range, container);
+    if (!clipped) return;
+    pages.push({
+      page,
+      box: toPixelRect(overlay.getBoundingClientRect()),
+      rects: textClientRects(clipped, container).map(toPixelRect),
+      text: clipped.toString()
+    });
+  });
+  return pages;
+}
+export {
+  PAGE_ATTRIBUTE,
+  clipRange,
+  extendFocusToPointer,
+  readSelection,
+  selectionToPageMarks
+};
+//# sourceMappingURL=selection-marks.js.map

package/dist/annotations/selection-marks.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/annotations/selection-marks.ts"],
+  "sourcesContent": ["/**\n * Turn a text selection into marks. The browser selects over pdf.js's text layer; each page's\n * share of the selection becomes one mark of normalised line boxes (page-relative, zoom-proof).\n *\n * `selectionToPageMarks` is pure so it can be tested without a layout engine; `readSelection`\n * is the thin DOM side that measures a real selection.\n */\n\nimport { mergeLineRects, toNorm, type PixelRect } from './geometry'\nimport type { NormRect } from './model'\n\n/** One page's slice of a selection, in client (viewport) coordinates. */\nexport interface PageSelection {\n  page: number\n  /** The page's box on screen. */\n  box: PixelRect\n  /** Client rects of the selected text on this page. */\n  rects: PixelRect[]\n  text: string\n}\n\nexport interface PageTextMark {\n  page: number\n  rects: NormRect[]\n  text: string\n}\n\n/** Rects smaller than this many CSS pixels (either side) are layout noise, not selected text. */\nconst MIN_RECT_PX = 1\n\nexport function selectionToPageMarks(pages: PageSelection[]): PageTextMark[] {\n  const out: PageTextMark[] = []\n  for (const p of pages) {\n    if (!(p.box.width > 0) || !(p.box.height > 0)) continue\n    const local = p.rects\n      .filter((r) => r.width >= MIN_RECT_PX && r.height >= MIN_RECT_PX)\n      .map((r) => ({ x: r.x - p.box.x, y: r.y - p.box.y, width: r.width, height: r.height }))\n      // keep only what overlaps the page area (a selection can brush a neighbouring page)\n      .filter(\n        (r) => r.x + r.width > 0 && r.y + r.height > 0 && r.x < p.box.width && r.y < p.box.height\n      )\n    const lines = mergeLineRects(local)\n    if (lines.length === 0) continue\n    out.push({\n      page: p.page,\n      rects: lines.map((r) => toNorm(r, { width: p.box.width, height: p.box.height })),\n      text: p.text.replace(/\\s+/g, ' ').trim(),\n    })\n  }\n  return out\n}\n\nexport const PAGE_ATTRIBUTE = 'data-annotation-page'\n\n/** The document a node lives in: the page's own, which is not the opener's when popped out. */\nconst ownerDocument = (node: Node): Document => node.ownerDocument ?? document\n\nconst toPixelRect = (r: DOMRect): PixelRect => ({\n  x: r.left,\n  y: r.top,\n  width: r.width,\n  height: r.height,\n})\n\n/** Narrow `range` to the part inside `container`, or null if it does not reach it. */\nexport function clipRange(range: Range, container: Node): Range | null {\n  if (!range.intersectsNode(container)) return null\n  const bounds = ownerDocument(container).createRange()\n  bounds.selectNodeContents(container)\n  const clipped = range.cloneRange()\n  if (clipped.compareBoundaryPoints(Range.START_TO_START, bounds) < 0) {\n    clipped.setStart(bounds.startContainer, bounds.startOffset)\n  }\n  if (clipped.compareBoundaryPoints(Range.END_TO_END, bounds) > 0) {\n    clipped.setEnd(bounds.endContainer, bounds.endOffset)\n  }\n  return clipped\n}\n\n/**\n * The client rects of the TEXT in `range`, one text node at a time. `range.getClientRects()` also\n * returns the box of every element the range covers completely, and a range clipped to a page\n * starts or ends at that page's container, so on a selection that crosses pages it returns\n * page-sized boxes (the text layer, the canvas wrapper). Measuring only text nodes gives the\n * glyph lines the user actually selected.\n */\nfunction textClientRects(range: Range, container: Node): DOMRect[] {\n  const doc = ownerDocument(container)\n  const walker = doc.createTreeWalker(container, NodeFilter.SHOW_TEXT)\n  const rects: DOMRect[] = []\n  for (let node = walker.nextNode(); node; node = walker.nextNode()) {\n    if (!node.textContent?.trim() || !range.intersectsNode(node)) continue\n    const part = doc.createRange()\n    part.selectNodeContents(node)\n    if (node === range.startContainer) part.setStart(node, range.startOffset)\n    if (node === range.endContainer) part.setEnd(node, range.endOffset)\n    rects.push(...Array.from(part.getClientRects()))\n  }\n  return rects\n}\n\n/**\n * The text position a boundary point stands for: a text node is itself, and an element boundary\n * means the first text node after it. Null when there is no text there.\n */\nfunction firstTextAt(container: Node, offset: number): { node: Node; offset: number } | null {\n  if (container.nodeType === Node.TEXT_NODE) return { node: container, offset }\n  const child = container.childNodes[offset]\n  if (!child) return null\n  if (child.nodeType === Node.TEXT_NODE) return { node: child, offset: 0 }\n  const first = ownerDocument(child).createTreeWalker(child, NodeFilter.SHOW_TEXT).nextNode()\n  return first ? { node: first, offset: 0 } : null\n}\n\n/**\n * A mouse drag released just past a line's last glyph can end one character short, or on another\n * line: pdf.js's text layer has an end-of-content element under the text, and the browser puts the\n * caret for a point beyond the glyphs in the wrong place. This moves the focus of a forward\n * selection to the last glyph that lies left of the release point on the release line. It only\n * ever extends the selection, and does nothing when the focus is already where the pointer is.\n */\nexport function extendFocusToPointer(selection: Selection, point: { x: number; y: number }): void {\n  if (selection.rangeCount === 0 || selection.isCollapsed) return\n  const range = selection.getRangeAt(0)\n  // Only a forward selection has its focus at the end of the range.\n  if (selection.focusNode !== range.endContainer || selection.focusOffset !== range.endOffset)\n    return\n  const start = firstTextAt(range.endContainer, range.endOffset)\n  if (!start) return\n\n  const doc = ownerDocument(start.node)\n  const walker = doc.createTreeWalker(doc.body, NodeFilter.SHOW_TEXT)\n  walker.currentNode = start.node\n  const glyph = doc.createRange()\n  let end: { node: Node; offset: number } | null = null\n  let node: Node | null = start.node\n  let offset = start.offset\n  let passed = false\n  while (node && !passed) {\n    const text = node.textContent ?? ''\n    for (let i = offset; i < text.length && !passed; i++) {\n      glyph.setStart(node, i)\n      glyph.setEnd(node, i + 1)\n      const r = glyph.getBoundingClientRect()\n      if (r.height === 0) continue\n      const mid = r.top + r.height / 2\n      if (mid > point.y + r.height / 2) passed = true\n      else if (Math.abs(mid - point.y) > r.height / 2) continue\n      else if (r.right > point.x + 0.5) passed = true\n      else end = { node, offset: i + 1 }\n    }\n    node = walker.nextNode()\n    offset = 0\n  }\n  if (end) selection.extend(end.node, end.offset)\n}\n\n/** Read the live selection as per-page slices, using the overlays in `root` to find the pages. */\nexport function readSelection(selection: Selection, root: ParentNode = document): PageSelection[] {\n  if (selection.rangeCount === 0 || selection.isCollapsed) return []\n  const range = selection.getRangeAt(0)\n  const pages: PageSelection[] = []\n  root.querySelectorAll<HTMLElement>(`[${PAGE_ATTRIBUTE}]`).forEach((overlay) => {\n    const page = Number(overlay.getAttribute(PAGE_ATTRIBUTE))\n    const container = overlay.parentElement\n    if (!container || !Number.isInteger(page)) return\n    const clipped = clipRange(range, container)\n    if (!clipped) return\n    pages.push({\n      page,\n      box: toPixelRect(overlay.getBoundingClientRect()),\n      rects: textClientRects(clipped, container).map(toPixelRect),\n      text: clipped.toString(),\n    })\n  })\n  return pages\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/annotations/state.js

@@ -0,0 +1,140 @@
+import {
+  parseAnnotation
+} from "./model.js";
+const HISTORY_LIMIT = 200;
+function createHistory(layer) {
+  return { present: layer, past: [], future: [] };
+}
+function reduceLayer(layer, action) {
+  switch (action.type) {
+    case "replaceAll":
+      return action.layer;
+    case "add": {
+      const annotation = parseAnnotation(action.annotation);
+      if (layer.annotations.some((a) => a.id === annotation.id)) {
+        throw new Error(`annotation ${annotation.id} already exists`);
+      }
+      return {
+        ...layer,
+        annotations: [...layer.annotations, annotation],
+        updatedAt: annotation.updatedAt
+      };
+    }
+    case "addMany": {
+      let next = layer;
+      for (const annotation of action.annotations)
+        next = reduceLayer(next, { type: "add", annotation });
+      return next;
+    }
+    case "update": {
+      const found = layer.annotations.find((a) => a.id === action.id);
+      if (!found) return layer;
+      const next = parseAnnotation({
+        ...found,
+        ...action.patch,
+        id: found.id,
+        kind: found.kind,
+        page: found.page,
+        createdAt: found.createdAt,
+        updatedAt: action.now
+      });
+      return replace(layer, next, action.now);
+    }
+    case "remove": {
+      if (!layer.annotations.some((a) => a.id === action.id)) return layer;
+      return {
+        ...layer,
+        annotations: layer.annotations.filter((a) => a.id !== action.id),
+        updatedAt: action.now
+      };
+    }
+    case "setRedactionStatus": {
+      const ids = new Set(action.ids);
+      let changed = false;
+      const annotations = layer.annotations.map((a) => {
+        if (a.kind !== "redaction" || !ids.has(a.id) || a.status === action.status) return a;
+        changed = true;
+        const next = { ...a, status: action.status, updatedAt: action.now };
+        delete next.reviewedBy;
+        delete next.reviewedAt;
+        if (action.status !== "pending" && action.by) {
+          next.reviewedBy = action.by;
+          next.reviewedAt = action.now;
+        }
+        return next;
+      });
+      return changed ? { ...layer, annotations, updatedAt: action.now } : layer;
+    }
+    case "reply": {
+      const found = layer.annotations.find((a) => a.id === action.id);
+      if (!found || found.kind !== "comment") return layer;
+      const next = parseAnnotation({
+        ...found,
+        replies: [...found.replies, action.reply],
+        updatedAt: action.now
+      });
+      return replace(layer, next, action.now);
+    }
+    case "resolve": {
+      const found = layer.annotations.find((a) => a.id === action.id);
+      if (!found || found.kind !== "comment" || found.resolved === action.resolved) return layer;
+      return replace(
+        layer,
+        { ...found, resolved: action.resolved, updatedAt: action.now },
+        action.now
+      );
+    }
+  }
+}
+function replace(layer, next, now) {
+  return {
+    ...layer,
+    annotations: layer.annotations.map((a) => a.id === next.id ? next : a),
+    updatedAt: now
+  };
+}
+function applyAction(history, action) {
+  const present = reduceLayer(history.present, action);
+  if (present === history.present) return history;
+  const past = [...history.past, history.present];
+  return {
+    present,
+    past: past.length > HISTORY_LIMIT ? past.slice(past.length - HISTORY_LIMIT) : past,
+    future: []
+  };
+}
+function undo(history) {
+  const previous = history.past[history.past.length - 1];
+  if (!previous) return history;
+  return {
+    present: previous,
+    past: history.past.slice(0, -1),
+    future: [history.present, ...history.future]
+  };
+}
+function redo(history) {
+  const [next, ...rest] = history.future;
+  if (!next) return history;
+  return { present: next, past: [...history.past, history.present], future: rest };
+}
+const canUndo = (h) => h.past.length > 0;
+const canRedo = (h) => h.future.length > 0;
+function annotationsOnPage(layer, page) {
+  return layer.annotations.filter((a) => a.page === page);
+}
+function pendingRedactions(layer) {
+  return layer.annotations.filter((a) => a.kind === "redaction" && a.status === "pending");
+}
+export {
+  HISTORY_LIMIT,
+  annotationsOnPage,
+  applyAction,
+  canRedo,
+  canUndo,
+  createHistory,
+  pendingRedactions,
+  redo,
+  reduceLayer,
+  undo
+};
+//# sourceMappingURL=state.js.map

package/dist/annotations/state.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/annotations/state.ts"],
+  "sourcesContent": ["/**\n * Pure state for an annotation layer: actions, a reducer and undo/redo history.\n *\n * No clock and no randomness in here. Callers pass ids and timestamps in, so the reducer is\n * deterministic, trivially testable, and an agent can replay the same actions a person makes.\n */\n\nimport {\n  parseAnnotation,\n  type Annotation,\n  type AnnotationLayer,\n  type CommentReply,\n  type RedactionAnnotation,\n  type RedactionStatus,\n} from './model'\n\n/** Fields a caller may change on any mark. Identity (`id`, `kind`, `page`) is fixed. */\ntype PatchOf<A> = A extends Annotation\n  ? Partial<Omit<A, 'id' | 'kind' | 'page' | 'createdAt'>>\n  : never\nexport type AnnotationPatch = PatchOf<Annotation>\n\nexport type AnnotationAction =\n  | { type: 'add'; annotation: Annotation }\n  | { type: 'addMany'; annotations: Annotation[] }\n  | { type: 'update'; id: string; patch: AnnotationPatch; now: string }\n  | { type: 'remove'; id: string; now: string }\n  | {\n      type: 'setRedactionStatus'\n      ids: string[]\n      status: RedactionStatus\n      now: string\n      /** Who reviewed it; recorded with the time for approve/reject, cleared for pending. */\n      by?: string\n    }\n  | { type: 'reply'; id: string; reply: CommentReply; now: string }\n  | { type: 'resolve'; id: string; resolved: boolean; now: string }\n  | { type: 'replaceAll'; layer: AnnotationLayer }\n\nexport interface LayerHistory {\n  present: AnnotationLayer\n  past: AnnotationLayer[]\n  future: AnnotationLayer[]\n}\n\nexport const HISTORY_LIMIT = 200\n\nexport function createHistory(layer: AnnotationLayer): LayerHistory {\n  return { present: layer, past: [], future: [] }\n}\n\n/** Apply one action to a layer. Returns the same object when nothing changed. */\nexport function reduceLayer(layer: AnnotationLayer, action: AnnotationAction): AnnotationLayer {\n  switch (action.type) {\n    case 'replaceAll':\n      return action.layer\n    case 'add': {\n      // Validate on the way in: a bad mark must never reach storage or a frozen document.\n      const annotation = parseAnnotation(action.annotation)\n      if (layer.annotations.some((a) => a.id === annotation.id)) {\n        throw new Error(`annotation ${annotation.id} already exists`)\n      }\n      return {\n        ...layer,\n        annotations: [...layer.annotations, annotation],\n        updatedAt: annotation.updatedAt,\n      }\n    }\n    case 'addMany': {\n      // All or nothing: one bad mark rejects the batch, so history never holds half of it.\n      let next = layer\n      for (const annotation of action.annotations)\n        next = reduceLayer(next, { type: 'add', annotation })\n      return next\n    }\n    case 'update': {\n      const found = layer.annotations.find((a) => a.id === action.id)\n      if (!found) return layer\n      // The patch type forbids identity fields, but patches also arrive from JSON (an agent, a\n      // network message), so enforce it here rather than trusting the type.\n      const next = parseAnnotation({\n        ...found,\n        ...action.patch,\n        id: found.id,\n        kind: found.kind,\n        page: found.page,\n        createdAt: found.createdAt,\n        updatedAt: action.now,\n      })\n      return replace(layer, next, action.now)\n    }\n    case 'remove': {\n      if (!layer.annotations.some((a) => a.id === action.id)) return layer\n      return {\n        ...layer,\n        annotations: layer.annotations.filter((a) => a.id !== action.id),\n        updatedAt: action.now,\n      }\n    }\n    case 'setRedactionStatus': {\n      const ids = new Set(action.ids)\n      let changed = false\n      const annotations = layer.annotations.map((a) => {\n        if (a.kind !== 'redaction' || !ids.has(a.id) || a.status === action.status) return a\n        changed = true\n        const next: RedactionAnnotation = { ...a, status: action.status, updatedAt: action.now }\n        delete next.reviewedBy\n        delete next.reviewedAt\n        if (action.status !== 'pending' && action.by) {\n          next.reviewedBy = action.by\n          next.reviewedAt = action.now\n        }\n        return next\n      })\n      return changed ? { ...layer, annotations, updatedAt: action.now } : layer\n    }\n    case 'reply': {\n      const found = layer.annotations.find((a) => a.id === action.id)\n      if (!found || found.kind !== 'comment') return layer\n      const next = parseAnnotation({\n        ...found,\n        replies: [...found.replies, action.reply],\n        updatedAt: action.now,\n      })\n      return replace(layer, next, action.now)\n    }\n    case 'resolve': {\n      const found = layer.annotations.find((a) => a.id === action.id)\n      if (!found || found.kind !== 'comment' || found.resolved === action.resolved) return layer\n      return replace(\n        layer,\n        { ...found, resolved: action.resolved, updatedAt: action.now },\n        action.now\n      )\n    }\n  }\n}\n\nfunction replace(layer: AnnotationLayer, next: Annotation, now: string): AnnotationLayer {\n  return {\n    ...layer,\n    annotations: layer.annotations.map((a) => (a.id === next.id ? next : a)),\n    updatedAt: now,\n  }\n}\n\n/** Apply an action and record it for undo. A no-op action leaves history untouched. */\nexport function applyAction(history: LayerHistory, action: AnnotationAction): LayerHistory {\n  const present = reduceLayer(history.present, action)\n  if (present === history.present) return history\n  const past = [...history.past, history.present]\n  return {\n    present,\n    past: past.length > HISTORY_LIMIT ? past.slice(past.length - HISTORY_LIMIT) : past,\n    future: [],\n  }\n}\n\nexport function undo(history: LayerHistory): LayerHistory {\n  const previous = history.past[history.past.length - 1]\n  if (!previous) return history\n  return {\n    present: previous,\n    past: history.past.slice(0, -1),\n    future: [history.present, ...history.future],\n  }\n}\n\nexport function redo(history: LayerHistory): LayerHistory {\n  const [next, ...rest] = history.future\n  if (!next) return history\n  return { present: next, past: [...history.past, history.present], future: rest }\n}\n\nexport const canUndo = (h: LayerHistory) => h.past.length > 0\nexport const canRedo = (h: LayerHistory) => h.future.length > 0\n\nexport function annotationsOnPage(layer: AnnotationLayer, page: number): Annotation[] {\n  return layer.annotations.filter((a) => a.page === page)\n}\n\nexport function pendingRedactions(layer: AnnotationLayer) {\n  return layer.annotations.filter((a) => a.kind === 'redaction' && a.status === 'pending')\n}\n"],
+  "mappings": "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",
+  "names": []
+}