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

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

@@ -0,0 +1,361 @@
+import ts from 'typescript';
+import { resolveImportedSymbol, resolveProjectImport, staticText, unwrap, visit, } from '../../adapters/typescript/index.js';
+import { ambiguity, forbiddenIoImport, hasForbiddenGlobalCall, production, violation, } from './shared.js';
+import { machineExportStatus, stateMachineConstructorOrigin } from './state-machine.js';
+const STATE_MODULES = new Set(['@astrale-os/sdk/state']);
+const FORBIDDEN_LAYERS = new Set([
+    'functions',
+    'integrations',
+    'mutations',
+    'providers',
+    'queries',
+    'rules',
+    'scripts',
+    'views',
+]);
+export const stateRules = [
+    {
+        id: 'SCH-STATE-RELATION',
+        ruleRevision: '5dd255417705fa49bda9c79a65032408e2817616c03e8d761ed8c6d089a733d3',
+        evaluate(project) {
+            const evidence = [];
+            const files = production(project, 'schema').filter((file) => file.submodule !== undefined);
+            const bySubmodule = new Map();
+            for (const file of files) {
+                if (file.submodule === undefined)
+                    continue;
+                const owned = bySubmodule.get(file.submodule) ?? [];
+                owned.push(file);
+                bySubmodule.set(file.submodule, owned);
+            }
+            for (const [, ownedFiles] of [...bySubmodule].sort(([left], [right]) => left.localeCompare(right))) {
+                const machines = ownedFiles.flatMap((file) => machineCalls(file).map((machine) => ({ file, ...machine })));
+                for (const machine of machines) {
+                    if (machine.origin === 'ambiguous') {
+                        evidence.push(ambiguity(machine.file, machine.call, 'State machine constructor is reached through a local facade; its SDK origin is unresolved.'));
+                        continue;
+                    }
+                    const exportStatus = machineExportStatus(machine.file, machine.call);
+                    if (exportStatus !== 'exported') {
+                        evidence.push(violation(machine.file, machine.call, exportStatus === 'private'
+                            ? 'State machine relation must be exported as its Schema module StateMachine authority.'
+                            : exportStatus === 'mutable'
+                                ? 'State machine relation must be declared const as its stable Schema module authority.'
+                                : 'State machine relation must be assigned to one exported top-level binding.'));
+                    }
+                    evidence.push(...admitStaticRelation(machine.file, machine.call));
+                }
+                for (const machine of machines) {
+                    if (machine.origin === 'resolved') {
+                        evidence.push(...parallelAuthorityEvidence(ownedFiles, machine.file, machine.call));
+                    }
+                }
+            }
+            for (const file of files) {
+                visit(file.source, (node) => {
+                    if (!ts.isCallExpression(node))
+                        return;
+                    const symbol = resolveImportedSymbol(file, node.expression);
+                    if ((symbol.kind === 'resolved' || symbol.kind === 'ambiguous') &&
+                        symbol.name === 'defineStateMachine' &&
+                        STATE_MODULES.has(symbol.module)) {
+                        evidence.push(violation(file, node, 'StateMachine uses unsupported defineStateMachine; use stateMachine.'));
+                    }
+                });
+            }
+            return evidence;
+        },
+    },
+    {
+        id: 'SCH-STATE-PURE',
+        ruleRevision: '8bc69ef2aea37f568d34953c81cad55b1a91ab021e5d6e9b98c6aee3db6f4dd5',
+        evaluate(project) {
+            const evidence = [];
+            for (const file of production(project, 'schema').filter((candidate) => machineCalls(candidate).length > 0)) {
+                const exports = localExportNames(file);
+                for (const statement of file.source.statements) {
+                    if (ts.isClassDeclaration(statement) &&
+                        (hasExportModifier(statement) ||
+                            (statement.name !== undefined && exports.has(statement.name.text)))) {
+                        evidence.push(violation(file, statement, 'StateMachine declaration file exports executable behavior; move guards and callbacks to Rules or an effect-owning layer.'));
+                    }
+                    if (ts.isFunctionDeclaration(statement) &&
+                        statement.name &&
+                        (hasExportModifier(statement) || exports.has(statement.name.text))) {
+                        evidence.push(violation(file, statement, 'StateMachine declaration file exports executable behavior; move guards and callbacks to Rules or an effect-owning layer.'));
+                    }
+                    if (!ts.isVariableStatement(statement))
+                        continue;
+                    const directExport = hasExportModifier(statement);
+                    for (const declaration of statement.declarationList.declarations) {
+                        if (!ts.isIdentifier(declaration.name) ||
+                            declaration.initializer === undefined ||
+                            (!directExport && !exports.has(declaration.name.text))) {
+                            continue;
+                        }
+                        const initializer = unwrap(declaration.initializer);
+                        let behavior;
+                        visit(initializer, (node) => {
+                            if (behavior === undefined && (ts.isFunctionLike(node) || ts.isNewExpression(node))) {
+                                behavior = node;
+                            }
+                        });
+                        if (behavior === undefined)
+                            continue;
+                        evidence.push(violation(file, behavior, 'StateMachine declaration file exports executable behavior; move guards and callbacks to Rules or an effect-owning layer.'));
+                    }
+                }
+                for (const sourceImport of file.imports) {
+                    const target = resolveProjectImport(project, file, sourceImport.specifier);
+                    if ((target?.layer !== undefined && FORBIDDEN_LAYERS.has(target.layer)) ||
+                        forbiddenIoImport(sourceImport.specifier) ||
+                        sourceImport.specifier.startsWith('@astrale-os/adapter-')) {
+                        evidence.push(violation(file, sourceImport.node, `StateMachine declaration imports behavioral boundary ${sourceImport.specifier}.`));
+                    }
+                }
+                for (const { node, name } of hasForbiddenGlobalCall(file)) {
+                    evidence.push(violation(file, node, `StateMachine declaration calls effectful global ${name}.`));
+                }
+                for (const machine of machineCalls(file)) {
+                    const input = machine.call.arguments[0];
+                    if (input === undefined)
+                        continue;
+                    visit(unwrap(input), (node) => {
+                        if (node === input || ts.isObjectLiteralExpression(node))
+                            return;
+                        if (ts.isFunctionLike(node) ||
+                            ts.isAwaitExpression(node) ||
+                            ts.isNewExpression(node) ||
+                            (ts.isCallExpression(node) && node !== machine.call)) {
+                            evidence.push(violation(file, node, 'State machine relation contains executable behavior instead of finite topology.'));
+                        }
+                    });
+                }
+            }
+            return evidence;
+        },
+    },
+];
+function machineCalls(file) {
+    const calls = [];
+    visit(file.source, (node) => {
+        if (!ts.isCallExpression(node))
+            return;
+        const origin = stateMachineConstructorOrigin(file, node.expression);
+        if (origin !== 'absent') {
+            calls.push({ call: node, origin });
+        }
+    });
+    return calls;
+}
+function admitStaticRelation(file, call) {
+    const input = call.arguments[0] && unwrap(call.arguments[0]);
+    if (!input || !ts.isObjectLiteralExpression(input)) {
+        return [ambiguity(file, call, 'State machine relation is not one static object literal.')];
+    }
+    const names = input.properties.map(staticPropertyName);
+    if (names.some((name) => name === undefined) ||
+        names.length !== 2 ||
+        !names.includes('initial') ||
+        !names.includes('transitions')) {
+        return [
+            violation(file, input, 'State machine relation must contain exactly initial and transitions.'),
+        ];
+    }
+    const initial = assignedValue(input, 'initial');
+    const transitionsValue = assignedValue(input, 'transitions');
+    if (staticText(initial) === undefined) {
+        return [ambiguity(file, initial ?? input, 'State machine initial state is not static text.')];
+    }
+    if (!transitionsValue || !ts.isObjectLiteralExpression(unwrap(transitionsValue))) {
+        return [
+            ambiguity(file, transitionsValue ?? input, 'State machine transitions are not one static object literal.'),
+        ];
+    }
+    const transitions = unwrap(transitionsValue);
+    for (const state of transitions.properties) {
+        const stateName = staticPropertyName(state);
+        if (stateName === undefined ||
+            !ts.isPropertyAssignment(state) ||
+            !ts.isObjectLiteralExpression(unwrap(state.initializer))) {
+            return [
+                ambiguity(file, state, 'State machine state transitions are not statically enumerable.'),
+            ];
+        }
+        const outgoing = unwrap(state.initializer);
+        for (const transition of outgoing.properties) {
+            if (staticPropertyName(transition) === undefined ||
+                !ts.isPropertyAssignment(transition) ||
+                staticText(transition.initializer) === undefined) {
+                return [
+                    ambiguity(file, transition, `State machine transitions from ${stateName} are not statically enumerable.`),
+                ];
+            }
+        }
+    }
+    return [];
+}
+function assignedValue(object, name) {
+    const property = object.properties.find((candidate) => staticPropertyName(candidate) === name);
+    return property && ts.isPropertyAssignment(property) ? property.initializer : undefined;
+}
+function staticPropertyName(property) {
+    if (!('name' in property) || property.name === undefined)
+        return undefined;
+    if (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) {
+        return property.name.text;
+    }
+    if (ts.isComputedPropertyName(property.name))
+        return staticText(property.name.expression);
+    return undefined;
+}
+function parallelAuthorityEvidence(files, machineFile, machineCall) {
+    const vocabulary = relationVocabulary(machineCall);
+    if (vocabulary === undefined)
+        return [];
+    const evidence = [];
+    for (const file of files) {
+        const locallyExported = localExportNames(file);
+        for (const statement of file.source.statements) {
+            if (ts.isVariableStatement(statement)) {
+                const directExport = hasExportModifier(statement);
+                for (const declaration of statement.declarationList.declarations) {
+                    if (!ts.isIdentifier(declaration.name) ||
+                        declaration.initializer === undefined ||
+                        (file === machineFile && unwrap(declaration.initializer) === machineCall) ||
+                        (!directExport && !locallyExported.has(declaration.name.text))) {
+                        continue;
+                    }
+                    const duplicated = duplicatedProjection(declaration.initializer, vocabulary);
+                    if (duplicated !== undefined) {
+                        evidence.push(violation(file, declaration, `Schema module exports a separate ${duplicated}; derive it from the StateMachine at the use site.`));
+                    }
+                }
+            }
+            if (ts.isTypeAliasDeclaration(statement) &&
+                (hasExportModifier(statement) || locallyExported.has(statement.name.text)) &&
+                duplicatesClosedVocabulary(statement.type, vocabulary)) {
+                evidence.push(violation(file, statement, 'Schema module exports a separate state or event union; derive it with StateOf or EventOf.'));
+            }
+        }
+    }
+    return evidence;
+}
+function relationVocabulary(call) {
+    const input = call.arguments[0] && unwrap(call.arguments[0]);
+    if (!input || !ts.isObjectLiteralExpression(input))
+        return undefined;
+    const transitionsValue = assignedValue(input, 'transitions');
+    const transitions = transitionsValue && unwrap(transitionsValue);
+    if (!transitions || !ts.isObjectLiteralExpression(transitions))
+        return undefined;
+    const states = new Set();
+    const events = new Set();
+    const terminalStates = new Set();
+    const relationKey = staticRelationKey(transitions);
+    if (relationKey === undefined)
+        return undefined;
+    for (const property of transitions.properties) {
+        const state = staticPropertyName(property);
+        if (state === undefined ||
+            !ts.isPropertyAssignment(property) ||
+            !ts.isObjectLiteralExpression(unwrap(property.initializer))) {
+            return undefined;
+        }
+        states.add(state);
+        const outgoing = unwrap(property.initializer);
+        if (outgoing.properties.length === 0)
+            terminalStates.add(state);
+        for (const transition of outgoing.properties) {
+            const event = staticPropertyName(transition);
+            if (event === undefined)
+                return undefined;
+            events.add(event);
+        }
+    }
+    return { states, events, terminalStates, relationKey };
+}
+function duplicatedProjection(expression, vocabulary) {
+    const value = unwrap(expression);
+    if (ts.isPropertyAccessExpression(value) &&
+        ['initial', 'states', 'terminalStates', 'transitions'].includes(value.name.text)) {
+        return `${value.name.text} StateMachine projection`;
+    }
+    if (ts.isStringLiteral(value) && vocabulary.states.has(value.text)) {
+        return 'initial-state constant';
+    }
+    if (ts.isObjectLiteralExpression(value) && staticRelationKey(value) === vocabulary.relationKey) {
+        return 'transition relation';
+    }
+    if (!ts.isArrayLiteralExpression(value))
+        return undefined;
+    const strings = value.elements.map((element) => ts.isSpreadElement(element) ? undefined : staticText(element));
+    if (strings.length === 0 || strings.some((item) => item === undefined))
+        return undefined;
+    const actual = new Set(strings);
+    if (setEquals(actual, vocabulary.states))
+        return 'state list';
+    if (setEquals(actual, vocabulary.terminalStates))
+        return 'terminal-state list';
+    if (setEquals(actual, vocabulary.events))
+        return 'event list';
+    return undefined;
+}
+function staticRelationKey(object) {
+    const relation = [];
+    for (const property of object.properties) {
+        const state = staticPropertyName(property);
+        if (state === undefined ||
+            !ts.isPropertyAssignment(property) ||
+            !ts.isObjectLiteralExpression(unwrap(property.initializer))) {
+            return undefined;
+        }
+        const outgoing = [];
+        for (const transition of unwrap(property.initializer)
+            .properties) {
+            const event = staticPropertyName(transition);
+            if (event === undefined || !ts.isPropertyAssignment(transition))
+                return undefined;
+            const target = staticText(transition.initializer);
+            if (target === undefined)
+                return undefined;
+            outgoing.push([event, target]);
+        }
+        relation.push([state, outgoing.sort(([left], [right]) => left.localeCompare(right))]);
+    }
+    relation.sort(([left], [right]) => left.localeCompare(right));
+    return JSON.stringify(relation);
+}
+function duplicatesClosedVocabulary(type, vocabulary) {
+    const members = ts.isUnionTypeNode(type) ? type.types : [type];
+    const values = members.map((member) => ts.isLiteralTypeNode(member) && ts.isStringLiteral(member.literal)
+        ? member.literal.text
+        : undefined);
+    if (values.some((value) => value === undefined))
+        return false;
+    const actual = new Set(values);
+    return setEquals(actual, vocabulary.states) || setEquals(actual, vocabulary.events);
+}
+function setEquals(left, right) {
+    return left.size === right.size && [...left].every((value) => right.has(value));
+}
+function localExportNames(file) {
+    const names = new Set();
+    for (const statement of file.source.statements) {
+        if (!ts.isExportDeclaration(statement) ||
+            statement.moduleSpecifier ||
+            !statement.exportClause ||
+            !ts.isNamedExports(statement.exportClause)) {
+            continue;
+        }
+        for (const element of statement.exportClause.elements) {
+            names.add(element.propertyName?.text ?? element.name.text);
+        }
+    }
+    return names;
+}
+function hasExportModifier(node) {
+    return (ts
+        .getModifiers(node)
+        ?.some(({ kind }) => kind === ts.SyntaxKind.ExportKeyword) === true);
+}

