@cogcoin/client 0.5.15 → 1.0.1

package/dist/wallet/mining/hook-protocol.d.ts

@@ -1,47 +0,0 @@
-import { MINING_HOOK_SCHEMA_VERSION } from "./constants.js";
-export interface GenerateSentencesHookRequestV1 {
-    schemaVersion: typeof MINING_HOOK_SCHEMA_VERSION;
-    requestId: string;
-    targetBlockHeight: number;
-    referencedBlockHashDisplay: string;
-    generatedAtUnixMs: number;
-    extraPrompt: string | null;
-    limits: {
-        maxCandidatesPerRootDomain: number;
-        maxCandidatesTotal: number;
-        timeoutMs: number;
-        maxCandidateSentenceUtf8Bytes: number;
-    };
-    rootDomains: Array<{
-        domainId: number;
-        domainName: string;
-        requiredWords: [string, string, string, string, string];
-    }>;
-}
-export interface GenerateSentencesHookCandidateV1 {
-    domainId: number;
-    sentence: string;
-    attribution?: {
-        hook?: string;
-        provider?: string;
-        model?: string;
-        promptLabel?: string;
-    };
-}
-export interface GenerateSentencesHookResponseV1 {
-    schemaVersion: typeof MINING_HOOK_SCHEMA_VERSION;
-    requestId: string;
-    candidates: GenerateSentencesHookCandidateV1[];
-}
-export type MiningHookOperatorValidationState = "never" | "current" | "stale" | "failed";
-export declare const MINING_HOOK_VALIDATION_FIXTURES: GenerateSentencesHookRequestV1[];
-export declare function createGenerateSentencesHookLimits(): GenerateSentencesHookRequestV1["limits"];
-export declare function parseStrictJsonValue(raw: string, invalidMessage: string): unknown;
-export declare function stripMarkdownCodeFence(raw: string): string;
-export declare function normalizeHookResponse(options: {
-    request: GenerateSentencesHookRequestV1;
-    response: unknown;
-}): {
-    response: GenerateSentencesHookResponseV1;
-    candidates: GenerateSentencesHookCandidateV1[];
-};

package/dist/wallet/mining/hook-protocol.js

