modwright 0.1.0

package/dist/core/knowledge/store.js

@@ -0,0 +1,123 @@
+import { existsSync, promises as fs } from "node:fs";
+import * as path from "node:path";
+import initSqlJs from "sql.js";
+import { legacyCacheDirs, userCacheDir } from "../home.js";
+let sqlPromise;
+async function sql() {
+    sqlPromise ??= initSqlJs();
+    return sqlPromise;
+}
+export class IndexStore {
+    file;
+    db;
+    constructor(file, db) {
+        this.file = file;
+        this.db = db;
+    }
+    static async open(file) {
+        const SQL = await sql();
+        let bytes;
+        if (file) {
+            try {
+                bytes = new Uint8Array(await fs.readFile(file));
+            }
+            catch {
+                bytes = undefined;
+            }
+        }
+        return new IndexStore(file, bytes ? new SQL.Database(bytes) : new SQL.Database());
+    }
+    run(statement, params = []) {
+        this.db.run(statement, params);
+    }
+    exec(script) {
+        this.db.exec(script);
+    }
+    all(statement, params = []) {
+        const stmt = this.db.prepare(statement);
+        try {
+            stmt.bind(params);
+            const rows = [];
+            while (stmt.step())
+                rows.push(stmt.getAsObject());
+            return rows;
+        }
+        finally {
+            stmt.free();
+        }
+    }
+    get(statement, params = []) {
+        return this.all(statement, params)[0];
+    }
+    transaction(fn) {
+        this.db.run("BEGIN");
+        try {
+            const result = fn();
+            this.db.run("COMMIT");
+            return result;
+        }
+        catch (error) {
+            this.db.run("ROLLBACK");
+            throw error;
+        }
+    }
+    insertMany(table, columns, rows) {
+        const placeholders = columns.map(() => "?").join(", ");
+        const stmt = this.db.prepare(`INSERT INTO ${table} (${columns.join(", ")}) VALUES (${placeholders})`);
+        try {
+            for (const row of rows) {
+                stmt.run(row);
+                stmt.reset();
+            }
+        }
+        finally {
+            stmt.free();
+        }
+        return rows.length;
+    }
+    tableCounts() {
+        const counts = {};
+        for (const row of this.all("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '%_content' AND name NOT LIKE '%_segments' AND name NOT LIKE '%_segdir' AND name NOT LIKE '%_docsize' AND name NOT LIKE '%_stat'")) {
+            const name = String(row.name);
+            counts[name] = Number(this.get(`SELECT count(*) AS n FROM "${name}"`)?.n ?? 0);
+        }
+        return counts;
+    }
+    async save(file = this.file) {
+        if (!file)
+            throw new Error("IndexStore.save: no file path given.");
+        await fs.mkdir(path.dirname(file), { recursive: true });
+        const bytes = this.db.export();
+        const tmp = `${file}.tmp-${process.pid}`;
+        await fs.writeFile(tmp, bytes);
+        await fs.rename(tmp, file);
+        return file;
+    }
+    close() {
+        this.db.close();
+    }
+}
+export function indexFile(cacheDir, game, name = "vanilla") {
+    return path.join(cacheDir, game, `${name}.sqlite`);
+}
+export function defaultCacheDir() {
+    return process.env.MODWRIGHT_CACHE_DIR ?? userCacheDir();
+}
+export function findLegacyIndex(game, cacheDir = defaultCacheDir()) {
+    if (existsSync(indexFile(cacheDir, game)))
+        return undefined;
+    for (const dir of legacyCacheDirs(cacheDir)) {
+        const file = indexFile(dir, game);
+        if (existsSync(file))
+            return { dir, file, gameDir: path.dirname(file) };
+    }
+    return undefined;
+}
+export function resolveIndexFile(game, cacheDir = defaultCacheDir()) {
+    const legacy = findLegacyIndex(game, cacheDir);
+    return legacy ? { file: legacy.file, legacy } : { file: indexFile(cacheDir, game) };
+}
+export function legacyIndexHint(game, legacy, cacheDir = defaultCacheDir()) {
+    return (`The ${game} index is being read from the old cache location (${legacy.gameDir}); ModWright now keeps its cache in ${cacheDir}. ` +
+        `Move that folder to ${path.join(cacheDir, game)} when convenient (or set MODWRIGHT_CACHE_DIR=${legacy.dir}).`);
+}

