@texuli/blocks 0.0.0-stage → 0.1.0-next.0

package/dist/code/languages/shared.js

@@ -0,0 +1,37 @@
+import { sticky } from "../tokenizer.js";
+/**
+ * Rules several grammars share. Each opening delimiter always matches: an
+ * unterminated single-line string ends at its line break (`$` with the `m`
+ * flag), an unterminated block comment or multi-line string at the end of
+ * the input (`$` without it). See tokenizer.ts for why that keeps scanning
+ * linear.
+ */
+export const WHITESPACE = { re: sticky(String.raw `[ \t\r\n]+`), kind: 'plain' };
+/** `"…"` on one line, with backslash escapes. */
+export const DOUBLE_QUOTED = {
+    re: sticky(String.raw `"(?:[^"\\\n]|\\.?)*(?:"|$)`),
+    kind: 'string',
+};
+/** `'…'` on one line, with backslash escapes. */
+export const SINGLE_QUOTED = {
+    re: sticky(String.raw `'(?:[^'\\\n]|\\.?)*(?:'|$)`),
+    kind: 'string',
+};
+/** `/* … *\/`, possibly across lines. */
+export const BLOCK_COMMENT = {
+    re: sticky(String.raw `\/\*[\s\S]*?(?:\*\/|(?![\s\S]))`),
+    kind: 'comment',
+};
+/** `// …` to the end of the line. */
+export const SLASH_COMMENT = { re: sticky(String.raw `\/\/[^\n]*`), kind: 'comment' };
+/** `# …` at a line start or after whitespace (not `$#` or `a#b`). */
+export const HASH_COMMENT = {
+    re: sticky(String.raw `(?<=^|[ \t;|&(])#[^\n]*`),
+    kind: 'comment',
+};
+/** Decimal, hex, octal and binary numbers with `_` separators and exponents. */
+export const C_NUMBER = {
+    re: sticky(String.raw `0[xX][\da-fA-F_]+n?|0[bB][01_]+n?|0[oO][0-7_]+n?|\d[\d_]*(?:\.\d[\d_]*)?(?:[eE][+-]?\d+)?n?|\.\d[\d_]*(?:[eE][+-]?\d+)?`),
+    kind: 'number',
+};
+export const words = (...list) => new Set(list);

package/dist/code/languages/sql.d.ts

@@ -0,0 +1,3 @@
+import { type Grammar } from '../tokenizer.js';
+/** Standard SQL with the common Postgres and SQLite spellings. */
+export declare const sqlGrammar: Grammar;

package/dist/code/languages/sql.js

@@ -0,0 +1,32 @@
+import { classifyWord, sticky } from "../tokenizer.js";
+import { BLOCK_COMMENT, C_NUMBER, WHITESPACE, words } from "./shared.js";
+const word = classifyWord({
+    ignoreCase: true,
+    keywords: words('add', 'all', 'alter', 'and', 'as', 'asc', 'begin', 'between', 'by', 'case', 'commit', 'constraint', 'create', 'cross', 'default', 'delete', 'desc', 'distinct', 'drop', 'else', 'end', 'exists', 'foreign', 'from', 'full', 'group', 'having', 'if', 'in', 'index', 'inner', 'insert', 'into', 'is', 'join', 'key', 'left', 'like', 'limit', 'not', 'offset', 'on', 'or', 'order', 'outer', 'primary', 'references', 'returning', 'right', 'rollback', 'select', 'set', 'table', 'then', 'transaction', 'union', 'unique', 'update', 'values', 'view', 'when', 'where', 'with'),
+    constants: words('null', 'true', 'false'),
+    builtins: words('avg', 'cast', 'coalesce', 'count', 'lower', 'max', 'min', 'now', 'sum', 'upper'),
+    types: words('bigint', 'boolean', 'char', 'date', 'decimal', 'float', 'int', 'integer', 'json', 'jsonb', 'numeric', 'real', 'serial', 'text', 'timestamp', 'timestamptz', 'uuid', 'varchar'),
+});
+/** Standard SQL with the common Postgres and SQLite spellings. */
+export const sqlGrammar = {
+    name: 'sql',
+    start: 'code',
+    states: {
+        code: [
+            WHITESPACE,
+            { re: sticky(String.raw `--[^\n]*`), kind: 'comment' },
+            BLOCK_COMMENT,
+            // '' escapes a quote; strings may span lines.
+            { re: sticky(String.raw `'(?:[^']|'')*(?:'|(?![\s\S]))`), kind: 'string' },
+            {
+                re: sticky(String.raw `"(?:[^"]|"")*(?:"|(?![\s\S]))|\x60[^\x60\n]*\x60?`),
+                kind: 'property',
+            },
+            { re: sticky(String.raw `\$\d+|[:@][A-Za-z_]\w*|\?`), kind: 'variable' },
+            { re: sticky(String.raw `[A-Za-z_]\w*`), kind: word },
+            C_NUMBER,
+            { re: sticky(String.raw `[<>=!|+\-*/%]+`), kind: 'operator' },
+            { re: sticky('[(),;.]'), kind: 'punctuation' },
+        ],
+    },
+};