@@ -1,161 +0,0 @@
-import { MINING_HOOK_MAX_CANDIDATES_PER_ROOT_DOMAIN, MINING_HOOK_MAX_CANDIDATES_TOTAL, MINING_HOOK_MAX_CANDIDATE_SENTENCE_UTF8_BYTES, MINING_HOOK_SCHEMA_VERSION, MINING_HOOK_TIMEOUT_MS, } from "./constants.js";
-export const MINING_HOOK_VALIDATION_FIXTURES = [
-    {
-        schemaVersion: MINING_HOOK_SCHEMA_VERSION,
-        requestId: "validation-empty-mining-v1",
-        targetBlockHeight: 840_000,
-        referencedBlockHashDisplay: "0000000000000000000000000000000000000000000000000000000000000042",
-        generatedAtUnixMs: 0,
-        extraPrompt: "",
-        limits: {
-            maxCandidateSentenceUtf8Bytes: MINING_HOOK_MAX_CANDIDATE_SENTENCE_UTF8_BYTES,
-            maxCandidatesPerRootDomain: MINING_HOOK_MAX_CANDIDATES_PER_ROOT_DOMAIN,
-            maxCandidatesTotal: MINING_HOOK_MAX_CANDIDATES_TOTAL,
-            timeoutMs: MINING_HOOK_TIMEOUT_MS,
-        },
-        rootDomains: [],
-    },
-    {
-        schemaVersion: MINING_HOOK_SCHEMA_VERSION,
-        requestId: "validation-fixture-mining-v1",
-        targetBlockHeight: 840_000,
-        referencedBlockHashDisplay: "0000000000000000000000000000000000000000000000000000000000000042",
-        generatedAtUnixMs: 0,
-        extraPrompt: "",
-        limits: {
-            maxCandidateSentenceUtf8Bytes: MINING_HOOK_MAX_CANDIDATE_SENTENCE_UTF8_BYTES,
-            maxCandidatesPerRootDomain: MINING_HOOK_MAX_CANDIDATES_PER_ROOT_DOMAIN,
-            maxCandidatesTotal: MINING_HOOK_MAX_CANDIDATES_TOTAL,
-            timeoutMs: MINING_HOOK_TIMEOUT_MS,
-        },
-        rootDomains: [
-            {
-                domainId: 424_242,
-                domainName: "fixture",
-                requiredWords: ["abandon", "ability", "able", "about", "above"],
-            },
-        ],
-    },
-];
-export function createGenerateSentencesHookLimits() {
-    return {
-        maxCandidateSentenceUtf8Bytes: MINING_HOOK_MAX_CANDIDATE_SENTENCE_UTF8_BYTES,
-        maxCandidatesPerRootDomain: MINING_HOOK_MAX_CANDIDATES_PER_ROOT_DOMAIN,
-        maxCandidatesTotal: MINING_HOOK_MAX_CANDIDATES_TOTAL,
-        timeoutMs: MINING_HOOK_TIMEOUT_MS,
-    };
-}
-function normalizeAttribution(raw) {
-    if (raw === null || typeof raw !== "object") {
-        return undefined;
-    }
-    const attribution = raw;
-    const normalized = {};
-    for (const key of ["hook", "provider", "model", "promptLabel"]) {
-        const value = attribution[key];
-        if (typeof value === "string" && value.length > 0) {
-            normalized[key] = value;
-        }
-    }
-    return Object.keys(normalized).length === 0
-        ? undefined
-        : normalized;
-}
-export function parseStrictJsonValue(raw, invalidMessage) {
-    const trimmed = raw.trim();
-    if (trimmed.length === 0) {
-        throw new Error(invalidMessage);
-    }
-    try {
-        return JSON.parse(trimmed);
-    }
-    catch {
-        throw new Error(invalidMessage);
-    }
-}
-export function stripMarkdownCodeFence(raw) {
-    const trimmed = raw.trim();
-    if (!trimmed.startsWith("```")) {
-        return raw;
-    }
-    const lines = trimmed.split(/\r?\n/);
-    if (lines.length < 3) {
-        return raw;
-    }
-    const first = lines[0].trim();
-    const last = lines.at(-1)?.trim();
-    if (!first.startsWith("```") || last !== "```") {
-        return raw;
-    }
-    return lines.slice(1, -1).join("\n");
-}
-export function normalizeHookResponse(options) {
-    const raw = options.response;
-    if (raw === null || typeof raw !== "object") {
-        throw new Error("Custom mining hook returned an invalid JSON response.");
-    }
-    const response = raw;
-    if (response.schemaVersion !== MINING_HOOK_SCHEMA_VERSION) {
-        throw new Error("Custom mining hook returned an unsupported schema version.");
-    }
-    if (response.requestId !== options.request.requestId) {
-        throw new Error("Custom mining hook returned a mismatched requestId.");
-    }
-    if (!Array.isArray(response.candidates)) {
-        throw new Error("Custom mining hook response must include a candidates array.");
-    }
-    if (response.candidates.length > options.request.limits.maxCandidatesTotal) {
-        throw new Error("Custom mining hook returned too many total candidates.");
-    }
-    const allowedDomainIds = new Set(options.request.rootDomains.map((domain) => domain.domainId));
-    const perDomainCounts = new Map();
-    const dedupe = new Set();
-    const candidates = [];
-    for (const rawCandidate of response.candidates) {
-        if (rawCandidate === null || typeof rawCandidate !== "object") {
-            throw new Error("Custom mining hook returned an invalid candidate entry.");
-        }
-        const candidate = rawCandidate;
-        const domainId = candidate.domainId;
-        const sentence = candidate.sentence;
-        if (!Number.isInteger(domainId)) {
-            throw new Error("Custom mining hook candidate is missing a valid domainId.");
-        }
-        if (!allowedDomainIds.has(domainId)) {
-            throw new Error("Custom mining hook candidate referenced an unknown domainId.");
-        }
-        if (typeof sentence !== "string") {
-            throw new Error("Custom mining hook candidate is missing a valid sentence.");
-        }
-        const trimmedSentence = sentence.trim();
-        if (trimmedSentence.length === 0) {
-            throw new Error("Custom mining hook candidate sentence was empty after trimming.");
-        }
-        if (Buffer.byteLength(trimmedSentence, "utf8") > options.request.limits.maxCandidateSentenceUtf8Bytes) {
-            throw new Error("Custom mining hook candidate sentence exceeded the UTF-8 byte limit.");
-        }
-        const nextCount = (perDomainCounts.get(domainId) ?? 0) + 1;
-        perDomainCounts.set(domainId, nextCount);
-        if (nextCount > options.request.limits.maxCandidatesPerRootDomain) {
-            throw new Error("Custom mining hook returned too many candidates for one domain.");
-        }
-        const dedupeKey = `${domainId}:${trimmedSentence}`;
-        if (dedupe.has(dedupeKey)) {
-            continue;
-        }
-        dedupe.add(dedupeKey);
-        candidates.push({
-            domainId: domainId,
-            sentence: trimmedSentence,
-            attribution: normalizeAttribution(candidate.attribution),
-        });
-    }
-    return {
-        response: {
-            schemaVersion: MINING_HOOK_SCHEMA_VERSION,
-            requestId: options.request.requestId,
-            candidates,
-        },
-        candidates,
-    };
-}

