@rip-lang/server 1.3.125 → 1.4.1

package/tests/config.rip

@@ -0,0 +1,215 @@
+import { test, eq, ok } from './runner.rip'
+import { normalizeConfig, summarizeConfig, formatConfigErrors } from '../serving/config.rip'
+
+getErrors = (fn) ->
+  try
+    fn()
+    []
+  catch e
+    e.validationErrors or []
+
+test "normalizeConfig accepts composable groups rules and certs", ->
+  normalized = normalizeConfig(
+    certs:
+      trusthealth: '/ssl/trusthealth.com'
+    rules:
+      web: [
+        { path: '/*', app: 'web' }
+      ]
+    groups:
+      publicWeb: ['example.com', 'www.example.com']
+    apps:
+      web:
+        entry: './web/index.rip'
+    hosts:
+      publicWeb:
+        hosts: 'publicWeb'
+        cert: 'trusthealth'
+        rules: 'web'
+  , '/srv')
+  eq normalized.kind, 'serve'
+  eq Object.keys(normalized.sites).length, 2
+  eq normalized.sites['example.com'].routes[0].app, 'web'
+  eq normalized.sites['www.example.com'].routes[0].app, 'web'
+  ok normalized.resolvedCerts['example.com']
+  ok normalized.resolvedCerts['www.example.com']
+
+test "normalizeConfig accepts map-literal style grouped host keys", ->
+  normalized = normalizeConfig(
+    certs:
+      shared: '/ssl/shared'
+    rules:
+      web: [
+        { path: '/*', app: 'web' }
+      ]
+    apps:
+      web:
+        entry: './web/index.rip'
+    hosts: *{
+      ['example.com', 'foo.bar.com', 'larry.me.org']:
+        cert: 'shared'
+        rules: 'web'
+    }
+  , '/srv')
+  eq Object.keys(normalized.sites).length, 3
+  eq normalized.sites['foo.bar.com'].routes[0].app, 'web'
+  ok normalized.resolvedCerts['larry.me.org']
+
+test "normalizeConfig allows rule-set refs mixed with inline rules", ->
+  normalized = normalizeConfig(
+    rules:
+      web: [
+        { path: '/*', app: 'web' }
+      ]
+    proxies:
+      api:
+        hosts: ['http://127.0.0.1:4000']
+    apps:
+      web:
+        entry: './web/index.rip'
+    hosts:
+      'example.com':
+        rules: [
+          { path: '/api/*', proxy: 'api' }
+          'web'
+        ]
+  , '/srv')
+  eq normalized.sites['example.com'].routes.length, 2
+  eq normalized.sites['example.com'].routes[0].proxy, 'api'
+  eq normalized.sites['example.com'].routes[1].app, 'web'
+
+test "normalizeConfig preserves verify policy", ->
+  normalized = normalizeConfig(
+    edge:
+      verify:
+        requireHealthyProxies: false
+        requireReadyApps: true
+        includeUnroutedManagedApps: false
+        minHealthyTargetsPerProxy: 2
+    hosts:
+      '*.example.com':
+        root: '/mnt/site'
+  , '/srv')
+  eq normalized.server.verify.requireHealthyProxies, false
+  eq normalized.server.verify.includeUnroutedManagedApps, false
+  eq normalized.server.verify.minHealthyTargetsPerProxy, 2
+
+test "normalizeConfig accepts TCP proxies and streams", ->
+  normalized = normalizeConfig(
+    proxies:
+      incus:
+        hosts: ['tcp://127.0.0.1:8443']
+    hosts:
+      '*.example.com':
+        root: '/mnt/site'
+    streams: [
+      { listen: 8443, sni: ['incus.example.com'], proxy: 'incus' }
+    ]
+  , '/srv')
+  ok normalized.streamUpstreams['incus']
+  eq normalized.streams.length, 1
+
+test "normalizeConfig rejects wildcard ACME domains", ->
+  errors = getErrors ->
+    normalizeConfig(
+      server:
+        acme: ['*.example.com']
+      hosts:
+        '*.example.com':
+          root: '/mnt/site'
+    , '/srv')
+  ok errors.some((err) -> err.code is 'E_ACME_WILDCARD')
+
+test "normalizeConfig rejects unknown rule-set references", ->
+  errors = getErrors ->
+    normalizeConfig(
+      hosts:
+        '*.example.com':
+          rules: 'missing'
+    , '/srv')
+  ok errors.some((err) -> err.code is 'E_RULE_UNKNOWN')
+
+test "normalizeConfig rejects inline app definitions on host blocks", ->
+  errors = getErrors ->
+    normalizeConfig(
+      hosts:
+        'api.example.com':
+          app:
+            entry: './api/index.rip'
+    , '/srv')
+  ok errors.some((err) -> err.code is 'E_SERVER_APP_INLINE')
+
+test "normalizeConfig rejects duplicate hosts after expansion", ->
+  errors = getErrors ->
+    normalizeConfig(
+      groups:
+        publicWeb: ['example.com']
+      hosts:
+        publicWeb:
+          hosts: 'publicWeb'
+          root: '/srv/site'
+        'example.com':
+          root: '/srv/other'
+    , '/srv')
+  ok errors.some((err) -> err.code is 'E_HOST_DUPLICATE')
+
+test "normalizeConfig infers HTTP and TCP proxy kinds from hosts", ->
+  normalized = normalizeConfig(
+    proxies:
+      api:
+        hosts: ['http://127.0.0.1:4000']
+        check:
+          path: '/health'
+      incus:
+        hosts: ['tcp://127.0.0.1:8443']
+    hosts:
+      'example.com':
+        rules: [{ path: '/api/*', proxy: 'api' }]
+      'incus.example.com':
+        proxy: 'incus'
+  , '/srv')
+  eq normalized.proxies.api.kind, 'http'
+  eq normalized.proxies.incus.kind, 'tcp'
+  eq normalized.streams[0].proxy, 'incus'
+
+test "normalizeConfig rejects mixed proxy host kinds", ->
+  errors = getErrors ->
+    normalizeConfig(
+      proxies:
+        bad:
+          hosts: ['http://127.0.0.1:4000', 'tcp://127.0.0.1:8443']
+      hosts:
+        'example.com':
+          root: '/srv/site'
+    , '/srv')
+  ok errors.some((err) -> err.code is 'E_PROXY_KIND_MIX')
+
+test "formatConfigErrors includes code path and hint", ->
+  output = formatConfigErrors('serve.rip', [
+    code: 'E_ROUTE_ACTION'
+    path: 'hosts.publicWeb.rules[0]'
+    message: 'route must define exactly one action'
+    hint: 'Choose one action field per route.'
+  ])
+  ok output.includes('[E_ROUTE_ACTION]')
+  ok output.includes('hosts.publicWeb.rules[0]')
+  ok output.includes('Hint:')
+
+test "summarizeConfig reports canonical counts", ->
+  summary = summarizeConfig('/srv/serve.rip',
+    kind: 'serve'
+    version: 1
+    server: {}
+    proxies: { app: { id: 'app', kind: 'http', hosts: ['http://127.0.0.1:3000'] } }
+    apps: { web: { entry: '/srv/web/index.rip' } }
+    sites:
+      'example.com':
+        routes: [{ path: '/*', app: 'web' }]
+      'www.example.com':
+        routes: [{ path: '/*', app: 'web' }]
+    streams: []
+  )
+  eq summary.counts.proxies, 1
+  eq summary.counts.apps, 1
+  eq summary.counts.hosts, 2
+  eq summary.counts.routes, 2

