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 createDataSubscription(transport: JoltTransport, token: string, identity: string, prefix: string, options?: CallOptions): Promise<DataSubscriptionRecordResponse>

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

function deleteLocalRecord(transport: JoltTransport, token: string, path: string, revision: string, mutationId: string, observedRevisions: undefined | readonly string[], options?: CallOptions): Promise<LocalRecordDeleteResponse>

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 getAppApiFeatures(transport: JoltTransport, options?: CallOptions): Promise<AppApiFeatureManifestResponse>

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

function getDataSubscriptionView(transport: JoltTransport, token: string, subscriptionId: string, options?: CallOptions): Promise<DataSubscriptionViewResponse>

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

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

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

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

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

function nextDataSubscriptionChange(transport: JoltTransport, token: string, subscriptionId: string, cursor?: string, options?: CallOptions): Promise<DataSubscriptionChangeResponse>

function openEncryptedTarget(transport: JoltTransport, token: string, target: string, path?: string, options?: CallOptions): Promise<OpenedEncryptedObject>

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

function pinHomeRelay(transport: JoltTransport, token: string, contentId: string, path?: string, options?: CallOptions): Promise<HomeRelayPinResponse>

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 readLocalRecord(transport: JoltTransport, token: string, path: string, options?: CallOptions): Promise<LocalRecordReadResponse>

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

function removeDataSubscription(transport: JoltTransport, token: string, subscriptionId: string, options?: CallOptions): Promise<RemoveDataSubscriptionResponse>

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

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

function restoreLocalRecord(transport: JoltTransport, token: string, path: string, body: object, revision: string, mutationId: string, observedRevisions: undefined | readonly string[], options?: CallOptions): Promise<LocalRecordRestoreResponse>

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

function updateLocalRecord(transport: JoltTransport, token: string, path: string, body: object, revision: string, mutationId: string, observedRevisions: undefined | readonly string[], options?: CallOptions): Promise<LocalRecordUpdateResponse>

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.

interfaceJoltAvailabilitySdk

Explicit application-owned requests for delegated content availability.

pinHomeRelay

pinHomeRelay(contentId: string, path?: string, options?: CallOptions): Promise<HomeRelayPinResult>

Ask the configured home relay to retain one of this app's own publications.

interfaceJoltCompatibilitySdk

App API compatibility checks that require no app session.

checkCompatibility

checkCompatibility(declaration: AppCompatibilityDeclaration, options?: CompatibilityCheckOptions): Promise<AppCompatibilityResult>

interfaceJoltEncryptedSdk

Encrypted publish and tolerant encrypted reads.

listPublished

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

The local node's published inventory.

openEncrypted

openEncrypted(target: string, path?: string, options?: CallOptions): Promise<OpenEncryptedResult>

Open encrypted content without hiding a ciphertext-only result.

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.

deleteRecord

deleteRecord(ref: Reference, mutation: RecordMutationContext, options?: CallOptions): Promise<RecordDeletedResult>

Compare-and-set one present local stable record to a Tombstone.

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.

readRecord

readRecord(ref: Reference, options?: CallOptions): Promise<RecordReadResult>

Read authoritative local record state without collapsing failures into absence.

resolve

resolve(ref: Reference, options?: CallOptions): Promise<ResolvedReference>

Resolve a reference strictly, preserving daemon errors such as Tombstones.

restoreRecord

restoreRecord(ref: Reference, body: object, mutation: RecordMutationContext, options?: CallOptions): Promise<RecordPresentResult>

Compare-and-set one local Tombstone to new immutable content.

updateRecord

updateRecord(ref: Reference, body: object, mutation: RecordMutationContext, options?: CallOptions): Promise<RecordPresentResult>

Compare-and-set one local stable record against an observed revision.

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.

typeAppApiFeatureManifest

type AppApiFeatureManifest = { ... }

Generic App API behavior available through the connected daemon.

typeAppApiFeatureManifestResponse

type AppApiFeatureManifestResponse = { ... }

/app/v1/features: generic behavior implemented by this App API.

typeAppCompatibilityDeclaration

type AppCompatibilityDeclaration = { ... }

App-owned runtime requirements, independent of daemon release versions.

typeAppCompatibilityDeclarationWire

type AppCompatibilityDeclarationWire = { ... }

JSON representation embedded in signed application update manifests.

typeAppCompatibilityResult

type AppCompatibilityResult = { ... }

Complete compatibility result; applications own optional fallback choices.

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.