package/dist/tooling/linter/implementations/source/tests.d.ts

@@ -0,0 +1,2 @@
+import type { SourceRuleVerifier } from './verifier.js';
+export declare const testRules: readonly SourceRuleVerifier[];

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

@@ -0,0 +1,35 @@
+import { production, violation } from './shared.js';
+export const testRules = [
+    {
+        id: 'TST-COLOCATED',
+        ruleRevision: 'be48ff455304d184c5691a3f14877ead47404226ba22d0a44e9df5f1b65ff3dc',
+        evaluate(project) {
+            const evidence = [];
+            const owners = new Map();
+            for (const file of production(project)) {
+                if (file.layer && file.layer !== 'tests' && file.submodule) {
+                    const sourcePath = project.policy.layers.find(({ id }) => id === file.layer)?.sourcePath;
+                    if (sourcePath !== undefined) {
+                        owners.set(`${file.layer}\0${file.submodule}`, {
+                            file,
+                            layer: file.layer,
+                            sourcePath,
+                            submodule: file.submodule,
+                        });
+                    }
+                }
+            }
+            for (const { file, layer, sourcePath, submodule } of owners.values()) {
+                const physicalOwner = `${sourcePath}${submodule}`;
+                const hasFocusedEvidence = project.files.some((candidate) => candidate.layer === layer &&
+                    candidate.submodule === submodule &&
+                    candidate.role === 'focused-test' &&
+                    candidate.path.startsWith(`${physicalOwner}/__tests__/`));
+                if (!hasFocusedEvidence) {
+                    evidence.push(violation(file, file.source, `Semantic submodule ${physicalOwner} has no local __tests__ evidence.`));
+                }
+            }
+            return evidence;
+        },
+    },
+];