package/dist/wallet/mining/hook-runner.js

@@ -1,52 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { pathToFileURL } from "node:url";
-async function readStdin() {
-    const chunks = [];
-    for await (const chunk of process.stdin) {
-        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-    }
-    return Buffer.concat(chunks).toString("utf8");
-}
-async function run() {
-    const entrypointPath = process.argv[2];
-    if (typeof entrypointPath !== "string" || entrypointPath.length === 0) {
-        throw new Error("Missing custom mining hook entrypoint path.");
-    }
-    const moduleUrl = pathToFileURL(entrypointPath).href;
-    const requestText = await readStdin();
-    let request;
-    try {
-        request = JSON.parse(requestText);
-    }
-    catch {
-        throw new Error("Custom mining hook runner received invalid JSON on stdin.");
-    }
-    const loaded = await import(moduleUrl);
-    const generateSentences = loaded.generateSentences;
-    if (typeof generateSentences !== "function") {
-        throw new Error("Custom mining hooks must export generateSentences(request).");
-    }
-    const response = await generateSentences(request);
-    process.stdout.write(`${JSON.stringify(response)}\n`, "utf8");
-}
-if (process.argv[1] !== undefined) {
-    const mainUrl = pathToFileURL(process.argv[1]).href;
-    if (import.meta.url === mainUrl) {
-        await run().catch(async (error) => {
-            if (error instanceof Error && error.message.includes("Cannot find module")) {
-                try {
-                    const entrypointPath = process.argv[2];
-                    if (typeof entrypointPath === "string") {
-                        await readFile(entrypointPath, "utf8");
-                    }
-                }
-                catch {
-                    // Ignore; the original import error is still the best diagnostic.
-                }
-            }
-            const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
-            process.stderr.write(`${message.trim()}\n`, "utf8");
-            process.exitCode = 1;
-        });
-    }
-}

package/dist/wallet/mining/hooks.d.ts

@@ -1,38 +0,0 @@
-import type { HookClientStateRecord } from "../types.js";
-import { type GenerateSentencesHookCandidateV1, type GenerateSentencesHookRequestV1, type GenerateSentencesHookResponseV1 } from "./hook-protocol.js";
-import type { MiningHookInspection } from "./types.js";
-export declare function runGenerateSentencesHookRequest(options: {
-    hookRootPath: string;
-    entrypointPath: string;
-    request: GenerateSentencesHookRequestV1;
-    signal?: AbortSignal;
-    timeoutMs?: number;
-}): Promise<{
-    response: GenerateSentencesHookResponseV1;
-    candidates: GenerateSentencesHookCandidateV1[];
-}>;
-export declare function ensureMiningHookTemplate(options: {
-    hookRootPath: string;
-    entrypointPath: string;
-    packagePath: string;
-}): Promise<boolean>;
-export declare function validateCustomMiningHook(options: {
-    hookRootPath: string;
-    entrypointPath: string;
-    packagePath: string;
-}): Promise<{
-    launchFingerprint: string;
-    fullFingerprint: string;
-}>;
-export declare function inspectMiningHookState(options: {
-    hookRootPath: string;
-    entrypointPath: string;
-    packagePath: string;
-    localState: HookClientStateRecord | null;
-    verify: boolean;
-    nowUnixMs?: number;
-}): Promise<MiningHookInspection>;
-export declare function shouldEnterHookCooldown(options: {
-    consecutiveFailureCount: number;
-    nowUnixMs: number;
-}): number | null;