package/tests/control.rip

@@ -1,4 +1,4 @@
-import { test, eq, ok } from '../test.rip'
+import { test, eq, ok } from './runner.rip'
 import { handleReloadControl } from '../control/control.rip'
 
 test "handleReloadControl ignores non-POST requests", ->

package/tests/{runtime_entrypoints.rip → entrypoints.rip}

@@ -1,12 +1,16 @@
-import { test, eq, ok } from '../test.rip'
+import { test, eq, ok } from './runner.rip'
+import { dirname, join } from 'node:path'
 import { coerceInt, computeSocketPrefix, parseFlags } from '../control/cli.rip'
-import { createEdgeRuntime, createReloadHistoryEntry } from '../edge/runtime.rip'
+import { createServingRuntime, createReloadHistoryEntry } from '../serving/runtime.rip'
+
+serverDir = dirname(import.meta.dir)
+defaultRip = join(serverDir, 'browse.rip')
 
 test "control cli helpers load and parse basic flags", ->
-  flags = parseFlags(['bun', 'server', '--https-port=9445', '--edgefile=./Edgefile.rip', 'packages/server/default.rip'])
+  flags = parseFlags(['bun', 'server', '--https-port=9445', '--file=./serve.rip', defaultRip])
   eq coerceInt('42', 0), 42
   eq flags.httpsPort, 9445
