@ai-matrx/rich-content 0.0.0-stage → 0.2.2

package/dist/utils/table-source.d.ts

@@ -0,0 +1,62 @@
+export { rowCells, splitRowSegments } from "@ai-matrx/content-ir/source";
+/**
+ * A cell the person typed, made safe for one GFM cell: line breaks become `<br>`
+ * and every `|` that would be a boundary (an EVEN run of backslashes before it,
+ * zero included) gets one more backslash. A pipe already escaped is left alone.
+ */
+export declare function freshCell(text: string): string;
+/** A table edit the writer could not make read back as the intended grid. */
+export declare class TableWriteRefused extends Error {
+    readonly row: string;
+    constructor(row: string, detail: string);
+}
+/**
+ * The WHOLE written table must read back as one table — judged by `marked`
+ * (a GFM parser that does not use this module's splitter): one table, one row
+ * per written data line, and every cell equal to what the line stores. A row
+ * can split correctly and still END the table — a pipe-less row starting `- `
+ * is a list item, not a row (verify-RC-B4 R5-1) — so a per-row check is not
+ * enough.
+ *
+ * With `original`, the stored table sets the floor instead: lines the stored
+ * table itself never read as rows (a stray `- | x` line after it, an indented
+ * line read as code) may stay outside the written table, but the write must
+ * never end the table EARLIER than the stored one did, and every row it does
+ * read must hold exactly the stored cells.
+ */
+export declare function assertTableReadsBack(tableText: string, original?: string): void;
+/**
+ * The stored row with ONLY the edited cells rewritten. A row with MORE stored
+ * cells than the header keeps the extra ones verbatim (renderers ignore them;
+ * they are still the author's bytes); a SHORT row gains a segment only for a
+ * cell the person actually filled. A row without an edge pipe gets one when
+ * its first or last cell is empty — GFM would otherwise read that empty cell
+ * as the edge and shift the row. The result is read back through the splitter
+ * and REFUSED (TableWriteRefused) unless it holds exactly the intended cells.
+ * Null only when there are no stored segments or the stored texts do not line
+ * up with the new ones.
+ */
+export declare function respliceRow(segs: unknown[] | null, stored: unknown[] | null, texts: readonly string[]): string | null;
+/** A row the table never stored, in the table's pipe style (edge pipes added where an empty edge cell needs one). */
+export declare function freshRow(texts: readonly string[], lead?: boolean, trail?: boolean): string;
+export interface TableGrid {
+    headers: readonly string[];
+    rows: ReadonlyArray<readonly string[]>;
+}
+/**
+ * The stored table source with the edited grid spliced in — THE writer for
+ * every table edit path (see header). `original` is the table's markdown as
+ * stored; `grid` is the edited headers and rows as the ONE parser produced
+ * them (cell text trimmed, `\|` kept). No edit returns `original` exactly.
+ * A row added or removed changes only its own line; a column added or
+ * removed rewrites the rows (and the delimiter row) it touches.
+ */
+/**
+ * Which of a table's data lines are ROWS — THE rule the parser (parseMarkdownTable)
+ * and the writer share, so they can never disagree about row count: every
+ * non-blank line after the delimiter is a row (an all-empty `| | |` included, as
+ * GFM shows it); only a trailing line with no cells at all (a lone `|` still
+ * arriving) is not.
+ */
+export declare function dataRowIndexes(lines: readonly string[], candidates: readonly number[]): number[];
+export declare function rewriteTableSource(original: string, grid: TableGrid): string;

package/dist/utils/table-source.js

