@astrale-os/sdk 0.6.0-beta.4 → 0.6.0-beta.41

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

@@ -1,11 +1,11 @@
 import ts from 'typescript';
 import { propertyChain, resolveImportedSymbol, unwrap, visit, } from '../../adapters/typescript/index.js';
-import { applicationFunctionRequirements, callableReference, callableSelector, declaredDomainDependencies, remoteCallableKey, } from './callable-requirements.js';
-import { ambiguity, calls, isForeignDomain, production, violation } from './shared.js';
+import { domainFunctionRequirements, callableReference, callableSelector, declaredDomainDependencies, remoteCallableKey, } from './callable-requirements.js';
+import { ambiguity, calls, contextPath, isForeignDomain, production, violation } from './shared.js';
 export const dependencyRules = [
     {
         id: 'FNC-XDOM-DECLARED',
-        ruleRevision: '269e22202a0fbec5ec4afc3579ca504eed457f44046b99e64a38d08634294909',
+        ruleRevision: '72f960f87ac682695ea495925e31d15b9bd640b25d90ac1dcc6a1329a0be51b0',
         evaluate(project) {
             const evidence = [];
             for (const file of production(project, 'functions')) {
@@ -19,15 +19,15 @@ export const dependencyRules = [
     },
     {
         id: 'FNC-XDOM-REQ',
-        ruleRevision: 'a646c9931bb8b5a011a2cf7431f362fcb0e63be49dfc4c1bc0eba77a8aca8fdb',
+        ruleRevision: 'a4666ebb09b2027983edc2ffc6411692ade9877ee9c4f23c4b0a8d157a0cf385',
         evaluate(project) {
             const { targets, evidence } = observeInvocations(project);
-            const declared = applicationFunctionRequirements(project);
+            const declared = domainFunctionRequirements(project);
             const results = evidence.filter(({ kind }) => kind === 'ambiguity');
             for (const target of targets) {
                 if (declared.keys.has(remoteCallableKey(target)))
                     continue;
-                results.push((declared.indeterminate ? ambiguity : violation)(target.file, target.node, `Remote Domain callable ${target.module} ${target.selector.join('.')} lacks one provable exact Application Function requirement.`));
+                results.push((declared.indeterminate ? ambiguity : violation)(target.file, target.node, `Remote Domain callable ${target.module} ${target.selector.join('.')} lacks one provable exact Domain Function requirement.`));
             }
             return results;
         },
@@ -70,16 +70,18 @@ function observeInvocations(project) {
                 let alias;
                 let selector;
                 if (path[0] === 'dependencies') {
-                    if (path.length !== 4 || !['caller', 'self', 'union'].includes(path[2])) {
-                        evidence.push(violation(file, node, 'Dependency invocation requires one direct alias and one explicit caller, self, or union authority.'));
+                    if (path.length !== 4 || !['caller', 'self'].includes(path[2])) {
+                        evidence.push(violation(file, node, 'Dependency invocation requires one direct alias and one explicit caller or self authority.'));
                         return;
                     }
                     alias = path[1];
                     selector = selectedCallable(node.arguments[0]);
                 }
-                else if (path[0] === 'kernel' &&
-                    (path.length === 2 ||
-                        (path.length === 3 && ['caller', 'self', 'union'].includes(path[1])))) {
+                else if (path[0] === 'kernel') {
+                    if (path.length !== 2 && (path.length !== 3 || !['caller', 'self'].includes(path[1]))) {
+                        evidence.push(violation(file, node, 'Kernel invocation requires the default, caller, or self authority.'));
+                        return;
+                    }
                     const argument = node.arguments[0];
                     if (!argument) {
                         evidence.push(violation(file, node, 'Kernel invocation requires one canonical typed reference.'));
@@ -156,64 +158,3 @@ function selectedCallable(input) {
     const chain = expression && propertyChain(expression);
     return chain && chain[0] === parameter.text ? chain.slice(1) : undefined;
 }
-/** Resolve handler context bindings and one immutable local alias without following arbitrary helpers. */
-function contextPath(input, run, aliases = 1) {
-    const expression = unwrap(input);
-    if (ts.isPropertyAccessExpression(expression)) {
-        const base = contextPath(expression.expression, run, aliases);
-        return base && [...base, expression.name.text];
-    }
-    if (ts.isElementAccessExpression(expression)) {
-        const base = contextPath(expression.expression, run, aliases);
-        return base && [...base, '[computed]'];
-    }
-    if (!ts.isIdentifier(expression))
-        return undefined;
-    let current = expression.parent;
-    while (current) {
-        if (ts.isFunctionLike(current)) {
-            for (const parameter of current.parameters) {
-                const path = bindingPath(parameter.name, expression.text);
-                if (path)
-                    return current === run && parameter === run.parameters[0] ? path : undefined;
-            }
-        }
-        if (ts.isBlock(current) || ts.isSourceFile(current)) {
-            for (const statement of current.statements) {
-                if (ts.isFunctionDeclaration(statement) && statement.name?.text === expression.text)
-                    return undefined;
-                if (!ts.isVariableStatement(statement))
-                    continue;
-                for (const declaration of statement.declarationList.declarations) {
-                    const path = bindingPath(declaration.name, expression.text);
-                    if (!path)
-                        continue;
-                    if (aliases === 0 ||
-                        !declaration.initializer ||
-                        declaration.end > expression.pos ||
-                        !(statement.declarationList.flags & ts.NodeFlags.Const))
-                        return undefined;
-                    const base = contextPath(declaration.initializer, run, aliases - 1);
-                    return base && [...base, ...path];
-                }
-            }
-        }
-        current = current.parent;
-    }
-    return undefined;
-}
-function bindingPath(name, identifier) {
-    if (ts.isIdentifier(name))
-        return name.text === identifier ? [] : undefined;
-    if (!ts.isObjectBindingPattern(name))
-        return undefined;
-    for (const element of name.elements) {
-        if (element.dotDotDotToken)
-            continue;
-        const nested = bindingPath(element.name, identifier);
-        const property = element.propertyName ?? (ts.isIdentifier(element.name) ? element.name : undefined);
-        if (nested && property && (ts.isIdentifier(property) || ts.isStringLiteral(property)))
-            return [property.text, ...nested];
-    }
-    return undefined;
-}

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

@@ -506,7 +506,6 @@ export const globalRules = [
                 { layer: 'queries', name: 'defineQuery', members: [undefined] },
                 { layer: 'queries', name: 'defineCompositeQuery', members: [undefined] },
                 { layer: 'mutations', name: 'defineMutation', members: [undefined] },
-                { layer: 'migrations', name: 'defineMigration', members: [undefined] },
             ];
             for (const definition of definitions) {
                 for (const file of production(project, definition.layer)) {
@@ -887,7 +886,7 @@ function isDomainDefinitionCall(file, call) {
     const expression = unwrap(call.expression);
     const direct = importedSymbol(file, expression);
     if (direct?.module.startsWith('@astrale-os/sdk') &&
-        (direct.name === 'defineApplication' ||
+        (direct.name === 'defineDomain' ||
             direct.name === 'defineFrontend' ||
             direct.name === 'defineRuntime' ||
             direct.name === 'requirements')) {

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

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 import { isLocalAlias } from '../../../../platform/graph/alias.js';
-import { expressionType, importedSymbol, propertyChain, staticText, unwrap, visit, } from '../../adapters/typescript/index.js';
+import { expressionType, importedSymbol, propertyChain, staticText, unwrap, visit, visitOwnBody, } from '../../adapters/typescript/index.js';
 import { ambiguity, callback, calls, DSL_MODULES, definitionOriginAmbiguity, definitionObjects, domainProjectorEvidence, forbiddenIoImport, hasForbiddenGlobalCall, production, violation, } from './shared.js';
 import { stateMachineIdentity, statePropertyIdentity } from './state-machine.js';
 const FORBIDDEN_LAYERS = new Set(['integrations', 'functions', 'providers', 'queries']);
@@ -8,7 +8,7 @@ const FORBIDDEN_CALLS = new Set(['invoke', 'query', 'retry', 'run', 'submit']);
 export const mutationRules = [
     {
         id: 'MUT-PLAN-REQ',
-        ruleRevision: '9201a4e5799f62cc8df37d281d1f02516132632e33b4a82187c399780bdfe340',
+        ruleRevision: '73f37ffa6b2fa4a1f236749696404d6b1fb399f1ea0e3947d8ac4df7073b3ceb',
         evaluate(project) {
             const evidence = [];
             const targets = [];
@@ -30,7 +30,7 @@ export const mutationRules = [
                         targets.push({ file, node: selectedClass, ...target, operation: classOperation });
                     }
                     else if (selectedClass && expressionSelectsDependency(selectedClass)) {
-                        evidence.push(ambiguity(file, selectedClass, 'Mutation plan selects a foreign Class dynamically, so its Application requirement cannot be proven.'));
+                        evidence.push(ambiguity(file, selectedClass, 'Mutation plan selects a foreign Class dynamically, so its Domain requirement cannot be proven.'));
                     }
                 });
             }
@@ -46,21 +46,21 @@ export const mutationRules = [
             }
             if (targets.length === 0 && identityCalls.length === 0)
                 return evidence;
-            const requirements = applicationPlanRequirements(project);
+            const requirements = domainPlanRequirements(project);
             for (const target of targets) {
                 const key = classRequirementKey(target.dependency, target.className, target.operation);
                 if (requirements.classes.has(key))
                     continue;
                 evidence.push(requirements.indeterminate
-                    ? ambiguity(target.file, target.node, `Application Class requirements are opaque for dependency ${target.dependency} Class ${target.className}.`)
-                    : violation(target.file, target.node, `Mutation plan dependency ${target.dependency} Class ${target.className} lacks Application ${target.operation} authority.`));
+                    ? ambiguity(target.file, target.node, `Domain Class requirements are opaque for dependency ${target.dependency} Class ${target.className}.`)
+                    : violation(target.file, target.node, `Mutation plan dependency ${target.dependency} Class ${target.className} lacks Domain ${target.operation} authority.`));
             }
             for (const invocation of identityCalls) {
                 if (!requirements.functions.has(invocation.syscall)) {
                     const name = invocation.syscall === 'register' ? 'Register' : 'Provision';
                     evidence.push(requirements.indeterminate
-                        ? ambiguity(invocation.file, invocation.node, `Application Function requirements are opaque for Kernel ${name}.`)
-                        : violation(invocation.file, invocation.node, `Kernel ${name} invocation lacks the exact Application Function requirement.`));
+                        ? ambiguity(invocation.file, invocation.node, `Domain Function requirements are opaque for Kernel ${name}.`)
+                        : violation(invocation.file, invocation.node, `Kernel ${name} invocation lacks the exact Domain Function requirement.`));
                 }
             }
             return evidence;
@@ -748,24 +748,24 @@ function parameterProperty(use, sourceName) {
     const property = element.propertyName ?? element.name;
     return (ts.isIdentifier(property) || ts.isStringLiteral(property)) && property.text === sourceName;
 }
-function applicationPlanRequirements(project) {
-    const applicationPath = project.policy.rootFiles.find(({ id }) => id === 'application')?.sourcePath;
-    const file = applicationPath && project.filesByPath.get(applicationPath);
+function domainPlanRequirements(project) {
+    const domainPath = project.policy.rootFiles.find(({ id }) => id === 'domain')?.sourcePath;
+    const file = domainPath && project.filesByPath.get(domainPath);
     if (!file)
         return emptyPlanRequirements(true);
-    const applications = [];
+    const definitions = [];
     visit(file.source, (node) => {
         if (!ts.isCallExpression(node))
             return;
         const symbol = importedSymbol(file, node.expression);
-        if (symbol?.name === 'defineApplication' &&
-            (symbol.module === '@astrale-os/sdk' || symbol.module === '@astrale-os/sdk/application')) {
-            applications.push(node);
+        if (symbol?.name === 'defineDomain' &&
+            (symbol.module === '@astrale-os/sdk' || symbol.module === '@astrale-os/sdk/domain')) {
+            definitions.push(node);
         }
     });
-    if (applications.length !== 1)
+    if (definitions.length !== 1)
         return emptyPlanRequirements(true);
-    const input = staticObject(applications[0].arguments[0]);
+    const input = staticObject(definitions[0].arguments[0]);
     const requirementValue = input && assignedValue(input, 'requirements');
     if (requirementValue === undefined)
         return emptyPlanRequirements(false);
@@ -774,7 +774,7 @@ function applicationPlanRequirements(project) {
     if (!requirementCall ||
         requirementSymbol?.name !== 'requirements' ||
         (requirementSymbol.module !== '@astrale-os/sdk' &&
-            requirementSymbol.module !== '@astrale-os/sdk/application')) {
+            requirementSymbol.module !== '@astrale-os/sdk/domain')) {
         return emptyPlanRequirements(true);
     }
     const definition = staticObject(requirementCall.arguments[0]);
@@ -1399,17 +1399,6 @@ function referencesIdentifier(arguments_, name) {
     }
     return found;
 }
-function visitOwnBody(fn, callback) {
-    if (!fn.body)
-        return;
-    const walk = (node) => {
-        callback(node);
-        if (node !== fn.body && ts.isFunctionLike(node))
-            return;
-        node.forEachChild(walk);
-    };
-    walk(fn.body);
-}
 function returnedValues(fn) {
     if (!fn.body)
         return 0;

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

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 import { propertyChain, resolveImportedSymbol, resolveProjectImport, unwrap, visit, } from '../../adapters/typescript/index.js';
-import { applicationFunctionRequirements, callableReference, callableSelector, externalFacade, lexicalConstInitializer, remoteCallableKey, } from './callable-requirements.js';
+import { domainFunctionRequirements, callableReference, callableSelector, externalFacade, lexicalConstInitializer, remoteCallableKey, } from './callable-requirements.js';
 import { ambiguity, production, violation } from './shared.js';
 const LOCAL_DOMAIN_LAYERS = new Set([
     'functions',
@@ -54,7 +54,7 @@ export const providerRules = [
     },
     {
         id: 'PRV-XDOM-REQ',
-        ruleRevision: '065816fda57910e917670ed657cf45b1ad3bfdc8fba6362f48123221725e20a0',
+        ruleRevision: 'b3fc6c409374b924b1b06c17f6d3702ec9d1e9e7a286bd955a151d0bf12c5b24',
         evaluate(project) {
             const targets = [];
             const evidence = [];
@@ -71,14 +71,14 @@ export const providerRules = [
             }
             if (targets.length === 0)
                 return evidence;
-            const declared = applicationFunctionRequirements(project);
+            const declared = domainFunctionRequirements(project);
             for (const target of targets) {
                 if (declared.keys.has(remoteCallableKey(target)))
                     continue;
                 const selector = target.selector.join('.');
                 evidence.push(declared.indeterminate
-                    ? ambiguity(target.file, target.node, `Application Function requirements are opaque for ${target.module} ${selector}.`)
-                    : violation(target.file, target.node, `Remote Domain callable ${target.module} ${selector} lacks one exact Application Function requirement.`));
+                    ? ambiguity(target.file, target.node, `Domain Function requirements are opaque for ${target.module} ${selector}.`)
+                    : violation(target.file, target.node, `Remote Domain callable ${target.module} ${selector} lacks one exact Domain Function requirement.`));
             }
             return evidence;
         },

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

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { importedSymbol, observeQueryDefinitions, propertyChain, queryCollectionKind, unwrap, visit, } from '../../adapters/typescript/index.js';
+import { bindingContains, importedSymbol, observeQueryDefinitions, propertyChain, queryCollectionKind, unwrap, visit, visitOwnBody, } from '../../adapters/typescript/index.js';
 import { decideCanonicalQuery, decideSingleQuery } from '../../analysis/query/index.js';
 import { ambiguity, callback, definitionOriginAmbiguity, definitionObjects, domainProjectorEvidence, propertyExpression, production, returnedExpressions, staticId, violation, } from './shared.js';
 import { sourceEvidence } from './verifier.js';
@@ -1130,22 +1130,6 @@ function enclosingFunction(node) {
         current = current.parent;
     return current;
 }
-function bindingContains(binding, name) {
-    if (ts.isIdentifier(binding))
-        return binding.text === name;
-    return binding.elements.some((element) => !ts.isOmittedExpression(element) && bindingContains(element.name, name));
-}
-function visitOwnBody(fn, callback) {
-    if (!fn.body)
-        return;
-    const walk = (node) => {
-        callback(node);
-        if (node !== fn.body && ts.isFunctionLike(node))
-            return;
-        node.forEachChild(walk);
-    };
-    walk(fn.body);
-}
 function isCompositeLeaf(expression, file) {
     if (!expression || !ts.isIdentifier(unwrap(expression)))
         return false;

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

@@ -25,20 +25,28 @@ export declare function domainProjectorEvidence(file: SourceFile, importedName:
 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;
 }>;
+/** The global a call reaches, as `name(…)` with no import or local binding, or `globalThis.name(…)`. */
+export declare function globalCallName(file: SourceFile, node: ts.CallExpression): string | undefined;
+/**
+ * The member path an expression reads from a global: `Date.now` when no import or local binding
+ * names `Date`, the same through `globalThis.Date.now`.
+ */
+export declare function globalPath(file: SourceFile, input: ts.Expression): readonly string[] | undefined;
+/**
+ * Resolve the path of `input` from the first parameter of `run`, or of a durable Step callback in
+ * it, through one immutable local alias, without following arbitrary helpers.
+ */
+export declare function contextPath(input: ts.Expression, run: ts.FunctionLikeDeclaration, aliases?: number): readonly string[] | undefined;
 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

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { importedSymbol, location, objectProperty, propertyChain, resolveImportedSymbol, resolveProjectImport, staticText, unwrap, visit, } from '../../adapters/typescript/index.js';
+import { bindingContains, 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',
@@ -159,9 +159,6 @@ export function ambiguity(file, node, evidence) {
 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;
@@ -209,14 +206,6 @@ export function returnedExpressions(fn) {
     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);
 }
@@ -226,22 +215,109 @@ export function hasForbiddenGlobalCall(file) {
     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 });
+        const name = globalCallName(file, node);
+        if (name !== undefined && forbidden.has(name))
+            result.push({ node, name });
+    });
+    return result;
+}
+/** The global a call reaches, as `name(…)` with no import or local binding, or `globalThis.name(…)`. */
+export function globalCallName(file, node) {
+    const path = globalPath(file, node.expression);
+    return path?.length === 1 ? path[0] : undefined;
+}
+/**
+ * The member path an expression reads from a global: `Date.now` when no import or local binding
+ * names `Date`, the same through `globalThis.Date.now`.
+ */
+export function globalPath(file, input) {
+    const expression = unwrap(input);
+    const chain = propertyChain(expression);
+    if (!chain)
+        return undefined;
+    let root = expression;
+    while (ts.isPropertyAccessExpression(root))
+        root = unwrap(root.expression);
+    if (!ts.isIdentifier(root) || isLocallyBound(root, root.text))
+        return undefined;
+    if (chain[0] === 'globalThis')
+        return chain.length > 1 ? chain.slice(1) : undefined;
+    return importedSymbol(file, root) ? undefined : chain;
+}
+/**
+ * Resolve the path of `input` from the first parameter of `run`, or of a durable Step callback in
+ * it, through one immutable local alias, without following arbitrary helpers.
+ */
+export function contextPath(input, run, aliases = 1) {
+    const expression = unwrap(input);
+    if (ts.isPropertyAccessExpression(expression)) {
+        const base = contextPath(expression.expression, run, aliases);
+        return base && [...base, expression.name.text];
+    }
+    if (ts.isElementAccessExpression(expression)) {
+        const base = contextPath(expression.expression, run, aliases);
+        return base && [...base, '[computed]'];
+    }
+    if (!ts.isIdentifier(expression))
+        return undefined;
+    let current = expression.parent;
+    while (current) {
+        if (ts.isFunctionLike(current)) {
+            for (const parameter of current.parameters) {
+                const path = bindingPath(parameter.name, expression.text);
+                if (path)
+                    return parameter === current.parameters[0] &&
+                        (current === run || stepCallback(current, run))
+                        ? path
+                        : undefined;
             }
-            return;
         }
-        const chain = propertyChain(expression);
-        if (chain?.length === 2 && chain[0] === 'globalThis' && forbidden.has(chain[1])) {
-            result.push({ node, name: chain[1] });
+        if (ts.isBlock(current) || ts.isSourceFile(current)) {
+            for (const statement of current.statements) {
+                if (ts.isFunctionDeclaration(statement) && statement.name?.text === expression.text)
+                    return undefined;
+                if (!ts.isVariableStatement(statement))
+                    continue;
+                for (const declaration of statement.declarationList.declarations) {
+                    const path = bindingPath(declaration.name, expression.text);
+                    if (!path)
+                        continue;
+                    if (aliases === 0 ||
+                        !declaration.initializer ||
+                        declaration.end > expression.pos ||
+                        !(statement.declarationList.flags & ts.NodeFlags.Const))
+                        return undefined;
+                    const base = contextPath(declaration.initializer, run, aliases - 1);
+                    return base && [...base, ...path];
+                }
+            }
         }
-    });
-    return result;
+        current = current.parent;
+    }
+    return undefined;
+}
+/** A durable Step callback receives the handler's capabilities under the same names. */
+function stepCallback(callback, run) {
+    const call = callback.parent;
+    if (!ts.isCallExpression(call) || call.arguments[1] !== callback)
+        return false;
+    const callee = contextPath(call.expression, run, 0);
+    return callee?.length === 2 && callee[0] === 'step' && callee[1] === 'run';
+}
+function bindingPath(name, identifier) {
+    if (ts.isIdentifier(name))
+        return name.text === identifier ? [] : undefined;
+    if (!ts.isObjectBindingPattern(name))
+        return undefined;
+    for (const element of name.elements) {
+        if (element.dotDotDotToken)
+            continue;
+        const nested = bindingPath(element.name, identifier);
+        const property = element.propertyName ?? (ts.isIdentifier(element.name) ? element.name : undefined);
+        if (nested && property && (ts.isIdentifier(property) || ts.isStringLiteral(property)))
+            return [property.text, ...nested];
+    }
+    return undefined;
 }
 export function isLocallyBoundIdentifier(node) {
     return isLocallyBound(node, node.text);
@@ -251,22 +327,6 @@ export function forbiddenIoImport(specifier) {
         !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) {
@@ -312,8 +372,3 @@ function statementDeclares(statement, 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/verifiers.js

@@ -2,7 +2,6 @@ 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';
@@ -23,7 +22,6 @@ export const sourceRuleVerifiers = Object.freeze([
     ...mutationRules,
     ...workflowRules,
     ...dependencyRules,
-    ...migrationRules,
     ...integrationRules,
     ...actionRules,
     ...providerRules,

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

@@ -11,7 +11,7 @@ const DECLARATIONS = [
 ];
 const FRONTEND_MODULES = new Set([
     '@astrale-os/sdk',
-    '@astrale-os/sdk/application',
+    '@astrale-os/sdk/domain',
     '@astrale-os/sdk/view',
 ]);
 export const viewRules = [
@@ -48,7 +48,7 @@ export const viewRules = [
                         evidence.push(uncertain);
                         continue;
                     }
-                    evidence.push(violation(file, definition.call, 'Views composes an SDK frontend; move defineFrontend beside defineApplication in application.ts.'));
+                    evidence.push(violation(file, definition.call, 'Views composes an SDK frontend; move defineFrontend beside defineDomain in domain.ts.'));
                 }
             }
             return evidence;