-  ok flags.edgefilePath.endsWith('Edgefile.rip')
+  ok flags.configPath.endsWith('serve.rip')
 
 test "control cli uses bare app token as true app name override", ->
   flags = parseFlags(['bun', 'server', 'ola'])
@@ -25,13 +29,13 @@ test "control cli uses bare app token as true app name override", ->
   eq socketPrefix, 'rip_ola'
 
 test "control cli supports explicit path with custom app name", ->
-  flags = parseFlags(['bun', 'server', 'packages/server/default.rip@ola'])
+  flags = parseFlags(['bun', 'server', "#{defaultRip}@ola"])
   eq flags.appName, 'ola'
   eq flags.appAliases[0], 'ola'
   eq flags.socketPrefix, 'rip_ola'
 
-test "edge runtime helpers load and create summary entries", ->
-  runtime = createEdgeRuntime()
+test "serving runtime helpers load and create summary entries", ->
+  runtime = createServingRuntime()
   entry = createReloadHistoryEntry('reload-1', 'test', null, 1, 'applied')
   eq runtime.configInfo.kind, 'none'
   eq entry.id, 'reload-1'

package/tests/extracted.rip

@@ -0,0 +1,118 @@
+# extracted.rip — tests for modules extracted during the server rebuild
+
+import { test, eq, ok } from './runner.rip'
+import { nowMs, isDebug, applyFlagSideEffects, stripInternalHeaders } from '../serving/logging.rip'
+import { proxyRouteToUpstream, upgradeProxyWebSocket } from '../serving/proxy.rip'
+import { createMetrics, buildDiagnosticsBody } from '../serving/metrics.rip'
+import { proxyRealtimeToWorker, buildWebSocketHandlers, createHub } from '../serving/realtime.rip'
+import { Manager } from '../control/manager.rip'
+import { createUpstreamPool } from '../serving/upstream.rip'
+import { createServingRuntime } from '../serving/runtime.rip'
+
+# --- serving/logging.rip ---
+
+test "nowMs returns a number", ->
+  ok typeof nowMs() is 'number'
+  ok nowMs() > 0
+
+test "isDebug returns false by default", ->
+  eq isDebug(), false
+
+test "applyFlagSideEffects sets debug mode", ->
+  applyFlagSideEffects({ debug: true })
+  ok isDebug()
+  applyFlagSideEffects({ debug: false })
+
+test "stripInternalHeaders removes rip headers and preserves others", ->
+  h = new Headers()
+  h.set('content-type', 'text/plain')
+  h.set('rip-worker-busy', '1')
+  h.set('rip-worker-id', 'w-0')
+  h.set('rip-no-log', '1')
+  h.set('x-custom', 'keep')
+  stripped = stripInternalHeaders(h)
+  ok stripped.has('content-type')
+  ok stripped.has('x-custom')
+  eq stripped.has('rip-worker-busy'), false
+  eq stripped.has('rip-worker-id'), false
+  eq stripped.has('rip-no-log'), false
+
+# --- serving/proxy.rip ---
+
+test "proxyRouteToUpstream returns 503 when no matching proxy", ->
+  pool = createUpstreamPool()
+  runtime = createServingRuntime(null, pool)
+  metrics = createMetrics()
+  route = { proxy: 'nonexistent', timeouts: {} }
+  req = new Request('http://localhost/test')
+  res = await proxyRouteToUpstream(req, route, 'req-1', '127.0.0.1', runtime, metrics, {}, (->), (->))
+  eq res.status, 503
+
+test "upgradeProxyWebSocket returns 503 when no matching proxy", ->
+  pool = createUpstreamPool()
+  runtime = createServingRuntime(null, pool)
+  route = { proxy: 'nonexistent' }
+  res = upgradeProxyWebSocket(null, null, route, 'req-1', runtime)
+  eq res.status, 503
+
+# --- serving/metrics.rip ---
+
+test "buildDiagnosticsBody returns valid JSON with expected keys", ->
+  metrics = createMetrics()
+  runtime = createServingRuntime()
+  body = buildDiagnosticsBody
+    metrics: metrics
+    startedAt: Date.now()
+    appRegistry: { apps: new Map(), hostIndex: new Map() }
+    servingRuntime: runtime
+    serverVersion: '1.0.0'
+    ripVersion: '3.0.0'
+    configInfo: { kind: 'none' }
+    realtimeStats: { clients: 0, groups: 0 }
+    hosts: []
+    streamDiagnostics: {}
+    multiplexer: { enabled: false }
+    activeRuntime: { id: 'test', inflight: 0, wsConnections: 0 }
+    retiredRuntimes: []
+    activeStreamRuntime: { id: 'test', inflight: 0, listeners: [] }
+    retiredStreamRuntimes: []
+  parsed = JSON.parse(body)
+  ok parsed.status
+  ok parsed.version
+  ok parsed.metrics
+  ok parsed.gauges
+  eq parsed.version.server, '1.0.0'
+
+# --- serving/realtime.rip ---
+
+test "proxyRealtimeToWorker returns null when no socket available", ->
+  result = await proxyRealtimeToWorker(new Headers(), 'open', '', (-> null), (->))
+  eq result, null
+
+test "buildWebSocketHandlers returns object with websocket handlers", ->
+  hub = createHub()
+  serverStub =
+    metrics: createMetrics()
+    retainRuntimeWs: (->)
+    releaseRuntimeWs: (->)
+    createWsPassthrough: (->)
+    releaseProxyTarget: (->)
+    logEvent: (->)
+    proxyRealtimeToWorker: (->)
+  handlers = buildWebSocketHandlers(hub, serverStub)
+  ok handlers.websocket
+  ok typeof handlers.websocket.open is 'function'
+  ok typeof handlers.websocket.message is 'function'
+  ok typeof handlers.websocket.close is 'function'
+
+# --- control/manager.rip ---
+
+test "Manager constructor initializes expected state", ->
+  flags = { appName: 'test', workers: 2 }
+  mgr = new Manager(flags, '/tmp/server.rip')
+  eq mgr.appWorkers.size, 0
+  eq mgr.currentVersion, 1
+  eq mgr.shuttingDown, false
+  eq mgr.defaultAppId, 'test'
+  ok mgr.restartBudgets instanceof Map
+  ok mgr.deferredDeaths instanceof Set

