@hops-ops/distributed 0.0.0

package/README.md

@@ -0,0 +1,454 @@
+# `@hops-ops/distributed`
+
+The generated, end-to-end typed client for
+[Distributed](https://github.com/hops-ops/distributed) services.
+
+Rust table, relationship, role, and command definitions produce one authorized
+client surface. `dctl client` combines that surface with application GraphQL
+documents and emits typed operations, live companions, route-load plans, and
+commands. This package executes those artifacts through one normalized,
+causally consistent browser replica.
+
+The intended application experience is:
+
+```ts
+const todos = Todos.use();
+const commands = useCommands();
+await commands.todo.create({ title });
+```
+
+Reads populate the replica on demand. Every UI consumer reads that same
+replica. Generated optimistic command effects update it synchronously, and
+server-issued record/index clocks reconcile the authoritative result without
+application-authored cache policies.
+
+## Install
+
+```bash
+npm install @hops-ops/distributed graphql
+```
+
+The package is ESM-only and requires Node 20 or newer for server-side use. It
+also runs in modern browsers. Svelte 5 and React are optional peers used only
+by the `/sveltekit` and `/react` entry points, respectively.
+
+## Generate the client surface
+
+The service, not the browser, owns authorization and GraphQL semantics:
+
+```bash
+dctl client-manifest > target/distributed-client.json
+
+dctl client \
+  --manifest target/distributed-client.json \
+  --role user \
+  --documents 'src/**/*.graphql' \
+  --out src/lib/generated/distributed
+```
+
+Use `--surface <name>` for a named application surface. CI can append `--check`
+to validate that committed artifacts are current without rewriting them.
+
+A co-located route document can opt into SSR and live continuation:
+
+```graphql
+query Todos @load @live {
+  todos(order_by: [{ status: asc }, { todo_id: asc }]) {
+    todo_id
+    title
+    status
+  }
+}
+```
+
+Generation validates the document against the selected role/application,
+injects wire-only identity and revision fields, and emits:
+
+- an exact typed operation and optional live companion;
+- normalization, identity, relationship, filter, order, and pagination plans;
+- the closed variable codec used before cache lookup or transport;
+- a static `@load` route registry;
+- an SSR-safe SvelteKit wrapper with static operation bindings and tree-local
+  client/command access;
+- a nested command tree with input defaults, optimistic effects, and causal
+  confirmation contracts;
+- an exact schema, protocol, and client-surface binding.
+
+Unsupported or unprovable behavior fails during generation. The runtime does
+not parse GraphQL documents, guess cache keys, or infer mutation effects.
+
+## SvelteKit
+
+Install Svelte and describe each generated authorization surface once:
+
+```bash
+npm install svelte
+```
+
+```js
+// distributed.config.js
+const serviceManifestArgs = [
+  'client-manifest',
+  '--manifest-path',
+  '../service/Cargo.toml',
+  '--package',
+  'service'
+];
+
+export const distributedClients = [
+  {
+    module: '$distributed',
+    manifest: { args: serviceManifestArgs },
+    surface: 'fieldnote',
+    documents: ['src/routes/(app)/**/*.graphql'],
+    out: 'src/lib/generated/distributed'
+  },
+  {
+    module: '$distributed/admin',
+    manifest: {
+      args: [
+        ...serviceManifestArgs,
+        '--entrypoint',
+        'service::distributed_admin_client_surface'
+      ]
+    },
+    surface: 'fieldnote-admin',
+    documents: ['src/routes/admin/**/*.graphql'],
+    out: 'src/lib/generated/distributed-admin'
+  }
+];
+
+export const distributedViteOptions = {
+  clients: distributedClients
+};
+```
+
+The common and elevated document sets must not overlap. The route group above
+keeps ordinary application documents out of the admin tree; each trust boundary
+has its own Rust manifest entrypoint, generated directory, virtual module, and
+request-local replica. A single-surface application can omit the second entry.
+
+The Vite integration runs `dctl client` at startup/build, watches GraphQL
+documents, stages all surfaces, commits a rollback-capable multi-output
+transaction, then triggers one reload. It exposes the generated Svelte wrapper
+through the configured virtual module:
+
+```ts
+// vite.config.ts
+import { sveltekit } from '@sveltejs/kit/vite';
+import {
+  distributedGraphqlProxy,
+  distributedSvelteKit
+} from '@hops-ops/distributed/sveltekit/vite';
+import { defineConfig } from 'vite';
+import { distributedViteOptions } from './distributed.config.js';
+
+export default defineConfig({
+  plugins: [distributedSvelteKit(distributedViteOptions), sveltekit()],
+  server: {
+    proxy: distributedGraphqlProxy('http://127.0.0.1:8791')
+  }
+});
+```
+
+Give SvelteKit’s language tools the identical aliases:
+
+```js
+// svelte.config.js
+import {
+  distributedSvelteKitAliases
+} from '@hops-ops/distributed/sveltekit/vite';
+import {
+  distributedClients,
+  distributedViteOptions
+} from './distributed.config.js';
+
+export default {
+  kit: {
+    alias: distributedSvelteKitAliases({
+      cwd: distributedViteOptions.cwd,
+      clients: distributedClients
+    })
+  }
+};
+```
+
+One-shot scripts use the same configuration and transaction:
+
+```js
+import {
+  checkDistributedSvelteKit,
+  generateDistributedSvelteKit
+} from '@hops-ops/distributed/sveltekit/vite';
+import { distributedViteOptions } from './distributed.config.js';
+
+await generateDistributedSvelteKit(distributedViteOptions);
+await checkDistributedSvelteKit(distributedViteOptions); // never writes
+```
+
+Create one request-local server replica in the root layout:
+
+```ts
+// src/routes/+layout.server.ts
+import {
+  createDistributedSvelteKitServer
+} from '@hops-ops/distributed/sveltekit';
+import {
+  DISTRIBUTED_ROUTE_OPERATIONS
+} from '$distributed';
+
+const distributed = createDistributedSvelteKitServer({
+  routes: DISTRIBUTED_ROUTE_OPERATIONS,
+  getSession: ({ locals }) => locals.auth(),
+  getRole: (session) => roleFromSession(session)
+});
+
+export const load = distributed.load;
+```
+
+The browser layout installs one client in Svelte context for the current
+authorization lifecycle. The generated module retains no client singleton:
+
+```ts
+// src/routes/+layout.svelte
+import { browser } from '$app/environment';
+import {
+  createPageDataSessionSource
+} from '@hops-ops/distributed/sveltekit';
+import { provideDistributed } from '$distributed';
+
+let { data, children } = $props();
+const pageData = createPageDataSessionSource(data);
+
+const client = provideDistributed({
+  browser,
+  session: pageData.session,
+  ...(data.distributed !== undefined &&
+  data.distributedAuthority !== undefined
+    ? {
+        hydration: data.distributed,
+        authority: data.distributedAuthority
+      }
+    : {})
+});
+
+$effect(() => pageData.set(data));
+```
+
+Route components import only their generated surface. Static operation wrappers
+resolve the nearest tree-local client when used:
+
+```ts
+// src/routes/todos/+page.svelte
+import { Todos, useCommands } from '$distributed';
+
+const todos = Todos.use(); // generated @live attaches automatically
+const commands = useCommands();
+
+await commands.todo.create({ title: 'Ship it' });
+// $todos.data, $todos.status, $todos.pending
+```
+
+When the Rust command declaration supplies a UUIDv7, ULID, or literal input
+default, generation makes that field optional and the runtime fills it exactly
+once. Components do not generate IDs or maintain optimistic/cache recipes.
+
+`@load` results are normalized on the server, dehydrated, and restored in the
+browser without a duplicate first request. Hydration cannot authorize itself:
+the server sends a separate authority value, and the adapter requires both
+values to match. Session, token, tenant, or role changes abort HTTP and live
+work, discard the old generation, and reconnect under server-issued scope.
+
+Use a separate generated surface and replica for elevated routes. A normal
+client cannot import or mix admin artifacts. Configure it as a separate virtual
+module such as `$distributed/admin` and provide it only in the elevated layout.
+
+## Framework-neutral replica
+
+Other frameworks can bind the same core directly:
+
+```ts
+import {
+  createDistributedReplica,
+  createReplicaGraphqlTransport
+} from '@hops-ops/distributed/replica';
+import { Operation_Todos } from './generated/distributed/index.js';
+
+const transport = createReplicaGraphqlTransport({
+  getUrl: () => '/graphql',
+  getAuth: () => ({ accessToken: session.accessToken })
+});
+const replica = createDistributedReplica({ transport });
+const todos = replica.watch(Operation_Todos, {}, { live: true });
+
+const unsubscribe = todos.subscribe((snapshot) => {
+  render(snapshot.data, snapshot.status);
+});
+```
+
+`watch()` reads synchronously, fetches only missing or stale projections,
+deduplicates work, and optionally maintains the generated live operation.
+`read()` is side-effect-free. `dehydrate()` and `hydrate()` transfer confirmed
+request-local state without exposing a public storage schema.
+
+The replica stores normalized records and exact argument-sensitive indexes,
+not GraphQL response blobs. Generated selection metadata reconstructs each
+operation result from that shared state, so a detail read, list read, live
+frame, or optimistic command can update every affected view in one transaction.
+
+## Commands and optimistic UI
+
+Generated `createCommands` binds the service-owned command artifacts to the
+same replica and GraphQL transport. A command call:
+
+1. validates and freezes its typed input;
+2. fills generated UUIDv7, ULID, or literal defaults exactly once;
+3. applies the generated optimistic effect transaction;
+4. dispatches the exact compiler-owned mutation;
+5. keeps ambiguous commits recoverable by command ID;
+6. confirms or rejects only its own optimistic layer;
+7. resolves projected completion only after exact causal evidence arrives.
+
+Applications do not provide list targets, merge functions, mutation update
+callbacks, or invalidation maps. If the compiler cannot prove safe maintenance,
+the generated plan marks the affected projection stale and the replica performs
+one deduplicated revalidation.
+
+Callers may bound their own causal wait without inventing a rollback:
+
+```ts
+const receipt = await commands.todo.create(
+  { title: 'Ship it' },
+  { signal: AbortSignal.timeout(5_000) }
+);
+await receipt.projected;
+```
+
+Before acceptance the signal cancels dispatch. After finite acceptance it
+rejects only that caller's `receipt.projected` wait; the optimistic layer and
+internal causal tracking remain active, and `receipt.status()` stays available.
+
+## React
+
+Install React and use the optional adapter over an application-owned replica:
+
+```tsx
+import {
+  DistributedProvider,
+  useDistributedQuery
+} from '@hops-ops/distributed/react';
+import { Operation_Todos } from './generated/distributed/index.js';
+
+function TodosView() {
+  const todos = useDistributedQuery(Operation_Todos, {}, { live: true });
+  return todos.complete
+    ? todos.data.todos.map((todo) => <div key={todo.todo_id}>{todo.title}</div>)
+    : null;
+}
+
+root.render(
+  <DistributedProvider replica={replica}>
+    <TodosView />
+  </DistributedProvider>
+);
+```
+
+The adapter is only a `useSyncExternalStore` bridge. It does not add another
+cache, transport, auth lifecycle, or command path. For SSR, create one replica
+per request and hydrate only under the same authoritative scope.
+
+## Persistence and diagnostics
+
+The default replica is memory-only. Optional IndexedDB persistence is explicit,
+confirmed-state-only, and governed by generated/application model policy.
+Optimistic layers, command inputs, credentials, cache authority, and live
+connections are never persisted as replica data.
+
+Diagnostics are also opt-in:
+
+```ts
+import {
+  createReplicaDiagnostics
+} from '@hops-ops/distributed/diagnostics';
+
+const diagnostics = createReplicaDiagnostics();
+const replica = createDistributedReplica({ transport, diagnostics });
+const commands = createCommands(replica, transport, { diagnostics });
+```
+
+Snapshots explain operation artifacts, normalized records, index coverage,
+optimistic layers, causal receipts, revalidation, response fences, and garbage
+collection. Defaults pseudonymize identities and omit values, arguments,
+credentials, trusted presets, raw command inputs, and cache scope. Revealing
+additional development detail requires an in-process capability plus an
+explicit redactor.
+
+## Protocol and security boundaries
+
+Every accepted artifact and response is protocol v1 and carries an exact
+schema/client-surface binding. Every response is also bound to a server-issued
+cache scope, operation ID, and trusted-preset inventory; any supplied record
+clocks or index vector are bound to that same scope. Missing, malformed,
+stale-schema, or cross-surface evidence fails closed. An exact authorized
+payload without a safely comparable index vector may render, but it cannot
+advance index clocks/vectors, observations, live resume, or optimistic
+confirmation. Independently valid record clocks remain usable.
+
+OIDC credentials authorize transport requests; decoded client claims never
+create cache authority. GraphQL remains the API and command proxy layer, while
+the service's SQL read models remain authoritative.
+
+Normative architecture and API decisions live in the Distributed GitKB,
+including `specs/query-layer/v1/cache-engine`. They are intentionally not
+duplicated as decision documents in this package.
+
+## Public entry points
+
+- `@hops-ops/distributed` — GraphQL HTTP/WebSocket, auth, and protocol
+  primitives.
+- `@hops-ops/distributed/replica` — replica, GraphQL transport, generated
+  command runtime, query-plan helpers, and optional persistence.
+- `@hops-ops/distributed/diagnostics` — redacted support snapshots and artifact
+  inspection.
+- `@hops-ops/distributed/sveltekit` — Svelte stores, SSR route loading,
+  hydration, auth lifecycle, and tree-local generated bindings.
+- `@hops-ops/distributed/sveltekit/vite` — Node-only one-shot/check/watch
+  generation, virtual module aliases, and GraphQL HTTP/WebSocket proxy helpers.
+- `@hops-ops/distributed/react` — provider and query hook over the same replica.
+
+All other subpaths are private and blocked by the package export map.
+
+## Pre-release clean break
+
+The earlier pilot API and persistence format are intentionally unsupported.
+There is no `QueryCache`, `CacheTarget`, `ListMergeSpec`, `target/at/by`
+addressing, manual cache-policy map, resource wrapper, document store, legacy
+command pipeline, or package-owned codegen executable.
+
+To move an existing pilot application:
+
+1. rerun `dctl client` and import its operation/command artifacts;
+2. compose one replica through the framework adapter or core transport;
+3. remove handwritten cache targets, merge/update callbacks, and invalidation
+   policies;
+4. discard prior browser cache and SSR payloads rather than migrating them.
+
+Only protocol-v1 generated artifacts and server envelopes are accepted.
+
+## Verification and release
+
+```bash
+npm ci
+npm run quality
+npm run release:dry-run
+```
+
+`quality` typechecks generated consumers, runs behavior and adapter suites,
+packs and installs the real tarball into clean consumers, verifies bundle
+boundaries, and runs `publint`. `release:dry-run` exercises npm's publish
+payload without publishing.
+
+Version tags (`vX.Y.Z`) publish with npm provenance through GitHub Actions
+trusted publishing. The package currently uses `UNLICENSED` because the
+repository has no top-level license file; changing that is an explicit
+maintainer decision.

package/dist/auth-headers.d.ts

@@ -0,0 +1,8 @@
+/** Bearer and DevHeaders mapping shared by HTTP and WebSocket transports. */
+import type { GqlAuth } from './types.js';
+/** HTTP headers for a JSON GraphQL request. */
+export declare function buildAuthHeaders(auth?: GqlAuth): Record<string, string>;
+/** `graphql-transport-ws` connection-init payload. */
+export declare function wsConnectionInitPayload(auth?: GqlAuth): Record<string, string>;
+/** Add DevHeaders to a WebSocket URL when bearer authentication is absent. */
+export declare function applyWsDevHeaderParams(url: URL, auth?: GqlAuth): void;

package/dist/auth-headers.js

@@ -0,0 +1,35 @@
+/** HTTP headers for a JSON GraphQL request. */
+export function buildAuthHeaders(auth = {}) {
+    const headers = { 'content-type': 'application/json' };
+    const token = auth.accessToken?.trim() ?? '';
+    if (token) {
+        headers.authorization = `Bearer ${token}`;
+    }
+    else if (auth.userId) {
+        headers['x-user-id'] = auth.userId;
+        headers['x-role'] = auth.role ?? 'user';
+    }
+    return headers;
+}
+/** `graphql-transport-ws` connection-init payload. */
+export function wsConnectionInitPayload(auth = {}) {
+    const payload = {};
+    const token = auth.accessToken?.trim() ?? '';
+    if (token) {
+        payload.authorization = `Bearer ${token}`;
+        payload.accessToken = token;
+    }
+    else if (auth.userId) {
+        payload['x-user-id'] = auth.userId;
+        payload['x-role'] = auth.role ?? 'user';
+    }
+    return payload;
+}
+/** Add DevHeaders to a WebSocket URL when bearer authentication is absent. */
+export function applyWsDevHeaderParams(url, auth = {}) {
+    const token = auth.accessToken?.trim() ?? '';
+    if (token || !auth.userId)
+        return;
+    url.searchParams.set('x-user-id', auth.userId);
+    url.searchParams.set('x-role', auth.role ?? 'user');
+}

package/dist/diagnostics.d.ts

@@ -0,0 +1,2 @@
+export { createReplicaDevelopmentCapability, createReplicaDiagnostics, inspectReplicaCommandArtifact, inspectReplicaOperationArtifact } from './replica/diagnostics.js';
+export type { ReplicaArtifactSourceLocation, ReplicaCommandArtifactInspection, ReplicaCommandEffectInspection, ReplicaDevelopmentCapability, ReplicaDiagnosticEvent, ReplicaDiagnosticEventInput, ReplicaDiagnosticFieldValueContext, ReplicaDiagnosticFieldValuePolicy, ReplicaDiagnosticIndex, ReplicaDiagnosticIndexInput, ReplicaDiagnosticLayer, ReplicaDiagnosticLayerInput, ReplicaDiagnosticReceipt, ReplicaDiagnosticReceiptExpectationInput, ReplicaDiagnosticReceiptInput, ReplicaDiagnosticRecord, ReplicaDiagnosticRecordInput, ReplicaDiagnosticReasonContext, ReplicaDiagnosticReasonPolicy, ReplicaDiagnostics, ReplicaDiagnosticsOptions, ReplicaDiagnosticsSink, ReplicaDiagnosticsSnapshot, ReplicaDiagnosticScopeInput, ReplicaDiagnosticStateInput, ReplicaOperationArtifactInspection, ReplicaOperationIndexInspection, ReplicaOperationInjectedFieldInspection } from './replica/diagnostics.js';

package/dist/diagnostics.js

@@ -0,0 +1 @@
+export { createReplicaDevelopmentCapability, createReplicaDiagnostics, inspectReplicaCommandArtifact, inspectReplicaOperationArtifact } from './replica/diagnostics.js';

package/dist/document.d.ts

@@ -0,0 +1,8 @@
+/** Normalize GraphQL documents for HTTP and WebSocket wire formats. */
+import { type DocumentNode } from 'graphql';
+import type { TypedDocumentNode } from '@graphql-typed-document-node/core';
+import type { GraphqlVariables } from './types.js';
+/** A source string, GraphQL AST, or code-generated typed document. */
+export type GqlDocument<TData = unknown, TVariables extends GraphqlVariables = GraphqlVariables> = string | DocumentNode | TypedDocumentNode<TData, TVariables>;
+/** Convert a string or AST document to the GraphQL source sent on the wire. */
+export declare function documentToString(document: GqlDocument): string;

package/dist/document.js

@@ -0,0 +1,6 @@
+/** Normalize GraphQL documents for HTTP and WebSocket wire formats. */
+import { print } from 'graphql';
+/** Convert a string or AST document to the GraphQL source sent on the wire. */
+export function documentToString(document) {
+    return typeof document === 'string' ? document : print(document);
+}

package/dist/identity.d.ts

@@ -0,0 +1,23 @@
+/** Authentication identity helpers for display and exact credential fencing. */
+import type { GqlAuth } from './types.js';
+/**
+ * Produce a stable UX identity without embedding a bearer token in labels.
+ *
+ * This value is not authoritative and must never decide cache reuse. JWTs use
+ * the unverified `sub` claim only so UI state can retain a friendly identity
+ * label across refreshes.
+ * Opaque bearer tokens use a non-cryptographic hash of the complete token.
+ * DevHeaders use the user and role pair.
+ */
+export declare function authIdentityKey(auth: GqlAuth): string;
+/**
+ * Exact local credential comparison used only to invalidate in-flight client work.
+ *
+ * It can close a generation, but cannot authorize reuse: only a server-issued
+ * Distributed cache scope does that for the replica.
+ */
+export declare function sameAuthCredential(left: GqlAuth, right: GqlAuth): boolean;
+/** Detach caller-owned auth objects before transport and generation fencing. */
+export declare function snapshotAuthCredential(auth: GqlAuth): Readonly<GqlAuth>;
+/** Decode an unverified JWT payload's `sub` claim for UI cache identity only. */
+export declare function jwtPayloadSub(token: string): string | null;

package/dist/identity.js

@@ -0,0 +1,73 @@
+/**
+ * Produce a stable UX identity without embedding a bearer token in labels.
+ *
+ * This value is not authoritative and must never decide cache reuse. JWTs use
+ * the unverified `sub` claim only so UI state can retain a friendly identity
+ * label across refreshes.
+ * Opaque bearer tokens use a non-cryptographic hash of the complete token.
+ * DevHeaders use the user and role pair.
+ */
+export function authIdentityKey(auth) {
+    const token = auth.accessToken?.trim() ?? '';
+    if (token) {
+        const subject = jwtPayloadSub(token);
+        return subject ? `sub:${subject}` : `bearer:${hashString(token)}`;
+    }
+    return `dev:${auth.userId ?? ''}:${auth.role ?? ''}`;
+}
+/**
+ * Exact local credential comparison used only to invalidate in-flight client work.
+ *
+ * It can close a generation, but cannot authorize reuse: only a server-issued
+ * Distributed cache scope does that for the replica.
+ */
+export function sameAuthCredential(left, right) {
+    const leftToken = left.accessToken?.trim() ?? '';
+    const rightToken = right.accessToken?.trim() ?? '';
+    if (leftToken || rightToken) {
+        return leftToken.length > 0 && leftToken === rightToken;
+    }
+    return ((left.userId ?? '') === (right.userId ?? '') &&
+        (left.role ?? '') === (right.role ?? ''));
+}
+/** Detach caller-owned auth objects before transport and generation fencing. */
+export function snapshotAuthCredential(auth) {
+    return Object.freeze({
+        ...(auth.accessToken === undefined
+            ? {}
+            : { accessToken: auth.accessToken }),
+        ...(auth.userId === undefined ? {} : { userId: auth.userId }),
+        ...(auth.role === undefined ? {} : { role: auth.role })
+    });
+}
+/** Decode an unverified JWT payload's `sub` claim for UI cache identity only. */
+export function jwtPayloadSub(token) {
+    const parts = token.split('.');
+    if (parts.length !== 3 || !parts[1])
+        return null;
+    try {
+        const payload = JSON.parse(base64UrlDecode(parts[1]));
+        return typeof payload.sub === 'string' && payload.sub.length > 0 ? payload.sub : null;
+    }
+    catch {
+        return null;
+    }
+}
+function base64UrlDecode(segment) {
+    if (typeof globalThis.atob !== 'function') {
+        throw new Error('base64 decoding is unavailable in this runtime');
+    }
+    const padding = segment.length % 4 === 0 ? '' : '='.repeat(4 - (segment.length % 4));
+    const binary = globalThis.atob(segment.replace(/-/g, '+').replace(/_/g, '/') + padding);
+    const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+    return new TextDecoder().decode(bytes);
+}
+/** FNV-1a 32-bit: stable obfuscation for opaque tokens, not a security primitive. */
+function hashString(value) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < value.length; index += 1) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(16);
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export type { GqlAuth, GqlError, GqlErrorLocation, GqlResult, GraphqlVariables } from './types.js';
+export { DISTRIBUTED_PROTOCOL_VERSION, DistributedProtocolError, compareDistributedDecimal, distributedLiveResumeExtensions, parseDistributedProtocolEnvelope, parseGraphqlResponseExtensions, type DistributedDecimalString, type DistributedCommandConsistency, type DistributedCommandMetadata, type DistributedCommandState, type DistributedIndexRevision, type DistributedLiveCursor, type DistributedLiveMetadata, type DistributedLiveResumeExtensions, type DistributedOpaqueString, type DistributedProjectionExpectation, type DistributedProjectionObservation, type DistributedProtocolValue, type DistributedProtocolEnvelope, type DistributedProtocolErrorCode, type DistributedQuerySnapshot, type DistributedRecordRevision, type DistributedTrustedPreset, type DistributedTrustedPresetCodec, type GraphqlResponseExtensions } from './protocol.js';
+export { documentToString, type GqlDocument } from './document.js';
+export { applyWsDevHeaderParams, buildAuthHeaders, wsConnectionInitPayload } from './auth-headers.js';
+export { requestGraphql, type FetchLike, type RequestGraphqlOptions } from './request.js';
+export { graphqlWsUrl, httpUrlToWsUrl, subscribe, type GqlWsHandlers, type GqlWsResult, type SubscribeOptions, type WebSocketConstructor } from './websocket.js';
+export { authIdentityKey, jwtPayloadSub } from './identity.js';