package/dist/code/languages/yaml.d.ts

@@ -0,0 +1,7 @@
+import { type Grammar } from '../tokenizer.js';
+/**
+ * YAML: keys, scalars, anchors, tags, comments and document markers. A key is
+ * only looked for after a line's indentation (and an optional `- `), so each
+ * line is scanned for a key once.
+ */
+export declare const yamlGrammar: Grammar;

package/dist/code/languages/yaml.js

@@ -0,0 +1,36 @@
+import { sticky } from "../tokenizer.js";
+import { WHITESPACE, words } from "./shared.js";
+const CONSTANTS = words('true', 'false', 'yes', 'no', 'on', 'off', 'null', 'True', 'False', 'Null', 'TRUE', 'FALSE', 'NULL', '~');
+/**
+ * YAML: keys, scalars, anchors, tags, comments and document markers. A key is
+ * only looked for after a line's indentation (and an optional `- `), so each
+ * line is scanned for a key once.
+ */
+export const yamlGrammar = {
+    name: 'yaml',
+    start: 'code',
+    states: {
+        code: [
+            WHITESPACE,
+            { re: sticky(String.raw `(?<=^|[ \t])#[^\n]*`), kind: 'comment' },
+            { re: sticky(String.raw `^(?:---|\.\.\.)(?=[ \t]|$)`), kind: 'punctuation' },
+            {
+                re: sticky(String.raw `(?<=^[ \t]*(?:-[ \t]+)?)(?:"[^"\n]*"|'[^'\n]*'|[^\s#'"\-?:,[\]{}][^\n#]*?)(?=:(?:[ \t]|$))`),
+                kind: 'property',
+            },
+            { re: sticky(String.raw `"(?:[^"\\\n]|\\.?)*(?:"|$)`), kind: 'string' },
+            { re: sticky(String.raw `'(?:[^'\n]|'')*(?:'|$)`), kind: 'string' },
+            { re: sticky(String.raw `[&*][\w-]+`), kind: 'variable' },
+            { re: sticky(String.raw `![\w!/.-]*`), kind: 'type' },
+            {
+                re: sticky(String.raw `[-+]?(?:\d[\d_]*(?:\.\d*)?(?:[eE][+-]?\d+)?|\.(?:inf|nan|Inf|NaN))(?![\w.-])`),
+                kind: 'number',
+            },
+            {
+                re: sticky(String.raw `[A-Za-z_~][\w.~-]*`),
+                kind: (text) => (CONSTANTS.has(text) ? 'constant' : 'plain'),
+            },
+            { re: sticky(String.raw `[:{}[\],?|>-]`), kind: 'punctuation' },
+        ],
+    },
+};

package/dist/code/renderers.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Eager entry for hosts that render code blocks on first paint. Most hosts
+ * should prefer `loadCodeFamily()` from `@texuli/blocks` (lazy chunk).
+ */
+export { default as CodeBlockView } from './CodeBlockView.svelte';

package/dist/code/renderers.js

@@ -0,0 +1,5 @@
+/**
+ * Eager entry for hosts that render code blocks on first paint. Most hosts
+ * should prefer `loadCodeFamily()` from `@texuli/blocks` (lazy chunk).
+ */
+export { default as CodeBlockView } from './CodeBlockView.svelte';

package/dist/code/token-styles.d.ts