package/tests/helpers.rip

@@ -1,8 +1,8 @@
-# test-helpers.rip — edge/helpers and forwarding response factory tests
+# helpers.rip — serving/forwarding response factory tests
 
-import { test, eq, ok } from '../test.rip'
-import { formatPort, maybeAddSecurityHeaders, buildStatusBody, buildRipdevUrl } from '../edge/forwarding.rip'
-import { watchUnavailableResponse, serverBusyResponse, serviceUnavailableResponse, gatewayTimeoutResponse, queueTimeoutResponse } from '../edge/forwarding.rip'
+import { test, eq, ok } from './runner.rip'
+import { formatPort, maybeAddSecurityHeaders, buildStatusBody, buildRipdevUrl } from '../serving/forwarding.rip'
+import { watchUnavailableResponse, serverBusyResponse, serviceUnavailableResponse, gatewayTimeoutResponse, queueTimeoutResponse } from '../serving/forwarding.rip'
 
 # --- formatPort ---
 

package/tests/metrics.rip

@@ -1,9 +1,9 @@
 # ==============================================================================
-# test-metrics.rip — edge/metrics.rip tests
+# test-metrics.rip — serving/metrics.rip tests
 # ==============================================================================
 
-import { test, eq, ok, near } from '../test.rip'
-import { createMetrics } from '../edge/metrics.rip'
+import { test, eq, ok, near } from './runner.rip'
+import { createMetrics } from '../serving/metrics.rip'
 
 test "createMetrics returns object with counters", ->
   m = createMetrics()

