@macula-io/ts 0.18.0 → 0.20.0

package/dist/directdial.d.ts

@@ -1,79 +0,0 @@
-import type { CallOptions, Session } from "./session.js";
-/** What Session.resolveDirect() resolves with: `procedure`'s
- * currently-advertised serving station and its dialable host/port
- * (macula-go's `directdial.Resolve`). */
-export interface DirectDialTarget {
-    /** Hex-encoded, 32 bytes: the resolved station's NodeID (Ed25519
-     * public key) -- the SAME identity Session.callDirect()/
-     * callDirectWithUcan() pin the one-hop dial against internally before
-     * trusting it. */
-    readonly station: string;
-    readonly host: string;
-    readonly port: number;
-}
-/** Options for Session.advertiseDirect(). */
-export interface AdvertiseDirectOptions {
-    /** Same 64-character hex realm convention as CallOptions.realm --
-     * MUST match whatever realm resolveDirect()/callDirect()/
-     * callDirectWithUcan() (or the Erlang/Rust/Go equivalent) resolve
-     * under, or the two sides derive a different discovery URI and resolve
-     * comes back exactly as if this was never called at all (see
-     * directdial.go's own DiscoveryURI note). Omitted means the all-zero
-     * realm, this SDK's sole default before this option existed. */
-    realm?: string;
-    /** Milliseconds. Defaults to DHT_DEFAULT_TTL_MS (48h) -- matches
-     * macula-go's own dht.DefaultTTL, applied Go-side for ttlMs<=0 (not
-     * duplicated as a second default here; this SDK's default is threaded
-     * through explicitly instead, matching putProcedureAdvertisement's own
-     * convention). */
-    ttlMs?: number;
-}
-/** How long keepAdvertisedDirect() waits between re-advertise ticks, in
- * milliseconds, when opts.intervalMs is left unset. This is a real
- * production margin against AdvertiseDirectOptions' own 48h default TTL
- * actually expiring between ticks -- not chosen to match macula-go's own
- * KeepAdvertisedDirect live-test interval (1s there, only to keep that
- * particular test fast). A caller passing a much shorter `ttlMs` should
- * pass a correspondingly shorter `intervalMs` too; this constant does not
- * scale itself to `opts.ttlMs`. */
-export declare const KEEP_ADVERTISED_DIRECT_INTERVAL_MS: number;
-/** Options for keepAdvertisedDirect(). */
-export interface KeepAdvertisedDirectOptions extends AdvertiseDirectOptions {
-    /** Milliseconds between re-advertise ticks. Defaults to
-     * KEEP_ADVERTISED_DIRECT_INTERVAL_MS. */
-    intervalMs?: number;
-    /** Called with a tick's own thrown error when a re-advertise tick
-     * fails -- a network blip, a genuinely dead session, etc. Matches
-     * macula-go's own KeepAdvertisedDirect: a failed tick is reported, not
-     * fatal -- this loop tries again at the next interval regardless, and
-     * cannot detect or repair a dead Session on its own (a separate, larger
-     * concern this does not attempt to solve). Omit to drop the error
-     * silently. */
-    onError?: (err: unknown) => void;
-}
-/** Re-advertises `procedure` as direct-dial-reachable on `session` (via
- * `session.advertiseDirect()`) immediately, then again every
- * `opts.intervalMs`, until the returned `stop()` is called -- macula-go's
- * own `KeepAdvertisedDirect` free function, ported here as a standalone
- * helper rather than a Session method for the identical reason
- * macula-go's own is a free function taking a `*connection.Session`
- * rather than a method on one: a station's registration for a procedure
- * does not survive the connection that sent it being replaced, so a
- * long-lived provider needs to call `AdvertiseDirect` again on its own
- * schedule, and it is this function's CALLER's job to decide WHICH
- * Session that runs on. See `Session.advertiseDirect()`'s own doc for why
- * that must NOT be a Session with an active `serve()` on it
- * (`advertiseDirect()`'s own `PutRecord` CALL would race `serve()`'s own
- * reads of the same shared control stream): a long-lived provider that
- * also serves `procedure` needs a SEPARATE Session (and identity -- this
- * fleet enforces one connection per identity, kicking whichever connects
- * second) for that, passed here instead of the serving Session.
- *
- * The returned `stop()` is synchronous -- unlike `Session.serve()`'s own
- * async `stop()`, there is no pending tick to wait out and no unadvertise
- * step: `advertiseDirect()`'s own DHT record simply expires on its own
- * TTL once ticks stop, matching macula-go's own `KeepAdvertisedDirect`,
- * which has no corresponding "undo" either. Calling `stop()` more than
- * once is a no-op. */
-export declare function keepAdvertisedDirect(session: Session, procedure: string, opts?: KeepAdvertisedDirectOptions): () => void;
-export type { CallOptions };

