@cavelang/solver-z3 0.35.0 → 0.36.1

package/dist/src/cleanup.js

@@ -0,0 +1,65 @@
+import { errorMessage } from "./error-message.js";
+/**
+ * The binding's finalizers call this instance's low-level API directly, outside
+ * its async mutex. Native AST deletion must not race a pthread solver check.
+ * Guard the two async native operations CAVE uses; normal synchronous releases
+ * remain immediate, and queued releases drain before a check returns to CAVE.
+ */
+export const guardCleanup = (api) => {
+    const functions = api;
+    const pending = [];
+    let checking = 0;
+    for (const [name, value] of Object.entries(functions)) {
+        if (typeof value !== 'function')
+            continue;
+        if (name === 'dec_ref' || name.endsWith('_dec_ref') || name === 'del_context') {
+            functions[name] = (...args) => {
+                const release = () => { value.apply(api, args); };
+                if (checking > 0)
+                    pending.push(release);
+                else
+                    release();
+            };
+        }
+    }
+    for (const name of ['solver_check_assumptions', 'optimize_check']) {
+        const check = functions[name];
+        if (typeof check !== 'function')
+            throw new TypeError(`Z3 is missing ${name}`);
+        functions[name] = async (...args) => {
+            checking++;
+            let checkFailed = false;
+            let checkError;
+            try {
+                return await check.apply(api, args);
+            }
+            catch (error) {
+                checkFailed = true;
+                checkError = error;
+                throw error;
+            }
+            finally {
+                checking--;
+                if (checking === 0) {
+                    const releases = pending.splice(0);
+                    const failures = [];
+                    for (const release of releases) {
+                        try {
+                            release();
+                        }
+                        catch (error) {
+                            failures.push(error);
+                        }
+                    }
+                    if (failures.length > 0) {
+                        if (!checkFailed && failures.length === 1)
+                            throw failures[0];
+                        const errors = checkFailed ? [checkError, ...failures] : failures;
+                        throw new AggregateError(errors, `Z3 native cleanup failed: ${errors.map(errorMessage).join('; ')}`, checkFailed ? { cause: checkError } : undefined);
+                    }
+                }
+            }
+        };
+    }
+};
+//# sourceMappingURL=cleanup.js.map

package/dist/src/cleanup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanup.js","sourceRoot":"","sources":["../../src/cleanup.ts"],"names":[],"mappings":"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"}

package/dist/src/close-workers.d.ts

@@ -0,0 +1,12 @@
+type Worker = {
+    terminate: () => Promise<unknown>;
+};
+type Pool = {
+    readonly runningWorkers: readonly Worker[];
+    readonly unusedWorkers: readonly Worker[];
+    terminateAllThreads: () => void;
+};
+/** Keep Emscripten's message handlers until Node confirms each worker has exited. */
+export declare const closeWorkers: (pool: Pool | undefined) => Promise<void>;
+export {};
+//# sourceMappingURL=close-workers.d.ts.map

package/dist/src/close-workers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"close-workers.d.ts","sourceRoot":"","sources":["../../src/close-workers.ts"],"names":[],"mappings":"AACA,KAAK,MAAM,GAAG;IAAE,SAAS,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAA;AACnD,KAAK,IAAI,GAAG;IACV,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAA;IAC1C,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAA;IACzC,mBAAmB,EAAE,MAAM,IAAI,CAAA;CAChC,CAAA;AAED,qFAAqF;AACrF,eAAO,MAAM,YAAY,GAAU,MAAM,IAAI,GAAG,SAAS,KAAG,OAAO,CAAC,IAAI,CAkBvE,CAAA"}

package/dist/src/close-workers.js

