@deftai/directive 0.55.0

package/dist/verify-branch.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { evaluate } from "@deftai/directive-core/branch";
+/** Parse verify-branch CLI args, mirroring the Python argparse surface. */
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: ".",
+        allowMissingProjectDefinition: false,
+        defaultBranches: null,
+        quiet: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--allow-missing-project-definition") {
+            parsed.allowMissingProjectDefinition = true;
+        }
+        else if (arg === "--quiet") {
+            parsed.quiet = true;
+        }
+        else if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            }
+            parsed.projectRoot = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            parsed.projectRoot = arg.slice("--project-root=".length);
+        }
+        else if (arg === "--default-branch") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --default-branch: expected one argument" };
+            }
+            if (parsed.defaultBranches === null) {
+                parsed.defaultBranches = [];
+            }
+            parsed.defaultBranches.push(value);
+            i += 1;
+        }
+        else if (arg?.startsWith("--default-branch=")) {
+            if (parsed.defaultBranches === null) {
+                parsed.defaultBranches = [];
+            }
+            parsed.defaultBranches.push(arg.slice("--default-branch=".length));
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+/** Run the gate and return the process exit code. */
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`preflight_branch: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const defaultBranches = args.defaultBranches !== null ? new Set(args.defaultBranches) : undefined;
+    const result = evaluate(projectRoot, {
+        allowMissingProjectDefinition: args.allowMissingProjectDefinition,
+        defaultBranches,
+    });
+    if (result.exitCode === 0) {
+        if (!args.quiet) {
+            process.stdout.write(`${result.message}\n`);
+        }
+    }
+    else {
+        process.stderr.write(`${result.message}\n`);
+    }
+    return result.exitCode;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=verify-branch.js.map

package/dist/verify-encoding.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { type ScanMode } from "@deftai/directive-core";
+interface ParsedArgs {
+    mode: ScanMode;
+    projectRoot: string;
+    allowList: string | null;
+    quiet: boolean;
+    error?: string;
+}
+/** Parse the verify-encoding CLI args, mirroring the Python argparse surface. */
+export declare function parseArgs(argv: string[]): ParsedArgs;
+/** Run the gate and return the process exit code (no side effects on argv parse error -> 2). */
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=verify-encoding.d.ts.map

package/dist/verify-encoding.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { evaluate } from "@deftai/directive-core";
+/** Parse the verify-encoding CLI args, mirroring the Python argparse surface. */
+export function parseArgs(argv) {
+    const parsed = {
+        mode: "all",
+        projectRoot: ".",
+        allowList: null,
+        quiet: false,
+    };
+    let sawAll = false;
+    let sawStaged = false;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--all") {
+            sawAll = true;
+            parsed.mode = "all";
+        }
+        else if (arg === "--staged") {
+            sawStaged = true;
+            parsed.mode = "staged";
+        }
+        else if (arg === "--quiet") {
+            parsed.quiet = true;
+        }
+        else if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            }
+            parsed.projectRoot = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            parsed.projectRoot = arg.slice("--project-root=".length);
+        }
+        else if (arg === "--allow-list") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --allow-list: expected one argument" };
+            }
+            parsed.allowList = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--allow-list=")) {
+            parsed.allowList = arg.slice("--allow-list=".length);
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    if (sawAll && sawStaged) {
+        return { ...parsed, error: "argument --staged: not allowed with argument --all" };
+    }
+    return parsed;
+}
+/** Run the gate and return the process exit code (no side effects on argv parse error -> 2). */
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`verify_encoding: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const allowListPath = args.allowList !== null ? resolve(args.allowList) : null;
+    const result = evaluate(projectRoot, { mode: args.mode, allowListPath });
+    if (result.exitCode === 0) {
+        if (!args.quiet) {
+            process.stdout.write(`${result.message}\n`);
+        }
+    }
+    else {
+        process.stderr.write(`${result.message}\n`);
+    }
+    return result.exitCode;
+}
+// Only execute when invoked directly as a binary (not when imported in tests).
+// Normalize both sides via fileURLToPath so the guard fires on Windows too,
+// where process.argv[1] is a native backslash path and import.meta.url is a
+// forward-slash file:// URL -- a raw `file://${process.argv[1]}` never matches.
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=verify-encoding.js.map