@@ -0,0 +1,191 @@
+import { lexGfmBlocks } from "./gfm-lexer.js";
+import { rowCells, splitRowSegments, unescapeCellPipes } from "@ai-matrx/content-ir/source";
+import { rowCells as rowCells2, splitRowSegments as splitRowSegments2 } from "@ai-matrx/content-ir/source";
+function backslashRunBefore(text, index) {
+  let run = 0;
+  for (let i = index - 1; i >= 0 && text[i] === "\\"; i -= 1) run += 1;
+  return run;
+}
+function freshCell(text) {
+  const flat = text.replace(/(?: {2,}|\\)?\r?\n/g, "<br>");
+  let out = "";
+  for (let i = 0; i < flat.length; i += 1) {
+    if (flat[i] === "|" && backslashRunBefore(flat, i) % 2 === 0) out += "\\";
+    out += flat[i];
+  }
+  return out;
+}
+function endsInEscape(text) {
+  return backslashRunBefore(text, text.length) % 2 === 1;
+}
+class TableWriteRefused extends Error {
+  constructor(row, detail) {
+    super(`The table could not be written without changing other cells (${detail}). Your edit is kept \u2014 nothing was saved.`);
+    this.row = row;
+    this.name = "TableWriteRefused";
+  }
+  row;
+}
+function readTable(text) {
+  const tokens = lexGfmBlocks(text);
+  const first = tokens[0];
+  return { tokens: tokens.map((token) => token.type), table: first?.type === "table" ? first : null };
+}
+function strayLines(original) {
+  const text = original.replace(/^\n+|\n+$/g, "");
+  const data = text.split("\n").filter((line) => line.trim()).length - 2;
+  return Math.max(0, data - (readTable(text).table?.rows.length ?? 0));
+}
+function assertTableReadsBack(tableText, original) {
+  const text = tableText.replace(/^\n+|\n+$/g, "");
+  if (original !== void 0 && !readTable(original.replace(/^\n+|\n+$/g, "")).table) return;
+  const { tokens, table: parsed } = readTable(text);
+  const lines = text.split("\n").filter((line) => line.trim());
+  const dataLines = lines.slice(2);
+  const floor = dataLines.length - (original === void 0 ? 0 : strayLines(original));
+  if (!parsed || tokens.length !== 1 && parsed.rows.length >= dataLines.length) {
+    throw new TableWriteRefused(text, `it would read as ${tokens.join(" + ") || "nothing"}, not one table`);
+  }
+  if (parsed.rows.length < floor) {
+    throw new TableWriteRefused(
+      text,
+      `it would read as ${tokens.join(" + ")} \u2014 ${parsed.rows.length} of ${dataLines.length} rows would stay in the table`
+    );
+  }
+  const width = parsed.header.length;
+  const same = (line, cells) => {
+    const written = rowCells(line);
+    return cells.every((cell, i) => cell.text === unescapeCellPipes(written[i] ?? ""));
+  };
+  if (rowCells(lines[0] ?? "").length !== width || !same(lines[0] ?? "", parsed.header)) {
+    throw new TableWriteRefused(text, "the header would read back differently");
+  }
+  parsed.rows.forEach((cells, r) => {
+    const line = dataLines[r] ?? "";
+    if (!same(line, cells)) throw new TableWriteRefused(line, `row ${r + 1} would read back differently`);
+  });
+}
+function assertRowReadsBack(line, intended) {
+  const got = rowCells(line);
+  if (got.length !== intended.length || got.some((cell, i) => cell !== intended[i])) {
+    throw new TableWriteRefused(line, `expected ${JSON.stringify(intended)}, would read ${JSON.stringify(got)}`);
+  }
+  return line;
+}
+function rewriteSegment(seg, text) {
+  const lead = /^\s*/.exec(seg)?.[0] ?? "";
+  const core = seg.slice(lead.length).trimEnd();
+  const trail = seg.slice(lead.length + core.length);
+  const fresh = freshCell(text).trim();
+  const pad = Math.max(trail.length > 0 || endsInEscape(fresh) ? 1 : 0, core.length + trail.length - fresh.length);
+  return `${lead}${fresh}${" ".repeat(pad)}`;
+}
+function respliceRow(segs, stored, texts) {
+  if (!segs || !stored || stored.length !== texts.length || !segs.every((seg) => typeof seg === "string")) return null;
+  const parts = segs;
+  const original = rowCells(parts.join("|"));
+  const first = parts.length > 1 && (parts[0] ?? "").trim() === "" ? 1 : 0;
+  const closed = parts.length > 1 && (parts[parts.length - 1] ?? "").trim() === "";
+  const end = closed ? parts.length - 1 : parts.length;
+  const cells = parts.slice(first, end);
+  const edited = /* @__PURE__ */ new Set();
+  texts.forEach((text, index) => {
+    if (stored[index] === text) return;
+    edited.add(index);
+    if (index < cells.length) cells[index] = rewriteSegment(cells[index] ?? "", text);
+    else {
+      while (cells.length < index) cells.push(" ");
+      cells.push(` ${freshCell(text).trim()} `);
+    }
+  });
+  if (!edited.size) return parts.join("|");
+  const lastIndex = cells.length - 1;
+  const needLead = !first && (edited.has(0) || (cells[0] ?? "").trim() === "");
+  const needTrail = !closed && lastIndex >= 0 && (cells[lastIndex] ?? "").trim() === "";
+  if (needLead && !/^\s/.test(cells[0] ?? "")) cells[0] = ` ${cells[0] ?? ""}`;
+  if (needTrail && cells[lastIndex] === "") cells[lastIndex] = " ";
+  const edge = first ? [parts[0] ?? ""] : needLead ? [""] : [];
+  const tail = closed ? [parts[parts.length - 1] ?? ""] : needTrail || cells.length > end - first ? [""] : [];
+  const line = [...edge, ...cells, ...tail].join("|");
+  const intended = cells.map((cell, i) => edited.has(i) ? freshCell(texts[i] ?? "").trim() : original[i] ?? cell.trim());
+  return assertRowReadsBack(line, intended);
+}
+function freshRow(texts, lead = true, trail = true) {
+  const cells = texts.map((text) => freshCell(text).trim());
+  const needLead = lead || !cells.every((cell) => /^:?-+:?$/.test(cell));
+  const needTrail = trail || cells[cells.length - 1] === "" || endsInEscape(cells[cells.length - 1] ?? "");
+  const line = `${needLead ? "| " : ""}${cells.join(" | ")}${needTrail ? " |" : ""}`;
+  return assertRowReadsBack(line, cells);
+}
+function rewriteLine(line, texts, lead, trail) {
+  const stored = rowCells(line);
+  if (texts.length < stored.length && stored.slice(texts.length).some((cell) => cell !== "")) {
+    return freshRow(texts, lead, trail);
+  }
+  const padded = texts.length > stored.length ? [...stored, ...Array(texts.length - stored.length).fill("")] : stored;
+  const aligned = texts.length < stored.length ? texts.concat(stored.slice(texts.length)) : texts;
+  return respliceRow(splitRowSegments(line), padded, aligned) ?? freshRow(texts, lead, trail);
+}
+function dataRowIndexes(lines, candidates) {
+  const last = candidates[candidates.length - 1];
+  if (last !== void 0 && rowCells(lines[last] ?? "").length === 0) return candidates.slice(0, -1);
+  return [...candidates];
+}
+function rewriteTableSource(original, grid) {
+  const lines = original.split("\n");
+  const used = lines.map((line, index) => line.trim() ? index : -1).filter((index) => index >= 0);
+  const headerAt = used[0];
+  const delimAt = used[1];
+  if (headerAt === void 0 || delimAt === void 0) {
+    return [freshRow(grid.headers), freshRow(grid.headers.map(() => "---")), ...grid.rows.map((row) => freshRow(row))].join("\n");
+  }
+  const headerLine = lines[headerAt] ?? "";
+  const lead = headerLine.trimStart().startsWith("|");
+  const trail = headerLine.trimEnd().endsWith("|");
+  const width = rowCells(headerLine).length;
+  const columnsChanged = grid.headers.length !== width;
+  const out = [...lines];
+  out[headerAt] = rewriteLine(headerLine, grid.headers, lead, trail);
+  if (columnsChanged) {
+    out[delimAt] = freshRow(grid.headers.map(() => "---"), lead, trail);
+  }
+  const dataAt = dataRowIndexes(lines, used.slice(2));
+  if (grid.rows.length === dataAt.length) {
+    grid.rows.forEach((row, i) => {
+      const at = dataAt[i];
+      out[at] = rewriteLine(lines[at] ?? "", row, lead, trail);
+    });
+    const written2 = out.join("\n");
+    if (written2 !== original) assertTableReadsBack(written2, original);
+    return written2;
+  }
+  const key = (cells) => JSON.stringify(cells);
+  const storedKeys = dataAt.map((index) => key(rowCells(lines[index] ?? "")));
+  let cursor = 0;
+  const rebuilt = grid.rows.map((row) => {
+    const k = key(row);
+    for (let j = cursor; j < storedKeys.length; j += 1) {
+      if (storedKeys[j] === k) {
+        cursor = j + 1;
+        return lines[dataAt[j]] ?? "";
+      }
+    }
+    return freshRow(row, lead, trail);
+  });
+  const firstData = dataAt[0] ?? delimAt + 1;
+  const lastData = dataAt.length ? dataAt[dataAt.length - 1] : delimAt;
+  const written = [...out.slice(0, firstData), ...rebuilt, ...out.slice(lastData + 1)].join("\n");
+  assertTableReadsBack(written, original);
+  return written;
+}
+export {
+  TableWriteRefused,
+  assertTableReadsBack,
+  dataRowIndexes,
+  freshCell,
+  freshRow,
+  respliceRow,
+  rewriteTableSource,
+  rowCells2 as rowCells,
+  splitRowSegments2 as splitRowSegments
+};