@@ -0,0 +1,27 @@
+import { errorMessage } from "./error-message.js";
+/** Keep Emscripten's message handlers until Node confirms each worker has exited. */
+export const closeWorkers = async (pool) => {
+    if (pool === undefined)
+        return;
+    const stopped = new Set();
+    while (true) {
+        const workers = [...new Set([...pool.runningWorkers, ...pool.unusedWorkers])]
+            .filter(worker => !stopped.has(worker));
+        if (workers.length === 0)
+            break;
+        for (const worker of workers)
+            stopped.add(worker);
+        // A throwing termination must not prevent attempts on the remaining workers.
+        // Keep handlers alive until every attempted termination has settled.
+        const results = await Promise.allSettled(workers.map(async (worker) => worker.terminate()));
+        const failures = results.flatMap(result => result.status === 'rejected' ? [result.reason] : []);
+        if (failures.length === 1)
+            throw failures[0];
+        if (failures.length > 1)
+            throw new AggregateError(failures, `Z3 worker termination failed: ${failures.map(errorMessage).join('; ')}`);
+    }
+    // The binding replaces handlers with warnings when it clears the pool.
+    // Worker exit acknowledgments ensure pending cleanup messages came first.
+    pool.terminateAllThreads();
+};
+//# sourceMappingURL=close-workers.js.map

package/dist/src/close-workers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"close-workers.js","sourceRoot":"","sources":["../../src/close-workers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAQjD,qFAAqF;AACrF,MAAM,CAAC,MAAM,YAAY,GAAG,KAAK,EAAE,IAAsB,EAAiB,EAAE;IAC1E,IAAI,IAAI,KAAK,SAAS;QAAE,OAAM;IAC9B,MAAM,OAAO,GAAG,IAAI,GAAG,EAAU,CAAA;IACjC,OAAO,IAAI,EAAE,CAAC;QACZ,MAAM,OAAO,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,cAAc,EAAE,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;aAC1E,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;QACzC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;YAAE,MAAK;QAC/B,KAAK,MAAM,MAAM,IAAI,OAAO;YAAE,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;QACjD,6EAA6E;QAC7E,qEAAqE;QACrE,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,EAAC,MAAM,EAAC,EAAE,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,CAAA;QACzF,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,KAAK,UAAU,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;QAC/F,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;YAAE,MAAM,QAAQ,CAAC,CAAC,CAAC,CAAA;QAC5C,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC;YAAE,MAAM,IAAI,cAAc,CAAC,QAAQ,EAAE,iCAAiC,QAAQ,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;IACvI,CAAC;IACD,uEAAuE;IACvE,0EAA0E;IAC1E,IAAI,CAAC,mBAAmB,EAAE,CAAA;AAC5B,CAAC,CAAA"}

package/dist/src/deadline.d.ts

@@ -0,0 +1,7 @@
+export declare const withDeadline: (context: {
+    interrupt: () => void;
+}, timeoutMs: number, check: () => Promise<"sat" | "unsat" | "unknown">) => Promise<{
+    readonly status: "sat" | "unsat" | "unknown";
+    readonly interrupted: boolean;
+}>;
+//# sourceMappingURL=deadline.d.ts.map

package/dist/src/deadline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deadline.d.ts","sourceRoot":"","sources":["../../src/deadline.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,GACvB,SAAS;IAAE,SAAS,EAAE,MAAM,IAAI,CAAA;CAAE,EAClC,WAAW,MAAM,EACjB,OAAO,MAAM,OAAO,CAAC,KAAK,GAAG,OAAO,GAAG,SAAS,CAAC,KAChD,OAAO,CAAC;IAAE,QAAQ,CAAC,MAAM,EAAE,KAAK,GAAG,OAAO,GAAG,SAAS,CAAC;IAAC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAA;CAAE,CAkCzF,CAAA"}

package/dist/src/deadline.js

