sdocs 0.0.39 → 0.0.41

package/CHANGELOG.md

@@ -7,6 +7,35 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.41] - 2026-07-04
+
+### Added
+
+- **`sdocs/language`** — a scanner and parser for the block-based sdoc
+  format: line-anchored `[DOCS]`/`[PAGE]`/`[LAYOUT]` entities with
+  `[preview]`/`[example]` sub-blocks, Svelte-style attributes, precise
+  source spans, and recoverable diagnostics (it never throws, and keeps
+  scanning past mistakes). Groundwork for the format switch — the runtime
+  still reads the current `.sdoc` format.
+- **A TextMate grammar for sdoc** at `sdocs/grammar/sdoc.tmLanguage.json`,
+  usable by any TextMate-compatible highlighter; the documentation site
+  uses it to highlight ```` ```sdoc ```` fences.
+
+## [0.0.40] - 2026-07-04
+
+### Fixed
+
+- **Wrapped previews bind to the documented component.** When a preview
+  wraps the documented component in another one (a `<Tab>` shown inside
+  `<Tabs>`), method calls and live state used to attach to the outer
+  wrapper — the first capitalized tag in the snippet. The preview ref now
+  binds to the doc's own component wherever it appears in the snippet,
+  falling back to the first capitalized tag when it's absent.
+- **Usage-code patching matches the component name exactly.** Attribute
+  updates from the controls located the root tag with a prefix search, so
+  a component like `Tab` could patch a sibling `<Tabs>` tag instead of its
+  own. The tag search now requires a whole-name match.
+
 ## [0.0.39] - 2026-07-04
 
 ### Changed

package/dist/explorer/views/ComponentView.svelte

@@ -106,8 +106,11 @@
 		if (changes.length === 0) return snippetBody;
 
 		// Find the opening tag: <ComponentName ...> or <ComponentName ... />
-		const tagStart = snippetBody.indexOf(`<${name}`);
-		if (tagStart === -1) return snippetBody;
+		// (whole-name match, so <Tab doesn't hit <Tabs)
+		const escapedName = name.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
+		const tagMatch = snippetBody.match(new RegExp(`<${escapedName}(?=[\\s/>])`));
+		if (!tagMatch || tagMatch.index === undefined) return snippetBody;
+		const tagStart = tagMatch.index;
 
 		// Find the end of the opening tag, respecting {} expressions
 		let braceDepth = 0;

package/dist/grammar/sdoc.tmLanguage.json

@@ -0,0 +1,245 @@
+{
+	"$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+	"name": "sdoc",
+	"scopeName": "source.sdoc",
+	"fileTypes": ["sdoc"],
+	"patterns": [
+		{ "include": "#comment" },
+		{ "include": "#script-ts" },
+		{ "include": "#script-js" },
+		{ "include": "#style" },
+		{ "include": "#docs" },
+		{ "include": "#page" },
+		{ "include": "#layout" }
+	],
+	"repository": {
+		"comment": {
+			"name": "comment.block.html.sdoc",
+			"begin": "<!--",
+			"end": "-->"
+		},
+		"script-ts": {
+			"begin": "^\\s*(<)(script)(?=[^>]*lang=([\"'])ts\\3)",
+			"beginCaptures": {
+				"1": { "name": "punctuation.definition.tag.begin.sdoc" },
+				"2": { "name": "entity.name.tag.script.sdoc" }
+			},
+			"end": "(</)(script)\\s*(>)",
+			"endCaptures": {
+				"1": { "name": "punctuation.definition.tag.begin.sdoc" },
+				"2": { "name": "entity.name.tag.script.sdoc" },
+				"3": { "name": "punctuation.definition.tag.end.sdoc" }
+			},
+			"patterns": [
+				{ "include": "#tag-rest" },
+				{
+					"begin": "(?<=>)",
+					"end": "(?=</script)",
+					"contentName": "source.ts",
+					"patterns": [{ "include": "source.ts" }]
+				}
+			]
+		},
+		"script-js": {
+			"begin": "^\\s*(<)(script)(?![^>]*lang=([\"'])ts\\3)(?=[\\s>])",
+			"beginCaptures": {
+				"1": { "name": "punctuation.definition.tag.begin.sdoc" },
+				"2": { "name": "entity.name.tag.script.sdoc" }
+			},
+			"end": "(</)(script)\\s*(>)",
+			"endCaptures": {
+				"1": { "name": "punctuation.definition.tag.begin.sdoc" },
+				"2": { "name": "entity.name.tag.script.sdoc" },
+				"3": { "name": "punctuation.definition.tag.end.sdoc" }
+			},
+			"patterns": [
+				{ "include": "#tag-rest" },
+				{
+					"begin": "(?<=>)",
+					"end": "(?=</script)",
+					"contentName": "source.js",
+					"patterns": [{ "include": "source.js" }]
+				}
+			]
+		},
+		"style": {
+			"begin": "^\\s*(<)(style)(?=[\\s>])",
+			"beginCaptures": {
+				"1": { "name": "punctuation.definition.tag.begin.sdoc" },
+				"2": { "name": "entity.name.tag.style.sdoc" }
+			},
+			"end": "(</)(style)\\s*(>)",
+			"endCaptures": {
+				"1": { "name": "punctuation.definition.tag.begin.sdoc" },
+				"2": { "name": "entity.name.tag.style.sdoc" },
+				"3": { "name": "punctuation.definition.tag.end.sdoc" }
+			},
+			"patterns": [
+				{ "include": "#tag-rest" },
+				{
+					"begin": "(?<=>)",
+					"end": "(?=</style)",
+					"contentName": "source.css",
+					"patterns": [{ "include": "source.css" }]
+				}
+			]
+		},
+		"tag-rest": {
+			"begin": "\\G",
+			"end": "(>)",
+			"endCaptures": {
+				"1": { "name": "punctuation.definition.tag.end.sdoc" }
+			},
+			"patterns": [{ "include": "#attributes" }]
+		},
+		"docs": {
+			"name": "meta.block.docs.sdoc",
+			"begin": "^\\s*(\\[)(DOCS)\\b",
+			"beginCaptures": {
+				"1": { "name": "punctuation.definition.tag.begin.sdoc" },
+				"2": { "name": "keyword.control.entity.sdoc" }
+			},
+			"end": "^\\s*(\\[/)(DOCS)(\\])\\s*$",
+			"endCaptures": {
+				"1": { "name": "punctuation.definition.tag.begin.sdoc" },
+				"2": { "name": "keyword.control.entity.sdoc" },
+				"3": { "name": "punctuation.definition.tag.end.sdoc" }
+			},
+			"patterns": [
+				{ "include": "#opener-attrs" },
+				{ "include": "#comment" },
+				{ "include": "#preview" },
+				{ "include": "#example" }
+			]
+		},
+		"page": {
+			"name": "meta.block.page.sdoc",
+			"begin": "^\\s*(\\[)(PAGE)\\b",
+			"beginCaptures": {
+				"1": { "name": "punctuation.definition.tag.begin.sdoc" },
+				"2": { "name": "keyword.control.entity.sdoc" }
+			},
+			"end": "^\\s*(\\[/)(PAGE)(\\])\\s*$",
+			"endCaptures": {
+				"1": { "name": "punctuation.definition.tag.begin.sdoc" },
+				"2": { "name": "keyword.control.entity.sdoc" },
+				"3": { "name": "punctuation.definition.tag.end.sdoc" }
+			},
+			"patterns": [
+				{ "include": "#opener-attrs" },
+				{ "include": "source.svelte" }
+			]
+		},
+		"layout": {
+			"name": "meta.block.layout.sdoc",
+			"begin": "^\\s*(\\[)(LAYOUT)\\b",
+			"beginCaptures": {
+				"1": { "name": "punctuation.definition.tag.begin.sdoc" },
+				"2": { "name": "keyword.control.entity.sdoc" }
+			},
+			"end": "^\\s*(\\[/)(LAYOUT)(\\])\\s*$",
+			"endCaptures": {
+				"1": { "name": "punctuation.definition.tag.begin.sdoc" },
+				"2": { "name": "keyword.control.entity.sdoc" },
+				"3": { "name": "punctuation.definition.tag.end.sdoc" }
+			},
+			"patterns": [
+				{ "include": "#opener-attrs" },
+				{ "include": "source.svelte" }
+			]
+		},
+		"preview": {
+			"name": "meta.block.preview.sdoc",
+			"begin": "^\\s*(\\[)(preview)\\b",
+			"beginCaptures": {
+				"1": { "name": "punctuation.definition.tag.begin.sdoc" },
+				"2": { "name": "entity.name.tag.sdoc" }
+			},
+			"end": "^\\s*(\\[/)(preview)(\\])\\s*$",
+			"endCaptures": {
+				"1": { "name": "punctuation.definition.tag.begin.sdoc" },
+				"2": { "name": "entity.name.tag.sdoc" },
+				"3": { "name": "punctuation.definition.tag.end.sdoc" }
+			},
+			"patterns": [
+				{ "include": "#opener-attrs" },
+				{ "include": "source.svelte" }
+			]
+		},
+		"example": {
+			"name": "meta.block.example.sdoc",
+			"begin": "^\\s*(\\[)(example)\\b",
+			"beginCaptures": {
+				"1": { "name": "punctuation.definition.tag.begin.sdoc" },
+				"2": { "name": "entity.name.tag.sdoc" }
+			},
+			"end": "^\\s*(\\[/)(example)(\\])\\s*$",
+			"endCaptures": {
+				"1": { "name": "punctuation.definition.tag.begin.sdoc" },
+				"2": { "name": "entity.name.tag.sdoc" },
+				"3": { "name": "punctuation.definition.tag.end.sdoc" }
+			},
+			"patterns": [
+				{ "include": "#opener-attrs" },
+				{ "include": "source.svelte" }
+			]
+		},
+		"opener-attrs": {
+			"begin": "\\G",
+			"end": "(\\])",
+			"endCaptures": {
+				"1": { "name": "punctuation.definition.tag.end.sdoc" }
+			},
+			"patterns": [{ "include": "#attributes" }]
+		},
+		"attributes": {
+			"patterns": [
+				{
+					"match": "([A-Za-z_][\\w-]*)\\s*(=)",
+					"captures": {
+						"1": { "name": "entity.other.attribute-name.sdoc" },
+						"2": { "name": "punctuation.separator.key-value.sdoc" }
+					}
+				},
+				{
+					"match": "([A-Za-z_][\\w-]*)",
+					"name": "entity.other.attribute-name.sdoc"
+				},
+				{
+					"name": "string.quoted.double.sdoc",
+					"begin": "\"",
+					"end": "\"",
+					"beginCaptures": {
+						"0": { "name": "punctuation.definition.string.begin.sdoc" }
+					},
+					"endCaptures": {
+						"0": { "name": "punctuation.definition.string.end.sdoc" }
+					}
+				},
+				{ "include": "#expression" }
+			]
+		},
+		"expression": {
+			"name": "meta.embedded.expression.sdoc",
+			"begin": "\\{",
+			"end": "\\}",
+			"beginCaptures": {
+				"0": { "name": "punctuation.section.embedded.begin.sdoc" }
+			},
+			"endCaptures": {
+				"0": { "name": "punctuation.section.embedded.end.sdoc" }
+			},
+			"patterns": [{ "include": "#expression-inner" }]
+		},
+		"expression-inner": {
+			"patterns": [
+				{
+					"begin": "\\{",
+					"end": "\\}",
+					"patterns": [{ "include": "#expression-inner" }]
+				},
+				{ "include": "source.ts" }
+			]
+		}
+	}
+}

package/dist/language/index.d.ts

@@ -0,0 +1,2 @@
+export { scanSdoc, offsetToPosition, ENTITY_KINDS, SUB_BLOCK_KINDS, type Span, type EntityKind, type SubBlockKind, type AttrValue, type Attrs, type SubBlock, type Entity, type TagBlock, type ScanError, type SdocFile, } from './scanner.js';
+export { parseSdoc, parseArgsLiteral, slugifyTitle, normalizeBody, type ArgValue, type PreviewBlock, type ExampleBlock, type DocsEntity, type PageEntity, type LayoutEntity, type SdocEntity, type SdocDocument, } from './parser.js';

package/dist/language/index.js

@@ -0,0 +1,2 @@
+export { scanSdoc, offsetToPosition, ENTITY_KINDS, SUB_BLOCK_KINDS, } from './scanner.js';
+export { parseSdoc, parseArgsLiteral, slugifyTitle, normalizeBody, } from './parser.js';

package/dist/language/parser.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Semantic layer over the syntactic scanner: validates attributes against
+ * the sdoc language rules and produces typed entities ready for the Vite
+ * plugin, the CLI app-gen, and the editor tooling.
+ */
+import { type ScanError, type Span, type TagBlock } from './scanner.js';
+export type ArgValue = string | number | boolean;
+export interface PreviewBlock {
+    /** The identifier from component={X}; null when invalid/missing (already reported) */
+    componentName: string | null;
+    /** Parsed args literal; null when absent or invalid */
+    args: Record<string, ArgValue> | null;
+    /** Exact source of the args expression (inner object), for code display */
+    argsRaw: string | null;
+    /** Explicit title="…" override, when present */
+    title: string | null;
+    /** Tab label: the title override or the component name */
+    label: string;
+    body: string;
+    bodySpan: Span;
+    span: Span;
+}
+export interface ExampleBlock {
+    title: string;
+    body: string;
+    bodySpan: Span;
+    span: Span;
+}
+export interface DocsEntity {
+    kind: 'DOCS';
+    title: string;
+    slug: string;
+    description: string | null;
+    previews: PreviewBlock[];
+    examples: ExampleBlock[];
+    openerSpan: Span;
+    span: Span;
+}
+export interface PageEntity {
+    kind: 'PAGE';
+    title: string;
+    slug: string;
+    body: string;
+    bodySpan: Span;
+    openerSpan: Span;
+    span: Span;
+}
+export interface LayoutEntity {
+    kind: 'LAYOUT';
+    title: string;
+    slug: string;
+    padding: string | null;
+    body: string;
+    bodySpan: Span;
+    openerSpan: Span;
+    span: Span;
+}
+export type SdocEntity = DocsEntity | PageEntity | LayoutEntity;
+export interface SdocDocument {
+    script: TagBlock | null;
+    style: TagBlock | null;
+    entities: SdocEntity[];
+    diagnostics: ScanError[];
+    source: string;
+}
+/**
+ * Normalize a raw block body for consumption: strip the common leading
+ * indentation (bodies sit one level deep inside their block), drop a
+ * trailing carriage return per line, and unescape lines that start with
+ * `\[` (the escape for body lines that would otherwise read as tags).
+ * The scanner keeps the raw text and spans; this is the display/runtime form.
+ */
+export declare function normalizeBody(raw: string): string;
+/** Slug used for entity addressing: relPath + '#' + slug. */
+export declare function slugifyTitle(title: string): string;
+/**
+ * Parse a preview args expression: a flat object literal whose values are
+ * plain literals (strings, numbers, booleans). Anything richer belongs in
+ * the block body, so it is rejected here.
+ */
+export declare function parseArgsLiteral(raw: string, span: Span, diagnostics: ScanError[]): Record<string, ArgValue> | null;
+export declare function parseSdoc(source: string): SdocDocument;

package/dist/language/parser.js

@@ -0,0 +1,293 @@
+/**
+ * Semantic layer over the syntactic scanner: validates attributes against
+ * the sdoc language rules and produces typed entities ready for the Vite
+ * plugin, the CLI app-gen, and the editor tooling.
+ */
+import { scanSdoc, } from './scanner.js';
+/**
+ * Normalize a raw block body for consumption: strip the common leading
+ * indentation (bodies sit one level deep inside their block), drop a
+ * trailing carriage return per line, and unescape lines that start with
+ * `\[` (the escape for body lines that would otherwise read as tags).
+ * The scanner keeps the raw text and spans; this is the display/runtime form.
+ */
+export function normalizeBody(raw) {
+    const lines = raw.split('\n').map((line) => line.replace(/\r$/, ''));
+    let common = null;
+    for (const line of lines) {
+        if (line.trim() === '')
+            continue;
+        const indent = line.match(/^[ \t]*/)[0];
+        if (common === null) {
+            common = indent;
+        }
+        else {
+            let k = 0;
+            while (k < common.length && k < indent.length && common[k] === indent[k])
+                k++;
+            common = common.slice(0, k);
+        }
+    }
+    const cut = common?.length ?? 0;
+    return lines
+        .map((line) => (line.trim() === '' ? '' : line.slice(cut)))
+        .map((line) => (line.startsWith('\\[') ? line.slice(1) : line))
+        .join('\n')
+        .replace(/^\n+|\n+$/g, '');
+}
+/** Slug used for entity addressing: relPath + '#' + slug. */
+export function slugifyTitle(title) {
+    return (title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '') || 'untitled');
+}
+const IDENTIFIER_RE = /^[A-Z][A-Za-z0-9_]*$/;
+const ENTITY_ATTR_RULES = {
+    DOCS: {
+        title: { required: true, kind: 'string', hint: 'title="Group / Name"' },
+        description: { required: false, kind: 'string', hint: 'description="…"' },
+    },
+    PAGE: {
+        title: { required: true, kind: 'string', hint: 'title="Group / Name"' },
+    },
+    LAYOUT: {
+        title: { required: true, kind: 'string', hint: 'title="Group / Name"' },
+        padding: { required: false, kind: 'string', hint: 'padding="48px"' },
+    },
+};
+const SUB_BLOCK_ATTR_RULES = {
+    preview: {
+        component: { required: true, kind: 'expression', hint: 'component={Button}' },
+        args: { required: false, kind: 'expression', hint: 'args={{ label: "Hi" }}' },
+        title: { required: false, kind: 'string', hint: 'title="…"' },
+    },
+    example: {
+        title: { required: true, kind: 'string', hint: 'title="…"' },
+    },
+};
+function checkAttrs(owner, attrs, rules, ownerSpan, diagnostics) {
+    for (const [name, value] of Object.entries(attrs)) {
+        const rule = rules[name];
+        if (!rule) {
+            diagnostics.push({
+                code: 'unknown-attr',
+                message: `Unknown attribute "${name}" on ${owner}. Allowed: ${Object.keys(rules).join(', ')}.`,
+                span: value.span,
+            });
+            continue;
+        }
+        if (value.kind !== rule.kind) {
+            diagnostics.push({
+                code: 'attr-value-kind',
+                message: `Attribute "${name}" on ${owner} must be written ${rule.hint}.`,
+                span: value.span,
+            });
+        }
+    }
+    for (const [name, rule] of Object.entries(rules)) {
+        if (rule.required && !attrs[name]) {
+            diagnostics.push({
+                code: 'missing-attr',
+                message: `${owner} requires ${rule.hint}.`,
+                span: ownerSpan,
+            });
+        }
+    }
+}
+function stringAttr(attrs, name) {
+    const v = attrs[name];
+    return v && v.kind === 'string' ? v.raw : null;
+}
+/**
+ * Parse a preview args expression: a flat object literal whose values are
+ * plain literals (strings, numbers, booleans). Anything richer belongs in
+ * the block body, so it is rejected here.
+ */
+export function parseArgsLiteral(raw, span, diagnostics) {
+    const fail = (message) => {
+        diagnostics.push({ code: 'args-literal', message, span });
+        return null;
+    };
+    let i = 0;
+    const ws = () => {
+        while (i < raw.length && /\s/.test(raw[i]))
+            i++;
+    };
+    ws();
+    if (raw[i] !== '{')
+        return fail('args must be an object literal: args={{ name: value }}.');
+    i++;
+    const values = {};
+    ws();
+    while (i < raw.length && raw[i] !== '}') {
+        const keyMatch = raw.slice(i).match(/^([A-Za-z_$][A-Za-z0-9_$]*|'[^']*'|"[^"]*")\s*:/);
+        if (!keyMatch)
+            return fail('args keys must be plain names, like args={{ label: "Hi" }}.');
+        const key = keyMatch[1].replace(/^['"]|['"]$/g, '');
+        i += keyMatch[0].length;
+        ws();
+        const rest = raw.slice(i);
+        let m;
+        if ((m = rest.match(/^'((?:[^'\\]|\\.)*)'/)) || (m = rest.match(/^"((?:[^"\\]|\\.)*)"/))) {
+            values[key] = m[1].replace(/\\(.)/g, '$1');
+            i += m[0].length;
+        }
+        else if ((m = rest.match(/^-?\d+(\.\d+)?/))) {
+            values[key] = Number(m[0]);
+            i += m[0].length;
+        }
+        else if ((m = rest.match(/^(true|false)\b/))) {
+            values[key] = m[0] === 'true';
+            i += m[0].length;
+        }
+        else {
+            return fail(`args value for "${key}" must be a plain literal (string, number, or boolean); richer values go in the block body.`);
+        }
+        ws();
+        if (raw[i] === ',') {
+            i++;
+            ws();
+        }
+        else if (raw[i] !== '}') {
+            return fail('args entries must be separated by commas.');
+        }
+    }
+    if (raw[i] !== '}')
+        return fail('args object literal is missing its closing "}".');
+    i++;
+    ws();
+    if (i !== raw.length)
+        return fail('Unexpected text after the args object literal.');
+    return values;
+}
+function parsePreview(block, diagnostics) {
+    checkAttrs('[preview]', block.attrs, SUB_BLOCK_ATTR_RULES.preview, block.openerSpan, diagnostics);
+    let componentName = null;
+    const component = block.attrs.component;
+    if (component && component.kind === 'expression') {
+        const name = component.raw.trim();
+        if (IDENTIFIER_RE.test(name)) {
+            componentName = name;
+        }
+        else {
+            diagnostics.push({
+                code: 'component-identifier',
+                message: 'component must be a component identifier imported in the file\'s <script>, like component={Button}.',
+                span: component.valueSpan,
+            });
+        }
+    }
+    let args = null;
+    let argsRaw = null;
+    const argsAttr = block.attrs.args;
+    if (argsAttr && argsAttr.kind === 'expression') {
+        argsRaw = argsAttr.raw.trim();
+        args = parseArgsLiteral(argsAttr.raw, argsAttr.valueSpan, diagnostics);
+    }
+    const title = stringAttr(block.attrs, 'title');
+    return {
+        componentName,
+        args,
+        argsRaw,
+        title,
+        label: title ?? componentName ?? 'Preview',
+        body: normalizeBody(block.body),
+        bodySpan: block.bodySpan,
+        span: block.span,
+    };
+}
+function parseDocs(entity, diagnostics) {
+    checkAttrs('[DOCS]', entity.attrs, ENTITY_ATTR_RULES.DOCS, entity.openerSpan, diagnostics);
+    const previews = [];
+    const examples = [];
+    const exampleTitles = new Set();
+    const previewLabels = new Set();
+    for (const block of entity.blocks) {
+        if (block.kind === 'preview') {
+            const preview = parsePreview(block, diagnostics);
+            if (previewLabels.has(preview.label)) {
+                diagnostics.push({
+                    code: 'duplicate-preview-label',
+                    message: `Two previews are both labeled "${preview.label}" — give one a title="…".`,
+                    span: block.openerSpan,
+                });
+            }
+            previewLabels.add(preview.label);
+            previews.push(preview);
+        }
+        else {
+            checkAttrs('[example]', block.attrs, SUB_BLOCK_ATTR_RULES.example, block.openerSpan, diagnostics);
+            const title = stringAttr(block.attrs, 'title') ?? '';
+            if (title && exampleTitles.has(title)) {
+                diagnostics.push({
+                    code: 'duplicate-example-title',
+                    message: `Duplicate example title "${title}" — titles are unique within a [DOCS] block.`,
+                    span: block.openerSpan,
+                });
+            }
+            exampleTitles.add(title);
+            examples.push({
+                title,
+                body: normalizeBody(block.body),
+                bodySpan: block.bodySpan,
+                span: block.span,
+            });
+        }
+    }
+    const title = stringAttr(entity.attrs, 'title') ?? '';
+    return {
+        kind: 'DOCS',
+        title,
+        slug: slugifyTitle(title),
+        description: stringAttr(entity.attrs, 'description'),
+        previews,
+        examples,
+        openerSpan: entity.openerSpan,
+        span: entity.span,
+    };
+}
+export function parseSdoc(source) {
+    const scanned = scanSdoc(source);
+    const diagnostics = [...scanned.errors];
+    const entities = [];
+    const slugs = new Set();
+    for (const entity of scanned.entities) {
+        let typed;
+        if (entity.kind === 'DOCS') {
+            typed = parseDocs(entity, diagnostics);
+        }
+        else {
+            checkAttrs(`[${entity.kind}]`, entity.attrs, ENTITY_ATTR_RULES[entity.kind], entity.openerSpan, diagnostics);
+            const title = stringAttr(entity.attrs, 'title') ?? '';
+            const base = {
+                title,
+                slug: slugifyTitle(title),
+                body: normalizeBody(entity.body),
+                bodySpan: entity.bodySpan,
+                openerSpan: entity.openerSpan,
+                span: entity.span,
+            };
+            typed =
+                entity.kind === 'PAGE'
+                    ? { kind: 'PAGE', ...base }
+                    : { kind: 'LAYOUT', padding: stringAttr(entity.attrs, 'padding'), ...base };
+        }
+        if (slugs.has(typed.slug)) {
+            diagnostics.push({
+                code: 'duplicate-entity-title',
+                message: `Two entities in this file resolve to the same address ("${typed.slug}") — make their titles distinct.`,
+                span: typed.openerSpan,
+            });
+        }
+        slugs.add(typed.slug);
+        entities.push(typed);
+    }
+    return {
+        script: scanned.script,
+        style: scanned.style,
+        entities,
+        diagnostics,
+        source,
+    };
+}

package/dist/language/parser.test.d.ts

@@ -0,0 +1 @@
+export {};