package/dist/core/knowledge/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/ledger/check.js

@@ -0,0 +1,42 @@
+import * as path from "node:path";
+import { pathExists } from "../fsutil.js";
+import { lookupProbe } from "../testplan/registry.js";
+import { requiresEvidence } from "./status.js";
+export async function checkLedger(projectRoot, claims) {
+    const issues = [];
+    const seenIds = new Set();
+    for (const claim of claims) {
+        if (seenIds.has(claim.id)) {
+            issues.push({ claimId: claim.id, message: `duplicate claim id "${claim.id}".` });
+        }
+        seenIds.add(claim.id);
+        if (!requiresEvidence(claim.status))
+            continue;
+        if (!claim.evidence || claim.evidence.length === 0) {
+            issues.push({ claimId: claim.id, message: `status "${claim.status}" requires an evidence block, but none is recorded.` });
+            continue;
+        }
+        for (const entry of claim.evidence) {
+            const abs = path.isAbsolute(entry.resultPath) ? entry.resultPath : path.join(projectRoot, entry.resultPath);
+            if (!(await pathExists(abs))) {
+                issues.push({ claimId: claim.id, message: `evidence resultPath "${entry.resultPath}" does not exist on disk.` });
+            }
+        }
+        const usesUnverifiedProbe = claim.evidence.some((e) => !e.manual && lookupProbe(e.probeKind)?.status === "unverified");
+        const hasManualCorroboration = claim.evidence.some((e) => e.manual);
+        if (usesUnverifiedProbe && !hasManualCorroboration) {
+            issues.push({
+                claimId: claim.id,
+                message: `evidence names an unverified probe kind but carries no manual-row corroboration: ` +
+                    `an unverified probe can never quietly become the sole proof of a claim.`,
+            });
+        }
+    }
+    const ids = new Set(claims.map((c) => c.id));
+    for (const claim of claims) {
+        if (claim.supersedes && !ids.has(claim.supersedes)) {
+            issues.push({ claimId: claim.id, message: `supersedes unknown claim id "${claim.supersedes}".` });
+        }
+    }
+    return { ok: issues.length === 0, issues };
+}

package/dist/core/ledger/hooks.js

