@astrale-os/sdk 0.5.0-beta.13 → 0.5.0-beta.130

package/dist/tooling/linter/implementations/source/schema.js

@@ -0,0 +1,826 @@
+import ts from 'typescript';
+import { NEUTRAL_CLASS_ICON_SVG } from '../../../../platform/schema/class-icon.js';
+import { importedSymbol, objectProperty, propertyChain, resolveImportedSymbol, staticText, unwrap, visit, } from '../../adapters/typescript/index.js';
+import { ambiguity, definitionObjects, definitionOriginAmbiguity, DSL_MODULES, forbiddenIoImport, production, propertyExpression, violation, } from './shared.js';
+import { stateMachineConstructorOrigin, stateMachineOrigin, statePropertyIdentity, statePropertyOrigin, stateSchemaIdentity, } from './state-machine.js';
+const FORBIDDEN_LAYERS = new Set([
+    'integrations',
+    'functions',
+    'providers',
+    'mutations',
+    'queries',
+    'ui',
+    'views',
+]);
+const EXECUTION_NAMES = new Set([
+    'defineAction',
+    'defineMutation',
+    'defineQuery',
+    'defineWorkflow',
+    'invoke',
+    'mutate',
+    'query',
+]);
+const SCHEMA_KINDS = Object.freeze([
+    'classes',
+    'core',
+    'dependencies',
+    'errors',
+    'functions',
+    'policies',
+    'states',
+    'types',
+    'views',
+]);
+const SCHEMA_KIND_DIRECTORIES = new Set(SCHEMA_KINDS);
+const SCHEMA_ROOT_DIRECTORIES = new Set(['__tests__', 'modules', ...SCHEMA_KINDS]);
+const SCHEMA_KIND_LIST = SCHEMA_KINDS.join(', ');
+const SCHEMA_ROOT_DIRECTORY_LIST = [...SCHEMA_ROOT_DIRECTORIES].join(', ');
+const OWNED_DECLARATION_KINDS = new Set(['classes', 'functions', 'policies', 'states', 'views']);
+const DECLARATION_KIND_CONTRACTS = Object.freeze({
+    classes: {
+        label: 'Class',
+        constructors: [
+            { module: '@astrale-os/sdk/schema', name: 'nodeClass' },
+            { module: '@astrale-os/sdk/schema', name: 'defineClass' },
+            { module: '@astrale-os/sdk/schema', name: 'edgeClass', member: 'directed' },
+            { module: '@astrale-os/sdk/schema', name: 'edgeClass', member: 'undirected' },
+        ],
+    },
+    functions: {
+        label: 'Function or Method',
+        constructors: [
+            { module: '@astrale-os/sdk/schema', name: 'func' },
+            { module: '@astrale-os/sdk/schema', name: 'method' },
+        ],
+    },
+    policies: {
+        label: 'Policy',
+        constructors: [
+            { module: '@astrale-os/sdk/schema', name: 'policy' },
+            { module: '@astrale-os/sdk/schema', name: 'policy', member: 'allOf' },
+            { module: '@astrale-os/sdk/schema', name: 'policy', member: 'anyOf' },
+        ],
+    },
+    states: {
+        label: 'StateMachine',
+        constructors: [{ module: '@astrale-os/sdk/state', name: 'stateMachine' }],
+    },
+    views: {
+        label: 'View',
+        constructors: [{ module: '@astrale-os/sdk/schema', name: 'view' }],
+    },
+});
+function classIconObservation(file, call, object) {
+    if (!object) {
+        if (call.arguments.length === 0 || isUndefinedExpression(call.arguments[0])) {
+            return { state: 'missing', node: call };
+        }
+        return {
+            state: 'presence-ambiguous',
+            node: call,
+            detail: 'Node Class icon is hidden inside an opaque configuration.',
+        };
+    }
+    const property = objectProperty(object, 'icon');
+    if (!property) {
+        if (object.properties.some(mayAssignUnknownProperty)) {
+            return {
+                state: 'presence-ambiguous',
+                node: object,
+                detail: 'Node Class icon may be supplied by an object spread or computed property.',
+            };
+        }
+        return { state: 'missing', node: object };
+    }
+    if (object.properties.some((candidate) => candidate.pos > property.pos && mayAssignUnknownProperty(candidate))) {
+        return {
+            state: 'presence-ambiguous',
+            node: property,
+            detail: 'Node Class icon may be overridden by a later object spread or computed property.',
+        };
+    }
+    if (!ts.isPropertyAssignment(property)) {
+        return {
+            state: 'value-ambiguous',
+            node: property,
+            detail: 'Node Class icon value is not statically visible.',
+        };
+    }
+    if (isUndefinedExpression(property.initializer)) {
+        return { state: 'missing', node: property };
+    }
+    const state = neutralIconState(file, property.initializer);
+    if (state === 'neutral') {
+        return { state, node: property };
+    }
+    if (state === 'value-ambiguous') {
+        return {
+            state,
+            node: property,
+            detail: 'Node Class icon origin is not statically resolvable.',
+        };
+    }
+    return { state: 'meaningful', node: property };
+}
+function neutralIconState(file, expression) {
+    if (staticText(expression) === NEUTRAL_CLASS_ICON_SVG)
+        return 'neutral';
+    const target = unwrap(expression);
+    if (ts.isCallExpression(target)) {
+        const callee = unwrap(target.expression);
+        if (!ts.isPropertyAccessExpression(callee) || callee.name.text !== 'svg') {
+            return 'meaningful';
+        }
+        const resolution = resolveImportedSymbol(file, callee.expression);
+        if (resolution.kind === 'local' || resolution.name !== 'classIcon')
+            return 'meaningful';
+        if (resolution.kind === 'ambiguous')
+            return 'value-ambiguous';
+        if (resolution.module !== '@astrale-os/sdk/schema')
+            return 'meaningful';
+        return staticText(target.arguments[0]) === NEUTRAL_CLASS_ICON_SVG ? 'neutral' : 'meaningful';
+    }
+    if (!ts.isPropertyAccessExpression(target) || target.name.text !== 'neutral') {
+        return 'meaningful';
+    }
+    const resolution = resolveImportedSymbol(file, target.expression);
+    if (resolution.kind === 'local')
+        return 'meaningful';
+    if (resolution.name !== 'classIcon')
+        return 'meaningful';
+    if (resolution.kind === 'resolved') {
+        return resolution.module === '@astrale-os/sdk/schema' ? 'neutral' : 'meaningful';
+    }
+    return resolution.kind === 'ambiguous' ? 'value-ambiguous' : 'meaningful';
+}
+function requiredClassIconEvidence(file, observation) {
+    if (observation.state === 'missing') {
+        return [
+            violation(file, observation.node, 'Node Class must declare icon explicitly; use classIcon.neutral only for an intentional neutral choice.'),
+        ];
+    }
+    if (observation.state === 'presence-ambiguous') {
+        return [ambiguity(file, observation.node, observation.detail ?? 'Node Class icon is opaque.')];
+    }
+    return [];
+}
+function neutralClassIconEvidence(file, observation) {
+    if (observation.state !== 'neutral')
+        return [];
+    return [
+        violation(file, observation.node, 'Node Class uses classIcon.neutral; choose a meaningful Lucide or custom SVG icon.'),
+    ];
+}
+function classIconEvidence(project, mode) {
+    const evidence = [];
+    const report = mode === 'required' ? requiredClassIconEvidence : neutralClassIconEvidence;
+    for (const file of production(project, 'schema')) {
+        for (const definition of definitionObjects(file, 'nodeClass', undefined, DSL_MODULES)) {
+            const uncertain = definitionOriginAmbiguity(file, definition, 'nodeClass declaration');
+            if (uncertain) {
+                if (mode === 'required')
+                    evidence.push(uncertain);
+                continue;
+            }
+            evidence.push(...report(file, classIconObservation(file, definition.call, definition.object)));
+        }
+        for (const definition of definitionObjects(file, 'defineClass', undefined, DSL_MODULES)) {
+            if (!definition.object)
+                continue;
+            if (staticText(propertyExpression(definition.object, 'kind')) !== 'node')
+                continue;
+            const uncertain = definitionOriginAmbiguity(file, definition, 'defineClass declaration');
+            if (uncertain) {
+                if (mode === 'required')
+                    evidence.push(uncertain);
+                continue;
+            }
+            evidence.push(...report(file, classIconObservation(file, definition.call, definition.object)));
+        }
+    }
+    return evidence;
+}
+function isUndefinedExpression(expression) {
+    if (!expression)
+        return false;
+    const target = unwrap(expression);
+    return (ts.isIdentifier(target) && target.text === 'undefined') || ts.isVoidExpression(target);
+}
+function mayAssignUnknownProperty(property) {
+    if (ts.isSpreadAssignment(property))
+        return true;
+    return ('name' in property &&
+        property.name !== undefined &&
+        ts.isComputedPropertyName(property.name) &&
+        staticText(property.name.expression) === undefined);
+}
+function declarationKindFile(project, file) {
+    if (file.role !== 'production' || file.layer !== 'schema')
+        return undefined;
+    const layer = project.policy.layers.find(({ id }) => id === 'schema');
+    if (!layer)
+        return undefined;
+    const segments = file.path.slice(layer.sourcePath.length).split('/');
+    const nestedModule = segments[0] === 'modules';
+    const kind = segments[nestedModule ? 2 : 0];
+    if (!kind || !OWNED_DECLARATION_KINDS.has(kind))
+        return undefined;
+    const index = nestedModule
+        ? segments.length === 4 && segments[3] === 'index.ts'
+        : segments.length === 2 && segments[1] === 'index.ts';
+    return { kind: kind, index };
+}
+function declarationConstructor(file, expression) {
+    const call = unwrap(expression);
+    if (!ts.isCallExpression(call))
+        return undefined;
+    const callee = unwrap(call.expression);
+    const direct = resolveImportedSymbol(file, callee);
+    if (direct.kind === 'resolved') {
+        for (const contract of Object.values(DECLARATION_KIND_CONTRACTS)) {
+            const constructor = contract.constructors.find((candidate) => candidate.module === direct.module &&
+                candidate.name === direct.name &&
+                candidate.member === undefined);
+            if (constructor)
+                return constructor;
+        }
+    }
+    if (!ts.isPropertyAccessExpression(callee))
+        return undefined;
+    const resolution = resolveImportedSymbol(file, callee.expression);
+    if (resolution.kind !== 'resolved')
+        return undefined;
+    for (const contract of Object.values(DECLARATION_KIND_CONTRACTS)) {
+        const constructor = contract.constructors.find((candidate) => candidate.module === resolution.module &&
+            candidate.name === resolution.name &&
+            candidate.member === callee.name.text);
+        if (constructor)
+            return constructor;
+    }
+    return undefined;
+}
+function expectedDeclarationConstructor(file, expression, kind) {
+    if (!expression)
+        return false;
+    const constructor = declarationConstructor(file, expression);
+    return (constructor !== undefined &&
+        DECLARATION_KIND_CONTRACTS[kind].constructors.some((candidate) => candidate.module === constructor.module &&
+            candidate.name === constructor.name &&
+            candidate.member === constructor.member));
+}
+function locallyConstructedDeclarations(file) {
+    const declarations = [];
+    visit(file.source, (node) => {
+        if (ts.isCallExpression(node) && declarationConstructor(file, node))
+            declarations.push(node);
+    });
+    return declarations;
+}
+function runtimeExports(file) {
+    const bindings = new Map();
+    for (const statement of file.source.statements) {
+        if (ts.isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                if (ts.isIdentifier(declaration.name)) {
+                    bindings.set(declaration.name.text, {
+                        node: declaration,
+                        ...(declaration.initializer ? { initializer: declaration.initializer } : {}),
+                    });
+                }
+            }
+            continue;
+        }
+        if ((ts.isFunctionDeclaration(statement) ||
+            ts.isClassDeclaration(statement) ||
+            ts.isEnumDeclaration(statement) ||
+            ts.isModuleDeclaration(statement)) &&
+            statement.name) {
+            bindings.set(statement.name.text, { node: statement });
+        }
+    }
+    const exports = [];
+    for (const statement of file.source.statements) {
+        if (ts.isVariableStatement(statement) && hasModifier(statement, ts.SyntaxKind.ExportKeyword)) {
+            for (const declaration of statement.declarationList.declarations) {
+                exports.push({
+                    node: declaration,
+                    ...(declaration.initializer ? { initializer: declaration.initializer } : {}),
+                });
+            }
+            continue;
+        }
+        if ((ts.isFunctionDeclaration(statement) ||
+            ts.isClassDeclaration(statement) ||
+            ts.isEnumDeclaration(statement) ||
+            ts.isModuleDeclaration(statement)) &&
+            hasModifier(statement, ts.SyntaxKind.ExportKeyword)) {
+            exports.push({ node: statement });
+            continue;
+        }
+        if (ts.isExportAssignment(statement)) {
+            exports.push({
+                node: statement,
+                initializer: localInitializer(statement.expression, bindings),
+            });
+            continue;
+        }
+        if (!ts.isExportDeclaration(statement) || statement.isTypeOnly)
+            continue;
+        if (!statement.exportClause || !ts.isNamedExports(statement.exportClause)) {
+            exports.push({ node: statement });
+            continue;
+        }
+        for (const element of statement.exportClause.elements) {
+            if (element.isTypeOnly)
+                continue;
+            exports.push({
+                node: element,
+                ...(statement.moduleSpecifier
+                    ? {}
+                    : { initializer: localInitializer(element.propertyName ?? element.name, bindings) }),
+            });
+        }
+    }
+    return exports;
+}
+function localInitializer(expression, bindings, seen = new Set()) {
+    const target = unwrap(expression);
+    if (!ts.isIdentifier(target))
+        return target;
+    if (seen.has(target.text))
+        return undefined;
+    seen.add(target.text);
+    const initializer = bindings.get(target.text)?.initializer;
+    return initializer ? localInitializer(initializer, bindings, seen) : undefined;
+}
+function hasModifier(node, kind) {
+    return (ts.canHaveModifiers(node) &&
+        ts.getModifiers(node)?.some((modifier) => modifier.kind === kind) === true);
+}
+function curatedDeclarationIndex(statement) {
+    if (ts.isEmptyStatement(statement))
+        return true;
+    if (ts.isImportDeclaration(statement))
+        return statement.importClause !== undefined;
+    return (ts.isExportDeclaration(statement) &&
+        statement.exportClause !== undefined &&
+        ts.isNamedExports(statement.exportClause));
+}
+export const schemaRules = [
+    {
+        id: 'SCH-SUBMODULE',
+        ruleRevision: '8b226c1ec1f283372e048d40338f010ba97ae81230b4ebae63e48d533c7152c4',
+        evaluate(project) {
+            const layer = project.policy.layers.find(({ id }) => id === 'schema');
+            if (!layer)
+                return [];
+            const evidence = [];
+            const rootFiles = new Set(['index.ts', ...(layer.facade ? [layer.facade] : [])]);
+            const reportedRootDirectories = new Set();
+            const reportedModuleDirectories = new Set();
+            for (const file of project.files) {
+                if (file.layer !== 'schema')
+                    continue;
+                const relative = file.path.slice(layer.sourcePath.length);
+                const segments = relative.split('/');
+                if (segments.length === 1) {
+                    if (!rootFiles.has(relative)) {
+                        evidence.push(violation(file, file.source, `Schema root source ${file.path} is flat; only ${[...rootFiles]
+                            .map((name) => `${layer.sourcePath}${name}`)
+                            .join(' and ')} may be flat.`));
+                    }
+                    continue;
+                }
+                const rootDirectory = segments[0];
+                if (!SCHEMA_ROOT_DIRECTORIES.has(rootDirectory)) {
+                    if (!reportedRootDirectories.has(rootDirectory)) {
+                        reportedRootDirectories.add(rootDirectory);
+                        evidence.push(violation(file, file.source, `Schema source ${file.path} uses unknown root directory ${layer.sourcePath}${rootDirectory}/; expected one of ${SCHEMA_ROOT_DIRECTORY_LIST}.`));
+                    }
+                    continue;
+                }
+                if (rootDirectory !== 'modules')
+                    continue;
+                if (segments.length === 2) {
+                    evidence.push(violation(file, file.source, `Schema modules source ${file.path} is flat; declarations must belong to ${layer.sourcePath}modules/<module>/.`));
+                    continue;
+                }
+                const moduleName = segments[1];
+                if (segments.length === 3) {
+                    if (segments[2] !== 'index.ts') {
+                        evidence.push(violation(file, file.source, `Schema module source ${file.path} is flat; only ${layer.sourcePath}modules/${moduleName}/index.ts may be flat.`));
+                    }
+                    continue;
+                }
+                const kind = segments[2];
+                if (kind === '__tests__' || SCHEMA_KIND_DIRECTORIES.has(kind))
+                    continue;
+                const directory = `${moduleName}/${kind}`;
+                if (reportedModuleDirectories.has(directory))
+                    continue;
+                reportedModuleDirectories.add(directory);
+                evidence.push(violation(file, file.source, `Schema module source ${file.path} uses unknown declaration-kind directory ${kind}/; expected one of ${SCHEMA_KIND_LIST}, __tests__.`));
+            }
+            return evidence;
+        },
+    },
+    {
+        id: 'SCH-ONE-DECL',
+        ruleRevision: '62d059e983429281d3858d3d3e10573668cb5b59762247c3b47c8bb5ed99ee2d',
+        evaluate(project) {
+            const evidence = [];
+            for (const file of project.files) {
+                const owner = declarationKindFile(project, file);
+                if (!owner)
+                    continue;
+                if (owner.index) {
+                    const unsupported = file.source.statements.find((statement) => !curatedDeclarationIndex(statement));
+                    if (unsupported) {
+                        evidence.push(violation(file, unsupported, `Schema declaration-kind index ${file.path} owns a value or uses an uncurated export; keep index.ts limited to imports and named re-exports.`));
+                    }
+                    continue;
+                }
+                const contract = DECLARATION_KIND_CONTRACTS[owner.kind];
+                const exports = runtimeExports(file);
+                if (exports.length !== 1) {
+                    evidence.push(violation(file, exports[0]?.node ?? file.source, `Schema ${owner.kind} leaf ${file.path} exports ${exports.length} runtime values; export exactly one locally authored ${contract.label} declaration.`));
+                    continue;
+                }
+                if (!expectedDeclarationConstructor(file, exports[0]?.initializer, owner.kind)) {
+                    evidence.push(violation(file, exports[0].node, `Schema ${owner.kind} leaf ${file.path} does not export one locally authored ${contract.label} declaration; only index.ts may re-export declarations.`));
+                    continue;
+                }
+                const declarations = locallyConstructedDeclarations(file);
+                if (declarations.length !== 1) {
+                    evidence.push(violation(file, declarations[1] ?? declarations[0] ?? exports[0].node, `Schema ${owner.kind} leaf ${file.path} constructs ${declarations.length} Schema declarations; construct exactly one ${contract.label} declaration.`));
+                }
+            }
+            return evidence;
+        },
+    },
+    {
+        id: 'SCH-ICON-REQUIRED',
+        ruleRevision: 'f4055b93066289f9b7d9cfceb5ef236420f88311a357ea11161b6fda0922ab9f',
+        evaluate(project) {
+            return classIconEvidence(project, 'required');
+        },
+    },
+    {
+        id: 'SCH-ICON-NEUTRAL',
+        ruleRevision: '061939249964440ceba92dcb86f166553d56cc0196dff15785616423963d4d5b',
+        evaluate(project) {
+            return classIconEvidence(project, 'neutral');
+        },
+    },
+    {
+        id: 'SCH-STATE-SOURCE',
+        ruleRevision: '153bb37fbc7ddcf164dea299d6874251b6b2aeffa707e809044c5390f25b3fe6',
+        evaluate(project) {
+            const evidence = [];
+            const machineVocabularies = stateVocabularies(project);
+            for (const file of production(project, 'schema')) {
+                const ownedVocabularies = file.submodule === undefined ? undefined : machineVocabularies.get(file.submodule);
+                const reportedEnums = new Set();
+                visit(file.source, (node) => {
+                    if ((ts.isPropertyAssignment(node) || ts.isShorthandPropertyAssignment(node)) &&
+                        isPropertiesMember(node)) {
+                        const value = ts.isPropertyAssignment(node) ? node.initializer : node.name;
+                        const result = persistedStatePropertyEvidence(project, file, value, node);
+                        if (result !== undefined)
+                            evidence.push(result);
+                    }
+                    if (ts.isSpreadAssignment(node) && isPropertiesObject(node.parent)) {
+                        const spread = staticSchemaObject(file, node.expression);
+                        for (const entry of spread?.properties ?? []) {
+                            if (!ts.isPropertyAssignment(entry) && !ts.isShorthandPropertyAssignment(entry)) {
+                                continue;
+                            }
+                            const value = ts.isPropertyAssignment(entry) ? entry.initializer : entry.name;
+                            const result = persistedStatePropertyEvidence(project, file, value, node);
+                            if (result !== undefined)
+                                evidence.push(result);
+                        }
+                    }
+                    if (ts.isCallExpression(node)) {
+                        const machineOrigin = stateMachineConstructorOrigin(file, node.expression);
+                        if (machineOrigin === 'ambiguous') {
+                            evidence.push(ambiguity(file, node, 'Schema call resembles stateMachine through a local facade, but its SDK origin is unresolved.'));
+                        }
+                        const values = enumValues(file, node);
+                        if (values !== undefined &&
+                            ownedVocabularies?.has(vocabularyKey(values)) === true &&
+                            !reportedEnums.has(node.pos)) {
+                            reportedEnums.add(node.pos);
+                            evidence.push(ambiguity(file, node, 'Schema declares an enum equal to its module StateMachine vocabulary, but copied semantic ownership cannot be proven from literals alone.'));
+                        }
+                    }
+                    const projection = stateMachineCodecProjection(node);
+                    if (projection !== undefined) {
+                        const origin = stateMachineOrigin(project, file, projection.owner);
+                        if (origin === 'ambiguous') {
+                            evidence.push(ambiguity(file, node, `Schema StateMachine codec ${projection.name} has an unresolved Schema module export origin.`));
+                        }
+                        else if (origin === 'absent') {
+                            evidence.push(violation(file, node, `Schema StateMachine codec ${projection.name} does not originate from an exported stateMachine.`));
+                        }
+                    }
+                });
+            }
+            return evidence;
+        },
+    },
+    {
+        id: 'SCH-EXACT-TYPES',
+        ruleRevision: '952b22e447d155ca168ac900eede803085cf6326ae73df3c588f6dc8caa3f116',
+        evaluate(project) {
+            const evidence = [];
+            const erased = new Set([
+                'ClassDefinition',
+                'FunctionDefinition',
+                'MethodDefinition',
+                'PolicyDefinition',
+                'ViewDefinition',
+            ]);
+            for (const file of production(project, 'schema')) {
+                visit(file.source, (node) => {
+                    const type = ts.isVariableDeclaration(node)
+                        ? node.type
+                        : ts.isFunctionDeclaration(node) ||
+                            ts.isFunctionExpression(node) ||
+                            ts.isMethodDeclaration(node)
+                            ? node.type
+                            : undefined;
+                    if (!type || !ts.isTypeReferenceNode(type))
+                        return;
+                    const name = ts.isIdentifier(type.typeName)
+                        ? type.typeName.text
+                        : ts.isQualifiedName(type.typeName)
+                            ? type.typeName.right.text
+                            : undefined;
+                    const root = ts.isIdentifier(type.typeName)
+                        ? type.typeName
+                        : ts.isQualifiedName(type.typeName) && ts.isIdentifier(type.typeName.left)
+                            ? type.typeName.left
+                            : undefined;
+                    const symbol = root && importedSymbol(file, root);
+                    if (!name ||
+                        !erased.has(name) ||
+                        !symbol ||
+                        (symbol.module !== '@astrale-os/sdk/schema' &&
+                            !symbol.module.startsWith('@astrale-os/kernel-dsl'))) {
+                        return;
+                    }
+                    evidence.push(violation(file, type, `Schema authoring value is widened to ${name}; preserve its exact inferred type.`));
+                });
+            }
+            return evidence;
+        },
+    },
+    {
+        id: 'SCH-DECL-ONLY',
+        ruleRevision: '3243da10715f3fbb500444cc562195ae10eb61dad84646ab8ef1d1a73b94c99a',
+        evaluate(project) {
+            const evidence = [];
+            for (const file of production(project, 'schema')) {
+                for (const sourceImport of file.imports) {
+                    const target = project.filesByPath.get(
+                    // Imported source classification is resolved by the alias/relative verifier elsewhere.
+                    sourceImport.specifier.replace(/^#([^/]+)\//, '$1/').replace(/\.js$/, '.ts'));
+                    const layer = target?.layer ?? sourceImport.specifier.match(/^#([^/]+)\//)?.[1];
+                    if (layer && FORBIDDEN_LAYERS.has(layer)) {
+                        evidence.push(violation(file, sourceImport.node, `Schema imports execution layer ${layer} through ${sourceImport.specifier}.`));
+                    }
+                    else if (forbiddenIoImport(sourceImport.specifier)) {
+                        evidence.push(violation(file, sourceImport.node, `Schema imports I/O boundary ${sourceImport.specifier}.`));
+                    }
+                }
+                visit(file.source, (node) => {
+                    if (!ts.isCallExpression(node))
+                        return;
+                    const symbol = importedSymbol(file, node.expression);
+                    const chain = propertyChain(node.expression);
+                    const name = symbol?.name;
+                    if (name && EXECUTION_NAMES.has(name)) {
+                        evidence.push(violation(file, node, `Schema executes ${name} instead of declaring a contract.`));
+                    }
+                    else if (!symbol &&
+                        chain &&
+                        chain.length > 1 &&
+                        EXECUTION_NAMES.has(chain.at(-1) ?? '')) {
+                        evidence.push(ambiguity(file, node, `Schema call ${chain.join('.')} resembles an excluded operation but its receiver is opaque.`));
+                    }
+                });
+            }
+            return evidence;
+        },
+    },
+];
+function enumValues(file, call) {
+    if (!isZodCall(file, call.expression))
+        return undefined;
+    const chain = propertyChain(call.expression);
+    const symbol = importedSymbol(file, call.expression);
+    if (symbol?.name === 'union' || chain?.at(-1) === 'union') {
+        return literalUnionValues(file, call);
+    }
+    if (symbol?.name !== 'enum' && chain?.at(-1) !== 'enum')
+        return undefined;
+    const argument = call.arguments[0] && unwrap(call.arguments[0]);
+    if (!argument || !ts.isArrayLiteralExpression(argument))
+        return undefined;
+    const values = argument.elements.map((element) => staticText(element));
+    return values.every((value) => value !== undefined) ? values : undefined;
+}
+function stateMachineCodecProjection(node) {
+    if (ts.isPropertyAccessExpression(node)) {
+        if (node.name.text === 'stateSchema' || node.name.text === 'eventSchema') {
+            return { owner: node.expression, name: node.name.text };
+        }
+        return undefined;
+    }
+    if (!ts.isElementAccessExpression(node))
+        return undefined;
+    const name = staticText(node.argumentExpression);
+    return name === 'stateSchema' || name === 'eventSchema'
+        ? { owner: node.expression, name }
+        : undefined;
+}
+function isZodCall(file, expression) {
+    const chain = propertyChain(expression);
+    const root = chain?.[0];
+    if (root === undefined)
+        return false;
+    return file.imports.some((sourceImport) => sourceImport.specifier === 'zod' &&
+        (sourceImport.namespace === root ||
+            [...sourceImport.bindings].some(([, local]) => local === root)));
+}
+function literalUnionValues(file, call) {
+    const argument = call.arguments[0] && unwrap(call.arguments[0]);
+    if (!argument || !ts.isArrayLiteralExpression(argument) || argument.elements.length === 0) {
+        return undefined;
+    }
+    const values = [];
+    for (const element of argument.elements) {
+        if (ts.isSpreadElement(element))
+            return undefined;
+        const literalCall = unwrap(element);
+        if (!ts.isCallExpression(literalCall))
+            return undefined;
+        const chain = propertyChain(literalCall.expression);
+        const symbol = importedSymbol(file, literalCall.expression);
+        if (symbol?.name !== 'literal' && chain?.at(-1) !== 'literal')
+            return undefined;
+        const value = staticText(literalCall.arguments[0]);
+        if (value === undefined)
+            return undefined;
+        values.push(value);
+    }
+    return values;
+}
+function stateVocabularies(project) {
+    const vocabularies = new Map();
+    for (const file of production(project, 'schema')) {
+        if (file.submodule === undefined)
+            continue;
+        const submodule = file.submodule;
+        visit(file.source, (node) => {
+            if (!ts.isCallExpression(node))
+                return;
+            if (stateMachineConstructorOrigin(file, node.expression) !== 'resolved')
+                return;
+            const input = node.arguments[0] && unwrap(node.arguments[0]);
+            if (!input || !ts.isObjectLiteralExpression(input))
+                return;
+            const transitions = input.properties.find((property) => 'name' in property && property.name && propertyName(property.name) === 'transitions');
+            if (!transitions || !ts.isPropertyAssignment(transitions))
+                return;
+            const relation = unwrap(transitions.initializer);
+            if (!ts.isObjectLiteralExpression(relation))
+                return;
+            const states = [];
+            const events = [];
+            for (const state of relation.properties) {
+                if (!('name' in state) || !state.name || !ts.isPropertyAssignment(state))
+                    return;
+                const stateName = propertyName(state.name);
+                if (stateName === '<dynamic>')
+                    return;
+                states.push(stateName);
+                const outgoing = unwrap(state.initializer);
+                if (!ts.isObjectLiteralExpression(outgoing))
+                    return;
+                for (const event of outgoing.properties) {
+                    if (!('name' in event) || !event.name)
+                        return;
+                    const eventName = propertyName(event.name);
+                    if (eventName === '<dynamic>')
+                        return;
+                    events.push(eventName);
+                }
+            }
+            const owned = vocabularies.get(submodule) ?? new Set();
+            owned.add(vocabularyKey(states));
+            owned.add(vocabularyKey(events));
+            vocabularies.set(submodule, owned);
+        });
+    }
+    return vocabularies;
+}
+function vocabularyKey(values) {
+    return [...new Set(values)].sort().join('\0');
+}
+function propertyName(name) {
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+        return name.text;
+    }
+    return ts.isComputedPropertyName(name)
+        ? (staticText(name.expression) ?? '<dynamic>')
+        : '<dynamic>';
+}
+function persistedStatePropertyEvidence(project, file, value, placement) {
+    const associationOrigin = statePropertyOrigin(file, value);
+    const association = statePropertyIdentity(project, file, value);
+    if (associationOrigin === 'resolved' && isEdgePropertyPlacement(file, placement)) {
+        return violation(file, value, 'Schema StateProperty is supported only on Node Classes.');
+    }
+    if (associationOrigin === 'resolved' && association.kind === 'absent') {
+        return violation(file, value, 'Schema stateProperty does not reference an exported StateMachine authority.');
+    }
+    if (associationOrigin === 'resolved' && association.kind === 'resolved') {
+        const separator = association.identity.lastIndexOf('#');
+        const machinePath = separator === -1 ? association.identity : association.identity.slice(0, separator);
+        const machineFile = project.filesByPath.get(machinePath);
+        if (machineFile?.layer !== 'schema' ||
+            machineFile.submodule === undefined ||
+            machineFile.submodule !== file.submodule) {
+            return violation(file, value, 'Schema stateProperty must reference an exported StateMachine authority in the same business module.');
+        }
+    }
+    if (associationOrigin === 'ambiguous' || association.kind === 'ambiguous') {
+        return ambiguity(file, value, 'Schema StateProperty has no exact StateMachine source.');
+    }
+    if (associationOrigin !== 'absent')
+        return undefined;
+    const codec = stateSchemaIdentity(project, file, value);
+    if (codec.kind === 'resolved') {
+        return violation(file, value, 'Schema persists a StateMachine codec without retaining its authority; use stateProperty(machine).');
+    }
+    return codec.kind === 'ambiguous'
+        ? ambiguity(file, value, 'Schema machine-backed Property has no exact stateProperty source.')
+        : undefined;
+}
+function isEdgePropertyPlacement(file, placement) {
+    let current = placement;
+    while (current !== undefined && !ts.isSourceFile(current)) {
+        if (ts.isCallExpression(current)) {
+            const expression = unwrap(current.expression);
+            if (ts.isPropertyAccessExpression(expression) || ts.isElementAccessExpression(expression)) {
+                const member = ts.isPropertyAccessExpression(expression)
+                    ? expression.name.text
+                    : staticText(expression.argumentExpression);
+                const owner = importedSymbol(file, expression.expression);
+                if ((member === 'directed' || member === 'undirected') &&
+                    owner?.name === 'edgeClass' &&
+                    DSL_MODULES.has(owner.module)) {
+                    return true;
+                }
+            }
+        }
+        current = current.parent;
+    }
+    return false;
+}
+function staticSchemaObject(file, expression, seen = new Set()) {
+    const value = unwrap(expression);
+    if (ts.isObjectLiteralExpression(value))
+        return value;
+    if (!ts.isIdentifier(value) || seen.has(value.text))
+        return undefined;
+    for (const statement of file.source.statements) {
+        if (!ts.isVariableStatement(statement))
+            continue;
+        if ((statement.declarationList.flags & ts.NodeFlags.Const) === 0)
+            continue;
+        for (const declaration of statement.declarationList.declarations) {
+            if (ts.isIdentifier(declaration.name) &&
+                declaration.name.text === value.text &&
+                declaration.initializer !== undefined) {
+                return staticSchemaObject(file, declaration.initializer, new Set([...seen, value.text]));
+            }
+        }
+    }
+    return undefined;
+}
+function isPropertiesMember(node) {
+    const owner = node.parent.parent;
+    return (ts.isPropertyAssignment(owner) &&
+        owner.name !== undefined &&
+        propertyName(owner.name) === 'properties');
+}
+function isPropertiesObject(node) {
+    const owner = node.parent;
+    return (ts.isPropertyAssignment(owner) &&
+        owner.name !== undefined &&
+        propertyName(owner.name) === 'properties');
+}