@astrale-os/sdk 0.5.0-beta.8 → 0.5.0-beta.80

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,368 @@
+import ts from 'typescript';
+import { importedSymbol, propertyChain, staticText, unwrap, visit, } from '../../adapters/typescript/index.js';
+import { ambiguity, DSL_MODULES, forbiddenIoImport, production, violation } from './shared.js';
+import { stateMachineConstructorOrigin, stateMachineOrigin, statePropertyIdentity, statePropertyOrigin, stateSchemaIdentity, } from './state-machine.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-STATE-SOURCE',
+        ruleRevision: '4f126e23835b6c46dabb94d2c94021ddb992a8e9a295faef4403df74ecfb2a41',
+        evaluate(project) {
+            const evidence = [];
+            const machineVocabularies = stateVocabularies(project);
+            for (const file of production(project, 'schema')) {
+                const ownedVocabularies = file.submodule === undefined ? undefined : machineVocabularies.get(file.submodule);
+                const reportedEnums = new Set();
+                visit(file.source, (node) => {
+                    if ((ts.isPropertyAssignment(node) || ts.isShorthandPropertyAssignment(node)) &&
+                        isPropertiesMember(node)) {
+                        const value = ts.isPropertyAssignment(node) ? node.initializer : node.name;
+                        const result = persistedStatePropertyEvidence(project, file, value, node);
+                        if (result !== undefined)
+                            evidence.push(result);
+                    }
+                    if (ts.isSpreadAssignment(node) && isPropertiesObject(node.parent)) {
+                        const spread = staticSchemaObject(file, node.expression);
+                        for (const entry of spread?.properties ?? []) {
+                            if (!ts.isPropertyAssignment(entry) && !ts.isShorthandPropertyAssignment(entry)) {
+                                continue;
+                            }
+                            const value = ts.isPropertyAssignment(entry) ? entry.initializer : entry.name;
+                            const result = persistedStatePropertyEvidence(project, file, value, node);
+                            if (result !== undefined)
+                                evidence.push(result);
+                        }
+                    }
+                    if (ts.isCallExpression(node)) {
+                        const machineOrigin = stateMachineConstructorOrigin(file, node.expression);
+                        if (machineOrigin === 'resolved') {
+                            evidence.push(violation(file, node, 'Schema declares a stateMachine; move the StateMachine relation to States.'));
+                        }
+                        else if (machineOrigin === 'ambiguous') {
+                            evidence.push(ambiguity(file, node, 'Schema call resembles stateMachine through a local facade, but its SDK origin is unresolved.'));
+                        }
+                        const values = enumValues(file, node);
+                        if (values !== undefined &&
+                            ownedVocabularies?.has(vocabularyKey(values)) === true &&
+                            !reportedEnums.has(node.pos)) {
+                            reportedEnums.add(node.pos);
+                            evidence.push(ambiguity(file, node, 'Schema declares an enum equal to its States machine vocabulary, but copied semantic ownership cannot be proven from literals alone.'));
+                        }
+                    }
+                    const projection = stateMachineCodecProjection(node);
+                    if (projection !== undefined) {
+                        const origin = stateMachineOrigin(project, file, projection.owner);
+                        if (origin === 'ambiguous') {
+                            evidence.push(ambiguity(file, node, `Schema StateMachine codec ${projection.name} has an unresolved States export origin.`));
+                        }
+                        else if (origin === 'absent') {
+                            evidence.push(violation(file, node, `Schema StateMachine codec ${projection.name} does not originate from an exported stateMachine.`));
+                        }
+                    }
+                });
+            }
+            return evidence;
+        },
+    },
+    {
+        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;
+        },
+    },
+];
+function enumValues(file, call) {
+    if (!isZodCall(file, call.expression))
+        return undefined;
+    const chain = propertyChain(call.expression);
+    const symbol = importedSymbol(file, call.expression);
+    if (symbol?.name === 'union' || chain?.at(-1) === 'union') {
+        return literalUnionValues(file, call);
+    }
+    if (symbol?.name !== 'enum' && chain?.at(-1) !== 'enum')
+        return undefined;
+    const argument = call.arguments[0] && unwrap(call.arguments[0]);
+    if (!argument || !ts.isArrayLiteralExpression(argument))
+        return undefined;
+    const values = argument.elements.map((element) => staticText(element));
+    return values.every((value) => value !== undefined) ? values : undefined;
+}
+function stateMachineCodecProjection(node) {
+    if (ts.isPropertyAccessExpression(node)) {
+        if (node.name.text === 'stateSchema' || node.name.text === 'eventSchema') {
+            return { owner: node.expression, name: node.name.text };
+        }
+        return undefined;
+    }
+    if (!ts.isElementAccessExpression(node))
+        return undefined;
+    const name = staticText(node.argumentExpression);
+    return name === 'stateSchema' || name === 'eventSchema'
+        ? { owner: node.expression, name }
+        : undefined;
+}
+function isZodCall(file, expression) {
+    const chain = propertyChain(expression);
+    const root = chain?.[0];
+    if (root === undefined)
+        return false;
+    return file.imports.some((sourceImport) => sourceImport.specifier === 'zod' &&
+        (sourceImport.namespace === root ||
+            [...sourceImport.bindings].some(([, local]) => local === root)));
+}
+function literalUnionValues(file, call) {
+    const argument = call.arguments[0] && unwrap(call.arguments[0]);
+    if (!argument || !ts.isArrayLiteralExpression(argument) || argument.elements.length === 0) {
+        return undefined;
+    }
+    const values = [];
+    for (const element of argument.elements) {
+        if (ts.isSpreadElement(element))
+            return undefined;
+        const literalCall = unwrap(element);
+        if (!ts.isCallExpression(literalCall))
+            return undefined;
+        const chain = propertyChain(literalCall.expression);
+        const symbol = importedSymbol(file, literalCall.expression);
+        if (symbol?.name !== 'literal' && chain?.at(-1) !== 'literal')
+            return undefined;
+        const value = staticText(literalCall.arguments[0]);
+        if (value === undefined)
+            return undefined;
+        values.push(value);
+    }
+    return values;
+}
+function stateVocabularies(project) {
+    const vocabularies = new Map();
+    for (const file of production(project, 'states')) {
+        if (file.submodule === undefined)
+            continue;
+        const submodule = file.submodule;
+        visit(file.source, (node) => {
+            if (!ts.isCallExpression(node))
+                return;
+            if (stateMachineConstructorOrigin(file, node.expression) !== 'resolved')
+                return;
+            const input = node.arguments[0] && unwrap(node.arguments[0]);
+            if (!input || !ts.isObjectLiteralExpression(input))
+                return;
+            const transitions = input.properties.find((property) => 'name' in property && property.name && propertyName(property.name) === 'transitions');
+            if (!transitions || !ts.isPropertyAssignment(transitions))
+                return;
+            const relation = unwrap(transitions.initializer);
+            if (!ts.isObjectLiteralExpression(relation))
+                return;
+            const states = [];
+            const events = [];
+            for (const state of relation.properties) {
+                if (!('name' in state) || !state.name || !ts.isPropertyAssignment(state))
+                    return;
+                const stateName = propertyName(state.name);
+                if (stateName === '<dynamic>')
+                    return;
+                states.push(stateName);
+                const outgoing = unwrap(state.initializer);
+                if (!ts.isObjectLiteralExpression(outgoing))
+                    return;
+                for (const event of outgoing.properties) {
+                    if (!('name' in event) || !event.name)
+                        return;
+                    const eventName = propertyName(event.name);
+                    if (eventName === '<dynamic>')
+                        return;
+                    events.push(eventName);
+                }
+            }
+            const owned = vocabularies.get(submodule) ?? new Set();
+            owned.add(vocabularyKey(states));
+            owned.add(vocabularyKey(events));
+            vocabularies.set(submodule, owned);
+        });
+    }
+    return vocabularies;
+}
+function vocabularyKey(values) {
+    return [...new Set(values)].sort().join('\0');
+}
+function propertyName(name) {
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+        return name.text;
+    }
+    return ts.isComputedPropertyName(name)
+        ? (staticText(name.expression) ?? '<dynamic>')
+        : '<dynamic>';
+}
+function persistedStatePropertyEvidence(project, file, value, placement) {
+    const associationOrigin = statePropertyOrigin(file, value);
+    const association = statePropertyIdentity(project, file, value);
+    if (associationOrigin === 'resolved' && isEdgePropertyPlacement(file, placement)) {
+        return violation(file, value, 'Schema StateProperty is supported only on Node Classes.');
+    }
+    if (associationOrigin === 'resolved' && association.kind === 'absent') {
+        return violation(file, value, 'Schema stateProperty does not reference an exported StateMachine authority.');
+    }
+    if (associationOrigin === 'ambiguous' || association.kind === 'ambiguous') {
+        return ambiguity(file, value, 'Schema StateProperty has no exact StateMachine source.');
+    }
+    if (associationOrigin !== 'absent')
+        return undefined;
+    const codec = stateSchemaIdentity(project, file, value);
+    if (codec.kind === 'resolved') {
+        return violation(file, value, 'Schema persists a StateMachine codec without retaining its authority; use stateProperty(machine).');
+    }
+    return codec.kind === 'ambiguous'
+        ? ambiguity(file, value, 'Schema machine-backed Property has no exact stateProperty source.')
+        : undefined;
+}
+function isEdgePropertyPlacement(file, placement) {
+    let current = placement;
+    while (current !== undefined && !ts.isSourceFile(current)) {
+        if (ts.isCallExpression(current)) {
+            const expression = unwrap(current.expression);
+            if (ts.isPropertyAccessExpression(expression) || ts.isElementAccessExpression(expression)) {
+                const member = ts.isPropertyAccessExpression(expression)
+                    ? expression.name.text
+                    : staticText(expression.argumentExpression);
+                const owner = importedSymbol(file, expression.expression);
+                if ((member === 'directed' || member === 'undirected') &&
+                    owner?.name === 'edgeClass' &&
+                    DSL_MODULES.has(owner.module)) {
+                    return true;
+                }
+            }
+        }
+        current = current.parent;
+    }
+    return false;
+}
+function staticSchemaObject(file, expression, seen = new Set()) {
+    const value = unwrap(expression);
+    if (ts.isObjectLiteralExpression(value))
+        return value;
+    if (!ts.isIdentifier(value) || seen.has(value.text))
+        return undefined;
+    for (const statement of file.source.statements) {
+        if (!ts.isVariableStatement(statement))
+            continue;
+        if ((statement.declarationList.flags & ts.NodeFlags.Const) === 0)
+            continue;
+        for (const declaration of statement.declarationList.declarations) {
+            if (ts.isIdentifier(declaration.name) &&
+                declaration.name.text === value.text &&
+                declaration.initializer !== undefined) {
+                return staticSchemaObject(file, declaration.initializer, new Set([...seen, value.text]));
+            }
+        }
+    }
+    return undefined;
+}
+function isPropertiesMember(node) {
+    const owner = node.parent.parent;
+    return (ts.isPropertyAssignment(owner) &&
+        owner.name !== undefined &&
+        propertyName(owner.name) === 'properties');
+}
+function isPropertiesObject(node) {
+    const owner = node.parent;
+    return (ts.isPropertyAssignment(owner) &&
+        owner.name !== undefined &&
+        propertyName(owner.name) === 'properties');
+}

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

@@ -0,0 +1,44 @@
+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 projector?: ts.FunctionLikeDeclaration;
+    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;
+/** Prove the clean curried Domain projector shape for Query and Mutation recipes. */
+export declare function domainProjectorEvidence(file: SourceFile, importedName: 'defineCollectionQuery' | 'defineCompositeQuery' | 'defineMutation' | 'defineQuery', label: string): SourceRuleEvidence[];
+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[];