package/tests/proxy.rip

@@ -1,9 +1,9 @@
 # proxy.rip — reverse proxy and config loader tests
 
-import { test, eq, ok } from '../test.rip'
-import { normalizeAppConfig, applyConfig, applyEdgeConfig } from '../edge/config.rip'
-import { createAppRegistry, registerApp, resolveHost, getAppState } from '../edge/registry.rip'
-import { broadcastBinary, createHub, addClient } from '../edge/realtime.rip'
+import { test, eq, ok } from './runner.rip'
+import { normalizeAppConfig, applyConfig } from '../serving/config.rip'
+import { createAppRegistry, registerApp, resolveHost, getAppState } from '../serving/registry.rip'
+import { broadcastBinary, createHub, addClient } from '../serving/realtime.rip'
 import { setEventJsonMode, logEvent } from '../control/lifecycle.rip'
 
 # --- Config normalization ---
@@ -36,6 +36,7 @@ test "normalizeAppConfig keeps absolute entry path", ->
 test "applyConfig registers apps in registry", ->
   registry = createAppRegistry()
   config =
+    kind: 'serve'
     apps:
       web: { hosts: ['example.com'], workers: 4 }
       api: { hosts: ['api.example.com'], workers: 2 }
@@ -46,13 +47,13 @@ test "applyConfig registers apps in registry", ->
 
 test "applyConfig handles empty apps", ->
   registry = createAppRegistry()
-  registered = applyConfig({ apps: {} }, registry, registerApp, '/srv')
+  registered = applyConfig({ kind: 'serve', apps: {} }, registry, registerApp, '/srv')
   eq registered.length, 0
 
-test "applyEdgeConfig preserves managed app entry workers and env", ->
+test "applyConfig preserves managed app entry workers and env", ->
   registry = createAppRegistry()
   config =
-    kind: 'edge'
+    kind: 'serve'
     apps:
       admin:
         entry: '/srv/admin/index.rip'
@@ -62,7 +63,7 @@ test "applyEdgeConfig preserves managed app entry workers and env", ->
         queueTimeoutMs: 1234
         readTimeoutMs: 5678
         env: { ADMIN_MODE: '1' }
-  registered = applyEdgeConfig(config, registry, registerApp, '/srv')
+  registered = applyConfig(config, registry, registerApp, '/srv')
   eq registered.length, 1
   state = getAppState(registry, 'admin')
   eq state.config.entry, '/srv/admin/index.rip'

package/tests/read.rip

@@ -7,7 +7,7 @@
 # Each test is self-contained: t(name, input, expected, fn)
 # No HTTP server needed — uses requestContext.run() directly.
 #
-# Run: rip packages/server/test/tests/read.rip
+# Run: ./bin/rip packages/server/tests/read.rip
 #
 
 import { read, requestContext } from '../api.rip'

package/tests/realtime.rip

@@ -1,7 +1,7 @@
-# realtime.rip — edge/realtime.rip unit tests
+# realtime.rip — serving/realtime.rip unit tests
 
-import { test, eq, ok } from '../test.rip'
-import { createHub, generateClientId, addClient, removeClient, processResponse, handlePublish, getRealtimeStats } from '../edge/realtime.rip'
+import { test, eq, ok } from './runner.rip'
+import { createHub, generateClientId, addClient, removeClient, processResponse, handlePublish, getRealtimeStats } from '../serving/realtime.rip'
 
 # --- Hub lifecycle ---
 

package/tests/registry.rip

@@ -1,8 +1,8 @@
-# test-registry.rip — edge/registry, scheduler, and queue tests
+# test-registry.rip — serving/registry, scheduler, and queue tests
 
