castle-web-cli 0.4.244 → 0.4.245

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.
@@ -45,7 +45,9 @@ test('newest session fences the old writer without touching legacy rows; loss is
45
45
  // Once every visit has left, a visit back claims afresh at once.
46
46
  for (const id of ['p1', 'p2', 'new-tab']) a.lease.leave(id);
47
47
  a.lease.join('p2', '101');
48
- await deck.set({ 'band:101': 3 });
48
+ // A view stays bound to the claim it was made under.
49
+ await assert.rejects(deck.set({ 'band:101': 9 }), lost);
50
+ await a.api.deck('101').set({ 'band:101': 3 });
49
51
  assert.equal(a.calls.claim.length, 2);
50
52
  assert.equal(a.api.lost('101'), false);
51
53
  await assert.rejects(b.api.fence('101'), lost);
@@ -56,6 +58,7 @@ test('disabled and older hosts return raw stores by identity', async () => {
56
58
  const lease = create({ storage }, opted);
57
59
  assert.equal(lease.api.enabled, false);
58
60
  assert.equal(lease.api.deck('101'), storage.deck);
61
+ assert.equal(await lease.api.holds(storage.deck), true);
59
62
  lease.join('p1', '101');
60
63
  lease.sync([['p2', '101']], ['p1'], () => assert.fail('disabled leases never forget visits'));
61
64
  await lease.api.fence('101');
@@ -279,3 +282,384 @@ test('a fresh connection beside a connected lost visit preserves the stale accou
279
282
  assert.equal(a.api.lost('101'), true);
280
283
  await b.api.fence('101');
281
284
  });
285
+
286
+ test('a lone visit back within the keep revalidates: kept claim reused, a stolen one reclaimed silently', async t => {
287
+ t.mock.timers.enable({ apis: ['setTimeout'] });
288
+ const { instance, rows } = setup(t), a = instance('a'), b = instance('b');
289
+ const notices = [];
290
+ a.api.onLost(user => notices.push(user));
291
+ // Nobody else claimed: the visit back keeps the claim and its end saves land.
292
+ a.lease.join('p1', '101'); await a.api.ready('101');
293
+ const first = a.api.deck('101');
294
+ assert.equal(await a.api.holds(b.api.deck('101')), true, 'another lease’s views are unrecognized');
295
+ a.lease.leave('p1');
296
+ a.lease.join('p2', '101');
297
+ assert.equal(await a.api.holds(first), true);
298
+ await first.set({ progress: 1 });
299
+ assert.equal(a.calls.claim.length, 1);
300
+ assert.equal(a.api.deck('101'), first, 'same claim, same view');
301
+ // Town B takes the account; the player closes B and comes back here inside 60 s.
302
+ a.lease.leave('p2');
303
+ b.lease.join('p9', '101'); await b.api.deck('101').set({ progress: 2 });
304
+ b.lease.leave('p9');
305
+ t.mock.timers.tick(KEEP_MS - 1);
306
+ a.lease.join('p3', '101');
307
+ const returned = a.api.deck('101');
308
+ assert.equal(await a.api.holds(first), false);
309
+ assert.equal(await a.api.holds(returned), true);
310
+ const loaded = await a.api.deck('101').get(['progress']);
311
+ assert.deepEqual(loaded, { progress: 2 });
312
+ assert.equal(a.calls.claim.length, 2, 'reclaimed on arrival');
313
+ assert.equal(a.api.lost('101'), false);
314
+ // The old visit's late write cannot land under the new claim.
315
+ await assert.rejects(first.set({ progress: 1 }), lost);
316
+ await a.api.deck('101').set({ progress: 3 });
317
+ assert.equal(rows.get('deck:progress'), 3);
318
+ assert.deepEqual(notices, []);
319
+ assert.equal(a.api.lost('101'), false);
320
+ await assert.rejects(b.api.fence('101'), lost);
321
+ });
322
+
323
+ test('a fresh connection replaces a held visit of a claimed account and revalidates', async t => {
324
+ const { instance, rows } = setup(t), a = instance('a'), b = instance('b');
325
+ a.lease.sync([['p1', '101']]);
326
+ await a.api.deck('101').set({ progress: 1 });
327
+ // The socket drops; resumePose retention holds p1. The player opens B, then returns.
328
+ a.lease.sync([], ['p1']);
329
+ b.lease.join('p9', '101'); await b.api.deck('101').set({ progress: 2 });
330
+ b.lease.shutdown();
331
+ const forgotten = [];
332
+ a.lease.sync([['fresh', '101']], ['p1'], id => {
333
+ forgotten.push(id);
334
+ // The held visit's leave saves under its own, superseded claim.
335
+ void a.api.deck('101').set({ progress: 1 }).catch(() => {});
336
+ });
337
+ assert.deepEqual(forgotten, ['p1']);
338
+ assert.deepEqual(await a.api.deck('101').get(['progress']), { progress: 2 });
339
+ await a.api.deck('101').set({ progress: 3 });
340
+ assert.equal(rows.get('deck:progress'), 3);
341
+ assert.equal(a.calls.claim.length, 2);
342
+ assert.equal(a.api.lost('101'), false);
343
+ });
344
+
345
+ test('revalidation retries a rate-limited check, hides a late old-visit loss, and arrival views follow the new claim', async t => {
346
+ t.mock.timers.enable({ apis: ['setTimeout'] });
347
+ const { instance, rows } = setup(t), a = instance('a'), b = instance('b');
348
+ const notices = [];
349
+ a.api.onLost(user => notices.push(user));
350
+ a.lease.join('p1', '101'); await a.api.ready('101');
351
+ const old = a.api.deck('101');
352
+ // The old visit's write is past its queue when the player leaves for B.
353
+ const send = a.storage.transaction, hold = deferred();
354
+ let checks = 0;
355
+ a.storage.transaction = async input => {
356
+ checks++;
357
+ if (checks === 1) { await hold.promise; return send(input); }
358
+ if (checks === 2) throw Object.assign(Error('busy'), { code: 'CAULDRON_STORAGE_RATE_LIMITED', retryable: true, committed: false });
359
+ return send(input);
360
+ };
361
+ const late = old.set({ progress: 1 });
362
+ a.lease.leave('p1');
363
+ b.lease.join('p9', '101'); await b.api.deck('101').set({ progress: 2 }); b.lease.leave('p9');
364
+ a.lease.join('p2', '101');
365
+ // The arrival takes its view while the claim is being revalidated.
366
+ const arrival = a.api.deck('101');
367
+ assert.notEqual(arrival, old);
368
+ const write = arrival.set({ progress: 3 });
369
+ hold.resolve();
370
+ await assert.rejects(late, lost);
371
+ assert.equal(a.api.lost('101'), false, 'no notice while revalidating');
372
+ for (let i = 0; i < 6; i++) await new Promise(r => setImmediate(r));
373
+ t.mock.timers.tick(1000);
374
+ await a.api.ready('101');
375
+ await write;
376
+ assert.equal(rows.get('deck:progress'), 3);
377
+ assert.equal(a.calls.claim.length, 2, 'a rate-limited check retried, found the claim taken and reclaimed');
378
+ assert.equal(a.api.lost('101'), false);
379
+ assert.deepEqual(notices, []);
380
+ await assert.rejects(old.set({ progress: 1 }), lost);
381
+ });
382
+
383
+ test('a view made during one revalidation never follows a later visit\'s reclaim', async t => {
384
+ const { instance, rows } = setup(t), a = instance('a'), b = instance('b');
385
+ a.lease.join('p1', '101'); await a.api.ready('101');
386
+ a.lease.leave('p1');
387
+ // Visit B comes back; nobody else claimed, so its round keeps the claim.
388
+ a.lease.join('p2', '101');
389
+ const viewB = a.api.deck('101');
390
+ await a.api.ready('101');
391
+ await viewB.set({ progress: 1 });
392
+ // B goes, another instance takes the account, visit C comes back and reclaims.
393
+ a.lease.leave('p2');
394
+ b.lease.join('p9', '101'); await b.api.deck('101').set({ progress: 2 }); b.lease.leave('p9');
395
+ a.lease.join('p3', '101');
396
+ await a.api.ready('101');
397
+ assert.equal(a.calls.claim.length, 2);
398
+ await assert.rejects(viewB.set({ progress: 1 }), lost);
399
+ assert.equal(rows.get('deck:progress'), 2);
400
+ await a.api.deck('101').set({ progress: 3 });
401
+ assert.equal(rows.get('deck:progress'), 3);
402
+ });
403
+
404
+ test('a second lone return while a revalidation is pending checks again after a takeover', async t => {
405
+ const { instance, rows } = setup(t), a = instance('a'), b = instance('b');
406
+ const notices = [];
407
+ a.api.onLost(user => notices.push(user));
408
+ a.lease.join('p1', '101'); await a.api.ready('101');
409
+ a.lease.leave('p1');
410
+ // The first return's check succeeds at the broker, but its reply is late.
411
+ const send = a.storage.transaction, reply = deferred();
412
+ let checks = 0;
413
+ a.storage.transaction = async input => {
414
+ const result = send(input);
415
+ if (++checks === 1) await reply.promise;
416
+ return result;
417
+ };
418
+ a.lease.join('p2', '101');
419
+ await new Promise(r => setImmediate(r));
420
+ assert.equal(checks, 1, 'the first round is in flight');
421
+ // That visit leaves; another instance takes the account; the player comes back.
422
+ a.lease.leave('p2');
423
+ b.lease.join('p9', '101'); await b.api.deck('101').set({ progress: 2 }); b.lease.leave('p9');
424
+ a.lease.join('p3', '101');
425
+ const arrival = a.api.deck('101');
426
+ reply.resolve();
427
+ await a.api.ready('101');
428
+ assert.deepEqual(await arrival.get(['progress']), { progress: 2 });
429
+ await arrival.set({ progress: 3 });
430
+ assert.equal(rows.get('deck:progress'), 3);
431
+ assert.equal(a.calls.claim.length, 2, 'the second return reclaimed after the stale success');
432
+ assert.equal(a.api.lost('101'), false);
433
+ assert.deepEqual(notices, []);
434
+ });
435
+
436
+ test('an older pending round defers to a newer arrival already checking the replacement claim', async t => {
437
+ const { instance, rows } = setup(t), a = instance('a'), b = instance('b');
438
+ const notices = [];
439
+ a.api.onLost(user => notices.push(user));
440
+ a.lease.join('p1', '101'); await a.api.ready('101');
441
+ a.lease.leave('p1');
442
+ // Return 1's check waits before it is sent.
443
+ const send = a.storage.transaction, gate = deferred();
444
+ let checks = 0, refuse = false;
445
+ a.storage.transaction = async input => {
446
+ if (++checks === 1) await gate.promise;
447
+ // Another instance took the replacement claim just after it settled.
448
+ if (refuse && input.changes.length === 0) { refuse = false; throw Object.assign(Error('taken'), { code: 'CAULDRON_STORAGE_WRITER_LOST' }); }
449
+ return send(input);
450
+ };
451
+ a.lease.join('p2', '101');
452
+ await new Promise(r => setImmediate(r));
453
+ a.lease.leave('p2');
454
+ b.lease.join('p9', '101'); await b.api.deck('101').set({ progress: 2 }); b.lease.leave('p9');
455
+ // Return 2 queues behind return 1, and goes.
456
+ a.lease.join('p3', '101');
457
+ const departed = a.api.deck('101');
458
+ // Return 1 finds the claim taken and, with return 2 still here, reclaims;
459
+ // that claim is slow to settle.
460
+ const claim = a.storage.claim, held = deferred();
461
+ let claims = 0;
462
+ a.storage.claim = async input => { if (++claims === 1) await held.promise; return claim(input); };
463
+ gate.resolve();
464
+ for (let i = 0; i < 6; i++) await new Promise(r => setImmediate(r));
465
+ assert.equal(claims, 1, 'return 1 is reclaiming');
466
+ a.lease.leave('p3');
467
+ // Return 3 arrives on the replacement claim while it settles.
468
+ a.lease.join('p4', '101');
469
+ const newest = a.api.deck('101');
470
+ const before = checks;
471
+ refuse = true;
472
+ held.resolve();
473
+ await newest.set({ progress: 4 });
474
+ assert.equal(checks - before, 2, 'one round check of the replacement claim (return 3\'s), then the write\'s fence');
475
+ assert.equal(rows.get('deck:progress'), 4, 'the newest arrival saves under the claim its round reopened');
476
+ assert.equal(claims, 2, 'return 3 reclaimed; return 2 only waited for it');
477
+ // Return 2 had gone: its view never writes under return 3's claim.
478
+ await assert.rejects(departed.set({ progress: 3 }), lost);
479
+ assert.equal(rows.get('deck:progress'), 4);
480
+ assert.equal(a.api.lost('101'), false);
481
+ assert.deepEqual(notices, []);
482
+ });
483
+
484
+ test('a lone visit back whose check is refused claims afresh instead of losing its first save', async t => {
485
+ t.mock.timers.enable({ apis: ['setTimeout'] });
486
+ for (const failure of ['refused', 'timed out']) {
487
+ const { instance, rows } = setup(t), a = instance('a'), b = instance('b');
488
+ const notices = [];
489
+ a.api.onLost(user => notices.push(user));
490
+ a.lease.join('p1', '101'); await a.api.ready('101');
491
+ const old = a.api.deck('101');
492
+ a.lease.leave('p1');
493
+ // Town B takes the account; the player closes B and comes back alone inside 60 s.
494
+ b.lease.join('p9', '101'); await b.api.deck('101').set({ progress: 2 }); b.lease.leave('p9');
495
+ // A's return check fails without saying whether the claim is still A's;
496
+ // storage recovers before the first save.
497
+ const send = a.storage.transaction;
498
+ let failing = true;
499
+ a.storage.transaction = async input => {
500
+ if (failing && input.changes.length === 0) {
501
+ if (failure === 'refused') { failing = false; throw Object.assign(Error('bad'), { code: 'CAULDRON_STORAGE_INTERNAL', retryable: false, committed: false }); }
502
+ throw Object.assign(Error('busy'), { code: 'CAULDRON_STORAGE_RATE_LIMITED', retryable: true, committed: false });
503
+ }
504
+ return send(input);
505
+ };
506
+ a.lease.join('p2', '101');
507
+ const arrival = a.api.deck('101');
508
+ if (failure === 'timed out') {
509
+ for (let i = 0; i < 40 && a.calls.claim.length < 2; i++) {
510
+ for (let j = 0; j < 4; j++) await new Promise(r => setImmediate(r));
511
+ t.mock.timers.tick(8000);
512
+ }
513
+ failing = false;
514
+ }
515
+ await a.api.ready('101');
516
+ assert.equal(a.calls.claim.length, 2, `${failure}: the arrival claimed afresh`);
517
+ assert.equal(await a.api.holds(old), false, `${failure}: the departed visit's view no longer holds`);
518
+ assert.equal(await a.api.holds(arrival), true);
519
+ assert.deepEqual(await arrival.get(['progress']), { progress: 2 }, `${failure}: the arrival loads B's save`);
520
+ await arrival.set({ progress: 3 });
521
+ assert.equal(rows.get('deck:progress'), 3, `${failure}: the first save lands`);
522
+ await a.api.deck('101').set({ progress: 4 });
523
+ assert.equal(rows.get('deck:progress'), 4, `${failure}: later saves land`);
524
+ await assert.rejects(old.set({ progress: 1 }), lost);
525
+ assert.equal(a.api.lost('101'), false);
526
+ assert.deepEqual(notices, []);
527
+ a.lease.shutdown(); b.lease.shutdown();
528
+ }
529
+ });
530
+
531
+ test('a return that left again never reclaims from the instance the player is on now', async t => {
532
+ for (const answer of ['refused', 'taken']) {
533
+ const { instance, rows } = setup(t), a = instance('a'), b = instance('b');
534
+ const notices = [];
535
+ a.api.onLost(user => notices.push(user));
536
+ a.lease.join('p1', '101'); await a.api.ready('101');
537
+ a.lease.leave('p1');
538
+ // The return's check is slow; the player leaves again and opens B.
539
+ const send = a.storage.transaction, gate = deferred();
540
+ let first = true;
541
+ a.storage.transaction = async input => {
542
+ if (first && input.changes.length === 0) {
543
+ first = false; await gate.promise;
544
+ if (answer === 'refused') throw Object.assign(Error('bad'), { code: 'CAULDRON_STORAGE_INTERNAL', retryable: false, committed: false });
545
+ }
546
+ return send(input);
547
+ };
548
+ a.lease.join('p2', '101');
549
+ await new Promise(r => setImmediate(r));
550
+ a.lease.leave('p2');
551
+ b.lease.join('p9', '101'); await b.api.deck('101').set({ progress: 2 });
552
+ gate.resolve();
553
+ for (let i = 0; i < 8; i++) await new Promise(r => setImmediate(r));
554
+ await a.api.ready('101');
555
+ assert.equal(a.calls.claim.length, 1, `${answer}: A did not claim again`);
556
+ await b.api.deck('101').set({ progress: 3 });
557
+ assert.equal(rows.get('deck:progress'), 3, `${answer}: B keeps saving`);
558
+ assert.equal(b.api.lost('101'), false);
559
+ assert.deepEqual(notices, []);
560
+ a.lease.shutdown(); b.lease.shutdown();
561
+ }
562
+ });
563
+
564
+ test('an unanswered return check lets the previous visit\'s queued end save land before reclaiming', async t => {
565
+ const { instance, rows } = setup(t), a = instance('a');
566
+ const notices = [];
567
+ a.api.onLost(user => notices.push(user));
568
+ a.lease.join('p1', '101'); await a.api.ready('101');
569
+ const old = a.api.deck('101');
570
+ a.lease.leave('p1');
571
+ // Nobody else claims. The return's check is refused once; storage recovers.
572
+ const send = a.storage.transaction;
573
+ let first = true;
574
+ a.storage.transaction = async input => {
575
+ if (first && input.changes.length === 0) { first = false; throw Object.assign(Error('bad'), { code: 'CAULDRON_STORAGE_INTERNAL', retryable: false, committed: false }); }
576
+ return send(input);
577
+ };
578
+ a.lease.join('p2', '101');
579
+ // The leave hook's end save is queued under the old claim as the return starts.
580
+ const end = old.set({ progress: 1 });
581
+ const arrival = a.api.deck('101');
582
+ await end;
583
+ assert.equal(rows.get('deck:progress'), 1, 'the end save landed under its own claim');
584
+ await a.api.ready('101');
585
+ assert.equal(a.calls.claim.length, 2, 'then the arrival claimed afresh');
586
+ assert.deepEqual(await arrival.get(['progress']), { progress: 1 });
587
+ await arrival.set({ progress: 2 });
588
+ assert.equal(rows.get('deck:progress'), 2);
589
+ assert.equal(a.api.lost('101'), false);
590
+ assert.deepEqual(notices, []);
591
+ });
592
+
593
+ test('a return held after its connection went never reclaims from the instance the player moved to', async t => {
594
+ const { instance, rows } = setup(t), a = instance('a'), b = instance('b');
595
+ a.lease.sync([['p1', '101']]); await a.api.ready('101');
596
+ a.lease.sync([]);
597
+ const send = a.storage.transaction, gate = deferred();
598
+ let first = true;
599
+ a.storage.transaction = async input => {
600
+ if (first && input.changes.length === 0) { first = false; await gate.promise; throw Object.assign(Error('bad'), { code: 'CAULDRON_STORAGE_INTERNAL', retryable: false, committed: false }); }
601
+ return send(input);
602
+ };
603
+ a.lease.sync([['p2', '101']]);
604
+ await new Promise(r => setImmediate(r));
605
+ // The socket drops; the place still holds p2 (resumePose). The player opens B.
606
+ a.lease.sync([], ['p2']);
607
+ b.lease.join('p9', '101'); await b.api.deck('101').set({ progress: 2 });
608
+ gate.resolve();
609
+ for (let i = 0; i < 8; i++) await new Promise(r => setImmediate(r));
610
+ await a.api.ready('101');
611
+ assert.equal(a.calls.claim.length, 1, 'A did not claim again');
612
+ await b.api.deck('101').set({ progress: 3 });
613
+ assert.equal(rows.get('deck:progress'), 3);
614
+ assert.equal(b.api.lost('101'), false);
615
+ });
616
+
617
+ test('a claim still retrying stops once every visit of the account has gone', async t => {
618
+ t.mock.timers.enable({ apis: ['setTimeout'] });
619
+ const { instance, rows } = setup(t), a = instance('a'), b = instance('b');
620
+ const claim = a.storage.claim;
621
+ let tries = 0;
622
+ a.storage.claim = async input => {
623
+ if (++tries === 1) throw Object.assign(Error('busy'), { code: 'CAULDRON_STORAGE_RATE_LIMITED', retryable: true, committed: false });
624
+ return claim(input);
625
+ };
626
+ a.lease.join('p1', '101');
627
+ await new Promise(r => setImmediate(r));
628
+ a.lease.leave('p1');
629
+ b.lease.join('p9', '101'); await b.api.deck('101').set({ progress: 2 });
630
+ for (let i = 0; i < 4; i++) { t.mock.timers.tick(8000); await new Promise(r => setImmediate(r)); }
631
+ await a.api.ready('101');
632
+ assert.equal(tries, 1, 'no retry after the visit left');
633
+ await b.api.deck('101').set({ progress: 3 });
634
+ assert.equal(rows.get('deck:progress'), 3);
635
+ assert.equal(b.api.lost('101'), false);
636
+ });
637
+
638
+ test('an unanswered return check drains end saves queued while earlier ones were in flight', async t => {
639
+ const { instance, rows } = setup(t), a = instance('a');
640
+ a.lease.join('p1', '101'); await a.api.ready('101');
641
+ const old = a.api.deck('101');
642
+ a.lease.leave('p1');
643
+ const send = a.storage.transaction;
644
+ let first = true;
645
+ a.storage.transaction = async input => {
646
+ if (first && input.changes.length === 0) { first = false; throw Object.assign(Error('bad'), { code: 'CAULDRON_STORAGE_INTERNAL', retryable: false, committed: false }); }
647
+ return send(input);
648
+ };
649
+ // The first end save is slow to write; a second is queued while it is in flight.
650
+ const set = a.storage.deck.set, slow = deferred();
651
+ let writes = 0;
652
+ a.storage.deck.set = async values => { if (++writes === 1) await slow.promise; return set(values); };
653
+ a.lease.join('p2', '101');
654
+ const one = old.set({ end: 1 });
655
+ for (let i = 0; i < 6; i++) await new Promise(r => setImmediate(r));
656
+ assert.equal(writes, 1, 'the first end save is in flight');
657
+ const two = old.set({ end: 2 });
658
+ slow.resolve();
659
+ await one; await two;
660
+ assert.equal(rows.get('deck:end'), 2, 'both end saves landed under their own claim');
661
+ await a.api.ready('101');
662
+ assert.equal(a.calls.claim.length, 2);
663
+ await a.api.deck('101').set({ progress: 5 });
664
+ assert.equal(rows.get('deck:progress'), 5);
665
+ });
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "castle-web-cli",
3
- "version": "0.4.244",
3
+ "version": "0.4.245",
4
4
  "repository": {
5
5
  "type": "git",
6
6
  "url": "git+https://github.com/castle-xyz/castle-experimental-web.git"
@@ -12,7 +12,7 @@
12
12
  "scripts": {
13
13
  "build": "rm -rf dist && tsc && chmod +x dist/index.js && vite build && vite build -c vite.cover-bridge.config.ts && cp -R src/castle-host dist/castle-host && chmod -R u+w kits 2>/dev/null; rm -rf kits && cp -R ../kits kits && chmod -R u+w kits && rm -rf kits/*/imports && node ../scripts/vendor-three.mjs",
14
14
  "dev": "tsc --watch",
15
- "check": "node ../scripts/sync-shared.mjs --check && node ../scripts/tests/icon-registry.mjs && node ../scripts/tests/sandbox-graphql-fields.mjs && node ../scripts/tests/kit-package-json.mjs && node ../scripts/tests/kit-catalog.mjs && node ../scripts/tests/import-order.mjs && node ../scripts/tests/import-deck-ref.mjs && node ../scripts/tests/hub-server-config.mjs && node ../scripts/tests/save-failure-reason.mjs && node ../scripts/tests/flow-draft-status.mjs && node ../scripts/tests/router-fences.mjs && node ../scripts/tests/held-tasks.mjs && node ../scripts/tests/held-task-prompts.mjs && node ../scripts/tests/router-stops.mjs && node ../scripts/tests/task-steer.mjs && node ../scripts/tests/task-steer-store.mjs && node ../scripts/tests/task-steer-line.mjs && node ../scripts/tests/router-task-endings.mjs && node ../scripts/tests/router-task-report.mjs && node ../scripts/tests/task-resume.mjs && node ../scripts/tests/task-model-request.mjs && node ../scripts/tests/plan-answered-questions.mjs && node ../scripts/tests/plan-no-standing-nudge.mjs && node ../scripts/tests/sdk-readme-limits.mjs && node ../scripts/tests/task-account.mjs && node ../scripts/tests/effort-support.mjs && node ../scripts/tests/cli-login-pkce.mjs && node ../scripts/tests/publish-timeout.mjs && node ../scripts/tests/bundle-latin1.mjs && eslint . && jscpd && tsc --noEmit && tsc --noEmit -p src/shell/tsconfig.json"
15
+ "check": "node ../scripts/sync-shared.mjs --check && node ../scripts/tests/icon-registry.mjs && node ../scripts/tests/sandbox-graphql-fields.mjs && node ../scripts/tests/kit-package-json.mjs && node ../scripts/tests/kit-catalog.mjs && node ../scripts/tests/import-order.mjs && node ../scripts/tests/import-deck-ref.mjs && node ../scripts/tests/restore-pinned-import.mjs && node ../scripts/tests/hub-server-config.mjs && node ../scripts/tests/save-failure-reason.mjs && node ../scripts/tests/flow-draft-status.mjs && node ../scripts/tests/router-fences.mjs && node ../scripts/tests/held-tasks.mjs && node ../scripts/tests/held-task-prompts.mjs && node ../scripts/tests/router-stops.mjs && node ../scripts/tests/task-steer.mjs && node ../scripts/tests/task-steer-store.mjs && node ../scripts/tests/task-steer-line.mjs && node ../scripts/tests/router-task-endings.mjs && node ../scripts/tests/router-task-report.mjs && node ../scripts/tests/task-resume.mjs && node ../scripts/tests/task-model-request.mjs && node ../scripts/tests/plan-answered-questions.mjs && node ../scripts/tests/plan-no-standing-nudge.mjs && node ../scripts/tests/sdk-readme-limits.mjs && node ../scripts/tests/task-account.mjs && node ../scripts/tests/effort-support.mjs && node ../scripts/tests/cli-login-pkce.mjs && node ../scripts/tests/publish-timeout.mjs && node ../scripts/tests/bundle-latin1.mjs && eslint . && jscpd && tsc --noEmit && tsc --noEmit -p src/shell/tsconfig.json"
16
16
  },
17
17
  "jscpd": {
18
18
  "path": [