@dotit/core 1.0.0

package/dist/themes/minimal.json

@@ -0,0 +1,50 @@
+{
+    "name": "minimal",
+    "version": "1.0.0",
+    "description": "Maximum whitespace, no decorative elements. High contrast.",
+    "author": "IntentText",
+    "fonts": {
+        "body": "system-ui",
+        "heading": "system-ui",
+        "mono": "ui-monospace",
+        "size": "11pt",
+        "leading": "1.7"
+    },
+    "colors": {
+        "text": "#111111",
+        "heading": "#000000",
+        "muted": "#555555",
+        "accent": "#111111",
+        "border": "#dddddd",
+        "background": "#ffffff",
+        "code-bg": "#f5f5f5",
+        "trust-approved": "#16a34a",
+        "trust-signed": "#2563eb",
+        "trust-frozen": "#7c3aed",
+        "trust-warning": "#dc2626",
+        "watermark": "#00000008"
+    },
+    "spacing": {
+        "page-margin": "20mm",
+        "section-gap": "2.5em",
+        "block-gap": "0.8em",
+        "indent": "1em"
+    },
+    "blocks": {
+        "section": {
+            "font-weight": "700",
+            "margin-top": "2.5em"
+        },
+        "quote": {
+            "padding-left": "1em",
+            "font-style": "italic",
+            "color": "muted"
+        }
+    },
+    "print": {
+        "header-font-size": "8pt",
+        "footer-font-size": "8pt",
+        "header-color": "muted",
+        "footer-color": "muted"
+    }
+}

package/dist/themes/print.json

@@ -0,0 +1,54 @@
+{
+    "name": "print",
+    "version": "1.0.0",
+    "description": "Optimized for black-and-white laser printing. No color, no backgrounds.",
+    "author": "IntentText",
+    "fonts": {
+        "body": "Georgia",
+        "heading": "Helvetica",
+        "mono": "Courier",
+        "size": "11pt",
+        "leading": "1.5"
+    },
+    "colors": {
+        "text": "#000000",
+        "heading": "#000000",
+        "muted": "#333333",
+        "accent": "#000000",
+        "border": "#000000",
+        "background": "#ffffff",
+        "code-bg": "#ffffff",
+        "trust-approved": "#000000",
+        "trust-signed": "#000000",
+        "trust-frozen": "#000000",
+        "trust-warning": "#000000",
+        "watermark": "#00000008"
+    },
+    "spacing": {
+        "page-margin": "25mm",
+        "section-gap": "2em",
+        "block-gap": "0.75em",
+        "indent": "1.5em"
+    },
+    "blocks": {
+        "section": {
+            "font-weight": "bold",
+            "margin-top": "2em",
+            "border-bottom": true
+        },
+        "quote": {
+            "padding-left": "1em",
+            "font-style": "italic"
+        },
+        "warning": {
+            "border-left": "3px solid #000",
+            "padding-left": "1em"
+        }
+    },
+    "print": {
+        "header-font-size": "8pt",
+        "footer-font-size": "8pt",
+        "header-color": "#333333",
+        "footer-color": "#333333"
+    }
+}

package/dist/themes/technical.json

