@astrale-os/sdk 0.5.0-beta.2 → 0.5.0-beta.21

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

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

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

@@ -0,0 +1,140 @@
+import ts from 'typescript';
+import { resolveProjectImport, unwrap, visit } from '../../adapters/typescript/index.js';
+import { ambiguity, hasForbiddenGlobalCall, isLocallyBoundIdentifier, production, violation, } from './shared.js';
+const FORBIDDEN_LAYERS = new Set([
+    'integrations',
+    'actions',
+    'providers',
+    'mutations',
+    'ui',
+    'views',
+    'workflows',
+]);
+export const pureRuleRules = [
+    {
+        id: 'RUL-SYNC',
+        ruleRevision: 'b319f50b900aa00880a19cccc0ec850fe86d6b317ffcb8dc578e7d6fac1c0548',
+        evaluate(project) {
+            const evidence = [];
+            for (const file of production(project, 'rules')) {
+                visit(file.source, (node) => {
+                    if (ts.isFunctionLike(node) && 'body' in node) {
+                        if (ts.getModifiers(node)?.some(({ kind }) => kind === ts.SyntaxKind.AsyncKeyword)) {
+                            evidence.push(violation(file, node, 'Rule function is async.'));
+                        }
+                        if ('asteriskToken' in node && node.asteriskToken) {
+                            evidence.push(violation(file, node, 'Rule function is a generator.'));
+                        }
+                        if (node.type && typeContainsPromise(node.type)) {
+                            evidence.push(violation(file, node.type, 'Rule return type is asynchronous.'));
+                        }
+                    }
+                    if (ts.isAwaitExpression(node) || (ts.isForOfStatement(node) && node.awaitModifier)) {
+                        evidence.push(violation(file, node, 'Rule contains asynchronous continuation syntax.'));
+                    }
+                    if (ts.isNewExpression(node)) {
+                        const constructor = globalPromiseConstructor(node.expression);
+                        if (constructor && !isLocallyBoundIdentifier(constructor)) {
+                            evidence.push(violation(file, node, 'Rule constructs a global Promise.'));
+                        }
+                    }
+                    if (ts.isCallExpression(node)) {
+                        const member = globalPromiseMember(node.expression);
+                        if (!member || isLocallyBoundIdentifier(member.root))
+                            return;
+                        evidence.push(member.name === undefined
+                            ? ambiguity(file, node, 'Rule invokes a computed member on the global Promise but the member name is dynamic.')
+                            : violation(file, node, `Rule invokes asynchronous global Promise.${member.name}.`));
+                    }
+                });
+            }
+            return evidence;
+        },
+    },
+    {
+        id: 'RUL-PURE',
+        ruleRevision: '34957b915d98bd69f459a9865dba400d0c10f76be15502d55175bbd71de416c4',
+        evaluate(project) {
+            const evidence = [];
+            for (const file of production(project, 'rules')) {
+                for (const sourceImport of file.imports) {
+                    const target = resolveProjectImport(project, file, sourceImport.specifier);
+                    if ((target?.layer && FORBIDDEN_LAYERS.has(target.layer)) ||
+                        (!sourceImport.typeOnly && effectBoundaryImport(sourceImport.specifier)) ||
+                        sourceImport.specifier.startsWith('@astrale-os/adapter-') ||
+                        sourceImport.specifier === '@astrale-os/kernel-client' ||
+                        sourceImport.specifier.startsWith('@astrale-os/kernel-client/')) {
+                        evidence.push(violation(file, sourceImport.node, `Rule imports effect boundary ${sourceImport.specifier}.`));
+                    }
+                }
+                for (const { node, name } of hasForbiddenGlobalCall(file)) {
+                    evidence.push(violation(file, node, `Rule calls effectful global ${name}.`));
+                }
+            }
+            return evidence;
+        },
+    },
+];
+function globalPromiseConstructor(expression) {
+    const path = accessPath(expression);
+    if (!path)
+        return undefined;
+    if (path.root.text === 'Promise' && path.members.length === 0)
+        return path.root;
+    if (path.root.text === 'globalThis' &&
+        path.members.length === 1 &&
+        path.members[0] === 'Promise') {
+        return path.root;
+    }
+    return undefined;
+}
+function globalPromiseMember(expression) {
+    const path = accessPath(expression);
+    if (!path)
+        return undefined;
+    if (path.root.text === 'Promise' && path.members.length === 1) {
+        return {
+            root: path.root,
+            ...(path.members[0] !== undefined ? { name: path.members[0] } : {}),
+        };
+    }
+    if (path.root.text === 'globalThis' &&
+        path.members.length === 2 &&
+        path.members[0] === 'Promise') {
+        return {
+            root: path.root,
+            ...(path.members[1] !== undefined ? { name: path.members[1] } : {}),
+        };
+    }
+    return undefined;
+}
+function accessPath(expression) {
+    const target = unwrap(expression);
+    if (ts.isIdentifier(target))
+        return { root: target, members: [] };
+    if (ts.isPropertyAccessExpression(target)) {
+        const owner = accessPath(target.expression);
+        return owner ? { root: owner.root, members: [...owner.members, target.name.text] } : undefined;
+    }
+    if (ts.isElementAccessExpression(target)) {
+        const owner = accessPath(target.expression);
+        if (!owner)
+            return undefined;
+        const argument = target.argumentExpression && unwrap(target.argumentExpression);
+        const name = argument && (ts.isStringLiteral(argument) || ts.isNoSubstitutionTemplateLiteral(argument))
+            ? argument.text
+            : undefined;
+        return { root: owner.root, members: [...owner.members, name] };
+    }
+    return undefined;
+}
+function typeContainsPromise(node) {
+    if (ts.isTypeReferenceNode(node)) {
+        const name = ts.isIdentifier(node.typeName) ? node.typeName.text : node.typeName.right.text;
+        return name === 'Promise' || name === 'AsyncIterable' || name === 'AsyncIterator';
+    }
+    return ts.isUnionTypeNode(node) && node.types.some(typeContainsPromise);
+}
+function effectBoundaryImport(specifier) {
+    return (/^(?:node:)?(?:child_process|cluster|dgram|dns(?:\/promises)?|fs(?:\/promises)?|http2?|https|net|os|process|readline(?:\/promises)?|repl|sqlite|timers(?:\/promises)?|tls|worker_threads)$/.test(specifier) || specifier.startsWith('@astrale-os/adapter-'));
+}

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

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

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

