@yoyoboot/yoyo-admin-schema 10.5.5

package/dist/compiler.js

@@ -0,0 +1,1300 @@
+import { z } from 'zod';
+import { YOYO_PAGE_KINDS, YOYO_COLUMN_PRIORITIES, YOYO_COLUMN_ROLES, YOYO_GRID_PRESENTATIONS, YOYO_FILTER_OPERATORS, YOYO_MOBILE_PLACEMENTS, } from './types.js';
+import { isYoyoMutationActionKind, linkYoyoActionContract, operationForYoyoActionKind, validateYoyoActionContractCatalog, } from './action-contract.js';
+import { linkYoyoGeneratedValidationContract, validateYoyoGeneratedValidationContractCatalog, } from './generated-validation-contract.js';
+import { yoyoV1ActionRegistry } from './action-registry.js';
+import { YOYO_EXTENSION_SLOTS } from './extension-registry.js';
+import { yoyoV1FieldRegistry } from './field-registry.js';
+import { yoyoV1RendererRegistry } from './renderer-registry.js';
+import { YoyoSchemaValidationError } from './diagnostics.js';
+const fieldLifecycleShape = z
+    .object({
+    editableOn: z.enum(['create', 'edit', 'both', 'never']).optional(),
+    createDefault: z.unknown().optional(),
+    editDefault: z.unknown().optional(),
+    submitOnEdit: z.boolean().optional(),
+})
+    .strict();
+const fieldOptionShape = z.lazy(() => z
+    .object({
+    value: z.string().min(1),
+    label: z.string().min(1),
+    disabled: z.boolean().optional(),
+    children: z.array(fieldOptionShape).optional(),
+})
+    .strict());
+const queryPresentationShape = z
+    .object({
+    defaultSort: z
+        .object({ key: z.string().min(1), direction: z.enum(['asc', 'desc']) })
+        .optional(),
+    pageSize: z.number().int().positive().optional(),
+    allowedUrlParams: z.array(z.string().min(1)).optional(),
+})
+    .strict();
+const actionConfirmationShape = z
+    .object({
+    intent: z.enum(['destructive', 'warning']),
+    subjectFields: z.array(z.string().min(1)).optional(),
+})
+    .strict();
+const fieldShape = z
+    .object({
+    key: z.string().min(1),
+    kind: z.string().min(1),
+    label: z.string().min(1),
+    description: z.string().optional(),
+    required: z.boolean().optional(),
+    lifecycle: fieldLifecycleShape.optional(),
+    options: z.array(fieldOptionShape).min(1).optional(),
+    optionSource: z.string().min(1).optional(),
+    filter: z
+        .object({
+        quick: z.boolean().optional(),
+        operators: z.array(z.enum(YOYO_FILTER_OPERATORS)).min(1).optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+const columnShape = z
+    .object({
+    key: z.string().min(1),
+    title: z.string().min(1),
+    renderer: z.string().optional(),
+    sortable: z.boolean().optional(),
+    role: z.enum(YOYO_COLUMN_ROLES).optional(),
+    priority: z.enum(YOYO_COLUMN_PRIORITIES).optional(),
+    mobilePlacement: z.enum(YOYO_MOBILE_PLACEMENTS).optional(),
+    recordRendererKey: z.string().min(1).optional(),
+    export: z
+        .object({
+        mode: z.enum(['allowed', 'sensitive', 'disabled']),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+const actionShape = z
+    .object({
+    key: z.string().min(1),
+    kind: z.string().min(1),
+    label: z.string().optional(),
+    placement: z.enum(['page', 'row', 'bulk', 'form']).optional(),
+    permission: z.string().optional(),
+    feature: z.string().optional(),
+    contractKey: z.string().min(1).optional(),
+    confirmation: actionConfirmationShape.optional(),
+    rowOverlay: z.string().min(1).optional(),
+})
+    .strict();
+const extensionShape = z
+    .object({
+    key: z.string().min(1),
+    slot: z.string().min(1),
+    overlay: z.enum(['dialog', 'drawer']).optional(),
+})
+    .strict();
+const tableVirtualizationShape = z
+    .object({
+    mode: z.literal('fixed'),
+})
+    .strict();
+const tableGroupingShape = z
+    .object({
+    mode: z.literal('client'),
+    columnKey: z.string().min(1),
+    defaultExpanded: z.boolean().optional(),
+})
+    .strict();
+const queryPageShape = z
+    .object({
+    schemaVersion: z.literal(1),
+    pageKind: z.literal('query'),
+    pageKey: z.string().min(1),
+    title: z.string().min(1),
+    query: z
+        .object({
+        datasource: z.string().min(1),
+        fields: z.array(fieldShape).optional(),
+        defaultValues: z.record(z.string(), z.unknown()).optional(),
+        presentation: queryPresentationShape.optional(),
+    })
+        .strict(),
+    table: z
+        .object({
+        rowKey: z.string().min(1),
+        columns: z.array(columnShape).min(1),
+        grouping: tableGroupingShape.optional(),
+        virtualization: tableVirtualizationShape.optional(),
+    })
+        .strict(),
+    form: z.never().optional(),
+    actions: z.array(actionShape).optional(),
+    extensions: z.never().optional(),
+})
+    .strict();
+function isJsonFixedValue(value, ancestors = new Set()) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return true;
+    if (typeof value === 'number')
+        return Number.isFinite(value);
+    if (typeof value !== 'object' || ancestors.has(value))
+        return false;
+    if (!Array.isArray(value) &&
+        Object.getPrototypeOf(value) !== Object.prototype &&
+        Object.getPrototypeOf(value) !== null)
+        return false;
+    ancestors.add(value);
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    const valid = Reflect.ownKeys(value).every((key) => typeof key === 'string') &&
+        Object.entries(descriptors).every(([key, descriptor]) => Array.isArray(value) && key === 'length'
+            ? true
+            : descriptor.enumerable &&
+                'value' in descriptor &&
+                isJsonFixedValue(descriptor.value, ancestors)) &&
+        (!Array.isArray(value) || Object.keys(value).length === value.length);
+    ancestors.delete(value);
+    return valid;
+}
+const fixedRequestShape = z
+    .object({
+    fixedValues: z.custom((value) => value !== null &&
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        isJsonFixedValue(value), 'fixedValues must contain only deterministic JSON-safe values'),
+})
+    .strict();
+const formShape = z
+    .object({
+    fields: z.array(fieldShape).min(1),
+    request: z
+        .object({
+        create: fixedRequestShape.optional(),
+        update: fixedRequestShape.optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+const crudPageShape = z
+    .object({
+    schemaVersion: z.literal(1),
+    pageKind: z.literal('crud'),
+    pageKey: z.string().min(1),
+    title: z.string().min(1),
+    query: z
+        .object({
+        datasource: z.string().min(1),
+        fields: z.array(fieldShape).optional(),
+        defaultValues: z.record(z.string(), z.unknown()).optional(),
+        presentation: queryPresentationShape.optional(),
+    })
+        .strict(),
+    table: z
+        .object({
+        rowKey: z.string().min(1),
+        columns: z.array(columnShape).min(1),
+        grouping: tableGroupingShape.optional(),
+        virtualization: tableVirtualizationShape.optional(),
+    })
+        .strict(),
+    form: formShape,
+    actions: z.array(actionShape).optional(),
+    extensions: z.never().optional(),
+})
+    .strict();
+const crudExPageShape = z
+    .object({
+    schemaVersion: z.literal(1),
+    pageKind: z.literal('crud-ex'),
+    pageKey: z.string().min(1),
+    title: z.string().min(1),
+    query: z
+        .object({
+        datasource: z.string().min(1),
+        fields: z.array(fieldShape).optional(),
+        defaultValues: z.record(z.string(), z.unknown()).optional(),
+        presentation: queryPresentationShape.optional(),
+    })
+        .strict(),
+    table: z
+        .object({
+        rowKey: z.string().min(1),
+        columns: z.array(columnShape).min(1),
+        grouping: tableGroupingShape.optional(),
+        virtualization: tableVirtualizationShape.optional(),
+    })
+        .strict(),
+    form: formShape,
+    actions: z.array(actionShape).optional(),
+    extensions: z.array(extensionShape).min(1),
+})
+    .strict();
+const pageShape = z.discriminatedUnion('pageKind', [queryPageShape, crudPageShape, crudExPageShape]);
+/**
+ * Declares a canonical V1 page schema while retaining its literal page kind.
+ * The historical name remains the single public authoring entry point.
+ */
+export function defineYoyoQueryPage(page) {
+    return page;
+}
+export function compileYoyoPageSchema(input, options = {}) {
+    const structuralResult = pageShape.safeParse(input);
+    if (!structuralResult.success) {
+        throw new YoyoSchemaValidationError(structuralResult.error.issues.map((issue) => ({
+            code: issue.code === 'unrecognized_keys' ? 'YSCH003' : 'YSCH002',
+            path: formatPath(issue.path),
+            severity: 'blocking',
+            guidance: issue.path[0] === 'pageKind'
+                ? 'Use one of query/crud/crud-ex and satisfy its required structure.'
+                : 'Use the declared v1 schema shape and remove unknown fields.',
+            message: issue.message,
+        })));
+    }
+    const page = structuralResult.data;
+    const diagnostics = [];
+    const mode = options.mode ?? 'fixture';
+    const context = mode === 'project' ? requireCompileContext(page.pageKey, options) : options.context;
+    const source = toSourceLocation(page.pageKey, context);
+    const registry = options.registry ?? context?.registry;
+    if (page.pageKind === 'query' && !page.table) {
+        diagnostics.push({
+            code: 'YSCH006',
+            path: 'table',
+            severity: 'blocking',
+            ...diagnosticSource(source),
+            guidance: 'Query pages must provide table for rendering and conformance.',
+            message: 'Query pages require a table contract.',
+        });
+    }
+    if (isBareUrl(page.query.datasource)) {
+        diagnostics.push({
+            code: 'YSCH005',
+            path: 'query.datasource',
+            severity: 'blocking',
+            ...diagnosticSource(source),
+            guidance: 'Replace URL paths with a registered datasource key.',
+            message: 'Schema datasource must be a registered key, not a URL.',
+        });
+    }
+    if (!isPageKindAllowed(page.pageKind)) {
+        diagnostics.push({
+            code: 'YSCH010',
+            path: 'pageKind',
+            severity: 'blocking',
+            ...diagnosticSource(source),
+            guidance: 'Use query / crud / crud-ex only.',
+            message: `Page kind '${page.pageKind}' is not supported by Schema v1.`,
+        });
+    }
+    if (page.pageKind === 'crud' && !page.form) {
+        diagnostics.push({
+            code: 'YSCH006',
+            path: 'form',
+            severity: 'blocking',
+            ...diagnosticSource(source),
+            guidance: 'CRUD pages must declare form fields.',
+            message: 'CRUD pages require form schema.',
+        });
+    }
+    if (page.pageKind === 'crud-ex' && (!page.extensions || page.extensions.length === 0)) {
+        diagnostics.push({
+            code: 'YSCH006',
+            path: 'extensions',
+            severity: 'blocking',
+            ...diagnosticSource(source),
+            guidance: 'crud-ex pages must declare at least one extension entry.',
+            message: 'crud-ex pages require extension entries.',
+        });
+    }
+    if (registry?.datasources && !registry.datasources.includes(page.query.datasource)) {
+        diagnostics.push({
+            code: 'YDS001',
+            path: 'query.datasource',
+            severity: 'blocking',
+            source,
+            guidance: 'Register the datasource key in compile project context.',
+            message: `Datasource '${page.query.datasource}' is not registered.`,
+        });
+    }
+    addDuplicateDiagnostics(diagnostics, page.query.fields ?? [], 'query.fields', source, 'YSCH004');
+    if (page.table) {
+        addDuplicateDiagnostics(diagnostics, page.table.columns, 'table.columns', source, 'YSCH004');
+        if (page.table.grouping &&
+            !page.table.columns.some((column) => column.key === page.table.grouping.columnKey)) {
+            diagnostics.push({
+                code: 'YGRP001',
+                path: 'table.grouping.columnKey',
+                severity: 'blocking',
+                source,
+                guidance: 'Reference a column declared by table.columns.',
+                message: `Grouping column '${page.table.grouping.columnKey}' is not declared by the table.`,
+            });
+        }
+        if (page.table.grouping && page.table.virtualization) {
+            diagnostics.push({
+                code: 'YGRP002',
+                path: 'table.grouping',
+                severity: 'blocking',
+                source,
+                guidance: 'Use client grouping or fixed-row virtualization independently until a mixed-height grouped virtualizer is approved.',
+                message: 'Client row grouping cannot be combined with fixed-row virtualization in Schema v1.',
+            });
+        }
+    }
+    const actions = page.actions ?? [];
+    const linkedActionContracts = new Map();
+    const linkedValidationContracts = new Map();
+    const extensions = page.pageKind === 'crud-ex' ? page.extensions : [];
+    addDuplicateDiagnostics(diagnostics, actions, 'actions', source, 'YSCH004');
+    addDuplicateDiagnostics(diagnostics, extensions, 'extensions', source, 'YSCH004');
+    if (registry?.actionContracts) {
+        diagnostics.push(...validateYoyoActionContractCatalog(registry.actionContracts, registry));
+    }
+    if (registry?.validationContracts) {
+        diagnostics.push(...validateYoyoGeneratedValidationContractCatalog(registry.validationContracts));
+    }
+    for (const [index, field] of page.query.fields?.entries() ?? []) {
+        validateField(diagnostics, field, `query.fields[${index}]`, registry, source);
+        validateFieldLifecycle(diagnostics, field, `query.fields[${index}]`, source);
+        validateQueryFilterContract(diagnostics, field, `query.fields[${index}]`, registry, source);
+    }
+    for (const [index, field] of page.form?.fields.entries() ?? []) {
+        validateField(diagnostics, field, `form.fields[${index}]`, registry, source);
+        validateFieldLifecycle(diagnostics, field, `form.fields[${index}]`, source);
+    }
+    const normalizedColumns = page.table?.columns.map((column, index) => normalizeColumn(column, page.table.rowKey, index)) ?? [];
+    for (const [index, column] of normalizedColumns.entries()) {
+        const renderer = resolveRendererDefinition(column.renderer, registry);
+        if (!renderer) {
+            diagnostics.push({
+                code: 'YREG001',
+                path: `table.columns[${index}].renderer`,
+                severity: 'blocking',
+                ...diagnosticSource(source),
+                guidance: 'Use renderer keys from the registered renderer catalog.',
+                message: `Renderer '${column.renderer}' is not registered in Schema v1.`,
+            });
+        }
+        else if (renderer.inputKind !== 'cell-value' ||
+            !renderer.slots.includes('cell') ||
+            YOYO_GRID_PRESENTATIONS.some((presentation) => !renderer.presentations.includes(presentation))) {
+            diagnostics.push({
+                code: 'YREG002',
+                path: `table.columns[${index}].renderer`,
+                severity: 'blocking',
+                ...diagnosticSource(source),
+                guidance: 'Use a registered cell-value renderer that supports Grid, Priority Table, and Record List.',
+                message: `Renderer '${column.renderer}' does not support the required Data Workbench cell presentations.`,
+            });
+        }
+        if (column.recordRendererKey) {
+            const recordRenderer = resolveRendererDefinition(column.recordRendererKey, registry);
+            if (!recordRenderer ||
+                recordRenderer.inputKind !== 'record' ||
+                !recordRenderer.slots.includes('record') ||
+                !recordRenderer.presentations.includes('record-list')) {
+                diagnostics.push({
+                    code: 'YREG002',
+                    path: `table.columns[${index}].recordRendererKey`,
+                    severity: 'blocking',
+                    source,
+                    guidance: 'Register a record renderer with inputKind record, slot record, and record-list presentation support.',
+                    message: `Record renderer '${column.recordRendererKey}' does not support the required record-list capability.`,
+                });
+            }
+        }
+    }
+    validateResponsiveColumns(diagnostics, normalizedColumns, source);
+    for (const [index, action] of actions.entries()) {
+        if (!yoyoV1ActionRegistry.has(action.kind) && !registry?.actions?.includes(action.kind)) {
+            diagnostics.push({
+                code: 'YREG001',
+                path: `actions[${index}].kind`,
+                severity: 'blocking',
+                source,
+                guidance: 'Use action keys from the registered action catalog.',
+                message: `Action '${action.kind}' is not registered in Schema v1.`,
+            });
+        }
+        if (!allowedActionPlacements(action.kind).includes(action.placement ?? defaultActionPlacement(action.kind))) {
+            diagnostics.push({
+                code: 'YACT013',
+                path: `actions[${index}].placement`,
+                severity: 'blocking',
+                source,
+                guidance: 'Use the canonical action outlet or register a separately typed action capability.',
+                message: `Action '${action.kind}' cannot be placed in '${action.placement}'.`,
+            });
+        }
+        const expectedOperation = operationForYoyoActionKind(action.kind);
+        // A generic 'command' carries no canonical operation, but it links the same generated action
+        // contract so the runtime can resolve its context before invoking the executor.
+        const linksActionContract = Boolean(expectedOperation) || action.kind === 'command';
+        const linkedContract = action.contractKey && linksActionContract && registry?.actionContracts
+            ? linkYoyoActionContract(registry.actionContracts, action.contractKey)
+            : undefined;
+        if (action.confirmation &&
+            !isYoyoMutationActionKind(action.kind) &&
+            !(action.kind === 'command' && linkedContract)) {
+            diagnostics.push({
+                code: 'YCON001',
+                path: `actions[${index}].confirmation`,
+                severity: 'blocking',
+                source,
+                guidance: 'Confirmation intent is only valid for datasource mutation actions.',
+                message: `Non-mutation action '${action.kind}' cannot declare confirmation intent.`,
+            });
+        }
+        if (action.confirmation?.intent === 'destructive' && expectedOperation === 'create') {
+            diagnostics.push({
+                code: 'YCON002',
+                path: `actions[${index}].confirmation`,
+                severity: 'blocking',
+                source,
+                guidance: 'A destructive confirmation intent is incompatible with a create operation/contract.',
+                message: `Destructive confirmation on action '${action.key}' conflicts with operation '${expectedOperation}'.`,
+            });
+        }
+        if (action.confirmation?.intent === 'destructive' &&
+            linkedContract?.operation === 'create' &&
+            expectedOperation !== 'create') {
+            diagnostics.push({
+                code: 'YCON004',
+                path: `actions[${index}].confirmation`,
+                severity: 'blocking',
+                source,
+                guidance: 'Use a non-create linked action contract for destructive confirmation.',
+                message: `Destructive confirmation on action '${action.key}' conflicts with linked contract operation 'create'.`,
+            });
+        }
+        // YACT001 only fires once an action contract catalog is configured (downstream phase).
+        // In the foundation phase no action contract catalog exists, so mutations may declare
+        // permission/feature literals validated by the capability catalog (YCAP001) instead.
+        if (isYoyoMutationActionKind(action.kind) && !action.contractKey && registry?.actionContracts) {
+            diagnostics.push({
+                code: 'YACT001',
+                path: `actions[${index}].contractKey`,
+                severity: 'blocking',
+                source,
+                guidance: 'Link every datasource mutation to a backend action contract with contractKey.',
+                message: `Mutation action '${action.key}' must declare contractKey.`,
+            });
+        }
+        // 'command' is a generic semantic kind: it carries no canonical operation, but it
+        // must be able to link the action contract the runtime resolves before executing.
+        if (!isYoyoMutationActionKind(action.kind) && action.kind !== 'command' && action.contractKey) {
+            diagnostics.push({
+                code: 'YACT007',
+                path: `actions[${index}].contractKey`,
+                severity: 'blocking',
+                source,
+                guidance: 'Only datasource mutation actions may declare contractKey.',
+                message: `Non-mutation action '${action.kind}' cannot declare contractKey.`,
+            });
+        }
+        if (action.contractKey && linksActionContract) {
+            const contract = linkedContract;
+            if (!contract) {
+                diagnostics.push({
+                    code: 'YACT002',
+                    path: `actions[${index}].contractKey`,
+                    severity: 'blocking',
+                    source,
+                    guidance: 'Register the feature-scoped contractKey in the generated backend action catalog.',
+                    message: `Action contract '${action.contractKey}' is unknown or the action catalog is unavailable.`,
+                });
+            }
+            else {
+                if (expectedOperation && contract.operation !== expectedOperation) {
+                    diagnostics.push({
+                        code: 'YACT003',
+                        path: `actions[${index}].contractKey`,
+                        severity: 'blocking',
+                        source,
+                        guidance: 'Use the fixed Schema kind to catalog operation compatibility mapping.',
+                        message: `Schema action kind '${action.kind}' is incompatible with contract operation '${contract.operation}'.`,
+                    });
+                }
+                if (action.permission || action.feature) {
+                    diagnostics.push({
+                        code: 'YACT004',
+                        path: `actions[${index}]`,
+                        severity: 'blocking',
+                        source,
+                        guidance: 'Read permission and feature references from the linked action contract only.',
+                        message: 'A mutation with contractKey must not duplicate permission or feature literals in Page Schema.',
+                    });
+                }
+                linkedActionContracts.set(action.key, contract);
+                const formMode = action.kind === 'create' ? 'create' : action.kind === 'edit' ? 'update' : undefined;
+                if (formMode) {
+                    const validationCatalog = registry?.validationContracts;
+                    const validation = validationCatalog && contract.validationOperationId
+                        ? linkYoyoGeneratedValidationContract(validationCatalog, contract.validationOperationId, formMode)
+                        : undefined;
+                    if (validation) {
+                        linkedValidationContracts.set(action.key, validation);
+                        validateValidationFieldMapping(diagnostics, page, validation, formMode, source);
+                        if (!registry?.validationContractExecutables?.includes(validation.contractKey)) {
+                            diagnostics.push({
+                                code: 'YVAL006',
+                                path: `actions[${index}].contractKey`,
+                                severity: 'blocking',
+                                source,
+                                guidance: 'Regenerate and register the executable validator that matches this validation contract key.',
+                                message: `Generated validation contract '${validation.contractKey}' has no executable validator.`,
+                            });
+                        }
+                    }
+                    else {
+                        diagnostics.push({
+                            code: 'YVAL003',
+                            path: `actions[${index}].contractKey`,
+                            severity: 'blocking',
+                            source,
+                            guidance: 'Regenerate matching backend action and OpenAPI validation contracts for this create/update action.',
+                            message: `Action contract '${contract.actionKey}' has no generated validation branch for mode '${formMode}'.`,
+                        });
+                    }
+                }
+            }
+        }
+        validateActionConfirmation(diagnostics, page, action, index, source);
+        if (!action.contractKey &&
+            action.permission &&
+            registry?.permissions &&
+            !registry.permissions.includes(action.permission)) {
+            diagnostics.push({
+                code: 'YCAP001',
+                path: `actions[${index}].permission`,
+                severity: 'blocking',
+                source,
+                guidance: 'Use permission keys produced by capability catalog.',
+                message: `Permission '${action.permission}' is not present in the capability catalog.`,
+            });
+        }
+        if (!action.contractKey &&
+            action.feature &&
+            registry?.features &&
+            !registry.features.includes(action.feature)) {
+            diagnostics.push({
+                code: 'YCAP001',
+                path: `actions[${index}].feature`,
+                severity: 'blocking',
+                source,
+                guidance: 'Use feature keys produced by capability catalog.',
+                message: `Feature '${action.feature}' is not present in the capability catalog.`,
+            });
+        }
+    }
+    validateQueryPresentation(diagnostics, page, source);
+    for (const [index, extension] of extensions.entries()) {
+        if (!isYoyoExtensionSlot(extension.slot)) {
+            diagnostics.push({
+                code: 'YREG001',
+                path: `extensions[${index}].slot`,
+                severity: 'blocking',
+                source,
+                guidance: 'Use allowed extension slot values only.',
+                message: `Extension slot '${extension.slot}' is not registered in Schema v1.`,
+            });
+        }
+        if (extension.overlay !== undefined &&
+            extension.slot !== 'editor' &&
+            extension.slot !== 'row-overlay') {
+            diagnostics.push({
+                code: 'YREG001',
+                path: `extensions[${index}].overlay`,
+                severity: 'blocking',
+                source,
+                guidance: 'Only editor and row-overlay extensions may select an overlay.',
+                message: `Extension '${extension.key}' cannot declare an overlay for slot '${extension.slot}'.`,
+            });
+        }
+        if (extension.key && extension.key.length > 0) {
+            const definition = registry?.extensions?.find((candidate) => candidate.key === extension.key);
+            if (!definition) {
+                diagnostics.push({
+                    code: 'YREG001',
+                    path: `extensions[${index}].key`,
+                    severity: 'blocking',
+                    source,
+                    guidance: 'Use extension keys from the extension registry.',
+                    message: `Extension '${extension.key}' is not registered.`,
+                });
+            }
+            else if (definition.slot !== extension.slot) {
+                diagnostics.push({
+                    code: 'YREG001',
+                    path: `extensions[${index}].slot`,
+                    severity: 'blocking',
+                    source,
+                    guidance: 'Use the slot declared by the extension registry.',
+                    message: `Extension '${extension.key}' is registered for slot '${definition.slot}', not '${extension.slot}'.`,
+                });
+            }
+        }
+    }
+    for (const [index, action] of actions.entries()) {
+        if (!action.rowOverlay)
+            continue;
+        if (action.placement !== 'row') {
+            diagnostics.push({
+                code: 'YACT017',
+                path: `actions[${index}].rowOverlay`,
+                severity: 'blocking',
+                source,
+                guidance: "Declare placement 'row' for an action that opens a row-overlay extension.",
+                message: `Action '${action.key}' references row-overlay extension '${action.rowOverlay}' but its placement is '${action.placement ?? defaultActionPlacement(action.kind)}'.`,
+            });
+        }
+        if (!extensions.some((extension) => extension.key === action.rowOverlay && extension.slot === 'row-overlay')) {
+            diagnostics.push({
+                code: 'YACT017',
+                path: `actions[${index}].rowOverlay`,
+                severity: 'blocking',
+                source,
+                guidance: "Declare the extension key in page.extensions with slot 'row-overlay'.",
+                message: `Action '${action.key}' references row-overlay extension '${action.rowOverlay}' which is not declared with slot 'row-overlay'.`,
+            });
+        }
+    }
+    const defaultValues = page.query.defaultValues;
+    if (defaultValues) {
+        const availableDefaults = new Set([
+            ...(page.query.fields?.map((field) => field.key) ?? []),
+            ...(page.form?.fields?.map((field) => field.key) ?? []),
+        ]);
+        const ghostDefaultValues = Object.keys(defaultValues).filter((name) => !availableDefaults.has(name));
+        if (ghostDefaultValues.length > 0) {
+            diagnostics.push({
+                code: 'YSCH007',
+                path: 'query.defaultValues',
+                severity: 'blocking',
+                source,
+                guidance: 'Only declare defaults for declared field keys.',
+                message: `Unknown default keys: ${ghostDefaultValues.join(', ')}.`,
+            });
+        }
+    }
+    if (diagnostics.length > 0) {
+        throw new YoyoSchemaValidationError(diagnostics);
+    }
+    return {
+        ir: normalizePage(page, source, linkedActionContracts, linkedValidationContracts),
+        diagnostics: [],
+        usageReport: createUsageReport(page, linkedActionContracts),
+    };
+}
+function requireCompileContext(pageKey, options) {
+    const context = options.context;
+    if (!context) {
+        throw new YoyoSchemaValidationError([
+            {
+                code: 'YSCH009',
+                path: 'mode',
+                severity: 'blocking',
+                message: `Project compile for '${pageKey}' requires compile context.`,
+                guidance: 'Provide mode: "project" together with context.source/context.manifest/context.registry.',
+            },
+        ]);
+    }
+    const missing = [];
+    if (!context.manifest ||
+        !context.manifest.schemaVersion ||
+        !context.manifest.generatorVersion ||
+        !context.manifest.sourceHash ||
+        !context.manifest.generatedBy ||
+        !context.manifest.generatedCommand) {
+        missing.push('context.manifest');
+    }
+    if (!context.registry) {
+        missing.push('context.registry');
+    }
+    if (!context.source?.path ||
+        !Number.isInteger(context.source.line) ||
+        !Number.isInteger(context.source.column)) {
+        missing.push('context.source');
+    }
+    if (missing.length > 0) {
+        throw new YoyoSchemaValidationError([
+            {
+                code: 'YSCH009',
+                path: missing[0],
+                severity: 'blocking',
+                message: 'Project compile context is incomplete.',
+                guidance: `Provide complete compile context before project checks: ${missing.join(', ')}.`,
+            },
+        ]);
+    }
+    return context;
+}
+export function isPageKindAllowed(value) {
+    return YOYO_PAGE_KINDS.includes(value);
+}
+function validateField(diagnostics, field, path, registry, source) {
+    if (!yoyoV1FieldRegistry.has(field.kind) && !registry?.fields?.includes(field.kind)) {
+        diagnostics.push({
+            code: 'YREG001',
+            path: `${path}.kind`,
+            severity: 'blocking',
+            ...diagnosticSource(source),
+            guidance: 'Use field keys from field registry.',
+            message: `Field '${field.kind}' is not registered in Schema v1.`,
+        });
+    }
+}
+function validateQueryFilterContract(diagnostics, field, path, registry, source) {
+    const unknownOperator = field.filter?.operators?.find((operator) => !YOYO_FILTER_OPERATORS.includes(operator));
+    if (unknownOperator) {
+        diagnostics.push({
+            code: 'YFIL006',
+            path: `${path}.filter.operators`,
+            severity: 'blocking',
+            ...diagnosticSource(source),
+            guidance: 'Use a controlled operator from YOYO_FILTER_OPERATORS.',
+            message: `Query filter '${field.key}' declares unsupported operator '${unknownOperator}'.`,
+        });
+    }
+    const requiresStaticOptions = field.kind === 'select' || field.kind === 'multi-select';
+    const requiresOptionContract = requiresStaticOptions || field.kind === 'remote-select' || field.kind === 'tree-select';
+    if (requiresStaticOptions && !field.options?.length) {
+        diagnostics.push({
+            code: 'YFIL001',
+            path,
+            severity: 'blocking',
+            ...diagnosticSource(source),
+            guidance: `Declare non-empty options for query filter kind '${field.kind}'.`,
+            message: `Query filter '${field.key}' is missing its option contract.`,
+        });
+    }
+    if ((field.kind === 'remote-select' || field.kind === 'tree-select') &&
+        !field.options?.length &&
+        !field.optionSource) {
+        diagnostics.push({
+            code: 'YFIL001',
+            path,
+            severity: 'blocking',
+            ...diagnosticSource(source),
+            guidance: `Declare options or a typed optionSource for query filter kind '${field.kind}'.`,
+            message: `Query filter '${field.key}' is missing its option contract.`,
+        });
+    }
+    if (field.optionSource &&
+        registry &&
+        !registry.filterOptionSources?.includes(field.optionSource)) {
+        diagnostics.push({
+            code: 'YREG001',
+            path: `${path}.optionSource`,
+            severity: 'blocking',
+            ...diagnosticSource(source),
+            guidance: 'Use an optionSource from the filter option source registry.',
+            message: `Filter option source '${field.optionSource}' is not registered.`,
+        });
+    }
+    if (!requiresOptionContract && (field.options?.length || field.optionSource)) {
+        diagnostics.push({
+            code: 'YFIL003',
+            path,
+            severity: 'blocking',
+            ...diagnosticSource(source),
+            guidance: 'Remove options/optionSource or use an option-based query filter kind.',
+            message: `Query filter '${field.key}' cannot declare an option contract for kind '${field.kind}'.`,
+        });
+    }
+    const optionValues = flattenOptionValues(field.options ?? []);
+    const duplicate = optionValues.find((value, index) => optionValues.indexOf(value) !== index);
+    if (duplicate) {
+        diagnostics.push({
+            code: 'YFIL002',
+            path,
+            severity: 'blocking',
+            ...diagnosticSource(source),
+            guidance: 'Use one unique option value across the entire query filter option tree.',
+            message: `Query filter '${field.key}' declares duplicate option value '${duplicate}'.`,
+        });
+    }
+}
+function flattenOptionValues(options) {
+    return options.flatMap((option) => [option.value, ...flattenOptionValues(option.children ?? [])]);
+}
+function diagnosticSource(source) {
+    return source === undefined ? {} : { source };
+}
+function validateFieldLifecycle(diagnostics, field, path, source) {
+    const lifecycle = field.lifecycle;
+    if (!lifecycle)
+        return;
+    const editableOn = lifecycle.editableOn ?? 'both';
+    const editableAtCreate = editableOn === 'both' || editableOn === 'create';
+    const editableAtEdit = editableOn === 'both' || editableOn === 'edit';
+    // A create default is useless when the field is never editable at create (YDL001).
+    if (lifecycle.createDefault !== undefined && !editableAtCreate) {
+        diagnostics.push({
+            code: 'YDL001',
+            path: `${path}.lifecycle`,
+            severity: 'blocking',
+            ...diagnosticSource(source),
+            guidance: 'Remove createDefault or set lifecycle.editableOn to include create.',
+            message: `Field '${field.key}' declares createDefault but is not editable at create.`,
+        });
+    }
+    // An edit default is useless when the field is never editable at edit (YDL001).
+    if (lifecycle.editDefault !== undefined && !editableAtEdit) {
+        diagnostics.push({
+            code: 'YDL001',
+            path: `${path}.lifecycle`,
+            severity: 'blocking',
+            ...diagnosticSource(source),
+            guidance: 'Remove editDefault or set lifecycle.editableOn to include edit.',
+            message: `Field '${field.key}' declares editDefault but is not editable at edit.`,
+        });
+    }
+    // A required field that is never editable can never receive a value (YDL001).
+    if (field.required === true && editableOn === 'never') {
+        diagnostics.push({
+            code: 'YDL001',
+            path: `${path}.lifecycle`,
+            severity: 'blocking',
+            ...diagnosticSource(source),
+            guidance: 'A required field must be editable in at least one phase.',
+            message: `Field '${field.key}' is required but lifecycle.editableOn is 'never'.`,
+        });
+    }
+}
+const RESERVED_URL_PARAMS = ['page', 'pageSize', 'sort'];
+function validateQueryPresentation(diagnostics, page, source) {
+    const presentation = page.query.presentation;
+    if (!presentation)
+        return;
+    const sortableColumns = page.table?.columns.filter((column) => column.sortable).map((column) => column.key) ?? [];
+    if (presentation.defaultSort && !sortableColumns.includes(presentation.defaultSort.key)) {
+        diagnostics.push({
+            code: 'YURL001',
+            path: 'query.presentation.defaultSort.key',
+            severity: 'blocking',
+            ...diagnosticSource(source),
+            guidance: 'defaultSort.key must reference a column declared with sortable: true.',
+            message: `Query presentation defaultSort references undeclared sort key '${presentation.defaultSort.key}'.`,
+        });
+    }
+    if (presentation.allowedUrlParams) {
+        const duplicateParams = presentation.allowedUrlParams.filter((param, index) => presentation.allowedUrlParams.indexOf(param) !== index);
+        if (duplicateParams.length > 0) {
+            diagnostics.push({
+                code: 'YURL002',
+                path: 'query.presentation.allowedUrlParams',
+                severity: 'blocking',
+                ...diagnosticSource(source),
+                guidance: 'Declare each URL parameter at most once.',
+                message: `Query presentation contains duplicate URL parameters: ${[...new Set(duplicateParams)].join(', ')}.`,
+            });
+        }
+        const declaredFilterKeys = new Set([
+            ...(page.query.fields ?? []).map((field) => field.key),
+            ...RESERVED_URL_PARAMS,
+        ]);
+        const undeclared = presentation.allowedUrlParams.filter((param) => !declaredFilterKeys.has(param));
+        if (undeclared.length > 0) {
+            diagnostics.push({
+                code: 'YURL001',
+                path: 'query.presentation.allowedUrlParams',
+                severity: 'blocking',
+                ...diagnosticSource(source),
+                guidance: 'allowedUrlParams must be a subset of declared filter field keys plus page/pageSize/sort.',
+                message: `Query presentation declares URL parameters that are not in the query contract: ${undeclared.join(', ')}.`,
+            });
+        }
+    }
+}
+function validateActionConfirmation(diagnostics, page, action, index, source) {
+    const subjectFields = action.confirmation?.subjectFields;
+    if (!subjectFields)
+        return;
+    const declaredFields = new Set([
+        ...(page.query.fields ?? []).map((field) => field.key),
+        ...(page.form?.fields ?? []).map((field) => field.key),
+        ...(page.table?.columns ?? []).map((column) => column.key),
+    ]);
+    const unknownFields = subjectFields.filter((field) => !declaredFields.has(field));
+    const duplicateFields = subjectFields.filter((field, fieldIndex) => subjectFields.indexOf(field) !== fieldIndex);
+    if (unknownFields.length > 0 || duplicateFields.length > 0) {
+        diagnostics.push({
+            code: 'YCON003',
+            path: `actions[${index}].confirmation.subjectFields`,
+            severity: 'blocking',
+            ...diagnosticSource(source),
+            guidance: 'Use unique field keys declared by the query, table, or form contract.',
+            message: [
+                unknownFields.length > 0
+                    ? `Unknown subject fields: ${[...new Set(unknownFields)].join(', ')}.`
+                    : '',
+                duplicateFields.length > 0
+                    ? `Duplicate subject fields: ${[...new Set(duplicateFields)].join(', ')}.`
+                    : '',
+            ]
+                .filter(Boolean)
+                .join(' '),
+        });
+    }
+}
+function createUsageReport(page, linkedActionContracts) {
+    const fields = [...(page.query.fields ?? []), ...(page.form?.fields ?? [])];
+    const permissions = page.actions?.flatMap((action) => {
+        const linked = linkedActionContracts.get(action.key);
+        return linked?.permission ? [linked.permission] : action.permission ? [action.permission] : [];
+    }) ?? [];
+    const features = page.actions?.flatMap((action) => {
+        const linked = linkedActionContracts.get(action.key);
+        return linked?.feature ? [linked.feature] : action.feature ? [action.feature] : [];
+    }) ?? [];
+    return {
+        pageKey: page.pageKey,
+        datasources: [page.query.datasource],
+        permissions: unique(permissions),
+        features: unique(features),
+        fields: unique(fields.map((field) => field.kind)),
+        renderers: unique(page.table?.columns.map((column) => column.renderer ?? 'text') ?? []),
+        actions: unique(page.actions?.map((action) => action.kind) ?? []),
+        filterOptionSources: unique(fields.flatMap((field) => (field.optionSource ? [field.optionSource] : []))),
+    };
+}
+export function diffYoyoPageIR(before, after) {
+    const beforeValues = flattenValues(before);
+    const afterValues = flattenValues(after);
+    const paths = [...new Set([...beforeValues.keys(), ...afterValues.keys()])].sort();
+    const changes = [];
+    for (const path of paths) {
+        const hasBefore = beforeValues.has(path);
+        const hasAfter = afterValues.has(path);
+        if (!hasBefore) {
+            changes.push({ kind: 'added', path, after: afterValues.get(path) });
+            continue;
+        }
+        if (!hasAfter) {
+            changes.push({ kind: 'removed', path, before: beforeValues.get(path) });
+            continue;
+        }
+        if (!Object.is(beforeValues.get(path), afterValues.get(path))) {
+            changes.push({
+                kind: 'changed',
+                path,
+                before: beforeValues.get(path),
+                after: afterValues.get(path),
+            });
+        }
+    }
+    return changes;
+}
+export function formatYoyoSchemaDiff(entries) {
+    return entries
+        .map((entry) => {
+        if (entry.kind === 'added') {
+            return `+ ${entry.path}: ${String(entry.after)}`;
+        }
+        if (entry.kind === 'removed') {
+            return `- ${entry.path}: ${String(entry.before)}`;
+        }
+        return `~ ${entry.path}: ${String(entry.before)} -> ${String(entry.after)}`;
+    })
+        .join('\n');
+}
+function flattenValues(value, prefix = '', result = new Map()) {
+    if (value === null || typeof value !== 'object') {
+        result.set(prefix || '$', value);
+        return result;
+    }
+    for (const [key, child] of Object.entries(value)) {
+        flattenValues(child, prefix ? `${prefix}.${key}` : key, result);
+    }
+    return result;
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+function addDuplicateDiagnostics(diagnostics, items, path, source, code = 'YSCH004') {
+    const seen = new Set();
+    for (const [index, item] of items.entries()) {
+        if (seen.has(item.key)) {
+            diagnostics.push({
+                code,
+                path: `${path}[${index}].key`,
+                severity: 'blocking',
+                ...diagnosticSource(source),
+                guidance: 'Ensure key uniqueness within the same declaration block.',
+                message: `Duplicate key '${item.key}'.`,
+            });
+        }
+        seen.add(item.key);
+    }
+}
+function normalizePage(page, source, linkedActionContracts = new Map(), linkedValidationContracts = new Map()) {
+    return {
+        schemaVersion: 1,
+        pageKind: page.pageKind,
+        pageKey: page.pageKey,
+        title: page.title,
+        query: {
+            ...page.query,
+            fields: page.query.fields ?? [],
+        },
+        ...(page.table
+            ? {
+                table: {
+                    rowKey: page.table.rowKey,
+                    columns: page.table.columns.map((column, index) => normalizeColumn(column, page.table.rowKey, index)),
+                    ...(page.table.grouping
+                        ? {
+                            grouping: {
+                                mode: page.table.grouping.mode,
+                                columnKey: page.table.grouping.columnKey,
+                                ...(page.table.grouping.defaultExpanded === undefined
+                                    ? {}
+                                    : { defaultExpanded: page.table.grouping.defaultExpanded }),
+                            },
+                        }
+                        : {}),
+                    ...(page.table.virtualization
+                        ? {
+                            virtualization: {
+                                mode: page.table.virtualization.mode,
+                            },
+                        }
+                        : {}),
+                },
+            }
+            : {}),
+        ...(page.form ? { form: { ...page.form } } : {}),
+        actions: (page.actions ?? []).map((action) => {
+            const contract = linkedActionContracts.get(action.key);
+            const validation = linkedValidationContracts.get(action.key);
+            return {
+                ...action,
+                placement: action.placement ?? defaultActionPlacement(action.kind),
+                ...(contract ? { contract } : {}),
+                ...(validation ? { validation } : {}),
+            };
+        }),
+        extensions: page.extensions ?? [],
+        source,
+    };
+}
+function defaultActionPlacement(kind) {
+    switch (kind) {
+        case 'edit':
+        case 'disable':
+        case 'delete':
+            return 'row';
+        case 'replaceRoles':
+        case 'addChild':
+        case 'updateChild':
+        case 'removeChild':
+        case 'command':
+            return 'form';
+        default:
+            return 'page';
+    }
+}
+function allowedActionPlacements(kind) {
+    switch (kind) {
+        case 'delete':
+        case 'disable':
+            return ['row', 'bulk'];
+        case 'edit':
+            return ['row'];
+        case 'replaceRoles':
+        case 'addChild':
+        case 'updateChild':
+        case 'removeChild':
+            return ['form'];
+        case 'command':
+            return ['page', 'row', 'bulk', 'form'];
+        default:
+            return ['page'];
+    }
+}
+function normalizeColumn(column, rowKey, index) {
+    const role = column.role ??
+        (column.key === rowKey || index === 0
+            ? 'identity'
+            : column.renderer === 'booleanBadge'
+                ? 'status'
+                : 'meta');
+    const priority = column.priority ??
+        (role === 'identity' || role === 'key' || role === 'status' || role === 'action'
+            ? 'high'
+            : 'medium');
+    const mobilePlacement = column.mobilePlacement ??
+        (role === 'identity' || role === 'key'
+            ? 'headline'
+            : role === 'status' || role === 'media' || role === 'action'
+                ? 'supporting'
+                : 'details');
+    const responsiveProvenance = {
+        role: column.role === undefined ? 'defaulted' : 'declared',
+        priority: column.priority === undefined ? 'defaulted' : 'declared',
+        mobilePlacement: column.mobilePlacement === undefined ? 'defaulted' : 'declared',
+        ...(column.recordRendererKey === undefined ? {} : { recordRendererKey: 'declared' }),
+    };
+    return {
+        ...column,
+        renderer: column.renderer ?? 'text',
+        sortable: column.sortable ?? false,
+        role,
+        priority,
+        mobilePlacement,
+        responsiveProvenance,
+    };
+}
+function resolveRendererDefinition(key, registry) {
+    if (yoyoV1RendererRegistry.has(key))
+        return yoyoV1RendererRegistry.resolve(key);
+    const external = registry?.rendererDefinitions?.find((definition) => definition.key === key);
+    if (external)
+        return external;
+    if (!registry?.renderers?.includes(key))
+        return undefined;
+    return {
+        key,
+        inputKind: 'cell-value',
+        presentations: ['grid', 'priority-table', 'record-list'],
+        slots: ['cell'],
+    };
+}
+function validateResponsiveColumns(diagnostics, columns, source) {
+    if (columns.length === 0)
+        return;
+    const reachableIdentity = columns.filter((column) => (column.role === 'identity' || column.role === 'key') && column.mobilePlacement !== 'hidden');
+    if (reachableIdentity.length === 0) {
+        diagnostics.push({
+            code: 'YGRID001',
+            path: 'table.columns',
+            severity: 'blocking',
+            source,
+            guidance: 'Declare at least one identity or key column with a reachable mobile placement.',
+            message: 'A record-list requires a reachable identity or key column.',
+        });
+    }
+    const identityIndexes = columns.flatMap((column, index) => column.role === 'identity' ? [index] : []);
+    for (const index of identityIndexes.slice(1)) {
+        diagnostics.push({
+            code: 'YGRID002',
+            path: `table.columns[${index}].role`,
+            severity: 'blocking',
+            source,
+            guidance: 'Use one identity column and mark additional identifying data as key.',
+            message: 'Only one identity column may define the record headline.',
+        });
+    }
+    const actionIndexes = columns.flatMap((column, index) => column.role === 'action' ? [index] : []);
+    for (const index of actionIndexes.slice(1)) {
+        diagnostics.push({
+            code: 'YGRID003',
+            path: `table.columns[${index}].role`,
+            severity: 'blocking',
+            source,
+            guidance: 'Expose one action surface and group additional row operations behind it.',
+            message: 'Only one action column may define the record-list action surface.',
+        });
+    }
+    const allowedPlacements = {
+        identity: ['headline'],
+        key: ['headline', 'supporting'],
+        status: ['supporting', 'details'],
+        meta: ['supporting', 'details', 'hidden'],
+        media: ['supporting', 'details', 'hidden'],
+        action: ['supporting'],
+    };
+    for (const [index, column] of columns.entries()) {
+        if (!allowedPlacements[column.role].includes(column.mobilePlacement)) {
+            diagnostics.push({
+                code: 'YGRID004',
+                path: `table.columns[${index}].mobilePlacement`,
+                severity: 'blocking',
+                source,
+                guidance: `Use a supported mobile placement for the '${column.role}' role.`,
+                message: `Role '${column.role}' cannot use mobile placement '${column.mobilePlacement}'.`,
+            });
+        }
+        if ((column.role === 'identity' || column.role === 'key' || column.role === 'action') &&
+            column.priority === 'low') {
+            diagnostics.push({
+                code: 'YGRID005',
+                path: `table.columns[${index}].priority`,
+                severity: 'blocking',
+                source,
+                guidance: `Use high or medium priority for the '${column.role}' role.`,
+                message: `Role '${column.role}' cannot be assigned low priority.`,
+            });
+        }
+    }
+}
+function validateValidationFieldMapping(diagnostics, page, validation, formMode, source) {
+    const schemaFields = new Set((page.form?.fields ?? [])
+        .filter((field) => isSubmittedInFormMode(field, formMode))
+        .map((field) => field.key));
+    const runtimeSuppliedFields = new Set(['id', 'concurrencyToken', 'concurrencyStamp']);
+    const generatedFields = new Set(validation.fieldPaths.filter((fieldPath) => !(formMode === 'update' && runtimeSuppliedFields.has(fieldPath))));
+    const fixedFields = Object.keys(page.form?.request?.[formMode]?.fixedValues ?? {});
+    const overlap = fixedFields.some((field) => schemaFields.has(field));
+    const suppliedFields = new Set([...schemaFields, ...fixedFields]);
+    if (!overlap && sameStringSet(suppliedFields, generatedFields))
+        return;
+    diagnostics.push({
+        code: 'YVAL005',
+        path: 'form.fields',
+        severity: 'blocking',
+        source,
+        guidance: 'Editable and fixed request fields must be disjoint and exactly cover generated validation fields; runtime entity identity is supplied separately for update.',
+        message: `Form fields for '${formMode}' do not match generated validation fields for '${validation.contractKey}'.`,
+    });
+}
+function isEditableInFormMode(field, formMode) {
+    const editableOn = field.lifecycle?.editableOn ?? 'both';
+    const lifecycleMode = formMode === 'update' ? 'edit' : formMode;
+    return editableOn === 'both' || editableOn === lifecycleMode;
+}
+function isSubmittedInFormMode(field, formMode) {
+    return (isEditableInFormMode(field, formMode) ||
+        (formMode === 'update' && field.lifecycle?.submitOnEdit === true));
+}
+function sameStringSet(left, right) {
+    return left.size === right.size && [...left].every((value) => right.has(value));
+}
+function toSourceLocation(pageKey, context) {
+    if (!context) {
+        return { kind: 'typescript', pageKey };
+    }
+    return {
+        kind: 'typescript',
+        pageKey,
+        path: context.source.path,
+        line: context.source.line,
+        column: context.source.column,
+    };
+}
+function isBareUrl(value) {
+    const trimmed = value.trim();
+    return (/^(https?:\/\/)/i.test(trimmed) ||
+        trimmed.startsWith('/') ||
+        trimmed.startsWith('./') ||
+        trimmed.startsWith('../') ||
+        trimmed.includes('/'));
+}
+function isYoyoExtensionSlot(value) {
+    return YOYO_EXTENSION_SLOTS.includes(value);
+}
+function formatPath(path) {
+    let result = '';
+    for (const segment of path) {
+        if (typeof segment === 'number') {
+            result += `[${segment}]`;
+            continue;
+        }
+        const name = String(segment);
+        result += result ? `.${name}` : name;
+    }
+    return result || '$';
+}