@transitrix/diagrams 1.0.0

package/dist/assertion/validate.js

@@ -0,0 +1,137 @@
+// ASSERTION validator — methodology notations/elements/16-assertion.md §5.
+//
+// Implements ASSERT-001..008. The shared HDR-/LIFECYCLE- rules and the
+// cross-cutting ASSERT-DEAD-LINK-001 are owned elsewhere (CONTRACT.md §8) and
+// are out of scope for this single-artefact validator.
+//
+// Resolution rules (ASSERT-002/003/004/005) that need artefact *existence*
+// run only when a `CanonCatalog` is supplied; the TYPE checks they also carry
+// are derivable from the id prefix and run either way. ASSERT-008 (staleness)
+// runs only when `today` is supplied, keeping the validator clock-free.
+import { typeOfId, isCanonicalIdOfType } from '../typed-id.js';
+import { ASSERTION_STATUSES, ASSERTION_SUBJECT_TYPES } from './types.js';
+const SUBJECT_TYPES = ASSERTION_SUBJECT_TYPES;
+export function validateAssertion(input, options = {}) {
+    const errors = [];
+    const warnings = [];
+    const { catalog, today } = options;
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        errors.push({ code: 'ASSERT-001', message: 'Assertion must be a YAML mapping.' });
+        return { valid: false, errors, warnings };
+    }
+    const a = input;
+    // ── ASSERT-001 — id grammar + plain required fields ──────────────────────
+    if (!isCanonicalIdOfType(a.id, 'ASSERTION')) {
+        errors.push({ code: 'ASSERT-001', message: `id "${String(a.id)}" must match ASSERTION-[<middle>-]<INTEGER>.`, path: 'id' });
+    }
+    if (a.notation !== 'assertion') {
+        errors.push({ code: 'ASSERT-001', message: 'notation must be the fixed value "assertion".', path: 'notation' });
+    }
+    if (a.zone !== 'canon') {
+        errors.push({ code: 'ASSERT-001', message: 'zone is required and must be "canon".', path: 'zone' });
+    }
+    for (const f of ['admitted_at', 'admitted_by', 'valid_from']) {
+        if (typeof a[f] !== 'string' || a[f].trim() === '') {
+            errors.push({ code: 'ASSERT-001', message: `${f} is required.`, path: f });
+        }
+    }
+    if (a.gate_checks === null || typeof a.gate_checks !== 'object') {
+        errors.push({ code: 'ASSERT-001', message: 'gate_checks is required and must be a mapping.', path: 'gate_checks' });
+    }
+    if (!('valid_to' in a) || !(typeof a.valid_to === 'string' || a.valid_to === null)) {
+        errors.push({ code: 'ASSERT-001', message: 'valid_to is required (an ISO date string or null).', path: 'valid_to' });
+    }
+    // ── ASSERT-002 — about → REQUIREMENT ─────────────────────────────────────
+    const about = a.about;
+    if (typeof about !== 'string' || about.trim() === '') {
+        errors.push({ code: 'ASSERT-002', message: 'about is required and must be a typed REQUIREMENT id.', path: 'about' });
+    }
+    else if (catalog) {
+        const t = catalog.typeOf(about);
+        if (t === undefined) {
+            errors.push({ code: 'ASSERT-002', message: `about "${about}" does not resolve to an admitted artefact.`, path: 'about' });
+        }
+        else if (t !== 'REQUIREMENT') {
+            errors.push({ code: 'ASSERT-002', message: `about "${about}" resolves to a ${t}, not a REQUIREMENT.`, path: 'about' });
+        }
+    }
+    else if (typeOfId(about) !== 'REQUIREMENT') {
+        errors.push({ code: 'ASSERT-002', message: `about "${about}" must be a REQUIREMENT typed id.`, path: 'about' });
+    }
+    // ── ASSERT-003 — subject ∈ {PRODUCT, PROCESS, CAPABILITY} ────────────────
+    const subject = a.subject;
+    if (typeof subject !== 'string' || subject.trim() === '') {
+        errors.push({ code: 'ASSERT-003', message: 'subject is required and must be a typed PRODUCT/PROCESS/CAPABILITY id.', path: 'subject' });
+    }
+    else if (catalog) {
+        const t = catalog.typeOf(subject);
+        if (t === undefined) {
+            errors.push({ code: 'ASSERT-003', message: `subject "${subject}" does not resolve to an admitted artefact.`, path: 'subject' });
+        }
+        else if (!SUBJECT_TYPES.includes(t)) {
+            errors.push({ code: 'ASSERT-003', message: `subject "${subject}" resolves to a ${t}; must be PRODUCT, PROCESS or CAPABILITY.`, path: 'subject' });
+        }
+    }
+    else {
+        const t = typeOfId(subject);
+        if (!t || !SUBJECT_TYPES.includes(t)) {
+            errors.push({ code: 'ASSERT-003', message: `subject "${subject}" TYPE must be PRODUCT, PROCESS or CAPABILITY.`, path: 'subject' });
+        }
+    }
+    // ── ASSERT-004 — realised_via resolves ───────────────────────────────────
+    if (a.realised_via !== undefined) {
+        if (!Array.isArray(a.realised_via)) {
+            errors.push({ code: 'ASSERT-001', message: 'realised_via must be a list of typed IDs.', path: 'realised_via' });
+        }
+        else {
+            a.realised_via.forEach((ref, i) => {
+                if (!typeOfId(ref)) {
+                    errors.push({ code: 'ASSERT-004', message: `realised_via[${i}] "${String(ref)}" is not a resolvable typed ID.`, path: `realised_via[${i}]` });
+                }
+                else if (catalog && catalog.typeOf(ref) === undefined) {
+                    errors.push({ code: 'ASSERT-004', message: `realised_via[${i}] "${String(ref)}" does not resolve to an admitted element.`, path: `realised_via[${i}]` });
+                }
+            });
+        }
+    }
+    // ── ASSERT-005 — canonical_ref evidence resolves ─────────────────────────
+    if (a.evidence !== undefined) {
+        if (!Array.isArray(a.evidence)) {
+            errors.push({ code: 'ASSERT-001', message: 'evidence must be a list.', path: 'evidence' });
+        }
+        else {
+            a.evidence.forEach((e, i) => {
+                if (e === null || typeof e !== 'object')
+                    return;
+                const entry = e;
+                if (entry.kind !== 'canonical_ref')
+                    return;
+                const ref = entry.ref;
+                if (!typeOfId(ref)) {
+                    errors.push({ code: 'ASSERT-005', message: `evidence[${i}] canonical_ref "${String(ref)}" is not a resolvable typed ID.`, path: `evidence[${i}].ref` });
+                }
+                else if (catalog && catalog.typeOf(ref) === undefined) {
+                    errors.push({ code: 'ASSERT-005', message: `evidence[${i}] canonical_ref "${String(ref)}" does not resolve.`, path: `evidence[${i}].ref` });
+                }
+            });
+        }
+    }
+    // ── ASSERT-006 / ASSERT-001 — status ─────────────────────────────────────
+    const status = a.status;
+    if (status === undefined || status === null) {
+        errors.push({ code: 'ASSERT-001', message: 'status is required.', path: 'status' });
+    }
+    else if (!ASSERTION_STATUSES.includes(status)) {
+        errors.push({ code: 'ASSERT-006', message: `status "${String(status)}" must be one of ${ASSERTION_STATUSES.join(', ')}.`, path: 'status' });
+    }
+    // ── ASSERT-007 (warning) — positive status with no evidence ──────────────
+    const evidenceEmpty = !Array.isArray(a.evidence) || a.evidence.length === 0;
+    if (evidenceEmpty && (status === 'compliant' || status === 'partial')) {
+        warnings.push({ code: 'ASSERT-007', message: `status "${status}" has no evidence — a positive status without evidence is undefended.`, path: 'evidence' });
+    }
+    // ── ASSERT-008 (warning) — stale review (only when `today` is known) ──────
+    if (today && typeof a.next_review_at === 'string' && a.next_review_at < today) {
+        warnings.push({ code: 'ASSERT-008', message: `next_review_at ${a.next_review_at} is in the past — the assertion is stale and due for re-review.`, path: 'next_review_at' });
+    }
+    return { valid: errors.length === 0, errors, warnings };
+}