@@ -0,0 +1,59 @@
+{
+    "name": "technical",
+    "version": "1.0.0",
+    "description": "Monospace-forward, high contrast — developer docs, agent specs, runbooks",
+    "author": "IntentText",
+    "fonts": {
+        "body": "JetBrains Mono",
+        "heading": "JetBrains Mono",
+        "mono": "JetBrains Mono",
+        "size": "10pt",
+        "leading": "1.5"
+    },
+    "colors": {
+        "text": "#1e1e1e",
+        "heading": "#0a0a0a",
+        "muted": "#6b7280",
+        "accent": "#0969da",
+        "border": "#30363d",
+        "background": "#ffffff",
+        "code-bg": "#f0f2f4",
+        "trust-approved": "#16a34a",
+        "trust-signed": "#0969da",
+        "trust-frozen": "#7c3aed",
+        "trust-warning": "#dc2626",
+        "watermark": "#00000008"
+    },
+    "spacing": {
+        "page-margin": "20mm",
+        "section-gap": "1.8em",
+        "block-gap": "0.6em",
+        "indent": "2em"
+    },
+    "blocks": {
+        "section": {
+            "font-weight": "700",
+            "margin-top": "1.8em",
+            "border-bottom": true
+        },
+        "code": {
+            "background": "code-bg",
+            "padding": "0.3em 0.5em",
+            "border-radius": "2px",
+            "border": "1px solid",
+            "border-color": "border"
+        },
+        "warning": {
+            "border-left": "4px solid",
+            "border-color": "trust-warning",
+            "padding-left": "1em",
+            "background": "#fef2f2"
+        }
+    },
+    "print": {
+        "header-font-size": "7pt",
+        "footer-font-size": "7pt",
+        "header-color": "muted",
+        "footer-color": "muted"
+    }
+}

package/dist/themes/warm.json

@@ -0,0 +1,53 @@
+{
+    "name": "warm",
+    "version": "1.0.0",
+    "description": "Serif body font, warm tones — editorial, journalism, long-form writing",
+    "author": "IntentText",
+    "fonts": {
+        "body": "Georgia",
+        "heading": "Georgia",
+        "mono": "Menlo",
+        "size": "11.5pt",
+        "leading": "1.7"
+    },
+    "colors": {
+        "text": "#2c2416",
+        "heading": "#1a1208",
+        "muted": "#7a6e5e",
+        "accent": "#b45309",
+        "border": "#d6cfc2",
+        "background": "#fafaf8",
+        "code-bg": "#f3f0ea",
+        "trust-approved": "#3d7a3d",
+        "trust-signed": "#4a6fa5",
+        "trust-frozen": "#6b4c8a",
+        "trust-warning": "#b91c1c",
+        "watermark": "#00000008"
+    },
+    "spacing": {
+        "page-margin": "30mm",
+        "section-gap": "2em",
+        "block-gap": "0.75em",
+        "indent": "1.5em"
+    },
+    "blocks": {
+        "section": {
+            "border-bottom": true,
+            "font-weight": "600",
+            "margin-top": "2em"
+        },
+        "quote": {
+            "border-left": "3px solid",
+            "border-color": "accent",
+            "padding-left": "1.2em",
+            "font-style": "italic",
+            "color": "muted"
+        }
+    },
+    "print": {
+        "header-font-size": "8pt",
+        "footer-font-size": "8pt",
+        "header-color": "muted",
+        "footer-color": "muted"
+    }
+}

package/dist/trust.d.ts

@@ -0,0 +1,66 @@
+import { RegistryEntry } from "./types";
+export declare function computeDocumentHash(source: string): string;
+export declare function findHistoryBoundaryInSource(source: string): number;
+export declare function detectHistoryBoundary(lines: string[]): number;
+export declare function generateBlockId(): string;
+export declare function blockFingerprint(content: string): string;
+export declare function matchBlocksToRegistry(blocks: Array<{
+    type: string;
+    content: string;
+    section: string;
+}>, registry: RegistryEntry[]): Map<number, string>;
+export interface BlockSnapshot {
+    id: string;
+    type: string;
+    content: string;
+    section: string;
+    properties: Record<string, string>;
+}
+export interface TrustDiff {
+    added: BlockSnapshot[];
+    removed: BlockSnapshot[];
+    modified: Array<{
+        id: string;
+        was: BlockSnapshot;
+        now: BlockSnapshot;
+    }>;
+    moved: Array<{
+        id: string;
+        wasSection: string;
+        nowSection: string;
+        block: BlockSnapshot;
+    }>;
+    unchanged: BlockSnapshot[];
+}
+export declare function computeTrustDiff(before: BlockSnapshot[], after: BlockSnapshot[]): TrustDiff;
+export declare function incrementVersion(current: string, changeType: "major" | "minor"): string;
+export interface SealOptions {
+    signer: string;
+    role?: string;
+    skipSign?: boolean;
+}
+export interface SealResult {
+    success: boolean;
+    hash: string;
+    source: string;
+    at: string;
+    error?: string;
+}
+export declare function sealDocument(source: string, options: SealOptions): SealResult;
+export interface VerifyResult {
+    intact: boolean;
+    frozen: boolean;
+    frozenAt?: string;
+    signers?: Array<{
+        signer: string;
+        role?: string;
+        at: string;
+        valid: boolean;
+        signedCurrentVersion: boolean;
+    }>;
+    hash?: string;
+    expectedHash?: string;
+    error?: string;
+    warning?: string;
+}
+export declare function verifyDocument(source: string): VerifyResult;

