@deepstrike/wasm 0.2.49 → 0.2.51

package/dist/runtime/kernel-rebuild.js

@@ -1,65 +0,0 @@
-import { KernelLogIntegrityError, kernelRecordDigest, verifyKernelTransactionStream, } from "./kernel-transaction-log.js";
-/** Deterministically fold an authoritative stream into a fresh WASM runtime. */
-export async function rebuildKernelRuntime(runtime, genesis, transactions) {
-    const cursor = await verifyKernelTransactionStream(genesis, transactions);
-    await assertFreshRuntimeMatchesGenesis(runtime, genesis);
-    for (const transaction of transactions) {
-        const prepared = JSON.parse(runtime.prepareStep(JSON.stringify(transaction.input)));
-        const token = prepared.prepare_token;
-        try {
-            if (prepared.status !== "prepared" || !token) {
-                throw new KernelLogIntegrityError(`kernel rebuild step ${transaction.step_seq} was not accepted as a new transition`);
-            }
-            if (prepared.base_generation !== transaction.base_generation) {
-                throw new KernelLogIntegrityError(`kernel rebuild generation diverged at step ${transaction.step_seq}`);
-            }
-            if (prepared.step.step_seq !== transaction.step_seq) {
-                throw new KernelLogIntegrityError(`kernel rebuild step_seq diverged at step ${transaction.step_seq}`);
-            }
-            if (await kernelRecordDigest(prepared.input) !== transaction.input_digest) {
-                throw new KernelLogIntegrityError(`kernel rebuild normalized input diverged at step ${transaction.step_seq}`);
-            }
-            if (await kernelRecordDigest(prepared.step) !== transaction.step_digest) {
-                throw new KernelLogIntegrityError(`kernel rebuild planned step diverged at step ${transaction.step_seq}`);
-            }
-            const committed = JSON.parse(runtime.commitPrepared(token));
-            if (await kernelRecordDigest(committed) !== transaction.step_digest) {
-                throw new KernelLogIntegrityError(`kernel rebuild committed step diverged at step ${transaction.step_seq}`);
-            }
-        }
-        catch (error) {
-            if (token && prepared.status === "prepared") {
-                try {
-                    runtime.abortPrepared(token);
-                }
-                catch { /* discard failed runtime */ }
-            }
-            throw error;
-        }
-    }
-    return { runtime, cursor };
-}
-async function assertFreshRuntimeMatchesGenesis(runtime, genesis) {
-    const snapshot = JSON.parse(runtime.snapshot());
-    if (snapshot.abi_version !== genesis.abi_version) {
-        throw new KernelLogIntegrityError("kernel runtime ABI version does not match operation genesis");
-    }
-    if (genesis.default_policy_version !== 1) {
-        throw new KernelLogIntegrityError("kernel operation uses an unsupported default policy version");
-    }
-    if (snapshot.operation_id || snapshot.next_step_seq !== 1 || snapshot.accepted_inputs.length !== 0) {
-        throw new KernelLogIntegrityError("kernel rebuild requires a fresh runtime");
-    }
-    if (await kernelRecordDigest(snapshot.initial_policy) !== await kernelRecordDigest(genesis.initial_scheduler_policy)) {
-        throw new KernelLogIntegrityError("kernel runtime initial policy does not match operation genesis");
-    }
-    const defaults = {
-        snapshot_version: snapshot.snapshot_version,
-        snapshot_input_limit: snapshot.snapshot_input_limit,
-        max_input_bytes: snapshot.max_input_bytes,
-        snapshot_journal_bytes_limit: snapshot.snapshot_journal_bytes_limit,
-    };
-    if (await kernelRecordDigest(defaults) !== await kernelRecordDigest(genesis.resolved_runtime_defaults)) {
-        throw new KernelLogIntegrityError("kernel runtime defaults do not match operation genesis");
-    }
-}

package/dist/runtime/kernel-transaction-log.d.ts