package/dist/verify-env-parity.d.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+export interface Capture {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface ParityCase {
+    readonly name: string;
+    readonly runPython: (deftRoot: string) => Capture;
+    readonly runTs: (deftRoot: string) => Capture;
+}
+export interface ParityDiff {
+    readonly name: string;
+    readonly exitMismatch: boolean;
+    readonly stdoutMismatch: boolean;
+    readonly stderrMismatch: boolean;
+    readonly pythonExit: number;
+    readonly tsExit: number;
+}
+export interface ParityResult {
+    readonly ok: boolean;
+    readonly diffs: ParityDiff[];
+}
+export declare const PARITY_CASES: readonly ParityCase[];
+export declare function diffCase(python: Capture, ts: Capture, name: string): ParityDiff;
+export declare function runParity(deftRoot?: string): ParityResult;
+export declare function renderReport(result: ParityResult): string;
+//# sourceMappingURL=verify-env-parity.d.ts.map

package/dist/verify-env-parity.js

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+/**
+ * Golden-output parity harness (#1783 s1): runs BOTH the Python oracles and the
+ * ported TS verify-env gates over shared fixtures (cache-off), asserting
+ * byte-identical stdout/stderr and exit codes.
+ */
+import { spawnSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { evaluate as evaluateHooks, formatScanResult, runToolchainCheck, scan, verifyRequiredTools, } from "@deftai/directive-core/verify-env";
+function captureFromRun(exitCode, stdout, stderr) {
+    return { exitCode, stdout, stderr };
+}
+function loadModule(name, relPath) {
+    return `spec = importlib.util.spec_from_file_location(${JSON.stringify(name)}, root / ${JSON.stringify(relPath)})
+mod = importlib.util.module_from_spec(spec)
+sys.modules[${JSON.stringify(name)}] = mod
+spec.loader.exec_module(mod)`;
+}
+function runPythonScript(deftRoot, script) {
+    const code = `import importlib.util, sys\nfrom pathlib import Path\nroot = Path(${JSON.stringify(deftRoot)})\n${script}`;
+    const result = spawnSync("uv", ["run", "python", "-c", code], {
+        cwd: deftRoot,
+        encoding: "utf8",
+        env: { ...process.env, DEFT_CACHE_DISABLE: "1", PYTHONUTF8: "1" },
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    return {
+        exitCode: result.status ?? 2,
+        stdout: typeof result.stdout === "string" ? result.stdout : "",
+        stderr: typeof result.stderr === "string" ? result.stderr : "",
+    };
+}
+function probeWith(available) {
+    return (command) => (available.has(command) ? `/usr/bin/${command}` : null);
+}
+function makeNoTaskFixture(deftRoot) {
+    const root = mkdtempSync(join(tmpdir(), "deft-verify-env-notask-"));
+    mkdirSync(join(root, "scripts"), { recursive: true });
+    writeFileSync(join(root, "run"), "#!/usr/bin/env python3\n", "utf8");
+    writeFileSync(join(root, "scripts", "probe.py"), 'import subprocess\nimport shutil\nsubprocess.check_output(["task", "check"])\nshutil.which("task")\n', "utf8");
+    writeFileSync(join(root, "scripts", "verify_no_task_runtime.py"), readFileSync(join(deftRoot, "scripts", "verify_no_task_runtime.py"), "utf8"), "utf8");
+    return root;
+}
+export const PARITY_CASES = [
+    {
+        name: "verify-tools-clean-linux",
+        runPython(deftRoot) {
+            return runPythonScript(deftRoot, `${loadModule("verify_tools", "scripts/verify_tools.py")}
+available = {"git","uv","python3","gh","apt-get"}
+def probe(c):
+    return f"/usr/bin/{c}" if c in available else None
+lines = []
+result = mod.verify_required_tools(platform_id="linux", probe=probe, output_fn=lines.append)
+for line in lines:
+    print(line)
+sys.exit(result.exit_code)`);
+        },
+        runTs() {
+            const lines = [];
+            const result = verifyRequiredTools({
+                platformId: "linux",
+                probe: probeWith(new Set(["git", "uv", "python3", "gh", "apt-get"])),
+                outputFn: (line) => {
+                    lines.push(line);
+                },
+            });
+            return captureFromRun(result.exitCode, `${lines.join("\n")}\n`, "");
+        },
+    },
+    {
+        name: "verify-tools-missing-task",
+        runPython(deftRoot) {
+            return runPythonScript(deftRoot, `${loadModule("verify_tools", "scripts/verify_tools.py")}
+available = {"git","uv","python3","gh","apt-get"}
+def probe(c):
+    return f"/usr/bin/{c}" if c in available else None
+lines = []
+result = mod.verify_required_tools(platform_id="linux", include_task=True, probe=probe, output_fn=lines.append)
+for line in lines:
+    print(line)
+sys.exit(result.exit_code)`);
+        },
+        runTs() {
+            const lines = [];
+            const result = verifyRequiredTools({
+                platformId: "linux",
+                includeTask: true,
+                probe: probeWith(new Set(["git", "uv", "python3", "gh", "apt-get"])),
+                outputFn: (line) => {
+                    lines.push(line);
+                },
+            });
+            return captureFromRun(result.exitCode, `${lines.join("\n")}\n`, "");
+        },
+    },
+    {
+        name: "verify-tools-foundational-git-missing",
+        runPython(deftRoot) {
+            return runPythonScript(deftRoot, `${loadModule("verify_tools", "scripts/verify_tools.py")}
+available = {"task","uv","python3","gh","apt-get"}
+def probe(c):
+    return f"/usr/bin/{c}" if c in available else None
+result = mod.verify_required_tools(platform_id="linux", probe=probe)
+sys.exit(result.exit_code)`);
+        },
+        runTs() {
+            const result = verifyRequiredTools({
+                platformId: "linux",
+                probe: probeWith(new Set(["task", "uv", "python3", "gh", "apt-get"])),
+            });
+            return captureFromRun(result.exitCode, "", "");
+        },
+    },
+    {
+        name: "verify-hooks-clean-deft-root",
+        runPython(deftRoot) {
+            return runPythonScript(deftRoot, `${loadModule("verify_hooks_installed", "scripts/verify_hooks_installed.py")}
+code, msg = mod.evaluate(root)
+print(msg, file=sys.stdout if code == 0 else sys.stderr)
+sys.exit(code)`);
+        },
+        runTs(deftRoot) {
+            const result = evaluateHooks(deftRoot);
+            if (result.stream === "stdout") {
+                return captureFromRun(result.code, `${result.message}\n`, "");
+            }
+            return captureFromRun(result.code, "", `${result.message}\n`);
+        },
+    },
+    {
+        name: "verify-hooks-unset",
+        runPython(deftRoot) {
+            const fixture = mkdtempSync(join(tmpdir(), "deft-verify-env-hooks-unset-"));
+            mkdirSync(fixture, { recursive: true });
+            const cap = runPythonScript(deftRoot, `${loadModule("verify_hooks_installed", "scripts/verify_hooks_installed.py")}
+code, msg = mod.evaluate(Path(${JSON.stringify(fixture)}))
+print(msg, file=sys.stdout if code == 0 else sys.stderr)
+sys.exit(code)`);
+            rmSync(fixture, { recursive: true, force: true });
+            return cap;
+        },
+        runTs() {
+            const fixture = mkdtempSync(join(tmpdir(), "deft-verify-env-hooks-unset-ts-"));
+            const result = evaluateHooks(fixture, {
+                gitConfigReader: () => ({ hooksPath: null, error: null }),
+            });
+            rmSync(fixture, { recursive: true, force: true });
+            return captureFromRun(result.code, "", `${result.message}\n`);
+        },
+    },
+    {
+        name: "toolchain-empty-path",
+        runPython(deftRoot) {
+            return runPythonScript(deftRoot, `${loadModule("toolchain_check", "scripts/toolchain-check.py")}
+from unittest.mock import patch
+def fake_run(*args, **kwargs):
+    raise FileNotFoundError(args[0][0])
+with patch("subprocess.run", fake_run):
+    sys.exit(mod.main())`);
+        },
+        runTs() {
+            const result = runToolchainCheck(() => ({ error: "not-found", message: "" }));
+            return captureFromRun(result.exitCode, `${result.lines.join("\n")}\n`, "");
+        },
+    },
+    {
+        name: "verify-no-task-runtime-clean-deft-root",
+        runPython(deftRoot) {
+            return runPythonScript(deftRoot, `${loadModule("verify_no_task_runtime", "scripts/verify_no_task_runtime.py")}
+sys.exit(mod.main())`);
+        },
+        runTs(deftRoot) {
+            const findings = scan({ root: deftRoot });
+            const formatted = formatScanResult(findings);
+            return captureFromRun(formatted.exitCode, formatted.stdout, formatted.stderr);
+        },
+    },
+    {
+        name: "verify-no-task-runtime-findings",
+        runPython(deftRoot) {
+            const fixture = makeNoTaskFixture(deftRoot);
+            const cap = runPythonScript(deftRoot, `${loadModule("verify_no_task_runtime", "scripts/verify_no_task_runtime.py")}
+fixture = Path(${JSON.stringify(fixture)})
+mod.ROOT = fixture
+mod._python_files = lambda: [fixture / "run", fixture / "scripts" / "probe.py"]
+findings = mod.scan()
+if not findings:
+    print("No runtime go-task subprocess dependencies found")
+    sys.exit(0)
+print("Runtime go-task dependencies found:", file=sys.stderr)
+for finding in findings:
+    rel = finding.path.relative_to(mod.ROOT)
+    print(f"  {rel}:{finding.line}: {finding.message}", file=sys.stderr)
+sys.exit(1)`);
+            rmSync(fixture, { recursive: true, force: true });
+            return cap;
+        },
+        runTs(deftRoot) {
+            const fixture = makeNoTaskFixture(deftRoot);
+            const findings = scan({
+                root: fixture,
+                pythonFiles: () => [join(fixture, "run"), join(fixture, "scripts", "probe.py")],
+            });
+            const formatted = formatScanResult(findings);
+            rmSync(fixture, { recursive: true, force: true });
+            return captureFromRun(formatted.exitCode, formatted.stdout, formatted.stderr);
+        },
+    },
+];
+function resolveDeftRoot() {
+    if (process.env.DEFT_ROOT !== undefined && process.env.DEFT_ROOT.length > 0) {
+        return resolve(process.env.DEFT_ROOT);
+    }
+    return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+}
+export function diffCase(python, ts, name) {
+    return {
+        name,
+        exitMismatch: python.exitCode !== ts.exitCode,
+        stdoutMismatch: python.stdout !== ts.stdout,
+        stderrMismatch: python.stderr !== ts.stderr,
+        pythonExit: python.exitCode,
+        tsExit: ts.exitCode,
+    };
+}
+export function runParity(deftRoot = resolveDeftRoot()) {
+    const diffs = [];
+    for (const testCase of PARITY_CASES) {
+        diffs.push(diffCase(testCase.runPython(deftRoot), testCase.runTs(deftRoot), testCase.name));
+    }
+    return {
+        ok: diffs.every((d) => !d.exitMismatch && !d.stdoutMismatch && !d.stderrMismatch),
+        diffs,
+    };
+}
+export function renderReport(result) {
+    if (result.ok) {
+        return `verify-env parity: CLEAN -- Python and TS agree on ${PARITY_CASES.length} case(s).`;
+    }
+    const lines = ["verify-env parity: DIVERGENCE"];
+    for (const d of result.diffs) {
+        if (d.exitMismatch || d.stdoutMismatch || d.stderrMismatch) {
+            lines.push(`  case: ${d.name}`);
+            if (d.exitMismatch)
+                lines.push(`    exit: python=${d.pythonExit} ts=${d.tsExit}`);
+            if (d.stdoutMismatch)
+                lines.push("    stdout mismatch");
+            if (d.stderrMismatch)
+                lines.push("    stderr mismatch");
+        }
+    }
+    return lines.join("\n");
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    try {
+        const result = runParity();
+        if (result.ok) {
+            process.stdout.write(`${renderReport(result)}\n`);
+            process.exit(0);
+        }
+        process.stderr.write(`${renderReport(result)}\n`);
+        process.exit(1);
+    }
+    catch (err) {
+        process.stderr.write(`verify-env parity: harness error -- ${String(err)}\n`);
+        process.exit(2);
+    }
+}
+//# sourceMappingURL=verify-env-parity.js.map

package/dist/verify-hooks-installed.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string;
+    quiet: boolean;
+    error?: string;
+}
+export declare function parseArgs(argv: string[]): ParsedArgs;
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=verify-hooks-installed.d.ts.map

package/dist/verify-hooks-installed.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { evaluate } from "@deftai/directive-core/verify-env";
+export function parseArgs(argv) {
+    const parsed = { projectRoot: ".", quiet: false };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--quiet")
+            parsed.quiet = true;
+        else if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            }
+            parsed.projectRoot = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            parsed.projectRoot = arg.slice("--project-root=".length);
+        }
+        else {
+            return { ...parsed, error: `unrecognized arguments: ${arg}` };
+        }
+    }
+    return parsed;
+}
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`${args.error}\n`);
+        return 2;
+    }
+    const result = evaluate(resolve(args.projectRoot));
+    if (!args.quiet) {
+        if (result.stream === "stdout") {
+            process.stdout.write(`${result.message}\n`);
+        }
+        else if (result.stream === "stderr") {
+            process.stderr.write(`${result.message}\n`);
+        }
+    }
+    return result.code;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=verify-hooks-installed.js.map

