@byline/core 3.20.4 → 4.0.0

package/dist/codegen/index.js

@@ -0,0 +1,431 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import { createHash } from 'node:crypto';
+const FORMAT_VERSION = 1;
+const HASH_DOMAIN = '@byline/core/codegen:collection-types:v1\n';
+const IMPORT_ORDER = ['JsonObject', 'JsonValue', 'RelatedDocumentValue', 'StoredFileValue'];
+function compareStrings(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+function sha256(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function quote(value) {
+    return `'${value.replace(/[\\'\b\f\n\r\t\v\0\u2028\u2029]/g, (character) => {
+        switch (character) {
+            case '\\':
+                return '\\\\';
+            case "'":
+                return "\\'";
+            case '\b':
+                return '\\b';
+            case '\f':
+                return '\\f';
+            case '\n':
+                return '\\n';
+            case '\r':
+                return '\\r';
+            case '\t':
+                return '\\t';
+            case '\v':
+                return '\\v';
+            case '\0':
+                return '\\0';
+            case '\u2028':
+                return '\\u2028';
+            case '\u2029':
+                return '\\u2029';
+            default:
+                return character;
+        }
+    })}'`;
+}
+function propertyKey(value) {
+    return /^[$_\p{ID_Start}](?:[$_\p{ID_Continue}]|\u200C|\u200D)*$/u.test(value)
+        ? value
+        : quote(value);
+}
+function normalizeIdentifier(value) {
+    const ascii = value
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2');
+    const words = ascii.match(/[A-Za-z0-9]+/g) ?? [];
+    const normalized = words
+        .map((word) => {
+        const lower = word.toLowerCase();
+        return `${lower[0]?.toUpperCase() ?? ''}${lower.slice(1)}`;
+    })
+        .join('');
+    if (normalized.length === 0)
+        return 'Unnamed';
+    return /^[0-9]/.test(normalized) ? `N${normalized}` : normalized;
+}
+function uniqueValues(values) {
+    return [...new Set(values)];
+}
+function assignNames(values, baseName, identity) {
+    const groups = new Map();
+    for (const value of values) {
+        const base = baseName(value);
+        const group = groups.get(base);
+        if (group)
+            group.push(value);
+        else
+            groups.set(base, [value]);
+    }
+    const result = new Map();
+    for (const [base, group] of groups) {
+        if (group.length === 1) {
+            const only = group[0];
+            if (only !== undefined)
+                result.set(only, base);
+            continue;
+        }
+        const ordered = [...group].sort((a, b) => compareStrings(identity(a), identity(b)));
+        const hashes = ordered.map((value) => sha256(identity(value)));
+        let suffixLength = 8;
+        while (suffixLength < 64 &&
+            new Set(hashes.map((hash) => hash.slice(0, suffixLength))).size !== hashes.length) {
+            suffixLength += 1;
+        }
+        for (const [index, value] of ordered.entries()) {
+            const hash = hashes[index];
+            if (hash === undefined)
+                continue;
+            const duplicateHashIndex = hashes.indexOf(hash);
+            const suffix = duplicateHashIndex === index ? hash.slice(0, suffixLength) : `${hash}_${index + 1}`;
+            result.set(value, `${base}_${suffix}`);
+        }
+    }
+    return result;
+}
+function assertObject(value, location) {
+    if (value === null || typeof value !== 'object') {
+        throw new Error(`emitCollectionTypes: expected an object at ${location}`);
+    }
+}
+function analyze(collections) {
+    const sortedCollections = [...collections].sort((a, b) => compareStrings(a.path, b.path));
+    const seenPaths = new Set();
+    const active = new Set();
+    const blocks = new Map();
+    const blockKeyByDefinition = new WeakMap();
+    function describeFieldSet(fields, location) {
+        if (!Array.isArray(fields)) {
+            throw new Error(`emitCollectionTypes: expected fields array at ${location}`);
+        }
+        if (active.has(fields))
+            throw new Error(`emitCollectionTypes: cycle detected at ${location}`);
+        active.add(fields);
+        const seenNames = new Set();
+        const descriptions = [];
+        for (const [index, fieldValue] of fields.entries()) {
+            const fieldLocation = `${location}[${index}]`;
+            assertObject(fieldValue, fieldLocation);
+            const field = fieldValue;
+            if (typeof field.name !== 'string') {
+                throw new Error(`emitCollectionTypes: expected field name at ${fieldLocation}`);
+            }
+            if (seenNames.has(field.name)) {
+                throw new Error(`emitCollectionTypes: duplicate sibling field ${quote(field.name)} at ${location}`);
+            }
+            seenNames.add(field.name);
+            descriptions.push(describeField(field, fieldLocation));
+        }
+        active.delete(fields);
+        return JSON.stringify(descriptions);
+    }
+    function describeBlock(blockValue, location) {
+        assertObject(blockValue, location);
+        const block = blockValue;
+        if (active.has(block))
+            throw new Error(`emitCollectionTypes: cycle detected at ${location}`);
+        active.add(block);
+        if (typeof block.blockType !== 'string') {
+            throw new Error(`emitCollectionTypes: expected blockType at ${location}`);
+        }
+        const fieldsSignature = describeFieldSet(block.fields, `${location}.fields`);
+        const key = JSON.stringify([block.blockType, fieldsSignature]);
+        blockKeyByDefinition.set(block, key);
+        if (!blocks.has(key)) {
+            blocks.set(key, { blockType: block.blockType, fields: block.fields, key });
+        }
+        active.delete(block);
+        return key;
+    }
+    function describeField(field, location) {
+        if (active.has(field))
+            throw new Error(`emitCollectionTypes: cycle detected at ${location}`);
+        active.add(field);
+        const modifiers = [field.optional === true, field.localized === true];
+        let specific;
+        switch (field.type) {
+            case 'array':
+            case 'group':
+                specific = describeFieldSet(field.fields, `${location}.fields`);
+                break;
+            case 'blocks': {
+                if (!Array.isArray(field.blocks)) {
+                    throw new Error(`emitCollectionTypes: expected blocks array at ${location}.blocks`);
+                }
+                if (active.has(field.blocks)) {
+                    throw new Error(`emitCollectionTypes: cycle detected at ${location}.blocks`);
+                }
+                active.add(field.blocks);
+                const seenBlockTypes = new Set();
+                specific = field.blocks.map((block, index) => {
+                    if (seenBlockTypes.has(block.blockType)) {
+                        throw new Error(`emitCollectionTypes: duplicate local block type ${quote(block.blockType)} at ${location}`);
+                    }
+                    seenBlockTypes.add(block.blockType);
+                    return describeBlock(block, `${location}.blocks[${index}]`);
+                });
+                active.delete(field.blocks);
+                break;
+            }
+            case 'select':
+                specific = uniqueValues(field.options.map((option) => option.value));
+                break;
+            case 'relation':
+                specific = field.hasMany === true;
+                break;
+            case 'boolean':
+            case 'checkbox':
+            case 'counter':
+            case 'date':
+            case 'datetime':
+            case 'decimal':
+            case 'file':
+            case 'float':
+            case 'image':
+            case 'integer':
+            case 'json':
+            case 'object':
+            case 'richText':
+            case 'text':
+            case 'textArea':
+            case 'time':
+                specific = null;
+                break;
+            default: {
+                const exhaustive = field;
+                throw new Error(`emitCollectionTypes: unsupported runtime field type ${quote(String(exhaustive.type))} at ${location}`);
+            }
+        }
+        active.delete(field);
+        return JSON.stringify([field.name, field.type, ...modifiers, specific]);
+    }
+    for (const collection of sortedCollections) {
+        assertObject(collection, 'collections[]');
+        if (typeof collection.path !== 'string') {
+            throw new Error('emitCollectionTypes: expected collection path');
+        }
+        if (seenPaths.has(collection.path)) {
+            throw new Error(`emitCollectionTypes: duplicate collection path ${quote(collection.path)}`);
+        }
+        seenPaths.add(collection.path);
+        describeFieldSet(collection.fields, `collection ${quote(collection.path)}.fields`);
+    }
+    return { blockKeyByDefinition, blocks, collections: sortedCollections };
+}
+function indentLines(lines, spaces) {
+    const indentation = ' '.repeat(spaces);
+    return lines.map((line) => `${indentation}${line}`);
+}
+function objectType(properties) {
+    if (properties.length === 0)
+        return ['{}'];
+    const lines = ['{'];
+    for (const property of properties) {
+        const first = property.value[0] ?? 'never';
+        const suffix = property.optional ? ' | undefined' : '';
+        if (property.value.length === 1) {
+            lines.push(`  ${propertyKey(property.key)}${property.optional ? '?' : ''}: ${first}${suffix}`);
+        }
+        else {
+            lines.push(`  ${propertyKey(property.key)}${property.optional ? '?' : ''}: ${first}`);
+            lines.push(...indentLines(property.value.slice(1), 2));
+            if (suffix)
+                lines[lines.length - 1] = `${lines[lines.length - 1]}${suffix}`;
+        }
+    }
+    lines.push('}');
+    return lines;
+}
+function wrapGeneric(name, value) {
+    if (value.length === 1)
+        return [`${name}<${value[0]}>`];
+    return [`${name}<`, ...indentLines(value, 2), '>'];
+}
+function wrapLocaleMap(value) {
+    if (value.length === 1)
+        return [`{ [locale: string]: ${value[0]} }`];
+    return ['{', `  [locale: string]: ${value[0]}`, ...indentLines(value.slice(1), 2), '}'];
+}
+function emitBody(analysis) {
+    const imports = new Set();
+    const rawBlocks = [...analysis.blocks.values()];
+    const blockNames = assignNames(rawBlocks, (block) => {
+        const stem = normalizeIdentifier(block.blockType);
+        return stem.endsWith('Block') ? `${stem}Data` : `${stem}BlockData`;
+    }, (block) => block.key);
+    const blocks = rawBlocks
+        .map((block) => ({ ...block, alias: blockNames.get(block) ?? 'UnnamedBlock' }))
+        .sort((a, b) => compareStrings(a.alias, b.alias));
+    const collectionNames = assignNames(analysis.collections, (collection) => `${normalizeIdentifier(collection.path)}Fields`, (collection) => collection.path);
+    const collectionContracts = analysis.collections.map((definition) => ({
+        alias: collectionNames.get(definition) ?? 'UnnamedFields',
+        definition,
+    }));
+    const blockAliasByKey = new Map(blocks.map((block) => [block.key, block.alias]));
+    function fieldSetType(fields, mode) {
+        return objectType(fields.map((field) => ({
+            key: field.name,
+            optional: field.optional === true,
+            value: fieldType(field, mode),
+        })));
+    }
+    function fieldType(field, mode) {
+        let value;
+        switch (field.type) {
+            case 'array':
+                value = wrapGeneric('Array', objectType([
+                    { key: '_id', value: ['string'] },
+                    ...field.fields.map((child) => ({
+                        key: child.name,
+                        optional: child.optional === true,
+                        value: fieldType(child, mode),
+                    })),
+                ]));
+                break;
+            case 'blocks': {
+                const aliases = field.blocks.map((block) => {
+                    const key = analysis.blockKeyByDefinition.get(block);
+                    const alias = key === undefined ? undefined : blockAliasByKey.get(key);
+                    if (alias === undefined) {
+                        throw new Error(`emitCollectionTypes: missing analyzed block ${quote(block.blockType)}`);
+                    }
+                    return mode === 'all' ? `${alias}AllLocales` : alias;
+                });
+                value = [`Array<${aliases.length === 0 ? 'never' : aliases.join(' | ')}>`];
+                break;
+            }
+            case 'group':
+                value = fieldSetType(field.fields, mode);
+                break;
+            case 'select':
+                value = [
+                    field.options.length === 0
+                        ? 'never'
+                        : uniqueValues(field.options.map((option) => option.value))
+                            .map(quote)
+                            .join(' | '),
+                ];
+                break;
+            case 'relation':
+                imports.add('RelatedDocumentValue');
+                value = [field.hasMany === true ? 'RelatedDocumentValue[]' : 'RelatedDocumentValue'];
+                break;
+            case 'boolean':
+            case 'checkbox':
+                value = ['boolean'];
+                break;
+            case 'date':
+            case 'datetime':
+                value = ['Date'];
+                break;
+            case 'decimal':
+            case 'text':
+            case 'textArea':
+            case 'time':
+                value = ['string'];
+                break;
+            case 'counter':
+            case 'float':
+            case 'integer':
+                value = ['number'];
+                break;
+            case 'json':
+            case 'richText':
+                imports.add('JsonValue');
+                value = ['JsonValue'];
+                break;
+            case 'object':
+                imports.add('JsonObject');
+                value = ['JsonObject'];
+                break;
+            case 'file':
+            case 'image':
+                imports.add('StoredFileValue');
+                value = ['StoredFileValue'];
+                break;
+            default: {
+                const exhaustive = field;
+                throw new Error(`emitCollectionTypes: unsupported runtime field type ${String(exhaustive)}`);
+            }
+        }
+        return mode === 'all' && field.localized === true ? wrapLocaleMap(value) : value;
+    }
+    const declarations = [];
+    for (const block of blocks) {
+        const baseProperties = [
+            { key: '_id', value: ['string'] },
+            { key: '_type', value: [quote(block.blockType)] },
+        ];
+        declarations.push(`export type ${block.alias} = ${objectType([
+            ...baseProperties,
+            ...block.fields.map((field) => ({
+                key: field.name,
+                optional: field.optional === true,
+                value: fieldType(field, 'single'),
+            })),
+        ]).join('\n')}`, '', `export type ${block.alias}AllLocales = ${objectType([
+            ...baseProperties,
+            ...block.fields.map((field) => ({
+                key: field.name,
+                optional: field.optional === true,
+                value: fieldType(field, 'all'),
+            })),
+        ]).join('\n')}`, '');
+    }
+    for (const collection of [...collectionContracts].sort((a, b) => compareStrings(a.alias, b.alias))) {
+        declarations.push(`export type ${collection.alias} = ${fieldSetType(collection.definition.fields, 'single').join('\n')}`, '', `export type ${collection.alias}AllLocales = ${fieldSetType(collection.definition.fields, 'all').join('\n')}`, '');
+    }
+    declarations.push('export type CollectionFieldsByPath = {');
+    for (const collection of collectionContracts) {
+        declarations.push(`  ${propertyKey(collection.definition.path)}: ${collection.alias}`);
+    }
+    declarations.push('}', '', 'export type CollectionFieldsAllLocalesByPath = {');
+    for (const collection of collectionContracts) {
+        declarations.push(`  ${propertyKey(collection.definition.path)}: ${collection.alias}AllLocales`);
+    }
+    declarations.push('}', '', 'export type CollectionPath = keyof CollectionFieldsByPath');
+    const usedImports = IMPORT_ORDER.filter((name) => imports.has(name));
+    const importLines = usedImports.length === 0
+        ? []
+        : ['import type {', ...usedImports.map((name) => `  ${name},`), "} from '@byline/core'", ''];
+    return `${[...importLines, ...declarations].join('\n').replace(/\n+$/, '')}\n`;
+}
+/**
+ * Emit deterministic application collection types from evaluated runtime definitions.
+ * The returned hash is SHA-256 over the versioned format domain and generated module body.
+ */
+export function emitCollectionTypes(collections) {
+    const body = emitBody(analyze(collections));
+    const hash = sha256(`${HASH_DOMAIN}${body}`);
+    const header = [
+        '// Generated by @byline/core/codegen',
+        `// Format version: ${FORMAT_VERSION}`,
+        `// Hash: ${hash}`,
+        '',
+        '',
+    ].join('\n');
+    return { source: `${header}${body}`, hash };
+}

package/dist/codegen/index.test.node.d.ts

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

package/dist/codegen/index.test.node.js

@@ -0,0 +1,230 @@
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, expectTypeOf, it } from 'vitest';
+import { AllFieldsCollection, AllFieldsCollections, } from './fixtures/all-fields.js';
+import { emitCollectionTypes } from './index.js';
+const fixtureDirectory = resolve(dirname(fileURLToPath(import.meta.url)), 'fixtures');
+function collection(path, fields) {
+    return { path, labels: { singular: path, plural: path }, fields };
+}
+describe('emitCollectionTypes', () => {
+    it('matches the checked-in all-fields fixture and canonical inferred contracts exactly', () => {
+        const result = emitCollectionTypes(AllFieldsCollections);
+        const fixture = readFileSync(resolve(fixtureDirectory, 'all-fields.generated.txt'), 'utf8');
+        expect(result.source).toBe(fixture);
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf().toEqualTypeOf();
+    });
+    it('emits a versioned header, verifiable body hash, and canonical formatting', () => {
+        const { source, hash } = emitCollectionTypes([collection('plain', [])]);
+        const body = source.split('\n').slice(4).join('\n');
+        expect(source).toMatch(/^\/\/ Generated by @byline\/core\/codegen\n\/\/ Format version: 1\n\/\/ Hash: [a-f0-9]{64}\n\n/);
+        expect(hash).toBe(createHash('sha256').update(`@byline/core/codegen:collection-types:v1\n${body}`).digest('hex'));
+        expect(source).toContain(`// Hash: ${hash}`);
+        expect(source.endsWith('\n')).toBe(true);
+        expect(source).not.toContain('\r');
+        expect(source).not.toContain(';');
+    });
+    it('sorts collections and declarations without changing field, select, or block union order', () => {
+        const alpha = collection('alpha', [
+            {
+                name: 'choice',
+                type: 'select',
+                options: [
+                    { label: 'Zulu', value: 'zulu' },
+                    { label: 'Duplicate Zulu', value: 'zulu' },
+                    { label: 'Alpha', value: 'alpha' },
+                ],
+            },
+            {
+                name: 'content',
+                type: 'blocks',
+                blocks: [
+                    { blockType: 'zulu', fields: [] },
+                    { blockType: 'alpha', fields: [] },
+                ],
+            },
+        ]);
+        const zulu = collection('zulu', [{ name: 'title', type: 'text' }]);
+        const forward = emitCollectionTypes([zulu, alpha]);
+        const reverse = emitCollectionTypes([alpha, zulu]);
+        expect(forward).toEqual(reverse);
+        expect(forward.source).toContain(`choice: 'zulu' | 'alpha'`);
+        expect(forward.source).toContain(`content: Array<ZuluBlockData | AlphaBlockData>`);
+        expect(forward.source.indexOf(`alpha: AlphaFields`)).toBeLessThan(forward.source.indexOf(`zulu: ZuluFields`));
+    });
+    it('normalizes identifiers and quotes only invalid property keys', () => {
+        const source = emitCollectionTypes([
+            collection('API_response', [
+                { name: 'validKey', type: 'text' },
+                { name: 'café', type: 'text' },
+                { name: 'not-valid', type: 'text' },
+                {
+                    name: 'choice',
+                    type: 'select',
+                    options: [
+                        { label: 'First', value: 'first' },
+                        { label: 'First duplicate', value: 'first' },
+                        { label: 'Second', value: 'second' },
+                    ],
+                },
+                {
+                    name: 'content',
+                    type: 'blocks',
+                    blocks: [{ blockType: 'photoBlock', fields: [] }],
+                },
+            ]),
+            collection('photoBlock', []),
+            collection('café—API_response', []),
+        ]).source;
+        expect(source).toContain('export type ApiResponseFields = {');
+        expect(source).toContain('export type PhotoBlockFields = {}');
+        expect(source).toContain('export type CafeApiResponseFields = {}');
+        expect(source).toContain('export type PhotoBlockData = {');
+        expect(source).toContain('validKey: string');
+        expect(source).toContain('café: string');
+        expect(source).toContain(`'not-valid': string`);
+        expect(source).toContain(`choice: 'first' | 'second'`);
+        expect(source).toContain('API_response: ApiResponseFields');
+        expect(source).toContain(`'café—API_response': CafeApiResponseFields`);
+    });
+    it('ignores non-type metadata but changes output for type-significant values', () => {
+        const base = collection('articles', [
+            { name: 'title', type: 'text' },
+            { name: 'kind', type: 'select', options: [{ label: 'News', value: 'news' }] },
+        ]);
+        const metadataOnly = {
+            ...base,
+            labels: { singular: 'Story', plural: 'Stories' },
+            version: 99,
+            fields: [
+                { name: 'title', type: 'text', label: 'Headline', helpText: 'Displayed prominently' },
+                {
+                    name: 'kind',
+                    type: 'select',
+                    label: 'Kind',
+                    options: [{ label: 'Article', value: 'news' }],
+                },
+            ],
+        };
+        const changed = collection('articles', [
+            { name: 'title', type: 'integer' },
+            { name: 'kind', type: 'select', options: [{ label: 'News', value: 'report' }] },
+        ]);
+        expect(emitCollectionTypes([metadataOnly])).toEqual(emitCollectionTypes([base]));
+        expect(emitCollectionTypes([changed]).hash).not.toBe(emitCollectionTypes([base]).hash);
+    });
+    it('imports only used canonical types in fixed order', () => {
+        const noImports = emitCollectionTypes([
+            collection('simple', [{ name: 'title', type: 'text' }]),
+        ]).source;
+        const selectedImports = emitCollectionTypes([
+            collection('typed', [
+                { name: 'data', type: 'json' },
+                { name: 'relation', type: 'relation', targetCollection: 'simple' },
+                { name: 'file', type: 'file' },
+            ]),
+        ]).source;
+        expect(noImports).not.toContain('import type');
+        expect(selectedImports).toContain("import type {\n  JsonValue,\n  RelatedDocumentValue,\n  StoredFileValue,\n} from '@byline/core'");
+        expect(selectedImports).not.toContain('JsonObject');
+    });
+    it('reuses identical block contracts and suffixes incompatible normalized names', () => {
+        const sharedA = { blockType: 'hero', fields: [{ name: 'title', type: 'text' }] };
+        const sharedB = {
+            blockType: 'hero',
+            fields: [{ name: 'title', type: 'text', label: 'Ignored metadata' }],
+        };
+        const incompatible = {
+            blockType: 'hero',
+            fields: [{ name: 'title', type: 'integer' }],
+        };
+        const source = emitCollectionTypes([
+            collection('foo-bar', [{ name: 'content', type: 'blocks', blocks: [sharedA] }]),
+            collection('foo_bar', [{ name: 'content', type: 'blocks', blocks: [sharedB] }]),
+            collection('other', [{ name: 'content', type: 'blocks', blocks: [incompatible] }]),
+        ]).source;
+        expect(source.match(/export type HeroBlockData_[a-f0-9]+ =/g)).toHaveLength(2);
+        expect(source.match(/export type FooBarFields_[a-f0-9]+ =/g)).toHaveLength(2);
+        expect(source.match(/_type: 'hero'/g)).toHaveLength(4);
+    });
+    it('escapes property keys, block discriminants, and select literals', () => {
+        const source = emitCollectionTypes([AllFieldsCollection]).source;
+        expect(source).toContain(`'content\\'s':`);
+        expect(source).toContain(`_type: 'quote\\'block'`);
+        expect(source).toContain(`'tone\\'choice'?: 'calm' | 'author\\'s' | undefined`);
+    });
+    it('does not mutate definitions and accepts deeply frozen input', () => {
+        const field = Object.freeze({ name: 'title', type: 'text' });
+        const fields = Object.freeze([field]);
+        const definition = Object.freeze({
+            path: 'frozen',
+            labels: Object.freeze({ singular: 'Frozen', plural: 'Frozen' }),
+            fields,
+        });
+        const before = JSON.stringify(definition);
+        emitCollectionTypes(Object.freeze([definition]));
+        expect(JSON.stringify(definition)).toBe(before);
+    });
+    it('rejects duplicate collection paths', () => {
+        expect(() => emitCollectionTypes([collection('same', []), collection('same', [])])).toThrow("duplicate collection path 'same'");
+    });
+    it('rejects duplicate sibling fields at any nesting level', () => {
+        expect(() => emitCollectionTypes([
+            collection('duplicates', [
+                {
+                    name: 'group',
+                    type: 'group',
+                    fields: [
+                        { name: 'same', type: 'text' },
+                        { name: 'same', type: 'integer' },
+                    ],
+                },
+            ]),
+        ])).toThrow("duplicate sibling field 'same'");
+    });
+    it('rejects duplicate block types within one blocks field', () => {
+        expect(() => emitCollectionTypes([
+            collection('duplicates', [
+                {
+                    name: 'content',
+                    type: 'blocks',
+                    blocks: [
+                        { blockType: 'hero', fields: [] },
+                        { blockType: 'hero', fields: [{ name: 'title', type: 'text' }] },
+                    ],
+                },
+            ]),
+        ])).toThrow("duplicate local block type 'hero'");
+    });
+    it('rejects cyclic runtime definitions', () => {
+        const fields = [];
+        fields.push({ name: 'recursive', type: 'group', fields });
+        expect(() => emitCollectionTypes([collection('cycle', fields)])).toThrow('cycle detected');
+    });
+    it('rejects unsupported runtime field types', () => {
+        expect(() => emitCollectionTypes([
+            collection('unsupported', [{ name: 'future', type: 'future' }]),
+        ])).toThrow("unsupported runtime field type 'future'");
+    });
+    it('is exposed only through the published codegen subpath', () => {
+        const packageJson = JSON.parse(readFileSync(resolve(fixtureDirectory, '../../../package.json'), 'utf8'));
+        const rootSource = readFileSync(resolve(fixtureDirectory, '../../index.ts'), 'utf8');
+        expect(packageJson.exports['./codegen']).toEqual({
+            types: './dist/codegen/index.d.ts',
+            import: './dist/codegen/index.js',
+            require: './dist/codegen/index.js',
+        });
+        expect(rootSource).not.toMatch(/codegen/);
+    });
+});