@@ -0,0 +1,109 @@
+import ts from 'typescript';
+import { importedSymbol, propertyChain, visit } from '../../adapters/typescript/index.js';
+import { ambiguity, forbiddenIoImport, production, violation } from './shared.js';
+const FORBIDDEN_LAYERS = new Set([
+    'integrations',
+    'actions',
+    'providers',
+    'mutations',
+    'queries',
+    'ui',
+    'views',
+    'workflows',
+]);
+const EXECUTION_NAMES = new Set([
+    'defineAction',
+    'defineMutation',
+    'defineQuery',
+    'defineWorkflow',
+    'invoke',
+    'mutate',
+    'query',
+]);
+export const schemaRules = [
+    {
+        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;
+        },
+    },
+];

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

@@ -0,0 +1,41 @@
+import ts from 'typescript';
+import type { SourceRuleEvidence } from './verifier.js';
+import { type SourceProject, type SourceFile, type SourceImport } from '../../adapters/typescript/index.js';
+export declare const SDK_MODULES: Set<string>;
+export declare const DSL_MODULES: Set<string>;
+export interface DefinitionObject {
+    readonly call: ts.CallExpression;
+    readonly object?: ts.ObjectLiteralExpression;
+    readonly origin: 'resolved' | 'ambiguous';
+}
+export declare function production(project: SourceProject, layer?: string): SourceFile[];
+export declare function calls(file: SourceFile, importedName: string, modules?: Set<string>): Array<{
+    readonly call: ts.CallExpression;
+    readonly origin: 'resolved' | 'ambiguous';
+}>;
+export declare function memberCalls(file: SourceFile, importedName: string, member: string, modules?: Set<string>): Array<{
+    readonly call: ts.CallExpression;
+    readonly origin: 'resolved' | 'ambiguous';
+}>;
+export declare function definitionObjects(file: SourceFile, importedName: string, member?: string, modules?: Set<string>, argumentIndex?: number): DefinitionObject[];
+export declare function definitionOriginAmbiguity(file: SourceFile, definition: DefinitionObject, name: string): SourceRuleEvidence | undefined;
+export declare function violation(file: SourceFile, node: ts.Node, evidence: string): SourceRuleEvidence;
+export declare function ambiguity(file: SourceFile, node: ts.Node, evidence: string): SourceRuleEvidence;
+export declare function localTarget(project: SourceProject, file: SourceFile, sourceImport: SourceImport): SourceFile | undefined;
+export declare function importedLayer(project: SourceProject, file: SourceFile, sourceImport: SourceImport): string | undefined;
+export declare function isForeignDomain(specifier: string): boolean;
+export declare function packageRoot(specifier: string): string;
+export declare function isDeepPackageImport(specifier: string): boolean;
+export declare function propertyExpression(object: ts.ObjectLiteralExpression | undefined, name: string): ts.Expression | undefined;
+export declare function callback(object: ts.ObjectLiteralExpression | undefined, name: string): ts.FunctionLikeDeclaration | undefined;
+export declare function returnedExpressions(fn: ts.FunctionLikeDeclaration): ts.Expression[];
+export declare function callChain(expression: ts.Expression): readonly string[] | undefined;
+export declare function staticId(expression: ts.Expression | undefined): string | undefined;
+export declare function hasForbiddenGlobalCall(file: SourceFile): Array<{
+    node: ts.Node;
+    name: string;
+}>;
+export declare function isLocallyBoundIdentifier(node: ts.Identifier): boolean;
+export declare function forbiddenIoImport(specifier: string): boolean;
+export declare function variableName(call: ts.CallExpression): string | undefined;
+export declare function allPropertyNames(object: ts.ObjectLiteralExpression): string[];

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

