modality-ts 0.0.15 → 0.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modality-ts",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "description": "Model-checking-based testing tools for React state-transition bugs.",
   "license": "MIT",
   "repository": {
@@ -11,6 +11,7 @@
   "types": "./dist/cli/cli.d.ts",
   "files": [
     "dist/**",
+    "native/**",
     "README.md",
     "LICENSE"
   ],
@@ -126,14 +127,15 @@
   "packageManager": "pnpm@10.12.4",
   "scripts": {
     "architecture": "depcruise --config tools/depcruise.config.cjs src",
-    "build": "tsc -b",
-    "clean": "rm -rf dist tsconfig.tsbuildinfo",
+    "build:rust": "napi build --platform --release --cargo-cwd crates/checker native",
+    "build": "pnpm build:rust && tsc -b",
+    "clean": "rm -rf dist native tsconfig.tsbuildinfo && cargo clean --manifest-path crates/checker/Cargo.toml",
     "ci:examples": "tsx tools/examples-ci.ts",
     "demo": "vitest run test/modality/demo-acceptance.test.ts",
     "fix": "biome lint --write . && biome format --write .",
     "phase7": "tsx tools/phase7-differential.ts",
     "publish:npm": "npm publish --access public",
-    "test": "vitest run",
+    "test": "pnpm build:rust && vitest run",
     "typecheck": "tsc -b"
   },
   "dependencies": {
@@ -142,9 +144,17 @@
   },
   "devDependencies": {
     "@biomejs/biome": "2.5.0",
+    "@napi-rs/cli": "^2.18.4",
     "@types/node": "^24.10.1",
     "dependency-cruiser": "^17.4.3",
     "tsx": "^4.20.6",
     "vitest": "^4.0.14"
+  },
+  "napi": {
+    "name": "modality-checker",
+    "triples": {
+      "defaults": true,
+      "additional": []
+    }
   }
 }

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

@@ -1,5 +0,0 @@
-import type { Model, ModelState, Transition } from "modality-ts/core";
-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 +0,0 @@
-{"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,25 +0,0 @@
-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, index)) {
-            enabledTransitionIds.add(transition.id);
-            blockedTransitions.add(transition.id);
-        }
-    }
-    for (const id of [...blockedTransitions].sort()) {
-        boundHits.add(`maxDepth reached before ${id}`);
-    }
-}
-export function effectContainsEnqueue(effect) {
-    if (effect.kind === "enqueue")
-        return true;
-    if (effect.kind === "seq")
-        return effect.effects.some(effectContainsEnqueue);
-    if (effect.kind === "if")
-        return (effectContainsEnqueue(effect.then) || effectContainsEnqueue(effect.else));
-    return false;
-}
-//# sourceMappingURL=bounds.js.map

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