@@ -0,0 +1,25 @@
+import type { CodeTokenKind } from './tokenizer.js';
+/**
+ * Theme roles a token kind may be drawn in. Each one reaches WCAG AA (4.5:1)
+ * as text on `surface` (the code background) and on `muted` (a highlighted
+ * line) in every library theme, light and dark; `code.test.ts` checks all of
+ * them. `secondary` and `accent` are fills, never text, so they are not used.
+ */
+export declare const CODE_COLOR_ROLES: readonly ["surfaceForeground", "mutedForeground", "primary", "success", "info", "destructive"];
+export type CodeColorRole = (typeof CODE_COLOR_ROLES)[number];
+export interface CodeTokenStyle {
+    color: CodeColorRole;
+    /** A non-color cue, so kinds differ without color too. */
+    emphasis?: 'bold' | 'italic';
+}
+/** One style per token kind; keywords and tags are also bold, comments italic. */
+export declare const CODE_TOKEN_STYLES: Readonly<Record<CodeTokenKind, CodeTokenStyle>>;
+/** The CSS class of a token kind (`tx-code-tok--keyword`); plain text has none. */
+export declare function codeTokenClass(kind: CodeTokenKind): string | undefined;
+/**
+ * Which highlight step a block shows. An explicit `step` wins. Otherwise a
+ * host step (a deck fragment index) counts from the block's own `blockStep`:
+ * host step `blockStep + i` shows step `i`, clamped to the first and last.
+ * With neither, the first step shows as static emphasis. `-1` means none.
+ */
+export declare function activeHighlightIndex(stepCount: number, step: number | undefined, hostStep?: number, blockStep?: number): number;

package/dist/code/token-styles.js

@@ -0,0 +1,51 @@
+/**
+ * Theme roles a token kind may be drawn in. Each one reaches WCAG AA (4.5:1)
+ * as text on `surface` (the code background) and on `muted` (a highlighted
+ * line) in every library theme, light and dark; `code.test.ts` checks all of
+ * them. `secondary` and `accent` are fills, never text, so they are not used.
+ */
+export const CODE_COLOR_ROLES = [
+    'surfaceForeground',
+    'mutedForeground',
+    'primary',
+    'success',
+    'info',
+    'destructive',
+];
+/** One style per token kind; keywords and tags are also bold, comments italic. */
+export const CODE_TOKEN_STYLES = Object.freeze({
+    plain: { color: 'surfaceForeground' },
+    punctuation: { color: 'surfaceForeground' },
+    operator: { color: 'surfaceForeground' },
+    variable: { color: 'surfaceForeground' },
+    property: { color: 'surfaceForeground' },
+    keyword: { color: 'primary', emphasis: 'bold' },
+    tag: { color: 'primary', emphasis: 'bold' },
+    string: { color: 'success' },
+    attr: { color: 'success' },
+    number: { color: 'destructive' },
+    constant: { color: 'destructive' },
+    function: { color: 'info' },
+    type: { color: 'info' },
+    comment: { color: 'mutedForeground', emphasis: 'italic' },
+});
+/** The CSS class of a token kind (`tx-code-tok--keyword`); plain text has none. */
+export function codeTokenClass(kind) {
+    return kind === 'plain' ? undefined : `tx-code-tok--${kind}`;
+}
+/**
+ * Which highlight step a block shows. An explicit `step` wins. Otherwise a
+ * host step (a deck fragment index) counts from the block's own `blockStep`:
+ * host step `blockStep + i` shows step `i`, clamped to the first and last.
+ * With neither, the first step shows as static emphasis. `-1` means none.
+ */
+export function activeHighlightIndex(stepCount, step, hostStep, blockStep = 0) {
+    if (stepCount <= 0)
+        return -1;
+    const clamp = (value) => Math.min(stepCount - 1, Math.max(0, Math.floor(value)));
+    if (step !== undefined && Number.isFinite(step))
+        return clamp(step);
+    if (hostStep !== undefined && Number.isFinite(hostStep))
+        return clamp(hostStep - blockStep);
+    return 0;
+}

package/dist/code/tokenize-code.d.ts

@@ -0,0 +1,17 @@
+import { bashGrammar } from './languages/bash.js';
+import { cssGrammar } from './languages/css.js';
+import { htmlGrammar } from './languages/html.js';
+import { javascriptGrammar, typescriptGrammar } from './languages/javascript.js';
+import { jsonGrammar } from './languages/json.js';
+import { pythonGrammar } from './languages/python.js';
+import { sqlGrammar } from './languages/sql.js';
+import { yamlGrammar } from './languages/yaml.js';
+import { type CodeToken } from './tokenizer.js';
+/**
+ * Tokenizes `code` for `lang` (an id or alias) with every grammar bundled, for
+ * servers, tests and tools. Renderers use `loadCodeGrammar` + `tokenize`, which
+ * load one grammar on demand. Unknown languages, including `text`, give one
+ * plain token. Concatenated texts always equal the input.
+ */
+export declare function tokenizeCode(code: string, lang: string): CodeToken[];
+export { bashGrammar, cssGrammar, htmlGrammar, javascriptGrammar, jsonGrammar, pythonGrammar, sqlGrammar, typescriptGrammar, yamlGrammar, };