package/dist/directdial.js

@@ -1,76 +0,0 @@
-// Direct-dial: caller-side resolve+one-hop-call and provider-side
-// advertise-direct, built on macula-go's directdial package (see
-// cabi/directdial.go's own doc for the trust model -- every candidate
-// procedure_advertisement must carry a valid signature before its
-// serving_station is trusted at all, the resolved station_endpoint must
-// be signed by the station itself, and after the one-hop dial -- which
-// trusts neither the TLS certificate nor nothing -- the freshly connected
-// peer's own HELLO-proven identity is checked against the exact pubkey
-// the signed DHT chain resolved, application-layer pinning instead of
-// relying on the dial's own TLS -- and for why AdvertiseDirect publishes
-// BOTH a plain ADVERTISE and a signed procedure_advertisement DHT record:
-// skipping the plain ADVERTISE lets resolve+dial complete cleanly against
-// a station with nothing registered to route the CALL to, a real bug
-// macula-go fixed live 2026-08-30). The actual FFI plumbing lives on
-// Session (session.ts's resolveDirect/callDirect/callDirectWithUcan/
-// advertiseDirect), matching this SDK's own call()/serve() split; this
-// file holds the shapes those share, plus keepAdvertisedDirect -- a
-// standalone helper mirroring macula-go's own free-function
-// KeepAdvertisedDirect, not a Session method (see its own doc for why).
-/** How long keepAdvertisedDirect() waits between re-advertise ticks, in
- * milliseconds, when opts.intervalMs is left unset. This is a real
- * production margin against AdvertiseDirectOptions' own 48h default TTL
- * actually expiring between ticks -- not chosen to match macula-go's own
- * KeepAdvertisedDirect live-test interval (1s there, only to keep that
- * particular test fast). A caller passing a much shorter `ttlMs` should
- * pass a correspondingly shorter `intervalMs` too; this constant does not
- * scale itself to `opts.ttlMs`. */
-export const KEEP_ADVERTISED_DIRECT_INTERVAL_MS = 15 * 60 * 1000;
-/** Re-advertises `procedure` as direct-dial-reachable on `session` (via
- * `session.advertiseDirect()`) immediately, then again every
- * `opts.intervalMs`, until the returned `stop()` is called -- macula-go's
- * own `KeepAdvertisedDirect` free function, ported here as a standalone
- * helper rather than a Session method for the identical reason
- * macula-go's own is a free function taking a `*connection.Session`
- * rather than a method on one: a station's registration for a procedure
- * does not survive the connection that sent it being replaced, so a
- * long-lived provider needs to call `AdvertiseDirect` again on its own
- * schedule, and it is this function's CALLER's job to decide WHICH
- * Session that runs on. See `Session.advertiseDirect()`'s own doc for why
- * that must NOT be a Session with an active `serve()` on it
- * (`advertiseDirect()`'s own `PutRecord` CALL would race `serve()`'s own
- * reads of the same shared control stream): a long-lived provider that
- * also serves `procedure` needs a SEPARATE Session (and identity -- this
- * fleet enforces one connection per identity, kicking whichever connects
- * second) for that, passed here instead of the serving Session.
- *
- * The returned `stop()` is synchronous -- unlike `Session.serve()`'s own
- * async `stop()`, there is no pending tick to wait out and no unadvertise
- * step: `advertiseDirect()`'s own DHT record simply expires on its own
- * TTL once ticks stop, matching macula-go's own `KeepAdvertisedDirect`,
- * which has no corresponding "undo" either. Calling `stop()` more than
- * once is a no-op. */
-export function keepAdvertisedDirect(session, procedure, opts = {}) {
-    const intervalMs = opts.intervalMs ?? KEEP_ADVERTISED_DIRECT_INTERVAL_MS;
-    let stopped = false;
-    const tick = () => {
-        session.advertiseDirect(procedure, { realm: opts.realm, ttlMs: opts.ttlMs }).catch((err) => {
-            opts.onError?.(err);
-        });
-    };
-    tick();
-    const timer = setInterval(tick, intervalMs);
-    // Node keeps the event loop alive for a pending timer by default --
-    // unref() so a program that starts this loop with nothing else keeping
-    // it running (no active serve()/subscribe()/etc. elsewhere) can still
-    // exit on its own; a real, still-open Session doing other work keeps
-    // the process alive on its own merits regardless, unaffected by this.
-    timer.unref?.();
-    return () => {
-        if (stopped)
-            return;
-        stopped = true;
-        clearInterval(timer);
-    };
-}
-//# sourceMappingURL=directdial.js.map

