on-zero 0.4.36 → 0.4.38

package/src/createUseQueryDirect.tsx

@@ -0,0 +1,309 @@
+import {
+  addContextToQuery,
+  asQueryInternals,
+  DEFAULT_TTL_MS,
+  deepClone,
+} from '@rocicorp/zero/bindings'
+import { useEmitterValue, type Emitter } from '@take-out/helpers'
+import { useContext, useMemo, useRef, useSyncExternalStore, type Context } from 'react'
+
+import {
+  parseUseQueryArgs,
+  type QueryControlMode,
+  type UseQueryHook,
+  type UseQueryOptions,
+} from './createUseQuery'
+import { resolveQuery } from './resolveQuery'
+
+import type {
+  AnyQueryRegistry,
+  ReadonlyJSONValue,
+  Schema as ZeroSchema,
+} from '@rocicorp/zero'
+
+// optional multi-instance adapter. normal apps should use zero-react's native
+// useQuery path via createZeroClient; this exists only for nested providers
+// where a non-innermost instance cannot be selected through react context.
+
+const EMPTY_RESPONSE = [null, { type: 'unknown' }] as never
+const DISABLED_SUBSCRIBE = () => () => {}
+const DISABLED_SNAPSHOT: readonly [undefined, { type: 'unknown' }] = [
+  undefined,
+  { type: 'unknown' },
+]
+const getDisabledSnapshot = () => DISABLED_SNAPSHOT
+
+type DirectSnapshot = readonly [unknown, { type: string }]
+
+type DirectView = {
+  subscribe: (notify: () => void) => () => void
+  getSnapshot: () => DirectSnapshot
+}
+
+export type MaterializableZero = {
+  clientID: string
+  context: unknown
+  materialize(
+    query: any,
+    options?: { ttl?: any },
+  ): {
+    addListener(
+      cb: (data: any, resultType: string, error?: DirectQueryError) => void,
+    ): void
+    destroy(): void
+    updateTTL(ttl: any): void
+  }
+}
+
+export type CreateUseQueryDirect<Schema extends ZeroSchema> = (props: {
+  DisabledContext: Context<QueryControlMode>
+  customQueries: AnyQueryRegistry
+  getZero: () => MaterializableZero | null
+  zeroVersion: Emitter<number>
+}) => UseQueryHook<Schema>
+
+type DirectResultType = 'unknown' | 'complete' | 'error'
+type DirectQueryError = {
+  error: 'app' | 'parse'
+  message?: string
+  details?: unknown
+}
+
+const emptyArray: readonly unknown[] = []
+const resultTypeUnknown = { type: 'unknown' } as const
+const resultTypeComplete = { type: 'complete' } as const
+const resultTypeError = { type: 'error' } as const
+const emptySnapshotSingularUnknown: DirectSnapshot = [undefined, resultTypeUnknown]
+const emptySnapshotSingularComplete: DirectSnapshot = [undefined, resultTypeComplete]
+const emptySnapshotSingularError: DirectSnapshot = [undefined, resultTypeError]
+const emptySnapshotPluralUnknown: DirectSnapshot = [emptyArray, resultTypeUnknown]
+const emptySnapshotPluralComplete: DirectSnapshot = [emptyArray, resultTypeComplete]
+const emptySnapshotPluralError: DirectSnapshot = [emptyArray, resultTypeError]
+
+function getDefaultSnapshot(singular: boolean) {
+  return singular ? emptySnapshotSingularUnknown : emptySnapshotPluralUnknown
+}
+
+function makeError(retry: () => void, error?: DirectQueryError) {
+  const message = error?.message ?? 'An unknown error occurred'
+  return {
+    type: 'error',
+    retry,
+    refetch: retry,
+    error: {
+      type: error?.error ?? 'app',
+      message,
+      ...(error?.details ? { details: error.details } : {}),
+    },
+  } as const
+}
+
+function getSnapshot(
+  singular: boolean,
+  data: unknown,
+  resultType: DirectResultType,
+  retry: () => void,
+  error?: DirectQueryError,
+): DirectSnapshot {
+  if (singular && data === undefined) {
+    if (resultType === 'complete') return emptySnapshotSingularComplete
+    if (resultType === 'error')
+      return error ? [undefined, makeError(retry, error)] : emptySnapshotSingularError
+    return emptySnapshotSingularUnknown
+  }
+
+  if (!singular && Array.isArray(data) && data.length === 0) {
+    if (resultType === 'complete') return emptySnapshotPluralComplete
+    if (resultType === 'error')
+      return error ? [emptyArray, makeError(retry, error)] : emptySnapshotPluralError
+    return emptySnapshotPluralUnknown
+  }
+
+  if (resultType === 'complete') return [data, resultTypeComplete]
+  if (resultType === 'error') return [data, makeError(retry, error)]
+  return [data, resultTypeUnknown]
+}
+
+class DirectViewWrapper implements DirectView {
+  private view: ReturnType<MaterializableZero['materialize']> | undefined
+  private snapshot: DirectSnapshot
+  private readonly listeners = new Set<() => void>()
+  private destroyTimer: ReturnType<typeof setTimeout> | undefined
+
+  constructor(
+    private readonly query: any,
+    private readonly zero: MaterializableZero,
+    private ttl: UseQueryOptions['ttl'] | number,
+    private readonly singular: boolean,
+    private readonly onDematerialized: (view: DirectViewWrapper) => void,
+  ) {
+    this.snapshot = getDefaultSnapshot(singular)
+    this.materializeIfNeeded()
+  }
+
+  private onData = (data: unknown, resultType: string, error?: DirectQueryError) => {
+    const cloned = data === undefined ? undefined : deepClone(data as ReadonlyJSONValue)
+    this.snapshot = getSnapshot(
+      this.singular,
+      cloned,
+      resultType as DirectResultType,
+      this.retry,
+      error,
+    )
+    for (const listener of this.listeners) {
+      listener()
+    }
+  }
+
+  private retry = () => {
+    this.destroyView()
+    this.materializeIfNeeded()
+  }
+
+  private materializeIfNeeded() {
+    if (this.view) return
+    this.view = this.zero.materialize(this.query, { ttl: this.ttl })
+    this.view.addListener(this.onData)
+  }
+
+  private destroyView() {
+    const current = this.view
+    this.view = undefined
+    if (!current) return
+    try {
+      current.destroy()
+    } catch {
+      // the owning zero can close before react unsubscribes during rotation
+    }
+  }
+
+  updateTTL(ttl: UseQueryOptions['ttl'] | number) {
+    this.ttl = ttl
+    this.view?.updateTTL(ttl)
+  }
+
+  subscribe = (notify: () => void) => {
+    this.listeners.add(notify)
+    if (this.destroyTimer !== undefined) {
+      clearTimeout(this.destroyTimer)
+      this.destroyTimer = undefined
+    }
+    this.materializeIfNeeded()
+
+    return () => {
+      this.listeners.delete(notify)
+      if (this.listeners.size === 0) {
+        this.destroyTimer = setTimeout(() => {
+          this.destroyTimer = undefined
+          if (this.listeners.size > 0) return
+          this.destroyView()
+          this.onDematerialized(this)
+        }, 10)
+      }
+    }
+  }
+
+  getSnapshot = () => this.snapshot
+}
+
+class DirectViewStore {
+  private readonly views = new Map<string, DirectViewWrapper>()
+
+  getView(
+    zero: MaterializableZero,
+    queryRequest: unknown,
+    enabled: boolean,
+    ttl: UseQueryOptions['ttl'] | number,
+  ): DirectView {
+    const query = addContextToQuery(queryRequest as any, zero.context as any)
+    const queryInternals = asQueryInternals(query)
+
+    if (!enabled) {
+      const snapshot = getDefaultSnapshot(queryInternals.format.singular)
+      return {
+        subscribe: DISABLED_SUBSCRIBE,
+        getSnapshot: () => snapshot,
+      }
+    }
+
+    const hash = `${zero.clientID}:${queryInternals.hash()}`
+    let view = this.views.get(hash)
+    if (!view) {
+      view = new DirectViewWrapper(
+        query,
+        zero,
+        ttl,
+        queryInternals.format.singular,
+        (dematerialized) => {
+          if (this.views.get(hash) === dematerialized) {
+            this.views.delete(hash)
+          }
+        },
+      )
+      this.views.set(hash, view)
+    } else {
+      view.updateTTL(ttl)
+    }
+
+    return view
+  }
+}
+
+export function createUseQueryDirect<Schema extends ZeroSchema>({
+  DisabledContext,
+  customQueries,
+  getZero,
+  zeroVersion,
+}: Parameters<CreateUseQueryDirect<Schema>>[0]): UseQueryHook<Schema> {
+  const directViewStore = new DirectViewStore()
+
+  function useQueryDirect(...args: any[]): any {
+    // SSG: skip every hook below — see createUseQuery for the rationale.
+    if (typeof window === 'undefined') return EMPTY_RESPONSE
+    const disableMode = useContext(DisabledContext)
+    const lastRef = useRef<any>(EMPTY_RESPONSE)
+    const [fn, paramsOrOptions, optionsArg] = args
+
+    const version = useEmitterValue(zeroVersion)
+    const { params, options } = parseUseQueryArgs(paramsOrOptions, optionsArg)
+
+    let enabled = true
+    let ttl: UseQueryOptions['ttl'] | number = DEFAULT_TTL_MS
+    if (typeof options === 'boolean') {
+      enabled = options
+    } else if (options) {
+      enabled = options.enabled !== false
+      ttl = options.ttl ?? DEFAULT_TTL_MS
+    }
+
+    const paramsKey = params === undefined ? '' : JSON.stringify(params)
+
+    const view = useMemo((): DirectView | null => {
+      const zero = getZero()
+      if (!zero) return null
+      const queryRequest = resolveQuery({ customQueries, fn, params })
+      return directViewStore.getView(zero, queryRequest, enabled, ttl)
+      // params is keyed by paramsKey; version re-materializes on a new zero
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [fn, paramsKey, enabled, ttl, version])
+
+    const out = useSyncExternalStore(
+      view ? view.subscribe : DISABLED_SUBSCRIBE,
+      view ? view.getSnapshot : getDisabledSnapshot,
+      view ? view.getSnapshot : getDisabledSnapshot,
+    )
+
+    if (!disableMode) {
+      lastRef.current = out
+      return out
+    }
+
+    if (disableMode === 'last-value') {
+      return lastRef.current
+    }
+
+    return EMPTY_RESPONSE
+  }
+
+  return useQueryDirect as UseQueryHook<Schema>
+}

package/src/createZeroClient.tsx

@@ -1,6 +1,11 @@
 import { defineQueries, defineQuery, Zero as ZeroClient } from '@rocicorp/zero'
-import { useConnectionState, useZero, ZeroProvider } from '@rocicorp/zero/react'
-import { createEmitter } from '@take-out/helpers'
+import {
+  useConnectionState,
+  useZero,
+  ZeroContext,
+  ZeroProvider,
+} from '@rocicorp/zero/react'
+import { createEmitter, type Emitter } from '@take-out/helpers'
 import {
   createContext,
   memo,
@@ -9,6 +14,7 @@ import {
   useMemo,
   useRef,
   useState,
+  type Context,
   type ReactNode,
 } from 'react'
 
@@ -16,7 +22,6 @@ import { createPermissions } from './createPermissions'
 import { ensureHttpPullTransport } from './httpPullTransport'
 import {
   createUseQuery,
-  createUseQueryDirect,
   type QueryControlMode,
   type UseQueryHook,
 } from './createUseQuery'
@@ -38,7 +43,14 @@ import { setRunner, type ZeroRunner } from './zeroRunner'
 import { zql } from './zql'
 
 import type { AuthData, GenericModels, GetZeroMutators, ZeroEvent } from './types'
-import type { Query, Row, Zero, ZeroOptions, Schema as ZeroSchema } from '@rocicorp/zero'
+import type {
+  AnyQueryRegistry,
+  Query,
+  Row,
+  Zero,
+  ZeroOptions,
+  Schema as ZeroSchema,
+} from '@rocicorp/zero'
 
 type PreloadOptions = { ttl?: 'always' | 'never' | number | undefined }
 
@@ -50,6 +62,27 @@ export type GroupedQueries = Record<string, Record<string, (...args: any[]) => a
 //  - 'optimistic-allow': return true until server confirms
 export type PermissionStrategy = 'optimistic' | 'optimistic-deny' | 'optimistic-allow'
 
+export type CreateZeroClientOptions<
+  Schema extends ZeroSchema,
+  Models extends GenericModels,
+> = {
+  schema: Schema
+  models: Models
+  groupedQueries: GroupedQueries
+  permissionStrategy?: PermissionStrategy
+  // names this client instance so multiple instances can coexist on one page.
+  // each query/mutator namespace is claimed by exactly one instance, and the
+  // ambient run() + the combineZeroClients facade dispatch by that claim.
+  instanceName?: string
+}
+
+export type DirectQueryAdapter<Schema extends ZeroSchema> = (props: {
+  DisabledContext: Context<QueryControlMode>
+  customQueries: AnyQueryRegistry
+  getZero: () => any
+  zeroVersion: Emitter<number>
+}) => UseQueryHook<Schema>
+
 function getZeroProxyValue(instance: object, key: PropertyKey) {
   const value = Reflect.get(instance, key, instance)
   if (typeof value !== 'function') return value
@@ -67,7 +100,25 @@ function getZeroProxyValue(instance: object, key: PropertyKey) {
   return bound
 }
 
-export function createZeroClient<
+function createUnavailableDirectUseQuery<
+  Schema extends ZeroSchema,
+>(): UseQueryHook<Schema> {
+  function useQueryDirect(): never {
+    throw new Error(
+      `[on-zero] direct queries are optional. Import createZeroClientWithDirectQueries from 'on-zero/multi' for clients used outside the innermost ZeroProvider.`,
+    )
+  }
+
+  return useQueryDirect as UseQueryHook<Schema>
+}
+
+export function createZeroClient<Schema extends ZeroSchema, Models extends GenericModels>(
+  options: CreateZeroClientOptions<Schema, Models>,
+) {
+  return createZeroClientInternal(options)
+}
+
+export function createZeroClientInternal<
   Schema extends ZeroSchema,
   Models extends GenericModels,
 >({
@@ -76,15 +127,9 @@ export function createZeroClient<
   groupedQueries,
   permissionStrategy = 'optimistic',
   instanceName = 'default',
-}: {
-  schema: Schema
-  models: Models
-  groupedQueries: GroupedQueries
-  permissionStrategy?: PermissionStrategy
-  // names this client instance so multiple instances can coexist on one page.
-  // each query/mutator namespace is claimed by exactly one instance, and the
-  // ambient run() + the combineZeroClients facade dispatch by that claim.
-  instanceName?: string
+  createDirectUseQuery,
+}: CreateZeroClientOptions<Schema, Models> & {
+  createDirectUseQuery?: DirectQueryAdapter<Schema>
 }) {
   type ZeroMutators = GetZeroMutators<Models>
   type ZeroInstance = Zero<Schema, ZeroMutators>
@@ -230,13 +275,9 @@ export function createZeroClient<
 
   const zeroEvents = createEmitter<ZeroEvent | null>(`zero${emitterScope}`, null)
 
-  // bumped after commit whenever the mounted zero instance changes (first
-  // mount, identity change) — the direct query path re-materializes its views
-  // against the new instance
-  const zeroInstanceVersion = createEmitter<number>(
-    `zero-instance-version${emitterScope}`,
-    0,
-  )
+  const zeroInstanceVersion = createDirectUseQuery
+    ? createEmitter<number>(`zero-instance-version${emitterScope}`, 0)
+    : null
 
   const AuthDataContext = createContext<AuthData>({} as AuthData)
 
@@ -245,15 +286,14 @@ export function createZeroClient<
     customQueries,
   })
 
-  // context-free counterpart: materializes directly on THIS instance's
-  // mounted zero instead of the nearest ZeroProvider context. used by
-  // combineZeroClients for instances whose provider is not innermost.
-  const useQueryDirect = createUseQueryDirect<Schema>({
-    DisabledContext,
-    customQueries,
-    getZero: () => latestZeroInstance,
-    zeroVersion: zeroInstanceVersion,
-  })
+  const useQueryDirect = createDirectUseQuery
+    ? createDirectUseQuery({
+        DisabledContext,
+        customQueries,
+        getZero: () => latestZeroInstance,
+        zeroVersion: zeroInstanceVersion!,
+      })
+    : createUnavailableDirectUseQuery<Schema>()
 
   // permission check uses a per-model synced query so server is authoritative
   // permissionStrategy controls client behavior before server responds.
@@ -266,6 +306,8 @@ export function createZeroClient<
       enabled = typeof objOrId !== 'undefined',
       debug = false,
     ): boolean | null {
+      // SSG: skip every hook below — see createUseQuery for rationale.
+      if (typeof window === 'undefined') return null
       const disableMode = useContext(DisabledContext)
       const lastRef = useRef<boolean | null>(null)
       const tableStr = table as string
@@ -321,17 +363,45 @@ export function createZeroClient<
   // with different identities would thrash this slot.
   let cachedZero: { key: string; instance: ZeroInstance } | null = null
 
-  const ProvideZero = ({
-    children,
-    authData: authDataIn,
-    disable,
-    transport,
-    pullIntervalMs = 30_000,
-    beforeReload,
-    ...props
-  }: Omit<ZeroOptions<Schema, ZeroMutators>, 'schema' | 'mutators'> & {
+  // when ProvideZero is rendered without a real Zero instance (SSG, disable=true,
+  // or transiently while the active path is still creating its first instance),
+  // we want descendants' useZero() / useConnectionState() / on-zero useQuery to
+  // NOT throw — but also not run real queries. Hand them a stub Zero plus
+  // DisabledContext='empty':
+  //   1. zero/react's useZero() reads ZeroContext; the stub is truthy so it
+  //      doesn't throw "useZero must be used within a ZeroProvider".
+  //   2. on-zero's useQuery wrapper forces enabled=false to the underlying
+  //      zero useQuery when DisabledContext is set, so zero's viewStore.getView
+  //      returns its disabled-view stub without ever reading zero.clientID or
+  //      subscribing through the stub.
+  //   3. addContextToQuery(query, zero.context) is the only deep access in the
+  //      query path; the stub's .context is a plain object so that call
+  //      succeeds harmlessly.
+  //   4. useConnectionState reads zero.connection.state.{subscribe,current};
+  //      we provide a perma-'closed' state with a no-op subscribe. consumers
+  //      handle 'closed' as a normal disconnected state.
+  // This stub lets the provider tree render with stable shape regardless of
+  // whether Zero is active — so children never re-parent across enable/disable.
+  const DISABLED_ZERO_STUB_CONNECTION_STATE = {
+    current: { name: 'closed' as const },
+    subscribe: () => () => {},
+  }
+  const DISABLED_ZERO_STUB = {
+    context: {},
+    connection: { state: DISABLED_ZERO_STUB_CONNECTION_STATE },
+  } as unknown as ZeroInstance
+
+  type ProvideZeroProps = Omit<ZeroOptions<Schema, ZeroMutators>, 'schema' | 'mutators'> & {
     children: ReactNode
     authData?: AuthData | null
+    // when true, ProvideZero renders a stable shell with stub Zero — no real
+    // client is created, no websocket is opened, no IDB store is touched.
+    // useQuery descendants receive EMPTY_RESPONSE via DisabledContext='empty'.
+    // toggling this on/off NEVER re-parents children: the React tree shape is
+    // identical in both modes (active just mounts a sibling lifecycle, which
+    // doesn't shift children's position). use this when consumers need the
+    // provider tree mounted (e.g. inside a marketing splash that lazily
+    // upgrades to the real IDE) without paying for Zero until activation.
     disable?: boolean
     // 'http-pull' runs the stock zero client over stateless HTTP pull/push
     // (no websocket, no resident server state) by intercepting the sync
@@ -343,7 +413,42 @@ export function createZeroClient<
     // awaited before a self-healing recovery reload — e.g. wait for the dev
     // origin to be reachable so the reload doesn't hit a restarting server.
     beforeReload?: () => Promise<void>
-  }) => {
+  }
+
+  const ProvideZero = ({ children, ...props }: ProvideZeroProps) => {
+    // SSG branch: NO HOOKS. on-zero's hooks call useRef/useState/useEffect
+    // through its bundled React copy, which the SSG build's runtime sees as
+    // null ("Cannot read properties of null (reading 'useRef')") because react
+    // isn't deduplicated across the bundle and on-zero's slot is undefined at
+    // render time. emit the stable shell synchronously instead. children
+    // re-parent ONCE at hydration (server: this branch; client: the active
+    // branch), but that happens before any heavy descendant (e.g. consumer
+    // F2CShell-style skip-first-render mounts) is in the tree — so the parent
+    // swap is invisible at the DOM layer (all our wrappers are
+    // Context.Providers with no DOM) and incurs no remount jank.
+    if (typeof window === 'undefined' || props.disable) {
+      return (
+        <AuthDataContext.Provider value={(props.authData ?? {}) as AuthData}>
+          <DisabledContext.Provider value="empty">
+            <ZeroContext.Provider value={DISABLED_ZERO_STUB as any}>
+              {children}
+            </ZeroContext.Provider>
+          </DisabledContext.Provider>
+        </AuthDataContext.Provider>
+      )
+    }
+
+    return <ProvideZeroActive {...props}>{children}</ProvideZeroActive>
+  }
+
+  const ProvideZeroActive = ({
+    children,
+    authData: authDataIn,
+    transport,
+    pullIntervalMs = 30_000,
+    beforeReload,
+    ...props
+  }: Omit<ProvideZeroProps, 'disable'>) => {
     // resolve the auth token first: a real logout (token gone) must clear
     // authData so client mutators don't keep running as the old user, while a
     // transient authData blip with the token still present (session refresh, tab
@@ -478,20 +583,21 @@ export function createZeroClient<
       }
     }, [instance, auth])
 
-    // for now we re-parent
-    if (disable) {
-      return children
-    }
-
+    // Always render the same shell shape, with or without an instance. While
+    // the instance is being constructed (first effect tick) we hand descendants
+    // the stub Zero plus DisabledContext='empty' so useZero/useQuery
+    // short-circuit instead of throwing. SetZeroInstance + ConnectionMonitor
+    // only mount once instance exists, as siblings of children — they NEVER
+    // wrap children, so toggling them never re-parents.
     return (
       <AuthDataContext.Provider value={authData}>
-        {instance ? (
-          <ZeroProvider zero={instance}>
-            <SetZeroInstance />
-            <ConnectionMonitor zeroEvents={zeroEvents} />
+        <DisabledContext.Provider value={instance ? false : 'empty'}>
+          <ZeroContext.Provider value={instance ?? (DISABLED_ZERO_STUB as any)}>
+            {instance ? <SetZeroInstance /> : null}
+            {instance ? <ConnectionMonitor zeroEvents={zeroEvents} /> : null}
             {children}
-          </ZeroProvider>
-        ) : null}
+          </ZeroContext.Provider>
+        </DisabledContext.Provider>
       </AuthDataContext.Provider>
     )
   }
