@joe-broadhead/messaging 0.0.0-stage → 0.7.1

package/dist/types/testing/jelly-id.d.ts

@@ -0,0 +1,518 @@
+/**
+ * A Jelly ID issuer double, for tests only: the issuing side of Jelly's resource-token contract v1.1
+ * (`jelly-resource-token-contract-v1.1.md` §3-§5, §9-§11; design `docs/design/people-and-consent.md` §2.2, §3.7,
+ * §3.10, §11), with Jelly's change of 2026-11-05: an unbindable `cnf_jwk` is
+ * `400 {error: "invalid_target", detail: "invalid_cnf_jwk"}`, and a plain `invalid_target` (no `detail`) still
+ * means "no such resource".
+ *
+ * The directory tests (`packages/relay/test/directory/`) and the end-to-end suites (`test/e2e/`) import it by
+ * relative path; other repositories' tests import `@joe-broadhead/messaging/testing/jelly-id`, which carries it as tsc
+ * builds it (`test/doubles/tsconfig.json`). Production code never imports it. It loads only Node built-ins
+ * (`node:crypto`, `node:http`).
+ *
+ * What it serves, in process (`mint`, `events`, `jwks`, …) and over HTTP once `JellyIdDouble.start()` listens:
+ *
+ * | Route | Contract |
+ * |---|---|
+ * | `GET /.well-known/oauth-authorization-server` | §2: `jelly_resources`, `jelly_account_events` |
+ * | `GET /.well-known/jwks.json` | §4-§5: the current public keys; a key leaves `jwksDropMs` after a rotation |
+ * | `GET /.well-known/jwks-history.json` | §11: every key ever published, with `nbf`, `retired_at`, `revoked_at` |
+ * | `POST /hosts/<hostId>/resource-tokens` | §3: the mint, with a host's RFC 7523 assertion and an optional `cnf_jwk` |
+ * | `POST /resource/accounts/events` | §10: the deletion feed, with a service's assertion (§9) and a cursor |
+ * | `POST /resource/device/code` | v1.2 §12.1: a device client asks for a code (only while a resource has `device_sign_in`) |
+ * | `POST /resource/device/token` | v1.2 §12.3: the device polls for its `src: "device"` token |
+ * | `POST /hosts/<hostId>/wake` | Jelly's A5 (hey-jelly#36, 7 Nov): a service wakes a sleeping host with its `jelly-wake+jwt`, once per `jti` |
+ *
+ * Device sign-in (§12) behaves as Jelly's contract v1.2 §12 is built in hey-jelly
+ * (`backend/control/src/broker/resource-device-routes.ts` and `protocol/contracts/src/jelly-id-device-sign-in.ts`, at
+ * the commit `jelly-device-sign-in.md` beside this file cites): the same answers, in the same order of checks, and
+ * never a `verification_uri_complete`. The consent page of §12.2 is in process: `consentPage(code, {account})` and
+ * `decide(code, {account}, "approve" | "deny")` (or `approve(code, account)`), as the person signed in at Jelly ID,
+ * having typed the code. `jelly-id-device.test.ts` checks the double against that excerpt's tables.
+ *
+ * Time comes from `options.now` (milliseconds), so a test can rotate a key, age a cursor past retention or let a
+ * token expire without waiting: `manualClock()` gives one.
+ *
+ * Test-only powers a real issuer does not have, for adversarial cases: `sign()` signs any header and claims with
+ * any key the double ever held (a "stolen" retired key), `mint()` takes `iat` and `kid` overrides, and `fail()`
+ * makes a route answer an error. `requests` records method, path and status of every HTTP request, never a body
+ * or a header (the bodies carry assertions and tokens).
+ */
+import { type KeyObject } from "node:crypto";
+export declare const RESOURCE_TOKEN_TYP = "jelly-resource+jwt";
+export declare const JWT_BEARER = "urn:ietf:params:oauth:client-assertion-type:jwt-bearer";
+/** §4: `exp = iat + 600`. */
+export declare const TOKEN_TTL_S = 600;
+/** §3: more than 120 tokens for one host in an hour is `429 slow_down`. */
+export declare const MINTS_PER_HOUR = 120;
+/** §9: a service assertion lives at most 300 s; times hold with 60 s of leeway. */
+export declare const ASSERTION_MAX_S = 300;
+export declare const LEEWAY_S = 60;
+/** §10: an event is served once it is 60 s old; events and cursors are kept 90 days; at most 100 an answer. */
+export declare const FEED_DELAY_MS = 60000;
+export declare const FEED_RETENTION_MS: number;
+export declare const FEED_PAGE = 100;
+/** §11: `jwks.json` drops a key about ten minutes after a rotation. */
+export declare const JWKS_DROP_MS: number;
+/** Jelly's contract v1.2 §12 (`jelly-device-sign-in.md` beside this file): a service's device signs in through the browser. */
+export declare const DEVICE_GRANT = "urn:ietf:params:oauth:grant-type:device_code";
+/** §12.1, §12.6: a code lives 600 s; the device polls every 5 s, and each `slow_down` adds 5 s to the code's interval. */
+export declare const DEVICE_CODE_TTL_S = 600;
+export declare const DEVICE_INTERVAL_S = 5;
+export declare const SLOW_DOWN_STEP_S = 5;
+/** §12.6: the limits. Approvals are counted per account and resource (Jelly's `approve:<account>:<resource>` window). */
+export declare const DEVICE_CODES_PER_ADDRESS_HOUR = 10;
+export declare const DEVICE_CODES_WAITING_PER_CLIENT = 1000;
+export declare const DEVICE_APPROVALS_PER_ACCOUNT_RESOURCE_DAY = 5;
+/** §12.2: the page and the decision need a Jelly ID sign-in of the last 15 minutes. */
+export declare const RECENT_SIGN_IN_MS: number;
+export declare const LINK_ATTEMPTS = 10;
+export declare const LINK_WINDOW_MS: number;
+/** §9: a service's `jwks_uri` is believed for an hour, refetched for an unknown `kid` at most once a minute. */
+export declare const SERVICE_JWKS_TTL_MS = 3600000;
+export declare const SERVICE_JWKS_REFETCH_MS = 60000;
+export declare const b64u: (bytes: Uint8Array | string) => string;
+/** A clock a test moves by hand. */
+export interface ManualClock {
+    (): number;
+    advance(ms: number): number;
+    set(ms: number): number;
+}
+export declare function manualClock(start?: number): ManualClock;
+export interface Jwk {
+    kty: "OKP";
+    crv: "Ed25519";
+    x: string;
+    kid?: string;
+    alg?: "EdDSA";
+    use?: "sig";
+}
+/** A bare public `cnf` key: exactly `{kty, crv, x}` (§3). */
+export interface CnfJwk {
+    kty: "OKP";
+    crv: "Ed25519";
+    x: string;
+}
+export interface Ed25519Pair {
+    privateKey: KeyObject;
+    publicKey: KeyObject;
+    /** The raw public key, base64url: a DeviceId when this pair is a device. */
+    x: string;
+}
+export declare function ed25519(): Ed25519Pair;
+/** The `cnf_jwk` for a device's raw public key (base64url), as the plugin passes it to `token(name, {cnf})`. */
+export declare const cnfOf: (x: string) => CnfJwk;
+/** RFC 7638 thumbprint of an OKP key. */
+export declare function thumbprint(jwk: CnfJwk): string;
+/**
+ * §12.3: a key's fingerprint as the consent page shows it: the first six bytes of its RFC 7638 thumbprint, in
+ * lower-case hex, in three groups of four (`3fa9-1c07-e2b4`).
+ */
+export declare function keyFingerprint(x: string): string;
+/** A compact JWS signed with Ed25519 over `b64u(header).b64u(payload)`. */
+export declare function signJwt(header: Record<string, unknown>, claims: Record<string, unknown>, key: KeyObject): string;
+export interface DecodedJwt {
+    header: Record<string, unknown>;
+    claims: Record<string, unknown>;
+    input: string;
+    signature: Buffer;
+}
+/** Splits a compact JWS. Returns undefined for anything that is not three base64url segments of JSON objects. */
+export declare function decodeJwt(token: string): DecodedJwt | undefined;
+/** Why 32 bytes are not a bindable Ed25519 public key, or undefined when they are. */
+export declare function pointProblem(bytes: Uint8Array): string | undefined;
+/** Why a `cnf_jwk` is not bindable (§3), or undefined when it is. Takes the form value (JSON text) or an object. */
+export declare function cnfProblem(value: unknown): string | undefined;
+export interface ResourceEntry {
+    /** `^[a-z][a-z0-9-]{0,31}$`: the name plugins ask for and the service's client id (§1, §9). */
+    name: string;
+    /** The token audience, e.g. `https://msg.toqanjelly.ai`. */
+    resource: string;
+    url: string;
+    /** §1, §9: the service's own public keys, inline (one or two, each with a `kid`). */
+    jwks?: {
+        keys: Jwk[];
+    };
+    /** §9: or an https URL to read them from (the double also accepts `http://127.0.0.1…`). */
+    jwks_uri?: string;
+    /** v1.2 §1, §12: this resource's device client may sign in through the browser. Default false. */
+    device_sign_in?: boolean;
+}
+/** One code of §12.1, as the double keeps it (Jelly keeps both codes hashed). */
+export interface DeviceCode {
+    deviceCode: string;
+    userCode: string;
+    clientId: string;
+    resource: string;
+    cnf: CnfJwk;
+    label: string;
+    kind: string;
+    address: string;
+    /** Ms. */
+    createdAt: number;
+    expiresAt: number;
+    /** Seconds; grows by 5 on each `slow_down`. */
+    interval: number;
+    lastPoll?: number;
+    decision?: {
+        approved: true;
+        account: Account;
+    } | {
+        approved: false;
+    };
+    /** An approval collected (or refused at the exchange's live check): spent once. A denial is never spent. */
+    consumed: boolean;
+}
+/** What the consent page of §12.2 shows for a code. */
+export interface ConsentPage {
+    service: {
+        name: string;
+        url: string;
+    };
+    device: {
+        label: string;
+        kind: string;
+    };
+    fingerprint: string;
+    userCode: string;
+    account: string;
+    asked: {
+        at: string;
+        address: string;
+    };
+    says: string;
+}
+export interface Account {
+    sub: string;
+    email?: string;
+    emailVerified: boolean;
+    name?: string;
+    state: "active" | "disabled" | "deleting" | "purged";
+}
+export interface Host {
+    id: string;
+    account: Account;
+    key: Ed25519Pair;
+    removed: boolean;
+}
+export interface IssuerKey {
+    kid: string;
+    key: Ed25519Pair;
+    /** Seconds: when it was first published. */
+    nbf: number;
+    /** Ms: when another key took over signing; the key leaves `jwks.json` `jwksDropMs` later. */
+    rotatedAt?: number;
+    /** Ms: when it left `jwks.json` (set by `retire`, or derived from `rotatedAt`). */
+    droppedAt?: number;
+    /** Seconds: when an operator revoked it. */
+    revokedAt?: number;
+}
+export interface AccountEvent {
+    id: string;
+    sub: string;
+    event: string;
+    /** ISO time of the purge. */
+    at: string;
+    /** Internal: the resource whose feed serves it, and the write order. */
+    resource: string;
+    seq: number;
+    atMs: number;
+}
+export interface Answer<T = Record<string, unknown>> {
+    status: number;
+    body: T;
+    headers: Record<string, string>;
+}
+export interface MintArgs {
+    host: Host | string;
+    resource: string;
+    /** The `cnf_jwk` form value: JSON text, or an object (serialized as given). */
+    cnf?: unknown;
+    /** Test-only: mint at another time (seconds). */
+    iat?: number;
+    /** Test-only: sign with this key (it must be one the double holds, current or not). */
+    kid?: string;
+}
+export type Route = "discovery" | "jwks" | "history" | "mint" | "events" | "device-code" | "device-token" | "wake";
+/** Jelly's A5: a `jelly-wake+jwt` lives at most seven days; a host is woken at most 6 times an hour and 48 a day. */
+export declare const WAKE_TICKET_MAX_S: number;
+export declare const WAKES_PER_HOUR = 6;
+export declare const WAKES_PER_DAY = 48;
+export interface JellyIdDoubleOptions {
+    /** Jelly ID's issuer origin. `start()` defaults it to the listening origin. */
+    issuer?: string;
+    resources?: ResourceEntry[];
+    /** Milliseconds since the epoch. Default `Date.now`. */
+    now?: () => number;
+    /** Start with no signing key: the mint answers `503 temporarily_unavailable`. */
+    noKeys?: boolean;
+    mintsPerHour?: number;
+    feedPage?: number;
+    feedDelayMs?: number;
+    feedRetentionMs?: number;
+    jwksDropMs?: number;
+    /** §12: the poll interval a code answers with (seconds, default 5) and a code's life (default 600). */
+    deviceIntervalS?: number;
+    deviceCodeTtlS?: number;
+}
+export interface RequestRecord {
+    method: string;
+    path: string;
+    status: number;
+}
+export declare class JellyIdDouble {
+    #private;
+    issuer: string;
+    readonly resources: ResourceEntry[];
+    readonly now: () => number;
+    readonly keys: IssuerKey[];
+    readonly accounts: Map<string, Account>;
+    readonly hosts: Map<string, Host>;
+    readonly events: AccountEvent[];
+    /** HTTP requests seen: method, path (no query) and status only. */
+    readonly requests: RequestRecord[];
+    /** resource → sub → first mint (ms): the scope of the deletion feed (§3, §10). */
+    readonly minted: Map<string, Map<string, number>>;
+    /** Every token the mint issued, for tests that must check a log never shows one. */
+    readonly issued: string[];
+    /** Hosts woken (A5): which, when (ms), and the ticket's `jti`. */
+    readonly wakes: {
+        host: string;
+        at: number;
+        jti: string;
+    }[];
+    /** §12: every code asked for, by `device_code`. */
+    readonly deviceCodes: Map<string, DeviceCode>;
+    constructor(options?: JellyIdDoubleOptions);
+    /** Listens on 127.0.0.1 (a free port unless given); the issuer is the origin unless `options.issuer` is set. */
+    static start(options?: JellyIdDoubleOptions, port?: number): Promise<JellyIdDouble>;
+    get origin(): string;
+    get jwksUri(): string;
+    get historyUri(): string;
+    get eventsUri(): string;
+    /** v1.2 §12: the routes of §12.1 and §12.3, and the consent page of §12.2. */
+    get deviceCodeUri(): string;
+    get deviceTokenUri(): string;
+    get linkUri(): string;
+    close(): Promise<void>;
+    /** The key that signs now: the newest one not dropped or revoked. */
+    get signer(): IssuerKey | undefined;
+    addKey(kid?: string): IssuerKey;
+    /** A new key takes over signing; the old one stays in `jwks.json` for `jwksDropMs`, then only in the history. */
+    rotate(kid?: string): IssuerKey;
+    /** Drops a key from `jwks.json` now: its `retired_at` is now. */
+    retire(kid: string): void;
+    /** An operator revokes a key (`JELLY_ID_REVOKED_KEYS`): `revoked_at` in the history, gone from `jwks.json`. */
+    revoke(kid: string, atSeconds?: number): void;
+    /** `jwks.json`: the published keys, newest (the signer) first. Never a private member. */
+    jwks(): {
+        keys: Jwk[];
+    };
+    /** `jwks-history.json` (§11): every key ever published, oldest first; it never shrinks. */
+    history(): {
+        keys: (Jwk & {
+            nbf: number;
+            retired_at: number | null;
+            revoked_at?: number;
+        })[];
+    };
+    /**
+     * The RFC 8414 metadata. Like Jelly ID's in production, it names `device_authorization_endpoint`: the route that
+     * enrols *hosts* with a host's assertion (`/device/code`), which a service's device must not take for §12. The
+     * double does not serve it. §12's own two members appear only when a resource has `device_sign_in` (v1.2 §2).
+     */
+    discovery(): Record<string, unknown>;
+    /** Test-only: signs anything with any key the double holds or held (a stolen key, a backdated token). */
+    sign(header: Record<string, unknown>, claims: Record<string, unknown>, kid?: string | undefined): string;
+    account(opts?: {
+        sub?: string;
+        email?: string;
+        name?: string;
+        emailVerified?: boolean;
+    }): Account;
+    /** Enrols a host owned by `account`, with its own Ed25519 key for its client assertions. */
+    host(account: Account, id?: string): Host;
+    /** The host's RFC 7523 client assertion (`iss = sub = hostId`, `aud` = the issuer). */
+    hostAssertion(host: Host, opts?: {
+        jti?: string;
+        iat?: number;
+        ttl?: number;
+        aud?: string;
+        key?: KeyObject;
+    }): string;
+    /**
+     * The host's wake ticket (Jelly's A5): a `jelly-wake+jwt` signed with its enrolled key, `iss` and `sub` the host, `aud`
+     * its wake URL, `svc` the service, a fresh `jti`, valid `ttl` seconds (default a day; Jelly allows seven).
+     */
+    wakeTicket(host: Host, opts?: {
+        svc?: string;
+        ttl?: number;
+        iat?: number;
+        jti?: string;
+        aud?: string;
+        key?: KeyObject;
+        typ?: string;
+    }): string;
+    /** `<issuer>/hosts/<id>/wake`. */
+    wakeUrl(host: Host | string): string;
+    /**
+     * `POST /hosts/<hostId>/wake` as Jelly ID answers it (A5): `202` wakes the host and spends the ticket's `jti`; `401`
+     * for a ticket that is not this host's, has expired or was spent; `404` for no such host; `429` with `Retry-After`
+     * past the host's budget (6 an hour, 48 a day); `503` (by `fail("wake")`) spends nothing.
+     */
+    wake(hostId: string, form: URLSearchParams): Answer;
+    disable(account: Account): void;
+    /** The person asks to delete: no more tokens (§10, "From the request on…"). No event yet. */
+    requestDeletion(account: Account): void;
+    /** The grace period ends: `account.deleted` for every service the account was minted a token for (§10). */
+    purge(account: Account): AccountEvent[];
+    /** Test-only: writes any event (an unknown kind, an unknown person) into one service's feed. */
+    emit({ sub, resource, event, atMs }: {
+        sub: string;
+        resource: string;
+        event?: string;
+        atMs?: number;
+    }): AccountEvent;
+    /** A service key pair and its public JWK (with `kid`), for `ResourceEntry.jwks` and `serviceAssertion`. */
+    static serviceKey(kid?: string): {
+        kid: string;
+        pair: Ed25519Pair;
+        jwk: Jwk;
+    };
+    /** A service's RFC 7523 assertion (§9): `iss = sub = name`, `aud` = the issuer. */
+    serviceAssertion(name: string, key: {
+        kid: string;
+        pair: Ed25519Pair;
+    }, opts?: {
+        jti?: string;
+        iat?: number;
+        ttl?: number;
+        aud?: string;
+        iss?: string;
+        sub?: string;
+    }): string;
+    /** The next `times` requests to `route` answer `status` with `body` (default a `temporarily_unavailable`). */
+    fail(route: Route, status?: number, body?: Record<string, unknown>, times?: number): void;
+    /**
+     * The mint as the HTTP route answers it, with the host's assertion checked (§3). `mint()` skips the assertion;
+     * use this to test `invalid_client`.
+     */
+    mintWithAssertion(hostId: string, form: URLSearchParams): Answer;
+    /** Mints as an enrolled, owned host asked for it (the assertion is assumed good). */
+    mint(args: MintArgs): Answer;
+    /** `mint()` that returns the token or throws with the error code (and detail). */
+    token(args: MintArgs): string;
+    /** The deletion feed as the HTTP route answers it (§10). */
+    accountEvents(form: URLSearchParams): Promise<Answer>;
+    /**
+     * `POST /resource/device/code` (§12.1) as Jelly's route answers it, in its order of checks: every field present
+     * (a repeated one is missing), the client, the resource, the key, the label and kind, then the per-address and
+     * per-client limits. `address` is the client's address, for the per-address limit. Never `verification_uri_complete`.
+     */
+    deviceAuthorize(form: URLSearchParams, address?: string): Answer;
+    /**
+     * The consent page of §12.2 for the person signed in as `account` (in `session`, signed in at `signedInAt`, default
+     * now), who typed `code` (`from: "typed"`, the default) or arrived with it from `/link?code=` (`from: "link"`). Errors:
+     * `account_inactive` (the live check), `type_the_code` (a code from a link is asked for again: "A sign-in code for a
+     * device cannot come from a link"), `sign_in_again` (a sign-in older than 15 minutes), `too_many_codes` (10 wrong
+     * codes in 15 minutes), `code_invalid` (unknown, decided or expired: "That code didn't work").
+     */
+    consentPage(code: string, as: {
+        account: Account;
+        session?: string;
+        signedInAt?: number;
+        from?: "typed" | "link";
+    }): {
+        status: 200;
+        page: ConsentPage;
+    } | {
+        status: number;
+        error: string;
+    };
+    /**
+     * The person's decision on the consent page (`POST /link/device`, §12.2): `approve` or `deny`, once per code. Errors
+     * as `consentPage`, and `too_many_sign_ins` when the account approved 5 sign-ins to this resource in the day's window
+     * (§12.6): nothing is decided then, and the code waits on until it expires.
+     */
+    decide(code: string, as: {
+        account: Account;
+        session?: string;
+        signedInAt?: number;
+    }, decision: "approve" | "deny"): {
+        status: 200;
+        decided: "approved" | "denied";
+    } | {
+        status: number;
+        error: string;
+    };
+    /** The person approves the code a device shows (test shorthand); throws on a refusal. */
+    approve(code: string, account: Account): void;
+    /**
+     * A whole sign-in through the browser in process (§12.1-§12.3): a code for `cnf` from `client` (the resource's
+     * name), approved by `account`, exchanged once. Returns the `src: "device"` token, or throws with the error code.
+     */
+    signInToken(args: {
+        account: Account;
+        cnf: CnfJwk;
+        client?: string;
+        label?: string;
+        kind?: string;
+    }): string;
+    /**
+     * `POST /resource/device/token` (§12.3) as Jelly's route answers it, in its order of checks: the grant type, the
+     * client, the code (recording the poll: one sooner than the code's interval grows it by 5 s), the code's client,
+     * spent, denied, expired (decided or not), undecided (`slow_down` when early, else `authorization_pending`), then
+     * the approval is spent and the account checked live. A repeated field is a missing one.
+     */
+    deviceToken(form: URLSearchParams): Answer;
+    /** The waiting or decided code whose `user_code` (as shown) is `shown`. */
+    codeOf(shown: string): DeviceCode | undefined;
+}
+/** `POST <issuer>/hosts/<hostId>/resource-tokens` as a host sends it (§3). */
+export declare function requestToken(double: JellyIdDouble, host: Host, resource: string, cnf?: unknown, assertion?: string): Promise<{
+    status: number;
+    body: Record<string, unknown>;
+    cacheControl: string | null;
+}>;
+/** `POST <issuer>/resource/accounts/events` as a service sends it (§10). */
+export declare function requestEvents(double: JellyIdDouble, assertion: string, cursor?: string): Promise<{
+    status: number;
+    body: Record<string, unknown>;
+    cacheControl: string | null;
+}>;
+/** `POST <issuer>/resource/device/code` (§12.2). */
+export declare function requestDeviceCode(double: JellyIdDouble, fields: Record<string, string | string[]>): Promise<{
+    status: number;
+    body: Record<string, unknown>;
+    cacheControl: string | null;
+}>;
+/** `POST <issuer>/resource/device/token` (§12.4). */
+export declare function requestDeviceToken(double: JellyIdDouble, fields: Record<string, string | string[]>): Promise<{
+    status: number;
+    body: Record<string, unknown>;
+    cacheControl: string | null;
+}>;
+export type AccessorErrorCode = "unavailable" | "not_enrolled" | "access_denied" | "invalid_target" | "invalid_request";
+export interface JellyIdentityAccessor {
+    resources(): ReadonlyArray<{
+        name: string;
+        resource: string;
+        url: string;
+    }>;
+    token(name: string, options?: {
+        cnf?: CnfJwk;
+    }): Promise<{
+        accessToken: string;
+        expiresAt: number;
+    }>;
+}
+/**
+ * The accessor as Jelly's core plugin offers it on `host` (§6): tokens cached until 60 s before `exp`, single-flight
+ * per resource and bound key (RFC 7638 thumbprint, or none), and a token bound to one key never handed out for
+ * another key or for none. Rejections carry `code` (and, for an unbindable key, `detail: "invalid_cnf_jwk"`).
+ * `install()` puts it on `globalThis[Symbol.for("jelly.identity")]` and returns the undo.
+ */
+export declare function identityAccessor(double: JellyIdDouble, host: Host | undefined): JellyIdentityAccessor & {
+    install(): () => void;
+    mints: number;
+};

