modality-ts 0.0.1 → 0.0.3

package/dist/extraction/index.d.ts

@@ -25,7 +25,7 @@ export interface UseStateExtractionResult {
 export interface ExtractedModelSkeleton extends UseStateExtractionResult {
     transitions: Transition[];
 }
-export declare function inferDomainFromTypeNode(node: ts.TypeNode | undefined): AbstractDomain;
+export declare function inferDomainFromTypeNode(node: ts.TypeNode | undefined, typeAliases?: ReadonlyMap<string, ts.TypeNode>): AbstractDomain;
 export declare function extractUseStateVars(sourceText: string, options?: UseStateExtractionOptions): UseStateExtractionResult;
 export declare function extractUseStateSkeleton(sourceText: string, options?: UseStateExtractionOptions): ExtractedModelSkeleton;
 //# sourceMappingURL=index.d.ts.map

package/dist/extraction/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/extraction/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,KAAK,EAAE,cAAc,EAA6B,YAAY,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AACrH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAE/B,MAAM,WAAW,yBAAyB;IACxC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,KAAK,CAAC;QAAC,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE,CAAC,CAAC;IAClE,SAAS,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IACpC,aAAa,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;CACzC;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,YAAY,EAAE,CAAC;IACrB,QAAQ,EAAE,iBAAiB,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,sBAAuB,SAAQ,wBAAwB;IACtE,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B;AA0CD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,GAAG,SAAS,GAAG,cAAc,CAuBrF;AAED,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,GAAE,yBAA8B,GAAG,wBAAwB,CAEzH;AAED,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,GAAE,yBAA8B,GAAG,sBAAsB,CAyI3H"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/extraction/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,KAAK,EAAE,cAAc,EAA6B,YAAY,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AACrH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAE/B,MAAM,WAAW,yBAAyB;IACxC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,KAAK,CAAC;QAAC,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE,CAAC,CAAC;IAClE,SAAS,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IACpC,aAAa,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;CACzC;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,YAAY,EAAE,CAAC;IACrB,QAAQ,EAAE,iBAAiB,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,sBAAuB,SAAQ,wBAAwB;IACtE,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B;AA0CD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,GAAG,SAAS,EAAE,WAAW,GAAE,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC,QAAQ,CAAa,GAAG,cAAc,CAuBhJ;AAED,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,GAAE,yBAA8B,GAAG,wBAAwB,CAEzH;AAED,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,GAAE,yBAA8B,GAAG,sBAAsB,CA4I3H"}

package/dist/extraction/index.js

@@ -11,7 +11,7 @@ function setterBindingFromDecl(decl) {
         domain: decl.domain
     };
 }