typeCompatibilityCheckOptions

type CompatibilityCheckOptions = CallOptions & { ... }

Compatibility call controls; refresh after daemon reconnection.

typeContractLevelCheck

type ContractLevelCheck = { ... }

One comparison between an application requirement and daemon support.

typeCurrentAppSession

type CurrentAppSession = { ... }

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

typeDataSubscriptionChangeResponse

type DataSubscriptionChangeResponse = { cursor: string; identity: string; records: MaterializedRecordInfo[]; state: DataSubscriptionRefreshResponse; type: "snapshot" } | { cursor: string; identity: string; records: MaterializedRecordInfo[]; removed: string[]; type: "changed" } | { cursor: string; state: DataSubscriptionRefreshResponse; type: "state" } | { cursor: string; type: "timeout" } | { type: "resync_required" } | { type: "cancelled" } | { type: "revoked" }

One bounded local Materialized View event returned by a Change Stream poll.

typeDataSubscriptionRecordResponse

type DataSubscriptionRecordResponse = { ... }

Persisted Data Subscription metadata owned by the current app session.

typeDataSubscriptionRefreshResponse

type DataSubscriptionRefreshResponse = { status: "loading" } | { last_verified_at?: number; status: "updating" } | { last_verified_at: number; status: "ready" } | { last_verified_at: number; reason: "networkUnavailable" | "verificationFailed" | "overloaded"; status: "stale" } | { reason: "networkUnavailable" | "verificationFailed" | "overloaded"; status: "unavailable" }

One Data Subscription's last bounded refresh state.

typeDataSubscriptionViewResponse

type DataSubscriptionViewResponse = { ... }

Last verified records plus the outcome of this subscription refresh.

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).

typeHomeRelayPinResponse

type HomeRelayPinResponse = { ... }

Result of requesting availability from the configured home relay.

typeHomeRelayPinResult

type HomeRelayPinResult = { ... }

Confirmation that a home relay accepted an availability request.

typeIngressRecord

type IngressRecord = { ... }

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

typeJoltClient

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

Everything a typical Jolt application needs, in one object.

typeJoltClientOptions

type JoltClientOptions = { ... }

Configuration for createJoltClient.

typeLocalRecordDeleteResponse

type LocalRecordDeleteResponse = { ... }

Successful compare-and-set deletion of one local stable record.

typeLocalRecordHeadResponse

type LocalRecordHeadResponse = { revision: string; state: "deleted" } | { content_id: string; data: number[]; revision: string; state: "present" }

One current or common-base head in a local record conflict.

typeLocalRecordReadResponse

type LocalRecordReadResponse = { path: string; state: "missing" } | { path: string } & LocalRecordHeadResponse | { alternatives: LocalRecordHeadResponse[]; base?: LocalRecordHeadResponse; path: string; state: "conflicted" }

Result of reading one authoritative local singleton path (/app/v1/records/read).

typeLocalRecordRestoreResponse

type LocalRecordRestoreResponse = LocalRecordUpdateResponse

Successful compare-and-set restoration of one local stable record.

typeLocalRecordUpdateResponse

type LocalRecordUpdateResponse = { ... }

Successful compare-and-set write of one local stable record.

typeMaterializedRecordInfo

type MaterializedRecordInfo = { ... }

One current non-deleted logical record in a Materialized View.

typeNodeStatus

type NodeStatus = { ... }

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

typeOpenedEncryptedObject

type OpenedEncryptedObject = { ... }

Encrypted bytes opened with plaintext when this identity can decrypt them.

typeOpenEncryptedResult

type OpenEncryptedResult = { ... }

Encrypted content plus the daemon's honest decrypt/access state.

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.

typeRecordConflictResult

type RecordConflictResult = { ... }

Every current local record head, plus an unambiguous common base when known.

typeRecordDeletedResult

type RecordDeletedResult = { ... }

One authoritative local stable record whose current state is a Tombstone.

typeRecordHeadResult

type RecordHeadResult = RecordDeletedResult | RecordPresentResult

One immutable current or common-base head in a local record conflict.

typeRecordMissingResult

type RecordMissingResult = { ... }

One authoritative local stable record reference that has no current value.

typeRecordMutationContext

type RecordMutationContext = { ... }

Opaque compare-and-set context used by advanced record mutations.

typeRecordPresentResult

type RecordPresentResult = { ... }

One present authoritative local stable record.

typeRecordReadResult

