@macula-io/ts 0.13.0

package/dist/binding.js

@@ -0,0 +1,133 @@
+// Loads the compiled N-API addon (addon/binding.cc) and re-exports its
+// typed functions. Unlike the koffi-era version of this file, there is
+// no runtime signature declaration here -- the addon's C++ glue already
+// knows its own shapes, throws real JS errors on failure (no more
+// manual errOut-array/checkErr dance), and is a single self-contained
+// .node file (cabi/'s Go code is statically linked in via
+// -buildmode=c-archive, not loaded separately at runtime).
+//
+// node-gyp-build picks, at require time, whichever of these exists:
+// build/Release/*.node (a local dev build via `npm run build:addon:dev`)
+// or prebuilds/<platform>-<arch>/*.node (baked in by `npm run
+// build:prebuilds` / prebuildify, and published as part of the npm
+// package) -- this is the whole point: a consumer installing this
+// package from npm never runs a compiler or fetches anything, because
+// the matching prebuild is already sitting in the downloaded tarball.
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+const require = createRequire(import.meta.url);
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const addon = require("node-gyp-build")(repoRoot);
+export const native = {
+    identityGenerate() {
+        return addon.identityGenerate();
+    },
+    identityFromSeedBytes(seed32) {
+        if (seed32.length !== 32) {
+            throw new Error(`macula-ts: seed must be exactly 32 bytes, got ${seed32.length}`);
+        }
+        return addon.identityFromSeedBytes(seed32);
+    },
+    identityNodeId(handle) {
+        return addon.identityNodeId(handle);
+    },
+    identityPrivateBytes(handle) {
+        return addon.identityPrivateBytes(handle);
+    },
+    identityFree(handle) {
+        addon.identityFree(handle);
+    },
+    identitySign(handle, data) {
+        return addon.identitySign(handle, data);
+    },
+    sessionConnect(host, port, identityHandle) {
+        return addon.sessionConnect(host, port, identityHandle);
+    },
+    sessionRemoteAddr(handle) {
+        return addon.sessionRemoteAddr(handle);
+    },
+    sessionStationNodeId(handle) {
+        return addon.sessionStationNodeId(handle);
+    },
+    sessionClose(handle, identityHandle, reason) {
+        return addon.sessionClose(handle, identityHandle, reason);
+    },
+    sessionCall(sessionHandle, identityHandle, procedure, realm, payloadJson, timeoutMs) {
+        return addon.sessionCall(sessionHandle, identityHandle, procedure, realm, payloadJson, timeoutMs);
+    },
+    ucanMint(identityHandle, issuer, audience, capabilitiesJson, expiresAt, notBefore, nonce, factsJson, proofsJson) {
+        return addon.ucanMint(identityHandle, issuer, audience, capabilitiesJson, expiresAt, notBefore, nonce, factsJson, proofsJson);
+    },
+    ucanDecode(token) {
+        return addon.ucanDecode(token);
+    },
+    sessionCallWithUcan(sessionHandle, identityHandle, procedure, realm, payloadJson, timeoutMs, ucanToken) {
+        return addon.sessionCallWithUcan(sessionHandle, identityHandle, procedure, realm, payloadJson, timeoutMs, ucanToken);
+    },
+    sessionAdvertise(sessionHandle, identityHandle, realm, procedure) {
+        return addon.sessionAdvertise(sessionHandle, identityHandle, realm, procedure);
+    },
+    sessionUnadvertise(sessionHandle, identityHandle, realm, procedure) {
+        return addon.sessionUnadvertise(sessionHandle, identityHandle, realm, procedure);
+    },
+    serveWaitForCall(sessionHandle, identityHandle, realm, procedure, timeoutMs) {
+        return addon.serveWaitForCall(sessionHandle, identityHandle, realm, procedure, timeoutMs);
+    },
+    pendingCallProcedure(pendingHandle) {
+        return addon.pendingCallProcedure(pendingHandle);
+    },
+    pendingCallPayloadJson(pendingHandle) {
+        return addon.pendingCallPayloadJson(pendingHandle);
+    },
+    pendingCallReplyResult(pendingHandle, resultJson) {
+        return addon.pendingCallReplyResult(pendingHandle, resultJson);
+    },
+    pendingCallReplyError(pendingHandle, detail) {
+        return addon.pendingCallReplyError(pendingHandle, detail);
+    },
+    dhtFindRecordsByType(sessionHandle, identityHandle, recordType) {
+        return addon.dhtFindRecordsByType(sessionHandle, identityHandle, recordType);
+    },
+    dhtFindRecords(sessionHandle, identityHandle, key32) {
+        return addon.dhtFindRecords(sessionHandle, identityHandle, key32);
+    },
+    dhtFindRecord(sessionHandle, identityHandle, key32) {
+        return addon.dhtFindRecord(sessionHandle, identityHandle, key32);
+    },
+    dhtPutProcedureAdvertisement(sessionHandle, identityHandle, realm, procedure, servingStation32, ttlMs) {
+        return addon.dhtPutProcedureAdvertisement(sessionHandle, identityHandle, realm, procedure, servingStation32, ttlMs);
+    },
+    dhtPutContentAnnouncement(sessionHandle, identityHandle, mcid34, endpoint, ttlMs) {
+        return addon.dhtPutContentAnnouncement(sessionHandle, identityHandle, mcid34, endpoint, ttlMs);
+    },
+    sessionPublish(sessionHandle, identityHandle, realm, topic, payloadJson, ttlMs) {
+        return addon.sessionPublish(sessionHandle, identityHandle, realm, topic, payloadJson, ttlMs);
+    },
+    sessionSubscribeStart(sessionHandle, identityHandle, realm, topic, onEvent) {
+        return addon.sessionSubscribeStart(sessionHandle, identityHandle, realm, topic, onEvent);
+    },
+    sessionSubscribeStop(subscriptionHandle) {
+        return addon.sessionSubscribeStop(subscriptionHandle);
+    },
+    contentPut(sessionHandle, identityHandle, data, name) {
+        return addon.contentPut(sessionHandle, identityHandle, data, name);
+    },
+    contentGet(sessionHandle, identityHandle, mcidHex) {
+        return addon.contentGet(sessionHandle, identityHandle, mcidHex);
+    },
+    directdialResolve(sessionHandle, identityHandle, realm, procedure) {
+        return addon.directdialResolve(sessionHandle, identityHandle, realm, procedure);
+    },
+    directdialCall(sessionHandle, identityHandle, procedure, realm, payloadJson, timeoutMs) {
+        return addon.directdialCall(sessionHandle, identityHandle, procedure, realm, payloadJson, timeoutMs);
+    },
+    directdialCallWithUcan(sessionHandle, identityHandle, procedure, realm, payloadJson, timeoutMs, ucanToken) {
+        return addon.directdialCallWithUcan(sessionHandle, identityHandle, procedure, realm, payloadJson, timeoutMs, ucanToken);
+    },
+    directdialAdvertise(sessionHandle, identityHandle, realm, procedure, ttlMs) {
+        return addon.directdialAdvertise(sessionHandle, identityHandle, realm, procedure, ttlMs);
+    },
+};
+//# sourceMappingURL=binding.js.map