-export function inferDomainFromTypeNode(node) {
+export function inferDomainFromTypeNode(node, typeAliases = new Map()) {
     if (!node)
         return { kind: "tokens", count: 1 };
     switch (node.kind) {
@@ -25,13 +25,13 @@ export function inferDomainFromTypeNode(node) {
         case ts.SyntaxKind.LiteralType:
             return domainFromLiteralType(node);
         case ts.SyntaxKind.UnionType:
-            return domainFromUnion(node);
+            return domainFromUnion(node, typeAliases);
         case ts.SyntaxKind.TypeLiteral:
             return domainFromTypeLiteral(node);
         case ts.SyntaxKind.ArrayType:
             return { kind: "lengthCat" };
         case ts.SyntaxKind.TypeReference:
-            return domainFromTypeReference(node);
+            return domainFromTypeReference(node, typeAliases);
         default:
             return { kind: "tokens", count: 1 };
     }
@@ -42,6 +42,7 @@ export function extractUseStateVars(sourceText, options = {}) {
 export function extractUseStateSkeleton(sourceText, options = {}) {
     const fileName = options.fileName ?? "App.tsx";
     const source = ts.createSourceFile(fileName, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+    const typeAliases = typeAliasDeclarations(source);
     const vars = options.stateVars ? [...options.stateVars] : [];
     const transitions = [];
     const warnings = [];
@@ -67,8 +68,10 @@ export function extractUseStateSkeleton(sourceText, options = {}) {
         if (!componentName && isCustomHookDeclaration(node))
             return;
         const nextComponent = componentNameFor(node) ?? componentName;
-        if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && isExtractableHandler(node.initializer)) {
-            handlers.set(node.name.text, node.initializer);
+        if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
+            const handler = extractableHandlerInitializer(node.initializer);
+            if (handler)
+                handlers.set(node.name.text, handler);
         }
         if (ts.isVariableDeclaration(node) && node.initializer && isUseReducerCall(node.initializer)) {
             warnings.push({ message: `Unsupported useReducer ${nextComponent ?? "Anonymous"}.useReducer`, ...lineAndColumn(source, node) });
@@ -96,7 +99,7 @@ export function extractUseStateSkeleton(sourceText, options = {}) {
             const stateName = node.name.elements[0];
             const setterName = node.name.elements[1];
             if (ts.isBindingElement(stateName) && ts.isIdentifier(stateName.name)) {
-                const domain = inferUseStateDomain(node.initializer);
+                const domain = inferUseStateDomain(node.initializer, typeAliases);
                 const component = nextComponent ?? "Anonymous";
                 const varId = `local:${component}.${stateName.name.text}`;
                 if (!options.stateVars) {
@@ -159,9 +162,10 @@ export function extractUseStateSkeleton(sourceText, options = {}) {
                 ts.forEachChild(node, (child) => visit(child, nextComponent));
                 return;
             }
+            const guardLocals = componentGuardLocalsFor(node, setters);
             const guard = combineParsedGuards([
-                renderGuardFor(node, setters, warnings, source, nextComponent ?? "Anonymous"),
-                disabledGuardFor(node, setters, warnings, source, nextComponent ?? "Anonymous")
+                renderGuardFor(node, setters, warnings, source, nextComponent ?? "Anonymous", guardLocals),
+                disabledGuardFor(node, setters, warnings, source, nextComponent ?? "Anonymous", guardLocals)
             ]);
             const extracted = transitionsFromJsxAttribute(source, fileName, node, setters, handlers, nextComponent ?? "Anonymous", effectApis, options.asyncOutcomes ?? {}, guard, warnings);
             transitions.push(...extracted);
@@ -223,10 +227,10 @@ function shortHash(value) {
     }
     return (hash >>> 0).toString(36).padStart(6, "0").slice(0, 6);
 }
-function inferUseStateDomain(call) {
+function inferUseStateDomain(call, typeAliases = new Map()) {
     const typeArg = call.typeArguments?.[0];
     if (typeArg)
-        return inferDomainFromTypeNode(typeArg);
+        return inferDomainFromTypeNode(typeArg, typeAliases);
     const initial = call.arguments[0];
     if (!initial)
         return { kind: "tokens", count: 1 };
@@ -289,10 +293,10 @@ function domainFromLiteralType(node) {
         return { kind: "option", inner: { kind: "tokens", count: 1 } };
     return { kind: "tokens", count: 1 };
 }
-function domainFromUnion(node) {
+function domainFromUnion(node, typeAliases = new Map()) {
     const nonNull = node.types.filter((part) => part.kind !== ts.SyntaxKind.UndefinedKeyword && !(ts.isLiteralTypeNode(part) && part.literal.kind === ts.SyntaxKind.NullKeyword));
     if (nonNull.length !== node.types.length && nonNull.length > 0) {
-        return { kind: "option", inner: nonNull.length === 1 ? inferDomainFromTypeNode(nonNull[0]) : domainFromUnionMembers(nonNull) };
+        return { kind: "option", inner: nonNull.length === 1 ? inferDomainFromTypeNode(nonNull[0], typeAliases) : domainFromUnionMembers(nonNull) };
     }
     return domainFromUnionMembers(node.types);
 }
@@ -353,14 +357,27 @@ function domainFromTypeLiteral(node, omitField) {
     }
     return { kind: "record", fields };
 }
-function domainFromTypeReference(node) {
+function domainFromTypeReference(node, typeAliases = new Map()) {
     const name = node.typeName.getText();
+    const alias = typeAliases.get(name);
+    if (alias)
+        return inferDomainFromTypeNode(alias, typeAliases);
     if ((name === "Array" || name === "ReadonlyArray") && node.typeArguments?.length === 1)
         return { kind: "lengthCat" };
     if (name === "Record")
         return { kind: "tokens", count: 1 };
     return { kind: "tokens", count: 1 };
 }
+function typeAliasDeclarations(source) {
+    const aliases = new Map();
+    const visit = (node) => {
+        if (ts.isTypeAliasDeclaration(node) && ts.isIdentifier(node.name))
+            aliases.set(node.name.text, node.type);
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    return aliases;
+}
 function isUseStateCall(node) {
     return ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "useState";
 }
@@ -376,6 +393,15 @@ function isUseEffectCall(node) {
 function isExtractableHandler(node) {
     return ts.isArrowFunction(node) || ts.isFunctionExpression(node);
 }
+function extractableHandlerInitializer(node) {
+    if (isExtractableHandler(node))
+        return node;
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "useCallback") {
+        const callback = node.arguments[0];
+        return callback && isExtractableHandler(callback) ? callback : undefined;
+    }
+    return undefined;
+}
 function refSetterTaint(node, setters) {
     if (ts.isVariableDeclaration(node) && node.initializer && isUseRefCall(node.initializer)) {
         const arg = node.initializer.arguments[0];
@@ -504,9 +530,10 @@ function transitionsFromComponentPropAttribute(source, fileName, node, setters,
     const handler = handlerExpression(expression, handlers);
     if (!handler)
         return [];
+    const guardLocals = componentGuardLocalsFor(node, setters);
     const callerGuard = combineParsedGuards([
-        renderGuardFor(node, setters, warnings, source, component),
-        disabledGuardFor(node, setters, warnings, source, component)
+        renderGuardFor(node, setters, warnings, source, component, guardLocals),
+        disabledGuardFor(node, setters, warnings, source, component, guardLocals)
     ]);
     return tagStableIdKey(transitionsFromResolvedHandler(source, fileName, node, trigger.attr, handler, setters, handlers, component, effectApis, asyncOutcomes, combineParsedGuards([trigger.guard, callerGuard]), trigger.locator, warnings), handler);
 }
@@ -578,7 +605,7 @@ function transitionsFromResolvedHandler(source, fileName, node, attr, handler, s
     const loopTransitions = loopWriteTransitions(source, fileName, node, attr, handler, setters, component, locator);
     if (loopTransitions.length > 0)
         return applyParsedGuard(loopTransitions, disabledGuard);
-    const sequentialTransition = sequentialTransitionFromHandler(source, fileName, node, attr, handler, setters, component, locator);
+    const sequentialTransition = sequentialTransitionFromHandler(source, fileName, node, attr, handler, setters, handlers, component, locator);
     if (sequentialTransition)
         return applyParsedGuard([sequentialTransition], disabledGuard);
     const summary = callSummaryFromHandler(handler, setters);
@@ -590,6 +617,9 @@ function transitionsFromResolvedHandler(source, fileName, node, attr, handler, s
     const navigation = navigationTransition(source, fileName, node, attr, component, inlinedCall, locator);
     if (navigation)
         return applyParsedGuard([navigation], disabledGuard);
+    const swrMutate = swrMutateTransition(source, fileName, node, attr, component, inlinedCall, locator);
+    if (swrMutate)
+        return applyParsedGuard([swrMutate], disabledGuard);
     const setterCall = setterCallFrom(inlinedCall, setters);
     if (!setterCall) {
         const escaped = escapedSetters(inlinedCall, setters);
@@ -617,7 +647,7 @@ function transitionsFromResolvedHandler(source, fileName, node, attr, handler, s
             confidence: "exact"
         }], disabledGuard);
 }
-function sequentialTransitionFromHandler(source, fileName, node, attr, handler, setters, component, locator) {
+function sequentialTransitionFromHandler(source, fileName, node, attr, handler, setters, handlers, component, locator) {
     if (!ts.isBlock(handler.body))
         return undefined;
     const locals = new Map();
@@ -625,6 +655,11 @@ function sequentialTransitionFromHandler(source, fileName, node, attr, handler,
     for (const statement of handler.body.statements) {
         if (bindConstStatement(statement, setters, locals))
             continue;
+        const helper = helperSummariesFromStatement(statement, handlers, setters);
+        if (helper) {
+            summaries.push(...helper);
+            continue;
+        }
         const summary = summarizeSetterStatement(statement, setters, locals);
         if (!summary)
             return undefined;
@@ -646,6 +681,23 @@ function sequentialTransitionFromHandler(source, fileName, node, attr, handler,
         confidence: effects.some((effect) => effect.kind === "havoc") ? "over-approx" : "exact"
     };
 }
+function helperSummariesFromStatement(statement, handlers, setters) {
+    if (!ts.isExpressionStatement(statement) || !ts.isCallExpression(statement.expression) || !ts.isIdentifier(statement.expression.expression))
+        return undefined;
+    const helper = handlers.get(statement.expression.expression.text);
+    if (!helper || !ts.isBlock(helper.body))
+        return undefined;
+    const locals = new Map();
+    const summaries = [];
+    for (const child of helper.body.statements) {
+        if (bindConstStatement(child, setters, locals))
+            continue;
+        const summary = summarizeSetterStatement(child, setters, locals);
+        if (summary)
+            summaries.push(summary);
+    }
+    return summaries.length > 0 ? summaries : undefined;
+}
 function loopWriteTransitions(source, fileName, node, attr, handler, setters, component, locator) {
     if (!ts.isBlock(handler.body))
         return [];
@@ -711,6 +763,11 @@ function havocSetterTransition(source, fileName, node, attr, component, setter,
     };
 }
 function setterArgumentExpr(argument, setter, setters, locals) {
+    if (ts.isObjectLiteralExpression(argument)) {
+        const object = objectLiteralAssignmentExpr(argument, setter.domain, setters, locals);
+        if (object)
+            return object;
+    }
     if ((ts.isArrowFunction(argument) || ts.isFunctionExpression(argument)) && argument.parameters.length === 1 && ts.isIdentifier(argument.parameters[0].name)) {
         if (ts.isBlock(argument.body))
             return undefined;
@@ -718,11 +775,42 @@ function setterArgumentExpr(argument, setter, setters, locals) {
     }
     return valueExpr(argument, setters, locals);
 }
+function objectLiteralAssignmentExpr(expression, domain, setters, locals) {
+    const value = {};
+    const reads = new Set();
+    const fields = domain.kind === "record" ? domain.fields : domain.kind === "tagged" ? taggedFieldsForObject(expression, domain) : {};
+    for (const property of expression.properties) {
+        if (!ts.isPropertyAssignment(property))
+            return undefined;
+        const name = propertyName(property.name);
+        if (!name)
+            return undefined;
+        const literal = literalValue(property.initializer);
+        if (literal !== undefined) {
+            value[name] = literal;
+            continue;
+        }
+        const bound = valueExpr(property.initializer, setters, locals);
+        if (bound?.expr.kind === "lit") {
+            value[name] = bound.expr.value;
+            bound.reads.forEach((read) => reads.add(read));
+            continue;
+        }
+        value[name] = firstValue(fields[name] ?? { kind: "tokens", count: 1 });
+    }
+    return { expr: { kind: "lit", value }, reads: [...reads] };
+}
+function taggedFieldsForObject(expression, domain) {
+    const tagProperty = expression.properties.find((property) => ts.isPropertyAssignment(property) && propertyName(property.name) === domain.tag);
+    const tag = tagProperty ? literalValue(tagProperty.initializer) : undefined;
+    const variant = typeof tag === "string" ? domain.variants[tag] : undefined;
+    return variant?.kind === "record" ? variant.fields : {};
+}
 function valueExpr(expression, setters, locals) {
     const value = literalValue(expression);
     if (value !== undefined)
         return { expr: { kind: "lit", value }, reads: [] };
-    if (ts.isIdentifier(expression) || ts.isPropertyAccessExpression(expression))
+    if (ts.isIdentifier(expression) || isPropertyAccessLike(expression))
         return modeledReadExpr(expression, setters, locals);
     if (ts.isPrefixUnaryExpression(expression) && expression.operator === ts.SyntaxKind.ExclamationToken) {
         const parsed = booleanExpr(expression.operand, setters, locals);
@@ -731,7 +819,7 @@ function valueExpr(expression, setters, locals) {
     if (ts.isParenthesizedExpression(expression))
         return valueExpr(expression.expression, setters, locals);
     if (ts.isBinaryExpression(expression) && expression.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
-        return nullishOptionalReadExpr(expression, setters);
+        return nullishOptionalReadExpr(expression, setters, locals);
     }
     if (ts.isConditionalExpression(expression)) {
         const condition = booleanExpr(expression.condition, setters, locals);
@@ -775,22 +863,25 @@ function objectSpreadUpdateExpr(expression, setters, locals) {
     }
     return current;
 }
-function nullishOptionalReadExpr(expression, setters) {
-    if (literalValue(expression.right) !== null)
+function nullishOptionalReadExpr(expression, setters, locals = new Map()) {
+    const fallback = literalValue(expression.right);
+    if (fallback === undefined)
         return undefined;
     const read = optionalReadPath(expression.left);
     if (!read?.optional || read.path.length === 0)
         return undefined;
-    const varId = stateVarForName(read.base, setters);
+    const local = locals.get(read.base);
+    const varId = local?.expr.kind === "read" ? local.expr.var : stateVarForName(read.base, setters);
     if (!varId)
         return undefined;
+    const basePath = local?.expr.kind === "read" ? local.expr.path ?? [] : [];
     return {
         expr: {
             kind: "cond",
             args: [
-                { kind: "eq", args: [{ kind: "read", var: varId }, { kind: "lit", value: null }] },
-                { kind: "lit", value: null },
-                { kind: "read", var: varId, path: read.path }
+                { kind: "eq", args: [{ kind: "read", var: varId, ...(basePath.length > 0 ? { path: basePath } : {}) }, { kind: "lit", value: null }] },
+                { kind: "lit", value: fallback },
+                { kind: "read", var: varId, path: [...basePath, ...read.path] }
             ]
         },
         reads: [varId]
@@ -799,7 +890,7 @@ function nullishOptionalReadExpr(expression, setters) {
 function optionalReadPath(expression) {
     if (ts.isIdentifier(expression))
         return { base: expression.text, path: [], optional: false };
-    if (ts.isPropertyAccessExpression(expression)) {
+    if (isPropertyAccessLike(expression)) {
         const base = optionalReadPath(expression.expression);
         if (!base)
             return undefined;
@@ -875,9 +966,13 @@ function modeledReadExpr(expression, setters, locals) {
             reads: local.reads
         };
     }
-    const stateVar = stateVarForName(base, setters);
+    const setter = setterForName(base, setters);
+    const stateVar = setter?.varId;
     if (!stateVar)
         return undefined;
+    if (setter.domain.kind === "tagged" && segments.length > 0 && segments[0] !== setter.domain.tag) {
+        return { expr: { kind: "lit", value: firstValue(taggedPathDomain(setter.domain, segments) ?? { kind: "tokens", count: 1 }) }, reads: [] };
+    }
     return {
         expr: { kind: "read", var: stateVar, ...(segments.length > 0 ? { path: segments } : {}) },
         reads: [stateVar]
@@ -936,10 +1031,36 @@ function effectWriteVars(effect) {
 function stateNameForVar(varId, setters) {
     return [...setters.values()].find((setter) => setter.varId === varId)?.stateName;
 }
+function componentGuardLocalsFor(attribute, setters) {
+    const body = enclosingFunctionBody(attribute);
+    if (!body)
+        return new Map();
+    const locals = new Map();
+    for (const statement of body.statements) {
+        if (statement.pos > attribute.pos)
+            break;
+        if (ts.isReturnStatement(statement))
+            break;
+        bindConstStatement(statement, setters, locals, true);
+    }
+    return locals;
+}
+function enclosingFunctionBody(node) {
+    let current = node;
+    while (current) {
+        if ((ts.isFunctionDeclaration(current) || ts.isFunctionExpression(current) || ts.isArrowFunction(current)) && current.body && ts.isBlock(current.body)) {
+            return current.body;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
 function callSummaryFromHandler(handler, setters, initialLocals = new Map()) {
     const body = handler.body;
     if (ts.isCallExpression(body))
         return { call: body, locals: new Map(initialLocals) };
+    if (ts.isVoidExpression(body) && ts.isCallExpression(body.expression))
+        return { call: body.expression, locals: new Map(initialLocals) };
     if (ts.isBlock(body)) {
         const locals = new Map(initialLocals);
         for (let index = 0; index < body.statements.length; index += 1) {
@@ -947,13 +1068,30 @@ function callSummaryFromHandler(handler, setters, initialLocals = new Map()) {
             const isLast = index === body.statements.length - 1;
             if (isLast && ts.isExpressionStatement(statement) && ts.isCallExpression(statement.expression))
                 return { call: statement.expression, locals };
+            if (isLast && ts.isExpressionStatement(statement) && ts.isVoidExpression(statement.expression) && ts.isCallExpression(statement.expression.expression))
+                return { call: statement.expression.expression, locals };
             if (!bindConstStatement(statement, setters, locals))
                 return undefined;
         }
     }
     return undefined;
 }
-function bindConstStatement(statement, setters, locals) {
+function swrMutateTransition(source, fileName, node, attr, component, call, locator) {
+    if (!ts.isIdentifier(call.expression) || call.expression.text !== "mutate")
+        return undefined;
+    return {
+        id: `${component}.${attr}.mutate`,
+        cls: "user",
+        label: labelForEvent(attr, locator),
+        source: [{ file: fileName, ...lineAndColumn(source, node) }],
+        guard: { kind: "lit", value: true },
+        effect: { kind: "seq", effects: [] },
+        reads: [],
+        writes: [],
+        confidence: "exact"
+    };
+}
+function bindConstStatement(statement, setters, locals, partialBoolean = false) {
     if (!ts.isVariableStatement(statement))
         return false;
     if ((ts.getCombinedNodeFlags(statement.declarationList) & ts.NodeFlags.Const) === 0)
@@ -961,7 +1099,8 @@ function bindConstStatement(statement, setters, locals) {
     for (const declaration of statement.declarationList.declarations) {
         if (!ts.isIdentifier(declaration.name) || !declaration.initializer)
             return false;
-        const binding = valueExpr(declaration.initializer, setters, locals);
+        const binding = valueExpr(declaration.initializer, setters, locals) ??
+            (partialBoolean ? parseConjunctiveGuardExpression(declaration.initializer, setters, locals) : booleanExpr(declaration.initializer, setters, locals));
         if (!binding)
             return false;
         locals.set(declaration.name.text, binding);
@@ -1847,7 +1986,7 @@ function combineParsedGuards(guards) {
         reads: [...new Set(parsed.flatMap((guard) => guard.reads))]
     };
 }
-function renderGuardFor(eventAttribute, setters, warnings, source, component) {
+function renderGuardFor(eventAttribute, setters, warnings, source, component, locals = new Map()) {
     const element = jsxElementForAttribute(eventAttribute);
     if (!element)
         return undefined;
@@ -1857,7 +1996,7 @@ function renderGuardFor(eventAttribute, setters, warnings, source, component) {
         if (ts.isBinaryExpression(parent) &&
             parent.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken &&
             parent.right === current) {
-            const parsed = parseGuardExpression(parent.left, setters);
+            const parsed = parseConjunctiveGuardExpression(parent.left, setters, locals);
             if (!parsed) {
                 warnings.push({ message: `Unsupported render guard ${component}.${eventAttribute.name.getText(source)}`, ...lineAndColumn(source, parent.left) });
                 return undefined;
@@ -1865,7 +2004,7 @@ function renderGuardFor(eventAttribute, setters, warnings, source, component) {
             return parsed;
         }
         if (ts.isConditionalExpression(parent) && parent.whenTrue === current) {
-            const parsed = parseGuardExpression(parent.condition, setters);
+            const parsed = parseConjunctiveGuardExpression(parent.condition, setters, locals);
             if (!parsed) {
                 warnings.push({ message: `Unsupported render guard ${component}.${eventAttribute.name.getText(source)}`, ...lineAndColumn(source, parent.condition) });
                 return undefined;
@@ -1873,7 +2012,7 @@ function renderGuardFor(eventAttribute, setters, warnings, source, component) {
             return parsed;
         }
         if (ts.isConditionalExpression(parent) && parent.whenFalse === current) {
-            const parsed = parseGuardExpression(parent.condition, setters);
+            const parsed = parseConjunctiveGuardExpression(parent.condition, setters, locals);
             if (!parsed) {
                 warnings.push({ message: `Unsupported render guard ${component}.${eventAttribute.name.getText(source)}`, ...lineAndColumn(source, parent.condition) });
                 return undefined;
@@ -1897,50 +2036,73 @@ function jsxElementForAttribute(attribute) {
         return element.parent;
     return ts.isJsxSelfClosingElement(element) ? element : undefined;
 }
-function disabledGuardFor(eventAttribute, setters, warnings, source, component) {
+function disabledGuardFor(eventAttribute, setters, warnings, source, component, locals = new Map()) {
     const attrs = eventAttribute.parent;
     if (!ts.isJsxAttributes(attrs))
         return undefined;
-    const disabled = attrs.properties.find((property) => ts.isJsxAttribute(property) && ts.isIdentifier(property.name) && (property.name.text === "disabled" || property.name.text === "aria-disabled"));
+    const disabled = attrs.properties.find((property) => ts.isJsxAttribute(property) && ts.isIdentifier(property.name) && (property.name.text === "disabled" || property.name.text === "aria-disabled")) ?? submitButtonDisabledAttribute(eventAttribute);
     if (!disabled)
         return undefined;
-    const parsed = jsxAttributeBoolean(disabled, setters);
+    const parsed = jsxAttributeBoolean(disabled, setters, locals);
     if (!parsed) {
         warnings.push({ message: `Unsupported disabled guard ${component}.${eventAttribute.name.getText(source)}`, ...lineAndColumn(source, disabled) });
         return undefined;
     }
     return { expr: { kind: "not", args: [parsed.expr] }, reads: parsed.reads };
 }
-function jsxAttributeBoolean(attribute, setters) {
+function submitButtonDisabledAttribute(eventAttribute) {
+    if (!ts.isIdentifier(eventAttribute.name) || eventAttribute.name.text !== "onSubmit")
+        return undefined;
+    const element = jsxElementForAttribute(eventAttribute);
+    if (!element || !ts.isJsxElement(element))
+        return undefined;
+    let found;
+    const visit = (node) => {
+        if (found)
+            return;
+        if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
+            const tag = ts.isIdentifier(node.tagName) ? node.tagName.text : undefined;
+            if (tag === "button" && stringAttribute(node.attributes, "type") === "submit") {
+                found = node.attributes.properties.find((property) => ts.isJsxAttribute(property) && ts.isIdentifier(property.name) && (property.name.text === "disabled" || property.name.text === "aria-disabled"));
+                if (found)
+                    return;
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(element);
+    return found;
+}
+function jsxAttributeBoolean(attribute, setters, locals = new Map()) {
     if (!attribute.initializer)
         return { expr: { kind: "lit", value: true }, reads: [] };
     if (ts.isStringLiteral(attribute.initializer))
         return { expr: { kind: "lit", value: attribute.initializer.text === "true" }, reads: [] };
     if (!ts.isJsxExpression(attribute.initializer) || !attribute.initializer.expression)
         return undefined;
-    return parseGuardExpression(attribute.initializer.expression, setters);
+    return parseConjunctiveGuardExpression(attribute.initializer.expression, setters, locals);
 }
-function parseGuardExpression(expression, setters) {
+function parseGuardExpression(expression, setters, locals = new Map()) {
     if (expression.kind === ts.SyntaxKind.TrueKeyword)
         return { expr: { kind: "lit", value: true }, reads: [] };
     if (expression.kind === ts.SyntaxKind.FalseKeyword)
         return { expr: { kind: "lit", value: false }, reads: [] };
-    if (ts.isIdentifier(expression) || ts.isPropertyAccessExpression(expression))
-        return valueExpr(expression, setters, new Map());
+    if (ts.isIdentifier(expression) || isPropertyAccessLike(expression))
+        return valueExpr(expression, setters, locals);
     if (ts.isPrefixUnaryExpression(expression) && expression.operator === ts.SyntaxKind.ExclamationToken) {
-        const parsed = parseGuardExpression(expression.operand, setters);
+        const parsed = parseGuardExpression(expression.operand, setters, locals);
         return parsed ? { expr: { kind: "not", args: [parsed.expr] }, reads: parsed.reads } : undefined;
     }
     if (ts.isParenthesizedExpression(expression))
-        return parseGuardExpression(expression.expression, setters);
+        return parseGuardExpression(expression.expression, setters, locals);
     if (ts.isBinaryExpression(expression))
-        return parseBinaryGuardExpression(expression, setters);
+        return parseBinaryGuardExpression(expression, setters, locals);
     return undefined;
 }
-function parseBinaryGuardExpression(expression, setters) {
+function parseBinaryGuardExpression(expression, setters, locals = new Map()) {
     if (expression.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || expression.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
-        const left = parseGuardExpression(expression.left, setters);
-        const right = parseGuardExpression(expression.right, setters);
+        const left = parseGuardExpression(expression.left, setters, locals);
+        const right = parseGuardExpression(expression.right, setters, locals);
         if (!left || !right)
             return undefined;
         return {
@@ -1952,8 +2114,8 @@ function parseBinaryGuardExpression(expression, setters) {
         expression.operatorToken.kind === ts.SyntaxKind.EqualsEqualsToken ||
         expression.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken ||
         expression.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsToken) {
-        const left = parseGuardOperand(expression.left, setters);
-        const right = parseGuardOperand(expression.right, setters);
+        const left = parseGuardOperand(expression.left, setters, locals);
+        const right = parseGuardOperand(expression.right, setters, locals);
         if (!left || !right)
             return undefined;
         return {
@@ -1966,16 +2128,52 @@ function parseBinaryGuardExpression(expression, setters) {
     }
     return undefined;
 }
-function parseGuardOperand(expression, setters) {
+function parseGuardOperand(expression, setters, locals = new Map()) {
     const value = literalValue(expression);
     if (value !== undefined)
         return { expr: { kind: "lit", value }, reads: [] };
-    if (ts.isIdentifier(expression) || ts.isPropertyAccessExpression(expression))
-        return valueExpr(expression, setters, new Map());
-    return parseGuardExpression(expression, setters);
+    if (ts.isIdentifier(expression) || isPropertyAccessLike(expression))
+        return valueExpr(expression, setters, locals);
+    return parseGuardExpression(expression, setters, locals);
+}
+function parseConjunctiveGuardExpression(expression, setters, locals = new Map()) {
+    if (ts.isParenthesizedExpression(expression))
+        return parseConjunctiveGuardExpression(expression.expression, setters, locals);
+    if (ts.isBinaryExpression(expression) && expression.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
+        return combineParsedGuards([
+            parseConjunctiveGuardExpression(expression.left, setters, locals),
+            parseConjunctiveGuardExpression(expression.right, setters, locals)
+        ]);
+    }
+    return parseGuardExpression(expression, setters, locals);
 }
 function stateVarForName(name, setters) {
-    return [...setters.values()].find((setter) => setter.stateName === name)?.varId;
+    return setterForName(name, setters)?.varId;
+}
+function setterForName(name, setters) {
+    return setters.get(name) ?? [...setters.values()].find((setter) => setter.stateName === name);
+}
+function taggedPathDomain(domain, path) {
+    const [field, ...rest] = path;
+    if (!field)
+        return domain;
+    const variants = Object.values(domain.variants).filter((variant) => variant.kind === "record");
+    const fieldDomains = variants.map((variant) => variant.fields[field]).filter((candidate) => Boolean(candidate));
+    if (fieldDomains.length === 0)
+        return undefined;
+    const first = fieldDomains[0];
+    if (rest.length === 0)
+        return first;
+    return first.kind === "record" ? domainAtRecordPath(first, rest) : undefined;
+}
+function domainAtRecordPath(domain, path) {
+    const [field, ...rest] = path;
+    if (!field)
+        return domain;
+    const next = domain.fields[field];
+    if (!next || rest.length === 0)
+        return next;
+    return next.kind === "record" ? domainAtRecordPath(next, rest) : undefined;
 }
 function andGuard(left, right) {
     if (isTrueLiteral(left))
@@ -2074,12 +2272,15 @@ function isInputValueExpression(node, parameter) {
 function propertyAccessPath(node) {
     if (ts.isIdentifier(node))
         return [node.text];
-    if (ts.isPropertyAccessExpression(node)) {
+    if (isPropertyAccessLike(node)) {
         const base = propertyAccessPath(node.expression);
         return base ? [...base, node.name.text] : undefined;
     }
     return undefined;
 }
+function isPropertyAccessLike(node) {
+    return ts.isPropertyAccessExpression(node) || ts.isPropertyAccessChain(node);
+}
 function valueClassForDomain(domain) {
     if (domain.kind === "enum")
         return domain.values.join("|") || "enum";