jolt-sdk

re-exportSessionRequest

Re-export of index.operations.SessionRequest.

namespaceoperations

Typed daemon operations over a JoltTransport.

One function per daemon endpoint the application contract declares stable. These are the lowest app-facing layer: wire DTOs in and out, no domain marshalling. Most applications should use the client from createJoltClient instead and drop to operations only for endpoints the client does not wrap (e.g. binary publish).

type SessionRequest = { ... }

function acceptIngress(transport: JoltTransport, token: string, ingressId: string, options?: CallOptions): Promise<IngressRecord>

function appendPublishJson(transport: JoltTransport, token: string, path: string, body: object, options?: CallOptions): Promise<PublishResponse>

function decryptEncryptedTarget(transport: JoltTransport, token: string, target: string, options?: CallOptions): Promise<DecryptedEncryptedObject>

function enumerate(transport: JoltTransport, token: string, identity: string, pathPrefix: string, options?: CallOptions): Promise<AppendRecordInfo[]>

function fetchTarget(transport: JoltTransport, token: string, target: string, options?: CallOptions): Promise<FetchResult>

function getCurrentSession(transport: JoltTransport, token: string, options?: CallOptions): Promise<CurrentAppSession>

function getSessionRequestStatus(transport: JoltTransport, requestId: string, options?: CallOptions): Promise<AppSessionStatusResponse>

function getStatus(transport: JoltTransport, options?: CallOptions): Promise<NodeStatus>

function listPendingIngress(transport: JoltTransport, token: string, options?: CallOptions): Promise<IngressRecord[]>

function listPublished(transport: JoltTransport, token: string, options?: CallOptions): Promise<PublishedContent[]>

function openIngress(transport: JoltTransport, token: string, ingressId: string, options?: CallOptions): Promise<DecryptedIngress>

function publishBytes(transport: JoltTransport, token: string, path: string, bytes: Uint8Array<ArrayBufferLike>, meta: { fileName: string; mimeType: string }, options?: CallOptions): Promise<PublishResponse>

function publishEncryptedBytes(transport: JoltTransport, token: string, path: string, plaintext: Uint8Array<ArrayBufferLike>, meta: { mimeType: string; recipients: string[] }, options?: CallOptions): Promise<EncryptedPublishResponse>

function publishEncryptedJson(transport: JoltTransport, token: string, path: string, body: object, recipients: string[], options?: CallOptions): Promise<EncryptedPublishResponse>

function publishJson(transport: JoltTransport, token: string, path: string, body: object, options?: CallOptions): Promise<PublishResponse>

function rejectIngress(transport: JoltTransport, token: string, ingressId: string, options?: CallOptions): Promise<IngressRecord>

function requestSession(transport: JoltTransport, req: SessionRequest, options?: CallOptions): Promise<AppSessionRequestResponse>

function resolveAddress(transport: JoltTransport, token: string, address: string, options?: CallOptions): Promise<ResolveResponse>

function sendIngress(transport: JoltTransport, token: string, req: { encryptedObject: number[]; expiresAt?: number; recipient: string }, options?: CallOptions): Promise<IngressRecord>

classJoltApiError

The daemon (or its dev proxy) answered with a non-success status.

The daemon's JSON error body, when present, is preserved on body and its error field becomes the message.

new JoltApiError

new JoltApiError(message: string, options?: { body?: unknown; code?: string; status?: number }): JoltApiError

classJoltTransportError

The daemon could not be reached at all: connection refused, DNS failure, aborted request, or timeout. The cause carries the underlying error.

new JoltTransportError

new JoltTransportError(message: string, options?: { cause?: unknown }): JoltTransportError

interfaceJoltAppendSdk

Coexisting append records and their enumeration.

enumerate

enumerate(identity: string, pathPrefix: string, options?: CallOptions): Promise<EnumeratedRecord[]>

List an identity's append records under a path prefix.

publishAppend

publishAppend(path: string, body: object, options?: CallOptions): Promise<PublishResult>

Publish a coexisting device-writer append record at path.

interfaceJoltEncryptedSdk

Encrypted publish and tolerant encrypted reads.

listPublished

listPublished(options?: CallOptions): Promise<PublishedContent[]>

The local node's published inventory.

publishEncryptedJson

publishEncryptedJson(path: string, body: object, recipients: string[], options?: CallOptions): Promise<PublishResult>

Publish a JSON body encrypted to recipients (identity addresses). Use [self] for an encrypt-to-self publication; the publisher can always decrypt its own publications, so readEncrypted reads them back.

readEncrypted