@@ -515,10 +621,8 @@ export function createZeroClient<
       setRunner(runner)
     }
 
-    // notify direct-path views after commit (emitting during render would
-    // setState other components mid-render)
     useEffect(() => {
-      zeroInstanceVersion.emit(zeroInstanceVersion.value + 1)
+      zeroInstanceVersion?.emit(zeroInstanceVersion.value + 1)
     }, [zeroInstance])
 
     return null

package/src/helpers/recoverZeroClient.test.ts

@@ -177,7 +177,10 @@ describe('zero recovery', () => {
   // remount. previously crashed as an unhandled rejection.
   test('default reload path is a safe no-op when location is absent', async () => {
     const events: ZeroEvent[] = []
-    const zeroEvents = createEmitter<ZeroEvent | null>(`test-recover-${emitterSeq++}`, null)
+    const zeroEvents = createEmitter<ZeroEvent | null>(
+      `test-recover-${emitterSeq++}`,
+      null,
+    )
     zeroEvents.listen((event) => {
       if (event) events.push(event)
     })
@@ -200,6 +203,9 @@ describe('zero recovery', () => {
       })
     }
     expect(deleteLocalState).toHaveBeenCalledTimes(1)
-    expect(events).toContainEqual({ type: 'recovering', reason: 'client state not found' })
+    expect(events).toContainEqual({
+      type: 'recovering',
+      reason: 'client state not found',
+    })
   })
 })

