modality-ts 0.0.10 → 0.0.12

package/README.md

@@ -36,6 +36,8 @@ Check the extracted model against a property file:
 modality check
 ```
 
+`modality check` applies conservative default search limits (`--max-states`, `--max-edges`, `--max-frontier`, `--memory-guard-mb`). Use `--no-search-limits` for intentionally unbounded runs.
+
 When a property fails, replay the generated counterexample trace:
 
 ```bash
@@ -53,7 +55,7 @@ Useful commands:
 ```bash
 modality init
 modality extract [source.tsx ...]
-modality check [model.json] [props.mjs ...]
+modality check [model.json] [props.mjs ...] [--max-states N] [--max-edges N] [--max-frontier N] [--memory-guard-mb N] [--no-search-limits]
 modality replay <trace.json>
 modality conform --count 8 --depth 4
 modality export

package/dist/check/diagnostics/bounds.d.ts

@@ -1,4 +1,5 @@
 import type { Model, ModelState, Transition } from "modality-ts/core";
-export declare function recordMaxDepthBoundHits(model: Model, frontier: readonly ModelState[], enabledTransitionIds: Set<string>, boundHits: Set<string>): void;
+import { type TransitionIndex } from "../engine/transitions.js";
+export declare function recordMaxDepthBoundHits(model: Model, frontier: readonly ModelState[], enabledTransitionIds: Set<string>, boundHits: Set<string>, index?: TransitionIndex): void;
 export declare function effectContainsEnqueue(effect: Transition["effect"]): boolean;
 //# sourceMappingURL=bounds.d.ts.map

package/dist/check/diagnostics/bounds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bounds.d.ts","sourceRoot":"","sources":["../../../src/check/diagnostics/bounds.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAGtE,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,SAAS,UAAU,EAAE,EAC/B,oBAAoB,EAAE,GAAG,CAAC,MAAM,CAAC,EACjC,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,GACrB,IAAI,CAYN;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,UAAU,CAAC,QAAQ,CAAC,GAAG,OAAO,CAQ3E"}
+{"version":3,"file":"bounds.d.ts","sourceRoot":"","sources":["../../../src/check/diagnostics/bounds.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,0BAA0B,CAAC;AAElC,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,SAAS,UAAU,EAAE,EAC/B,oBAAoB,EAAE,GAAG,CAAC,MAAM,CAAC,EACjC,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,EACtB,KAAK,CAAC,EAAE,eAAe,GACtB,IAAI,CAYN;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,UAAU,CAAC,QAAQ,CAAC,GAAG,OAAO,CAQ3E"}

package/dist/check/diagnostics/bounds.js

@@ -1,10 +1,10 @@
-import { enabledTransitions } from "../engine/transitions.js";
-export function recordMaxDepthBoundHits(model, frontier, enabledTransitionIds, boundHits) {
+import { enabledTransitions, } from "../engine/transitions.js";
+export function recordMaxDepthBoundHits(model, frontier, enabledTransitionIds, boundHits, index) {
     if (frontier.length === 0)
         return;
     const blockedTransitions = new Set();
     for (const state of frontier) {
-        for (const transition of enabledTransitions(model, state)) {
+        for (const transition of enabledTransitions(model, state, index)) {
             enabledTransitionIds.add(transition.id);
             blockedTransitions.add(transition.id);
         }

package/dist/check/diagnostics/bounds.js.map

@@ -1 +1 @@
-{"version":3,"file":"bounds.js","sourceRoot":"","sources":["../../../src/check/diagnostics/bounds.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAE9D,MAAM,UAAU,uBAAuB,CACrC,KAAY,EACZ,QAA+B,EAC/B,oBAAiC,EACjC,SAAsB;IAEtB,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO;IAClC,MAAM,kBAAkB,GAAG,IAAI,GAAG,EAAU,CAAC;IAC7C,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;QAC7B,KAAK,MAAM,UAAU,IAAI,kBAAkB,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC;YAC1D,oBAAoB,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;YACxC,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;QACxC,CAAC;IACH,CAAC;IACD,KAAK,MAAM,EAAE,IAAI,CAAC,GAAG,kBAAkB,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;QAChD,SAAS,CAAC,GAAG,CAAC,2BAA2B,EAAE,EAAE,CAAC,CAAC;IACjD,CAAC;AACH,CAAC;AAED,MAAM,UAAU,qBAAqB,CAAC,MAA4B;IAChE,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IAC3C,IAAI,MAAM,CAAC,IAAI,KAAK,KAAK;QAAE,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;IAC7E,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI;QACtB,OAAO,CACL,qBAAqB,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,qBAAqB,CAAC,MAAM,CAAC,IAAI,CAAC,CACzE,CAAC;IACJ,OAAO,KAAK,CAAC;AACf,CAAC"}
+{"version":3,"file":"bounds.js","sourceRoot":"","sources":["../../../src/check/diagnostics/bounds.ts"],"names":[],"mappings":"AACA,OAAO,EACL,kBAAkB,GAEnB,MAAM,0BAA0B,CAAC;AAElC,MAAM,UAAU,uBAAuB,CACrC,KAAY,EACZ,QAA+B,EAC/B,oBAAiC,EACjC,SAAsB,EACtB,KAAuB;IAEvB,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO;IAClC,MAAM,kBAAkB,GAAG,IAAI,GAAG,EAAU,CAAC;IAC7C,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;QAC7B,KAAK,MAAM,UAAU,IAAI,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC;YACjE,oBAAoB,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;YACxC,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;QACxC,CAAC;IACH,CAAC;IACD,KAAK,MAAM,EAAE,IAAI,CAAC,GAAG,kBAAkB,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;QAChD,SAAS,CAAC,GAAG,CAAC,2BAA2B,EAAE,EAAE,CAAC,CAAC;IACjD,CAAC;AACH,CAAC;AAED,MAAM,UAAU,qBAAqB,CAAC,MAA4B;IAChE,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IAC3C,IAAI,MAAM,CAAC,IAAI,KAAK,KAAK;QAAE,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;IAC7E,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI;QACtB,OAAO,CACL,qBAAqB,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,qBAAqB,CAAC,MAAM,CAAC,IAAI,CAAC,CACzE,CAAC;IACJ,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/check/engine/check-model.d.ts

@@ -1,4 +1,7 @@
 import type { Model, Property } from "modality-ts/core";
 import type { CheckOptions, CheckResult } from "../types.js";
+export declare function needsRecordedEdges(properties: readonly Property[]): boolean;
+export declare function needsReverseGraph(properties: readonly Property[]): boolean;
+export declare function needsStepMonitoring(properties: readonly Property[]): boolean;
 export declare function checkModel(model: Model, properties: readonly Property[], options?: CheckOptions): CheckResult;
 //# sourceMappingURL=check-model.d.ts.map

package/dist/check/engine/check-model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-model.d.ts","sourceRoot":"","sources":["../../../src/check/engine/check-model.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAc,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAWpE,OAAO,KAAK,EACV,YAAY,EACZ,WAAW,EAIZ,MAAM,aAAa,CAAC;AAUrB,wBAAgB,UAAU,CACxB,KAAK,EAAE,KAAK,EACZ,UAAU,EAAE,SAAS,QAAQ,EAAE,EAC/B,OAAO,GAAE,YAAiB,GACzB,WAAW,CASb"}
+{"version":3,"file":"check-model.d.ts","sourceRoot":"","sources":["../../../src/check/engine/check-model.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,KAAK,EAEL,QAAQ,EAGT,MAAM,kBAAkB,CAAC;AAe1B,OAAO,KAAK,EAEV,YAAY,EACZ,WAAW,EAOZ,MAAM,aAAa,CAAC;AAuBrB,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,SAAS,QAAQ,EAAE,GAAG,OAAO,CAE3E;AAED,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,SAAS,QAAQ,EAAE,GAAG,OAAO,CAE1E;AAED,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,SAAS,QAAQ,EAAE,GAAG,OAAO,CAE5E;AAqFD,wBAAgB,UAAU,CACxB,KAAK,EAAE,KAAK,EACZ,UAAU,EAAE,SAAS,QAAQ,EAAE,EAC/B,OAAO,GAAE,YAAiB,GACzB,WAAW,CAyBb"}

package/dist/check/engine/check-model.js

@@ -4,44 +4,184 @@ import { vacuityWarnings } from "../diagnostics/vacuity.js";
 import { finalizeProperties } from "../properties/finalize.js";
 import { observeEdge, observeStates } from "../properties/observe.js";
 import { applyEffect } from "../runtime/effects.js";
-import { sliceModelForProperty } from "../slicing/slice-model.js";
+import { canSliceProperty, sliceModelForProperty, } from "../slicing/slice-model.js";
 import { facts } from "../traces/step-facts.js";
 import { initialStates } from "./initial-states.js";
 import { stabilize } from "./stabilize.js";
-import { changedVars, compareStates, initialChangedVars, } from "./state-utils.js";
-import { enabledTransitions, installEnabledHook } from "./transitions.js";
+import { changedVars, initialChangedVars, sortStatesByCanon, } from "./state-utils.js";
+import { buildTransitionIndex, enabledTransitions, installEnabledHook, } from "./transitions.js";
+export function needsRecordedEdges(properties) {
+    return properties.some((property) => property.kind === "leadsToWithin");
+}
+export function needsReverseGraph(properties) {
+    return properties.some((property) => property.kind === "reachableFrom");
+}
+export function needsStepMonitoring(properties) {
+    return properties.some((property) => property.kind === "alwaysStep");
+}
+function resolveEdgeRecordingMode(properties) {
+    if (needsRecordedEdges(properties))
+        return "compact";
+    if (needsReverseGraph(properties))
+        return "reverse";
+    return "none";
+}
+function createGraphRecording(mode) {
+    return {
+        mode,
+        compactEdges: [],
+        reverseEdges: [],
+        fullEdges: [],
+    };
+}
+function recordExploredEdge(graph, properties, preCanon, postCanon, pre, post, transition, step) {
+    switch (graph.mode) {
+        case "full":
+            graph.fullEdges.push({
+                preCanon,
+                postCanon,
+                pre,
+                post,
+                transition,
+                step,
+            });
+            break;
+        case "compact":
+            graph.compactEdges.push({
+                preCanon,
+                postCanon,
+                transitionId: transition.id,
+                triggeredProperties: properties
+                    .filter((property) => property.kind === "leadsToWithin")
+                    .filter((property) => property.trigger(step))
+                    .map((property) => property.name),
+            });
+            break;
+        case "reverse":
+            graph.reverseEdges.push({ preCanon, postCanon });
+            break;
+        case "none":
+            break;
+    }
+}
+function buildStorageDiagnostics(parents, states, graph) {
+    const recordedEdges = graph.mode === "none"
+        ? 0
+        : graph.mode === "reverse"
+            ? graph.reverseEdges.length
+            : graph.mode === "compact"
+                ? graph.compactEdges.length
+                : graph.fullEdges.length;
+    return {
+        recordedEdges,
+        storedStates: states.size,
+        parentEntries: parents.size,
+        edgeRecordingMode: graph.mode,
+    };
+}
 export function checkModel(model, properties, options = {}) {
+    const slicingDiagnostics = buildSlicingRequestDiagnostics(properties, options.slicing === true);
     if (options.slicing &&
         properties.length > 0 &&
         properties.every((property) => property.reads !== undefined)) {
-        return checkModelSliced(model, properties);
+        const result = checkModelSliced(model, properties, options);
+        return {
+            ...result,
+            diagnostics: mergeDiagnostics(result.diagnostics, {
+                slicing: slicingDiagnostics,
+            }),
+        };
     }
-    return checkModelCore(model, properties);
+    const result = checkModelCore(model, properties, options);
+    return {
+        ...result,
+        diagnostics: mergeDiagnostics(result.diagnostics, {
+            slicing: slicingDiagnostics,
+        }),
+    };
 }
-function checkModelCore(model, properties) {
-    const validation = validateModel(model);
+function buildSlicingRequestDiagnostics(properties, slicingRequested) {
+    if (!slicingRequested) {
+        return { enabled: false };
+    }
+    if (properties.length === 0) {
+        return { enabled: false, skipped: true, skipReason: "no properties" };
+    }
+    if (!properties.every((property) => property.reads !== undefined)) {
+        return {
+            enabled: false,
+            skipped: true,
+            skipReason: "property missing reads",
+        };
+    }
+    return { enabled: true };
+}
+function checkModelCore(model, properties, options = {}) {
+    const validation = validateModel(model, { sliced: options.slicedModel });
     if (!validation.ok)
         return invalidModelResult(properties, validation.errors);
+    const startedAt = options.trackElapsed ? Date.now() : undefined;
     installEnabledHook(model);
+    const transitionIndex = buildTransitionIndex(model);
+    const canonCache = new WeakMap();
+    const canon = (state) => {
+        const cached = canonCache.get(state);
+        if (cached !== undefined)
+            return cached;
+        const encoded = canonicalState(model, state);
+        canonCache.set(state, encoded);
+        return encoded;
+    };
     const parents = new Map();
     const states = new Map();
-    const edges = [];
+    const graph = createGraphRecording(resolveEdgeRecordingMode(properties));
+    const traceCtx = { model, parents, states };
     const enabledTransitionIds = new Set();
     const boundHits = new Set();
-    let frontier = seedFrontier(model, parents, states);
+    const tracker = createSearchTracker(model);
+    let frontier = seedFrontier(model, parents, states, tracker, transitionIndex, canon);
     const verdicts = new Map();
     let depth = 0;
     let edgeCount = 0;
-    observeStates(model, properties, frontier, parents, verdicts);
-    while (frontier.length > 0 && depth < model.bounds.maxDepth) {
-        const result = exploreDepth(model, properties, frontier, parents, states, edges, verdicts, enabledTransitionIds, boundHits);
+    observeStates(model, properties, frontier, traceCtx, verdicts);
+    recordDominantVars(model, frontier, tracker);
+    while (frontier.length > 0 &&
+        depth < model.bounds.maxDepth &&
+        tracker.limitHit === null) {
+        tracker.maxFrontier = Math.max(tracker.maxFrontier, frontier.length);
+        tracker.finalFrontier = frontier.length;
+        const limit = checkSearchLimits(options, parents.size, edgeCount, frontier.length, depth);
+        if (limit) {
+            tracker.limitHit = limit;
+            break;
+        }
+        const result = exploreDepth(model, properties, frontier, parents, states, graph, traceCtx, verdicts, enabledTransitionIds, boundHits, tracker, options, edgeCount, depth, transitionIndex, canon);
         frontier = result.next;
         edgeCount += result.edges;
-        observeStates(model, properties, frontier, parents, verdicts);
+        observeStates(model, properties, frontier, traceCtx, verdicts);
+        recordDominantVars(model, frontier, tracker);
         depth += 1;
+        tracker.expandedDepths = depth;
+        options.onProgress?.({
+            depth,
+            frontier: frontier.length,
+            nextFrontier: frontier.length,
+            states: parents.size,
+            edges: edgeCount,
+        });
+        const postLimit = checkSearchLimits(options, parents.size, edgeCount, frontier.length, depth);
+        if (postLimit) {
+            tracker.limitHit = postLimit;
+            break;
+        }
+    }
+    recordMaxDepthBoundHits(model, frontier, enabledTransitionIds, boundHits, transitionIndex);
+    if (tracker.limitHit) {
+        applySearchLimitVerdicts(properties, verdicts, tracker.limitHit);
+    }
+    else {
+        finalizeProperties(model, properties, traceCtx, graph, verdicts);
     }
-    recordMaxDepthBoundHits(model, frontier, enabledTransitionIds, boundHits);
-    finalizeProperties(model, properties, parents, states, edges, verdicts);
     return {
         verdicts: properties.map((property) => verdicts.get(property.name) ?? {
             status: "verified-within-bounds",
@@ -50,6 +190,7 @@ function checkModelCore(model, properties) {
         stats: { states: parents.size, edges: edgeCount, depth },
         vacuityWarnings: vacuityWarnings(model, states, enabledTransitionIds),
         boundHits: [...boundHits].sort(),
+        diagnostics: buildSearchDiagnostics(tracker, startedAt, buildStorageDiagnostics(parents, states, graph), transitionIndex),
     };
 }
 function invalidModelResult(properties, errors) {
@@ -64,30 +205,125 @@ function invalidModelResult(properties, errors) {
         boundHits: [],
     };
 }
-function seedFrontier(model, parents, states) {
-    const frontier = initialStates(model)
-        .flatMap((state) => stabilize(model, state, initialChangedVars(model)))
-        .sort(compareStates(model));
+function createSearchTracker(model) {
+    return {
+        maxFrontier: 0,
+        finalFrontier: 0,
+        expandedDepths: 0,
+        dominantVarValues: new Map(model.vars.map((decl) => [decl.id, new Set()])),
+        limitHit: null,
+    };
+}
+function recordDominantVars(model, frontier, tracker) {
     for (const state of frontier) {
-        const canon = canonicalState(model, state);
-        if (!parents.has(canon)) {
-            parents.set(canon, {
-                parent: null,
-                transition: null,
-                pre: null,
-                post: state,
-            });
-            states.set(canon, state);
+        for (const decl of model.vars) {
+            const value = JSON.stringify(state[decl.id]);
+            tracker.dominantVarValues.get(decl.id)?.add(value);
+        }
+    }
+}
+function buildSearchDiagnostics(tracker, startedAt, storage, transitionIndex) {
+    const dominantVars = [...tracker.dominantVarValues.entries()]
+        .map(([varId, values]) => ({ varId, distinctValues: values.size }))
+        .filter((entry) => entry.distinctValues > 0)
+        .sort((left, right) => right.distinctValues - left.distinctValues)
+        .slice(0, 5);
+    const search = {
+        maxFrontier: tracker.maxFrontier,
+        finalFrontier: tracker.finalFrontier,
+        expandedDepths: tracker.expandedDepths,
+    };
+    if (startedAt !== undefined) {
+        search.elapsedMs = Date.now() - startedAt;
+    }
+    return {
+        search,
+        storage,
+        hotPath: {
+            canonicalCache: true,
+            transitionIndex: true,
+            internalTransitionIndex: transitionIndex.internalTransitions.length > 0,
+        },
+        ...(tracker.limitHit ? { limits: tracker.limitHit } : {}),
+        ...(dominantVars.length > 0 ? { dominantVars } : {}),
+    };
+}
+function hitSearchLimit(tracker, options, states, edges, frontier, depth) {
+    if (tracker.limitHit !== null)
+        return true;
+    const limit = checkSearchLimits(options, states, edges, frontier, depth);
+    if (!limit)
+        return false;
+    tracker.limitHit = limit;
+    return true;
+}
+function checkSearchLimits(options, states, edges, frontier, depth) {
+    if (options.maxStates !== undefined && states >= options.maxStates) {
+        return {
+            reason: `search limit exceeded: maxStates=${options.maxStates}`,
+            maxStates: options.maxStates,
+        };
+    }
+    if (options.maxEdges !== undefined && edges >= options.maxEdges) {
+        return {
+            reason: `search limit exceeded: maxEdges=${options.maxEdges}`,
+            maxEdges: options.maxEdges,
+        };
+    }
+    if (options.maxFrontier !== undefined && frontier >= options.maxFrontier) {
+        return {
+            reason: `search limit exceeded: maxFrontier=${options.maxFrontier}`,
+            maxFrontier: options.maxFrontier,
+        };
+    }
+    const maxHeap = options.memoryGuard?.maxHeapUsedBytes;
+    if (maxHeap !== undefined && process.memoryUsage().heapUsed >= maxHeap) {
+        return {
+            reason: `search limit exceeded: memoryGuard=${maxHeap}`,
+            memoryGuardBytes: maxHeap,
+        };
+    }
+    void depth;
+    return null;
+}
+function applySearchLimitVerdicts(properties, verdicts, limit) {
+    for (const property of properties) {
+        const verdict = verdicts.get(property.name);
+        if (verdict &&
+            (verdict.status === "violated" ||
+                verdict.status === "reachable" ||
+                verdict.status === "vacuous-warning" ||
+                verdict.status === "error")) {
+            continue;
+        }
+        verdicts.set(property.name, {
+            status: "error",
+            property: property.name,
+            message: limit.reason,
+        });
+    }
+}
+function seedFrontier(model, parents, states, tracker, index, canon) {
+    const frontier = sortStatesByCanon(initialStates(model).flatMap((state) => stabilize(model, state, initialChangedVars(model), index, canon)), canon);
+    tracker.maxFrontier = Math.max(tracker.maxFrontier, frontier.length);
+    tracker.finalFrontier = frontier.length;
+    for (const state of frontier) {
+        const key = canon(state);
+        if (!parents.has(key)) {
+            parents.set(key, { parent: null, transitionId: null });
+            states.set(key, state);
         }
     }
     return frontier;
 }
-function exploreDepth(model, properties, frontier, parents, states, edges, verdicts, enabledTransitionIds, boundHits) {
+function exploreDepth(model, properties, frontier, parents, states, graph, traceCtx, verdicts, enabledTransitionIds, boundHits, tracker, options, startingEdgeCount, depth, index, canon) {
     const next = [];
     let edgeCount = 0;
     for (const pre of frontier) {
-        const preCanon = canonicalState(model, pre);
-        for (const transition of enabledTransitions(model, pre)) {
+        if (tracker.limitHit !== null)
+            break;
+        const preCanon = canon(pre);
+        for (const transition of enabledTransitions(model, pre, index)) {
             enabledTransitionIds.add(transition.id);
             const rawPosts = applyEffect(model, pre, transition.effect, {
                 onBoundHit: (hit) => {
@@ -100,35 +336,92 @@ function exploreDepth(model, properties, frontier, parents, states, edges, verdi
                 boundHits.add(`pending cap saturated at ${transition.id}`);
             }
             for (const rawPost of rawPosts) {
-                for (const post of stabilize(model, rawPost, changedVars(pre, rawPost))) {
+                for (const post of stabilize(model, rawPost, changedVars(pre, rawPost, model), index, canon)) {
                     edgeCount += 1;
-                    const postCanon = canonicalState(model, post);
+                    const postCanon = canon(post);
                     const step = facts(pre, post, transition);
-                    edges.push({ preCanon, postCanon, pre, post, transition, step });
-                    observeEdge(model, properties, pre, post, transition, step, parents, verdicts);
+                    recordExploredEdge(graph, properties, preCanon, postCanon, pre, post, transition, step);
+                    observeEdge(model, properties, pre, post, transition, step, traceCtx, verdicts);
+                    if (hitSearchLimit(tracker, options, parents.size, startingEdgeCount + edgeCount, next.length, depth)) {
+                        break;
+                    }
                     if (!parents.has(postCanon)) {
-                        parents.set(postCanon, { parent: preCanon, transition, pre, post });
+                        parents.set(postCanon, {
+                            parent: preCanon,
+                            transitionId: transition.id,
+                        });
                         states.set(postCanon, post);
                         next.push(post);
+                        tracker.maxFrontier = Math.max(tracker.maxFrontier, next.length);
+                        if (hitSearchLimit(tracker, options, parents.size, startingEdgeCount + edgeCount, next.length, depth)) {
+                            break;
+                        }
                     }
                 }
+                if (tracker.limitHit !== null)
+                    break;
             }
+            if (tracker.limitHit !== null)
+                break;
         }
+        if (tracker.limitHit !== null)
+            break;
     }
-    return { next: next.sort(compareStates(model)), edges: edgeCount };
+    return { next: sortStatesByCanon(next, canon), edges: edgeCount };
 }
-function checkModelSliced(model, properties) {
+function checkModelSliced(model, properties, options = {}) {
     const groups = new Map();
+    const sliceSummaries = [];
+    let sliceIndex = 0;
     for (const property of properties) {
-        const slice = sliceModelForProperty(model, property);
+        const slice = canSliceProperty(property)
+            ? sliceModelForProperty(model, property)
+            : model;
         const key = slice.vars.map((decl) => decl.id).join("\0");
         const group = groups.get(key);
-        if (group)
+        if (group) {
             group.properties.push(property);
-        else
-            groups.set(key, { model: slice, properties: [property] });
+        }
+        else {
+            groups.set(key, {
+                model: slice,
+                properties: [property],
+                index: sliceIndex,
+            });
+            sliceIndex += 1;
+        }
     }
-    return combineSlicedResults(properties, [...groups.values()].map((group) => checkModelCore(group.model, group.properties)));
+    const results = [...groups.values()].map((group) => {
+        const result = checkModelCore(group.model, group.properties, {
+            ...options,
+            slicedModel: true,
+        });
+        sliceSummaries.push({
+            index: group.index,
+            properties: group.properties.map((property) => property.name),
+            vars: group.model.vars.length,
+            transitions: group.model.transitions.length,
+            states: result.stats.states,
+            edges: result.stats.edges,
+            depth: result.stats.depth,
+        });
+        return result;
+    });
+    sliceSummaries.sort((left, right) => left.index - right.index);
+    const combined = combineSlicedResults(properties, results);
+    return {
+        ...combined,
+        diagnostics: mergeDiagnostics(combined.diagnostics, {
+            slicing: {
+                enabled: true,
+                slices: sliceSummaries.length,
+                sliceSummaries,
+            },
+            search: combined.diagnostics?.search,
+            limits: combined.diagnostics?.limits,
+            dominantVars: combined.diagnostics?.dominantVars,
+        }),
+    };
 }
 function combineSlicedResults(properties, results) {
     const verdicts = new Map();
@@ -137,6 +430,7 @@ function combineSlicedResults(properties, results) {
     let depth = 0;
     const vacuity = new Set();
     const boundHits = new Set();
+    let diagnostics;
     for (const result of results) {
         for (const verdict of result.verdicts)
             verdicts.set(verdict.property, verdict);
@@ -147,6 +441,7 @@ function combineSlicedResults(properties, results) {
         states += result.stats.states;
         edges += result.stats.edges;
         depth = Math.max(depth, result.stats.depth);
+        diagnostics = mergeSearchDiagnostics(diagnostics, result.diagnostics);
     }
     return {
         verdicts: properties.map((property) => verdicts.get(property.name) ?? {
@@ -157,6 +452,76 @@ function combineSlicedResults(properties, results) {
         stats: { states, edges, depth },
         vacuityWarnings: [...vacuity].sort(),
         boundHits: [...boundHits].sort(),
+        diagnostics,
+    };
+}
+function mergeDiagnostics(base, overlay) {
+    if (!base && !overlay)
+        return undefined;
+    return {
+        ...base,
+        ...overlay,
+        slicing: base?.slicing || overlay?.slicing
+            ? {
+                enabled: overlay?.slicing?.enabled ?? base?.slicing?.enabled ?? false,
+                slices: overlay?.slicing?.slices ?? base?.slicing?.slices,
+                skipped: overlay?.slicing?.skipped ?? base?.slicing?.skipped,
+                skipReason: overlay?.slicing?.skipReason ?? base?.slicing?.skipReason,
+                sliceSummaries: overlay?.slicing?.sliceSummaries ?? base?.slicing?.sliceSummaries,
+            }
+            : undefined,
+        search: overlay?.search ?? base?.search,
+        limits: overlay?.limits ?? base?.limits,
+        dominantVars: overlay?.dominantVars ?? base?.dominantVars,
+        storage: overlay?.storage ?? base?.storage,
+        hotPath: overlay?.hotPath ?? base?.hotPath,
     };
 }
+function mergeSearchDiagnostics(left, right) {
+    if (!left)
+        return right;
+    if (!right)
+        return left;
+    const dominant = mergeDominantVars(left.dominantVars, right.dominantVars);
+    return {
+        slicing: left.slicing ?? right.slicing,
+        search: {
+            maxFrontier: Math.max(left.search?.maxFrontier ?? 0, right.search?.maxFrontier ?? 0),
+            finalFrontier: Math.max(left.search?.finalFrontier ?? 0, right.search?.finalFrontier ?? 0),
+            expandedDepths: Math.max(left.search?.expandedDepths ?? 0, right.search?.expandedDepths ?? 0),
+            elapsedMs: left.search?.elapsedMs !== undefined ||
+                right.search?.elapsedMs !== undefined
+                ? (left.search?.elapsedMs ?? 0) + (right.search?.elapsedMs ?? 0)
+                : undefined,
+        },
+        limits: left.limits ?? right.limits,
+        dominantVars: dominant,
+        storage: mergeStorageDiagnostics(left.storage, right.storage),
+        hotPath: left.hotPath ?? right.hotPath,
+    };
+}
+function mergeStorageDiagnostics(left, right) {
+    if (!left)
+        return right;
+    if (!right)
+        return left;
+    return {
+        recordedEdges: left.recordedEdges + right.recordedEdges,
+        storedStates: left.storedStates + right.storedStates,
+        parentEntries: left.parentEntries + right.parentEntries,
+        edgeRecordingMode: left.edgeRecordingMode === right.edgeRecordingMode
+            ? left.edgeRecordingMode
+            : "property-specific",
+    };
+}
+function mergeDominantVars(left, right) {
+    const counts = new Map();
+    for (const entry of [...(left ?? []), ...(right ?? [])]) {
+        counts.set(entry.varId, Math.max(counts.get(entry.varId) ?? 0, entry.distinctValues));
+    }
+    return [...counts.entries()]
+        .map(([varId, distinctValues]) => ({ varId, distinctValues }))
+        .sort((a, b) => b.distinctValues - a.distinctValues)
+        .slice(0, 5);
+}
 //# sourceMappingURL=check-model.js.map