@@ -0,0 +1,80 @@
+import * as path from "node:path";
+import { loadClaims, saveClaims } from "./store.js";
+import { applyClaimTransition } from "./record.js";
+const NONE = { skipped: true, applied: [], refused: [] };
+function toPosix(p) {
+    return p.split(path.sep).join("/");
+}
+function claimFileSet(claim, projectRoot) {
+    const files = claim.scope?.files ?? [];
+    return new Set(files.map((f) => toPosix(path.isAbsolute(f) ? path.relative(projectRoot, f) : f)));
+}
+export async function applyValidateLedgerHook(projectRoot, blockingFindingFiles, ranFiles, tool = "validate", options = {}) {
+    const loaded = await loadClaims(projectRoot);
+    if (!loaded.exists)
+        return NONE;
+    const blocked = new Set(blockingFindingFiles.map(toPosix));
+    const ran = ranFiles ? new Set(ranFiles.map(toPosix)) : undefined;
+    const by = options.by ?? "validate";
+    let claims = loaded.claims;
+    const applied = [];
+    const refused = [];
+    for (const claim of loaded.claims) {
+        if (claim.status !== "authored")
+            continue;
+        const files = claimFileSet(claim, projectRoot);
+        if (files.size === 0)
+            continue;
+        const allRan = !ran || [...files].every((f) => ran.has(f));
+        if (!allRan)
+            continue;
+        const anyBlocked = [...files].some((f) => blocked.has(f));
+        if (anyBlocked)
+            continue;
+        const result = applyClaimTransition({ claims, id: claim.id, to: "checker-clean", tool, by, now: options.now });
+        if (result.ok) {
+            claims = result.claims;
+            applied.push({ claimId: claim.id, from: "authored", to: "checker-clean" });
+        }
+        else {
+            refused.push({ claimId: claim.id, reason: result.refusal ?? "refused" });
+        }
+    }
+    if (applied.length === 0)
+        return { skipped: false, applied, refused };
+    await saveClaims(projectRoot, claims, { mode: options.mode ?? "apply", now: options.now });
+    return { skipped: false, applied, refused };
+}
+export async function applyBuildLedgerHook(projectRoot, manifestPath, tool = "build", options = {}) {
+    const loaded = await loadClaims(projectRoot);
+    if (!loaded.exists)
+        return NONE;
+    const by = options.by ?? "build";
+    let claims = loaded.claims;
+    const applied = [];
+    const refused = [];
+    for (const claim of loaded.claims) {
+        if (claim.status !== "checker-clean")
+            continue;
+        const result = applyClaimTransition({
+            claims,
+            id: claim.id,
+            to: "built",
+            tool,
+            by,
+            now: options.now,
+            note: `manifest: ${toPosix(path.relative(projectRoot, manifestPath))}`,
+        });
+        if (result.ok) {
+            claims = result.claims;
+            applied.push({ claimId: claim.id, from: "checker-clean", to: "built" });
+        }
+        else {
+            refused.push({ claimId: claim.id, reason: result.refusal ?? "refused" });
+        }
+    }
+    if (applied.length === 0)
+        return { skipped: false, applied, refused };
+    await saveClaims(projectRoot, claims, { mode: options.mode ?? "apply", now: options.now });
+    return { skipped: false, applied, refused };
+}

package/dist/core/ledger/index.js

@@ -0,0 +1,7 @@
+export * from "./types.js";
+export { checkTransition, requiresEvidence } from "./status.js";
+export { claimsFilePath, decisionsFilePath, evidenceDir, loadClaims, loadDecisions, saveClaims, saveDecisions } from "./store.js";
+export { applyClaimTransition, applyDecisionRecord } from "./record.js";
+export { checkLedger } from "./check.js";
+export { applyBuildLedgerHook, applyValidateLedgerHook } from "./hooks.js";
+export { listClaims, showClaim } from "./query.js";

package/dist/core/ledger/query.js

@@ -0,0 +1,17 @@
+export function listClaims(claims, filter = {}) {
+    return claims.filter((c) => {
+        if (filter.status && c.status !== filter.status)
+            return false;
+        if (filter.claim && c.id !== filter.claim)
+            return false;
+        if (filter.file) {
+            const files = c.scope?.files ?? [];
+            if (!files.some((f) => f === filter.file || f.endsWith(filter.file)))
+                return false;
+        }
+        return true;
+    });
+}
+export function showClaim(claims, id) {
+    return claims.find((c) => c.id === id);
+}

package/dist/core/ledger/record.js

