@deftai/directive-core 0.55.0

package/dist/verify-source/rule-ownership-lint.js

@@ -0,0 +1,179 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+export const EXIT_OK = 0;
+export const EXIT_DRIFT = 1;
+export const EXIT_CONFIG_ERROR = 2;
+export const DEFAULT_MAP_PATH = "content/conventions/rule-ownership.json";
+export const VALID_AUTHORITIES = new Set([
+    "MUST",
+    "SHOULD",
+    "MUST_NOT",
+    "SHOULD_NOT",
+    "AXIOM",
+    "lesson",
+]);
+export const REQUIRED_FIELDS = [
+    "id",
+    "text",
+    "owner_file",
+    "owner_section",
+    "authority",
+    "last_verified",
+];
+/** Parse markdown ATX heading: returns [level, text] or null. Linear scan, no backtracking regex. */
+export function parseHeading(line) {
+    let level = 0;
+    while (level < line.length && line.charAt(level) === "#") {
+        level += 1;
+    }
+    if (level === 0 || level > 6) {
+        return null;
+    }
+    if (line.charAt(level) !== " ") {
+        return null;
+    }
+    const i = level + 1;
+    let end = line.length;
+    while (end > i && (line.charAt(end - 1) === " " || line.charAt(end - 1) === "\t")) {
+        end -= 1;
+    }
+    const text = line.slice(i, end).trim();
+    return [level, text];
+}
+export function extractSectionBody(content, ownerSection) {
+    const parsed = parseHeading(ownerSection.trim());
+    if (parsed === null) {
+        return null;
+    }
+    const [targetLevel, targetText] = parsed;
+    const lines = content.split("\n");
+    let inSection = false;
+    const body = [];
+    for (const line of lines) {
+        const heading = parseHeading(line);
+        if (!inSection) {
+            if (heading && heading[0] === targetLevel && heading[1] === targetText) {
+                inSection = true;
+            }
+            continue;
+        }
+        if (heading && heading[0] <= targetLevel) {
+            break;
+        }
+        body.push(line);
+    }
+    if (!inSection) {
+        return null;
+    }
+    return body.join("\n");
+}
+export function loadMap(mapPath) {
+    if (!existsSync(mapPath)) {
+        throw new Error(`ROM data file not found: ${mapPath}`);
+    }
+    let raw;
+    try {
+        raw = readFileSync(mapPath, { encoding: "utf8" });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`Failed to read ROM data file ${mapPath}: ${msg}`);
+    }
+    let payload;
+    try {
+        payload = JSON.parse(raw);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`Malformed JSON in ROM data file ${mapPath}: ${msg}`);
+    }
+    if (typeof payload !== "object" || payload === null) {
+        throw new Error(`ROM data file ${mapPath} must contain a JSON object at the top level (got ${typeof payload}).`);
+    }
+    const rules = payload.rules;
+    if (!Array.isArray(rules)) {
+        throw new Error(`ROM data file ${mapPath} must contain a 'rules' array (got ${typeof rules}).`);
+    }
+    const seenIds = new Set();
+    for (let index = 0; index < rules.length; index += 1) {
+        const rule = rules[index];
+        if (typeof rule !== "object" || rule === null) {
+            throw new Error(`ROM rule at index ${index} must be a JSON object (got ${typeof rule}).`);
+        }
+        const rec = rule;
+        for (const field of REQUIRED_FIELDS) {
+            if (!(field in rec)) {
+                throw new Error(`ROM rule at index ${index} is missing required field '${field}'.`);
+            }
+            const val = rec[field];
+            if (typeof val !== "string" || val.length === 0) {
+                throw new Error(`ROM rule at index ${index} field '${field}' must be a non-empty string.`);
+            }
+        }
+        const ruleId = rec.id;
+        if (seenIds.has(ruleId)) {
+            throw new Error(`Duplicate ROM rule id: '${ruleId}'`);
+        }
+        seenIds.add(ruleId);
+        const authority = rec.authority;
+        if (!VALID_AUTHORITIES.has(authority)) {
+            const sorted = [...VALID_AUTHORITIES].sort();
+            throw new Error(`ROM rule '${ruleId}' has invalid authority '${authority}'; expected one of ${JSON.stringify(sorted)}.`);
+        }
+    }
+    return { rules: rules };
+}
+export function lintRules(payload, root) {
+    const diagnostics = [];
+    for (const rule of payload.rules) {
+        const { id: ruleId, owner_file: ownerFile, owner_section: ownerSection, text } = rule;
+        const target = join(root, ownerFile);
+        if (!existsSync(target)) {
+            diagnostics.push(`[${ruleId}] owner_file not found: ${ownerFile} -- either restore the file or update the ROM row to point at the new owner.`);
+            continue;
+        }
+        let content;
+        try {
+            content = readFileSync(target, { encoding: "utf8" });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            diagnostics.push(`[${ruleId}] failed to read ${ownerFile}: ${msg}`);
+            continue;
+        }
+        const body = extractSectionBody(content, ownerSection);
+        if (body === null) {
+            diagnostics.push(`[${ruleId}] owner_section '${ownerSection}' not found in ${ownerFile} -- either restore the heading or update the ROM row to point at the new section.`);
+            continue;
+        }
+        if (!body.includes(text)) {
+            diagnostics.push(`[${ruleId}] rule text not found in ${ownerFile} '${ownerSection}' -- the rule has been moved, deleted, or rewritten. Update the ROM row's 'text' (or 'owner_file' / 'owner_section') to match. Looked for: '${text}'`);
+        }
+    }
+    return diagnostics;
+}
+export function evaluateRuleOwnership(projectRoot, options = {}) {
+    const root = resolve(options.root ?? projectRoot);
+    const mapPath = resolve(options.mapPath ?? join(root, DEFAULT_MAP_PATH));
+    try {
+        const payload = loadMap(mapPath);
+        const diagnostics = lintRules(payload, root);
+        if (diagnostics.length > 0) {
+            const lines = [
+                `FAIL: rule ownership map drift detected in ${diagnostics.length} row(s):`,
+                ...diagnostics.map((d) => `  - ${d}`),
+            ];
+            return { code: EXIT_DRIFT, message: lines.join("\n"), stream: "stderr" };
+        }
+        return {
+            code: EXIT_OK,
+            message: `OK: rule ownership map clean -- ${payload.rules.length} row(s) verified against their owner files (root=${root}).`,
+            stream: "stderr",
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { code: EXIT_CONFIG_ERROR, message: `Error: ${msg}`, stream: "stderr" };
+    }
+}
+//# sourceMappingURL=rule-ownership-lint.js.map

package/dist/verify-source/scm-boundary.d.ts

@@ -0,0 +1,26 @@
+export declare const GH_BINARIES: Set<string>;
+export declare const SCOPE_GLOBS: readonly string[];
+export declare const BUILTIN_ALLOW_LIST: readonly string[];
+export interface ScmFinding {
+    readonly path: string;
+    readonly line: number;
+    readonly col: number;
+    readonly helper: string;
+    readonly context: string;
+}
+export declare function renderScmFinding(f: ScmFinding): string;
+export declare function candidateFiles(projectRoot: string, scopeGlobs?: readonly string[]): Array<[string, string]>;
+export declare function scanFile(relPath: string, fullPath: string): ScmFinding[];
+export interface ScmEvaluateResult {
+    readonly code: 0 | 1 | 2;
+    readonly findings: readonly ScmFinding[];
+    readonly message: string;
+    readonly stream: "stdout" | "stderr";
+}
+export interface ScmEvaluateOptions {
+    readonly allowListPath?: string | null;
+    readonly scopeGlobs?: readonly string[];
+    readonly quiet?: boolean;
+}
+export declare function evaluateScmBoundary(projectRoot: string, options?: ScmEvaluateOptions): ScmEvaluateResult;
+//# sourceMappingURL=scm-boundary.d.ts.map

package/dist/verify-source/scm-boundary.js

@@ -0,0 +1,170 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { fnmatchCase } from "../encoding/text.js";
+import { scanPythonGhCalls } from "./python-call-scan.js";
+export const GH_BINARIES = new Set(["gh", "ghx"]);
+export const SCOPE_GLOBS = [
+    "scripts/triage_*.py",
+    "scripts/_triage_*.py",
+    "scripts/scope_*.py",
+    "scripts/_scope_*.py",
+    "scripts/slice_*.py",
+    "scripts/resume_conditions.py",
+    "scripts/issue_ingest.py",
+];
+export const BUILTIN_ALLOW_LIST = [
+    "scripts/scm.py",
+    "tests/cli/test_verify_scm_boundary.py",
+];
+export function renderScmFinding(f) {
+    const ctx = f.context.length <= 120 ? f.context : `${f.context.slice(0, 117)}...`;
+    return `  ${f.path}:${f.line}:${f.col} [${f.helper}] ${ctx}`;
+}
+function loadAllowList(path) {
+    if (path === null) {
+        return [];
+    }
+    if (!existsSync(path)) {
+        return {
+            error: `verify_scm_boundary: --allow-list file not found: [Errno 2] No such file or directory: '${path}'\n` +
+                "  Recovery: pass an existing path or omit the flag.",
+        };
+    }
+    try {
+        const raw = readFileSync(path, { encoding: "utf8" });
+        const out = [];
+        for (const line of raw.split("\n")) {
+            const stripped = line.trim();
+            if (!stripped || stripped.startsWith("#")) {
+                continue;
+            }
+            out.push(stripped);
+        }
+        return out;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            error: `verify_scm_boundary: --allow-list unreadable: ${msg}\n` +
+                "  Recovery: check file permissions.",
+        };
+    }
+}
+function isAllowListed(relPath, patterns) {
+    return patterns.some((pat) => fnmatchCase(relPath, pat));
+}
+function globOnePattern(projectRoot, pattern) {
+    const slash = pattern.lastIndexOf("/");
+    const dir = slash >= 0 ? join(projectRoot, pattern.slice(0, slash)) : projectRoot;
+    if (!existsSync(dir) || !statSync(dir).isDirectory()) {
+        return [];
+    }
+    const out = [];
+    for (const name of readdirSync(dir)) {
+        const rel = slash >= 0 ? `${pattern.slice(0, slash)}/${name}` : name;
+        const full = join(projectRoot, rel);
+        try {
+            if (!statSync(full).isFile()) {
+                continue;
+            }
+        }
+        catch {
+            continue;
+        }
+        if (fnmatchCase(rel.replace(/\\/g, "/"), pattern)) {
+            out.push([rel.replace(/\\/g, "/"), full]);
+        }
+    }
+    return out;
+}
+export function candidateFiles(projectRoot, scopeGlobs = SCOPE_GLOBS) {
+    const out = new Map();
+    for (const pattern of scopeGlobs) {
+        for (const [rel, full] of globOnePattern(projectRoot, pattern)) {
+            out.set(rel, full);
+        }
+    }
+    return [...out.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+}
+export function scanFile(relPath, fullPath) {
+    let source;
+    try {
+        source = readFileSync(fullPath, { encoding: "utf8" });
+    }
+    catch {
+        return [];
+    }
+    const findings = [];
+    const sites = scanPythonGhCalls(source);
+    for (const site of sites) {
+        findings.push({
+            path: relPath,
+            line: site.line,
+            col: site.col,
+            helper: site.helper,
+            context: site.context,
+        });
+    }
+    return findings;
+}
+export function evaluateScmBoundary(projectRoot, options = {}) {
+    const root = resolve(projectRoot);
+    const allowLoaded = loadAllowList(options.allowListPath ?? null);
+    if (!Array.isArray(allowLoaded)) {
+        return { code: 2, findings: [], message: allowLoaded.error, stream: "stderr" };
+    }
+    let isDir = false;
+    try {
+        isDir = statSync(root).isDirectory();
+    }
+    catch {
+        isDir = false;
+    }
+    if (!isDir) {
+        return {
+            code: 2,
+            findings: [],
+            message: `verify_scm_boundary: --project-root is not a directory: ${root}\n` +
+                "  Recovery: pass an existing directory path.",
+            stream: "stderr",
+        };
+    }
+    const allowGlobs = [...BUILTIN_ALLOW_LIST, ...allowLoaded];
+    const scopeGlobs = options.scopeGlobs ?? SCOPE_GLOBS;
+    const candidates = candidateFiles(root, scopeGlobs);
+    const findings = [];
+    let scanned = 0;
+    for (const [rel, full] of candidates) {
+        if (isAllowListed(rel, allowGlobs)) {
+            continue;
+        }
+        scanned += 1;
+        findings.push(...scanFile(rel, full));
+    }
+    if (findings.length > 0) {
+        const filesWithHits = new Set(findings.map((f) => f.path)).size;
+        const header = `verify_scm_boundary: detected ${findings.length} raw ` +
+            "`gh` / `ghx` subprocess call(s) across " +
+            `${filesWithHits} file(s) (#1145 / N5).\n` +
+            "  Root cause: the verb layer is required to invoke `gh` only via `scripts.scm.call(source, verb, args, **kwargs)` so a future\n" +
+            "  GitLab / Gitea / local consumer sees a loud `NotImplementedError` (see #445 / #935 Workstream 6) instead of a confusing\n" +
+            "  `gh: command not found` deep in the call stack. Fix: rewrite the offending call sites as\n" +
+            "    `import scm`\n" +
+            '    `scm.call("github-issue", verb, args, ...)`\n' +
+            "  Allow-list a documented exception via `--allow-list <path>` (file with newline-separated glob patterns).";
+        let body = findings
+            .slice(0, 50)
+            .map((f) => renderScmFinding(f))
+            .join("\n");
+        if (findings.length > 50) {
+            body += `\n  ... and ${findings.length - 50} more`;
+        }
+        return { code: 1, findings, message: `${header}\n${body}`, stream: "stderr" };
+    }
+    const msg = `verify_scm_boundary: ${scanned} verb-layer file(s) clean -- every \`gh\` / \`ghx\` invocation routes through \`scm.call\` (#1145 / N5).`;
+    if (options.quiet) {
+        return { code: 0, findings: [], message: "", stream: "stdout" };
+    }
+    return { code: 0, findings: [], message: msg, stream: "stdout" };
+}
+//# sourceMappingURL=scm-boundary.js.map

package/dist/verify-source/verify-stubs.d.ts

@@ -0,0 +1,19 @@
+export declare const EXCLUDE_DIRS: Set<string>;
+export declare const EXTENSIONS: Set<string>;
+export interface StubFinding {
+    readonly path: string;
+    readonly line: number;
+    readonly label: string;
+    readonly text: string;
+}
+/** Recursive sorted rglob mirroring `sorted(Path(".").rglob("*"))`. */
+export declare function sortedRglob(root: string): string[];
+export declare function scanFileForStubs(relPath: string, fullPath: string): StubFinding[];
+export interface VerifyStubsResult {
+    readonly code: 0 | 1;
+    readonly findings: readonly StubFinding[];
+    readonly message: string;
+    readonly stream: "stdout";
+}
+export declare function evaluateVerifyStubs(projectRoot?: string): VerifyStubsResult;
+//# sourceMappingURL=verify-stubs.d.ts.map

package/dist/verify-source/verify-stubs.js

@@ -0,0 +1,185 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+export const EXCLUDE_DIRS = new Set([
+    "tests",
+    "vendor",
+    ".git",
+    "backup",
+    "history",
+    "node_modules",
+    ".venv",
+    "__pycache__",
+    "dist",
+    "scripts",
+]);
+export const EXTENSIONS = new Set([".py", ".go", ".sh"]);
+function isWordChar(ch) {
+    if (ch.length === 0) {
+        return false;
+    }
+    const c = ch.charCodeAt(0);
+    return (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c === 95;
+}
+function hasWordBoundary(text, index) {
+    if (index > 0 && isWordChar(text.charAt(index - 1))) {
+        return false;
+    }
+    return true;
+}
+function hasWordEnd(text, index, word) {
+    const after = index + word.length;
+    if (after < text.length && isWordChar(text.charAt(after))) {
+        return false;
+    }
+    return true;
+}
+function findWord(text, word) {
+    let from = 0;
+    while (from < text.length) {
+        const idx = text.indexOf(word, from);
+        if (idx < 0) {
+            return false;
+        }
+        if (hasWordBoundary(text, idx) && hasWordEnd(text, idx, word)) {
+            return true;
+        }
+        from = idx + 1;
+    }
+    return false;
+}
+function hasReturnNull(text) {
+    const needle = "return";
+    let from = 0;
+    while (from < text.length) {
+        const idx = text.indexOf(needle, from);
+        if (idx < 0) {
+            return false;
+        }
+        if (!hasWordBoundary(text, idx)) {
+            from = idx + 1;
+            continue;
+        }
+        let i = idx + needle.length;
+        while (i < text.length && /\s/.test(text.charAt(i))) {
+            i += 1;
+        }
+        if (text.slice(i, i + 4) === "null" && hasWordEnd(text, i, "null")) {
+            return true;
+        }
+        from = idx + 1;
+    }
+    return false;
+}
+/** Recursive sorted rglob mirroring `sorted(Path(".").rglob("*"))`. */
+export function sortedRglob(root) {
+    const out = [];
+    function walk(dir, relPrefix) {
+        let names;
+        try {
+            names = readdirSync(dir).sort();
+        }
+        catch {
+            return;
+        }
+        for (const name of names) {
+            const rel = relPrefix ? `${relPrefix}/${name}` : name;
+            const full = join(dir, name);
+            let st;
+            try {
+                st = statSync(full);
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory()) {
+                walk(full, rel);
+            }
+            else {
+                out.push(rel);
+            }
+        }
+    }
+    walk(root, "");
+    return out;
+}
+export function scanFileForStubs(relPath, fullPath) {
+    const findings = [];
+    const suffix = relPath.includes(".") ? relPath.slice(relPath.lastIndexOf(".")) : "";
+    if (!EXTENSIONS.has(suffix)) {
+        return findings;
+    }
+    const parts = relPath.split("/");
+    if (parts.some((p) => EXCLUDE_DIRS.has(p))) {
+        return findings;
+    }
+    let text;
+    try {
+        text = readFileSync(fullPath, { encoding: "utf8" });
+    }
+    catch {
+        return findings;
+    }
+    const lines = text.split("\n");
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i] ?? "";
+        const lineno = i + 1;
+        const stripped = line.trim();
+        if (stripped === "pass" && suffix === ".py" && lineno >= 2) {
+            const prev = (lines[i - 1] ?? "").trim();
+            if (prev.endsWith(":") && !prev.startsWith("#")) {
+                findings.push({
+                    path: relPath,
+                    line: lineno,
+                    label: "bare pass",
+                    text: line.replace(/\r$/, ""),
+                });
+            }
+        }
+        const patterns = [
+            [findWord(line, "TODO"), "TODO"],
+            [findWord(line, "FIXME"), "FIXME"],
+            [findWord(line, "HACK"), "HACK"],
+            [hasReturnNull(line), "return null"],
+        ];
+        for (const [hit, label] of patterns) {
+            if (hit) {
+                findings.push({ path: relPath, line: lineno, label, text: line.replace(/\r$/, "") });
+            }
+        }
+    }
+    return findings;
+}
+export function evaluateVerifyStubs(projectRoot = ".") {
+    const root = resolve(projectRoot);
+    const allFindings = [];
+    for (const rel of sortedRglob(root)) {
+        const full = join(root, rel);
+        try {
+            if (!statSync(full).isFile()) {
+                continue;
+            }
+        }
+        catch {
+            continue;
+        }
+        allFindings.push(...scanFileForStubs(rel, full));
+    }
+    if (allFindings.length > 0) {
+        let body = `Found ${allFindings.length} stub(s):\n`;
+        for (const f of allFindings.slice(0, 50)) {
+            const ctx = f.text.length <= 120 ? f.text : f.text.slice(0, 120);
+            body += `  ${f.path}:${f.line} [${f.label}] ${ctx}\n`;
+        }
+        if (allFindings.length > 50) {
+            body += `  ... and ${allFindings.length - 50} more\n`;
+        }
+        return { code: 1, findings: allFindings, message: body.trimEnd(), stream: "stdout" };
+    }
+    return {
+        code: 0,
+        findings: [],
+        message: "No stub patterns found in source files",
+        stream: "stdout",
+    };
+}
+//# sourceMappingURL=verify-stubs.js.map