package/dist/tooling/linter/implementations/source/ui.d.ts

@@ -0,0 +1,2 @@
+import type { SourceRuleVerifier } from './verifier.js';
+export declare const uiRules: readonly SourceRuleVerifier[];

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

@@ -0,0 +1,20 @@
+import { resolveProjectImport } from '../../adapters/typescript/index.js';
+import { isForeignDomain, production, violation } from './shared.js';
+export const uiRules = [
+    {
+        id: 'UI-NO-DOMAIN',
+        ruleRevision: '042a25c0aaa76576e6c9b4f9f4f1cc9b08fe5860b9d77a3e5cc64be0f121214c',
+        evaluate(project) {
+            const evidence = [];
+            for (const file of production(project, 'ui')) {
+                for (const sourceImport of file.imports) {
+                    const target = resolveProjectImport(project, file, sourceImport.specifier);
+                    if ((target?.layer && target.layer !== 'ui') || isForeignDomain(sourceImport.specifier)) {
+                        evidence.push(violation(file, sourceImport.node, `UI imports Domain dependency ${sourceImport.specifier}.`));
+                    }
+                }
+            }
+            return evidence;
+        },
+    },
+];

package/dist/tooling/linter/implementations/source/utility-rules.d.ts

@@ -0,0 +1,2 @@
+import type { SourceRuleVerifier } from './verifier.js';
+export declare const utilRules: readonly SourceRuleVerifier[];