package/dist/binding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binding.js","sourceRoot":"","sources":["../src/binding.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,uEAAuE;AACvE,wEAAwE;AACxE,kEAAkE;AAClE,sEAAsE;AACtE,0DAA0D;AAC1D,2DAA2D;AAC3D,EAAE;AACF,oEAAoE;AACpE,yEAAyE;AACzE,8DAA8D;AAC9D,mEAAmE;AACnE,kEAAkE;AAClE,sEAAsE;AACtE,sEAAsE;AACtE,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAE1C,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC/C,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;AAErE,8DAA8D;AAC9D,MAAM,KAAK,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC,QAAQ,CAkM/C,CAAC;AAQF,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB,gBAAgB;QACd,OAAO,KAAK,CAAC,gBAAgB,EAAE,CAAC;IAClC,CAAC;IACD,qBAAqB,CAAC,MAAkB;QACtC,IAAI,MAAM,CAAC,MAAM,KAAK,EAAE,EAAE,CAAC;YACzB,MAAM,IAAI,KAAK,CAAC,iDAAiD,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;QACpF,CAAC;QACD,OAAO,KAAK,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;IAC7C,CAAC;IACD,cAAc,CAAC,MAAc;QAC3B,OAAO,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IACtC,CAAC;IACD,oBAAoB,CAAC,MAAc;QACjC,OAAO,KAAK,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;IAC5C,CAAC;IACD,YAAY,CAAC,MAAc;QACzB,KAAK,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;IAC7B,CAAC;IACD,YAAY,CAAC,MAAc,EAAE,IAAgB;QAC3C,OAAO,KAAK,CAAC,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC1C,CAAC;IACD,cAAc,CAAC,IAAY,EAAE,IAAY,EAAE,cAAsB;QAC/D,OAAO,KAAK,CAAC,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC;IAC1D,CAAC;IACD,iBAAiB,CAAC,MAAc;QAC9B,OAAO,KAAK,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;IACzC,CAAC;IACD,oBAAoB,CAAC,MAAc;QACjC,OAAO,KAAK,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;IAC5C,CAAC;IACD,YAAY,CAAC,MAAc,EAAE,cAAsB,EAAE,MAAc;QACjE,OAAO,KAAK,CAAC,YAAY,CAAC,MAAM,EAAE,cAAc,EAAE,MAAM,CAAC,CAAC;IAC5D,CAAC;IACD,WAAW,CACT,aAAqB,EACrB,cAAsB,EACtB,SAAiB,EACjB,KAA6B,EAC7B,WAAmB,EACnB,SAAiB;QAEjB,OAAO,KAAK,CAAC,WAAW,CAAC,aAAa,EAAE,cAAc,EAAE,SAAS,EAAE,KAAK,EAAE,WAAW,EAAE,SAAS,CAAC,CAAC;IACpG,CAAC;IACD,QAAQ,CACN,cAAsB,EACtB,MAAc,EACd,QAAgB,EAChB,gBAAwB,EACxB,SAA6B,EAC7B,SAA6B,EAC7B,KAAa,EACb,SAA6B,EAC7B,UAA8B;QAE9B,OAAO,KAAK,CAAC,QAAQ,CAAC,cAAc,EAAE,MAAM,EAAE,QAAQ,EAAE,gBAAgB,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;IAChI,CAAC;IACD,UAAU,CAAC,KAAa;QACtB,OAAO,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;IACD,mBAAmB,CACjB,aAAqB,EACrB,cAAsB,EACtB,SAAiB,EACjB,KAA6B,EAC7B,WAAmB,EACnB,SAAiB,EACjB,SAAiB;QAEjB,OAAO,KAAK,CAAC,mBAAmB,CAAC,aAAa,EAAE,cAAc,EAAE,SAAS,EAAE,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;IACvH,CAAC;IACD,gBAAgB,CAAC,aAAqB,EAAE,cAAsB,EAAE,KAA6B,EAAE,SAAiB;QAC9G,OAAO,KAAK,CAAC,gBAAgB,CAAC,aAAa,EAAE,cAAc,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;IACjF,CAAC;IACD,kBAAkB,CAAC,aAAqB,EAAE,cAAsB,EAAE,KAA6B,EAAE,SAAiB;QAChH,OAAO,KAAK,CAAC,kBAAkB,CAAC,aAAa,EAAE,cAAc,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;IACnF,CAAC;IACD,gBAAgB,CACd,aAAqB,EACrB,cAAsB,EACtB,KAA6B,EAC7B,SAAiB,EACjB,SAAiB;QAEjB,OAAO,KAAK,CAAC,gBAAgB,CAAC,aAAa,EAAE,cAAc,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;IAC5F,CAAC;IACD,oBAAoB,CAAC,aAAqB;QACxC,OAAO,KAAK,CAAC,oBAAoB,CAAC,aAAa,CAAC,CAAC;IACnD,CAAC;IACD,sBAAsB,CAAC,aAAqB;QAC1C,OAAO,KAAK,CAAC,sBAAsB,CAAC,aAAa,CAAC,CAAC;IACrD,CAAC;IACD,sBAAsB,CAAC,aAAqB,EAAE,UAAkB;QAC9D,OAAO,KAAK,CAAC,sBAAsB,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC;IACjE,CAAC;IACD,qBAAqB,CAAC,aAAqB,EAAE,MAAc;QACzD,OAAO,KAAK,CAAC,qBAAqB,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;IAC5D,CAAC;IACD,oBAAoB,CAAC,aAAqB,EAAE,cAAsB,EAAE,UAAkB;QACpF,OAAO,KAAK,CAAC,oBAAoB,CAAC,aAAa,EAAE,cAAc,EAAE,UAAU,CAAC,CAAC;IAC/E,CAAC;IACD,cAAc,CAAC,aAAqB,EAAE,cAAsB,EAAE,KAAiB;QAC7E,OAAO,KAAK,CAAC,cAAc,CAAC,aAAa,EAAE,cAAc,EAAE,KAAK,CAAC,CAAC;IACpE,CAAC;IACD,aAAa,CAAC,aAAqB,EAAE,cAAsB,EAAE,KAAiB;QAC5E,OAAO,KAAK,CAAC,aAAa,CAAC,aAAa,EAAE,cAAc,EAAE,KAAK,CAAC,CAAC;IACnE,CAAC;IACD,4BAA4B,CAC1B,aAAqB,EACrB,cAAsB,EACtB,KAA6B,EAC7B,SAAiB,EACjB,gBAA4B,EAC5B,KAAa;QAEb,OAAO,KAAK,CAAC,4BAA4B,CAAC,aAAa,EAAE,cAAc,EAAE,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,KAAK,CAAC,CAAC;IACtH,CAAC;IACD,yBAAyB,CACvB,aAAqB,EACrB,cAAsB,EACtB,MAAkB,EAClB,QAAgB,EAChB,KAAa;QAEb,OAAO,KAAK,CAAC,yBAAyB,CAAC,aAAa,EAAE,cAAc,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;IACjG,CAAC;IACD,cAAc,CACZ,aAAqB,EACrB,cAAsB,EACtB,KAA6B,EAC7B,KAAa,EACb,WAAmB,EACnB,KAAa;QAEb,OAAO,KAAK,CAAC,cAAc,CAAC,aAAa,EAAE,cAAc,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;IAC/F,CAAC;IACD,qBAAqB,CACnB,aAAqB,EACrB,cAAsB,EACtB,KAA6B,EAC7B,KAAa,EACb,OAIS;QAET,OAAO,KAAK,CAAC,qBAAqB,CAAC,aAAa,EAAE,cAAc,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;IAC3F,CAAC;IACD,oBAAoB,CAAC,kBAA0B;QAC7C,OAAO,KAAK,CAAC,oBAAoB,CAAC,kBAAkB,CAAC,CAAC;IACxD,CAAC;IACD,UAAU,CAAC,aAAqB,EAAE,cAAsB,EAAE,IAAgB,EAAE,IAAY;QACtF,OAAO,KAAK,CAAC,UAAU,CAAC,aAAa,EAAE,cAAc,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;IACrE,CAAC;IACD,UAAU,CAAC,aAAqB,EAAE,cAAsB,EAAE,OAAe;QACvE,OAAO,KAAK,CAAC,UAAU,CAAC,aAAa,EAAE,cAAc,EAAE,OAAO,CAAC,CAAC;IAClE,CAAC;IACD,iBAAiB,CAAC,aAAqB,EAAE,cAAsB,EAAE,KAA6B,EAAE,SAAiB;QAC/G,OAAO,KAAK,CAAC,iBAAiB,CAAC,aAAa,EAAE,cAAc,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;IAClF,CAAC;IACD,cAAc,CACZ,aAAqB,EACrB,cAAsB,EACtB,SAAiB,EACjB,KAA6B,EAC7B,WAAmB,EACnB,SAAiB;QAEjB,OAAO,KAAK,CAAC,cAAc,CAAC,aAAa,EAAE,cAAc,EAAE,SAAS,EAAE,KAAK,EAAE,WAAW,EAAE,SAAS,CAAC,CAAC;IACvG,CAAC;IACD,sBAAsB,CACpB,aAAqB,EACrB,cAAsB,EACtB,SAAiB,EACjB,KAA6B,EAC7B,WAAmB,EACnB,SAAiB,EACjB,SAAiB;QAEjB,OAAO,KAAK,CAAC,sBAAsB,CAAC,aAAa,EAAE,cAAc,EAAE,SAAS,EAAE,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;IAC1H,CAAC;IACD,mBAAmB,CACjB,aAAqB,EACrB,cAAsB,EACtB,KAA6B,EAC7B,SAAiB,EACjB,KAAa;QAEb,OAAO,KAAK,CAAC,mBAAmB,CAAC,aAAa,EAAE,cAAc,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;IAC3F,CAAC;CACF,CAAC"}

