@genkaku/protocol 0.0.0-stage → 0.1.1

package/dist/llmBridge.js

@@ -0,0 +1,284 @@
+// GENKAKU: local LLM bridge (worker mode).
+// Translates an in-flight libp2p worker stream into the machine's local Ollama
+// API (127.0.0.1:11434 — same source the upstream agent uses via
+// agent/agent_init_ollama.py), streaming tokens out and reporting metering.
+//
+// Deviation from P2 §6 note: the LLM-side transport is *local HTTP*, not the
+// Python relay — the sidecar stays a thin, testable layer; a future variant can
+// point it at a hermes gateway's internal completion API instead (the interface
+// below is the seam: LocalCompletionSource).
+import { profileOf } from "./capabilities.js";
+export function ollamaAdmin(host = process.env.GENKAKU_OLLAMA_HOST ?? DEFAULT_HOST) {
+    async function readNdjson(res, onFrame) {
+        if (!res.ok || !res.body) {
+            throw new Error(`[genkaku:ollama] ${new URL(res.url).pathname} refused (${res.status})`);
+        }
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buf = '';
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done) {
+                break;
+            }
+            buf += decoder.decode(value, { stream: true });
+            let nl;
+            while ((nl = buf.indexOf('\n')) >= 0) {
+                const line = buf.slice(0, nl).trim();
+                buf = buf.slice(nl + 1);
+                if (!line) {
+                    continue;
+                }
+                try {
+                    onFrame(JSON.parse(line));
+                }
+                catch { /* tolerate */ }
+            }
+        }
+    }
+    return {
+        /** locally installed models (what the worker may choose to publish) */
+        async list() {
+            const res = await fetch(new URL('/api/tags', host), { method: 'GET' });
+            if (!res.ok) {
+                throw new Error(`[genkaku:ollama] /api/tags refused (${res.status}) — is Ollama running?`);
+            }
+            const body = (await res.json());
+            return (body.models ?? []).map(m => ({
+                name: m.name,
+                sizeBytes: m.size,
+                family: m.details?.family,
+                quantization: m.details?.quantization_level,
+            }));
+        },
+        /** download a model from the Ollama registry (registry name like "llama3:8b") */
+        async pull(model, onProgress, signal) {
+            const res = await fetch(new URL('/api/pull', host), {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({ model, stream: true }),
+                ...(signal === undefined ? {} : { signal }),
+            });
+            let status = 'unknown';
+            await readNdjson(res, (f) => {
+                const total = typeof f.total === 'number' ? f.total : undefined;
+                const completed = typeof f.completed === 'number' ? f.completed : undefined;
+                let percent;
+                if (total != null && completed != null && total > 0) {
+                    percent = Math.min(100, Math.round((completed / total) * 100));
+                }
+                const frame = { status: String(f.status ?? ''), percent };
+                status = frame.status;
+                onProgress?.(frame);
+            });
+            return { status };
+        },
+    };
+}
+const DEFAULT_HOST = 'http://127.0.0.1:11434';
+/**
+ * Ask Ollama what a model can do.
+ *
+ * `/api/show` is the authoritative answer for capabilities; the parameter size
+ * lives in `/api/tags` under `details.parameter_size`. Both are needed for the
+ * tier, so callers usually want {@link probeModels}.
+ *
+ * @param model - model name as Ollama knows it.
+ * @param host - Ollama base URL.
+ */
+export async function probeModel(model, host = process.env.GENKAKU_OLLAMA_HOST ?? DEFAULT_HOST) {
+    const res = await fetch(new URL('/api/show', host), {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ model }),
+    });
+    if (!res.ok) {
+        throw new Error(`[genkaku:ollama] /api/show refused for ${model} (${res.status})`);
+    }
+    const body = (await res.json());
+    return {
+        ...(Array.isArray(body.capabilities) ? { capabilities: body.capabilities } : {}),
+        ...(body.details?.parameter_size === undefined ? {} : { parameterSize: body.details.parameter_size }),
+    };
+}
+/**
+ * Profile every model Ollama has locally: capabilities from `/api/show`,
+ * size from `/api/tags`.
+ *
+ * A model whose probe fails is reported with no capabilities, which lands it in
+ * the `chat` tier. That is the safe direction: an unreadable model is never
+ * advertised as agent-capable.
+ *
+ * @param host - Ollama base URL.
+ */
+export async function probeModels(host = process.env.GENKAKU_OLLAMA_HOST ?? DEFAULT_HOST) {
+    const res = await fetch(new URL('/api/tags', host), { method: 'GET' });
+    if (!res.ok) {
+        throw new Error(`[genkaku:ollama] /api/tags refused (${res.status}) — is Ollama running?`);
+    }
+    const body = (await res.json());
+    const rows = body.models ?? [];
+    return Promise.all(rows.map(async (row) => {
+        let capabilities;
+        try {
+            capabilities = (await probeModel(row.name, host)).capabilities;
+        }
+        catch {
+            capabilities = undefined;
+        }
+        return profileOf(row.name, {
+            ...(capabilities === undefined ? {} : { capabilities }),
+            ...(row.details?.parameter_size === undefined ? {} : { parameterSize: row.details.parameter_size }),
+        });
+    }));
+}
+export function createOllamaSource(host = process.env.GENKAKU_OLLAMA_HOST ?? DEFAULT_HOST) {
+    return {
+        async stream(req, onDelta, signal) {
+            const res = await fetch(new URL('/api/generate', host), {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({
+                    model: req.model,
+                    prompt: req.prompt,
+                    system: req.system,
+                    stream: true,
+                    options: {
+                        num_ctx: Number(process.env.GENKAKU_OLLAMA_NUM_CTX ?? 8192),
+                        ...(req.maxTokens ? { num_predict: req.maxTokens } : {}),
+                    },
+                }),
+                ...(signal === undefined ? {} : { signal }),
+            });
+            if (!res.ok || !res.body) {
+                throw new Error(`[genkaku:ollama] local source refused (${res.status}) — is Ollama running?`);
+            }
+            const reader = res.body.getReader();
+            const decoder = new TextDecoder();
+            let completionChars = 0;
+            let done = false;
+            let evalCount = 0;
+            let promptTokens = 0;
+            // LP-JSON over the ollama ndjson
+            let buf = '';
+            while (!done) {
+                const { value, done: rDone } = await reader.read();
+                if (rDone) {
+                    break;
+                }
+                buf += decoder.decode(value, { stream: true });
+                let nl;
+                while ((nl = buf.indexOf('\n')) >= 0) {
+                    const line = buf.slice(0, nl).trim();
+                    buf = buf.slice(nl + 1);
+                    if (!line) {
+                        continue;
+                    }
+                    try {
+                        const parsed = JSON.parse(line);
+                        if (parsed.response) {
+                            completionChars += parsed.response.length;
+                            onDelta(parsed.response);
+                        }
+                        if (parsed.prompt_eval_count != null) {
+                            promptTokens = parsed.prompt_eval_count;
+                        }
+                        if (parsed.eval_count != null) {
+                            evalCount = parsed.eval_count;
+                        }
+                        if (parsed.done) {
+                            done = true;
+                            break;
+                        }
+                    }
+                    catch {
+                        // tolerate partial frames (ollama does not truncate mid-line)
+                    }
+                }
+            }
+            return {
+                promptTokens,
+                // prefer ollama's own count; fall back to the ~4-chars-per-token estimate
+                completionTokens: evalCount || Math.ceil(completionChars / 4),
+                model: req.model,
+            };
+        },
+    };
+}
+/**
+ * Serve a chat with tools through Ollama's `/api/chat`.
+ *
+ * The legacy `/api/generate` path takes a single prompt string and therefore
+ * cannot carry tool schemas or tool results; this source exists so a worker can
+ * serve an agent, not only a chat box.
+ *
+ * Ollama reports tool calls as complete objects rather than deltas, so each one
+ * is emitted as a single `tool-call` event with the full arguments string.
+ */
+export function createOllamaChatSource(host = process.env.GENKAKU_OLLAMA_HOST ?? DEFAULT_HOST) {
+    return {
+        async streamChat(req, onEvent, signal) {
+            const res = await fetch(new URL('/api/chat', host), {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({
+                    model: req.model,
+                    messages: req.messages,
+                    stream: true,
+                    ...(req.tools === undefined || req.tools.length === 0 ? {} : { tools: req.tools }),
+                    options: {
+                        num_ctx: Number(process.env.GENKAKU_OLLAMA_NUM_CTX ?? 8192),
+                        ...(req.maxTokens ? { num_predict: req.maxTokens } : {}),
+                    },
+                }),
+                ...(signal === undefined ? {} : { signal }),
+            });
+            if (!res.ok) {
+                throw new Error(`[genkaku:ollama] /api/chat refused (${res.status}) — is Ollama running?`);
+            }
+            let completionTokens = 0;
+            let toolIndex = 0;
+            const handleFrame = (frame) => {
+                const message = frame.message;
+                if (typeof message?.content === 'string' && message.content !== '') {
+                    completionTokens += 1;
+                    onEvent({ type: 'text', text: message.content });
+                }
+                for (const call of message?.tool_calls ?? []) {
+                    const args = call.function?.arguments;
+                    onEvent({
+                        type: 'tool-call',
+                        index: toolIndex++,
+                        name: call.function?.name ?? '',
+                        argumentsDelta: typeof args === 'string' ? args : JSON.stringify(args ?? {}),
+                    });
+                }
+            };
+            const reader = res.body?.getReader();
+            if (reader == null)
+                throw new Error('[genkaku:ollama] /api/chat returned no body');
+            const decoder = new TextDecoder();
+            let buffer = '';
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                let nl = buffer.indexOf('\n');
+                while (nl >= 0) {
+                    const line = buffer.slice(0, nl).trim();
+                    buffer = buffer.slice(nl + 1);
+                    if (line !== '') {
+                        try {
+                            handleFrame(JSON.parse(line));
+                        }
+                        catch { /* tolerate */ }
+                    }
+                    nl = buffer.indexOf('\n');
+                }
+            }
+            return { completionTokens, model: req.model };
+        },
+    };
+}
+//# sourceMappingURL=llmBridge.js.map

