@astrale-os/sdk 0.5.0-beta.99 → 0.6.0-beta.0

package/dist/tooling/cli/upgrade/process.js

@@ -0,0 +1,57 @@
+import spawn from 'cross-spawn';
+/** pnpm owns registry configuration, installation policy, and lockfile resolution. */
+export function runPnpm(cwd, args, install = false) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('pnpm', [...args], {
+            cwd,
+            stdio: install ? 'inherit' : ['ignore', 'pipe', 'pipe'],
+            shell: false,
+        });
+        let stdout = '';
+        let stderr = '';
+        let failure;
+        let escalation;
+        const stop = (reason) => {
+            if (failure)
+                return;
+            failure = new Error(reason);
+            child.kill('SIGTERM');
+            escalation = setTimeout(() => child.kill('SIGKILL'), 1_000);
+        };
+        const interrupt = () => stop('Upgrade interrupted; inspect local changes before retrying.');
+        process.once('SIGINT', interrupt);
+        process.once('SIGTERM', interrupt);
+        const timer = setTimeout(() => stop('pnpm timed out.'), install ? 600_000 : 60_000);
+        child.stdout?.on('data', (chunk) => {
+            stdout += chunk.toString('utf8');
+            if (stdout.length > 4 * 1024 * 1024)
+                stop('pnpm output exceeded the supported limit.');
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderr += chunk.toString('utf8');
+            if (stderr.length > 4 * 1024 * 1024)
+                stop('pnpm output exceeded the supported limit.');
+        });
+        const cleanup = () => {
+            clearTimeout(timer);
+            if (escalation)
+                clearTimeout(escalation);
+            process.removeListener('SIGINT', interrupt);
+            process.removeListener('SIGTERM', interrupt);
+        };
+        child.once('error', (cause) => {
+            cleanup();
+            reject(new Error("Could not start pnpm. Install the project's declared pnpm version.", { cause }));
+        });
+        child.once('close', (code, signal) => {
+            cleanup();
+            if (failure)
+                reject(failure);
+            else if (code !== 0) {
+                reject(new Error(`pnpm ${args[0]} failed (${signal ?? code}).${stderr ? `\n${stderr.trim()}` : ''}`));
+            }
+            else
+                resolve(stdout);
+        });
+    });
+}

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