@@ -0,0 +1,84 @@
+import { checkTransition, requiresEvidence } from "./status.js";
+export function applyClaimTransition(input) {
+    const now = input.now ?? (() => new Date());
+    const idx = input.claims.findIndex((c) => c.id === input.id);
+    const existing = idx === -1 ? undefined : input.claims[idx];
+    if (!existing) {
+        if (input.to !== "authored" || input.tool !== "ledger") {
+            return {
+                ok: false,
+                claims: input.claims,
+                refusal: `claim "${input.id}" does not exist yet; only "ledger record" authoring it with status "authored" can create it.`,
+            };
+        }
+        if (!input.claimText) {
+            return { ok: false, claims: input.claims, refusal: `authoring a new claim "${input.id}" requires "claim" (the claim text).` };
+        }
+        const claim = {
+            id: input.id,
+            claim: input.claimText,
+            scope: input.scope,
+            status: "authored",
+            history: [{ status: "authored", at: now().toISOString(), by: input.by, note: input.note }],
+            evidence: null,
+            supersedes: input.supersedes ?? null,
+        };
+        return { ok: true, claims: [...input.claims, claim], claim };
+    }
+    const check = checkTransition(existing.status, input.to, input.tool);
+    if (!check.ok) {
+        return { ok: false, claims: input.claims, refusal: check.rule ?? `transition "${existing.status}" -> "${input.to}" via "${input.tool}" refused.` };
+    }
+    const evidence = input.evidence && input.evidence.length > 0 ? [...(existing.evidence ?? []), ...input.evidence] : existing.evidence;
+    if (requiresEvidence(input.to) && (!evidence || evidence.length === 0)) {
+        return {
+            ok: false,
+            claims: input.claims,
+            refusal: `"${input.to}" requires an evidence block; none was given and the claim carries none.`,
+        };
+    }
+    const note = [check.note, input.note].filter((s) => Boolean(s)).join("; ") || undefined;
+    const updated = {
+        ...existing,
+        status: input.to,
+        evidence,
+        supersedes: input.supersedes !== undefined ? input.supersedes : existing.supersedes,
+        history: [...existing.history, { status: input.to, at: now().toISOString(), by: input.by, note }],
+    };
+    const claims = [...input.claims];
+    claims[idx] = updated;
+    return { ok: true, claims, claim: updated };
+}
+export function applyDecisionRecord(input) {
+    const idx = input.decisions.findIndex((d) => d.id === input.id);
+    const existing = idx === -1 ? undefined : input.decisions[idx];
+    if (!existing) {
+        if (!input.question || !input.appliedDefault || !input.where || input.madeBlind === undefined) {
+            return {
+                ok: false,
+                decisions: input.decisions,
+                refusal: `authoring a new decision "${input.id}" requires "question", "appliedDefault", "where" and "madeBlind".`,
+            };
+        }
+        const decision = {
+            id: input.id,
+            question: input.question,
+            appliedDefault: input.appliedDefault,
+            where: input.where,
+            madeBlind: input.madeBlind,
+            resolution: input.resolution ?? { status: "open" },
+        };
+        return { ok: true, decisions: [...input.decisions, decision], decision };
+    }
+    const updated = {
+        ...existing,
+        question: input.question ?? existing.question,
+        appliedDefault: input.appliedDefault ?? existing.appliedDefault,
+        where: input.where ?? existing.where,
+        madeBlind: input.madeBlind ?? existing.madeBlind,
+        resolution: input.resolution ?? existing.resolution,
+    };
+    const decisions = [...input.decisions];
+    decisions[idx] = updated;
+    return { ok: true, decisions, decision: updated };
+}

package/dist/core/ledger/status.js

@@ -0,0 +1,53 @@
+const STATUS_RANK = {
+    authored: 0,
+    "checker-clean": 1,
+    built: 2,
+    verified: 3,
+    contradicted: 3,
+};
+const STAGE_NAME = {
+    authored: "authored",
+    "checker-clean": "checker-clean",
+    built: "built",
+    verified: "verified",
+    contradicted: "contradicted",
+};
+const REQUIRED_TOOL = {
+    "checker-clean": "validate",
+    built: "build",
+    verified: "run_tests",
+    contradicted: "run_tests",
+};
+function skippedStagesNote(from, to) {
+    const order = ["authored", "checker-clean", "built"];
+    const fromRank = STATUS_RANK[from];
+    const toRank = STATUS_RANK[to];
+    if (toRank - fromRank <= 1)
+        return undefined;
+    const skipped = order.filter((s) => STATUS_RANK[s] > fromRank && STATUS_RANK[s] < toRank);
+    return skipped.length > 0 ? `skipped ${skipped.map((s) => STAGE_NAME[s]).join(", ")}` : undefined;
+}
+export function checkTransition(from, to, tool) {
+    if (from === to)
+        return { ok: true };
+    if (tool === "ledger") {
+        return { ok: true, note: skippedStagesNote(from, to) };
+    }
+    const requiredTool = REQUIRED_TOOL[to];
+    if (!requiredTool) {
+        return { ok: false, rule: `"${to}" is written only by "ledger record", not "${tool}".` };
+    }
+    if (tool !== requiredTool) {
+        return { ok: false, rule: `"${to}" is written by "${requiredTool}" (the ledger's transition table), not "${tool}".` };
+    }
+    if (STATUS_RANK[to] < STATUS_RANK[from]) {
+        return {
+            ok: false,
+            rule: `"${from}" → "${to}" is a backward move; "${tool}" only moves a claim forward. Use "ledger record" for a manual correction, with a reason.`,
+        };
+    }
+    return { ok: true, note: skippedStagesNote(from, to) };
+}
+export function requiresEvidence(status) {
+    return status === "verified" || status === "contradicted";
+}

