@indigoai-us/hq-cloud 5.26.0 → 5.28.0

package/src/bin/sync-runner.ts

@@ -94,6 +94,11 @@ import {
   systemClock,
   type Clock,
 } from "../watcher.js";
+import {
+  NoopPushReceiver,
+  type PushReceiver,
+  type SyncEngineFn,
+} from "../sync/push-receiver.js";
 
 /**
  * Sync direction for a run.
@@ -1249,6 +1254,26 @@ export interface RunnerLoopDeps {
    * handler (called during teardown so tests don't leak listeners).
    */
   onShutdownSignal?: (handler: () => void) => () => void;
+  /**
+   * Factory for the Phase 2 pull-on-event receiver (US-009). Defaults to a
+   * {@link NoopPushReceiver} — the daemon ships the receiver SEAM wired into
+   * the lifecycle (start after the watcher, dispose before exit) but stays
+   * DORMANT by default: the per-client SQS queue is provisioned server-side
+   * (an unbuilt follow-up) and the receiver is feature-flag gated. A future
+   * menubar/CLI release injects an {@link SqsPushReceiver} here once a queue
+   * URL is available. Only consulted when `--event-push` is on.
+   *
+   * The factory is handed a {@link SyncEngineFn} that bridges a received
+   * PushEvent to a TARGETED pull pass (`--company <slug> --direction pull`,
+   * or a personal `--companies --direction pull`) routed by the event's
+   * `relativePath`, funneled through the same in-flight guard as the poll
+   * loop and the watcher push so a pull-on-event never overlaps an in-flight
+   * pass.
+   */
+  createReceiver?: (opts: {
+    syncFn: SyncEngineFn;
+    hqRoot: string;
+  }) => PushReceiver;
 }
 
 /**
@@ -1318,6 +1343,28 @@ export function buildTargetedPushArgv(
   return ["--companies", "--direction", "push", ...carried];
 }
 
+/**
+ * Build the argv for a targeted PULL pass from a routed change (US-009 — the
+ * receiver's pull-on-event path). Mirrors {@link buildTargetedPushArgv} but
+ * with `--direction pull`: a peer device pushed a change, so this device pulls
+ * just the affected company/subtree instead of waiting for the next
+ * `--poll-remote-ms` cycle. Company routes use `--company <slug>`; personal
+ * routes use `--companies` (the personal-vault scope is resolved inside
+ * runRunner's fanout; skipUnchanged no-ops the subtrees that didn't change).
+ * Inherits `--hq-root` / `--on-conflict` from the base argv. Pure helper,
+ * exported for unit testing the event→argv map.
+ */
+export function buildTargetedPullArgv(
+  route: { kind: "company"; slug: string } | { kind: "personal" },
+  baseArgv: string[],
+): string[] {
+  const carried = carriedFlags(baseArgv);
+  if (route.kind === "company") {
+    return ["--company", route.slug, "--direction", "pull", ...carried];
+  }
+  return ["--companies", "--direction", "pull", ...carried];
+}
+
 export async function runRunnerWithLoop(
   argv: string[],
   deps: RunnerLoopDeps = {},
@@ -1333,6 +1380,15 @@ export async function runRunnerWithLoop(
   const pollMs =
     pollIdx >= 0 && argv[pollIdx + 1] ? Number(argv[pollIdx + 1]) : 600_000;
   const eventPush = argv.includes("--event-push");
+  // In `--companies` mode the sync scope is companies/*/{knowledge,projects,…}
+  // (per .hqinclude), so the watcher must NOT apply the personal-vault
+  // top-level exclusions (PERSONAL_VAULT_EXCLUDED_TOP_LEVEL drops `companies/`
+  // and `workspace/`) — doing so would exclude exactly the paths being synced,
+  // and no local edit would ever trigger an instant push. The shared ignore
+  // stack (createIgnoreFilter / .hqignore / .hqinclude) already scopes the
+  // watch filter correctly in companies mode. personalMode is only for a
+  // personal-vault-as-root run, where companies/ et al. genuinely aren't synced.
+  const companiesMode = argv.includes("--companies");
   const hqIdx = argv.indexOf("--hq-root");
   const hqRoot =
     hqIdx >= 0 && argv[hqIdx + 1] ? argv[hqIdx + 1] : DEFAULT_HQ_ROOT;
@@ -1372,6 +1428,12 @@ export async function runRunnerWithLoop(
   let driver: WatchPushDriver | null = null;
   let detachSignal: (() => void) | null = null;
   let lastChangedRel: string | null = null;
+  // ---- pull-on-event receiver (Phase 2, US-009) ------------------------
+  // Started after the watcher, disposed before the watcher (mirror of the
+  // PushTransport ordering). Dormant by default: the default factory returns
+  // a NoopPushReceiver, and even a real receiver stays dormant unless the
+  // per-tenant feature flag is on AND a queue URL is provisioned server-side.
+  let receiver: PushReceiver | null = null;
 
   if (eventPush) {
     const clock = deps.clock ?? systemClock;
@@ -1383,7 +1445,10 @@ export async function runRunnerWithLoop(
           hqRoot: opts.hqRoot,
           debounceMs: opts.debounceMs,
           clock: opts.clock,
-          personalMode: true,
+          // false in --companies mode so the watch filter matches the sync
+          // scope (companies/* are included via .hqinclude); true only for a
+          // personal-vault-as-root run.
+          personalMode: !companiesMode,
         }));
     watcher = createWatcher({ hqRoot, debounceMs, clock });
 
@@ -1416,6 +1481,31 @@ export async function runRunnerWithLoop(
       driver?.notifyChange();
     });
     watcher.start();
+
+    // Pull-on-event receiver (US-009). The injected SyncEngineFn bridges a
+    // received PushEvent → a TARGETED pull pass routed by relativePath, funneled
+    // through the SAME `runGuarded` mutex as the poll loop + watcher push so a
+    // pull-on-event never overlaps an in-flight pass. Started AFTER the watcher
+    // so a live event can't race a half-built daemon. Default factory = noop
+    // (dormant); a real SqsPushReceiver is injected by a later release once the
+    // server-side per-client SQS queue is provisioned.
+    const receiverSyncFn: SyncEngineFn = async (ctx) => {
+      if (stopped) return;
+      const route = routeChangeToTarget(ctx.event.relativePath);
+      if (!route) return;
+      const targetedArgv = buildTargetedPullArgv(route, passArgv);
+      await runGuarded(() => runPass(targetedArgv));
+    };
+    const createReceiver =
+      deps.createReceiver ?? (() => new NoopPushReceiver());
+    receiver = createReceiver({ syncFn: receiverSyncFn, hqRoot });
+    // Fire-and-forget start: a receiver's start() kicks off its own poll loop
+    // (SqsPushReceiver) or trivially flips connected (noop) — it must NOT block
+    // the runner's poll loop from entering. Errors are swallowed; the cadence
+    // poll is the safety net regardless of receiver health. (The await-free
+    // start also keeps the poll loop's microtask timing identical to the
+    // pre-US-009 wiring.)
+    void Promise.resolve(receiver.start()).catch(() => undefined);
   }
 
   // ---- clean shutdown --------------------------------------------------
