@intentius/chant 0.28.0 → 0.30.0

package/src/lifecycle/deep-diff.ts

@@ -0,0 +1,213 @@
+/**
+ * Property-level live drift (#1014) — declared vs live vs accepted baseline.
+ *
+ * The thin diff (./live-diff.ts) compares whole entities on status, physical id
+ * and a few outputs. This compares their property trees, path by path, which is
+ * where a console edit actually shows up. Pure function; the reading happens in
+ * ./deep-observe.ts and the CLI.
+ *
+ * Three axes, and all three matter:
+ *
+ *   - **declared** — the property tree chant synthesized, normalized with the
+ *     lexicon's own hooks so it is in the same shape as the live tree.
+ *   - **live** — what the provider returned, normalized with the same hooks.
+ *   - **baseline** — the value somebody accepted (./observation-baseline.ts). A
+ *     deviation whose live value matches the accepted value is not drift; one
+ *     that has moved away from the accepted value is drift again, and the
+ *     report shows all three so the reader can see what changed and from what.
+ *
+ * A path is skipped entirely when the declared value is
+ * {@link UNRESOLVED} — an unevaluated intrinsic (`Fn::Sub`, `Ref`) has no
+ * source-side value to compare, and reporting one as drift would light up every
+ * interpolated property forever.
+ */
+
+import {
+  UNRESOLVED,
+  deepValueEqual,
+  flattenDeepProperties,
+  type DeepNormalizationHooks,
+  type NormalizedDeepObservation,
+} from "../deep-observation";
+import type { UnobservedResource } from "./live-diff";
+import { acceptedDeviation, type BaselineLexicon } from "./observation-baseline";
+
+/**
+ * How a property differs.
+ *
+ * - `changed` — declared and live both have the path, with different values.
+ * - `undeclared` — live has it, source never did. cdk-real-drift's whole reason
+ *   to exist: the console-added property CloudFormation itself will not report.
+ * - `absent` — source declares it and the live tree does not carry it. Weaker
+ *   than the other two: a provider that omits a property it considers unset is
+ *   common, which is what the lexicon's pruning hook is for.
+ */
+export type PropertyDriftKind = "changed" | "undeclared" | "absent";
+
+/** One property-level difference. */
+export interface PropertyDrift {
+  /** Path within the normalized property tree (`Tags[0].Value`). */
+  path: string;
+  kind: PropertyDriftKind;
+  /** Value in source. Absent for `undeclared`. */
+  declared?: unknown;
+  /** Value in the cloud. Absent for `absent`. */
+  live?: unknown;
+  /**
+   * The accepted value from the baseline, when this path has one. Present on a
+   * reported drift too — that is the "accepted X, now Y" case, and hiding the
+   * accepted value there would lose the most useful column in the report.
+   */
+  baseline?: unknown;
+}
+
+/** Property-level drift for one declared entity. */
+export interface DeepEntityDrift {
+  name: string;
+  type: string;
+  changes: PropertyDrift[];
+}
+
+export interface DeepDiffResult {
+  /** Entities with at least one reportable property difference. Sorted by name. */
+  drifted: DeepEntityDrift[];
+  /**
+   * Differences suppressed by the baseline — reported separately rather than
+   * dropped, so `--json` consumers and `--update-baseline` can see what is
+   * being held back and the count never silently changes meaning.
+   */
+  accepted: DeepEntityDrift[];
+  /** Entities whose property trees matched. Sorted. */
+  unchanged: string[];
+  /** Declared entities whose *properties* could not be read (#1089). Sorted. */
+  unobserved: UnobservedResource[];
+  /** Entities the deep reader returned that were never declared. Sorted. */
+  undeclaredEntities: string[];
+}
+
+/** A declared entity's property tree, already normalized with the lexicon's hooks. */
+export interface DeclaredDeepEntity {
+  type: string;
+  properties: Record<string, unknown>;
+}
+
+export interface DiffDeepInput {
+  /** Normalized declared property trees, keyed by chant entity name. */
+  declared: Record<string, DeclaredDeepEntity>;
+  /** Normalized live observation, as returned by `observeResourcesDeep()`. */
+  live: NormalizedDeepObservation;
+  /** Accepted deviations for this lexicon. Omit for "nothing accepted". */
+  baseline?: BaselineLexicon;
+  /**
+   * The lexicon's hooks, so set-like arrays are addressed by key rather than by
+   * position (see `flattenDeepProperties`). Omit and paths are positional,
+   * which still diffs correctly but shifts every path after an inserted
+   * element.
+   */
+  hooks?: DeepNormalizationHooks;
+}
+
+/**
+ * Compare declared and live property trees path by path, subtracting accepted
+ * deviations. Deterministic: every list is sorted.
+ */
+export function diffDeep(input: DiffDeepInput): DeepDiffResult {
+  const baseline = input.baseline ?? {};
+  const drifted: DeepEntityDrift[] = [];
+  const accepted: DeepEntityDrift[] = [];
+  const unchanged: string[] = [];
+  const unobserved: UnobservedResource[] = [];
+  const undeclaredEntities: string[] = [];
+
+  const liveNames = new Set(Object.keys(input.live.resources));
+
+  for (const [name, entry] of Object.entries(input.live.unobserved)) {
+    // Present beats not-observed, exactly as the thin contract resolves it.
+    if (liveNames.has(name)) continue;
+    unobserved.push({
+      name,
+      ...(entry.type ? { type: entry.type } : {}),
+      reason: entry.reason,
+      ...(entry.detail ? { detail: entry.detail } : {}),
+    });
+  }
+
+  for (const name of liveNames) {
+    if (!(name in input.declared)) undeclaredEntities.push(name);
+  }
+
+  for (const name of Object.keys(input.declared).sort()) {
+    const liveEntity = input.live.resources[name];
+    // Not observed deeply → already recorded above; no properties to compare.
+    // Observed absent by the deep reader is the thin diff's `missing` case and
+    // is not restated here: a resource that does not exist has no property
+    // drift, and reporting every one of its declared properties as `absent`
+    // would bury the one line that matters.
+    if (!liveEntity) continue;
+
+    const declaredEntity = input.declared[name];
+    const type = liveEntity.type || declaredEntity.type;
+    const declaredFlat = flattenDeepProperties(declaredEntity.properties, {
+      entityType: type,
+      side: "declared",
+      hooks: input.hooks,
+    });
+    const liveFlat = flattenDeepProperties(liveEntity.properties, {
+      entityType: type,
+      side: "live",
+      hooks: input.hooks,
+    });
+
+    const paths = [...new Set([...declaredFlat.keys(), ...liveFlat.keys()])].sort();
+    const reported: PropertyDrift[] = [];
+    const suppressed: PropertyDrift[] = [];
+
+    for (const path of paths) {
+      const hasDeclared = declaredFlat.has(path);
+      const hasLive = liveFlat.has(path);
+      const declaredValue = declaredFlat.get(path);
+      const liveValue = liveFlat.get(path);
+
+      // An unevaluated intrinsic has no source-side value to compare against.
+      if (hasDeclared && declaredValue === UNRESOLVED) continue;
+      if (hasDeclared && hasLive && deepValueEqual(declaredValue, liveValue)) continue;
+
+      const kind: PropertyDriftKind = !hasDeclared ? "undeclared" : !hasLive ? "absent" : "changed";
+      const drift: PropertyDrift = {
+        path,
+        kind,
+        ...(hasDeclared ? { declared: declaredValue } : {}),
+        ...(hasLive ? { live: liveValue } : {}),
+      };
+
+      const acceptedEntry = acceptedDeviation(baseline, name, path);
+      if (acceptedEntry) {
+        drift.baseline = acceptedEntry.value;
+        // Value-bound acceptance: the accepted value is not drift, a different
+        // one is drift again.
+        if (hasLive && deepValueEqual(liveValue, acceptedEntry.value)) {
+          suppressed.push(drift);
+          continue;
+        }
+      }
+      reported.push(drift);
+    }
+
+    if (suppressed.length > 0) accepted.push({ name, type, changes: suppressed });
+    if (reported.length > 0) drifted.push({ name, type, changes: reported });
+    else if (suppressed.length === 0) unchanged.push(name);
+  }
+
+  return {
+    drifted: drifted.sort((a, b) => a.name.localeCompare(b.name)),
+    accepted: accepted.sort((a, b) => a.name.localeCompare(b.name)),
+    unchanged: unchanged.sort(),
+    unobserved: unobserved.sort((a, b) => a.name.localeCompare(b.name)),
+    undeclaredEntities: undeclaredEntities.sort(),
+  };
+}
+
+/** Total reported property differences across every entity. */
+export function countPropertyDrift(result: DeepDiffResult): number {
+  return result.drifted.reduce((n, e) => n + e.changes.length, 0);
+}