package/dist/utils/youtube.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Shared YouTube URL primitives.
+ *
+ * Single source of truth for turning any YouTube URL (watch / share / embed /
+ * shorts / live) into a video id + start offset, building a privacy-enhanced
+ * embed URL, and deriving a poster thumbnail without an API call.
+ *
+ * Consumed by:
+ *   - the markdown splitter's `detectYoutubeMarkdown` (auto-playable YouTube
+ *     links in any rendered content)
+ *   - `features/files/blocks/youtube/YouTubeEmbed` (the one embed component)
+ *   - `features/research/.../mediaEmbed` (delegates its `youtubeId` here)
+ *
+ * Do NOT re-implement YouTube id extraction anywhere else — extend this file.
+ */
+/**
+ * Parse a YouTube time token into whole seconds.
+ * Accepts plain seconds ("15", "15s") and the `1h2m3s` form ("1m30s", "90").
+ * Returns undefined when the token is absent or unparseable.
+ */
+export declare function parseYouTubeStart(token: string | null | undefined): number | undefined;
+export interface ParsedYouTube {
+    /** The 11-ish char video id. */
+    videoId: string;
+    /** Start offset in whole seconds, when the URL carried `t` / `start`. */
+    start?: number;
+}
+/**
+ * Extract `{ videoId, start }` from any YouTube URL, or null when the URL is
+ * not a recognizable YouTube video link.
+ */
+export declare function parseYouTubeUrl(url: string): ParsedYouTube | null;
+/** Just the video id, or null — back-compat helper for callers that only need it. */
+export declare function youtubeId(url: string): string | null;
+/**
+ * True when the URL points at a YouTube channel or profile page — not an
+ * embeddable video. These must open on YouTube; they cannot be iframe-embedded.
+ */
+export declare function isYouTubeChannelUrl(url: string): boolean;
+/** A readable channel/handle label parsed from a YouTube channel URL. */
+export declare function youTubeChannelLabel(url: string): string;
+/** True when a thumbnail URL points at YouTube's image host (img.youtube.com / i.ytimg.com). */
+export declare function isYouTubeThumbnailUrl(url: string): boolean;
+/** Privacy-enhanced (`youtube-nocookie.com`) embed URL for a video id. */
+export declare function youTubeEmbedUrl(videoId: string, opts?: {
+    start?: number;
+    autoplay?: boolean;
+}): string;
+/** Canonical watch URL for a video id (used for durable round-trip + "open on YouTube"). */
+export declare function youTubeWatchUrl(videoId: string, start?: number): string;
+/** A poster thumbnail derived without any API call. `maxres` falls back to `hq`. */
+export declare function youTubeThumbnail(videoId: string, quality?: "maxres" | "hq" | "mq" | "sd"): string;

