toiljs 0.0.55 → 0.0.56

package/src/devserver/email/config.ts

@@ -94,7 +94,10 @@ export function resolveEmailConfig(
     } else if (providerId === 'gmail' || providerId === 'smtp') {
         provider = 'smtp';
         const isGmail = providerId === 'gmail';
-        const host = envOf(reserved, 'SMTP_HOST') ?? c.smtp?.host?.trim() ?? (isGmail ? 'smtp.gmail.com' : '');
+        const host =
+            envOf(reserved, 'SMTP_HOST') ??
+            c.smtp?.host?.trim() ??
+            (isGmail ? 'smtp.gmail.com' : '');
         if (!host) {
             return { config: null, warning: 'provider `smtp` requires TOIL_EMAIL_SMTP_HOST' };
         }
@@ -102,7 +105,10 @@ export function resolveEmailConfig(
         const user = envOf(reserved, 'SMTP_USER') ?? c.smtp?.user?.trim() ?? from;
         smtp = { host, port, user };
     } else {
-        return { config: null, warning: `unknown email provider "${providerId}" (resend|gmail|smtp)` };
+        return {
+            config: null,
+            warning: `unknown email provider "${providerId}" (resend|gmail|smtp)`,
+        };
     }
 
     return {

package/src/devserver/email/index.ts

@@ -11,11 +11,11 @@
  */
 import { loadEnvFiles } from '../dotenv.js';
 import { EmailCaps } from './caps.js';
-import { resolveEmailConfig, type ResolvedEmailConfig } from './config.js';
-import { sendVia, type OutboundMessage } from './providers.js';
+import { type ResolvedEmailConfig, resolveEmailConfig } from './config.js';
+import { type OutboundMessage, sendVia } from './providers.js';
 import { EmailStatus } from './status.js';
 import { validRecipient } from './validate.js';
-import { parseEmailBlob, type ParsedEmail } from './wire.js';
+import { type ParsedEmail, parseEmailBlob } from './wire.js';
 
 import type { EmailBackendConfig } from 'toiljs/shared';
 

package/src/devserver/email/validate.ts

@@ -17,10 +17,7 @@ export function validRecipient(s: string): boolean {
     if (parts.length !== 2) return false; // not exactly one '@'
     const [local, domain] = parts;
     return (
-        local.length > 0 &&
-        domain.includes('.') &&
-        !domain.startsWith('.') &&
-        !domain.endsWith('.')
+        local.length > 0 && domain.includes('.') && !domain.startsWith('.') && !domain.endsWith('.')
     );
 }
 

package/src/devserver/envelope.ts

@@ -69,15 +69,15 @@ export function encodeRequestEnvelope(req: EnvelopeRequest): Buffer {
     if (path.length > U16_MAX) throw new Error(`path too long: ${String(path.length)} bytes`);
     if (req.headers.length > U16_MAX)
         throw new Error(`too many headers: ${String(req.headers.length)}`);
-    if (req.body.length > U32_MAX) throw new Error(`body too long: ${String(req.body.length)} bytes`);
+    if (req.body.length > U32_MAX)
+        throw new Error(`body too long: ${String(req.body.length)} bytes`);
 
     const headers: { name: Buffer; value: Buffer }[] = [];
     let headersSize = 0;
     for (const [name, value] of req.headers) {
         const n = Buffer.from(name, 'utf8');
         const v = Buffer.from(value, 'utf8');
-        if (n.length > U16_MAX || v.length > U16_MAX)
-            throw new Error(`header too long: ${name}`);
+        if (n.length > U16_MAX || v.length > U16_MAX) throw new Error(`header too long: ${name}`);
         headers.push({ name: n, value: v });
         headersSize += 4 + n.length + v.length;
     }

package/src/devserver/host.ts

@@ -17,8 +17,8 @@
  * `WebAssembly.Instance`, so offering the full surface costs nothing.
  */
 
-import { buildCryptoImports, freshCryptoState, type CryptoState } from './crypto.js';
-import { buildDatabaseImports, freshDbState, type DbDevState } from './database.js';
+import { buildCryptoImports, type CryptoState, freshCryptoState } from './crypto.js';
+import { buildDatabaseImports, type DbDevState, freshDbState } from './database.js';
 import { EmailStatus, getEmailService } from './email/index.js';
 import { parseEmailBlob } from './email/wire.js';
 import { devEnvGet, devEnvGetSecure } from './env.js';
@@ -158,7 +158,12 @@ export function buildHostImports(ref: MemoryRef, state: DispatchState): WebAssem
                 state.status = code >= 100 && code <= 599 ? code : 500;
             },
 
-            set_header: (namePtr: number, nameLen: number, valPtr: number, valLen: number): void => {
+            set_header: (
+                namePtr: number,
+                nameLen: number,
+                valPtr: number,
+                valLen: number,
+            ): void => {
                 if (nameLen > MAX_HEADER_NAME_LEN)
                     throw new Error(`header name too long: ${String(nameLen)} bytes`);
                 if (valLen > MAX_HEADER_VALUE_LEN)
@@ -228,7 +233,9 @@ export function buildHostImports(ref: MemoryRef, state: DispatchState): WebAssem
                 const svc = getEmailService();
                 if (svc === null) {
                     const to = parseEmailBlob(raw)?.to ?? '<unparsed>';
-                    process.stdout.write(`  ✉ dev email_send -> ${to} (no email config; not sent)\n`);
+                    process.stdout.write(
+                        `  ✉ dev email_send -> ${to} (no email config; not sent)\n`,
+                    );
                     return EmailStatus.Sent;
                 }
                 const { status, parsed } = svc.prepare(raw);
@@ -243,7 +250,9 @@ export function buildHostImports(ref: MemoryRef, state: DispatchState): WebAssem
                         process.stdout.write(`  ✉ dev email_send -> ${parsed.to} (${label})\n`);
                     })
                     .catch((e: unknown) => {
-                        process.stdout.write(`  ✉ dev email_send -> ${parsed.to} (error: ${String(e)})\n`);
+                        process.stdout.write(
+                            `  ✉ dev email_send -> ${parsed.to} (error: ${String(e)})\n`,
+                        );
                     });
                 return EmailStatus.Sent; // optimistic; sync wasm can't await the send
             },

package/src/devserver/index.ts

@@ -22,18 +22,23 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
-import { Server, type Request, type Response } from '@dacely/hyper-express';
+import { type Request, type Response, Server } from '@dacely/hyper-express';
 import pc from 'picocolors';
 
 import type { EmailBackendConfig } from 'toiljs/shared';
 
 import { applyCacheRule, lookupCache } from './cache.js';
 import { initEmailService } from './email/index.js';
-import { METHOD_CODES, type EnvelopeRequest } from './envelope.js';
+import { type EnvelopeRequest, METHOD_CODES } from './envelope.js';
 import { WasmServerModule } from './module.js';
-import { proxyToVite, wireWebsocketProxy, type ViteTarget } from './proxy.js';
+import { proxyToVite, type ViteTarget, wireWebsocketProxy } from './proxy.js';
 
-export { METHOD_CODES, encodeRequestEnvelope, decodeResponseEnvelope, unpackHandleResult } from './envelope.js';
+export {
+    METHOD_CODES,
+    encodeRequestEnvelope,
+    decodeResponseEnvelope,
+    unpackHandleResult,
+} from './envelope.js';
 export type { EnvelopeRequest, EnvelopeResponse } from './envelope.js';
 export { WasmServerModule, WasmAbortError, UNHANDLED_HEADER } from './module.js';
 export type { WasmDispatchResult } from './module.js';
@@ -161,7 +166,10 @@ function sendWasmResponse(
         if (!hasContentType) {
             // The edge defaults file bodies to application/octet-stream; in dev we
             // guess from the extension so a guest-served asset renders in the browser.
-            response.header('content-type', MIME[path.extname(file).toLowerCase()] ?? 'application/octet-stream');
+            response.header(
+                'content-type',
+                MIME[path.extname(file).toLowerCase()] ?? 'application/octet-stream',
+            );
         }
         response.sendFile(file);
         return;
@@ -267,7 +275,8 @@ export async function startDevServer(options: DevServerOptions): Promise<Running
                 // A trap (ToilScript abort, OOB, malformed envelope) is isolated to
                 // this request, exactly like the edge poisoning one instance.
                 process.stdout.write(
-                    pc.red(`  ✗ ${request.method} ${request.path} server error: ${String(e)}`) + '\n',
+                    pc.red(`  ✗ ${request.method} ${request.path} server error: ${String(e)}`) +
+                        '\n',
                 );
                 response.status(500).send('internal error\n');
                 return;

package/src/devserver/module.ts

@@ -16,8 +16,8 @@ import fs from 'node:fs';
 import {
     decodeResponseEnvelope,
     encodeRequestEnvelope,
-    unpackHandleResult,
     type EnvelopeRequest,
+    unpackHandleResult,
 } from './envelope.js';
 import { buildHostImports, freshDispatchState, type MemoryRef } from './host.js';
 
@@ -52,21 +52,60 @@ interface HandleExports {
 
 /** Host functions the dev server provides under `env` (see `host.ts`). */
 const PROVIDED_IMPORTS = new Set([
-    'abort', 'set_status', 'set_header', 'respond_file', 'thread_spawn', 'Date.now',
-    'client_ip', 'ratelimit_check', 'email_send', 'env_get', 'env_get_secure',
+    'abort',
+    'set_status',
+    'set_header',
+    'respond_file',
+    'thread_spawn',
+    'Date.now',
+    'client_ip',
+    'ratelimit_check',
+    'email_send',
+    'env_get',
+    'env_get_secure',
     // Web Crypto host functions (see ./crypto.ts).
-    'crypto.fill_random', 'crypto.random_uuid', 'crypto.take_result', 'crypto.digest',
-    'crypto.import_key', 'crypto.export_key', 'crypto.encrypt', 'crypto.decrypt',
-    'crypto.sign', 'crypto.verify', 'crypto.derive_bits',
-    'crypto.mldsa_verify', 'crypto.mlkem_decapsulate', 'crypto.voprf_evaluate',
+    'crypto.fill_random',
+    'crypto.random_uuid',
+    'crypto.take_result',
+    'crypto.digest',
+    'crypto.import_key',
+    'crypto.export_key',
+    'crypto.encrypt',
+    'crypto.decrypt',
+    'crypto.sign',
+    'crypto.verify',
+    'crypto.derive_bits',
+    'crypto.mldsa_verify',
+    'crypto.mlkem_decapsulate',
+    'crypto.voprf_evaluate',
     // ToilDB data API (see ./database.ts). Backed by ScyllaDB on the production
     // edge; backs the auth example's accounts + login challenges in dev.
-    'data.resolve_collection', 'data.get', 'data.get_many', 'data.exists', 'data.create',
-    'data.patch', 'data.delete', 'data.get_delete',
-    'data.unique_lookup', 'data.unique_claim', 'data.unique_release',
-    'data.view_get', 'data.view_publish',
-    'data.membership_contains', 'data.membership_add', 'data.membership_remove', 'data.membership_list',
-    'data.counter_get', 'data.counter_add', 'data.append', 'data.latest',
+    'data.resolve_collection',
+    'data.get',
+    'data.get_many',
+    'data.exists',
+    'data.create',
+    'data.patch',
+    'data.delete',
+    'data.get_delete',
+    'data.unique_lookup',
+    'data.unique_claim',
+    'data.unique_release',
+    'data.view_get',
+    'data.view_publish',
+    'data.membership_contains',
+    'data.membership_add',
+    'data.membership_remove',
+    'data.membership_list',
+    'data.counter_get',
+    'data.counter_add',
+    'data.append',
+    'data.latest',
+    'data.capacity_set_total',
+    'data.capacity_available',
+    'data.capacity_reserve',
+    'data.capacity_confirm',
+    'data.capacity_cancel',
     'data.take_result',
 ]);
 
@@ -204,7 +243,10 @@ export class WasmServerModule {
     /** Fail instantiation up front, with names, when the guest needs imports we do not provide. */
     private assertImportSurface(module: WebAssembly.Module): void {
         const missing = WebAssembly.Module.imports(module)
-            .filter((i) => i.kind === 'function' && (i.module !== 'env' || !PROVIDED_IMPORTS.has(i.name)))
+            .filter(
+                (i) =>
+                    i.kind === 'function' && (i.module !== 'env' || !PROVIDED_IMPORTS.has(i.name)),
+            )
             .map((i) => `${i.module}.${i.name}`);
         if (missing.length > 0)
             throw new Error(

package/src/devserver/proxy.ts

@@ -6,12 +6,7 @@
  * websocket through Node's built-in `WebSocket` client, both loopback-only.
  */
 
-import {
-    type Request,
-    type Response,
-    type Server,
-    type Websocket,
-} from '@dacely/hyper-express';
+import { type Request, type Response, type Server, type Websocket } from '@dacely/hyper-express';
 
 /** Where the internal Vite dev server listens (always loopback). */
 export interface ViteTarget {
@@ -151,7 +146,10 @@ export function wireWebsocketProxy(app: Server, target: ViteTarget): void {
                 else pending.push(m);
             });
             ws.on('close', () => {
-                if (upstream.readyState === WebSocket.OPEN || upstream.readyState === WebSocket.CONNECTING) {
+                if (
+                    upstream.readyState === WebSocket.OPEN ||
+                    upstream.readyState === WebSocket.CONNECTING
+                ) {
                     upstream.close();
                 }
             });