package/dist/lp.d.ts

@@ -0,0 +1,31 @@
+export declare function lpEncode(obj: unknown): Uint8Array;
+export type ByteChunk = Uint8Array | {
+    subarray(): Uint8Array;
+};
+/** Parse every COMPLETE frame in a byte blob (tests / whole-stream reads). */
+export declare function lpFrames(chunks: ByteChunk[]): unknown[];
+/**
+ * Incremental frame reader — feeds whatever bytes arrive and pops complete
+ * frames WITHOUT waiting for stream end.
+ */
+export declare class FrameReader {
+    private buf;
+    push(chunk: ByteChunk): void;
+    /** next complete frame, or undefined while the current one is still partial */
+    next(): unknown | undefined;
+}
+/**
+ * One durable write side per stream: `sink(queue.source())` once, then push
+ * frames as they happen; the write half stays open until .end().
+ */
+export declare class WriteQueue {
+    private items;
+    private waiters;
+    /** end() has been called — readers will see EOF after draining the items */
+    ended: boolean;
+    push(b: Uint8Array): void;
+    end(): void;
+    private drain;
+    source(): AsyncGenerator<Uint8Array>;
+}
+//# sourceMappingURL=lp.d.ts.map

package/dist/lp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lp.d.ts","sourceRoot":"","sources":["../src/lp.ts"],"names":[],"mappings":"AAOA,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,UAAU,CAQjD;AAED,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG;IAAE,QAAQ,IAAI,UAAU,CAAA;CAAE,CAAA;AA2B/D,8EAA8E;AAC9E,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG,OAAO,EAAE,CAgBvD;AAED;;;GAGG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,GAAG,CAAoB;IAE/B,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAQ5B,+EAA+E;IAC/E,IAAI,IAAI,OAAO,GAAG,SAAS;CAQ5B;AAED;;;GAGG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,KAAK,CAAmB;IAChC,OAAO,CAAC,OAAO,CAAwB;IACvC,4EAA4E;IAC5E,KAAK,UAAQ;IAEb,IAAI,CAAC,CAAC,EAAE,UAAU,GAAG,IAAI;IAMzB,GAAG,IAAI,IAAI;IAKX,OAAO,CAAC,KAAK;IAIN,MAAM,IAAI,cAAc,CAAC,UAAU,CAAC;CAQ5C"}

