@ai-matrx/rich-content 0.0.0 → 0.2.3

package/dist/markdown-core/syntax/remark-table-code-pipes.js

@@ -0,0 +1,23 @@
+import { unescapeCellPipes } from "./gfm-cell-pipes.js";
+function unescapeCodeIn(node) {
+  if (node.type === "inlineCode" && typeof node.value === "string") {
+    node.value = unescapeCellPipes(node.value);
+    return;
+  }
+  node.children?.forEach(unescapeCodeIn);
+}
+function visit(node) {
+  if (node.type === "tableCell") {
+    unescapeCodeIn(node);
+    return;
+  }
+  node.children?.forEach(visit);
+}
+function remarkTableCodePipes() {
+  return (tree) => {
+    visit(tree);
+  };
+}
+export {
+  remarkTableCodePipes as default
+};

package/dist/markdown-core/syntax/stream-heal-syntax.d.ts

@@ -0,0 +1,2 @@
+import { type RemendHandler } from "remend";
+export declare const SYNTAX_STREAM_HANDLERS: RemendHandler[];

package/dist/markdown-core/syntax/stream-heal-syntax.js

@@ -0,0 +1,108 @@
+import { isWithinCodeBlock } from "remend";
+import { hasUnclosedFrontmatter } from "./frontmatter.js";
+import { unfinishedHeadingIdHead } from "./linear-scan.js";
+function lastLineStart(text) {
+  return text.lastIndexOf("\n") + 1;
+}
+const pendingFrontmatter = {
+  name: "matrx-pending-frontmatter",
+  priority: 0,
+  handle: (text) => {
+    if (text === "-" || text === "--" || text === "---" || text === "+" || text === "++" || text === "+++") return "";
+    if (!hasUnclosedFrontmatter(text)) return text;
+    const [opener, ...rest] = text.split("\n");
+    const looks = opener === "+++" ? TOML_LINE : YAML_LINE;
+    return rest.every((line, i) => looks.test(line) || i === rest.length - 1 && /^[\w"'-]*$/.test(line)) ? "" : text;
+  }
+};
+const YAML_LINE = /^(?:[\w"'][^:\n]*:(?:\s.*)?|\s+.*|-(?:\s.*)?|#.*|)$/;
+const TOML_LINE = /^\s*(?:[\w."-]+\s*=.*|\[.*\]|#.*|)$/;
+const TRAILING_BLOCK_MARKER = /^(?:[ \t]{0,3}:{2,}[^\n]*|[ \t]{0,3}>[ \t]*\[!?[^\]\n]*\]?[+-]?|(?:!!!|\?\?\?\+?)[^\n]*|\*\[[^\n]*)$/;
+const pendingBlockMarker = {
+  name: "matrx-pending-block-marker",
+  priority: 2,
+  handle: (text) => {
+    const start = lastLineStart(text);
+    const line = text.slice(start);
+    if (!line || !TRAILING_BLOCK_MARKER.test(line)) return text;
+    if (isWithinCodeBlock(text, start)) return text;
+    if (/^[ \t]{0,3}>[ \t]*\[![A-Za-z-]+\][+-]?[ \t]*$/.test(line)) return text;
+    return text.slice(0, start);
+  }
+};
+const TRAILING_WIKILINK = /(!?)\[\[([^[\]\n]*)\]?$/;
+const TRAILING_TEXT_DIRECTIVE = /:(?:span|mark|kbd|abbr|sup|sub)\[([^\]\n]*)(?:\](\{[^}\n]*)?)?$/;
+const TRAILING_FOOTNOTE_REF = /\[\^[^\]\s]*$/;
+const TRAILING_EMOJI = /(^|[\s(])(:[a-z0-9_+-]+)$/;
+const TRAILING_HIGHLIGHT = /(^|[^=\\])==(?=[^\s=])([^\n=]*)$/;
+const pendingInline = {
+  name: "matrx-pending-inline-syntax",
+  priority: 3,
+  handle: (text) => {
+    const start = lastLineStart(text);
+    if (isWithinCodeBlock(text, start)) return text;
+    let out = text;
+    const wiki = TRAILING_WIKILINK.exec(out);
+    if (wiki && wiki.index >= start) {
+      out = out.slice(0, wiki.index) + (wiki[1] ? "" : wiki[2] ?? "");
+    }
+    const directive = TRAILING_TEXT_DIRECTIVE.exec(out);
+    if (directive && directive.index >= start && (directive[2] !== void 0 || !out.endsWith("]"))) {
+      out = out.slice(0, directive.index) + (directive[1] ?? "");
+    }
+    const fn = TRAILING_FOOTNOTE_REF.exec(out);
+    if (fn && fn.index >= start) out = out.slice(0, fn.index);
+    const emoji = TRAILING_EMOJI.exec(out);
+    if (emoji && emoji.index >= start) out = out.slice(0, emoji.index + (emoji[1] ?? "").length);
+    const hl = TRAILING_HIGHLIGHT.exec(out);
+    if (hl && hl.index >= start && (hl[2] ?? "").trim() && !/\s$/.test(out)) out = `${out}==`;
+    return out;
+  }
+};
+const pendingHeadingId = {
+  name: "matrx-pending-heading-id",
+  priority: -2,
+  handle: (text) => {
+    const start = lastLineStart(text);
+    const head = unfinishedHeadingIdHead(text.slice(start));
+    if (head === null || isWithinCodeBlock(text, start)) return text;
+    return text.slice(0, start) + head;
+  }
+};
+function openDisplayDollar(text) {
+  let at = -1;
+  let open = -1;
+  while ((at = text.indexOf("$$", at + 1)) !== -1) {
+    if (isWithinCodeBlock(text, at)) continue;
+    open = open === -1 ? at : -1;
+    at += 1;
+  }
+  return open;
+}
+const pendingMath = {
+  name: "matrx-pending-math",
+  priority: -1,
+  handle: (text) => {
+    let cut = openDisplayDollar(text);
+    for (const [open, close] of [
+      ["\\[", "\\]"],
+      ["\\(", "\\)"]
+    ]) {
+      const o = text.lastIndexOf(open);
+      if (o !== -1 && text.indexOf(close, o) === -1 && !isWithinCodeBlock(text, o)) {
+        cut = cut === -1 ? o : Math.min(cut, o);
+      }
+    }
+    return cut === -1 ? text : text.slice(0, cut);
+  }
+};
+const SYNTAX_STREAM_HANDLERS = [
+  pendingFrontmatter,
+  pendingBlockMarker,
+  pendingInline,
+  pendingHeadingId,
+  pendingMath
+];
+export {
+  SYNTAX_STREAM_HANDLERS
+};

package/dist/markdown-core/syntax/task-source.d.ts

@@ -0,0 +1,10 @@
+export interface TaskToggleRequest {
+    /** The item text as rendered. */
+    text: string;
+    /** Index among the rendered block's tasks — the tiebreaker for duplicates. */
+    index: number;
+    /** The state the person asked for. */
+    checked: boolean;
+}
+/** The new source with that one task toggled, or null when no stored task matches. */
+export declare function toggleTaskInSource(source: string, request: TaskToggleRequest): string | null;

package/dist/markdown-core/syntax/task-source.js

@@ -0,0 +1,34 @@
+import { blockEdit, spliceSave, tokenizeSource } from "@ai-matrx/content-ir/source";
+const TASK_LINE = /^([ \t]*(?:[-*+]|\d+[.)])[ \t]+)\[([ xX])\]([ \t]+|$)(.*)$/;
+function normalize(text) {
+  return text.replace(/[*_~`=]|\[\[|\]\]/g, "").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/\s+/g, " ").trim().toLowerCase();
+}
+function toggleTaskInSource(source, request) {
+  const blocks = tokenizeSource(source);
+  const all = [];
+  blocks.forEach((block2, blockIndex) => {
+    if (block2.kind !== "prose") return;
+    let offset = 0;
+    for (const line of block2.raw.split("\n")) {
+      const m = TASK_LINE.exec(line);
+      if (m) {
+        all.push({ blockIndex, lineStart: offset, markerOffset: offset + (m[1] ?? "").length + 1, text: m[4] ?? "" });
+      }
+      offset += line.length + 1;
+    }
+  });
+  if (all.length === 0) return null;
+  const wanted = normalize(request.text);
+  const matches = all.filter((c) => normalize(c.text) === wanted);
+  const pick = matches.length === 1 ? matches[0] : matches.length > 1 ? matches[Math.min(request.index, matches.length - 1)] ?? matches[0] : wanted === "" && all[request.index] ? all[request.index] : void 0;
+  if (!pick) return null;
+  const block = blocks[pick.blockIndex];
+  if (!block) return null;
+  const nextRaw = block.raw.slice(0, pick.markerOffset) + (request.checked ? "x" : " ") + block.raw.slice(pick.markerOffset + 1);
+  if (nextRaw === block.raw) return source;
+  const result = spliceSave(source, [blockEdit(block, nextRaw)], { blocks, requireIntegrity: true });
+  return result.text;
+}
+export {
+  toggleTaskInSource
+};

package/dist/markdown-core/syntax/useDocumentProperties.d.ts

@@ -0,0 +1,3 @@
+import { type DocumentPropertiesResult } from "./frontmatter.js";
+/** The React Compiler memoizes this per `source`. */
+export declare function useDocumentProperties(source: string): DocumentPropertiesResult;

package/dist/markdown-core/syntax/useDocumentProperties.js

@@ -0,0 +1,8 @@
+"use client";
+import { extractFrontmatter } from "./frontmatter.js";
+function useDocumentProperties(source) {
+  return extractFrontmatter(source);
+}
+export {
+  useDocumentProperties
+};

package/dist/math-vendor-LICENSE-NOTICE.md

@@ -0,0 +1,18 @@
+# Vendored math plugins
+
+`remark-math`, `rehype-katex` and the syntax half of `micromark-extension-math` are copied here
+verbatim (one import path changed each) under their MIT license:
+
+> (The MIT License) Copyright (c) Titus Wormer <tituswormer@gmail.com>. Permission is hereby
+> granted, free of charge, to any person obtaining a copy of this software and associated
+> documentation files (the 'Software'), to deal in the Software without restriction, including
+> without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+> and/or sell copies of the Software, and to permit persons to whom the Software is furnished to
+> do so, subject to the following conditions: The above copyright notice and this permission
+> notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS
+> PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND.
+
+Why: the upstream packages pin `katex ^0.16.0`, which carries GHSA-238p-pmpm-9mq7 (fixed in
+0.18.2), so any npm consumer of this package installed a vulnerable KaTeX. Vendored, the only
+KaTeX in the graph is this package's own `katex` dependency (^0.18.9). Drop the vendor copy the
+day upstream depends on katex >= 0.18.2.

package/dist/utils/addressWithoutNavigating.d.ts

@@ -0,0 +1,68 @@
+/**
+ * addressWithoutNavigating — THE one way to change the address bar without a
+ * navigation (lane URL-STATE, 2026-09-24; born in lane PANEL-REMOUNT).
+ *
+ * Query state (`?view=`, `?panels=`, `?tab=`, a selected row, a filter) is
+ * bookkeeping about the page you are on, never a new page. `router.replace` /
+ * `router.push` are App Router NAVIGATIONS: each one fetches a fresh RSC
+ * payload for the route (a `?_rsc=` request, a server round trip) and, on
+ * commit, can remount the page — measured on /data/[tableId]: one `?_rsc=`
+ * request per layout switch, and before PANEL-REMOUNT the whole grid re-read.
+ *
+ * `history.pushState` / `history.replaceState` are patched by Next's app
+ * router: called with a state object that does NOT carry `__NA`, the patch
+ * copies Next's own tree state onto the new entry and dispatches a `restore`,
+ * so `useSearchParams` / `usePathname` hold the new URL with no server round
+ * trip and no remount. Back/forward still work (Next owns the entry).
+ *
+ * 🚨 This module always passes `null`. Passing `window.history.state` (the
+ * old habit) forwards Next's `__NA` marker, which SKIPS the patch: the address
+ * bar changes while `useSearchParams` keeps the old value.
+ *
+ * Use the router for a REAL route change (another page), or when the server
+ * component of the current route reads the changed param from `searchParams`
+ * — only a navigation re-renders server output. Everything else comes here.
+ * Guard: eslint `matrx/no-navigation-for-query-state`.
+ */
+/**
+ * Replace the current history entry's address. No navigation, no RSC fetch.
+ *
+ * A HASH-ONLY change skips Next's patch on purpose: nothing Next exposes
+ * (`usePathname`, `useSearchParams`, `useParams`) reads the hash, yet the
+ * patch's `restore` hands every `useSearchParams` reader a new object, so each
+ * write re-rendered all of them. A canvas writing its camera to `#cam=` while
+ * panning paid that per write — over a second per pointer move on a board of
+ * fifteen heavy tiles, so the board froze while panning (2026-10-01). Forwarding
+ * the entry's own state keeps Next's `__NA` tree on it (Back still works).
+ */
+export declare function replaceAddressWithoutNavigating(href: string | URL): void;
+/** Push a new history entry (Back returns to the old address). No navigation, no RSC fetch. */
+export declare function pushAddressWithoutNavigating(href: string | URL): void;
+/**
+ * The current path (and hash) carrying `search` as its query — the usual
+ * argument for the two writers above. An empty query drops the `?`.
+ */
+export declare function currentPathWithSearch(search: URLSearchParams | string): string;
+/** Just enough of Next's router for the two helpers below (and their tests). */
+export interface AddressRouter {
+    push: (href: string, options?: {
+        scroll?: boolean;
+    }) => void;
+    replace: (href: string, options?: {
+        scroll?: boolean;
+    }) => void;
+}
+/**
+ * For a caller that names its page by a literal path (`/tasks?task=…`) but
+ * can also render somewhere else (a window panel over another page): on that
+ * page the change is query state, so no navigation; anywhere else it is a real
+ * route change, so the router carries it exactly as before (`options` are the
+ * router's, passed through unchanged).
+ */
+export declare function replaceAddressOrNavigate(router: AddressRouter, href: string, options?: {
+    scroll?: boolean;
+}): void;
+/** The push twin of {@link replaceAddressOrNavigate}. */
+export declare function pushAddressOrNavigate(router: AddressRouter, href: string, options?: {
+    scroll?: boolean;
+}): void;

package/dist/utils/addressWithoutNavigating.js

@@ -0,0 +1,60 @@
+function currentHref() {
+  return `${window.location.pathname}${window.location.search}${window.location.hash}`;
+}
+function resolve(href) {
+  const url = new URL(String(href), window.location.href);
+  if (url.origin !== window.location.origin) {
+    throw new Error(
+      `addressWithoutNavigating: ${url.origin} is another origin; history writes are same-origin only. Navigate instead.`
+    );
+  }
+  return `${url.pathname}${url.search}${url.hash}`;
+}
+function replaceAddressWithoutNavigating(href) {
+  if (typeof window === "undefined") return;
+  const next = resolve(href);
+  if (next === currentHref()) return;
+  const sameDocument = next.split("#")[0] === `${window.location.pathname}${window.location.search}`;
+  const state = window.history.state;
+  if (sameDocument && isNextEntry(state)) {
+    window.history.replaceState(state, "", next);
+    return;
+  }
+  window.history.replaceState(null, "", next);
+}
+function isNextEntry(state) {
+  return typeof state === "object" && state !== null && ("__NA" in state || "_N" in state);
+}
+function pushAddressWithoutNavigating(href) {
+  if (typeof window === "undefined") return;
+  const next = resolve(href);
+  if (next === currentHref()) return;
+  window.history.pushState(null, "", next);
+}
+function currentPathWithSearch(search) {
+  const qs = (typeof search === "string" ? search : search.toString()).replace(
+    /^\?/,
+    ""
+  );
+  if (typeof window === "undefined") return qs ? `?${qs}` : "";
+  return `${window.location.pathname}${qs ? `?${qs}` : ""}${window.location.hash}`;
+}
+function isCurrentPath(href) {
+  const url = new URL(String(href), window.location.href);
+  return url.origin === window.location.origin && url.pathname === window.location.pathname;
+}
+function replaceAddressOrNavigate(router, href, options) {
+  if (typeof window !== "undefined" && isCurrentPath(href)) replaceAddressWithoutNavigating(href);
+  else router.replace(href, options);
+}
+function pushAddressOrNavigate(router, href, options) {
+  if (typeof window !== "undefined" && isCurrentPath(href)) pushAddressWithoutNavigating(href);
+  else router.push(href, options);
+}
+export {
+  currentPathWithSearch,
+  pushAddressOrNavigate,
+  pushAddressWithoutNavigating,
+  replaceAddressOrNavigate,
+  replaceAddressWithoutNavigating
+};

package/dist/utils/client-lazy.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `clientLazy` — the package's replacement for `next/dynamic(..., { ssr: false })`: a lazily
+ * loaded component that renders only on the client. On the server and during hydration it
+ * renders `loading` (hydration-safe through `useSyncExternalStore`); on the client it renders
+ * the loaded component inside a Suspense boundary with the same `loading` as the fallback.
+ */
+import { type ComponentType } from "react";
+export declare function useIsClient(): boolean;
+export declare function clientLazy<P extends object>(load: () => Promise<{
+    default: ComponentType<P>;
+}>, options?: {
+    loading?: ComponentType;
+}): ComponentType<P>;

package/dist/utils/client-lazy.js

@@ -0,0 +1,24 @@
+"use client";
+import { createElement, lazy, Suspense, useSyncExternalStore } from "react";
+const subscribe = () => () => {
+};
+const onClient = () => true;
+const onServer = () => false;
+function useIsClient() {
+  return useSyncExternalStore(subscribe, onClient, onServer);
+}
+function clientLazy(load, options = {}) {
+  const Lazy = lazy(load);
+  const Loading = options.loading;
+  function ClientLazy(props) {
+    const client = useIsClient();
+    const fallback = Loading ? createElement(Loading) : null;
+    if (!client) return fallback;
+    return createElement(Suspense, { fallback }, createElement(Lazy, props));
+  }
+  return ClientLazy;
+}
+export {
+  clientLazy,
+  useIsClient
+};

package/dist/utils/decision-options.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The ONE place a `<decision>` body becomes options. Used by the splitter
+ * (content-splitter-core), the stream accumulator, and parseDecisionXml — the
+ * server twin is aidream matrx_ai/processing/blocks/parsers/decision_parser.py
+ * and MUST stay in lockstep with this file.
+ *
+ * Tolerant of real model output (captured 2026-10-04): extra attributes on
+ * <option> (`id` before/after `label`), single or double quotes, indentation
+ * and blank lines, and self-describing options with no `label` attribute
+ * (`<option id="x">Label text</option>` — the text names the choice).
+ * The choice id is the model's `id` attribute when present (unique), else
+ * `opt-N`. Only options whose closing tag has arrived count.
+ */
+export interface ParsedDecisionOption {
+    /** The model's own `id` attribute when present and unique, else `opt-N`. */
+    id: string;
+    label: string;
+    text: string;
+}
+export declare function parseOptionAttributes(attrString: string): Record<string, string>;
+export declare function parseDecisionOptionsFromBody(body: string): ParsedDecisionOption[];

package/dist/utils/decision-options.js

@@ -0,0 +1,32 @@
+const OPTION_RE = /<option\b([^>]*)>([\s\S]*?)<\/option\s*>/gi;
+const ATTR_RE = /([\w-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+function parseOptionAttributes(attrString) {
+  const attrs = {};
+  ATTR_RE.lastIndex = 0;
+  let m;
+  while ((m = ATTR_RE.exec(attrString)) !== null) {
+    attrs[m[1]] = m[2] ?? m[3] ?? "";
+  }
+  return attrs;
+}
+function parseDecisionOptionsFromBody(body) {
+  const options = [];
+  const seen = /* @__PURE__ */ new Set();
+  const re = new RegExp(OPTION_RE.source, OPTION_RE.flags);
+  let m;
+  while ((m = re.exec(body)) !== null) {
+    const attrs = parseOptionAttributes(m[1]);
+    const text = m[2].trim();
+    const label = (attrs.label ?? attrs.title ?? attrs.name ?? "").trim() || text.split("\n")[0].trim();
+    if (label === "") continue;
+    const own = (attrs.id ?? "").trim();
+    const id = own !== "" && !seen.has(own) ? own : `opt-${options.length}`;
+    seen.add(id);
+    options.push({ id, label, text });
+  }
+  return options;
+}
+export {
+  parseDecisionOptionsFromBody,
+  parseOptionAttributes
+};

package/dist/utils/gfm-lexer.d.ts

@@ -0,0 +1,5 @@
+import { type Token, type Tokens } from "marked";
+export { Lexer, Tokenizer } from "marked";
+export type { Token, Tokens };
+/** GFM block tokens of `text` (each with its exact `raw`), blank-line tokens dropped. */
+export declare function lexGfmBlocks(text: string): Token[];

package/dist/utils/gfm-lexer.js

@@ -0,0 +1,10 @@
+import { marked } from "marked";
+import { Lexer, Tokenizer } from "marked";
+function lexGfmBlocks(text) {
+  return marked.lexer(text, { gfm: true }).filter((token) => token.type !== "space");
+}
+export {
+  Lexer,
+  Tokenizer,
+  lexGfmBlocks
+};

package/dist/utils/json.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Canonical JSON value types + narrowing guards.
+ *
+ * ─── Why this exists ───────────────────────────────────────────────────────
+ * This repo patches the Supabase-generated `Json` alias to `unknown`
+ * (scripts/patch-db-types.sh) so that typed objects are freely assignable INTO
+ * JSONB columns on the write side. The cost lands on the READ side: a JSONB
+ * column comes back as bare `unknown`, and to do anything with it you must
+ * narrow it.
+ *
+ * The lazy/cheating reaction (the #1 source of `as unknown as` in the codebase)
+ * is to cast the WHOLE row — `row as unknown as MyTypedRow` — which re-asserts
+ * every already-correctly-typed column just to reach the one `unknown` JSON
+ * field. That silently discards real type information and is exactly the
+ * "type cheating" this system exists to kill.
+ *
+ * The honest move is to narrow ONLY the JSON field, and to have a real name for
+ * "this is just a JSON object, accept it" that is NOT `any` and NOT a bare
+ * `unknown`:
+ *
+ *   import { type JsonObject, isJsonObject } from "@/types/json";
+ *
+ *   // 1. "It's just an object" — type the ONE field, leave the row typed:
+ *   interface MyRow { id: string; name: string; config: JsonObject }
+ *
+ *   // 2. Narrowing a bare `unknown` DB field honestly (runtime-checked):
+ *   const cfg = isJsonObject(row.config) ? row.config : undefined;
+ *   //    cfg is JsonObject | undefined — no cast, no `any`, no whole-row nuke.
+ *
+ *   // 3. Reading a leaf — JsonObject values are JsonValue, narrow as needed:
+ *   const label = typeof cfg?.label === "string" ? cfg.label : null;
+ *
+ * For a concrete, known shape (an API/DB frame), prefer a Zod parse at the
+ * boundary (see TYPESCRIPT_STANDARDS.md §4). These types are for the genuinely
+ * open / loosely-shaped JSON the standards doc calls "just an object" — they
+ * give it an honest name so nobody reaches for `any` or a whole-row cast.
+ */
+export type JsonPrimitive = string | number | boolean | null;
+/**
+ * A JSON object. Values are `JsonValue | undefined` so optional keys read
+ * cleanly (mirrors Supabase's original generated `Json` object member).
+ */
+export interface JsonObject {
+    [key: string]: JsonValue | undefined;
+}
+export type JsonArray = JsonValue[];
+export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+/**
+ * Narrow an `unknown` (e.g. a bare JSONB column) to a `JsonObject`.
+ * Plain object only — arrays and `null` return false.
+ */
+export declare function isJsonObject(value: unknown): value is JsonObject;
+/**
+ * Convert a `JsonObject` (values `JsonValue | undefined`) into the strict
+ * `Record<string, JsonValue>` shape generated API request bodies demand,
+ * dropping `undefined` entries (they don't exist in real JSON — `undefined`
+ * only appears via optional-key reads). Cast-free by construction.
+ */
+export declare function toJsonRecord(obj: JsonObject): Record<string, JsonValue>;
+/** Narrow an `unknown` to a `JsonArray`. */
+export declare function isJsonArray(value: unknown): value is JsonArray;
+/** Narrow an `unknown` to a JSON primitive (string | number | boolean | null). */
+export declare function isJsonPrimitive(value: unknown): value is JsonPrimitive;

package/dist/utils/json.js

@@ -0,0 +1,22 @@
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toJsonRecord(obj) {
+  const out = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+function isJsonArray(value) {
+  return Array.isArray(value);
+}
+function isJsonPrimitive(value) {
+  return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+export {
+  isJsonArray,
+  isJsonObject,
+  isJsonPrimitive,
+  toJsonRecord
+};

package/dist/utils/plain-title.d.ts

@@ -0,0 +1,25 @@
+/** Strip markdown syntax from ONE line, keeping its readable text. */
+export declare function plainTextOfMarkdownLine(line: string): string;
+export interface PlainTitleOptions {
+    /** Longest title; longer titles are cut at a word boundary with "…". */
+    maxLength?: number;
+}
+/**
+ * The plain-text title of markdown content: its first heading or line with
+ * the syntax removed. Returns "" when the content has no nameable line.
+ */
+export declare function plainTitleFromMarkdown(source: string | null | undefined, { maxLength }?: PlainTitleOptions): string;
+/**
+ * Display form of a STORED title that may still carry syntax (rows written
+ * before the projection existed). Clean titles come back unchanged; a title
+ * that projects to nothing keeps its original text rather than going blank.
+ */
+export declare function displayTitle(title: string | null | undefined): string;
+/**
+ * A read-boundary copy of `row` whose `key` title is in display form.
+ * Services that return rows whose title may have been derived from markdown
+ * (flashcard sets, assessments, study media) pass them through this, so every
+ * list, header, picker and export shows the clean name. Storage is untouched;
+ * a person who edits and saves the name saves what they see.
+ */
+export declare function withDisplayTitle<T, K extends keyof T>(row: T, key: K): T;

package/dist/utils/plain-title.js

@@ -0,0 +1,51 @@
+import { fenceLineKinds } from "@ai-matrx/content-ir/source";
+import { hasJsonKindKey } from "@ai-matrx/content-ir/surfaces";
+import { kindTextLabel } from "@ai-matrx/content-ir/surfaces";
+function firstContentLine(source) {
+  const lines = source.split(/\r?\n/);
+  let i = 0;
+  if (lines[0]?.trim() === "---") {
+    const end = lines.findIndex((l, k) => k > 0 && /^(---|\.\.\.)\s*$/.test(l));
+    if (end > 0) i = end + 1;
+  }
+  const kinds = fenceLineKinds(source);
+  for (; i < lines.length; i += 1) {
+    const line = lines[i];
+    if (kinds[i] !== "prose") continue;
+    if (/^\s*([-=*_])(\s*\1){2,}\s*$/.test(line)) continue;
+    if (line.trim()) return line;
+  }
+  return "";
+}
+function plainTextOfMarkdownLine(line) {
+  let text = line.replace(/^\s{0,3}#{1,6}(\s+|$)/, "").replace(/^\s*(>\s?)+/, "").replace(/^\s*([-*+]|\d+[.)])\s+/, "").replace(/^\s*\[[ xX]\]\s+/, "").replace(/\s+#+\s*$/, "");
+  text = text.replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/\[([^\]]+)\]\([^)]*\)/g, "$1").replace(/\[([^\]]+)\]\[[^\]]*\]/g, "$1").replace(/<(https?:\/\/[^>\s]+)>/g, "$1").replace(/<\/?[A-Za-z][\w:-]*(\s[^<>]*)?\/?>/g, "").replace(/(`+)([\s\S]*?)\1/g, "$2").replace(/(\*\*|__)(?=\S)([\s\S]*?\S)\1/g, "$2").replace(/\*(?=\S)([^*]*?\S)\*/g, "$1").replace(/(^|\W)_(?=\S)([^_]*?\S)_(?=\W|$)/g, "$1$2").replace(/~~(?=\S)([\s\S]*?\S)~~/g, "$1").replace(/\\([\\`*_{}#+\-.!>~|])/g, "$1");
+  return text.replace(/\s+/g, " ").trim();
+}
+function plainTitleFromMarkdown(source, { maxLength } = {}) {
+  const text = source ?? "";
+  const holdsKind = hasJsonKindKey(text);
+  const title = plainTextOfMarkdownLine(holdsKind ? kindTextLabel(text, 200) : firstContentLine(text)) || // A kind always names its record (an `<artifact>`-wrapped kind used to
+  // project to "") — R4, round 6.
+  (holdsKind ? kindTextLabel(text, 200) : "");
+  if (!maxLength || title.length <= maxLength) return title;
+  const cut = title.slice(0, maxLength - 1);
+  const space = cut.lastIndexOf(" ");
+  return `${(space > maxLength * 0.6 ? cut.slice(0, space) : cut).trimEnd()}\u2026`;
+}
+function displayTitle(title) {
+  const raw = title ?? "";
+  return plainTitleFromMarkdown(raw) || raw.trim();
+}
+function withDisplayTitle(row, key) {
+  const value = row[key];
+  if (typeof value !== "string") return row;
+  const clean = displayTitle(value);
+  return clean === value ? row : { ...row, [key]: clean };
+}
+export {
+  displayTitle,
+  plainTextOfMarkdownLine,
+  plainTitleFromMarkdown,
+  withDisplayTitle
+};