@openparachute/vault 0.7.4 → 0.7.5-rc.4

package/src/mirror-routes.ts

@@ -76,8 +76,17 @@ import {
   cloneAndImport,
   type GitSpawn,
   type ImportAuth,
+  type ImportProgress,
   type ImportResult,
 } from "./mirror-import.ts";
+import {
+  ImportJobConflictError,
+  getImportJob,
+  getRunningImportJob,
+  startImportJob,
+  type ImportJob,
+  type ImportJobError,
+} from "./mirror-import-jobs.ts";
 import { redactToken } from "./export-watch.ts";
 import {
   findConflictingVault,
@@ -1668,12 +1677,24 @@ export async function applyCredentialsToMirror(
 //   - Sync setup throws → import result still returned (success);
 //     `sync_enabled: false` + a warning. Import success is never lost.
 //
-// Response:
-//   200 { notes_imported, tags_imported, attachments_imported,
-//         notes_deleted?, warnings, sync_enabled, sync_warning? }
-//   400 { error, error_type, message }  — validation / not-a-vault-export
-//   409 { error, error_type, message }  — concurrent import for this vault
-//   502 { error, message }              — clone failed (auth, network, …)
+// Response (vault#640 — ASYNC by default):
+//   202 { job_id, vault_name, status, stage, started_at, … }
+//                                       — import started; poll the status route
+//   400 { error, error_type, message }  — validation
+//   409 { error, error_type, message, job_id? }
+//                                       — an import is already running here
+//   503 { error, error_type, message }  — git isn't installed on this box
+//
+// Terminal outcomes (not-a-vault-export, clone failure, import counts) arrive
+// on the JOB record, not this response:
+//   GET /vault/<name>/.parachute/mirror/import/<job_id>
+//     200 { status: "running",   stage, detail? }
+//     200 { status: "succeeded", result: { notes_imported, … } }
+//     200 { status: "failed",    error: { error_type, message } }
+//     404 { error_type: "job_not_found" }
+//
+// `{ "wait": true }` in the POST body restores the old synchronous 200 shape
+// for scripted callers. See the note in the handler.
 //
 // Admin-gated upstream in routing.ts.
 // ---------------------------------------------------------------------------
@@ -1681,10 +1702,13 @@ export async function applyCredentialsToMirror(
 /**
  * `POST /vault/<name>/.parachute/mirror/import`. See block comment above.
  *
- * Synchronous response: imports complete in <30s for typical vaults
- * (a 1k-note vault clones+imports in well under that bound on Aaron's hardware).
- * If/when bigger vaults arrive we promote to async polling — for now the
- * synchronous path keeps the UI flow simple.
+ * Starts a background job and returns 202 immediately. Before vault#640 this
+ * ran the whole clone-and-import inside the request; that could not work for a
+ * real vault, because hub fronts this route with
+ * `Bun.serve({ idleTimeout: 255 })` and kills anything past ~4 minutes
+ * regardless of what vault does. The 60s clone cap the old code carried was a
+ * symptom of the same constraint, and it made every non-trivial vault
+ * un-importable with "git clone timed out after 60s".
  *
  * `spawnOverride` is a test seam: lets the test inject a fake git binary.
  * Production callers omit it; `cloneAndImport` falls back to `defaultGitSpawn`.
@@ -1712,6 +1736,7 @@ export async function handleMirrorImport(
     credentials?: unknown;
     enable_sync?: unknown;
     override?: unknown;
+    wait?: unknown;
   };
   try {
     body = (await req.json()) as Record<string, unknown>;
@@ -1804,10 +1829,22 @@ export async function handleMirrorImport(
     );
   }
 
-  // vault#416: `enable_sync` defaults TRUE when omitted — the default-on UX.
-  // Only a literal `false` opts out; any other type is a validation error so
-  // a malformed body never silently flips the default.
-  let enableSync = true;
+  // `enable_sync` defaults FALSE when omitted (vault#641).
+  //
+  // vault#416 shipped this default-ON: importing a repo silently turned that
+  // repo into this vault's push target. That inverts the risk. Import is a
+  // READ — the operator is pulling a vault onto a new box — and the natural
+  // reading of "import from this repo" does not include "and start writing
+  // back to it." Default-on meant the safe intent (pull a copy) required
+  // noticing and unchecking a box, while the destructive one (rewire backup,
+  // potentially clobbering the repo a DIFFERENT box is backing up to) was what
+  // you got by not reading carefully. Worse, it made the credential question
+  // incoherent: operators reasonably refused to supply a token to *read* a
+  // private repo because supplying it appeared to arm a write.
+  //
+  // Opting in is now explicit. Only a literal `true` enables it; any
+  // non-boolean is a validation error so a malformed body can't flip it.
+  let enableSync = false;
   if ("enable_sync" in body && body.enable_sync !== undefined) {
     if (typeof body.enable_sync !== "boolean") {
       return Response.json(
@@ -1815,7 +1852,7 @@ export async function handleMirrorImport(
           error: "enable_sync invalid",
           error_type: "validation",
           field: "enable_sync",
-          message: "enable_sync must be a boolean (defaults to true when omitted).",
+          message: "enable_sync must be a boolean (defaults to false when omitted).",
         },
         { status: 400 },
       );
@@ -1823,6 +1860,14 @@ export async function handleMirrorImport(
     enableSync = body.enable_sync;
   }
 
+  // Back-compat seam: `wait: true` restores the pre-vault#640 synchronous
+  // response (200 + the ImportResult body) for scripted callers that read the
+  // result straight off the POST. It inherits the new stall-based timeout, so
+  // it is no longer capped at 60s — but it is still subject to whatever
+  // request timeout sits between the caller and vault, which is exactly why it
+  // is no longer the default. The SPA never sets it.
+  const wait = body.wait === true;
+
   // vault#482: cross-vault clobber override for the sync-enable step. Default
   // off; a literal `true` lets the operator deliberately point this vault's
   // sync at a repo a SIBLING vault already backs up to (e.g. they moved the
@@ -1837,22 +1882,13 @@ export async function handleMirrorImport(
   const store = getVaultStore(vaultName);
   const assets = assetsDir(vaultName);
 
-  let result: ImportResult;
+  // Preflight git BEFORE the job starts. `cloneAndImport` preflights too, but
+  // doing it here keeps "git isn't installed" a synchronous, actionable 503
+  // instead of a job the operator has to poll to discover was doomed.
   try {
-    result = await cloneAndImport({
-      vaultName,
-      remoteUrl: remote_url,
-      auth,
-      mode,
-      store,
-      assetsDir: assets,
-      spawn: spawnOverride,
-      which: whichOverride,
-    });
+    ensureGitAvailable(whichOverride);
   } catch (err) {
     if (err instanceof GitNotInstalledError) {
-      // 503 Service Unavailable — the server isn't configured to do this
-      // yet (git missing). The message tells the operator how to fix it.
       return Response.json(
         {
           error: "git not installed",
@@ -1862,82 +1898,188 @@ export async function handleMirrorImport(
         { status: 503 },
       );
     }
-    if (err instanceof ImportConflictError) {
-      return Response.json(
-        {
-          error: "Import already running",
-          error_type: "concurrent_import",
-          message: err.message,
-        },
-        { status: 409 },
-      );
+    throw err;
+  }
+
+  /**
+   * The actual work, shared by the async (default) and `wait: true` paths.
+   * Runs the clone+import, then optionally wires push-back. Every failure
+   * after a SUCCESSFUL import is non-fatal — an import is never lost to a
+   * sync-setup error.
+   */
+  const runImport = async (
+    onProgress: (update: ImportProgress) => void,
+  ): Promise<ImportResult> => {
+    const result = await cloneAndImport({
+      vaultName,
+      remoteUrl: remote_url,
+      auth,
+      mode,
+      store,
+      assetsDir: assets,
+      spawn: spawnOverride,
+      which: whichOverride,
+      onProgress,
+    });
+
+    if (enableSync) {
+      onProgress({ stage: "syncing" });
+      try {
+        const manager = managerOverride ?? getMirrorManager(vaultName) ?? undefined;
+        const outcome = await enableSyncToImportedRepo({
+          vaultName,
+          remoteUrl: remote_url,
+          auth,
+          manager,
+          override,
+        });
+        result.sync_enabled = outcome.sync_enabled;
+        if (outcome.warning) result.sync_warning = outcome.warning;
+      } catch (err) {
+        // Defense-in-depth: enableSyncToImportedRepo is written to not throw
+        // (it catches its own write/credential/reload errors), but a future
+        // edit or an unexpected throw must NOT take down a successful import.
+        const msg = redactToken((err as Error).message ?? String(err));
+        console.warn(
+          `[mirror-import] sync-enable threw after a successful import (non-fatal): ${msg}`,
+        );
+        result.sync_enabled = false;
+        result.sync_warning =
+          "Import succeeded, but enabling Sync failed. Set up Sync separately from the Git remote section.";
+      }
     }
-    if (err instanceof NotAVaultExportError) {
+    return result;
+  };
+
+  // ---- Back-compat synchronous path (`wait: true`) ------------------------
+  if (wait) {
+    try {
+      const result = await runImport(() => {});
+      return Response.json(result, {
+        headers: { "Access-Control-Allow-Origin": "*" },
+      });
+    } catch (err) {
+      const { error_type, message } = classifyImportError(err);
       return Response.json(
-        {
-          error: "Not a vault export",
-          error_type: "not_a_vault_export",
-          message: err.message,
-        },
-        { status: 400 },
+        { error: importErrorTitle(error_type), error_type, message },
+        { status: importErrorStatus(error_type) },
       );
     }
-    if (err instanceof CloneFailedError) {
+  }
+
+  // ---- Async path (default) ----------------------------------------------
+  let job: ImportJob;
+  try {
+    job = startImportJob(vaultName, runImport, classifyImportError);
+  } catch (err) {
+    if (err instanceof ImportJobConflictError) {
+      const existing = getRunningImportJob(vaultName);
       return Response.json(
         {
-          error: "Clone failed",
-          error_type: "clone_failed",
+          error: "Import already running",
+          error_type: "concurrent_import",
           message: err.message,
+          // Hand back the in-flight job so a second tab can attach to the
+          // running import's progress rather than just being told "no".
+          job_id: existing?.job_id,
         },
-        { status: 502 },
+        { status: 409 },
       );
     }
+    throw err;
+  }
+
+  return Response.json(job, {
+    status: 202,
+    headers: { "Access-Control-Allow-Origin": "*" },
+  });
+}
+
+/**
+ * `GET /vault/<name>/.parachute/mirror/import/<job_id>` — poll an import.
+ *
+ * Returns the job record (status / stage / detail, plus `result` or `error`
+ * once terminal). 404 when the id is unknown for this vault — which is also
+ * what a caller sees after a vault restart, since jobs are in-memory by design
+ * (see `mirror-import-jobs.ts`).
+ *
+ * Admin-gated upstream in routing.ts, same as the POST.
+ */
+export function handleMirrorImportStatus(
+  vaultName: string,
+  jobId: string,
+): Response {
+  const job = getImportJob(vaultName, jobId);
+  if (!job) {
     return Response.json(
       {
-        error: "Import failed",
-        error_type: "internal",
-        message: (err as Error).message ?? String(err),
+        error: "No such import job",
+        error_type: "job_not_found",
+        message:
+          "That import job isn't known to this vault. It may have finished more than an hour ago, or the vault restarted while it was running.",
       },
-      { status: 500 },
+      { status: 404, headers: { "Access-Control-Allow-Origin": "*" } },
     );
   }
+  return Response.json(job, {
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      // Polled endpoint — never let an intermediary serve a stale stage.
+      "cache-control": "no-store",
+    },
+  });
+}
 
-  // ---- vault#416: auto-enable sync to the imported repo (default-on) -------
-  //
-  // The import SUCCEEDED above. From here on, every failure is non-fatal —
-  // we never lose a successful import to a sync-setup error. `result` already
-  // carries `sync_enabled: false` (set by importResultFromStats); we flip it
-  // true only when sync is actually wired (or already wired to this remote).
-  if (enableSync) {
-    try {
-      const manager =
-        managerOverride ?? getMirrorManager(vaultName) ?? undefined;
-      const outcome = await enableSyncToImportedRepo({
-        vaultName,
-        remoteUrl: remote_url,
-        auth,
-        manager,
-        override,
-      });
-      result.sync_enabled = outcome.sync_enabled;
-      if (outcome.warning) result.sync_warning = outcome.warning;
-    } catch (err) {
-      // Defense-in-depth: enableSyncToImportedRepo is written to not throw
-      // (it catches its own write/credential/reload errors), but a future
-      // edit or an unexpected throw must NOT take down a successful import.
-      const msg = redactToken((err as Error).message ?? String(err));
-      console.warn(
-        `[mirror-import] sync-enable threw after a successful import (non-fatal): ${msg}`,
-      );
-      result.sync_enabled = false;
-      result.sync_warning =
-        "Import succeeded, but enabling Sync failed. Set up Sync separately from the Git remote section.";
-    }
+/** Map a thrown import error onto the wire's `error_type` vocabulary. */
+function classifyImportError(err: unknown): ImportJobError {
+  if (err instanceof GitNotInstalledError) {
+    return { error_type: "git_not_installed", message: err.message };
   }
+  if (err instanceof ImportConflictError) {
+    return { error_type: "concurrent_import", message: err.message };
+  }
+  if (err instanceof NotAVaultExportError) {
+    return { error_type: "not_a_vault_export", message: err.message };
+  }
+  if (err instanceof CloneFailedError) {
+    return { error_type: "clone_failed", message: err.message };
+  }
+  return {
+    error_type: "internal",
+    message: redactToken((err as Error)?.message ?? String(err)),
+  };
+}
 
-  return Response.json(result, {
-    headers: { "Access-Control-Allow-Origin": "*" },
-  });
+/** HTTP status for an `error_type` — used by the `wait: true` path. */
+function importErrorStatus(errorType: ImportJobError["error_type"]): number {
+  switch (errorType) {
+    case "git_not_installed":
+      return 503;
+    case "concurrent_import":
+      return 409;
+    case "not_a_vault_export":
+      return 400;
+    case "clone_failed":
+      return 502;
+    default:
+      return 500;
+  }
+}
+
+/** Human title for an `error_type` — used by the `wait: true` path. */
+function importErrorTitle(errorType: ImportJobError["error_type"]): string {
+  switch (errorType) {
+    case "git_not_installed":
+      return "git not installed";
+    case "concurrent_import":
+      return "Import already running";
+    case "not_a_vault_export":
+      return "Not a vault export";
+    case "clone_failed":
+      return "Clone failed";
+    default:
+      return "Import failed";
+  }
 }
 
 // ---------------------------------------------------------------------------

package/src/routing.ts

@@ -112,6 +112,7 @@ import {
   handleMirrorHistory,
   handleMirrorHistoryShow,
   handleMirrorImport,
+  handleMirrorImportStatus,
   handleMirrorPushNow,
   handleMirrorPut,
   handleMirrorRunNow,
@@ -874,12 +875,18 @@ export async function route(
     return handleMirrorHistory(req, manager);
   }
 
-  // /.parachute/mirror/import — clone a vault export from git + import.
-  // Admin-gated. POST-only. Synchronous (imports finish in <30s for
-  // typical vaults). See mirror-routes.ts:handleMirrorImport for the
+  // /.parachute/mirror/import       — POST: start a clone+import job (202).
+  // /.parachute/mirror/import/<id>  — GET:  poll that job.
+  //
+  // Admin-gated. Async since vault#640 — the synchronous shape couldn't
+  // survive hub's 255s proxy idleTimeout, which is what capped imports at a
+  // vault-sized demo. See mirror-routes.ts:handleMirrorImport for the
   // request/response shape + error map. Symmetric counterpart to the
   // export-to-git flow vault#382 + vault#384 shipped.
-  if (subpath === "/.parachute/mirror/import") {
+  if (
+    subpath === "/.parachute/mirror/import" ||
+    subpath.startsWith("/.parachute/mirror/import/")
+  ) {
     if (!hasScopeForVault(auth.scopes, vaultName, "admin")) {
       return Response.json(
         {
@@ -892,10 +899,19 @@ export async function route(
         { status: 403 },
       );
     }
-    if (req.method !== "POST") {
+    if (subpath === "/.parachute/mirror/import") {
+      if (req.method !== "POST") {
+        return Response.json({ error: "Method not allowed" }, { status: 405 });
+      }
+      return handleMirrorImport(req, vaultName);
+    }
+    if (req.method !== "GET") {
       return Response.json({ error: "Method not allowed" }, { status: 405 });
     }
-    return handleMirrorImport(req, vaultName);
+    const jobId = decodeURIComponent(
+      subpath.slice("/.parachute/mirror/import/".length),
+    );
+    return handleMirrorImportStatus(vaultName, jobId);
   }
 
   // /.parachute/mirror/auth/* — UI-configurable git push credentials.

package/src/server.ts

@@ -36,6 +36,7 @@ import { TranscribeCppProvider } from "./transcription/providers/transcribe-cpp.
 import { ParakeetMlxProvider } from "./transcription/providers/parakeet-mlx.ts";
 import { OnnxAsrProvider } from "./transcription/providers/onnx-asr.ts";
 import {
+  resolveTranscriptionModelId,
   resolveTranscriptionProviderName,
   resolveTranscribeCppPaths,
   transcribeCppInstalled,
@@ -63,6 +64,15 @@ import {
 } from "./mirror-config.ts";
 import { GLOBAL_CONFIG_PATH } from "./config.ts";
 import { selfRegister } from "./self-register.ts";
+import { join } from "node:path";
+import { TRANSCRIPTION_MODELS, findModel } from "./transcription/models.ts";
+import {
+  candidateBinDirs,
+  managedModelDir,
+  resolveCliBinary,
+  resolveFfmpeg,
+} from "./transcription/resolve-binary.ts";
+import { WhisperCppProvider } from "./transcription/providers/whisper-cpp.ts";
 import { createSubscribeWsBinding, isWebSocketUpgrade } from "./ws-server.ts";
 import { warnLegacyGlobalApiKeys } from "./auth.ts";
 import pkg from "../package.json" with { type: "json" };
@@ -149,7 +159,58 @@ const commonWorkerOpts = {
 // Provider selection (scribe-fold Phase 2a). Default is `scribe-http` — unset
 // TRANSCRIPTION_PROVIDER means the existing scribe-http path runs unchanged.
 const providerName = resolveTranscriptionProviderName();
-if (providerName === "transcribe-cpp") {
+if (providerName === "whisper-cpp") {
+  // whisper.cpp's prebuilt CLIs — the local, no-Python path that actually
+  // ships binaries on both macOS (brew bottle) and Linux (release tarball).
+  // The model decides which CLI runs: parakeet-cli or whisper-cli.
+  //
+  // Binaries are resolved through the ladder in `resolve-binary.ts` rather
+  // than PATH alone, because a launchd-supervised vault does not inherit a
+  // login shell's PATH — on a Mac, `brew install whisper-cpp` otherwise looks
+  // installed to the operator and invisible to us.
+  const model = findModel(resolveTranscriptionModelId());
+  if (!model) {
+    console.warn(
+      `[transcribe] TRANSCRIPTION_MODEL="${resolveTranscriptionModelId()}" is not a known model — ` +
+        `valid ids: ${TRANSCRIPTION_MODELS.map((m) => m.id).join(", ")}`,
+    );
+  } else {
+    const binPath = resolveCliBinary(model.engine);
+    const modelPath = join(managedModelDir(), model.filename);
+    const ffmpegPath = resolveFfmpeg();
+    if (binPath && existsSync(modelPath)) {
+      transcriptionWorker = startTranscriptionWorker({
+        ...commonWorkerOpts,
+        provider: new WhisperCppProvider({
+          binPath,
+          engine: model.engine,
+          modelPath,
+          ffmpegPath,
+        }),
+      });
+      wireTranscriptionWorker(transcriptionWorker);
+      console.log(`[transcribe] worker started → whisper-cpp (${model.label}, ${binPath})`);
+      if (!ffmpegPath) {
+        console.warn(
+          "[transcribe] ffmpeg was not found — audio still has to be transcoded to 16 kHz mono " +
+            "WAV, so transcription will fail until it's installed (`brew install ffmpeg` / `apt install ffmpeg`).",
+        );
+      }
+    } else {
+      // Say WHICH piece is missing and where we looked. "Not installed" with
+      // two possible meanings and different fixes for each is not actionable.
+      const missing = [
+        binPath ? null : `the ${model.engine === "whisper" ? "whisper-cli" : "parakeet-cli"} binary`,
+        existsSync(modelPath) ? null : `the model (${model.label}, ${model.sizeMb} MB)`,
+      ].filter(Boolean);
+      console.warn(
+        `[transcribe] TRANSCRIPTION_PROVIDER=whisper-cpp but ${missing.join(" and ")} ` +
+          `${missing.length > 1 ? "are" : "is"} missing — run \`parachute-vault transcription install\`. ` +
+          `Searched for binaries in: ${candidateBinDirs().slice(0, 4).join(", ")}…`,
+      );
+    }
+  }
+} else if (providerName === "transcribe-cpp") {
   // Local, no-Python provider: subprocess a transcribe-cli. Only start the
   // worker when a runnable CLI + model are actually present — otherwise every
   // pending item would terminal-fail with `missing_provider`. (v0.1.1 ships a

package/src/transcription/models.test.ts

@@ -0,0 +1,87 @@
+/**
+ * The model catalog.
+ *
+ * These tests care about two things a catalog gets wrong quietly: URLs that
+ * don't match the filename we save to (so a re-run re-downloads forever), and
+ * a default-picker that hands a 1.5 GB model to a 1 GB box.
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+  DEFAULT_MODEL_ID,
+  findModel,
+  pickDefaultModel,
+  TRANSCRIPTION_MODELS,
+} from "./models.ts";
+
+describe("catalog integrity", () => {
+  test("ids are unique", () => {
+    const ids = TRANSCRIPTION_MODELS.map((m) => m.id);
+    expect(ids.length).toBe(new Set(ids).size);
+  });
+
+  test("every URL's basename matches the filename we write", () => {
+    // Drift here means the downloader saves to a name the resolver never
+    // looks for, so every boot re-downloads and nothing ever becomes ready.
+    for (const m of TRANSCRIPTION_MODELS) {
+      expect(m.url.split("/").pop()).toBe(m.filename);
+    }
+  });
+
+  test("Parakeet models come from ggml-org, Whisper from ggerganov", () => {
+    // Load-bearing: handy-computer's GGUFs are NOT loadable by whisper.cpp's
+    // parakeet-cli (verified — "failed to load Parakeet model"). Pointing a
+    // Parakeet entry at handy-computer would produce a model that downloads
+    // fine and then fails at every transcription.
+    for (const m of TRANSCRIPTION_MODELS) {
+      if (m.engine === "parakeet") expect(m.url).toContain("ggml-org/parakeet-GGUF");
+      else expect(m.url).toContain("ggerganov/whisper.cpp");
+    }
+  });
+
+  test("catalog is ordered smallest-first", () => {
+    const sizes = TRANSCRIPTION_MODELS.map((m) => m.sizeMb);
+    expect([...sizes].sort((a, b) => a - b)).toEqual(sizes);
+  });
+
+  test("the default exists and is a Parakeet model", () => {
+    const d = findModel(DEFAULT_MODEL_ID);
+    expect(d).toBeDefined();
+    expect(d!.engine).toBe("parakeet");
+  });
+
+  test("covers the small and mid size classes an operator asks for", () => {
+    const sizes = TRANSCRIPTION_MODELS.map((m) => m.sizeMb);
+    expect(sizes.some((s) => s < 150)).toBe(true); // ~100 MB class
+    expect(sizes.some((s) => s >= 300 && s <= 700)).toBe(true); // ~400–700 MB class
+  });
+});
+
+describe("pickDefaultModel", () => {
+  test("a comfortable box gets the recommended Parakeet", () => {
+    expect(pickDefaultModel(16384).id).toBe(DEFAULT_MODEL_ID);
+  });
+
+  test("a small box steps DOWN rather than swapping itself to death", () => {
+    const picked = pickDefaultModel(1024);
+    expect(picked.minRamMb).toBeLessThanOrEqual(1024);
+    expect(picked.sizeMb).toBeLessThan(200);
+  });
+
+  test("never returns undefined, even on an absurdly small box", () => {
+    const picked = pickDefaultModel(64);
+    expect(picked).toBeDefined();
+    expect(picked.id).toBe(TRANSCRIPTION_MODELS[0]!.id);
+  });
+
+  test("a mid box gets something that fits its RAM floor", () => {
+    const picked = pickDefaultModel(2048);
+    expect(picked.minRamMb).toBeLessThanOrEqual(2048);
+  });
+});
+
+describe("findModel", () => {
+  test("unknown id → undefined, not a throw", () => {
+    expect(findModel("nope")).toBeUndefined();
+  });
+});