@rokkit/graph 1.6.0

package/dist/preset.js

@@ -0,0 +1,61 @@
+import { categoricalPalette } from '@rokkit/core';
+/**
+ * Mirrors `createChartPreset`'s shape on purpose — a consumer who has met one
+ * has met both. Shade picks differ from chart's because a cluster is a large
+ * background area rather than a small mark.
+ *
+ * The `groups` ramp and the `patterns` list are chart's own leading entries, in
+ * chart's order, so a graph and a chart on one page differentiate alike.
+ */
+export const defaultGraphPreset = {
+    groups: ['blue', 'emerald', 'rose', 'amber', 'violet', 'sky', 'pink', 'teal'],
+    // The label shade is measured against the FILL shade, not against paper: the cluster label
+    // sits on the cluster. 700-on-100 came out at 3.63:1 for green — under the 4.5 text bar —
+    // so the label sits two more steps away from its own background.
+    shades: {
+        light: { fill: '100', stroke: '400', label: '900' },
+        dark: { fill: '900', stroke: '600', label: '100' }
+    },
+    patterns: ['diagonal', 'dots', 'triangles', 'hatch', 'lattice', 'swell', 'checkerboard', 'waves'],
+    using: 'color'
+};
+export function createGraphPreset(overrides = {}) {
+    return {
+        ...defaultGraphPreset,
+        ...overrides,
+        shades: {
+            light: { ...defaultGraphPreset.shades.light, ...overrides.shades?.light },
+            dark: { ...defaultGraphPreset.shades.dark, ...overrides.shades?.dark }
+        }
+    };
+}
+/**
+ * Resolves group names to CSS custom properties.
+ *
+ * Returns custom properties rather than concrete fills so a theme or an app can
+ * still override with one attribute rule — the JS decides the DEFAULT, never the
+ * final paint.
+ *
+ * Assignment is by SORTED group name so a group keeps its colour when `arrange`
+ * reorders the layout. Callers pass one name per NODE, so names are de-duplicated
+ * first; otherwise the ramp would advance per node and two nodes in the same group
+ * would disagree.
+ */
+export function resolveGroupStyles(groups, mode, preset = defaultGraphPreset) {
+    const styles = new Map();
+    const ordered = [...new Set(groups)].sort();
+    ordered.forEach((group, index) => {
+        if (preset.using === 'pattern') {
+            styles.set(group, { '--group-pattern': preset.patterns[index % preset.patterns.length] });
+            return;
+        }
+        const family = categoricalPalette[preset.groups[index % preset.groups.length]];
+        const shades = preset.shades[mode];
+        styles.set(group, {
+            '--group-fill': family[shades.fill],
+            '--group-stroke': family[shades.stroke],
+            '--group-label': family[shades.label]
+        });
+    });
+    return styles;
+}

package/dist/schema/EntitiesView.svelte

