on-zero 0.4.23 → 0.4.24

package/src/instanceRegistry.ts

@@ -0,0 +1,75 @@
+// registry mapping query/mutator namespaces to the zero client instance that
+// owns them. enables multiple createZeroClient instances on one page (e.g. a
+// control-plane instance + a per-project instance): the ambient run() and the
+// combineZeroClients facade dispatch each query/mutation to the owning
+// instance by its registered namespace instead of whichever mounted last.
+//
+// stored via globalValue so dual-loaded module copies (cjs/esm) share one map,
+// matching the package's other cross-module registries.
+
+import { globalValue } from '@take-out/helpers'
+
+import { getQueryName } from './queryRegistry'
+
+import type { ZeroRunner } from './zeroRunner'
+import type { AnyQueryRegistry } from '@rocicorp/zero'
+
+export type ZeroClientInstance = {
+  name: string
+  customQueries: AnyQueryRegistry
+  // set when the instance's provider mounts (client); stays null on the
+  // server, where the ambient transaction runner serves every instance
+  runner: ZeroRunner | null
+}
+
+const getInstancesByNamespace = () =>
+  globalValue<Map<string, ZeroClientInstance>>(
+    'on-zero:instances-by-namespace',
+    () => new Map(),
+  )
+
+export function registerClientInstance({
+  name,
+  namespaces,
+  customQueries,
+}: {
+  name: string
+  namespaces: string[]
+  customQueries: AnyQueryRegistry
+}): ZeroClientInstance {
+  const instancesByNamespace = getInstancesByNamespace()
+
+  // re-creating an instance under the same name (hmr) replaces its claims
+  for (const [namespace, owner] of instancesByNamespace) {
+    if (owner.name === name) {
+      instancesByNamespace.delete(namespace)
+    }
+  }
+
+  const instance: ZeroClientInstance = { name, customQueries, runner: null }
+
+  for (const namespace of namespaces) {
+    const existing = instancesByNamespace.get(namespace)
+    if (existing) {
+      throw new Error(
+        `[on-zero] namespace '${namespace}' is already claimed by zero client instance '${existing.name}' ` +
+          `(while creating instance '${name}'). Each query/mutator namespace must belong to exactly one createZeroClient instance.`,
+      )
+    }
+    instancesByNamespace.set(namespace, instance)
+  }
+
+  return instance
+}
+
+export function getInstanceForNamespace(
+  namespace: string,
+): ZeroClientInstance | undefined {
+  return getInstancesByNamespace().get(namespace)
+}
+
+export function getInstanceForQueryFn(fn: Function): ZeroClientInstance | undefined {
+  const queryName = getQueryName(fn)
+  if (!queryName) return undefined
+  return getInstanceForNamespace(queryName.split('.', 1)[0])
+}

package/src/multiInstance.test.tsx

