@indigoai-us/hq-cloud 6.18.8 → 6.18.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -20,7 +20,7 @@ import { PresignObjectIO, S3SdkObjectIO } from "../object-io.js";
20
20
  import { BandwidthGovernor, setBandwidthGovernorForTesting, } from "../bandwidth.js";
21
21
  import { POST_SYNC_FLAG_KEYS, } from "./sync-runner-post-sync-flags.js";
22
22
  import { FakeClock, TreeWatcher, } from "../watcher.js";
23
- import { adaptivePollMs, advanceMonotonicDeadline, DEFAULT_EVENT_BATCH_LIMIT, DEFAULT_FAST_LANE_MAX_BYTES, DEFAULT_FAST_LANE_MAX_FILE_BYTES, DEFAULT_FAST_LANE_MAX_FILES, DEFAULT_FULL_RECONCILE_MS, EVENT_BATCH_LIMIT_ENV, FAST_LANE_MAX_BYTES_ENV, FAST_LANE_MAX_FILES_ENV, FULL_RECONCILE_MS_ENV, isFastLocalBatch, isFastReceiverBatch, partitionLocalBatch, journalEntriesForWatcherDelete, resolveEventBatchLimit, resolveFullReconcileMs, resolveWatchPollMs, CHORE_STARVATION_CAP_MS, CooperativePassScheduler, REALTIME_ADMISSION_DEADLINE_MS, REALTIME_DRAIN_BURST_MS, REALTIME_WORKER_OCCUPANCY_CAP, RealtimeAdmissionTimeoutError, setRealtimeAdmissionDeadlineMsForTesting, setRealtimeDrainBurstMsForTesting, normalizeCoordinatorPaths, shouldQuarantineWatcherDeleteIntents, shouldUseAreaStorage, WATCHER_REDISCOVERY_RETRY_MS, WATCHER_REDISCOVERY_RETRY_MAX_MS, } from "./sync-runner-watch-loop.js";
23
+ import { adaptivePollMs, advanceMonotonicDeadline, DEFAULT_EVENT_BATCH_LIMIT, DEFAULT_FAST_LANE_MAX_BYTES, DEFAULT_FAST_LANE_MAX_FILE_BYTES, DEFAULT_FAST_LANE_MAX_FILES, DEFAULT_FULL_RECONCILE_MS, EVENT_BATCH_LIMIT_ENV, FAST_LANE_MAX_BYTES_ENV, FAST_LANE_MAX_FILES_ENV, FULL_RECONCILE_MS_ENV, isFastLocalBatch, isFastReceiverBatch, partitionLocalBatch, journalEntriesForWatcherDelete, resolveEventBatchLimit, resolveFullReconcileMs, resolveWatchPollMs, CHORE_STARVATION_CAP_MS, CooperativePassScheduler, REALTIME_ADMISSION_DEADLINE_MS, REALTIME_DRAIN_BURST_MS, REALTIME_WORKER_OCCUPANCY_CAP, RealtimeAdmissionTimeoutError, setRealtimeAdmissionDeadlineMsForTesting, setRealtimeDrainBurstMsForTesting, normalizeCoordinatorPaths, shouldQuarantineWatcherDeleteIntents, shouldUseAreaStorage, WATCHER_REDISCOVERY_RETRY_MS, WATCHER_REDISCOVERY_RETRY_MAX_MS, EVENT_SYNC_STARTUP_SHUTDOWN_WAIT_MS, } from "./sync-runner-watch-loop.js";
24
24
  import { FullPassCapController, resetFullPassCapLogForTest, } from "../sync/full-pass-caps.js";
25
25
  import { AreaLedgerMigration, JournalStore, openJournalStateStoreForMigration, PERSONAL_VAULT_JOURNAL_SLUG, readJournal, readJournalScoped, writeJournal, } from "../journal.js";
26
26
  import { AreaLedger } from "../sync/area-ledger.js";
@@ -13500,6 +13500,296 @@ describe("runRunnerWithLoop — Phase 3 event-sync wiring (US-017/018/019)", ()
13500
13500
  await loop;
13501
13501
  expect(dispose).toHaveBeenCalled();
13502
13502
  });
