@kaskad/schema 0.0.1 → 0.0.2

package/fesm2022/kaskad-schema.mjs

@@ -0,0 +1,1368 @@
+import { DefinitionStore } from '@kaskad/definition';
+import { NodeTypes, isSwitchComputation, isIfComputation, isForComputation, isTemplateComputation } from '@kaskad/types';
+import { Delimiters, log } from '@kaskad/config';
+import { parse } from 'yaml';
+
+// Recipe types used for unfolding
+// These types represent the raw input format before normalization
+
+function isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Set);
+}
+
+function stringifyObject(label, data) {
+    return `\n${label}:\n${JSON.stringify(data, null, 2)}`;
+}
+
+function parseValueType(type) {
+    type = type.replaceAll(' ', '');
+    if (type.startsWith('(') && type.endsWith(')')) {
+        return createCommandType(type.slice(1, -1));
+    }
+    // Check for map type first (but not just '{}')
+    if (type.endsWith('{}') && type !== '{}') {
+        const rest = type.slice(0, -2);
+        return {
+            type: 'map',
+            item: parseValueType(rest),
+        };
+    }
+    // Check for set type
+    if (type.endsWith('#')) {
+        const rest = type.slice(0, -1);
+        return {
+            type: 'set',
+            item: parseValueType(rest),
+        };
+    }
+    if (type.endsWith('[]')) {
+        const rest = type.slice(0, -2);
+        return {
+            type: 'array',
+            item: parseValueType(rest),
+        };
+    }
+    // Check for object type after map/array to handle {} and complex object types
+    if (type.startsWith('{') && type.endsWith('}')) {
+        return createObjectType(type.slice(1, -1));
+    }
+    return createSimpleType(type);
+}
+function createObjectType(type) {
+    const fieldsPairs = splitTypesByComma(type);
+    const fields = fieldsPairs.reduce((acc, str) => {
+        if (!str)
+            return acc; // Handle empty object case
+        const colonIndex = str.indexOf(':');
+        const errorPrefix = `Invalid object field definition: "${str}"`;
+        if (colonIndex === -1) {
+            throw new Error(`${errorPrefix} - expected format "fieldName:type"`);
+        }
+        const fieldKey = str.substring(0, colonIndex);
+        const fieldType = str.substring(colonIndex + 1);
+        if (!fieldKey) {
+            throw new Error(`${errorPrefix} - field name cannot be empty`);
+        }
+        if (!fieldType) {
+            throw new Error(`${errorPrefix} - field type cannot be empty`);
+        }
+        acc[fieldKey] = parseValueType(fieldType);
+        return acc;
+    }, {});
+    return {
+        type: 'object',
+        fields,
+    };
+}
+function createCommandType(type) {
+    const args = splitTypesByComma(type).filter(Boolean);
+    return {
+        type: 'command',
+        args: args.map(parseValueType),
+    };
+}
+function createSimpleType(type) {
+    if (NodeTypes.includes(type)) {
+        return { type };
+    }
+    if (type in DefinitionStore.getInstance().shapes) {
+        return {
+            type: 'shape',
+            shapeType: type,
+        };
+    }
+    if (type in DefinitionStore.getInstance().variantShapes) {
+        return {
+            type: 'variantShape',
+            shapeType: type,
+        };
+    }
+    throw new Error(`Unknown type '${type}'`);
+}
+function splitTypesByComma(str) {
+    const pairs = [];
+    let braceCount = 0;
+    let part = '';
+    for (let i = 0; i < str.length; i++) {
+        const char = str[i];
+        if (char === '{') {
+            braceCount++;
+            part += char;
+            continue;
+        }
+        if (char === '}') {
+            braceCount--;
+            part += char;
+            continue;
+        }
+        if (char === ',' && braceCount === 0) {
+            pairs.push(part);
+            part = '';
+        }
+        else {
+            part += char;
+        }
+    }
+    pairs.push(part);
+    return pairs;
+}
+
+function parsePropertyKeyShorthand(shorthand) {
+    const [key, type] = shorthand.split('@');
+    if (!type) {
+        throw new Error(`Invalid node key expression "${key}". Expected type for key "${key}"`);
+    }
+    return [key, parseValueType(type)];
+}
+
+function unfoldForComputationSchema(schema) {
+    if (!isObject(schema) || !('computationType' in schema)) {
+        return null;
+    }
+    let rawDimensions = schema['dimensions'];
+    if (rawDimensions) {
+        if (!Array.isArray(rawDimensions)) {
+            throw new Error(`Invalid dimensions schema "${JSON.stringify(rawDimensions)}". It must be an array.`);
+        }
+    }
+    else {
+        // schema can be a flat object if only one dimension is defined
+        rawDimensions = [schema];
+    }
+    const dimensions = rawDimensions.map((dimension) => {
+        const { item = 'item', index = 'index', first = null, last = null } = dimension.as || {};
+        const itemsKey = Object.keys(dimension).find((key) => key.startsWith('items'));
+        const [items, itemsType] = parsePropertyKeyShorthand(itemsKey ?? '');
+        if (items !== 'items') {
+            throw new Error(`Computation "for" requires "items" field: ${JSON.stringify(schema)}`);
+        }
+        const itemsArr = dimension[itemsKey];
+        return {
+            items: unfoldNodeSchema(itemsArr, itemsType, []),
+            itemsType,
+            item: unfoldNodeSchema(item, { type: 'string' }, []),
+            index: unfoldNodeSchema(index, { type: 'string' }, []),
+            first: unfoldNodeSchema(first, { type: 'string' }, []),
+            last: unfoldNodeSchema(last, { type: 'string' }, []),
+            trackBy: unfoldNodeSchema(null, { type: 'unknown' }, []),
+        };
+    });
+    const normalizedYield = unfoldNodeSchema(schema['yield'], { type: 'unknown' }, []);
+    const result = {
+        computationType: 'for',
+        dimensions,
+        yield: normalizedYield,
+        [Symbol.for('type')]: 'ComputationSchema',
+    };
+    return result;
+}
+
+/**
+ * Parses metadata object from the `with` clause
+ * Example: "index: $i, first: $isFirst, last: $isLast"
+ */
+function parseMetadata(str) {
+    const result = {};
+    const trimmed = str.trim();
+    if (!trimmed) {
+        throw new Error('Empty metadata block. Omit "with" clause if no metadata is needed.');
+    }
+    const pairs = trimmed.split(',').map((s) => s.trim());
+    for (const pair of pairs) {
+        const colonIndex = pair.indexOf(':');
+        if (colonIndex === -1) {
+            throw new Error(`Invalid metadata pair: "${pair}". Expected format: "key: $value"`);
+        }
+        const key = pair.slice(0, colonIndex).trim();
+        const value = pair.slice(colonIndex + 1).trim();
+        if (!['index', 'first', 'last'].includes(key)) {
+            throw new Error(`Invalid metadata key: "${key}". Only "index", "first", and "last" are allowed.`);
+        }
+        if (!value || !value.startsWith('$')) {
+            throw new Error(`Invalid metadata value: "${value}". Must be a variable starting with $.`);
+        }
+        result[key] = value.slice(1); // Remove $
+    }
+    return result;
+}
+/**
+ * Parses a single for-loop specification
+ * Example: "$row@Row of $rows with { index: $i, first: $isFirst } trackBy $row.id"
+ */
+function parseForSpec(spec) {
+    const trimmed = spec.trim();
+    // First, extract trackBy if present at the end
+    // trackBy uses $variable or $variable.property syntax (e.g., "$item" or "$item.id")
+    let trackBy = null;
+    let specWithoutTrackBy = trimmed;
+    const trackByMatch = trimmed.match(/\s+trackBy\s+(\$\w+(?:\.\w+)*)$/);
+    if (trackByMatch) {
+        const trackByValue = trackByMatch[1].trim();
+        specWithoutTrackBy = trimmed.slice(0, trackByMatch.index).trim();
+        // Parse the $variable.property syntax
+        const pathMatch = trackByValue.match(/^\$(\w+)((?:\.\w+)*)$/);
+        if (!pathMatch) {
+            throw new Error(`Invalid trackBy syntax: ${trackByValue}. Expected format: $variable or $variable.property`);
+        }
+        const variableName = pathMatch[1]; // e.g., "item"
+        const propertyPath = pathMatch[2]; // e.g., ".id" or ""
+        // We'll validate against itemName after parsing the main pattern
+        // Store both parts temporarily - validation happens after we know itemName
+        trackBy = `${variableName}${propertyPath}`;
+    }
+    // Pattern: $item@Type of $items with { metadata }
+    //          ^^^^^ ^^^^    ^^^^^^      ^^^^^^^^^^^^^^^
+    //          name  type    expr        metadata (optional)
+    // Note: Type can include dots for namespaced types like "app.table.Row"
+    const pattern = /^\$(\w+)@([\w.[\]{}:,\s]+)\s+of\s+(.+?)(?:\s+with\s*\{([^}]+)})?$/;
+    const match = specWithoutTrackBy.match(pattern);
+    if (!match) {
+        throw new Error(`Invalid for-loop syntax: "${spec}". Expected format: "$item@Type of $items" or "$item@Type of $items with { index: $i }"`);
+    }
+    const [, itemName, typeStr, itemsExpr, metadataStr] = match;
+    // Validate and process trackBy
+    // null = no trackBy specified (use index)
+    // "" = trackBy $var (use item value directly for primitives)
+    // "id" or "user.id" = trackBy $var.property (use property path)
+    let processedTrackBy = null;
+    if (trackBy !== null) {
+        // trackBy is in format "variableName" or "variableName.property.path"
+        const parts = trackBy.split('.');
+        const variableName = parts[0];
+        // Validate that trackBy references the loop variable
+        if (variableName !== itemName) {
+            throw new Error(`trackBy must reference loop variable $${itemName}, got $${variableName}`);
+        }
+        // Extract the property path (everything after the variable name)
+        // If parts.length === 1, it's just the variable (primitive array) -> "" (use item value)
+        // If parts.length > 1, it's a property path -> "id" or "user.id"
+        processedTrackBy = parts.length > 1 ? parts.slice(1).join('.') : '';
+    }
+    return {
+        itemName,
+        itemType: typeStr.trim(),
+        itemsExpr,
+        metadata: metadataStr ? parseMetadata(metadataStr) : {},
+        trackBy: processedTrackBy,
+    };
+}
+/**
+ * Unfolds the new for-loop syntax into a ForComputationSchema
+ * Supports: for: "$item@Type of $items" or for: ["$item1@Type1 of $items1", "$item2@Type2 of $items2"]
+ */
+function unfoldForWithNewSyntax(schema) {
+    if (!isObject(schema) || !('for' in schema)) {
+        return null;
+    }
+    const forSpec = schema['for'];
+    const specs = Array.isArray(forSpec) ? forSpec : [forSpec];
+    if (specs.length === 0) {
+        throw new Error('For-loop requires at least one dimension');
+    }
+    const dimensions = specs.map((spec) => {
+        if (typeof spec !== 'string') {
+            throw new Error(`Invalid for-loop spec: ${JSON.stringify(spec)}. Must be a string.`);
+        }
+        const parsed = parseForSpec(spec);
+        // Parse the type annotation
+        // The type can be either:
+        // 1. An item type (e.g., "string") - we need to wrap in array
+        // 2. Already an array type (e.g., "string[]") - use as-is
+        const parsedType = parseValueType(parsed.itemType);
+        const itemsType = parsedType.type === 'array' ? parsedType : { type: 'array', item: parsedType };
+        return {
+            items: unfoldNodeSchema(parsed.itemsExpr, itemsType, []),
+            itemsType,
+            item: unfoldNodeSchema(parsed.itemName, { type: 'string' }, []),
+            index: unfoldNodeSchema(parsed.metadata.index || 'index', { type: 'string' }, []),
+            first: unfoldNodeSchema(parsed.metadata.first || null, { type: 'string' }, []),
+            last: unfoldNodeSchema(parsed.metadata.last || null, { type: 'string' }, []),
+            // trackBy: null = use index, property path (e.g., "id") = extract from item
+            trackBy: unfoldNodeSchema(parsed.trackBy, { type: 'string' }, []),
+        };
+    });
+    // Extract yield: either explicit 'yield' property or all other properties (inline yield)
+    let yieldSchema;
+    if ('yield' in schema) {
+        yieldSchema = schema['yield'];
+    }
+    else {
+        // Inline yield: all properties except 'for'
+        const { for: _, ...rest } = schema;
+        yieldSchema = rest;
+    }
+    const normalizedYield = unfoldNodeSchema(yieldSchema, { type: 'componentSchema' }, []);
+    const result = {
+        computationType: 'for',
+        dimensions,
+        yield: normalizedYield,
+        [Symbol.for('type')]: 'ComputationSchema',
+    };
+    return result;
+}
+
+function unfoldIfComputationSchema(schema) {
+    if (schema.if === undefined) {
+        throw new Error('If computation requires the "if" field.');
+    }
+    const result = {
+        computationType: 'if',
+        if: unfoldNodeSchema(schema.if, { type: 'boolean' }, []),
+        then: createBranch(schema.then),
+        else: createBranch(schema.else),
+        [Symbol.for('type')]: 'ComputationSchema',
+    };
+    return result;
+}
+function createBranch(schema = null) {
+    return unfoldNodeSchema(schema, { type: 'componentSchema' }, []);
+}
+
+function unfoldImportComputationSchema(schema) {
+    if (!isObject(schema) || !('computationType' in schema)) {
+        return null;
+    }
+    const { path, ref, computationType, _defer, ...contractVariables } = schema;
+    if (!path) {
+        throw new Error(`Import resolver requires a path field.`);
+    }
+    const defer = _defer
+        ? {
+            placeholder: unfoldNodeSchema(_defer.placeholder || null, { type: 'component' }, []),
+            error: unfoldNodeSchema(_defer.error || null, { type: 'component' }, []),
+        }
+        : null;
+    return {
+        computationType,
+        path,
+        defer,
+        ref,
+        contractVariables,
+        [Symbol.for('type')]: 'ComputationSchema',
+    };
+}
+
+function unfoldInterpolationComputationSchema(schema) {
+    const args = stringToFuncArgs(schema);
+    return { computationType: 'formula', formula: `concat(${args})` };
+}
+function replaceInterpolationsInFormula(formula) {
+    // Replace {{}} inside single-quoted string literals
+    let result = formula.replace(/'([^']*\{\{.*?\}\}[^']*)'/g, (_, content) => {
+        return `concat(${stringToFuncArgs(content)})`;
+    });
+    // Replace {{}} inside double-quoted string literals
+    result = result.replace(/"([^"]*\{\{.*?\}\}[^"]*)"/g, (_, content) => {
+        return `concat(${stringToFuncArgs(content)})`;
+    });
+    // Strip bare {{}} delimiters (expression is already valid formula syntax)
+    result = result.replace(/\{\{(.*?)\}\}/g, (_, expr) => expr.trim());
+    return result;
+}
+function stringToFuncArgs(str) {
+    const result = [];
+    let currentIndex = 0;
+    while (currentIndex < str.length) {
+        const startBrace = str.indexOf('{{', currentIndex);
+        if (startBrace === -1) {
+            const remaining = str.slice(currentIndex);
+            if (remaining)
+                result.push(`'${remaining}'`);
+            break;
+        }
+        const before = str.slice(currentIndex, startBrace);
+        if (before)
+            result.push(`'${before}'`);
+        const endBrace = str.indexOf('}}', startBrace);
+        if (!endBrace) {
+            result.push(str);
+            break;
+        }
+        const template = str.slice(startBrace + 2, endBrace).trim();
+        if (template)
+            result.push(template);
+        currentIndex = endBrace + 2;
+    }
+    return '[' + result.join(', ') + ']';
+}
+
+const unfoldFormula = (schema) => {
+    const result = {
+        computationType: 'formula',
+        formula: schema.formula,
+        [Symbol.for('type')]: 'ComputationSchema',
+    };
+    return result;
+};
+const unfoldSwitch = (schema) => {
+    return {
+        computationType: 'switch',
+        source: unfoldNodeSchema(schema.source, { type: 'unknown' }, []),
+        cases: schema.cases.map((c) => {
+            return {
+                equals: c.equals,
+                then: unfoldNodeSchema(c.then, { type: 'componentSchema' }),
+            };
+        }),
+        default: unfoldNodeSchema(schema.default, { type: 'componentSchema' }),
+        [Symbol.for('type')]: 'ComputationSchema',
+    };
+};
+function unfoldComputationSchema(schema) {
+    if (typeof schema === 'string') {
+        if (schema.startsWith('=> ')) {
+            let formula = schema.slice(3);
+            if (formula.includes('{{')) {
+                formula = replaceInterpolationsInFormula(formula);
+            }
+            return { computationType: 'formula', formula };
+        }
+        if (schema.includes('{{') && schema.includes('}}')) {
+            return unfoldInterpolationComputationSchema(schema);
+        }
+    }
+    // Check for new for-loop syntax (before computationType check)
+    if (isObject(schema) && 'for' in schema && !('computationType' in schema)) {
+        return unfoldForWithNewSyntax(schema);
+    }
+    if (!isObject(schema) || !('computationType' in schema)) {
+        return null;
+    }
+    if (isUnfoldedComputationSchema(schema)) {
+        return schema;
+    }
+    const computationUnfolders = {
+        formula: (schema) => unfoldFormula(schema),
+        for: (schema) => unfoldForComputationSchema(schema),
+        template: (schema) => unfoldImportComputationSchema(schema),
+        if: (schema) => unfoldIfComputationSchema(schema),
+        switch: (schema) => unfoldSwitch(schema),
+    };
+    const unfolder = computationUnfolders[schema['computationType']];
+    if (unfolder) {
+        return unfolder(schema);
+    }
+    throw new Error(`Unable to unfold computation schema.\n${stringifyObject('Schema', schema)}`);
+}
+function isUnfoldedComputationSchema(schema) {
+    return isObject(schema) && Symbol.for('type') in schema;
+}
+
+const MIRROR_PATTERN = /^<=>\s*(\S+)$/;
+const SELECTION_PATTERN = /^<#>\s*(\S+)->\((\$\w+),\s*(\$\w+)\)$/;
+const OBJECT_PATTERN = /^<\{\}>\s*(\S+)->\((\$\w+),\s*(\$\w+)\)$/;
+const ARRAY_PATTERN = /^<\[\]>\s*(\S+)->\((\$\w+)\)$/;
+function parseBindingShorthand(value) {
+    let match;
+    match = value.match(MIRROR_PATTERN);
+    if (match) {
+        return { bindingType: 'mirror', selector: match[1] };
+    }
+    match = value.match(SELECTION_PATTERN);
+    if (match) {
+        return {
+            bindingType: 'selection',
+            componentSelector: match[1],
+            mapping: { key: match[2], selected: match[3] },
+        };
+    }
+    match = value.match(OBJECT_PATTERN);
+    if (match) {
+        return {
+            bindingType: 'object',
+            componentSelector: match[1],
+            mapping: { key: match[2], value: match[3] },
+        };
+    }
+    match = value.match(ARRAY_PATTERN);
+    if (match) {
+        return {
+            bindingType: 'array',
+            componentSelector: match[1],
+            mapping: { value: match[2] },
+        };
+    }
+    return null;
+}
+function isBindingShorthand(value) {
+    return value.startsWith('<=>') || value.startsWith('<#>') || value.startsWith('<{}>') || value.startsWith('<[]>');
+}
+
+const WrapperPrefix = '+';
+const PathSymbol = '/';
+function unfoldFlatWrappers(wrappers, schema, resultingNode) {
+    const composed = wrappers
+        .reverse()
+        .reduce((composed, wrapper) => unfoldWrapper(wrapper, composed), schema);
+    if ('computationType' in composed) {
+        resultingNode._computation = composed;
+    }
+    else {
+        resultingNode._value = composed;
+    }
+    return resultingNode;
+}
+function unfoldWrapper(wrapper, schema) {
+    const [componentType, props] = wrapper;
+    if (componentType.includes(PathSymbol)) {
+        return {
+            computationType: 'template',
+            path: componentType,
+            ...props,
+            slot: schema,
+        };
+    }
+    const slot = getComponentSlot(componentType);
+    return {
+        componentType,
+        ...props,
+        [slot]: {
+            ...schema,
+        },
+    };
+}
+function getComponentSlot(wrapperType) {
+    const props = DefinitionStore.getInstance().getComputedComponentContract(wrapperType);
+    const componentSlots = Object.entries(props)
+        .filter(([, prop]) => prop.valueType.type === 'component')
+        .map(([key]) => key);
+    if (!componentSlots.length) {
+        throw new Error(`No component slot found for wrapper: "${wrapperType}"`);
+    }
+    if (componentSlots.length > 1) {
+        const defaultSlot = DefinitionStore.getInstance().getComponent(wrapperType)?.defaultSlot;
+        if (!defaultSlot) {
+            throw new Error(`Multiple component slots found for wrapper: "${wrapperType}". Please specify a default slot.`);
+        }
+        return defaultSlot;
+    }
+    return componentSlots[0];
+}
+function extractWrappers(schema) {
+    const wrappers = [];
+    const shallow = { ...schema };
+    for (const key in shallow) {
+        if (key.startsWith(WrapperPrefix)) {
+            const wrapperType = key.slice(1);
+            const wrapperProps = shallow[key] || {};
+            if (!isObject(wrapperProps)) {
+                throw new Error(`Properties for wrapper "${wrapperType}" must be an object`);
+            }
+            wrappers.push([wrapperType, wrapperProps]);
+            delete shallow[key];
+        }
+    }
+    return [wrappers, shallow];
+}
+function hasWrappers(schema) {
+    return Object.keys(schema).some((key) => key.startsWith(WrapperPrefix));
+}
+
+function toFullNotation(nodeSchema, valueType) {
+    const rawNode = {
+        _valueType: valueType,
+        _value: null,
+        _computation: null,
+        _binding: null,
+    };
+    if (nodeSchema === null) {
+        rawNode._value = null;
+        return rawNode;
+    }
+    if (typeof nodeSchema === 'string') {
+        if (nodeSchema.includes('{{') && nodeSchema.includes('}}')) {
+            rawNode._computation = nodeSchema;
+            return rawNode;
+        }
+        if (nodeSchema === '=>') {
+            rawNode._value = '=>';
+            return rawNode;
+        }
+        if (nodeSchema.startsWith('=> ')) {
+            rawNode._computation = nodeSchema;
+            return rawNode;
+        }
+        if (isBindingShorthand(nodeSchema)) {
+            const binding = parseBindingShorthand(nodeSchema);
+            if (binding) {
+                rawNode._binding = binding;
+                return rawNode;
+            }
+        }
+    }
+    if (Array.isArray(nodeSchema) && valueType.type === 'string') {
+        const desugared = desugarStringArray(nodeSchema);
+        return toFullNotation(desugared, valueType);
+    }
+    if (typeof nodeSchema !== 'object') {
+        rawNode._value = nodeSchema;
+        return rawNode;
+    }
+    if ('computationType' in nodeSchema) {
+        rawNode._computation = nodeSchema;
+        return rawNode;
+    }
+    if ('bindingType' in nodeSchema) {
+        rawNode._binding = nodeSchema;
+        return rawNode;
+    }
+    const isFullNotation = ['_valueType', '_value', '_computation', '_binding'].some((key) => key in nodeSchema);
+    if (isFullNotation) {
+        if ('_value' in nodeSchema)
+            rawNode._value = nodeSchema._value;
+        if ('_computation' in nodeSchema)
+            rawNode._computation = nodeSchema._computation;
+        if ('_binding' in nodeSchema)
+            rawNode._binding = nodeSchema._binding;
+        return rawNode;
+    }
+    // detect 'if' short notation
+    // TODO: change to _if to isolate keyword)
+    if ('if' in nodeSchema) {
+        const computation = {
+            computationType: 'if',
+            if: nodeSchema.if,
+            then: null,
+            else: null,
+        };
+        if (!('then' in nodeSchema) && !('else' in nodeSchema)) {
+            const { if: _, ...thenSchema } = nodeSchema;
+            computation['then'] = thenSchema;
+        }
+        else {
+            if ('then' in nodeSchema) {
+                computation['then'] = nodeSchema['then'];
+            }
+            if ('else' in nodeSchema) {
+                computation['else'] = nodeSchema['else'];
+            }
+        }
+        rawNode._computation = computation;
+        return rawNode;
+    }
+    // detect new 'for' syntax
+    if ('for' in nodeSchema) {
+        rawNode._computation = nodeSchema;
+        return rawNode;
+    }
+    if ('templateUrl' in nodeSchema) {
+        const schema = nodeSchema;
+        if (hasWrappers(schema)) {
+            const [wrappers, cleanedSchema] = extractWrappers(schema);
+            return unfoldFlatWrappers(wrappers, toFullNotation(cleanedSchema, valueType), rawNode);
+        }
+        const { templateUrl: path, ...rest } = nodeSchema;
+        rawNode._computation = { computationType: 'template', path, ...rest };
+        return rawNode;
+    }
+    if (hasWrappers(nodeSchema)) {
+        const [wrappers, cleanedSchema] = extractWrappers(nodeSchema);
+        return unfoldFlatWrappers(wrappers, toFullNotation(cleanedSchema, valueType), rawNode);
+    }
+    rawNode._value = nodeSchema;
+    return rawNode;
+}
+function desugarStringArray(items) {
+    if (items.length === 0)
+        return '';
+    if (items.length === 1)
+        return items[0];
+    for (const item of items) {
+        if (typeof item !== 'string') {
+            throw new Error(`styleClass array items must be strings, got ${typeof item}: ${JSON.stringify(item)}`);
+        }
+    }
+    const strings = items;
+    const hasFormula = strings.some((s) => s.startsWith('=> '));
+    if (!hasFormula)
+        return strings.join(' ');
+    const parts = strings.map((s) => (s.startsWith('=> ') ? s.slice(3) : `'${s}'`));
+    return `=> concat([${parts.join(', ')}], ' ')`;
+}
+
+function throwUnfoldError(ctx) {
+    let message = 'Error happened while unfolding node';
+    if (ctx.nodePath) {
+        message += `\nPath: ${JSON.stringify(ctx.nodePath)}.`;
+    }
+    message += stringifyObject('ValueType', ctx.valueType);
+    message += stringifyObject('Provided value', ctx.rawValue);
+    throw new Error(message);
+}
+
+const unfoldBoolean = (ctx) => {
+    if (typeof ctx.rawValue !== 'boolean') {
+        throwUnfoldError(ctx);
+    }
+    return ctx.rawValue;
+};
+
+function unfoldNumber(ctx) {
+    if (!isValidNumber(ctx.rawValue)) {
+        throwUnfoldError(ctx);
+    }
+    return ctx.rawValue;
+}
+function isValidNumber(value) {
+    return typeof value === 'number' && !isNaN(value);
+}
+
+function unfoldString(ctx) {
+    if (typeof ctx.rawValue !== 'string') {
+        throwUnfoldError(ctx);
+    }
+    return ctx.rawValue;
+}
+
+function unfoldUnknown(ctx) {
+    return ctx.rawValue;
+}
+
+function unfoldArray(ctx) {
+    if (!Array.isArray(ctx.rawValue)) {
+        throwUnfoldError(ctx);
+    }
+    return ctx.rawValue.map((item, index) => unfoldNodeSchema(item, ctx.valueType.item, [...ctx.nodePath, index]));
+}
+
+function unfoldMap(ctx) {
+    if (!isObject(ctx.rawValue)) {
+        throwUnfoldError(ctx);
+    }
+    return Object.entries(ctx.rawValue).reduce((structure, [key, child]) => {
+        structure[key] = unfoldNodeSchema(child, ctx.valueType.item, [...ctx.nodePath, key]);
+        return structure;
+    }, {});
+}
+
+function unfoldObject(ctx) {
+    if (!isObject(ctx.rawValue)) {
+        throwUnfoldError(ctx);
+    }
+    const rawObject = ctx.rawValue;
+    return Object.entries(ctx.valueType.fields).reduce((structure, [fieldKey, fieldValueType]) => {
+        const fieldValue = fieldKey in rawObject ? rawObject[fieldKey] : null;
+        structure[fieldKey] = unfoldNodeSchema(fieldValue, fieldValueType, [...ctx.nodePath, fieldKey]);
+        return structure;
+    }, {});
+}
+
+function unfoldCommand(ctx) {
+    const rawValue = ctx.rawValue;
+    if (typeof rawValue === 'string') {
+        return { runnerType: 'js', target: rawValue, owner: null };
+    }
+    if (isObject(rawValue) && 'runnerType' in rawValue && 'target' in rawValue) {
+        if (typeof rawValue['runnerType'] !== 'string') {
+            throw new Error(`Command schema is invalid. Field "runnerType" must be string.`);
+        }
+        if (!rawValue['target']) {
+            throw new Error(`Command schema is invalid. Field "target" must be defined.`);
+        }
+        return rawValue;
+    }
+    if (typeof rawValue === 'function') {
+        return { runnerType: 'inline', target: rawValue, owner: null };
+    }
+    throwUnfoldError(ctx);
+}
+
+function validateProps(rawSchema) {
+    const componentDefinitionProps = DefinitionStore.getInstance().getComputedComponentContract(rawSchema.componentType);
+    const ignoredSchemaProps = new Set([
+        'componentType',
+        'onNodeChange',
+        'ref',
+        'contract',
+        'defaultSlot',
+        'context',
+        'types',
+        'importTypes',
+    ]);
+    const invalidProps = Object.keys(rawSchema).filter((prop) => !componentDefinitionProps[prop] && !ignoredSchemaProps.has(prop) && !prop.startsWith(Delimiters.Variable));
+    if (invalidProps.length) {
+        throw new Error(`Component schema "${rawSchema.componentType}" contains unknown properties: ${invalidProps.join(', ')}`);
+    }
+}
+
+function unfoldComponentSchema(ctx) {
+    if (!isObject(ctx.rawValue)) {
+        throw new Error('Unfolded component schema type');
+    }
+    const componentRawSchema = ctx.rawValue;
+    if (!componentRawSchema.componentType) {
+        componentRawSchema.componentType = 'browser.Element';
+    }
+    validateProps(componentRawSchema);
+    return componentRawSchema;
+}
+
+function unfoldProperty(keyEx, rawSchema) {
+    if (isUnfoldedNodeSchema(rawSchema)) {
+        return [keyEx, rawSchema];
+    }
+    if (keyEx.includes('@')) {
+        const [key, valueType] = parsePropertyKeyShorthand(keyEx);
+        const nodeSchema = unfoldNodeSchema(toFullNotation(rawSchema, valueType), valueType, [key]);
+        return [key, nodeSchema];
+    }
+    if (isObject(rawSchema) && '_valueType' in rawSchema) {
+        const valueType = rawSchema['_valueType']; // TODO: check if valueType is valid
+        const nodeSchema = unfoldNodeSchema(rawSchema, valueType, [keyEx]);
+        return [keyEx, nodeSchema];
+    }
+    throw new Error(`Cannot unfold node schema. Invalid schema notation ${JSON.stringify(rawSchema)} for key "${keyEx}"`);
+}
+
+function unfoldComponent(ctx) {
+    if (typeof ctx.rawValue === 'string' && ctx.rawValue.startsWith('csid-')) {
+        return ctx.rawValue;
+    }
+    if (!isObject(ctx.rawValue)) {
+        throwUnfoldError(ctx);
+    }
+    const componentRawSchema = ctx.rawValue;
+    if (!componentRawSchema.componentType) {
+        componentRawSchema.componentType = 'browser.Element';
+    }
+    validateProps(componentRawSchema);
+    const properties = DefinitionStore.getInstance().getComputedComponentContract(componentRawSchema.componentType);
+    const props = new Map();
+    for (const [key, baseSchema] of Object.entries(properties)) {
+        if (!(key in componentRawSchema)) {
+            props.set(key, baseSchema);
+            continue;
+        }
+        const unfoldedRawSchema = unfoldNodeSchema(componentRawSchema[key], baseSchema.valueType, [...ctx.nodePath, key]);
+        const node = {
+            valueType: baseSchema.valueType,
+            value: unfoldedRawSchema.value ?? baseSchema.value,
+            computation: unfoldedRawSchema.computation || baseSchema.computation,
+            binding: unfoldedRawSchema.binding || baseSchema.binding,
+        };
+        props.set(key, node);
+    }
+    const variables = new Map();
+    for (const [keyEx, schema] of Object.entries(componentRawSchema)) {
+        if (!keyEx.startsWith(Delimiters.Variable)) {
+            continue;
+        }
+        const variableKeyEx = keyEx.slice(Delimiters.Variable.length);
+        const [key, unfolded] = unfoldProperty(variableKeyEx, schema);
+        variables.set(key, unfolded);
+    }
+    const rawHandlers = componentRawSchema.onNodeChange || [];
+    const onNodeChange = rawHandlers.map((handler) => {
+        if (!handler.selector) {
+            throw new Error(`onNodeChange handler "${JSON.stringify(handler)}" is missing required selector.`);
+        }
+        if (!handler.command) {
+            throw new Error(`onNodeChange handler "${JSON.stringify(handler)}" is missing required command.`);
+        }
+        return {
+            selector: handler.selector,
+            command: unfoldNodeSchema(handler.command, { type: 'command' }, ctx.nodePath),
+        };
+    });
+    return {
+        componentType: componentRawSchema.componentType,
+        ref: componentRawSchema.ref || '',
+        props,
+        variables,
+        onNodeChange,
+    };
+}
+
+function unfoldSet(ctx) {
+    const items = ctx.rawValue instanceof Set ? Array.from(ctx.rawValue) : Array.isArray(ctx.rawValue) ? ctx.rawValue : [];
+    return items.map((item, index) => unfoldNodeSchema(item, ctx.valueType.item, [...ctx.nodePath, index]));
+}
+
+function unfoldShape(ctx) {
+    if (!isObject(ctx.rawValue)) {
+        throwUnfoldError(ctx);
+    }
+    const rawValue = ctx.rawValue;
+    const objectValueType = DefinitionStore.getInstance().getShape(ctx.valueType.shapeType);
+    return unfoldObject({ rawValue, valueType: objectValueType, nodePath: ctx.nodePath });
+}
+
+function unfoldShortValidatorSyntax(rawValue) {
+    if ('validatorType' in rawValue) {
+        return rawValue;
+    }
+    const entries = Object.entries(rawValue);
+    const validatorEntries = entries.filter(([key]) => key !== 'message' && key !== 'disabled');
+    if (validatorEntries.length === 0) {
+        throw new Error(`Validator must have at least one validator type specified. Raw value: ${JSON.stringify(rawValue)}`);
+    }
+    if (validatorEntries.length > 1) {
+        throw new Error(`Validator can only have one validator type specified. Raw value: ${JSON.stringify(rawValue)}`);
+    }
+    const [validatorType, param] = validatorEntries[0];
+    const validator = {
+        validatorType,
+        params: {},
+        message: rawValue['message'] || '',
+        disabled: !!rawValue['disabled'],
+    };
+    if (isObject(param)) {
+        validator.params = param;
+    }
+    else {
+        validator.params = { [validatorType]: param };
+    }
+    return validator;
+}
+function unfoldVariantShape(ctx) {
+    if (!isObject(ctx.rawValue)) {
+        throwUnfoldError(ctx);
+    }
+    let rawValue = ctx.rawValue;
+    if ('kind' in rawValue && 'fields' in rawValue) {
+        const kindKey = `${ctx.valueType.shapeType}Type`;
+        const kind = rawValue['kind'];
+        const fields = rawValue['fields'];
+        return {
+            ...fields,
+            [kindKey]: kind,
+        };
+    }
+    const kindKey = `${ctx.valueType.shapeType}Type`;
+    if (kindKey === 'validatorType') {
+        rawValue = unfoldShortValidatorSyntax(rawValue);
+    }
+    const kind = rawValue[kindKey];
+    if (!kind) {
+        throw new Error(`Missing the kind field "${kindKey}"`);
+    }
+    const objectValueType = DefinitionStore.getInstance().getVariantShape(ctx.valueType.shapeType, kind);
+    const objectNode = unfoldNodeSchema(rawValue, objectValueType, ctx.nodePath);
+    return {
+        ...objectNode.value,
+        [kindKey]: kind,
+    };
+}
+
+const handlers = {
+    unknown: unfoldUnknown,
+    number: unfoldNumber,
+    string: unfoldString,
+    boolean: unfoldBoolean,
+    array: unfoldArray,
+    map: unfoldMap,
+    set: unfoldSet,
+    object: unfoldObject,
+    shape: unfoldShape,
+    variantShape: unfoldVariantShape,
+    command: unfoldCommand,
+    componentSchema: unfoldComponentSchema,
+    component: unfoldComponent,
+};
+function unfoldValue(ctx) {
+    const handler = handlers[ctx.valueType.type];
+    if (!handler) {
+        throw new Error(`Cannot unfold value "${ctx.rawValue}". Unknown value type '${ctx.valueType.type}'`);
+    }
+    if (ctx.rawValue === undefined || ctx.rawValue === null) {
+        return null;
+    }
+    return handler(ctx);
+}
+
+function unfoldNodeSchema(rawSchema, valueType, nodePath = []) {
+    if (isUnfoldedNodeSchema(rawSchema)) {
+        return rawSchema;
+    }
+    const node = {
+        valueType,
+        value: null,
+        computation: null,
+        binding: null,
+        [Symbol.for('type')]: 'NodeSchema',
+    };
+    const nodeSchema = toFullNotation(rawSchema, valueType);
+    if ('_binding' in nodeSchema) {
+        node.binding = nodeSchema['_binding'];
+    }
+    if ('_computation' in nodeSchema) {
+        node.computation = unfoldComputationSchema(nodeSchema._computation);
+    }
+    if ('_value' in nodeSchema) {
+        node.value = unfoldValue({
+            rawValue: nodeSchema._value,
+            valueType,
+            nodePath,
+        });
+    }
+    return node;
+}
+function isUnfoldedNodeSchema(nodeSchema) {
+    return isObject(nodeSchema) && ['valueType', 'value', 'computation', 'binding'].every((key) => key in nodeSchema);
+}
+
+function extractComponentTypes(schema, types = new Set()) {
+    extractFromValue(schema, types);
+    extractFromComputations(schema, types);
+    return types;
+}
+function extractFromValue(schema, types) {
+    if (!schema.value) {
+        return types;
+    }
+    const type = schema.valueType.type;
+    if (type === 'component') {
+        const componentSchema = schema;
+        if (!isObject(componentSchema.value)) {
+            return types;
+        }
+        types.add(componentSchema.value.componentType);
+        for (const prop of componentSchema.value.props.values()) {
+            extractComponentTypes(prop, types);
+        }
+        for (const variable of componentSchema.value.variables.values()) {
+            extractComponentTypes(variable, types);
+        }
+    }
+    if (type === 'componentSchema' || type === 'unknown') {
+        const componentSchema = schema;
+        if (isObject(componentSchema.value) && 'componentType' in componentSchema.value) {
+            extractFromRawComponentSchema(componentSchema.value, types);
+        }
+    }
+    if (type === 'array') {
+        const arraySchema = schema;
+        for (const item of arraySchema.value || []) {
+            extractComponentTypes(item, types);
+        }
+    }
+    if (type === 'object' || type === 'map') {
+        const objectSchema = schema;
+        for (const prop of Object.values(objectSchema.value || {})) {
+            extractComponentTypes(prop, types);
+        }
+    }
+    return types;
+}
+function extractFromComputations(schema, types) {
+    if (!schema.computation) {
+        return types;
+    }
+    if (isSwitchComputation(schema.computation)) {
+        for (const caseItem of schema.computation.cases) {
+            extractComponentTypes(caseItem.then, types);
+        }
+        extractComponentTypes(schema.computation.default, types);
+    }
+    if (isIfComputation(schema.computation)) {
+        extractComponentTypes(schema.computation.then, types);
+        extractComponentTypes(schema.computation.else, types);
+    }
+    if (isForComputation(schema.computation)) {
+        extractComponentTypes(schema.computation.yield, types);
+    }
+    if (isTemplateComputation(schema.computation)) {
+        if (schema.computation.defer) {
+            if (schema.computation.defer.placeholder) {
+                extractComponentTypes(schema.computation.defer.placeholder, types);
+            }
+            if (schema.computation.defer.error) {
+                extractComponentTypes(schema.computation.defer.error, types);
+            }
+        }
+        for (const variable of Object.values(schema.computation.contractVariables)) {
+            if (isObject(variable) || Array.isArray(variable)) {
+                extractFromRawComponentSchema(variable, types);
+            }
+        }
+    }
+    return types;
+}
+function extractFromRawComponentSchema(schema, types) {
+    if (Array.isArray(schema)) {
+        for (const item of schema) {
+            if (isObject(item) || Array.isArray(item)) {
+                extractFromRawComponentSchema(item, types);
+            }
+        }
+        return types;
+    }
+    if (isObject(schema)) {
+        for (const [key, value] of Object.entries(schema)) {
+            if (key === 'componentType' && typeof value === 'string') {
+                types.add(value);
+            }
+            if (isObject(value) || Array.isArray(value)) {
+                extractFromRawComponentSchema(value, types);
+            }
+        }
+    }
+    return types;
+}
+
+const templateRegistry = {
+    entries: new Map(),
+    get(url) {
+        return this.entries.get(url);
+    },
+    getAggregatedComponentTypes(url) {
+        const aggregated = new Set();
+        const visited = new Set();
+        const collect = (currentUrl) => {
+            if (visited.has(currentUrl))
+                return;
+            visited.add(currentUrl);
+            const entry = this.entries.get(currentUrl);
+            if (!entry)
+                return;
+            // Add own component types
+            for (const type of entry.ownComponentTypes) {
+                aggregated.add(type);
+            }
+            // Recursively collect from dependencies
+            for (const depUrl of entry.dependencies) {
+                collect(depUrl);
+            }
+        };
+        collect(url);
+        return aggregated;
+    },
+    getAllComponentTypes() {
+        const allTypes = new Set();
+        for (const entry of this.entries.values()) {
+            for (const type of entry.ownComponentTypes) {
+                allTypes.add(type);
+            }
+        }
+        return allTypes;
+    },
+    set(url, recipe, ownComponentTypes, dependencies) {
+        this.entries.set(url, {
+            recipe,
+            ownComponentTypes,
+            dependencies: dependencies || new Set(),
+        });
+    },
+    has(url) {
+        return this.entries.has(url);
+    },
+    reset() {
+        this.entries.clear();
+    },
+};
+
+const withBaseTemplateUrl = (url) => `/recipes/${url}.yml`;
+async function loadRecipe(url) {
+    const response = await fetch(withBaseTemplateUrl(url));
+    if (response.status === 404) {
+        throw new Error(`Schema not found: ${url}`);
+    }
+    const text = await response.text();
+    try {
+        return parse(text);
+    }
+    catch (e) {
+        throw new Error(`Failed to parse YAML: ${e}`);
+    }
+}
+
+function registerDeclaredType(name, definition) {
+    let properties;
+    if (typeof definition === 'string') {
+        const parsed = parseValueType(definition);
+        if (parsed.type !== 'object') {
+            throw new Error(`Type "${name}" must be an object type, got "${parsed.type}"`);
+        }
+        properties = parsed.fields;
+    }
+    else {
+        properties = {};
+        for (const [propName, propType] of Object.entries(definition)) {
+            properties[propName] = parseValueType(propType);
+        }
+    }
+    const store = DefinitionStore.getInstance();
+    const existing = store.shapes[name];
+    if (existing && !isEqualType(existing.properties, properties)) {
+        throw new Error(`Type "${name}" is already defined with a different shape`);
+    }
+    store.setShape(name, properties);
+}
+function isEqualType(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+
+const reservedKeys = new Set(['importTypes', 'types', 'contract', 'defaultSlot']);
+function isTypeOnlyTemplate(template) {
+    const contentKeys = Object.keys(template).filter((k) => !reservedKeys.has(k));
+    return contentKeys.length > 0 && contentKeys.every((k) => k.includes('.'));
+}
+async function loadTemplates(recipe) {
+    // Pass 1: Recursively load all templates and register types immediately
+    const allTemplates = new Map();
+    await collectAllTemplates(recipe, allTemplates);
+    // Register types from the root recipe (after all dependencies are loaded)
+    const rootTypes = recipe.types;
+    if (rootTypes) {
+        for (const [key, value] of Object.entries(rootTypes)) {
+            if (typeof value === 'string' || isObject(value)) {
+                registerDeclaredType(key, value);
+            }
+        }
+    }
+    // Pass 2: Unfold and register all templates (types are already registered)
+    for (const [url, template] of allTemplates) {
+        try {
+            const { types: _types, importTypes: _importTypes, contract: _contract, defaultSlot: _defaultSlot, ...rootRawSchema } = template;
+            // Skip unfolding for type-only templates (all keys are namespaced)
+            if (isTypeOnlyTemplate(template)) {
+                templateRegistry.set(url, template, new Set(), extractUrls(template));
+                continue;
+            }
+            const schema = unfoldNodeSchema(rootRawSchema, { type: 'component' });
+            const componentTypes = extractComponentTypes(schema);
+            const dependencies = extractUrls(template);
+            templateRegistry.set(url, template, componentTypes, dependencies);
+        }
+        catch (e) {
+            log.error(`Failed to resolve template: ${url}`, e);
+            throw new Error(`Failed to resolve template: ${url}`, { cause: e });
+        }
+    }
+}
+async function collectAllTemplates(recipe, collected) {
+    const urls = extractUrls(recipe);
+    const newUrls = Array.from(urls).filter((url) => !templateRegistry.has(url) && !collected.has(url));
+    if (newUrls.length === 0)
+        return;
+    const templates = await Promise.all(newUrls.map((url) => loadRecipe(url)));
+    // Register types immediately after loading (before recursive collection)
+    const pending = new Map();
+    for (const template of templates) {
+        const isTypeOnlyFile = isTypeOnlyTemplate(template);
+        const typesToRegister = isTypeOnlyFile ? template : (template.types ?? {});
+        for (const [key, value] of Object.entries(typesToRegister)) {
+            if (key === 'importTypes')
+                continue;
+            if (isTypeOnlyFile && !key.includes('.')) {
+                throw new Error(`Invalid key "${key}" in type-only file. Type names must be namespaced (e.g., "app.MyType")`);
+            }
+            if (typeof value !== 'string' && !isObject(value)) {
+                throw new Error(`Invalid type definition for "${key}". Expected string or object, got ${typeof value}`);
+            }
+            pending.set(key, value);
+        }
+    }
+    // Register with retries to handle forward references between types
+    let lastSize = -1;
+    while (pending.size > 0 && pending.size !== lastSize) {
+        lastSize = pending.size;
+        for (const [key, value] of pending) {
+            try {
+                registerDeclaredType(key, value);
+                pending.delete(key);
+            }
+            catch {
+                // Will retry after other types are registered
+            }
+        }
+    }
+    for (const [key, value] of pending) {
+        try {
+            registerDeclaredType(key, value);
+        }
+        catch (e) {
+            throw new Error(`Failed to register type "${key}"`, { cause: e });
+        }
+    }
+    for (let i = 0; i < newUrls.length; i++) {
+        collected.set(newUrls[i], templates[i]);
+    }
+    // Recursively collect from loaded templates
+    await Promise.all(templates.map((t) => collectAllTemplates(t, collected)));
+}
+function extractUrls(value, urls = new Set()) {
+    if (value == null)
+        return urls;
+    if (Array.isArray(value)) {
+        value.forEach((item) => extractUrls(item, urls));
+        return urls;
+    }
+    if (!isObject(value))
+        return urls;
+    if ('_defer' in value)
+        return urls;
+    for (const [key, val] of Object.entries(value)) {
+        if (key.startsWith(WrapperPrefix) && key.includes(PathSymbol)) {
+            urls.add(key.slice(1));
+        }
+        if (key === 'importTypes') {
+            if (!Array.isArray(val)) {
+                throw new Error(`"importTypes" must be an array, got ${typeof val}`);
+            }
+            for (const url of val) {
+                if (typeof url !== 'string') {
+                    throw new Error(`"importTypes" entries must be strings, got ${typeof url}`);
+                }
+                urls.add(url);
+            }
+            continue;
+        }
+        if (typeof val !== 'string') {
+            extractUrls(val, urls);
+            continue;
+        }
+        if (key === 'templateUrl') {
+            urls.add(val);
+        }
+        extractUrls(val, urls);
+    }
+    return urls;
+}
+
+function unfoldComponentDefinition(rawDefinition) {
+    const properties = {};
+    for (const entry of Object.entries(rawDefinition.properties)) {
+        const [key, prop] = unfoldProperty(...entry);
+        properties[key] = prop;
+    }
+    return {
+        traits: rawDefinition.traits,
+        properties,
+        defaultSlot: rawDefinition.defaultSlot,
+    };
+}
+function unfoldComponentDefinitions(rawDefinitions) {
+    const result = {};
+    for (const [componentType, rawDefinition] of Object.entries(rawDefinitions)) {
+        result[componentType] = unfoldComponentDefinition(rawDefinition);
+    }
+    return result;
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { PathSymbol, WrapperPrefix, extractComponentTypes, extractWrappers, hasWrappers, isObject, isUnfoldedNodeSchema, loadRecipe, loadTemplates, parseValueType, registerDeclaredType, templateRegistry, toFullNotation, unfoldComponentDefinition, unfoldComponentDefinitions, unfoldFlatWrappers, unfoldNodeSchema, unfoldProperty, withBaseTemplateUrl };
+//# sourceMappingURL=kaskad-schema.mjs.map