package/src/index.ts

@@ -8,8 +8,12 @@ export * from './helpers/useMutation'
 export { ensureAuth, getAuth } from './helpers/getAuth'
 export { setAuthData, setEnvironment } from './state'
 
-export * from './combineZeroClients'
-export * from './createZeroClient'
+export {
+  createZeroClient,
+  type CreateZeroClientOptions,
+  type GroupedQueries,
+  type PermissionStrategy,
+} from './createZeroClient'
 export * from './httpPullTransport'
 export * from './createUseQuery'
 export * from './resolveQuery'

package/src/multi.ts

@@ -0,0 +1,24 @@
+import {
+  createZeroClientInternal,
+  type DirectQueryAdapter,
+  type CreateZeroClientOptions,
+} from './createZeroClient'
+import { createUseQueryDirect } from './createUseQueryDirect'
+
+import type { GenericModels } from './types'
+import type { Schema as ZeroSchema } from '@rocicorp/zero'
+
+export * from './combineZeroClients'
+
+export function createZeroClientWithDirectQueries<
+  Schema extends ZeroSchema,
+  Models extends GenericModels,
+>(
+  options: CreateZeroClientOptions<Schema, Models>,
+): ReturnType<typeof createZeroClientInternal<Schema, Models>> {
+  const createDirectUseQuery: DirectQueryAdapter<Schema> = createUseQueryDirect
+  return createZeroClientInternal<Schema, Models>({
+    ...options,
+    createDirectUseQuery,
+  })
+}