@@ -0,0 +1,284 @@
+import { createSchema, string, table } from '@rocicorp/zero'
+import { createEmitter } from '@take-out/helpers'
+import { describe, expect, test, vi } from 'vitest'
+
+import { combineZeroClients } from './combineZeroClients'
+import { createZeroClient } from './createZeroClient'
+import { getInstanceForNamespace, registerClientInstance } from './instanceRegistry'
+import { registerQuery } from './queryRegistry'
+import { run } from './run'
+import { setRunner, type ZeroRunner } from './zeroRunner'
+
+import type { ZeroEvent } from './types'
+import type { AnyQueryRegistry, Query } from '@rocicorp/zero'
+import type { ReactNode } from 'react'
+
+const userTable = table('user').columns({ id: string(), name: string() }).primaryKey('id')
+const taskTable = table('task')
+  .columns({ id: string(), title: string() })
+  .primaryKey('id')
+const schema = createSchema({ tables: [userTable, taskTable] })
+
+// query fns are never invoked in these tests (runners are mocked, and
+// defineQueries resolves to lazy QueryRequests), so the body is a stub
+const makeQueryFn = () => (args: { id: string }) =>
+  args as unknown as Query<'user', typeof schema>
+
+// each test uses unique instance names + namespaces — the instance registry
+// is module-global and shared across tests in this file
+function makeClient(instanceName: string, namespace: string) {
+  const byId = makeQueryFn()
+  return {
+    byId,
+    client: createZeroClient({
+      schema,
+      models: {},
+      groupedQueries: { [namespace]: { byId } },
+      instanceName,
+    }),
+  }
+}
+
+// a structural stand-in for a createZeroClient return value, registered in
+// the instance registry so the facade can resolve namespace ownership.
+// real clients can't be used for mutate/useQuery dispatch tests because
+// their zero proxy requires a mounted ZeroProvider.
+function fakeClient(name: string, namespaces: string[], zeroStub: unknown) {
+  registerClientInstance({
+    name,
+    namespaces,
+    // boundary stub: dispatch tests never resolve queries through it
+    customQueries: {} as AnyQueryRegistry,
+  })
+  return {
+    instanceName: name,
+    useQuery: vi.fn(() => `${name}-useQuery`),
+    useQueryDirect: vi.fn(() => `${name}-useQueryDirect`),
+    usePermission: vi.fn(() => `${name}-usePermission`),
+    usePermissionDirect: vi.fn(() => `${name}-usePermissionDirect`),
+    zero: zeroStub,
+    preload: vi.fn(() => `${name}-preload`),
+    getQuery: vi.fn(() => `${name}-getQuery`),
+    zeroEvents: createEmitter<ZeroEvent | null>(`zero:test-${name}`, null),
+    ControlQueries: ({ children }: { children: ReactNode }) => children,
+  }
+}
+
+describe('multi-instance namespace dispatch', () => {
+  test('run() dispatches named queries to the owning instance runner', async () => {
+    const control = makeClient('run-control', 'runUser')
+    const project = makeClient('run-project', 'runTask')
+
+    // simulate each instance's provider mount (SetZeroInstance)
+    const controlRunner = vi.fn(async (..._args: unknown[]) => ({ from: 'control' }))
+    const projectRunner = vi.fn(async (..._args: unknown[]) => ({ from: 'project' }))
+    getInstanceForNamespace('runUser')!.runner = controlRunner as ZeroRunner
+    getInstanceForNamespace('runTask')!.runner = projectRunner as ZeroRunner
+
+    // the last mount also claims the ambient runner — owned namespaces must
+    // not use it (this is the "second mount steals run()" bug)
+    const ambientRunner = vi.fn(async (..._args: unknown[]) => ({ from: 'ambient' }))
+    setRunner(ambientRunner as ZeroRunner)
+
+    await expect(run(control.byId, { id: '1' })).resolves.toEqual({ from: 'control' })
+    await expect(run(project.byId, { id: '2' })).resolves.toEqual({ from: 'project' })
+    expect(ambientRunner).not.toHaveBeenCalled()
+
+    // the request resolved through the owning instance's own query registry
+    const request = controlRunner.mock.calls[0]![0] as { query: { queryName: string } }
+    expect(request.query.queryName).toBe('runUser.byId')
+  })
+
+  test('a claimed namespace with an unmounted instance uses the ambient runner (server path)', async () => {
+    const { byId } = makeClient('srv-instance', 'srvThing')
+    const ambient = vi.fn(async (..._args: unknown[]) => ({ from: 'ambient' }))
+    setRunner(ambient as ZeroRunner)
+
+    await expect(run(byId, { id: '1' })).resolves.toEqual({ from: 'ambient' })
+    expect(ambient).toHaveBeenCalledTimes(1)
+  })
+
+  test('duplicate namespace claim throws at create time', () => {
+    makeClient('dup-a', 'dupNs')
+    expect(() => makeClient('dup-b', 'dupNs')).toThrow(/already claimed/)
+  })
+
+  test('re-creating an instance under the same name re-claims without throwing (hmr)', () => {
+    makeClient('hmr', 'hmrNs')
+    expect(() => makeClient('hmr', 'hmrNs')).not.toThrow()
+    expect(getInstanceForNamespace('hmrNs')?.name).toBe('hmr')
+  })
+
+  test('model namespaces are claimed too', () => {
+    const models = { mdlThing: { mutate: { insert: async () => {} } } }
+    createZeroClient({
+      schema,
+      models,
+      groupedQueries: {},
+      instanceName: 'mdl-a',
+    })
+    expect(getInstanceForNamespace('mdlThing')?.name).toBe('mdl-a')
+    expect(() =>
+      createZeroClient({
+        schema,
+        models,
+        groupedQueries: {},
+        instanceName: 'mdl-b',
+      }),
+    ).toThrow(/already claimed/)
+  })
+})
+
+describe('multi-instance isolation', () => {
+  test('each instance has an isolated zeroEvents emitter', () => {
+    const { client: a } = makeClient('emit-a', 'emitA')
+    const { client: b } = makeClient('emit-b', 'emitB')
+
+    expect(a.zeroEvents).not.toBe(b.zeroEvents)
+    expect(a.zeroEvents.options?.name).toBe('zero:emit-a')
+    expect(b.zeroEvents.options?.name).toBe('zero:emit-b')
+
+    const seenByB: Array<ZeroEvent | null> = []
+    b.zeroEvents.listen((event) => seenByB.push(event))
+    a.zeroEvents.emit({ type: 'error', message: 'a-only' })
+
+    expect(seenByB).toEqual([])
+    expect(a.zeroEvents.value).toEqual({ type: 'error', message: 'a-only' })
+    expect(b.zeroEvents.value).toBe(null)
+  })
+
+  test('the default instance keeps the legacy emitter name', () => {
+    const { client } = makeClient('default', 'defaultNs')
+    expect(client.zeroEvents.options?.name).toBe('zero')
+  })
+
+  test('each instance has its own unmounted zero proxy', () => {
+    const { client: a } = makeClient('proxy-a', 'proxyA')
+    const { client: b } = makeClient('proxy-b', 'proxyB')
+    // identity check without handing the proxy to expect() — vitest's
+    // thenable detection would access .then and trip the unmounted throw
+    expect(a.zero === (b.zero as unknown)).toBe(false)
+    // neither provider is mounted; each proxy throws its own error rather
+    // than resolving against some shared/global instance
+    expect(() => a.zero.clientID).toThrow(/not initialized/)
+    expect(() => b.zero.clientID).toThrow(/not initialized/)
+  })
+})
+
+describe('combineZeroClients facade', () => {
+  test('zero.mutate dispatches by model namespace, rest forwards to primary', () => {
+    const insertSpy = vi.fn()
+    const updateSpy = vi.fn()
+    const control = fakeClient('fz-control', ['fzUser'], {
+      mutate: { fzUser: { insert: insertSpy } },
+      userID: 'primary-user',
+    })
+    const project = fakeClient('fz-project', ['fzTask'], {
+      mutate: { fzTask: { update: updateSpy } },
+      userID: 'project-user',
+    })
+
+    const combined = combineZeroClients(control, project)
+    const zero = combined.zero as Record<string, any>
+
+    zero.mutate.fzUser.insert({ id: '1' })
+    zero.mutate.fzTask.update({ id: '2' })
+
+    expect(insertSpy).toHaveBeenCalledWith({ id: '1' })
+    expect(updateSpy).toHaveBeenCalledWith({ id: '2' })
+    expect(zero.userID).toBe('primary-user')
+    // unclaimed namespaces fall back to the primary instance
+    expect(zero.mutate.unknownNs).toBe(undefined)
+  })
+
+  test('useQuery/preload/getQuery/usePermission dispatch by namespace', () => {
+    const control = fakeClient('fq-control', ['fqUser'], {})
+    const project = fakeClient('fq-project', ['fqTask'], {})
+    const userQuery = makeQueryFn()
+    const taskQuery = makeQueryFn()
+    registerQuery(userQuery, 'fqUser.byId')
+    registerQuery(taskQuery, 'fqTask.byId')
+
+    // project is last → inner: its hooks ride the upstream context path;
+    // control is outer → its hooks go through the context-free direct path
+    const combined = combineZeroClients(control, project)
+    const useQuery = combined.useQuery as (...args: any[]) => any
+    const preload = combined.preload as (...args: any[]) => any
+    const getQuery = combined.getQuery as (...args: any[]) => any
+    const usePermission = combined.usePermission as (...args: any[]) => any
+
+    useQuery(userQuery, { id: '1' })
+    expect(control.useQueryDirect).toHaveBeenCalledWith(userQuery, { id: '1' })
+    expect(control.useQuery).not.toHaveBeenCalled()
+    expect(project.useQuery).not.toHaveBeenCalled()
+
+    useQuery(taskQuery, { id: '2' })
+    expect(project.useQuery).toHaveBeenCalledWith(taskQuery, { id: '2' })
+    expect(project.useQueryDirect).not.toHaveBeenCalled()
+
+    preload(taskQuery, { id: '3' })
+    expect(project.preload).toHaveBeenCalledWith(taskQuery, { id: '3' })
+    expect(control.preload).not.toHaveBeenCalled()
+
+    getQuery(userQuery, { id: '4' })
+    expect(control.getQuery).toHaveBeenCalledWith(userQuery, { id: '4' })
+    expect(project.getQuery).not.toHaveBeenCalled()
+
+    // unregistered query fns fall back to the primary instance (outer → direct)
+    const anonymous = makeQueryFn()
+    useQuery(anonymous, { id: '5' })
+    expect(control.useQueryDirect).toHaveBeenCalledWith(anonymous, { id: '5' })
+
+    // usePermission dispatches by table-named model namespace and follows the
+    // same context vs direct split: inner table → context, outer table → direct
+    usePermission('fqTask', 'row-1')
+    expect(project.usePermission).toHaveBeenCalledWith('fqTask', 'row-1')
+    expect(project.usePermissionDirect).not.toHaveBeenCalled()
+
+    usePermission('fqUser', 'row-2')
+    expect(control.usePermissionDirect).toHaveBeenCalledWith('fqUser', 'row-2')
+    expect(control.usePermission).not.toHaveBeenCalled()
+  })
+
+  test('the inner option overrides which client uses the context path', () => {
+    const a = fakeClient('inner-a', ['innerA'], {})
+    const b = fakeClient('inner-b', ['innerB'], {})
+    const aQuery = makeQueryFn()
+    const bQuery = makeQueryFn()
+    registerQuery(aQuery, 'innerA.byId')
+    registerQuery(bQuery, 'innerB.byId')
+
+    // a is FIRST (primary) but declared inner → context path; b becomes direct
+    const combined = combineZeroClients(a, b, { inner: 'inner-a' })
+    const useQuery = combined.useQuery as (...args: any[]) => any
+
+    useQuery(aQuery, { id: '1' })
+    expect(a.useQuery).toHaveBeenCalledWith(aQuery, { id: '1' })
+    expect(a.useQueryDirect).not.toHaveBeenCalled()
+
+    useQuery(bQuery, { id: '2' })
+    expect(b.useQueryDirect).toHaveBeenCalledWith(bQuery, { id: '2' })
+    expect(b.useQuery).not.toHaveBeenCalled()
+
+    expect(() => combineZeroClients(a, b, { inner: 'nope' })).toThrow(
+      /not one of the passed clients/,
+    )
+  })
+
+  test('combined zeroEvents relays every instance', () => {
+    const { client: a } = makeClient('relay-a', 'relayA')
+    const { client: b } = makeClient('relay-b', 'relayB')
+
+    const combined = combineZeroClients(a, b)
+    const seen: Array<ZeroEvent | null> = []
+    combined.zeroEvents.listen((event) => seen.push(event))
+
+    a.zeroEvents.emit({ type: 'error', message: 'from-a' })
+    b.zeroEvents.emit({ type: 'error', message: 'from-b' })
+
+    expect(seen.map((event) => event?.message)).toEqual(['from-a', 'from-b'])
+    // the source emitters stay independent of each other
+    expect(a.zeroEvents.value?.message).toBe('from-a')
+    expect(b.zeroEvents.value?.message).toBe('from-b')
+  })
+})