package/dist/code/tokenize-code.js

@@ -0,0 +1,34 @@
+import { resolveCodeLanguage } from "./grammars.js";
+import { bashGrammar } from "./languages/bash.js";
+import { cssGrammar } from "./languages/css.js";
+import { htmlGrammar } from "./languages/html.js";
+import { javascriptGrammar, typescriptGrammar } from "./languages/javascript.js";
+import { jsonGrammar } from "./languages/json.js";
+import { pythonGrammar } from "./languages/python.js";
+import { sqlGrammar } from "./languages/sql.js";
+import { yamlGrammar } from "./languages/yaml.js";
+import { tokenize } from "./tokenizer.js";
+const GRAMMARS = {
+    ts: typescriptGrammar,
+    js: javascriptGrammar,
+    json: jsonGrammar,
+    bash: bashGrammar,
+    python: pythonGrammar,
+    html: htmlGrammar,
+    css: cssGrammar,
+    sql: sqlGrammar,
+    yaml: yamlGrammar,
+};
+/**
+ * Tokenizes `code` for `lang` (an id or alias) with every grammar bundled, for
+ * servers, tests and tools. Renderers use `loadCodeGrammar` + `tokenize`, which
+ * load one grammar on demand. Unknown languages, including `text`, give one
+ * plain token. Concatenated texts always equal the input.
+ */
+export function tokenizeCode(code, lang) {
+    const resolved = resolveCodeLanguage(lang);
+    if (resolved === null)
+        return code === '' ? [] : [{ kind: 'plain', text: code }];
+    return tokenize(code, GRAMMARS[resolved]);
+}
+export { bashGrammar, cssGrammar, htmlGrammar, javascriptGrammar, jsonGrammar, pythonGrammar, sqlGrammar, typescriptGrammar, yamlGrammar, };

package/dist/code/tokenizer.d.ts

@@ -0,0 +1,76 @@
+/**
+ * A tiny, linear-time code tokenizer. A grammar is a small state machine of
+ * sticky regular expressions; at each position the first rule that matches
+ * wins, and text no rule claims becomes `plain`. Tokens are data
+ * (`{ kind, text }`) that renderers map to theme-token classes: nothing is
+ * ever turned into HTML.
+ *
+ * Linear time comes from how the grammars are written, and the tests hold
+ * them to it with pathological inputs:
+ *
+ * - every rule starts with a distinctive character and consumes at least one;
+ * - an opening delimiter always matches: an unterminated string runs to the
+ *   end of its line, and an unterminated block comment or multi-line string
+ *   runs to the end of the input, so no position is scanned twice;
+ * - no rule nests quantifiers over overlapping alternatives;
+ * - keywords are looked up in sets after matching a word, never by a long
+ *   alternation.
+ */
+export declare const CODE_TOKEN_KINDS: readonly ["plain", "keyword", "string", "number", "comment", "operator", "punctuation", "function", "type", "property", "constant", "variable", "tag", "attr"];
+export type CodeTokenKind = (typeof CODE_TOKEN_KINDS)[number];
+export interface CodeToken {
+    kind: CodeTokenKind;
+    text: string;
+}
+/** Characters tokenized per call; the rest is returned as one plain token. */
+export declare const CODE_TOKENIZE_MAX_LENGTH = 20000;
+/** What a classifier knows about the match. */
+export interface RuleContext {
+    input: string;
+    /** Index just after the match. */
+    end: number;
+    /** The previous token that is not whitespace, if any. */
+    prev: CodeToken | null;
+}
+export interface GrammarRule {
+    /** Built with `sticky`; must not match the empty string or capture groups. */
+    re: RegExp;
+    kind: CodeTokenKind | ((text: string, ctx: RuleContext) => CodeTokenKind);
+    /** State to switch to after this rule matches. */
+    next?: string;
+}
+export interface Grammar {
+    /** Language id, for diagnostics and tests. */
+    name: string;
+    start: string;
+    states: Readonly<Record<string, readonly GrammarRule[]>>;
+}
+/**
+ * Rule regex from a source string; every grammar builds rules with it. All
+ * rules share the `m` flag (`^`/`$` are line anchors; write end of input as
+ * `(?![\s\S])`) so a state's rules compile into one alternation.
+ */
+export declare function sticky(source: string): RegExp;
+/** The next character after `index` that is not a space or tab (bounded lookahead). */
+export declare function nextNonBlank(input: string, index: number): string;
+export interface WordSets {
+    keywords?: ReadonlySet<string>;
+    builtins?: ReadonlySet<string>;
+    constants?: ReadonlySet<string>;
+    types?: ReadonlySet<string>;
+    /** Words after which the next word names a type (`class`, `interface`…). */
+    typeIntroducers?: ReadonlySet<string>;
+    /** Words after which the next word names a function (`function`, `def`). */
+    functionIntroducers?: ReadonlySet<string>;
+    /** Case-insensitive lookup (SQL). */
+    ignoreCase?: boolean;
+}
+/** A classifier for identifiers: set lookups plus a little context. */
+export declare function classifyWord(sets: WordSets): (text: string, ctx: RuleContext) => CodeTokenKind;
+/**
+ * Tokenizes `code` with `grammar`. The concatenated token texts always equal
+ * the input. Input beyond `CODE_TOKENIZE_MAX_LENGTH` is one plain token.
+ */
+export declare function tokenize(code: string, grammar: Grammar): CodeToken[];
+/** Splits tokens into lines; line breaks are dropped, empty lines are `[]`. */
+export declare function splitTokenLines(tokens: readonly CodeToken[]): CodeToken[][];