package/dist/lp.js

@@ -0,0 +1,116 @@
+// GENKAKU: LP-JSON wire primitives (protocol v0).
+// 4-byte big-endian length prefix + UTF-8 JSON. Frame codec is streamable:
+// sessions START before the peer finishes writing (tokens keep flowing after
+// the open envelope), so reads must increment — never drain-to-EOS.
+// A sink may only be attached ONCE per libp2p stream; all writes to one stream
+// go through a WriteQueue whose async generator never ends until .end().
+export function lpEncode(obj) {
+    const body = new TextEncoder().encode(JSON.stringify(obj) + '\n');
+    const head = new Uint8Array(4);
+    new DataView(head.buffer).setUint32(0, body.byteLength);
+    const out = new Uint8Array(head.length + body.length);
+    out.set(head);
+    out.set(body, head.length);
+    return out;
+}
+function toU8(c) {
+    if (c instanceof Uint8Array) {
+        return c;
+    }
+    return c.subarray();
+}
+function parseFrames(buf) {
+    const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    const frames = [];
+    let p = 0;
+    while (p + 4 <= buf.length) {
+        const len = dv.getUint32(p);
+        if (len === 0 || p + 4 + len > buf.length) {
+            break;
+        }
+        try {
+            frames.push(JSON.parse(new TextDecoder().decode(buf.subarray(p + 4, p + 4 + len))));
+        }
+        catch { /* tolerate */ }
+        p += 4 + len;
+    }
+    return { frames, consumed: p };
+}
+/** Parse every COMPLETE frame in a byte blob (tests / whole-stream reads). */
+export function lpFrames(chunks) {
+    const parts = [];
+    let total = 0;
+    for (const c of chunks) {
+        const u = toU8(c);
+        parts.push(u);
+        total += u.length;
+    }
+    const buf = new Uint8Array(total);
+    let off = 0;
+    for (const u of parts) {
+        buf.set(u, off);
+        off += u.length;
+    }
+    return parseFrames(buf).frames;
+}
+/**
+ * Incremental frame reader — feeds whatever bytes arrive and pops complete
+ * frames WITHOUT waiting for stream end.
+ */
+export class FrameReader {
+    buf = new Uint8Array(0);
+    push(chunk) {
+        const u = toU8(chunk);
+        const merged = new Uint8Array(this.buf.length + u.length);
+        merged.set(this.buf);
+        merged.set(u, this.buf.length);
+        this.buf = merged;
+    }
+    /** next complete frame, or undefined while the current one is still partial */
+    next() {
+        const { frames, consumed } = parseFrames(this.buf);
+        if (frames.length === 0) {
+            return undefined;
+        }
+        this.buf = this.buf.subarray(consumed);
+        return frames[0];
+    }
+}
+/**
+ * One durable write side per stream: `sink(queue.source())` once, then push
+ * frames as they happen; the write half stays open until .end().
+ */
+export class WriteQueue {
+    items = [];
+    waiters = [];
+    /** end() has been called — readers will see EOF after draining the items */
+    ended = false;
+    push(b) {
+        if (this.ended) {
+            return;
+        }
+        this.items.push(b);
+        this.drain();
+    }
+    end() {
+        this.ended = true;
+        this.drain();
+    }
+    drain() {
+        for (const w of this.waiters.splice(0)) {
+            w();
+        }
+    }
+    async *source() {
+        while (true) {
+            while (this.items.length > 0) {
+                yield this.items.shift();
+            }
+            if (this.ended) {
+                return;
+            }
+            await new Promise(resolve => this.waiters.push(resolve));
+        }
+    }
+}
+//# sourceMappingURL=lp.js.map

