lptp-mcp-server 0.1.0

package/LICENSE

@@ -0,0 +1,29 @@
+MIT License
+
+Copyright (c) 2025-2026 Thierry Marianne
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+Note: This package provides a Model Context Protocol (MCP) server interface
+to LPTP (Logic Program Theorem Prover), originally developed by Robert F.
+Staerk (1996). The LPTP Prolog source code (src/lptp.pl) is distributed
+under its own license terms. This MIT license applies only to the MCP server
+TypeScript code in this package.

package/README.md

@@ -0,0 +1,91 @@
+# lptp-mcp-server
+
+An [MCP (Model Context Protocol)](https://modelcontextprotocol.io/) server that exposes [LPTP (Logic Program Theorem Prover)](https://www.sciencedirect.com/science/article/pii/S0743106698100060 "Stärk, R.F. (1998). The theoretical foundations of LPTP. Journal of Logic Programming, 36(3):241-269.") operations as tools — proof verification, tactic application, definition querying, and ground representation compilation. Any MCP-compatible client (Claude Code, Claude Desktop, etc.) can connect and use these tools to interactively construct and verify formal proofs of Prolog programs.
+
+## Prerequisites
+
+- **Node.js** >= 18
+- **LPTP source checkout** — the directory containing `src/lptp.pl` and the `lib/` hierarchy
+- **At least one Prolog backend** on PATH:
+  - [SWI-Prolog](https://www.swi-prolog.org/) (`swipl`) — recommended, best resource-limit support
+  - [Scryer Prolog](https://www.scryer.pl/) (`scryer-prolog`) — ISO-compliant alternative
+  - GNU Prolog (`bin/lptp-gnu-prolog`) — pre-compiled binary with LPTP baked in
+
+## Installation
+
+```bash
+npm install lptp-mcp-server
+```
+
+Or install from a local checkout:
+
+```bash
+cd etc/lptp-mcp-server
+npm install
+npm run build
+```
+
+## Configuration
+
+### Claude Code
+
+Add to your `.mcp.json` (project or global):
+
+```json
+{
+  "mcpServers": {
+    "lptp-server": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["lptp-mcp-server"],
+      "env": {
+        "LPTP_ROOT_DIR": "/path/to/your/lptp/checkout"
+      }
+    }
+  }
+}
+```
+
+### Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `LPTP_ROOT_DIR` | Yes* | Path to the LPTP checkout root (directory containing `src/lptp.pl`). *If the server is installed inside the LPTP tree, it can auto-detect. |
+| `LPTP_PROLOG_BACKEND` | No | Force a specific backend: `swipl`, `scryer`, or `gprolog`. Default: auto-detect in that order. |
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `get_lptp_grammar` | Returns LPTP grammar summary for LLM reasoning |
+| `verify_lemma` | Validates LPTP proof code (lemma/3, theorem/3) |
+| `check_proof` | Runs `check/1` on a `.pr` proof file on disk |
+| `apply_tactic` | Applies a tactic to a formula, returns derivation tree |
+| `tactic_auto` | Automatic proof with configurable depth and resource limits |
+| `tactic_case` | Case splitting on disjunctions |
+| `tactic_comp` | Completion formula (fixed-point semantics) |
+| `tactic_elim` | Predicate definition elimination |
+| `tactic_ex` | Existential quantifier instantiation |
+| `tactic_fact` | Apply a known fact (lemma, theorem, corollary) |
+| `tactic_ind` | Structural induction |
+| `tactic_indqf` | Quantifier-free induction |
+| `tactic_tot` | Totality (termination) case splitting |
+| `tactic_unfold` | Unfold an abbreviation or definition |
+| `tactic_debug` | Show available formulas and assumptions in context |
+| `print_definition` | Print completion definition (IND(P) axioms) of a predicate |
+| `list_facts` | List known theorems/lemmas/corollaries about a predicate |
+| `compile_gr` | Compile `.pl` to LPTP ground representation (`.gr`) |
+
+## Prolog Backend Selection
+
+The server auto-detects backends in this order:
+
+1. **SWI-Prolog** (`swipl`) — full resource limits (time, inference, depth)
+2. **Scryer Prolog** (`scryer-prolog`) — inference limits only, Node.js timeout for time
+3. **GNU Prolog** (`bin/lptp-gnu-prolog`) — Node.js timeout only
+
+Override with `LPTP_PROLOG_BACKEND=swipl` (or `scryer`, `gprolog`).
+
+## License
+
+MIT — see [LICENSE](./LICENSE). The LPTP Prolog source (`src/lptp.pl`) has its own license (R.F. Staerk, 1996).

package/build/backends/gprolog.d.ts

@@ -0,0 +1,32 @@
+import type { PrologBackend, ResourceLimits } from './types';
+/**
+ * GNU Prolog backend.
+ *
+ * CLI pattern (from Makefile line 839):
+ *   cat ./src/allg.pl | ./bin/lptp-gnu-prolog
+ *
+ * Key differences from SWI-Prolog:
+ *   - Uses a pre-compiled binary (bin/lptp-gnu-prolog) with LPTP baked in
+ *   - No consult needed — LPTP is compiled into the binary
+ *   - Input is piped via stdin: echo "goal." | bin/lptp-gnu-prolog
+ *   - No Prolog-level resource limits — Node.js timeout only
+ *   - PREVENT_PRE_COMPILATION=true avoids .gr compilation on startup
+ */
+export declare class GprologBackend implements PrologBackend {
+    readonly id: "gprolog";
+    readonly displayName = "GNU Prolog";
+    private getBinaryPath;
+    isAvailable(): boolean;
+    /**
+     * GNU Prolog has no Prolog-level resource limits.
+     * Returns the goal unchanged, wrapped in once/1 for determinism.
+     */
+    wrapWithLimits(goal: string, _limits?: ResourceLimits): string;
+    buildExecCommand(_lptpSrc: string, tmpFile: string, _limits?: ResourceLimits): string;
+    buildCheckCommand(_lptpSrc: string, checkPath: string, _limits?: ResourceLimits): string;
+    buildCompileGrCommand(_lptpSrc: string, tmpFile: string, _limits?: ResourceLimits): string;
+    suppressWarningsGoal(): string;
+    nodeTimeout(limits?: ResourceLimits, defaultMs?: number): number;
+    execEnv(): Record<string, string>;
+}
+//# sourceMappingURL=gprolog.d.ts.map

package/build/backends/gprolog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gprolog.d.ts","sourceRoot":"","sources":["../../src/backends/gprolog.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE7D;;;;;;;;;;;;GAYG;AACH,qBAAa,cAAe,YAAW,aAAa;IAChD,QAAQ,CAAC,EAAE,EAAG,SAAS,CAAU;IACjC,QAAQ,CAAC,WAAW,gBAAgB;IAEpC,OAAO,CAAC,aAAa;IAkBrB,WAAW,IAAI,OAAO;IAStB;;;OAGG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM;IAI9D,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM;IAMrF,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM;IAKxF,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM;IAK1F,oBAAoB,IAAI,MAAM;IAI9B,WAAW,CAAC,MAAM,GAAE,cAAmB,EAAE,SAAS,GAAE,MAAe,GAAG,MAAM;IAQ5E,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CAGpC"}

package/build/backends/gprolog.js

@@ -0,0 +1,113 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GprologBackend = void 0;
+const path = __importStar(require("path"));
+/**
+ * GNU Prolog backend.
+ *
+ * CLI pattern (from Makefile line 839):
+ *   cat ./src/allg.pl | ./bin/lptp-gnu-prolog
+ *
+ * Key differences from SWI-Prolog:
+ *   - Uses a pre-compiled binary (bin/lptp-gnu-prolog) with LPTP baked in
+ *   - No consult needed — LPTP is compiled into the binary
+ *   - Input is piped via stdin: echo "goal." | bin/lptp-gnu-prolog
+ *   - No Prolog-level resource limits — Node.js timeout only
+ *   - PREVENT_PRE_COMPILATION=true avoids .gr compilation on startup
+ */
+class GprologBackend {
+    id = 'gprolog';
+    displayName = 'GNU Prolog';
+    getBinaryPath() {
+        const root = process.env['LPTP_ROOT_DIR'];
+        if (root)
+            return path.join(root, 'bin', 'lptp-gnu-prolog');
+        // Walk up from __dirname to find bin/lptp-gnu-prolog
+        let dir = __dirname;
+        for (let i = 0; i < 8; i++) {
+            const candidate = path.join(dir, 'bin', 'lptp-gnu-prolog');
+            if (require('fs').existsSync(candidate))
+                return candidate;
+            dir = path.dirname(dir);
+        }
+        throw new Error('GNU Prolog binary (bin/lptp-gnu-prolog) not found. ' +
+            'Set LPTP_ROOT_DIR to your LPTP checkout root, or build the binary with: cd src && make gprolog');
+    }
+    isAvailable() {
+        try {
+            this.getBinaryPath();
+            return require('fs').existsSync(this.getBinaryPath());
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * GNU Prolog has no Prolog-level resource limits.
+     * Returns the goal unchanged, wrapped in once/1 for determinism.
+     */
+    wrapWithLimits(goal, _limits) {
+        return `once(${goal})`;
+    }
+    buildExecCommand(_lptpSrc, tmpFile, _limits) {
+        const binary = this.getBinaryPath();
+        // LPTP is compiled into the binary — no consult needed
+        return `echo "exec('${tmpFile}')." | ${binary}`;
+    }
+    buildCheckCommand(_lptpSrc, checkPath, _limits) {
+        const binary = this.getBinaryPath();
+        return `echo "check('${checkPath}')." | ${binary}`;
+    }
+    buildCompileGrCommand(_lptpSrc, tmpFile, _limits) {
+        const binary = this.getBinaryPath();
+        return `echo "exec('${tmpFile}')." | ${binary}`;
+    }
+    suppressWarningsGoal() {
+        return '';
+    }
+    nodeTimeout(limits = {}, defaultMs = 30_000) {
+        // Node.js timeout is the only guard for GNU Prolog.
+        if (limits.timeLimitS != null) {
+            return limits.timeLimitS * 1000 + 5000;
+        }
+        return defaultMs;
+    }
+    execEnv() {
+        return { PREVENT_PRE_COMPILATION: 'true' };
+    }
+}
+exports.GprologBackend = GprologBackend;
+//# sourceMappingURL=gprolog.js.map

package/build/backends/gprolog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gprolog.js","sourceRoot":"","sources":["../../src/backends/gprolog.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2CAA6B;AAG7B;;;;;;;;;;;;GAYG;AACH,MAAa,cAAc;IACd,EAAE,GAAG,SAAkB,CAAC;IACxB,WAAW,GAAG,YAAY,CAAC;IAE5B,aAAa;QACjB,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;QAC1C,IAAI,IAAI;YAAE,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,iBAAiB,CAAC,CAAC;QAE3D,qDAAqD;QACrD,IAAI,GAAG,GAAG,SAAS,CAAC;QACpB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YACzB,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,KAAK,EAAE,iBAAiB,CAAC,CAAC;YAC3D,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,SAAS,CAAC;gBAAE,OAAO,SAAS,CAAC;YAC1D,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAC5B,CAAC;QAED,MAAM,IAAI,KAAK,CACX,qDAAqD;YACrD,gGAAgG,CACnG,CAAC;IACN,CAAC;IAED,WAAW;QACP,IAAI,CAAC;YACD,IAAI,CAAC,aAAa,EAAE,CAAC;YACrB,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC;QAC1D,CAAC;QAAC,MAAM,CAAC;YACL,OAAO,KAAK,CAAC;QACjB,CAAC;IACL,CAAC;IAED;;;OAGG;IACH,cAAc,CAAC,IAAY,EAAE,OAAwB;QACjD,OAAO,QAAQ,IAAI,GAAG,CAAC;IAC3B,CAAC;IAED,gBAAgB,CAAC,QAAgB,EAAE,OAAe,EAAE,OAAwB;QACxE,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;QACpC,uDAAuD;QACvD,OAAO,eAAe,OAAO,UAAU,MAAM,EAAE,CAAC;IACpD,CAAC;IAED,iBAAiB,CAAC,QAAgB,EAAE,SAAiB,EAAE,OAAwB;QAC3E,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;QACpC,OAAO,gBAAgB,SAAS,UAAU,MAAM,EAAE,CAAC;IACvD,CAAC;IAED,qBAAqB,CAAC,QAAgB,EAAE,OAAe,EAAE,OAAwB;QAC7E,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;QACpC,OAAO,eAAe,OAAO,UAAU,MAAM,EAAE,CAAC;IACpD,CAAC;IAED,oBAAoB;QAChB,OAAO,EAAE,CAAC;IACd,CAAC;IAED,WAAW,CAAC,SAAyB,EAAE,EAAE,YAAoB,MAAM;QAC/D,oDAAoD;QACpD,IAAI,MAAM,CAAC,UAAU,IAAI,IAAI,EAAE,CAAC;YAC5B,OAAO,MAAM,CAAC,UAAU,GAAG,IAAI,GAAG,IAAI,CAAC;QAC3C,CAAC;QACD,OAAO,SAAS,CAAC;IACrB,CAAC;IAED,OAAO;QACH,OAAO,EAAE,uBAAuB,EAAE,MAAM,EAAE,CAAC;IAC/C,CAAC;CACJ;AAtED,wCAsEC"}

package/build/backends/registry.d.ts

@@ -0,0 +1,15 @@
+import type { PrologBackend } from './types';
+/**
+ * Returns the active Prolog backend.
+ *
+ * Selection logic:
+ *   1. If LPTP_PROLOG_BACKEND env var is set, use that backend (throw if unavailable).
+ *   2. Otherwise auto-detect in order: swipl -> scryer -> gprolog (first available wins).
+ *   3. If none found, throw a descriptive error.
+ *
+ * Result is cached for the lifetime of the server process.
+ */
+export declare function getBackend(): PrologBackend;
+/** Reset cached backend — useful for tests. */
+export declare function resetBackendCache(): void;
+//# sourceMappingURL=registry.d.ts.map

package/build/backends/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/backends/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,aAAa,EAAE,MAAM,SAAS,CAAC;AAexD;;;;;;;;;GASG;AACH,wBAAgB,UAAU,IAAI,aAAa,CAuC1C;AAED,+CAA+C;AAC/C,wBAAgB,iBAAiB,IAAI,IAAI,CAExC"}

package/build/backends/registry.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBackend = getBackend;
+exports.resetBackendCache = resetBackendCache;
+const swipl_1 = require("./swipl");
+const scryer_1 = require("./scryer");
+const gprolog_1 = require("./gprolog");
+let cachedBackend = null;
+function instantiate(id) {
+    switch (id) {
+        case 'swipl': return new swipl_1.SwiplBackend();
+        case 'scryer': return new scryer_1.ScryerBackend();
+        case 'gprolog': return new gprolog_1.GprologBackend();
+    }
+}
+/**
+ * Returns the active Prolog backend.
+ *
+ * Selection logic:
+ *   1. If LPTP_PROLOG_BACKEND env var is set, use that backend (throw if unavailable).
+ *   2. Otherwise auto-detect in order: swipl -> scryer -> gprolog (first available wins).
+ *   3. If none found, throw a descriptive error.
+ *
+ * Result is cached for the lifetime of the server process.
+ */
+function getBackend() {
+    if (cachedBackend)
+        return cachedBackend;
+    const envChoice = process.env['LPTP_PROLOG_BACKEND'];
+    if (envChoice) {
+        const validIds = ['swipl', 'scryer', 'gprolog'];
+        if (!validIds.includes(envChoice)) {
+            throw new Error(`LPTP_PROLOG_BACKEND="${envChoice}" is not valid. ` +
+                `Choose one of: ${validIds.join(', ')}`);
+        }
+        const backend = instantiate(envChoice);
+        if (!backend.isAvailable()) {
+            throw new Error(`LPTP_PROLOG_BACKEND="${envChoice}" requested but ` +
+                `${backend.displayName} is not available on this system.`);
+        }
+        cachedBackend = backend;
+        return cachedBackend;
+    }
+    // Auto-detect: try each backend in preference order
+    const probeOrder = ['swipl', 'scryer', 'gprolog'];
+    for (const id of probeOrder) {
+        const backend = instantiate(id);
+        if (backend.isAvailable()) {
+            cachedBackend = backend;
+            return cachedBackend;
+        }
+    }
+    throw new Error('No Prolog backend found. Install SWI-Prolog (swipl), ' +
+        'Scryer Prolog (scryer-prolog), or build GNU Prolog binary ' +
+        '(cd src && make gprolog). Or set LPTP_PROLOG_BACKEND explicitly.');
+}
+/** Reset cached backend — useful for tests. */
+function resetBackendCache() {
+    cachedBackend = null;
+}
+//# sourceMappingURL=registry.js.map

package/build/backends/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/backends/registry.ts"],"names":[],"mappings":";;AAyBA,gCAuCC;AAGD,8CAEC;AApED,mCAAuC;AACvC,qCAAyC;AACzC,uCAA2C;AAE3C,IAAI,aAAa,GAAyB,IAAI,CAAC;AAE/C,SAAS,WAAW,CAAC,EAAa;IAC9B,QAAQ,EAAE,EAAE,CAAC;QACT,KAAK,OAAO,CAAC,CAAE,OAAO,IAAI,oBAAY,EAAE,CAAC;QACzC,KAAK,QAAQ,CAAC,CAAC,OAAO,IAAI,sBAAa,EAAE,CAAC;QAC1C,KAAK,SAAS,CAAC,CAAC,OAAO,IAAI,wBAAc,EAAE,CAAC;IAChD,CAAC;AACL,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,UAAU;IACtB,IAAI,aAAa;QAAE,OAAO,aAAa,CAAC;IAExC,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,qBAAqB,CAA0B,CAAC;IAE9E,IAAI,SAAS,EAAE,CAAC;QACZ,MAAM,QAAQ,GAAgB,CAAC,OAAO,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;QAC7D,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;YAChC,MAAM,IAAI,KAAK,CACX,wBAAwB,SAAS,kBAAkB;gBACnD,kBAAkB,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAC1C,CAAC;QACN,CAAC;QACD,MAAM,OAAO,GAAG,WAAW,CAAC,SAAS,CAAC,CAAC;QACvC,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC;YACzB,MAAM,IAAI,KAAK,CACX,wBAAwB,SAAS,kBAAkB;gBACnD,GAAG,OAAO,CAAC,WAAW,mCAAmC,CAC5D,CAAC;QACN,CAAC;QACD,aAAa,GAAG,OAAO,CAAC;QACxB,OAAO,aAAa,CAAC;IACzB,CAAC;IAED,oDAAoD;IACpD,MAAM,UAAU,GAAgB,CAAC,OAAO,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;IAC/D,KAAK,MAAM,EAAE,IAAI,UAAU,EAAE,CAAC;QAC1B,MAAM,OAAO,GAAG,WAAW,CAAC,EAAE,CAAC,CAAC;QAChC,IAAI,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC;YACxB,aAAa,GAAG,OAAO,CAAC;YACxB,OAAO,aAAa,CAAC;QACzB,CAAC;IACL,CAAC;IAED,MAAM,IAAI,KAAK,CACX,uDAAuD;QACvD,4DAA4D;QAC5D,kEAAkE,CACrE,CAAC;AACN,CAAC;AAED,+CAA+C;AAC/C,SAAgB,iBAAiB;IAC7B,aAAa,GAAG,IAAI,CAAC;AACzB,CAAC"}

package/build/backends/scryer.d.ts

@@ -0,0 +1,33 @@
+import type { PrologBackend, ResourceLimits } from './types';
+/**
+ * Scryer Prolog backend.
+ *
+ * CLI pattern (from Makefile line 819):
+ *   scryer-prolog -g "consult('./src/lptp.pl'),exec('file')." -g "halt."
+ *
+ * Key differences from SWI-Prolog:
+ *   - Goals passed to -g need a trailing period
+ *   - Supports call_with_inference_limit/3 from iso_ext module
+ *   - No call_with_time_limit or call_with_depth_limit — Node.js timeout covers those
+ *   - Quiet mode via QUIET_MODE=true environment variable
+ *   - No message_hook suppression needed
+ */
+export declare class ScryerBackend implements PrologBackend {
+    readonly id: "scryer";
+    readonly displayName = "Scryer Prolog";
+    isAvailable(): boolean;
+    /**
+     * Wraps a Prolog goal with Scryer-specific resource limits.
+     * Only inference limit is supported at the Prolog level via
+     * call_with_inference_limit/3 (iso_ext module).
+     * Time and depth limits fall back to Node.js timeout.
+     */
+    wrapWithLimits(goal: string, limits?: ResourceLimits): string;
+    buildExecCommand(lptpSrc: string, tmpFile: string, limits?: ResourceLimits): string;
+    buildCheckCommand(lptpSrc: string, checkPath: string, limits?: ResourceLimits): string;
+    buildCompileGrCommand(lptpSrc: string, tmpFile: string, limits?: ResourceLimits): string;
+    suppressWarningsGoal(): string;
+    nodeTimeout(limits?: ResourceLimits, defaultMs?: number): number;
+    execEnv(): Record<string, string>;
+}
+//# sourceMappingURL=scryer.d.ts.map

package/build/backends/scryer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scryer.d.ts","sourceRoot":"","sources":["../../src/backends/scryer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAI7D;;;;;;;;;;;;GAYG;AACH,qBAAa,aAAc,YAAW,aAAa;IAC/C,QAAQ,CAAC,EAAE,EAAG,QAAQ,CAAU;IAChC,QAAQ,CAAC,WAAW,mBAAmB;IAEvC,WAAW,IAAI,OAAO;IAKtB;;;;;OAKG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,cAAmB,GAAG,MAAM;IASjE,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,cAAc,GAAG,MAAM;IAQnF,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,cAAc,GAAG,MAAM;IAQtF,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,cAAc,GAAG,MAAM;IAQxF,oBAAoB,IAAI,MAAM;IAI9B,WAAW,CAAC,MAAM,GAAE,cAAmB,EAAE,SAAS,GAAE,MAAe,GAAG,MAAM;IAS5E,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CAGpC"}

package/build/backends/scryer.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScryerBackend = void 0;
+const child_process_1 = require("child_process");
+const DEFAULT_INFERENCE_LIMIT = 1_000_000;
+/**
+ * Scryer Prolog backend.
+ *
+ * CLI pattern (from Makefile line 819):
+ *   scryer-prolog -g "consult('./src/lptp.pl'),exec('file')." -g "halt."
+ *
+ * Key differences from SWI-Prolog:
+ *   - Goals passed to -g need a trailing period
+ *   - Supports call_with_inference_limit/3 from iso_ext module
+ *   - No call_with_time_limit or call_with_depth_limit — Node.js timeout covers those
+ *   - Quiet mode via QUIET_MODE=true environment variable
+ *   - No message_hook suppression needed
+ */
+class ScryerBackend {
+    id = 'scryer';
+    displayName = 'Scryer Prolog';
+    isAvailable() {
+        try {
+            (0, child_process_1.execSync)('which scryer-prolog', { stdio: 'ignore' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Wraps a Prolog goal with Scryer-specific resource limits.
+     * Only inference limit is supported at the Prolog level via
+     * call_with_inference_limit/3 (iso_ext module).
+     * Time and depth limits fall back to Node.js timeout.
+     */
+    wrapWithLimits(goal, limits = {}) {
+        let wrapped = `once(${goal})`;
+        const infLim = limits.inferenceLimit ?? DEFAULT_INFERENCE_LIMIT;
+        wrapped = `call_with_inference_limit((${wrapped}), ${infLim}, _InfRes)`;
+        return wrapped;
+    }
+    buildExecCommand(lptpSrc, tmpFile, limits) {
+        const wrappedGoal = this.wrapWithLimits(`(consult('${lptpSrc}'), exec('${tmpFile}'))`, limits);
+        return `scryer-prolog -g "${wrappedGoal}." -g "halt."`;
+    }
+    buildCheckCommand(lptpSrc, checkPath, limits) {
+        const wrappedGoal = this.wrapWithLimits(`(consult('${lptpSrc}'), check('${checkPath}'))`, limits ?? { inferenceLimit: 10_000_000 });
+        return `scryer-prolog -g "${wrappedGoal}." -g "halt."`;
+    }
+    buildCompileGrCommand(lptpSrc, tmpFile, limits) {
+        const wrappedGoal = this.wrapWithLimits(`(consult('${lptpSrc}'), exec('${tmpFile}'))`, limits);
+        return `scryer-prolog -g "${wrappedGoal}." -g "halt."`;
+    }
+    suppressWarningsGoal() {
+        return '';
+    }
+    nodeTimeout(limits = {}, defaultMs = 30_000) {
+        // Scryer has no Prolog-level time limit, so Node.js timeout is the primary guard.
+        // Use the timeLimitS hint if provided, otherwise fall back to defaultMs.
+        if (limits.timeLimitS != null) {
+            return limits.timeLimitS * 1000 + 5000;
+        }
+        return defaultMs;
+    }
+    execEnv() {
+        return { QUIET_MODE: 'true' };
+    }
+}
+exports.ScryerBackend = ScryerBackend;
+//# sourceMappingURL=scryer.js.map

package/build/backends/scryer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scryer.js","sourceRoot":"","sources":["../../src/backends/scryer.ts"],"names":[],"mappings":";;;AAAA,iDAAyC;AAGzC,MAAM,uBAAuB,GAAG,SAAS,CAAC;AAE1C;;;;;;;;;;;;GAYG;AACH,MAAa,aAAa;IACb,EAAE,GAAG,QAAiB,CAAC;IACvB,WAAW,GAAG,eAAe,CAAC;IAEvC,WAAW;QACP,IAAI,CAAC;YAAC,IAAA,wBAAQ,EAAC,qBAAqB,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;YAAC,OAAO,IAAI,CAAC;QAAC,CAAC;QAC1E,MAAM,CAAC;YAAC,OAAO,KAAK,CAAC;QAAC,CAAC;IAC3B,CAAC;IAED;;;;;OAKG;IACH,cAAc,CAAC,IAAY,EAAE,SAAyB,EAAE;QACpD,IAAI,OAAO,GAAG,QAAQ,IAAI,GAAG,CAAC;QAE9B,MAAM,MAAM,GAAG,MAAM,CAAC,cAAc,IAAI,uBAAuB,CAAC;QAChE,OAAO,GAAG,8BAA8B,OAAO,MAAM,MAAM,YAAY,CAAC;QAExE,OAAO,OAAO,CAAC;IACnB,CAAC;IAED,gBAAgB,CAAC,OAAe,EAAE,OAAe,EAAE,MAAuB;QACtE,MAAM,WAAW,GAAG,IAAI,CAAC,cAAc,CACnC,aAAa,OAAO,aAAa,OAAO,KAAK,EAC7C,MAAM,CACT,CAAC;QACF,OAAO,qBAAqB,WAAW,eAAe,CAAC;IAC3D,CAAC;IAED,iBAAiB,CAAC,OAAe,EAAE,SAAiB,EAAE,MAAuB;QACzE,MAAM,WAAW,GAAG,IAAI,CAAC,cAAc,CACnC,aAAa,OAAO,cAAc,SAAS,KAAK,EAChD,MAAM,IAAI,EAAE,cAAc,EAAE,UAAU,EAAE,CAC3C,CAAC;QACF,OAAO,qBAAqB,WAAW,eAAe,CAAC;IAC3D,CAAC;IAED,qBAAqB,CAAC,OAAe,EAAE,OAAe,EAAE,MAAuB;QAC3E,MAAM,WAAW,GAAG,IAAI,CAAC,cAAc,CACnC,aAAa,OAAO,aAAa,OAAO,KAAK,EAC7C,MAAM,CACT,CAAC;QACF,OAAO,qBAAqB,WAAW,eAAe,CAAC;IAC3D,CAAC;IAED,oBAAoB;QAChB,OAAO,EAAE,CAAC;IACd,CAAC;IAED,WAAW,CAAC,SAAyB,EAAE,EAAE,YAAoB,MAAM;QAC/D,kFAAkF;QAClF,yEAAyE;QACzE,IAAI,MAAM,CAAC,UAAU,IAAI,IAAI,EAAE,CAAC;YAC5B,OAAO,MAAM,CAAC,UAAU,GAAG,IAAI,GAAG,IAAI,CAAC;QAC3C,CAAC;QACD,OAAO,SAAS,CAAC;IACrB,CAAC;IAED,OAAO;QACH,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,CAAC;IAClC,CAAC;CACJ;AAhED,sCAgEC"}

package/build/backends/swipl.d.ts

@@ -0,0 +1,24 @@
+import type { PrologBackend, ResourceLimits } from './types';
+export declare class SwiplBackend implements PrologBackend {
+    readonly id: "swipl";
+    readonly displayName = "SWI-Prolog";
+    isAvailable(): boolean;
+    /**
+     * Wraps a SWI-Prolog goal with resource limits:
+     *   once/1                       — deterministic, no backtracking
+     *   call_with_time_limit/2       — wall-clock timeout (throws time_limit_exceeded)
+     *   call_with_inference_limit/3  — inference bound (binds Result)
+     *   call_with_depth_limit/3      — depth bound (binds Result)
+     *
+     * If any limit is exceeded the process writes a diagnostic and halts with
+     * a non-zero exit code so the Node.js side captures it as an error.
+     */
+    wrapWithLimits(goal: string, limits?: ResourceLimits): string;
+    buildExecCommand(lptpSrc: string, tmpFile: string, limits?: ResourceLimits): string;
+    buildCheckCommand(lptpSrc: string, checkPath: string, limits?: ResourceLimits): string;
+    buildCompileGrCommand(lptpSrc: string, tmpFile: string, limits?: ResourceLimits): string;
+    suppressWarningsGoal(): string;
+    nodeTimeout(limits?: ResourceLimits, defaultMs?: number): number;
+    execEnv(): Record<string, string>;
+}
+//# sourceMappingURL=swipl.d.ts.map

package/build/backends/swipl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swipl.d.ts","sourceRoot":"","sources":["../../src/backends/swipl.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAK7D,qBAAa,YAAa,YAAW,aAAa;IAC9C,QAAQ,CAAC,EAAE,EAAG,OAAO,CAAU;IAC/B,QAAQ,CAAC,WAAW,gBAAgB;IAEpC,WAAW,IAAI,OAAO;IAKtB;;;;;;;;;OASG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,cAAmB,GAAG,MAAM;IAyBjE,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,cAAc,GAAG,MAAM;IAQnF,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,cAAc,GAAG,MAAM;IAStF,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,cAAc,GAAG,MAAM;IAQxF,oBAAoB,IAAI,MAAM;IAI9B,WAAW,CAAC,MAAM,GAAE,cAAmB,EAAE,SAAS,GAAE,MAAe,GAAG,MAAM;IAK5E,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CAGpC"}

package/build/backends/swipl.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwiplBackend = void 0;
+const child_process_1 = require("child_process");
+const DEFAULT_PROLOG_TIME_LIMIT_S = 25;
+const DEFAULT_INFERENCE_LIMIT = 1_000_000;
+class SwiplBackend {
+    id = 'swipl';
+    displayName = 'SWI-Prolog';
+    isAvailable() {
+        try {
+            (0, child_process_1.execSync)('which swipl', { stdio: 'ignore' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Wraps a SWI-Prolog goal with resource limits:
+     *   once/1                       — deterministic, no backtracking
+     *   call_with_time_limit/2       — wall-clock timeout (throws time_limit_exceeded)
+     *   call_with_inference_limit/3  — inference bound (binds Result)
+     *   call_with_depth_limit/3      — depth bound (binds Result)
+     *
+     * If any limit is exceeded the process writes a diagnostic and halts with
+     * a non-zero exit code so the Node.js side captures it as an error.
+     */
+    wrapWithLimits(goal, limits = {}) {
+        const timeS = limits.timeLimitS ?? DEFAULT_PROLOG_TIME_LIMIT_S;
+        const infLim = limits.inferenceLimit ?? DEFAULT_INFERENCE_LIMIT;
+        // Build from inside out:
+        //   innermost: once(Goal)
+        //   then: call_with_inference_limit(…, InfLim, InfRes)
+        //   then: call_with_time_limit(TimeS, …)
+        //   outermost: catch(…, time_limit_exceeded, diagnostic)
+        let wrapped = `once(${goal})`;
+        // Inference limit guard
+        wrapped = `call_with_inference_limit((${wrapped}), ${infLim}, _InfRes)`;
+        // Optional depth limit
+        if (limits.depthLimit != null) {
+            wrapped = `call_with_depth_limit((${wrapped}), ${limits.depthLimit}, _DepthRes)`;
+        }
+        // Time limit guard (outermost catch)
+        wrapped = `catch(call_with_time_limit(${timeS}, (${wrapped})), time_limit_exceeded, (write('TIME_LIMIT_EXCEEDED'), nl, halt(2)))`;
+        return wrapped;
+    }
+    buildExecCommand(lptpSrc, tmpFile, limits) {
+        const wrappedGoal = this.wrapWithLimits(`(consult('${lptpSrc}'), exec('${tmpFile}'))`, limits);
+        return `swipl -q -g "${wrappedGoal}, halt" -t "halt(1)"`;
+    }
+    buildCheckCommand(lptpSrc, checkPath, limits) {
+        const suppressWarnings = this.suppressWarningsGoal();
+        const wrappedGoal = this.wrapWithLimits(`(${suppressWarnings}, consult('${lptpSrc}'), check('${checkPath}'))`, limits ?? { timeLimitS: 110, inferenceLimit: 10_000_000 });
+        return `swipl -q -g "${wrappedGoal}, halt" -t "halt(1)"`;
+    }
+    buildCompileGrCommand(lptpSrc, tmpFile, limits) {
+        const wrappedGoal = this.wrapWithLimits(`(consult('${lptpSrc}'), exec('${tmpFile}'))`, limits);
+        return `swipl -q -g "${wrappedGoal}, halt" -t "halt(1)"`;
+    }
+    suppressWarningsGoal() {
+        return `asserta((user:message_hook(_,warning,_) :- !))`;
+    }
+    nodeTimeout(limits = {}, defaultMs = 30_000) {
+        const timeS = limits.timeLimitS ?? DEFAULT_PROLOG_TIME_LIMIT_S;
+        return timeS * 1000 + 5000;
+    }
+    execEnv() {
+        return {};
+    }
+}
+exports.SwiplBackend = SwiplBackend;
+//# sourceMappingURL=swipl.js.map

package/build/backends/swipl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"swipl.js","sourceRoot":"","sources":["../../src/backends/swipl.ts"],"names":[],"mappings":";;;AAAA,iDAAyC;AAGzC,MAAM,2BAA2B,GAAG,EAAE,CAAC;AACvC,MAAM,uBAAuB,GAAO,SAAS,CAAC;AAE9C,MAAa,YAAY;IACZ,EAAE,GAAG,OAAgB,CAAC;IACtB,WAAW,GAAG,YAAY,CAAC;IAEpC,WAAW;QACP,IAAI,CAAC;YAAC,IAAA,wBAAQ,EAAC,aAAa,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;YAAC,OAAO,IAAI,CAAC;QAAC,CAAC;QAClE,MAAM,CAAC;YAAC,OAAO,KAAK,CAAC;QAAC,CAAC;IAC3B,CAAC;IAED;;;;;;;;;OASG;IACH,cAAc,CAAC,IAAY,EAAE,SAAyB,EAAE;QACpD,MAAM,KAAK,GAAI,MAAM,CAAC,UAAU,IAAI,2BAA2B,CAAC;QAChE,MAAM,MAAM,GAAG,MAAM,CAAC,cAAc,IAAI,uBAAuB,CAAC;QAEhE,yBAAyB;QACzB,0BAA0B;QAC1B,uDAAuD;QACvD,yCAAyC;QACzC,yDAAyD;QACzD,IAAI,OAAO,GAAG,QAAQ,IAAI,GAAG,CAAC;QAE9B,wBAAwB;QACxB,OAAO,GAAG,8BAA8B,OAAO,MAAM,MAAM,YAAY,CAAC;QAExE,uBAAuB;QACvB,IAAI,MAAM,CAAC,UAAU,IAAI,IAAI,EAAE,CAAC;YAC5B,OAAO,GAAG,0BAA0B,OAAO,MAAM,MAAM,CAAC,UAAU,cAAc,CAAC;QACrF,CAAC;QAED,qCAAqC;QACrC,OAAO,GAAG,8BAA8B,KAAK,MAAM,OAAO,uEAAuE,CAAC;QAElI,OAAO,OAAO,CAAC;IACnB,CAAC;IAED,gBAAgB,CAAC,OAAe,EAAE,OAAe,EAAE,MAAuB;QACtE,MAAM,WAAW,GAAG,IAAI,CAAC,cAAc,CACnC,aAAa,OAAO,aAAa,OAAO,KAAK,EAC7C,MAAM,CACT,CAAC;QACF,OAAO,gBAAgB,WAAW,sBAAsB,CAAC;IAC7D,CAAC;IAED,iBAAiB,CAAC,OAAe,EAAE,SAAiB,EAAE,MAAuB;QACzE,MAAM,gBAAgB,GAAG,IAAI,CAAC,oBAAoB,EAAE,CAAC;QACrD,MAAM,WAAW,GAAG,IAAI,CAAC,cAAc,CACnC,IAAI,gBAAgB,cAAc,OAAO,cAAc,SAAS,KAAK,EACrE,MAAM,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,cAAc,EAAE,UAAU,EAAE,CAC5D,CAAC;QACF,OAAO,gBAAgB,WAAW,sBAAsB,CAAC;IAC7D,CAAC;IAED,qBAAqB,CAAC,OAAe,EAAE,OAAe,EAAE,MAAuB;QAC3E,MAAM,WAAW,GAAG,IAAI,CAAC,cAAc,CACnC,aAAa,OAAO,aAAa,OAAO,KAAK,EAC7C,MAAM,CACT,CAAC;QACF,OAAO,gBAAgB,WAAW,sBAAsB,CAAC;IAC7D,CAAC;IAED,oBAAoB;QAChB,OAAO,gDAAgD,CAAC;IAC5D,CAAC;IAED,WAAW,CAAC,SAAyB,EAAE,EAAE,YAAoB,MAAM;QAC/D,MAAM,KAAK,GAAG,MAAM,CAAC,UAAU,IAAI,2BAA2B,CAAC;QAC/D,OAAO,KAAK,GAAG,IAAI,GAAG,IAAI,CAAC;IAC/B,CAAC;IAED,OAAO;QACH,OAAO,EAAE,CAAC;IACd,CAAC;CACJ;AAjFD,oCAiFC"}

package/build/backends/types.d.ts

@@ -0,0 +1,27 @@
+export type BackendId = 'swipl' | 'scryer' | 'gprolog';
+export interface ResourceLimits {
+    timeLimitS?: number;
+    inferenceLimit?: number;
+    depthLimit?: number;
+}
+export interface PrologBackend {
+    readonly id: BackendId;
+    readonly displayName: string;
+    /** Returns true when the backend's binary / compiled artifact is on PATH or at expected location. */
+    isAvailable(): boolean;
+    /** Build shell command that runs `exec(TmpFile)` through LPTP. */
+    buildExecCommand(lptpSrc: string, tmpFile: string, limits?: ResourceLimits): string;
+    /** Build shell command that runs `check(CheckPath)` through LPTP. */
+    buildCheckCommand(lptpSrc: string, checkPath: string, limits?: ResourceLimits): string;
+    /** Build shell command that compiles a .gr file through LPTP. */
+    buildCompileGrCommand(lptpSrc: string, tmpFile: string, limits?: ResourceLimits): string;
+    /** Wrap a Prolog goal with backend-specific resource limits. */
+    wrapWithLimits(goal: string, limits?: ResourceLimits): string;
+    /** Return a Prolog goal that suppresses backend-specific warnings, or '' if N/A. */
+    suppressWarningsGoal(): string;
+    /** Compute Node.js exec timeout (ms) from limits. */
+    nodeTimeout(limits?: ResourceLimits, defaultMs?: number): number;
+    /** Extra environment variables for child_process.exec. */
+    execEnv(): Record<string, string>;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/backends/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/backends/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEvD,MAAM,WAAW,cAAc;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,aAAa;IAC1B,QAAQ,CAAC,EAAE,EAAE,SAAS,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAE7B,qGAAqG;IACrG,WAAW,IAAI,OAAO,CAAC;IAEvB,kEAAkE;IAClE,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,cAAc,GAAG,MAAM,CAAC;IAEpF,qEAAqE;IACrE,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,cAAc,GAAG,MAAM,CAAC;IAEvF,iEAAiE;IACjE,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,cAAc,GAAG,MAAM,CAAC;IAEzF,gEAAgE;IAChE,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,cAAc,GAAG,MAAM,CAAC;IAE9D,oFAAoF;IACpF,oBAAoB,IAAI,MAAM,CAAC;IAE/B,qDAAqD;IACrD,WAAW,CAAC,MAAM,CAAC,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAEjE,0DAA0D;IAC1D,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACrC"}

package/build/backends/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/build/backends/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/backends/types.ts"],"names":[],"mappings":""}

package/build/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}