package/dist/blocks/__tests__/layout.test.d.ts

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

package/dist/blocks/__tests__/layout.test.js

@@ -0,0 +1,153 @@
+import { describe, it, expect } from 'vitest';
+import { layoutNestedBlocks, iterateBlocks } from '../layout.js';
+function findById(layout, id) {
+    for (const b of iterateBlocks(layout)) {
+        if (b.id === id)
+            return b;
+    }
+    return undefined;
+}
+const TWO_TOP_LEVEL = {
+    notation: 'blocks',
+    spec_version: '0.1',
+    nested_blocks: {
+        id: 'BLOCKS-ARCH-1',
+        name: 'Software architecture',
+        blocks: [
+            {
+                id: 'APPLICATION_LAYER',
+                name: 'Application Layer',
+                children: [
+                    {
+                        id: 'FRONTEND',
+                        name: 'Frontend',
+                        children: [
+                            { id: 'REACT_APP', name: 'React App' },
+                            { id: 'REDUX_STORE', name: 'Redux Store' },
+                        ],
+                    },
+                    {
+                        id: 'BACKEND',
+                        name: 'Backend',
+                        children: [
+                            { id: 'REST_API', name: 'REST API' },
+                            { id: 'BUSINESS_LOGIC', name: 'Business Logic' },
+                        ],
+                    },
+                ],
+            },
+            {
+                id: 'DATA_LAYER',
+                name: 'Data Layer',
+                children: [
+                    { id: 'POSTGRESQL', name: 'PostgreSQL' },
+                    { id: 'REDIS_CACHE', name: 'Redis Cache' },
+                ],
+            },
+        ],
+    },
+};
+describe('layoutNestedBlocks', () => {
+    it('lays out top-level blocks vertically starting at y=0', () => {
+        const layout = layoutNestedBlocks(TWO_TOP_LEVEL);
+        expect(layout.blocks).toHaveLength(2);
+        expect(layout.blocks[0].y).toBe(0);
+        expect(layout.blocks[1].y).toBeGreaterThan(layout.blocks[0].y + layout.blocks[0].height);
+    });
+    it('assigns depth=1 to top-level blocks and increases for each nesting level', () => {
+        const layout = layoutNestedBlocks(TWO_TOP_LEVEL);
+        const app = findById(layout, 'APPLICATION_LAYER');
+        const frontend = findById(layout, 'FRONTEND');
+        const react = findById(layout, 'REACT_APP');
+        expect(app.depth).toBe(1);
+        expect(frontend.depth).toBe(2);
+        expect(react.depth).toBe(3);
+    });
+    it('records max depth on the layout', () => {
+        const layout = layoutNestedBlocks(TWO_TOP_LEVEL);
+        expect(layout.maxDepth).toBe(3);
+    });
+    it('places every child strictly inside its parent (containment property)', () => {
+        const layout = layoutNestedBlocks(TWO_TOP_LEVEL);
+        function checkContainment(b) {
+            for (const c of b.children) {
+                expect(c.x).toBeGreaterThanOrEqual(b.x);
+                expect(c.y).toBeGreaterThanOrEqual(b.y + b.headerHeight);
+                expect(c.x + c.width).toBeLessThanOrEqual(b.x + b.width);
+                expect(c.y + c.height).toBeLessThanOrEqual(b.y + b.height);
+                checkContainment(c);
+            }
+        }
+        for (const top of layout.blocks)
+            checkContainment(top);
+    });
+    it('siblings do not overlap', () => {
+        const layout = layoutNestedBlocks(TWO_TOP_LEVEL);
+        function checkSiblings(b) {
+            for (let i = 0; i < b.children.length; i++) {
+                for (let j = i + 1; j < b.children.length; j++) {
+                    const a = b.children[i];
+                    const c = b.children[j];
+                    const disjointX = a.x + a.width <= c.x || c.x + c.width <= a.x;
+                    const disjointY = a.y + a.height <= c.y || c.y + c.height <= a.y;
+                    expect(disjointX || disjointY).toBe(true);
+                }
+                checkSiblings(b.children[i]);
+            }
+        }
+        for (const top of layout.blocks)
+            checkSiblings(top);
+    });
+    it('a leaf block uses the configured leaf dimensions', () => {
+        const layout = layoutNestedBlocks({
+            notation: 'blocks',
+            nested_blocks: {
+                id: 'BLOCKS-LEAF-1',
+                name: 'Leaf only',
+                blocks: [{ id: 'A', name: 'A' }],
+            },
+        });
+        const a = layout.blocks[0];
+        expect(a.width).toBe(160);
+        expect(a.height).toBe(60);
+    });
+    it('honours custom layout options', () => {
+        const layout = layoutNestedBlocks({
+            notation: 'blocks',
+            nested_blocks: {
+                id: 'BLOCKS-LEAF-1',
+                name: 'Leaf only',
+                blocks: [{ id: 'A', name: 'A' }],
+            },
+        }, { leafWidth: 200, leafHeight: 80 });
+        expect(layout.blocks[0].width).toBe(200);
+        expect(layout.blocks[0].height).toBe(80);
+    });
+    it('iterateBlocks visits every block once in pre-order', () => {
+        const layout = layoutNestedBlocks(TWO_TOP_LEVEL);
+        const ids = Array.from(iterateBlocks(layout)).map((b) => b.id);
+        expect(ids).toEqual([
+            'APPLICATION_LAYER',
+            'FRONTEND',
+            'REACT_APP',
+            'REDUX_STORE',
+            'BACKEND',
+            'REST_API',
+            'BUSINESS_LOGIC',
+            'DATA_LAYER',
+            'POSTGRESQL',
+            'REDIS_CACHE',
+        ]);
+    });
+    it('handles an empty top-level array gracefully (returns zero-size bounds)', () => {
+        const layout = layoutNestedBlocks({
+            notation: 'blocks',
+            // Schema-wise this is invalid (BL-004), but the layout function still
+            // needs to be defensive — validation runs separately.
+            nested_blocks: { id: 'X', name: 'X', blocks: [] },
+        });
+        expect(layout.blocks).toHaveLength(0);
+        expect(layout.bounds.width).toBe(0);
+        expect(layout.bounds.height).toBe(0);
+    });
+});