package/dist/directdial.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"directdial.js","sourceRoot":"","sources":["../src/directdial.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,iEAAiE;AACjE,sEAAsE;AACtE,kEAAkE;AAClE,wEAAwE;AACxE,uEAAuE;AACvE,0EAA0E;AAC1E,uEAAuE;AACvE,sEAAsE;AACtE,yEAAyE;AACzE,0EAA0E;AAC1E,0EAA0E;AAC1E,qEAAqE;AACrE,qEAAqE;AACrE,qEAAqE;AACrE,uEAAuE;AACvE,oEAAoE;AACpE,4DAA4D;AAC5D,wEAAwE;AAmCxE;;;;;;;mCAOmC;AACnC,MAAM,CAAC,MAAM,kCAAkC,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAiBjE;;;;;;;;;;;;;;;;;;;;;;;sBAuBsB;AACtB,MAAM,UAAU,oBAAoB,CAAC,OAAgB,EAAE,SAAiB,EAAE,IAAI,GAAgC,EAAE;IAC9G,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,IAAI,kCAAkC,CAAC;IACzE,IAAI,OAAO,GAAG,KAAK,CAAC;IAEpB,MAAM,IAAI,GAAG,GAAS,EAAE;QACtB,OAAO,CAAC,eAAe,CAAC,SAAS,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,GAAY,EAAE,EAAE;YAClG,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC;QACtB,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;IAEF,IAAI,EAAE,CAAC;IACP,MAAM,KAAK,GAAG,WAAW,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IAC5C,oEAAoE;IACpE,uEAAuE;IACvE,sEAAsE;IACtE,qEAAqE;IACrE,sEAAsE;IACtE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC;IAEhB,OAAO,GAAS,EAAE;QAChB,IAAI,OAAO;YAAE,OAAO;QACpB,OAAO,GAAG,IAAI,CAAC;QACf,aAAa,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC,CAAC;AACJ,CAAC"}

package/dist/identity.d.ts

@@ -1,43 +0,0 @@
-import { type Handle } from "./binding.js";
-export declare class Identity {
-    #private;
-    private constructor();
-    /** Mints a fresh identity, grinding an Ed25519 keypair until its
-     * NodeID's SHA-256 has the required S/Kademlia puzzle difficulty
-     * (macula-go's DefaultPuzzleDifficulty = 8 leading zero bits). This
-     * is real work done on the Go side -- not instant, not mocked. */
-    static generate(): Identity;
-    /** Reconstructs an identity from a previously-saved 32-byte Ed25519
-     * seed. Deterministic: does not re-grind the puzzle (a seed that
-     * already satisfied it at generation time still does). */
-    static fromSeedBytes(seed32: Uint8Array): Identity;
-    /** The 32-byte Ed25519 public key this identity is known by on the
-     * wire (CONNECT/HELLO's node_id field). */
-    get nodeId(): Uint8Array;
-    /** The 32-byte Ed25519 seed -- persist this (e.g. to a 0600 file)
-     * to reconstruct the identity later via fromSeedBytes. Treat as a
-     * private key: anyone with this seed can sign as this identity. */
-    get privateSeedBytes(): Uint8Array;
-    /** Signs data with this identity's private key (Ed25519, via
-     * macula-go's identity.KeyPair.Sign -- a direct ed25519.Sign wrapper)
-     * and returns the raw 64-byte signature. This is a generic signing
-     * primitive: no application-specific message format is baked in
-     * here or on the Go side -- data is signed exactly as given, byte
-     * for byte. A caller that needs a particular byte-layout convention
-     * (e.g. an ownership-proof format binding this signature to some
-     * other value) builds those bytes itself and passes the result in;
-     * that convention is the caller's concern, not this method's.
-     * Deterministic: signing the same data twice with the same identity
-     * produces the same signature (Ed25519 has no per-signature nonce
-     * randomness the way ECDSA does). */
-    sign(data: Uint8Array): Uint8Array;
-    /** Frees the Go-side handle. Safe to call more than once. */
-    dispose(): void;
-    /** The raw native handle, for Session.connect/close only -- they need
-     * it to establish/close a connection under this identity. JS private
-     * fields (#handle) are genuinely inaccessible from outside this
-     * class body, even to other code in this package, so this method is
-     * how Session and Identity cooperate across the FFI boundary. Not
-     * part of the intended public API. */
-    handleForFfi(): Handle;
-}

