toiljs 0.0.68 → 0.0.70

package/build/client/rpc.js

@@ -1,7 +1,7 @@
 function restMissingStub(path) {
     const call = () => {
         throw new Error(`toiljs REST: ${path}() is unavailable. The generated REST client has not loaded - ` +
-            `import a type from your 'shared/server' (so the client attaches), or run 'npm run build:server'.`);
+            `run 'npm run build:server' to generate shared/server.ts; the client then attaches automatically.`);
     };
     return new Proxy(call, {
         get(_target, prop) {
@@ -17,7 +17,7 @@ function restMissingStub(path) {
 function streamMissingStub(path) {
     const call = () => {
         throw new Error(`toiljs Stream: ${path}() is unavailable. The generated stream client has not loaded - ` +
-            `import a type from your 'shared/server' (so the client attaches), or run 'npm run build:server'.`);
+            `run 'npm run build:server' to generate shared/server.ts; the client then attaches automatically.`);
     };
     return new Proxy(call, {
         get(_target, prop) {
@@ -32,8 +32,8 @@ function streamMissingStub(path) {
 }
 function rpcStub(path) {
     const call = () => {
-        throw new Error(`toiljs RPC: ${path}() is not available yet. The client<->server transport ` +
-            `is not wired; this is a generated stub. Remote calls will work once transport lands.`);
+        throw new Error(`toiljs RPC: ${path}() is unavailable. The generated RPC client has not loaded - ` +
+            `run 'npm run build:server' to generate shared/server.ts; the client then attaches automatically.`);
     };
     return new Proxy(call, {
         get(_target, prop) {
@@ -47,6 +47,11 @@ function rpcStub(path) {
                 const stream = globalThis.__toilStream;
                 return stream !== undefined ? stream : streamMissingStub('Server.Stream');
             }
+            if (path === 'Server') {
+                const rpc = globalThis.__toilRpc;
+                if (rpc !== undefined && prop in rpc)
+                    return rpc[prop];
+            }
             return rpcStub(`${path}.${prop}`);
         },
         apply() {
@@ -55,3 +60,4 @@ function rpcStub(path) {
     });
 }
 export const Server = rpcStub('Server');
+globalThis.Server = Server;

package/build/client/stream/client.js

@@ -5,9 +5,13 @@ function connectStream(url, encode) {
         let opened = false;
         let messageCb;
         let closeCb;
+        const pending = [];
         const channel = {
             onMessage: (cb) => {
                 messageCb = cb;
+                for (const m of pending)
+                    cb(m);
+                pending.length = 0;
             },
             onClose: (cb) => {
                 closeCb = cb;
@@ -16,7 +20,11 @@ function connectStream(url, encode) {
                 if (ws.readyState !== WebSocket.OPEN)
                     return;
                 const bytes = encode ? encode(data) : data;
-                ws.send(bytes);
+                try {
+                    ws.send(bytes);
+                }
+                catch {
+                }
             },
             close: () => {
                 ws.close();
@@ -27,8 +35,13 @@ function connectStream(url, encode) {
             resolve(channel);
         });
         ws.addEventListener('message', (event) => {
-            if (event.data instanceof ArrayBuffer)
-                messageCb?.(new Uint8Array(event.data));
+            if (!(event.data instanceof ArrayBuffer))
+                return;
+            const bytes = new Uint8Array(event.data);
+            if (messageCb)
+                messageCb(bytes);
+            else
+                pending.push(bytes);
         });
         ws.addEventListener('close', (event) => {
             if (!opened)
@@ -42,17 +55,107 @@ function connectStream(url, encode) {
         });
     });
 }
+function connectStreamWT(url, encode) {
+    return new Promise((resolve, reject) => {
+        if (!('WebTransport' in globalThis)) {
+            reject(new Error('WebTransport is not available in this browser'));
+            return;
+        }
+        let transport;
+        try {
+            transport = new WebTransport(url);
+        }
+        catch (e) {
+            reject(e instanceof Error ? e : new Error(String(e)));
+            return;
+        }
+        let messageCb;
+        let closeCb;
+        let writer;
+        let opened = false;
+        const pending = [];
+        const channel = {
+            onMessage: (cb) => {
+                messageCb = cb;
+                for (const m of pending)
+                    cb(m);
+                pending.length = 0;
+            },
+            onClose: (cb) => {
+                closeCb = cb;
+            },
+            send: (data) => {
+                if (!writer)
+                    return;
+                const bytes = encode ? encode(data) : data;
+                void writer.write(bytes).catch(() => { });
+            },
+            close: () => {
+                try {
+                    transport.close();
+                }
+                catch {
+                }
+            },
+        };
+        transport.closed
+            .then((info) => {
+            if (opened)
+                closeCb?.(info?.closeCode ?? 0);
+        })
+            .catch(() => {
+            if (opened)
+                closeCb?.(1);
+        });
+        transport.ready
+            .then(() => {
+            opened = true;
+            writer = transport.datagrams.writable.getWriter();
+            const reader = transport.datagrams.readable.getReader();
+            void (async () => {
+                try {
+                    for (;;) {
+                        const { value, done } = await reader.read();
+                        if (done)
+                            break;
+                        const bytes = value instanceof Uint8Array
+                            ? value
+                            : new Uint8Array(value);
+                        if (messageCb)
+                            messageCb(bytes);
+                        else
+                            pending.push(bytes);
+                    }
+                }
+                catch {
+                }
+            })();
+            resolve(channel);
+        })
+            .catch((e) => reject(e instanceof Error ? e : new Error(String(e))));
+    });
+}
+function openChannel(url, encode) {
+    return url.startsWith('https://')
+        ? connectStreamWT(url, encode)
+        : connectStream(url, encode);
+}
 function defaultOrigin() {
     const loc = globalThis.location;
     return `${loc.protocol === 'https:' ? 'wss:' : 'ws:'}//${loc.host}`;
 }
+function resolveStreamOrigin() {
+    const override = globalThis.__TOIL_STREAM_ORIGIN__;
+    if (typeof override === 'string' && override.length > 0)
+        return override;
+    return defaultOrigin();
+}
 export function makeStreamClient(routes, origin, encoders) {
-    const base = origin ?? defaultOrigin();
     const client = {};
     for (const [name, route] of Object.entries(routes)) {
         const encode = encoders?.[name];
         client[name] = {
-            connect: (path = '') => connectStream(`${base}${route}${path}`, encode),
+            connect: (path = '') => openChannel(`${origin ?? resolveStreamOrigin()}${route}${path}`, encode),
         };
     }
     return client;