package/dist/types/zod.d.ts

@@ -0,0 +1 @@
+export * from "zod";

package/package.json

@@ -1,6 +1,79 @@
 {
   "name": "@joe-broadhead/messaging",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.7.1",
+  "description": "Messaging: the relay, the per-machine daemon and its CLI, and the MCP server as bundled single files, plus the client libraries and the protocol spec. Zero dependencies.",
+  "type": "module",
+  "license": "MIT",
+  "author": "Joe Broadhead",
+  "homepage": "https://github.com/joe-broadhead/messaging/tree/main/packages/messaging#readme",
+  "bugs": {
+    "url": "https://github.com/joe-broadhead/messaging/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/joe-broadhead/messaging.git",
+    "directory": "packages/messaging"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "a2a",
+    "agent-to-agent",
+    "messaging",
+    "mcp"
+  ],
+  "engines": {
+    "node": ">=22.15.0"
+  },
+  "sideEffects": false,
+  "bin": {
+    "messaging": "./dist/bin/messaging.js",
+    "messagingd": "./dist/bin/messagingd.js",
+    "messaging-relay": "./dist/bin/messaging-relay.js",
+    "messaging-mcp": "./dist/bin/messaging-mcp.js"
+  },
+  "exports": {
+    "./core": {
+      "types": "./dist/types/core/index.d.ts",
+      "default": "./dist/lib/core.js"
+    },
+    "./core/testing": {
+      "types": "./dist/types/core/testing.d.ts",
+      "default": "./dist/lib/core-testing.js"
+    },
+    "./ipc": {
+      "types": "./dist/types/ipc/index.d.ts",
+      "default": "./dist/lib/ipc.js"
+    },
+    "./ipc/testing": {
+      "types": "./dist/types/ipc/testing.d.ts",
+      "default": "./dist/lib/ipc-testing.js"
+    },
+    "./testing/jelly-id": {
+      "types": "./dist/types/testing/jelly-id.d.ts",
+      "default": "./dist/lib/testing-jelly-id.js"
+    },
+    "./zod": {
+      "types": "./dist/types/zod.d.ts",
+      "default": "./dist/lib/zod.js"
+    },
+    "./bin/messaging.js": "./dist/bin/messaging.js",
+    "./bin/messagingd.js": "./dist/bin/messagingd.js",
+    "./spec/messaging-v1.md": "./dist/spec/messaging-v1.md",
+    "./third-party.json": "./dist/third-party.json",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/bin/*.js",
+    "dist/lib/**/*.js",
+    "dist/types/**/*.d.ts",
+    "dist/spec/messaging-v1.md",
+    "dist/third-party.json",
+    "dist/third-party-notices.md",
+    "README.md",
+    "LICENSE",
+    "NOTICE",
+    "CHANGELOG.md"
+  ]
+}