@weft-js/start 0.1.0 → 0.1.1

package/README.md

@@ -1,6 +1,6 @@
 # @weft-js/start
 
-> **Early release (0.1.0).** APIs will change between minor versions.
+> **Early release (0.1.1).** APIs will change between minor versions.
 
 The full-stack part of weft: routes from files, server functions, server rendering with streaming, a database, auth and
 realtime. It runs on Node, Bun or Deno, and doesn't need Rust. An app made with `npm create @weft-js` already has it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weft-js/start",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "weft Start: file routes, server functions, streaming SSR, a database and auth",
   "license": "MIT",
   "type": "module",
@@ -20,7 +20,7 @@
     "drizzle-zod": "^0.8.0",
     "mysql2": "^3.24.0",
     "postgres": ">=3",
-    "@weft-js/core": "^0.1.0",
+    "@weft-js/core": "^0.1.1",
     "zod": "^4.0.0"
   },
   "exports": {

package/src/app.mjs

@@ -8,6 +8,7 @@ import { createBuilder, createServer } from 'vite'
 import { nitro } from 'nitro/vite'
 import weft from '@weft-js/core/vite'
 import { devRunner, devSockets } from './dev-runtime.mjs'
+import { holdsSockets } from './live-target.mjs'
 import weftStart, { startDir } from './vite.mjs'
 
 /** An app with a `channel` or `sharedState`: only those pay for crossws in the server bundle (research 32 §1). */
@@ -27,6 +28,8 @@ function config({ root, site, hydration, preset, port, logLevel, command, nitro:
     configFile: user ?? false,
     logLevel,
     server: { port: port ?? 5173, strictPort: port !== undefined },
+    // A function host can't hold a socket: the page goes straight to SSE, and a channel says `unavailable` (R024)
+    ...(command === 'build' && { define: { __WEFT_SOCKETS__: JSON.stringify(holdsSockets(preset)) } }),
     plugins: [
       weft({ hydratable: true }),
       weftStart({ root, site, hydration }),
@@ -52,10 +55,17 @@ function config({ root, site, hydration, preset, port, logLevel, command, nitro:
   }
 }
 
+/** Where the last build's Nitro wrote, known once it prerenders: a preset may move it (netlify serves `dist`). */
+let wrote
+
 function immutableCards() {
   let built
   return {
-    'prerender:generate'(_route, instance) { built = instance },
+    'prerender:generate'(_route, instance) {
+      built = instance
+      const { dir, publicDir } = instance.options.output
+      wrote = publicDir.startsWith(dir) ? dir : publicDir
+    },
     'prerender:done'({ prerenderedRoutes }) {
       if (!built) return
       for (const r of prerenderedRoutes) {
@@ -73,10 +83,11 @@ export async function dev(options) {
   return server
 }
 
-/** Build client and server into `.output/` for `preset` (node by default; bun, deno_server…). */
+/** Build client and server for `preset` (node by default; bun, deno_server…), into `.output/` unless the preset moves it. */
 export async function build(options) {
   process.env.WEFT_START_DIR ??= startDir // for the share cards a build draws (og/native.mjs)
   const builder = await createBuilder(config({ ...options, command: 'build' }))
+  wrote = undefined
   await builder.buildApp()
-  return { output: join(resolve(options.root), '.output') }
+  return { output: wrote ?? join(resolve(options.root), '.output') }
 }

package/src/channel.ts

@@ -4,7 +4,7 @@
 // `runtime.channels`, so nothing of the server ships here.
 
 import { Box, DEV, batch, collect as boxes, createRoot, derived, effect, getOwner, onCleanup, state, untrack, type Derived, type State } from '@weft-js/core'
-import { HANDOVER, openLine, socketDown } from './link'
+import { HANDOVER, SOCKETS, openLine, socketDown } from './link'
 import { currentScope, fns, FnError, keyOf, net, rt, runtime, skip, StartError, track, type Context, type Fn, type Skip, type StandardSchemaV1 } from './data'
 
 // ---- definitions ----------------------------------------------------------------------------------------------------
@@ -15,8 +15,11 @@ type Schemas = Record<string, StandardSchemaV1>
 type Inputs<T extends Schemas> = { [K in keyof T]: In<T[K]> }
 type Outputs<T extends Schemas> = { [K in keyof T]: Out<T[K]> }
 
-/** Where a connection stands; `unauthorized` waits for `rejoin`. */
-export type ChannelStatus = 'connecting' | 'open' | 'reconnecting' | 'closed' | 'unauthorized'
+/**
+ * Where a connection stands; `unauthorized` waits for `rejoin`. `unavailable`: this deploy can't hold a socket (a
+ * function host, R024), so nothing connects and nothing is retried.
+ */
+export type ChannelStatus = 'connecting' | 'open' | 'reconnecting' | 'closed' | 'unauthorized' | 'unavailable'
 
 /** `room.publish`: who a message goes to, and whether it can be replayed. */
 export interface PublishOptions {
@@ -363,6 +366,7 @@ const acks = new Map<number, { ok: () => void; no: (e: unknown) => void; n: numb
 let ackId = 0
 
 async function post(j: Join, name: string, message: unknown): Promise<void> {
+  if (!SOCKETS && !(DEV && net())) throw new FnError({ code: 'R024', message: "this deploy can't hold a socket: not sent" }, 503)
   if (!j.joined && !j.refused) {
     await new Promise<void>(ok => {
       const done = () => {
@@ -444,6 +448,8 @@ function rejoin(j: Join) {
 
 function start() {
   if (running) return
+  // a function host: no socket to dial, so say so once instead of retrying forever
+  if (!SOCKETS && !(DEV && net())) return statusAll('unavailable')
   running = true
   queueMicrotask(() => void run())
 }

package/src/contract.mjs

@@ -7,7 +7,7 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from
 import { join, resolve } from 'node:path'
 import { createServer } from 'vite'
 import weft from '@weft-js/core/vite'
-import { literalSecrets, livePlan, refusal, resolveTarget, scanRequired } from './live-target.mjs'
+import { holdsSockets, literalSecrets, liveTarget, livePlan, refusal, resolveTarget, scanRequired } from './live-target.mjs'
 import { readMigrations } from './migrations.mjs'
 import { shapeTree, toJson } from './shape.mjs'
 import weftStart, { startDir } from './vite.mjs'
@@ -151,7 +151,7 @@ const MULTI = /^(vercel|netlify|aws[-_]|azure|cloudflare|firebase|deno[-_]deploy
 const usesLive = root => {
   const walk = dir => readdirSync(dir, { withFileTypes: true }).some(d => {
     const f = join(dir, d.name)
-    return d.isDirectory() ? walk(f) : /\.[cm]?[jt]sx?$/.test(d.name) && /\.live\(/.test(readFileSync(f, 'utf8'))
+    return d.isDirectory() ? walk(f) : /\.[cm]?[jt]sx?$/.test(d.name) && /[\w)\]]\.live\(/.test(readFileSync(f, 'utf8'))
   })
   return existsSync(join(root, 'src')) && walk(join(root, 'src'))
 }
@@ -287,7 +287,11 @@ export function writeContract({ root, site = {}, preset, rust, live, verify }) {
   return withFns({ root, site }, async (fns, server) => {
     const { diagnostics, ...contract } = describe(fns, rust)
     const mod = await server.ssrLoadModule('virtual:weft/realtime')
-    const bus = busProblem({ preset, bus: mod.default?.bus?.name ?? 'memory', streams: [...fns.values()].some(f => f.kind === 'stream' || f.kind === 'channel' || f.kind === 'shared'), root })
+    const socket = [...fns.values()].find(f => f.kind === 'channel' || f.kind === 'shared')
+    // a channel needs the socket itself: on a function host no bus helps, so R024 says where it can run instead of R002
+    const unheld = socket && !holdsSockets(preset)
+    if (unheld) diagnostics.push({ code: 'R024', severity: 'error', why: `\`${socket.$id.replace(/\..*$/, '')}\` is a ${socket.kind === 'shared' ? 'shared state' : 'channel'}, which needs a WebSocket, and ${liveTarget(preset).host} on \`${preset}\` can't hold one: the page loads, and the channel says \`unavailable\`. \`weft deploy hosts\` lists the hosts that can (Fly, Render).` })
+    const bus = busProblem({ preset, bus: mod.default?.bus?.name ?? 'memory', streams: [...fns.values()].some(f => f.kind === 'stream' || (!unheld && (f.kind === 'channel' || f.kind === 'shared'))), root })
     if (bus) diagnostics.push({ code: 'R002', severity: 'error', why: `${bus}. Add \`@weft-js/realtime-redis\` or \`@weft-js/realtime-nats\` to \`plugins\`, or set \`postgresBus\` in \`src/realtime.server.ts\`.` })
     diagnostics.push(...planOf({ root, preset, realtime: mod.default }).diagnostics)
     let verified = []

package/src/link.ts

@@ -145,10 +145,15 @@ interface Mine { id: string; hello: string; frame(text: string): void; closed(co
 const lines = new Map<string, Mine>()
 let nth = 0
 
+declare const __WEFT_SOCKETS__: boolean | undefined
+/** Whether this deploy can hold a socket. `weft build` says no for a function host (Netlify, Vercel, Lambda…). */
+export const SOCKETS = typeof __WEFT_SOCKETS__ === 'undefined' || __WEFT_SOCKETS__
+
 /** Sockets that never said hello in a row: the page's way to learn this host has none. */
 export let socketFailures = 0
-/** The one who asked goes round SSE once, and the socket gets another chance after. */
+/** The one who asked goes round SSE once, and the socket gets another chance after. Where the build said none, always. */
 export const noSockets = () => {
+  if (!SOCKETS) return true
   const none = socketFailures >= 2
   if (none) socketFailures = 0
   return none
@@ -351,7 +356,7 @@ function forward(owner: string, text: string) {
 }
 
 function wantSocket() {
-  if (ws || retry !== undefined || !election?.leading() || offline()) return
+  if (!SOCKETS || ws || retry !== undefined || !election?.leading() || offline()) return
   if (!attempt) return dial()
   retry = setTimeout(() => {
     retry = undefined

package/src/live-target.mjs

@@ -23,6 +23,9 @@ export function liveTarget(preset = 'node') {
   return hit ? { preset, held: false, host: hit[1] } : { preset, held: true, host: 'a long-running server' }
 }
 
+/** Whether a deploy can hold a browser's socket: a long-running server, a Durable Object, or Deno's upgraded request. */
+export const holdsSockets = (preset = 'node') => liveTarget(preset).held || /^(cloudflare[-_]durable|deno[-_]deploy)/.test(preset)
+
 const SKIP = new Set(['node_modules', '.weft', '.output', 'dist'])
 
 /** `live: { required: true }` on a query, and `.live(input, { required: true })` in a component, with where. */

package/src/run.tsx

@@ -62,6 +62,10 @@ export async function start(routes: ClientRoutes, options: { container?: Element
   let warm: { path: string; at: number; res: Promise<Response> } | undefined
   // A fade pictures the whole page twice, and the picture holds up every frame. Where that's slow, the page just changes.
   let fades = !(navigator.hardwareConcurrency <= 4)
+  // A navigation before the first frame (a moved page's onMount) has no old picture to hold: Chrome aborts that
+  // transition and logs an InvalidStateError. Two frames in, the page has painted.
+  let painted = false
+  requestAnimationFrame(() => requestAnimationFrame(() => (painted = true)))
   async function go(href: string, opts: NavigateOptions & { pop?: boolean; hops?: number } = {}): Promise<void> {
     const url = new URL(href, location.href)
     if (url.origin !== location.origin) return location.assign(url.href)
@@ -100,7 +104,7 @@ export async function start(routes: ClientRoutes, options: { container?: Element
       }
     }
     // The old page stays on screen, as a picture, until the new one is ready to fade in. `hidden`: nothing would show it.
-    if (fades && document.startViewTransition && !document.hidden && !matchMedia('(prefers-reduced-motion: reduce)').matches) {
+    if (fades && painted && document.startViewTransition && !document.hidden && !matchMedia('(prefers-reduced-motion: reduce)').matches) {
       const started = performance.now()
       const fade = document.startViewTransition(swap)
       void fade.ready.then(() => { if (performance.now() - started > SLOW_FADE) fades = false }, () => {})

package/src/server.tsx

@@ -147,6 +147,13 @@ const CARD = { width: 1200, height: 630 }
 const stores = () => ({ createMutableStore: createNonReactiveMutableStore, createReadonlyStore: createNonReactiveReadonlyStore, batch: (f: () => void) => f() })
 const json = (v: unknown) => JSON.stringify(v ?? null).replace(/</g, '\\u003c')
 const esc = (s: string) => s.replace(/[&<"]/g, c => (c === '&' ? '&amp;' : c === '<' ? '&lt;' : '&quot;'))
+/**
+ * A redirect's body. A server's 3xx is followed by its `location`; a prerendered one is a file on a static host, and this
+ * is what that file says: go now, and the address to index. No stylesheet, so no view transition starts on a page
+ * that never paints (Chrome aborts it, and logs an InvalidStateError).
+ */
+const moved = (href: string) =>
+  `<!doctype html><html lang="en"><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>Moved</title><meta name="robots" content="noindex"><link rel="canonical" href="${esc(href)}"><meta http-equiv="refresh" content="0; url=${esc(href)}"><a href="${esc(href)}">Moved here</a>`
 const thenable = (v: unknown): v is PromiseLike<unknown> => typeof (v as Partial<PromiseLike<unknown>> | null | undefined)?.then === 'function'
 
 /** The origin a head's URLs are built on, or none: then canonical and og:url stay out. */
@@ -365,7 +372,7 @@ export function createHandler(options: HandlerOptions) {
   async function page(url: URL, request: Request, scope: Scope): Promise<Response> {
     const path = url.pathname + url.search
     const r = await resolve(path, request)
-    if (r.redirect) return withHeaders(new Response(null, { status: r.redirect.status, headers: { location: r.redirect.href, 'cache-control': 'no-cache' } }), scope)
+    if (r.redirect) return withHeaders(new Response(moved(r.redirect.href), { status: r.redirect.status, headers: { location: r.redirect.href, 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-cache' } }), scope)
     scope.started = true // from here a redirect can't change the status (Q007)
     // The server renders from the raw data (deferred fields are still promises, for Boundaries to stream); the page
     // carries the settled part.