@checkstack/maintenance-backend 1.2.0 → 1.3.1

package/CHANGELOG.md

@@ -1,5 +1,98 @@
 # @checkstack/maintenance-backend
 
+## 1.3.1
+
+### Patch Changes
+
+- Updated dependencies [a57f7db]
+  - @checkstack/backend-api@0.20.0
+  - @checkstack/automation-backend@0.4.0
+  - @checkstack/cache-api@0.3.8
+  - @checkstack/catalog-backend@1.3.1
+  - @checkstack/command-backend@0.1.33
+  - @checkstack/cache-utils@0.2.13
+
+## 1.3.0
+
+### Minor Changes
+
+- 270ef29: Add the health-state provider data contract (automation sensing layer, Wave 2 Phase 13).
+
+  - New `health_check_state_transitions` table records every aggregate health-status transition for a system (all statuses, not just unhealthy), giving a reliable "in current status since" timestamp. Written wherever an aggregate transition is detected. Pruned with raw-run retention, but the single most-recent row per system is always kept so an active streak never blanks.
+  - New service-typed RPCs on `HealthCheckApi`: `getHealthState({ systemId, configurationId? })` returns `{ status, inStatusSince, inStatusForMs, latencyMs?, avgLatencyMs?, p95LatencyMs?, successRate?, lastRunAt?, inMaintenance, evaluatedAt }`, and `getBulkHealthState({ systemIds })` (POST) resolves many systems against one shared timestamp.
+  - New service-typed RPC on `MaintenanceApi`: `hasActiveMaintenance({ systemId })` reports whether a system is in an active maintenance window regardless of notification-suppression (suppression-agnostic), folded into `getHealthState` as `inMaintenance`.
+
+  All reads are fail-safe: a missing transition row yields `inStatusSince: null`, and a maintenance-plugin error fails open to `inMaintenance: false`.
+
+- b995afb: Make `maintenance` a plugin-backed reactive entity via the Model-B entity state machine.
+
+  Maintenance defines a `maintenance` entity `{ status, systemIds, startAt, endAt }`. The `maintenances` + `maintenance_systems` tables are BOTH authoritative AND the entity's current-state storage - there is no framework `entity_state` mirror. `defineEntity` is given a plugin `read` accessor (`MaintenanceService.getManyEntityStates`, projecting the reactive subset with ISO-serialized timestamps straight off those tables), and every create / update / add-update / close / delete site (plus the automation actions) drives the REAL service write through `handle.mutate` / `handle.remove` via the `writeMaintenanceEntity` / `removeMaintenanceEntity` helpers: `apply` runs the write in the plugin's own transaction and returns the new state; the framework snapshots `prev` via `read` BEFORE the write, appends the transition log, and emits `ENTITY_CHANGED` AFTER the write commits. `MaintenanceService.createMaintenance` accepts an optional pre-generated `id` so a create is keyed on a known id and its `prev` snapshot reads the not-yet-existing row as absent.
+
+  A registered change-deriver maps `maintenance` entity changes back to the `maintenance.created` / `maintenance.updated` trigger events, so existing automations keep firing via the reactive Stage-1/Stage-2 dispatch pipeline. The old `maintenance.created` / `maintenance.updated` change hooks and their hook-backed triggers are removed in favor of the reactive entity.
+
+  BREAKING CHANGES:
+
+  - Removed the `maintenance.created` and `maintenance.updated` hooks (`createHook`) and their re-export from the plugin entry point. Use the `maintenance` entity's auto-emitted change events (subscribe via the `automation.entity` extension point's `onEntityChanged`, or author automations against the derived `maintenance.created` / `maintenance.updated` trigger events).
+  - The `created` / `updated` automation triggers are now ENTITY-DRIVEN instead of hook-backed: they are fired by the `maintenance` entity change-deriver (Stage-1 routing) rather than a `createHook`, but stay REGISTERED in the automation editor's trigger catalog (a no-op `setup` via `makeEntityDrivenTriggerSetup`), so they remain offered as picker entries and payload-introspectable. Already-authored automations referencing `maintenance.created` / `maintenance.updated` continue to fire. A registered `toPayload` mapper keeps the runtime `trigger.payload` matching each trigger's declared `payloadSchema` (`maintenanceId`, `status`, `systemIds`, `startAt`, `endAt`). The descriptive fields the old hook carried (`title`, `description`, the `updated`/`closed` `action` discriminator) are NOT part of the reactive entity state, so they are no longer present on the payload.
+  - NARROWING: `maintenance.updated` now fires only on a change to the REACTIVE state (`status`, `startAt` / `endAt` window, or affected `systemIds`). A title / description / message-only edit no longer fires `maintenance.updated` (those fields are not reactive entity state). Re-author any automation that needed to react to a metadata-only maintenance edit against a different signal.
+
+### Patch Changes
+
+- b995afb: Extract a shared `withEntityWrite` / `withEntityRemove` guard for PLUGIN-BACKED (Model B) reactive entities and refactor the per-domain copies onto it.
+
+  Every plugin-backed domain (incident, catalog, dependency, maintenance, slo, satellite) reimplemented the same "no handle wired → run the plugin write directly; handle wired → route through `handle.mutate` / `handle.remove`" guard, varying only in the id-key name. `@checkstack/automation-backend` now exports `withEntityWrite` / `withEntityRemove` (from the entity barrel) and each domain's thin, well-named wrappers (`writeIncidentEntity`, `writeMaintenanceEntity`, satellite's `mirror`, …) delegate to it, so the branch lives in exactly one place. Behavior is unchanged.
+
+  `writeHealthEntity` (healthcheck-backend) is intentionally NOT migrated onto the helper — it is genuinely bespoke (closure-captured durable state, distinct rethrow-vs-fail-soft branches, a per-system serializer, and it returns the computed state). SLO keeps its fail-soft `onError` wrapper around the shared guard.
+
+- Updated dependencies [270ef29]
+- Updated dependencies [b995afb]
+- Updated dependencies [b995afb]
+- Updated dependencies [b995afb]
+- Updated dependencies [270ef29]
+- Updated dependencies [270ef29]
+- Updated dependencies [270ef29]
+- Updated dependencies [270ef29]
+- Updated dependencies [270ef29]
+- Updated dependencies [270ef29]
+- Updated dependencies [270ef29]
+- Updated dependencies [270ef29]
+- Updated dependencies [270ef29]
+- Updated dependencies [b995afb]
+- Updated dependencies [b995afb]
+- Updated dependencies [b995afb]
+- Updated dependencies [b995afb]
+- Updated dependencies [270ef29]
+- Updated dependencies [b995afb]
+- Updated dependencies [270ef29]
+- Updated dependencies [b995afb]
+- Updated dependencies [b995afb]
+- Updated dependencies [270ef29]
+- Updated dependencies [b995afb]
+- Updated dependencies [b995afb]
+- Updated dependencies [b995afb]
+- Updated dependencies [b995afb]
+- Updated dependencies [b995afb]
+- Updated dependencies [b995afb]
+- Updated dependencies [b995afb]
+- Updated dependencies [270ef29]
+- Updated dependencies [270ef29]
+- Updated dependencies [270ef29]
+- Updated dependencies [270ef29]
+- Updated dependencies [270ef29]
+- Updated dependencies [270ef29]
+- Updated dependencies [270ef29]
+- Updated dependencies [270ef29]
+- Updated dependencies [b995afb]
+- Updated dependencies [b995afb]
+  - @checkstack/backend-api@0.19.0
+  - @checkstack/automation-backend@0.3.0
+  - @checkstack/automation-common@0.3.0
+  - @checkstack/maintenance-common@1.3.0
+  - @checkstack/catalog-backend@1.3.0
+  - @checkstack/cache-api@0.3.7
+  - @checkstack/command-backend@0.1.32
+  - @checkstack/cache-utils@0.2.12
+
 ## 1.2.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/maintenance-backend",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "license": "Elastic-2.0",
   "type": "module",
   "main": "src/index.ts",