@@ -1,61 +0,0 @@
-export declare const KERNEL_LOG_RECORD_VERSION: 1;
-export interface KernelOperationGenesisBody {
-    record_version: typeof KERNEL_LOG_RECORD_VERSION;
-    abi_version: number;
-    operation_id: string;
-    initial_scheduler_policy: Record<string, unknown>;
-    resolved_runtime_defaults: Record<string, unknown>;
-    default_policy_version: number;
-}
-export interface KernelOperationGenesis extends KernelOperationGenesisBody {
-    genesis_digest: string;
-}
-export interface KernelTransactionBody {
-    record_version: typeof KERNEL_LOG_RECORD_VERSION;
-    operation_id: string;
-    step_seq: number;
-    base_generation: number;
-    input: Record<string, unknown>;
-    input_digest: string;
-    previous_transaction_digest: string;
-    step_digest: string;
-}
-export interface KernelTransaction extends KernelTransactionBody {
-    transaction_digest: string;
-}
-export interface KernelGenesisReceipt {
-    log_seq: number;
-    genesis_digest: string;
-}
-export interface DurableAppendReceipt {
-    log_seq: number;
-    transaction_digest: string;
-}
-export interface KernelOperationCursor {
-    operation_id: string;
-    next_event_sequence: number;
-    next_step_seq: number;
-    transaction_head_digest: string;
-}
-export declare class KernelLogConflictError extends Error {
-    constructor(message: string);
-}
-export declare class KernelLogIntegrityError extends Error {
-    constructor(message: string);
-}
-export declare function canonicalKernelJson(value: unknown): string;
-export declare function kernelRecordDigest(value: unknown): Promise<string>;
-export declare function createKernelOperationGenesis(input: Omit<KernelOperationGenesisBody, "record_version">): Promise<KernelOperationGenesis>;
-export declare function createKernelTransaction(input: {
-    operation_id: string;
-    step_seq: number;
-    base_generation: number;
-    input: Record<string, unknown>;
-    step: Record<string, unknown>;
-    previous_transaction_digest: string;
-}): Promise<KernelTransaction>;
-export declare function verifyKernelOperationGenesis(genesis: KernelOperationGenesis): Promise<void>;
-export declare function verifyKernelTransaction(transaction: KernelTransaction): Promise<void>;
-export declare function verifyKernelTransactionSuccessor(previous: KernelTransaction | undefined, transaction: KernelTransaction): void;
-/** Validate one complete authoritative operation stream and derive its next wire cursor. */
-export declare function verifyKernelTransactionStream(genesis: KernelOperationGenesis, transactions: readonly KernelTransaction[]): Promise<KernelOperationCursor>;

package/dist/runtime/kernel-transaction-log.js