package/src/lifecycle/deep-observe.test.ts

@@ -0,0 +1,174 @@
+import { describe, test, expect, vi } from "vitest";
+import { deepDiffForLexicon, diffDeepObservation, mergeDeepObservations, observeDeep } from "./deep-observe";
+import { deepObservation, type DeepNormalizationHooks } from "../deep-observation";
+import type { ObservationLexicon } from "../lexicon";
+
+const entities = (
+  record: Record<string, { entityType: string; props: Record<string, unknown> }>,
+): Map<string, { entityType: string; props: Record<string, unknown> }> => new Map(Object.entries(record));
+
+/** Minimal plugin shell — only the observation surface matters here. */
+const pluginWith = (over: Partial<ObservationLexicon>): ObservationLexicon =>
+  ({ name: "test", serializer: {} , ...over } as unknown as ObservationLexicon);
+
+describe("observeDeep", () => {
+  test("a lexicon with no deep reader observes nothing and claims nothing", async () => {
+    const result = await observeDeep(pluginWith({}), {
+      environment: "prod",
+      buildOutput: "",
+      entities: entities({ a: { entityType: "T", props: {} } }),
+    });
+    expect(result).toEqual({ resources: {}, unobserved: {} });
+  });
+
+  test("a thrown reader becomes read-failed for every declared entity, never an empty tree", async () => {
+    const result = await observeDeep(
+      pluginWith({
+        observeResourcesDeep: () => Promise.reject(new Error("kubeconfig has no current context")),
+      }),
+      {
+        environment: "prod",
+        buildOutput: "",
+        entities: entities({ a: { entityType: "T", props: {} }, b: { entityType: "U", props: {} } }),
+      },
+    );
+    expect(result.resources).toEqual({});
+    expect(result.unobserved.a).toEqual({
+      type: "T",
+      reason: "read-failed",
+      detail: "kubeconfig has no current context",
+    });
+    expect(Object.keys(result.unobserved)).toEqual(["a", "b"]);
+  });
+
+  test("multi-stack reads merge with present beating not-observed", async () => {
+    const reader = vi.fn(async (opts: { stack?: string }) =>
+      opts.stack === "one"
+        ? deepObservation({}, { a: { reason: "read-failed", detail: "not in this stack" } })
+        : deepObservation({ a: { type: "T", properties: { A: 1 } } }),
+    );
+    const result = await observeDeep(pluginWith({ observeResourcesDeep: reader as never }), {
+      environment: "prod",
+      buildOutput: "",
+      entities: entities({ a: { entityType: "T", props: {} } }),
+      componentStacks: ["one", "two"],
+    });
+    expect(result.unobserved).toEqual({});
+    expect(result.resources.a.properties).toEqual({ A: 1 });
+  });
+
+  test("passes the declared entity names through to the reader", async () => {
+    const reader = vi.fn(async () => deepObservation({}));
+    await observeDeep(pluginWith({ observeResourcesDeep: reader as never }), {
+      environment: "prod",
+      buildOutput: "out",
+      entities: entities({ a: { entityType: "T", props: {} } }),
+      owned: true,
+    });
+    expect(reader).toHaveBeenCalledWith(
+      expect.objectContaining({ environment: "prod", buildOutput: "out", entityNames: ["a"], owned: true }),
+    );
+  });
+});
+
+describe("mergeDeepObservations", () => {
+  test("a resource found in any part is present everywhere", () => {
+    const merged = mergeDeepObservations([
+      { resources: {}, unobserved: { a: { reason: "read-failed" } } },
+      { resources: { a: { type: "T", properties: {} } }, unobserved: {} },
+    ]);
+    expect(merged.unobserved).toEqual({});
+    expect(Object.keys(merged.resources)).toEqual(["a"]);
+  });
+});
+
+describe("diffDeepObservation", () => {
+  const hooks: DeepNormalizationHooks = {
+    prune(node) {
+      // Server-populated everywhere.
+      if (node.pattern === "Arn") return true;
+      // A provider default, subtracted only where source is silent.
+      return node.side === "live" && node.counterpart === "absent" && node.pattern === "Path" && node.value === "/";
+    },
+  };
+
+  test("applies the lexicon's hooks to both sides", () => {
+    const result = diffDeepObservation(
+      entities({ r: { entityType: "AWS::IAM::Role", props: { Arn: "declared-arn", RoleName: "r" } } }),
+      {
+        resources: {
+          r: { type: "AWS::IAM::Role", properties: { Arn: "arn:aws:iam::1:role/r", RoleName: "r", Path: "/" } },
+        },
+        unobserved: {},
+      },
+      hooks,
+    );
+    // Arn pruned on both sides; Path subtracted as an undeclared default.
+    expect(result.drifted).toEqual([]);
+    expect(result.unchanged).toEqual(["r"]);
+  });
+
+  test("a declared property at its default is still compared", () => {
+    const result = diffDeepObservation(
+      entities({ r: { entityType: "AWS::IAM::Role", props: { Path: "/" } } }),
+      { resources: { r: { type: "AWS::IAM::Role", properties: { Path: "/team/" } } }, unobserved: {} },
+      hooks,
+    );
+    expect(result.drifted[0].changes).toEqual([
+      { path: "Path", kind: "changed", declared: "/", live: "/team/" },
+    ]);
+  });
+
+  test("unevaluated declared props never read as drift", () => {
+    class Sub {
+      constructor(readonly t: string) {}
+    }
+    const result = diffDeepObservation(
+      entities({ b: { entityType: "AWS::S3::Bucket", props: { BucketName: new Sub("${AWS::StackName}") } } }),
+      { resources: { b: { type: "AWS::S3::Bucket", properties: { BucketName: "prod-data" } } }, unobserved: {} },
+      hooks,
+    );
+    expect(result.drifted).toEqual([]);
+  });
+});
+
+describe("deepDiffForLexicon", () => {
+  test("an unreadable deep read surfaces as a hole with a reason, not as clean", async () => {
+    const result = await deepDiffForLexicon(
+      pluginWith({
+        observeResourcesDeep: async () =>
+          deepObservation({}, { a: { type: "T", reason: "no-credentials", detail: "token expired" } }),
+      }),
+      {
+        environment: "prod",
+        buildOutput: "",
+        entities: entities({ a: { entityType: "T", props: { A: 1 } } }),
+      },
+    );
+    expect(result.drifted).toEqual([]);
+    expect(result.unobserved).toEqual([
+      { name: "a", type: "T", reason: "no-credentials", detail: "token expired" },
+    ]);
+  });
+
+  test("subtracts the accepted baseline it is handed", async () => {
+    const plugin = pluginWith({
+      observeResourcesDeep: async () =>
+        deepObservation({ a: { type: "T", properties: { Extra: "accepted-value" } } }),
+    });
+    const opts = {
+      environment: "prod",
+      buildOutput: "",
+      entities: entities({ a: { entityType: "T", props: {} } }),
+    };
+    const withoutBaseline = await deepDiffForLexicon(plugin, opts);
+    expect(withoutBaseline.drifted[0].changes[0].path).toBe("Extra");
+
+    const withBaseline = await deepDiffForLexicon(plugin, {
+      ...opts,
+      baseline: { a: { accepted: [{ path: "Extra", value: "accepted-value" }] } },
+    });
+    expect(withBaseline.drifted).toEqual([]);
+    expect(withBaseline.accepted[0].changes[0].path).toBe("Extra");
+  });
+});