@@ -15,26 +15,27 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@checkstack/backend-api": "0.17.1",
-    "@checkstack/cache-api": "0.3.5",
-    "@checkstack/cache-utils": "0.2.10",
-    "@checkstack/maintenance-common": "1.2.2",
-    "@checkstack/notification-common": "1.2.0",
-    "@checkstack/catalog-common": "2.2.2",
-    "@checkstack/catalog-backend": "1.1.6",
-    "@checkstack/auth-common": "0.7.1",
-    "@checkstack/command-backend": "0.1.30",
-    "@checkstack/signal-common": "0.2.4",
-    "@checkstack/automation-backend": "0.1.0",
+    "@checkstack/backend-api": "0.18.0",
+    "@checkstack/cache-api": "0.3.6",
+    "@checkstack/cache-utils": "0.2.11",
+    "@checkstack/maintenance-common": "1.2.3",
+    "@checkstack/notification-common": "1.2.1",
+    "@checkstack/catalog-common": "2.2.3",
+    "@checkstack/catalog-backend": "1.2.0",
+    "@checkstack/auth-common": "0.7.2",
+    "@checkstack/command-backend": "0.1.31",
+    "@checkstack/signal-common": "0.2.5",
+    "@checkstack/automation-backend": "0.2.0",
+    "@checkstack/automation-common": "0.2.0",
     "drizzle-orm": "^0.45.0",
     "zod": "^4.2.1",