package/dist/index.js

@@ -0,0 +1,6 @@
+export { DISTRIBUTED_PROTOCOL_VERSION, DistributedProtocolError, compareDistributedDecimal, distributedLiveResumeExtensions, parseDistributedProtocolEnvelope, parseGraphqlResponseExtensions } from './protocol.js';
+export { documentToString } from './document.js';
+export { applyWsDevHeaderParams, buildAuthHeaders, wsConnectionInitPayload } from './auth-headers.js';
+export { requestGraphql } from './request.js';
+export { graphqlWsUrl, httpUrlToWsUrl, subscribe } from './websocket.js';
+export { authIdentityKey, jwtPayloadSub } from './identity.js';

package/dist/internal/cache-engine/create.d.ts

@@ -0,0 +1,5 @@
+import { cacheIndexKey } from './helpers.js';
+import type { CacheEngine, CacheEngineOptions } from './types.js';
+/** Create the selected private cache-engine implementation. */
+export declare function createCacheEngine(options?: CacheEngineOptions): CacheEngine;
+export { cacheIndexKey };

package/dist/internal/cache-engine/create.js

@@ -0,0 +1,7 @@
+import { PurposeBuiltCacheEngine } from './engine.js';
+import { cacheIndexKey } from './helpers.js';
+/** Create the selected private cache-engine implementation. */
+export function createCacheEngine(options = {}) {
+    return new PurposeBuiltCacheEngine(options);
+}
+export { cacheIndexKey };