package/dist/modeManager.d.ts

@@ -0,0 +1,30 @@
+export type RoleMode = 'user' | 'localPlusSharing' | 'workerDedicated';
+export type ModeState = {
+    mode: RoleMode;
+    /** a live remote session consumes another peer's worker this instant */
+    remoteUserActive: boolean;
+    /** this machine exposes /genkaku/* worker protocols on its libp2p node */
+    sharingActive: boolean;
+};
+export declare class ModeError extends Error {
+    readonly code: string;
+    constructor(msg: string, code: string);
+}
+export declare class ModeManager {
+    private readonly onTransition?;
+    private state;
+    constructor(onTransition?: ((from: RoleMode, to: RoleMode) => void) | undefined);
+    current(): Readonly<ModeState>;
+    /** Enter a role. `remoteUserActive` hints whether a live remote session should
+     *  carry over (only meaningful user→user). */
+    switch(to: RoleMode, opts?: {
+        remoteUserActive?: boolean;
+    }): ModeState;
+    /** Sidecar calls at transport start (user mode only; D-block is enforced here). */
+    beginRemoteSession(): void;
+    endRemoteSession(): void;
+    /** Sidecar guard before installing /genkaku/* protocol handlers. */
+    installWorkerListeners(): 'installed' | 'already';
+    removeWorkerListeners(): void;
+}
+//# sourceMappingURL=modeManager.d.ts.map

