Sterister
7520b11b25
4.1.0's HTTP RPC for browsers capped at inline payloads (≤ 256 KiB).
4.2.0 unlocks streams: server queues outbound chunks + control
envelopes per peer, browser long-polls the queue. Browser-to-server
writes ride the existing /v1/transfer/<id>/chunk POST routes
unchanged.
For Dispatch this unlocks mod-jar uploads (50 MB) and world-backup
downloads (100+ MB) — the actual reason browser-side @shade/files
matters.
### New API
@shade/sdk:
- shade.transferQueueRoute(opts?) — Hono app with /queue +
/v1/transfer/* routes. Auto-configures the queue transport.
- shade.configureTransfers extended: transport + envelopeTransport
override slots; resolveBaseUrl optional when both supplied.
@shade/transfer:
- OutboundQueue — per-peer monotonic event log with long-poll
semantics, idle-eviction GC, ring-buffered to maxEventsPerPeer.
- QueueTransferTransport — enqueues instead of POSTing.
@shade/files:
- httpClient({ outboundQueueUrl, transferBaseUrl }) — when set,
starts a long-poll drainer + builds a streams-bridge. fs.read /
fs.write of >256 KiB work end-to-end.
- startQueueDrainer(shade, opts) — exported helper for advanced
consumers driving their own drainer.
### Implementation notes
- ClientStreamsBridge's TransformStream had HWM=0 by default which
stalled the drainer's await chain at chunk 4 (writer.write pended
before the consumer's reader was attached). Bumped to HWM=64 so
the receive loop can buffer ahead of the consumer.
### Tests
3 new integration tests in tests/integration/http-rpc-streams.test.ts:
4 MiB streamed read round-trip, inline-only error path, idle-timeout
long-poll behaviour.
Wire-compatible. Source-compatible. Lockstep bump to 4.2.0.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
95 lines
3.6 KiB
TypeScript
95 lines
3.6 KiB
TypeScript
/**
|
|
* Structural surface @shade/files needs from a Shade instance.
|
|
*
|
|
* Defining this locally — instead of `import type { Shade } from '@shade/sdk'`
|
|
* — breaks the @shade/sdk ↔ @shade/files dependency cycle. Without this
|
|
* break, a consumer that installs @shade/sdk from a registry ends up with
|
|
* two distinct `Shade` classes in `node_modules` (one from
|
|
* `@shade/sdk/node_modules/@shade/files/.../Shade`, one from
|
|
* `@shade/sdk/Shade`). TypeScript treats them as nominally different types,
|
|
* raising `this is not assignable to Shade` from inside SDK methods that
|
|
* pass `this` into `createFilesNamespace`.
|
|
*
|
|
* The Shade class structurally implements every member listed below, so
|
|
* `createFilesNamespace(this)` from the SDK side compiles regardless of
|
|
* how many copies of @shade/sdk a consumer's package manager installs.
|
|
*
|
|
* Member signatures match Shade's exactly so this is a structural
|
|
* subtype, not a parallel API.
|
|
*/
|
|
import type { ShadeEnvelope } from '@shade/core';
|
|
import type {
|
|
IncomingTransfer,
|
|
TransferHandle,
|
|
TransferOptions,
|
|
} from '@shade/transfer';
|
|
import type { ObservabilityHook } from '@shade/observability';
|
|
|
|
export interface ShadeBridge {
|
|
/** Address that names this Shade instance to peers. */
|
|
readonly myAddress: string;
|
|
|
|
/** Encrypt + send `plaintext` to `peer`; returns the wire envelope. */
|
|
send(peer: string, plaintext: string): Promise<ShadeEnvelope>;
|
|
|
|
/**
|
|
* Decrypt an inbound envelope from `peer` and return the plaintext.
|
|
* Used by the request-response RPC route on the server side.
|
|
*/
|
|
receive(peer: string, envelope: ShadeEnvelope): Promise<string>;
|
|
|
|
/**
|
|
* Subscribe to incoming ratchet plaintext. Returns an unsubscribe.
|
|
* Handlers may be sync or async; async handlers are awaited in
|
|
* registration order.
|
|
*/
|
|
onMessage(
|
|
handler: (from: string, plaintext: string) => void | Promise<void>,
|
|
): () => void;
|
|
|
|
/**
|
|
* Upload bytes via the SDK's transfer engine. Required when the bridge
|
|
* is used with `streams` content I/O (read/write > 256 KiB).
|
|
*/
|
|
upload(opts: TransferOptions): Promise<TransferHandle>;
|
|
|
|
/** Subscribe to incoming transfers initiated by a peer. */
|
|
onIncomingTransfer(
|
|
handler: (incoming: IncomingTransfer) => void | Promise<void>,
|
|
): Promise<() => void>;
|
|
|
|
/** Fingerprint accessor for the trust-gate hooks. */
|
|
getFingerprintFor(peer: string): Promise<string>;
|
|
|
|
/**
|
|
* Optional inheritable observability bus. Files inherits the bus when
|
|
* the SDK passes one in via the namespace; otherwise files runs without
|
|
* observability hooks.
|
|
*/
|
|
getObservability?(): ObservabilityHook | undefined;
|
|
|
|
/** Optional control-envelope passthrough used by the WebRTC bridge. */
|
|
deliverControlEnvelope?(peer: string, envelope: ShadeEnvelope): Promise<void>;
|
|
|
|
/**
|
|
* Hand a freshly-decoded wire envelope (control or chunk) to the
|
|
* transfer engine. Required by the pull-mode HTTP client when it
|
|
* drains queued events from the server: each polled chunk / control
|
|
* envelope is dispatched here so the engine sees it just as if it
|
|
* had arrived via an HTTP POST on `/v1/transfer/...`.
|
|
*/
|
|
acceptTransferEnvelope?(from: string, env: ShadeEnvelope | Uint8Array): Promise<void>;
|
|
|
|
/**
|
|
* Configure the transfer stack. Called by the pull-mode HTTP client
|
|
* to point the browser's outgoing chunks + control envelopes at the
|
|
* server's transferQueueRoute mount. Optional because the
|
|
* server-to-server path uses a separate, app-driven configuration.
|
|
*/
|
|
configureTransfers?(opts: {
|
|
resolveBaseUrl?: (peerAddress: string) => Promise<string>;
|
|
transport?: unknown;
|
|
envelopeTransport?: unknown;
|
|
}): void;
|
|
}
|