@@ -0,0 +1,46 @@
+export const withDeadline = async (context, timeoutMs, check) => {
+    let interrupted = false;
+    let interruptFailed = false;
+    let interruptError;
+    // Dispatch and native cancellation are asynchronous. Keep requesting cancellation
+    // until the check settles instead of assuming one interrupt was acknowledged.
+    const interrupt = () => {
+        interrupted = true;
+        try {
+            context.interrupt();
+        }
+        catch (error) {
+            // Timer failures belong to this check, not the host's uncaught-error
+            // handler. Retain one error while continuing cooperative cancellation.
+            if (!interruptFailed) {
+                interruptFailed = true;
+                interruptError = error;
+            }
+        }
+        timer = setTimeout(interrupt, 50);
+        timer.unref();
+    };
+    let timer = setTimeout(interrupt, timeoutMs);
+    timer.unref();
+    try {
+        let status;
+        try {
+            status = await check();
+        }
+        catch (error) {
+            if (interruptFailed) {
+                throw new AggregateError([error, interruptError], `Z3 check failed: ${errorMessage(error)}; deadline interruption also failed: ${errorMessage(interruptError)}`, { cause: error });
+            }
+            throw error;
+        }
+        // Wait for native work before the caller releases its solver/optimizer.
+        if (interruptFailed)
+            throw interruptError;
+        return { status, interrupted };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+};
+import { errorMessage } from "./error-message.js";
+//# sourceMappingURL=deadline.js.map

package/dist/src/deadline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deadline.js","sourceRoot":"","sources":["../../src/deadline.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,YAAY,GAAG,KAAK,EAC/B,OAAkC,EAClC,SAAiB,EACjB,KAAiD,EACyC,EAAE;IAC5F,IAAI,WAAW,GAAG,KAAK,CAAA;IACvB,IAAI,eAAe,GAAG,KAAK,CAAA;IAC3B,IAAI,cAAuB,CAAA;IAC3B,kFAAkF;IAClF,8EAA8E;IAC9E,MAAM,SAAS,GAAG,GAAS,EAAE;QAC3B,WAAW,GAAG,IAAI,CAAA;QAClB,IAAI,CAAC;YAAC,OAAO,CAAC,SAAS,EAAE,CAAA;QAAC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACzC,qEAAqE;YACrE,uEAAuE;YACvE,IAAI,CAAC,eAAe,EAAE,CAAC;gBAAC,eAAe,GAAG,IAAI,CAAC;gBAAC,cAAc,GAAG,KAAK,CAAA;YAAC,CAAC;QAC1E,CAAC;QACD,KAAK,GAAG,UAAU,CAAC,SAAS,EAAE,EAAE,CAAC,CAAA;QACjC,KAAK,CAAC,KAAK,EAAE,CAAA;IACf,CAAC,CAAA;IACD,IAAI,KAAK,GAAG,UAAU,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;IAC5C,KAAK,CAAC,KAAK,EAAE,CAAA;IACb,IAAI,CAAC;QACH,IAAI,MAAmC,CAAA;QACvC,IAAI,CAAC;YAAC,MAAM,GAAG,MAAM,KAAK,EAAE,CAAA;QAAC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YAC5C,IAAI,eAAe,EAAE,CAAC;gBACpB,MAAM,IAAI,cAAc,CAAC,CAAC,KAAK,EAAE,cAAc,CAAC,EAC9C,oBAAoB,YAAY,CAAC,KAAK,CAAC,wCAAwC,YAAY,CAAC,cAAc,CAAC,EAAE,EAC7G,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAA;YACrB,CAAC;YACD,MAAM,KAAK,CAAA;QACb,CAAC;QACD,wEAAwE;QACxE,IAAI,eAAe;YAAE,MAAM,cAAc,CAAA;QACzC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,CAAA;IAChC,CAAC;YAAS,CAAC;QACT,YAAY,CAAC,KAAK,CAAC,CAAA;IACrB,CAAC;AACH,CAAC,CAAA;AACD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA"}

package/dist/src/error-message.d.ts

@@ -0,0 +1,3 @@
+/** Formatting a failure must not prevent runtime cleanup or replace its diagnostic. */
+export declare const errorMessage: (error: unknown) => string;
+//# sourceMappingURL=error-message.d.ts.map

package/dist/src/error-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-message.d.ts","sourceRoot":"","sources":["../../src/error-message.ts"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,eAAO,MAAM,YAAY,GAAI,OAAO,OAAO,KAAG,MAG7C,CAAA"}

package/dist/src/error-message.js

@@ -0,0 +1,10 @@
+/** Formatting a failure must not prevent runtime cleanup or replace its diagnostic. */
+export const errorMessage = (error) => {
+    try {
+        return error instanceof Error ? String(error.message) : String(error);
+    }
+    catch {
+        return '[unprintable thrown value]';
+    }
+};
+//# sourceMappingURL=error-message.js.map