package/dist/modeManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modeManager.d.ts","sourceRoot":"","sources":["../src/modeManager.ts"],"names":[],"mappings":"AAaA,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,kBAAkB,GAAG,iBAAiB,CAAA;AAEtE,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,QAAQ,CAAA;IACd,wEAAwE;IACxE,gBAAgB,EAAE,OAAO,CAAA;IACzB,0EAA0E;IAC1E,aAAa,EAAE,OAAO,CAAA;CACvB,CAAA;AAED,qBAAa,SAAU,SAAQ,KAAK;aACO,IAAI,EAAE,MAAM;gBAAzC,GAAG,EAAE,MAAM,EAAkB,IAAI,EAAE,MAAM;CAGtD;AAED,qBAAa,WAAW;IAGV,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC;IAF1C,OAAO,CAAC,KAAK,CAAW;gBAEK,YAAY,CAAC,GAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,QAAQ,KAAK,IAAI,aAAA;IAIlF,OAAO,IAAI,QAAQ,CAAC,SAAS,CAAC;IAI9B;kDAC8C;IAC9C,MAAM,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,GAAE;QAAE,gBAAgB,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,SAAS;IAkB1E,mFAAmF;IACnF,kBAAkB,IAAI,IAAI;IAY1B,gBAAgB,IAAI,IAAI;IAIxB,oEAAoE;IACpE,sBAAsB,IAAI,WAAW,GAAG,SAAS;IAgBjD,qBAAqB,IAAI,IAAI;CAO9B"}

package/dist/modeManager.js

@@ -0,0 +1,81 @@
+// GENKAKU: role mode manager — the D-block enforcement lives HERE and in the
+// sidecar (never both a remote-user dialer and a worker listener on one machine).
+// Spec: docs/genkaku/P4-ADAPTATION.md §2; user-locked rule 2026-11-06.
+//
+// Semantics:
+//   · "remote session"  = this machine CONSUMES someone else's worker stream
+//   · "sharing"         = this machine SERVES its local LLM over libp2p
+//   · A user            : may hold remote sessions, never shares
+//   · B localPlusSharing: owners use their LOCAL model + share idle capacity
+//        ("local use" is not a remote session — no counterparty, no metering)
+//   · C workerDedicated : pure serving
+//   · D                 : remote-consumption + sharing simultaneously — banned
+export class ModeError extends Error {
+    code;
+    constructor(msg, code) {
+        super(`[genkaku:${code}] ${msg}`);
+        this.code = code;
+    }
+}
+export class ModeManager {
+    onTransition;
+    state;
+    constructor(onTransition) {
+        this.onTransition = onTransition;
+        this.state = { mode: 'localPlusSharing', remoteUserActive: false, sharingActive: false };
+    }
+    current() {
+        return { ...this.state };
+    }
+    /** Enter a role. `remoteUserActive` hints whether a live remote session should
+     *  carry over (only meaningful user→user). */
+    switch(to, opts = {}) {
+        if (this.state.mode === 'user' && this.state.remoteUserActive && to !== 'user') {
+            throw new ModeError('open remote sessions must end before leaving user mode', 'remote-must-drain');
+        }
+        if (this.state.sharingActive && to === 'user') {
+            throw new ModeError('stop worker listening before becoming a remote user', 'sharing-must-drain');
+        }
+        const sharing = to !== 'user';
+        const remote = to === 'user' ? Boolean(opts.remoteUserActive) : false;
+        const before = this.state.mode;
+        this.state = { mode: to, remoteUserActive: remote, sharingActive: sharing };
+        this.onTransition?.(before, to);
+        return { ...this.state };
+    }
+    /** Sidecar calls at transport start (user mode only; D-block is enforced here). */
+    beginRemoteSession() {
+        if (this.state.mode !== 'user') {
+            throw new ModeError('remote consumption is only allowed in dedicated user mode (D-block)', 'd-block');
+        }
+        if (this.state.sharingActive) {
+            throw new ModeError('cannot consume a remote worker while sharing (D-block)', 'd-block');
+        }
+        this.state.remoteUserActive = true;
+    }
+    endRemoteSession() {
+        this.state.remoteUserActive = false;
+    }
+    /** Sidecar guard before installing /genkaku/* protocol handlers. */
+    installWorkerListeners() {
+        if (this.state.mode === 'user') {
+            throw new ModeError('worker listeners forbidden in user mode (D-block)', 'd-block');
+        }
+        if (this.state.remoteUserActive) {
+            throw new ModeError('still draining a remote session before installing listeners', 'remote-must-drain');
+        }
+        if (this.state.sharingActive) {
+            return 'already';
+        }
+        this.state.sharingActive = true;
+        this.onTransition?.('user', this.state.mode);
+        return 'installed';
+    }
+    removeWorkerListeners() {
+        if (this.state.remoteUserActive) {
+            throw new ModeError('still draining a remote session before removing listeners', 'remote-must-drain');
+        }
+        this.state.sharingActive = false;
+    }
+}
+//# sourceMappingURL=modeManager.js.map