package/dist/core/ledger/store.js

@@ -0,0 +1,98 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { parse as parseYaml } from "yaml";
+import { pathExists } from "../fsutil.js";
+import { executePlan, planFile } from "../safety/index.js";
+import { stringifyPreserving } from "../yamledit.js";
+import { parseClaimsFile, parseDecisionsFile } from "./types.js";
+export function claimsFilePath(projectRoot) {
+    return path.join(projectRoot, "ledger", "claims.yaml");
+}
+export function decisionsFilePath(projectRoot) {
+    return path.join(projectRoot, "ledger", "decisions.yaml");
+}
+export async function loadClaims(projectRoot) {
+    const file = claimsFilePath(projectRoot);
+    if (!(await pathExists(file))) {
+        return { path: file, exists: false, claims: [], problems: [] };
+    }
+    let text;
+    try {
+        text = await fs.readFile(file, "utf8");
+    }
+    catch (err) {
+        return { path: file, exists: true, claims: [], problems: [`${file}: cannot read file: ${err.message}`] };
+    }
+    let raw;
+    try {
+        raw = parseYaml(text);
+    }
+    catch (err) {
+        return { path: file, exists: true, claims: [], problems: [`${file}: YAML parse error: ${err.message}`] };
+    }
+    try {
+        const parsed = parseClaimsFile(raw);
+        return { path: file, exists: true, claims: parsed.claims, problems: [] };
+    }
+    catch (err) {
+        return { path: file, exists: true, claims: [], problems: [err.message] };
+    }
+}
+export async function loadDecisions(projectRoot) {
+    const file = decisionsFilePath(projectRoot);
+    if (!(await pathExists(file))) {
+        return { path: file, exists: false, decisions: [], problems: [] };
+    }
+    let text;
+    try {
+        text = await fs.readFile(file, "utf8");
+    }
+    catch (err) {
+        return { path: file, exists: true, decisions: [], problems: [`${file}: cannot read file: ${err.message}`] };
+    }
+    let raw;
+    try {
+        raw = parseYaml(text);
+    }
+    catch (err) {
+        return { path: file, exists: true, decisions: [], problems: [`${file}: YAML parse error: ${err.message}`] };
+    }
+    try {
+        const parsed = parseDecisionsFile(raw);
+        return { path: file, exists: true, decisions: parsed.decisions, problems: [] };
+    }
+    catch (err) {
+        return { path: file, exists: true, decisions: [], problems: [err.message] };
+    }
+}
+export async function saveClaims(projectRoot, claims, options = {}) {
+    const file = claimsFilePath(projectRoot);
+    const content = stringifyPreserving(await fs.readFile(file, "utf8").catch(() => undefined), { claims }, { lineWidth: 0 });
+    const plan = {
+        purpose: `write ${claims.length} claim(s) to ledger/claims.yaml`,
+        operations: [planFile(file, content)],
+        backupRoot: path.join(projectRoot, ".modwright", "backups"),
+    };
+    return executePlan(plan, {
+        mode: options.mode ?? "dry-run",
+        now: options.now,
+        confidence: options.confidence ?? { level: "high", assumptions: [], verifiedBy: [] },
+    });
+}
+export async function saveDecisions(projectRoot, decisions, options = {}) {
+    const file = decisionsFilePath(projectRoot);
+    const content = stringifyPreserving(await fs.readFile(file, "utf8").catch(() => undefined), { decisions }, { lineWidth: 0 });
+    const plan = {
+        purpose: `write ${decisions.length} decision(s) to ledger/decisions.yaml`,
+        operations: [planFile(file, content)],
+        backupRoot: path.join(projectRoot, ".modwright", "backups"),
+    };
+    return executePlan(plan, {
+        mode: options.mode ?? "dry-run",
+        now: options.now,
+        confidence: options.confidence ?? { level: "high", assumptions: [], verifiedBy: [] },
+    });
+}
+export function evidenceDir(projectRoot, runId) {
+    return path.join(projectRoot, ".modwright", "evidence", runId);
+}