package/dist/blocks/__tests__/validate.test.d.ts

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

package/dist/blocks/__tests__/validate.test.js

@@ -0,0 +1,235 @@
+import { describe, it, expect } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import yaml from 'js-yaml';
+import { validateNestedBlocks } from '../validate.js';
+const EXAMPLES_DIR = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'blocks');
+const VALID_DOC = {
+    notation: 'blocks',
+    spec_version: '0.1',
+    nested_blocks: {
+        id: 'BLOCKS-ARCH-1',
+        name: 'Software architecture',
+        blocks: [
+            {
+                id: 'APPLICATION_LAYER',
+                name: 'Application Layer',
+                children: [
+                    { id: 'FRONTEND', name: 'Frontend' },
+                    { id: 'BACKEND', name: 'Backend' },
+                ],
+            },
+            {
+                id: 'DATA_LAYER',
+                name: 'Data Layer',
+                children: [
+                    { id: 'POSTGRESQL', name: 'PostgreSQL' },
+                    { id: 'REDIS_CACHE', name: 'Redis Cache' },
+                ],
+            },
+        ],
+    },
+};
+describe('validateNestedBlocks', () => {
+    it('passes on a valid document', () => {
+        const r = validateNestedBlocks(VALID_DOC);
+        expect(r.valid).toBe(true);
+        expect(r.errors).toHaveLength(0);
+    });
+    it('BL-001: rejects non-object input', () => {
+        expect(validateNestedBlocks(null).valid).toBe(false);
+        expect(validateNestedBlocks(null).errors[0].code).toBe('BL-001');
+        expect(validateNestedBlocks('string').errors[0].code).toBe('BL-001');
+    });
+    it('BL-001: rejects missing nested_blocks root key', () => {
+        const r = validateNestedBlocks({ notation: 'blocks' });
+        expect(r.errors.some((e) => e.code === 'BL-001')).toBe(true);
+    });
+    it('BL-001: rejects wrong notation value', () => {
+        const r = validateNestedBlocks({ ...VALID_DOC, notation: 'goals' });
+        expect(r.errors.some((e) => e.code === 'BL-001')).toBe(true);
+    });
+    it('BL-001: tolerates a missing notation field (header check is contract-level)', () => {
+        const { notation: _, ...rest } = VALID_DOC;
+        const r = validateNestedBlocks(rest);
+        expect(r.errors.some((e) => e.code === 'BL-001')).toBe(false);
+    });
+    it('BL-002: rejects missing id', () => {
+        const r = validateNestedBlocks({
+            ...VALID_DOC,
+            nested_blocks: { ...VALID_DOC.nested_blocks, id: '' },
+        });
+        expect(r.errors.some((e) => e.code === 'BL-002')).toBe(true);
+    });
+    it('BL-002: rejects id that does not match BLOCKS grammar', () => {
+        const r = validateNestedBlocks({
+            ...VALID_DOC,
+            nested_blocks: { ...VALID_DOC.nested_blocks, id: 'BLK-1' },
+        });
+        expect(r.errors.some((e) => e.code === 'BL-002')).toBe(true);
+    });
+    it('BL-003: rejects missing name', () => {
+        const r = validateNestedBlocks({
+            ...VALID_DOC,
+            nested_blocks: { ...VALID_DOC.nested_blocks, name: '' },
+        });
+        expect(r.errors.some((e) => e.code === 'BL-003')).toBe(true);
+    });
+    it('BL-004: rejects missing blocks array', () => {
+        const { blocks: _, ...rest } = VALID_DOC.nested_blocks;
+        const r = validateNestedBlocks({ ...VALID_DOC, nested_blocks: rest });
+        expect(r.errors.some((e) => e.code === 'BL-004')).toBe(true);
+    });
+    it('BL-004: rejects empty blocks array', () => {
+        const r = validateNestedBlocks({
+            ...VALID_DOC,
+            nested_blocks: { ...VALID_DOC.nested_blocks, blocks: [] },
+        });
+        expect(r.errors.some((e) => e.code === 'BL-004')).toBe(true);
+    });
+    it('BL-005: rejects block missing id', () => {
+        const r = validateNestedBlocks({
+            ...VALID_DOC,
+            nested_blocks: {
+                ...VALID_DOC.nested_blocks,
+                blocks: [{ name: 'Anonymous' }],
+            },
+        });
+        expect(r.errors.some((e) => e.code === 'BL-005' && /id/.test(e.message))).toBe(true);
+    });
+    it('BL-005: rejects block missing name', () => {
+        const r = validateNestedBlocks({
+            ...VALID_DOC,
+            nested_blocks: {
+                ...VALID_DOC.nested_blocks,
+                blocks: [{ id: 'X', name: '' }],
+            },
+        });
+        expect(r.errors.some((e) => e.code === 'BL-005' && /name/.test(e.message))).toBe(true);
+    });
+    it('BL-005: rejects an id with whitespace (not a valid free label)', () => {
+        const r = validateNestedBlocks({
+            ...VALID_DOC,
+            nested_blocks: {
+                ...VALID_DOC.nested_blocks,
+                blocks: [{ id: 'bad id', name: 'X' }],
+            },
+        });
+        expect(r.errors.some((e) => e.code === 'BL-005' && /whitespace/.test(e.message))).toBe(true);
+    });
+    it('BL-006: rejects a canonical-shaped id whose TYPE is not registered', () => {
+        const r = validateNestedBlocks({
+            ...VALID_DOC,
+            nested_blocks: {
+                ...VALID_DOC.nested_blocks,
+                blocks: [{ id: 'XYZ-SOMETHING-1', name: 'X' }],
+            },
+        });
+        expect(r.errors.some((e) => e.code === 'BL-006')).toBe(true);
+    });
+    it('BL-006: accepts canonical ids with registered TYPE (APPLICATION-OMS-1)', () => {
+        const r = validateNestedBlocks({
+            ...VALID_DOC,
+            nested_blocks: {
+                ...VALID_DOC.nested_blocks,
+                blocks: [{ id: 'APPLICATION-OMS-1', name: 'OMS' }],
+            },
+        });
+        expect(r.errors.some((e) => e.code === 'BL-006')).toBe(false);
+    });
+    it('BL-006: accepts the CAPABILITY V/H exception (CAPABILITY-V1.2)', () => {
+        const r = validateNestedBlocks({
+            ...VALID_DOC,
+            nested_blocks: {
+                ...VALID_DOC.nested_blocks,
+                blocks: [{ id: 'CAPABILITY-V1.2', name: 'Order intake' }],
+            },
+        });
+        expect(r.errors.some((e) => e.code === 'BL-006')).toBe(false);
+    });
+    it('BL-006: accepts free-form local labels (APPLICATION_LAYER, frontend, my-thing)', () => {
+        const r = validateNestedBlocks({
+            ...VALID_DOC,
+            nested_blocks: {
+                ...VALID_DOC.nested_blocks,
+                blocks: [
+                    { id: 'APPLICATION_LAYER', name: 'AL' },
+                    { id: 'my-thing', name: 'MT' },
+                    { id: 'FRONTEND', name: 'FE' },
+                ],
+            },
+        });
+        expect(r.errors.some((e) => e.code === 'BL-006')).toBe(false);
+    });
+    it('BL-007: rejects duplicate ids anywhere in the tree', () => {
+        const r = validateNestedBlocks({
+            ...VALID_DOC,
+            nested_blocks: {
+                ...VALID_DOC.nested_blocks,
+                blocks: [
+                    {
+                        id: 'A',
+                        name: 'A',
+                        children: [{ id: 'A', name: 'A again' }],
+                    },
+                ],
+            },
+        });
+        expect(r.errors.some((e) => e.code === 'BL-007' && /Duplicate/.test(e.message))).toBe(true);
+    });
+    it('BL-008: warns when nesting exceeds depth 5', () => {
+        // 6-deep chain: blocks[0] (depth 1) → c → c → c → c → c (depth 6)
+        let inner = { id: 'L6', name: 'L6' };
+        for (const id of ['L5', 'L4', 'L3', 'L2', 'L1']) {
+            inner = { id, name: id, children: [inner] };
+        }
+        const r = validateNestedBlocks({
+            ...VALID_DOC,
+            nested_blocks: { ...VALID_DOC.nested_blocks, blocks: [inner] },
+        });
+        expect(r.warnings.some((w) => w.code === 'BL-008')).toBe(true);
+        expect(r.valid).toBe(true);
+    });
+    it('BL-008: does not warn at exactly depth 5', () => {
+        let inner = { id: 'L5', name: 'L5' };
+        for (const id of ['L4', 'L3', 'L2', 'L1']) {
+            inner = { id, name: id, children: [inner] };
+        }
+        const r = validateNestedBlocks({
+            ...VALID_DOC,
+            nested_blocks: { ...VALID_DOC.nested_blocks, blocks: [inner] },
+        });
+        expect(r.warnings.some((w) => w.code === 'BL-008')).toBe(false);
+    });
+    it('BL-009: warns on an empty children array', () => {
+        const r = validateNestedBlocks({
+            ...VALID_DOC,
+            nested_blocks: {
+                ...VALID_DOC.nested_blocks,
+                blocks: [{ id: 'A', name: 'A', children: [] }],
+            },
+        });
+        expect(r.warnings.some((w) => w.code === 'BL-009')).toBe(true);
+        expect(r.valid).toBe(true);
+    });
+    it('happy path: surfaces no warnings on a clean document', () => {
+        const r = validateNestedBlocks(VALID_DOC);
+        expect(r.valid).toBe(true);
+        expect(r.warnings).toHaveLength(0);
+    });
+});
+describe('blocks examples (regression)', () => {
+    const files = fs.existsSync(EXAMPLES_DIR)
+        ? fs.readdirSync(EXAMPLES_DIR).filter((f) => f.endsWith('.yaml'))
+        : [];
+    expect(files.length).toBeGreaterThan(0);
+    for (const file of files) {
+        it(`validates tests/fixtures/notation-corpus/blocks/${file}`, () => {
+            const text = fs.readFileSync(path.join(EXAMPLES_DIR, file), 'utf8');
+            const parsed = yaml.load(text);
+            const r = validateNestedBlocks(parsed);
+            expect(r.errors).toEqual([]);
+            expect(r.valid).toBe(true);
+        });
+    }
+});

package/dist/blocks/index.d.ts

@@ -0,0 +1,4 @@
+export type { Block, NestedBlocksHeader, BlocksFile, BlocksLayoutOptions, LaidOutBlock, BlocksLayout, } from './types.js';
+export { validateNestedBlocks, isWellFormedBlock } from './validate.js';
+export type { ValidationError as BlocksValidationError, ValidationWarning as BlocksValidationWarning, ValidationResult as BlocksValidationResult, } from './validate.js';
+export { layoutNestedBlocks, iterateBlocks } from './layout.js';

package/dist/blocks/index.js

@@ -0,0 +1,2 @@
+export { validateNestedBlocks, isWellFormedBlock } from './validate.js';
+export { layoutNestedBlocks, iterateBlocks } from './layout.js';

package/dist/blocks/layout.d.ts

@@ -0,0 +1,4 @@
+import type { BlocksFile, BlocksLayout, BlocksLayoutOptions, LaidOutBlock } from './types.js';
+export declare function layoutNestedBlocks(file: BlocksFile, options?: BlocksLayoutOptions): BlocksLayout;
+/** Iterate every laid-out block (including nested children) in pre-order. */
+export declare function iterateBlocks(layout: BlocksLayout): Iterable<LaidOutBlock>;