-import { test, eq, ok } from '../test.rip'
-import { createAppRegistry, registerApp, resolveHost, getAppState, removeApp } from '../edge/registry.rip'
-import { isCurrentVersion, getNextAvailableSocket, releaseWorker, shouldRetryBodylessBusy, drainQueueOnce } from '../edge/queue.rip'
+import { test, eq, ok } from './runner.rip'
+import { createAppRegistry, registerApp, resolveHost, getAppState, removeApp } from '../serving/registry.rip'
+import { isCurrentVersion, getNextAvailableSocket, releaseWorker, shouldRetryBodylessBusy, drainQueueOnce } from '../serving/queue.rip'
 
 # --- Registry ---
 

package/tests/router.rip

@@ -1,10 +1,10 @@
-import { test, eq, ok } from '../test.rip'
-import { compileRouteTable, matchRoute, describeRoute } from '../edge/router.rip'
+import { test, eq, ok } from './runner.rip'
+import { compileRouteTable, matchRoute, describeRoute } from '../serving/router.rip'
 
 test "compileRouteTable keeps global route order", ->
   table = compileRouteTable([
-    { id: 'one', path: '/a', upstream: 'app' }
-    { id: 'two', path: '/b', upstream: 'app' }
+    { id: 'one', path: '/a', proxy: 'app' }
+    { id: 'two', path: '/b', proxy: 'app' }
   ])
   eq table.routes.length, 2
   eq table.routes[0].order, 0
@@ -20,62 +20,62 @@ test "compileRouteTable merges site routes with inherited host", ->
 
 test "matchRoute prefers exact host over catchall", ->
   table = compileRouteTable([
-    { path: '/*', upstream: 'fallback' }
-    { host: 'api.example.com', path: '/*', upstream: 'api' }
+    { path: '/*', proxy: 'fallback' }
+    { host: 'api.example.com', path: '/*', proxy: 'api' }
   ])
-  eq matchRoute(table, 'api.example.com', '/users').upstream, 'api'
+  eq matchRoute(table, 'api.example.com', '/users').proxy, 'api'
 
 test "matchRoute prefers wildcard host over catchall", ->
   table = compileRouteTable([
-    { path: '/*', upstream: 'fallback' }
-    { host: '*.example.com', path: '/*', upstream: 'wild' }
+    { path: '/*', proxy: 'fallback' }
+    { host: '*.example.com', path: '/*', proxy: 'wild' }
   ])
-  eq matchRoute(table, 'api.example.com', '/users').upstream, 'wild'
+  eq matchRoute(table, 'api.example.com', '/users').proxy, 'wild'
 
 test "matchRoute does not let wildcard span multiple labels", ->
   table = compileRouteTable([
-    { host: '*.example.com', path: '/*', upstream: 'wild' }
-    { path: '/*', upstream: 'fallback' }
+    { host: '*.example.com', path: '/*', proxy: 'wild' }
+    { path: '/*', proxy: 'fallback' }
   ])
-  eq matchRoute(table, 'a.b.example.com', '/users').upstream, 'fallback'
+  eq matchRoute(table, 'a.b.example.com', '/users').proxy, 'fallback'
 
 test "matchRoute prefers exact path over prefix", ->
   table = compileRouteTable([
-    { path: '/api/*', upstream: 'api' }
-    { path: '/api/users', upstream: 'users' }
+    { path: '/api/*', proxy: 'api' }
+    { path: '/api/users', proxy: 'users' }
   ])
-  eq matchRoute(table, 'example.com', '/api/users').upstream, 'users'
+  eq matchRoute(table, 'example.com', '/api/users').proxy, 'users'
 
 test "matchRoute prefers longer prefix", ->
   table = compileRouteTable([
-    { path: '/api/*', upstream: 'api' }
-    { path: '/api/admin/*', upstream: 'admin' }
+    { path: '/api/*', proxy: 'api' }
+    { path: '/api/admin/*', proxy: 'admin' }
   ])