package/dist/utils/youtube.js

@@ -0,0 +1,137 @@
+function isYouTubeId(id) {
+  return !!id && /^[A-Za-z0-9_-]{6,}$/.test(id);
+}
+function parseYouTubeStart(token) {
+  if (!token) return void 0;
+  const raw = token.trim();
+  if (!raw) return void 0;
+  if (/^\d+$/.test(raw)) {
+    const n = parseInt(raw, 10);
+    return Number.isFinite(n) && n > 0 ? n : void 0;
+  }
+  const m = raw.match(/^(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?$/i);
+  if (m && (m[1] || m[2] || m[3])) {
+    const h = parseInt(m[1] ?? "0", 10);
+    const min = parseInt(m[2] ?? "0", 10);
+    const s = parseInt(m[3] ?? "0", 10);
+    const total = h * 3600 + min * 60 + s;
+    return total > 0 ? total : void 0;
+  }
+  return void 0;
+}
+function parseYouTubeUrl(url) {
+  let u;
+  try {
+    u = new URL(url.trim());
+  } catch {
+    return null;
+  }
+  const host = u.hostname.replace(/^www\./, "").toLowerCase();
+  let videoId = null;
+  if (host === "youtu.be") {
+    videoId = u.pathname.split("/").filter(Boolean)[0] ?? null;
+  } else if (host.endsWith("youtube.com") || host === "youtube-nocookie.com") {
+    if (u.pathname === "/watch") {
+      videoId = u.searchParams.get("v");
+    } else {
+      const m = u.pathname.match(/^\/(?:embed|shorts|v|live)\/([^/?#]+)/);
+      videoId = m ? m[1] : null;
+    }
+  }
+  if (!isYouTubeId(videoId)) return null;
+  const hashT = u.hash.match(/[#&]t=([^&]+)/)?.[1];
+  const start = parseYouTubeStart(u.searchParams.get("start")) ?? parseYouTubeStart(u.searchParams.get("t")) ?? parseYouTubeStart(hashT);
+  return start !== void 0 ? { videoId, start } : { videoId };
+}
+function youtubeId(url) {
+  return parseYouTubeUrl(url)?.videoId ?? null;
+}
+const YOUTUBE_NON_CHANNEL_SEGMENTS = /* @__PURE__ */ new Set([
+  "watch",
+  "embed",
+  "shorts",
+  "v",
+  "live",
+  "results",
+  "feed",
+  "playlist",
+  "account",
+  "about",
+  "trends",
+  "gaming",
+  "music",
+  "news",
+  "movies",
+  "premium",
+  "redirect",
+  "attribution_link"
+]);
+function isYouTubeChannelUrl(url) {
+  if (parseYouTubeUrl(url)) return false;
+  try {
+    const u = new URL(url.trim());
+    const host = u.hostname.replace(/^www\./, "").toLowerCase();
+    if (host === "youtu.be") return false;
+    if (!host.endsWith("youtube.com") && host !== "youtube-nocookie.com") {
+      return false;
+    }
+    const segments = u.pathname.split("/").filter(Boolean);
+    if (segments.length === 0) return true;
+    const first = segments[0].toLowerCase();
+    if (YOUTUBE_NON_CHANNEL_SEGMENTS.has(first)) return false;
+    if (first === "user" || first === "channel" || first === "c") return true;
+    if (first.startsWith("@")) return true;
+    return segments.length === 1;
+  } catch {
+    return false;
+  }
+}
+function youTubeChannelLabel(url) {
+  try {
+    const u = new URL(url.trim());
+    const segments = u.pathname.split("/").filter(Boolean);
+    if (segments.length === 0) return "YouTube";
+    const first = segments[0];
+    const firstLower = first.toLowerCase();
+    if (first.startsWith("@")) return first;
+    if (firstLower === "user" || firstLower === "channel" || firstLower === "c") {
+      return segments[1] ?? first;
+    }
+    return first;
+  } catch {
+    return "YouTube channel";
+  }
+}
+function isYouTubeThumbnailUrl(url) {
+  try {
+    const host = new URL(url).hostname.replace(/^www\./, "").toLowerCase();
+    return host === "img.youtube.com" || host === "i.ytimg.com";
+  } catch {
+    return false;
+  }
+}
+function youTubeEmbedUrl(videoId, opts = {}) {
+  const params = new URLSearchParams({ rel: "0" });
+  if (opts.autoplay) params.set("autoplay", "1");
+  if (opts.start && opts.start > 0) params.set("start", String(opts.start));
+  return `https://www.youtube-nocookie.com/embed/${videoId}?${params.toString()}`;
+}
+function youTubeWatchUrl(videoId, start) {
+  const base = `https://www.youtube.com/watch?v=${videoId}`;
+  return start && start > 0 ? `${base}&t=${start}s` : base;
+}
+function youTubeThumbnail(videoId, quality = "hq") {
+  const file = quality === "maxres" ? "maxresdefault" : quality === "mq" ? "mqdefault" : quality === "sd" ? "sddefault" : "hqdefault";
+  return `https://i.ytimg.com/vi/${videoId}/${file}.jpg`;
+}
+export {
+  isYouTubeChannelUrl,
+  isYouTubeThumbnailUrl,
+  parseYouTubeStart,
+  parseYouTubeUrl,
+  youTubeChannelLabel,
+  youTubeEmbedUrl,
+  youTubeThumbnail,
+  youTubeWatchUrl,
+  youtubeId
+};

package/package.json

@@ -1,6 +1,136 @@
 {
   "name": "@ai-matrx/rich-content",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.2",
+  "description": "The AI Matrx formatted-text engine: the one markdown renderer, streaming markdown, the block splitter and renderer, the generic blocks, <RichContent> levels, the rich-document action registry and menus, copy, and the selection toolbar — as portable React.",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AI-Matrix-Engine/aidream.git",
+    "directory": "apps/shared/rich-content"
+  },
+  "homepage": "https://github.com/AI-Matrix-Engine/aidream/tree/main/apps/shared/rich-content#readme",
+  "bugs": {
+    "url": "https://github.com/AI-Matrix-Engine/aidream/issues"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "sideEffects": [
+    "*.css"
+  ],
+  "exports": {
+    "./host": {
+      "types": "./dist/host/index.d.ts",
+      "import": "./dist/host/index.js"
+    },
+    "./host/*": {
+      "types": "./dist/host/*.d.ts",
+      "import": "./dist/host/*.js"
+    },
+    "./markdown-core/*": {
+      "types": "./dist/markdown-core/*.d.ts",
+      "import": "./dist/markdown-core/*.js"
+    },
+    "./display/*": {
+      "types": "./dist/display/*.d.ts",
+      "import": "./dist/display/*.js"
+    },
+    "./kinds/*": {
+      "types": "./dist/kinds/*.d.ts",
+      "import": "./dist/kinds/*.js"
+    },
+    "./utils/*": {
+      "types": "./dist/utils/*.d.ts",
+      "import": "./dist/utils/*.js"
+    },
+    "./styles.css": "./dist/styles.css",
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@types/hast": "^3.0.4",
+    "@types/mdast": "^4.0.4",
+    "@types/unist": "^3.0.3",
+    "hast-util-from-html": "^2.0.3",
+    "hast-util-from-html-isomorphic": "^2.0.0",
+    "hast-util-sanitize": "^5.0.2",
+    "hast-util-to-string": "^3.0.1",
+    "hast-util-to-text": "^4.0.2",
+    "katex": "^0.18.9",
+    "lucide-react": "^1.48.0",
+    "marked": "^18.0.14",
+    "mdast-util-math": "^3.0.0",
+    "micromark-factory-space": "^2.1.0",
+    "micromark-util-character": "^2.1.1",
+    "react-markdown": "^10.1.0",
+    "rehype-raw": "^7.0.0",
+    "rehype-slug": "^6.0.0",
+    "remark-breaks": "^4.0.0",
+    "remark-definition-list": "^2.0.0",
+    "remark-directive": "^4.0.0",
+    "remark-frontmatter": "^5.0.0",
+    "remark-gemoji": "^8.0.0",
+    "remark-gfm": "^4.0.1",
+    "remark-parse": "^11.0.0",
+    "remark-rehype": "^11.1.2",
+    "remend": "1.3.1",
+    "server-only": "^0.0.1",
+    "smol-toml": "^1.9.0",
+    "unified": "^11.0.5",
+    "unist-util-visit": "^5.1.0",
+    "unist-util-visit-parents": "^6.0.2",
+    "yaml": "^2.9.1",
+    "@ai-matrx/agents": "latest",
+    "@ai-matrx/content-ir": "latest",
+    "@ai-matrx/content-ir-react": "latest",
+    "@ai-matrx/kit": "latest",
+    "@ai-matrx/media": "latest",
+    "@ai-matrx/design-system": "latest",
+    "@ai-matrx/print": "latest",
+    "@ai-matrx/records": "latest"
+  },
+  "peerDependencies": {
+    "react": ">=19.0.0",
+    "react-dom": ">=19.0.0"
+  },
+  "devDependencies": {
+    "@testing-library/react": "^16.3.3",
+    "@types/jest": "^30.0.0",
+    "@types/katex": "^0.16.7",
+    "@types/node": "^26.6.2",
+    "@types/react": "19.3.0",
+    "@types/react-dom": "19.3.0",
+    "@typescript/native": "npm:typescript@^7.0.2",
+    "jest": "^30.5.2",
+    "jest-environment-jsdom": "^30.5.2",
+    "jsdom": "^30.1.1",
+    "publint": "^0.3.24",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "ts-jest": "^29.4.14",
+    "tsup": "^8.5.1",
+    "tsx": "^4.23.15",
+    "typescript": "^6.0.3"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsup && node ./scripts/copy-css.mjs && node ./scripts/tsc-own.mjs -p tsconfig.build.json && node ./scripts/finish-build.mjs",
+    "check:package": "pnpm build && publint && pnpm verify:modules-tarball && pnpm verify:tarball && pnpm check:host-boundary",
+    "check:host-boundary": "node ./scripts/check-host-boundary.mjs && node ./scripts/check-host-boundary.mjs --self-test",
+    "deps:write": "node ./scripts/finish-build.mjs --write-deps",
+    "typecheck": "node ./scripts/tsc-own.mjs -p tsconfig.json",
+    "test": "pnpm test:linear-time && jest -c jest.config.mjs --testPathPatterns='^(?!.*regex-linear-time\\.guard\\.test\\.ts$).*'",
+    "test:linear-time": "jest -c jest.config.mjs src/markdown-core/__tests__/regex-linear-time.guard.test.ts --runInBand",
+    "verify:modules-tarball": "node ./scripts/verify-modules-tarball.mjs",
+    "verify:tarball": "node ./scripts/verify-tarball.mjs"
+  }
+}