modality-ts 0.0.2 → 0.0.4

package/dist/extraction/index.js

@@ -1,4 +1,5 @@
 import * as ts from "typescript";
+import { effectReads, effectWrites } from "modality-ts/kernel";
 export * from "./pipeline/index.js";
 export * from "./spi/index.js";
 function setterBindingFromDecl(decl) {
@@ -48,6 +49,8 @@ export function extractUseStateSkeleton(sourceText, options = {}) {
     const warnings = [];
     const route = options.route ?? "/";
     const effectApis = new Set(options.effectApis ?? []);
+    const sourcePlugins = options.sourcePlugins ?? [];
+    const routerPlugin = options.routerPlugin;
     const setters = new Map();
     const globalTaints = new Set();
     const components = componentDeclarations(source);
@@ -68,8 +71,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) });
@@ -135,7 +140,7 @@ export function extractUseStateSkeleton(sourceText, options = {}) {
             }
         }
         if (ts.isJsxAttribute(node) && ts.isIdentifier(node.name) && node.initializer && isForwardablePropName(node.name.text) && !isIntrinsicJsxAttribute(node)) {
-            const extracted = transitionsFromComponentPropAttribute(source, fileName, node, setters, handlers, components, nextComponent ?? "Anonymous", effectApis, options.asyncOutcomes ?? {}, warnings);
+            const extracted = transitionsFromComponentPropAttribute(source, fileName, node, setters, handlers, components, nextComponent ?? "Anonymous", effectApis, options.asyncOutcomes ?? {}, sourcePlugins, routerPlugin, warnings);
             transitions.push(...extracted);
             if (extracted.length === 0) {
                 warnings.push({ message: `Unextractable handler ${nextComponent ?? "Anonymous"}.${node.name.text}`, ...lineAndColumn(source, node) });
@@ -165,7 +170,7 @@ export function extractUseStateSkeleton(sourceText, options = {}) {
                 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);
+            const extracted = transitionsFromJsxAttribute(source, fileName, node, setters, handlers, nextComponent ?? "Anonymous", effectApis, options.asyncOutcomes ?? {}, sourcePlugins, routerPlugin, guard, warnings);
             transitions.push(...extracted);
             if (extracted.length === 0 && !forwardsComponentProp(node, handlers, components.get(nextComponent ?? "")) && !handlerSchedulesModeledTimer(node, handlers, setters)) {
                 warnings.push({ message: `Unextractable handler ${nextComponent ?? "Anonymous"}.${node.name.text}`, ...lineAndColumn(source, node) });
@@ -391,6 +396,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];
@@ -490,7 +504,7 @@ function handlerSchedulesModeledTimer(attribute, handlers, setters) {
     visit(handler.body);
     return found;
 }
-function transitionsFromJsxAttribute(source, fileName, node, setters, handlers, component, effectApis, asyncOutcomes, disabledGuard, warnings) {
+function transitionsFromJsxAttribute(source, fileName, node, setters, handlers, component, effectApis, asyncOutcomes, sourcePlugins, routerPlugin, disabledGuard, warnings) {
     if (!node.initializer)
         return [];
     const expression = ts.isJsxExpression(node.initializer) ? node.initializer.expression : undefined;
@@ -501,9 +515,9 @@ function transitionsFromJsxAttribute(source, fileName, node, setters, handlers,
         return [];
     const attr = node.name.text;
     const locator = locatorForEventAttribute(node);
-    return tagStableIdKey(transitionsFromResolvedHandler(source, fileName, node, attr, handler, setters, handlers, component, effectApis, asyncOutcomes, disabledGuard, locator, warnings), handler);
+    return tagStableIdKey(transitionsFromResolvedHandler(source, fileName, node, attr, handler, setters, handlers, component, effectApis, asyncOutcomes, sourcePlugins, routerPlugin, disabledGuard, locator, warnings), handler);
 }
-function transitionsFromComponentPropAttribute(source, fileName, node, setters, handlers, components, component, effectApis, asyncOutcomes, warnings) {
+function transitionsFromComponentPropAttribute(source, fileName, node, setters, handlers, components, component, effectApis, asyncOutcomes, sourcePlugins, routerPlugin, warnings) {
     if (!node.initializer || !ts.isIdentifier(node.name))
         return [];
     const tag = jsxTagName(node);
@@ -524,7 +538,7 @@ function transitionsFromComponentPropAttribute(source, fileName, node, setters,
         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);
+    return tagStableIdKey(transitionsFromResolvedHandler(source, fileName, node, trigger.attr, handler, setters, handlers, component, effectApis, asyncOutcomes, sourcePlugins, routerPlugin, combineParsedGuards([trigger.guard, callerGuard]), trigger.locator, warnings), handler);
 }
 function transitionsFromBoundedListAttribute(source, fileName, node, setters, handlers, component, listInfo) {
     if (!node.initializer || !ts.isIdentifier(node.name))
@@ -584,7 +598,7 @@ function normalizedAstKey(node) {
         .replace(/\/\/.*$/gm, "")
         .replace(/\s+/g, "");
 }
-function transitionsFromResolvedHandler(source, fileName, node, attr, handler, setters, handlers, component, effectApis, asyncOutcomes, disabledGuard, locator, warnings) {
+function transitionsFromResolvedHandler(source, fileName, node, attr, handler, setters, handlers, component, effectApis, asyncOutcomes, sourcePlugins, routerPlugin, disabledGuard, locator, warnings) {
     const asyncTransitions = transitionsFromAsyncHandler(source, fileName, attr, handler, setters, component, effectApis, asyncOutcomes, locator, warnings);
     if (asyncTransitions.length > 0)
         return applyParsedGuard(asyncTransitions, disabledGuard);
@@ -594,7 +608,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);
@@ -603,12 +617,18 @@ function transitionsFromResolvedHandler(source, fileName, node, attr, handler, s
     const inlined = inlinedHelperCall(summary.call, handlers, setters);
     const inlinedCall = inlined?.call ?? summary.call;
     const locals = inlined?.locals ?? summary.locals;
-    const navigation = navigationTransition(source, fileName, node, attr, component, inlinedCall, locator);
+    const navigation = navigationTransition(source, fileName, node, attr, component, inlinedCall, locator, routerPlugin);
     if (navigation)
         return applyParsedGuard([navigation], disabledGuard);
+    const pluginWrite = pluginWriteTransition(source, fileName, node, attr, component, inlinedCall, setters, locals, sourcePlugins, locator);
+    if (pluginWrite)
+        return applyParsedGuard([pluginWrite], 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);
+        const escaped = escapedSetters(inlinedCall, setters, locals);
         if (escaped.length === 0)
             return [];
         return applyParsedGuard(escapedSetterTransitions(source, fileName, node, attr, component, escaped, locator), disabledGuard);
@@ -633,7 +653,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();
@@ -641,6 +661,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;
@@ -662,6 +687,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 [];
@@ -727,6 +769,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;
@@ -734,11 +781,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);
@@ -746,8 +824,12 @@ function valueExpr(expression, setters, locals) {
     }
     if (ts.isParenthesizedExpression(expression))
         return valueExpr(expression.expression, setters, locals);
+    if (ts.isBinaryExpression(expression) &&
+        (expression.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || expression.operatorToken.kind === ts.SyntaxKind.BarBarToken)) {
+        return booleanExpr(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);
@@ -791,22 +873,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]
@@ -815,7 +900,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;
@@ -891,9 +976,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]
@@ -980,6 +1069,8 @@ 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) {
@@ -987,12 +1078,89 @@ 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 pluginWriteTransition(source, fileName, node, attr, component, call, setters, locals, sourcePlugins, locator) {
+    const callee = callName(call.expression);
+    if (!callee)
+        return undefined;
+    const ctx = {
+        read: (name, path) => {
+            const local = locals.get(name);
+            if (local?.expr.kind === "read") {
+                return { kind: "read", var: local.expr.var, path: [...(local.expr.path ?? []), ...(path ?? [])] };
+            }
+            const varId = stateVarForName(name, setters) ?? name;
+            return { kind: "read", var: varId, ...(path && path.length > 0 ? { path } : {}) };
+        },
+        locator
+    };
+    const callSite = {
+        callee,
+        arguments: call.arguments.map(callArgumentValue),
+        source: { file: fileName, ...lineAndColumn(source, call) }
+    };
+    for (const plugin of sourcePlugins) {
+        const summary = plugin.summarizeWrite?.(callSite, ctx);
+        if (!summary || summary === "unsupported")
+            continue;
+        const reads = [...effectReads(summary)].sort();
+        const writes = [...effectWrites(summary)].sort();
+        return {
+            id: `${component}.${attr}.${safeId(plugin.id)}.${safeId(callee)}`,
+            cls: "user",
+            label: labelForEvent(attr, locator),
+            source: [{ file: fileName, ...lineAndColumn(source, node) }],
+            guard: { kind: "lit", value: true },
+            effect: summary,
+            reads,
+            writes,
+            confidence: "exact"
+        };
+    }
+    return undefined;
+}
+function callArgumentValue(argument) {
+    const literal = literalValue(argument);
+    if (literal !== undefined)
+        return literal;
+    if (ts.isIdentifier(argument))
+        return argument.text;
+    if (ts.isObjectLiteralExpression(argument)) {
+        const fields = {};
+        for (const property of argument.properties) {
+            if (!ts.isPropertyAssignment(property))
+                return argument.getText();
+            const name = propertyName(property.name);
+            if (!name)
+                return argument.getText();
+            fields[name] = callArgumentValue(property.initializer);
+        }
+        return fields;
+    }
+    return argument.getText();
+}
+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;
@@ -1001,7 +1169,8 @@ function bindConstStatement(statement, setters, locals, partialBoolean = false)
     for (const declaration of statement.declarationList.declarations) {
         if (!ts.isIdentifier(declaration.name) || !declaration.initializer)
             return false;
-        const binding = valueExpr(declaration.initializer, setters, locals) ??
+        const setterAlias = ts.isIdentifier(declaration.initializer) ? setters.get(declaration.initializer.text) ?? locals.get(declaration.initializer.text)?.setter : undefined;
+        const binding = setterAlias ? { expr: { kind: "lit", value: null }, reads: [], setter: setterAlias } : valueExpr(declaration.initializer, setters, locals) ??
             (partialBoolean ? parseConjunctiveGuardExpression(declaration.initializer, setters, locals) : booleanExpr(declaration.initializer, setters, locals));
         if (!binding)
             return false;
@@ -1015,8 +1184,8 @@ function inlinedHelperCall(call, handlers, setters) {
     const helper = handlers.get(call.expression.text);
     return helper ? callSummaryFromHandler(helper, setters) : undefined;
 }
-function navigationTransition(source, fileName, node, attr, component, call, locator) {
-    const navigation = navigationCall(call);
+function navigationTransition(source, fileName, node, attr, component, call, locator, routerPlugin) {
+    const navigation = navigationCall(call, routerPlugin);
     if (!navigation)
         return undefined;
     const routeId = navigation.to ? safeId(navigation.to) : "back";
@@ -1040,10 +1209,13 @@ function navigationTransition(source, fileName, node, attr, component, call, loc
         confidence: "exact"
     };
 }
-function navigationCall(call) {
+function navigationCall(call, routerPlugin) {
     const name = callName(call.expression);
     if (!name)
         return undefined;
+    const pluginNavigation = routerPlugin?.navigationCall(name, call.arguments.map(callArgumentValue));
+    if (pluginNavigation && pluginNavigation !== "unsupported")
+        return pluginNavigation;
     if (name === "navigate" && call.arguments.length === 1) {
         const to = literalValue(call.arguments[0]);
         return typeof to === "string" ? { mode: "push", to } : undefined;
@@ -1059,10 +1231,10 @@ function navigationCall(call) {
     }
     return undefined;
 }
-function escapedSetters(call, setters) {
+function escapedSetters(call, setters, locals = new Map()) {
     return call.arguments
         .filter(ts.isIdentifier)
-        .map((arg) => setters.get(arg.text))
+        .map((arg) => setters.get(arg.text) ?? locals.get(arg.text)?.setter)
         .filter((setter) => Boolean(setter));
 }
 function escapedSetterTransitions(source, fileName, node, attr, component, setters, locator) {
@@ -1892,6 +2064,7 @@ function renderGuardFor(eventAttribute, setters, warnings, source, component, lo
     const element = jsxElementForAttribute(eventAttribute);
     if (!element)
         return undefined;
+    const guards = [];
     let current = element;
     while (current.parent) {
         const parent = current.parent;
@@ -1903,7 +2076,9 @@ function renderGuardFor(eventAttribute, setters, warnings, source, component, lo
                 warnings.push({ message: `Unsupported render guard ${component}.${eventAttribute.name.getText(source)}`, ...lineAndColumn(source, parent.left) });
                 return undefined;
             }
-            return parsed;
+            guards.push(parsed);
+            current = parent;
+            continue;
         }
         if (ts.isConditionalExpression(parent) && parent.whenTrue === current) {
             const parsed = parseConjunctiveGuardExpression(parent.condition, setters, locals);
@@ -1911,7 +2086,9 @@ function renderGuardFor(eventAttribute, setters, warnings, source, component, lo
                 warnings.push({ message: `Unsupported render guard ${component}.${eventAttribute.name.getText(source)}`, ...lineAndColumn(source, parent.condition) });
                 return undefined;
             }
-            return parsed;
+            guards.push(parsed);
+            current = parent;
+            continue;
         }
         if (ts.isConditionalExpression(parent) && parent.whenFalse === current) {
             const parsed = parseConjunctiveGuardExpression(parent.condition, setters, locals);
@@ -1919,15 +2096,17 @@ function renderGuardFor(eventAttribute, setters, warnings, source, component, lo
                 warnings.push({ message: `Unsupported render guard ${component}.${eventAttribute.name.getText(source)}`, ...lineAndColumn(source, parent.condition) });
                 return undefined;
             }
-            return { expr: { kind: "not", args: [parsed.expr] }, reads: parsed.reads };
+            guards.push({ expr: { kind: "not", args: [parsed.expr] }, reads: parsed.reads });
+            current = parent;
+            continue;
         }
-        if (ts.isParenthesizedExpression(parent) || ts.isJsxExpression(parent)) {
+        if (ts.isParenthesizedExpression(parent) || ts.isJsxExpression(parent) || ts.isJsxElement(parent) || ts.isJsxFragment(parent)) {
             current = parent;
             continue;
         }
-        return undefined;
+        return combineParsedGuards(guards);
     }
-    return undefined;
+    return combineParsedGuards(guards);
 }
 function jsxElementForAttribute(attribute) {
     const attrs = attribute.parent;
@@ -1989,7 +2168,7 @@ function parseGuardExpression(expression, setters, locals = new Map()) {
         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))
+    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, locals);
@@ -2034,7 +2213,7 @@ 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))
+    if (ts.isIdentifier(expression) || isPropertyAccessLike(expression))
         return valueExpr(expression, setters, locals);
     return parseGuardExpression(expression, setters, locals);
 }
@@ -2050,7 +2229,32 @@ function parseConjunctiveGuardExpression(expression, setters, locals = new Map()
     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))
@@ -2149,12 +2353,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";