package/dist/trust.js

@@ -0,0 +1,200 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeDocumentHash = computeDocumentHash;
+exports.findHistoryBoundaryInSource = findHistoryBoundaryInSource;
+exports.detectHistoryBoundary = detectHistoryBoundary;
+exports.generateBlockId = generateBlockId;
+exports.blockFingerprint = blockFingerprint;
+exports.matchBlocksToRegistry = matchBlocksToRegistry;
+exports.computeTrustDiff = computeTrustDiff;
+exports.incrementVersion = incrementVersion;
+exports.sealDocument = sealDocument;
+exports.verifyDocument = verifyDocument;
+const crypto_1 = __importDefault(require("crypto"));
+const parser_1 = require("./parser");
+function computeDocumentHash(source) {
+    const boundary = findHistoryBoundaryInSource(source);
+    const content = boundary === -1 ? source : source.slice(0, boundary);
+    const bodyLines = content
+        .split("\n")
+        .filter((line) => !line.startsWith("sign:") &&
+        !line.startsWith("freeze:") &&
+        !line.startsWith("amendment:"));
+    const body = bodyLines.join("\n").trim();
+    return "sha256:" + crypto_1.default.createHash("sha256").update(body).digest("hex");
+}
+function findHistoryBoundaryInSource(source) {
+    const lines = source.split("\n");
+    let pos = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (trimmed === "history:" || trimmed === "history: ") {
+            return pos;
+        }
+        if (trimmed === "---" && i < lines.length - 1) {
+            const next = lines[i + 1]?.trim();
+            if (next === "// history" || next?.startsWith("// history")) {
+                return pos;
+            }
+        }
+        pos += lines[i].length + 1;
+    }
+    return -1;
+}
+function detectHistoryBoundary(lines) {
+    for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (trimmed === "history:" || trimmed === "history: ") {
+            return i;
+        }
+        if (trimmed === "---" && i < lines.length - 1) {
+            const next = lines[i + 1]?.trim();
+            if (next === "// history" || next?.startsWith("// history")) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+function generateBlockId() {
+    return crypto_1.default.randomBytes(3).toString("hex").slice(0, 5);
+}
+function blockFingerprint(content) {
+    return content.toLowerCase().trim().replace(/\s+/g, " ");
+}
+function matchBlocksToRegistry(blocks, registry) {
+    const result = new Map();
+    const usedIds = new Set();
+    for (let i = 0; i < blocks.length; i++) {
+        const block = blocks[i];
+        const fp = blockFingerprint(block.content);
+        const exact = registry.find((r) => !r.dead &&
+            !usedIds.has(r.id) &&
+            r.blockType === block.type &&
+            r.section === block.section &&
+            r.fingerprint === fp);
+        if (exact) {
+            result.set(i, exact.id);
+            usedIds.add(exact.id);
+            continue;
+        }
+        const fuzzy = registry.find((r) => !r.dead &&
+            !usedIds.has(r.id) &&
+            r.blockType === block.type &&
+            r.section === block.section &&
+            similarity(r.fingerprint, fp) > 0.6);
+        if (fuzzy) {
+            result.set(i, fuzzy.id);
+            usedIds.add(fuzzy.id);
+        }
+    }
+    return result;
+}
+function similarity(a, b) {
+    if (a === b)
+        return 1;
+    const longer = a.length > b.length ? a : b;
+    const shorter = a.length > b.length ? b : a;
+    if (longer.length === 0)
+        return 1;
+    let matches = 0;
+    for (const char of shorter) {
+        if (longer.includes(char))
+            matches++;
+    }
+    return matches / longer.length;
+}
+function computeTrustDiff(before, after) {
+    const result = {
+        added: [],
+        removed: [],
+        modified: [],
+        moved: [],
+        unchanged: [],
+    };
+    const beforeById = new Map(before.map((b) => [b.id, b]));
+    const afterById = new Map(after.map((b) => [b.id, b]));
+    for (const [id, beforeBlock] of beforeById) {
+        const afterBlock = afterById.get(id);
+        if (!afterBlock) {
+            result.removed.push(beforeBlock);
+        }
+        else if (beforeBlock.content !== afterBlock.content) {
+            result.modified.push({ id, was: beforeBlock, now: afterBlock });
+        }
+        else if (beforeBlock.section !== afterBlock.section) {
+            result.moved.push({
+                id,
+                wasSection: beforeBlock.section,
+                nowSection: afterBlock.section,
+                block: afterBlock,
+            });
+        }
+        else {
+            result.unchanged.push(afterBlock);
+        }
+    }
+    for (const [id, afterBlock] of afterById) {
+        if (!beforeById.has(id)) {
+            result.added.push(afterBlock);
+        }
+    }
+    return result;
+}
+function incrementVersion(current, changeType) {
+    const parts = current.split(".").map(Number);
+    if (changeType === "major") {
+        return `${parts[0] + 1}.0`;
+    }
+    else {
+        return `${parts[0]}.${(parts[1] || 0) + 1}`;
+    }
+}
+function sealDocument(source, options) {
+    const hash = computeDocumentHash(source);
+    const at = new Date().toISOString();
+    const boundaryPos = findHistoryBoundaryInSource(source);
+    const insertBefore = boundaryPos === -1 ? source.length : boundaryPos;
+    const signLine = options.skipSign
+        ? ""
+        : `sign: ${options.signer}${options.role ? ` | role: ${options.role}` : ""} | at: ${at} | hash: ${hash}\n`;
+    const freezeLine = `freeze: | at: ${at} | hash: ${hash} | status: locked\n`;
+    const insertion = signLine + freezeLine;
+    const before = source.slice(0, insertBefore);
+    const after = source.slice(insertBefore);
+    const needsNewline = before.length > 0 && !before.endsWith("\n");
+    const updated = before + (needsNewline ? "\n" : "") + insertion + after;
+    return { success: true, hash, source: updated, at };
+}
+function verifyDocument(source) {
+    const doc = (0, parser_1.parseIntentText)(source, { includeHistorySection: false });
+    if (!doc.metadata?.freeze) {
+        return {
+            intact: false,
+            frozen: false,
+            warning: "Document is not sealed. No freeze: block found.",
+        };
+    }
+    const currentHash = computeDocumentHash(source);
+    const expectedHash = doc.metadata.freeze.hash;
+    const intact = currentHash === expectedHash;
+    const signers = doc.metadata.signatures?.map((sig) => ({
+        signer: sig.signer,
+        role: sig.role,
+        at: sig.at,
+        valid: sig.hash === expectedHash,
+        signedCurrentVersion: sig.hash === currentHash,
+    })) || [];
+    return {
+        intact,
+        frozen: true,
+        frozenAt: doc.metadata.freeze.at,
+        signers,
+        hash: currentHash,
+        expectedHash,
+        error: intact ? undefined : "Document has been modified since sealing.",
+    };
+}