package/src/multiInstanceNested.test.tsx

@@ -0,0 +1,205 @@
+// @vitest-environment jsdom
+//
+// real nested-provider tests for combineZeroClients: zero-react's useQuery
+// resolves its zero instance from the NEAREST ZeroProvider context, so under
+// nested providers an outer instance's queries must NOT ride the context
+// path — they must materialize directly on the owning instance.
+
+import { createSchema, string, table } from '@rocicorp/zero'
+import { act } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterEach, beforeEach, expect, test } from 'vitest'
+
+import { combineZeroClients } from './combineZeroClients'
+import { createZeroClient } from './createZeroClient'
+import { zql } from './zql'
+
+import type { MutatorContext } from './types'
+import type { ReactNode } from 'react'
+
+declare global {
+  // eslint-disable-next-line no-var
+  var IS_REACT_ACT_ENVIRONMENT: boolean | undefined
+}
+globalThis.IS_REACT_ACT_ENVIRONMENT = true
+
+const userTable = table('user').columns({ id: string(), name: string() }).primaryKey('id')
+const taskTable = table('task')
+  .columns({ id: string(), title: string() })
+  .primaryKey('id')
+const schema = createSchema({ tables: [userTable, taskTable] })
+
+type UserRow = { id: string; name: string }
+
+// control = OUTER/primary instance — owns the 'user' model namespace and the
+// 'ctlUser' query namespace
+const controlModels = {
+  user: {
+    mutate: {
+      seed: async (ctx: MutatorContext, row?: UserRow) => {
+        await (ctx.tx.mutate as any).user.upsert(row)
+      },
+    },
+  },
+}
+const ctlUserById = (args: { id: string }) => (zql as any).user.where('id', args.id).one()
+
+const control = createZeroClient({
+  schema,
+  models: controlModels,
+  groupedQueries: { ctlUser: { byId: ctlUserById } },
+  instanceName: 'nested-control',
+})
+
+// project = INNER instance — its own store. its seed mutator writes the same
+// user TABLE (tables are physical, only namespaces are claims) so the two
+// stores can hold conflicting rows for the same id.
+const projectModels = {
+  prjSeed: {
+    mutate: {
+      seedUser: async (ctx: MutatorContext, row?: UserRow) => {
+        await (ctx.tx.mutate as any).user.upsert(row)
+      },
+    },
+  },
+}
+const prjTaskById = (args: { id: string }) => (zql as any).task.where('id', args.id).one()
+
+const project = createZeroClient({
+  schema,
+  models: projectModels,
+  groupedQueries: { prjTask: { byId: prjTaskById } },
+  instanceName: 'nested-project',
+})
+
+// default contract: last argument = inner provider
+const combined = combineZeroClients(control, project)
+
+let root: Root
+let container: HTMLElement
+
+beforeEach(() => {
+  resetProbe()
+  container = document.createElement('div')
+  document.body.appendChild(container)
+  root = createRoot(container)
+})
+
+afterEach(async () => {
+  await act(async () => root.unmount())
+  container.remove()
+})
+
+const render = (ui: ReactNode) => act(async () => root.render(ui))
+
+async function waitFor(condition: () => boolean, what: string) {
+  for (let i = 0; i < 200; i++) {
+    if (condition()) return
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 5))
+    })
+  }
+  throw new Error(`timed out waiting for ${what}`)
+}
+
+const probe: { data: UserRow | undefined; renders: number } = {
+  data: undefined,
+  renders: 0,
+}
+
+// reset via helper so the assignments don't narrow probe.data to undefined
+// in test scope
+function resetProbe() {
+  probe.data = undefined
+  probe.renders = 0
+}
+
+function ControlUserProbe({ id }: { id: string }) {
+  const [data] = (combined.useQuery as any)(ctlUserById, { id })
+  probe.data = data ?? undefined
+  probe.renders++
+  return null
+}
+
+const seedControl = async (row: UserRow) => {
+  await act(async () => {
+    await (control.zero.mutate as any).user.seed(row).client
+  })
+}
+
+const seedProject = async (row: UserRow) => {
+  await act(async () => {
+    await (project.zero.mutate as any).prjSeed.seedUser(row).client
+  })
+}
+
+test('outer-instance query reads the OUTER store under nested providers', async () => {
+  await render(
+    <control.ProvideZero server={null} userID="t1-ctl">
+      <project.ProvideZero server={null} userID="t1-prj">
+        <ControlUserProbe id="u1" />
+      </project.ProvideZero>
+    </control.ProvideZero>,
+  )
+  await waitFor(() => probe.renders > 0, 'probe mount')
+
+  // same row id, conflicting values per store — whichever store the view
+  // materialized against decides the rendered name
+  await seedControl({ id: 'u1', name: 'from-control' })
+  await seedProject({ id: 'u1', name: 'from-project' })
+
+  await waitFor(() => probe.data !== undefined, 'control row visible')
+  expect(probe.data?.name).toBe('from-control')
+})
+
+test('inner provider unmount/remount does not break outer-instance subscriptions', async () => {
+  const App = ({ showInner }: { showInner: boolean }) => (
+    <control.ProvideZero server={null} userID="t2-ctl">
+      {showInner ? (
+        <project.ProvideZero server={null} userID="t2-prj">
+          <ControlUserProbe id="u2" />
+        </project.ProvideZero>
+      ) : (
+        <ControlUserProbe id="u2" />
+      )}
+    </control.ProvideZero>
+  )
+
+  await render(<App showInner />)
+  await waitFor(() => probe.renders > 0, 'probe mount')
+
+  await seedControl({ id: 'u2', name: 'v1' })
+  await waitFor(() => probe.data?.name === 'v1', 'v1 visible')
+
+  // unmount the inner provider (probe remounts outside it)
+  await render(<App showInner={false} />)
+  await seedControl({ id: 'u2', name: 'v2' })
+  await waitFor(() => probe.data?.name === 'v2', 'v2 visible after inner unmount')
+
+  // remount the inner provider
+  await render(<App showInner />)
+  await seedControl({ id: 'u2', name: 'v3' })
+  await waitFor(() => probe.data?.name === 'v3', 'v3 visible after inner remount')
+})
+
+test('direct-path views re-materialize when the owning instance rotates', async () => {
+  const App = ({ userID }: { userID: string }) => (
+    <control.ProvideZero server={null} userID={userID}>
+      <ControlUserProbe id="u3" />
+    </control.ProvideZero>
+  )
+
+  await render(<App userID="rot-1" />)
+  await waitFor(() => probe.renders > 0, 'probe mount')
+
+  await seedControl({ id: 'u3', name: 'before-rotation' })
+  await waitFor(() => probe.data?.name === 'before-rotation', 'pre-rotation row')
+
+  // identity change rotates the mounted zero instance (new client group,
+  // fresh store) — the same mechanism a zeroInstanceGeneration bump uses
+  await render(<App userID="rot-2" />)
+  await waitFor(() => probe.data === undefined, 'view reset to the new empty store')
+
+  await seedControl({ id: 'u3', name: 'after-rotation' })
+  await waitFor(() => probe.data?.name === 'after-rotation', 'post-rotation row')
+})

