@rip-lang/server 1.3.125 → 1.4.1

package/tests/security.rip

@@ -1,9 +1,9 @@
 # security.rip — rate limiter, request validation, and request ID tests
 
-import { test, eq, ok } from '../test.rip'
-import { createRateLimiter, rateLimitResponse } from '../edge/ratelimit.rip'
-import { validateRequest } from '../edge/security.rip'
-import { generateRequestId } from '../edge/forwarding.rip'
+import { test, eq, ok } from './runner.rip'
+import { createRateLimiter, rateLimitResponse } from '../serving/ratelimit.rip'
+import { validateRequest } from '../serving/security.rip'
+import { generateRequestId } from '../serving/forwarding.rip'
 
 # --- Request ID ---
 

package/tests/servers.rip

@@ -1,126 +1,110 @@
-import { test, eq, ok } from '../test.rip'
-import { normalizeEdgeConfig } from '../edge/config.rip'
+import { test, eq, ok } from './runner.rip'
+import { normalizeConfig } from '../serving/config.rip'
 
-# --- v2 basic normalization ---
+getErrors = (fn) ->
+  try
+    fn()
+    []
+  catch e
+    e.validationErrors or []
 
-test "normalizes hosts into sites object shape", ->
-  config = normalizeEdgeConfig({
-    version: 2
-    edge: {}
+test "normalizes hosts into concrete site entries", ->
+  config = normalizeConfig({
     hosts:
       '*.trusthealth.com':
         cert: '/ssl/trusthealth.com.crt'
         key:  '/ssl/trusthealth.com.key'
         root: '/mnt/trusthealth'
-        routes: [
+        rules: [
           { path: '/*', static: '.', spa: true }
         ]
   }, '/home/shreeve')
-  eq config.version, 2
-  eq config.kind, 'edge'
+  eq config.version, 1
+  eq config.kind, 'serve'
   ok config.sites['*.trusthealth.com']
   eq config.sites['*.trusthealth.com'].host, '*.trusthealth.com'
   eq config.sites['*.trusthealth.com'].routes.length, 1
 
-test "v2 extracts cert map from server blocks", ->
-  config = normalizeEdgeConfig({
-    version: 2
-    edge: {}
+test "extracts cert map from host blocks and certs", ->
+  config = normalizeConfig({
+    certs:
+      zion: '/ssl/zionlabshare.com'
     hosts:
       '*.trusthealth.com':
         cert: '/ssl/trusthealth.com.crt'
         key:  '/ssl/trusthealth.com.key'
-        routes: [
+        rules: [
           { path: '/*', static: '/mnt/web' }
         ]
       '*.zionlabshare.com':
-        cert: '/ssl/zionlabshare.com.crt'
-        key:  '/ssl/zionlabshare.com.key'
-        routes: [
+        cert: 'zion'
+        rules: [
           { path: '/*', static: '/mnt/zion' }
         ]
   }, '/home/shreeve')
-  ok config.certs
-  ok config.certs['*.trusthealth.com']
-  ok config.certs['*.zionlabshare.com']
-  ok config.certs['*.trusthealth.com'].certPath.endsWith('trusthealth.com.crt')
+  ok config.resolvedCerts['*.trusthealth.com']
+  ok config.resolvedCerts['*.zionlabshare.com']
+  ok config.resolvedCerts['*.trusthealth.com'].certPath.endsWith('trusthealth.com.crt')
+  ok config.resolvedCerts['*.zionlabshare.com'].certPath.endsWith('zionlabshare.com.crt')
 
-test "v2 inherits server root into routes", ->
-  config = normalizeEdgeConfig({
-    version: 2
-    edge: {}
+test "inherits host root into static routes", ->
+  config = normalizeConfig({
     hosts:
       '*.example.com':
         root: '/mnt/site'
-        routes: [
+        rules: [
           { path: '/*', static: '.' }
         ]
   }, '/home/shreeve')
   route = config.sites['*.example.com'].routes[0]
   ok route.root.includes('mnt/site')
 
-test "v2 route root overrides server root", ->
-  config = normalizeEdgeConfig({
-    version: 2
-    edge: {}
+test "route root overrides host root", ->
+  config = normalizeConfig({
     hosts:
       '*.example.com':
         root: '/mnt/default'
-        routes: [
+        rules: [
           { path: '/*', static: '.', root: '/mnt/override' }
         ]
   }, '/home/shreeve')
   route = config.sites['*.example.com'].routes[0]
   ok route.root.includes('mnt/override')
 
-test "v2 routes inherit host from server key", ->
-  config = normalizeEdgeConfig({
-    version: 2
-    edge: {}
+test "rules inherit host from the host block", ->
+  config = normalizeConfig({
     hosts:
       app.example.com:
-        routes: [
+        rules: [
           { path: '/*', static: '/mnt/app' }
         ]
   }, '/home/shreeve')
   route = config.sites['app.example.com'].routes[0]
   eq route.host, 'app.example.com'
 
-test "v2 preserves spa flag on routes", ->
-  config = normalizeEdgeConfig({
-    version: 2
-    edge: {}
+test "preserves spa flag on rules", ->
+  config = normalizeConfig({
     hosts:
       '*.example.com':
-        routes: [
+        rules: [
           { path: '/*', static: '/mnt/app', spa: true }
         ]
   }, '/home/shreeve')
   route = config.sites['*.example.com'].routes[0]
   eq route.spa, true
 
-# --- validation errors ---
-
-test "rejects server block with no routes and no root", ->
-  threw = false
-  try
-    normalizeEdgeConfig({
-      version: 1
-      edge: {}
+test "rejects host block with no rules and no root", ->
+  errors = getErrors ->
+    normalizeConfig({
       hosts:
         '*.example.com':
           cert: '/ssl/example.com.crt'
           key:  '/ssl/example.com.key'
     }, '/home/shreeve')
-  catch e
-    threw = true
-    ok e.validationErrors.some((err) -> err.code is 'E_SERVER_ROUTES')
-  ok threw
+  ok errors.some((err) -> err.code is 'E_SERVER_RULES')
 
-test "root-only server block generates implicit static route", ->
-  config = normalizeEdgeConfig({
-    version: 1
-    edge: {}
+test "root-only host block generates implicit static route", ->
+  config = normalizeConfig({
     hosts:
       '*.example.com':
         root: '/mnt/site'
@@ -130,10 +114,8 @@ test "root-only server block generates implicit static route", ->
   eq routes[0].static, '.'
   ok routes[0].root.includes('mnt/site')
 
-test "root-only server block with spa", ->
-  config = normalizeEdgeConfig({
-    version: 1
-    edge: {}
+test "root-only host block with spa", ->
+  config = normalizeConfig({
     hosts:
       '*.example.com':
         root: '/mnt/site'
@@ -141,83 +123,72 @@ test "root-only server block with spa", ->
   }, '/home/shreeve')
   eq config.sites['*.example.com'].routes[0].spa, true
 
-test "passthrough server block creates stream entries", ->
-  config = normalizeEdgeConfig({
-    version: 1
+test "passthrough host block creates stream entries", ->
+  config = normalizeConfig({
+    proxies:
+      incus:
+        hosts: ['tcp://127.0.0.1:8443']
     hosts:
       incus.example.com:
-        passthrough: '127.0.0.1:8443'
+        proxy: 'incus'
   }, '/home/shreeve')
-  ok config.streamUpstreams['passthrough-incus.example.com']
+  ok config.streamUpstreams['incus']
   eq config.streams.length, 1
+  eq config.streams[0].proxy, 'incus'
   eq config.streams[0].sni[0], 'incus.example.com'
 
-test "passthrough server block has no sites entry", ->
-  config = normalizeEdgeConfig({
-    version: 1
+test "passthrough host block has no sites entry", ->
+  config = normalizeConfig({
+    proxies:
+      incus:
+        hosts: ['tcp://127.0.0.1:8443']
     hosts:
       incus.example.com:
-        passthrough: '127.0.0.1:8443'
+        proxy: 'incus'
   }, '/home/shreeve')
   eq config.sites['incus.example.com'], undefined
 
-test "edge and version are optional", ->
-  config = normalizeEdgeConfig({
+test "server settings and version are optional", ->
+  config = normalizeConfig({
     hosts:
       '*.example.com':
         root: '/mnt/site'
   }, '/home/shreeve')
   eq config.version, 1
-  ok config.edge
+  ok config.server
 
-test "v2 rejects route with host field", ->
-  threw = false
-  try
-    normalizeEdgeConfig({
-      version: 2
-      edge: {}
+test "rejects route host fields inside host blocks", ->
+  errors = getErrors ->
+    normalizeConfig({
       hosts:
         '*.example.com':
-          routes: [{ path: '/*', static: '.', host: 'other.com' }]
+          rules: [{ path: '/*', static: '.', host: 'other.com' }]
     }, '/home/shreeve')
-  catch e
-    threw = true
-    ok e.validationErrors.some((err) -> err.code is 'E_SERVER_ROUTE_HOST')
-  ok threw
-
-test "v2 validates upstream references in server routes", ->
-  threw = false
-  try
-    normalizeEdgeConfig({
-      version: 2
-      edge: {}
+  ok errors.some((err) -> err.code is 'E_SERVER_ROUTE_HOST')
+
+test "validates proxy references in host rules", ->
+  errors = getErrors ->
+    normalizeConfig({
+      proxies:
+        api:
+          hosts: ['http://127.0.0.1:4000']
       hosts:
         '*.example.com':
-          routes: [{ path: '/api/*', upstream: 'nonexistent' }]
+          rules: [{ path: '/api/*', proxy: 'nonexistent' }]
     }, '/home/shreeve')
-  catch e
-    threw = true
-    ok e.validationErrors.some((err) -> err.code is 'E_ROUTE_UPSTREAM_REF')
-  ok threw
+  ok errors.some((err) -> err.code is 'E_ROUTE_PROXY_REF')
 
-test "v2 validates app references in server routes", ->
-  threw = false
-  try
-    normalizeEdgeConfig({
-      version: 2
-      edge: {}
+test "validates app references in host rules", ->
+  errors = getErrors ->
+    normalizeConfig({
       hosts:
         '*.example.com':
-          routes: [{ path: '/*', app: 'nonexistent' }]
+          rules: [{ path: '/*', app: 'nonexistent' }]
     }, '/home/shreeve')
-  catch e
-    threw = true
-    ok e.validationErrors.some((err) -> err.code is 'E_ROUTE_APP_REF')
-  ok threw
+  ok errors.some((err) -> err.code is 'E_ROUTE_APP_REF')
 
-
-test "server block with app field creates app route", ->
-  config = normalizeEdgeConfig({
+test "host block with app field creates app route", ->
+  config = normalizeConfig({
     hosts:
       'dev.example.com':
         cert: '/ssl/example.com.crt'
@@ -225,38 +196,33 @@ test "server block with app field creates app route", ->
         app:  'browser'
     apps:
       browser:
-        entry: '/srv/default.rip'
+        entry: '/srv/browse.rip'
         root:  '/mnt/www'
   }, '/home/shreeve')
   route = config.sites['dev.example.com'].routes[0]
   eq route.app, 'browser'
   eq route.host, 'dev.example.com'
-  ok config.certs['dev.example.com']
+  ok config.resolvedCerts['dev.example.com']
 
-test "server block rejects unknown app reference", ->
-  threw = false
-  try
-    normalizeEdgeConfig({
+test "host block rejects unknown app reference", ->
+  errors = getErrors ->
+    normalizeConfig({
       hosts:
         'dev.example.com':
           app: 'nonexistent'
     }, '/home/shreeve')
-  catch e
-    threw = true
-    ok e.validationErrors.some((err) -> err.code is 'E_SERVER_APP_REF')
-  ok threw
-
-test "inline app definition on host block", ->
-  config = normalizeEdgeConfig({
-    hosts:
-      'api.example.com':
-        cert: '/ssl/example.com.crt'
-        key:  '/ssl/example.com.key'
-        app:
-          entry: '/srv/myapi/index.rip'
-          root:  '/srv/myapi'
-  }, '/home/shreeve')
-  route = config.sites['api.example.com'].routes[0]
-  eq route.app, 'app-api.example.com'
-  ok config.apps['app-api.example.com']
-  ok config.apps['app-api.example.com'].entry.includes('myapi')
+  ok errors.some((err) -> err.code is 'E_SERVER_APP_REF')
+
+test "rejects TCP proxy host blocks that also terminate TLS", ->
+  errors = getErrors ->
+    normalizeConfig({
+      proxies:
+        incus:
+          hosts: ['tcp://127.0.0.1:8443']
+      hosts:
+        'incus.example.com':
+          proxy: 'incus'
+          cert: '/ssl/example.com.crt'
+          key:  '/ssl/example.com.key'
+    }, '/home/shreeve')
+  ok errors.some((err) -> err.code is 'E_SERVER_TCP_PROXY_ONLY')

package/tests/static.rip

@@ -1,5 +1,5 @@
-import { test, eq, ok } from '../test.rip'
-import { serveStaticRoute, buildRedirectResponse } from '../edge/static.rip'
+import { test, eq, ok } from './runner.rip'
+import { serveStaticRoute, buildRedirectResponse } from '../serving/static.rip'
 
 # --- helpers ---
 

package/tests/streams_clienthello.rip

@@ -1,5 +1,5 @@
-import { test, eq, ok } from '../test.rip'
-import { parseSNI } from '../streams/tls_clienthello.rip'
+import { test, eq, ok } from './runner.rip'
+import { parseSNI } from '../streams/clienthello.rip'
 
 buildClientHello = (hostname = 'incus.example.com', opts = {}) ->
   hostBytes = new TextEncoder().encode(hostname)

package/tests/streams_index.rip

@@ -1,4 +1,4 @@
-import { test, eq } from '../test.rip'
+import { test, eq } from './runner.rip'
 import { buildStreamRuntime, resolveHandshakeTarget } from '../streams/index.rip'
 
 test "resolveHandshakeTarget falls through to http fallback when no route matches", ->
@@ -7,7 +7,7 @@ test "resolveHandshakeTarget falls through to http fallback when no route matche
       incus:
         targets: [{ host: '127.0.0.1', port: 8443 }]
     streams: [
-      { id: 'incus', order: 0, listen: 443, sni: ['incus.example.com'], upstream: 'incus' }
+      { id: 'incus', order: 0, listen: 443, sni: ['incus.example.com'], proxy: 'incus' }
     ]
   )
   result = resolveHandshakeTarget(runtime, 443, 'app.example.com',
@@ -24,7 +24,7 @@ test "resolveHandshakeTarget prefers configured stream routes over fallback", ->
       incus:
         targets: [{ host: '127.0.0.1', port: 8443 }]
     streams: [
-      { id: 'incus', order: 0, listen: 443, sni: ['incus.example.com'], upstream: 'incus' }
+      { id: 'incus', order: 0, listen: 443, sni: ['incus.example.com'], proxy: 'incus' }
     ]
   )
   result = resolveHandshakeTarget(runtime, 443, 'incus.example.com',
@@ -41,7 +41,7 @@ test "resolveHandshakeTarget rejects when stream route matches but upstream is u
       incus:
         targets: []
     streams: [
-      { id: 'incus', order: 0, listen: 443, sni: ['incus.example.com'], upstream: 'incus' }
+      { id: 'incus', order: 0, listen: 443, sni: ['incus.example.com'], proxy: 'incus' }
     ]
   )
   result = resolveHandshakeTarget(runtime, 443, 'incus.example.com',

package/tests/streams_pipe.rip

@@ -1,4 +1,4 @@
-import { test, eq, ok } from '../test.rip'
+import { test, eq, ok } from './runner.rip'
 import { createPipeState, writeChunk, flushPending } from '../streams/pipe.rip'
 
 fakeSocket = (returns = []) ->

package/tests/streams_router.rip

@@ -1,39 +1,39 @@
-import { test, eq } from '../test.rip'
+import { test, eq } from './runner.rip'
 import { compileStreamTable, matchStreamRoute, describeStreamRoute } from '../streams/router.rip'
 
 test "compileStreamTable expands sni patterns", ->
   table = compileStreamTable([
-    { id: 'incus', order: 0, listen: 8443, sni: ['incus.example.com', '*.example.com'], upstream: 'incus' }
+    { id: 'incus', order: 0, listen: 8443, sni: ['incus.example.com', '*.example.com'], proxy: 'incus' }
   ])
   eq table.routes.length, 2
 
 test "matchStreamRoute prefers exact sni", ->
   table = compileStreamTable([
-    { id: 'wild', order: 0, listen: 8443, sni: ['*.example.com'], upstream: 'wild' }
-    { id: 'exact', order: 1, listen: 8443, sni: ['incus.example.com'], upstream: 'exact' }
+    { id: 'wild', order: 0, listen: 8443, sni: ['*.example.com'], proxy: 'wild' }
+    { id: 'exact', order: 1, listen: 8443, sni: ['incus.example.com'], proxy: 'exact' }
   ])
-  eq matchStreamRoute(table, 8443, 'incus.example.com').upstream, 'exact'
+  eq matchStreamRoute(table, 8443, 'incus.example.com').proxy, 'exact'
 
 test "matchStreamRoute matches wildcard sni", ->
   table = compileStreamTable([
-    { id: 'wild', order: 0, listen: 8443, sni: ['*.example.com'], upstream: 'wild' }
+    { id: 'wild', order: 0, listen: 8443, sni: ['*.example.com'], proxy: 'wild' }
   ])
-  eq matchStreamRoute(table, 8443, 'api.example.com').upstream, 'wild'
+  eq matchStreamRoute(table, 8443, 'api.example.com').proxy, 'wild'
 
 test "matchStreamRoute wildcard is single-label only", ->
   table = compileStreamTable([
-    { id: 'wild', order: 0, listen: 8443, sni: ['*.example.com'], upstream: 'wild' }
+    { id: 'wild', order: 0, listen: 8443, sni: ['*.example.com'], proxy: 'wild' }
   ])
   eq matchStreamRoute(table, 8443, 'a.b.example.com'), null
 
 test "matchStreamRoute filters by listen port", ->
   table = compileStreamTable([
-    { id: 'incus', order: 0, listen: 8443, sni: ['incus.example.com'], upstream: 'incus' }
+    { id: 'incus', order: 0, listen: 8443, sni: ['incus.example.com'], proxy: 'incus' }
   ])
   eq matchStreamRoute(table, 443, 'incus.example.com'), null
 
 test "describeStreamRoute summarizes route", ->
   table = compileStreamTable([
-    { id: 'incus', order: 0, listen: 8443, sni: ['incus.example.com'], upstream: 'incus' }
+    { id: 'incus', order: 0, listen: 8443, sni: ['incus.example.com'], proxy: 'incus' }
   ])
   eq describeStreamRoute(table.routes[0]), '8443 incus.example.com -> incus'

package/tests/streams_runtime.rip

@@ -1,4 +1,4 @@
-import { test, eq } from '../test.rip'
+import { test, eq } from './runner.rip'
 import { createStreamRuntime, describeStreamRuntime, buildStreamConfigInfo, streamUsesListenPort } from '../streams/runtime.rip'
 
 test "createStreamRuntime starts empty", ->
@@ -20,7 +20,7 @@ test "buildStreamConfigInfo reports counts and descriptions", ->
     streamUpstreams:
       incus: {}
     streams: [
-      { id: 'incus', order: 0, listen: 8443, sni: ['incus.example.com'], upstream: 'incus' }
+      { id: 'incus', order: 0, listen: 8443, sni: ['incus.example.com'], proxy: 'incus' }
     ]
   )
   eq info.streamCounts.streamUpstreams, 1
@@ -30,8 +30,8 @@ test "buildStreamConfigInfo reports counts and descriptions", ->
 test "streamUsesListenPort detects shared listener ports", ->
   runtime = createStreamRuntime(null, null,
     routes: [
-      { listen: 443, sni: 'incus.example.com', upstream: 'incus' }
-      { listen: 8443, sni: 'db.example.com', upstream: 'db' }
+      { listen: 443, sni: 'incus.example.com', proxy: 'incus' }
+      { listen: 8443, sni: 'db.example.com', proxy: 'db' }
     ]
   )
   eq streamUsesListenPort(runtime, 443), true

package/tests/streams_upstream.rip

@@ -1,4 +1,4 @@
-import { test, eq } from '../test.rip'
+import { test, eq } from './runner.rip'
 import { createStreamUpstreamPool, addStreamUpstream, getStreamUpstream, selectStreamTarget, openStreamConnection, releaseStreamConnection } from '../streams/upstream.rip'
 
 test "addStreamUpstream registers targets", ->

package/tests/upstream.rip

@@ -1,4 +1,4 @@
-import { test, eq, ok } from '../test.rip'
+import { test, eq, ok } from './runner.rip'
 import {
   createUpstreamPool
   addUpstream
@@ -11,7 +11,7 @@ import {
   shouldRetry
   computeRetryDelayMs
   updateTargetHealth
-} from '../edge/upstream.rip'
+} from '../serving/upstream.rip'
 
 test "createUpstreamPool starts empty", ->
   pool = createUpstreamPool()

package/tests/verify.rip

@@ -1,10 +1,10 @@
-import { test, eq, ok } from '../test.rip'
-import { compileRouteTable } from '../edge/router.rip'
-import { collectRouteRequirements, verifyRouteRuntime } from '../edge/verify.rip'
+import { test, eq, ok } from './runner.rip'
+import { compileRouteTable } from '../serving/router.rip'
+import { collectRouteRequirements, verifyRouteRuntime } from '../serving/verify.rip'
 
-test "collectRouteRequirements gathers upstreams and managed apps", ->
+test "collectRouteRequirements gathers proxies and managed apps", ->
   table = compileRouteTable([
-    { path: '/api/*', upstream: 'api' }
+    { path: '/api/*', proxy: 'api' }
     { path: '/admin/*', app: 'admin' }
   ])
   appRegistry =
@@ -13,17 +13,17 @@ test "collectRouteRequirements gathers upstreams and managed apps", ->
       ['reports', { config: { entry: '/srv/reports/index.rip' } }]
     ])
   reqs = collectRouteRequirements(table, appRegistry, 'default')
-  eq reqs.upstreamIds, ['api']
+  eq reqs.proxyIds, ['api']
   ok reqs.appIds.includes('admin')
   ok reqs.appIds.includes('reports')
 
-test "verifyRouteRuntime returns upstream reason code", ->
+test "verifyRouteRuntime returns proxy reason code", ->
   runtime =
     upstreamPool:
       upstreams: new Map([
         ['api', { id: 'api', targets: [{ targetId: 'api:0' }, { targetId: 'api:1' }] }]
       ])
-    routeTable: compileRouteTable([{ path: '/api/*', upstream: 'api' }])
+    routeTable: compileRouteTable([{ path: '/api/*', proxy: 'api' }])
   appRegistry = { apps: new Map() }
   result = verifyRouteRuntime(
     runtime,
@@ -34,8 +34,8 @@ test "verifyRouteRuntime returns upstream reason code", ->
     ((registry, appId) -> registry.apps.get(appId))
   )
   eq result.ok, false
-  eq result.code, 'upstream_no_healthy_targets'
-  eq result.details.upstreamId, 'api'
+  eq result.code, 'proxy_no_healthy_targets'
+  eq result.details.proxyId, 'api'
   eq result.details.requiredHealthyTargets, 1
 
 test "verifyRouteRuntime returns app worker reason code", ->
@@ -59,14 +59,14 @@ test "verifyRouteRuntime returns app worker reason code", ->
   eq result.code, 'app_no_ready_workers'
   eq result.details.appId, 'admin'
 
-test "verifyRouteRuntime succeeds when referenced upstreams and apps are healthy", ->
+test "verifyRouteRuntime succeeds when referenced proxies and apps are healthy", ->
   runtime =
     upstreamPool:
       upstreams: new Map([
         ['api', { id: 'api', targets: [{ targetId: 'api:0' }] }]
       ])
     routeTable: compileRouteTable([
-      { path: '/api/*', upstream: 'api' }
+      { path: '/api/*', proxy: 'api' }
       { path: '/admin/*', app: 'admin' }
     ])
   appRegistry =
@@ -90,7 +90,7 @@ test "verifyRouteRuntime honors minimum healthy targets policy", ->
       upstreams: new Map([
         ['api', { id: 'api', targets: [{ targetId: 'api:0' }, { targetId: 'api:1' }] }]
       ])
-    routeTable: compileRouteTable([{ path: '/api/*', upstream: 'api' }])
+    routeTable: compileRouteTable([{ path: '/api/*', proxy: 'api' }])
   appRegistry = { apps: new Map() }
   healthyCount = 0
   result = verifyRouteRuntime(
@@ -103,18 +103,18 @@ test "verifyRouteRuntime honors minimum healthy targets policy", ->
       healthyCount is 1
     ),
     ((registry, appId) -> registry.apps.get(appId)),
-    minHealthyTargetsPerUpstream: 2
+    minHealthyTargetsPerProxy: 2
   )
   eq result.ok, false
-  eq result.code, 'upstream_no_healthy_targets'
+  eq result.code, 'proxy_no_healthy_targets'
   eq result.details.healthyTargets, 1
   eq result.details.requiredHealthyTargets, 2
 
-test "verifyRouteRuntime can skip healthy upstream checks", ->
+test "verifyRouteRuntime can skip healthy proxy checks", ->
   runtime =
     upstreamPool:
       upstreams: new Map()
-    routeTable: compileRouteTable([{ path: '/api/*', upstream: 'api' }])
+    routeTable: compileRouteTable([{ path: '/api/*', proxy: 'api' }])
   appRegistry = { apps: new Map() }
   result = verifyRouteRuntime(
     runtime,
@@ -123,7 +123,7 @@ test "verifyRouteRuntime can skip healthy upstream checks", ->
     ((pool, id) -> pool.upstreams.get(id)),
     ((pool, target) -> false),
     ((registry, appId) -> registry.apps.get(appId)),
-    requireHealthyUpstreams: false
+    requireHealthyProxies: false
   )
   eq result.ok, true