package/dist/netconfig.d.ts

@@ -0,0 +1,11 @@
+export type NetEnvironment = 'base-sepolia' | 'base';
+export declare const CHAIN_ID: Record<NetEnvironment, 84532 | 8453>;
+export declare const CONTRACTS: Record<NetEnvironment, {
+    escrow: string;
+    registry: string;
+    usdc: string;
+}>;
+export declare const TREASURY = "0x639a2B713041e15B0c5C18710536b661d5265b48";
+export declare const HARDCODED_SEEDS: string[];
+export declare const DEFAULT_RECEIPT_STEP_TOKENS = 10;
+//# sourceMappingURL=netconfig.d.ts.map

package/dist/netconfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"netconfig.d.ts","sourceRoot":"","sources":["../src/netconfig.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,cAAc,GAAG,cAAc,GAAG,MAAM,CAAA;AAEpD,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,cAAc,EAAE,KAAK,GAAG,IAAI,CAGzD,CAAA;AAED,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,cAAc,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAWhG,CAAA;AAED,eAAO,MAAM,QAAQ,+CAA+C,CAAA;AAWpE,eAAO,MAAM,eAAe,EAAE,MAAM,EAQhC,CAAA;AAGJ,eAAO,MAAM,2BAA2B,KAAK,CAAA"}

package/dist/netconfig.js

@@ -0,0 +1,39 @@
+// GENKAKU: network constants for the desktop client (P4).
+// Chain/data-model follows protocol/GENKAKU-P1.md + GENKAKU-P2.md.
+// Testnet values are verified on-chain (deployed 2026-11-06, contracts/README.md).
+export const CHAIN_ID = {
+    'base-sepolia': 84532,
+    base: 8453,
+};
+export const CONTRACTS = {
+    'base-sepolia': {
+        escrow: '0x8175df796A659681009BeDa4609a3cFe9d281D82',
+        registry: '0xFbE9FF497dC24bD69d13E4201418938Df7435Ff6', // v0.2 — on-chain directory (P4.9a)
+        usdc: '0xEb33DFC0424810039337a38510ef522e9E7F9727', // MockUSDC — test only
+    },
+    base: {
+        escrow: '', // deploy at mainnet launch
+        registry: '',
+        usdc: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // canonical USDC — verify vs Circle
+    },
+};
+export const TREASURY = '0x639a2B713041e15B0c5C18710536b661d5265b48';
+// Discovery (P4.9): the worker directory lives on Base — see directory.ts and
+// rpc.ts. There is NO baked bootstrap seed: genkaku.app is a static download
+// page, and neither a user nor a worker may depend on infrastructure we run.
+//
+// `GENKAKU_BOOTSTRAP_SEEDS` (comma-separated multiaddrs) is a DEVELOPMENT
+// escape hatch for a LAN bring-up or a private deployment; it is empty in
+// shipped builds and is never required for discovery to work.
+const BAKED_SEEDS = [];
+export const HARDCODED_SEEDS = (() => {
+    const fromEnv = (process.env.GENKAKU_BOOTSTRAP_SEEDS ?? '')
+        .split(',')
+        .map(s => s.trim())
+        .filter(s => s !== '');
+    return (fromEnv.length > 0 ? fromEnv : BAKED_SEEDS)
+        .filter(s => !s.includes('PLACEHOLDER'));
+})();
+// Metered receipts: default k = 10 tokens per signed ledger increment (P2 §3).
+export const DEFAULT_RECEIPT_STEP_TOKENS = 10;
+//# sourceMappingURL=netconfig.js.map