package/dist/core/ledger/types.js

@@ -0,0 +1,108 @@
+import { z } from "zod";
+const iso8601Schema = z.string().refine((s) => !Number.isNaN(Date.parse(s)), {
+    message: "must be a parseable ISO 8601 timestamp",
+});
+export const claimStatusSchema = z.enum(["authored", "checker-clean", "built", "verified", "contradicted"]);
+export const claimHistoryEntrySchema = z
+    .object({
+    status: claimStatusSchema,
+    at: iso8601Schema,
+    by: z.string().min(1),
+    note: z.string().optional(),
+})
+    .strict();
+export const claimEvidenceSchema = z
+    .object({
+    runId: z.string().min(1),
+    planId: z.string().min(1),
+    rowId: z.string().min(1),
+    probeId: z.string().min(1),
+    probeKind: z.string().min(1),
+    resultPath: z.string().min(1),
+    resultSha256: z.string().regex(/^[0-9a-f]{64}$/, "must be a 64-character hex sha256"),
+    observedAt: iso8601Schema,
+    observed: z.unknown(),
+    manual: z.boolean().optional(),
+    verifiedWithSetup: z.array(z.string().min(1)).optional(),
+})
+    .strict();
+export const claimScopeSchema = z
+    .object({
+    files: z.array(z.string().min(1)).optional(),
+    entries: z.array(z.string().min(1)).optional(),
+})
+    .strict();
+export const claimSchema = z
+    .object({
+    id: z.string().min(1),
+    claim: z.string().min(1),
+    scope: claimScopeSchema.optional(),
+    status: claimStatusSchema,
+    history: z.array(claimHistoryEntrySchema).min(1),
+    evidence: z.array(claimEvidenceSchema).nullable().default(null),
+    supersedes: z.string().min(1).nullable().default(null),
+})
+    .strict();
+export const claimsFileSchema = z.object({ claims: z.array(claimSchema) }).strict();
+export const decisionResolutionSchema = z
+    .object({
+    status: z.enum(["open", "resolved"]),
+    at: iso8601Schema.optional(),
+    outcome: z.string().optional(),
+    source: z.string().optional(),
+})
+    .strict();
+export const decisionSchema = z
+    .object({
+    id: z.string().min(1),
+    question: z.string().min(1),
+    appliedDefault: z.string().min(1),
+    where: z.string().min(1),
+    madeBlind: z.boolean(),
+    resolution: decisionResolutionSchema,
+})
+    .strict();
+export const decisionsFileSchema = z.object({ decisions: z.array(decisionSchema) }).strict();
+function formatPath(segments) {
+    if (segments.length === 0)
+        return "(root)";
+    let out = "";
+    for (const segment of segments) {
+        out += typeof segment === "number" ? `[${segment}]` : out ? `.${segment}` : segment;
+    }
+    return out;
+}
+export function parseClaimsFile(raw) {
+    const result = claimsFileSchema.safeParse(raw);
+    if (result.success)
+        return result.data;
+    const rawClaims = Array.isArray(raw?.claims) ? (raw.claims) : [];
+    const lines = result.error.issues.map((issue) => {
+        const [first, second, ...rest] = issue.path;
+        if (first === "claims" && typeof second === "number") {
+            const rawClaim = rawClaims[second];
+            const claimId = typeof rawClaim?.id === "string" ? rawClaim.id : `#${second}`;
+            const field = rest.length > 0 ? ` ${formatPath(rest)}` : "";
+            return `claims[${second}] (id=${claimId})${field}: ${issue.message}`;
+        }
+        return `${formatPath(issue.path)}: ${issue.message}`;
+    });
+    throw new Error(`Invalid ledger/claims.yaml:\n${lines.join("\n")}`);
+}
+export function parseDecisionsFile(raw) {
+    const result = decisionsFileSchema.safeParse(raw);
+    if (result.success)
+        return result.data;
+    const rawDecisions = Array.isArray(raw?.decisions) ? (raw.decisions) : [];
+    const lines = result.error.issues.map((issue) => {
+        const [first, second, ...rest] = issue.path;
+        if (first === "decisions" && typeof second === "number") {
+            const rawDecision = rawDecisions[second];
+            const decisionId = typeof rawDecision?.id === "string" ? rawDecision.id : `#${second}`;
+            const field = rest.length > 0 ? ` ${formatPath(rest)}` : "";
+            return `decisions[${second}] (id=${decisionId})${field}: ${issue.message}`;
+        }
+        return `${formatPath(issue.path)}: ${issue.message}`;
+    });
+    throw new Error(`Invalid ledger/decisions.yaml:\n${lines.join("\n")}`);
+}