package/dist/tooling/linter/implementations/source/utility-rules.js

@@ -0,0 +1,28 @@
+import { resolveProjectImport } from '../../adapters/typescript/index.js';
+import { production, violation } from './shared.js';
+export const utilRules = [
+    {
+        id: 'UTL-PUBLIC-DEPS',
+        ruleRevision: 'b64df16bd3b7d9a03142f4f651a29b4785ae64ab7d0ff8a5868a8fb82df9dc1a',
+        evaluate(project) {
+            const evidence = [];
+            for (const file of production(project, 'utils')) {
+                for (const sourceImport of file.imports) {
+                    const target = resolveProjectImport(project, file, sourceImport.specifier);
+                    if (target?.layer && target.layer !== 'utils') {
+                        evidence.push(violation(file, sourceImport.node, `Utils imports Domain layer ${target.layer}.`));
+                    }
+                    if (sourceImport.specifier.startsWith('@astrale-os/sdk/src/') ||
+                        sourceImport.specifier.startsWith('@astrale-os/kernel-core/src/') ||
+                        sourceImport.specifier.startsWith('@astrale-os/kernel-dsl/src/')) {
+                        evidence.push(violation(file, sourceImport.node, `Utils deep-imports private package path ${sourceImport.specifier}.`));
+                    }
+                    if (sourceImport.specifier.startsWith('@astrale-domains/')) {
+                        evidence.push(violation(file, sourceImport.node, `Utils imports foreign Domain ${sourceImport.specifier}.`));
+                    }
+                }
+            }
+            return evidence;
+        },
+    },
+];