readEncrypted<T>(ref: Reference, decode: Decoder<T>, options?: CallOptions): Promise<null | Versioned<T>>

Resolve + decrypt + parse + decode; null on any failing step.

interfaceJoltIngressSdk

The recipient-controlled ingress door: deliver identified objects to another identity's daemon and review what arrives at yours. Transport-level vocabulary only; classifying payloads is the app's job.

acceptIngress

acceptIngress(ingressId: string, options?: CallOptions): Promise<void>

listPendingIngress

listPendingIngress(options?: CallOptions): Promise<IngressRecord[]>

openIngress

openIngress(ingressId: string, options?: CallOptions): Promise<unknown>

Decrypt a pending envelope and return its parsed JSON, or null.

rejectIngress

rejectIngress(ingressId: string, options?: CallOptions): Promise<void>

sendObject

sendObject(recipient: string, path: string, body: object, options?: CallOptions): Promise<PublishResult>

Encrypt-publish the object at path (the sender's own copy) and deliver it to recipient's daemon. Returns the publish result so the sender can version its own copy.

interfaceJoltSdk

Public publish and tolerant versioned reads.

publishJson

publishJson(path: string, body: object, options?: CallOptions): Promise<PublishResult>

Publish a JSON object at a signed path (last-writer-wins).

read

read<T>(ref: Reference, decode: Decoder<T>, options?: CallOptions): Promise<null | Versioned<T>>

Resolve, fetch, parse, and decode a publication. Returns null when the reference is missing/unreachable or the bytes do not decode to T.

readContent

readContent<T>(contentId: string, ref: Reference, latestSequence: number, decode: Decoder<T>, options?: CallOptions): Promise<null | Versioned<T>>

Fetch a known content id (from an enumerated append record), then parse and decode it against the supplied logical reference.

interfaceJoltSessionSdk

Session bootstrap and daemon status, bound to the client's transport.

getCurrentSession

getCurrentSession(options?: CallOptions): Promise<CurrentAppSession>

The session behind the current token, as the daemon sees it.

getSessionRequestStatus

getSessionRequestStatus(requestId: string, options?: CallOptions): Promise<AppSessionStatusResponse>

Poll a session request until it carries a token.

getStatus

getStatus(options?: CallOptions): Promise<NodeStatus>

Local daemon status (no session required).

requestSession

requestSession(req: SessionRequest, options?: CallOptions): Promise<AppSessionRequestResponse>

Ask the daemon for a scoped session; the user approves it in Console.

interfaceJoltTransport

The single interface a transport implements.

Implementations must throw JoltApiError for non-success daemon responses and JoltTransportError for network-level failures, so application error handling is uniform across runtimes.

request

request<T>(base: ApiBase, path: string, req?: TransportRequest): Promise<T>

Send a JSON request to base + path and parse the JSON response.

upload

upload<T>(base: ApiBase, path: string, req: TransportUpload): Promise<T>

Send a multipart file upload to base + path and parse the JSON response.

typeApiBase

type ApiBase = "app" | "daemon"

Which daemon API surface a request targets.

typeAppendRecordInfo

type AppendRecordInfo = { ... }

One device-writer append record as enumeration returns it (/app/v1/enumerate).

typeAppSessionRequestResponse

type AppSessionRequestResponse = { ... }

Response to a session request (/app/v1/sessions/request).

typeAppSessionStatus

type AppSessionStatus = "pending" | "active" | "rejected" | "revoked" | "expired"

Lifecycle states of an app session.

typeAppSessionStatusResponse

type AppSessionStatusResponse = { ... }

Polled session request status (/app/v1/sessions/{request_id}).

typeCallOptions

type CallOptions = { ... }

Options accepted by every SDK operation.

signal aborts the request; timeoutMs fails it with a JoltTransportError after the given time. Both may be combined.

typeCurrentAppSession

type CurrentAppSession = { ... }

The current session, as seen by the daemon (/app/v1/session).

typeDecoder

type Decoder<T> = (value: unknown) => T | null

A decoder is the app's schema-level reader: it validates an already-parsed JSON value into a canonical type, or returns null to reject it. Decoders never see bytes or transport concerns.

typeDecryptedEncryptedObject

type DecryptedEncryptedObject = { ... }

Decrypted encrypted publication (/app/v1/encrypted/decrypt).

typeDecryptedIngress

type DecryptedIngress = { ... }

Decrypted ingress payload (/app/v1/ingress/{id}/open).

typeEncryptedPublishResponse

type EncryptedPublishResponse = PublishResponse & { ... }

Result of an encrypted publish (/app/v1/encrypted/publish).

typeEnumeratedRecord

type EnumeratedRecord = { ... }

One append record, marshalled into domain shape.

typeFetchResult

type FetchResult = { ... }

Raw bytes fetched by content id (/app/v1/fetch).

typeIngressRecord

type IngressRecord = { ... }

One recipient-controlled ingress envelope awaiting (or past) review.

typeJoltClient

type JoltClient = JoltSdk & JoltAppendSdk & JoltEncryptedSdk & JoltIngressSdk & JoltSessionSdk & { ... }

Everything a typical Jolt application needs, in one object.

typeJoltClientOptions

type JoltClientOptions = { ... }

Configuration for createJoltClient.

typeNodeStatus

type NodeStatus = { ... }

/api/v1/status: the local daemon's identity and connectivity summary.

typePublishedContent

type PublishedContent = { ... }

One locally published item (/app/v1/published).

typePublishResponse

type PublishResponse = { ... }

Result of a public publish (/app/v1/publish).

typePublishResult

type PublishResult = { ... }

Result of any publish, in domain (camelCase) shape.

typeReference

type Reference = { ... }

The stable identity of a publication: (identity, path).

typeResolveResponse

type ResolveResponse = { ... }

Result of resolving a .jolt address (/app/v1/resolve).

typeTransportRequest

type TransportRequest = CallOptions & { ... }

A JSON (or empty-body) request.

typeTransportUpload

type TransportUpload = CallOptions & { ... }

A multipart upload request (public publish and append).

typeVersioned

type Versioned<T> = { ... }

A versioned, decoded publication: what a read hands back to the app.

functionapiErrorMessage

function apiErrorMessage(error: unknown): string

Map any error thrown by the SDK to a short human-readable message suitable for an app's error banner. Never throws.

functioncreateJoltClient

function createJoltClient(options: JoltClientOptions): JoltClient

Build a JoltClient over a transport and a session-token source.

functionmakeId

function makeId(prefix: string): string

Generate a collision-resistant id with an app-chosen prefix.

functionreferenceKey

function referenceKey(ref: Reference): string

A stable string key for a Reference, for maps and stores.

functionreferenceTarget

function referenceTarget(ref: Reference): string

The .jolt address a Reference resolves through.

classHttpTransport

class HttpTransport implements JoltTransport

The fetch-based transport: reaches the daemon directly by URL, or through dev-server proxy paths via HttpTransport.viteProxy.

new HttpTransport

new HttpTransport(options?: HttpTransportOptions): HttpTransport

request

request<T>(base: ApiBase, path: string, req?: TransportRequest): Promise<T>

Send a JSON request to base + path and parse the JSON response.

upload

upload<T>(base: ApiBase, path: string, req: TransportUpload): Promise<T>

Send a multipart file upload to base + path and parse the JSON response.

viteProxy

static viteProxy(options?: Omit<HttpTransportOptions, "bases" | "daemonUrl">): HttpTransport

The browser dev-server preset: requests go to the /jolt-api (app API) and /jolt-daemon (daemon API) proxy paths on the current origin.

typeHttpTransportOptions

type HttpTransportOptions = { ... }

Configuration for HttpTransport.

classTauriTransport

class TauriTransport implements JoltTransport

The Tauri transport: routes every request through the host shell's Rust commands (tauri-plugin-jolt in plugin mode, or app-defined commands).

new TauriTransport

new TauriTransport(options?: TauriTransportOptions): TauriTransport

request

request<T>(base: ApiBase, path: string, req?: TransportRequest): Promise<T>

Send a JSON request to base + path and parse the JSON response.

upload

upload<T>(base: ApiBase, path: string, req: TransportUpload): Promise<T>

Send a multipart file upload to base + path and parse the JSON response.

typeTauriTransportOptions

type TauriTransportOptions = { ... }

Configuration for TauriTransport.

functionisTauriRuntime

function isTauriRuntime(): boolean

True when running inside a Tauri webview. Use this to choose between TauriTransport and an HTTP transport in apps that also run in a plain browser during development.

re-exportreferenceKey

Re-export of index.referenceKey.

typeFakeJolt

type FakeJolt = { ... }

Handle returned by createFakeJolt.

typeRecordedSend

type RecordedSend = { ... }

An ingress send recorded by the fake.

functioncreateFakeJolt

function createFakeJolt(identity: string): FakeJolt

Create an in-memory fake Jolt for one identity.

const { client, deliverIngress, sent } = createFakeJolt("alice.jolt");
await client.publishJson("/myapp/profile", { name: "Alice" });
const got = await client.read(
  { identity: "alice.jolt", path: "/myapp/profile" },
  (v) => v as { name: string }
);