@@ -1 +0,0 @@
-{"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/diagnostics/vacuity.d.ts

@@ -1,3 +0,0 @@
-import type { Model, ModelState } from "modality-ts/core";
-export declare function vacuityWarnings(model: Model, states: Map<string, ModelState>, enabledTransitionIds: Set<string>): string[];
-//# sourceMappingURL=vacuity.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"vacuity.d.ts","sourceRoot":"","sources":["../../../src/check/diagnostics/vacuity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE1D,wBAAgB,eAAe,CAC7B,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,EAC/B,oBAAoB,EAAE,GAAG,CAAC,MAAM,CAAC,GAChC,MAAM,EAAE,CAuBV"}

package/dist/check/diagnostics/vacuity.js

@@ -1,22 +0,0 @@
-export function vacuityWarnings(model, states, enabledTransitionIds) {
-    const warnings = [];
-    for (const transition of model.transitions) {
-        if (transition.cls !== "internal" &&
-            !enabledTransitionIds.has(transition.id)) {
-            warnings.push(`transition never enabled: ${transition.id}`);
-        }
-    }
-    for (const decl of model.vars) {
-        if (decl.domain.kind !== "enum")
-            continue;
-        const inhabited = new Set([...states.values()]
-            .map((state) => state[decl.id])
-            .filter((value) => typeof value === "string"));
-        for (const value of decl.domain.values) {
-            if (!inhabited.has(value))
-                warnings.push(`enum value never inhabited: ${decl.id}=${value}`);
-        }
-    }
-    return warnings.sort();
-}
-//# sourceMappingURL=vacuity.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"vacuity.js","sourceRoot":"","sources":["../../../src/check/diagnostics/vacuity.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,eAAe,CAC7B,KAAY,EACZ,MAA+B,EAC/B,oBAAiC;IAEjC,MAAM,QAAQ,GAAa,EAAE,CAAC;IAC9B,KAAK,MAAM,UAAU,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC;QAC3C,IACE,UAAU,CAAC,GAAG,KAAK,UAAU;YAC7B,CAAC,oBAAoB,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC,EACxC,CAAC;YACD,QAAQ,CAAC,IAAI,CAAC,6BAA6B,UAAU,CAAC,EAAE,EAAE,CAAC,CAAC;QAC9D,CAAC;IACH,CAAC;IACD,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;QAC9B,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,MAAM;YAAE,SAAS;QAC1C,MAAM,SAAS,GAAG,IAAI,GAAG,CACvB,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;aACjB,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;aAC9B,MAAM,CAAC,CAAC,KAAK,EAAmB,EAAE,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC,CACjE,CAAC;QACF,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;YACvC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC;gBACvB,QAAQ,CAAC,IAAI,CAAC,+BAA+B,IAAI,CAAC,EAAE,IAAI,KAAK,EAAE,CAAC,CAAC;QACrE,CAAC;IACH,CAAC;IACD,OAAO,QAAQ,CAAC,IAAI,EAAE,CAAC;AACzB,CAAC"}

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

@@ -1,7 +0,0 @@
-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 +0,0 @@
-{"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

@@ -1,527 +0,0 @@
-import { canonicalState, validateModel } from "modality-ts/core";
-import { effectContainsEnqueue, recordMaxDepthBoundHits, } from "../diagnostics/bounds.js";
-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 { 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, 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)) {
-        const result = checkModelSliced(model, properties, options);
-        return {
-            ...result,
-            diagnostics: mergeDiagnostics(result.diagnostics, {
-                slicing: slicingDiagnostics,
-            }),
-        };
-    }
-    const result = checkModelCore(model, properties, options);
-    return {
-        ...result,
-        diagnostics: mergeDiagnostics(result.diagnostics, {
-            slicing: slicingDiagnostics,
-        }),
-    };
-}
-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 graph = createGraphRecording(resolveEdgeRecordingMode(properties));
-    const traceCtx = { model, parents, states };
-    const enabledTransitionIds = new Set();
-    const boundHits = new Set();
-    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, 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, 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);
-    }
-    return {
-        verdicts: properties.map((property) => verdicts.get(property.name) ?? {
-            status: "verified-within-bounds",
-            property: property.name,
-        }),
-        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) {
-    return {
-        verdicts: properties.map((property) => ({
-            status: "error",
-            property: property.name,
-            message: errors.join("; "),
-        })),
-        stats: { states: 0, edges: 0, depth: 0 },
-        vacuityWarnings: [],
-        boundHits: [],
-    };
-}
-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) {
-        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, graph, traceCtx, verdicts, enabledTransitionIds, boundHits, tracker, options, startingEdgeCount, depth, index, canon) {
-    const next = [];
-    let edgeCount = 0;
-    for (const pre of frontier) {
-        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) => {
-                    boundHits.add(hit.startsWith("token cap exhausted")
-                        ? `token cap exhausted at ${transition.id}`
-                        : `${hit} at ${transition.id}`);
-                },
-            });
-            if (rawPosts.length === 0 && effectContainsEnqueue(transition.effect)) {
-                boundHits.add(`pending cap saturated at ${transition.id}`);
-            }
-            for (const rawPost of rawPosts) {
-                for (const post of stabilize(model, rawPost, changedVars(pre, rawPost, model), index, canon)) {
-                    edgeCount += 1;
-                    const postCanon = canon(post);
-                    const step = facts(pre, post, transition);
-                    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,
-                            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: sortStatesByCanon(next, canon), edges: edgeCount };
-}
-function checkModelSliced(model, properties, options = {}) {
-    const groups = new Map();
-    const sliceSummaries = [];
-    let sliceIndex = 0;
-    for (const property of properties) {
-        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) {
-            group.properties.push(property);
-        }
-        else {
-            groups.set(key, {
-                model: slice,
-                properties: [property],
-                index: sliceIndex,
-            });
-            sliceIndex += 1;
-        }
-    }
-    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();
-    let states = 0;
-    let edges = 0;
-    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);
-        for (const warning of result.vacuityWarnings)
-            vacuity.add(warning);
-        for (const hit of result.boundHits)
-            boundHits.add(hit);
-        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) ?? {
-            status: "error",
-            property: property.name,
-            message: "missing sliced verdict",
-        }),
-        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