fix(spec): the credential walk reads a schema's public def, so an instrumented lazy schema derives instead of throwing (#24994)

Claude-Session: https://claude.ai/code/session_01D6F9axfoPzR7t8G1J7Ytzz
Co-authored-by: Claude <noreply@anthropic.com>

Author: claude

packages/spec/src/kernel/metadata-credential-fields.ts

@@ -88,9 +88,19 @@ interface ZodDefLike {
   shape?: Record<string, unknown>;
 }
 
-/** The `_zod.def` of a schema, or `undefined` for anything that is not one. */
+/**
+ * The definition of a schema, or `undefined` for anything that is not one.
+ *
+ * Read through the public `.def` first, and `_zod.def` only for a core schema
+ * that has no `.def`: a `lazySchema` Proxy reports `_zod` as a non-configurable
+ * own property its function target does not have, so a second Proxy wrapped
+ * around it (a test that instruments a registered schema does exactly this)
+ * throws a Proxy invariant TypeError on any `_zod` read, while `.def` resolves.
+ */
 export function zodDefOf(schema: unknown): ZodDefLike | undefined {
   if (!schema || (typeof schema !== 'object' && typeof schema !== 'function')) return undefined;
+  const publicDef = (schema as { def?: ZodDefLike }).def;
+  if (publicDef && typeof publicDef === 'object' && typeof publicDef.type === 'string') return publicDef;
   const internals = (schema as { _zod?: { def?: ZodDefLike } })._zod;
   return internals?.def;
 }

packages/spec/src/kernel/metadata-type-redaction.test.ts

@@ -30,7 +30,7 @@ import {
   type MetadataTypeRedactor,
 } from './metadata-type-redaction';
 import { z } from 'zod';
-import { registerMetadataTypeSchema } from './metadata-type-schemas';
+import { getMetadataTypeSchema as getMetadataTypeSchemaForTest, registerMetadataTypeSchema } from './metadata-type-schemas';
 
 describe('register/lookup round trip (the registry pattern of registerMetadataTypeSchema)', () => {
   it('a registered redactor is returned for its type', () => {
@@ -351,6 +351,14 @@ describe('[ruling B+ on #24966] the third resolution: a redactor DERIVED from th
     expect(result.redactedKeys).toEqual(['config.password']);
   });
 
+  it('derives through a registered schema wrapped in a second Proxy (an instrumented lazy schema)', () => {
+    const webhook = getMetadataTypeSchemaForTest('webhook');
+    const wrapped = new Proxy(webhook as object, { get: (t, p, r) => Reflect.get(t, p, r) });
+    registerMetadataTypeSchema('zz_proxied_rule_test', wrapped as never);
+    const result = getMetadataTypeRedactor('zz_proxied_rule_test')!(declaredWebhook());
+    expect(result.redactedKeys).toEqual(['headers', 'secret']);
+  });
+
   it('the derivation is memoised per schema identity: one redactor across lookups', () => {
     expect(getMetadataTypeRedactor('webhook')).toBe(getMetadataTypeRedactor('webhook'));
   });