@astrale-os/sdk 0.5.0-beta.13 → 0.5.0-beta.131

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

@@ -0,0 +1,1404 @@
+import ts from 'typescript';
+import { expressionType, importedSymbol, propertyChain, staticText, unwrap, visit, } 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']);
+const FORBIDDEN_CALLS = new Set(['invoke', 'query', 'retry', 'run', 'submit']);
+export const mutationRules = [
+    {
+        id: 'MUT-PLAN-REQ',
+        ruleRevision: '9201a4e5799f62cc8df37d281d1f02516132632e33b4a82187c399780bdfe340',
+        evaluate(project) {
+            const evidence = [];
+            const targets = [];
+            for (const file of production(project, 'mutations')) {
+                const builderScopes = mutationBuilderScopes(file);
+                visit(file.source, (node) => {
+                    if (!ts.isCallExpression(node))
+                        return;
+                    const operation = mutationBuilderOperation(node, builderScopes);
+                    if (operation === undefined)
+                        return;
+                    const classOperation = classOperationForBuilder(operation);
+                    if (classOperation === undefined)
+                        return;
+                    const input = staticObject(node.arguments[0]);
+                    const selectedClass = input && assignedValue(input, 'class');
+                    const target = selectedClass && dependencyClassTarget(selectedClass);
+                    if (selectedClass !== undefined && target !== undefined) {
+                        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.'));
+                    }
+                });
+            }
+            const identityCalls = [];
+            for (const file of production(project, 'functions')) {
+                visit(file.source, (node) => {
+                    if (ts.isCallExpression(node) && kernelProvisionCall(node)) {
+                        identityCalls.push({ file, node, syscall: 'provision' });
+                    }
+                });
+                for (const node of kernelRegisterCalls(file))
+                    identityCalls.push({ file, node, syscall: 'register' });
+            }
+            if (targets.length === 0 && identityCalls.length === 0)
+                return evidence;
+            const requirements = applicationPlanRequirements(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.`));
+            }
+            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.`));
+                }
+            }
+            return evidence;
+        },
+    },
+    {
+        id: 'MUT-STATE-INITIAL',
+        ruleRevision: 'd88f178994e9ad56d14f50ad5ffdff398413e42a690985c5ddc669c0f293d9bb',
+        evaluate(project) {
+            const evidence = [];
+            const machineProperties = machinePropertiesByClass(project);
+            for (const file of production(project, 'mutations')) {
+                const builderScopes = mutationBuilderScopes(file);
+                visit(file.source, (node) => {
+                    if (!ts.isCallExpression(node) ||
+                        mutationBuilderMember(node, builderScopes) !== 'createNode') {
+                        return;
+                    }
+                    const input = staticObject(node.arguments[0]);
+                    if (!input) {
+                        if (hasMachineCandidates(machineProperties)) {
+                            evidence.push(ambiguity(file, node, 'Mutation createNode input is dynamic, so machine-state initialization cannot be proven.'));
+                        }
+                        return;
+                    }
+                    const selectedClass = propertiesForClass(input, machineProperties);
+                    if (selectedClass.kind === 'ambiguous') {
+                        evidence.push(ambiguity(file, assignedValue(input, 'class') ?? input, 'Mutation createNode Class has no statically resolvable Schema owner.'));
+                        return;
+                    }
+                    if (selectedClass.kind === 'absent')
+                        return;
+                    const selected = selectedClass.properties;
+                    const propsValue = assignedValue(input, 'props');
+                    const props = staticObject(propsValue);
+                    if (!props) {
+                        evidence.push(propsValue === undefined
+                            ? violation(file, input, 'Mutation creates a StateMachine-backed node without its initial state.')
+                            : ambiguity(file, propsValue, 'Mutation createNode properties are dynamic, so machine-state initialization cannot be proven.'));
+                        return;
+                    }
+                    const assignments = machineAssignments(props, selected);
+                    const uncertain = [...selected.keys()].filter((name) => spreadMaySet(props, name));
+                    if (uncertain.length > 0) {
+                        evidence.push(ambiguity(file, props, `Mutation createNode properties contain a spread that may determine machine-backed ${uncertain.join(', ')}.`));
+                    }
+                    for (const name of selected.keys()) {
+                        if (assignments.some((property) => staticPropertyName(property) === name))
+                            continue;
+                        if (uncertain.includes(name))
+                            continue;
+                        evidence.push(violation(file, props, `Mutation creates a StateMachine-backed node without initial property ${name}.`));
+                    }
+                    for (const property of assignments) {
+                        const name = staticPropertyName(property) ?? '<dynamic>';
+                        if (uncertain.includes(name))
+                            continue;
+                        const expectedIdentity = selected.get(name);
+                        const value = assignedPropertyValue(property);
+                        const initial = initialIdentity(project, file, value);
+                        if (initial.kind === 'resolved' && initial.identity === expectedIdentity)
+                            continue;
+                        if (initial.kind === 'resolved') {
+                            evidence.push(violation(file, value, `Mutation initializes machine-backed property ${name} from a different StateMachine authority.`));
+                            continue;
+                        }
+                        if (staticText(value) !== undefined) {
+                            evidence.push(violation(file, value, `Mutation initializes machine-backed property ${name} with a copied state instead of machine.initial.`));
+                        }
+                        else {
+                            evidence.push(ambiguity(file, value, `Mutation StateMachine initializer for ${name} has no resolvable machine.initial source.`));
+                        }
+                    }
+                });
+            }
+            return evidence;
+        },
+    },
+    {
+        id: 'MUT-STATE-ATOMIC',
+        ruleRevision: 'c734069c35bab09f47b4fcd6b3f207fccceb69a9da4f1fb1c50d9fd2711bf6dd',
+        evaluate(project) {
+            const evidence = [];
+            const machineProperties = machinePropertiesByClass(project);
+            for (const file of production(project, 'mutations')) {
+                const builderScopes = mutationBuilderScopes(file);
+                visit(file.source, (node) => {
+                    if (!ts.isCallExpression(node))
+                        return;
+                    const member = mutationBuilderMember(node, builderScopes);
+                    if (member === undefined)
+                        return;
+                    if (member === 'updateNode') {
+                        if (!hasMachineCandidates(machineProperties))
+                            return;
+                        const input = staticObject(node.arguments[0]);
+                        if (!input) {
+                            evidence.push(ambiguity(file, node, 'Mutation updateNode input is dynamic and may bypass a StateMachine transition.'));
+                            return;
+                        }
+                        const selectedClass = propertiesForClass(input, machineProperties);
+                        if (selectedClass.kind === 'ambiguous') {
+                            evidence.push(ambiguity(file, assignedValue(input, 'class') ?? input, 'Mutation updateNode Class has no statically resolvable Schema owner.'));
+                            return;
+                        }
+                        if (selectedClass.kind === 'absent')
+                            return;
+                        const selected = selectedClass.properties;
+                        const propsValue = assignedValue(input, 'props');
+                        const props = staticObject(propsValue);
+                        if (!props) {
+                            evidence.push(ambiguity(file, propsValue ?? input, 'Mutation updateNode properties are dynamic and may bypass a StateMachine transition.'));
+                            return;
+                        }
+                        if (hasSpread(props)) {
+                            evidence.push(ambiguity(file, props, 'Mutation updateNode properties contain a spread that may bypass a StateMachine transition.'));
+                        }
+                        const setValue = assignedValue(props, 'set');
+                        const set = staticObject(setValue);
+                        if (setValue !== undefined && !set) {
+                            const typed = typedPatchMachineProperties(project, file, setValue, selected);
+                            if (typed === undefined) {
+                                evidence.push(ambiguity(file, setValue, 'Mutation updateNode set patch is dynamic and may bypass a StateMachine transition.'));
+                            }
+                            else {
+                                for (const property of typed) {
+                                    evidence.push(violation(file, setValue, `Mutation updateNode patch type permits machine-backed property ${property}; use transition for one atomic compare-and-set.`));
+                                }
+                            }
+                        }
+                        if (set && hasSpread(set)) {
+                            evidence.push(ambiguity(file, set, 'Mutation updateNode set patch contains a spread that may bypass a StateMachine transition.'));
+                        }
+                        for (const property of set ? machineAssignments(set, selected) : []) {
+                            evidence.push(violation(file, property, `Mutation writes machine-backed property ${String(staticPropertyName(property))} through updateNode; use transition for one atomic compare-and-set.`));
+                        }
+                        const unsetValue = assignedValue(props, 'unset');
+                        const unset = unsetValue && staticStringArray(unsetValue);
+                        if (unsetValue !== undefined && unset === undefined) {
+                            evidence.push(ambiguity(file, unsetValue, 'Mutation updateNode unset patch is dynamic and may bypass a StateMachine transition.'));
+                        }
+                        else {
+                            for (const property of unset ?? []) {
+                                if (!selected.has(property.value))
+                                    continue;
+                                evidence.push(violation(file, property.node, `Mutation unsets machine-backed property ${property.value} through updateNode; StateMachine changes require transition.`));
+                            }
+                        }
+                    }
+                    if (member !== 'transition')
+                        return;
+                    if (!hasMachineCandidates(machineProperties))
+                        return;
+                    const input = staticObject(node.arguments[0]);
+                    if (!input) {
+                        evidence.push(ambiguity(file, node, 'StateMachine transition input is not one static object.'));
+                        return;
+                    }
+                    const removed = [
+                        'machine',
+                        'lifecycle',
+                        'decision',
+                        'to',
+                        'transition',
+                        'witness',
+                        'step',
+                    ].filter((name) => assignedValue(input, name) !== undefined);
+                    if (removed.length > 0) {
+                        evidence.push(violation(file, input, `StateMachine transition derives authority and target from StateProperty; remove ${removed.join(', ')}.`));
+                    }
+                    const spread = hasSpread(input);
+                    if (spread) {
+                        evidence.push(ambiguity(file, input, 'StateMachine transition input contains a spread that may override or add governed fields.'));
+                    }
+                    if (!spread) {
+                        for (const required of ['from', 'event']) {
+                            if (assignedValue(input, required) !== undefined)
+                                continue;
+                            evidence.push(violation(file, input, `StateMachine transition has no ${required} intent.`));
+                        }
+                    }
+                    const selectedClass = propertiesForClass(input, machineProperties);
+                    if (selectedClass.kind === 'ambiguous') {
+                        evidence.push(ambiguity(file, assignedValue(input, 'class') ?? input, 'StateMachine transition Class has no statically resolvable Schema owner.'));
+                    }
+                    const property = staticTextValue(assignedValue(input, 'property'));
+                    if (property === undefined) {
+                        evidence.push(ambiguity(file, assignedValue(input, 'property') ?? input, 'StateMachine transition property is not static text.'));
+                    }
+                    else if (selectedClass.kind === 'absent' ||
+                        (selectedClass.kind === 'resolved' && !selectedClass.properties.has(property))) {
+                        evidence.push(violation(file, assignedValue(input, 'property') ?? input, `StateMachine transition property ${property} is not a machine-backed Property of the selected Class.`));
+                    }
+                });
+            }
+            return evidence;
+        },
+    },
+    {
+        id: 'MUT-CANON',
+        ruleRevision: '238b94e9c936fc7c8cd2e1b1d5b61e59f32069ff9974dc366de6633717f38756',
+        evaluate(project) {
+            const evidence = [];
+            for (const file of production(project, 'mutations')) {
+                evidence.push(...domainProjectorEvidence(file, 'defineMutation', 'Mutation'));
+                for (const definition of definitionObjects(file, 'defineMutation')) {
+                    const uncertain = definitionOriginAmbiguity(file, definition, 'Mutation definition');
+                    if (uncertain) {
+                        evidence.push(uncertain);
+                        continue;
+                    }
+                    const { call, object } = definition;
+                    if (!object) {
+                        evidence.push(ambiguity(file, call, 'Mutation definition is not a static object literal.'));
+                        continue;
+                    }
+                    const build = callback(object, 'build');
+                    if (!build) {
+                        evidence.push(violation(file, object, 'Mutation definition has no build callback.'));
+                        continue;
+                    }
+                    if (build.parameters.length < 2) {
+                        evidence.push(violation(file, build, 'Mutation build has no callback-scoped builder as its second parameter.'));
+                    }
+                    if (returnedValues(build) > 0) {
+                        evidence.push(violation(file, build, 'Mutation build returns a value.'));
+                    }
+                    if (build.modifiers?.some(({ kind }) => kind === ts.SyntaxKind.AsyncKeyword)) {
+                        evidence.push(violation(file, build, 'Mutation build callback is async.'));
+                    }
+                    let nestedBuilds = 0;
+                    if (build.body)
+                        visit(build.body, (node) => {
+                            if (!ts.isCallExpression(node))
+                                return;
+                            const symbol = importedSymbol(file, node.expression);
+                            const chain = propertyChain(node.expression);
+                            if (symbol?.name === 'MutationAST' ||
+                                (chain?.includes('MutationAST') && chain.at(-1) === 'build')) {
+                                nestedBuilds += 1;
+                            }
+                        });
+                    if (nestedBuilds > 0) {
+                        evidence.push(violation(file, build, 'Mutation definition constructs a nested MutationAST.'));
+                    }
+                }
+            }
+            return evidence;
+        },
+    },
+    {
+        id: 'MUT-FRAGMENTS',
+        ruleRevision: '6102ea4dbe2e461ef38b98afcfbe28639f4f472ee6a83e44ce6aad7de3c3c7ef',
+        evaluate(project) {
+            const evidence = [];
+            for (const file of production(project, 'mutations')) {
+                for (const definition of definitionObjects(file, 'defineMutation')) {
+                    const uncertain = definitionOriginAmbiguity(file, definition, 'Mutation definition');
+                    if (uncertain) {
+                        evidence.push(uncertain);
+                        continue;
+                    }
+                    const { object } = definition;
+                    const build = object && callback(object, 'build');
+                    if (!build)
+                        continue;
+                    const builderName = build.parameters[1]?.name;
+                    if (!builderName || !ts.isIdentifier(builderName)) {
+                        evidence.push(ambiguity(file, build, 'Mutation build builder parameter is not an identifier.'));
+                        continue;
+                    }
+                    visitOwnBody(build, (node) => {
+                        if (ts.isReturnStatement(node) && node.expression) {
+                            evidence.push(violation(file, node, 'Mutation build returns a value or escaped builder.'));
+                        }
+                        if (!ts.isCallExpression(node))
+                            return;
+                        const chain = propertyChain(node.expression);
+                        if (chain?.[0] === builderName.text)
+                            return;
+                        if (!referencesIdentifier(node.arguments, builderName.text))
+                            return;
+                        const first = node.arguments[0];
+                        if (!first ||
+                            !ts.isIdentifier(unwrap(first)) ||
+                            unwrap(first).text !== builderName.text) {
+                            evidence.push(violation(file, node, `Mutation fragment must receive ${builderName.text} as its first argument.`));
+                        }
+                    });
+                }
+            }
+            return evidence;
+        },
+    },
+    {
+        id: 'MUT-PURE',
+        ruleRevision: '0101d7edd7d34e69338aaec7129a14df40d3395b6a58b40265ccb5448e739170',
+        evaluate(project) {
+            const evidence = [];
+            for (const file of production(project, 'mutations')) {
+                for (const sourceImport of file.imports) {
+                    const targetLayer = sourceImport.specifier.match(/^#([^/]+)\//)?.[1];
+                    if ((targetLayer && FORBIDDEN_LAYERS.has(targetLayer)) ||
+                        forbiddenIoImport(sourceImport.specifier) ||
+                        sourceImport.specifier.startsWith('@astrale-os/adapter-')) {
+                        evidence.push(violation(file, sourceImport.node, `Mutation imports effect boundary ${sourceImport.specifier}.`));
+                    }
+                }
+                for (const { node, name } of hasForbiddenGlobalCall(file)) {
+                    evidence.push(violation(file, node, `Mutation definition calls effectful global ${name}.`));
+                }
+                for (const definition of definitionObjects(file, 'defineMutation')) {
+                    const uncertain = definitionOriginAmbiguity(file, definition, 'Mutation definition');
+                    if (uncertain) {
+                        evidence.push(uncertain);
+                        continue;
+                    }
+                    const { object } = definition;
+                    const build = object && callback(object, 'build');
+                    if (!build)
+                        continue;
+                    const builderName = build.parameters[1]?.name;
+                    visitOwnBody(build, (node) => {
+                        if (!ts.isCallExpression(node))
+                            return;
+                        const symbol = importedSymbol(file, node.expression);
+                        const chain = propertyChain(node.expression);
+                        if (builderName && ts.isIdentifier(builderName) && chain?.[0] === builderName.text) {
+                            return;
+                        }
+                        const name = symbol?.name;
+                        if (name && FORBIDDEN_CALLS.has(name)) {
+                            evidence.push(violation(file, node, `Mutation definition invokes ${name}.`));
+                        }
+                        else if (!symbol &&
+                            chain &&
+                            chain.length > 1 &&
+                            FORBIDDEN_CALLS.has(chain.at(-1) ?? '')) {
+                            evidence.push(ambiguity(file, node, `Mutation call ${chain.join('.')} resembles an excluded operation but its receiver is opaque.`));
+                        }
+                    });
+                }
+            }
+            return evidence;
+        },
+    },
+];
+function machineAssignments(object, machineProperties) {
+    return object.properties.filter((property) => (ts.isPropertyAssignment(property) || ts.isShorthandPropertyAssignment(property)) &&
+        machineProperties.has(staticPropertyName(property) ?? ''));
+}
+function assignedPropertyValue(property) {
+    return ts.isPropertyAssignment(property) ? property.initializer : property.name;
+}
+function hasSpread(object) {
+    return object.properties.some((property) => ts.isSpreadAssignment(property));
+}
+function spreadMaySet(object, name) {
+    let explicit = -1;
+    for (let index = 0; index < object.properties.length; index += 1) {
+        if (staticPropertyName(object.properties[index]) === name)
+            explicit = index;
+    }
+    return object.properties.some((property, index) => ts.isSpreadAssignment(property) && index > explicit);
+}
+function staticStringArray(expression) {
+    const value = unwrap(expression);
+    if (!ts.isArrayLiteralExpression(value))
+        return undefined;
+    const strings = [];
+    for (const element of value.elements) {
+        if (ts.isSpreadElement(element))
+            return undefined;
+        const text = staticText(element);
+        if (text === undefined)
+            return undefined;
+        strings.push({ value: text, node: element });
+    }
+    return strings;
+}
+function typedPatchMachineProperties(project, file, expression, machineProperties) {
+    const resolved = expressionType(project, file, expression);
+    if (resolved === undefined)
+        return undefined;
+    const properties = typePropertyNames(resolved.checker, resolved.type);
+    if (properties === undefined)
+        return undefined;
+    return [...machineProperties.keys()].filter((name) => properties.has(name));
+}
+function typePropertyNames(checker, type) {
+    if (type.flags &
+        (ts.TypeFlags.Any |
+            ts.TypeFlags.Unknown |
+            ts.TypeFlags.Never |
+            ts.TypeFlags.Null |
+            ts.TypeFlags.Undefined)) {
+        return undefined;
+    }
+    if (type.isUnionOrIntersection()) {
+        const properties = new Set();
+        for (const member of type.types) {
+            const names = typePropertyNames(checker, member);
+            if (names === undefined)
+                return undefined;
+            for (const name of names)
+                properties.add(name);
+        }
+        return properties;
+    }
+    const apparent = checker.getApparentType(type);
+    if (apparent.getStringIndexType() !== undefined ||
+        apparent.getNumberIndexType() !== undefined ||
+        !(apparent.flags & ts.TypeFlags.Object)) {
+        return undefined;
+    }
+    return new Set(apparent.getProperties().map(({ name }) => name));
+}
+function mutationBuilderScopes(file) {
+    const mutable = new Map();
+    const pending = [];
+    const add = (fn, binding) => {
+        const bindings = mutable.get(fn) ?? new Set();
+        if (bindings.has(binding))
+            return;
+        bindings.add(binding);
+        mutable.set(fn, bindings);
+        pending.push([fn, binding]);
+    };
+    for (const definition of definitionObjects(file, 'defineMutation')) {
+        if (definition.origin !== 'resolved')
+            continue;
+        const build = definition.object && callback(definition.object, 'build');
+        const builder = build?.parameters[1]?.name;
+        if (build && builder && ts.isIdentifier(builder))
+            add(build, builder);
+    }
+    visit(file.source, (node) => {
+        if (!ts.isCallExpression(node) || !mutationAstBuild(file, node))
+            return;
+        const build = node.arguments[0] && unwrap(node.arguments[0]);
+        if (build &&
+            (ts.isArrowFunction(build) || ts.isFunctionExpression(build)) &&
+            ts.isIdentifier(build.parameters[0]?.name)) {
+            add(build, build.parameters[0].name);
+        }
+    });
+    const richBuilderTypes = new Set();
+    for (const sourceImport of file.imports) {
+        if (sourceImport.specifier !== '@astrale-os/sdk' &&
+            sourceImport.specifier !== '@astrale-os/sdk/mutation') {
+            continue;
+        }
+        for (const [imported, local] of sourceImport.bindings) {
+            if (imported === 'RichMutationBuilder')
+                richBuilderTypes.add(local);
+        }
+    }
+    visit(file.source, (node) => {
+        if (!ts.isFunctionLike(node) || !('body' in node))
+            return;
+        for (const parameter of node.parameters) {
+            if (ts.isIdentifier(parameter.name) &&
+                parameter.type !== undefined &&
+                ts.isTypeReferenceNode(parameter.type) &&
+                ts.isIdentifier(parameter.type.typeName) &&
+                richBuilderTypes.has(parameter.type.typeName.text)) {
+                add(node, parameter.name);
+            }
+        }
+    });
+    const localFunctions = localFunctionBindings(file);
+    for (let index = 0; index < pending.length; index += 1) {
+        const [owner, builder] = pending[index];
+        visitOwnBody(owner, (node) => {
+            if (ts.isVariableDeclaration(node) &&
+                ts.isIdentifier(node.name) &&
+                node.initializer !== undefined &&
+                ts.isIdentifier(unwrap(node.initializer)) &&
+                identifierDeclaration(unwrap(node.initializer)) === builder &&
+                (node.parent.flags & ts.NodeFlags.Const) !== 0) {
+                add(owner, node.name);
+            }
+            if (!ts.isCallExpression(node))
+                return;
+            const callee = unwrap(node.expression);
+            if (!ts.isIdentifier(callee))
+                return;
+            const declaration = identifierDeclaration(callee);
+            const target = declaration && localFunctions.get(declaration);
+            if (!target)
+                return;
+            for (let argumentIndex = 0; argumentIndex < node.arguments.length; argumentIndex += 1) {
+                const argument = unwrap(node.arguments[argumentIndex]);
+                const parameter = target.parameters[argumentIndex]?.name;
+                if (ts.isIdentifier(argument) &&
+                    identifierDeclaration(argument) === builder &&
+                    parameter &&
+                    ts.isIdentifier(parameter)) {
+                    add(target, parameter);
+                }
+            }
+        });
+    }
+    return mutable;
+}
+function mutationAstBuild(file, call) {
+    const expression = unwrap(call.expression);
+    if (!ts.isPropertyAccessExpression(expression) || expression.name.text !== 'build')
+        return false;
+    const owner = unwrap(expression.expression);
+    const symbol = importedSymbol(file, owner);
+    return (symbol?.name === 'MutationAST' &&
+        (symbol.module === '@astrale-os/sdk' || symbol.module === '@astrale-os/sdk/mutation'));
+}
+function mutationBuilderMember(call, scopes) {
+    const owner = containingFunction(call);
+    const builders = owner && scopes.get(owner);
+    if (!owner || !builders)
+        return undefined;
+    const expression = unwrap(call.expression);
+    if (ts.isPropertyAccessExpression(expression)) {
+        const receiver = unwrap(expression.expression);
+        return ts.isIdentifier(receiver) && builders.has(identifierDeclaration(receiver))
+            ? expression.name.text
+            : undefined;
+    }
+    if (ts.isElementAccessExpression(expression)) {
+        const receiver = unwrap(expression.expression);
+        return ts.isIdentifier(receiver) && builders.has(identifierDeclaration(receiver))
+            ? staticText(expression.argumentExpression)
+            : undefined;
+    }
+    if (!ts.isIdentifier(expression))
+        return undefined;
+    return destructuredBuilderMember(expression, builders);
+}
+function mutationBuilderOperation(call, scopes) {
+    const owner = containingFunction(call);
+    const builders = owner && scopes.get(owner);
+    if (!owner || !builders)
+        return undefined;
+    const chain = propertyChain(call.expression);
+    if (!chain || chain.length < 2)
+        return mutationBuilderMember(call, scopes);
+    const root = firstIdentifier(unwrap(call.expression));
+    if (!root || !builders.has(identifierDeclaration(root)))
+        return undefined;
+    return chain.slice(1).join('.');
+}
+function firstIdentifier(expression) {
+    let current = expression;
+    while (ts.isPropertyAccessExpression(current) || ts.isElementAccessExpression(current)) {
+        current = unwrap(current.expression);
+    }
+    return ts.isIdentifier(current) ? current : undefined;
+}
+function classOperationForBuilder(operation) {
+    switch (operation) {
+        case 'createNode':
+        case 'createEdge':
+            return 'create';
+        case 'expect.node':
+        case 'expect.edge':
+            return 'read';
+        case 'updateNode':
+        case 'updateEdge':
+        case 'transition':
+            return 'update';
+        case 'deleteNode':
+        case 'deleteEdge':
+            return 'delete';
+        default:
+            return undefined;
+    }
+}
+function dependencyClassTarget(expression) {
+    const chain = staticPropertyChain(expression);
+    if (!chain)
+        return undefined;
+    const dependency = chain.indexOf('dependencies');
+    const suffix = chain.at(-1) === 'key' ? chain.slice(0, -1) : chain;
+    if (dependency < 0 || suffix.length !== dependency + 4 || suffix[dependency + 2] !== 'classes') {
+        return undefined;
+    }
+    return { dependency: suffix[dependency + 1], className: suffix[dependency + 3] };
+}
+function expressionSelectsDependency(expression) {
+    const chain = staticPropertyChain(expression);
+    return chain?.includes('dependencies') ?? false;
+}
+function kernelProvisionCall(call) {
+    const chain = propertyChain(call.expression);
+    if (chain?.length === 4 &&
+        chain[0] === 'kernel' &&
+        chain[1] === 'self' &&
+        chain[2] === 'auth' &&
+        chain[3] === 'provision') {
+        const root = firstIdentifier(unwrap(call.expression));
+        return root !== undefined && parameterProperty(root, 'kernel');
+    }
+    return false;
+}
+/** Only context-owned Client calls in publicly resolved SDK handlers, not lookalike objects. */
+function kernelRegisterCalls(file) {
+    const result = [];
+    for (const { call: factory, origin } of [
+        ...calls(file, 'defineAction'),
+        ...calls(file, 'defineWorkflow'),
+    ]) {
+        if (origin !== 'resolved')
+            continue;
+        const definition = ts.isCallExpression(factory.parent) && factory.parent.expression === factory
+            ? factory.parent
+            : factory;
+        const argument = definition.arguments.at(-1);
+        const handler = argument && unwrap(argument);
+        if (!handler || (!ts.isArrowFunction(handler) && !ts.isFunctionExpression(handler)))
+            continue;
+        const parameter = handler.parameters[0]?.name;
+        if (!parameter)
+            continue;
+        const roots = [];
+        if (ts.isIdentifier(parameter))
+            roots.push({ declaration: parameter, prefix: [parameter.text, 'client'] });
+        else if (ts.isObjectBindingPattern(parameter)) {
+            for (const element of parameter.elements) {
+                const property = element.propertyName ?? element.name;
+                if (ts.isIdentifier(element.name) &&
+                    ts.isIdentifier(property) &&
+                    property.text === 'client')
+                    roots.push({ declaration: element.name, prefix: [element.name.text] });
+            }
+        }
+        visit(handler, (node) => {
+            if (!ts.isCallExpression(node))
+                return;
+            const chain = propertyChain(node.expression);
+            const root = firstIdentifier(unwrap(node.expression));
+            if (!chain || !root)
+                return;
+            if (roots.some(({ declaration, prefix }) => identifierDeclaration(root) === declaration &&
+                chain.join('.') === [...prefix, 'auth', 'register'].join('.')))
+                result.push(node);
+        });
+    }
+    return result;
+}
+function parameterProperty(use, sourceName) {
+    const binding = identifierDeclaration(use);
+    if (binding === undefined)
+        return false;
+    if (ts.isParameter(binding.parent) && binding.parent.name === binding) {
+        return binding.text === sourceName;
+    }
+    const element = binding.parent;
+    if (!ts.isBindingElement(element) ||
+        element.name !== binding ||
+        !ts.isObjectBindingPattern(element.parent) ||
+        !ts.isParameter(element.parent.parent)) {
+        return false;
+    }
+    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);
+    if (!file)
+        return emptyPlanRequirements(true);
+    const applications = [];
+    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 (applications.length !== 1)
+        return emptyPlanRequirements(true);
+    const input = staticObject(applications[0].arguments[0]);
+    const requirementValue = input && assignedValue(input, 'requirements');
+    if (requirementValue === undefined)
+        return emptyPlanRequirements(false);
+    const requirementCall = staticCall(requirementValue);
+    const requirementSymbol = requirementCall && importedSymbol(file, requirementCall.expression);
+    if (!requirementCall ||
+        requirementSymbol?.name !== 'requirements' ||
+        (requirementSymbol.module !== '@astrale-os/sdk' &&
+            requirementSymbol.module !== '@astrale-os/sdk/application')) {
+        return emptyPlanRequirements(true);
+    }
+    const definition = staticObject(requirementCall.arguments[0]);
+    if (!definition)
+        return emptyPlanRequirements(requirementCall.arguments[0] !== undefined);
+    const functions = new Set();
+    const classes = new Set();
+    let indeterminate = false;
+    const functionValues = staticArray(assignedValue(definition, 'functions'));
+    if (assignedValue(definition, 'functions') !== undefined && !functionValues)
+        indeterminate = true;
+    for (const value of functionValues?.elements ?? []) {
+        if (!ts.isExpression(value)) {
+            indeterminate = true;
+            continue;
+        }
+        const chain = staticPropertyChain(value);
+        if (chain?.at(-2) !== 'functions' || chain.at(-1) === undefined)
+            indeterminate = true;
+        else
+            functions.add(chain.at(-1));
+    }
+    const classValues = staticArray(assignedValue(definition, 'classes'));
+    if (assignedValue(definition, 'classes') !== undefined && !classValues)
+        indeterminate = true;
+    for (const value of classValues?.elements ?? []) {
+        if (!ts.isExpression(value)) {
+            indeterminate = true;
+            continue;
+        }
+        const object = staticObject(value);
+        const selected = object && assignedValue(object, 'class');
+        const target = selected && resolvedDependencyClassTarget(file, selected);
+        const operationValue = object && assignedValue(object, 'operations');
+        const operations = operationValue && staticStringArray(operationValue);
+        if (!target || !operations || operations.length === 0) {
+            indeterminate = true;
+            continue;
+        }
+        for (const { value: operation } of operations) {
+            if (operation === 'create' ||
+                operation === 'read' ||
+                operation === 'update' ||
+                operation === 'delete') {
+                classes.add(classRequirementKey(target.dependency, target.className, operation));
+            }
+            else if (operation !== 'traverse') {
+                indeterminate = true;
+            }
+        }
+    }
+    return { functions, classes, indeterminate };
+}
+function emptyPlanRequirements(indeterminate) {
+    return { functions: new Set(), classes: new Set(), indeterminate };
+}
+function staticCall(expression) {
+    const value = unwrap(expression);
+    if (ts.isIdentifier(value)) {
+        const initializer = visibleConstInitializer(value);
+        return initializer && staticCall(initializer);
+    }
+    return ts.isCallExpression(value) ? value : undefined;
+}
+function resolvedDependencyClassTarget(file, expression) {
+    let current = unwrap(expression);
+    const selector = [];
+    while (ts.isPropertyAccessExpression(current)) {
+        selector.unshift(current.name.text);
+        current = unwrap(current.expression);
+    }
+    if (selector.length !== 4 ||
+        selector[0] !== 'dependencies' ||
+        selector[2] !== 'classes' ||
+        !ts.isCallExpression(current)) {
+        return undefined;
+    }
+    const resolve = unwrap(current.expression);
+    if (!ts.isPropertyAccessExpression(resolve) || resolve.name.text !== 'resolve')
+        return undefined;
+    const schema = importedSymbol(file, resolve.expression);
+    if (schema?.name !== 'schema' || schema.module !== '@astrale-os/sdk/schema')
+        return undefined;
+    return { dependency: selector[1], className: selector[3] };
+}
+function classRequirementKey(dependency, className, operation) {
+    return `${dependency}\0${className}\0${operation}`;
+}
+function destructuredBuilderMember(callee, builders) {
+    const calleeBinding = identifierDeclaration(callee);
+    const element = calleeBinding?.parent;
+    if (!element ||
+        !ts.isBindingElement(element) ||
+        element.dotDotDotToken !== undefined ||
+        element.name !== calleeBinding ||
+        !ts.isObjectBindingPattern(element.parent)) {
+        return undefined;
+    }
+    const declaration = element.parent.parent;
+    if (!ts.isVariableDeclaration(declaration))
+        return undefined;
+    const initializer = declaration.initializer && unwrap(declaration.initializer);
+    if (!initializer ||
+        !ts.isIdentifier(initializer) ||
+        !builders.has(identifierDeclaration(initializer))) {
+        return undefined;
+    }
+    const member = element.propertyName ?? element.name;
+    return ts.isIdentifier(member) || ts.isStringLiteral(member) ? member.text : undefined;
+}
+function localFunctionBindings(file) {
+    const functions = new Map();
+    const record = (binding, fn) => {
+        functions.set(binding, fn);
+    };
+    visit(file.source, (node) => {
+        if (ts.isFunctionDeclaration(node) && node.name) {
+            record(node.name, node);
+            return;
+        }
+        if (!ts.isVariableDeclaration(node) || !ts.isIdentifier(node.name) || !node.initializer)
+            return;
+        const value = unwrap(node.initializer);
+        if (ts.isArrowFunction(value) || ts.isFunctionExpression(value)) {
+            record(node.name, value);
+        }
+    });
+    return functions;
+}
+function identifierDeclaration(use) {
+    let current = use.parent;
+    while (current !== undefined) {
+        if (ts.isBlock(current) || ts.isSourceFile(current)) {
+            const binding = directBlockBinding(current, use.text);
+            if (binding !== undefined)
+                return binding;
+        }
+        if (ts.isFunctionLike(current)) {
+            for (const parameter of current.parameters) {
+                const binding = bindingIdentifier(parameter.name, use.text);
+                if (binding !== undefined)
+                    return binding;
+            }
+        }
+        if (ts.isCatchClause(current) && current.variableDeclaration !== undefined) {
+            const binding = bindingIdentifier(current.variableDeclaration.name, use.text);
+            if (binding !== undefined)
+                return binding;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+function directBlockBinding(block, name) {
+    for (const statement of block.statements) {
+        if (ts.isFunctionDeclaration(statement) && statement.name?.text === name) {
+            return statement.name;
+        }
+        if (!ts.isVariableStatement(statement))
+            continue;
+        for (const declaration of statement.declarationList.declarations) {
+            const binding = bindingIdentifier(declaration.name, name);
+            if (binding !== undefined)
+                return binding;
+        }
+    }
+    return undefined;
+}
+function bindingIdentifier(binding, name) {
+    if (ts.isIdentifier(binding))
+        return binding.text === name ? binding : undefined;
+    for (const element of binding.elements) {
+        if (ts.isOmittedExpression(element))
+            continue;
+        const identifier = bindingIdentifier(element.name, name);
+        if (identifier !== undefined)
+            return identifier;
+    }
+    return undefined;
+}
+function containingFunction(node) {
+    let current = node.parent;
+    while (current) {
+        if (ts.isFunctionLike(current) && 'body' in current) {
+            return current;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+function machinePropertiesByClass(project) {
+    const all = new Map();
+    const mutableByClass = new Map();
+    const ambiguousByClass = new Map();
+    const ownerSources = new Map();
+    const record = (file, owner, name, value) => {
+        const machine = statePropertyIdentity(project, file, value);
+        if (machine.kind === 'resolved') {
+            const identities = all.get(name) ?? new Set();
+            identities.add(machine.identity);
+            all.set(name, identities);
+            if (owner !== undefined) {
+                const sources = ownerSources.get(owner) ?? new Set();
+                sources.add(`${file.path}#${owner}`);
+                ownerSources.set(owner, sources);
+                const properties = mutableByClass.get(owner) ?? new Map();
+                properties.set(name, machine.identity);
+                mutableByClass.set(owner, properties);
+            }
+        }
+        else if (machine.kind === 'ambiguous' && owner !== undefined) {
+            const sources = ownerSources.get(owner) ?? new Set();
+            sources.add(`${file.path}#${owner}`);
+            ownerSources.set(owner, sources);
+            const names = ambiguousByClass.get(owner) ?? new Set();
+            names.add(name);
+            ambiguousByClass.set(owner, names);
+        }
+    };
+    for (const file of production(project, 'schema')) {
+        visit(file.source, (node) => {
+            if (ts.isPropertyAssignment(node) || ts.isShorthandPropertyAssignment(node)) {
+                const name = staticPropertyName(node);
+                if (name === undefined || !isPropertiesMember(node))
+                    return;
+                const value = ts.isPropertyAssignment(node) ? node.initializer : node.name;
+                record(file, containingVariableName(node), name, value);
+                return;
+            }
+            if (ts.isSpreadAssignment(node) && isPropertiesObject(node.parent)) {
+                const owner = containingVariableName(node);
+                const spread = staticObject(node.expression);
+                if (spread !== undefined) {
+                    for (const entry of spread.properties) {
+                        if (!ts.isPropertyAssignment(entry) && !ts.isShorthandPropertyAssignment(entry)) {
+                            continue;
+                        }
+                        const name = staticPropertyName(entry);
+                        if (name === undefined)
+                            continue;
+                        record(file, owner, name, ts.isPropertyAssignment(entry) ? entry.initializer : entry.name);
+                    }
+                }
+                else if (owner !== undefined) {
+                    const machine = statePropertyIdentity(project, file, node.expression);
+                    if (machine.kind !== 'absent') {
+                        const names = ambiguousByClass.get(owner) ?? new Set();
+                        names.add('<spread>');
+                        ambiguousByClass.set(owner, names);
+                    }
+                }
+            }
+        });
+    }
+    for (const [owner, sources] of ownerSources) {
+        if (sources.size <= 1)
+            continue;
+        const names = ambiguousByClass.get(owner) ?? new Set();
+        for (const name of mutableByClass.get(owner)?.keys() ?? [])
+            names.add(name);
+        ambiguousByClass.set(owner, names);
+        mutableByClass.delete(owner);
+    }
+    const topology = classTopology(project);
+    inheritMachineProperties(topology.parents, mutableByClass, ambiguousByClass);
+    for (const file of production(project, 'schema')) {
+        for (const definition of definitionObjects(file, 'defineSchema', undefined, DSL_MODULES, 1)) {
+            if (definition.origin !== 'resolved')
+                continue;
+            const classesValue = definition.object && assignedValue(definition.object, 'classes');
+            const classes = staticObject(classesValue);
+            if (!classes)
+                continue;
+            for (const entry of classes.properties) {
+                if (!ts.isPropertyAssignment(entry) && !ts.isShorthandPropertyAssignment(entry))
+                    continue;
+                const publicName = staticPropertyName(entry);
+                const value = ts.isPropertyAssignment(entry) ? unwrap(entry.initializer) : entry.name;
+                if (publicName === undefined || !ts.isIdentifier(value))
+                    continue;
+                const sourceName = value.text;
+                const ambiguous = ambiguousByClass.get(sourceName);
+                if (ambiguous !== undefined) {
+                    const names = ambiguousByClass.get(publicName) ?? new Set();
+                    for (const name of ambiguous)
+                        names.add(name);
+                    ambiguousByClass.set(publicName, names);
+                }
+                const source = mutableByClass.get(sourceName);
+                if (source === undefined || sourceName === publicName)
+                    continue;
+                const target = mutableByClass.get(publicName);
+                if (target === undefined) {
+                    mutableByClass.set(publicName, new Map(source));
+                    continue;
+                }
+                for (const [name, identity] of source) {
+                    const prior = target.get(name);
+                    if (prior === undefined || prior === identity) {
+                        target.set(name, identity);
+                    }
+                    else {
+                        const names = ambiguousByClass.get(publicName) ?? new Set();
+                        names.add(name);
+                        ambiguousByClass.set(publicName, names);
+                    }
+                }
+            }
+        }
+    }
+    return {
+        all,
+        byClass: mutableByClass,
+        ambiguousByClass,
+        ...topology,
+    };
+}
+function inheritMachineProperties(parents, byClass, ambiguousByClass) {
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const [owner, inherited] of parents) {
+            for (const parent of inherited) {
+                const ambiguous = ambiguousByClass.get(parent);
+                if (ambiguous !== undefined) {
+                    const target = ambiguousByClass.get(owner) ?? new Set();
+                    const before = target.size;
+                    for (const name of ambiguous)
+                        target.add(name);
+                    ambiguousByClass.set(owner, target);
+                    if (target.size !== before)
+                        changed = true;
+                }
+                const source = byClass.get(parent);
+                if (source === undefined)
+                    continue;
+                const target = byClass.get(owner) ?? new Map();
+                const before = target.size;
+                for (const [name, identity] of source) {
+                    const prior = target.get(name);
+                    if (prior === undefined || prior === identity) {
+                        target.set(name, identity);
+                    }
+                    else {
+                        const names = ambiguousByClass.get(owner) ?? new Set();
+                        const beforeAmbiguous = names.size;
+                        names.add(name);
+                        ambiguousByClass.set(owner, names);
+                        if (names.size !== beforeAmbiguous)
+                            changed = true;
+                    }
+                }
+                byClass.set(owner, target);
+                if (target.size !== before)
+                    changed = true;
+            }
+        }
+    }
+}
+function classTopology(project) {
+    const classes = new Set();
+    const abstractClasses = new Set();
+    const parents = new Map();
+    for (const file of production(project, 'schema')) {
+        visit(file.source, (node) => {
+            if (!ts.isCallExpression(node))
+                return;
+            const symbol = importedSymbol(file, node.expression);
+            if (symbol?.name !== 'nodeClass' || !DSL_MODULES.has(symbol.module))
+                return;
+            const owner = containingVariableName(node);
+            const object = staticObject(node.arguments[0]);
+            if (owner === undefined || object === undefined)
+                return;
+            classes.add(owner);
+            if (assignedValue(object, 'abstract')?.kind === ts.SyntaxKind.TrueKeyword) {
+                abstractClasses.add(owner);
+            }
+            const extended = staticArray(assignedValue(object, 'extends'));
+            if (extended === undefined)
+                return;
+            const names = parents.get(owner) ?? new Set();
+            for (const expression of extended.elements) {
+                if (!ts.isExpression(expression))
+                    continue;
+                const chain = propertyChain(expression) ?? staticPropertyChain(expression);
+                const name = chain?.at(-1);
+                if (name !== undefined)
+                    names.add(name);
+            }
+            parents.set(owner, names);
+        });
+    }
+    return { classes, abstractClasses, parents };
+}
+function containingVariableName(node) {
+    let current = node;
+    while (current && !ts.isSourceFile(current)) {
+        if (ts.isVariableDeclaration(current) && ts.isIdentifier(current.name)) {
+            return current.name.text;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+function propertiesForClass(input, properties) {
+    const selectedClass = assignedValue(input, 'class');
+    const selection = selectedClass && selectedClassNames(selectedClass);
+    if (selection === undefined || !closedClassSelection(selection, properties)) {
+        return { kind: 'ambiguous' };
+    }
+    const resolved = new Map();
+    let hasMachineProperty = false;
+    for (const className of selection) {
+        if ((properties.ambiguousByClass.get(className)?.size ?? 0) > 0) {
+            return { kind: 'ambiguous' };
+        }
+        const selected = properties.byClass.get(className);
+        if (selected === undefined)
+            continue;
+        hasMachineProperty = true;
+        for (const [name, identity] of selected) {
+            const prior = resolved.get(name);
+            if (prior !== undefined && prior !== identity)
+                return { kind: 'ambiguous' };
+            resolved.set(name, identity);
+        }
+    }
+    return hasMachineProperty ? { kind: 'resolved', properties: resolved } : { kind: 'absent' };
+}
+function selectedClassNames(expression, seen = new Set()) {
+    const value = unwrap(expression);
+    if (ts.isConditionalExpression(value)) {
+        const whenTrue = selectedClassNames(value.whenTrue, seen);
+        const whenFalse = selectedClassNames(value.whenFalse, seen);
+        return whenTrue && whenFalse ? new Set([...whenTrue, ...whenFalse]) : undefined;
+    }
+    if (ts.isIdentifier(value)) {
+        if (seen.has(value.text))
+            return undefined;
+        const initializer = visibleConstInitializer(value);
+        if (initializer !== undefined) {
+            const next = new Set(seen);
+            next.add(value.text);
+            return selectedClassNames(initializer, next);
+        }
+    }
+    const chain = staticPropertyChain(value);
+    if (!chain || chain.length < 2)
+        return undefined;
+    const className = chain.at(-1) === 'key' ? chain.at(-2) : chain.at(-1);
+    return className === undefined ? undefined : new Set([className]);
+}
+function closedClassSelection(selection, topology) {
+    if (selection.size === 0)
+        return false;
+    if (selection.size === 1)
+        return true;
+    if ([...selection].some((name) => !topology.classes.has(name)))
+        return false;
+    if ([...selection].some((name) => topology.abstractClasses.has(name)))
+        return false;
+    for (const ancestor of topology.abstractClasses) {
+        if (![...selection].every((name) => ancestorsOf(name, topology.parents).has(ancestor))) {
+            continue;
+        }
+        const descendants = [...topology.classes].filter((name) => !topology.abstractClasses.has(name) && ancestorsOf(name, topology.parents).has(ancestor));
+        if (descendants.length === selection.size && descendants.every((name) => selection.has(name))) {
+            return true;
+        }
+    }
+    return false;
+}
+function ancestorsOf(className, parents) {
+    const ancestors = new Set();
+    const pending = [...(parents.get(className) ?? [])];
+    while (pending.length > 0) {
+        const parent = pending.pop();
+        if (ancestors.has(parent))
+            continue;
+        ancestors.add(parent);
+        pending.push(...(parents.get(parent) ?? []));
+    }
+    return ancestors;
+}
+function hasMachineCandidates(properties) {
+    return properties.all.size > 0 || properties.ambiguousByClass.size > 0;
+}
+function isPropertiesMember(node) {
+    return isPropertiesObject(node.parent);
+}
+function isPropertiesObject(node) {
+    const owner = node.parent;
+    return ts.isPropertyAssignment(owner) && staticPropertyName(owner) === 'properties';
+}
+function staticObject(expression, seen = new Set()) {
+    if (!expression)
+        return undefined;
+    const value = unwrap(expression);
+    if (ts.isIdentifier(value)) {
+        if (seen.has(value.text))
+            return undefined;
+        const initializer = visibleConstInitializer(value);
+        if (initializer !== undefined) {
+            const next = new Set(seen);
+            next.add(value.text);
+            return staticObject(initializer, next);
+        }
+    }
+    return ts.isObjectLiteralExpression(value) ? value : undefined;
+}
+function staticArray(expression) {
+    const value = expression && unwrap(expression);
+    return value && ts.isArrayLiteralExpression(value) ? value : undefined;
+}
+function assignedValue(object, name) {
+    const property = object.properties.find((candidate) => staticPropertyName(candidate) === name);
+    if (property && ts.isPropertyAssignment(property))
+        return property.initializer;
+    return property && ts.isShorthandPropertyAssignment(property) ? property.name : undefined;
+}
+function staticPropertyName(property) {
+    if (!('name' in property) || property.name === undefined)
+        return undefined;
+    if (ts.isIdentifier(property.name) ||
+        ts.isStringLiteral(property.name) ||
+        ts.isNumericLiteral(property.name)) {
+        return property.name.text;
+    }
+    if (!ts.isComputedPropertyName(property.name))
+        return undefined;
+    const literal = staticText(property.name.expression);
+    if (literal !== undefined)
+        return literal;
+    const chain = staticPropertyChain(property.name.expression);
+    return chain?.at(-1) === 'key' ? chain.at(-2) : undefined;
+}
+function initialIdentity(project, file, expression, seen = new Set()) {
+    const value = unwrap(expression);
+    const initialOwner = ts.isPropertyAccessExpression(value) && value.name.text === 'initial'
+        ? value.expression
+        : ts.isElementAccessExpression(value) && staticText(value.argumentExpression) === 'initial'
+            ? value.expression
+            : undefined;
+    if (initialOwner !== undefined) {
+        return stateMachineIdentity(project, file, initialOwner);
+    }
+    if (ts.isIdentifier(value)) {
+        if (seen.has(value.text))
+            return { kind: 'ambiguous' };
+        const initializer = visibleConstInitializer(value);
+        if (initializer !== undefined) {
+            const next = new Set(seen);
+            next.add(value.text);
+            return initialIdentity(project, file, initializer, next);
+        }
+    }
+    return { kind: 'absent' };
+}
+function staticTextValue(expression, seen = new Set()) {
+    const text = staticText(expression);
+    if (text !== undefined || expression === undefined)
+        return text;
+    const value = unwrap(expression);
+    if (!ts.isIdentifier(value) || seen.has(value.text))
+        return undefined;
+    const initializer = visibleConstInitializer(value);
+    if (initializer === undefined)
+        return undefined;
+    const next = new Set(seen);
+    next.add(value.text);
+    return staticTextValue(initializer, next);
+}
+function staticPropertyChain(expression, seen = new Set()) {
+    const chain = propertyChain(expression);
+    if (chain !== undefined && chain.length > 1)
+        return chain;
+    const value = unwrap(expression);
+    if (!ts.isIdentifier(value) || seen.has(value.text))
+        return chain;
+    const initializer = visibleConstInitializer(value);
+    if (initializer === undefined)
+        return chain;
+    const next = new Set(seen);
+    next.add(value.text);
+    return staticPropertyChain(initializer, next);
+}
+function visibleConstInitializer(identifier) {
+    let current = identifier.parent;
+    while (current) {
+        if (ts.isBlock(current) || ts.isSourceFile(current)) {
+            let match;
+            for (const statement of current.statements) {
+                if (statement.getStart() >= identifier.getStart())
+                    break;
+                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 === identifier.text &&
+                        declaration.initializer !== undefined) {
+                        match = declaration.initializer;
+                    }
+                }
+            }
+            if (match !== undefined)
+                return match;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+function referencesIdentifier(arguments_, name) {
+    let found = false;
+    for (const argument of arguments_) {
+        visit(argument, (node) => {
+            if (ts.isIdentifier(node) && node.text === name)
+                found = true;
+        });
+    }
+    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;
+    if (!ts.isBlock(fn.body))
+        return 1;
+    let count = 0;
+    const walk = (node) => {
+        if (node !== fn && ts.isFunctionLike(node))
+            return;
+        if (ts.isReturnStatement(node) && node.expression)
+            count += 1;
+        node.forEachChild(walk);
+    };
+    fn.body.forEachChild(walk);
+    return count;
+}