package/dist/identity.js

@@ -1,83 +0,0 @@
-// Public identity API -- the one real capability this walking
-// skeleton proves end-to-end: minting a Macula peer identity (an
-// Ed25519 keypair, S/Kademlia puzzle-hardened) via macula-go's own
-// identity.Generate(), reached through cabi/'s FFI boundary rather
-// than reimplemented here.
-//
-// An Identity wraps a Go-side handle. It is a disposable, freeable
-// resource: call dispose() when done with it (or let the process
-// exit -- the Go side doesn't leak across a process lifetime, but a
-// long-running host process minting many identities should dispose
-// each one). There is no finalizer/GC integration in this skeleton;
-// forgetting to call dispose() leaks the Go-side handle for the life
-// of the process, exactly as macula-php's identical handle-based
-// design does.
-import { native } from "./binding.js";
-export class Identity {
-    #handle;
-    constructor(handle) {
-        this.#handle = handle;
-    }
-    /** Mints a fresh identity, grinding an Ed25519 keypair until its
-     * NodeID's SHA-256 has the required S/Kademlia puzzle difficulty
-     * (macula-go's DefaultPuzzleDifficulty = 8 leading zero bits). This
-     * is real work done on the Go side -- not instant, not mocked. */
-    static generate() {
-        return new Identity(native.identityGenerate());
-    }
-    /** Reconstructs an identity from a previously-saved 32-byte Ed25519
-     * seed. Deterministic: does not re-grind the puzzle (a seed that
-     * already satisfied it at generation time still does). */
-    static fromSeedBytes(seed32) {
-        return new Identity(native.identityFromSeedBytes(seed32));
-    }
-    #requireHandle() {
-        if (this.#handle === null) {
-            throw new Error("macula-ts: Identity used after dispose()");
-        }
-        return this.#handle;
-    }
-    /** The 32-byte Ed25519 public key this identity is known by on the
-     * wire (CONNECT/HELLO's node_id field). */
-    get nodeId() {
-        return native.identityNodeId(this.#requireHandle());
-    }
-    /** The 32-byte Ed25519 seed -- persist this (e.g. to a 0600 file)
-     * to reconstruct the identity later via fromSeedBytes. Treat as a
-     * private key: anyone with this seed can sign as this identity. */
-    get privateSeedBytes() {
-        return native.identityPrivateBytes(this.#requireHandle());
-    }
-    /** Signs data with this identity's private key (Ed25519, via
-     * macula-go's identity.KeyPair.Sign -- a direct ed25519.Sign wrapper)
-     * and returns the raw 64-byte signature. This is a generic signing
-     * primitive: no application-specific message format is baked in
-     * here or on the Go side -- data is signed exactly as given, byte
-     * for byte. A caller that needs a particular byte-layout convention
-     * (e.g. an ownership-proof format binding this signature to some
-     * other value) builds those bytes itself and passes the result in;
-     * that convention is the caller's concern, not this method's.
-     * Deterministic: signing the same data twice with the same identity
-     * produces the same signature (Ed25519 has no per-signature nonce
-     * randomness the way ECDSA does). */
-    sign(data) {
-        return native.identitySign(this.#requireHandle(), data);
-    }
-    /** Frees the Go-side handle. Safe to call more than once. */
-    dispose() {
-        if (this.#handle !== null) {
-            native.identityFree(this.#handle);
-            this.#handle = null;
-        }
-    }
-    /** The raw native handle, for Session.connect/close only -- they need
-     * it to establish/close a connection under this identity. JS private
-     * fields (#handle) are genuinely inaccessible from outside this
-     * class body, even to other code in this package, so this method is
-     * how Session and Identity cooperate across the FFI boundary. Not
-     * part of the intended public API. */
-    handleForFfi() {
-        return this.#requireHandle();
-    }
-}
-//# sourceMappingURL=identity.js.map

package/dist/identity.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"identity.js","sourceRoot":"","sources":["../src/identity.ts"],"names":[],"mappings":"AAAA,8DAA8D;AAC9D,iEAAiE;AACjE,mEAAmE;AACnE,mEAAmE;AACnE,2BAA2B;AAC3B,EAAE;AACF,mEAAmE;AACnE,iEAAiE;AACjE,oEAAoE;AACpE,mEAAmE;AACnE,oEAAoE;AACpE,qEAAqE;AACrE,iEAAiE;AACjE,eAAe;AACf,OAAO,EAAE,MAAM,EAAe,MAAM,cAAc,CAAC;AAEnD,MAAM,OAAO,QAAQ;IACnB,OAAO,CAAgB;IAEvB,YAAoB,MAAc;QAChC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;IACxB,CAAC;IAED;;;sEAGkE;IAClE,MAAM,CAAC,QAAQ;QACb,OAAO,IAAI,QAAQ,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC,CAAC;IACjD,CAAC;IAED;;8DAE0D;IAC1D,MAAM,CAAC,aAAa,CAAC,MAAkB;QACrC,OAAO,IAAI,QAAQ,CAAC,MAAM,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC,CAAC;IAC5D,CAAC;IAED,cAAc;QACZ,IAAI,IAAI,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;QAC9D,CAAC;QACD,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED;+CAC2C;IAC3C,IAAI,MAAM;QACR,OAAO,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;IACtD,CAAC;IAED;;uEAEmE;IACnE,IAAI,gBAAgB;QAClB,OAAO,MAAM,CAAC,oBAAoB,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;IAC5D,CAAC;IAED;;;;;;;;;;;yCAWqC;IACrC,IAAI,CAAC,IAAgB;QACnB,OAAO,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,cAAc,EAAE,EAAE,IAAI,CAAC,CAAC;IAC1D,CAAC;IAED,6DAA6D;IAC7D,OAAO;QACL,IAAI,IAAI,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;YAC1B,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAClC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACtB,CAAC;IACH,CAAC;IAED;;;;;0CAKsC;IACtC,YAAY;QACV,OAAO,IAAI,CAAC,cAAc,EAAE,CAAC;IAC/B,CAAC;CACF"}

package/dist/pubsub.d.ts

@@ -1,60 +0,0 @@
-import type { BytesOutput, JsonValue } from "./rpc.js";
-/** Options for Session.publish(). */
-export interface PublishOptions {
-    /** How many milliseconds from now this event should live -- a
-     * DURATION, not a timestamp (matches every other ttlMs in this SDK,
-     * e.g. dht.ts's DHT_DEFAULT_TTL_MS) -- PublishSpec's own `ttl_ms`
-     * (frame/pubsub.go) is computed from this. Omitted means no TTL, not
-     * zero or an invented default -- macula-go's Publish has no fallback
-     * of its own for this field, unlike the DHT puts' TTL. */
-    ttlMs?: number;
-    /** The realm this PUBLISH is scoped to, as a 64-character hex string
-     * (32 bytes) -- see session.ts's CallOptions.realm for the full
-     * convention this shares. Omitted means the all-zero realm. Realm is
-     * an exact-match routing key: a subscribe() only ever receives this
-     * event if its own realm matches exactly, not a prefix or default
-     * fallback. */
-    realm?: string;
-}
-/** Options for Session.subscribe(). */
-export interface SubscribeOptions {
-    /** The realm this SUBSCRIBE listens on -- see PublishOptions.realm's
-     * own doc for the format and exact-match semantics. Omitted means the
-     * all-zero realm. Must match the realm a publisher actually used, or
-     * nothing published under a different realm is ever delivered here. */
-    realm?: string;
-    /** How bytes in each event's payload reach the handler: "hex" (the
-     * default) or "tagged" -- see rpc.ts's BytesOutput. */
-    bytes?: BytesOutput;
-    /** Called at most once, only if this subscription's background
-     * reader exits on its own -- the underlying session/connection died,
-     * or some other transport error ended the read loop -- rather than
-     * via the stop() subscribe() returned being called. See
-     * Session.subscribe()'s own doc for the full story (a real bug this
-     * SDK had and fixed: without this signal, such a subscription went
-     * silent forever and left the Session unable to close cleanly).
-     * Optional: even without a handler here, the subscription still
-     * tears itself down automatically and correctly the moment this
-     * happens -- this is purely a notification hook for a caller who
-     * wants to know why events stopped arriving. */
-    onClosed?: (error: Error) => void;
-}
-/** One delivered EVENT -- macula-go's frame.EventInfo, minus `Realm`
- * (the delivering EVENT's own realm is not surfaced back per-event here
- * -- a caller already knows it, since subscribe()'s own `realm` option
- * is what selected which realm's events reach this handler at all) and
- * `DeliveredVia` (a routing/telemetry detail, not part of this SDK's
- * scope yet). `payload`
- * follows rpc.ts's JsonValue rules exactly like a CALL payload does --
- * no boolean, embedded bytes as "0x"-prefixed hex by default or as
- * `{"$bytes": base64}` when subscribe() asked for `bytes: "tagged"`
- * (see cabi/wirevalue.go).
- * `publisher` is the raw 32-byte Ed25519 public key of whoever published
- * this event -- NOT verified against the frame's own signature by this
- * SDK, matching findRecord/findRecords/findRecordsByType's identical
- * "does not verify" posture (dht.ts). */
-export interface PubsubEvent {
-    readonly payload: JsonValue;
-    readonly publisher: Uint8Array;
-    readonly seq: number;
-}

package/dist/pubsub.js

@@ -1,8 +0,0 @@
-// Pubsub shapes -- macula-go's connection.Session.Publish/Subscribe/
-// Unsubscribe and frame.EventInfo (frame/pubsub.go, connection/
-// connection.go, connection/subscriber.go). Session (session.ts) is the
-// actual FFI entry point (publish()/subscribe()), matching call()/
-// serve()/the DHT methods' own shape -- this file holds the shapes that
-// side needs, the same split rpc.ts/dht.ts already have.
-export {};
-//# sourceMappingURL=pubsub.js.map

package/dist/pubsub.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pubsub.js","sourceRoot":"","sources":["../src/pubsub.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,gEAAgE;AAChE,wEAAwE;AACxE,mEAAmE;AACnE,wEAAwE;AACxE,yDAAyD"}

package/dist/rpc.d.ts

@@ -1,86 +0,0 @@
-/** A CALL/RESULT payload, restricted to what macula's wire CBOR can
- * actually represent (cbor.Value's Kind enum: UInt/NegInt/Bytes/Text/
- * List/Map/Null/Float -- no bool, no undefined). There is deliberately
- * no `boolean` in this union: encode true/false as 1/0 yourself, the
- * same rule this project's macula MCP server and macula-cli's own
- * wirevalue package both enforce -- a JS boolean silently reaching the
- * wire is exactly the mistake this type exists to make impossible at
- * compile time.
- *
- * Bytes have no native JSON shape either. Going IN, write them as an
- * object whose ONLY key is "$bytes", holding standard padded base64
- * (RFC 4648 section 4): `{"$bytes": "AQID"}` is the three bytes 01 02 03.
- * Any other value under that sole key is rejected, an object with more
- * keys stays an ordinary map, and a plain string is always text, even
- * one that looks like hex -- so the sole-key "$bytes" object is
- * reserved. Coming OUT, bytes are a "0x"-prefixed lowercase hex string
- * by default, or that same tagged object when the call, serve() or
- * subscribe() asked for `bytes: "tagged"` (see BytesOutput), which lets
- * a returned value be sent straight back. See cabi/wirevalue.go. */
-export type JsonValue = string | number | null | JsonValue[] | {
-    [key: string]: JsonValue;
-};
-/** How bytes in a RESULT, an inbound CALL or an EVENT payload reach
- * JavaScript: "hex" (the default) as a "0x"-prefixed lowercase hex
- * string, "tagged" as `{"$bytes": "<base64>"}`, the same form a payload
- * uses going IN. The choice is made on the Go side, per call, serve()
- * or subscribe(), because only Go still knows which values were bytes:
- * once rendered as hex, bytes and a text value that looks like "0x..."
- * can no longer be told apart. */
-export type BytesOutput = "hex" | "tagged";
-/** BytesOutput as the integer cabi's bytesOutput takes. An unknown value
- * (reachable from plain JavaScript) throws instead of silently falling
- * back to hex. Internal to the FFI boundary. */
-export declare function bytesModeFor(bytes: BytesOutput | undefined): number;
-/** The BOLT#4 fields a failed CALL carries -- see bolt4/bolt4.go's own
- * 17-code table (UnknownNextPeer, TemporaryRelayFailure, Unauthorized,
- * ...). `retryable` is bolt4.Code.IsRetryable()'s verdict, computed
- * Go-side from `code` (cabi/rpc.go), not re-derived here. */
-export interface Bolt4ErrorInfo {
-    readonly code: number;
-    readonly name: string;
-    readonly retryable: boolean;
-    readonly detail: string | null;
-}
-/** Thrown by Session.call() when the provider (or a relay in between)
- * answered with a real BOLT#4 ERROR frame instead of a RESULT -- e.g.
- * calling a procedure nobody has advertised comes back
- * unknown_next_peer; a provider handler that threw comes back
- * unknown_error (macula-go's connection/serve.go maps every handler
- * error to that one code, matching macula_station_link.erl's own
- * handle_inbound_call/2); a provider handler that panicked (recovered)
- * comes back temporary_relay_failure. Distinct from a plain
- * Error/rejection out of call() itself, which means this CALL never
- * got a wire-level answer at all (a local timeout, a dead connection,
- * a payload macula's CBOR can't represent). */
-export declare class MaculaCallError extends Error {
-    readonly code: number;
-    readonly bolt4Name: string;
-    readonly retryable: boolean;
-    readonly detail: string | null;
-    constructor(info: Bolt4ErrorInfo);
-}
-/** The JSON envelope cabi/rpc.go's macula_session_call returns --
- * internal to the FFI boundary, not part of the public API. Kept in
- * sync BY HAND with cabi/rpc.go's callEnvelope/callEnvelopeError Go
- * structs; there is no shared schema generating either side. */
-export type CallEnvelope = {
-    ok: true;
-    payload: JsonValue;
-} | {
-    ok: false;
-    bolt4: Bolt4ErrorInfo;
-};
-/** How long Session.call() waits for a RESULT/ERROR before giving up,
- * in milliseconds -- also becomes the wire's own `deadline_ms` (now +
- * this), matching macula-go's own examples/quickstart/main.go, which
- * derives both from one duration rather than treating the local wait
- * and the wire deadline as independent numbers. */
-export declare const DEFAULT_CALL_TIMEOUT_MS = 30000;
-/** How long one Session.serve() poll tick blocks waiting for the next
- * inbound CALL before checking whether stop() was requested --
- * mirrors macula-go's own servePollInterval (connection/serve_loop.go),
- * the exact tick length its ServeForever uses internally for the same
- * "poll with a bounded per-tick wait, check for cancellation between
- * ticks" shape. */
-export declare const SERVE_POLL_MS = 2000;

package/dist/rpc.js

@@ -1,57 +0,0 @@
-// Unary RPC -- the caller and provider roles built on top of a
-// handshaked Session's control stream, via macula-go's own
-// Session.Call (caller) and Session.Advertise + Session.ServeOneCall
-// (provider) -- see connection/connection.go and connection/serve.go.
-// The actual FFI plumbing lives on Session (session.ts); this file
-// holds the shapes both directions share: the JSON-only payload model
-// and the structured BOLT#4 error macula-go's own bolt4 package
-// defines (bolt4/bolt4.go, 17 codes).
-/** BytesOutput as the integer cabi's bytesOutput takes. An unknown value
- * (reachable from plain JavaScript) throws instead of silently falling
- * back to hex. Internal to the FFI boundary. */
-export function bytesModeFor(bytes) {
-    if (bytes === undefined || bytes === "hex")
-        return 0;
-    if (bytes === "tagged")
-        return 1;
-    throw new Error(`macula-ts: bytes must be "hex" or "tagged", got ${JSON.stringify(bytes)}`);
-}
-/** Thrown by Session.call() when the provider (or a relay in between)
- * answered with a real BOLT#4 ERROR frame instead of a RESULT -- e.g.
- * calling a procedure nobody has advertised comes back
- * unknown_next_peer; a provider handler that threw comes back
- * unknown_error (macula-go's connection/serve.go maps every handler
- * error to that one code, matching macula_station_link.erl's own
- * handle_inbound_call/2); a provider handler that panicked (recovered)
- * comes back temporary_relay_failure. Distinct from a plain
- * Error/rejection out of call() itself, which means this CALL never
- * got a wire-level answer at all (a local timeout, a dead connection,
- * a payload macula's CBOR can't represent). */
-export class MaculaCallError extends Error {
-    code;
-    bolt4Name;
-    retryable;
-    detail;
-    constructor(info) {
-        super(`macula-ts: CALL failed: ${info.name} (bolt4 code ${info.code})${info.detail ? `: ${info.detail}` : ""}`);
-        this.name = "MaculaCallError";
-        this.code = info.code;
-        this.bolt4Name = info.name;
-        this.retryable = info.retryable;
-        this.detail = info.detail;
-    }
-}
-/** How long Session.call() waits for a RESULT/ERROR before giving up,
- * in milliseconds -- also becomes the wire's own `deadline_ms` (now +
- * this), matching macula-go's own examples/quickstart/main.go, which
- * derives both from one duration rather than treating the local wait
- * and the wire deadline as independent numbers. */
-export const DEFAULT_CALL_TIMEOUT_MS = 30_000;
-/** How long one Session.serve() poll tick blocks waiting for the next
- * inbound CALL before checking whether stop() was requested --
- * mirrors macula-go's own servePollInterval (connection/serve_loop.go),
- * the exact tick length its ServeForever uses internally for the same
- * "poll with a bounded per-tick wait, check for cancellation between
- * ticks" shape. */
-export const SERVE_POLL_MS = 2_000;
-//# sourceMappingURL=rpc.js.map

package/dist/rpc.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"rpc.js","sourceRoot":"","sources":["../src/rpc.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,2DAA2D;AAC3D,qEAAqE;AACrE,sEAAsE;AACtE,mEAAmE;AACnE,sEAAsE;AACtE,gEAAgE;AAChE,sCAAsC;AAgCtC;;gDAEgD;AAChD,MAAM,UAAU,YAAY,CAAC,KAA8B;IACzD,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,KAAK;QAAE,OAAO,CAAC,CAAC;IACrD,IAAI,KAAK,KAAK,QAAQ;QAAE,OAAO,CAAC,CAAC;IACjC,MAAM,IAAI,KAAK,CAAC,mDAAmD,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;AAC9F,CAAC;AAaD;;;;;;;;;;+CAU+C;AAC/C,MAAM,OAAO,eAAgB,SAAQ,KAAK;IAC/B,IAAI,CAAS;IACb,SAAS,CAAS;IAClB,SAAS,CAAU;IACnB,MAAM,CAAgB;IAE/B,YAAY,IAAoB;QAC9B,KAAK,CAAC,2BAA2B,IAAI,CAAC,IAAI,gBAAgB,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QAChH,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;QAC9B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACtB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC;QAC3B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QAChC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;IAC5B,CAAC;CACF;AAQD;;;;mDAImD;AACnD,MAAM,CAAC,MAAM,uBAAuB,GAAG,MAAM,CAAC;AAE9C;;;;;mBAKmB;AACnB,MAAM,CAAC,MAAM,aAAa,GAAG,KAAK,CAAC"}