@loj-lang/rdsl-compiler 0.5.0

package/dist/parser.js

@@ -0,0 +1,1335 @@
+/**
+ * ReactDSL Parser
+ *
+ * Parses .rdsl files (strict YAML subset) into a raw AST.
+ *
+ * Restrictions vs full YAML:
+ *  - No anchors/aliases
+ *  - No merge keys
+ *  - No custom tags
+ *  - No implicit bool/date coercions
+ */
+import { parseDocument, LineCounter, isAlias, isMap, isSeq, isPair, isScalar } from 'yaml';
+import { CANONICAL_RDSL_SOURCE_SUFFIX, describeRdslSourceSuffixes, } from './source-files.js';
+// ─── Decorator Parser ────────────────────────────────────────────
+const DECORATOR_REGEX = /@(\w+)(?:\(([^)]*)\))?/g;
+export function parseDecorators(input) {
+    const decorators = [];
+    let baseName = input;
+    // Extract all @decorator(...) patterns
+    const firstAt = input.indexOf('@');
+    if (firstAt > 0) {
+        baseName = input.substring(0, firstAt).trim();
+        const decoratorPart = input.substring(firstAt);
+        let match;
+        DECORATOR_REGEX.lastIndex = 0;
+        while ((match = DECORATOR_REGEX.exec(decoratorPart)) !== null) {
+            decorators.push({
+                name: match[1],
+                args: match[2] || undefined,
+            });
+        }
+    }
+    else if (firstAt === 0) {
+        // Entire string is decorators (shouldn't happen for fields, but handle gracefully)
+        baseName = '';
+        let match;
+        DECORATOR_REGEX.lastIndex = 0;
+        while ((match = DECORATOR_REGEX.exec(input)) !== null) {
+            decorators.push({
+                name: match[1],
+                args: match[2] || undefined,
+            });
+        }
+    }
+    return { baseName, decorators };
+}
+// ─── Field Type Parser ───────────────────────────────────────────
+export function parseFieldType(expr) {
+    const enumMatch = expr.match(/^enum\(([^)]+)\)$/);
+    if (enumMatch) {
+        const values = enumMatch[1].split(',').map(v => v.trim());
+        return { typeName: 'enum', enumValues: values };
+    }
+    return { typeName: expr.trim() };
+}
+// ─── Effect Parser ───────────────────────────────────────────────
+export function parseEffect(entry) {
+    if (typeof entry === 'object' && entry !== null) {
+        const obj = entry;
+        const keys = Object.keys(obj);
+        if (keys.length === 1) {
+            const type = keys[0];
+            const value = obj[type];
+            if (type === 'toast' && value && typeof value === 'object' && !Array.isArray(value)) {
+                return {
+                    type,
+                    value: parseToastDescriptorObject(value),
+                };
+            }
+            return { type, value: String(value) };
+        }
+    }
+    return null;
+}
+// ─── Column/Field Entry Parser ───────────────────────────────────
+export function parseColumnEntry(entry, sourceSpan) {
+    if (typeof entry === 'string') {
+        const { baseName, decorators } = parseDecorators(entry);
+        return { field: baseName, decorators, sourceSpan };
+    }
+    // Shouldn't normally happen in valid DSL, but handle object form
+    if (typeof entry === 'object' && entry !== null) {
+        const obj = entry;
+        return {
+            field: String(obj['field'] || ''),
+            decorators: [],
+            sourceSpan,
+        };
+    }
+    return { field: String(entry), decorators: [], sourceSpan };
+}
+export function parseFormFieldEntry(entry, fileName, lineCounter) {
+    if (isScalar(entry)) {
+        const value = String(entry.value);
+        if (value.includes('@')) {
+            return parseColumnEntry(value, getNodeSpan(entry, fileName, lineCounter));
+        }
+        return value;
+    }
+    if (isMap(entry)) {
+        const map = entry;
+        const fieldValue = getMapValue(map, 'field');
+        const rawField = fieldValue === undefined
+            ? ''
+            : String(isScalar(fieldValue) ? fieldValue.value : fieldValue);
+        const parsed = parseColumnEntry(rawField, getNodeSpan(entry, fileName, lineCounter));
+        const rules = parseRules(map, fileName, lineCounter);
+        return {
+            ...parsed,
+            rules,
+            sourceSpan: getNodeSpan(entry, fileName, lineCounter),
+        };
+    }
+    return String(entry);
+}
+// ─── Action Entry Parser ─────────────────────────────────────────
+export function parseActionEntry(entry, sourceSpan) {
+    if (typeof entry === 'string') {
+        const { baseName, decorators } = parseDecorators(entry);
+        return { name: baseName, decorators, sourceSpan };
+    }
+    return { name: String(entry), decorators: [], sourceSpan };
+}
+export function parse(source, fileName = `app${CANONICAL_RDSL_SOURCE_SUFFIX}`) {
+    const errors = [];
+    const ast = {
+        imports: [],
+        models: [],
+        resources: [],
+        readModels: [],
+        pages: [],
+    };
+    let doc;
+    const lineCounter = new LineCounter();
+    const normalizedSource = preprocessRelationTypeExprs(source);
+    try {
+        doc = parseDocument(normalizedSource, {
+            // Strict subset: reject YAML features we don't support
+            merge: false,
+            uniqueKeys: true,
+            lineCounter,
+        });
+    }
+    catch (err) {
+        errors.push({
+            message: `YAML parse error: ${err instanceof Error ? err.message : String(err)}`,
+        });
+        return { ast, errors };
+    }
+    // Check for YAML-level errors
+    for (const err of doc.errors) {
+        errors.push({ message: err.message, line: err.pos?.[0] });
+    }
+    const root = doc.contents;
+    detectUnsupportedYamlFeatures(root, errors);
+    if (errors.length > 0)
+        return { ast, errors };
+    if (!isMap(root)) {
+        errors.push({ message: 'Root document must be a YAML mapping' });
+        return { ast, errors };
+    }
+    // Walk top-level keys
+    for (const pair of root.items) {
+        if (!isPair(pair) || !isScalar(pair.key))
+            continue;
+        const key = String(pair.key.value);
+        if (key === 'app') {
+            ast.app = parseAppBlock(pair.value, fileName, lineCounter, getPairSpan(pair, fileName, lineCounter));
+        }
+        else if (key === 'compiler') {
+            ast.compiler = parseCompilerBlock(pair.value, fileName, lineCounter, errors, getPairSpan(pair, fileName, lineCounter));
+        }
+        else if (key === 'imports') {
+            ast.imports = parseImportsBlock(pair.value, fileName, lineCounter, errors, getPairSpan(pair, fileName, lineCounter));
+        }
+        else if (key.startsWith('model ')) {
+            const modelName = key.substring(6).trim();
+            const model = parseModelBlock(modelName, pair.value, fileName, lineCounter, getPairSpan(pair, fileName, lineCounter));
+            if (model)
+                ast.models.push(model);
+        }
+        else if (key.startsWith('resource ')) {
+            const resourceName = key.substring(9).trim();
+            const resource = parseResourceBlock(resourceName, pair.value, fileName, lineCounter, errors, getPairSpan(pair, fileName, lineCounter));
+            if (resource)
+                ast.resources.push(resource);
+        }
+        else if (key.startsWith('readModel ')) {
+            const readModelName = key.substring('readModel '.length).trim();
+            const readModel = parseReadModelBlock(readModelName, pair.value, fileName, lineCounter, errors, getPairSpan(pair, fileName, lineCounter));
+            if (readModel)
+                ast.readModels.push(readModel);
+        }
+        else if (key.startsWith('page ')) {
+            const pageName = key.substring(5).trim();
+            const page = parsePageBlock(pageName, pair.value, fileName, lineCounter, getPairSpan(pair, fileName, lineCounter));
+            if (page)
+                ast.pages.push(page);
+        }
+        else {
+            errors.push({ message: `Unknown top-level key: "${key}"` });
+        }
+    }
+    return { ast, errors };
+}
+function preprocessRelationTypeExprs(source) {
+    return source.replace(/^(\s*[A-Za-z_][A-Za-z0-9_]*\s*:\s*)(hasMany\([^#\n]*\)(?:\s+@\w+(?:\([^)]*\))?)*)((?:\s+#.*)?)$/gm, (_match, prefix, expr, suffix) => {
+        const trimmed = expr.trim();
+        if (trimmed.startsWith('"') || trimmed.startsWith('\'')) {
+            return `${prefix}${expr}${suffix}`;
+        }
+        const escaped = trimmed
+            .replace(/\\/g, '\\\\')
+            .replace(/"/g, '\\"');
+        return `${prefix}"${escaped}"${suffix}`;
+    });
+}
+function detectUnsupportedYamlFeatures(node, errors) {
+    if (!node || typeof node !== 'object')
+        return;
+    if (isAlias(node)) {
+        errors.push({ message: `YAML aliases are not supported in ${describeRdslSourceSuffixes()} files` });
+        return;
+    }
+    const maybeAnchored = node;
+    if (maybeAnchored.anchor) {
+        errors.push({ message: `YAML anchors are not supported in ${describeRdslSourceSuffixes()} files` });
+    }
+    if (isPair(node)) {
+        const pair = node;
+        detectUnsupportedYamlFeatures(pair.key, errors);
+        detectUnsupportedYamlFeatures(pair.value, errors);
+        return;
+    }
+    if (isMap(node) || isSeq(node)) {
+        const coll = node;
+        for (const item of coll.items) {
+            detectUnsupportedYamlFeatures(item, errors);
+        }
+    }
+}
+// ─── Block Parsers ───────────────────────────────────────────────
+function getScalarValue(node) {
+    if (isScalar(node))
+        return String(node.value);
+    return undefined;
+}
+function getMapValue(map, key) {
+    const pair = getMapPair(map, key);
+    return pair?.value;
+}
+function getMapPair(map, key) {
+    for (const pair of map.items) {
+        if (isPair(pair) && isScalar(pair.key) && String(pair.key.value) === key) {
+            return pair;
+        }
+    }
+    return undefined;
+}
+function getNodeSpan(node, fileName, lineCounter) {
+    if (!node || typeof node !== 'object')
+        return undefined;
+    const rangedNode = node;
+    if (!rangedNode.range)
+        return undefined;
+    return rangeToSourceSpan(rangedNode.range, fileName, lineCounter);
+}
+function getPairSpan(pair, fileName, lineCounter) {
+    if (!pair)
+        return undefined;
+    const keyRange = isScalar(pair.key) || (pair.key && typeof pair.key === 'object' && 'range' in pair.key)
+        ? pair.key.range
+        : undefined;
+    const valueRange = pair.value && typeof pair.value === 'object' && 'range' in pair.value
+        ? pair.value.range
+        : undefined;
+    if (keyRange && valueRange) {
+        return rangeToSourceSpan([keyRange[0], valueRange[1]], fileName, lineCounter);
+    }
+    if (valueRange) {
+        return rangeToSourceSpan(valueRange, fileName, lineCounter);
+    }
+    if (keyRange) {
+        return rangeToSourceSpan(keyRange, fileName, lineCounter);
+    }
+    return undefined;
+}
+function rangeToSourceSpan(range, file, lineCounter) {
+    const start = lineCounter.linePos(range[0]);
+    const end = lineCounter.linePos(range[1]);
+    return {
+        file,
+        startLine: start.line,
+        startCol: start.col,
+        endLine: end.line,
+        endCol: end.col,
+    };
+}
+function parseAppBlock(node, fileName, lineCounter, sourceSpan) {
+    const app = { name: 'Untitled', sourceSpan };
+    if (!isMap(node))
+        return app;
+    const map = node;
+    const name = getMapValue(map, 'name');
+    if (name !== undefined)
+        app.name = String(isScalar(name) ? name.value : name);
+    const theme = getMapValue(map, 'theme');
+    if (theme !== undefined)
+        app.theme = String(isScalar(theme) ? theme.value : theme);
+    const auth = getMapValue(map, 'auth');
+    if (auth !== undefined)
+        app.auth = String(isScalar(auth) ? auth.value : auth);
+    const style = getMapValue(map, 'style');
+    if (style !== undefined)
+        app.style = String(isScalar(style) ? style.value : style);
+    const seo = getMapValue(map, 'seo');
+    if (isMap(seo)) {
+        app.seo = parseAppSeoBlock(seo, fileName, lineCounter);
+    }
+    // Parse navigation
+    const nav = getMapValue(map, 'navigation');
+    if (isSeq(nav)) {
+        app.navigation = [];
+        for (const item of nav.items) {
+            if (isMap(item)) {
+                const group = parseNavGroup(item, fileName, lineCounter);
+                if (group)
+                    app.navigation.push(group);
+            }
+        }
+    }
+    return app;
+}
+function parseAppSeoBlock(map, fileName, lineCounter) {
+    const seo = {
+        sourceSpan: getNodeSpan(map, fileName, lineCounter),
+    };
+    const siteName = getMapValue(map, 'siteName');
+    if (siteName !== undefined)
+        seo.siteName = parseMessageLikeNode(siteName, fileName, lineCounter);
+    const defaultTitle = getMapValue(map, 'defaultTitle');
+    if (defaultTitle !== undefined)
+        seo.defaultTitle = parseMessageLikeNode(defaultTitle, fileName, lineCounter);
+    const titleTemplate = getMapValue(map, 'titleTemplate');
+    if (titleTemplate !== undefined)
+        seo.titleTemplate = parseMessageLikeNode(titleTemplate, fileName, lineCounter);
+    const defaultDescription = getMapValue(map, 'defaultDescription');
+    if (defaultDescription !== undefined)
+        seo.defaultDescription = parseMessageLikeNode(defaultDescription, fileName, lineCounter);
+    const defaultImage = getMapValue(map, 'defaultImage');
+    if (defaultImage !== undefined)
+        seo.defaultImage = String(isScalar(defaultImage) ? defaultImage.value : defaultImage);
+    const favicon = getMapValue(map, 'favicon');
+    if (favicon !== undefined)
+        seo.favicon = String(isScalar(favicon) ? favicon.value : favicon);
+    return seo;
+}
+function parsePageSeoBlock(map, fileName, lineCounter) {
+    const seo = {
+        sourceSpan: getNodeSpan(map, fileName, lineCounter),
+    };
+    const description = getMapValue(map, 'description');
+    if (description !== undefined)
+        seo.description = parseMessageLikeNode(description, fileName, lineCounter);
+    const canonicalPath = getMapValue(map, 'canonicalPath');
+    if (canonicalPath !== undefined)
+        seo.canonicalPath = String(isScalar(canonicalPath) ? canonicalPath.value : canonicalPath);
+    const image = getMapValue(map, 'image');
+    if (image !== undefined)
+        seo.image = String(isScalar(image) ? image.value : image);
+    const noIndex = getMapValue(map, 'noIndex');
+    if (isScalar(noIndex)) {
+        seo.noIndex = Boolean(noIndex.value);
+    }
+    else if (typeof noIndex === 'boolean') {
+        seo.noIndex = noIndex;
+    }
+    return seo;
+}
+function parseCompilerBlock(node, fileName, lineCounter, errors, sourceSpan) {
+    const compiler = { sourceSpan };
+    if (!isMap(node))
+        return compiler;
+    const map = node;
+    for (const pair of map.items) {
+        if (!isPair(pair) || !isScalar(pair.key))
+            continue;
+        const key = String(pair.key.value);
+        if (key !== 'target') {
+            const span = getPairSpan(pair, fileName, lineCounter);
+            errors.push({
+                message: `Unknown compiler key: "${key}"`,
+                line: span?.startLine,
+                col: span?.startCol,
+            });
+            continue;
+        }
+        if (pair.value !== undefined) {
+            compiler.target = String(isScalar(pair.value) ? pair.value.value : pair.value);
+        }
+    }
+    return compiler;
+}
+function parseImportsBlock(node, fileName, lineCounter, errors, sourceSpan) {
+    if (!isSeq(node)) {
+        errors.push({
+            message: `imports must be a YAML sequence of relative ${describeRdslSourceSuffixes()} file paths`,
+            line: sourceSpan?.startLine,
+            col: sourceSpan?.startCol,
+        });
+        return [];
+    }
+    const imports = [];
+    for (const item of node.items) {
+        const value = getScalarValue(item);
+        const itemSpan = getNodeSpan(item, fileName, lineCounter);
+        if (value === undefined || value.length === 0) {
+            errors.push({
+                message: 'imports entries must be scalar file paths',
+                line: itemSpan?.startLine,
+                col: itemSpan?.startCol,
+            });
+            continue;
+        }
+        imports.push(value);
+    }
+    return imports;
+}
+function parseNavGroup(map, fileName, lineCounter) {
+    const groupVal = getMapValue(map, 'group');
+    if (!groupVal)
+        return null;
+    const parsedGroup = parseMessageLikeNode(groupVal, fileName, lineCounter);
+    if (parsedGroup === undefined) {
+        return null;
+    }
+    const group = {
+        group: parsedGroup,
+        items: [],
+        sourceSpan: getNodeSpan(map, fileName, lineCounter),
+    };
+    const visibleIf = getMapValue(map, 'visibleIf');
+    if (visibleIf !== undefined)
+        group.visibleIf = String(isScalar(visibleIf) ? visibleIf.value : visibleIf);
+    const items = getMapValue(map, 'items');
+    if (isSeq(items)) {
+        for (const item of items.items) {
+            if (isMap(item)) {
+                const navItem = parseNavItem(item, fileName, lineCounter);
+                if (navItem)
+                    group.items.push(navItem);
+            }
+        }
+    }
+    return group;
+}
+function parseNavItem(map, fileName, lineCounter) {
+    const label = getMapValue(map, 'label');
+    const target = getMapValue(map, 'target');
+    if (!label || !target)
+        return null;
+    const parsedLabel = parseMessageLikeNode(label, fileName, lineCounter);
+    if (parsedLabel === undefined) {
+        return null;
+    }
+    const item = {
+        label: parsedLabel,
+        target: String(isScalar(target) ? target.value : target),
+        sourceSpan: getNodeSpan(map, fileName, lineCounter),
+    };
+    const icon = getMapValue(map, 'icon');
+    if (icon !== undefined)
+        item.icon = String(isScalar(icon) ? icon.value : icon);
+    return item;
+}
+function parseModelBlock(name, node, fileName, lineCounter, sourceSpan) {
+    const model = { name, fields: [], sourceSpan };
+    if (!isMap(node))
+        return model;
+    const map = node;
+    for (const pair of map.items) {
+        if (!isPair(pair) || !isScalar(pair.key))
+            continue;
+        const fieldName = String(pair.key.value);
+        const rawType = String(isScalar(pair.value) ? pair.value.value : pair.value);
+        const { baseName: typeExpr, decorators } = parseDecorators(rawType);
+        const field = {
+            name: fieldName,
+            typeExpr: typeExpr || rawType,
+            decorators,
+            sourceSpan: getPairSpan(pair, fileName, lineCounter),
+        };
+        model.fields.push(field);
+    }
+    return model;
+}
+function parseResourceBlock(name, node, fileName, lineCounter, errors, sourceSpan) {
+    if (!isMap(node))
+        return null;
+    const map = node;
+    const resource = {
+        name,
+        model: '',
+        api: '',
+        sourceSpan,
+    };
+    const model = getMapValue(map, 'model');
+    if (model !== undefined)
+        resource.model = String(isScalar(model) ? model.value : model);
+    const api = getMapValue(map, 'api');
+    if (api !== undefined)
+        resource.api = String(isScalar(api) ? api.value : api);
+    const workflowPair = getMapPair(map, 'workflow');
+    if (workflowPair) {
+        if (isScalar(workflowPair.value)) {
+            resource.workflow = String(workflowPair.value.value);
+            resource.workflowSourceSpan = getPairSpan(workflowPair, fileName, lineCounter);
+        }
+        else if (isMap(workflowPair.value)) {
+            const workflowMap = workflowPair.value;
+            const source = getMapValue(workflowMap, 'source');
+            if (source !== undefined) {
+                resource.workflow = String(isScalar(source) ? source.value : source);
+            }
+            else {
+                errors.push({
+                    message: 'resource workflow map must declare source',
+                    line: getPairSpan(workflowPair, fileName, lineCounter)?.startLine,
+                    col: getPairSpan(workflowPair, fileName, lineCounter)?.startCol,
+                });
+            }
+            const style = getMapValue(workflowMap, 'style');
+            if (style !== undefined) {
+                resource.workflowStyle = String(isScalar(style) ? style.value : style);
+            }
+            resource.workflowSourceSpan = getPairSpan(workflowPair, fileName, lineCounter);
+        }
+        else {
+            errors.push({
+                message: 'resource workflow must be a scalar @flow(...) link or a mapping with source/style',
+                line: getPairSpan(workflowPair, fileName, lineCounter)?.startLine,
+                col: getPairSpan(workflowPair, fileName, lineCounter)?.startCol,
+            });
+        }
+    }
+    // Parse list view
+    const listPair = getMapPair(map, 'list');
+    if (isMap(listPair?.value))
+        resource.list = parseListView(listPair.value, fileName, lineCounter, getPairSpan(listPair, fileName, lineCounter));
+    // Parse edit view
+    const editPair = getMapPair(map, 'edit');
+    if (isMap(editPair?.value))
+        resource.edit = parseEditView(editPair.value, fileName, lineCounter, errors, getPairSpan(editPair, fileName, lineCounter));
+    // Parse create view
+    const createPair = getMapPair(map, 'create');
+    if (isMap(createPair?.value))
+        resource.create = parseCreateView(createPair.value, fileName, lineCounter, errors, getPairSpan(createPair, fileName, lineCounter));
+    // Parse read view
+    const readPair = getMapPair(map, 'read');
+    if (isMap(readPair?.value))
+        resource.read = parseReadView(readPair.value, fileName, lineCounter, getPairSpan(readPair, fileName, lineCounter));
+    return resource;
+}
+function parseFieldMapBlock(ownerLabel, node, fileName, lineCounter, errors, sourceSpan) {
+    if (!isMap(node)) {
+        errors.push({
+            message: `${ownerLabel} must be a YAML mapping`,
+            line: sourceSpan?.startLine,
+            col: sourceSpan?.startCol,
+        });
+        return undefined;
+    }
+    const fields = [];
+    for (const pair of node.items) {
+        if (!isPair(pair) || !isScalar(pair.key))
+            continue;
+        const fieldName = String(pair.key.value);
+        const rawType = isScalar(pair.value) ? String(pair.value.value) : undefined;
+        const pairSpan = getPairSpan(pair, fileName, lineCounter);
+        if (!rawType) {
+            errors.push({
+                message: `${ownerLabel} field "${fieldName}" must have a scalar type expression`,
+                line: pairSpan?.startLine,
+                col: pairSpan?.startCol,
+            });
+            continue;
+        }
+        const { baseName: typeExpr, decorators } = parseDecorators(rawType);
+        fields.push({
+            name: fieldName,
+            typeExpr: typeExpr || rawType,
+            decorators,
+            sourceSpan: pairSpan,
+        });
+    }
+    return fields;
+}
+function parseReadModelBlock(name, node, fileName, lineCounter, errors, sourceSpan) {
+    if (!isMap(node)) {
+        errors.push({
+            message: `readModel ${name} must be a YAML mapping`,
+            line: sourceSpan?.startLine,
+            col: sourceSpan?.startCol,
+        });
+        return null;
+    }
+    const map = node;
+    const readModel = {
+        name,
+        inputs: [],
+        result: [],
+        sourceSpan,
+    };
+    const api = getMapValue(map, 'api');
+    if (api !== undefined) {
+        readModel.api = String(isScalar(api) ? api.value : api);
+    }
+    const rules = getMapValue(map, 'rules');
+    if (rules !== undefined) {
+        readModel.rules = String(isScalar(rules) ? rules.value : rules);
+    }
+    const inputsPair = getMapPair(map, 'inputs');
+    if (inputsPair) {
+        readModel.inputs = parseFieldMapBlock(`readModel ${name} inputs`, inputsPair.value, fileName, lineCounter, errors, getPairSpan(inputsPair, fileName, lineCounter)) ?? [];
+    }
+    const resultPair = getMapPair(map, 'result');
+    if (resultPair) {
+        readModel.result = parseFieldMapBlock(`readModel ${name} result`, resultPair.value, fileName, lineCounter, errors, getPairSpan(resultPair, fileName, lineCounter)) ?? [];
+    }
+    const listPair = getMapPair(map, 'list');
+    if (isMap(listPair?.value)) {
+        readModel.list = parseReadModelListView(listPair.value, fileName, lineCounter, getPairSpan(listPair, fileName, lineCounter));
+    }
+    return readModel;
+}
+function parseReadModelListView(map, fileName, lineCounter, sourceSpan) {
+    const view = { sourceSpan };
+    const columns = getMapValue(map, 'columns');
+    if (isSeq(columns)) {
+        view.columns = columns.items.map((item) => {
+            const value = isScalar(item) ? String(item.value) : String(item);
+            return parseColumnEntry(value, getNodeSpan(item, fileName, lineCounter));
+        });
+    }
+    const groupBy = getMapValue(map, 'groupBy');
+    if (isSeq(groupBy)) {
+        view.groupBy = groupBy.items.map((item) => String(isScalar(item) ? item.value : item));
+    }
+    const pivotBy = getMapValue(map, 'pivotBy');
+    if (pivotBy !== undefined) {
+        view.pivotBy = String(isScalar(pivotBy) ? pivotBy.value : pivotBy);
+    }
+    const pagination = getMapValue(map, 'pagination');
+    if (isMap(pagination)) {
+        const paginationMap = pagination;
+        const size = getMapValue(paginationMap, 'size');
+        const style = getMapValue(paginationMap, 'style');
+        view.pagination = {
+            size: size !== undefined ? Number(isScalar(size) ? size.value : size) : undefined,
+            style: style !== undefined ? String(isScalar(style) ? style.value : style) : undefined,
+        };
+    }
+    return view;
+}
+function parseListView(map, fileName, lineCounter, sourceSpan) {
+    const view = { sourceSpan };
+    const title = getMapValue(map, 'title');
+    if (title !== undefined)
+        view.title = parseMessageLikeNode(title, fileName, lineCounter);
+    const style = getMapValue(map, 'style');
+    if (style !== undefined)
+        view.style = String(isScalar(style) ? style.value : style);
+    // Filters — array of strings
+    const filters = getMapValue(map, 'filters');
+    if (isSeq(filters)) {
+        view.filters = filters.items.map((i) => String(isScalar(i) ? i.value : i));
+    }
+    // Columns — array of decorated strings
+    const columns = getMapValue(map, 'columns');
+    if (isSeq(columns)) {
+        view.columns = columns.items.map((i) => {
+            const val = isScalar(i) ? String(i.value) : String(i);
+            return parseColumnEntry(val, getNodeSpan(i, fileName, lineCounter));
+        });
+    }
+    // Actions
+    const actions = getMapValue(map, 'actions');
+    if (isSeq(actions)) {
+        view.actions = actions.items.map((i) => {
+            const val = isScalar(i) ? String(i.value) : String(i);
+            return parseActionEntry(val, getNodeSpan(i, fileName, lineCounter));
+        });
+    }
+    // Pagination
+    const pagination = getMapValue(map, 'pagination');
+    if (isMap(pagination)) {
+        const pMap = pagination;
+        const size = getMapValue(pMap, 'size');
+        const style = getMapValue(pMap, 'style');
+        view.pagination = {
+            size: size !== undefined ? Number(isScalar(size) ? size.value : size) : undefined,
+            style: style !== undefined ? String(isScalar(style) ? style.value : style) : undefined,
+        };
+    }
+    // Rules
+    view.rules = parseRules(map, fileName, lineCounter);
+    return view;
+}
+function parseEditView(map, fileName, lineCounter, errors, sourceSpan) {
+    const view = { sourceSpan };
+    const style = getMapValue(map, 'style');
+    if (style !== undefined)
+        view.style = String(isScalar(style) ? style.value : style);
+    const fields = getMapValue(map, 'fields');
+    if (isSeq(fields)) {
+        view.fields = fields.items.map((item) => parseFormFieldEntry(item, fileName, lineCounter));
+    }
+    const includes = getMapValue(map, 'includes');
+    if (isSeq(includes)) {
+        view.includes = includes.items
+            .map((item) => parseCreateInclude(item, fileName, lineCounter))
+            .filter((entry) => Boolean(entry));
+    }
+    view.rules = parseViewRules(map, fileName, lineCounter);
+    const onSuccess = getMapValue(map, 'onSuccess');
+    if (isSeq(onSuccess)) {
+        view.onSuccess = parseEffectList(onSuccess, fileName, lineCounter, errors);
+    }
+    return view;
+}
+function parseCreateView(map, fileName, lineCounter, errors, sourceSpan) {
+    const view = { sourceSpan };
+    const style = getMapValue(map, 'style');
+    if (style !== undefined)
+        view.style = String(isScalar(style) ? style.value : style);
+    const fields = getMapValue(map, 'fields');
+    if (isSeq(fields)) {
+        view.fields = fields.items.map((item) => parseFormFieldEntry(item, fileName, lineCounter));
+    }
+    const includes = getMapValue(map, 'includes');
+    if (isSeq(includes)) {
+        view.includes = includes.items
+            .map((item) => parseCreateInclude(item, fileName, lineCounter))
+            .filter((entry) => Boolean(entry));
+    }
+    view.rules = parseViewRules(map, fileName, lineCounter);
+    const onSuccess = getMapValue(map, 'onSuccess');
+    if (isSeq(onSuccess)) {
+        view.onSuccess = parseEffectList(onSuccess, fileName, lineCounter, errors);
+    }
+    return view;
+}
+function parseCreateInclude(node, fileName, lineCounter) {
+    if (!isMap(node)) {
+        return null;
+    }
+    const map = node;
+    const field = getMapValue(map, 'field');
+    if (!field) {
+        return null;
+    }
+    const include = {
+        field: String(isScalar(field) ? field.value : field),
+        sourceSpan: getNodeSpan(map, fileName, lineCounter),
+    };
+    const minItems = getMapValue(map, 'minItems');
+    if (minItems !== undefined) {
+        include.minItems = Number(isScalar(minItems) ? minItems.value : minItems);
+    }
+    const rules = getMapValue(map, 'rules');
+    if (rules !== undefined) {
+        include.rules = String(isScalar(rules) ? rules.value : rules);
+    }
+    const fields = getMapValue(map, 'fields');
+    if (isSeq(fields)) {
+        include.fields = fields.items.map((item) => parseFormFieldEntry(item, fileName, lineCounter));
+    }
+    return include;
+}
+function parseReadView(map, fileName, lineCounter, sourceSpan) {
+    const view = { sourceSpan };
+    const title = getMapValue(map, 'title');
+    if (title !== undefined)
+        view.title = parseMessageLikeNode(title, fileName, lineCounter);
+    const style = getMapValue(map, 'style');
+    if (style !== undefined)
+        view.style = String(isScalar(style) ? style.value : style);
+    const fields = getMapValue(map, 'fields');
+    if (isSeq(fields)) {
+        view.fields = fields.items.map((i) => {
+            const val = isScalar(i) ? String(i.value) : String(i);
+            return parseColumnEntry(val, getNodeSpan(i, fileName, lineCounter));
+        });
+    }
+    const related = getMapValue(map, 'related');
+    if (isSeq(related)) {
+        view.related = related.items.map((i) => String(isScalar(i) ? i.value : i));
+    }
+    return view;
+}
+function parseRules(map, fileName, lineCounter) {
+    const rulesPair = getMapPair(map, 'rules');
+    if (!isMap(rulesPair?.value)) {
+        // Fallback: check for top-level rule fields
+        const result = {};
+        let found = false;
+        for (const key of ['visibleIf', 'enabledIf', 'allowIf', 'enforce']) {
+            const val = getMapValue(map, key);
+            if (val !== undefined) {
+                result[key] = String(isScalar(val) ? val.value : val);
+                found = true;
+            }
+        }
+        return found ? result : undefined;
+    }
+    const rMap = rulesPair.value;
+    const result = {
+        sourceSpan: getPairSpan(rulesPair, fileName, lineCounter),
+    };
+    for (const key of ['visibleIf', 'enabledIf', 'allowIf', 'enforce']) {
+        const val = getMapValue(rMap, key);
+        if (val !== undefined) {
+            result[key] = String(isScalar(val) ? val.value : val);
+        }
+    }
+    return result;
+}
+function parseViewRules(map, fileName, lineCounter) {
+    const rulesPair = getMapPair(map, 'rules');
+    if (isScalar(rulesPair?.value)) {
+        return String(rulesPair.value.value);
+    }
+    return parseRules(map, fileName, lineCounter);
+}
+function parseEffectList(seq, fileName, lineCounter, errors) {
+    const effects = [];
+    for (const item of seq.items) {
+        if (isMap(item)) {
+            const map = item;
+            for (const pair of map.items) {
+                if (isPair(pair) && isScalar(pair.key)) {
+                    const type = String(pair.key.value);
+                    const parsedValue = parseEffectValue(type, pair.value, fileName, lineCounter, errors);
+                    if (parsedValue === undefined) {
+                        continue;
+                    }
+                    effects.push({
+                        type,
+                        value: parsedValue,
+                        sourceSpan: getPairSpan(pair, fileName, lineCounter),
+                    });
+                }
+            }
+        }
+        else if (isScalar(item)) {
+            // Simple string effect like "toast: saved"
+            const val = String(item.value);
+            const colonIdx = val.indexOf(':');
+            if (colonIdx > 0) {
+                effects.push({
+                    type: val.substring(0, colonIdx).trim(),
+                    value: val.substring(colonIdx + 1).trim(),
+                    sourceSpan: getNodeSpan(item, fileName, lineCounter),
+                });
+            }
+        }
+    }
+    return effects;
+}
+function parseEffectValue(type, node, fileName, lineCounter, errors) {
+    if (type === 'toast' && isMap(node)) {
+        return parseToastDescriptor(node, fileName, lineCounter, errors, getNodeSpan(node, fileName, lineCounter));
+    }
+    if (isScalar(node)) {
+        return String(node.value);
+    }
+    errors.push({
+        message: `Effect "${type}" must use a scalar value${type === 'toast' ? ' or a supported toast descriptor object' : ''}`,
+        line: getNodeSpan(node, fileName, lineCounter)?.startLine,
+        col: getNodeSpan(node, fileName, lineCounter)?.startCol,
+    });
+    return undefined;
+}
+function parseToastDescriptor(map, fileName, lineCounter, errors, sourceSpan) {
+    const descriptor = { sourceSpan };
+    for (const pair of map.items) {
+        if (!isPair(pair) || !isScalar(pair.key)) {
+            continue;
+        }
+        const key = String(pair.key.value);
+        if (key === 'key') {
+            if (isScalar(pair.value)) {
+                descriptor.key = String(pair.value.value);
+            }
+            else {
+                errors.push({
+                    message: 'toast.key must be a scalar string',
+                    line: getPairSpan(pair, fileName, lineCounter)?.startLine,
+                    col: getPairSpan(pair, fileName, lineCounter)?.startCol,
+                });
+            }
+            continue;
+        }
+        if (key === 'defaultMessage') {
+            if (isScalar(pair.value)) {
+                descriptor.defaultMessage = String(pair.value.value);
+            }
+            else {
+                errors.push({
+                    message: 'toast.defaultMessage must be a scalar string',
+                    line: getPairSpan(pair, fileName, lineCounter)?.startLine,
+                    col: getPairSpan(pair, fileName, lineCounter)?.startCol,
+                });
+            }
+            continue;
+        }
+        if (key === 'values') {
+            if (isMap(pair.value)) {
+                descriptor.values = parseToastValues(pair.value, fileName, lineCounter, errors);
+            }
+            else {
+                errors.push({
+                    message: 'toast.values must be a mapping of literal values or { ref: ... } objects',
+                    line: getPairSpan(pair, fileName, lineCounter)?.startLine,
+                    col: getPairSpan(pair, fileName, lineCounter)?.startCol,
+                });
+            }
+            continue;
+        }
+        errors.push({
+            message: `Unknown toast descriptor key: "${key}"`,
+            line: getPairSpan(pair, fileName, lineCounter)?.startLine,
+            col: getPairSpan(pair, fileName, lineCounter)?.startCol,
+        });
+    }
+    return descriptor;
+}
+function parseToastValues(map, fileName, lineCounter, errors) {
+    const values = {};
+    for (const pair of map.items) {
+        if (!isPair(pair) || !isScalar(pair.key)) {
+            continue;
+        }
+        const name = String(pair.key.value);
+        if (isScalar(pair.value)) {
+            const scalarValue = pair.value.value;
+            if (typeof scalarValue === 'string'
+                || typeof scalarValue === 'number'
+                || typeof scalarValue === 'boolean'
+                || scalarValue === null) {
+                values[name] = scalarValue;
+            }
+            else {
+                values[name] = String(scalarValue);
+            }
+            continue;
+        }
+        if (isMap(pair.value)) {
+            const refPair = getMapPair(pair.value, 'ref');
+            if (pair.value.items.length === 1 && refPair && isScalar(refPair.value)) {
+                values[name] = {
+                    ref: String(refPair.value.value),
+                    sourceSpan: getPairSpan(refPair, fileName, lineCounter),
+                };
+            }
+            else {
+                errors.push({
+                    message: `toast.values.${name} must be a scalar or { ref: <path> }`,
+                    line: getPairSpan(pair, fileName, lineCounter)?.startLine,
+                    col: getPairSpan(pair, fileName, lineCounter)?.startCol,
+                });
+            }
+            continue;
+        }
+        errors.push({
+            message: `toast.values.${name} must be a scalar or { ref: <path> }`,
+            line: getPairSpan(pair, fileName, lineCounter)?.startLine,
+            col: getPairSpan(pair, fileName, lineCounter)?.startCol,
+        });
+    }
+    return values;
+}
+function parseToastDescriptorObject(value) {
+    const descriptor = {};
+    if (value.key !== undefined) {
+        descriptor.key = String(value.key);
+    }
+    if (value.defaultMessage !== undefined) {
+        descriptor.defaultMessage = String(value.defaultMessage);
+    }
+    if (value.values && typeof value.values === 'object' && !Array.isArray(value.values)) {
+        descriptor.values = Object.fromEntries(Object.entries(value.values).map(([key, entry]) => {
+            if (entry && typeof entry === 'object' && !Array.isArray(entry) && 'ref' in entry) {
+                return [key, { ref: String(entry.ref) }];
+            }
+            return [key, entry];
+        }));
+    }
+    return descriptor;
+}
+function parseMessageLikeNode(node, fileName, lineCounter) {
+    if (isScalar(node)) {
+        return String(node.value);
+    }
+    if (isMap(node)) {
+        return parseUiMessageDescriptor(node, fileName, lineCounter, getNodeSpan(node, fileName, lineCounter));
+    }
+    return undefined;
+}
+function parseMessageLikeObject(value) {
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return parseUiMessageDescriptorObject(value);
+    }
+    return undefined;
+}
+function parseUiMessageDescriptor(map, _fileName, _lineCounter, sourceSpan) {
+    const descriptor = { sourceSpan };
+    for (const pair of map.items) {
+        if (!isPair(pair) || !isScalar(pair.key)) {
+            continue;
+        }
+        const key = String(pair.key.value);
+        if (key === 'key' || key === 'defaultMessage') {
+            if (isScalar(pair.value)) {
+                descriptor[key] = String(pair.value.value);
+            }
+            continue;
+        }
+        if (key === 'values' && isMap(pair.value)) {
+            descriptor.values = Object.fromEntries(pair.value.items.flatMap((entry) => {
+                if (!isPair(entry) || !isScalar(entry.key) || !isScalar(entry.value)) {
+                    return [];
+                }
+                const value = entry.value.value;
+                if (typeof value === 'string'
+                    || typeof value === 'number'
+                    || typeof value === 'boolean'
+                    || value === null) {
+                    return [[String(entry.key.value), value]];
+                }
+                return [];
+            }));
+        }
+    }
+    return descriptor;
+}
+function parseUiMessageDescriptorObject(value) {
+    const descriptor = {};
+    if (value.key !== undefined) {
+        descriptor.key = String(value.key);
+    }
+    if (value.defaultMessage !== undefined) {
+        descriptor.defaultMessage = String(value.defaultMessage);
+    }
+    if (value.values && typeof value.values === 'object' && !Array.isArray(value.values)) {
+        descriptor.values = Object.fromEntries(Object.entries(value.values).flatMap(([key, entry]) => {
+            if (typeof entry === 'string'
+                || typeof entry === 'number'
+                || typeof entry === 'boolean'
+                || entry === null) {
+                return [[key, entry]];
+            }
+            return [];
+        }));
+    }
+    return descriptor;
+}
+function parsePageBlock(name, node, fileName, lineCounter, sourceSpan) {
+    if (!isMap(node))
+        return null;
+    const map = node;
+    const page = {
+        name,
+        title: '',
+        type: 'dashboard',
+        blocks: [],
+        sourceSpan,
+    };
+    const title = getMapValue(map, 'title');
+    if (title !== undefined)
+        page.title = parseMessageLikeNode(title, fileName, lineCounter) ?? '';
+    const type = getMapValue(map, 'type');
+    if (type !== undefined)
+        page.type = String(isScalar(type) ? type.value : type);
+    const path = getMapValue(map, 'path');
+    if (path !== undefined)
+        page.path = String(isScalar(path) ? path.value : path);
+    const layout = getMapValue(map, 'layout');
+    if (layout !== undefined)
+        page.layout = String(isScalar(layout) ? layout.value : layout);
+    const style = getMapValue(map, 'style');
+    if (style !== undefined)
+        page.style = String(isScalar(style) ? style.value : style);
+    const seo = getMapValue(map, 'seo');
+    if (isMap(seo)) {
+        page.seo = parsePageSeoBlock(seo, fileName, lineCounter);
+    }
+    const actions = getMapValue(map, 'actions');
+    if (isSeq(actions)) {
+        page.actions = actions.items
+            .map((entry) => parsePageAction(entry, fileName, lineCounter))
+            .filter((entry) => Boolean(entry));
+    }
+    const blocks = getMapValue(map, 'blocks');
+    if (isSeq(blocks)) {
+        for (const item of blocks.items) {
+            if (isMap(item)) {
+                const bMap = item;
+                const block = {
+                    type: '',
+                    title: '',
+                    sourceSpan: getNodeSpan(bMap, fileName, lineCounter),
+                };
+                const bType = getMapValue(bMap, 'type');
+                if (bType !== undefined)
+                    block.type = String(isScalar(bType) ? bType.value : bType);
+                const bTitle = getMapValue(bMap, 'title');
+                if (bTitle !== undefined)
+                    block.title = parseMessageLikeNode(bTitle, fileName, lineCounter) ?? '';
+                const bStyle = getMapValue(bMap, 'style');
+                if (bStyle !== undefined)
+                    block.style = String(isScalar(bStyle) ? bStyle.value : bStyle);
+                const bData = getMapValue(bMap, 'data');
+                if (bData !== undefined)
+                    block.data = String(isScalar(bData) ? bData.value : bData);
+                const bQueryState = getMapValue(bMap, 'queryState');
+                if (bQueryState !== undefined) {
+                    block.queryState = String(isScalar(bQueryState) ? bQueryState.value : bQueryState);
+                }
+                const bSelectionState = getMapValue(bMap, 'selectionState');
+                if (bSelectionState !== undefined) {
+                    block.selectionState = String(isScalar(bSelectionState) ? bSelectionState.value : bSelectionState);
+                }
+                const bDateNavigation = getMapValue(bMap, 'dateNavigation');
+                if (isScalar(bDateNavigation)) {
+                    block.dateNavigation = {
+                        field: String(bDateNavigation.value),
+                        sourceSpan: getNodeSpan(bMap, fileName, lineCounter),
+                    };
+                }
+                else if (isMap(bDateNavigation)) {
+                    const dateNavigationMap = bDateNavigation;
+                    const field = getMapValue(dateNavigationMap, 'field');
+                    const prevLabel = getMapValue(dateNavigationMap, 'prevLabel');
+                    const nextLabel = getMapValue(dateNavigationMap, 'nextLabel');
+                    block.dateNavigation = {
+                        field: field === undefined ? '' : String(isScalar(field) ? field.value : field),
+                        prevLabel: prevLabel === undefined ? undefined : parseMessageLikeNode(prevLabel, fileName, lineCounter),
+                        nextLabel: nextLabel === undefined ? undefined : parseMessageLikeNode(nextLabel, fileName, lineCounter),
+                        sourceSpan: getNodeSpan(dateNavigationMap, fileName, lineCounter),
+                    };
+                }
+                // Escape hatch tier 3: custom block
+                const bCustom = getMapValue(bMap, 'custom');
+                if (bCustom !== undefined)
+                    block.custom = String(isScalar(bCustom) ? bCustom.value : bCustom);
+                const bRowActions = getMapValue(bMap, 'rowActions');
+                if (isSeq(bRowActions)) {
+                    block.rowActions = bRowActions.items
+                        .map((entry) => parseDashboardRowAction(entry, fileName, lineCounter))
+                        .filter((entry) => Boolean(entry));
+                }
+                page.blocks.push(block);
+            }
+        }
+    }
+    return page;
+}
+function parsePageActionSeedValue(node, fileName, lineCounter) {
+    if (isScalar(node)) {
+        const value = node.value;
+        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+            return value;
+        }
+        return String(value);
+    }
+    if (!isMap(node)) {
+        return undefined;
+    }
+    const map = node;
+    const input = getMapValue(map, 'input');
+    if (isScalar(input)) {
+        return {
+            input: String(input.value),
+            sourceSpan: getNodeSpan(map, fileName, lineCounter),
+        };
+    }
+    const selection = getMapValue(map, 'selection');
+    if (isScalar(selection)) {
+        return {
+            selection: String(selection.value),
+            sourceSpan: getNodeSpan(map, fileName, lineCounter),
+        };
+    }
+    return undefined;
+}
+function parseDashboardRowSeedValue(node, fileName, lineCounter) {
+    if (isScalar(node)) {
+        const value = node.value;
+        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+            return value;
+        }
+        return String(value);
+    }
+    if (!isMap(node)) {
+        return undefined;
+    }
+    const map = node;
+    const row = getMapValue(map, 'row');
+    if (isScalar(row)) {
+        return {
+            row: String(row.value),
+            sourceSpan: getNodeSpan(map, fileName, lineCounter),
+        };
+    }
+    const input = getMapValue(map, 'input');
+    if (isScalar(input)) {
+        return {
+            input: String(input.value),
+            sourceSpan: getNodeSpan(map, fileName, lineCounter),
+        };
+    }
+    return undefined;
+}
+function parsePageAction(node, fileName, lineCounter) {
+    if (!isMap(node)) {
+        return null;
+    }
+    const map = node;
+    const createPair = getMapPair(map, 'create');
+    if (!createPair) {
+        return null;
+    }
+    if (isScalar(createPair.value)) {
+        return {
+            create: {
+                resource: String(createPair.value.value),
+                sourceSpan: getPairSpan(createPair, fileName, lineCounter),
+            },
+            sourceSpan: getNodeSpan(map, fileName, lineCounter),
+        };
+    }
+    if (!isMap(createPair.value)) {
+        return null;
+    }
+    const createMap = createPair.value;
+    const resource = getMapValue(createMap, 'resource');
+    if (!isScalar(resource)) {
+        return null;
+    }
+    const create = {
+        resource: String(resource.value),
+        sourceSpan: getPairSpan(createPair, fileName, lineCounter),
+    };
+    const label = getMapValue(createMap, 'label');
+    if (label !== undefined) {
+        create.label = parseMessageLikeNode(label, fileName, lineCounter);
+    }
+    const seed = getMapValue(createMap, 'seed');
+    if (isMap(seed)) {
+        create.seed = {};
+        for (const pair of seed.items) {
+            if (!isPair(pair) || !isScalar(pair.key)) {
+                continue;
+            }
+            const key = String(pair.key.value);
+            const value = parsePageActionSeedValue(pair.value, fileName, lineCounter);
+            if (value !== undefined) {
+                create.seed[key] = value;
+            }
+        }
+    }
+    return {
+        create,
+        sourceSpan: getNodeSpan(map, fileName, lineCounter),
+    };
+}
+function parseDashboardRowAction(node, fileName, lineCounter) {
+    if (!isMap(node)) {
+        return null;
+    }
+    const map = node;
+    const createPair = getMapPair(map, 'create');
+    if (!createPair) {
+        return null;
+    }
+    if (isScalar(createPair.value)) {
+        return {
+            create: {
+                resource: String(createPair.value.value),
+                sourceSpan: getPairSpan(createPair, fileName, lineCounter),
+            },
+            sourceSpan: getNodeSpan(map, fileName, lineCounter),
+        };
+    }
+    if (!isMap(createPair.value)) {
+        return null;
+    }
+    const createMap = createPair.value;
+    const resource = getMapValue(createMap, 'resource');
+    if (!isScalar(resource)) {
+        return null;
+    }
+    const create = {
+        resource: String(resource.value),
+        sourceSpan: getPairSpan(createPair, fileName, lineCounter),
+    };
+    const label = getMapValue(createMap, 'label');
+    if (label !== undefined) {
+        create.label = parseMessageLikeNode(label, fileName, lineCounter);
+    }
+    const seed = getMapValue(createMap, 'seed');
+    if (isMap(seed)) {
+        const entries = {};
+        for (const pair of seed.items) {
+            if (!isPair(pair) || !isScalar(pair.key)) {
+                continue;
+            }
+            const fieldName = String(pair.key.value);
+            const parsedValue = parseDashboardRowSeedValue(pair.value, fileName, lineCounter);
+            if (parsedValue !== undefined) {
+                entries[fieldName] = parsedValue;
+            }
+        }
+        create.seed = entries;
+    }
+    return {
+        create,
+        sourceSpan: getNodeSpan(map, fileName, lineCounter),
+    };
+}
+//# sourceMappingURL=parser.js.map