-    "@checkstack/common": "0.11.0",
+    "@checkstack/common": "0.12.0",
     "@orpc/server": "^1.13.2"
   },
   "devDependencies": {
     "@checkstack/drizzle-helper": "0.0.5",
-    "@checkstack/scripts": "0.3.3",
-    "@checkstack/test-utils-backend": "0.1.30",
+    "@checkstack/scripts": "0.3.4",
+    "@checkstack/test-utils-backend": "0.1.31",
     "@checkstack/tsconfig": "0.0.7",
     "@types/bun": "^1.0.0",
     "drizzle-kit": "^0.31.10",

package/src/automations.test.ts

@@ -1,18 +1,25 @@
 /**
- * Behaviour tests for the maintenance automation triggers + actions.
+ * Behaviour tests for the maintenance automation actions.
+ *
+ * The maintenance domain is now a Model-B PLUGIN-BACKED entity (reactive
+ * automation engine §10.2): the `maintenances` table IS the current-state
+ * storage. Mutation actions drive the REAL write through `handle.mutate`
+ * (the write runs inside `apply`); these tests assert the mutate is keyed by
+ * maintenance id and `apply` returns the §10.2 entity shape.
  */
 import { describe, expect, it, mock } from "bun:test";
 import type { Logger } from "@checkstack/backend-api";
+import type {
+  EntityHandle,
+  EntityMutationOpts,
+} from "@checkstack/automation-backend";
 import { createMockLogger } from "@checkstack/test-utils-backend";
 
 import {
   createMaintenanceActions,
   maintenanceArtifactType,
-  maintenanceCreatedTrigger,
-  maintenanceTriggers,
-  maintenanceUpdatedTrigger,
 } from "./automations";
-import { maintenanceHooks } from "./hooks";
+import type { MaintenanceEntityState } from "./entity";
 import type { MaintenanceService } from "./service";
 
 const logger = createMockLogger() as Logger;
@@ -27,56 +34,55 @@ const ctxBase = {
   },
 };
 
