replace @traversable/zod since it's incompatible with zod mini

src/feedline/schema/actions-entry.ts

···
-import {zx} from '@traversable/zod'
 import {z} from 'zod/mini'
+
+import {deepPartial} from '#lib/schema'
 
 import {makeActionSchema} from '#realm/schema'
 
···
   z.object({
     guid: z.string(), // entry GUID from feed
     feedurl: z.url(), // which feed this entry belongs to
-    payload: zx.deepPartial(entrySchema, 'applyToOutputType'),
+    payload: deepPartial(entrySchema),
   }),
 )
 

src/feedline/schema/actions-feed.ts

···
-import {zx} from '@traversable/zod'
 import {z} from 'zod/mini'
+
+import {deepPartial} from '#lib/schema'
 
 import {makeActionSchema} from '#realm/schema'
 
···
   'feed:patch',
   z.object({
     url: z.url(),
-    payload: zx.deepPartial(feedSchema, 'applyToOutputType'),
+    payload: deepPartial(feedSchema),
   }),
 )
 

src/lib/schema.ts

···
 import {normalizeProtocolError} from './errors'
 
 export * from './schema/brand'
+export * from './schema/deep-partial'
 export * from './schema/json'
 
 export const eventSchema = z.object({

src/lib/schema/deep-partial.ts

···
+import {z} from 'zod/mini'
+
+// Type-level deep partial for zod schemas
+type DeepPartialShape<T> = {
+  [K in keyof T]: T[K] extends z.ZodMiniType<infer O>
+    ? z.ZodMiniOptional<DeepPartialSchema<T[K] & z.ZodMiniType<O>>>
+    : T[K]
+}
+
+type DeepPartialSchema<T extends z.ZodMiniType> =
+  T extends z.ZodMiniObject<infer Shape>
+    ? z.ZodMiniObject<DeepPartialShape<Shape>>
+    : T extends z.ZodMiniArray<infer E extends z.ZodMiniType>
+      ? z.ZodMiniArray<DeepPartialSchema<E>>
+      : T extends z.ZodMiniOptional<infer U extends z.ZodMiniType>
+        ? z.ZodMiniOptional<DeepPartialSchema<U>>
+        : T extends z.ZodMiniNullable<infer U extends z.ZodMiniType>
+          ? z.ZodMiniNullable<DeepPartialSchema<U>>
+          : T
+
+export type DeepPartial<T extends z.ZodMiniType> = DeepPartialSchema<T>
+
+// Internal type for accessing schema internals
+type SchemaDef = {_zod: {def: {type: string}}}
+
+/**
+ * Creates a deep partial version of a zod schema.
+ * All object properties become optional recursively.
+ */
+export function deepPartial<T extends z.ZodMiniType>(schema: T): DeepPartial<T> {
+  return deepPartialImpl(schema) as DeepPartial<T>
+}
+
+function deepPartialImpl(schema: z.ZodMiniType): z.ZodMiniType {
+  const def = (schema as unknown as SchemaDef)._zod.def
+
+  switch (def.type) {
+    case 'object': {
+      const objDef = def as {type: 'object'; shape: Record<string, z.ZodMiniType>}
+      const newShape: Record<string, z.ZodMiniType> = {}
+
+      for (const [key, value] of Object.entries(objDef.shape)) {
+        newShape[key] = z.optional(deepPartialImpl(value))
+      }
+
+      return z.object(newShape)
+    }
+
+    case 'array': {
+      const arrDef = def as {type: 'array'; element: z.ZodMiniType}
+      return z.array(deepPartialImpl(arrDef.element))
+    }
+
+    case 'optional': {
+      const optDef = def as {type: 'optional'; innerType: z.ZodMiniType}
+      return z.optional(deepPartialImpl(optDef.innerType))
+    }
+
+    case 'nullable': {
+      const nullDef = def as {type: 'nullable'; innerType: z.ZodMiniType}
+      return z.nullable(deepPartialImpl(nullDef.innerType))
+    }
+
+    case 'record': {
+      type RecordDef = {type: 'record'; keyType: z.core.$ZodRecordKey; valueType: z.ZodMiniType}
+      const recDef = def as RecordDef
+      return z.record(recDef.keyType, deepPartialImpl(recDef.valueType))
+    }
+
+    case 'union': {
+      const unionDef = def as {type: 'union'; options: z.ZodMiniType[]}
+      return z.union(unionDef.options.map(deepPartialImpl) as [z.ZodMiniType, ...z.ZodMiniType[]])
+    }
+
+    case 'intersection': {
+      const intDef = def as {type: 'intersection'; left: z.ZodMiniType; right: z.ZodMiniType}
+      return z.intersection(deepPartialImpl(intDef.left), deepPartialImpl(intDef.right))
+    }
+
+    // Primitives and other types pass through unchanged
+    default:
+      return schema
+  }
+}

src/lib/types.ts

···
-import type {deepPartial} from '@traversable/zod'
-
 /**
  * Makes all properties in T optional recursively, including nested objects.
  * @typeParam T - The type to make deeply partial
  */
-export type DeepPartial<T> = deepPartial<T>
+export type DeepPartial<T> = T extends object
+  ? T extends (infer U)[]
+    ? DeepPartial<U>[]
+    : {[K in keyof T]?: DeepPartial<T[K]>}
+  : T
 
 /**
  * Excludes array types from T. Useful for constraining generics to non-array values.