package/dist/content.d.ts

@@ -0,0 +1,14 @@
+/** Thrown by Session.getContent() when the station reports the content
+ * isn't known to it (macula-go's content.ErrNotFound) -- an expected,
+ * routine outcome for a transfer mechanism with no durability
+ * guarantee, not a transport failure. Unlike DhtRecord's findRecord()
+ * (which resolves `null` for its own equivalent "not found" case),
+ * getContent() throws instead: its whole contract is "hand back the
+ * bytes or fail", and there is no sensible non-throwing value to return
+ * in place of the `Uint8Array` a caller asked for. */
+export declare class ContentNotFoundError extends Error {
+    /** The mcid that produced this error, hex-encoded (the same string
+     * that was passed to getContent()). */
+    readonly mcid: string;
+    constructor(mcid: string);
+}

package/dist/content.js

@@ -0,0 +1,45 @@
+// Content transfer -- macula-go's content package (Put/Get), thin
+// CALL/RESULT wrappers to reserved `_content.*` procedures sent on
+// their OWN dedicated QUIC stream (Session.OpenDedicatedStream on the
+// Go side), NOT the shared control stream call()/serve()/the DHT
+// methods/subscribe() all read from -- see cabi/content.go's own doc
+// for why Session.putContent()/getContent() (session.ts) are, unlike
+// those, never subject to Session's same-Session exclusivity guard, and
+// why two concurrent putContent()/getContent() calls on one Session
+// don't race each other either (each gets its own fresh dedicated
+// stream).
+//
+// IMPORTANT: this is a one-time TRANSFER mechanism, not durable object
+// storage. A station may forget content after serving it, there is no
+// "list what's stored here" operation, and there is no "delete"
+// operation -- putContent()/getContent() hand a blob to a peer once,
+// they do not give you a key-value store. Do not build anything on this
+// SDK that assumes content survives indefinitely, or that a station is
+// obligated to keep serving something it once accepted.
+//
+// mcid crosses the FFI boundary as a lowercase hex string (68 hex
+// chars = 34 bytes: <<Version:8, Codec:8, Hash:32/binary>>, macula-go's
+// manifest.Mcid) -- the same "raw byte identifier -> hex string"
+// convention DhtRecord's key/version/signature already use (dht.ts),
+// deliberately NOT rpc.ts's own "0x"-prefixed convention for bytes
+// embedded *inside* a JSON payload -- an mcid stands on its own here,
+// it isn't a payload field.
+/** Thrown by Session.getContent() when the station reports the content
+ * isn't known to it (macula-go's content.ErrNotFound) -- an expected,
+ * routine outcome for a transfer mechanism with no durability
+ * guarantee, not a transport failure. Unlike DhtRecord's findRecord()
+ * (which resolves `null` for its own equivalent "not found" case),
+ * getContent() throws instead: its whole contract is "hand back the
+ * bytes or fail", and there is no sensible non-throwing value to return
+ * in place of the `Uint8Array` a caller asked for. */
+export class ContentNotFoundError extends Error {
+    /** The mcid that produced this error, hex-encoded (the same string
+     * that was passed to getContent()). */
+    mcid;
+    constructor(mcid) {
+        super(`macula-ts: no content found for mcid ${mcid}`);
+        this.name = "ContentNotFoundError";
+        this.mcid = mcid;
+    }
+}
+//# sourceMappingURL=content.js.map

