refactor(kernel-utils): extract buildMethodGuard to eliminate duplication

asyncifyMethodGuards (sheafify.ts) and collectSheafGuard (guard.ts) both
contained an identical 4-way if/else for assembling a MethodGuard from its
components. The chain order required by @endo/patterns (callWhen → optional →
rest → returns) makes each branch non-obvious — a bad candidate for
duplication. Extract buildMethodGuard into guard.ts and use it in both sites.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: grypez

packages/kernel-utils/src/sheaf/guard.ts

@@ -16,6 +16,38 @@ export type MethodGuardPayload = {
   returnGuard: Pattern;
 };
 
+/**
+ * Assemble a MethodGuard from its components.
+ *
+ * The @endo/patterns builder API requires a strict chain order:
+ * callWhen → optional → rest → returns. All four combinations of
+ * optional/rest presence are handled here so callers don't repeat this logic.
+ *
+ * @param base - Result of M.callWhen(...requiredArgs).
+ * @param optionals - Optional positional arg guards (may be empty).
+ * @param restGuard - Rest arg guard, or undefined if none.
+ * @param returnGuard - Return value guard.
+ * @returns The assembled MethodGuard.
+ */
+export const buildMethodGuard = (
+  base: ReturnType<typeof M.callWhen>,
+  optionals: Pattern[],
+  restGuard: Pattern | undefined,
+  returnGuard: Pattern,
+): MethodGuard => {
+  if (optionals.length > 0 && restGuard !== undefined) {
+    return base
+      .optional(...optionals)
+      .rest(restGuard)
+      .returns(returnGuard);
+  } else if (optionals.length > 0) {
+    return base.optional(...optionals).returns(returnGuard);
+  } else if (restGuard === undefined) {
+    return base.returns(returnGuard);
+  }
+  return base.rest(restGuard).returns(returnGuard);
+};
+
 /**
  * Naive union of guards via M.or — no pattern canonicalization.
  *
@@ -121,23 +153,12 @@ export const collectSheafGuard = <Core extends Methods>(
       payloads.map((payload) => payload.returnGuard),
     );
 
-    const base = M.callWhen(...requiredArgGuards);
-    if (optionalArgGuards.length > 0 && unionRestArgGuard !== undefined) {
-      unionMethodGuards[methodName] = base
-        .optional(...optionalArgGuards)
-        .rest(unionRestArgGuard)
-        .returns(returnGuard);
-    } else if (optionalArgGuards.length > 0) {
-      unionMethodGuards[methodName] = base
-        .optional(...optionalArgGuards)
-        .returns(returnGuard);
-    } else if (unionRestArgGuard === undefined) {
-      unionMethodGuards[methodName] = base.returns(returnGuard);
-    } else {
-      unionMethodGuards[methodName] = base
-        .rest(unionRestArgGuard)
-        .returns(returnGuard);
-    }
+    unionMethodGuards[methodName] = buildMethodGuard(
+      M.callWhen(...requiredArgGuards),
+      optionalArgGuards,
+      unionRestArgGuard,
+      returnGuard,
+    );
   }
 
   return M.interface(name, unionMethodGuards);

packages/kernel-utils/src/sheaf/sheafify.ts

@@ -24,7 +24,7 @@ import { makeDiscoverableExo } from '../discoverable.ts';
 import type { MethodSchema } from '../schema.ts';
 import { stringify } from '../stringify.ts';
 import { driveLift } from './drive.ts';
-import { collectSheafGuard } from './guard.ts';
+import { buildMethodGuard, collectSheafGuard } from './guard.ts';
 import type { MethodGuardPayload } from './guard.ts';
 import { evaluateMetadata, resolveMetaDataSpec } from './metadata.ts';
 import type { ResolvedMetaDataSpec } from './metadata.ts';
@@ -140,23 +140,12 @@ const asyncifyMethodGuards = (
     const { argGuards, optionalArgGuards, restArgGuard, returnGuard } =
       getMethodGuardPayload(methodGuard) as unknown as MethodGuardPayload;
     const optionals = optionalArgGuards ?? [];
-    const base = M.callWhen(...argGuards);
-    if (optionals.length > 0 && restArgGuard !== undefined) {
-      asyncMethodGuards[methodName] = base
-        .optional(...optionals)
-        .rest(restArgGuard)
-        .returns(returnGuard);
-    } else if (optionals.length > 0) {
-      asyncMethodGuards[methodName] = base
-        .optional(...optionals)
-        .returns(returnGuard);
-    } else if (restArgGuard === undefined) {
-      asyncMethodGuards[methodName] = base.returns(returnGuard);
-    } else {
-      asyncMethodGuards[methodName] = base
-        .rest(restArgGuard)
-        .returns(returnGuard);
-    }
+    asyncMethodGuards[methodName] = buildMethodGuard(
+      M.callWhen(...argGuards),
+      optionals,
+      restArgGuard,
+      returnGuard,
+    );
   }
   return asyncMethodGuards;
 };