@@ -0,0 +1,83 @@
+<script lang="ts">
+	import { getContext, untrack } from 'svelte'
+	import { Table } from '@rokkit/ui'
+	import type { TableColumn } from '@rokkit/ui'
+	import { GraphState } from '../GraphState.svelte.js'
+	import type { EntityRow, GraphStateConfig } from '../GraphState.svelte.js'
+	import NoteBlocks from './NoteBlocks.svelte'
+	import type { GraphFields } from '../types.js'
+
+	let {
+		state: provided,
+		nodes = [],
+		edges = [],
+		fields = {},
+		caption = undefined,
+		class: className = ''
+	}: {
+		state?: GraphState
+		nodes?: unknown[]
+		edges?: unknown[]
+		fields?: GraphFields
+		caption?: string
+		class?: string
+	} = $props()
+
+	const config = (): GraphStateConfig => ({ nodes, edges, fields })
+
+	// untrack: the constructor's initial read must not become a dependency of the creating
+	// scope. Only built when this view is standalone — see the resolution order below.
+	const own = untrack(() => new GraphState(config()))
+	const fromContext = getContext<GraphState | undefined>('graph-state')
+
+	// Resolved ONCE, in the same three-way order Graph.svelte uses, so a view works inside a
+	// <Graph>, beside one, or alone: the prop wins, then context, then the state we build.
+	// svelte-ignore state_referenced_locally
+	const graph = provided ?? fromContext ?? own
+
+	// Only sync the state WE own. A prop- or context-supplied state is its owner's to drive.
+	$effect(() => {
+		if (graph === own) own.update(config())
+	})
+
+	const columns: TableColumn[] = [
+		{ name: 'label', label: 'Entity', snippet: 'entity' },
+		{ name: 'rowCount', label: 'Rows', align: 'right', snippet: 'rows' },
+		{ name: 'refCount', label: 'Refs', align: 'right', snippet: 'refs' },
+		{ name: 'note', label: 'Comment', sortable: false, snippet: 'comment' }
+	]
+</script>
+
+{#snippet entity(_value: unknown, _column: TableColumn, row: Record<string, unknown>)}
+	{@const item = row as unknown as EntityRow}
+	<span data-graph-entity data-graph-entity-kind={item.kind}>
+		{#if item.group}<span data-graph-entity-group>{item.group}.</span>{/if}<span
+			data-graph-entity-label>{item.label}</span
+		>
+	</span>
+{/snippet}
+
+{#snippet rows(_value: unknown, _column: TableColumn, row: Record<string, unknown>)}
+	<span data-graph-entity-rows>{(row as unknown as EntityRow).rowCount}</span>
+{/snippet}
+
+{#snippet refs(_value: unknown, _column: TableColumn, row: Record<string, unknown>)}
+	{@const count = (row as unknown as EntityRow).refCount}
+	<!-- The em dash is a PRESENTATION choice and belongs here: state reports the number 0,
+	     and a column of zeros reads as noise next to the counts that matter. -->
+	<span data-graph-entity-refs>{count > 0 ? count : '—'}</span>
+{/snippet}
+
+{#snippet comment(_value: unknown, _column: TableColumn, row: Record<string, unknown>)}
+	<NoteBlocks note={(row as unknown as EntityRow).note} />
+{/snippet}
+
+<Table
+	data={graph.entities}
+	{columns}
+	{caption}
+	class={className}
+	selectable="single"
+	onselect={(_value, row) => graph.select((row as unknown as EntityRow).id)}
+	snippets={{ entity, rows, refs, comment }}
+/>

package/dist/schema/EntitiesView.svelte.d.ts

@@ -0,0 +1,13 @@
+import { GraphState } from '../GraphState.svelte.js';
+import type { GraphFields } from '../types.js';
+type $$ComponentProps = {
+    state?: GraphState;
+    nodes?: unknown[];
+    edges?: unknown[];
+    fields?: GraphFields;
+    caption?: string;
+    class?: string;
+};
+declare const EntitiesView: import("svelte").Component<$$ComponentProps, {}, "">;
+type EntitiesView = ReturnType<typeof EntitiesView>;
+export default EntitiesView;

package/dist/schema/EntityView.svelte

@@ -0,0 +1,116 @@
+<script lang="ts">
+	import { getContext, untrack } from 'svelte'
+	import { GraphState } from '../GraphState.svelte.js'
+	import type { GraphStateConfig } from '../GraphState.svelte.js'
+	import NoteBlocks from './NoteBlocks.svelte'
+	import { baseType, typeSize } from './column-type.js'
+	import type { GraphFields } from '../types.js'
+
+	let {
+		state: provided,
+		nodes = [],
+		edges = [],
+		fields = {},
+		value = undefined,
+		class: className = ''
+	}: {
+		state?: GraphState
+		nodes?: unknown[]
+		edges?: unknown[]
+		fields?: GraphFields
+		value?: string | null
+		class?: string
+	} = $props()
+
+	const config = (): GraphStateConfig => ({ nodes, edges, fields, value })
+
+	const own = untrack(() => new GraphState(config()))
+	const fromContext = getContext<GraphState | undefined>('graph-state')
+
+	// Same three-way resolution as Graph and EntitiesView: prop, then context, then the state
+	// we build. Resolved once — context captures a value, not a getter.
+	// svelte-ignore state_referenced_locally
+	const graph = provided ?? fromContext ?? own
+
+	$effect(() => {
+		if (graph === own) own.update(config())
+	})
+
+	// A read, not a derivation: GraphState owns the in/out split and the meta passthrough.
+	const entity = $derived(graph.entity)
+	const indexes = $derived(
+		(entity?.meta.indexes ?? []) as { def: string; unique?: boolean; name?: string }[]
+	)
+</script>
+
+{#if entity}
+	<article data-graph-entity data-node-kind={entity.kind} class={className}>
+		<header data-graph-entity-head>
+			{#if entity.group}<span data-graph-entity-group>{entity.group}.</span>{/if}
+			<h2 data-graph-entity-title>{entity.label}</h2>
+			<span data-graph-entity-count>{entity.rows.length} columns</span>
+		</header>
+
+		{#if entity.note}
+			<section data-graph-section="note">
+				<h3 data-graph-section-title>Comment</h3>
+				<NoteBlocks note={entity.note} />
+			</section>
+		{/if}
+
+		<section data-graph-section="columns">
+			<h3 data-graph-section-title>Columns</h3>
+			{#each entity.rows as row (row.name)}
+				<div data-graph-column>
+					<span data-graph-column-name>{row.name}</span>
+					{#if row.note}<span data-graph-column-note>{row.note}</span>{/if}
+					<span data-graph-column-badges>
+						{#each row.badges as badge (badge)}
+							<span data-row-badge={badge}>{badge}</span>
+						{/each}
+					</span>
+					<span data-graph-column-type>{baseType(row.type ?? '')}</span>
+					<span data-graph-column-size>{typeSize(row.type ?? '')}</span>
+				</div>
+			{/each}
+		</section>
+
+		{#if indexes.length > 0}
+			<section data-graph-section="indexes">
+				<h3 data-graph-section-title>Indexes</h3>
+				{#each indexes as index, i (i)}
+					<div data-graph-index>
+						<span data-graph-index-def>{index.def}</span>
+						{#if index.unique}<span data-graph-index-unique>unique</span>{/if}
+						{#if index.name}<span data-graph-index-name>{index.name}</span>{/if}
+					</div>
+				{/each}
+			</section>
+		{/if}
+
+		<section data-graph-section="relationships">
+			<h3 data-graph-section-title>Relationships</h3>
+			{#if graph.relationships.length === 0}
+				<p data-graph-relationships-empty>No relationships reference this entity.</p>
+			{:else}
+				{#each graph.relationships as rel, i (rel.edge.id + i)}
+					<button
+						type="button"
+						data-graph-relationship={rel.direction}
+						onclick={() => graph.select(rel.id)}
+					>
+						{#if rel.group}<span data-graph-relationship-group>{rel.group}.</span>{/if}
+						<span data-graph-relationship-label>{rel.label}</span>
+						{#if rel.edge.action}
+							<span data-graph-relationship-action>{rel.edge.action}</span>
+						{/if}
+					</button>
+				{/each}
+			{/if}
+		</section>
+	</article>
+{:else}
+	<article data-graph-entity data-graph-entity-empty class={className}>
+		<p>No entity selected.</p>
+	</article>
+{/if}

package/dist/schema/EntityView.svelte.d.ts

@@ -0,0 +1,13 @@
+import { GraphState } from '../GraphState.svelte.js';
+import type { GraphFields } from '../types.js';
+type $$ComponentProps = {
+    state?: GraphState;
+    nodes?: unknown[];
+    edges?: unknown[];
+    fields?: GraphFields;
+    value?: string | null;
+    class?: string;
+};
+declare const EntityView: import("svelte").Component<$$ComponentProps, {}, "">;
+type EntityView = ReturnType<typeof EntityView>;
+export default EntityView;

package/dist/schema/NoteBlocks.svelte

@@ -0,0 +1,31 @@
+<script lang="ts">
+	import { noteBlocks } from './notes.js'
+
+	let { note }: { note?: string } = $props()
+
+	const blocks = $derived(noteBlocks(note))
+</script>
+
+{#snippet segs(parts: ReturnType<typeof noteBlocks>[number]['lines'][number])}
+	<!-- Keyed by INDEX, not by text. A segment has no identity of its own, and its text is
+	     not unique — "either `a` or `a`" yields two code segments reading `a`, which throws
+	     each_key_duplicate and renders nothing. Position is the only stable key here, and
+	     the whole list is re-derived whenever the note changes. -->
+	{#each parts as part, i (i)}
+		{#if part.code}<code data-graph-note-code>{part.text}</code>{:else}{part.text}{/if}
+	{/each}
+{/snippet}
+
+<div data-graph-note>
+	{#each blocks as block (block)}
+		{#if block.type === 'ul'}
+			<ul data-graph-note-list>
+				{#each block.lines as line (line)}
+					<li>{@render segs(line)}</li>
+				{/each}
+			</ul>
+		{:else}
+			<p>{@render segs(block.lines[0])}</p>
+		{/if}
+	{/each}
+</div>

package/dist/schema/NoteBlocks.svelte.d.ts

@@ -0,0 +1,6 @@
+type $$ComponentProps = {
+    note?: string;
+};
+declare const NoteBlocks: import("svelte").Component<$$ComponentProps, {}, "">;
+type NoteBlocks = ReturnType<typeof NoteBlocks>;
+export default NoteBlocks;

package/dist/schema/column-type.d.ts

@@ -0,0 +1,4 @@
+/** `varchar(255)` -> `varchar`, `text[]` -> `text`. */
+export declare function baseType(type: string): string;
+/** `varchar(255)` -> `255`, `text[]` -> `[]`, `uuid` -> an em dash. */
+export declare function typeSize(type: string): string;

package/dist/schema/column-type.js

@@ -0,0 +1,19 @@
+/* Splitting a SQL type into its base and its size, for the two-column display in the
+   entity detail panel. Ported from dbd's EntityView module block.
+
+   Parsing, not formatting choice, so it lives here with its own tests rather than inline
+   in the template — the component stays free of computation. */
+const ARG = /\(([^)]*)\)/;
+/** `varchar(255)` -> `varchar`, `text[]` -> `text`. */
+export function baseType(type) {
+    return type.replace(ARG, '').replace(/\[\]$/, '');
+}
+/** `varchar(255)` -> `255`, `text[]` -> `[]`, `uuid` -> an em dash. */
+export function typeSize(type) {
+    const matched = type.match(ARG);
+    if (matched)
+        return matched[1];
+    if (type.endsWith('[]'))
+        return '[]';
+    return '—';
+}

package/dist/schema/fromSchemaModel.d.ts

@@ -0,0 +1,66 @@
+import type { GraphFields, GraphModel } from '../types.js';
+/**
+ * Field map from a dbd `SchemaModel`'s ER half to the canonical model.
+ *
+ * Exported so a consumer can hand it straight to `<Graph fields={SCHEMA_FIELDS}>`
+ * and skip the transform entirely.
+ *
+ * Note what is NOT here: dbd's `SchemaModel` type. The package never imports it,
+ * so the hand-written TS mirror of `schema_model.rs` stays dbd's concern and this
+ * package is not a third definition to keep in step.
+ *
+ * One canonical field stays deliberately unmapped, because dbd's shape does not carry it and
+ * a path that cannot resolve looks correct while silently never firing:
+ *
+ * - `cardinality` — dbd's `Ref` is `{ from, to, action? }`.
+ */
+export declare const SCHEMA_FIELDS: GraphFields;
+/**
+ * Field map for a dbd v2 `DepEdge` — `{ from: { s, n }, to: { s, n }, kind, unresolved }`.
+ *
+ * `n` not `t`, and no `c`: a dependency links whole objects, not columns. `kind` is the VERB
+ * (`reads | writes | calls | member`), which is why it maps to `relation` and the edge kind
+ * comes from `defaultEdgeKind` instead — every entry in `deps` is a dependency by definition.
+ */
+export declare const DEPS_FIELDS: GraphFields;
+/**
+ * Which of a `SchemaModel`'s two graphs to build.
+ *
+ * dbd v2 splits the database in two and says so in its own doc comments: `tables` is "Tables
+ * only", `refs` is "Foreign keys only — the dependency graph is `deps`; an ER renderer wants
+ * these and a call-graph renderer wants those".
+ *
+ * That split is a modelling fact, not a rendering preference. An ER diagram is entities and
+ * their relationships; a view is a derived projection and a routine is behaviour, so neither
+ * is an entity and putting them on an ER canvas is a category error — they have no keys, no
+ * relationships, and (in v2) no columns, so they render as orphan cards with nothing in them.
+ *
+ * - `er` — `tables` + `refs`. The default, so a v1 caller reading a v2 model is unaffected.
+ * - `dependencies` — `tables` + `entities` as nodes, `deps` as edges. Tables stay because a
+ *   view READS a table; dropping them would leave every dependency dangling.
+ */
+export type SchemaScope = 'er' | 'dependencies';
+/** The minimum of dbd's `SchemaModel` this view reads. v2 fields are optional. */
+type SchemaModelInput = {
+    tables: unknown[];
+    refs: unknown[];
+    entities?: unknown[];
+    deps?: unknown[];
+};
+/**
+ * Consumer-side input for one scope: `nodes`, `edges` and the matching field map.
+ *
+ * Returned separately from `fromSchemaModel` because `<Graph>` takes `nodes`/`edges`/`fields`
+ * directly — a consumer binding the component does not want a pre-normalized model, and
+ * making them unpack one would mean normalizing twice.
+ */
+export declare function toGraphInput(model: SchemaModelInput, scope?: SchemaScope): {
+    nodes: unknown[];
+    edges: unknown[];
+    fields: GraphFields;
+};
+/** Convenience wrapper over `normalizeGraph` for dbd-shaped schema JSON. */
+export declare function fromSchemaModel(model: SchemaModelInput, options?: {
+    as?: SchemaScope;
+}): GraphModel;
+export {};

package/dist/schema/fromSchemaModel.js

@@ -0,0 +1,92 @@
+import { normalizeGraph } from '../model/normalize.js';
+/**
+ * Field map from a dbd `SchemaModel`'s ER half to the canonical model.
+ *
+ * Exported so a consumer can hand it straight to `<Graph fields={SCHEMA_FIELDS}>`
+ * and skip the transform entirely.
+ *
+ * Note what is NOT here: dbd's `SchemaModel` type. The package never imports it,
+ * so the hand-written TS mirror of `schema_model.rs` stays dbd's concern and this
+ * package is not a third definition to keep in step.
+ *
+ * One canonical field stays deliberately unmapped, because dbd's shape does not carry it and
+ * a path that cannot resolve looks correct while silently never firing:
+ *
+ * - `cardinality` — dbd's `Ref` is `{ from, to, action? }`.
+ */
+export const SCHEMA_FIELDS = {
+    // Identity must NOT be derived from the group, or regrouping re-keys every node. `id`
+    // defaults to `${group}.${label}`, so a consumer switching the axis to `kind` would turn
+    // `public.orders` into `table.orders` and every dep edge — which resolves
+    // `${from.s}.${name}` — would stop matching and the graph would render entirely unplaced.
+    // Safe for a consumer passing raw dbd rows too: a row with no `id` falls back as before.
+    id: 'id',
+    label: 'name',
+    group: 'schema',
+    kind: 'kind',
+    rows: 'columns',
+    note: 'noteMd',
+    rowName: 'name',
+    rowType: 'type',
+    rowNote: 'note',
+    // v2 (2026-09-27) added `fk` and `uq` to `Column`. `fk` is ALSO derived from the resolved
+    // refs; both are kept because they answer different questions — dbd resolved the
+    // constraint against the whole database, so a column referencing a table outside a scoped
+    // model is still honestly a foreign key even though no edge in this model proves it.
+    rowBadges: { pk: 'pk', nn: 'nn', fk: 'fk', uq: 'uq' },
+    source: 'from.t',
+    target: 'to.t',
+    sourceGroup: 'from.s',
+    targetGroup: 'to.s',
+    sourceRow: 'from.c',
+    targetRow: 'to.c',
+    action: 'action'
+};
+/**
+ * Field map for a dbd v2 `DepEdge` — `{ from: { s, n }, to: { s, n }, kind, unresolved }`.
+ *
+ * `n` not `t`, and no `c`: a dependency links whole objects, not columns. `kind` is the VERB
+ * (`reads | writes | calls | member`), which is why it maps to `relation` and the edge kind
+ * comes from `defaultEdgeKind` instead — every entry in `deps` is a dependency by definition.
+ */
+export const DEPS_FIELDS = {
+    ...SCHEMA_FIELDS,
+    source: 'from.n',
+    target: 'to.n',
+    sourceGroup: 'from.s',
+    targetGroup: 'to.s',
+    sourceRow: undefined,
+    targetRow: undefined,
+    action: undefined,
+    relation: 'kind',
+    defaultEdgeKind: 'dependency'
+};
+/** A dbd node row, with the canonical id made explicit so the grouping axis stays free. */
+function identified(rows) {
+    return rows.map((row) => {
+        const r = (row ?? {});
+        return { ...r, id: r.schema ? `${r.schema}.${r.name}` : String(r.name ?? '') };
+    });
+}
+/**
+ * Consumer-side input for one scope: `nodes`, `edges` and the matching field map.
+ *
+ * Returned separately from `fromSchemaModel` because `<Graph>` takes `nodes`/`edges`/`fields`
+ * directly — a consumer binding the component does not want a pre-normalized model, and
+ * making them unpack one would mean normalizing twice.
+ */
+export function toGraphInput(model, scope = 'er') {
+    if (scope === 'er') {
+        return { nodes: identified(model.tables), edges: model.refs, fields: SCHEMA_FIELDS };
+    }
+    return {
+        nodes: identified([...model.tables, ...(model.entities ?? [])]),
+        edges: model.deps ?? [],
+        fields: DEPS_FIELDS
+    };
+}
+/** Convenience wrapper over `normalizeGraph` for dbd-shaped schema JSON. */
+export function fromSchemaModel(model, options = {}) {
+    const { nodes, edges, fields } = toGraphInput(model, options.as ?? 'er');
+    return normalizeGraph(nodes, edges, fields);
+}

package/dist/schema/index.d.ts

@@ -0,0 +1,8 @@
+export { default as EntityView } from './EntityView.svelte';
+export { default as EntitiesView } from './EntitiesView.svelte';
+export { default as NoteBlocks } from './NoteBlocks.svelte';
+export { SCHEMA_FIELDS, DEPS_FIELDS, fromSchemaModel, toGraphInput } from './fromSchemaModel.js';
+export type { SchemaScope } from './fromSchemaModel.js';
+export { inlineSegs, noteBlocks } from './notes.js';
+export { baseType, typeSize } from './column-type.js';
+export type { Block, Seg } from './notes.js';

package/dist/schema/index.js

@@ -0,0 +1,7 @@
+// Public surface for `@rokkit/graph/schema` — the ER/schema-flavoured views.
+export { default as EntityView } from './EntityView.svelte';
+export { default as EntitiesView } from './EntitiesView.svelte';
+export { default as NoteBlocks } from './NoteBlocks.svelte';
+export { SCHEMA_FIELDS, DEPS_FIELDS, fromSchemaModel, toGraphInput } from './fromSchemaModel.js';
+export { inlineSegs, noteBlocks } from './notes.js';
+export { baseType, typeSize } from './column-type.js';

package/dist/schema/notes.d.ts

@@ -0,0 +1,12 @@
+export type Seg = {
+    code: boolean;
+    text: string;
+};
+export type Block = {
+    type: 'p' | 'ul';
+    lines: Seg[][];
+};
+/** Split a line into plain / `code` segments. */
+export declare function inlineSegs(text: string): Seg[];
+/** Parse a note string into paragraph / bullet-list blocks. */
+export declare function noteBlocks(src?: string): Block[];

package/dist/schema/notes.js

@@ -0,0 +1,65 @@
+/* Minimal note renderer for DDL comments: paragraphs, bullet lists, and `inline code`.
+   Shared by EntitiesView and EntityView so they format comments identically. Returns a
+   structured tree the components render.
+
+   Deliberately NOT a markdown library. It recognises backticks and bullets and nothing
+   else, so no tag is ever interpreted — the segment text carries any markup verbatim and
+   Svelte's text interpolation escapes it at render time. That is what lets this package
+   ship with no markdown parser and no sanitiser, which are exactly the dependencies
+   @rokkit/ui's MarkdownRenderer would have dragged in. */
+const BULLET = /^[-•]\s/;
+/** Split a line into plain / `code` segments. */
+export function inlineSegs(text) {
+    const segs = [];
+    let last = 0;
+    for (const m of text.matchAll(/`([^`]+)`/g)) {
+        const idx = m.index ?? 0;
+        if (idx > last)
+            segs.push({ code: false, text: text.slice(last, idx) });
+        segs.push({ code: true, text: m[1] });
+        last = idx + m[0].length;
+    }
+    if (last < text.length)
+        segs.push({ code: false, text: text.slice(last) });
+    return segs;
+}
+/** Consume a run of bullet lines starting at `i`, returning the block and the next index. */
+function takeList(lines, start) {
+    const items = [];
+    let i = start;
+    while (i < lines.length && BULLET.test(lines[i].trim())) {
+        items.push(inlineSegs(lines[i].trim().replace(BULLET, '')));
+        i++;
+    }
+    return { block: { type: 'ul', lines: items }, next: i };
+}
+/** Consume a run of non-blank, non-bullet lines as one paragraph. */
+function takeParagraph(lines, start) {
+    const para = [];
+    let i = start;
+    while (i < lines.length && lines[i].trim() && !BULLET.test(lines[i].trim())) {
+        para.push(lines[i].trim());
+        i++;
+    }
+    return { block: { type: 'p', lines: [inlineSegs(para.join(' '))] }, next: i };
+}
+/** Parse a note string into paragraph / bullet-list blocks. */
+export function noteBlocks(src) {
+    if (!src)
+        return [];
+    const out = [];
+    const lines = src.split('\n');
+    let i = 0;
+    while (i < lines.length) {
+        if (!lines[i].trim()) {
+            i++;
+            continue;
+        }
+        const { block, next } = BULLET.test(lines[i].trim())
+            ? takeList(lines, i)
+            : takeParagraph(lines, i);
+        out.push(block);
+        i = next;
+    }
+    return out;
+}