package/dist/content.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.js","sourceRoot":"","sources":["../src/content.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,mEAAmE;AACnE,sEAAsE;AACtE,iEAAiE;AACjE,qEAAqE;AACrE,qEAAqE;AACrE,wEAAwE;AACxE,oEAAoE;AACpE,kEAAkE;AAClE,WAAW;AACX,EAAE;AACF,uEAAuE;AACvE,sEAAsE;AACtE,gEAAgE;AAChE,qEAAqE;AACrE,wEAAwE;AACxE,uEAAuE;AACvE,wDAAwD;AACxD,EAAE;AACF,kEAAkE;AAClE,wEAAwE;AACxE,iEAAiE;AACjE,qEAAqE;AACrE,mEAAmE;AACnE,sEAAsE;AACtE,4BAA4B;AAE5B;;;;;;;sDAOsD;AACtD,MAAM,OAAO,oBAAqB,SAAQ,KAAK;IAC7C;2CACuC;IAC9B,IAAI,CAAS;IAEtB,YAAY,IAAY;QACtB,KAAK,CAAC,wCAAwC,IAAI,EAAE,CAAC,CAAC;QACtD,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC;QACnC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;CACF"}

package/dist/dht.d.ts

@@ -0,0 +1,54 @@
+import type { JsonValue } from "./rpc.js";
+/** Record type tags -- macula-go's dht.Type* constants (dht/record.go).
+ * There is no client-side constructor for StationEndpoint in macula-go
+ * (stations publish those themselves, not clients) -- it's listed here
+ * because Session.findRecord/findRecords/findRecordsByType can still
+ * return one, not because a Session.putRecord* method can build one. */
+export declare enum DhtRecordType {
+    ProcedureAdvertisement = 6,
+    ContentAnnouncement = 17,
+    StationEndpoint = 18
+}
+/** A signed, TTL'd DHT record envelope -- mirrors macula-go's dht.Record
+ * (dht/record.go). `key`/`version`/`signature` are raw bytes with no
+ * native JSON shape, so they cross the FFI boundary as lowercase hex
+ * strings -- deliberately NOT rpc.ts's own "0x"-prefixed convention for
+ * bytes embedded inside a payload (see cabi/dht.go's own doc for why:
+ * these three fields never go through jsonToCbor/cborToJSON at all,
+ * wirevalue.go's "0x"-hex convention is specifically for bytes found
+ * *inside* a cbor.Value payload, which these aren't). `payload` DID go
+ * through that conversion (it's the record's own cbor.Value map) and
+ * follows rpc.ts's JsonValue rules exactly like a CALL payload does --
+ * no boolean, embedded bytes as "0x"-prefixed hex. Note that a
+ * procedure_advertisement/content_announcement's own advertiser_node/
+ * serving_station/announcer_node/mcid payload fields are themselves raw
+ * bytes on the wire (CBOR byte strings) but surface here as the SAME
+ * "0x"-prefixed hex JsonValue strings cborToJSON gives any embedded
+ * bytes -- consistent with every other payload field this SDK decodes,
+ * just called out since they look similar to this record's own
+ * top-level key/version/signature while following the other convention.
+ *
+ * This SDK does not verify a record's signature or check its expiry on
+ * the caller's behalf (matching macula-go's own FindRecord/FindRecords/
+ * FindRecordsByType, which say the same in their own doc comments) --
+ * a caller that needs to trust a record's payload must check both
+ * itself (against `key`, `signature`, and `expiresAt`) before relying
+ * on it. */
+export interface DhtRecord {
+    readonly type: DhtRecordType | number;
+    /** Hex-encoded, 32 bytes: the envelope signer's Ed25519 public key. */
+    readonly key: string;
+    /** Hex-encoded, 16 bytes: a UUIDv7. */
+    readonly version: string;
+    /** Milliseconds since epoch. */
+    readonly createdAt: number;
+    /** Milliseconds since epoch. */
+    readonly expiresAt: number;
+    readonly payload: JsonValue;
+    /** Hex-encoded, 64 bytes. */
+    readonly signature: string;
+}
+/** Default TTL for a record built by Session.putProcedureAdvertisement()/
+ * putContentAnnouncement() when the caller doesn't specify one --
+ * matches macula-go's dht.DefaultTTL (48h). */
+export declare const DHT_DEFAULT_TTL_MS: number;