@@ -150,6 +150,8 @@ function importCandidates(path) {
     if (['.js', '.jsx', '.mjs', '.cjs'].includes(extension)) {
         const stem = path.slice(0, -extension.length);
         candidates.push(`${stem}.ts`, `${stem}.tsx`, `${stem}.mts`, `${stem}.cts`);
+        const declarationExtension = extension === '.mjs' ? '.d.mts' : extension === '.cjs' ? '.d.cts' : '.d.ts';
+        candidates.push(`${stem}${declarationExtension}`);
     }
     if (!extension) {
         candidates.push(`${path}.ts`, `${path}.tsx`, `${path}.mts`, `${path}.cts`);

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

@@ -5,6 +5,7 @@ export { importedSymbol, isLocallyDeclared, resolveImportedSymbol, location, obj
 export { assertSingleTypeUniverse } from './type-universe.js';
 export { observeQueryDefinitions } from './query-observation.js';
 export { queryCollectionKind } from './query-collection-type.js';
+export { expressionType, type ExpressionType } from './type-analysis.js';
 export { collectSuppressionDirectives } from './suppression-directives.js';
 import type ts from 'typescript';
 import type { DomainPolicy } from '../../policy/index.js';

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

@@ -5,4 +5,5 @@ export { importedSymbol, isLocallyDeclared, resolveImportedSymbol, location, obj
 export { assertSingleTypeUniverse } from './type-universe.js';
 export { observeQueryDefinitions } from './query-observation.js';
 export { queryCollectionKind } from './query-collection-type.js';
+export { expressionType } from './type-analysis.js';
 export { collectSuppressionDirectives } from './suppression-directives.js';

package/dist/tooling/linter/adapters/typescript/query-collection-type.js

@@ -1,60 +1,13 @@
-import { dirname } from 'node:path';
 import ts from 'typescript';
-const contexts = new WeakMap();
+import { expressionType } from './type-analysis.js';
 /** Infer the closed collection graph kind only when the Domain's real TypeScript program proves it. */
 export function queryCollectionKind(project, file, expression) {
-    const context = typeContext(project);
-    if (context === null)
+    const resolved = expressionType(project, file, expression);
+    if (resolved === undefined)
         return undefined;
-    const source = context.program.getSourceFile(file.absolutePath);
-    if (source === undefined)
-        return undefined;
-    const node = matchingNode(source, expression.getStart(file.source), expression.end);
-    if (node === undefined || !ts.isExpression(node))
-        return undefined;
-    const kinds = graphKinds(context.checker, context.checker.getTypeAtLocation(node), node);
+    const kinds = graphKinds(resolved.checker, resolved.type, resolved.node);
     return kinds.size === 1 ? [...kinds][0] : undefined;
 }
-function typeContext(project) {
-    const existing = contexts.get(project);
-    if (existing !== undefined)
-        return existing;
-    try {
-        const configPath = ts.findConfigFile(project.root, ts.sys.fileExists);
-        if (configPath === undefined)
-            return remember(project, null);
-        const loaded = ts.readConfigFile(configPath, ts.sys.readFile);
-        if (loaded.error !== undefined)
-            return remember(project, null);
-        const parsed = ts.parseJsonConfigFileContent(loaded.config, ts.sys, dirname(configPath), { noEmit: true }, configPath);
-        const context = {
-            program: ts.createProgram({ rootNames: parsed.fileNames, options: parsed.options }),
-        };
-        return remember(project, {
-            program: context.program,
-            checker: context.program.getTypeChecker(),
-        });
-    }
-    catch {
-        return remember(project, null);
-    }
-}
-function remember(project, context) {
-    contexts.set(project, context);
-    return context;
-}
-function matchingNode(source, start, end) {
-    let match;
-    const visit = (node) => {
-        if (node.getStart(source) > start || node.end < end)
-            return;
-        if (node.getStart(source) === start && node.end === end)
-            match = node;
-        node.forEachChild(visit);
-    };
-    visit(source);
-    return match;
-}
 function graphKinds(checker, type, location) {
     const kinds = new Set();
     const inspect = (candidate) => {

package/dist/tooling/linter/adapters/typescript/type-analysis.d.ts

@@ -0,0 +1,9 @@
+import ts from 'typescript';
+import type { SourceFile, SourceProject } from './index.js';
+export interface ExpressionType {
+    readonly checker: ts.TypeChecker;
+    readonly node: ts.Expression;
+    readonly type: ts.Type;
+}
+/** Resolve an expression against the Domain's admitted TypeScript program. */
+export declare function expressionType(project: SourceProject, file: SourceFile, expression: ts.Expression): ExpressionType | undefined;

package/dist/tooling/linter/adapters/typescript/type-analysis.js

@@ -0,0 +1,55 @@
+import { dirname } from 'node:path';
+import ts from 'typescript';
+const contexts = new WeakMap();
+/** Resolve an expression against the Domain's admitted TypeScript program. */
+export function expressionType(project, file, expression) {
+    const context = typeContext(project);
+    if (context === null)
+        return undefined;
+    const source = context.program.getSourceFile(file.absolutePath);
+    if (source === undefined)
+        return undefined;
+    const node = matchingNode(source, expression.getStart(file.source), expression.end);
+    if (node === undefined || !ts.isExpression(node))
+        return undefined;
+    return {
+        checker: context.checker,
+        node,
+        type: context.checker.getTypeAtLocation(node),
+    };
+}
+function typeContext(project) {
+    const existing = contexts.get(project);
+    if (existing !== undefined)
+        return existing;
+    try {
+        const configPath = ts.findConfigFile(project.root, ts.sys.fileExists);
+        if (configPath === undefined)
+            return remember(project, null);
+        const loaded = ts.readConfigFile(configPath, ts.sys.readFile);
+        if (loaded.error !== undefined)
+            return remember(project, null);
+        const parsed = ts.parseJsonConfigFileContent(loaded.config, ts.sys, dirname(configPath), { noEmit: true }, configPath);
+        const program = ts.createProgram({ rootNames: parsed.fileNames, options: parsed.options });
+        return remember(project, { program, checker: program.getTypeChecker() });
+    }
+    catch {
+        return remember(project, null);
+    }
+}
+function remember(project, context) {
+    contexts.set(project, context);
+    return context;
+}
+function matchingNode(source, start, end) {
+    let match;
+    const visit = (node) => {
+        if (node.getStart(source) > start || node.end < end)
+            return;
+        if (node.getStart(source) === start && node.end === end)
+            match = node;
+        node.forEachChild(visit);
+    };
+    visit(source);
+    return match;
+}

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

@@ -0,0 +1,28 @@
+import ts from 'typescript';
+import { type SourceFile, type SourceProject } from '../../adapters/typescript/index.js';
+export interface RemoteCallable {
+    readonly file: SourceFile;
+    readonly node: ts.CallExpression;
+    readonly module: string;
+    readonly selector: readonly string[];
+}
+export interface FunctionRequirements {
+    readonly keys: ReadonlySet<string>;
+    readonly indeterminate: boolean;
+}
+export declare function applicationFunctionRequirements(project: SourceProject): FunctionRequirements;
+export declare function requiredCallable(project: SourceProject, file: SourceFile, input: ts.Expression): Pick<RemoteCallable, 'module' | 'selector'> | undefined;
+export declare function declaredDomainDependencies(project: SourceProject): {
+    readonly aliases: ReadonlyMap<string, string>;
+    readonly indeterminate: boolean;
+};
+export declare function callableSelector(selector: readonly string[]): boolean;
+export declare function externalFacade(module: string): boolean;
+export declare function remoteCallableKey(input: Pick<RemoteCallable, 'module' | 'selector'>): string;
+export declare function callableReference(expression: ts.Expression): {
+    readonly expression: ts.Expression;
+    readonly resolved: boolean;
+};
+/** 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

@@ -0,0 +1,234 @@
+import ts from 'typescript';
+import { objectProperty, resolveImportedSymbol, resolveProjectImport, unwrap, visit, } from '../../adapters/typescript/index.js';
+import { definitionObjects, DSL_MODULES, production, propertyExpression } from './shared.js';
+export function applicationFunctionRequirements(project) {
+    const applicationPath = project.policy.rootFiles.find(({ id }) => id === 'application')?.sourcePath;
+    const file = applicationPath && project.filesByPath.get(applicationPath);
+    if (!file)
+        return { keys: new Set(), indeterminate: true };
+    const applications = [];
+    visit(file.source, (node) => {
+        if (!ts.isCallExpression(node))
+            return;
+        const symbol = resolveImportedSymbol(file, node.expression);
+        if (symbol.kind === 'resolved' &&
+            symbol.name === 'defineApplication' &&
+            (symbol.module === '@astrale-os/sdk' || symbol.module === '@astrale-os/sdk/application')) {
+            applications.push(node);
+        }
+    });
+    if (applications.length !== 1)
+        return { keys: new Set(), indeterminate: true };
+    const input = applications[0].arguments[0];
+    if (!input || !ts.isObjectLiteralExpression(unwrap(input))) {
+        return { keys: new Set(), indeterminate: true };
+    }
+    const requirementsProperty = objectProperty(unwrap(input), 'requirements');
+    if (requirementsProperty === undefined)
+        return { keys: new Set(), indeterminate: false };
+    const requirementsInput = ts.isPropertyAssignment(requirementsProperty)
+        ? requirementsProperty.initializer
+        : ts.isShorthandPropertyAssignment(requirementsProperty)
+            ? requirementsProperty.name
+            : undefined;
+    if (!requirementsInput)
+        return { keys: new Set(), indeterminate: true };
+    const requirementsCall = callableReference(unwrap(requirementsInput)).expression;
+    if (!ts.isCallExpression(requirementsCall))
+        return { keys: new Set(), indeterminate: true };
+    const requirementsSymbol = resolveImportedSymbol(file, requirementsCall.expression);
+    if (requirementsSymbol.kind !== 'resolved' ||
+        requirementsSymbol.name !== 'requirements' ||
+        (requirementsSymbol.module !== '@astrale-os/sdk' &&
+            requirementsSymbol.module !== '@astrale-os/sdk/application')) {
+        return { keys: new Set(), indeterminate: true };
+    }
+    const definition = requirementsCall.arguments[0];
+    if (definition === undefined)
+        return { keys: new Set(), indeterminate: false };
+    if (!ts.isObjectLiteralExpression(unwrap(definition))) {
+        return { keys: new Set(), indeterminate: true };
+    }
+    const functions = objectProperty(unwrap(definition), 'functions');
+    if (functions === undefined)
+        return { keys: new Set(), indeterminate: false };
+    if (!ts.isPropertyAssignment(functions))
+        return { keys: new Set(), indeterminate: true };
+    const values = unwrap(functions.initializer);
+    if (!ts.isArrayLiteralExpression(values))
+        return { keys: new Set(), indeterminate: true };
+    const keys = new Set();
+    let indeterminate = false;
+    for (const element of values.elements) {
+        if (ts.isSpreadElement(element)) {
+            indeterminate = true;
+            continue;
+        }
+        const target = requiredCallable(project, file, element);
+        if (target === undefined)
+            indeterminate = true;
+        else
+            keys.add(remoteCallableKey(target));
+    }
+    return { keys, indeterminate };
+}
+export function requiredCallable(project, file, input) {
+    const admitted = callableReference(unwrap(input));
+    if (!admitted.resolved)
+        return undefined;
+    let current = admitted.expression;
+    const selector = [];
+    while (ts.isPropertyAccessExpression(unwrap(current))) {
+        const property = unwrap(current);
+        selector.unshift(property.name.text);
+        current = unwrap(property.expression);
+    }
+    if (ts.isIdentifier(current))
+        current = callableReference(current).expression;
+    if (!ts.isCallExpression(current))
+        return undefined;
+    const resolve = unwrap(current.expression);
+    if (!ts.isPropertyAccessExpression(resolve) || resolve.name.text !== 'resolve')
+        return undefined;
+    const schemaSymbol = resolveImportedSymbol(file, resolve.expression);
+    if (schemaSymbol.kind !== 'resolved' ||
+        schemaSymbol.name !== 'schema' ||
+        schemaSymbol.module !== '@astrale-os/sdk/schema') {
+        return undefined;
+    }
+    const schemaValue = current.arguments[0];
+    if (!schemaValue)
+        return undefined;
+    const facade = resolveImportedSymbol(file, schemaValue);
+    if (facade.kind === 'resolved' && externalFacade(facade.module)) {
+        if (!callableSelector(selector))
+            return undefined;
+        return { module: facade.module, selector: Object.freeze(selector) };
+    }
+    if (facade.kind === 'local')
+        return undefined;
+    const localSchema = resolveProjectImport(project, file, facade.module);
+    if (facade.name !== 'schema' ||
+        localSchema?.layer !== 'schema' ||
+        selector[0] !== 'dependencies' ||
+        selector[1] === undefined) {
+        return undefined;
+    }
+    const callable = selector.slice(2);
+    if (!callableSelector(callable))
+        return undefined;
+    const dependency = declaredDomainDependencies(project).aliases.get(selector[1]);
+    return dependency === undefined
+        ? undefined
+        : { module: dependency, selector: Object.freeze(callable) };
+}
+export function declaredDomainDependencies(project) {
+    const aliases = new Map();
+    let indeterminate = false;
+    let definitions = 0;
+    for (const file of production(project, 'schema')) {
+        for (const definition of definitionObjects(file, 'defineSchema', undefined, DSL_MODULES, 1)) {
+            definitions++;
+            if (definition.origin !== 'resolved' || !definition.object) {
+                indeterminate = true;
+                continue;
+            }
+            const value = propertyExpression(definition.object, 'dependencies');
+            if (!value)
+                continue;
+            if (!ts.isObjectLiteralExpression(value)) {
+                indeterminate = true;
+                continue;
+            }
+            for (const property of value.properties) {
+                const input = ts.isPropertyAssignment(property)
+                    ? property.initializer
+                    : ts.isShorthandPropertyAssignment(property)
+                        ? property.name
+                        : undefined;
+                const name = property.name;
+                const alias = name && (ts.isIdentifier(name) || ts.isStringLiteral(name)) ? name.text : undefined;
+                if (!input || !alias) {
+                    indeterminate = true;
+                    continue;
+                }
+                const symbol = resolveImportedSymbol(file, input);
+                if (symbol.kind === 'resolved' &&
+                    symbol.name === 'KernelSchema' &&
+                    ['@astrale-os/sdk/schema', '@astrale-os/kernel-core'].includes(symbol.module)) {
+                    continue;
+                }
+                if (symbol.kind !== 'resolved' || !externalFacade(symbol.module)) {
+                    indeterminate = true;
+                    continue;
+                }
+                if (aliases.has(alias) && aliases.get(alias) !== symbol.module) {
+                    aliases.delete(alias);
+                    indeterminate = true;
+                    continue;
+                }
+                aliases.set(alias, symbol.module);
+            }
+        }
+    }
+    return { aliases, indeterminate: indeterminate || definitions !== 1 };
+}
+export function callableSelector(selector) {
+    return ((selector.length === 2 && selector[0] === 'functions') ||
+        (selector.length === 4 && selector[0] === 'classes' && selector[2] === 'methods') ||
+        (selector.length === 5 &&
+            selector[0] === 'classes' &&
+            selector[2] === 'static' &&
+            selector[3] === 'methods'));
+}
+export function externalFacade(module) {
+    return (!module.startsWith('.') &&
+        !module.startsWith('#') &&
+        !module.startsWith('@astrale-os/sdk') &&
+        !module.startsWith('@astrale-os/kernel-'));
+}
+export function remoteCallableKey(input) {
+    return `${input.module}\0${input.selector.join('\0')}`;
+}
+export function callableReference(expression) {
+    if (!ts.isIdentifier(expression))
+        return { expression, resolved: true };
+    const initializer = lexicalConstInitializer(expression);
+    return initializer === undefined
+        ? { expression, resolved: false }
+        : { expression: unwrap(initializer), resolved: true };
+}
+/** Resolve only one immutable lexical alias; the linter does not emulate program execution. */
+export function lexicalConstInitializer(identifier) {
+    let child = identifier;
+    let current = identifier.parent;
+    while (current) {
+        if (ts.isFunctionLike(current)) {
+            if (current.parameters.some(({ name }) => bindingContains(name, identifier.text))) {
+                return undefined;
+            }
+        }
+        if (ts.isBlock(current) || ts.isSourceFile(current) || ts.isModuleBlock(current)) {
+            const index = current.statements.findIndex((statement) => statement.pos <= child.pos && statement.end >= child.end);
+            const before = index < 0 ? current.statements : current.statements.slice(0, index);
+            for (const statement of [...before].reverse()) {
+                if (!ts.isVariableStatement(statement))
+                    continue;
+                const declaration = statement.declarationList.declarations.find(({ name }) => ts.isIdentifier(name) && name.text === identifier.text);
+                if (!declaration)
+                    continue;
+                return (statement.declarationList.flags & ts.NodeFlags.Const) !== 0
+                    ? declaration.initializer
+                    : undefined;
+            }
+        }
+        child = current;
+        current = current.parent;
+    }
+    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.d.ts

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