@@ -1,140 +0,0 @@
-export const KERNEL_LOG_RECORD_VERSION = 1;
-export class KernelLogConflictError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "KernelLogConflictError";
-    }
-}
-export class KernelLogIntegrityError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "KernelLogIntegrityError";
-    }
-}
-export function canonicalKernelJson(value) {
-    if (value === null)
-        return "null";
-    if (typeof value === "string" || typeof value === "boolean")
-        return JSON.stringify(value);
-    if (typeof value === "number") {
-        if (!Number.isFinite(value))
-            throw new KernelLogIntegrityError("canonical records require finite numbers");
-        if (Number.isSafeInteger(value))
-            return JSON.stringify(Object.is(value, -0) ? 0 : value);
-        if (Number.isInteger(value)) {
-            throw new KernelLogIntegrityError("canonical record integer exceeds the cross-SDK safe range");
-        }
-        const bytes = new Uint8Array(8);
-        new DataView(bytes.buffer).setFloat64(0, value, false);
-        return `f64:${Array.from(bytes, byte => byte.toString(16).padStart(2, "0")).join("")}`;
-    }
-    if (Array.isArray(value))
-        return `[${value.map(canonicalKernelJson).join(",")}]`;
-    if (typeof value === "object") {
-        const object = value;
-        const keys = Object.keys(object).sort();
-        return `{${keys.map(key => `${JSON.stringify(key)}:${canonicalKernelJson(object[key])}`).join(",")}}`;
-    }
-    throw new KernelLogIntegrityError(`unsupported canonical record value: ${typeof value}`);
-}
-export async function kernelRecordDigest(value) {
-    const bytes = new TextEncoder().encode(canonicalKernelJson(value));
-    const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
-    return Array.from(new Uint8Array(digest), byte => byte.toString(16).padStart(2, "0")).join("");
-}
-export async function createKernelOperationGenesis(input) {
-    const body = { record_version: KERNEL_LOG_RECORD_VERSION, ...input };
-    validateGenesisBody(body);
-    return { ...body, genesis_digest: await kernelRecordDigest(body) };
-}
-export async function createKernelTransaction(input) {
-    const body = {
-        record_version: KERNEL_LOG_RECORD_VERSION,
-        operation_id: input.operation_id,
-        step_seq: input.step_seq,
-        base_generation: input.base_generation,
-        input: input.input,
-        input_digest: await kernelRecordDigest(input.input),
-        previous_transaction_digest: input.previous_transaction_digest,
-        step_digest: await kernelRecordDigest(input.step),
-    };
-    validateTransactionBody(body);
-    return { ...body, transaction_digest: await kernelRecordDigest(body) };
-}
-export async function verifyKernelOperationGenesis(genesis) {
-    const { genesis_digest, ...body } = genesis;
-    validateGenesisBody(body);
-    if (await kernelRecordDigest(body) !== genesis_digest) {
-        throw new KernelLogIntegrityError("kernel genesis digest does not match its canonical body");
-    }
-}
-export async function verifyKernelTransaction(transaction) {
-    const { transaction_digest, ...body } = transaction;
-    validateTransactionBody(body);
-    if (await kernelRecordDigest(body.input) !== body.input_digest) {
-        throw new KernelLogIntegrityError("kernel transaction input digest does not match its input");
-    }
-    if (await kernelRecordDigest(body) !== transaction_digest) {
-        throw new KernelLogIntegrityError("kernel transaction digest does not match its canonical body");
-    }
-}
-export function verifyKernelTransactionSuccessor(previous, transaction) {
-    const expectedStepSeq = previous ? previous.step_seq + 1 : 1;
-    const expectedGeneration = previous ? previous.base_generation + 1 : 0;
-    if (transaction.step_seq !== expectedStepSeq) {
-        throw new KernelLogIntegrityError(`kernel transaction step_seq ${transaction.step_seq} does not follow ${expectedStepSeq - 1}`);
-    }
-    if (transaction.base_generation !== expectedGeneration) {
-        throw new KernelLogIntegrityError(`kernel transaction base_generation ${transaction.base_generation} does not match ${expectedGeneration}`);
-    }
-    if (transaction.input.operation_id !== transaction.operation_id) {
-        throw new KernelLogIntegrityError("kernel transaction input operation_id does not match its envelope");
-    }
-}
-/** Validate one complete authoritative operation stream and derive its next wire cursor. */
-export async function verifyKernelTransactionStream(genesis, transactions) {
-    await verifyKernelOperationGenesis(genesis);
-    let previous;
-    let head = genesis.genesis_digest;
-    for (const transaction of transactions) {
-        await verifyKernelTransaction(transaction);
-        if (transaction.operation_id !== genesis.operation_id) {
-            throw new KernelLogIntegrityError("kernel transaction operation_id does not match genesis");
-        }
-        if (transaction.previous_transaction_digest !== head) {
-            throw new KernelLogIntegrityError("kernel transaction digest chain is not continuous");
-        }
-        verifyKernelTransactionSuccessor(previous, transaction);
-        previous = transaction;
-        head = transaction.transaction_digest;
-    }
-    const nextSequence = (previous?.step_seq ?? 0) + 1;
-    return {
-        operation_id: genesis.operation_id,
-        next_event_sequence: nextSequence,
-        next_step_seq: nextSequence,
-        transaction_head_digest: head,
-    };
-}
-function validateGenesisBody(genesis) {
-    if (genesis.record_version !== KERNEL_LOG_RECORD_VERSION)
-        throw new KernelLogIntegrityError("unsupported kernel genesis record version");
-    if (!Number.isSafeInteger(genesis.abi_version) || genesis.abi_version <= 0)
-        throw new KernelLogIntegrityError("kernel genesis abi_version must be a positive safe integer");
-    if (!genesis.operation_id)
-        throw new KernelLogIntegrityError("kernel genesis operation_id is required");
-    if (!Number.isSafeInteger(genesis.default_policy_version) || genesis.default_policy_version <= 0)
-        throw new KernelLogIntegrityError("kernel genesis default_policy_version must be a positive safe integer");
-}
-function validateTransactionBody(transaction) {
-    if (transaction.record_version !== KERNEL_LOG_RECORD_VERSION)
-        throw new KernelLogIntegrityError("unsupported kernel transaction record version");
-    if (!transaction.operation_id)
-        throw new KernelLogIntegrityError("kernel transaction operation_id is required");
-    if (!Number.isSafeInteger(transaction.step_seq) || transaction.step_seq <= 0)
-        throw new KernelLogIntegrityError("kernel transaction step_seq must be a positive safe integer");
-    if (!Number.isSafeInteger(transaction.base_generation) || transaction.base_generation < 0)
-        throw new KernelLogIntegrityError("kernel transaction base_generation must be a non-negative safe integer");
-    if (!transaction.previous_transaction_digest)
-        throw new KernelLogIntegrityError("kernel transaction previous_transaction_digest is required");
-}