package/dist/verify-investigation.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function run(argv: string[]): number;
+//# sourceMappingURL=verify-investigation.d.ts.map

package/dist/verify-investigation.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { cmdVerifyInvestigation } from "@deftai/directive-core/orchestration";
+export function run(argv) {
+    return cmdVerifyInvestigation(argv);
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=verify-investigation.js.map

package/dist/verify-judgment-gates.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function run(argv: string[]): number;
+//# sourceMappingURL=verify-judgment-gates.d.ts.map

package/dist/verify-judgment-gates.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { cmdVerifyJudgmentGates } from "@deftai/directive-core/orchestration";
+export function run(argv) {
+    return cmdVerifyJudgmentGates(argv);
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=verify-judgment-gates.js.map

package/dist/verify-no-task-runtime.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function run(): number;
+//# sourceMappingURL=verify-no-task-runtime.d.ts.map

package/dist/verify-no-task-runtime.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { formatScanResult, scan } from "@deftai/directive-core/verify-env";
+export function run() {
+    const findings = scan();
+    const result = formatScanResult(findings);
+    if (result.stdout.length > 0)
+        process.stdout.write(result.stdout);
+    if (result.stderr.length > 0)
+        process.stderr.write(result.stderr);
+    return result.exitCode;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run());
+}
+//# sourceMappingURL=verify-no-task-runtime.js.map

package/dist/verify-session-ritual.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string;
+    tier: "quick" | "gated";
+    emitJson: boolean;
+    error?: string;
+}
+/** Parse verify-session-ritual CLI args, mirroring scripts/verify_session_ritual.py. */
+export declare function parseArgs(argv: string[]): ParsedArgs;
+/** Run the gate and return the process exit code. */
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=verify-session-ritual.d.ts.map