package/src/lifecycle/deep-observe.ts

@@ -0,0 +1,173 @@
+/**
+ * Deep observation orchestration (#1014) — call one lexicon's
+ * `observeResourcesDeep()`, put the declared trees in the same shape, and diff.
+ *
+ * The sibling of ./observe.ts on the thin path, and it inherits that path's
+ * rules: a reader that throws does not vanish, it reports every declared entity
+ * NOT-OBSERVED with `read-failed` (#1089); a multi-stack read merges with
+ * present > not-observed > absent. A deep read that fails is a hole with a
+ * reason, never a thin-but-clean answer.
+ *
+ * The normalization is applied here, on both sides, with the lexicon's own
+ * hooks. The reader already normalized what it returned — that is the contract
+ * — but only core can normalize the *declared* tree, and only core knows which
+ * paths exist on the other side, which is what
+ * {@link import("../deep-observation").DeepNode.counterpart} needs for default
+ * subtraction. Re-running the pass over an already-normalized live tree is
+ * idempotent for every hook that does not consult `counterpart`.
+ */
+
+import type { ObservationLexicon } from "../lexicon";
+import {
+  deepPathSet,
+  normalizeDeepObservation,
+  normalizeDeepProperties,
+  type DeepNormalizationHooks,
+  type DeepResourceObservation,
+  type NormalizedDeepObservation,
+} from "../deep-observation";
+import { unobservedAll, type UnobservedEntity } from "../observation";
+import { diffDeep, type DeclaredDeepEntity, type DeepDiffResult } from "./deep-diff";
+import type { BaselineLexicon } from "./observation-baseline";
+
+/** Declared entities for one lexicon, in the shape the observe paths pass around. */
+export type DeclaredEntities = Map<string, { entityType: string; props: Record<string, unknown> }>;
+
+export interface DeepObserveOptions {
+  environment: string;
+  buildOutput: string;
+  entities: DeclaredEntities;
+  /** Deployed stack for a multi-stack project (#932). */
+  stack?: string;
+  /** Component projects deploy one stack per component; read them all and merge. */
+  componentStacks?: string[];
+  owned?: boolean;
+}
+
+/**
+ * Merge several deep observations of the same lexicon (the multi-stack read).
+ * Precedence matches the thin contract: present > not-observed > absent.
+ */
+export function mergeDeepObservations(
+  parts: Iterable<NormalizedDeepObservation>,
+): NormalizedDeepObservation {
+  const resources: Record<string, DeepResourceObservation> = {};
+  const unobserved: Record<string, UnobservedEntity> = {};
+  for (const part of parts) {
+    Object.assign(resources, part.resources);
+    Object.assign(unobserved, part.unobserved);
+  }
+  for (const name of Object.keys(resources)) delete unobserved[name];
+  return { resources, unobserved };
+}
+
+/**
+ * Read one lexicon's live property trees. Never throws: a thrown reader becomes
+ * a NOT-OBSERVED verdict for every declared entity, with the error as the
+ * detail, so the caller sees a hole rather than an empty tree that reads as
+ * "no properties drifted".
+ */
+export async function observeDeep(
+  plugin: ObservationLexicon,
+  opts: DeepObserveOptions,
+): Promise<NormalizedDeepObservation> {
+  const entityNames = Array.from(opts.entities.keys());
+  if (!plugin.observeResourcesDeep) {
+    return { resources: {}, unobserved: {} };
+  }
+  const base = {
+    environment: opts.environment,
+    buildOutput: opts.buildOutput,
+    entityNames,
+    entities: opts.entities,
+    ...(opts.owned !== undefined ? { owned: opts.owned } : {}),
+  };
+  try {
+    if (opts.componentStacks && opts.componentStacks.length > 0) {
+      const parts: NormalizedDeepObservation[] = [];
+      for (const stack of opts.componentStacks) {
+        parts.push(normalizeDeepObservation(await plugin.observeResourcesDeep({ ...base, stack })));
+      }
+      return mergeDeepObservations(parts);
+    }
+    return normalizeDeepObservation(
+      await plugin.observeResourcesDeep({ ...base, ...(opts.stack ? { stack: opts.stack } : {}) }),
+    );
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      resources: {},
+      unobserved: unobservedAll(entityNames, "read-failed", message, opts.entities),
+    };
+  }
+}
+
+/**
+ * Normalize both sides into the same shape, then diff.
+ *
+ * Split out from {@link deepDiffForLexicon} so the pure half is testable
+ * without a plugin: given declared entities, a live observation and a baseline,
+ * this is a deterministic function.
+ */
+export function diffDeepObservation(
+  entities: DeclaredEntities,
+  live: NormalizedDeepObservation,
+  hooks?: DeepNormalizationHooks,
+  baseline?: BaselineLexicon,
+): DeepDiffResult {
+  const declared: Record<string, DeclaredDeepEntity> = {};
+  const normalizedLive: Record<string, DeepResourceObservation> = {};
+
+  for (const [name, entity] of entities) {
+    const liveEntity = live.resources[name];
+    const declaredRaw = entity.props ?? {};
+    const liveRaw = liveEntity?.properties ?? {};
+    const declaredPaths = deepPathSet(declaredRaw);
+    const livePaths = deepPathSet(liveRaw);
+
+    declared[name] = {
+      type: entity.entityType,
+      properties: normalizeDeepProperties(declaredRaw, {
+        entityType: entity.entityType,
+        side: "declared",
+        hooks,
+        counterpartPaths: livePaths,
+      }),
+    };
+    if (liveEntity) {
+      normalizedLive[name] = {
+        type: liveEntity.type || entity.entityType,
+        ...(liveEntity.physicalId ? { physicalId: liveEntity.physicalId } : {}),
+        properties: normalizeDeepProperties(liveRaw, {
+          entityType: liveEntity.type || entity.entityType,
+          side: "live",
+          hooks,
+          counterpartPaths: declaredPaths,
+        }),
+      };
+    }
+  }
+
+  // Live entities nobody declared keep their reader-normalized trees — there is
+  // no declared side to normalize them against, and `diffDeep` reports them as
+  // undeclared entities rather than diffing their properties.
+  for (const [name, liveEntity] of Object.entries(live.resources)) {
+    if (!normalizedLive[name]) normalizedLive[name] = liveEntity;
+  }
+
+  return diffDeep({
+    declared,
+    live: { resources: normalizedLive, unobserved: live.unobserved },
+    baseline,
+    hooks,
+  });
+}
+
+/** Read one lexicon deeply and diff it against source and the accepted baseline. */
+export async function deepDiffForLexicon(
+  plugin: ObservationLexicon,
+  opts: DeepObserveOptions & { baseline?: BaselineLexicon },
+): Promise<DeepDiffResult> {
+  const live = await observeDeep(plugin, opts);
+  return diffDeepObservation(opts.entities, live, plugin.deepNormalizationHooks, opts.baseline);
+}