type RecordReadResult = RecordMissingResult | RecordDeletedResult | RecordPresentResult | RecordConflictResult

Strict authoritative state for one local stable record reference.

typeReference

type Reference = { ... }

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

typeRemoveDataSubscriptionResponse

type RemoveDataSubscriptionResponse = { ... }

Terminal result of explicitly removing a Data Subscription.

typeResolvedReference

type ResolvedReference = { ... }

Strict resolution metadata for one logical reference, before content fetch.

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.

functioncreateDataClient

function createDataClient(options: JoltClientOptions): JoltClient & JoltDataSubscriptionSdk

Build the advanced transport required by an already-authorized Data SDK host.

functioncreateJoltClient

function createJoltClient(options: JoltClientOptions): JoltClient

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

functiondecodeAppCompatibilityDeclaration

function decodeAppCompatibilityDeclaration(value: unknown): AppCompatibilityDeclaration

Decode signed update metadata into the transport-independent SDK shape.

functionisContentUnavailableError

function isContentUnavailableError(error: unknown): boolean

Whether a reachable daemon reported that referenced content cannot be fetched.

functionisJoltUnavailableError

function isJoltUnavailableError(error: unknown): boolean

Whether a failed Jolt operation should be presented as unavailable.

Typed transport failures mean the daemon could not be reached. Unstructured HTTP 500 and 502 responses also cover browser development proxies that could not complete the request. A machine-readable API error code proves that the daemon answered and must not be weakened into host unavailability. This classifies the attempt, not the availability of content requested through a reachable daemon.

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.

classAccessRevokedError

The App Session no longer authorizes connected Data SDK operations.

new AccessRevokedError

new AccessRevokedError(options?: ErrorOptions): AccessRevokedError

classAppIncompatibleError

The connected Jolt node cannot provide the behavior declared by this App.

new AppIncompatibleError

new AppIncompatibleError(compatibility: AppCompatibilityResult): AppIncompatibleError

classAppSessionRejectedError

The person using Jolt did not approve the App's derived access request.

new AppSessionRejectedError

new AppSessionRejectedError(status: AppSessionStatus): AppSessionRejectedError

classChangeType

Symbol-backed event kinds emitted by a Materialized View Change Stream.

classConflictError

A mutation observed an older Item revision than the record currently has.

new ConflictError

new ConflictError(ref: Pick<Ref<object>, "path" | "identity">): ConflictError

classDeletedError

Creation was refused because the logical Item is explicitly deleted.

new DeletedError

new DeletedError(ref: Pick<Ref<object>, "path" | "identity">): DeletedError

classDeviceRevokedError

This installation's local device no longer has authority to mutate data.

new DeviceRevokedError

new DeviceRevokedError(options?: ErrorOptions): DeviceRevokedError

classDeviceSigningKeyMismatchError

This installation's persisted device identity conflicts with its authority record.

new DeviceSigningKeyMismatchError

new DeviceSigningKeyMismatchError(options?: ErrorOptions): DeviceSigningKeyMismatchError

classItemUnavailableError

A mutation could not safely proceed because the Item's state is unknown.

new ItemUnavailableError

new ItemUnavailableError(ref: Pick<Ref<object>, "path" | "identity">): ItemUnavailableError

classResourceKind

Symbol-backed kinds used when inspecting a derived App access plan. The class preserves unique-symbol types for direct equality narrowing.

classSchemaMigrationError

An older stored value could not be migrated into the current Schema Class.

new SchemaMigrationError

new SchemaMigrationError(fromVersion: number, toVersion: number, message: string, options?: ErrorOptions): SchemaMigrationError

classSchemaValidationError

A value failed validation against a Schema Class.

new SchemaValidationError

new SchemaValidationError(field: string, message: string): SchemaValidationError

classState

Symbol-backed states for immutable Item snapshots. The class keeps every static Symbol's unique-symbol type so direct equality checks narrow Items.

classSubscriptionCapacityError

The node could not admit another durable Data Subscription.

new SubscriptionCapacityError

new SubscriptionCapacityError(options?: ErrorOptions): SubscriptionCapacityError

classSubscriptionFailure

Symbol-backed explanation for a failed bounded subscription refresh.

classSubscriptionState

Symbol-backed freshness and terminal states for a Data Subscription.

classUnexpectedDataMutationError

Wraps an unrecognized Error thrown by a custom Data SDK client.

new UnexpectedDataMutationError