package/dist/tooling/linter/implementations/source/verifier.d.ts

@@ -0,0 +1,16 @@
+import type { SourceProject } from '../../adapters/typescript/index.js';
+import type { AmbiguityReason, DiagnosticLocation } from '../../diagnostics/index.js';
+import type { RuleDecision, RuleImplementation } from '../../evaluation/index.js';
+export interface SourceRuleEvidence {
+    readonly kind: 'violation' | 'ambiguity';
+    readonly evidence: string;
+    readonly ambiguityReason?: AmbiguityReason;
+    readonly location?: DiagnosticLocation;
+}
+export interface SourceRuleVerifier {
+    readonly id: string;
+    readonly ruleRevision: string;
+    evaluate(project: SourceProject): readonly SourceRuleEvidence[];
+}
+export declare function sourceImplementation(verifier: SourceRuleVerifier): RuleImplementation<SourceProject>;
+export declare function sourceEvidence(decision: RuleDecision): readonly SourceRuleEvidence[];

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

@@ -0,0 +1,52 @@
+import { requirementsFor } from '../../requirements/index.js';
+const SOURCE_IMPLEMENTATION = Object.freeze({
+    id: 'astrale.sdk.typescript-source',
+    version: '1',
+});
+export function sourceImplementation(verifier) {
+    const requirements = requirementsFor(verifier.id);
+    if (!requirements)
+        throw new TypeError(`Source verifier ${verifier.id} has no requirements.`);
+    return Object.freeze({
+        ruleId: verifier.id,
+        ruleRevision: verifier.ruleRevision,
+        requiredFacts: requirements.facts,
+        implementation: SOURCE_IMPLEMENTATION,
+        evaluate(project) {
+            const evidence = verifier.evaluate(project);
+            if (evidence.length === 0)
+                return Object.freeze({ status: 'pass' });
+            const findings = evidence.map(toFinding);
+            return Object.freeze({
+                status: findings.some(({ kind }) => kind === 'fail') ? 'fail' : 'indeterminate',
+                findings: Object.freeze(findings),
+            });
+        },
+    });
+}
+export function sourceEvidence(decision) {
+    switch (decision.status) {
+        case 'pass':
+        case 'not-applicable':
+            return [];
+        case 'error':
+            throw new TypeError(decision.evidence);
+        case 'fail':
+        case 'indeterminate':
+            break;
+    }
+    return Object.freeze(decision.findings.map((finding) => Object.freeze({
+        kind: finding.kind === 'fail' ? 'violation' : 'ambiguity',
+        evidence: finding.evidence,
+        ...(finding.ambiguityReason ? { ambiguityReason: finding.ambiguityReason } : {}),
+        ...(finding.location ? { location: finding.location } : {}),
+    })));
+}
+function toFinding(evidence) {
+    return Object.freeze({
+        kind: evidence.kind === 'violation' ? 'fail' : 'indeterminate',
+        evidence: evidence.evidence,
+        ...(evidence.ambiguityReason ? { ambiguityReason: evidence.ambiguityReason } : {}),
+        ...(evidence.location ? { location: evidence.location } : {}),
+    });
+}