package/dist/runtime/large-result-spool.d.ts

@@ -1,57 +0,0 @@
-export interface ToolResult {
-    callId: string;
-    tool: string;
-    output: string;
-    isError?: boolean;
-}
-export interface SpooledToolResult {
-    originalOutput: string;
-    preview: string;
-    spoolRef: string;
-    wasSpooled: boolean;
-}
-export interface SpoolConfig {
-    spoolThresholdBytes: number;
-    previewTokens: number;
-    totalMessageLimitBytes: number;
-    maxAgeMs?: number;
-    driver?: SpoolStorageDriver;
-}
-export interface SpoolStorageDriver {
-    write(key: string, content: string): Promise<void> | void;
-    read(key: string): Promise<string> | string;
-    delete(key: string): Promise<void> | void;
-    list(): Promise<string[]> | string[];
-    mtime?(key: string): Promise<number> | number;
-}
-export declare class MemorySpoolDriver implements SpoolStorageDriver {
-    private cache;
-    write(key: string, content: string): Promise<void>;
-    read(key: string): Promise<string>;
-    delete(key: string): Promise<void>;
-    list(): Promise<string[]>;
-    mtime(key: string): Promise<number>;
-}
-export declare const DEFAULT_SPOOL_CONFIG: SpoolConfig;
-export declare class LargeResultSpool {
-    private config;
-    private driver;
-    private activeWrites;
-    constructor(config?: Partial<SpoolConfig>);
-    private needsSpool;
-    private getSpoolKey;
-    private writeToDriver;
-    private generatePreview;
-    processToolResult(result: ToolResult): Promise<SpooledToolResult>;
-    private callKey;
-    persistOutput(sessionId: string, callId: string, content: string): Promise<string>;
-    readSpooledResult(spoolRef: string): Promise<string>;
-    /**
-     * O7: locate a spooled output by the tool call's id (the `read_result` meta-tool only knows
-     * `call_id`, not the content-hashed key `persistOutput` chose). Scans the driver's key list for
-     * the hashed session-scoped call-key prefix; returns `undefined` if nothing was ever
-     * spooled for that call.
-     */
-    findByCallId(sessionId: string, callId: string): Promise<string | undefined>;
-    cleanup(maxAgeMs?: number): Promise<number>;
-}

package/dist/runtime/large-result-spool.js