@@ -0,0 +1,238 @@
+import ts from 'typescript';
+import { importedSymbol, location, objectProperty, propertyChain, resolveImportedSymbol, resolveProjectImport, staticText, unwrap, visit, } from '../../adapters/typescript/index.js';
+export const SDK_MODULES = new Set([
+    '@astrale-os/sdk',
+    '@astrale-os/sdk/action',
+    '@astrale-os/sdk/integration',
+    '@astrale-os/sdk/query',
+    '@astrale-os/sdk/mutation',
+    '@astrale-os/sdk/state',
+    '@astrale-os/sdk/workflow',
+]);
+export const DSL_MODULES = new Set([
+    '@astrale-os/sdk/schema',
+    '@astrale-os/kernel-dsl',
+    '@astrale-os/kernel-dsl/v1',
+    '@astrale-os/kernel-core',
+]);
+export function production(project, layer) {
+    return project.files.filter((file) => file.role === 'production' && (layer === undefined || file.layer === layer));
+}
+export function calls(file, importedName, modules = SDK_MODULES) {
+    const result = [];
+    visit(file.source, (node) => {
+        if (!ts.isCallExpression(node))
+            return;
+        const symbol = resolveImportedSymbol(file, node.expression);
+        if (symbol.kind === 'resolved' && symbol.name === importedName && modules.has(symbol.module)) {
+            result.push({ call: node, origin: 'resolved' });
+        }
+        else if (symbol.kind === 'ambiguous' && symbol.name === importedName) {
+            result.push({ call: node, origin: 'ambiguous' });
+        }
+    });
+    return result;
+}
+export function memberCalls(file, importedName, member, modules = SDK_MODULES) {
+    const result = [];
+    visit(file.source, (node) => {
+        if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(unwrap(node.expression)))
+            return;
+        const expression = unwrap(node.expression);
+        if (expression.name.text !== member)
+            return;
+        const symbol = resolveImportedSymbol(file, expression.expression);
+        if (symbol.kind === 'resolved' && symbol.name === importedName && modules.has(symbol.module)) {
+            result.push({ call: node, origin: 'resolved' });
+        }
+        else if (symbol.kind === 'ambiguous' && symbol.name === importedName) {
+            result.push({ call: node, origin: 'ambiguous' });
+        }
+    });
+    return result;
+}
+export function definitionObjects(file, importedName, member, modules = SDK_MODULES, argumentIndex = 0) {
+    return (member ? memberCalls(file, importedName, member, modules) : calls(file, importedName, modules)).map(({ call, origin }) => ({
+        call,
+        origin,
+        object: objectArgumentAt(call, argumentIndex),
+    }));
+}
+export function definitionOriginAmbiguity(file, definition, name) {
+    return definition.origin === 'ambiguous'
+        ? ambiguity(file, definition.call, `${name} resolves through a local facade whose ultimate public constructor origin is unknown.`)
+        : undefined;
+}
+function objectArgumentAt(call, index) {
+    const value = call.arguments[index];
+    return value && ts.isObjectLiteralExpression(unwrap(value))
+        ? unwrap(value)
+        : undefined;
+}
+export function violation(file, node, evidence) {
+    return { kind: 'violation', evidence, location: location(file, node) };
+}
+export function ambiguity(file, node, evidence) {
+    return { kind: 'ambiguity', evidence, location: location(file, node) };
+}
+export function localTarget(project, file, sourceImport) {
+    return resolveProjectImport(project, file, sourceImport.specifier);
+}
+export function importedLayer(project, file, sourceImport) {
+    return localTarget(project, file, sourceImport)?.layer;
+}
+export function isForeignDomain(specifier) {
+    if (specifier.startsWith('@astrale-domains/'))
+        return true;
+    const root = packageRoot(specifier);
+    return /(?:^|[-/])domain$/.test(root) || root.endsWith('-domain');
+}
+export function packageRoot(specifier) {
+    if (!specifier.startsWith('@'))
+        return specifier.split('/')[0] ?? specifier;
+    return specifier.split('/').slice(0, 2).join('/');
+}
+export function isDeepPackageImport(specifier) {
+    return specifier !== packageRoot(specifier);
+}
+export function propertyExpression(object, name) {
+    const property = objectProperty(object, name);
+    if (property && ts.isPropertyAssignment(property))
+        return unwrap(property.initializer);
+    return undefined;
+}
+export function callback(object, name) {
+    const property = objectProperty(object, name);
+    if (property && ts.isMethodDeclaration(property))
+        return property;
+    if (property && ts.isPropertyAssignment(property)) {
+        const value = unwrap(property.initializer);
+        if (ts.isArrowFunction(value) || ts.isFunctionExpression(value))
+            return value;
+    }
+    return undefined;
+}
+export function returnedExpressions(fn) {
+    if (!fn.body)
+        return [];
+    if (!ts.isBlock(fn.body))
+        return [unwrap(fn.body)];
+    const expressions = [];
+    const walk = (node) => {
+        if (node !== fn && ts.isFunctionLike(node))
+            return;
+        if (ts.isReturnStatement(node) && node.expression)
+            expressions.push(unwrap(node.expression));
+        node.forEachChild(walk);
+    };
+    fn.body.forEachChild(walk);
+    return expressions;
+}
+export function callChain(expression) {
+    const target = unwrap(expression);
+    if (ts.isCallExpression(target))
+        return propertyChain(target.expression);
+    if (ts.isPropertyAccessExpression(target))
+        return propertyChain(target);
+    return undefined;
+}
+export function staticId(expression) {
+    return staticText(expression);
+}
+export function hasForbiddenGlobalCall(file) {
+    const forbidden = new Set(['fetch', 'setTimeout', 'setInterval', 'queueMicrotask']);
+    const result = [];
+    visit(file.source, (node) => {
+        if (!ts.isCallExpression(node))
+            return;
+        const expression = unwrap(node.expression);
+        if (ts.isIdentifier(expression)) {
+            const name = expression.text;
+            if (forbidden.has(name) &&
+                !importedSymbol(file, expression) &&
+                !isLocallyBound(expression, name)) {
+                result.push({ node, name });
+            }
+            return;
+        }
+        const chain = propertyChain(expression);
+        if (chain?.length === 2 && chain[0] === 'globalThis' && forbidden.has(chain[1])) {
+            result.push({ node, name: chain[1] });
+        }
+    });
+    return result;
+}
+export function isLocallyBoundIdentifier(node) {
+    return isLocallyBound(node, node.text);
+}
+export function forbiddenIoImport(specifier) {
+    return (specifier.startsWith('node:') &&
+        !specifier.startsWith('node:assert') &&
+        !specifier.startsWith('node:util/types'));
+}
+export function variableName(call) {
+    const parent = call.parent;
+    return ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)
+        ? parent.name.text
+        : undefined;
+}
+export function allPropertyNames(object) {
+    return object.properties.flatMap((property) => {
+        if (!('name' in property) || !property.name)
+            return [];
+        const name = ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)
+            ? property.name.text
+            : undefined;
+        return name ? [name] : [];
+    });
+}
+function isLocallyBound(node, name) {
+    let current = node.parent;
+    while (current) {
+        if (ts.isFunctionLike(current)) {
+            if (current.parameters.some((parameter) => bindingContains(parameter.name, name)) ||
+                ('name' in current &&
+                    current.name &&
+                    ts.isIdentifier(current.name) &&
+                    current.name.text === name)) {
+                return true;
+            }
+        }
+        if (ts.isBlock(current) || ts.isSourceFile(current)) {
+            if (current.statements.some((statement) => statementDeclares(statement, name)))
+                return true;
+        }
+        if (ts.isCatchClause(current) && current.variableDeclaration) {
+            if (bindingContains(current.variableDeclaration.name, name))
+                return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+function statementDeclares(statement, name) {
+    if (ts.isVariableStatement(statement)) {
+        return statement.declarationList.declarations.some((declaration) => bindingContains(declaration.name, name));
+    }
+    if ((ts.isFunctionDeclaration(statement) ||
+        ts.isClassDeclaration(statement) ||
+        ts.isEnumDeclaration(statement)) &&
+        statement.name?.text === name) {
+        return true;
+    }
+    if (ts.isImportDeclaration(statement) && statement.importClause) {
+        const clause = statement.importClause;
+        if (clause.name?.text === name)
+            return true;
+        const bindings = clause.namedBindings;
+        if (bindings && ts.isNamespaceImport(bindings))
+            return bindings.name.text === name;
+        return Boolean(bindings && bindings.elements.some((element) => element.name.text === name));
+    }
+    return false;
+}
+function bindingContains(binding, name) {
+    if (ts.isIdentifier(binding))
+        return binding.text === name;
+    return binding.elements.some((element) => ts.isOmittedExpression(element) ? false : bindingContains(element.name, name));
+}

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

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

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

@@ -0,0 +1 @@
+export const stateRules = [];

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,31 @@
+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}/${file.submodule}`, { file, sourcePath });
+                    }
+                }
+            }
+            for (const [owner, { file, sourcePath }] of owners) {
+                const [layer, submodule] = owner.split('/');
+                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[];