package/dist/tooling/linter/implementations/source/verifiers.d.ts

@@ -0,0 +1,2 @@
+import type { SourceRuleVerifier } from './verifier.js';
+export declare const sourceRuleVerifiers: readonly SourceRuleVerifier[];

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

@@ -0,0 +1,34 @@
+import { actionRules } from './actions.js';
+import { dependencyRules } from './dependencies.js';
+import { globalRules } from './global.js';
+import { integrationRules } from './integrations.js';
+import { migrationRules } from './migrations.js';
+import { mutationRules } from './mutations.js';
+import { providerRules } from './providers.js';
+import { queryRules } from './queries.js';
+import { pureRuleRules } from './rules.js';
+import { schemaRules } from './schema.js';
+import { stateRules } from './states.js';
+import { testRules } from './tests.js';
+import { uiRules } from './ui.js';
+import { utilRules } from './utility-rules.js';
+import { viewRules } from './views.js';
+import { workflowRules } from './workflows.js';
+export const sourceRuleVerifiers = Object.freeze([
+    ...globalRules,
+    ...schemaRules,
+    ...stateRules,
+    ...pureRuleRules,
+    ...queryRules,
+    ...mutationRules,
+    ...workflowRules,
+    ...dependencyRules,
+    ...migrationRules,
+    ...integrationRules,
+    ...actionRules,
+    ...providerRules,
+    ...viewRules,
+    ...uiRules,
+    ...utilRules,
+    ...testRules,
+]);