package/dist/core/logs/index.js

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export * from "./registry.js";
+export * from "./scan.js";
+export * from "./triage.js";

package/dist/core/logs/registry.js

@@ -0,0 +1,50 @@
+export class SignatureRegistry {
+    byGame = new Map();
+    ids = new Set();
+    register(signatures) {
+        const seenInBatch = new Set();
+        for (const sig of signatures) {
+            if (!sig.id.startsWith(`${sig.game}.`)) {
+                throw new Error(`Signature "${sig.id}" must be prefixed with its game id ("${sig.game}.")`);
+            }
+            if (this.ids.has(sig.id) || seenInBatch.has(sig.id)) {
+                throw new Error(`Duplicate signature id "${sig.id}"`);
+            }
+            if (sig.pattern.flags.includes("g")) {
+                throw new Error(`Signature "${sig.id}" pattern must not use the "g" flag (it carries lastIndex state across scans)`);
+            }
+            if (sig.extract?.length) {
+                const groups = namedGroupsOf(sig.pattern);
+                for (const name of sig.extract) {
+                    if (!groups.has(name)) {
+                        throw new Error(`Signature "${sig.id}" extracts "${name}" but its pattern has no named group "(?<${name}>...)"`);
+                    }
+                }
+            }
+            seenInBatch.add(sig.id);
+        }
+        for (const sig of signatures) {
+            this.ids.add(sig.id);
+            const list = this.byGame.get(sig.game);
+            if (list)
+                list.push(sig);
+            else
+                this.byGame.set(sig.game, [sig]);
+        }
+    }
+    forGame(game) {
+        return this.byGame.get(game) ?? [];
+    }
+    forSource(game, sourceId) {
+        return this.forGame(game).filter((sig) => sig.sources.length === 0 || sig.sources.includes(sourceId));
+    }
+}
+function namedGroupsOf(pattern) {
+    const names = new Set();
+    const groupRe = /\(\?<([a-zA-Z_$][a-zA-Z0-9_$]*)>/g;
+    let match;
+    while ((match = groupRe.exec(pattern.source))) {
+        names.add(match[1]);
+    }
+    return names;
+}