@nuucognition/ncm-ui 0.1.1-beta.0 → 0.1.1-beta.2

package/dist/lib/defaults.js

@@ -1,9 +1,9 @@
 "use client";
-import { createContext, useState, createElement, useMemo, useContext, useCallback, useEffect, useRef, Component, useId } from 'react';
+import { createContext, useMemo, useState, createElement, useContext, useCallback, useEffect, useRef, Component, useId } from 'react';
 import { clsx } from 'clsx';
 import { twMerge } from 'tailwind-merge';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
-import { serializeInlineContent, isTypedNestedList } from '@nuucognition/ncm';
+import { serializeInlineContent, isTypedNestedList, parseNcm } from '@nuucognition/ncm';
 import { extractExtension, embedTypeFromExtension } from '@nuucognition/mesh-core';
 
 // src/lib/defaults.ts
@@ -22,7 +22,7 @@ function CustomCodeBlock({ block, className }) {
       "data-block-id": block.id,
       "data-ncm-custom-code": "",
       "data-ncm-language": block.language,
-      className: cn("overflow-x-auto", className),
+      className: cn("overflow-x-auto overflow-y-hidden", className),
       children: [
         /* @__PURE__ */ jsx("div", { className: "mb-2 text-xs font-medium text-muted-foreground", children: block.language }),
         /* @__PURE__ */ jsx("pre", { children: /* @__PURE__ */ jsx("code", { children: block.content }) })
@@ -71,6 +71,52 @@ function tryParseInlineRef(input) {
   }
   return { token: { type: "inline_ref", kind: "footnote", content: inner.trim() }, length };
 }
+function runLength(input, index, char) {
+  let end = index;
+  while (end < input.length && input[end] === char) end++;
+  return end - index;
+}
+function tryParseEmphasis(input) {
+  const char = input[0];
+  if (char !== "*" && char !== "_") return null;
+  const open = Math.min(3, runLength(input, 0, char));
+  const need = open;
+  let i = open;
+  while (i < input.length) {
+    const ch = input[i];
+    if (ch === "`") {
+      const close = input.indexOf("`", i + 1);
+      if (close === -1) break;
+      i = close + 1;
+      continue;
+    }
+    if (ch !== char) {
+      i++;
+      continue;
+    }
+    const run = runLength(input, i, char);
+    const closes = need === 1 ? run % 2 === 1 : run >= need;
+    if (!closes) {
+      i += run;
+      continue;
+    }
+    const extra = run - need;
+    const inner = input.slice(open, i + extra);
+    if (inner.length === 0) return null;
+    const length = i + run;
+    const children = parseInline(inner);
+    let token;
+    if (need === 3) {
+      token = { type: "bold", children: [{ type: "italic", children }] };
+    } else if (need === 2) {
+      token = { type: "bold", children };
+    } else {
+      token = { type: "italic", children };
+    }
+    return { token, length };
+  }
+  return null;
+}
 function parseInline(content) {
   if (!content) return [];
   const tokens = [];
@@ -142,17 +188,11 @@ function parseInline(content) {
       remaining = remaining.slice(linkMatch[0].length);
       continue;
     }
-    const boldMatch = remaining.match(/^\*\*(.+?)\*\*|^__(.+?)__/);
-    if (boldMatch) {
-      const innerContent = boldMatch[1] ?? boldMatch[2];
-      if (innerContent !== void 0) {
-        tokens.push({
-          type: "bold",
-          children: parseInline(innerContent)
-        });
-        remaining = remaining.slice(boldMatch[0].length);
-        continue;
-      }
+    const emphasis = tryParseEmphasis(remaining);
+    if (emphasis) {
+      tokens.push(emphasis.token);
+      remaining = remaining.slice(emphasis.length);
+      continue;
     }
     const strikeMatch = remaining.match(/^~~(.+?)~~/);
     if (strikeMatch && strikeMatch[1] !== void 0) {
@@ -163,18 +203,6 @@ function parseInline(content) {
       remaining = remaining.slice(strikeMatch[0].length);
       continue;
     }
-    const italicMatch = remaining.match(/^\*([^*]+)\*|^_([^_]+)_/);
-    if (italicMatch) {
-      const innerContent = italicMatch[1] ?? italicMatch[2];
-      if (innerContent !== void 0) {
-        tokens.push({
-          type: "italic",
-          children: parseInline(innerContent)
-        });
-        remaining = remaining.slice(italicMatch[0].length);
-        continue;
-      }
-    }
     const nextSpecial = findNextSpecialChar(remaining);
     if (nextSpecial > 0) {
       tokens.push({ type: "text", content: remaining.slice(0, nextSpecial) });
@@ -209,17 +237,30 @@ function mergeAdjacentText(tokens) {
   }
   return result;
 }
-var ReferenceBasesContext = createContext(null);
+function normalizeReferenceContent(content) {
+  return content.replace(/\s+/g, " ").trim().toLowerCase();
+}
+var ReferenceNumberingContext = createContext(null);
 var BlockReferenceScopeContext = createContext(null);
-function BlockReferenceScope({ blockId, children }) {
-  const bases = useContext(ReferenceBasesContext);
-  const base = (blockId ? bases?.get(blockId) : void 0) ?? { ref: 0, footnote: 0 };
+function BlockReferenceScope({ children }) {
+  const numbering = useContext(ReferenceNumberingContext);
+  const local = useRef({ ref: /* @__PURE__ */ new Map(), footnote: /* @__PURE__ */ new Map() });
   const counter = useRef({ ref: 0, footnote: 0 });
-  counter.current = { ref: 0, footnote: 0 };
   const value = {
+    numberFor(kind, content) {
+      const key = normalizeReferenceContent(content);
+      const fromDocument = numbering?.[kind].get(key);
+      if (fromDocument !== void 0) return fromDocument;
+      const map = local.current[kind];
+      const existing = map.get(key);
+      if (existing !== void 0) return existing;
+      counter.current[kind] += 1;
+      map.set(key, counter.current[kind]);
+      return counter.current[kind];
+    },
     next(kind) {
       counter.current[kind] += 1;
-      return base[kind] + counter.current[kind];
+      return counter.current[kind];
     }
   };
   return /* @__PURE__ */ jsx(BlockReferenceScopeContext.Provider, { value, children });
@@ -227,7 +268,7 @@ function BlockReferenceScope({ blockId, children }) {
 function useBlockReferenceScope() {
   return useContext(BlockReferenceScopeContext);
 }
-var INERT_SCOPE = { next: () => 0 };
+var INERT_SCOPE = { numberFor: () => 0, next: () => 0 };
 function InertReferenceScope({ children }) {
   return /* @__PURE__ */ jsx(BlockReferenceScopeContext.Provider, { value: INERT_SCOPE, children });
 }
@@ -751,7 +792,7 @@ function TokenRenderer({ token, disableBionic, disableBeeline }) {
       );
     }
     case "inline_ref": {
-      const number = refScope?.next(token.kind) ?? 0;
+      const number = refScope?.numberFor(token.kind, token.content) ?? 0;
       return /* @__PURE__ */ jsx(ReferenceMarker, { kind: token.kind, number, children: token.content ? /* @__PURE__ */ jsx(InertReferenceScope, { children: /* @__PURE__ */ jsx(InlineContent, { content: token.content, disableBionic: true, disableBeeline: true }) }) : null });
     }
     default:
@@ -817,8 +858,32 @@ function renderReadingText(content, opts) {
   if (cursor < content.length) pieces.push(content.slice(cursor));
   return /* @__PURE__ */ jsx(Fragment, { children: pieces });
 }
+function quoteBlocks(block) {
+  try {
+    const doc = parseNcm(block.content, {
+      preset: "ncm-full",
+      allowMissingFrontmatter: true,
+      // Attribution off, as the NUU Editor's bridge keeps it: the promoter's
+      // trigger is any last quote line starting with `-`, so a nested quote
+      // ending in a list item would lose that item to a `— Author` line.
+      blockOptions: { extensions: { attribution: false } }
+    });
+    const blocks = doc.blocks ?? [];
+    if (blocks.length === 0 || blocks.some((child) => child.type === "frontmatter")) {
+      return null;
+    }
+    return blocks.map((child, index) => ({ ...child, id: `${block.id}.${index + 1}`, stableId: void 0 }));
+  } catch {
+    return null;
+  }
+}
+function QuotedLines({ content }) {
+  const lines = content.split("\n");
+  return /* @__PURE__ */ jsx(Fragment, { children: lines.map((line, index) => /* @__PURE__ */ jsx("p", { children: line.trim().length > 0 ? /* @__PURE__ */ jsx(InlineContent, { content: line }) : /* @__PURE__ */ jsx("span", { "aria-hidden": "true", children: "\xA0" }) }, index)) });
+}
 function BlockquoteBlock({ block, className }) {
-  const lines = block.content.split("\n");
+  const multiline = block.content.includes("\n");
+  const blocks = useMemo(() => multiline ? quoteBlocks(block) : null, [block, multiline]);
   return /* @__PURE__ */ jsx(
     "blockquote",
     {
@@ -828,7 +893,9 @@ function BlockquoteBlock({ block, className }) {
       "data-block-id": block.id,
       "data-ncm-blockquote": "",
       className,
-      children: lines.length <= 1 ? /* @__PURE__ */ jsx(InlineContent, { content: block.content }) : lines.map((line, index) => /* @__PURE__ */ jsx("p", { children: line.trim().length > 0 ? /* @__PURE__ */ jsx(InlineContent, { content: line }) : /* @__PURE__ */ jsx("span", { "aria-hidden": "true", children: "\xA0" }) }, index))
+      children: !multiline ? /* @__PURE__ */ jsx(InlineContent, { content: block.content }) : blocks === null ? /* @__PURE__ */ jsx(QuotedLines, { content: block.content }) : blocks.map(
+        (child) => child.type === "paragraph" ? /* @__PURE__ */ jsx(QuotedLines, { content: child.content ?? "" }, blockKey(child)) : /* @__PURE__ */ jsx(NcmBlock, { block: child }, blockKey(child))
+      )
     }
   );
 }
@@ -843,7 +910,8 @@ function ChartBlock({ block, className }) {
       "data-ncm-chart": "",
       "data-ncm-chart-type": block.chartType ?? "unknown",
       className: cn(
-        "overflow-x-auto rounded-lg border border-border bg-muted p-4 font-mono text-sm",
+        // `overflow-y-hidden` pairs with `overflow-x-auto` on purpose — see the note in `lib/defaults.ts`.
+        "overflow-x-auto overflow-y-hidden rounded-lg border border-border bg-muted p-4 font-mono text-sm",
         className
       ),
       children: /* @__PURE__ */ jsx("code", { children: block.content })
@@ -1023,7 +1091,8 @@ function DataviewBlock({ block, className }) {
       "data-ncm-dataview": "",
       "data-ncm-query-type": block.queryType,
       className: cn(
-        "overflow-x-auto rounded-lg border border-border bg-muted p-4 font-mono text-sm",
+        // `overflow-y-hidden` pairs with `overflow-x-auto` on purpose — see the note in `lib/defaults.ts`.
+        "overflow-x-auto overflow-y-hidden rounded-lg border border-border bg-muted p-4 font-mono text-sm",
         className
       ),
       children: /* @__PURE__ */ jsx("code", { children: block.query })
@@ -1362,7 +1431,8 @@ function HtmlBlock({ block, className }) {
       "data-block-id": block.id,
       "data-ncm-html": "",
       className: cn(
-        "overflow-x-auto rounded-lg border border-border bg-muted p-4 font-mono text-sm",
+        // `overflow-y-hidden` pairs with `overflow-x-auto` on purpose — see the note in `lib/defaults.ts`.
+        "overflow-x-auto overflow-y-hidden rounded-lg border border-border bg-muted p-4 font-mono text-sm",
         className
       ),
       children: /* @__PURE__ */ jsx("code", { children: block.content })
@@ -1400,7 +1470,7 @@ function LatexDisplayBlock({ block, className }) {
         "data-ncm-type": block.type,
         "data-block-id": block.id,
         "data-ncm-latex-display": "",
-        className: cn("overflow-x-auto", className),
+        className: cn("overflow-x-auto overflow-y-hidden", className),
         dangerouslySetInnerHTML: { __html: html }
       }
     );
@@ -1415,7 +1485,7 @@ function LatexDisplayBlock({ block, className }) {
       "data-ncm-type": block.type,
       "data-block-id": block.id,
       "data-ncm-latex-display": "",
-      className: cn("overflow-x-auto rounded-lg border border-border bg-muted p-4 font-mono text-sm", className),
+      className: cn("overflow-x-auto overflow-y-hidden rounded-lg border border-border bg-muted p-4 font-mono text-sm", className),
       children: /* @__PURE__ */ jsx("code", { children: block.content })
     }
   );
@@ -1535,7 +1605,7 @@ function MathBlock({ block, className }) {
         "data-ncm-type": block.type,
         "data-block-id": block.id,
         "data-ncm-math": "",
-        className: cn("overflow-x-auto", className),
+        className: cn("overflow-x-auto overflow-y-hidden", className),
         dangerouslySetInnerHTML: { __html: html }
       }
     );
@@ -1551,7 +1621,8 @@ function MathBlock({ block, className }) {
       "data-block-id": block.id,
       "data-ncm-math": "",
       className: cn(
-        "overflow-x-auto rounded-lg border border-border bg-muted p-4 font-mono text-sm",
+        // `overflow-y-hidden` pairs with `overflow-x-auto` on purpose — see the note in `lib/defaults.ts`.
+        "overflow-x-auto overflow-y-hidden rounded-lg border border-border bg-muted p-4 font-mono text-sm",
         className
       ),
       children: /* @__PURE__ */ jsx("code", { children: block.content })
@@ -1569,7 +1640,8 @@ function MermaidBlock({ block, className }) {
       "data-ncm-mermaid": "",
       "data-ncm-diagram-type": block.diagramType,
       className: cn(
-        "overflow-x-auto rounded-lg border border-border bg-muted p-4 font-mono text-sm",
+        // `overflow-y-hidden` pairs with `overflow-x-auto` on purpose — see the note in `lib/defaults.ts`.
+        "overflow-x-auto overflow-y-hidden rounded-lg border border-border bg-muted p-4 font-mono text-sm",
         className
       ),
       children: /* @__PURE__ */ jsx("code", { children: block.content })
@@ -1630,7 +1702,7 @@ function TableBlock({ block, className }) {
       "data-ncm-type": block.type,
       "data-block-id": block.id,
       "data-ncm-table": "",
-      className: cn("w-full overflow-x-auto", className),
+      className: cn("w-full overflow-x-auto overflow-y-hidden", className),
       children: /* @__PURE__ */ jsxs("table", { role: "table", "data-ncm-table-element": "", children: [
         /* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsx("tr", { "data-ncm-table-row": "", children: block.headers.map((header, index) => /* @__PURE__ */ jsx("th", { "data-ncm-table-header": "", children: /* @__PURE__ */ jsx(InlineContent, { content: header }) }, index)) }) }),
         /* @__PURE__ */ jsx("tbody", { children: block.rows.map((row, rowIndex) => {
@@ -1716,7 +1788,7 @@ function FallbackBlock({ block, className }) {
       "data-block-id": block.id,
       "data-ncm-fallback": "",
       className: cn(
-        "overflow-x-auto rounded-lg border border-border bg-muted p-4 font-mono text-sm",
+        "overflow-x-auto overflow-y-hidden rounded-lg border border-border bg-muted p-4 font-mono text-sm",
         className
       )
     },

package/dist/references-BM-lvGrq.d.ts

@@ -0,0 +1,99 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { Block } from '@nuucognition/ncm';
+
+/**
+ * Numbering for inline references (`^[ref: ...]` / `^[footnote: ...]`).
+ *
+ * The two kinds are counted **independently**: refs produce `[1] [2] …` and
+ * footnotes produce `¹ ² …`.
+ *
+ * Numbers are assigned by a pure pre-pass over the `blocks` array and looked up
+ * by **token content**, never by render order. That makes the marker number a
+ * function of the document alone: it is stable under React re-renders,
+ * StrictMode double rendering, virtualised or out-of-order block rendering,
+ * and it gives every citation of the same source the same number.
+ *
+ * Refs additionally honour the document's own bibliography. When a paragraph
+ * reads `[16] Google Gemini Team. Gemini: …` and a `^[ref: Google Gemini
+ * Team. Gemini: …]` token carries that entry, the marker shows `[16]` — the
+ * number the source document uses — so the inline citation, the reference
+ * list, and the original paper all agree. Refs with no bibliography match are
+ * numbered sequentially in first-appearance order, continuing after the
+ * highest bibliography number so the two ranges never collide.
+ *
+ * Footnotes are numbered sequentially in first-appearance order (identical
+ * footnote text shares a number).
+ */
+type ReferenceKind = "ref" | "footnote";
+interface ReferenceCounts {
+    ref: number;
+    footnote: number;
+}
+/** Document-wide numbering: normalised token content → marker number. */
+interface ReferenceNumbering {
+    ref: Map<string, number>;
+    footnote: Map<string, number>;
+}
+/** Collapse whitespace and case so a token and its bibliography entry compare equal. */
+declare function normalizeReferenceContent(content: string): string;
+/**
+ * Map every `[n] entry` paragraph in the document to its number. The first
+ * paragraph carrying a given entry text wins.
+ */
+declare function collectBibliography(blocks: readonly Block[]): Map<string, number>;
+/**
+ * Compute the document-wide numbering (see the module comment for the rules).
+ */
+declare function computeReferenceNumbering(blocks: readonly Block[]): ReferenceNumbering;
+/**
+ * Per-block count of inline references, as the *previous* numbering scheme
+ * exposed it. Kept for API compatibility; the marker numbers no longer derive
+ * from these offsets.
+ */
+declare function computeReferenceBases(blocks: readonly Block[]): Map<string, ReferenceCounts>;
+interface BlockReferenceScopeValue {
+    /**
+     * The marker number for a token with this `kind` and `content`. Pure with
+     * respect to the document: the same content always gets the same number.
+     */
+    numberFor(kind: ReferenceKind, content: string): number;
+    /**
+     * Allocate the next number for `kind` in render order. Legacy API — prefer
+     * `numberFor`, which is stable under re-renders.
+     */
+    next(kind: ReferenceKind): number;
+}
+interface NcmReferencesProviderProps {
+    blocks: readonly Block[];
+    children: ReactNode;
+}
+/** Document-root provider — runs the numbering pre-pass over `blocks`. */
+declare function NcmReferencesProvider({ blocks, children }: NcmReferencesProviderProps): react.JSX.Element;
+interface BlockReferenceScopeProps {
+    /** Block id. Accepted for API compatibility; numbering is document-wide. */
+    blockId?: string;
+    children: ReactNode;
+}
+/**
+ * Reference scope for one block (or one standalone `InlineContent` fragment).
+ *
+ * Inside an `NcmDocument` it resolves numbers from the document pre-pass.
+ * Standalone — no `NcmReferencesProvider` above it — it numbers the fragment's
+ * own tokens by content in first-request order, which is still idempotent
+ * under StrictMode double rendering because a repeated request for the same
+ * content returns the same number.
+ */
+declare function BlockReferenceScope({ children }: BlockReferenceScopeProps): react.JSX.Element;
+/** Read the active per-block reference scope, if any. */
+declare function useBlockReferenceScope(): BlockReferenceScopeValue | null;
+/**
+ * Wrap a subtree so any inline references inside it do NOT take document
+ * numbers — used for a reference's own popover content, which the numbering
+ * pre-pass deliberately does not descend into.
+ */
+declare function InertReferenceScope({ children }: {
+    children: ReactNode;
+}): react.JSX.Element;
+
+export { BlockReferenceScope as B, InertReferenceScope as I, NcmReferencesProvider as N, type ReferenceCounts as R, type BlockReferenceScopeProps as a, type BlockReferenceScopeValue as b, type NcmReferencesProviderProps as c, type ReferenceKind as d, type ReferenceNumbering as e, collectBibliography as f, computeReferenceBases as g, computeReferenceNumbering as h, normalizeReferenceContent as n, useBlockReferenceScope as u };

package/dist/styles/nuu.css

@@ -15,7 +15,7 @@
  * 1rem body at 1.65, headings 1.75 / 1.56 / 1.39 / 1.24 / 1.1em. Switching
  * view must not resize a single glyph. Since the flow-block rhythm pass, the
  * MARGINS are part of the same contract: the editor states this file's block
- * gaps (1rem between siblings, per-level rem heading margins, the 1.25rem /
+ * gaps (1rem between siblings, per-level rem heading margins, the 1.5rem /
  * 0.125rem list geometry) per element on its side. If one side of that pair
  * moves, move the other in the same change.
  *
@@ -105,13 +105,16 @@
 }
 
 /*
- * Callout (admonition) — minimalist: sharp corners, 1px hairline border, a
- * 2px colored left edge (the blockquote's own weight), tight padding. The
- * type supplies only colors, through the `--ncm-callout-*` hooks; a host
- * assigns them per `data-ncm-admonition-type` (Onyx does, from its palette
+ * Callout (admonition) — a quiet card: rounded `md` corners (the NUU chrome
+ * step, stated as radius × 0.8 so a host's `--radius` carries through), 1px
+ * hairline border, a 2px colored left edge (the blockquote's own weight),
+ * tight padding. Rounded since (Task) 581, superseding the sharp-corner line
+ * of the minimalist pass — everything else from that pass stands. The type
+ * supplies only colors, through the `--ncm-callout-*` hooks; a host assigns
+ * them per `data-ncm-admonition-type` (Onyx does, from its palette
  * families). Unset, every hook falls back to the neutral hairline card, so
  * a host with no callout stylesheet — and any type a host does not cover —
- * renders the same minimalist shell with no color.
+ * renders the same quiet shell with no color.
  *
  * These rules override the component's own rounded-card utilities
  * (`rounded-lg bg-card p-4`): this file is unlayered and Tailwind utilities
@@ -122,9 +125,18 @@
 [data-ncm-document].ncm-theme-nuu [data-ncm-admonition] {
   border: 1px solid var(--ncm-callout-border, var(--border));
   border-left: 2px solid var(--ncm-callout-edge, var(--border));
-  border-radius: 0;
+  border-radius: calc(var(--radius, 0.625rem) * 0.8);
   padding: 0.625rem 0.875rem;
   background-color: var(--ncm-callout-tint, transparent);
+  /*
+   * An unbroken word must stay inside the card. Hosts lay the title out as a
+   * flex row (glyph + text), and a flex item's min-content size is the whole
+   * unbreakable word — the text ran past the card edge. `anywhere`, not
+   * `break-word`: only `anywhere` lets the break point count toward the
+   * min-content size, which is what the flex layout measures. Inherited, so
+   * the title and every content paragraph get it. ((Task) 581)
+   */
+  overflow-wrap: anywhere;
 }
 
 /*
@@ -157,9 +169,14 @@
 }
 
 /* Lists */
+/*
+ * 1.5rem is the ONE marker-slot width all three list kinds share — disc,
+ * decimal, and the task checkbox (1em box + 0.5rem gap) — so the text column
+ * is identical across them at every depth.
+ */
 [data-ncm-document].ncm-theme-nuu [data-ncm-type="list_ordered"],
 [data-ncm-document].ncm-theme-nuu [data-ncm-type="list_unordered"] {
-  padding-left: 1.25rem;
+  padding-left: 1.5rem;
   color: var(--foreground);
   line-height: 1.65;
 }
@@ -182,7 +199,7 @@
 [data-ncm-document].ncm-theme-nuu [data-ncm-type="list_unordered"] ol,
 [data-ncm-document].ncm-theme-nuu [data-ncm-type="list_unordered"] ul {
   margin-top: 0.125rem;
-  padding-left: 1.25rem;
+  padding-left: 1.5rem;
 }
 
 [data-ncm-document].ncm-theme-nuu [data-ncm-type="list_ordered"] li::marker,
@@ -206,11 +223,14 @@
 /*
  * Task list — one spec with the editor's `ul[data-type="taskList"]` block in
  * `@nuucognition/nuu-editor` (`src/nuu-editor/nuu-editor.scss`): flush-left
- * rows 0.125rem apart, a 1em sharp-cornered checkbox drawn from theme tokens
- * (border-token box, foreground fill when checked, background-coloured check),
- * 0.5rem to the text, checked text dimmed to the muted tone with NO
- * strike-through, nested lists indented 1.5rem so they start at the text
- * column. If one side of that pair moves, move the other in the same change.
+ * rows 0.125rem apart, a 1em checkbox rounded 0.25rem (the nuu-ui Checkbox
+ * radius) drawn from theme tokens (border-token box, foreground fill when
+ * checked, background-coloured check), 0.5rem to the text — 1em + 0.5rem =
+ * the shared 1.5rem marker slot that lines task text up with disc and
+ * decimal text. Checked text dims to the muted tone with NO strike-through.
+ * A nested task list carries NO indent of its own: the checkbox slot IS the
+ * indent, the same 1.5rem step the other list kinds get from padding. If one
+ * side of that pair moves, move the other in the same change.
  *
  * The checkbox is drawn with `appearance: none` because the native control
  * neither themes nor matches the editor's; the input stays a real (disabled)
@@ -233,7 +253,9 @@
 }
 
 [data-ncm-document].ncm-theme-nuu [data-ncm-task-list] [data-ncm-list-nested] {
-  margin-left: 1.5rem;
+  /* No margin: the nested row's own checkbox slot (1em + 0.5rem) is the
+     1.5rem indent, the same step disc and decimal get from padding. */
+  margin-left: 0;
   margin-top: 0.125rem;
 }
 
@@ -252,7 +274,8 @@
   height: 1em;
   margin: 0.375rem 0 0;
   border: 1px solid var(--border);
-  border-radius: 0;
+  /* nuu-ui's Checkbox radius (rounded-[4px]). */
+  border-radius: 0.25rem;
   background-color: transparent;
   position: relative;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuucognition/ncm-ui",
-  "version": "0.1.1-beta.0",
+  "version": "0.1.1-beta.2",
   "description": "React renderers for NUU Cognition Markdown (NCM) blocks — a component library that renders parsed NCM Blocks to accessible, themeable markup.",
   "type": "module",
   "license": "MIT",
@@ -18,8 +18,7 @@
     "*.css"
   ],
   "publishConfig": {
-    "access": "public",
-    "tag": "beta"
+    "access": "public"
   },
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -30,7 +29,7 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@nuucognition/mesh-core": "1.0.1-beta.1",
+    "@nuucognition/mesh-core": "1.0.1-beta.2",
     "clsx": "^2.1.1",
     "katex": "^0.16.21",
     "shiki": "^1.29.2",

package/dist/references-BYW5pnj_.d.ts

@@ -1,63 +0,0 @@
-import * as react from 'react';
-import { ReactNode } from 'react';
-import { Block } from '@nuucognition/ncm';
-
-/**
- * Document-order numbering for inline references (`^[ref: ...]` /
- * `^[footnote: ...]`).
- *
- * The two kinds are counted **independently**: refs produce `[1] [2] …` and
- * footnotes produce `¹ ² …`, each with its own running counter across the
- * whole document.
- *
- * Numbering is computed from the `blocks` array — a pure pre-pass that does not
- * depend on React render order — so markers stay stable even if a host
- * virtualises blocks or renders them out of order. The pre-pass yields, per
- * block, the count of each kind in all *preceding* blocks (the "base"); within
- * a block, a `BlockReferenceScope` hands out sequential numbers in render
- * order. Only the within-block step relies on the block's inline content
- * rendering as a synchronous subtree (it always does).
- */
-type ReferenceKind = "ref" | "footnote";
-interface ReferenceCounts {
-    ref: number;
-    footnote: number;
-}
-/**
- * Map each block id to the number of refs/footnotes that precede it in
- * document order — the starting offset for that block's own markers.
- */
-declare function computeReferenceBases(blocks: readonly Block[]): Map<string, ReferenceCounts>;
-interface BlockReferenceScopeValue {
-    /** Allocate the next document-order number for `kind` within this block. */
-    next(kind: ReferenceKind): number;
-}
-interface NcmReferencesProviderProps {
-    blocks: readonly Block[];
-    children: ReactNode;
-}
-/** Document-root provider — runs the numbering pre-pass over `blocks`. */
-declare function NcmReferencesProvider({ blocks, children }: NcmReferencesProviderProps): react.JSX.Element;
-interface BlockReferenceScopeProps {
-    /** Block id; resolves the base offset from the document pre-pass. */
-    blockId?: string;
-    children: ReactNode;
-}
-/**
- * Per-block numbering scope. Seeds a fresh counter from the block's base offset
- * on every render and hands out sequential numbers as markers render. Resetting
- * each render keeps numbering idempotent under React re-renders / StrictMode.
- */
-declare function BlockReferenceScope({ blockId, children }: BlockReferenceScopeProps): react.JSX.Element;
-/** Read the active per-block reference scope, if any. */
-declare function useBlockReferenceScope(): BlockReferenceScopeValue | null;
-/**
- * Wrap a subtree so any inline references inside it do NOT allocate
- * document-order numbers — used for a reference's own popover content, which
- * the numbering pre-pass deliberately does not descend into.
- */
-declare function InertReferenceScope({ children }: {
-    children: ReactNode;
-}): react.JSX.Element;
-
-export { BlockReferenceScope as B, InertReferenceScope as I, NcmReferencesProvider as N, type ReferenceCounts as R, type BlockReferenceScopeProps as a, type BlockReferenceScopeValue as b, type NcmReferencesProviderProps as c, type ReferenceKind as d, computeReferenceBases as e, useBlockReferenceScope as u };