@yoyoboot/yoyo-admin-schema 10.5.5

package/dist/generated-validation-contract.js

@@ -0,0 +1,124 @@
+export const YOYO_GENERATED_VALIDATION_CONTRACT_SCHEMA_VERSION = '1.0.0';
+export const YOYO_GENERATED_FORM_MODES = ['create', 'update'];
+export function linkYoyoGeneratedValidationContract(catalog, operationId, formMode) {
+    const contract = catalog.contracts.find((candidate) => candidate.operationId === operationId && candidate.formMode === formMode);
+    if (!contract)
+        return undefined;
+    return {
+        ...contract,
+        catalogSchemaVersion: catalog.schemaVersion,
+        catalogGeneratorVersion: catalog.generatorVersion,
+        catalogSourceHash: catalog.sourceHash,
+    };
+}
+export function isYoyoGeneratedValidationContractSnapshotCompatible(linked, catalog) {
+    const current = linkYoyoGeneratedValidationContract(catalog, linked.operationId, linked.formMode);
+    return Boolean(current)
+        && current.contractKey === linked.contractKey
+        && current.inputPath === linked.inputPath
+        && sameStringArray(current.fieldPaths, linked.fieldPaths)
+        && current.schemaRef === linked.schemaRef
+        && current.schemaVersion === linked.schemaVersion
+        && current.generatorVersion === linked.generatorVersion
+        && current.sourceHash === linked.sourceHash
+        && linked.catalogSchemaVersion === catalog.schemaVersion
+        && linked.catalogGeneratorVersion === catalog.generatorVersion
+        && linked.catalogSourceHash === catalog.sourceHash;
+}
+export function diagnoseYoyoGeneratedValidationContractSnapshot(linked, catalog, executableContractKeys, path = 'validationContract') {
+    if (!linked || !catalog) {
+        return [{
+                code: 'YVAL003',
+                path,
+                severity: 'blocking',
+                guidance: 'Bind the current generated validation contract catalog before executing a form mutation.',
+                message: 'The generated validation contract snapshot is unavailable.',
+            }];
+    }
+    if (!isYoyoGeneratedValidationContractSnapshotCompatible(linked, catalog)) {
+        return [{
+                code: 'YVAL004',
+                path,
+                severity: 'blocking',
+                guidance: 'Regenerate and bind the validation contract catalog from the same OpenAPI snapshot used to compile the page.',
+                message: `Generated validation contract '${linked.contractKey}' is stale or incompatible with the current catalog snapshot.`,
+            }];
+    }
+    if (!executableContractKeys?.includes(linked.contractKey)) {
+        return [{
+                code: 'YVAL006',
+                path,
+                severity: 'blocking',
+                guidance: 'Register the executable generated validator that matches the compiled validation contract key.',
+                message: `Generated validation contract '${linked.contractKey}' has no executable validator.`,
+            }];
+    }
+    return [];
+}
+export function validateYoyoGeneratedValidationContractCatalog(catalog) {
+    const diagnostics = [];
+    if (!catalog.schemaVersion || !catalog.generatorVersion || !catalog.sourceHash) {
+        diagnostics.push({
+            code: 'YVAL001',
+            path: 'validationContracts',
+            severity: 'blocking',
+            guidance: 'Regenerate the OpenAPI validation contract catalog with complete provenance.',
+            message: 'Generated validation contract catalog provenance is incomplete.',
+        });
+    }
+    if (catalog.schemaVersion !== YOYO_GENERATED_VALIDATION_CONTRACT_SCHEMA_VERSION) {
+        diagnostics.push({
+            code: 'YVAL001',
+            path: 'validationContracts.schemaVersion',
+            severity: 'blocking',
+            guidance: `Regenerate the validation contract catalog with schemaVersion ${YOYO_GENERATED_VALIDATION_CONTRACT_SCHEMA_VERSION}.`,
+            message: `Generated validation contract catalog schemaVersion '${catalog.schemaVersion}' is incompatible.`,
+        });
+    }
+    const keys = new Set();
+    const operationModes = new Set();
+    for (const [index, contract] of catalog.contracts.entries()) {
+        const path = `validationContracts.contracts[${index}]`;
+        const operationMode = `${contract.operationId}:${contract.formMode}`;
+        if (keys.has(contract.contractKey) || operationModes.has(operationMode)) {
+            diagnostics.push({
+                code: 'YVAL002',
+                path: `${path}.contractKey`,
+                severity: 'blocking',
+                guidance: 'Generate exactly one validation branch for each operation and form mode.',
+                message: `Generated validation contract '${contract.contractKey}' duplicates an operation/form-mode branch.`,
+            });
+        }
+        keys.add(contract.contractKey);
+        operationModes.add(operationMode);
+        const fieldPaths = contract.fieldPaths;
+        if (!contract.contractKey || !contract.operationId || typeof contract.inputPath !== 'string' || !contract.schemaRef
+            || !contract.sourceHash || !contract.generatorVersion || !contract.schemaVersion
+            || !Array.isArray(fieldPaths)
+            || !fieldPaths.every((fieldPath) => typeof fieldPath === 'string')
+            || !YOYO_GENERATED_FORM_MODES.includes(contract.formMode)) {
+            diagnostics.push({
+                code: 'YVAL001',
+                path,
+                severity: 'blocking',
+                guidance: 'Regenerate the OpenAPI validation contract branch with complete supported metadata.',
+                message: `Generated validation contract '${contract.contractKey || '<unknown>'}' is incomplete or unsupported.`,
+            });
+        }
+        if (contract.schemaVersion !== catalog.schemaVersion
+            || contract.sourceHash !== catalog.sourceHash
+            || contract.generatorVersion !== catalog.generatorVersion) {
+            diagnostics.push({
+                code: 'YVAL004',
+                path,
+                severity: 'blocking',
+                guidance: 'Regenerate the validation contract catalog and all branch validators from the same OpenAPI snapshot.',
+                message: `Generated validation contract '${contract.contractKey}' provenance drifted from its catalog.`,
+            });
+        }
+    }
+    return diagnostics;
+}
+function sameStringArray(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export * from './compiler.js';
+export * from './diagnostics.js';
+export * from './action-registry.js';
+export * from './action-contract.js';
+export * from './generated-validation-contract.js';
+export * from './generated/action-contract/index.js';
+export * from './contract-drift.js';
+export * from './extension-registry.js';
+export * from './field-registry.js';
+export * from './project-check.js';
+export * from './page-contract-linking.js';
+export * from './renderer-registry.js';
+export * from './registry-diagnostics.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA;AAChC,cAAc,sBAAsB,CAAA;AACpC,cAAc,sBAAsB,CAAA;AACpC,cAAc,oCAAoC,CAAA;AAClD,cAAc,sCAAsC,CAAA;AACpD,cAAc,qBAAqB,CAAA;AACnC,cAAc,yBAAyB,CAAA;AACvC,cAAc,qBAAqB,CAAA;AACnC,cAAc,oBAAoB,CAAA;AAClC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,wBAAwB,CAAA;AACtC,cAAc,2BAA2B,CAAA;AACzC,cAAc,YAAY,CAAA"}

package/dist/index.js

@@ -0,0 +1,14 @@
+export * from './compiler.js';
+export * from './diagnostics.js';
+export * from './action-registry.js';
+export * from './action-contract.js';
+export * from './generated-validation-contract.js';
+export * from './generated/action-contract/index.js';
+export * from './contract-drift.js';
+export * from './extension-registry.js';
+export * from './field-registry.js';
+export * from './project-check.js';
+export * from './page-contract-linking.js';
+export * from './renderer-registry.js';
+export * from './registry-diagnostics.js';
+export * from './types.js';

package/dist/page-contract-linking.d.ts

@@ -0,0 +1,36 @@
+import { type YoyoActionContractCapabilityRegistry, type YoyoActionContractCatalog } from './action-contract.js';
+import { type YoyoGeneratedValidationContractCatalog } from './generated-validation-contract.js';
+import type { YoyoPageIR } from './types.js';
+/**
+ * Serializable shape of the runtime adapter facts needed for static linking.
+ * The adapter itself remains owned by the host application.
+ */
+export interface YoyoDatasourceOperationContract {
+    readonly id: string;
+    readonly operations: readonly string[];
+}
+export interface YoyoPageContractLinkingInput {
+    readonly page: YoyoPageIR;
+    readonly datasource: YoyoDatasourceOperationContract;
+    readonly actionContracts: YoyoActionContractCatalog;
+    readonly validationContracts: YoyoGeneratedValidationContractCatalog;
+    readonly validationContractExecutables: readonly string[];
+    readonly capabilities?: YoyoActionContractCapabilityRegistry;
+}
+export interface YoyoPageContractLinkingResult {
+    readonly pageKey: string;
+    readonly datasource: YoyoDatasourceOperationContract;
+    readonly fields: readonly string[];
+    readonly actionKeys: readonly string[];
+    readonly sourceFingerprint: {
+        readonly actionCatalog: string;
+        readonly validationCatalog: string;
+    };
+}
+/**
+ * Verifies the host-provided datasource operation surface against compiled IR
+ * and current generated snapshots. This is pure linking: it never invokes a
+ * datasource, renders a page, or receives transport/DTO values.
+ */
+export declare function linkYoyoPageContract(input: YoyoPageContractLinkingInput): YoyoPageContractLinkingResult;
+//# sourceMappingURL=page-contract-linking.d.ts.map

package/dist/page-contract-linking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-contract-linking.d.ts","sourceRoot":"","sources":["../src/page-contract-linking.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,oCAAoC,EACzC,KAAK,yBAAyB,EAC/B,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAGL,KAAK,sCAAsC,EAC5C,MAAM,oCAAoC,CAAA;AAE3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C;;;GAGG;AACH,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAA;CACvC;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,UAAU,EAAE,+BAA+B,CAAA;IACpD,QAAQ,CAAC,eAAe,EAAE,yBAAyB,CAAA;IACnD,QAAQ,CAAC,mBAAmB,EAAE,sCAAsC,CAAA;IACpE,QAAQ,CAAC,6BAA6B,EAAE,SAAS,MAAM,EAAE,CAAA;IACzD,QAAQ,CAAC,YAAY,CAAC,EAAE,oCAAoC,CAAA;CAC7D;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,UAAU,EAAE,+BAA+B,CAAA;IACpD,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;IAClC,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAA;IACtC,QAAQ,CAAC,iBAAiB,EAAE;QAC1B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;QAC9B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAA;KACnC,CAAA;CACF;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,4BAA4B,GAAG,6BAA6B,CAmFvG"}

package/dist/page-contract-linking.js

@@ -0,0 +1,78 @@
+import { diagnoseYoyoActionContractSnapshot, operationForYoyoActionKind, validateYoyoActionContractCatalog, } from './action-contract.js';
+import { diagnoseYoyoGeneratedValidationContractSnapshot, validateYoyoGeneratedValidationContractCatalog, } from './generated-validation-contract.js';
+import { YoyoSchemaValidationError } from './diagnostics.js';
+/**
+ * Verifies the host-provided datasource operation surface against compiled IR
+ * and current generated snapshots. This is pure linking: it never invokes a
+ * datasource, renders a page, or receives transport/DTO values.
+ */
+export function linkYoyoPageContract(input) {
+    const { page, datasource } = input;
+    const diagnostics = [
+        ...validateYoyoActionContractCatalog(input.actionContracts, input.capabilities),
+        ...validateYoyoGeneratedValidationContractCatalog(input.validationContracts),
+    ];
+    if (datasource.id !== page.query.datasource) {
+        diagnostics.push(linkDiagnostic('YLNK001', page, 'query.datasource', `Compiled datasource '${page.query.datasource}' does not match adapter '${datasource.id}'.`, 'Bind the production typed datasource that declares the compiled datasource id.'));
+    }
+    if (!datasource.operations.includes('query')) {
+        diagnostics.push(linkDiagnostic('YLNK002', page, 'datasource.operations', 'The typed datasource is missing its required query operation.', 'Expose query from the production typed datasource adapter.'));
+    }
+    for (const [index, action] of page.actions.entries()) {
+        const path = `actions[${index}]`;
+        const datasourceOperation = datasourceOperationForYoyoActionKind(action.kind);
+        if (datasourceOperation && !datasource.operations.includes(datasourceOperation)) {
+            diagnostics.push(linkDiagnostic('YLNK003', page, path, `Action '${action.key}' requires unavailable datasource operation '${datasourceOperation}'.`, 'Expose the required operation from the production typed datasource adapter.'));
+        }
+        if (!operationForYoyoActionKind(action.kind))
+            continue;
+        if (action.contract?.permission
+            && input.capabilities?.permissions
+            && !input.capabilities.permissions.includes(action.contract.permission)) {
+            diagnostics.push(linkDiagnostic('YLNK004', page, `${path}.permission`, `Action '${action.key}' references unknown permission '${action.contract.permission}'.`, 'Register the permission in the capability catalog before linking the action contract.'));
+        }
+        diagnostics.push(...diagnoseYoyoActionContractSnapshot(action.contract, input.actionContracts, `${path}.contractKey`));
+        if ((action.kind === 'create' || action.kind === 'edit') && action.contract?.validationOperationId) {
+            diagnostics.push(...diagnoseYoyoGeneratedValidationContractSnapshot(action.validation, input.validationContracts, input.validationContractExecutables, `${path}.contractKey`));
+        }
+    }
+    if (diagnostics.length > 0) {
+        throw new YoyoSchemaValidationError(diagnostics);
+    }
+    return {
+        pageKey: page.pageKey,
+        datasource: {
+            id: datasource.id,
+            operations: [...datasource.operations],
+        },
+        fields: [
+            ...page.query.fields.map((field) => field.key),
+            ...(page.table?.columns.map((column) => column.key) ?? []),
+            ...(page.form?.fields.map((field) => field.key) ?? []),
+        ],
+        actionKeys: page.actions.map((action) => action.key),
+        sourceFingerprint: {
+            actionCatalog: input.actionContracts.sourceHash,
+            validationCatalog: input.validationContracts.sourceHash,
+        },
+    };
+}
+function datasourceOperationForYoyoActionKind(kind) {
+    switch (kind) {
+        case 'create': return 'create';
+        case 'edit': return 'update';
+        case 'delete': return 'remove';
+        case 'disable': return 'setEnabled';
+        default: return undefined;
+    }
+}
+function linkDiagnostic(code, page, path, message, guidance) {
+    return {
+        code,
+        path,
+        severity: 'blocking',
+        source: page.source,
+        guidance,
+        message,
+    };
+}

package/dist/project-check.d.ts

@@ -0,0 +1,34 @@
+import { type YoyoCompileResult } from './compiler.js';
+import { type YoyoContractDriftInput } from './contract-drift.js';
+import type { YoyoSchemaCompileContext, YoyoSourceLocation } from './types.js';
+export interface YoyoProjectSchemaEntry {
+    source: Required<Pick<YoyoSourceLocation, 'path' | 'line' | 'column'>>;
+    schema: unknown;
+    context: Omit<YoyoSchemaCompileContext, 'source'>;
+    drift: YoyoContractDriftInput;
+    /**
+     * Raw source text of the schema file, supplied by the host that discovered it.
+     * admin-schema is host-independent and never touches the filesystem itself;
+     * when omitted, source boundary scanning is skipped for this entry.
+     */
+    sourceText?: string;
+}
+export interface YoyoProjectSchemaException {
+    sourcePath: string;
+    owner: string;
+    reason: string;
+    exitCondition: string;
+}
+export interface YoyoProjectSchemaCheckInput {
+    discoveredSources: readonly string[];
+    schemas: readonly YoyoProjectSchemaEntry[];
+    exceptions: readonly YoyoProjectSchemaException[];
+}
+export interface YoyoProjectSchemaCheckResult {
+    compiled: readonly YoyoCompileResult[];
+    handoff: {
+        schemaSources: readonly string[];
+    };
+}
+export declare function checkYoyoSchemaProject(input: YoyoProjectSchemaCheckInput): YoyoProjectSchemaCheckResult;
+//# sourceMappingURL=project-check.d.ts.map

package/dist/project-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-check.d.ts","sourceRoot":"","sources":["../src/project-check.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,KAAK,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAC7E,OAAO,EAA6B,KAAK,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;AAE5F,OAAO,KAAK,EAAE,wBAAwB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAE9E,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,kBAAkB,EAAE,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAA;IACtE,MAAM,EAAE,OAAO,CAAA;IACf,OAAO,EAAE,IAAI,CAAC,wBAAwB,EAAE,QAAQ,CAAC,CAAA;IACjD,KAAK,EAAE,sBAAsB,CAAA;IAC7B;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,0BAA0B;IACzC,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,aAAa,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,2BAA2B;IAC1C,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAA;IACpC,OAAO,EAAE,SAAS,sBAAsB,EAAE,CAAA;IAC1C,UAAU,EAAE,SAAS,0BAA0B,EAAE,CAAA;CAClD;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,EAAE,SAAS,iBAAiB,EAAE,CAAA;IACtC,OAAO,EAAE;QACP,aAAa,EAAE,SAAS,MAAM,EAAE,CAAA;KACjC,CAAA;CACF;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,2BAA2B,GAAG,4BAA4B,CA4FvG"}

package/dist/project-check.js

@@ -0,0 +1,151 @@
+import { compileYoyoPageSchema } from './compiler.js';
+import { diagnoseYoyoContractDrift } from './contract-drift.js';
+import { YoyoSchemaValidationError } from './diagnostics.js';
+export function checkYoyoSchemaProject(input) {
+    const diagnostics = [];
+    const discoveredSources = uniqueSorted(input.discoveredSources);
+    const schemaEntries = new Map();
+    const exceptions = new Map();
+    for (const entry of input.schemas) {
+        if (schemaEntries.has(entry.source.path)) {
+            diagnostics.push(projectDiagnostic('YPRJ001', entry.source.path, 'A project schema source may only have one registered entry.', entry.source));
+            continue;
+        }
+        schemaEntries.set(entry.source.path, entry);
+    }
+    for (const exception of input.exceptions) {
+        if (exceptions.has(exception.sourcePath)) {
+            diagnostics.push(projectDiagnostic('YPRJ001', exception.sourcePath, 'A project schema source may only have one exception.', { path: exception.sourcePath, line: 1, column: 1 }));
+            continue;
+        }
+        exceptions.set(exception.sourcePath, exception);
+        if (!exception.owner.trim() || !exception.reason.trim() || !exception.exitCondition.trim()) {
+            diagnostics.push(projectDiagnostic('YPRJ003', exception.sourcePath, 'Schema exceptions require owner, reason, and exit condition.', { path: exception.sourcePath, line: 1, column: 1 }));
+        }
+    }
+    for (const [sourcePath, entry] of schemaEntries) {
+        if (!discoveredSources.includes(sourcePath)) {
+            diagnostics.push(projectDiagnostic('YPRJ001', sourcePath, 'Registered schema source was not discovered by the project scan.', entry.source));
+        }
+        if (exceptions.has(sourcePath)) {
+            diagnostics.push(projectDiagnostic('YPRJ004', sourcePath, 'A source cannot be both compiled and excepted.', entry.source));
+        }
+        diagnostics.push(...scanBoundaryChecks(sourcePath, entry.sourceText ?? '', entry.source));
+    }
+    for (const [sourcePath, exception] of exceptions) {
+        if (!discoveredSources.includes(sourcePath)) {
+            diagnostics.push(projectDiagnostic('YPRJ001', sourcePath, 'Registered schema exception was not discovered by the project scan.', { path: sourcePath, line: 1, column: 1 }));
+        }
+        if (!exception.owner.trim() || !exception.reason.trim() || !exception.exitCondition.trim()) {
+            continue;
+        }
+    }
+    for (const sourcePath of discoveredSources) {
+        if (!schemaEntries.has(sourcePath) && !exceptions.has(sourcePath)) {
+            diagnostics.push(projectDiagnostic('YPRJ002', sourcePath, 'Discovered schema source is neither compiled nor covered by a complete exception.', { path: sourcePath, line: 1, column: 1 }));
+        }
+    }
+    const compiled = [];
+    for (const entry of schemaEntries.values()) {
+        try {
+            const result = compileYoyoPageSchema(entry.schema, {
+                mode: 'project',
+                context: {
+                    ...entry.context,
+                    source: entry.source,
+                },
+            });
+            compiled.push(result);
+        }
+        catch (error) {
+            if (error instanceof YoyoSchemaValidationError) {
+                diagnostics.push(...error.diagnostics);
+                continue;
+            }
+            throw error;
+        }
+        for (const drift of diagnoseYoyoContractDrift(entry.drift)) {
+            diagnostics.push({
+                code: drift.code,
+                path: drift.path,
+                severity: 'blocking',
+                source: entry.source,
+                guidance: 'Update the Schema, datasource binding, catalog, DTO mapping, or registry so the project contract is exact.',
+                message: drift.message,
+            });
+        }
+    }
+    if (diagnostics.length > 0) {
+        throw new YoyoSchemaValidationError(diagnostics);
+    }
+    return {
+        compiled,
+        handoff: {
+            schemaSources: [...schemaEntries.keys()].sort(),
+        },
+    };
+}
+function projectDiagnostic(code, path, message, source) {
+    return {
+        code,
+        path,
+        severity: 'blocking',
+        source,
+        guidance: 'Register and compile the source, or add a complete temporary exception with an owner and exit condition.',
+        message,
+    };
+}
+function scanBoundaryChecks(sourcePath, source, location) {
+    const normalized = sourcePath.replaceAll('\\', '/');
+    const diagnostics = [];
+    for (const rule of boundaryRules) {
+        const match = source.match(rule.pattern);
+        if (!match || match.index === undefined)
+            continue;
+        const sourceLocation = sourceLocationFromOffset(source, match.index);
+        diagnostics.push({
+            code: 'YPRJ005',
+            path: normalized,
+            severity: 'blocking',
+            source: {
+                path: location.path,
+                line: sourceLocation.line,
+                column: sourceLocation.column,
+            },
+            guidance: rule.guidance,
+            message: `Source boundary rule '${rule.label}' was violated in '${normalized}'. ${rule.message}`,
+        });
+    }
+    return diagnostics;
+}
+function sourceLocationFromOffset(source, offset) {
+    const clampedOffset = Math.max(0, Math.min(offset, source.length));
+    const normalized = source.slice(0, clampedOffset).replace(/\r\n/g, '\n');
+    const lines = normalized.split('\n');
+    const line = lines.length;
+    const column = (lines.at(-1)?.length ?? 0) + 1;
+    return { line, column };
+}
+const boundaryRules = [
+    {
+        label: 'handwritten-validation-validator',
+        pattern: /\bimport\b\s+(?:type\s+)?[^\n;]*?\bfrom\s+["'][^"']*\bzod\b[^"']*["']|\brequire\(\s*["'][^"']*\bzod\b[^"']*["']\s*\)/i,
+        message: 'Handwritten validation validator was referenced. Validation must come from generated validation contracts.',
+        guidance: 'Move rule definitions to backend validation contracts and compile the generated validation contract.',
+    },
+    {
+        label: 'tanstack-validation-callback',
+        pattern: /@tanstack\/(?:vue-form|form-core)|createYoyoTanstackForm|mapZodErrorToFieldErrors/i,
+        message: 'A TanStack/zod callback flow was referenced in the feature boundary.',
+        guidance: 'Render with schema primitives and do not introduce feature-local form validation callbacks.',
+    },
+    {
+        label: 'handwritten-boundary-callback',
+        pattern: /\b(?:interface|type)\s+\w*Dto\b|\bfunction\s+validate[A-Z]\w*\b|\bonValidate\b|\bvalidationPort\s*:\s*\{|\bthen\(\s*\(?\s*[\w$]+\s*=>/i,
+        message: 'A free validation/callback path was detected. Use compiled validation contracts and the page host seam only.',
+        guidance: 'Drop custom callback wiring and bind to the canonical `validation` contract reference.',
+    },
+];
+function uniqueSorted(values) {
+    return [...new Set(values)].sort();
+}

package/dist/registry-diagnostics.d.ts

@@ -0,0 +1,15 @@
+export interface YoyoRegistryGraphEntry {
+    key: string;
+    dependencies?: readonly string[];
+    slot?: string;
+}
+export interface YoyoRegistryGraphInput {
+    entries: readonly YoyoRegistryGraphEntry[];
+}
+export interface YoyoRegistryDiagnostic {
+    code: 'YREG002' | 'YREG003' | 'YREG004' | 'YREG005';
+    path: string;
+    message: string;
+}
+export declare function validateYoyoRegistryGraph(input: YoyoRegistryGraphInput): readonly YoyoRegistryDiagnostic[];
+//# sourceMappingURL=registry-diagnostics.d.ts.map

package/dist/registry-diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry-diagnostics.d.ts","sourceRoot":"","sources":["../src/registry-diagnostics.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,sBAAsB;IACrC,GAAG,EAAE,MAAM,CAAA;IACX,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAChC,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,SAAS,sBAAsB,EAAE,CAAA;CAC3C;AAED,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAA;IACnD,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,sBAAsB,GAAG,SAAS,sBAAsB,EAAE,CAuC1G"}

package/dist/registry-diagnostics.js

@@ -0,0 +1,41 @@
+import { YOYO_EXTENSION_SLOTS } from './extension-registry.js';
+export function validateYoyoRegistryGraph(input) {
+    const diagnostics = [];
+    const entries = new Map();
+    for (const [index, entry] of input.entries.entries()) {
+        if (entries.has(entry.key)) {
+            diagnostics.push({ code: 'YREG002', path: `entries[${index}].key`, message: `Registry key '${entry.key}' is duplicated.` });
+            continue;
+        }
+        entries.set(entry.key, entry);
+        if (entry.slot && !YOYO_EXTENSION_SLOTS.includes(entry.slot)) {
+            diagnostics.push({ code: 'YREG005', path: `entries[${index}].slot`, message: `Extension slot '${entry.slot}' is invalid.` });
+        }
+    }
+    for (const [index, entry] of input.entries.entries()) {
+        for (const [dependencyIndex, dependency] of (entry.dependencies ?? []).entries()) {
+            if (!entries.has(dependency))
+                diagnostics.push({ code: 'YREG003', path: `entries[${index}].dependencies[${dependencyIndex}]`, message: `Registry dependency '${dependency}' is unknown.` });
+        }
+    }
+    const visiting = new Set();
+    const visited = new Set();
+    const reportCycle = (key) => {
+        if (visiting.has(key)) {
+            diagnostics.push({ code: 'YREG004', path: `entries.${key}`, message: `Registry dependency cycle includes '${key}'.` });
+            return;
+        }
+        if (visited.has(key))
+            return;
+        visiting.add(key);
+        for (const dependency of entries.get(key)?.dependencies ?? []) {
+            if (entries.has(dependency))
+                reportCycle(dependency);
+        }
+        visiting.delete(key);
+        visited.add(key);
+    };
+    for (const key of entries.keys())
+        reportCycle(key);
+    return diagnostics;
+}

package/dist/renderer-registry.d.ts

@@ -0,0 +1,22 @@
+import { type YoyoGridPresentation, type YoyoRendererInputKind, type YoyoRendererSlot } from './types.js';
+export interface YoyoRendererDefinition<TInput = unknown> {
+    key: string;
+    input?: TInput;
+    inputKind?: YoyoRendererInputKind;
+    presentations?: readonly YoyoGridPresentation[];
+    slots?: readonly YoyoRendererSlot[];
+}
+export interface YoyoResolvedRendererDefinition<TInput = unknown> extends YoyoRendererDefinition<TInput> {
+    inputKind: YoyoRendererInputKind;
+    presentations: readonly YoyoGridPresentation[];
+    slots: readonly YoyoRendererSlot[];
+}
+export interface YoyoRendererRegistry {
+    has(key: string): boolean;
+    keys(): readonly string[];
+    resolve(key: string): YoyoResolvedRendererDefinition;
+}
+export declare const yoyoV1RendererDefinitions: readonly YoyoRendererDefinition[];
+export declare const yoyoV1RendererRegistry: YoyoRendererRegistry;
+export declare function createYoyoRendererRegistry(definitions: readonly YoyoRendererDefinition[]): YoyoRendererRegistry;
+//# sourceMappingURL=renderer-registry.d.ts.map

package/dist/renderer-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer-registry.d.ts","sourceRoot":"","sources":["../src/renderer-registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,oBAAoB,EAEzB,KAAK,qBAAqB,EAC1B,KAAK,gBAAgB,EACtB,MAAM,YAAY,CAAA;AAEnB,MAAM,WAAW,sBAAsB,CAAC,MAAM,GAAG,OAAO;IACtD,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,qBAAqB,CAAA;IACjC,aAAa,CAAC,EAAE,SAAS,oBAAoB,EAAE,CAAA;IAC/C,KAAK,CAAC,EAAE,SAAS,gBAAgB,EAAE,CAAA;CACpC;AAED,MAAM,WAAW,8BAA8B,CAAC,MAAM,GAAG,OAAO,CAAE,SAAQ,sBAAsB,CAAC,MAAM,CAAC;IACtG,SAAS,EAAE,qBAAqB,CAAA;IAChC,aAAa,EAAE,SAAS,oBAAoB,EAAE,CAAA;IAC9C,KAAK,EAAE,SAAS,gBAAgB,EAAE,CAAA;CACnC;AAED,MAAM,WAAW,oBAAoB;IACnC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;IACzB,IAAI,IAAI,SAAS,MAAM,EAAE,CAAA;IACzB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,8BAA8B,CAAA;CACrD;AAED,eAAO,MAAM,yBAAyB,EAAE,SAAS,sBAAsB,EAKpE,CAAA;AACH,eAAO,MAAM,sBAAsB,sBAAwD,CAAA;AAE3F,wBAAgB,0BAA0B,CAAC,WAAW,EAAE,SAAS,sBAAsB,EAAE,GAAG,oBAAoB,CAsB/G"}

package/dist/renderer-registry.js

@@ -0,0 +1,33 @@
+import { YOYO_GRID_PRESENTATIONS, YOYO_RENDERERS, } from './types.js';
+export const yoyoV1RendererDefinitions = YOYO_RENDERERS.map((key) => ({
+    key,
+    inputKind: 'cell-value',
+    presentations: YOYO_GRID_PRESENTATIONS,
+    slots: ['cell'],
+}));
+export const yoyoV1RendererRegistry = createYoyoRendererRegistry(yoyoV1RendererDefinitions);
+export function createYoyoRendererRegistry(definitions) {
+    const entries = new Map();
+    for (const definition of definitions) {
+        if (!definition.key.trim())
+            throw new Error('Renderer registry does not accept an empty key.');
+        if (entries.has(definition.key))
+            throw new Error(`Renderer '${definition.key}' is already registered.`);
+        entries.set(definition.key, {
+            ...definition,
+            inputKind: definition.inputKind ?? 'cell-value',
+            presentations: definition.presentations ?? YOYO_GRID_PRESENTATIONS,
+            slots: definition.slots ?? ['cell'],
+        });
+    }
+    return {
+        has: (key) => entries.has(key),
+        keys: () => [...entries.keys()].sort(),
+        resolve: (key) => {
+            const definition = entries.get(key);
+            if (!definition)
+                throw new Error(`Renderer '${key}' is not registered.`);
+            return definition;
+        },
+    };
+}