package/dist/src/error-message.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-message.js","sourceRoot":"","sources":["../../src/error-message.ts"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,KAAc,EAAU,EAAE;IACrD,IAAI,CAAC;QAAC,OAAO,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;IAAC,CAAC;IAC7E,MAAM,CAAC;QAAC,OAAO,4BAA4B,CAAA;IAAC,CAAC;AAC/C,CAAC,CAAA"}

package/dist/src/runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/runtime.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAgB,MAAM,kBAAkB,CAAA;AA+BxD,MAAM,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC,GAAG;IAChC,8DAA8D;IAC9D,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;IACjC,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CACpC,CAAA;AAqbD,+DAA+D;AAC/D,eAAO,MAAM,MAAM,QAAO,OAAO,CAAC,OAAO,CAGvC,CAAA"}
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/runtime.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,OAAO,EAAgB,MAAM,kBAAkB,CAAA;AAiCxD,MAAM,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC,GAAG;IAChC,8DAA8D;IAC9D,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;IACjC,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CACpC,CAAA;AA8eD,+DAA+D;AAC/D,eAAO,MAAM,MAAM,QAAO,OAAO,CAAC,OAAO,CAGvC,CAAA"}

package/dist/src/runtime.js

@@ -1,10 +1,15 @@
+import { withDeadline } from "./deadline.js";
+import { withRelease } from "./with-release.js";
+import { errorMessage } from "./error-message.js";
 import { performance } from 'node:perf_hooks';
 import { Adapter, Exact, Model } from '@cavelang/solver';
+import { guardCleanup } from "./cleanup.js";
+import { closeWorkers } from "./close-workers.js";
 const backendError = (backend, started, error) => ({
     status: 'unknown',
     reason: {
         kind: 'backend-error',
-        message: error instanceof Error ? error.message : String(error)
+        message: errorMessage(error)
     },
     backend,
     diagnostics: [],
@@ -29,6 +34,7 @@ const compiler = (context, model) => {
         domain.id,
         [...domain.values].sort(compareText)
     ]));
+    const enumCodes = new Map([...enums].map(([domain, values]) => [domain, new Map(values.map((value, index) => [value, index]))]));
     const variables = new Map();
     const bounds = [];
     for (const variable of model.variables) {
@@ -62,47 +68,110 @@ const compiler = (context, model) => {
             }
         }
     }