package/src/run.ts

@@ -1,3 +1,4 @@
+import { getInstanceForQueryFn } from './instanceRegistry'
 import { resolveQuery, type PlainQueryFn } from './resolveQuery'
 import { getRunner } from './zeroRunner'
 
@@ -62,7 +63,6 @@ export function run(
   const hasParams = modeArg !== undefined || (paramsOrMode && paramsOrMode !== 'complete')
   const params = hasParams ? paramsOrMode : undefined
   const mode = hasParams ? modeArg : paramsOrMode
-  const runner = getRunner()
   const options =
     mode === 'complete'
       ? ({
@@ -72,13 +72,14 @@ export function run(
 
   if (queryOrFn && queryOrFn['ast']) {
     // inline zql - on client it only resolves against cache, on server fully
-    return runner(queryOrFn, options)
+    return getRunner()(queryOrFn, options)
   }
 
-  const customQueries = getCustomQueries()
+  // with multiple client instances mounted, a named query executes against
+  // the instance that claimed its namespace, not whichever mounted last
+  const instance = getInstanceForQueryFn(queryOrFn)
+  const customQueries = instance?.customQueries ?? getCustomQueries()
   const queryRequest = resolveQuery({ customQueries, fn: queryOrFn, params })
 
-  const out = runner(queryRequest as any, options)
-
-  return out
+  return getRunner(instance)(queryRequest as any, options)
 }

package/src/zeroRunner.ts

@@ -20,11 +20,17 @@ export function setRunner(r: ZeroRunner) {
   runner = r
 }
 
-export function getRunner(): ZeroRunner {
+export function getRunner(instance?: { runner: ZeroRunner | null }): ZeroRunner {
   if (isInZeroMutation()) {
     return (q, o) => mutatorContext().tx.run(q, o)
   }
 
+  // a mounted instance's own runner wins; otherwise the ambient runner
+  // (single-instance client, or the server transaction runner)
+  if (instance?.runner) {
+    return instance.runner
+  }
+
   if (!runner) {
     throw new Error(
       'Zero runner not initialized. Ensure ProvideZero is mounted (client) or createZeroServer is called (server).',

package/types/combineZeroClients.d.ts

@@ -0,0 +1,38 @@
+import { type Emitter } from '@take-out/helpers';
+import { run } from './run';
+import type { ZeroEvent } from './types';
+import type { ReactNode } from 'react';
+type ControlQueriesProps = {
+    children: ReactNode;
+    action?: 'enable' | 'disable';
+    whenDisabled?: 'empty' | 'last-value';
+};
+type CombinableZeroClient = {
+    instanceName: string;
+    useQuery: (...args: any[]) => any;
+    useQueryDirect: (...args: any[]) => any;
+    usePermission: (...args: any[]) => any;
+    usePermissionDirect: (...args: any[]) => any;
+    zero: any;
+    preload: (...args: any[]) => any;
+    getQuery: (...args: any[]) => any;
+    zeroEvents: Emitter<ZeroEvent | null>;
+    ControlQueries: (props: ControlQueriesProps) => ReactNode;
+};
+export type CombineZeroClientsOptions = {
+    inner?: string;
+};
+type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+export type CombinedZeroClients<Clients extends readonly CombinableZeroClient[]> = {
+    useQuery: UnionToIntersection<Clients[number]['useQuery']>;
+    usePermission: UnionToIntersection<Clients[number]['usePermission']>;
+    zero: UnionToIntersection<Clients[number]['zero']>;
+    preload: UnionToIntersection<Clients[number]['preload']>;
+    getQuery: UnionToIntersection<Clients[number]['getQuery']>;
+    run: typeof run;
+    zeroEvents: Emitter<ZeroEvent | null>;
+    ControlQueries: (props: ControlQueriesProps) => ReactNode;
+};
+export declare function combineZeroClients<const Clients extends readonly [CombinableZeroClient, ...CombinableZeroClient[]]>(...clientsAndOptions: [...Clients] | [...Clients, CombineZeroClientsOptions]): CombinedZeroClients<Clients>;
+export {};
+//# sourceMappingURL=combineZeroClients.d.ts.map

package/types/combineZeroClients.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"combineZeroClients.d.ts","sourceRoot":"","sources":["../src/combineZeroClients.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAG/D,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA;AAE3B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AACxC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAsBtC,KAAK,mBAAmB,GAAG;IACzB,QAAQ,EAAE,SAAS,CAAA;IACnB,MAAM,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAA;IAC7B,YAAY,CAAC,EAAE,OAAO,GAAG,YAAY,CAAA;CACtC,CAAA;AAID,KAAK,oBAAoB,GAAG;IAC1B,YAAY,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAA;IACjC,cAAc,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAA;IACvC,aAAa,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAA;IACtC,mBAAmB,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAA;IAC5C,IAAI,EAAE,GAAG,CAAA;IACT,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAA;IAChC,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAA;IACjC,UAAU,EAAE,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAAA;IACrC,cAAc,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,SAAS,CAAA;CAC1D,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG;IAGtC,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED,KAAK,mBAAmB,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,GAAG,KAAK,CAAC,SAAS,CAC7E,CAAC,EAAE,MAAM,CAAC,KACP,IAAI,GACL,CAAC,GACD,KAAK,CAAA;AAET,MAAM,MAAM,mBAAmB,CAAC,OAAO,SAAS,SAAS,oBAAoB,EAAE,IAAI;IACjF,QAAQ,EAAE,mBAAmB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,UAAU,CAAC,CAAC,CAAA;IAC1D,aAAa,EAAE,mBAAmB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,eAAe,CAAC,CAAC,CAAA;IACpE,IAAI,EAAE,mBAAmB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,CAAA;IAClD,OAAO,EAAE,mBAAmB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,CAAC,CAAA;IACxD,QAAQ,EAAE,mBAAmB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,UAAU,CAAC,CAAC,CAAA;IAC1D,GAAG,EAAE,OAAO,GAAG,CAAA;IACf,UAAU,EAAE,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAAA;IACrC,cAAc,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,SAAS,CAAA;CAC1D,CAAA;AAED,wBAAgB,kBAAkB,CAChC,KAAK,CAAC,OAAO,SAAS,SAAS,CAAC,oBAAoB,EAAE,GAAG,oBAAoB,EAAE,CAAC,EAEhF,GAAG,iBAAiB,EAAE,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,OAAO,EAAE,yBAAyB,CAAC,GAC3E,mBAAmB,CAAC,OAAO,CAAC,CA6G9B"}