13503
+ it("waits for event-sync disposal before completing shutdown", async () => {
13504
+ let releaseDisposal;
13505
+ const disposal = new Promise((resolve) => {
13506
+ releaseDisposal = resolve;
13507
+ });
13508
+ const dispose = vi.fn(() => disposal);
13509
+ const startEventSync = vi.fn().mockResolvedValue({
13510
+ publishBatch: vi.fn(),
13511
+ receiver: { start: async () => { }, dispose: async () => { }, connected: true },
13512
+ ownDeviceId: "dev-test",
13513
+ dispose,
13514
+ });
13515
+ const { loop, shutdown } = runLoop({
13516
+ claims: EMAIL_CLAIMS,
13517
+ startEventSync,
13518
+ });
13519
+ await microtasks();
13520
+ shutdown();
13521
+ await vi.waitFor(() => expect(dispose).toHaveBeenCalledOnce());
13522
+ let loopSettled = false;
13523
+ const loopDone = loop.then(() => {
13524
+ loopSettled = true;
13525
+ });
13526
+ try {
13527
+ await microtasks();
13528
+ expect(loopSettled).toBe(false);
13529
+ }
13530
+ finally {
13531
+ releaseDisposal();
13532
+ }
13533
+ await loopDone;
13534
+ });
13535
+ it("awaits event-sync disposal when startup finishes during shutdown", async () => {
13536
+ let resolveStart;
13537
+ const starting = new Promise((resolve) => {
13538
+ resolveStart = resolve;
13539
+ });
13540
+ let releaseDisposal;
13541
+ const disposal = new Promise((resolve) => {
13542
+ releaseDisposal = resolve;
13543
+ });
13544
+ const dispose = vi.fn(() => disposal);
13545
+ const handles = {
13546
+ publishBatch: vi.fn(),
13547
+ receiver: { start: async () => { }, dispose: async () => { }, connected: true },
13548
+ ownDeviceId: "dev-test",
13549
+ dispose,
13550
+ };
13551
+ const startEventSync = vi.fn(() => starting);
13552
+ const { loop, shutdown } = runLoop({
13553
+ claims: EMAIL_CLAIMS,
13554
+ startEventSync,
13555
+ });
13556
+ await microtasks();
13557
+ let loopSettled = false;
13558
+ const loopDone = loop.then(() => {
13559
+ loopSettled = true;
13560
+ });
13561
+ shutdown();
13562
+ try {
13563
+ await microtasks();
13564
+ expect(loopSettled).toBe(false);
13565
+ }
13566
+ finally {
13567
+ resolveStart(handles);
13568
+ await vi.waitFor(() => expect(dispose).toHaveBeenCalledOnce());
13569
+ releaseDisposal();
13570
+ }
13571
+ await loopDone;
13572
+ });
13573
+ it("bounds shutdown while event-sync startup is pending and disposes late handles", async () => {
13574
+ vi.useFakeTimers();
13575
+ const stderr = vi
13576
+ .spyOn(process.stderr, "write")
13577
+ .mockImplementation(() => true);
13578
+ let resolveStart;
13579
+ const starting = new Promise((resolve) => {
13580
+ resolveStart = resolve;
13581
+ });
13582
+ const dispose = vi.fn().mockResolvedValue(undefined);
13583
+ const handles = {
13584
+ publishBatch: vi.fn(),
13585
+ receiver: { start: async () => { }, dispose: async () => { }, connected: true },
13586
+ ownDeviceId: "dev-test",
13587
+ dispose,
13588
+ };
13589
+ const startEventSync = vi.fn(() => starting);
13590
+ const { loop, shutdown } = runLoop({
13591
+ claims: EMAIL_CLAIMS,
13592
+ startEventSync,
13593
+ });
13594
+ let shutdownCompleted = false;
13595
+ const loopDone = loop.then(() => {
13596
+ shutdownCompleted = true;
13597
+ });
13598
+ try {
13599
+ await microtasks();
13600
+ shutdown();
13601
+ await vi.advanceTimersByTimeAsync(EVENT_SYNC_STARTUP_SHUTDOWN_WAIT_MS);
13602
+ expect(shutdownCompleted).toBe(true);
13603
+ const abandonedLines = stderr.mock.calls
13604
+ .map(([chunk]) => String(chunk).trimEnd())
13605
+ .filter((line) => line === "event-sync startup still pending at shutdown; abandoning");
13606
+ expect(abandonedLines).toHaveLength(1);
13607
+ resolveStart(handles);
13608
+ await microtasks(20);
13609
+ expect(dispose).toHaveBeenCalledOnce();
13610
+ await loopDone;
13611
+ }
13612
+ finally {
13613
+ resolveStart(handles);
13614
+ await microtasks(20);
13615
+ stderr.mockRestore();
13616
+ vi.useRealTimers();
13617
+ await loopDone;
13618
+ }
13619
+ });
13620
+ it("disposes late event-sync handles before shutdown completes", async () => {
13621
+ vi.useFakeTimers();
13622
+ let resolveStart;
13623
+ const starting = new Promise((resolve) => {
13624
+ resolveStart = resolve;
13625
+ });
13626
+ let releaseDisposal;
13627
+ const disposal = new Promise((resolve) => {
13628
+ releaseDisposal = resolve;
13629
+ });
13630
+ const dispose = vi.fn(() => disposal);
13631
+ const handles = {
13632
+ publishBatch: vi.fn(),
13633
+ receiver: { start: async () => { }, dispose: async () => { }, connected: true },
13634
+ ownDeviceId: "dev-test",
13635
+ dispose,
13636
+ };
13637
+ const startEventSync = vi.fn(() => starting);
13638
+ const { loop, shutdown } = runLoop({
13639
+ claims: EMAIL_CLAIMS,
13640
+ startEventSync,
13641
+ });
13642
+ await microtasks();
13643
+ let shutdownSettled = false;
13644
+ const shutdownDone = loop.then(() => {
13645
+ shutdownSettled = true;
13646
+ });
13647
+ try {
13648
+ shutdown();
13649
+ await vi.advanceTimersByTimeAsync(EVENT_SYNC_STARTUP_SHUTDOWN_WAIT_MS - 1);
13650
+ resolveStart(handles);
13651
+ await microtasks(20);
13652
+ expect(dispose).toHaveBeenCalledTimes(1);
13653
+ expect(shutdownSettled).toBe(false);
13654
+ releaseDisposal();
13655
+ await shutdownDone;
13656
+ expect(shutdownSettled).toBe(true);
13657
+ expect(dispose).toHaveBeenCalledTimes(1);
13658
+ }
13659
+ finally {
13660
+ releaseDisposal();
13661
+ resolveStart(handles);
13662
+ await shutdownDone;
13663
+ vi.useRealTimers();
13664
+ }
13665
+ });
13666
+ it("logs event-sync disposal errors and still exits the loop", async () => {
13667
+ const stderr = vi
13668
+ .spyOn(process.stderr, "write")
13669
+ .mockImplementation(() => true);
13670
+ const dispose = vi
13671
+ .fn()
13672
+ .mockRejectedValue(new Error("dispose rejected"));
13673
+ const startEventSync = vi.fn().mockResolvedValue({
13674
+ publishBatch: vi.fn(),
13675
+ receiver: { start: async () => { }, dispose: async () => { }, connected: true },
13676
+ ownDeviceId: "dev-test",
13677
+ dispose,
13678
+ });
13679
+ const { loop, shutdown } = runLoop({
13680
+ claims: EMAIL_CLAIMS,
13681
+ startEventSync,
13682
+ });
13683
+ await microtasks();
13684
+ try {
13685
+ shutdown();
13686
+ await loop;
13687
+ expect(dispose).toHaveBeenCalledOnce();
13688
+ expect(stderr.mock.calls.map(([chunk]) => String(chunk))).toContain("event-sync live disposal failed during shutdown: dispose rejected\n");
13689
+ }
13690
+ finally {
13691
+ stderr.mockRestore();
13692
+ }
13693
+ });
13694
+ it("bounds live event-sync disposal at shutdown", async () => {
13695
+ vi.useFakeTimers();
13696
+ const stderr = vi
13697
+ .spyOn(process.stderr, "write")
13698
+ .mockImplementation(() => true);
13699
+ let releaseDisposal;
13700
+ const disposal = new Promise((resolve) => {
13701
+ releaseDisposal = resolve;
13702
+ });
13703
+ const dispose = vi.fn(() => disposal);
13704
+ const startEventSync = vi.fn().mockResolvedValue({
13705
+ publishBatch: vi.fn(),
13706
+ receiver: { start: async () => { }, dispose: async () => { }, connected: true },
13707
+ ownDeviceId: "dev-test",
13708
+ dispose,
13709
+ });
13710
+ const { loop, shutdown } = runLoop({
13711
+ claims: EMAIL_CLAIMS,
13712
+ startEventSync,
13713
+ });
13714
+ await microtasks();
13715
+ let loopSettled = false;
13716
+ const loopDone = loop.then(() => {
13717
+ loopSettled = true;
13718
+ });
13719
+ try {
13720
+ shutdown();
13721
+ await vi.advanceTimersByTimeAsync(EVENT_SYNC_STARTUP_SHUTDOWN_WAIT_MS - 1);
13722
+ expect(loopSettled).toBe(false);
13723
+ await vi.advanceTimersByTimeAsync(1);
13724
+ await microtasks(20);
13725
+ expect(loopSettled).toBe(true);
13726
+ expect(dispose).toHaveBeenCalledOnce();
13727
+ expect(stderr.mock.calls.map(([chunk]) => String(chunk))).toContain("event-sync live disposal still pending at shutdown; abandoning\n");
13728
+ await loopDone;
13729
+ }
13730
+ finally {
13731
+ releaseDisposal();
13732
+ await microtasks(20);
13733
+ await loopDone;
13734
+ stderr.mockRestore();
13735
+ vi.useRealTimers();
13736
+ }
13737
+ });
13738
+ it("bounds late event-sync disposal at the shutdown deadline", async () => {
13739
+ vi.useFakeTimers();
13740
+ const stderr = vi
13741
+ .spyOn(process.stderr, "write")
13742
+ .mockImplementation(() => true);
13743
+ let resolveStart;
13744
+ const starting = new Promise((resolve) => {
13745
+ resolveStart = resolve;
13746
+ });
13747
+ let releaseDisposal;
13748
+ const disposal = new Promise((resolve) => {
13749
+ releaseDisposal = resolve;
13750
+ });
13751
+ const dispose = vi.fn(() => disposal);
13752
+ const handles = {
13753
+ publishBatch: vi.fn(),
13754
+ receiver: { start: async () => { }, dispose: async () => { }, connected: true },
13755
+ ownDeviceId: "dev-test",
13756
+ dispose,
13757
+ };
13758
+ const startEventSync = vi.fn(() => starting);
13759
+ const { loop, shutdown } = runLoop({
13760
+ claims: EMAIL_CLAIMS,
13761
+ startEventSync,
13762
+ });
13763
+ await microtasks();
13764
+ let loopSettled = false;
13765
+ const loopDone = loop.then(() => {
13766
+ loopSettled = true;
13767
+ });
13768
+ try {
13769
+ shutdown();
13770
+ await vi.advanceTimersByTimeAsync(EVENT_SYNC_STARTUP_SHUTDOWN_WAIT_MS - 1);
13771
+ resolveStart(handles);
13772
+ await microtasks(20);
13773
+ expect(dispose).toHaveBeenCalledOnce();
13774
+ expect(loopSettled).toBe(false);
13775
+ await vi.advanceTimersByTimeAsync(1);
13776
+ await microtasks(20);
13777
+ expect(loopSettled).toBe(true);
13778
+ expect(stderr.mock.calls.map(([chunk]) => String(chunk))).toContain("event-sync late disposal still pending at shutdown; abandoning\n");
13779
+ await loopDone;
13780
+ }
13781
+ finally {
13782
+ resolveStart(handles);
13783
+ releaseDisposal();
13784
+ if (!loopSettled) {
13785
+ await vi.advanceTimersByTimeAsync(EVENT_SYNC_STARTUP_SHUTDOWN_WAIT_MS);
13786
+ }
13787
+ await microtasks(20);
13788
+ await loopDone;
13789
+ stderr.mockRestore();
13790
+ vi.useRealTimers();
13791
+ }
13792
+ });
13503
13793
  it("env override HQ_SYNC_EVENT_SYNC=0 keeps the seam dormant for the enrolled account", async () => {
13504
13794
  const prev = process.env.HQ_SYNC_EVENT_SYNC;
13505
13795
  process.env.HQ_SYNC_EVENT_SYNC = "0";