-  eq matchRoute(table, 'example.com', '/api/admin/users').upstream, 'admin'
+  eq matchRoute(table, 'example.com', '/api/admin/users').proxy, 'admin'
 
 test "matchRoute uses lower priority number before order", ->
   table = compileRouteTable([
-    { path: '/api/*', upstream: 'one', priority: 10 }
-    { path: '/api/*', upstream: 'two', priority: 5 }
+    { path: '/api/*', proxy: 'one', priority: 10 }
+    { path: '/api/*', proxy: 'two', priority: 5 }
   ])
-  eq matchRoute(table, 'example.com', '/api/x').upstream, 'two'
+  eq matchRoute(table, 'example.com', '/api/x').proxy, 'two'
 
 test "matchRoute filters by method", ->
   table = compileRouteTable([
-    { path: '/submit', upstream: 'read', methods: ['GET'] }
-    { path: '/submit', upstream: 'write', methods: ['POST'] }
+    { path: '/submit', proxy: 'read', methods: ['GET'] }
+    { path: '/submit', proxy: 'write', methods: ['POST'] }
   ])
-  eq matchRoute(table, 'example.com', '/submit', 'POST').upstream, 'write'
+  eq matchRoute(table, 'example.com', '/submit', 'POST').proxy, 'write'
 
 test "matchRoute returns null when nothing matches", ->
   table = compileRouteTable([
-    { host: 'api.example.com', path: '/api/*', upstream: 'api' }
+    { host: 'api.example.com', path: '/api/*', proxy: 'api' }
   ])
   eq matchRoute(table, 'example.com', '/api/x'), null
 
 test "describeRoute summarizes action", ->
   table = compileRouteTable([
-    { host: 'api.example.com', path: '/api/*', upstream: 'api' }
+    { host: 'api.example.com', path: '/api/*', proxy: 'api' }
   ])
   summary = describeRoute(matchRoute(table, 'api.example.com', '/api/x'))
   ok summary.includes('proxy:api')

package/tests/runner.rip

@@ -0,0 +1,70 @@
+# ==============================================================================
+# tests/runner.rip — server test harness
+# ==============================================================================
+#
+# Run from package dir: bun run test
+# Run from repo root: ./bin/rip packages/server/tests/runner.rip
+#
+# Discovers and runs all *.rip files in tests/
+# ==============================================================================
+
+import { readdirSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+
+# --- Test helpers (exported for test files to use) ---
+
+passed = 0
+failed = 0
+failures = []
+
+export test = (name, fn) ->
+  try
+    result = fn()
+    await result if result?.then
+    passed++
+    p "  ✓ #{name}"
+  catch e
+    failed++
+    failures.push { name, error: e.message or String(e) }
+    p "  ✗ #{name}: #{e.message or e}"
+
+export eq = (actual, expected) ->
+  a = JSON.stringify(actual)
+  b = JSON.stringify(expected)
+  throw new Error("expected #{b}, got #{a}") unless a is b
+
+export ok = (value, msg) ->
+  throw new Error(msg or "expected truthy, got #{JSON.stringify(value)}") unless value
+
+export near = (actual, expected, tolerance = 0.001) ->
+  throw new Error("expected ~#{expected}, got #{actual}") unless Math.abs(actual - expected) < tolerance
+
+# --- Runner ---
+
+testDir = dirname(import.meta.path)
+files = readdirSync(testDir).filter((f) -> f.endsWith('.rip') and f isnt 'runner.rip').sort()
+
+p "rip-server tests: #{files.length} files\n"
+
+for file in files
+  p "  #{file}"
+  try
+    import!(join(testDir, file))
+  catch e
+    failed++
+    failures.push { name: "#{file} (load)", error: e.message or String(e) }
+    p "  ✗ #{file} failed to load: #{e.message or e}"
+  p ''
+
+# --- Summary ---
+
+total = passed + failed
+pct = if total > 0 then Math.round(passed / total * 100) else 0
+p "✓ #{passed} passing, ✗ #{failed} failing, ★ #{pct}% passing"
+
+if failures.length > 0
+  p "\nFailures:"
+  for f in failures[0...20]
+    p "  ✗ #{f.name}: #{f.error}"
+
+exit if failed > 0 then 1 else 0