package/dist/wip-cap/evaluate.d.ts

@@ -0,0 +1,17 @@
+export type OutputStream = "stdout" | "stderr" | "none";
+/** Result of verify:wip-cap evaluation; mirrors the Python three-state exit contract. */
+export interface EvaluateResult {
+    readonly code: 0 | 1 | 2;
+    readonly message: string;
+    readonly stream: OutputStream;
+}
+export interface EvaluateOptions {
+    readonly allowOverCap?: boolean;
+    readonly quiet?: boolean;
+}
+/**
+ * Pure evaluator for the WIP-cap re-validation gate (#1124 / D4 of #1119).
+ * Faithful to `scripts/preflight_wip_cap.py`.
+ */
+export declare function evaluate(projectRoot: string, options?: EvaluateOptions): EvaluateResult;
+//# sourceMappingURL=evaluate.d.ts.map

package/dist/wip-cap/evaluate.js

@@ -0,0 +1,62 @@
+import { resolve } from "node:path";
+import { countVbriefWip, resolveWipCap } from "../policy/wip.js";
+function formatRefusal(count, cap, projectRoot) {
+    return (`❌ verify:wip-cap: ${count}/${cap} in pending/+active/ ` +
+        `(over cap; project_root=${projectRoot}).\n` +
+        "   Drain the WIP set before merging:\n" +
+        "     task scope:demote <existing>                       # return one to proposed/\n" +
+        "     task scope:demote --batch --older-than-days 30     # bulk relief\n" +
+        "   Or open a follow-up PR with --force-merge intent (audit-logged).\n" +
+        "   (#1124 / D4 of #1119; see plan.policy.wipCap in " +
+        "vbrief/PROJECT-DEFINITION.vbrief.json.)");
+}
+/**
+ * Pure evaluator for the WIP-cap re-validation gate (#1124 / D4 of #1119).
+ * Faithful to `scripts/preflight_wip_cap.py`.
+ */
+export function evaluate(projectRoot, options = {}) {
+    const root = resolve(projectRoot);
+    const allowOverCap = options.allowOverCap ?? false;
+    const quiet = options.quiet ?? false;
+    const capResult = resolveWipCap(root);
+    if (capResult.source === "default-on-error" && capResult.error !== null) {
+        return {
+            code: 2,
+            message: `❌ verify:wip-cap: PROJECT-DEFINITION malformed: ${capResult.error}`,
+            stream: "stderr",
+        };
+    }
+    const cap = capResult.cap;
+    const count = countVbriefWip(root);
+    if (count < cap) {
+        if (quiet) {
+            return { code: 0, message: "", stream: "none" };
+        }
+        return {
+            code: 0,
+            message: `✓ verify:wip-cap: ${count}/${cap} in pending/+active/ ` +
+                `(within cap; source=${capResult.source}).`,
+            stream: "stdout",
+        };
+    }
+    if (allowOverCap) {
+        if (quiet) {
+            return { code: 0, message: "", stream: "none" };
+        }
+        return {
+            code: 0,
+            message: `⚠ verify:wip-cap: ${count}/${cap} in pending/+active/ ` +
+                "is OVER cap, but --allow-over-cap was passed (framework " +
+                "landing-day grace; consumers MUST NOT use this flag).\n" +
+                "  Drain via task scope:demote / task scope:demote --batch " +
+                "--older-than-days 30 (#1119 umbrella v3).",
+            stream: "stderr",
+        };
+    }
+    return {
+        code: 1,
+        message: formatRefusal(count, cap, root),
+        stream: "stderr",
+    };
+}
+//# sourceMappingURL=evaluate.js.map

package/dist/wip-cap/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./evaluate.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/wip-cap/index.js

@@ -0,0 +1,2 @@
+export * from "./evaluate.js";
+//# sourceMappingURL=index.js.map