package/src/lifecycle/index.ts

@@ -3,6 +3,9 @@ export * from "./git";
 export * from "./digest";
 export * from "./snapshot";
 export * from "./live-diff";
+export * from "./deep-diff";
+export * from "./deep-observe";
+export * from "./observation-baseline";
 export * from "./change-set";
 export * from "./affected";
 export * from "./release-ledger";

package/src/lifecycle/live-diff.test.ts

@@ -23,6 +23,7 @@ describe("diffLive", () => {
       newlyObserved: [],
       driftedSinceSnapshot: [],
       unchanged: [],
+      unobserved: [],
     });
   });
 
@@ -112,6 +113,44 @@ describe("diffLive", () => {
     expect(result.driftedSinceSnapshot.map((d) => d.name)).toEqual(["c"]);
     expect(result.unchanged).toEqual(["b"]);
   });
+
+  // ── The observation tri-state (#1089) ─────────────────────────────────────
+
+  test("declared and not observed → unobserved, not missing", () => {
+    const result = diffLive({
+      declared: new Set(["crd", "gone"]),
+      observedNow: {},
+      observedThen: undefined,
+      unobserved: { crd: { type: "K8s::X::Widget", reason: "unsupported-kind", detail: "no reader" } },
+    });
+    expect(result.missing).toEqual(["gone"]);
+    expect(result.unobserved).toEqual([
+      { name: "crd", type: "K8s::X::Widget", reason: "unsupported-kind", detail: "no reader" },
+    ]);
+  });
+
+  test("an unobserved entity in the last snapshot has not disappeared", () => {
+    const result = diffLive({
+      declared: new Set(["crd"]),
+      observedNow: {},
+      observedThen: { crd: meta() },
+      unobserved: { crd: { reason: "no-credentials" } },
+    });
+    expect(result.disappeared).toEqual([]);
+    expect(result.missing).toEqual([]);
+    expect(result.unobserved.map((u) => u.name)).toEqual(["crd"]);
+  });
+
+  test("a resource that was returned is never also unobserved", () => {
+    const result = diffLive({
+      declared: new Set(["a"]),
+      observedNow: { a: meta() },
+      observedThen: undefined,
+      unobserved: { a: { reason: "read-failed" } },
+    });
+    expect(result.unobserved).toEqual([]);
+    expect(result.newlyObserved).toEqual(["a"]);
+  });
 });
 
 describe("diffLiveArtifacts", () => {