-// ─── Triggers ──────────────────────────────────────────────────────────
-
-describe("maintenance triggers", () => {
-  it("exposes two triggers in a stable order", () => {
-    expect(maintenanceTriggers).toHaveLength(2);
-    expect(maintenanceTriggers[0]).toBe(
-      maintenanceCreatedTrigger as (typeof maintenanceTriggers)[number],
-    );
-    expect(maintenanceTriggers[1]).toBe(
-      maintenanceUpdatedTrigger as (typeof maintenanceTriggers)[number],
-    );
-  });
-
-  it("extracts maintenanceId as the contextKey on both triggers", () => {
-    const payload = {
-      maintenanceId: "m-1",
-      systemIds: ["sys-1"],
-      title: "Deploy",
-      status: "scheduled" as const,
-      startAt: "2026-05-29T11:00:00Z",
-      endAt: "2026-05-29T12:00:00Z",
-    };
-    expect(maintenanceCreatedTrigger.contextKey?.(payload)).toBe("m-1");
-    expect(
-      maintenanceUpdatedTrigger.contextKey?.({ ...payload, action: "updated" }),
-    ).toBe("m-1");
-  });
+interface RecordedMutate {
+  id: string;
+  next: MaintenanceEntityState;
+  opts?: EntityMutationOpts;
+}
 
-  it("requires action enum on updated payload", () => {
-    const ok = maintenanceUpdatedTrigger.payloadSchema.safeParse({
-      maintenanceId: "m-1",
-      systemIds: [],
-      title: "Deploy",
-      status: "completed",
-      startAt: "2026-05-29T11:00:00Z",
-      endAt: "2026-05-29T12:00:00Z",
-      action: "closed",
-    });
-    const bad = maintenanceUpdatedTrigger.payloadSchema.safeParse({
-      maintenanceId: "m-1",
-      systemIds: [],
-      title: "Deploy",
-      status: "completed",
-      startAt: "2026-05-29T11:00:00Z",
-      endAt: "2026-05-29T12:00:00Z",
-    });
-    expect(ok.success).toBe(true);
-    expect(bad.success).toBe(false);
-  });
-});
+/**
+ * A fake PLUGIN-BACKED entity handle that records `mutate` / `remove` calls
+ * for assertion. `mutate` runs the driven `apply()` (the action's real write)
+ * and captures the returned next-state, mirroring how the framework drives a
+ * plugin-backed write.
+ */
+function makeEntityHandle(): EntityHandle<MaintenanceEntityState> & {
+  mutates: RecordedMutate[];
+  removes: string[];
+} {
+  const mutates: RecordedMutate[] = [];
+  const removes: string[] = [];
+  return {
+    kind: "maintenance",
+    mutates,
+    removes,
+    async mutate(input) {
+      const next = await input.apply();
+      mutates.push({ id: input.id, next, opts: input.opts });
+      return next;
+    },
+    async get() {
+      return undefined;
+    },
+    async getMany() {
+      return {};
+    },
+    async remove(input) {
+      // Plugin-backed remove takes `{ id, apply }`; run apply + record the id.
+      await input.apply();
+      removes.push(input.id);
+    },
+    async inStateSince() {
+      return null;
+    },
+    async inStateForMs() {
+      return 0;
+    },
+    async transitionCount() {
+      return 0;
+    },
+  };
+}
 
 describe("maintenanceArtifactType", () => {
   it("validates the canonical artifact shape", () => {
@@ -117,7 +123,12 @@ function makeService(args: {
   activeMock: ReturnType<typeof mock>;
   closeMock: ReturnType<typeof mock>;
 } {
-  const createMock = mock(async (_input: unknown) => args.rowToReturn);
+  // The real service inserts with the server-generated id passed as the 2nd
+  // arg and returns the row carrying THAT id. Echo it so the entity key (the
+  // generated id) and the returned `externalId` agree, like production.
+  const createMock = mock(async (_input: unknown, id?: string) =>
+    args.rowToReturn ? { ...args.rowToReturn, id: id ?? args.rowToReturn.id } : args.rowToReturn,
+  );
   const updateMock = mock(async (_input: unknown) => args.updateReturn);
   const addUpdateMock = mock(async (_input: unknown) => ({
     id: "upd-1",
@@ -163,13 +174,10 @@ const sampleRow: FakeMaintenance = {
 };
 
 describe("maintenance.create", () => {
-  it("creates a maintenance, fires maintenanceCreated, and emits a maintenance.window artifact", async () => {
+  it("creates a maintenance, mirrors the entity state, and emits a maintenance.window artifact", async () => {
     const service = makeService({ rowToReturn: sampleRow });
-    const emitHook = mock(async (_hook: unknown, _payload: unknown) => {});
-    const [create] = createMaintenanceActions({
-      service,
-      emitHook: emitHook as never,
-    });
+    const entityHandle = makeEntityHandle();
+    const [create] = createMaintenanceActions({ service, entityHandle });
 
     const result = await create!.execute({
       ...ctxBase,
@@ -184,20 +192,28 @@ describe("maintenance.create", () => {
 
     expect(result.success).toBe(true);
     if (!result.success) return;
-    expect(result.externalId).toBe("m-1");
-    expect(emitHook).toHaveBeenCalledTimes(1);
-    expect(emitHook.mock.calls[0]![0]).toBe(maintenanceHooks.maintenanceCreated);
+    expect(entityHandle.mutates).toHaveLength(1);
+    // The entity is keyed on the server-generated id (the create's `prev`
+    // snapshot reads it as absent); the action's `externalId` echoes that
+    // same id, so the two MUST agree.
+    expect(typeof result.externalId).toBe("string");
+    expect(entityHandle.mutates[0]!.id).toBe(result.externalId!);
+    expect(entityHandle.mutates[0]!.next).toEqual({
+      status: "scheduled",
+      systemIds: ["sys-1"],
+      startAt: "2026-05-29T11:00:00.000Z",
+      endAt: "2026-05-29T12:00:00.000Z",
+    });
+    // Run-originated writes carry the runId (masking) + the run actor.
+    expect(entityHandle.mutates[0]!.opts?.runId).toBe("run-1");
   });
 });
 
 describe("maintenance.update", () => {
-  it("returns failure when the maintenance doesn't exist", async () => {
+  it("returns failure and mirrors nothing when the maintenance doesn't exist", async () => {
     const service = makeService({ updateReturn: undefined });
-    const emitHook = mock(async (_hook: unknown, _payload: unknown) => {});
-    const [, update] = createMaintenanceActions({
-      service,
-      emitHook: emitHook as never,
-    });
+    const entityHandle = makeEntityHandle();
+    const [, update] = createMaintenanceActions({ service, entityHandle });
 
     const result = await update!.execute({
       ...ctxBase,
@@ -208,16 +224,17 @@ describe("maintenance.update", () => {
     expect(result.success).toBe(false);
     if (result.success) return;
     expect(result.error).toMatch(/not found/i);
-    expect(emitHook).not.toHaveBeenCalled();
+    expect(entityHandle.mutates).toHaveLength(0);
   });
 
-  it("emits maintenanceUpdated with action='updated' on success", async () => {
-    const service = makeService({ updateReturn: sampleRow });
-    const emitHook = mock(async (_hook: unknown, _payload: unknown) => {});
-    const [, update] = createMaintenanceActions({
-      service,
-      emitHook: emitHook as never,
+  it("mirrors the updated state on success", async () => {
+    const service = makeService({
+      // The action probes existence first, then updates inside `apply`.
+      getMaintenanceReturn: sampleRow,
+      updateReturn: { ...sampleRow, status: "in_progress" },
     });
+    const entityHandle = makeEntityHandle();
+    const [, update] = createMaintenanceActions({ service, entityHandle });
 
     const result = await update!.execute({
       ...ctxBase,
@@ -226,22 +243,18 @@ describe("maintenance.update", () => {
     });
 
     expect(result.success).toBe(true);
-    const emitCall = emitHook.mock.calls[0]!;
-    expect(emitCall[0]).toBe(maintenanceHooks.maintenanceUpdated);
-    expect((emitCall[1] as { action: string }).action).toBe("updated");
+    expect(entityHandle.mutates).toHaveLength(1);
+    expect(entityHandle.mutates[0]!.next.status).toBe("in_progress");
   });
 });
 
 describe("maintenance.add_update", () => {
-  it("uses action='closed' when statusChange is 'completed'", async () => {
+  it("mirrors the refreshed state when statusChange is 'completed'", async () => {
     const service = makeService({
       getMaintenanceReturn: { ...sampleRow, status: "completed" },
     });
-    const emitHook = mock(async (_hook: unknown, _payload: unknown) => {});
-    const [, , addUpdate] = createMaintenanceActions({
-      service,
-      emitHook: emitHook as never,
-    });
+    const entityHandle = makeEntityHandle();
+    const [, , addUpdate] = createMaintenanceActions({ service, entityHandle });
 
     const result = await addUpdate!.execute({
       ...ctxBase,
@@ -254,18 +267,14 @@ describe("maintenance.add_update", () => {
     });
 
     expect(result.success).toBe(true);
-    expect((emitHook.mock.calls[0]![1] as { action: string }).action).toBe(
-      "closed",
-    );
+    expect(entityHandle.mutates).toHaveLength(1);
+    expect(entityHandle.mutates[0]!.next.status).toBe("completed");
   });
 
   it("returns failure when the maintenance vanishes between addUpdate and getMaintenance", async () => {
     const service = makeService({ getMaintenanceReturn: undefined });
-    const emitHook = mock(async (_hook: unknown, _payload: unknown) => {});
-    const [, , addUpdate] = createMaintenanceActions({
-      service,
-      emitHook: emitHook as never,
-    });
+    const entityHandle = makeEntityHandle();
+    const [, , addUpdate] = createMaintenanceActions({ service, entityHandle });
 
     const result = await addUpdate!.execute({
       ...ctxBase,
@@ -276,18 +285,18 @@ describe("maintenance.add_update", () => {
     expect(result.success).toBe(false);
     if (result.success) return;
     expect(result.error).toMatch(/not found/i);
-    expect(emitHook).not.toHaveBeenCalled();
+    expect(entityHandle.mutates).toHaveLength(0);
   });
 });
 
 describe("maintenance.set_system", () => {
-  it("schedules a now+durationMinutes window covering one system", async () => {
+  it("schedules a now+durationMinutes window and mirrors it covering one system", async () => {
     const service = makeService({ rowToReturn: sampleRow });
-    const emitHook = mock(async (_hook: unknown, _payload: unknown) => {});
+    const entityHandle = makeEntityHandle();
     const fixedNow = new Date("2026-05-29T11:00:00Z");
     const [, , , setSystem] = createMaintenanceActions({
       service,
-      emitHook: emitHook as never,
+      entityHandle,
       now: () => fixedNow,
     });
 
@@ -309,12 +318,14 @@ describe("maintenance.set_system", () => {
     expect(call.systemIds).toEqual(["sys-1"]);
     expect(call.startAt.toISOString()).toBe("2026-05-29T11:00:00.000Z");
     expect(call.endAt.toISOString()).toBe("2026-05-29T12:00:00.000Z");
+    expect(entityHandle.mutates).toHaveLength(1);
+    expect(entityHandle.mutates[0]!.next.systemIds).toEqual(["sys-1"]);
   });
 });
 
 describe("maintenance.clear_system", () => {
-  it("closes every active window for the system + emits one updated hook per close", async () => {
-    const window1 = { ...sampleRow, id: "m-1" };
+  it("closes every active window for the system + mirrors one state per close", async () => {
+    const window1 = { ...sampleRow, id: "m-1", status: "completed" };
     const window2 = { ...sampleRow, id: "m-2" };
     const service = makeService({
       activeForSystem: [window1, window2],
@@ -322,11 +333,8 @@ describe("maintenance.clear_system", () => {
     });
     // closeMaintenance returns the same row both times in the fixture
     // — that's fine for this test; we only assert the count + ids.
-    const emitHook = mock(async (_hook: unknown, _payload: unknown) => {});
-    const actions = createMaintenanceActions({
-      service,
-      emitHook: emitHook as never,
-    });
+    const entityHandle = makeEntityHandle();
+    const actions = createMaintenanceActions({ service, entityHandle });
     const clearSystem = actions[4]!;
 
     const result = await clearSystem.execute({
@@ -337,20 +345,16 @@ describe("maintenance.clear_system", () => {
 
     expect(result.success).toBe(true);
     expect(service.closeMock).toHaveBeenCalledTimes(2);
-    expect(emitHook).toHaveBeenCalledTimes(2);
-    for (const call of emitHook.mock.calls) {
-      expect(call[0]).toBe(maintenanceHooks.maintenanceUpdated);
-      expect((call[1] as { action: string }).action).toBe("closed");
+    expect(entityHandle.mutates).toHaveLength(2);
+    for (const recorded of entityHandle.mutates) {
+      expect(recorded.next.status).toBe("completed");
     }
   });
 
-  it("succeeds and emits an empty artifact when no windows are active for the system", async () => {
+  it("succeeds and mirrors nothing when no windows are active for the system", async () => {
     const service = makeService({ activeForSystem: [] });
-    const emitHook = mock(async (_hook: unknown, _payload: unknown) => {});
-    const actions = createMaintenanceActions({
-      service,
-      emitHook: emitHook as never,
-    });
+    const entityHandle = makeEntityHandle();
+    const actions = createMaintenanceActions({ service, entityHandle });
     const clearSystem = actions[4]!;
 
     const result = await clearSystem.execute({
@@ -363,6 +367,6 @@ describe("maintenance.clear_system", () => {
     if (!result.success) return;
     const artifact = result.artifact as { closedMaintenanceIds: string[] };
     expect(artifact.closedMaintenanceIds).toEqual([]);
-    expect(emitHook).not.toHaveBeenCalled();
+    expect(entityHandle.mutates).toHaveLength(0);
   });
 });