new UnexpectedDataMutationError(options?: ErrorOptions): UnexpectedDataMutationError

interfaceMigrationPlan

A chain of migrations, keyed by the version each step produces.

to

to(version: number, define: MigrationDefinition): this

typeAppAccessPlan

type AppAccessPlan = { ... }

Inspectable connection input derived from an App's Resource declarations. Requirements and Grants are index-aligned in declared Resource order.

typeAppConnectOptions

type AppConnectOptions = { ... }

Advanced connection seam for an already-authorized Jolt client. It keeps host bootstrap separate from typed Resource behavior.

typeAppDataDefinitions

type AppDataDefinitions = Readonly<Record<string, CollectionDefinition<object, ResourceAccess, ResourceConflicts> | DocumentDefinition<object, ResourceAccess, ResourceConflicts>>>

Named unbound Resources accepted by App.create.

typeAppDefinition

type AppDefinition<TData> = { ... }

A complete application definition with canonically bound Resources.

typeAppInstance

type AppInstance<TData> = mapped & { ... }

The local identity and direct named Resources returned by App.test or App.connect.

typeAppResource

type AppResource<TDefinition> = conditional

The connected Resource surface generated from one Resource definition.

typeAppTestOptions

type AppTestOptions = { ... }

Options for one fresh deterministic App test instance.

typeAppTestWorld

type AppTestWorld<TData> = { ... }

Shared deterministic state that can expose several identity-bound App views.

typeArrayFieldItem

type ArrayFieldItem = SchemaFieldFactory | SchemaFieldDecorator

A primitive or nested Schema Class descriptor accepted by Field.array.

typeAutomaticResourceConflicts

type AutomaticResourceConflicts = { ... }

Automatic conflict behavior used when a Resource declares no override.

typeBoundAppData

type BoundAppData<TData> = mapped

App data definitions after canonical paths have been derived.

typeBoundCollectionDefinition

type BoundCollectionDefinition<T, TAccess, TConflicts> = CollectionDefinition<T, TAccess, TConflicts> & { ... }

A Collection definition bound to its canonical App path prefix.

typeBoundDocumentDefinition

type BoundDocumentDefinition<T, TAccess, TConflicts> = DocumentDefinition<T, TAccess, TConflicts> & { ... }

A Document definition bound to its one canonical App path.

typeBulkMutationResult

type BulkMutationResult<TItem> = { ... }

Indexed partial-success result from independent itemwise mutations.

typeCollectionBulkDeleter

type CollectionBulkDeleter<T, TAccess, TConflicts> = { ... }

Itemwise Collection deletions exposed only when declared in Resource access.

typeCollectionBulkRestorer

type CollectionBulkRestorer<T, TAccess, TConflicts> = { ... }

Itemwise Collection restores exposed only when declared in Resource access.

typeCollectionBulkUpdater

type CollectionBulkUpdater<T, TAccess, TConflicts> = { ... }

Itemwise Collection updates exposed only when declared in Resource access.

typeCollectionCreator

type CollectionCreator<T, TAccess, TConflicts> = { ... }

Collection creation exposed only when declared in Resource access.

typeCollectionDefinition

type CollectionDefinition<T, TAccess, TConflicts> = ResourceDefinition<T, TAccess, query, TConflicts>

An unbound Collection definition created before it belongs to an App.

typeCollectionReader

type CollectionReader<T, TAccess, TConflicts> = { ... }

Read operations shared by every connected Collection surface.

typeCollectionRemoteReader

type CollectionRemoteReader<T, TConflicts> = { ... }

Remote Collection reads exposed only for AnyIdentity access.

typeCollectionResource

type CollectionResource<T, TAccess, TConflicts> = CollectionReader<T, TAccess, TConflicts> & conditional & conditional & conditional & conditional & conditional

A connected Collection surface derived from its access declaration.

typeConflictAlternative

type ConflictAlternative<T> = PresentConflictAlternative<T> | DeletedConflictAlternative<T>

One immutable signed state retained as an unresolved Manual alternative.

typeConflictItem

type ConflictItem<T, TAccess, TConflicts> = conditional & conditional & { ... }

An immutable unresolved state exposed only by a Resource using Manual policy.

typeDataChangeStream

type DataChangeStream<T, TConflicts> = AsyncIterable<DataSubscriptionChange<T, TConflicts>> & { ... }

A cancellable async sequence of local Materialized View changes.

typeDataMutationError

