shortcuts-playground 1.2.1

package/skills/shortcuts-playground/scripts/test_wiring_regressions.py

@@ -0,0 +1,2247 @@
+#!/usr/bin/env python3
+"""Regression suite for weather/location, Set Name, and HealthKit coverage.
+
+This script generates large synthetic shortcut corpora and runs them through
+validate_shortcut.py's validate() API.
+
+It is designed to enforce:
+- Get Detail of Weather Conditions must have non-empty, correctly wired input.
+- Location-bearing parameters must never be emitted empty/unwired.
+- Set Name must use setitemname with both input and target name.
+- Rename File must not be used as a renamed-copy step before Save/Share.
+- HealthKit actions must validate exported iOS plist parameter shapes across
+  all SDK-known HealthKit type/value families.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import plistlib
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+from validate_shortcut import load_allowed_ids, load_icon_metadata, validate
+
+PLACEHOLDER = "\uFFFC"
+WEATHER_DETAILS = [
+    "Date",
+    "Location",
+    "Condition",
+    "Temperature",
+    "High",
+    "Low",
+    "Feels Like",
+    "Humidity",
+    "Pressure",
+    "Precipitation Amount",
+    "Precipitation Chance",
+    "Wind Direction",
+    "UV Index",
+    "Sunrise Time",
+    "Sunset Time",
+    "Wind Speed",
+    "Visibility",
+    "Dewpoint",
+    "Air Quality Index",
+    "Air Quality Category",
+    "Air Pollutants",
+    "Name",
+]
+HEALTH_SAMPLE_DETAILS = ["Type", "Value", "Unit", "Start Date", "End Date", "Duration", "Source", "Name"]
+
+
+@dataclass
+class Case:
+    category: str
+    name: str
+    plist: dict
+    expect_valid: bool
+    expected_error_substring: Optional[str] = None
+
+
+def seeded_uuid(seed: str) -> str:
+    return str(uuid.uuid5(uuid.NAMESPACE_DNS, seed)).upper()
+
+
+def prompt_comment_text(prompt: str) -> str:
+    return (
+        "Shortcuts generated by Shortcuts Playground. May contain mistakes. "
+        "Always check the shortcut's actions first.\n\n"
+        "This shortcut was created via the following user prompt:\n\n"
+        f"> {prompt}"
+    )
+
+
+def base_actions(name: str, prompt: str) -> list[dict]:
+    return [
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.comment",
+            "WFWorkflowActionParameters": {
+                "WFCommentActionText": f"{name}: regression test fixture."
+            },
+        },
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.comment",
+            "WFWorkflowActionParameters": {"WFCommentActionText": prompt_comment_text(prompt)},
+        },
+    ]
+
+
+def root_plist(name: str, actions: list[dict]) -> dict:
+    return {
+        "WFWorkflowActions": actions,
+        "WFWorkflowClientVersion": "2700.0.4",
+        "WFWorkflowHasOutputFallback": False,
+        "WFWorkflowIcon": {
+            "WFWorkflowIconGlyphNumber": 61440,
+            "WFWorkflowIconStartColor": 431817727,
+        },
+        "WFWorkflowImportQuestions": [],
+        "WFWorkflowInputContentItemClasses": [],
+        "WFWorkflowMinimumClientVersion": 900,
+        "WFWorkflowMinimumClientVersionString": "900",
+        "WFWorkflowName": name,
+        "WFWorkflowOutputContentItemClasses": [],
+        "WFWorkflowTypes": [],
+    }
+
+
+def make_shortcuts_url_valid(case_name: str) -> dict:
+    plist = root_plist(
+        case_name,
+        base_actions(case_name, "Open an Apple-documented Shortcuts URL scheme.")
+        + [
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.url",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(case_name + "-url"),
+                    "WFURLActionURL": (
+                        "shortcuts://x-callback-url/run-shortcut?"
+                        "name=Calculate%20Tip&input=text&text=24.99&"
+                        "x-success=myapp%3A%2F%2Fdone&x-error=myapp%3A%2F%2Ferror"
+                    ),
+                },
+            }
+        ],
+    )
+    return plist
+
+
+def make_shortcuts_url_invalid(case_name: str) -> dict:
+    plist = root_plist(
+        case_name,
+        base_actions(case_name, "Reject unsupported Shortcuts URL scheme routes.")
+        + [
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.url",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(case_name + "-url"),
+                    "WFURLActionURL": "shortcuts://import-shortcut?url=https%3A%2F%2Fexample.com%2FTest.shortcut",
+                },
+            }
+        ],
+    )
+    return plist
+
+
+def make_javascript_webpage_valid(case_name: str) -> dict:
+    plist = root_plist(
+        case_name,
+        base_actions(case_name, "Run JavaScript on the current Safari webpage.")
+        + [
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.runjavascriptonwebpage",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(case_name + "-js"),
+                    "WFJavaScript": "const title = document.title; completion({title});",
+                },
+            }
+        ],
+    )
+    plist["WFWorkflowInputContentItemClasses"] = ["WFSafariWebPageContentItem"]
+    plist["WFWorkflowTypes"] = ["ActionExtension"]
+    return plist
+
+
+def make_javascript_webpage_invalid(case_name: str) -> dict:
+    plist = root_plist(
+        case_name,
+        base_actions(case_name, "Reject JavaScript webpage shortcuts without Safari/share-sheet wiring.")
+        + [
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.runjavascriptonwebpage",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(case_name + "-js"),
+                    "WFJavaScript": "window.alert('Done');",
+                },
+            }
+        ],
+    )
+    plist["WFWorkflowInputContentItemClasses"] = ["WFStringContentItem"]
+    plist["WFWorkflowTypes"] = []
+    return plist
+
+
+def attachment_action_output(output_uuid: str, output_name: str) -> dict:
+    return {
+        "WFSerializationType": "WFTextTokenAttachment",
+        "Value": {
+            "Type": "ActionOutput",
+            "OutputUUID": output_uuid,
+            "OutputName": output_name,
+        },
+    }
+
+
+def attachment_variable(name: str) -> dict:
+    return {
+        "WFSerializationType": "WFTextTokenAttachment",
+        "Value": {"Type": "Variable", "VariableName": name},
+    }
+
+
+def token_string_action_output(output_uuid: str, output_name: str) -> dict:
+    return {
+        "WFSerializationType": "WFTextTokenString",
+        "Value": {
+            "string": PLACEHOLDER,
+            "attachmentsByRange": {
+                "{0, 1}": {
+                    "Type": "ActionOutput",
+                    "OutputUUID": output_uuid,
+                    "OutputName": output_name,
+                }
+            },
+        },
+    }
+
+
+def token_string_variable(name: str) -> dict:
+    return {
+        "WFSerializationType": "WFTextTokenString",
+        "Value": {
+            "string": PLACEHOLDER,
+            "attachmentsByRange": {"{0, 1}": {"Type": "Variable", "VariableName": name}},
+        },
+    }
+
+
+def make_send_message_single_type_valid(case_name: str) -> dict:
+    prompt = "Send Message single-type content through an appended variable payload."
+    actions = base_actions(case_name, prompt)
+    first_uuid = seeded_uuid(f"{case_name}-first-text")
+    empty_uuid = seeded_uuid(f"{case_name}-empty-text")
+    var_name = "Message Items"
+
+    actions.extend(
+        [
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.gettext",
+                "WFWorkflowActionParameters": {
+                    "UUID": first_uuid,
+                    "WFTextActionText": "Single content item",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.appendvariable",
+                "WFWorkflowActionParameters": {
+                    "WFVariableName": var_name,
+                    "WFInput": attachment_action_output(first_uuid, "Text"),
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.gettext",
+                "WFWorkflowActionParameters": {
+                    "UUID": empty_uuid,
+                    "WFTextActionText": "",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.appendvariable",
+                "WFWorkflowActionParameters": {
+                    "WFVariableName": var_name,
+                    "WFInput": attachment_action_output(empty_uuid, "Text"),
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.sendmessage",
+                "WFWorkflowActionParameters": {
+                    "WFSendMessageContent": token_string_variable(var_name),
+                },
+            },
+        ]
+    )
+    return root_plist(case_name, actions)
+
+
+def make_send_message_one_append_invalid(case_name: str) -> tuple[dict, str]:
+    prompt = "Reject Send Message content variables with only one Append Variable action."
+    actions = base_actions(case_name, prompt)
+    text_uuid = seeded_uuid(f"{case_name}-text")
+    var_name = "Message Items"
+
+    actions.extend(
+        [
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.gettext",
+                "WFWorkflowActionParameters": {
+                    "UUID": text_uuid,
+                    "WFTextActionText": "Only one append",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.appendvariable",
+                "WFWorkflowActionParameters": {
+                    "WFVariableName": var_name,
+                    "WFInput": attachment_action_output(text_uuid, "Text"),
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.sendmessage",
+                "WFWorkflowActionParameters": {
+                    "WFSendMessageContent": token_string_variable(var_name),
+                },
+            },
+        ]
+    )
+    return root_plist(case_name, actions), "2+ appends"
+
+
+def make_send_message_action_output_invalid(case_name: str) -> tuple[dict, str]:
+    prompt = "Reject Send Message content wired directly to an action output."
+    actions = base_actions(case_name, prompt)
+    text_uuid = seeded_uuid(f"{case_name}-text")
+
+    actions.extend(
+        [
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.gettext",
+                "WFWorkflowActionParameters": {
+                    "UUID": text_uuid,
+                    "WFTextActionText": "Direct output",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.sendmessage",
+                "WFWorkflowActionParameters": {
+                    "WFSendMessageContent": token_string_action_output(text_uuid, "Text"),
+                },
+            },
+        ]
+    )
+    return root_plist(case_name, actions), "should reference a named variable"
+
+
+def make_send_message_attachment_invalid(case_name: str) -> tuple[dict, str]:
+    prompt = "Reject Send Message content using WFTextTokenAttachment."
+    plist = make_send_message_single_type_valid(case_name)
+    plist["WFWorkflowActions"][-1]["WFWorkflowActionParameters"]["WFSendMessageContent"] = (
+        attachment_variable("Message Items")
+    )
+    return plist, "should use WFTextTokenString"
+
+
+def calendar_next_event_filter(operator: int) -> dict:
+    return {
+        "WFSerializationType": "WFContentPredicateTableTemplate",
+        "Value": {
+            "WFActionParameterFilterPrefix": 1,
+            "WFContentPredicateBoundedDate": False,
+            "WFActionParameterFilterTemplates": [
+                {
+                    "Operator": 1002,
+                    "Property": "Start Date",
+                    "Removable": True,
+                    "Values": {},
+                },
+                {
+                    "Operator": operator,
+                    "Property": "Start Date",
+                    "Removable": True,
+                    "Values": {"Date": current_date_attachment()},
+                },
+            ],
+        },
+    }
+
+
+def make_calendar_next_event_filter_valid(case_name: str) -> dict:
+    actions = base_actions(case_name, "Find the next calendar event after now.")
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.filter.calendarevents",
+            "WFWorkflowActionParameters": {
+                "UUID": seeded_uuid(f"{case_name}-find-events"),
+                "WFContentItemFilter": calendar_next_event_filter(2),
+                "WFContentItemSortProperty": "Start Date",
+                "WFContentItemSortOrder": "Oldest First",
+                "WFContentItemLimitEnabled": True,
+                "WFContentItemLimitNumber": 1,
+            },
+        }
+    )
+    return root_plist(case_name, actions)
+
+
+def make_calendar_next_event_filter_invalid(case_name: str) -> tuple[dict, str]:
+    plist = make_calendar_next_event_filter_valid(case_name)
+    templates = plist["WFWorkflowActions"][-1]["WFWorkflowActionParameters"]["WFContentItemFilter"][
+        "Value"
+    ]["WFActionParameterFilterTemplates"]
+    templates[1]["Operator"] = 3
+    return plist, "numeric operator 3"
+
+
+def make_get_time_between_dates_valid(case_name: str) -> dict:
+    actions = base_actions(case_name, "Compute minutes between two dates.")
+    start_uuid = seeded_uuid(f"{case_name}-start-date")
+    now_uuid = seeded_uuid(f"{case_name}-now-date")
+    actions.extend(
+        [
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.date",
+                "WFWorkflowActionParameters": {
+                    "UUID": start_uuid,
+                    "WFDateActionMode": "Current Date",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.date",
+                "WFWorkflowActionParameters": {
+                    "UUID": now_uuid,
+                    "WFDateActionMode": "Current Date",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.gettimebetweendates",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-time-between"),
+                    "WFInput": token_string_action_output(start_uuid, "Date"),
+                    "WFTimeUntilFromDate": token_string_action_output(now_uuid, "Date"),
+                    "WFTimeUntilUnit": "Minutes",
+                },
+            },
+        ]
+    )
+    return root_plist(case_name, actions)
+
+
+def make_get_time_between_dates_current_date_invalid(case_name: str) -> tuple[dict, str]:
+    plist = make_get_time_between_dates_valid(case_name)
+    plist["WFWorkflowActions"][-1]["WFWorkflowActionParameters"]["WFTimeUntilFromDate"] = (
+        current_date_attachment()
+    )
+    return plist, "cannot use CurrentDate"
+
+
+def make_get_time_between_dates_attachment_invalid(case_name: str) -> tuple[dict, str]:
+    plist = make_get_time_between_dates_valid(case_name)
+    actions = plist["WFWorkflowActions"]
+    start_uuid = actions[-3]["WFWorkflowActionParameters"]["UUID"]
+    now_uuid = actions[-2]["WFWorkflowActionParameters"]["UUID"]
+    actions[-1]["WFWorkflowActionParameters"]["WFInput"] = attachment_action_output(start_uuid, "Date")
+    actions[-1]["WFWorkflowActionParameters"]["WFTimeUntilFromDate"] = attachment_action_output(
+        now_uuid, "Date"
+    )
+    return plist, "should use WFTextTokenString"
+
+
+def make_text_token_placeholder_invalid(case_name: str) -> tuple[dict, str]:
+    actions = base_actions(case_name, "Reject token strings whose range points away from the placeholder.")
+    date_uuid = seeded_uuid(f"{case_name}-date")
+    actions.extend(
+        [
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.date",
+                "WFWorkflowActionParameters": {
+                    "UUID": date_uuid,
+                    "WFDateActionMode": "Current Date",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.gettext",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-text"),
+                    "WFTextActionText": {
+                        "WFSerializationType": "WFTextTokenString",
+                        "Value": {
+                            "string": f"A{PLACEHOLDER}",
+                            "attachmentsByRange": {
+                                "{0, 1}": {
+                                    "Type": "ActionOutput",
+                                    "OutputUUID": date_uuid,
+                                    "OutputName": "Date",
+                                }
+                            },
+                        },
+                    },
+                },
+            },
+        ]
+    )
+    return root_plist(case_name, actions), "expected placeholder position"
+
+
+def current_date_attachment() -> dict:
+    return {
+        "WFSerializationType": "WFTextTokenAttachment",
+        "Value": {"Type": "CurrentDate"},
+    }
+
+
+def quantity_field(magnitude: object = "1", unit: str = "count") -> dict:
+    value = {"Unit": unit}
+    if magnitude is not None:
+        value["Magnitude"] = magnitude
+    return {"WFSerializationType": "WFQuantityFieldValue", "Value": value}
+
+
+def health_filter_template(
+    health_type: str | None = "Steps",
+    operator: int = 1002,
+    property_name: str = "Start Date",
+) -> dict:
+    templates = []
+    if health_type is not None:
+        templates.append(
+            {
+                "Bounded": True,
+                "Operator": 4,
+                "Property": "Type",
+                "Removable": False,
+                "Values": {
+                    "Enumeration": {
+                        "Value": health_type,
+                        "WFSerializationType": "WFStringSubstitutableState",
+                    },
+                },
+            }
+        )
+    date_values = {"Number": "7", "Unit": 16} if property_name == "Start Date" and operator == 1002 else {}
+    templates.append(
+        {
+            "Bounded": True,
+            "Operator": operator,
+            "Property": property_name,
+            "Removable": False,
+            "Values": date_values,
+        }
+    )
+    return {
+        "WFSerializationType": "WFContentPredicateTableTemplate",
+        "Value": {
+            "WFActionParameterFilterPrefix": 1,
+            "WFContentPredicateBoundedDate": False,
+            "WFActionParameterFilterTemplates": templates,
+        },
+    }
+
+
+def malformed_health_value_filter_template(health_type: str = "Step Count") -> dict:
+    return {
+        "WFSerializationType": "WFContentPredicateTableTemplate",
+        "Value": {
+            "WFActionParameterFilterPrefix": 1,
+            "WFContentPredicateBoundedDate": False,
+            "WFActionParameterFilterTemplates": [
+                {
+                    "Operator": 4,
+                    "Property": "Value",
+                    "Removable": True,
+                    "Values": {
+                        "String": health_type,
+                        "Unit": 4,
+                    },
+                },
+                {
+                    "Operator": 1002,
+                    "Property": "Start Date",
+                    "Removable": True,
+                    "Values": {},
+                },
+            ],
+        },
+    }
+
+
+def mixed_health_type_and_value_filter_template() -> dict:
+    filter_value = health_filter_template("Steps")
+    templates = filter_value["Value"]["WFActionParameterFilterTemplates"]
+    templates.insert(
+        1,
+        {
+            "Operator": 4,
+            "Property": "Value",
+            "Removable": True,
+            "Values": {
+                "String": "Step Count",
+                "Unit": 4,
+            },
+        },
+    )
+    return filter_value
+
+
+def health_unit_hint(row: dict) -> str:
+    hint = str(row.get("unit_and_aggregation") or "").split(",", 1)[0].strip()
+    return hint or "count"
+
+
+def health_find_sample_label(row: dict) -> str | None:
+    observed = row.get("observed_find_samples_labels")
+    if isinstance(observed, list):
+        for label in observed:
+            if isinstance(label, str) and label:
+                return label
+    return row.get("shortcut_label_guess") or row.get("sdk_suffix")
+
+
+def load_healthkit_reference() -> dict:
+    path = Path(__file__).resolve().parents[1] / "data/healthkit-ios26.2-reference.json"
+    with path.open("r", encoding="utf-8") as handle:
+        return json.load(handle)
+
+
+def validate_healthkit_reference_labels(health: dict) -> None:
+    quantity_by_suffix = {
+        row.get("sdk_suffix"): row
+        for row in health.get("quantity_types", [])
+        if isinstance(row, dict)
+    }
+    expected = {
+        "BloodPressureDiastolic": "Diastolic Blood Pressure",
+        "BloodPressureSystolic": "Systolic Blood Pressure",
+    }
+    failures = []
+    for sdk_suffix, expected_label in expected.items():
+        row = quantity_by_suffix.get(sdk_suffix)
+        actual = row.get("shortcut_label_guess") if row else None
+        if actual != expected_label:
+            failures.append(
+                f"{sdk_suffix}: expected shortcut_label_guess {expected_label!r}, got {actual!r}"
+            )
+    if failures:
+        raise AssertionError("HealthKit reference label mismatch:\n" + "\n".join(failures))
+
+
+def make_weather_valid(case_name: str, idx: int) -> dict:
+    prompt = f"Weather valid case {idx}"
+    actions = base_actions(case_name, prompt)
+
+    loc_uuid = seeded_uuid(f"{case_name}-location")
+    weather_uuid = seeded_uuid(f"{case_name}-weather")
+    detail_uuid = seeded_uuid(f"{case_name}-detail")
+    weather_var_name = f"Weather Data {idx}"
+
+    use_forecast = idx % 2 == 1
+    use_custom_location = idx % 3 == 0
+    use_token_string = idx % 5 in {2, 4}
+    include_weather_var = idx % 4 in {1, 2}
+    detail_name = WEATHER_DETAILS[idx % len(WEATHER_DETAILS)]
+
+    if use_custom_location:
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.getcurrentlocation",
+                "WFWorkflowActionParameters": {"UUID": loc_uuid},
+            }
+        )
+
+    weather_params = {"UUID": weather_uuid}
+    if use_custom_location:
+        weather_params["WFWeatherCustomLocation"] = attachment_action_output(
+            loc_uuid, "Current Location"
+        )
+    if use_forecast:
+        weather_params["WFWeatherForecastType"] = "Daily"
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": (
+                "is.workflow.actions.weather.forecast"
+                if use_forecast
+                else "is.workflow.actions.weather.currentconditions"
+            ),
+            "WFWorkflowActionParameters": weather_params,
+        }
+    )
+
+    if include_weather_var:
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.setvariable",
+                "WFWorkflowActionParameters": {
+                    "WFVariableName": weather_var_name,
+                    "WFInput": attachment_action_output(weather_uuid, "Weather Conditions"),
+                },
+            }
+        )
+    # Keep Get Detail of Weather Conditions input wired directly to Weather output.
+    input_payload = (
+        token_string_action_output(weather_uuid, "Weather Conditions")
+        if use_token_string
+        else attachment_action_output(weather_uuid, "Weather Conditions")
+    )
+
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.properties.weather.conditions",
+            "WFWorkflowActionParameters": {
+                "UUID": detail_uuid,
+                "WFInput": input_payload,
+                "WFContentItemPropertyName": detail_name,
+            },
+        }
+    )
+    return root_plist(case_name, actions)
+
+
+def make_weather_sun_times_valid(case_name: str) -> dict:
+    prompt = "Weather sunrise/sunset list extraction valid case"
+    actions = base_actions(case_name, prompt)
+
+    weather_uuid = seeded_uuid(f"{case_name}-weather")
+    sunrise_uuid = seeded_uuid(f"{case_name}-sunrise")
+    sunrise_item_uuid = seeded_uuid(f"{case_name}-sunrise-item")
+    sunrise_format_uuid = seeded_uuid(f"{case_name}-sunrise-format")
+    sunset_uuid = seeded_uuid(f"{case_name}-sunset")
+    sunset_item_uuid = seeded_uuid(f"{case_name}-sunset-item")
+    sunset_format_uuid = seeded_uuid(f"{case_name}-sunset-format")
+    text_uuid = seeded_uuid(f"{case_name}-text")
+
+    actions.extend(
+        [
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.comment",
+                "WFWorkflowActionParameters": {
+                    "WFCommentActionText": "Fetch a daily forecast, extract sunrise and sunset lists, choose the first sunrise and last sunset, then format both times.",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.weather.forecast",
+                "WFWorkflowActionParameters": {
+                    "UUID": weather_uuid,
+                    "WFWeatherForecastType": "Daily",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.properties.weather.conditions",
+                "WFWorkflowActionParameters": {
+                    "UUID": sunrise_uuid,
+                    "WFInput": attachment_action_output(weather_uuid, "Weather Conditions"),
+                    "WFContentItemPropertyName": "Sunrise Time",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.getitemfromlist",
+                "WFWorkflowActionParameters": {
+                    "UUID": sunrise_item_uuid,
+                    "WFInput": attachment_action_output(sunrise_uuid, "Sunrise Time"),
+                    "WFItemSpecifier": "First Item",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.format.date",
+                "WFWorkflowActionParameters": {
+                    "UUID": sunrise_format_uuid,
+                    "WFDate": token_string_action_output(sunrise_item_uuid, "Item from List"),
+                    "WFDateFormatStyle": "None",
+                    "WFTimeFormatStyle": "Short",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.properties.weather.conditions",
+                "WFWorkflowActionParameters": {
+                    "UUID": sunset_uuid,
+                    "WFInput": attachment_action_output(weather_uuid, "Weather Conditions"),
+                    "WFContentItemPropertyName": "Sunset Time",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.getitemfromlist",
+                "WFWorkflowActionParameters": {
+                    "UUID": sunset_item_uuid,
+                    "WFInput": attachment_action_output(sunset_uuid, "Sunset Time"),
+                    "WFItemSpecifier": "Last Item",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.format.date",
+                "WFWorkflowActionParameters": {
+                    "UUID": sunset_format_uuid,
+                    "WFDate": token_string_action_output(sunset_item_uuid, "Item from List"),
+                    "WFDateFormatStyle": "None",
+                    "WFTimeFormatStyle": "Short",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.gettext",
+                "WFWorkflowActionParameters": {
+                    "UUID": text_uuid,
+                    "WFTextActionText": {
+                        "WFSerializationType": "WFTextTokenString",
+                        "Value": {
+                            "string": "Sunrise: \uFFFC\nSunset: \uFFFC",
+                            "attachmentsByRange": {
+                                "{9, 1}": {
+                                    "Type": "ActionOutput",
+                                    "OutputUUID": sunrise_format_uuid,
+                                    "OutputName": "Formatted Date",
+                                },
+                                "{19, 1}": {
+                                    "Type": "ActionOutput",
+                                    "OutputUUID": sunset_format_uuid,
+                                    "OutputName": "Formatted Date",
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        ]
+    )
+    return root_plist(case_name, actions)
+
+
+def make_weather_invalid(case_name: str, idx: int) -> tuple[dict, str]:
+    prompt = f"Weather invalid case {idx}"
+    actions = base_actions(case_name, prompt)
+
+    weather_uuid = seeded_uuid(f"{case_name}-weather")
+    detail_uuid = seeded_uuid(f"{case_name}-detail")
+    text_uuid = seeded_uuid(f"{case_name}-text")
+    var_name = f"Non Weather {idx}"
+    weather_var_name = f"Weather Source {idx}"
+    pattern = idx % 15
+    detail_name = WEATHER_DETAILS[idx % len(WEATHER_DETAILS)]
+
+    expected = "Get Detail of Weather Conditions"
+
+    if pattern in {0, 1, 2, 6, 7, 10, 11, 12, 13, 14}:
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.weather.currentconditions",
+                "WFWorkflowActionParameters": {"UUID": weather_uuid},
+            }
+        )
+    if pattern == 10:
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.setvariable",
+                "WFWorkflowActionParameters": {
+                    "WFVariableName": weather_var_name,
+                    "WFInput": attachment_action_output(weather_uuid, "Weather Conditions"),
+                },
+            }
+        )
+
+    if pattern == 3:
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.gettext",
+                "WFWorkflowActionParameters": {
+                    "UUID": text_uuid,
+                    "WFTextActionText": "Not weather",
+                },
+            }
+        )
+    if pattern == 4:
+        # Unknown UUID reference case: no source action intentionally.
+        pass
+    if pattern == 5:
+        actions.extend(
+            [
+                {
+                    "WFWorkflowActionIdentifier": "is.workflow.actions.gettext",
+                    "WFWorkflowActionParameters": {
+                        "UUID": text_uuid,
+                        "WFTextActionText": "Still not weather",
+                    },
+                },
+                {
+                    "WFWorkflowActionIdentifier": "is.workflow.actions.setvariable",
+                    "WFWorkflowActionParameters": {
+                        "WFVariableName": var_name,
+                        "WFInput": attachment_action_output(text_uuid, "Text"),
+                    },
+                },
+            ]
+        )
+    if pattern in {8, 9}:
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.weather.forecast",
+                "WFWorkflowActionParameters": {
+                    "UUID": weather_uuid,
+                    "WFWeatherForecastType": "Daily",
+                },
+            }
+        )
+
+    params: dict = {"UUID": detail_uuid}
+    if pattern != 0:
+        if pattern == 1:
+            params["WFInput"] = {}
+            expected = "WFInput is not a token attachment"
+        elif pattern == 2:
+            params["WFInput"] = {"WFSerializationType": "WFTextTokenAttachment", "Value": {}}
+            expected = "WFInput has no variable/output reference"
+        elif pattern == 3:
+            params["WFInput"] = attachment_action_output(text_uuid, "Text")
+            expected = "should reference output from Get Weather/Forecast"
+        elif pattern == 4:
+            params["WFInput"] = attachment_action_output(
+                seeded_uuid(f"{case_name}-missing"), "Weather Conditions"
+            )
+            expected = "references unknown OutputUUID"
+        elif pattern == 5:
+            params["WFInput"] = attachment_variable(var_name)
+            expected = "should reference output from Get Weather/Forecast"
+        elif pattern == 6:
+            params["WFInput"] = attachment_action_output(weather_uuid, "Weather Conditions")
+        elif pattern == 7:
+            params["WFInput"] = attachment_action_output(weather_uuid, "Weather Conditions")
+        elif pattern == 8:
+            params["WFInput"] = token_string_variable("Ghost Weather Variable")
+            expected = "should reference output from Get Weather/Forecast"
+        elif pattern == 9:
+            params["WFInput"] = {
+                "WFSerializationType": "WFTextTokenString",
+                "Value": {"string": "No attachment", "attachmentsByRange": {}},
+            }
+            expected = "WFInput has no variable/output reference"
+        elif pattern == 10:
+            params["WFInput"] = attachment_variable(weather_var_name)
+            expected = "reference weather action output directly"
+        elif pattern == 11:
+            params["WFInput"] = attachment_action_output(weather_uuid, "Weather Conditions")
+        elif pattern == 12:
+            params["WFInput"] = attachment_action_output(weather_uuid, "Weather Conditions")
+        elif pattern in {13, 14}:
+            params["WFInput"] = attachment_action_output(weather_uuid, "Weather Conditions")
+
+    if pattern == 6:
+        # Missing property key entirely.
+        expected = "missing WFContentItemPropertyName"
+    elif pattern == 7:
+        params["WFContentItemPropertyName"] = "   "
+        expected = "missing WFContentItemPropertyName"
+    elif pattern == 11:
+        params["WFContentItemPropertyName"] = "Detail"
+        expected = "placeholder detail name"
+    elif pattern == 12:
+        params["WFContentItemPropertyName"] = "Sunrise Date"
+        expected = "unsupported detail name"
+    elif pattern in {13, 14}:
+        params["WFContentItemPropertyName"] = "Sunset Time"
+    else:
+        params["WFContentItemPropertyName"] = detail_name
+
+    if pattern == 0:
+        expected = "missing WFInput"
+
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.properties.weather.conditions",
+            "WFWorkflowActionParameters": params,
+        }
+    )
+
+    if pattern == 13:
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.format.date",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-format-direct-sun"),
+                    "WFDate": token_string_action_output(detail_uuid, "Sunset Time"),
+                },
+            }
+        )
+        expected = "Sunset Time returns a list"
+    if pattern == 14:
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.getitemfromlist",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-wrong-sun-item"),
+                    "WFInput": attachment_action_output(detail_uuid, "Sunset Time"),
+                    "WFItemSpecifier": "First Item",
+                },
+            }
+        )
+        expected = "Sunset Time returns a list"
+    return root_plist(case_name, actions), expected
+
+
+def make_location_valid(case_name: str, idx: int) -> dict:
+    prompt = f"Location valid case {idx}"
+    actions = base_actions(case_name, prompt)
+
+    loc_uuid = seeded_uuid(f"{case_name}-location-source")
+    var_name = f"Destination {idx}"
+    mode = idx % 4
+
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.getcurrentlocation",
+            "WFWorkflowActionParameters": {"UUID": loc_uuid},
+        }
+    )
+
+    if mode in {2, 3}:
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.setvariable",
+                "WFWorkflowActionParameters": {
+                    "WFVariableName": var_name,
+                    "WFInput": attachment_action_output(loc_uuid, "Current Location"),
+                },
+            }
+        )
+
+    if mode == 0:
+        params = {
+            "UUID": seeded_uuid(f"{case_name}-location-action"),
+            "WFLocation": attachment_action_output(loc_uuid, "Current Location"),
+        }
+        ident = "is.workflow.actions.location"
+    elif mode == 1:
+        params = {
+            "UUID": seeded_uuid(f"{case_name}-weather-current"),
+            "WFWeatherCustomLocation": attachment_action_output(
+                loc_uuid, "Current Location"
+            ),
+        }
+        ident = "is.workflow.actions.weather.currentconditions"
+    elif mode == 2:
+        params = {
+            "UUID": seeded_uuid(f"{case_name}-weather-forecast"),
+            "WFWeatherForecastType": "Daily",
+            "WFWeatherCustomLocation": attachment_variable(var_name),
+        }
+        ident = "is.workflow.actions.weather.forecast"
+    else:
+        params = {
+            "UUID": seeded_uuid(f"{case_name}-weather-forecast"),
+            "WFWeatherForecastType": "Hourly",
+            "WFWeatherCustomLocation": attachment_variable(var_name),
+            "WFWeatherLocation": attachment_variable(var_name),
+        }
+        ident = "is.workflow.actions.weather.forecast"
+
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": ident,
+            "WFWorkflowActionParameters": params,
+        }
+    )
+    return root_plist(case_name, actions)
+
+
+def make_location_invalid(case_name: str, idx: int) -> tuple[dict, str]:
+    prompt = f"Location invalid case {idx}"
+    actions = base_actions(case_name, prompt)
+
+    loc_uuid = seeded_uuid(f"{case_name}-location-source")
+    missing_uuid = seeded_uuid(f"{case_name}-missing-location")
+    var_name = f"Location Ref Invalid {idx}"
+    pattern = idx % 10
+
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.getcurrentlocation",
+            "WFWorkflowActionParameters": {"UUID": loc_uuid},
+        }
+    )
+
+    expected = "Location parameter"
+
+    if pattern == 0:
+        ident = "is.workflow.actions.location"
+        params = {"UUID": seeded_uuid(f"{case_name}-loc-missing")}
+        expected = "Location action missing WFLocation"
+    elif pattern == 1:
+        ident = "is.workflow.actions.location"
+        params = {
+            "UUID": seeded_uuid(f"{case_name}-loc-empty-dict"),
+            "WFLocation": {},
+        }
+        expected = "Location parameter WFLocation is not a token attachment"
+    elif pattern == 2:
+        ident = "is.workflow.actions.location"
+        params = {
+            "UUID": seeded_uuid(f"{case_name}-loc-empty-token"),
+            "WFLocation": {"WFSerializationType": "WFTextTokenAttachment", "Value": {}},
+        }
+        expected = "Location parameter WFLocation is empty"
+    elif pattern == 3:
+        ident = "is.workflow.actions.location"
+        params = {
+            "UUID": seeded_uuid(f"{case_name}-loc-unknown"),
+            "WFLocation": attachment_action_output(missing_uuid, "Current Location"),
+        }
+        expected = "references unknown OutputUUID"
+    elif pattern == 4:
+        ident = "is.workflow.actions.weather.currentconditions"
+        params = {
+            "UUID": seeded_uuid(f"{case_name}-weather-custom-empty"),
+            "WFWeatherCustomLocation": {},
+        }
+        expected = "Location parameter WFWeatherCustomLocation is not a token attachment"
+    elif pattern == 5:
+        ident = "is.workflow.actions.weather.currentconditions"
+        params = {
+            "UUID": seeded_uuid(f"{case_name}-weather-custom-empty-token"),
+            "WFWeatherCustomLocation": {
+                "WFSerializationType": "WFTextTokenAttachment",
+                "Value": {},
+            },
+        }
+        expected = "Location parameter WFWeatherCustomLocation is empty"
+    elif pattern == 6:
+        ident = "is.workflow.actions.weather.currentconditions"
+        params = {
+            "UUID": seeded_uuid(f"{case_name}-weather-custom-unknown"),
+            "WFWeatherCustomLocation": attachment_action_output(missing_uuid, "Current Location"),
+        }
+        expected = "Location parameter WFWeatherCustomLocation references unknown OutputUUID"
+    elif pattern == 7:
+        ident = "is.workflow.actions.weather.forecast"
+        params = {
+            "UUID": seeded_uuid(f"{case_name}-weather-location-empty"),
+            "WFWeatherForecastType": "Daily",
+            "WFWeatherLocation": {},
+        }
+        expected = "Location parameter WFWeatherLocation is not a token attachment"
+    elif pattern == 8:
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.setvariable",
+                "WFWorkflowActionParameters": {
+                    "WFVariableName": var_name,
+                    "WFInput": attachment_action_output(loc_uuid, "Current Location"),
+                },
+            }
+        )
+        ident = "is.workflow.actions.weather.forecast"
+        params = {
+            "UUID": seeded_uuid(f"{case_name}-weather-location-token"),
+            "WFWeatherForecastType": "Daily",
+            "WFWeatherLocation": token_string_variable(var_name),
+        }
+        expected = "should use WFTextTokenAttachment"
+    else:
+        ident = "is.workflow.actions.location"
+        params = {
+            "UUID": seeded_uuid(f"{case_name}-loc-empty-string"),
+            "WFLocation": "   ",
+        }
+        expected = "Location parameter WFLocation is empty"
+
+    actions.append({"WFWorkflowActionIdentifier": ident, "WFWorkflowActionParameters": params})
+    return root_plist(case_name, actions), expected
+
+
+def make_set_name_valid(case_name: str, idx: int) -> dict:
+    prompt = f"Set Name valid case {idx}"
+    actions = base_actions(case_name, prompt)
+    file_src_uuid = seeded_uuid(f"{case_name}-file-src")
+    set_name_uuid = seeded_uuid(f"{case_name}-set-name")
+    var_name = f"New Name {idx}"
+
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.gettext",
+            "WFWorkflowActionParameters": {"UUID": file_src_uuid, "WFTextActionText": "file payload"},
+        }
+    )
+
+    if idx % 2 == 0:
+        new_name_param = "Test.txt"
+    else:
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.setvariable",
+                "WFWorkflowActionParameters": {
+                    "WFVariableName": var_name,
+                    "WFInput": {"WFSerializationType": "WFTextTokenString", "Value": {"string": "Test.txt", "attachmentsByRange": {}}},
+                },
+            }
+        )
+        new_name_param = token_string_variable(var_name)
+
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.setitemname",
+            "WFWorkflowActionParameters": {
+                "UUID": set_name_uuid,
+                "WFInput": attachment_action_output(file_src_uuid, "Text"),
+                "WFName": new_name_param,
+            },
+        }
+    )
+    return root_plist(case_name, actions)
+
+
+def make_set_name_invalid(case_name: str, idx: int) -> tuple[dict, str]:
+    prompt = f"Set Name invalid case {idx}"
+    actions = base_actions(case_name, prompt)
+    file_src_uuid = seeded_uuid(f"{case_name}-file-src")
+    pattern = idx % 6
+    set_name_uuid = seeded_uuid(f"{case_name}-set-name")
+
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.gettext",
+            "WFWorkflowActionParameters": {"UUID": file_src_uuid, "WFTextActionText": "file payload"},
+        }
+    )
+
+    params = {"UUID": set_name_uuid}
+    expected = "Set Name"
+    if pattern == 0:
+        params["WFName"] = "Test.txt"
+        expected = "Set Name missing WFInput"
+    elif pattern == 1:
+        params["WFInput"] = {}
+        params["WFName"] = "Test.txt"
+        expected = "Set Name WFInput is not a token attachment"
+    elif pattern == 2:
+        params["WFInput"] = attachment_action_output(file_src_uuid, "Text")
+        expected = "Set Name missing WFName"
+    elif pattern == 3:
+        params["WFInput"] = attachment_action_output(file_src_uuid, "Text")
+        params["WFName"] = "   "
+        expected = "Set Name missing WFName"
+    elif pattern == 4:
+        params["WFInput"] = {
+            "WFSerializationType": "WFTextTokenAttachment",
+            "Value": {},
+        }
+        params["WFName"] = "Test.txt"
+        expected = "Set Name missing WFInput"
+    else:
+        params["WFInput"] = attachment_action_output("00000000-0000-4000-8000-000000000001", "File")
+        params["WFName"] = "Renamed.txt"
+        expected = "Set Name WFInput references unknown OutputUUID"
+
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.setitemname",
+            "WFWorkflowActionParameters": params,
+        }
+    )
+
+    return root_plist(case_name, actions), expected
+
+
+def make_set_name_delete_variable_valid(case_name: str) -> dict:
+    prompt = "Set Name followed by Delete File variable reuse valid case"
+    actions = base_actions(case_name, prompt)
+    file_src_uuid = seeded_uuid(f"{case_name}-file-src")
+    set_name_uuid = seeded_uuid(f"{case_name}-set-name")
+
+    actions.extend(
+        [
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.file.select",
+                "WFWorkflowActionParameters": {"UUID": file_src_uuid},
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.setvariable",
+                "WFWorkflowActionParameters": {
+                    "WFVariableName": "Original File",
+                    "WFInput": attachment_action_output(file_src_uuid, "File"),
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.setitemname",
+                "WFWorkflowActionParameters": {
+                    "UUID": set_name_uuid,
+                    "WFInput": attachment_variable("Original File"),
+                    "WFName": "Renamed.txt",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.documentpicker.save",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-save-renamed"),
+                    "WFInput": attachment_action_output(set_name_uuid, "Renamed Item"),
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.file.delete",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-delete-original"),
+                    "WFInput": attachment_variable("Original File"),
+                },
+            },
+        ]
+    )
+    return root_plist(case_name, actions)
+
+
+def make_set_name_delete_by_path_valid(case_name: str) -> dict:
+    prompt = "Set Name followed by Delete File using captured original path valid case"
+    actions = base_actions(case_name, prompt)
+    file_src_uuid = seeded_uuid(f"{case_name}-file-src")
+    path_uuid = seeded_uuid(f"{case_name}-path")
+    set_name_uuid = seeded_uuid(f"{case_name}-set-name")
+
+    actions.extend(
+        [
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.file.select",
+                "WFWorkflowActionParameters": {"UUID": file_src_uuid},
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.properties.files",
+                "WFWorkflowActionParameters": {
+                    "UUID": path_uuid,
+                    "WFContentItemPropertyName": "File Path",
+                    "WFInput": attachment_action_output(file_src_uuid, "File"),
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.setitemname",
+                "WFWorkflowActionParameters": {
+                    "UUID": set_name_uuid,
+                    "WFInput": attachment_action_output(file_src_uuid, "File"),
+                    "WFName": "Renamed.txt",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.file.delete",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-delete-by-path"),
+                    "WFInput": attachment_action_output(path_uuid, "File Path"),
+                },
+            },
+        ]
+    )
+    return root_plist(case_name, actions)
+
+
+def make_rename_file_share_invalid(case_name: str) -> tuple[dict, str]:
+    prompt = "Rename File used before Share invalid case"
+    actions = base_actions(case_name, prompt)
+    file_src_uuid = seeded_uuid(f"{case_name}-file-src")
+    rename_uuid = seeded_uuid(f"{case_name}-rename")
+
+    actions.extend(
+        [
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.file.select",
+                "WFWorkflowActionParameters": {"UUID": file_src_uuid},
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.setvariable",
+                "WFWorkflowActionParameters": {
+                    "WFVariableName": "Original File",
+                    "WFInput": attachment_action_output(file_src_uuid, "File"),
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.file.rename",
+                "WFWorkflowActionParameters": {
+                    "UUID": rename_uuid,
+                    "WFFile": attachment_variable("Original File"),
+                    "WFNewFilename": "Renamed.txt",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.share",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-share-renamed"),
+                    "WFInput": attachment_action_output(rename_uuid, "Renamed File"),
+                },
+            },
+        ]
+    )
+    return root_plist(case_name, actions), "Share consumes Rename File output"
+
+
+def make_rename_file_delete_original_invalid(case_name: str) -> tuple[dict, str]:
+    prompt = "Rename File followed by Delete File original variable invalid case"
+    actions = base_actions(case_name, prompt)
+    file_src_uuid = seeded_uuid(f"{case_name}-file-src")
+    actions.extend(
+        [
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.file.select",
+                "WFWorkflowActionParameters": {"UUID": file_src_uuid},
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.setvariable",
+                "WFWorkflowActionParameters": {
+                    "WFVariableName": "Original File",
+                    "WFInput": attachment_action_output(file_src_uuid, "File"),
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.file.rename",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-rename"),
+                    "WFFile": attachment_variable("Original File"),
+                    "WFNewFilename": "Renamed.txt",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.file.delete",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-delete-original"),
+                    "WFInput": attachment_variable("Original File"),
+                },
+            },
+        ]
+    )
+    return root_plist(case_name, actions), "Delete File reuses variable"
+
+
+def make_health_find_detail_valid(case_name: str, idx: int, health_type: str) -> dict:
+    prompt = f"HealthKit find/detail valid case {idx}"
+    actions = base_actions(case_name, prompt)
+    find_uuid = seeded_uuid(f"{case_name}-find-health")
+    detail_uuid = seeded_uuid(f"{case_name}-detail-health")
+    detail = HEALTH_SAMPLE_DETAILS[idx % len(HEALTH_SAMPLE_DETAILS)]
+
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.filter.health.quantity",
+            "WFWorkflowActionParameters": {
+                "UUID": find_uuid,
+                "WFContentItemFilter": health_filter_template(health_type),
+                "WFContentItemLimitEnabled": False,
+            },
+        }
+    )
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.properties.health.quantity",
+            "WFWorkflowActionParameters": {
+                "UUID": detail_uuid,
+                "WFContentItemPropertyName": detail,
+                "WFInput": attachment_action_output(find_uuid, "Health Samples"),
+            },
+        }
+    )
+    return root_plist(case_name, actions)
+
+
+def make_health_find_detail_via_variable_valid(case_name: str, health_type: str) -> dict:
+    prompt = "HealthKit find/detail via named variable valid case"
+    actions = base_actions(case_name, prompt)
+    find_uuid = seeded_uuid(f"{case_name}-find-health")
+    detail_uuid = seeded_uuid(f"{case_name}-detail-health")
+    var_name = "Latest Health Samples"
+
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.filter.health.quantity",
+            "WFWorkflowActionParameters": {
+                "UUID": find_uuid,
+                "WFContentItemFilter": health_filter_template(health_type),
+                "WFContentItemLimitEnabled": False,
+            },
+        }
+    )
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.setvariable",
+            "WFWorkflowActionParameters": {
+                "WFVariableName": var_name,
+                "WFInput": attachment_action_output(find_uuid, "Health Samples"),
+            },
+        }
+    )
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.properties.health.quantity",
+            "WFWorkflowActionParameters": {
+                "UUID": detail_uuid,
+                "WFContentItemPropertyName": "Value",
+                "WFInput": attachment_variable(var_name),
+            },
+        }
+    )
+    return root_plist(case_name, actions)
+
+
+def make_health_log_quantity_valid(case_name: str, idx: int, health_type: str, unit: str) -> dict:
+    prompt = f"HealthKit log quantity valid case {idx}"
+    actions = base_actions(case_name, prompt)
+    params = {
+        "UUID": seeded_uuid(f"{case_name}-log-health"),
+        "WFQuantitySampleType": health_type,
+        "WFQuantitySampleQuantity": quantity_field("1", unit),
+        "WFQuantitySampleDate": current_date_attachment(),
+    }
+    if idx % 11 == 0:
+        params["WFQuantitySampleAdditionalQuantity"] = quantity_field(None, unit)
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.health.quantity.log",
+            "WFWorkflowActionParameters": params,
+        }
+    )
+    return root_plist(case_name, actions)
+
+
+def make_health_log_quantity_variable_valid(case_name: str) -> dict:
+    prompt = "HealthKit log quantity with variable magnitude valid case"
+    actions = base_actions(case_name, prompt)
+    number_uuid = seeded_uuid(f"{case_name}-number")
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.number",
+            "WFWorkflowActionParameters": {
+                "UUID": number_uuid,
+                "WFNumberActionNumber": "120",
+            },
+        }
+    )
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.health.quantity.log",
+            "WFWorkflowActionParameters": {
+                "UUID": seeded_uuid(f"{case_name}-log-health"),
+                "WFQuantitySampleType": "Caffeine",
+                "WFQuantitySampleQuantity": quantity_field(
+                    token_string_action_output(number_uuid, "Number"), "g"
+                ),
+                "WFQuantitySampleDate": current_date_attachment(),
+            },
+        }
+    )
+    return root_plist(case_name, actions)
+
+
+def make_health_log_category_valid(case_name: str, idx: int, health_type: str, value: str) -> dict:
+    prompt = f"HealthKit log category valid case {idx}"
+    actions = base_actions(case_name, prompt)
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.health.quantity.log",
+            "WFWorkflowActionParameters": {
+                "UUID": seeded_uuid(f"{case_name}-log-health"),
+                "WFQuantitySampleType": health_type,
+                "WFCategorySampleEnumeration": value,
+                "WFQuantitySampleQuantity": quantity_field("10", "count"),
+                "WFQuantitySampleAdditionalQuantity": quantity_field(None, "count"),
+                "WFQuantitySampleDate": current_date_attachment(),
+                "WFSampleEndDate": current_date_attachment(),
+            },
+        }
+    )
+    return root_plist(case_name, actions)
+
+
+def make_health_log_unit_valid(case_name: str, idx: int, unit: str) -> dict:
+    prompt = f"HealthKit ActionKit unit valid case {idx}"
+    actions = base_actions(case_name, prompt)
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.health.quantity.log",
+            "WFWorkflowActionParameters": {
+                "UUID": seeded_uuid(f"{case_name}-log-health"),
+                "WFQuantitySampleType": "Caffeine",
+                "WFQuantitySampleQuantity": quantity_field("10", unit),
+                "WFQuantitySampleAdditionalQuantity": quantity_field(None, unit),
+                "WFQuantitySampleDate": current_date_attachment(),
+            },
+        }
+    )
+    return root_plist(case_name, actions)
+
+
+def make_health_find_invalid_type_label(case_name: str, label: str) -> dict:
+    prompt = f"HealthKit invalid Find Health Samples label {label}"
+    actions = base_actions(case_name, prompt)
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.filter.health.quantity",
+            "WFWorkflowActionParameters": {
+                "UUID": seeded_uuid(f"{case_name}-find-health"),
+                "WFContentItemFilter": health_filter_template(label),
+            },
+        }
+    )
+    return root_plist(case_name, actions)
+
+
+def make_health_sleep_duration_divide_60_invalid(case_name: str) -> dict:
+    prompt = "HealthKit invalid sleep duration conversion"
+    actions = base_actions(case_name, prompt)
+    number_uuid = seeded_uuid(f"{case_name}-sleep-total-number")
+    divide_uuid = seeded_uuid(f"{case_name}-sleep-divide")
+    round_uuid = seeded_uuid(f"{case_name}-sleep-round")
+    actions.extend(
+        [
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.number",
+                "WFWorkflowActionParameters": {
+                    "UUID": number_uuid,
+                    "WFNumberActionNumber": 0,
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.setvariable",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-set-sleep-total"),
+                    "WFVariableName": "Sleep Total",
+                    "WFInput": attachment_action_output(number_uuid, "Number"),
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.math",
+                "WFWorkflowActionParameters": {
+                    "UUID": divide_uuid,
+                    "WFInput": attachment_variable("Sleep Total"),
+                    "WFMathOperation": "÷",
+                    "WFMathOperand": "60",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.round",
+                "WFWorkflowActionParameters": {
+                    "UUID": round_uuid,
+                    "WFInput": attachment_action_output(divide_uuid, "Calculation Result"),
+                    "WFRoundMode": "Normal",
+                    "WFRoundTo": "Tenths",
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.setvariable",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-set-sleep-hours"),
+                    "WFVariableName": "Sleep Hours",
+                    "WFInput": attachment_action_output(round_uuid, "Rounded Number"),
+                },
+            },
+        ]
+    )
+    return root_plist(case_name, actions)
+
+
+def make_health_distance_divide_1000_invalid(case_name: str) -> dict:
+    prompt = "HealthKit invalid distance conversion"
+    actions = base_actions(case_name, prompt)
+    number_uuid = seeded_uuid(f"{case_name}-distance-total-number")
+    actions.extend(
+        [
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.number",
+                "WFWorkflowActionParameters": {
+                    "UUID": number_uuid,
+                    "WFNumberActionNumber": 0,
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.setvariable",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-set-distance-total"),
+                    "WFVariableName": "Distance Total",
+                    "WFInput": attachment_action_output(number_uuid, "Number"),
+                },
+            },
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.math",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-distance-divide"),
+                    "WFInput": attachment_variable("Distance Total"),
+                    "WFMathOperation": "÷",
+                    "WFMathOperand": "1000",
+                },
+            },
+        ]
+    )
+    return root_plist(case_name, actions)
+
+
+def make_health_workout_valid(case_name: str, idx: int, workout_type: str) -> dict:
+    prompt = f"HealthKit workout valid case {idx}"
+    actions = base_actions(case_name, prompt)
+    actions.append(
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.health.workout.log",
+            "WFWorkflowActionParameters": {
+                "UUID": seeded_uuid(f"{case_name}-log-workout"),
+                "WFWorkoutReadableActivityType": workout_type,
+                "WFWorkoutDate": current_date_attachment(),
+                "WFWorkoutDuration": quantity_field("30", "min"),
+                "WFWorkoutCaloriesQuantity": quantity_field("100", "kcal"),
+                "WFWorkoutDistanceQuantity": quantity_field("1000", "m"),
+            },
+        }
+    )
+    return root_plist(case_name, actions)
+
+
+def make_health_invalid(case_name: str, idx: int) -> tuple[dict, str]:
+    prompt = f"HealthKit invalid case {idx}"
+    actions = base_actions(case_name, prompt)
+    pattern = idx % 14
+    expected = "Health"
+
+    if pattern == 0:
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.filter.health.quantity",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-find-health"),
+                    "WFContentItemFilter": health_filter_template(None),
+                },
+            }
+        )
+        expected = "Type filter"
+    elif pattern == 1:
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.filter.health.quantity",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-find-health"),
+                },
+            }
+        )
+        expected = "WFContentItemFilter"
+    elif pattern == 2:
+        find_uuid = seeded_uuid(f"{case_name}-find-health")
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.filter.health.quantity",
+                "WFWorkflowActionParameters": {
+                    "UUID": find_uuid,
+                    "WFContentItemFilter": health_filter_template("Steps"),
+                    "WFContentItemLimitEnabled": False,
+                },
+            }
+        )
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.properties.health.quantity",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-detail-health"),
+                    "WFInput": attachment_action_output(find_uuid, "Health Samples"),
+                },
+            }
+        )
+        expected = "WFContentItemPropertyName"
+    elif pattern == 3:
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.properties.health.quantity",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-detail-health"),
+                    "WFContentItemPropertyName": "Value",
+                    "WFInput": attachment_action_output(seeded_uuid(f"{case_name}-missing"), "Text"),
+                },
+            }
+        )
+        expected = "unknown OutputUUID"
+    elif pattern == 4:
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.health.quantity.log",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-log-health"),
+                    "WFQuantitySampleQuantity": quantity_field("1", "g"),
+                },
+            }
+        )
+        expected = "WFQuantitySampleType"
+    elif pattern == 5:
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.health.quantity.log",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-log-health"),
+                    "WFQuantitySampleType": "Caffeine",
+                    "WFQuantitySampleQuantity": quantity_field(None, "g"),
+                },
+            }
+        )
+        expected = "missing Magnitude"
+    elif pattern == 6:
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.health.quantity.log",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-log-health"),
+                    "WFQuantitySampleType": "Caffeine",
+                    "WFQuantitySampleQuantity": {
+                        "WFSerializationType": "WFTextTokenString",
+                        "Value": {"string": "120", "attachmentsByRange": {}},
+                    },
+                },
+            }
+        )
+        expected = "WFQuantityFieldValue"
+    elif pattern == 7:
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.health.workout.log",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-log-workout"),
+                    "WFWorkoutDuration": quantity_field("30", "min"),
+                },
+            }
+        )
+        expected = "WFWorkoutReadableActivityType"
+    elif pattern == 8:
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.health.workout.log",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-log-workout"),
+                    "WFWorkoutReadableActivityType": "Running",
+                    "WFWorkoutDuration": quantity_field(None, "min"),
+                },
+            }
+        )
+        expected = "missing Magnitude"
+    elif pattern == 9:
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.filter.health.quantity",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-find-health"),
+                    "WFContentItemFilter": health_filter_template("Not A Health Quantity"),
+                },
+            }
+        )
+        expected = "unknown Type filter value"
+    elif pattern == 10:
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.filter.health.quantity",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-find-health"),
+                    "WFContentItemFilter": malformed_health_value_filter_template("Step Count"),
+                },
+            }
+        )
+        expected = "Type filter"
+    elif pattern == 11:
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.filter.health.quantity",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-find-health"),
+                    "WFContentItemFilter": mixed_health_type_and_value_filter_template(),
+                },
+            }
+        )
+        expected = "Type filter"
+    elif pattern == 12:
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.health.quantity.log",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-log-health"),
+                    "WFQuantitySampleType": "Caffeine",
+                    "WFQuantitySampleQuantity": quantity_field("1", "parsecs"),
+                },
+            }
+        )
+        expected = "unknown Unit"
+    else:
+        actions.append(
+            {
+                "WFWorkflowActionIdentifier": "is.workflow.actions.health.workout.log",
+                "WFWorkflowActionParameters": {
+                    "UUID": seeded_uuid(f"{case_name}-log-workout"),
+                    "WFWorkoutReadableActivityType": "Moonwalking",
+                    "WFWorkoutDuration": quantity_field("30", "min"),
+                },
+            }
+        )
+        expected = "unknown WFWorkoutReadableActivityType"
+
+    return root_plist(case_name, actions), expected
+
+
+def build_cases() -> list[Case]:
+    cases: list[Case] = []
+
+    cases.append(Case("url-schemes", "ZZ-Shortcuts-URL-Valid", make_shortcuts_url_valid("ZZ-Shortcuts-URL-Valid"), True))
+    cases.append(
+        Case(
+            "url-schemes",
+            "ZZ-Shortcuts-URL-Unsupported-Invalid",
+            make_shortcuts_url_invalid("ZZ-Shortcuts-URL-Unsupported-Invalid"),
+            False,
+            "Unsupported Apple-documented Shortcuts URL route",
+        )
+    )
+    cases.append(
+        Case(
+            "javascript-webpage",
+            "ZZ-JavaScript-Webpage-Valid",
+            make_javascript_webpage_valid("ZZ-JavaScript-Webpage-Valid"),
+            True,
+        )
+    )
+    cases.append(
+        Case(
+            "javascript-webpage",
+            "ZZ-JavaScript-Webpage-Invalid",
+            make_javascript_webpage_invalid("ZZ-JavaScript-Webpage-Invalid"),
+            False,
+            "requires ActionExtension",
+        )
+    )
+    cases.append(
+        Case(
+            "send-message",
+            "ZZ-SendMessage-Single-Type-Valid",
+            make_send_message_single_type_valid("ZZ-SendMessage-Single-Type-Valid"),
+            True,
+        )
+    )
+    for name, maker in [
+        ("ZZ-SendMessage-One-Append-Invalid", make_send_message_one_append_invalid),
+        ("ZZ-SendMessage-ActionOutput-Invalid", make_send_message_action_output_invalid),
+        ("ZZ-SendMessage-Attachment-Invalid", make_send_message_attachment_invalid),
+    ]:
+        plist, expected = maker(name)
+        cases.append(Case("send-message", name, plist, False, expected))
+    cases.append(
+        Case(
+            "calendar-filters",
+            "ZZ-Calendar-Next-Event-Filter-Valid",
+            make_calendar_next_event_filter_valid("ZZ-Calendar-Next-Event-Filter-Valid"),
+            True,
+        )
+    )
+    plist, expected = make_calendar_next_event_filter_invalid("ZZ-Calendar-Next-Event-Filter-Invalid")
+    cases.append(Case("calendar-filters", "ZZ-Calendar-Next-Event-Filter-Invalid", plist, False, expected))
+    cases.append(
+        Case(
+            "date-delta",
+            "ZZ-Get-Time-Between-Dates-Valid",
+            make_get_time_between_dates_valid("ZZ-Get-Time-Between-Dates-Valid"),
+            True,
+        )
+    )
+    for name, maker in [
+        ("ZZ-Get-Time-Between-Dates-CurrentDate-Invalid", make_get_time_between_dates_current_date_invalid),
+        ("ZZ-Get-Time-Between-Dates-Attachment-Invalid", make_get_time_between_dates_attachment_invalid),
+        ("ZZ-Text-Token-Placeholder-Invalid", make_text_token_placeholder_invalid),
+    ]:
+        plist, expected = maker(name)
+        cases.append(Case("date-delta", name, plist, False, expected))
+
+    # 43 weather cases (21 valid + 22 invalid)
+    for idx in range(20):
+        case_name = f"ZZ-Weather-Valid-{idx + 1:02d}"
+        cases.append(Case("weather", case_name, make_weather_valid(case_name, idx), True))
+    cases.append(
+        Case(
+            "weather",
+            "ZZ-Weather-Sun-Times-Valid",
+            make_weather_sun_times_valid("ZZ-Weather-Sun-Times-Valid"),
+            True,
+        )
+    )
+    for idx in range(22):
+        case_name = f"ZZ-Weather-Invalid-{idx + 1:02d}"
+        plist, expected = make_weather_invalid(case_name, idx)
+        cases.append(Case("weather", case_name, plist, False, expected))
+
+    # 40 location cases (20 valid + 20 invalid)
+    for idx in range(20):
+        case_name = f"ZZ-Location-Valid-{idx + 1:02d}"
+        cases.append(Case("location", case_name, make_location_valid(case_name, idx), True))
+    for idx in range(20):
+        case_name = f"ZZ-Location-Invalid-{idx + 1:02d}"
+        plist, expected = make_location_invalid(case_name, idx)
+        cases.append(Case("location", case_name, plist, False, expected))
+
+    # 16 Set Name/Rename File cases (8 valid + 8 invalid)
+    for idx in range(6):
+        case_name = f"ZZ-SetName-Valid-{idx + 1:02d}"
+        cases.append(Case("set-name", case_name, make_set_name_valid(case_name, idx), True))
+    cases.append(
+        Case(
+            "set-name",
+            "ZZ-SetName-Delete-Variable-Valid",
+            make_set_name_delete_variable_valid("ZZ-SetName-Delete-Variable-Valid"),
+            True,
+        )
+    )
+    cases.append(
+        Case(
+            "set-name",
+            "ZZ-SetName-Delete-By-Path-Valid",
+            make_set_name_delete_by_path_valid("ZZ-SetName-Delete-By-Path-Valid"),
+            True,
+        )
+    )
+    for idx in range(6):
+        case_name = f"ZZ-SetName-Invalid-{idx + 1:02d}"
+        plist, expected = make_set_name_invalid(case_name, idx)
+        cases.append(Case("set-name", case_name, plist, False, expected))
+    for name, maker in [
+        ("ZZ-RenameFile-Share-Invalid", make_rename_file_share_invalid),
+        ("ZZ-RenameFile-Delete-Original-Invalid", make_rename_file_delete_original_invalid),
+    ]:
+        plist, expected = maker(name)
+        cases.append(Case("set-name", name, plist, False, expected))
+
+    health = load_healthkit_reference()
+    validate_healthkit_reference_labels(health)
+    quantity_types = health.get("quantity_types", [])
+    category_types = health.get("category_types", [])
+    category_values = health.get("category_values", {})
+    quantity_units = health.get("quantity_units", [])
+    workout_types = health.get("workout_activity_types", [])
+    enum_to_category_label: dict[str, str] = {}
+    for row in category_types:
+        enum_name = row.get("unit_and_aggregation")
+        label = row.get("shortcut_label_guess") or row.get("sdk_suffix")
+        if isinstance(enum_name, str) and isinstance(label, str) and enum_name.startswith("HKCategoryValue"):
+            enum_to_category_label.setdefault(enum_name, label)
+    # SDK comments and enum names are not always one-to-one; these aliases keep
+    # enum value coverage tied to known Shortcuts category type labels.
+    enum_to_category_label.setdefault("HKCategoryValueAudioExposureEvent", "Environmental Audio Exposure Event")
+    enum_to_category_label.setdefault("HKCategoryValueMenstrualFlow", "Menstrual Flow")
+
+    # Find Health Samples + Get Details: all SDK-known quantity types.
+    for idx, row in enumerate(quantity_types):
+        label = health_find_sample_label(row) or f"Quantity {idx}"
+        case_name = f"ZZ-Health-Find-Detail-Valid-{idx + 1:03d}"
+        cases.append(Case("healthkit", case_name, make_health_find_detail_valid(case_name, idx, label), True))
+
+    # Find Health Samples also supports category types such as Sleep.
+    for idx, row in enumerate(category_types):
+        label = health_find_sample_label(row) or f"Category {idx}"
+        case_name = f"ZZ-Health-Find-Detail-Category-Valid-{idx + 1:03d}"
+        cases.append(Case("healthkit", case_name, make_health_find_detail_valid(case_name, idx, label), True))
+
+    if quantity_types:
+        case_name = "ZZ-Health-Find-Detail-Variable-Valid"
+        label = health_find_sample_label(quantity_types[0]) or "Steps"
+        cases.append(
+            Case(
+                "healthkit",
+                case_name,
+                make_health_find_detail_via_variable_valid(case_name, label),
+                True,
+            )
+        )
+
+    # Log Health Sample quantities: every SDK-known quantity type, with each
+    # type's unit hint from HealthKit headers.
+    for idx, row in enumerate(quantity_types):
+        label = row.get("shortcut_label_guess") or row.get("sdk_suffix") or f"Quantity {idx}"
+        case_name = f"ZZ-Health-Log-Quantity-Valid-{idx + 1:03d}"
+        cases.append(
+            Case(
+                "healthkit",
+                case_name,
+                make_health_log_quantity_valid(case_name, idx, label, health_unit_hint(row)),
+                True,
+            )
+        )
+
+    case_name = "ZZ-Health-Log-Quantity-Variable-Valid"
+    cases.append(Case("healthkit", case_name, make_health_log_quantity_variable_valid(case_name), True))
+
+    # Log Health Sample units: every unit string exposed by ActionKit's local
+    # WFHealthKitConstants.plist.
+    for idx, row in enumerate(quantity_units):
+        unit = row.get("unit") or f"unit-{idx}"
+        case_name = f"ZZ-Health-Log-Unit-Valid-{idx + 1:03d}"
+        cases.append(
+            Case(
+                "healthkit",
+                case_name,
+                make_health_log_unit_valid(case_name, idx, unit),
+                True,
+            )
+        )
+
+    # Log Health Sample categories: every SDK-known category type, plus every
+    # explicit category value enum exposed by HealthKit. Current iOS exports
+    # category values with WFCategorySampleEnumeration plus the same count-based
+    # quantity scaffold that quantity logs use.
+    for idx, row in enumerate(category_types):
+        label = row.get("shortcut_label_guess") or row.get("sdk_suffix") or f"Category {idx}"
+        case_name = f"ZZ-Health-Log-Category-Valid-{idx + 1:03d}"
+        cases.append(
+            Case("healthkit", case_name, make_health_log_category_valid(case_name, idx, label, "Present"), True)
+        )
+
+    enum_idx = 0
+    for enum_name in sorted(category_values):
+        for value_row in category_values.get(enum_name, []):
+            label = enum_to_category_label.get(enum_name)
+            if not label:
+                label = category_types[0].get("shortcut_label_guess") if category_types else "Bloating"
+            value = value_row.get("shortcut_label_guess") or value_row.get("symbol") or "Present"
+            case_name = f"ZZ-Health-Log-Category-Value-Valid-{enum_idx + 1:03d}"
+            cases.append(
+                Case(
+                    "healthkit",
+                    case_name,
+                    make_health_log_category_valid(case_name, enum_idx, label, value),
+                    True,
+                )
+            )
+            enum_idx += 1
+
+    # Log Workout: every SDK-known workout activity type.
+    for idx, row in enumerate(workout_types):
+        label = row.get("shortcut_label_guess") or row.get("symbol") or f"Workout {idx}"
+        case_name = f"ZZ-Health-Workout-Valid-{idx + 1:03d}"
+        cases.append(Case("healthkit", case_name, make_health_workout_valid(case_name, idx, label), True))
+
+    for idx in range(24):
+        case_name = f"ZZ-Health-Invalid-{idx + 1:02d}"
+        plist, expected = make_health_invalid(case_name, idx)
+        cases.append(Case("healthkit", case_name, plist, False, expected))
+
+    stale_find_labels = [
+        "Sleep Analysis",
+        "Active Energy",
+        "Active Energy Burned",
+        "Apple Exercise Time",
+        "Exercise Time",
+    ]
+    for idx, label in enumerate(stale_find_labels):
+        case_name = f"ZZ-Health-Find-Stale-Label-Invalid-{idx + 1:02d}"
+        cases.append(
+            Case(
+                "healthkit",
+                case_name,
+                make_health_find_invalid_type_label(case_name, label),
+                False,
+                "unknown Type filter value",
+            )
+        )
+
+    stale_log_labels = [
+        "Active Energy",
+        "Active Energy Burned",
+    ]
+    for idx, label in enumerate(stale_log_labels):
+        case_name = f"ZZ-Health-Log-Stale-Label-Invalid-{idx + 1:02d}"
+        cases.append(
+            Case(
+                "healthkit",
+                case_name,
+                make_health_log_quantity_valid(case_name, idx, label, "kcal"),
+                False,
+                "unknown WFQuantitySampleType",
+            )
+        )
+
+    case_name = "ZZ-Health-Sleep-Duration-Divide-60-Invalid"
+    cases.append(
+        Case(
+            "healthkit",
+            case_name,
+            make_health_sleep_duration_divide_60_invalid(case_name),
+            False,
+            "Sleep duration math divides by 60",
+        )
+    )
+
+    case_name = "ZZ-Health-Distance-Divide-1000-Invalid"
+    cases.append(
+        Case(
+            "healthkit",
+            case_name,
+            make_health_distance_divide_1000_invalid(case_name),
+            False,
+            "Health distance math divides",
+        )
+    )
+
+    return cases
+
+
+def write_fixture(path: Path, plist: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(plistlib.dumps(plist, fmt=plistlib.FMT_XML, sort_keys=False))
+
+
+def run_suite(cases: list[Case], fixture_dir: Optional[Path]) -> int:
+    skill_dir = Path(__file__).resolve().parents[1]
+    # This suite intentionally mixes macOS and iOS-only fixtures, including
+    # HealthKit. Use all packaged platform snapshots so target-platform gating
+    # does not hide the schemas this regression suite is meant to exercise.
+    allowed_ids = load_allowed_ids(skill_dir, target_platform=None)
+    allowed_glyph_ids, allowed_icon_colors = load_icon_metadata(skill_dir)
+
+    per_category: dict[str, dict[str, int]] = {}
+    failures: list[str] = []
+
+    for case in cases:
+        per_category.setdefault(
+            case.category, {"total": 0, "expected_valid": 0, "expected_invalid": 0, "passed": 0}
+        )
+        stats = per_category[case.category]
+        stats["total"] += 1
+        stats["expected_valid" if case.expect_valid else "expected_invalid"] += 1
+
+        if fixture_dir is not None:
+            write_fixture(fixture_dir / case.category / f"{case.name}.shortcut", case.plist)
+
+        errors, _ = validate(case.plist, allowed_ids, allowed_glyph_ids, allowed_icon_colors)
+        ok = False
+        if case.expect_valid:
+            ok = len(errors) == 0
+        else:
+            if errors:
+                if case.expected_error_substring:
+                    ok = any(case.expected_error_substring in err for err in errors)
+                else:
+                    ok = True
+
+        if ok:
+            stats["passed"] += 1
+            continue
+
+        preview = " | ".join(errors[:3]) if errors else "NO ERRORS"
+        failures.append(
+            f"{case.category}/{case.name} expected "
+            f"{'valid' if case.expect_valid else 'invalid'} but got {'valid' if not errors else 'invalid'} :: {preview}"
+        )
+
+    print("Regression summary:")
+    for category in sorted(per_category.keys()):
+        stats = per_category[category]
+        print(
+            f"- {category}: {stats['passed']}/{stats['total']} passed "
+            f"(valid={stats['expected_valid']}, invalid={stats['expected_invalid']})"
+        )
+
+    if failures:
+        print("\nFailures:")
+        for item in failures:
+            print(f"- {item}")
+        return 1
+
+    print("\nAll regression cases matched expectations.")
+    return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Run weather/location wiring regression tests for generate-shortcuts-skill."
+    )
+    parser.add_argument(
+        "--write-fixtures",
+        help="Directory where generated .shortcut fixtures should be written",
+    )
+    args = parser.parse_args()
+
+    fixture_dir = Path(args.write_fixtures).expanduser().resolve() if args.write_fixtures else None
+    return run_suite(build_cases(), fixture_dir)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())