package/dist/tooling/linter/implementations/source/views.d.ts

@@ -0,0 +1,2 @@
+import type { SourceRuleVerifier } from './verifier.js';
+export declare const viewRules: readonly SourceRuleVerifier[];

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

@@ -0,0 +1,57 @@
+import { DSL_MODULES, definitionOriginAmbiguity, definitionObjects, production, violation, } from './shared.js';
+const DECLARATIONS = [
+    'defineSchema',
+    'defineClass',
+    'edgeClass',
+    'func',
+    'nodeClass',
+    'policy',
+    'property',
+    'view',
+];
+const FRONTEND_MODULES = new Set([
+    '@astrale-os/sdk',
+    '@astrale-os/sdk/application',
+    '@astrale-os/sdk/view',
+]);
+export const viewRules = [
+    {
+        id: 'VIW-SCHEMA-DECL',
+        ruleRevision: '524ca0956e1ca5ecfd0010f2973075ef9844eb3b4ccf1771d1b784508292f906',
+        evaluate(project) {
+            const evidence = [];
+            for (const file of production(project, 'views')) {
+                for (const name of DECLARATIONS) {
+                    for (const definition of definitionObjects(file, name, undefined, DSL_MODULES)) {
+                        const uncertain = definitionOriginAmbiguity(file, definition, `${name} declaration`);
+                        if (uncertain) {
+                            evidence.push(uncertain);
+                            continue;
+                        }
+                        const { call } = definition;
+                        evidence.push(violation(file, call, `Views declares DSL construct ${name}; Schema owns it.`));
+                    }
+                }
+            }
+            return evidence;
+        },
+    },
+    {
+        id: 'VIW-NO-COMPOSE',
+        ruleRevision: '7c1ec262addbd460059e345ab388bf3dcff429618e5d3b1f618a7b0ae4b12d80',
+        evaluate(project) {
+            const evidence = [];
+            for (const file of production(project, 'views')) {
+                for (const definition of definitionObjects(file, 'defineFrontend', undefined, FRONTEND_MODULES)) {
+                    const uncertain = definitionOriginAmbiguity(file, definition, 'defineFrontend composition');
+                    if (uncertain) {
+                        evidence.push(uncertain);
+                        continue;
+                    }
+                    evidence.push(violation(file, definition.call, 'Views composes an SDK frontend; move defineFrontend beside defineApplication in application.ts.'));
+                }
+            }
+            return evidence;
+        },
+    },
+];

package/dist/tooling/linter/implementations/source/workflows.d.ts

@@ -0,0 +1,2 @@
+import type { SourceRuleVerifier } from './verifier.js';
+export declare const workflowRules: readonly SourceRuleVerifier[];