-    const compile = (expression) => {
+    const expressions = new WeakMap();
+    const compiledChild = (expression) => expressions.get(expression);
+    const compileBoolean = (kind, operands) => {
+        const combine = (values) => kind === 'and' ? context.And(...values) : context.Or(...values);
+        let values = operands.map(value => asBool(compiledChild(value)));
+        // The binding also spreads arguments internally, including its AstVector
+        // overload. Bound every call and retain all operands through associativity.
+        const width = 1024;
+        while (values.length > width) {
+            const groups = [];
+            for (let index = 0; index < values.length; index += width) {
+                groups.push(combine(values.slice(index, index + width)));
+            }
+            values = groups;
+        }
+        return combine(values);
+    };
+    const compileNode = (expression) => {
         switch (expression.kind) {
             case 'literal':
                 switch (expression.sort) {
                     case 'bool': return context.Bool.val(expression.value);
                     case 'int': return context.Int.val(Exact.integer(expression.value));
                     case 'real': return context.Real.val(exact(expression.value));
-                    case 'enum': return context.Int.val(enums.get(expression.domain).indexOf(expression.value));
+                    case 'enum': return context.Int.val(enumCodes.get(expression.domain).get(expression.value));
                 }
             case 'variable': return variables.get(expression.id);
-            case 'not': return asBool(compile(expression.value)).not();
-            case 'and': return context.And(...expression.operands.map(value => asBool(compile(value))));
-            case 'or': return context.Or(...expression.operands.map(value => asBool(compile(value))));
-            case 'implies': return context.Implies(asBool(compile(expression.left)), asBool(compile(expression.right)));
-            case 'eq': return compile(expression.left).eq(compile(expression.right));
-            case 'neq': return compile(expression.left).neq(compile(expression.right));
-            case 'lt': return asArith(compile(expression.left)).lt(asArith(compile(expression.right)));
-            case 'lte': return asArith(compile(expression.left)).le(asArith(compile(expression.right)));
-            case 'gt': return asArith(compile(expression.left)).gt(asArith(compile(expression.right)));
-            case 'gte': return asArith(compile(expression.left)).ge(asArith(compile(expression.right)));
+            case 'not': return asBool(compiledChild(expression.value)).not();
+            case 'and':
+            case 'or': return compileBoolean(expression.kind, expression.operands);
+            case 'implies': return context.Implies(asBool(compiledChild(expression.left)), asBool(compiledChild(expression.right)));
+            case 'eq': return compiledChild(expression.left).eq(compiledChild(expression.right));
+            case 'neq': return compiledChild(expression.left).neq(compiledChild(expression.right));
+            case 'lt': return asArith(compiledChild(expression.left)).lt(asArith(compiledChild(expression.right)));
+            case 'lte': return asArith(compiledChild(expression.left)).le(asArith(compiledChild(expression.right)));
+            case 'gt': return asArith(compiledChild(expression.left)).gt(asArith(compiledChild(expression.right)));
+            case 'gte': return asArith(compiledChild(expression.left)).ge(asArith(compiledChild(expression.right)));
             case 'add': {
-                const [first, ...rest] = expression.operands.map(value => asArith(compile(value)));
+                const [first, ...rest] = expression.operands.map(value => asArith(compiledChild(value)));
                 return rest.reduce((left, right) => left.add(right), first);
             }
             case 'multiply': {
-                const [first, ...rest] = expression.operands.map(value => asArith(compile(value)));
+                const [first, ...rest] = expression.operands.map(value => asArith(compiledChild(value)));
                 return rest.reduce((left, right) => left.mul(right), first);
             }
-            case 'subtract': return asArith(compile(expression.left)).sub(asArith(compile(expression.right)));
+            case 'subtract': return asArith(compiledChild(expression.left)).sub(asArith(compiledChild(expression.right)));
             case 'divide': {
-                const left = asArith(compile(expression.left));
-                const right = asArith(compile(expression.right));
+                const left = asArith(compiledChild(expression.left));
+                const right = asArith(compiledChild(expression.right));
                 // Portable division is exact-real division even when both operands are
                 // integers; Z3's native Int / Int operation would truncate instead.
                 const real = (value) => context.isInt(value) ? context.ToReal(value) : value;
                 return real(left).div(real(right));
             }
-            case 'negate': return asArith(compile(expression.value)).neg();
-            case 'if': return context.If(asBool(compile(expression.condition)), compile(expression.then), compile(expression.else));
+            case 'negate': return asArith(compiledChild(expression.value)).neg();
+            case 'if': return context.If(asBool(compiledChild(expression.condition)), compiledChild(expression.then), compiledChild(expression.else));
         }
     };
+    function* children(expression) {
+        switch (expression.kind) {
+            case 'literal':
+            case 'variable': return;
+            case 'not':
+            case 'negate':
+                yield expression.value;
+                return;
+            case 'and':
+            case 'or':
+            case 'add':
+            case 'multiply':
+                yield* expression.operands;
+                return;
+            case 'if':
+                yield expression.condition;
+                yield expression.then;
+                yield expression.else;
+                return;
+            default:
+                yield expression.left;
+                yield expression.right;
+        }
+    }
+    const compile = (expression) => {
+        if (expressions.has(expression))
+            return expressions.get(expression);
+        const stack = [{ expression, children: children(expression) }];
+        const active = new WeakSet([expression]);
+        while (stack.length > 0) {
+            const frame = stack[stack.length - 1];
+            const child = frame.children.next();
+            if (child.done) {
+                expressions.set(frame.expression, compileNode(frame.expression));
+                active.delete(frame.expression);
+                stack.pop();
+            }
+            else if (!expressions.has(child.value)) {
+                if (active.has(child.value))
+                    throw new TypeError('cyclic solver expression');
+                active.add(child.value);
+                stack.push({ expression: child.value, children: children(child.value) });
+            }
+        }
+        return expressions.get(expression);
+    };
     return {
         variables,
         enums,
@@ -164,20 +233,6 @@ const numericValue = (context, value) => {
         };
     throw new TypeError(`Z3 returned a non-rational objective value: ${value.sexpr()}`);
 };
-const withDeadline = async (context, timeoutMs, check) => {
-    let interrupted = false;
-    const timer = setTimeout(() => {
-        interrupted = true;
-        context.interrupt();
-    }, timeoutMs);
-    timer.unref();
-    try {
-        return { status: await check(), interrupted };
-    }
-    finally {
-        clearTimeout(timer);
-    }
-};
 const unknown = (backend, started, reason, interrupted) => {
     const timeout = interrupted || /timeout|canceled|cancelled/i.test(reason);
     const memory = /memory|memout/i.test(reason);
@@ -194,12 +249,13 @@ const unknown = (backend, started, reason, interrupted) => {
     };
 };
 const addHard = (solver, compiled, track) => {
-    solver.add(...compiled.bounds);
+    for (let index = 0; index < compiled.bounds.length; index += 1024) {
+        solver.add(...compiled.bounds.slice(index, index + 1024));
+    }
     const trackers = new Map();
     for (const [id, expression] of compiled.constraints) {
         if (track) {
-            const symbol = `cave.constraint.${id}`;
-            const tracker = solver.ctx.Bool.const(symbol);
+            const tracker = solver.ctx.Bool.fresh('cave.constraint');
             solver.addAndTrack(expression, tracker);
             trackers.set(tracker.id(), id);
         }
@@ -211,7 +267,7 @@ const addHard = (solver, compiled, track) => {
 };
 const coreFor = async (context, compiled, limits) => {
     const solver = new context.Solver();
-    try {
+    return withRelease(async () => {
         solver.set('timeout', limits.timeoutMs);
         const trackers = addHard(solver, compiled, true);
         if ((await withDeadline(context, limits.timeoutMs, () => solver.check())).status !== 'unsat')
@@ -220,10 +276,7 @@ const coreFor = async (context, compiled, limits) => {
             .map(value => trackers.get(value.id()))
             .filter((value) => value !== undefined)
             .sort();
-    }
-    finally {
-        solver.release();
-    }
+    }, () => solver.release());
 };
 const limitOutput = (result, limits) => Buffer.byteLength(JSON.stringify(result)) <= limits.maxOutputBytes
     ? result
@@ -240,13 +293,16 @@ const limitOutput = (result, limits) => Buffer.byteLength(JSON.stringify(result)
     };
 const solveModel = async (api, context, backend, model, request) => {
     const started = performance.now();
+    if (!Number.isSafeInteger(request.limits.timeoutMs) || request.limits.timeoutMs < 1 || request.limits.timeoutMs > 2147483647) {
+        return backendError(backend, started, new TypeError('Z3 timeoutMs must be in 1..2147483647'));
+    }
     try {
         api.setParam('memory_max_size', Math.max(1, Math.floor(request.limits.maxMemoryBytes / 1024 / 1024)));
         const compiled = compiler(context, model);
         const optimize = compiled.objectives.length > 0 || compiled.softConstraints.length > 0;
         if (!optimize) {
             const solver = new context.Solver();
-            try {
+            return await withRelease(async () => {
                 solver.set('timeout', request.limits.timeoutMs);
                 const trackers = addHard(solver, compiled, request.unsatCore);
                 const checked = await withDeadline(context, request.limits.timeoutMs, () => solver.check());
@@ -276,22 +332,16 @@ const solveModel = async (api, context, backend, model, request) => {
                     diagnostics: [],
                     elapsedMs: Math.round(performance.now() - started)
                 }, request.limits);
-            }
-            finally {
-                solver.release();
-            }
+            }, () => solver.release());
         }
         const optimizer = new context.Optimize();
-        try {
+        return await withRelease(async () => {
             optimizer.set('timeout', request.limits.timeoutMs);
             optimizer.set('priority', 'lex');
             addHard(optimizer, compiled, false);
-            for (const objective of compiled.objectives) {
-                if (objective.direction === 'minimize')
-                    optimizer.minimize(objective.expression);
-                else
-                    optimizer.maximize(objective.expression);
-            }
+            const handles = compiled.objectives.map(objective => objective.direction === 'minimize'
+                ? optimizer.minimize(objective.expression)
+                : optimizer.maximize(objective.expression));
             // Soft preferences are deliberately the lowest-priority objective. Their
             // weights are explicit model data and never derived from CAVE confidence.
             for (const constraint of compiled.softConstraints) {
@@ -313,6 +363,25 @@ const solveModel = async (api, context, backend, model, request) => {
                 }, request.limits);
             }
             const z3Model = optimizer.model();
+            const rational = (value) => {
+                if (context.isIntVal(value))
+                    return value.value().toString();
+                if (context.isRealVal(value))
+                    return {
+                        numerator: value.value().numerator.toString(),
+                        denominator: value.value().denominator.toString()
+                    };
+                return undefined;
+            };
+            for (const [index, objective] of compiled.objectives.entries()) {
+                const lower = rational(optimizer.getLower(handles[index]));
+                const upper = rational(optimizer.getUpper(handles[index]));
+                const attained = rational(z3Model.eval(objective.expression, true));
+                if (lower === undefined || upper === undefined || attained === undefined ||
+                    Exact.compare(lower, upper) !== 0 || Exact.compare(lower, attained) !== 0) {
+                    return unknown(backend, started, `objective ${JSON.stringify(objective.id)} has no proved finite attained optimum`, false);
+                }
+            }
             return limitOutput({
                 status: 'optimal',
                 assignment: assignment(context, compiled, model, z3Model),
@@ -325,10 +394,7 @@ const solveModel = async (api, context, backend, model, request) => {
                 diagnostics: [],
                 elapsedMs: Math.round(performance.now() - started)
             }, request.limits);
-        }
-        finally {
-            optimizer.release();
-        }
+        }, () => optimizer.release());
     }
     catch (error) {
         if (api.Z3.get_estimated_alloc_size() > BigInt(request.limits.maxMemoryBytes)) {
@@ -348,16 +414,18 @@ const solveModel = async (api, context, backend, model, request) => {
     }
 };
 let singleton;
+let shutdown;
 const initialize = async () => {
     const started = performance.now();
     // Keep this as the only runtime import: importing @cavelang/solver-z3 itself
     // must not load the 34 MB Wasm artifact or start worker threads.
     const api = await import('z3-solver').then(module => module.init());
+    guardCleanup(api.Z3);
     const context = api.Context('cave');
     const backend = Object.freeze({ name: 'z3-wasm', version: api.Z3.get_full_version() });
     let tail = Promise.resolve();
     let closing = false;
-    let closed = false;
+    let closePromise;
     const enqueue = (work) => {
         const result = tail.then(work, work);
         tail = result.then(() => undefined, () => undefined);
@@ -372,27 +440,24 @@ const initialize = async () => {
                 return Promise.resolve(backendError(backend, performance.now(), new Error('Z3 runtime is closed')));
             return enqueue(() => solveModel(api, context, backend, model, request));
         },
-        close: async () => {
-            if (closed)
-                return;
+        close: () => {
+            if (closePromise)
+                return closePromise;
             closing = true;
-            await enqueue(async () => {
-                if (closed)
-                    return;
-                // Let the completed pthread post its cleanup message before forcibly
-                // terminating the pool. Without this turn, Emscripten can report a
-                // late `cleanupThread` command from a worker we just terminated.
-                await new Promise(resolve => setTimeout(resolve, 0));
-                api.em?.PThread?.terminateAllThreads?.();
-                closed = true;
+            closePromise = enqueue(async () => {
+                // Await worker exits before Emscripten discards their message handlers.
+                await closeWorkers(api.em?.PThread);
                 singleton = undefined;
+                shutdown = undefined;
             });
+            shutdown = closePromise;
+            return closePromise;
         }
     };
     return runtime;
 };
 /** Lazily initialize and reuse one process-wide Z3 runtime. */
-export const create = () => singleton ??= initialize().catch(error => {
+export const create = () => shutdown ? shutdown.then(create) : singleton ??= initialize().catch(error => {
     singleton = undefined;
     throw error;
 });