@@ -1429,6 +1519,17 @@ export async function runRunnerWithLoop(
   const shutdown = (): void => {
     if (stopped) return;
     stopped = true;
+    // Dispose the receiver FIRST (mirror of the PushTransport ordering:
+    // inbound subscription torn down before the watcher) so no new
+    // pull-on-event fires mid-teardown. dispose() is async (it drains the
+    // in-flight pull up to its own deadline); fire-and-forget here — the
+    // receiver's internal drain + the runGuarded mutex bound the work, and
+    // SIGTERM teardown must not block. Errors are swallowed.
+    try {
+      void receiver?.dispose();
+    } catch {
+      /* ignore */
+    }
     try {
       driver?.dispose();
     } catch {

package/src/index.ts

@@ -292,9 +292,30 @@ export {
   encodePushEvent,
   decodePushEvent,
   NoopPushTransport,
+  HttpPushTransport,
+  FEATURE_FLAG_TENANTS_ENV_VAR,
+  FEATURE_FLAG_LEGACY_GLOBAL_ENV_VAR,
+  EnvTenantListFlagProvider,
+  StaticFlagProvider,
+  defaultFlagProvider,
 } from "./sync/index.js";
 export type {
   PushEvent,
   PushEventDecodeIssue,
   PushTransport,
+  HttpPushTransportOptions,
+  AuthTokenSource,
+  FetchLike,
+  EventDrivenPushFlagProvider,
+  FlagProviderWarnFn,
+  EnvTenantListFlagProviderOptions,
 } from "./sync/index.js";
+
+// US-008 — watcher PushEvent emitter (bridges TreeWatcher → PushTransport,
+// flag-gated, failure-safe).
+export { PushEventEmitter } from "./watcher.js";
+export type {
+  PushEventEmitterOptions,
+  TreeChangeBatch,
+  TreeChangeListener,
+} from "./watcher.js";

package/src/sync/feature-flags.test.ts

@@ -0,0 +1,392 @@
+/**
+ * US-008 — client push transport unit tests.
+ *
+ * The PRD names this file as the home for US-008's coverage; it spans the
+ * four required assertions across the three US-008 modules:
+ *
+ *   1. flag gating          — feature-flags.ts (env list, legacy global,
+ *                              static provider, malformed-entry tolerance)
+ *   2. POST                 — push-transport.ts HttpPushTransport posts an
+ *                              encoded PushEvent to `<apiUrl>/sync/push` with
+ *                              a Bearer token (mocked fetch — no real server)
+ *   3. emit                 — watcher.ts PushEventEmitter builds a valid
+ *                              PushEvent (sha256 hash, monotonic seq, tenant)
+ *                              per debounced change and hands it to the
+ *                              transport; dormant when the flag is OFF
+ *   4. transport failure    — a publish rejection (or hash error) is caught,
+ *                              surfaced via onError, and never crashes / never
+ *                              propagates (cadence poll is the safety net)
+ *
+ * The live `/sync/push` endpoint is NOT deployed yet — every POST is asserted
+ * against a mocked fetch / mocked transport.
+ */
+
+import { createHash } from "node:crypto";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import {
+  EnvTenantListFlagProvider,
+  FEATURE_FLAG_LEGACY_GLOBAL_ENV_VAR,
+  FEATURE_FLAG_TENANTS_ENV_VAR,
+  StaticFlagProvider,
+  defaultFlagProvider,
+} from "./feature-flags.js";
+import {
+  HttpPushTransport,
+  NoopPushTransport,
+  type FetchLike,
+  type PushTransport,
+} from "./push-transport.js";
+import { decodePushEvent, type PushEvent } from "./push-event.js";
+import { PushEventEmitter } from "../watcher.js";
+import type { TreeChangeBatch } from "../watcher.js";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function fakePushEvent(overrides: Partial<PushEvent> = {}): PushEvent {
+  return {
+    relativePath: "personal/notes/a.md",
+    contentHash: `sha256:${"a".repeat(64)}`,
+    mtime: "2026-05-21T12:00:00.000Z",
+    originDeviceId: "device-1",
+    originTenantId: "indigo",
+    sequenceNumber: 0,
+    eventTimestamp: "2026-05-21T12:00:01.000Z",
+    ...overrides,
+  };
+}
+
+/** A fetch double that records calls and returns a configurable response. */
+function makeFetch(
+  res: { ok: boolean; status: number; body?: string } = {
+    ok: true,
+    status: 200,
+  },
+): { fetch: FetchLike; calls: Array<{ url: string; init: unknown }> } {
+  const calls: Array<{ url: string; init: unknown }> = [];
+  const fetch: FetchLike = async (url, init) => {
+    calls.push({ url, init });
+    return {
+      ok: res.ok,
+      status: res.status,
+      text: async () => res.body ?? "",
+    };
+  };
+  return { fetch, calls };
+}
+
+// ─── 1. Flag gating (feature-flags.ts) ────────────────────────────────────────
+
+describe("EventDrivenPush feature flags — gating", () => {
+  it("StaticFlagProvider enables only listed tenants", () => {
+    const p = new StaticFlagProvider(["indigo"]);
+    expect(p.isEnabled("indigo")).toBe(true);
+    expect(p.isEnabled("acme")).toBe(false);
+  });
+
+  it("env tenant list: empty/unset → all tenants OFF (default)", () => {
+    expect(new EnvTenantListFlagProvider({ env: {} }).isEnabled("indigo")).toBe(
+      false,
+    );
+    expect(
+      new EnvTenantListFlagProvider({
+        env: { [FEATURE_FLAG_TENANTS_ENV_VAR]: "" },
+      }).isEnabled("indigo"),
+    ).toBe(false);
+  });
+
+  it("env tenant list enables exact, case-sensitive matches only", () => {
+    const p = new EnvTenantListFlagProvider({
+      env: { [FEATURE_FLAG_TENANTS_ENV_VAR]: " indigo , acme " },
+    });
+    expect(p.isEnabled("indigo")).toBe(true);
+    expect(p.isEnabled("acme")).toBe(true);
+    expect(p.isEnabled("Indigo")).toBe(false);
+    expect(p.isEnabled("other")).toBe(false);
+    expect(p.enabledTenants).toEqual(new Set(["indigo", "acme"]));
+  });
+
+  it("legacy global=true overrides → every tenant enabled", () => {
+    const p = new EnvTenantListFlagProvider({
+      env: { [FEATURE_FLAG_LEGACY_GLOBAL_ENV_VAR]: "true" },
+    });
+    expect(p.isEnabled("anything")).toBe(true);
+    expect(p.globalOverride).toBe(true);
+  });
+
+  it("trailing/empty commas dropped silently; internal-whitespace warn-and-skipped (no throw)", () => {
+    const warn = vi.fn();
+    const p = new EnvTenantListFlagProvider({
+      env: { [FEATURE_FLAG_TENANTS_ENV_VAR]: ",,indigo,,bad tenant," },
+      warn,
+    });
+    expect(p.isEnabled("indigo")).toBe(true);
+    expect(p.isEnabled("bad tenant")).toBe(false);
+    expect(warn).toHaveBeenCalledTimes(1);
+    expect(warn.mock.calls[0][1]).toMatchObject({ rawEntry: "bad tenant" });
+  });
+
+  it("defaultFlagProvider reads from the supplied env snapshot", () => {
+    const p = defaultFlagProvider({
+      [FEATURE_FLAG_TENANTS_ENV_VAR]: "indigo",
+    });
+    expect(p.isEnabled("indigo")).toBe(true);
+    expect(p.isEnabled("acme")).toBe(false);
+  });
+
+  it("enabledTenants returns a defensive copy (mutation does not corrupt cache)", () => {
+    const p = new EnvTenantListFlagProvider({
+      env: { [FEATURE_FLAG_TENANTS_ENV_VAR]: "indigo" },
+    });
+    (p.enabledTenants as Set<string>).add("acme");
+    expect(p.isEnabled("acme")).toBe(false);
+  });
+});
+
+// ─── 2. POST (HttpPushTransport) ──────────────────────────────────────────────
+
+describe("HttpPushTransport — POST /sync/push", () => {
+  it("POSTs an encoded PushEvent to <apiUrl>/sync/push with a Bearer token", async () => {
+    const { fetch, calls } = makeFetch({ ok: true, status: 200 });
+    const transport = new HttpPushTransport({
+      apiUrl: "https://vault-api.example.com/",
+      authToken: "tok-123",
+      fetchImpl: fetch,
+    });
+    await transport.start();
+    expect(transport.connected).toBe(true);
+
+    const event = fakePushEvent();
+    await transport.publish(event);
+
+    expect(calls).toHaveLength(1);
+    const call = calls[0];
+    // Trailing slash on apiUrl is normalized; default path is /sync/push.
+    expect(call.url).toBe("https://vault-api.example.com/sync/push");
+    const init = call.init as {
+      method: string;
+      headers: Record<string, string>;
+      body: string;
+    };
+    expect(init.method).toBe("POST");
+    expect(init.headers.Authorization).toBe("Bearer tok-123");
+    expect(init.headers["Content-Type"]).toBe("application/json");
+    // Body is a valid encoded PushEvent that round-trips.
+    expect(decodePushEvent(init.body)).toEqual(event);
+  });
+
+  it("resolves the auth token per-request via an async getter (self-heals across refresh)", async () => {
+    const { fetch, calls } = makeFetch();
+    let n = 0;
+    const transport = new HttpPushTransport({
+      apiUrl: "https://api.example.com",
+      authToken: () => `tok-${n++}`,
+      fetchImpl: fetch,
+    });
+    await transport.publish(fakePushEvent());
+    await transport.publish(fakePushEvent());
+    expect((calls[0].init as any).headers.Authorization).toBe("Bearer tok-0");
+    expect((calls[1].init as any).headers.Authorization).toBe("Bearer tok-1");
+  });
+
+  it("honors a custom pushPath + extra headers", async () => {
+    const { fetch, calls } = makeFetch();
+    const transport = new HttpPushTransport({
+      apiUrl: "https://api.example.com",
+      pushPath: "v1/sync/push",
+      authToken: "t",
+      headers: { "x-hq-client-name": "hq-sync-runner" },
+      fetchImpl: fetch,
+    });
+    await transport.publish(fakePushEvent());
+    expect(calls[0].url).toBe("https://api.example.com/v1/sync/push");
+    expect((calls[0].init as any).headers["x-hq-client-name"]).toBe(
+      "hq-sync-runner",
+    );
+  });
+
+  it("rejects when apiUrl is missing", () => {
+    expect(
+      () => new HttpPushTransport({ apiUrl: "", authToken: "t" }),
+    ).toThrow(/apiUrl is required/);
+  });
+
+  it("rejects (does not swallow) on a non-2xx response", async () => {
+    const { fetch } = makeFetch({ ok: false, status: 403, body: "forbidden" });
+    const transport = new HttpPushTransport({
+      apiUrl: "https://api.example.com",
+      authToken: "t",
+      fetchImpl: fetch,
+    });
+    await expect(transport.publish(fakePushEvent())).rejects.toThrow(/403/);
+  });
+
+  it("rejects on a malformed event before hitting the network", async () => {
+    const { fetch, calls } = makeFetch();
+    const transport = new HttpPushTransport({
+      apiUrl: "https://api.example.com",
+      authToken: "t",
+      fetchImpl: fetch,
+    });
+    await expect(
+      transport.publish(fakePushEvent({ contentHash: "not-a-hash" })),
+    ).rejects.toBeTruthy();
+    expect(calls).toHaveLength(0);
+  });
+});
+
+// ─── 3 + 4. Emit + gating + failure handling (PushEventEmitter) ───────────────
+
+describe("PushEventEmitter — emit, gating, failure handling", () => {
+  let dir: string;
+  let filePath: string;
+  const REL = "a.md";
+
+  beforeEach(() => {
+    dir = mkdtempSync(path.join(tmpdir(), "us008-"));
+    filePath = path.join(dir, REL);
+    writeFileSync(filePath, "hello world");
+  });
+
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  function batchFor(...rels: string[]): TreeChangeBatch {
+    const paths = new Map<string, string>();
+    for (const rel of rels) paths.set(path.join(dir, rel), rel);
+    return { paths };
+  }
+
+  it("emits a valid PushEvent (sha256 hash, tenant) per changed path and ships it", async () => {
+    const transport = new NoopPushTransport();
+    const published: PushEvent[] = [];
+    const spyTransport: PushTransport = {
+      start: () => transport.start(),
+      dispose: () => transport.dispose(),
+      get connected() {
+        return transport.connected;
+      },
+      publish: async (e) => {
+        published.push(e);
+      },
+    };
+    const emitter = new PushEventEmitter({
+      originTenantId: "indigo",
+      originDeviceId: "dev-1",
+      transport: spyTransport,
+      flagProvider: new StaticFlagProvider(["indigo"]),
+      now: () => new Date("2026-05-21T00:00:00.000Z"),
+    });
+
+    await emitter.emitForBatch(batchFor(REL));
+
+    expect(published).toHaveLength(1);
+    const e = published[0];
+    expect(e.relativePath).toBe(REL);
+    expect(e.originTenantId).toBe("indigo");
+    expect(e.originDeviceId).toBe("dev-1");
+    const expectedHex = createHash("sha256").update("hello world").digest("hex");
+    expect(e.contentHash).toBe(`sha256:${expectedHex}`);
+    // Round-trips through the wire contract.
+    expect(() => decodePushEvent(e)).not.toThrow();
+  });
+
+  it("assigns monotonic per-device sequence numbers across emits", async () => {
+    const published: PushEvent[] = [];
+    const emitter = new PushEventEmitter({
+      originTenantId: "indigo",
+      originDeviceId: "dev-1",
+      transport: { start: async () => {}, dispose: async () => {}, connected: true, publish: async (e) => { published.push(e); } },
+      flagProvider: new StaticFlagProvider(["indigo"]),
+    });
+    writeFileSync(path.join(dir, "b.md"), "second");
+    await emitter.emitForBatch(batchFor(REL));
+    await emitter.emitForBatch(batchFor("b.md"));
+    expect(published.map((e) => e.sequenceNumber)).toEqual([0, 1]);
+  });
+
+  it("is DORMANT when the flag is OFF: ships nothing, attach is a no-op", async () => {
+    const publish = vi.fn(async () => {});
+    const emitter = new PushEventEmitter({
+      originTenantId: "indigo",
+      originDeviceId: "dev-1",
+      transport: { start: async () => {}, dispose: async () => {}, connected: false, publish },
+      flagProvider: new StaticFlagProvider([]), // indigo NOT enabled
+    });
+    expect(emitter.enabled).toBe(false);
+    await emitter.emitForBatch(batchFor(REL));
+    expect(publish).not.toHaveBeenCalled();
+    // attach returns a callable no-op when dormant.
+    const fakeWatcher = { onChange: vi.fn() } as any;
+    const off = emitter.attach(fakeWatcher);
+    expect(fakeWatcher.onChange).not.toHaveBeenCalled();
+    expect(() => off()).not.toThrow();
+  });
+
+  it("transport publish failure is caught + surfaced, never throws (cadence safety net)", async () => {
+    const onError = vi.fn();
+    const emitter = new PushEventEmitter({
+      originTenantId: "indigo",
+      originDeviceId: "dev-1",
+      transport: {
+        start: async () => {},
+        dispose: async () => {},
+        connected: true,
+        publish: async () => {
+          throw new Error("network down");
+        },
+      },
+      flagProvider: new StaticFlagProvider(["indigo"]),
+      onError,
+    });
+    // Must not reject — the daemon stays alive.
+    await expect(emitter.emitForBatch(batchFor(REL))).resolves.toBeUndefined();
+    expect(onError).toHaveBeenCalledTimes(1);
+    expect(onError.mock.calls[0][0]).toBeInstanceOf(Error);
+    expect(onError.mock.calls[0][1]).toMatchObject({ relativePath: REL });
+  });
+
+  it("a missing file (hash/stat race) is surfaced, other paths still ship", async () => {
+    const published: PushEvent[] = [];
+    const onError = vi.fn();
+    const emitter = new PushEventEmitter({
+      originTenantId: "indigo",
+      originDeviceId: "dev-1",
+      transport: { start: async () => {}, dispose: async () => {}, connected: true, publish: async (e) => { published.push(e); } },
+      flagProvider: new StaticFlagProvider(["indigo"]),
+      onError,
+    });
+    // REL exists; "ghost.md" does not.
+    await emitter.emitForBatch(batchFor(REL, "ghost.md"));
+    expect(published.map((e) => e.relativePath)).toEqual([REL]);
+    expect(onError).toHaveBeenCalledTimes(1);
+    expect(onError.mock.calls[0][1]).toMatchObject({ relativePath: "ghost.md" });
+  });
+
+  it("end-to-end: emit → HttpPushTransport POST with a valid schema (mocked fetch)", async () => {
+    const { fetch, calls } = makeFetch({ ok: true, status: 200 });
+    const transport = new HttpPushTransport({
+      apiUrl: "https://api.example.com",
+      authToken: "tok",
+      fetchImpl: fetch,
+    });
+    const emitter = new PushEventEmitter({
+      originTenantId: "indigo",
+      originDeviceId: "dev-1",
+      transport,
+      flagProvider: new StaticFlagProvider(["indigo"]),
+    });
+    await transport.start();
+    await emitter.emitForBatch(batchFor(REL));
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0].url).toBe("https://api.example.com/sync/push");
+    const posted = decodePushEvent((calls[0].init as any).body);
+    expect(posted.relativePath).toBe(REL);
+    expect(posted.originTenantId).toBe("indigo");
+  });
+});