@toon-protocol/git 1.0.0

package/dist/index.js

@@ -0,0 +1,61 @@
+import {
+  GitError,
+  GitRepoReader,
+  NonFastForwardError,
+  OversizeObjectsError,
+  executePush,
+  planPush,
+  serializeEventReceipt,
+  serializeFeeEstimate,
+  serializePushPlan,
+  serializePushResult
+} from "./chunk-4WFGAICZ.js";
+import {
+  fetchRemoteState
+} from "./chunk-R3JVS6SX.js";
+import {
+  COMMENT_KIND,
+  REPOSITORY_STATE_KIND,
+  buildComment,
+  buildIssue,
+  buildPatch,
+  buildRepoAnnouncement,
+  buildRepoRefs,
+  buildStatus
+} from "./chunk-KXXHAUXL.js";
+import {
+  MAX_OBJECT_SIZE,
+  createGitBlob,
+  createGitCommit,
+  createGitTag,
+  createGitTree,
+  hashGitObject
+} from "./chunk-M7O4SEVW.js";
+export {
+  COMMENT_KIND,
+  GitError,
+  GitRepoReader,
+  MAX_OBJECT_SIZE,
+  NonFastForwardError,
+  OversizeObjectsError,
+  REPOSITORY_STATE_KIND,
+  buildComment,
+  buildIssue,
+  buildPatch,
+  buildRepoAnnouncement,
+  buildRepoRefs,
+  buildStatus,
+  createGitBlob,
+  createGitCommit,
+  createGitTag,
+  createGitTree,
+  executePush,
+  fetchRemoteState,
+  hashGitObject,
+  planPush,
+  serializeEventReceipt,
+  serializeFeeEstimate,
+  serializePushPlan,
+  serializePushResult
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/publisher-VEIEQHl6.d.ts

@@ -0,0 +1,254 @@
+import { STATUS_OPEN_KIND, STATUS_APPLIED_KIND, STATUS_CLOSED_KIND, STATUS_DRAFT_KIND } from '@toon-protocol/core/nip34';
+
+/**
+ * Pure git object construction and SHA-1 envelope hashing.
+ *
+ * Promoted from `packages/rig/tests/e2e/seed/lib/git-builder.ts` (#223) —
+ * the proven seed pipeline builders, now the core of the Git-to-TOON write
+ * path. Everything here is pure: no network, no signing, no payments.
+ * Upload/publish lives with the Publisher (#226).
+ *
+ * Git object format: `<type> <size>\0<content>`. The SHA-1 is computed over
+ * the full envelope (header + NUL + content); the `body` (content only) is
+ * what gets uploaded to Arweave.
+ */
+/** All git object types TOON can carry. */
+type GitObjectType = 'blob' | 'tree' | 'commit' | 'tag';
+interface GitObject {
+    /** SHA-1 hex digest computed over full git envelope */
+    sha: string;
+    /** Full git object (header + null + content) */
+    buffer: Buffer;
+    /** Body only (content after the null byte) — this is what gets uploaded */
+    body: Buffer;
+}
+/**
+ * Maximum uploadable git object body size: 95KB safety margin under the
+ * 100KB free tier (R10-005). Larger objects are a hard error in v1.
+ */
+declare const MAX_OBJECT_SIZE: number;
+/**
+ * Wrap a raw object body in the git envelope (`<type> <size>\0`) and compute
+ * its SHA-1. This is exactly what `git hash-object -t <type>` does.
+ */
+declare function hashGitObject(type: GitObjectType, body: Buffer): GitObject;
+/**
+ * Construct a git blob object and compute its SHA-1.
+ *
+ * Format: blob <size>\0<content>
+ * SHA is over the full envelope; body is content only (for upload).
+ */
+declare function createGitBlob(content: string): GitObject;
+/**
+ * Construct a git tree object from sorted entries.
+ *
+ * Format: tree <size>\0<entries>
+ * Each entry: <mode> <name>\0<20-byte-raw-sha1>
+ * Entries MUST be sorted by name (byte-wise).
+ */
+declare function createGitTree(entries: {
+    mode: string;
+    name: string;
+    sha: string;
+}[]): GitObject;
+/**
+ * Construct a git commit object.
+ *
+ * Format: commit <size>\0tree <tree-sha>\n[parent ...]\nauthor ...\ncommitter ...\n\n<message>
+ * Tree/parent SHAs are hex-encoded (40 chars) in commits, unlike tree entries.
+ */
+declare function createGitCommit(opts: {
+    treeSha: string;
+    parentSha?: string;
+    authorName: string;
+    authorPubkey: string;
+    message: string;
+    timestamp: number;
+}): GitObject;
+/**
+ * Construct an annotated git tag object.
+ *
+ * Format: tag <size>\0object <sha>\ntype <type>\ntag <name>\ntagger ...\n\n<message>
+ * The tagged object is usually a commit, but git allows tagging any object
+ * type (including another tag).
+ */
+declare function createGitTag(opts: {
+    /** SHA-1 of the object being tagged (hex, 40 chars) */
+    objectSha: string;
+    /** Type of the tagged object (usually 'commit') */
+    objectType: GitObjectType;
+    /** Tag name, e.g. 'v1.0.0' */
+    tagName: string;
+    taggerName: string;
+    taggerPubkey: string;
+    message: string;
+    timestamp: number;
+}): GitObject;
+
+/**
+ * Pure NIP-34 event builders for the Git-to-TOON write path.
+ *
+ * Promoted from `packages/rig/tests/e2e/seed/lib/event-builders.ts` (#223).
+ * All builders return UnsignedEvent — the caller signs with their keypair
+ * via finalizeEvent() and publishes through a Publisher (#226). Tag
+ * structures follow the NIP-34 spec and `@toon-protocol/core/nip34`.
+ */
+
+/** Repository State (refs) — replaceable, pairs with kind:30617 via `d` tag. */
+declare const REPOSITORY_STATE_KIND = 30618;
+/** Comment on an issue or patch (NIP-22 style threading within NIP-34). */
+declare const COMMENT_KIND = 1622;
+interface UnsignedEvent {
+    kind: number;
+    content: string;
+    tags: string[][];
+    created_at: number;
+}
+/**
+ * Build a kind:30617 repository announcement event.
+ *
+ * @param repoId - Repository identifier (d tag)
+ * @param name - Human-readable repository name
+ * @param description - Repository description
+ */
+declare function buildRepoAnnouncement(repoId: string, name: string, description: string): UnsignedEvent;
+/**
+ * Build a kind:30618 repository refs/state event.
+ *
+ * @param repoId - Repository identifier (d tag, matches kind:30617)
+ * @param refs - Map of ref paths to commit SHAs (e.g., { 'refs/heads/main': 'abc123' })
+ * @param arweaveMap - Map of git SHAs to Arweave transaction IDs
+ */
+declare function buildRepoRefs(repoId: string, refs: Record<string, string>, arweaveMap?: Record<string, string>): UnsignedEvent;
+/**
+ * Build a kind:1621 issue event.
+ *
+ * @param repoOwnerPubkey - Pubkey of the repository owner
+ * @param repoId - Repository identifier
+ * @param title - Issue title (subject tag)
+ * @param body - Issue body (Markdown content)
+ * @param labels - Optional labels (t tags)
+ */
+declare function buildIssue(repoOwnerPubkey: string, repoId: string, title: string, body: string, labels?: string[]): UnsignedEvent;
+/**
+ * Build a kind:1622 comment event.
+ *
+ * @param repoOwnerPubkey - Pubkey of the repository owner
+ * @param repoId - Repository identifier
+ * @param issueOrPrEventId - Event ID of the issue or PR being commented on
+ * @param authorPubkey - Pubkey of the issue/PR author (NIP-34 `p` tag for threading), NOT the comment author
+ * @param body - Comment body (Markdown content)
+ * @param marker - Event reference marker: 'root' or 'reply' (default: 'reply')
+ */
+declare function buildComment(repoOwnerPubkey: string, repoId: string, issueOrPrEventId: string, authorPubkey: string, body: string, marker?: 'root' | 'reply'): UnsignedEvent;
+/**
+ * Build a kind:1617 patch event.
+ *
+ * @param repoOwnerPubkey - Pubkey of the repository owner
+ * @param repoId - Repository identifier
+ * @param title - Patch/PR title (subject tag)
+ * @param commits - Array of { sha, parentSha } for commit and parent-commit tags
+ * @param branchTag - Branch name for the t tag
+ * @param content - Real `git format-patch` text (NIP-34 patch body); defaults
+ *                  to '' for callers that only reference commits by tag
+ */
+declare function buildPatch(repoOwnerPubkey: string, repoId: string, title: string, commits: {
+    sha: string;
+    parentSha: string;
+}[], branchTag?: string, content?: string): UnsignedEvent;
+/** Status kinds: 1630 open, 1631 applied/merged, 1632 closed, 1633 draft. */
+type StatusKind = typeof STATUS_OPEN_KIND | typeof STATUS_APPLIED_KIND | typeof STATUS_CLOSED_KIND | typeof STATUS_DRAFT_KIND;
+/**
+ * Build a status event (kind 1630-1633).
+ *
+ * @param targetEventId - Event ID of the patch, PR, or issue being updated
+ * @param statusKind - One of 1630 (open), 1631 (applied), 1632 (closed), 1633 (draft)
+ * @param targetPubkey - Optional pubkey of the target event author (p tag per NIP-34 StatusEvent)
+ */
+declare function buildStatus(targetEventId: string, statusKind: StatusKind, targetPubkey?: string): UnsignedEvent;
+
+/**
+ * Publisher — the paid-write seam between push planning (this package) and
+ * the two transport implementations that follow it in epic #222:
+ *
+ *   1. daemon (#227): client-mcp ControlClient → toon-clientd loopback
+ *      /git/* routes, backed by `ClientRunner.publish`/`uploadBlob` (the
+ *      production paid-publish path — apex channel, signBalanceProof, flat
+ *      per-event fee).
+ *   2. standalone (#228): an embedded ToonClient constructed from a
+ *      mnemonic, uploading git objects as kind:5094 store writes with
+ *      Git-SHA/Git-Type/Repo tags (the proven seed-pipeline shape) and
+ *      publishing NIP-34 events through the relay.
+ *
+ * The interface is deliberately minimal so both fit:
+ *
+ *  - `uploadGitObject` takes the raw object body (content only — no git
+ *    envelope header; the store re-derives the SHA envelope from the
+ *    Git-Type/Git-SHA tags) and returns the Arweave txId plus the fee paid.
+ *  - `publishEvent` takes an UNSIGNED event template — signing stays with
+ *    the implementation (the daemon-held key never leaves the daemon; the
+ *    standalone impl signs with its own keypair). Relay URLs are plural
+ *    from day one (forward-compat for parked #84/#92; size 1 today).
+ *  - `getFeeRates` exposes what `planPush` needs for the pre-push estimate:
+ *    a per-byte upload rate (seed pipeline bids bytes × rate) and a flat
+ *    per-event publish fee (the daemon charges `apex.feePerEvent` regardless
+ *    of event size).
+ *
+ * All fees are bigint in the smallest asset unit (matches `@toon-protocol/client`
+ * channel math); HTTP transports serialize them as strings and convert at
+ * the boundary.
+ */
+
+/** A git object queued for upload to Arweave via the paid store path. */
+interface GitObjectUpload {
+    /** Full 40-hex SHA-1 (over the git envelope — see `hashGitObject`). */
+    sha: string;
+    type: GitObjectType;
+    /** Raw object body (content only, no `<type> <size>\0` header). */
+    body: Buffer;
+    /** Repository identifier — becomes the `Repo` tag on the store write. */
+    repoId: string;
+}
+/** Receipt for one uploaded git object. */
+interface UploadReceipt {
+    /** Arweave transaction ID the object is retrievable under. */
+    txId: string;
+    /** Fee paid for this upload, in the smallest asset unit. */
+    feePaid: bigint;
+}
+/** Receipt for one published Nostr event. */
+interface PublishReceipt {
+    /** Event ID as accepted by the relay(s). */
+    eventId: string;
+    /** Fee paid for this publish, in the smallest asset unit. */
+    feePaid: bigint;
+}
+/** Fee rates used by `planPush` for the pre-push estimate. */
+interface FeeRates {
+    /** Upload cost per body byte (smallest asset unit). */
+    uploadFeePerByte: bigint;
+    /** Flat cost per published event (smallest asset unit). */
+    eventFee: bigint;
+}
+/**
+ * Paid transport for `executePush` — implemented by the daemon route
+ * handlers (#227) and the standalone embedded client (#228).
+ *
+ * Implementations must be safe to call sequentially (uploads are issued one
+ * at a time in dependency-safe order) and should throw on any failure —
+ * `executePush` does not retry; a crashed push is resumed by re-planning
+ * (content-addressed uploads make the retry idempotent).
+ */
+interface Publisher {
+    /** Current fee rates for estimation (may be queried before every plan). */
+    getFeeRates(): Promise<FeeRates>;
+    /** Upload one git object body to Arweave; paid. */
+    uploadGitObject(upload: GitObjectUpload): Promise<UploadReceipt>;
+    /**
+     * Sign (implementation-held key) and pay-to-publish one event to the
+     * given relay(s).
+     */
+    publishEvent(event: UnsignedEvent, relayUrls: string[]): Promise<PublishReceipt>;
+}
+
+export { COMMENT_KIND as C, type FeeRates as F, type GitObjectUpload as G, MAX_OBJECT_SIZE as M, type Publisher as P, REPOSITORY_STATE_KIND as R, type StatusKind as S, type UnsignedEvent as U, type UploadReceipt as a, type PublishReceipt as b, type GitObjectType as c, type GitObject as d, buildComment as e, buildIssue as f, buildPatch as g, buildRepoAnnouncement as h, buildRepoRefs as i, buildStatus as j, createGitBlob as k, createGitCommit as l, createGitTag as m, createGitTree as n, hashGitObject as o };

package/dist/standalone/index.d.ts

@@ -0,0 +1,272 @@
+import { ToonClientConfig, SignedBalanceProof, PublishEventResult } from '@toon-protocol/client';
+import { U as UnsignedEvent, P as Publisher, F as FeeRates, G as GitObjectUpload, a as UploadReceipt, b as PublishReceipt } from '../publisher-VEIEQHl6.js';
+import '@toon-protocol/core/nip34';
+
+/**
+ * StandalonePublisher — impl 2 of the {@link Publisher} seam (#228): an
+ * EMBEDDED ToonClient constructed from the caller's config (mnemonic +
+ * account index, the exact `packages/client/src/config.ts` shape) instead of
+ * routing through a running toon-clientd. Made for CI jobs, servers, and
+ * one-shot CLI runs where no daemon exists.
+ *
+ * Paid-write mechanics mirror the production daemon path
+ * (`client-mcp/src/daemon/client-runner.ts`) and the proven seed pipeline
+ * (`rig/tests/e2e/seed/lib/{publish,git-builder}.ts`):
+ *
+ *  - one signed balance-proof CLAIM per write (`signBalanceProof(channelId,
+ *    fee)` — the ChannelManager accumulates the cumulative watermark),
+ *  - publishes route to the relay write destination with a flat per-event
+ *    fee (the daemon's `feePerEvent` convention),
+ *  - git objects upload as kind:5094 store writes tagged
+ *    Git-SHA/Git-Type/Repo, priced at bytes × per-byte rate (the seed
+ *    pipeline's bid), routed to the store destination via `proxyPath:
+ *    '/store'`, with the Arweave txId decoded from the FULFILL data.
+ *
+ * Because the embedded client signs claims on the SAME channels a daemon on
+ * the same identity would, every paid operation is preceded by the nonce
+ * guard (./nonce-guard.ts): refuse if a toon-clientd holds this identity,
+ * and hold an exclusive per-pubkey lockfile against other standalone
+ * processes for the lifetime of this publisher.
+ */
+
+/** A fully-signed Nostr event (structural subset of nostr-tools' NostrEvent). */
+interface SignedNostrEvent extends UnsignedEvent {
+    id: string;
+    pubkey: string;
+    sig: string;
+}
+/**
+ * The slice of `ToonClient` the publisher drives. Kept structural so tests
+ * inject a mock and alternative client builds stay compatible.
+ */
+interface ToonClientLike {
+    start(): Promise<unknown>;
+    stop(): Promise<void>;
+    isStarted?(): boolean;
+    getPublicKey(): string;
+    signEvent(template: UnsignedEvent): SignedNostrEvent;
+    openChannel(destination?: string): Promise<string>;
+    signBalanceProof(channelId: string, amount: bigint): Promise<SignedBalanceProof>;
+    publishEvent(event: SignedNostrEvent, options?: {
+        destination?: string;
+        claim?: SignedBalanceProof;
+        ilpAmount?: bigint;
+        proxyPath?: string;
+    }): Promise<PublishEventResult>;
+}
+interface StandalonePublisherOptions {
+    /**
+     * ToonClient config (mnemonic + mnemonicAccountIndex + proxy/BTP uplink +
+     * settlement fields — see `packages/client/src/config.ts`). Exactly one of
+     * `clientConfig` | `client` is required.
+     */
+    clientConfig?: ToonClientConfig;
+    /** Pre-built client (tests / advanced callers). */
+    client?: ToonClientLike;
+    /**
+     * ILP route for event publishes (relay `/write`). Default: derived from the
+     * config's `destinationAddress` anchor (`<base>.relay.store` → `<base>.relay`,
+     * matching the daemon's route derivation), else the anchor itself.
+     */
+    publishDestination?: string;
+    /**
+     * ILP route for git-object uploads (store `/store` → Arweave). Default:
+     * derived like `publishDestination` (`<base>.relay.store` → `<base>.store`).
+     */
+    storeDestination?: string;
+    /**
+     * ILP destination the payment channel anchors to. Default: the client
+     * config's `destinationAddress`.
+     */
+    channelDestination?: string;
+    /** Flat fee per published event (daemon `feePerEvent` convention). Default 1n. */
+    eventFee?: bigint;
+    /** Upload fee per object body byte (seed pipeline's bid rate). Default 10n. */
+    uploadFeePerByte?: bigint;
+    /** Daemon control API port probed by the nonce guard. */
+    daemonPort?: number;
+    /** Directory for the per-identity advisory lockfile. */
+    lockDir?: string;
+    /** Fetch impl for the daemon probe (tests). */
+    fetchImpl?: typeof fetch;
+}
+/** A relay/store rejected a paid write (fee NOT spent iff the claim failed too). */
+declare class StandalonePublishError extends Error {
+    constructor(message: string);
+}
+/**
+ * Derive publish/store routes from the channel anchor. Behind the devnet
+ * proxy the anchor is `<base>.relay.store` (e.g. `g.proxy.relay.store`):
+ * publishes terminate at `<base>.relay`, uploads at `<base>.store`. Anchors
+ * not matching the convention pass through unchanged.
+ */
+declare function deriveRouteDestinations(anchor: string): {
+    publish: string;
+    store: string;
+};
+/**
+ * Decode the Arweave txId from a store-write FULFILL. The deployed payment
+ * proxy returns the store's verbatim HTTP/1.1 response
+ * (`{"accept":true,"txId":…}` body); legacy non-proxy providers return bare
+ * `base64(utf8(txId))`.
+ *
+ * @throws {StandalonePublishError} when no valid txId can be extracted.
+ */
+declare function extractArweaveTxId(base64Data: string): string;
+declare class StandalonePublisher implements Publisher {
+    private readonly client;
+    private readonly ownsClient;
+    private readonly publishDestination;
+    private readonly storeDestination;
+    private readonly channelDestination;
+    private readonly eventFee;
+    private readonly uploadFeePerByte;
+    private readonly daemonPort;
+    private readonly lockDir;
+    private readonly fetchImpl;
+    private lock;
+    private channelId;
+    private readyPromise;
+    constructor(options: StandalonePublisherOptions);
+    /** Hex Nostr pubkey of the embedded identity (available before start). */
+    getPublicKey(): string;
+    /**
+     * Run the nonce guard, start the embedded client, and open (or resume) the
+     * payment channel. Called lazily by the first paid operation; safe to call
+     * eagerly to fail fast. Idempotent.
+     */
+    start(): Promise<void>;
+    private doStart;
+    /** Release the identity lock and stop the embedded client (if we own it). */
+    stop(): Promise<void>;
+    /**
+     * Fee rates for `planPush` estimation: the flat per-event fee and the
+     * per-byte upload rate this publisher pays (daemon `feePerEvent` and seed
+     * bid-rate conventions; override via options).
+     */
+    getFeeRates(): Promise<FeeRates>;
+    /**
+     * Upload one git object as a kind:5094 store write (Git-SHA/Git-Type/Repo
+     * tagged — the proven seed-pipeline shape), signing one balance-proof claim
+     * for `body.length × uploadFeePerByte`.
+     */
+    uploadGitObject(upload: GitObjectUpload): Promise<UploadReceipt>;
+    /**
+     * Sign the event with the embedded identity and pay-to-publish it through
+     * the relay write route, one claim for the flat per-event fee.
+     *
+     * `relayUrls` is the interface's plural forward-compat surface (parked
+     * #84): the standalone impl routes over ILP to its single configured
+     * publish destination, so more than one relay is refused rather than
+     * silently half-published.
+     */
+    publishEvent(event: UnsignedEvent, relayUrls: string[]): Promise<PublishReceipt>;
+    private requireChannel;
+}
+
+/**
+ * Nonce-ownership guard for the STANDALONE embedded Publisher (#228).
+ *
+ * Why this exists: a payment channel's balance proof is a CUMULATIVE
+ * watermark — the ChannelManager auto-increments the nonce and cumulative
+ * amount on every `signBalanceProof`. Two writers signing claims on the same
+ * channel from separate processes (a running `toon-clientd` daemon plus a
+ * standalone embedded client, or two standalone processes) each keep their
+ * own cumulative counter, so their claims race: the connector sees
+ * non-monotonic watermarks and a re-signed claim can double-charge (the
+ * hazard documented in packages/rig/tests/e2e/seed/lib/publish.ts).
+ *
+ * Two independent defenses, both keyed by the Nostr pubkey (one identity =
+ * one channel set):
+ *
+ *  1. Daemon detection — probe the toon-clientd loopback control API
+ *     (`GET /status`) and REFUSE when it reports the SAME identity. A daemon
+ *     on a different identity holds different channels and is harmless.
+ *  2. Advisory lockfile — an exclusive per-pubkey lockfile under the shared
+ *     `~/.toon-client` state dir so two STANDALONE processes can't race each
+ *     other (the daemon check only covers the daemon). Stale locks (dead pid)
+ *     are reclaimed.
+ *
+ * The daemon port and state-dir conventions are DUPLICATED from
+ * `packages/client-mcp/src/daemon/config.ts` (default port 8787 /
+ * `TOON_CLIENT_HTTP_PORT`; `~/.toon-client` / `TOON_CLIENT_HOME`).
+ * `@toon-protocol/git` must not depend on `@toon-protocol/client-mcp`
+ * (the daemon package depends on this one for the #227 Publisher — the
+ * import would be circular), so the constants live here with this note.
+ * Keep them in sync.
+ */
+/** Default toon-clientd loopback control API port (client-mcp `httpPort`). */
+declare const DEFAULT_DAEMON_PORT = 8787;
+/** Daemon control API port: `TOON_CLIENT_HTTP_PORT` env, else 8787. */
+declare function defaultDaemonPort(): number;
+/**
+ * Shared client state dir: `TOON_CLIENT_HOME` env, else `~/.toon-client` —
+ * the same dir the daemon keeps its config/channel stores in, so daemon and
+ * standalone processes agree on where the advisory locks live.
+ */
+declare function defaultLockDir(): string;
+/** A running toon-clientd holds the same identity (channel watermark owner). */
+declare class DaemonIdentityConflictError extends Error {
+    /** The shared Nostr pubkey (hex). */
+    readonly pubkey: string;
+    /** The daemon control API URL that answered. */
+    readonly daemonUrl: string;
+    constructor(
+    /** The shared Nostr pubkey (hex). */
+    pubkey: string, 
+    /** The daemon control API URL that answered. */
+    daemonUrl: string);
+}
+/** Another standalone process already holds the per-identity lock. */
+declare class StandaloneLockError extends Error {
+    readonly pubkey: string;
+    readonly lockPath: string;
+    readonly holderPid: number;
+    constructor(pubkey: string, lockPath: string, holderPid: number);
+}
+interface CheckDaemonOptions {
+    /** Control API port (default: `TOON_CLIENT_HTTP_PORT` env, else 8787). */
+    port?: number;
+    /** Probe timeout, ms (default 1500 — loopback, so fast). */
+    timeoutMs?: number;
+    /** Inject a fetch implementation (tests). Defaults to global `fetch`. */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Probe the toon-clientd loopback control API and throw
+ * {@link DaemonIdentityConflictError} when a daemon responds on `/status`
+ * with `identity.nostrPubkey === pubkey`.
+ *
+ * Anything short of a positive identity match lets the caller proceed: no
+ * listener, a timeout, a non-JSON response (some other local service on the
+ * port), or a daemon on a DIFFERENT identity (its channels are keyed to its
+ * own pubkey — no shared watermark).
+ */
+declare function checkDaemonIdentity(pubkey: string, options?: CheckDaemonOptions): Promise<void>;
+interface AcquireLockOptions {
+    /** Directory the lockfile lives in (default: {@link defaultLockDir}). */
+    dir?: string;
+    /** Override the recorded pid (tests). Defaults to `process.pid`. */
+    pid?: number;
+}
+/**
+ * Exclusive advisory lock for one identity's payment-channel watermark.
+ *
+ * Acquired with an atomic `wx` create of `standalone-<pubkey>.lock` (JSON:
+ * pid + pubkey + timestamp) under the shared state dir. A pre-existing lock
+ * whose pid is dead (or whose contents are unreadable) is STALE and gets
+ * reclaimed; a live holder throws {@link StandaloneLockError}. Released
+ * explicitly via {@link release} and best-effort on process exit.
+ */
+declare class NonceLock {
+    readonly pubkey: string;
+    readonly lockPath: string;
+    private released;
+    private readonly exitHandler;
+    private constructor();
+    static acquire(pubkey: string, options?: AcquireLockOptions): Promise<NonceLock>;
+    /** Remove the lockfile and detach the exit hook. Idempotent. */
+    release(): void;
+}
+
+export { type AcquireLockOptions, type CheckDaemonOptions, DEFAULT_DAEMON_PORT, DaemonIdentityConflictError, NonceLock, type SignedNostrEvent, StandaloneLockError, StandalonePublishError, StandalonePublisher, type StandalonePublisherOptions, type ToonClientLike, checkDaemonIdentity, defaultDaemonPort, defaultLockDir, deriveRouteDestinations, extractArweaveTxId };

package/dist/standalone/index.js

@@ -0,0 +1,30 @@
+import {
+  StandalonePublishError,
+  StandalonePublisher,
+  deriveRouteDestinations,
+  extractArweaveTxId
+} from "../chunk-SBMFWVCP.js";
+import {
+  DEFAULT_DAEMON_PORT,
+  DaemonIdentityConflictError,
+  NonceLock,
+  StandaloneLockError,
+  checkDaemonIdentity,
+  defaultDaemonPort,
+  defaultLockDir
+} from "../chunk-LJA7PPZI.js";
+import "../chunk-M7O4SEVW.js";
+export {
+  DEFAULT_DAEMON_PORT,
+  DaemonIdentityConflictError,
+  NonceLock,
+  StandaloneLockError,
+  StandalonePublishError,
+  StandalonePublisher,
+  checkDaemonIdentity,
+  defaultDaemonPort,
+  defaultLockDir,
+  deriveRouteDestinations,
+  extractArweaveTxId
+};
+//# sourceMappingURL=index.js.map

package/dist/standalone/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}