package/dist/dht.js

@@ -0,0 +1,25 @@
+// DHT record shapes -- macula-go's dht package (FindRecord/FindRecords/
+// FindRecordsByType/PutRecord), thin CALL wrappers to the mesh's own
+// reserved `_dht.*` procedures under the DHT's own all-zero realm
+// (threaded internally by macula-go's dht package, never passed from
+// here -- see cabi/dht.go). Session (session.ts) is the actual FFI
+// entry point for these, matching call()/serve()'s own shape (a
+// Session-bound method, using that Session's own retained Identity to
+// sign); this file holds the shapes both directions share, the same
+// split rpc.ts has for call()/serve().
+/** Record type tags -- macula-go's dht.Type* constants (dht/record.go).
+ * There is no client-side constructor for StationEndpoint in macula-go
+ * (stations publish those themselves, not clients) -- it's listed here
+ * because Session.findRecord/findRecords/findRecordsByType can still
+ * return one, not because a Session.putRecord* method can build one. */
+export var DhtRecordType;
+(function (DhtRecordType) {
+    DhtRecordType[DhtRecordType["ProcedureAdvertisement"] = 6] = "ProcedureAdvertisement";
+    DhtRecordType[DhtRecordType["ContentAnnouncement"] = 17] = "ContentAnnouncement";
+    DhtRecordType[DhtRecordType["StationEndpoint"] = 18] = "StationEndpoint";
+})(DhtRecordType || (DhtRecordType = {}));
+/** Default TTL for a record built by Session.putProcedureAdvertisement()/
+ * putContentAnnouncement() when the caller doesn't specify one --
+ * matches macula-go's dht.DefaultTTL (48h). */
+export const DHT_DEFAULT_TTL_MS = 48 * 60 * 60 * 1000;
+//# sourceMappingURL=dht.js.map

