fix: ensure optional paths are not used as discriminants

dev/configs/.changeset/unlucky-kangaroos-divide.md

@@ -0,0 +1,5 @@
+---
+"arktype": patch
+---
+
+Fix an issue where optional paths could be used as discriminants

dev/test/discriminate.test.ts

@@ -77,6 +77,79 @@ describe("discriminate", () => {
             ]
         ])
     })
+    it("doesn't discriminate optional key", () => {
+        const a = type({
+            direction: "'forward' | 'backward'",
+            "operator?": "'by'"
+        })
+
+        const b = type({
+            duration: "'s' | 'min' | 'h'",
+            operator: "'to'"
+        })
+
+        const c = type([a, "|", b])
+        attest(c.flat).snap([
+            ["domain", "object"],
+            [
+                "branches",
+                [
+                    [
+                        [
+                            "requiredProp",
+                            [
+                                "direction",
+                                [
+                                    ["domain", "string"],
+                                    [
+                                        "switch",
+                                        {
+                                            path: [],
+                                            kind: "value",
+                                            cases: {
+                                                "'forward'": [],
+                                                "'backward'": []
+                                            }
+                                        }
+                                    ]
+                                ]
+                            ]
+                        ],
+                        ["optionalProp", ["operator", [["value", "by"]]]]
+                    ],
+                    [
+                        [
+                            "requiredProp",
+                            [
+                                "duration",
+                                [
+                                    ["domain", "string"],
+                                    [
+                                        "switch",
+                                        {
+                                            path: [],
+                                            kind: "value",
+                                            cases: {
+                                                "'s'": [],
+                                                "'min'": [],
+                                                "'h'": []
+                                            }
+                                        }
+                                    ]
+                                ]
+                            ]
+                        ],
+                        ["requiredProp", ["operator", [["value", "to"]]]]
+                    ]
+                ]
+            ]
+        ])
+        attest(
+            c.allows({
+                direction: "forward"
+            })
+        ).equals(true)
+    })
 
     it("undiscriminatable", () => {
         const t = getPlaces().type([

src/nodes/compose.ts

@@ -112,6 +112,8 @@ export type DisjointKind = keyof DisjointKinds
 
 export class IntersectionState {
     path = new Path()
+    lOptional = false
+    rOptional = false
     domain: Domain | undefined
     #disjoints: DisjointsByPath = {}
 
@@ -126,7 +128,13 @@ export class IntersectionState {
         l: DisjointKinds[kind]["l"],
         r: DisjointKinds[kind]["r"]
     ): Empty {
-        this.#disjoints[`${this.path}`] = { kind, l, r }
+        this.#disjoints[`${this.path}`] = {
+            kind,
+            l,
+            r,
+            lOptional: this.lOptional,
+            rOptional: this.rOptional
+        }
         return empty
     }
 }
@@ -135,6 +143,8 @@ export type DisjointsByPath = Record<string, DisjointContext>
 
 export type DisjointContext<kind extends DisjointKind = DisjointKind> = {
     kind: kind
+    lOptional: boolean
+    rOptional: boolean
 } & DisjointKinds[kind]
 
 const empty = Symbol("empty")

src/nodes/discriminate.ts

@@ -244,10 +244,14 @@ const calculateDiscriminants = (
                     // https://github.com/arktypeio/arktype/issues/593
                     continue
                 }
-                const { l, r, kind } = intersectionState.disjoints[path]
+                const { l, r, kind, lOptional, rOptional } =
+                    intersectionState.disjoints[path]
                 if (!isKeyOf(kind, discriminantKinds)) {
                     continue
                 }
+                if (lOptional || rOptional) {
+                    continue
+                }
                 const lSerialized = serializeDefinitionIfAllowed(kind, l)
                 const rSerialized = serializeDefinitionIfAllowed(kind, r)
                 if (lSerialized === undefined || rSerialized === undefined) {

src/nodes/rules/props.ts

@@ -145,9 +145,15 @@ const propKeysIntersection = composeKeyedIntersection<PropsRule>(
             return l
         }
         context.path.push(propKey)
+        const previousLOptional = context.lOptional
+        const previousROptional = context.rOptional
+        context.lOptional ||= isOptional(l)
+        context.rOptional ||= isOptional(r)
         const result = nodeIntersection(propToNode(l), propToNode(r), context)
+        const resultIsOptional = context.lOptional && context.rOptional
+        context.rOptional = previousROptional
+        context.lOptional = previousLOptional
         context.path.pop()
-        const resultIsOptional = isOptional(l) && isOptional(r)
         if (isDisjoint(result) && resultIsOptional) {
             // If an optional key has an empty intersection, the type can
             // still be satisfied as long as the key is not included. Set