type DataMutationError = SchemaValidationError | SchemaMigrationError | ItemUnavailableError | ConflictError | DeletedError | AccessRevokedError | DeviceRevokedError | DeviceSigningKeyMismatchError | JoltApiError | JoltTransportError | TypeError | UnexpectedDataMutationError

Errors retained on one failed item in a non-atomic bulk mutation.

typeDataSdkClient

type DataSdkClient = Pick<JoltSdk, "publishJson" | "read" | "readContent" | "readRecord" | "resolve" | "updateRecord" | "deleteRecord" | "restoreRecord"> & Pick<JoltDataSubscriptionSdk, "createDataSubscription" | "getDataSubscriptionView" | "nextDataSubscriptionChange" | "removeDataSubscription">

Low-level authorized client operations used by the Data SDK connection seam.

typeDataSubscription

type DataSubscription<T, TConflicts> = { ... }

A typed, refreshable view of one remote Collection.

typeDataSubscriptionChange

type DataSubscriptionChange<T, TConflicts> = { cursor: string; items: readonly SubscribedItem<T, TConflicts>[]; lastVerifiedAt?: number; reason?: SubscriptionFailureValue; state: SubscriptionStateValue; type: query } | { cursor: string; items: readonly SubscribedItem<T, TConflicts>[]; removed: readonly Ref<T>[]; type: query } | { cursor: string; lastVerifiedAt?: number; reason?: SubscriptionFailureValue; state: SubscriptionStateValue; type: query } | { type: query } | { type: query } | { type: query }

One typed event from a local Materialized View Change Stream.

typeDeletedConflictAlternative

type DeletedConflictAlternative<T> = { ... }

One deleted alternative in a Manual conflict.

typeDeletedItem

type DeletedItem<T, TAccess, TConflicts> = ItemSnapshot<T, query, TAccess, TConflicts> & conditional

An immutable Item snapshot whose current state is a Tombstone.

typeDocumentCreator

type DocumentCreator<T, TAccess, TConflicts> = { ... }

Document creation exposed only when declared in Resource access.

typeDocumentDefinition

type DocumentDefinition<T, TAccess, TConflicts> = ResourceDefinition<T, TAccess, query, TConflicts>

An unbound Document definition created before it belongs to an App.

typeDocumentReader

type DocumentReader<T, TAccess, TConflicts> = { ... }

Read operations shared by every connected Document surface.

typeDocumentRemoteReader

type DocumentRemoteReader<T, TConflicts> = { ... }

Remote Document reads exposed only for AnyIdentity access.

typeDocumentResource

type DocumentResource<T, TAccess, TConflicts> = DocumentReader<T, TAccess, TConflicts> & conditional & conditional

A connected Document surface derived from its access declaration.

typeFieldOptions

type FieldOptions = { ... }

Options shared by Schema Class field decorators.

typeIdentity

type Identity = string

A Jolt identity address such as alice.jolt.

typeImmutableValue

type ImmutableValue<T> = conditional

A schema value whose nested object properties and arrays cannot be mutated.

typeItem

type Item<T, TAccess, TConflicts> = PresentItem<T, TAccess, TConflicts> | DeletedItem<T, TAccess, TConflicts> | MissingItem<T, TAccess, TConflicts> | UnavailableItem<T, TAccess, TConflicts> | conditional

Any current immutable state of one logical Item.

typeItemSnapshot

type ItemSnapshot<T, TState, TAccess, TConflicts> = conditional & { ... }

Shared immutable state and narrowing behavior for an Item snapshot.

typeMigrationDefinition

type MigrationDefinition = (value: MigrationValue) => unknown

One deterministic, side-effect-free migration into its declared version.

typeMigrationRenames

type MigrationRenames = Readonly<Record<string, string>>

Source fields mapped to their new field names for a migration.

typeMigrationValue

type MigrationValue = Readonly<Record<string, unknown>>

The immutable object supplied to a migration step.

typeMissingItem

type MissingItem<T, TAccess, TConflicts> = ItemSnapshot<T, query, TAccess, TConflicts>

An immutable Item snapshot for a logical reference with no observed record.

typePresentConflictAlternative

type PresentConflictAlternative<T> = { ... }

One content-bearing alternative in a Manual conflict.

typePresentItem

type PresentItem<T, TAccess, TConflicts> = ItemSnapshot<T, query, TAccess, TConflicts> & conditional & conditional & { ... }

An immutable Item snapshot containing a current schema-valid value.

typeRef

