fix(engine): drop never-gated hidden array items instead of null holes

Hiding an array item wraps it in a multivariate flag gated by a `never`
matcher; flag.ts returns `undefined` when no variant matched. The engine
left that `undefined` as a hole in the resolved array, which serializes
to `null` in JSON and renders as an empty card (blank benefit rows,
etc.).

Compact `undefined` out of resolved arrays in resolvePropsWithHints. A
resolver returning `null` is a legitimate value and is kept — only the
`undefined` "not present" sentinel is filtered.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: guitavano

engine/core/mod.test.ts

@@ -153,6 +153,39 @@ Deno.test("resolve", async (t) => {
     });
   });
 
+  await t.step(
+    "drops hidden array items (resolver -> undefined) but keeps null",
+    async () => {
+      // A hidden array item is a multivariate flag gated by a `never` matcher;
+      // flag.ts returns `undefined` when no variant matched. Such items must be
+      // dropped from the array, not left as holes (which serialize to `null`
+      // and render as empty cards). A resolver returning `null` is a legitimate
+      // value and is kept.
+      const resolverMap = {
+        resolve: (data: unknown) => context.resolve(data),
+        hiddenFlag: (): unknown => undefined,
+        nullFlag: (): unknown => null,
+        keep: (p: { label: string }) => p,
+      };
+      const result = await resolve<{ items: unknown[] }>(
+        {
+          items: [
+            { label: "A", __resolveType: "keep" },
+            { __resolveType: "hiddenFlag" },
+            { label: "B", __resolveType: "keep" },
+            { __resolveType: "nullFlag" },
+            { __resolveType: "hiddenFlag" },
+          ],
+          __resolveType: "resolve",
+        },
+        { ...context, resolvers: resolverMap as unknown as ResolverMap },
+      );
+      assertEquals(result, {
+        items: [{ label: "A" }, { label: "B" }, null],
+      });
+    },
+  );
+
   await t.step("resolves object with no resolvable fields", async () => {
     type TestType = {
       foo: string;

engine/core/resolver.ts

@@ -424,6 +424,15 @@ const resolvePropsWithHints = async <
   }
 
   if (!type) {
+    // Drop array items that resolved to `undefined` — a hidden array item is a
+    // multivariate flag gated by a `never` matcher, and flag.ts returns
+    // `undefined` when no variant matched. Left in place it survives as a hole
+    // (and serializes to `null` in JSON), which the consuming section renders
+    // as an empty card. A `null` from a resolver is a legitimate value and is
+    // kept — only the `undefined` "not present" sentinel is filtered.
+    if (Array.isArray(mutableProps)) {
+      return mutableProps.filter((item) => item !== undefined) as T;
+    }
     return mutableProps;
   }