package/dist/dht.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dht.js","sourceRoot":"","sources":["../src/dht.ts"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,qEAAqE;AACrE,kEAAkE;AAClE,qEAAqE;AACrE,mEAAmE;AACnE,gEAAgE;AAChE,sEAAsE;AACtE,oEAAoE;AACpE,uCAAuC;AAIvC;;;;wEAIwE;AACxE,MAAM,CAAN,IAAY,aAIX;AAJD,WAAY,aAAa;IACvB,qFAA6B,CAAA;IAC7B,gFAA0B,CAAA;IAC1B,wEAAsB,CAAA;AACxB,CAAC,EAJW,aAAa,KAAb,aAAa,QAIxB;AA0CD;;+CAE+C;AAC/C,MAAM,CAAC,MAAM,kBAAkB,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC"}

package/dist/directdial.d.ts

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1,76 @@
+// 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

@@ -0,0 +1 @@
+{"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,OAAoC,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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,83 @@
+// 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

@@ -0,0 +1 @@
+{"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/index.d.ts

@@ -0,0 +1,8 @@
+export { Identity } from "./identity.js";
+export { Session, type CallOptions } from "./session.js";
+export { MaculaCallError, type JsonValue, type Bolt4ErrorInfo } from "./rpc.js";
+export { DhtRecordType, DHT_DEFAULT_TTL_MS, type DhtRecord } from "./dht.js";
+export type { PublishOptions, PubsubEvent } from "./pubsub.js";
+export { ContentNotFoundError } from "./content.js";
+export { Ucan, type UcanCapability, type UcanFactValue, type UcanMintOptions } from "./ucan.js";
+export { keepAdvertisedDirect, KEEP_ADVERTISED_DIRECT_INTERVAL_MS, type DirectDialTarget, type AdvertiseDirectOptions, type KeepAdvertisedDirectOptions, } from "./directdial.js";

package/dist/index.js

@@ -0,0 +1,8 @@
+export { Identity } from "./identity.js";
+export { Session } from "./session.js";
+export { MaculaCallError } from "./rpc.js";
+export { DhtRecordType, DHT_DEFAULT_TTL_MS } from "./dht.js";
+export { ContentNotFoundError } from "./content.js";
+export { Ucan } from "./ucan.js";
+export { keepAdvertisedDirect, KEEP_ADVERTISED_DIRECT_INTERVAL_MS, } from "./directdial.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,OAAO,EAAoB,MAAM,cAAc,CAAC;AACzD,OAAO,EAAE,eAAe,EAAuC,MAAM,UAAU,CAAC;AAChF,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAkB,MAAM,UAAU,CAAC;AAE7E,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,IAAI,EAAiE,MAAM,WAAW,CAAC;AAChG,OAAO,EACL,oBAAoB,EACpB,kCAAkC,GAInC,MAAM,iBAAiB,CAAC"}