type Ref<T> = { ... }

A stable logical reference to one typed Item.

typeRemoteCollection

type RemoteCollection<T, TConflicts> = CollectionReader<T, { read: query }, TConflicts> & { ... }

A read-only Collection view bound to another identity.

typeRemoteDocument

type RemoteDocument<T, TConflicts> = DocumentReader<T, { read: query }, TConflicts>

A read-only Document view bound to another identity.

typeResolvedResourceConflicts

type ResolvedResourceConflicts<TOverrides> = { ... }

Complete literal conflict behavior derived from a Resource's overrides.

typeResourceAccess

type ResourceAccess = { ... }

Operations an application requests for one Resource.

typeResourceConflictOverrides

type ResourceConflictOverrides = { ... }

Optional advanced overrides for a Resource's automatic conflict behavior.

typeResourceConflicts

type ResourceConflicts = { ... }

Complete conflict behavior resolved for one Resource definition.

typeResourceDefinition

type ResourceDefinition<T, TAccess, TKind, TConflicts> = { ... }

Shared metadata and migration behavior for an unbound Resource.

typeResourceGrantPlan

type ResourceGrantPlan = { ... }

High-level authority requested for one canonically scoped Resource.

typeResourceKindValue

type ResourceKindValue = query | query

One Collection or Document discriminant used throughout Resource definitions.

typeResourceOptions

type ResourceOptions<TAccess, TOverrides> = { ... }

Developer-facing access and conflict declarations for one Resource.

typeResourceRequirement

type ResourceRequirement = { ... }

High-level node behavior required by one declared Resource.

typeResourceSubscriptionPlan

type ResourceSubscriptionPlan = { ... }

One Collection prefix eligible for remote Data Subscriptions.

typeSchemaClass

type SchemaClass<T> = () => T

A decorated application value class used as both runtime schema and TypeScript type.

typeSchemaFieldDecorator

type SchemaFieldDecorator = PropertyDecorator

A property decorator produced by one of the typed Field helpers.

typeSchemaFieldFactory

type SchemaFieldFactory = (options?: FieldOptions) => SchemaFieldDecorator

A primitive field helper that can also describe an Array's item type.

typeSchemaOptions

type SchemaOptions = { ... }

Options for a Schema Class. Versions are positive and start at one.

typeShallowPatch

type ShallowPatch<T> = mapped

A shallow update: omitted fields remain and supplied fields replace whole values.

typeStoredSchemaValue

type StoredSchemaValue = { ... }

One stored schema version and its opaque value.

typeSubscriptionFailureValue

type SubscriptionFailureValue = indexedAccess

typeSubscriptionStateValue

type SubscriptionStateValue = indexedAccess

typeUnavailableItem

type UnavailableItem<T, TAccess, TConflicts> = ItemSnapshot<T, query, TAccess, TConflicts>

An immutable Item snapshot whose current state cannot be determined.

constApp

const App: { ... }

Composes Resource definitions into one application definition.

constCollection

const Collection: { ... }

Defines an unbound typed Collection. App.create derives its path.

constDeleteConflict

const DeleteConflict: { ... }

Conflict policies for a concurrent deletion and update.

constDocument

const Document: { ... }

Defines an unbound typed Document. App.create derives its path.

constField

const Field: { ... }

Typed field decorators for Schema Classes.

constMigrations

const Migrations: { ... }

Builds migrations and provides pure helpers for a current Schema Class.

constRead

const Read: { ... }

Read scopes available to a Resource access declaration.

constSubscription

const Subscription: { ... }

Creates a typed Data Subscription from a remote Collection view.

constUpdateConflict

const UpdateConflict: { ... }

Conflict policies for concurrent updates to the same field.

functionSchema

function Schema(options: SchemaOptions): ClassDecorator

migrate

migrate<T>(schemaClass: SchemaClass<T>, stored: StoredSchemaValue): T

parse

parse<T>(schemaClass: SchemaClass<T>, input: unknown): T

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.

typeFakeJoltOptions

type FakeJoltOptions = { appApi?: number; featureDiscovery?: "advertised"; features?: Readonly<Record<string, number>> } | { appApi?: never; featureDiscovery: "legacy"; features?: never }

App API behavior advertised by a deterministic fake daemon.

typeRecordedSend

type RecordedSend = { ... }

An ingress send recorded by the fake.

functioncreateFakeJolt

function createFakeJolt(identity: string, options?: FakeJoltOptions): 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 }
);