package/dist/code/tokenizer.js

@@ -0,0 +1,171 @@
+/**
+ * A tiny, linear-time code tokenizer. A grammar is a small state machine of
+ * sticky regular expressions; at each position the first rule that matches
+ * wins, and text no rule claims becomes `plain`. Tokens are data
+ * (`{ kind, text }`) that renderers map to theme-token classes: nothing is
+ * ever turned into HTML.
+ *
+ * Linear time comes from how the grammars are written, and the tests hold
+ * them to it with pathological inputs:
+ *
+ * - every rule starts with a distinctive character and consumes at least one;
+ * - an opening delimiter always matches: an unterminated string runs to the
+ *   end of its line, and an unterminated block comment or multi-line string
+ *   runs to the end of the input, so no position is scanned twice;
+ * - no rule nests quantifiers over overlapping alternatives;
+ * - keywords are looked up in sets after matching a word, never by a long
+ *   alternation.
+ */
+export const CODE_TOKEN_KINDS = [
+    'plain',
+    'keyword',
+    'string',
+    'number',
+    'comment',
+    'operator',
+    'punctuation',
+    'function',
+    'type',
+    'property',
+    'constant',
+    'variable',
+    'tag',
+    'attr',
+];
+/** Characters tokenized per call; the rest is returned as one plain token. */
+export const CODE_TOKENIZE_MAX_LENGTH = 20_000;
+/**
+ * Rule regex from a source string; every grammar builds rules with it. All
+ * rules share the `m` flag (`^`/`$` are line anchors; write end of input as
+ * `(?![\s\S])`) so a state's rules compile into one alternation.
+ */
+export function sticky(source) {
+    return new RegExp(source, 'my');
+}
+const LOOKAHEAD = 64;
+/** The next character after `index` that is not a space or tab (bounded lookahead). */
+export function nextNonBlank(input, index) {
+    const limit = Math.min(input.length, index + LOOKAHEAD);
+    for (let i = index; i < limit; i += 1) {
+        const char = input[i];
+        if (char !== ' ' && char !== '\t')
+            return char;
+    }
+    return '';
+}
+/** A classifier for identifiers: set lookups plus a little context. */
+export function classifyWord(sets) {
+    return (text, ctx) => {
+        const word = sets.ignoreCase ? text.toLowerCase() : text;
+        const prev = ctx.prev?.text;
+        if (prev === '.' || prev === '?.')
+            return 'property';
+        if (prev !== undefined && sets.functionIntroducers?.has(prev))
+            return 'function';
+        if (prev !== undefined && sets.typeIntroducers?.has(prev))
+            return 'type';
+        if (sets.keywords?.has(word))
+            return 'keyword';
+        if (sets.constants?.has(word))
+            return 'constant';
+        if (sets.types?.has(word))
+            return 'type';
+        if (nextNonBlank(ctx.input, ctx.end) === '(')
+            return 'function';
+        if (sets.builtins?.has(word))
+            return 'function';
+        return 'plain';
+    };
+}
+function push(tokens, kind, text) {
+    if (text === '')
+        return;
+    const last = tokens[tokens.length - 1];
+    if (last && last.kind === kind)
+        last.text += text;
+    else
+        tokens.push({ kind, text });
+}
+const compiled = new WeakMap();
+function captureGroups(source) {
+    return new RegExp(`${source}|`).exec('').length - 1;
+}
+/**
+ * Compiles a state once per grammar. One `exec` per position replaces one per
+ * rule, and alternation order keeps the first-rule-wins semantics.
+ */
+function compileState(grammar, state) {
+    let states = compiled.get(grammar);
+    if (!states) {
+        states = new Map();
+        compiled.set(grammar, states);
+    }
+    const cached = states.get(state);
+    if (cached)
+        return cached;
+    const rules = grammar.states[state] ?? [];
+    for (const rule of rules) {
+        if (captureGroups(rule.re.source) > 0) {
+            throw new Error(`${grammar.name}.${state}: use (?:…) instead of capture groups in ${rule.re.source}`);
+        }
+    }
+    const source = rules.length > 0 ? rules.map((rule) => `(${rule.re.source})`).join('|') : '(?!)';
+    const entry = { re: new RegExp(source, 'my'), rules };
+    states.set(state, entry);
+    return entry;
+}
+const BLANK = /^[ \t\r\n]+$/;
+/**
+ * Tokenizes `code` with `grammar`. The concatenated token texts always equal
+ * the input. Input beyond `CODE_TOKENIZE_MAX_LENGTH` is one plain token.
+ */
+export function tokenize(code, grammar) {
+    const tokens = [];
+    const input = code.length > CODE_TOKENIZE_MAX_LENGTH ? code.slice(0, CODE_TOKENIZE_MAX_LENGTH) : code;
+    let current = compileState(grammar, grammar.start);
+    let prev = null;
+    let index = 0;
+    while (index < input.length) {
+        current.re.lastIndex = index;
+        const match = current.re.exec(input);
+        const text = match?.[0] ?? '';
+        if (match === null || text.length === 0) {
+            // No rule claims this character: it is plain text.
+            const char = input[index];
+            push(tokens, 'plain', char);
+            if (!BLANK.test(char))
+                prev = { kind: 'plain', text: char };
+            index += 1;
+            continue;
+        }
+        let which = 1;
+        while (match[which] === undefined)
+            which += 1;
+        const rule = current.rules[which - 1];
+        const end = index + text.length;
+        const kind = typeof rule.kind === 'function' ? rule.kind(text, { input, end, prev }) : rule.kind;
+        push(tokens, kind, text);
+        if (!BLANK.test(text))
+            prev = { kind, text };
+        if (rule.next)
+            current = compileState(grammar, rule.next);
+        index = end;
+    }
+    if (input.length < code.length)
+        push(tokens, 'plain', code.slice(input.length));
+    return tokens;
+}
+/** Splits tokens into lines; line breaks are dropped, empty lines are `[]`. */
+export function splitTokenLines(tokens) {
+    const lines = [[]];
+    for (const token of tokens) {
+        const parts = token.text.split('\n');
+        parts.forEach((part, i) => {
+            if (i > 0)
+                lines.push([]);
+            if (part !== '')
+                lines[lines.length - 1].push({ kind: token.kind, text: part });
+        });
+    }
+    return lines;
+}

package/dist/core/catalog/entries.d.ts

@@ -0,0 +1,10 @@
+import type { BlockCatalogEntry } from './types.js';
+/**
+ * Catalog metadata for the core block vocabulary. Later family tasks extend
+ * this list; agents and the website read useWhen / dontUseWhen / limits / a11y.
+ */
+export declare const BLOCK_CATALOG: readonly BlockCatalogEntry[];
+/** Look up catalog metadata for a block type. */
+export declare function getCatalogEntry(type: string): BlockCatalogEntry | undefined;
+/** All catalog types in registration order. */
+export declare function listCatalogTypes(): BlockCatalogEntry['type'][];