@@ -1,169 +0,0 @@
-export class MemorySpoolDriver {
-    cache = new Map();
-    async write(key, content) {
-        this.cache.set(key, { content, mtime: Date.now() });
-    }
-    async read(key) {
-        const val = this.cache.get(key);
-        if (!val)
-            throw new Error(`Spooled result not found: ${key}`);
-        return val.content;
-    }
-    async delete(key) {
-        this.cache.delete(key);
-    }
-    async list() {
-        return Array.from(this.cache.keys());
-    }
-    async mtime(key) {
-        return this.cache.get(key)?.mtime ?? 0;
-    }
-}
-export const DEFAULT_SPOOL_CONFIG = {
-    spoolThresholdBytes: 50 * 1024, // 50KB
-    previewTokens: 500, // ~2KB
-    totalMessageLimitBytes: 200 * 1024, // 200KB
-};
-function simpleHash(content) {
-    let hash = 5381;
-    for (let i = 0; i < content.length; i++) {
-        hash = (hash * 33) ^ content.charCodeAt(i);
-    }
-    return (hash >>> 0).toString(16);
-}
-export class LargeResultSpool {
-    config;
-    driver;
-    activeWrites = new Map();
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_SPOOL_CONFIG, ...config };
-        this.driver = this.config.driver ?? new MemorySpoolDriver();
-    }
-    needsSpool(result) {
-        return result.output.length > this.config.spoolThresholdBytes;
-    }
-    getSpoolKey(hash) {
-        return `.spool/${hash}.txt`;
-    }
-    async writeToDriver(content, hash) {
-        const key = this.getSpoolKey(hash);
-        let promise = this.activeWrites.get(key);
-        if (!promise) {
-            promise = (async () => {
-                try {
-                    await this.driver.write(key, content);
-                    return key;
-                }
-                finally {
-                    this.activeWrites.delete(key);
-                }
-            })();
-            this.activeWrites.set(key, promise);
-        }
-        return promise;
-    }
-    generatePreview(content) {
-        const previewTokens = Math.min(this.config.previewTokens, content.length / 4);
-        const preview = content.substring(0, previewTokens);
-        const omitted = content.length - previewTokens;
-        return `[tool_result_spooled]
-size: ${content.length} bytes
-preview: first ${previewTokens} chars
-omitted: ${omitted} chars
-[full content available via Read tool]
-`;
-    }
-    async processToolResult(result) {
-        if (!this.needsSpool(result)) {
-            return {
-                originalOutput: result.output,
-                preview: result.output,
-                spoolRef: "",
-                wasSpooled: false,
-            };
-        }
-        const hash = simpleHash(result.output);
-        const spoolRef = await this.writeToDriver(result.output, hash);
-        const preview = this.generatePreview(result.output);
-        return {
-            originalOutput: result.output,
-            preview,
-            spoolRef,
-            wasSpooled: true,
-        };
-    }
-    callKey(sessionId, callId) {
-        // Session-scoped and hashed: the driver's key space is shared across sessions and outlives
-        // runs, while vendor call ids can be index-style ("call_0") and repeat — an unscoped key
-        // lets read_result in one session fetch another session's spooled output. Hashing also keeps
-        // untrusted call-id characters out of driver keys (parity with Node/Python).
-        return simpleHash(`${sessionId}\u0000${callId}`);
-    }
-    async persistOutput(sessionId, callId, content) {
-        const hash = simpleHash(content);
-        const key = `.spool/${this.callKey(sessionId, callId)}-${hash.slice(0, 16)}.txt`;
-        let promise = this.activeWrites.get(key);
-        if (!promise) {
-            promise = (async () => {
-                try {
-                    await this.driver.write(key, content);
-                    return key;
-                }
-                finally {
-                    this.activeWrites.delete(key);
-                }
-            })();
-            this.activeWrites.set(key, promise);
-        }
-        return promise;
-    }
-    async readSpooledResult(spoolRef) {
-        return this.driver.read(spoolRef);
-    }
-    /**
-     * O7: locate a spooled output by the tool call's id (the `read_result` meta-tool only knows
-     * `call_id`, not the content-hashed key `persistOutput` chose). Scans the driver's key list for
-     * the hashed session-scoped call-key prefix; returns `undefined` if nothing was ever
-     * spooled for that call.
-     */
-    async findByCallId(sessionId, callId) {
-        let keys;
-        try {
-            keys = await this.driver.list();
-        }
-        catch {
-            return undefined;
-        }
-        const prefix = `.spool/${this.callKey(sessionId, callId)}-`;
-        const match = keys.find(k => k.startsWith(prefix) && k.endsWith('.txt'));
-        if (!match)
-            return undefined;
-        try {
-            return await this.driver.read(match);
-        }
-        catch {
-            return undefined;
-        }
-    }
-    async cleanup(maxAgeMs) {
-        const limit = maxAgeMs ?? this.config.maxAgeMs ?? 7 * 24 * 60 * 60 * 1000;
-        try {
-            const keys = await this.driver.list();
-            let count = 0;
-            const now = Date.now();
-            for (const key of keys) {
-                if (this.driver.mtime) {
-                    const mtime = await this.driver.mtime(key);
-                    if (now - mtime > limit) {
-                        await this.driver.delete(key);
-                        count++;
-                    }
-                }
-            }
-            return count;
-        }
-        catch {
-            return 0;
-        }
-    }
-}