on-zero 0.16.20 → 0.16.21

package/src/generate.ts

@@ -40,7 +40,7 @@ import type { ExtractedMutation, ModelMutations, SchemaColumn } from './generate
 import type { DataLayout } from './generate-layout'
 
 const hash = (s: string) => createHash('sha256').update(s).digest('hex')
-const GENERATOR_CACHE_VERSION = '8'
+const GENERATOR_CACHE_VERSION = '10'
 
 const isGeneratorSourceFile = (name: string) =>
   name.endsWith('.ts') &&
@@ -48,13 +48,14 @@ const isGeneratorSourceFile = (name: string) =>
   !name.endsWith('.test.ts') &&
   !name.endsWith('.spec.ts')
 
-// hash every .ts input the generator reads (all of baseDir except the generated
-// output dir + node_modules) so a dev-boot regen can be skipped when nothing
-// changed. the expensive part of generate() — loading the typescript compiler
-// and building a TS program per query/model for type resolution — runs every
-// boot otherwise, even when the output is already current (the configureServer
-// watcher re-runs it on real edits, so the boot-time pass is pure redundancy).
-function hashInputTree(sourceRoots: string[], generatedDir: string): string {
+// hash generator inputs plus freshly resolved compiler dependencies. a verified
+// cache hit can skip source AST decoding and parsing, while edits still resolve
+// imported types and validate the generated bytes before reusing them.
+function hashInputTree(
+  sourceRoots: string[],
+  generatedDir: string,
+  dependencyPaths: string[]
+): string {
   const parts: string[] = []
   const seen = new Set<string>()
   const walk = (dir: string) => {
@@ -80,6 +81,14 @@ function hashInputTree(sourceRoots: string[], generatedDir: string): string {
     }
   }
   for (const root of sourceRoots) walk(root)
+  // imported types can live outside the data roots, including transitive
+  // re-exports and package declarations. use the compiler's resolved inputs.
+  for (const path of dependencyPaths) {
+    if (seen.has(path) || path.startsWith(`${generatedDir}/`) || !existsSync(path))
+      continue
+    seen.add(path)
+    parts.push(`${path}\0${readFileSync(path, 'utf-8')}`)
+  }
   return hash(parts.join('\0'))
 }
 
@@ -447,15 +456,17 @@ async function tsTypeToValibot(
   seen = new Set<number>()
 ): Promise<string> {
   const checker = project.checker
-  // prevent infinite recursion on circular types
-  // only track structured types (objects, intersections) — not primitives/unions
+  // prevent infinite recursion on circular types. `seen` holds only the
+  // structured types (objects, intersections) on the current path, so a type
+  // reused by siblings, such as `string[]`, still converts every time.
   const flags = type.flags
+  let path = seen
   if (flags & (TypeFlags.Object | TypeFlags.Intersection)) {
     if (seen.has(type.id)) return 'v.unknown()'
-    seen.add(type.id)
+    path = new Set(seen).add(type.id)
   }
 
-  const recurse = (value: Type) => tsTypeToValibot(project, value, seen)
+  const recurse = (value: Type) => tsTypeToValibot(project, value, path)
 
   // primitives
   if (flags & TypeFlags.String) return 'v.string()'
@@ -741,6 +752,8 @@ export interface GenerateOptions {
   dir: string
   /** explicit on-zero.config.ts path; auto-discovered in `dir` when omitted */
   config?: string
+  /** generation-only TypeScript project; defaults to each source file's project */
+  tsconfig?: string
   /** run after generation */
   after?: string
   /** suppress output */
@@ -799,20 +812,28 @@ function dataMembershipFromLayout(layout: DataLayout): DataMembership {
   }
 }
 
-async function loadGeneratorProject(baseDir: string): Promise<NativeTypeScriptProject> {
+async function loadGeneratorProject(
+  baseDir: string,
+  deferSources = false,
+  tsconfig?: string
+): Promise<NativeTypeScriptProject> {
   const sourcePaths = collectTypeScriptSourcePaths([
     baseDir,
     resolve(dirname(baseDir), 'database'),
   ])
-  return createNativeTypeScriptProject(baseDir, sourcePaths)
+  return createNativeTypeScriptProject(baseDir, sourcePaths, {
+    deferSources,
+    tsconfig: tsconfig ? resolve(tsconfig) : undefined,
+  })
 }
 
 export async function deriveDataMembership(options: {
   dir: string
   config?: string
+  tsconfig?: string
 }): Promise<DataMembership> {
   const baseDir = resolve(options.dir)
-  const project = await loadGeneratorProject(baseDir)
+  const project = await loadGeneratorProject(baseDir, false, options.tsconfig)
   try {
     const layout = discoverDataLayout(
       project,
@@ -829,9 +850,10 @@ export async function generateDrizzleSchemaInputFile(options: {
   dir: string
   schemaImportPath: string
   config?: string
+  tsconfig?: string
 }): Promise<string> {
   const baseDir = resolve(options.dir)
-  const project = await loadGeneratorProject(baseDir)
+  const project = await loadGeneratorProject(baseDir, false, options.tsconfig)
   try {
     return generateDrizzleSchemaInputFileWithProject(options, project)
   } finally {
@@ -925,7 +947,7 @@ async function generateDrizzleSchemaInputFileWithProject(
 }
 
 export async function generate(options: GenerateOptions): Promise<GenerateResult> {
-  const project = await loadGeneratorProject(resolve(options.dir))
+  const project = await loadGeneratorProject(resolve(options.dir), true, options.tsconfig)
   try {
     return await generateWithProject(options, project)
   } finally {
@@ -947,23 +969,43 @@ async function generateWithProject(
 
   loadCache()
 
-  // the layout pass is intentionally first: config, filenames, and related()
-  // calls determine schema membership before any type program exists.
-  const layout = discoverDataLayout(
-    project,
-    baseDir,
-    config ? resolve(config) : undefined
-  )
-  const metadataHash = hash(
-    layout.metadataPaths
-      .map((path) => `${path}\0${readFileSync(path, 'utf8')}`)
-      .join('\0')
-  )
+  const configPath = config ? resolve(config) : resolve(baseDir, 'on-zero.config.ts')
+  let cachedInputs: Pick<DataLayout, 'sourceRoots' | 'metadataPaths'> | null = null
+  if (generateCache.__configPath === configPath) {
+    try {
+      const value: unknown = JSON.parse(generateCache.__layoutInputs || 'null')
+      if (
+        value &&
+        typeof value === 'object' &&
+        'sourceRoots' in value &&
+        Array.isArray(value.sourceRoots) &&
+        value.sourceRoots.every((path) => typeof path === 'string') &&
+        'metadataPaths' in value &&
+        Array.isArray(value.metadataPaths) &&
+        value.metadataPaths.every((path) => typeof path === 'string')
+      ) {
+        cachedInputs = {
+          sourceRoots: value.sourceRoots,
+          metadataPaths: value.metadataPaths,
+        }
+      }
+    } catch {}
+  }
+  const dependencyPaths = await project.sourceFilePaths()
+  const hashInputs = (layout: Pick<DataLayout, 'sourceRoots' | 'metadataPaths'>) => {
+    const metadataHash = hash(
+      layout.metadataPaths
+        .map((path) => `${path}\0${readFileSync(path, 'utf8')}`)
+        .join('\0')
+    )
+    return hash(
+      `${hashInputTree(layout.sourceRoots, generatedDir, dependencyPaths)}\0${metadataHash}\0${externalZeroConfig}\0${project.configurationKey}`
+    )
+  }
 
   // input-freshness gate: if nothing under baseDir changed since the last
-  // COMPLETED generate (the input hash is only stored at the end, after
-  // saveCache), the outputs are already current — skip the typescript-program
-  // build entirely and return the cached counts. the configureServer watcher
+  // completed generate, the outputs are already current. resolve compiler inputs
+  // again, but skip source AST loading and return the cached counts. the watcher
   // still re-runs generate on real model/query edits.
   const databaseSchemaPath = resolve(dirname(baseDir), 'database/schema.ts')
   const needsDrizzleSchema = existsSync(databaseSchemaPath)
@@ -975,34 +1017,24 @@ async function generateWithProject(
     ? readFileSync(externalZeroConfigPath, 'utf8')
     : null
   const needsSqliteZeroSchema = needsDrizzleSchema && externalZeroConfig === null
-  const inputHash = hash(
-    `${hashInputTree(layout.sourceRoots, generatedDir)}\0${metadataHash}\0${externalZeroConfig}`
-  )
+  let cachedInputHash: string | null = null
+  if (cachedInputs) {
+    try {
+      cachedInputHash = hashInputs(cachedInputs)
+    } catch {}
+  }
   if (
     !force &&
     generateCache.__generatorVersion === GENERATOR_CACHE_VERSION &&
-    generateCache.__inputHash === inputHash &&
+    generateCache.__inputHash === cachedInputHash &&
     // the input hash deliberately skips the generated directory, so it cannot
     // notice that the outputs themselves moved. existence is not correctness
     // either: a checkout, merge or revert leaves every file present and stale.
     // confirm the bytes on disk still match what the cache says it wrote there
     // before skipping the build, or the fast path serves someone else's output.
     //
-    // a consumer that formats generated output after this runs never hits the
-    // fast path again, because the cache holds the bytes written here and disk
-    // holds the formatted ones. soot does exactly that, `on-zero generate &&
-    // generate-instance-tables && oxfmt src/data/generated/`, and the number is
-    // already taken: 2.50s median before, 3.69s after, four warm runs each in
-    // one checkout with only the pin swapped, so about 1.2 seconds or 47
-    // percent on this step. the full three-command script went 2.65s to 3.14s
-    // with a spread that swallows most of it.
-    //
-    // the shape matters more than the number. this is not a cache that hits
-    // less often, it is a cache that never hits, so the cost does not degrade
-    // gracefully and grows with the generated output rather than staying at
-    // 1.2s. correct and slower beats fast and stale, which is why it is written
-    // this way, but if generate time ever becomes the complaint, record the
-    // hash after the consumer's formatter runs rather than weakening this.
+    // successful after commands record their final output hashes. formatting
+    // therefore keeps the fast path without trusting stale generated bytes.
     Object.entries(generateCache).every(([cachedPath, cachedHash]) => {
       if (!cachedPath.startsWith(generatedDir)) return true
       try {
@@ -1028,6 +1060,16 @@ async function generateWithProject(
     }
   }
 
+  // the compiler still resolves current project inputs before the cache check.
+  // only decoding and parsing source ASTs waits until generation is necessary.
+  await project.loadSources()
+  const layout = discoverDataLayout(
+    project,
+    baseDir,
+    config ? resolve(config) : undefined
+  )
+  const inputHash = hashInputs(layout)
+
   const modelNamespaces = layout.namespaces.filter(
     (namespace): namespace is typeof namespace & { modelPath: string } =>
       namespace.modelPath !== null
@@ -1336,6 +1378,15 @@ async function generateWithProject(
         stdio: 'inherit',
         env: { ...process.env, ON_ZERO_GENERATED_DIR: generatedDir },
       })
+      // successful postprocessing owns the final generated bytes. collect all
+      // hashes before updating the cache so a missing output cannot certify a
+      // partially completed postprocessor.
+      const outputHashes = Object.fromEntries(
+        Object.keys(generateCache)
+          .filter((filePath) => filePath.startsWith(generatedDir))
+          .map((filePath) => [filePath, hash(readFileSync(filePath, 'utf-8'))])
+      )
+      Object.assign(generateCache, outputHashes)
     } catch (err) {
       if (!silent) console.error(`Error running after command: ${err}`)
     }
@@ -1343,6 +1394,11 @@ async function generateWithProject(
 
   // record the input hash + counts so the next boot can skip a no-op regen.
   generateCache.__generatorVersion = GENERATOR_CACHE_VERSION
+  generateCache.__configPath = configPath
+  generateCache.__layoutInputs = JSON.stringify({
+    sourceRoots: layout.sourceRoots,
+    metadataPaths: layout.metadataPaths,
+  })
   generateCache.__inputHash = inputHash
   generateCache.__counts = JSON.stringify({
     modelCount: modelNamespaces.length,
@@ -1383,7 +1439,7 @@ export async function watch(options: WatchOptions) {
   }
 
   const databaseDir = resolve(dirname(baseDir), 'database')
-  const project = await loadGeneratorProject(baseDir)
+  const project = await loadGeneratorProject(baseDir, false, options.tsconfig)
   let layout: DataLayout
   try {
     layout = discoverDataLayout(
@@ -1398,6 +1454,7 @@ export async function watch(options: WatchOptions) {
     [
       ...new Set([
         ...layout.sourceRoots,
+        ...(options.tsconfig ? [resolve(options.tsconfig)] : []),
         ...(existsSync(databaseDir) ? [databaseDir] : []),
       ]),
     ],

package/src/multi.ts

@@ -55,7 +55,7 @@ type ClientUnion<Instances extends Record<string, ZeroInstanceManifestEntry>> =
 
 export function createZeroClients<
   const Instances extends Record<string, ZeroInstanceManifestEntry>,
->(instances: Instances) {
+>(instances: Instances, options: { inner: keyof Instances & string }) {
   const names = Object.keys(instances)
   if (names.length === 0) {
     throw new Error('[on-zero] createZeroClients requires at least one instance')
@@ -65,7 +65,12 @@ export function createZeroClients<
     names.unshift('default')
   }
 
-  const innerName = names[names.length - 1]!
+  const innerName = options.inner
+  if (!names.includes(innerName)) {
+    throw new Error(
+      `[on-zero] createZeroClients inner instance '${innerName}' is not in the manifest`
+    )
+  }
   const clients: Record<string, ReturnType<typeof createZeroClientInternal>> = {}
 
   // release the complete old partition atomically before any new instance
@@ -99,6 +104,9 @@ export function createZeroClients<
   return {
     clients: typedClients,
     providers,
-    combined: combineZeroClients(...orderedClients),
+    combined: combineZeroClients<[ClientUnion<Instances>, ...ClientUnion<Instances>[]]>(
+      ...orderedClients,
+      { inner: innerName }
+    ),
   }
 }

package/src/multiPartition.test.ts

@@ -1,6 +1,7 @@
 import { createSchema, string, table } from '@rocicorp/zero'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test, vi } from 'vitest'
 
+import { getInstanceForQueryFn } from './instanceRegistry'
 import { createZeroClients } from './multi'
 
 const schema = createSchema({
@@ -32,7 +33,7 @@ describe('createZeroClients', () => {
       },
     } as const
 
-    const result = createZeroClients(instances)
+    const result = createZeroClients(instances, { inner: 'default' })
 
     expect(Object.keys(result.clients)).toEqual(['project', 'default'])
     expect(result.clients.default.instanceName).toBe('default')
@@ -40,10 +41,47 @@ describe('createZeroClients', () => {
     expect(result.providers.default).toBe(result.clients.default.ProvideZero)
     expect(result.providers.project).toBe(result.clients.project.ProvideZero)
     expect(result.combined.run).toBeTypeOf('function')
+
+    const innerQuery = vi
+      .spyOn(result.clients.default, 'useQuery')
+      .mockReturnValue('inner' as never)
+    const outerQuery = vi
+      .spyOn(result.clients.project, 'useQueryDirect')
+      .mockReturnValue('outer' as never)
+    expect(result.combined.useQuery(instances.default.queries.account.current, {})).toBe(
+      'inner'
+    )
+    expect(result.combined.useQuery(instances.project.queries.message.all, {})).toBe(
+      'outer'
+    )
+    expect(innerQuery).toHaveBeenCalledOnce()
+    expect(outerQuery).toHaveBeenCalledOnce()
   })
 
   test('requires at least one generated instance', () => {
-    expect(() => createZeroClients({})).toThrow(/at least one instance/)
+    expect(() => createZeroClients({}, { inner: 'missing' as never })).toThrow(
+      /at least one instance/
+    )
+  })
+
+  test('rejects an unknown inner instance before replacing registered clients', () => {
+    const entry = {
+      schema,
+      queries: { preserved: { current: () => ({}) as never } },
+      models: {},
+      tables: [],
+      syncTables: [],
+      supportTables: [],
+      scope: null,
+      defaultVisibility: null,
+    }
+    createZeroClients({ default: entry }, { inner: 'default' })
+    const owner = getInstanceForQueryFn(entry.queries.preserved.current)
+    expect(owner?.name).toBe('default')
+    expect(() =>
+      createZeroClients({ default: entry }, { inner: 'missing' as never })
+    ).toThrow(/inner instance 'missing'/)
+    expect(getInstanceForQueryFn(entry.queries.preserved.current)).toBe(owner)
   })
 
   test('replaces an existing partition atomically when a namespace moves', () => {
@@ -58,16 +96,22 @@ describe('createZeroClients', () => {
       defaultVisibility: null,
     })
 
-    createZeroClients({
-      default: entry({ movedNamespace: { before: () => ({}) as never } }),
-      project: entry({ stableProject: { before: () => ({}) as never } }),
-    })
+    createZeroClients(
+      {
+        default: entry({ movedNamespace: { before: () => ({}) as never } }),
+        project: entry({ stableProject: { before: () => ({}) as never } }),
+      },
+      { inner: 'project' }
+    )
 
     expect(() =>
-      createZeroClients({
-        default: entry({ stableDefault: { after: () => ({}) as never } }),
-        project: entry({ movedNamespace: { after: () => ({}) as never } }),
-      })
+      createZeroClients(
+        {
+          default: entry({ stableDefault: { after: () => ({}) as never } }),
+          project: entry({ movedNamespace: { after: () => ({}) as never } }),
+        },
+        { inner: 'project' }
+      )
     ).not.toThrow()
   })
 })

package/src/native-typescript.ts

@@ -9,7 +9,10 @@ import type { SourceFile } from 'typescript/unstable/ast'
 process.env.GOMAXPROCS ??= '2'
 
 export type NativeTypeScriptProject = {
+  configurationKey: string
   projectForFile(path: string): Project
+  sourceFilePaths(): Promise<string[]>
+  loadSources(): Promise<void>
   sourceFile(path: string): SourceFile
   hasParseErrors(path: string): boolean
   close(): Promise<void>
@@ -19,6 +22,7 @@ type CompilerSession = {
   api: API
   paths: Set<string>
   root: string
+  tsconfig?: string
 }
 
 let compiler: CompilerSession | null = null
@@ -30,7 +34,9 @@ async function closeCompiler(session: CompilerSession) {
   try {
     if (session.paths.size > 0) {
       const snapshot = await session.api.updateSnapshot({
-        closeFiles: [...session.paths],
+        ...(session.tsconfig
+          ? { closeProjects: [session.tsconfig] }
+          : { closeFiles: [...session.paths] }),
       })
       await snapshot.dispose()
     }
@@ -39,7 +45,7 @@ async function closeCompiler(session: CompilerSession) {
   }
 }
 
-async function acquireCompiler(root: string, sourcePaths: string[]) {
+async function acquireCompiler(root: string, sourcePaths: string[], tsconfig?: string) {
   const previousTurn = compilerTurn
   let releaseTurn = () => {}
   compilerTurn = new Promise<void>((resolveTurn) => {
@@ -51,26 +57,31 @@ async function acquireCompiler(root: string, sourcePaths: string[]) {
     compilerCloseTimer = null
   }
   if (compilerClose) await compilerClose
-  if (compiler && compiler.root !== root) {
+  // configured projects cache their root membership. reopen after generation
+  // adds files so a following run includes those outputs in its new program.
+  if (
+    compiler &&
+    (tsconfig || compiler.root !== root || compiler.tsconfig !== tsconfig)
+  ) {
     const previous = compiler
     compiler = null
     await closeCompiler(previous)
   }
-  compiler ??= { api: new API({ cwd: root }), paths: new Set(), root }
+  compiler ??= { api: new API({ cwd: root }), paths: new Set(), root, tsconfig }
   compiler.api.clearSourceFileCache()
   const previousPaths = compiler.paths
   const nextPaths = new Set(sourcePaths)
   compiler.paths = nextPaths
   if (previousPaths.size > 0) {
     const closedSnapshot = await compiler.api.updateSnapshot({
-      closeFiles: [...previousPaths],
+      ...(tsconfig ? { closeProjects: [tsconfig] } : { closeFiles: [...previousPaths] }),
       fileChanges: { invalidateAll: true },
     })
     await closedSnapshot.dispose()
     compiler.api.clearSourceFileCache()
   }
   const snapshot = await compiler.api.updateSnapshot({
-    openFiles: sourcePaths,
+    ...(tsconfig ? { openProjects: [tsconfig] } : { openFiles: sourcePaths }),
     fileChanges: { invalidateAll: true },
   })
   compiler.api.clearSourceFileCache()
@@ -115,25 +126,30 @@ export function collectTypeScriptSourcePaths(roots: string[]): string[] {
 
 export async function createNativeTypeScriptProject(
   root: string,
-  sourcePaths: string[]
+  sourcePaths: string[],
+  options: { deferSources?: boolean; tsconfig?: string } = {}
 ): Promise<NativeTypeScriptProject> {
   if (sourcePaths.length === 0) {
     throw new Error(`[on-zero] no TypeScript source files found under ${root}`)
   }
 
-  const { session, snapshot, releaseTurn } = await acquireCompiler(root, sourcePaths)
+  const { session, snapshot, releaseTurn } = await acquireCompiler(
+    root,
+    sourcePaths,
+    options.tsconfig
+  )
   const sources = new Map<string, SourceFile>()
   const projectsByFile = new Map<string, Project>()
   const parseErrors = new Set<string>()
 
-  try {
+  const loadSources = async () => {
     for (const path of sourcePaths) {
-      const project = await snapshot.getDefaultProjectForFile(path)
+      if (sources.has(path)) continue
+      const project = projectsByFile.get(path)
       if (!project) throw new Error(`[on-zero] TypeScript did not open ${path}`)
       const source = await project.program.getSourceFile(path)
       if (!source) throw new Error(`[on-zero] TypeScript did not parse ${path}`)
       sources.set(path, source)
-      projectsByFile.set(path, project)
       try {
         parse(readFileSync(path, 'utf8'), {
           plugins: ['jsx', 'typescript'],
@@ -143,6 +159,29 @@ export async function createNativeTypeScriptProject(
         parseErrors.add(path)
       }
     }
+  }
+
+  try {
+    const scopedProject = options.tsconfig
+      ? snapshot.getProject(options.tsconfig)
+      : undefined
+    if (options.tsconfig) {
+      if (!scopedProject)
+        throw new Error(`[on-zero] TypeScript did not open ${options.tsconfig}`)
+      const included = new Set(await scopedProject.program.getSourceFileNames())
+      for (const path of sourcePaths) {
+        if (!included.has(path))
+          throw new Error(`[on-zero] generation project does not include ${path}`)
+      }
+    }
+    for (const path of sourcePaths) {
+      const project = options.tsconfig
+        ? scopedProject
+        : await snapshot.getDefaultProjectForFile(path)
+      if (!project) throw new Error(`[on-zero] TypeScript did not open ${path}`)
+      projectsByFile.set(path, project)
+    }
+    if (!options.deferSources) await loadSources()
   } catch (error) {
     await snapshot.dispose()
     releaseCompiler(session, releaseTurn)
@@ -151,6 +190,20 @@ export async function createNativeTypeScriptProject(
 
   let closed = false
   return {
+    configurationKey: JSON.stringify(
+      [...new Map([...projectsByFile.values()].map((p) => [p.id, p])).values()]
+        .map((project) => [project.configFileName, project.compilerOptions])
+        .sort(([left], [right]) => String(left).localeCompare(String(right)))
+    ),
+    loadSources,
+    async sourceFilePaths() {
+      const paths = new Set<string>()
+      const projects = new Map([...projectsByFile.values()].map((p) => [p.id, p]))
+      for (const project of projects.values()) {
+        for (const path of await project.program.getSourceFileNames()) paths.add(path)
+      }
+      return [...paths].sort()
+    },
     projectForFile(path) {
       const project = projectsByFile.get(resolve(path))
       if (!project)

package/src/provideZero.eagerInstance.test.tsx

@@ -233,3 +233,30 @@ test('disable=true constructs nothing', () => {
 
   expect(fakeZero.instances.length).toBe(0)
 })
+
+test('unmounting one of two overlapping providers keeps the shared instance published', () => {
+  const client = makeClient()
+  const first = createRoot(document.createElement('div'))
+  root = createRoot(container)
+  const mount = (target: Root | null) =>
+    act(() => {
+      target?.render(
+        <client.ProvideZero cacheURL="http://127.0.0.1:7788/zero" userID="shared">
+          <span>ok</span>
+        </client.ProvideZero>
+      )
+    })
+
+  mount(first)
+  mount(root)
+  expect(fakeZero.instances.length).toBe(1)
+
+  act(() => first.unmount())
+  expect((client.zero as unknown as { clientID: string }).clientID).toBe(
+    fakeZero.instances[0].clientID
+  )
+
+  act(() => root?.unmount())
+  root = null
+  expect(() => client.zero.clientID).toThrow(/Zero instance not initialized/)
+})