@astrale-os/sdk 0.6.0-beta.36 → 0.6.0-beta.38

package/dist/tooling/cli/log.js

@@ -1,7 +1,5 @@
 /** CLI output helpers and ANSI colours for the one project command owner. */
-export const GREEN = '\x1b[32m';
 export const DIM = '\x1b[2m';
-export const BOLD = '\x1b[1m';
 export const YELLOW = '\x1b[33m';
 export const RED = '\x1b[31m';
 export const RESET = '\x1b[0m';

package/dist/tooling/linter/adapters/typescript/imports.d.ts

@@ -3,4 +3,3 @@ import type { SourceProject, SourceDependencyIssue, SourceFile, SourceImport } f
 export declare function collectImports(source: ts.SourceFile): SourceImport[];
 export declare function collectDependencyIssues(source: ts.SourceFile): SourceDependencyIssue[];
 export declare function resolveProjectImport(project: SourceProject, importer: SourceFile, specifier: string): SourceFile | undefined;
-export declare function isWithin(directory: string, path: string): boolean;

package/dist/tooling/linter/adapters/typescript/imports.js

@@ -1,4 +1,4 @@
-import { dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
+import { dirname, extname, join, relative, resolve } from 'node:path';
 import ts from 'typescript';
 import { isLocallyDeclared } from './syntax.js';
 export function collectImports(source) {
@@ -166,7 +166,3 @@ function visit(node, callback) {
     callback(node);
     node.forEachChild((child) => visit(child, callback));
 }
-export function isWithin(directory, path) {
-    const child = relative(directory, path);
-    return child === '' || (!child.startsWith('..') && !isAbsolute(child));
-}

package/dist/tooling/linter/adapters/typescript/index.d.ts

@@ -1,7 +1,7 @@
 export { discoverProject } from './discover.js';
 export { sourceEvidenceAdmission } from './evidence-admission.js';
 export { collectDependencyIssues, resolveProjectImport } from './imports.js';
-export { importedSymbol, isLocallyDeclared, resolveImportedSymbol, location, objectProperty, propertyChain, staticText, unwrap, visit, } from './syntax.js';
+export { bindingContains, importedSymbol, isLocallyDeclared, resolveImportedSymbol, location, objectProperty, propertyChain, staticText, unwrap, visit, visitOwnBody, } from './syntax.js';
 export { assertSingleTypeUniverse } from './type-universe.js';
 export { observeQueryDefinitions } from './query-observation.js';
 export { queryCollectionKind } from './query-collection-type.js';

package/dist/tooling/linter/adapters/typescript/index.js

@@ -1,7 +1,7 @@
 export { discoverProject } from './discover.js';
 export { sourceEvidenceAdmission } from './evidence-admission.js';
 export { collectDependencyIssues, resolveProjectImport } from './imports.js';
-export { importedSymbol, isLocallyDeclared, resolveImportedSymbol, location, objectProperty, propertyChain, staticText, unwrap, visit, } from './syntax.js';
+export { bindingContains, importedSymbol, isLocallyDeclared, resolveImportedSymbol, location, objectProperty, propertyChain, staticText, unwrap, visit, visitOwnBody, } from './syntax.js';
 export { assertSingleTypeUniverse } from './type-universe.js';
 export { observeQueryDefinitions } from './query-observation.js';
 export { queryCollectionKind } from './query-collection-type.js';

package/dist/tooling/linter/adapters/typescript/syntax.d.ts

@@ -27,12 +27,12 @@ export type ImportedSymbolResolution = Readonly<{
  */
 export declare function resolveImportedSymbol(file: SourceFile, expression: ts.Expression): ImportedSymbolResolution;
 export declare function isLocallyDeclared(identifier: ts.Identifier): boolean;
+export declare function bindingContains(binding: ts.BindingName, name: string): boolean;
+/** Visit a function body, without descending into the functions nested in it. */
+export declare function visitOwnBody(fn: ts.FunctionLikeDeclaration, callback: (node: ts.Node) => void): void;
 export declare function unwrap(expression: ts.Expression): ts.Expression;
 export declare function staticText(expression: ts.Expression | undefined): string | undefined;
 export declare function objectProperty(object: ts.ObjectLiteralExpression | undefined, name: string): ts.ObjectLiteralElementLike | undefined;
 export declare function propertyName(name: ts.PropertyName): string | undefined;
-export declare function callbackOf(property: ts.ObjectLiteralElementLike | undefined): ts.FunctionLikeDeclaration | undefined;
-export declare function objectArgument(call: ts.CallExpression): ts.ObjectLiteralExpression | undefined;
-export declare function isImportedCall(file: SourceFile, node: ts.Node, modules: ReadonlySet<string>, name: string): node is ts.CallExpression;
 export declare function propertyChain(expression: ts.Expression): readonly string[] | undefined;
 export declare function containingFunction(node: ts.Node): ts.FunctionLikeDeclaration | undefined;

package/dist/tooling/linter/adapters/typescript/syntax.js

@@ -103,11 +103,23 @@ function statementDeclares(statement, name) {
     }
     return false;
 }
-function bindingContains(binding, name) {
+export function bindingContains(binding, name) {
     if (ts.isIdentifier(binding))
         return binding.text === name;
     return binding.elements.some((element) => !ts.isOmittedExpression(element) && bindingContains(element.name, name));
 }
+/** Visit a function body, without descending into the functions nested in it. */
+export 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);
+}
 export function unwrap(expression) {
     let current = expression;
     while (ts.isParenthesizedExpression(current) ||
@@ -138,30 +150,6 @@ export function propertyName(name) {
         return name.text;
     return ts.isComputedPropertyName(name) ? staticText(name.expression) : undefined;
 }
-export function callbackOf(property) {
-    if (!property)
-        return undefined;
-    if (ts.isMethodDeclaration(property))
-        return property;
-    if (ts.isPropertyAssignment(property)) {
-        const value = unwrap(property.initializer);
-        if (ts.isArrowFunction(value) || ts.isFunctionExpression(value))
-            return value;
-    }
-    return undefined;
-}
-export function objectArgument(call) {
-    const value = call.arguments[0];
-    return value && ts.isObjectLiteralExpression(unwrap(value))
-        ? unwrap(value)
-        : undefined;
-}
-export function isImportedCall(file, node, modules, name) {
-    if (!ts.isCallExpression(node))
-        return false;
-    const symbol = importedSymbol(file, node.expression);
-    return symbol?.name === name && modules.has(symbol.module);
-}
 export function propertyChain(expression) {
     const target = unwrap(expression);
     if (ts.isIdentifier(target))

package/dist/tooling/linter/implementations/source/callable-requirements.d.ts

@@ -25,4 +25,3 @@ export declare function callableReference(expression: ts.Expression): {
 };
 /** Resolve only one immutable lexical alias; the linter does not emulate program execution. */
 export declare function lexicalConstInitializer(identifier: ts.Identifier): ts.Expression | undefined;
-export declare function bindingContains(binding: ts.BindingName, name: string): boolean;

package/dist/tooling/linter/implementations/source/callable-requirements.js

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { objectProperty, resolveImportedSymbol, resolveProjectImport, unwrap, visit, } from '../../adapters/typescript/index.js';
+import { bindingContains, objectProperty, resolveImportedSymbol, resolveProjectImport, unwrap, visit, } from '../../adapters/typescript/index.js';
 import { definitionObjects, DSL_MODULES, production, propertyExpression } from './shared.js';
 export function domainFunctionRequirements(project) {
     const domainPath = project.policy.rootFiles.find(({ id }) => id === 'domain')?.sourcePath;
@@ -227,8 +227,3 @@ export function lexicalConstInitializer(identifier) {
     }
     return undefined;
 }
-export function bindingContains(binding, name) {
-    if (ts.isIdentifier(binding))
-        return binding.text === name;
-    return binding.elements.some((element) => !ts.isOmittedExpression(element) && bindingContains(element.name, name));
-}

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

@@ -1,7 +1,7 @@
 import ts from 'typescript';
 import { propertyChain, resolveImportedSymbol, unwrap, visit, } from '../../adapters/typescript/index.js';
 import { domainFunctionRequirements, callableReference, callableSelector, declaredDomainDependencies, remoteCallableKey, } from './callable-requirements.js';
-import { ambiguity, calls, isForeignDomain, production, violation } from './shared.js';
+import { ambiguity, calls, contextPath, isForeignDomain, production, violation } from './shared.js';
 export const dependencyRules = [
     {
         id: 'FNC-XDOM-DECLARED',
@@ -158,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/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']);
@@ -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/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,23 @@ 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;
+/**
+ * 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,101 @@ 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 expression = unwrap(node.expression);
+    if (ts.isIdentifier(expression)) {
+        const name = expression.text;
+        return importedSymbol(file, expression) || isLocallyBound(expression, name) ? undefined : name;
+    }
+    const chain = propertyChain(expression);
+    if (chain?.length !== 2 || chain[0] !== 'globalThis')
+        return undefined;
+    let root = expression;
+    while (ts.isPropertyAccessExpression(root))
+        root = unwrap(root.expression);
+    return ts.isIdentifier(root) && isLocallyBound(root, root.text) ? undefined : chain[1];
+}
+/**
+ * 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 +319,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 +364,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));
-}