@rakay-technology/kraft 0.7.4

package/dist/chunk-BQMFIXHI.js

@@ -0,0 +1,975 @@
+#!/usr/bin/env sh
+":" //# ; exec "$(command -v node || command -v bun)" "$0" "$@"
+import { createRequire as __ospCreateRequire } from "node:module";
+const require = __ospCreateRequire(import.meta.url);
+import {
+  describeProcess,
+  probeListeningPortOwners
+} from "./chunk-WYNM7L22.js";
+import {
+  envOps,
+  opScript
+} from "./chunk-YRSZPVMB.js";
+import {
+  resolveEnvironment
+} from "./chunk-OFXBNFNL.js";
+import {
+  sq
+} from "./chunk-MNV2QFHW.js";
+import {
+  SYSTEM,
+  answered,
+  refused,
+  safeErrorMessage
+} from "./chunk-PVOWHIND.js";
+
+// ../../packages/adapters/src/infra/openresty-lua.ts
+import { createHash, randomBytes } from "crypto";
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+// ../../packages/adapters/src/infra/lua-embedded.ts
+var EMBEDDED_LUA = {
+  "geo_country.lua": "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",
+  "maxminddb.lua": "-- maxminddb.lua — VENDORED THIRD-PARTY. Do not edit; re-vendor instead.
--
-- Upstream: anjia0532/lua-resty-maxminddb v1.3.2 (opm). Loaded as
-- `kraft.maxminddb` (see geo_country.lua). Verbatim except this header and ONE
-- marked change to the `ffi.load` call — search "KRAFT LOCAL MODIFICATION".
--
-- Why vendored rather than `opm get` at image build: `opm` needs perl, which the
-- openresty alpine base does not ship, and a build-time fetch would make the
-- image non-reproducible. Everything else in this directory is already shipped
-- by us (and base64-embedded into the JS bundle), so a pinned copy is the house
-- pattern — same reasoning as the vendored GeoLite2 DB in apps/api/assets/geoip.
--
-- Needs libmaxminddb.so at runtime (`apk add libmaxminddb`, in apps/edge/Dockerfile).
-- `ffi.load` below runs at REQUIRE time, so a missing .so throws on require —
-- geo_country.lua pcalls it for exactly that reason.
--
-- Re-vendor with:
--   curl -fsSL https://opm.openresty.org/api/pkg/tarball/anjia0532/lua-resty-maxminddb-<v>.opm.tar.gz \
--     | tar xz -O '*/lib/resty/maxminddb.lua' > packages/adapters/src/infra/lua/maxminddb.lua
--   # then re-apply this header and run `bun run embed:lua`
--[[
	Copyright 2017-now anjia (anjia0532@gmail.com)

	Licensed under the Apache License, Version 2.0 (the "License");
	you may not use this file except in compliance with the License.
	You may obtain a copy of the License at
		http://www.apache.org/licenses/LICENSE-2.0
	Unless required by applicable law or agreed to in writing, software
	distributed under the License is distributed on an "AS IS" BASIS,
	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	See the License for the specific language governing permissions and
	limitations under the License.
]]

-- copy from https://github.com/lilien1010/lua-resty-maxminddb/blob/f96633e2428f8f7bcc1e2a7a28b747b33233a8db/resty/maxminddb.lua#L5-L12

local ffi                 = require ('ffi')
local ffi_new             = ffi.new
local ffi_str             = ffi.string
local ffi_cast            = ffi.cast
local ffi_gc              = ffi.gc
local C                   = ffi.C

local _M    ={}
_M._VERSION = '1.3.2'
local mt = { __index = _M }

-- copy from https://github.com/lilien1010/lua-resty-maxminddb/blob/f96633e2428f8f7bcc1e2a7a28b747b33233a8db/resty/maxminddb.lua#L36-L126
ffi.cdef[[

typedef long int ssize_t;

typedef unsigned int mmdb_uint128_t __attribute__ ((__mode__(TI)));

typedef struct MMDB_entry_s {
  struct MMDB_s *mmdb;
  uint32_t offset;
} MMDB_entry_s;

typedef struct MMDB_lookup_result_s {
  bool found_entry;
  MMDB_entry_s entry;
  uint16_t netmask;
} MMDB_lookup_result_s;

typedef struct MMDB_entry_data_s {
  bool has_data;
  union {
    uint32_t pointer;
    const char *utf8_string;
    double double_value;
    const uint8_t *bytes;
    uint16_t uint16;
    uint32_t uint32;
    int32_t int32;
    uint64_t uint64;
    mmdb_uint128_t uint128;
    bool boolean;
    float float_value;
  };

  uint32_t offset;
  uint32_t offset_to_next;
  uint32_t data_size;
  uint32_t type;
} MMDB_entry_data_s;

typedef struct MMDB_entry_data_list_s {
  MMDB_entry_data_s entry_data;
  struct MMDB_entry_data_list_s *next;
} MMDB_entry_data_list_s;

typedef struct MMDB_description_s {
  const char *language;
  const char *description;
} MMDB_description_s;

typedef struct MMDB_metadata_s {
  uint32_t node_count;
  uint16_t record_size;
  uint16_t ip_version;
  const char *database_type;
  struct {
    size_t count;
    const char **names;
  } languages;
  uint16_t binary_format_major_version;
  uint16_t binary_format_minor_version;
  uint64_t build_epoch;
  struct {
    size_t count;
    MMDB_description_s **descriptions;
  } description;
} MMDB_metadata_s;

typedef struct MMDB_ipv4_start_node_s {
  uint16_t netmask;
  uint32_t node_value;
} MMDB_ipv4_start_node_s;

typedef struct MMDB_s {
  uint32_t flags;
  const char *filename;
  ssize_t file_size;
  const uint8_t *file_content;
  const uint8_t *data_section;
  uint32_t data_section_size;
  const uint8_t *metadata_section;
  uint32_t metadata_section_size;
  uint16_t full_record_byte_size;
  uint16_t depth;
  MMDB_ipv4_start_node_s ipv4_start_node;
  MMDB_metadata_s metadata;
} MMDB_s;

typedef  char * pchar;

MMDB_lookup_result_s MMDB_lookup_string(MMDB_s *const mmdb,   const char *const ipstr, int *const gai_error,int *const mmdb_error);
int MMDB_open(const char *const filename, uint32_t flags, MMDB_s *const mmdb);
int MMDB_aget_value(MMDB_entry_s *const start,  MMDB_entry_data_s *const entry_data,  const char *const *const path);
char *MMDB_strerror(int error_code);

int MMDB_get_entry_data_list(MMDB_entry_s *start, MMDB_entry_data_list_s **const entry_data_list);
void MMDB_free_entry_data_list(MMDB_entry_data_list_s *const entry_data_list);
void MMDB_close(MMDB_s *const mmdb);
const char *gai_strerror(int errcode);
]]

-- error codes 
-- https://github.com/maxmind/libmaxminddb/blob/master/include/maxminddb.h#L66
local MMDB_SUCCESS                                  =   0
local MMDB_FILE_OPEN_ERROR                          =   1
local MMDB_CORRUPT_SEARCH_TREE_ERROR                =   2
local MMDB_INVALID_METADATA_ERROR                   =   3
local MMDB_IO_ERROR                                 =   4
local MMDB_OUT_OF_MEMORY_ERROR                      =   5
local MMDB_UNKNOWN_DATABASE_FORMAT_ERROR            =   6
local MMDB_INVALID_DATA_ERROR                       =   7
local MMDB_INVALID_LOOKUP_PATH_ERROR                =   8
local MMDB_LOOKUP_PATH_DOES_NOT_MATCH_DATA_ERROR    =   9
local MMDB_INVALID_NODE_NUMBER_ERROR                =   10
local MMDB_IPV6_LOOKUP_IN_IPV4_DATABASE_ERROR       =   11

-- data type
-- https://github.com/maxmind/libmaxminddb/blob/master/include/maxminddb.h#L40
local MMDB_DATA_TYPE_EXTENDED                       =   0
local MMDB_DATA_TYPE_POINTER                        =   1
local MMDB_DATA_TYPE_UTF8_STRING                    =   2
local MMDB_DATA_TYPE_DOUBLE                         =   3
local MMDB_DATA_TYPE_BYTES                          =   4
local MMDB_DATA_TYPE_UINT16                         =   5
local MMDB_DATA_TYPE_UINT32                         =   6
local MMDB_DATA_TYPE_MAP                            =   7
local MMDB_DATA_TYPE_INT32                          =   8
local MMDB_DATA_TYPE_UINT64                         =   9
local MMDB_DATA_TYPE_UINT128                        =   10
local MMDB_DATA_TYPE_ARRAY                          =   11
local MMDB_DATA_TYPE_CONTAINER                      =   12
local MMDB_DATA_TYPE_END_MARKER                     =   13
local MMDB_DATA_TYPE_BOOLEAN                        =   14
local MMDB_DATA_TYPE_FLOAT                          =   15

-- copy from https://github.com/lilien1010/lua-resty-maxminddb/blob/f96633e2428f8f7bcc1e2a7a28b747b33233a8db/resty/maxminddb.lua#L136-L138
-- you should install the libmaxminddb to your system
--
-- ── KRAFT LOCAL MODIFICATION (the only deviation from upstream) ───────────
-- Upstream is `ffi.load('libmaxminddb')`, which resolves the LINKER name
-- `libmaxminddb.so` — and that unversioned symlink ships in the -dev package, not
-- the runtime one. Alpine's `libmaxminddb` and Debian's `libmaxminddb0` both give
-- only `libmaxminddb.so.0`, so the bare name fails on a normal runtime install and
-- geo goes silently dark (geo_country pcalls this require). Try the soname too so
-- the runtime package alone is enough on every distro.
local maxm
do
    local candidates = { 'libmaxminddb', 'libmaxminddb.so.0', 'libmaxminddb.so' }
    local last_err
    for i = 1, #candidates do
        local ok, lib = pcall(ffi.load, candidates[i])
        if ok then maxm = lib; break end
        last_err = lib
    end
    if not maxm then
        error('libmaxminddb not loadable (tried ' .. table.concat(candidates, ', ') ..
              '): ' .. tostring(last_err), 2)
    end
end
--https://github.com/maxmind/libmaxminddb
local mmdb                                          = ffi_new('MMDB_s')
local initted                                       = false

local function mmdb_strerror(rc)
    return ffi_str(maxm.MMDB_strerror(rc))
end

local function gai_strerror(rc)
    return ffi_str(C.gai_strerror(rc))
end

function _M.init(dbfile)
  if not initted then
    local maxmind_ready   = maxm.MMDB_open(dbfile,0,mmdb)

    if maxmind_ready ~= MMDB_SUCCESS then
        return nil, mmdb_strerror(maxmind_ready)
    end
    
    initted = true
    
    ffi_gc(mmdb, maxm.MMDB_close)
  end
  return initted
end

function _M.initted()
    return initted
end

-- https://github.com/maxmind/libmaxminddb/blob/master/src/maxminddb.c#L1938 
-- LOCAL MMDB_entry_data_list_s *dump_entry_data_list( FILE *stream, MMDB_entry_data_list_s *entry_data_list, int indent, int *status)
local function _dump_entry_data_list(entry_data_list,status)

  if not entry_data_list then
    return nil,MMDB_INVALID_DATA_ERROR
  end
  
  local entry_data_item = entry_data_list[0].entry_data
  local data_type = entry_data_item.type
  local data_size = entry_data_item.data_size
  local result
  
  if data_type == MMDB_DATA_TYPE_MAP then
    result = {}
    
    local size = entry_data_item.data_size
    
    entry_data_list = entry_data_list[0].next
    
    while(size > 0 and entry_data_list)
    do 
      entry_data_item = entry_data_list[0].entry_data
      data_type = entry_data_item.type
      data_size = entry_data_item.data_size
      
      if MMDB_DATA_TYPE_UTF8_STRING  ~= data_type then
        return nil,MMDB_INVALID_DATA_ERROR
      end
      
      local key = ffi_str(entry_data_item.utf8_string,data_size)

      if not key then
        return nil,MMDB_OUT_OF_MEMORY_ERROR
      end
      
      local val
      entry_data_list = entry_data_list[0].next
      entry_data_list,status,val = _dump_entry_data_list(entry_data_list)
      
      if status ~= MMDB_SUCCESS then
        return nil,status
      end

      result[key] = val
      
      size = size -1 
    end
    

  elseif entry_data_list[0].entry_data.type == MMDB_DATA_TYPE_ARRAY then
    local size = entry_data_list[0].entry_data.data_size
    result = {}

    entry_data_list = entry_data_list[0].next
    
    local i = 1
    while(i <= size and entry_data_list)
    do
      local val
      entry_data_list,status,val = _dump_entry_data_list(entry_data_list)
      
      if status ~= MMDB_SUCCESS then
        return nil,nil,val
      end
      
      result[i] = val
      i = i + 1
    end

    
  else
    entry_data_item = entry_data_list[0].entry_data
    data_type = entry_data_item.type
    data_size = entry_data_item.data_size
    
    local val
    -- string type "key":"val"
    -- other type "key":val
    -- default other type
    if data_type == MMDB_DATA_TYPE_UTF8_STRING then
      val = ffi_str(entry_data_item.utf8_string,data_size)
      if not val then
        status = MMDB_OUT_OF_MEMORY_ERROR
        return nil,status
      end
    elseif data_type == MMDB_DATA_TYPE_BYTES then
      val = ffi_str(ffi_cast('char * ',entry_data_item.bytes),data_size)
      if not val then
        status = MMDB_OUT_OF_MEMORY_ERROR
        return nil,status
      end
    elseif data_type == MMDB_DATA_TYPE_DOUBLE then
      val = entry_data_item.double_value
    elseif data_type == MMDB_DATA_TYPE_FLOAT then
      val = entry_data_item.float_value
    elseif data_type == MMDB_DATA_TYPE_UINT16 then
      val = entry_data_item.uint16
    elseif data_type == MMDB_DATA_TYPE_UINT32 then
      val = entry_data_item.uint32
    elseif data_type == MMDB_DATA_TYPE_BOOLEAN then
      val = entry_data_item.boolean
    elseif data_type == MMDB_DATA_TYPE_UINT64 then
      val = entry_data_item.uint64
    elseif data_type == MMDB_DATA_TYPE_INT32 then
      val = entry_data_item.int32
    else
      return nil,MMDB_INVALID_DATA_ERROR
    end
    
    result = val
    entry_data_list = entry_data_list[0].next
  end

  status = MMDB_SUCCESS
  return entry_data_list,status,result
end

function _M.lookup(ip)

  if not initted then
      return nil, "not initialized"
  end
  
  -- copy from https://github.com/lilien1010/lua-resty-maxminddb/blob/f96633e2428f8f7bcc1e2a7a28b747b33233a8db/resty/maxminddb.lua#L159-L176
  local gai_error = ffi_new('int[1]')
  local mmdb_error = ffi_new('int[1]')

  local result = maxm.MMDB_lookup_string(mmdb,ip,gai_error,mmdb_error)

  if mmdb_error[0] ~= MMDB_SUCCESS then
    return nil,'lookup failed: ' .. mmdb_strerror(mmdb_error[0])
  end

  if gai_error[0] ~= MMDB_SUCCESS then
    return nil,'lookup failed: ' .. gai_strerror(gai_error[0])
  end

  if true ~= result.found_entry then
    return nil,'not found'
  end

  local entry_data_list = ffi_cast('MMDB_entry_data_list_s **const',ffi_new("MMDB_entry_data_list_s"))

  local status = maxm.MMDB_get_entry_data_list(result.entry,entry_data_list)

  if status ~= MMDB_SUCCESS then
    return nil,'get entry data failed: ' .. mmdb_strerror(status)
  end  
  
  local head = entry_data_list[0] -- Save so this can be passed to free fn.
  local _,status,result = _dump_entry_data_list(entry_data_list)
  maxm.MMDB_free_entry_data_list(head)
  
  if status ~= MMDB_SUCCESS then
    return nil,'dump entry data failed: ' .. mmdb_strerror(status)
  end
  
  
  return result
end

-- copy from https://github.com/lilien1010/lua-resty-maxminddb/blob/master/resty/maxminddb.lua#L208
-- https://www.maxmind.com/en/geoip2-databases  you should download  the mmdb file from maxmind
 
return _M;
",
+  "mgmt_api.lua": "-- mgmt_api.lua
-- REST analytics endpoints backed by ngx.shared.dict.
-- Internal management port only (127.0.0.1:9145).

local cjson = require "cjson.safe"

local analytics    = ngx.shared.analytics
local request_data = ngx.shared.request_data
local uri          = ngx.var.uri

local function json(data, code)
    ngx.status = code or 200
    ngx.header["Content-Type"] = "application/json"
    ngx.say(cjson.encode(data))
    return ngx.exit(ngx.status)
end

local function bad(msg)
    return json({ error = msg }, 400)
end

-- ── GET /health ──────────────────────────────────────────────────────────────
-- Bare "ok", NOT JSON. probeMgmt() in apps/api/src/lib/project-analytics.ts
-- asserts `body.trim() === "ok"`, so anything richer here silently reports every
-- edge as unreachable and stops the analytics scrape. Richer diagnostics go on
-- /status below.

if uri == "/health" then
    ngx.say("ok")
    return ngx.exit(200)
end

-- ── GET /status - diagnosable edge health ────────────────────────────────────
-- Why this exists: geo failing is INVISIBLE otherwise. geo_country.lua pcalls its
-- FFI binding and returns nil on failure, so a missing libmaxminddb.so or a
-- missing database presents exactly like "nobody visited from a known country" —
-- an empty map with no error anywhere. This reports which it is.
--
-- Also reports shared-dict headroom: these zones LRU-EVICT when full rather than
-- erroring, so a full `visitors` zone silently UNDERCOUNTS. Callers surface that
-- as "approximate" instead of presenting an eviction artifact as a measurement.

if uri == "/status" then
    local geo_available, geo_reason, geo_db = false, "geo_country module not loadable", nil
    local geo_ok, geo = pcall(require, "kraft.geo_country")
    if geo_ok and geo and geo.status then
        geo_available, geo_reason, geo_db = geo.status()
    end

    local dicts = {}
    for _, name in ipairs({ "analytics", "request_data", "rules", "rl_counters", "visitors" }) do
        local d = ngx.shared[name]
        if d then
            dicts[name] = {
                capacity   = d.capacity and d:capacity() or nil,
                free_space = d.free_space and d:free_space() or nil,
            }
        end
    end

    return json({
        ok  = true,
        geo = { available = geo_available, reason = geo_reason, db = geo_db },
        dicts = dicts,
    })
end

-- ── /rules - per-route rules cache (written by the API, read by rules_guard) ──
-- POST /rules  body: { "host": "...", "rules": [ { "pathPrefix": "/", "spec": {...} } ] }
--   → replaces the ruleset for that host in the `rules` shared dict (reload-free).
--   An empty/absent `rules` array clears the host.
-- GET  /rules?host=...   → the stored ruleset (debug).
-- DELETE /rules?host=... → clear the host's ruleset.
-- Handled BEFORE the analytics guard: rules use their own dict.
-- ── /analytics/config - per-host collection switches ─────────────────────────
--
-- POST body: { "hosts": [ { "host": "...", "paths": true|false }, ... ] }
-- GET  ?host=...  → { host, paths }
--
-- A LIST, not a single host: a shared dict is RAM, so a full nginx restart (a reboot, a
-- `docker restart`, a package upgrade) empties it and every host on the box has to be
-- re-set at once. `openresty -s reload` preserves the zone — verified — so only a real
-- restart loses it, which is why the reconcile below exists and why it needs to cost one
-- round trip per server rather than one per domain.
--
-- Lives in the `rules` zone rather than `analytics` for the reason site_logger states:
-- the analytics zone is a 256 MB churn of counters under LRU pressure, and an evicted
-- config flag would silently change what is collected. This zone holds a few small values.
--
-- Deliberately its own endpoint rather than a field on /rules: the API only pushes /rules
-- for hosts that HAVE rules, so a project with none would never receive this flag.
--
-- No TTL — a shared dict is RAM and is lost on restart either way, so the API re-pushes on
-- every route apply and the database stays the source of truth.
if uri == "/analytics/config" then
    local rules = ngx.shared.rules
    if not rules then return json({ error = "rules dict unavailable" }, 503) end
    local method = ngx.req.get_method()

    if method == "GET" then
        local host = ngx.var.arg_host
        if not host or host == "" then return bad("missing ?host=") end
        host = host:lower()
        return json({ host = host, paths = rules:get("cfg:" .. host .. ":paths") == 1 })
    end

    if method == "POST" then
        ngx.req.read_body()
        local body = ngx.req.get_body_data()
        if not body then return bad("empty body") end
        local payload = cjson.decode(body)
        if type(payload) ~= "table" or type(payload.hosts) ~= "table" then
            return bad("expected { hosts: [ { host, paths } ] }")
        end
        local applied = 0
        for _, entry in ipairs(payload.hosts) do
            if type(entry) == "table" and entry.host then
                local key = "cfg:" .. tostring(entry.host):lower() .. ":paths"
                if entry.paths == true then
                    rules:set(key, 1)
                else
                    -- Deleted rather than set to 0, so "absent" is the only off state there
                    -- is. Two representations of off is how a reader ends up treating one of
                    -- them as on — and absent is also what a restarted box starts from, so
                    -- off has to mean exactly the same thing in both cases.
                    rules:delete(key)
                end
                applied = applied + 1
            end
        end
        return json({ ok = true, applied = applied })
    end

    return json({ error = "method not allowed" }, 405)
end

if uri == "/rules" then
    local rules = ngx.shared.rules
    if not rules then return json({ error = "rules dict unavailable" }, 503) end
    local method = ngx.req.get_method()

    if method == "GET" then
        local host = ngx.var.arg_host
        if not host or host == "" then return bad("missing ?host=") end
        host = host:lower()
        local raw = rules:get(host)
        return json({ host = host, rules = raw and cjson.decode(raw) or {} })
    end

    if method == "DELETE" then
        local host = ngx.var.arg_host
        if not host or host == "" then return bad("missing ?host=") end
        rules:delete(host:lower())
        return json({ ok = true })
    end

    if method == "POST" then
        ngx.req.read_body()
        local body = ngx.req.get_body_data()
        if not body then return bad("empty body") end
        local payload = cjson.decode(body)
        if type(payload) ~= "table" or not payload.host then
            return bad("expected { host, rules: [...] }")
        end
        local host = tostring(payload.host):lower()
        local list = payload.rules
        if type(list) ~= "table" or #list == 0 then
            rules:delete(host)                 -- empty set = clear the host
            return json({ ok = true, host = host, count = 0 })
        end
        local ok, err = rules:set(host, cjson.encode(list))
        if not ok then return json({ error = "set failed: " .. (err or "?") }, 500) end
        return json({ ok = true, host = host, count = #list })
    end

    return json({ error = "method not allowed" }, 405)
end

if not analytics then
    return json({ error = "analytics dict unavailable" }, 503)
end

-- ── Per-minute country index ─────────────────────────────────────────────────
--
-- site_logger writes one key per (domain, minute, country): `c:{domain}:{min}:{CC}`.
-- Reading them back needs key DISCOVERY, and `get_keys` is the only mechanism.
--
-- This used to sit INSIDE the per-minute loop, so a 24h window ran up to 1440
-- `get_keys(10000)` calls — each a full scan of a 256 MB zone, each holding the
-- dict lock against every worker. One scan per request instead, bucketed by
-- minute in a single pass; the loop then does plain table lookups.
--
-- `get_keys(0)` (all keys) rather than 10000: the cap silently TRUNCATED, so a
-- busy box just lost countries with no error. Unbounded is safe precisely because
-- this is now called once — see the comment on the call.
--- Read an enumerable set written by site_logger's index_add.
--
-- Replaces `get_keys`, which walked EVERY key in the 256 MB zone holding its lock — cost
-- proportional to zone population rather than to the answer, on a path called four
-- different ways. Here the counter says how many members exist and the slots name them, so
-- a read costs exactly as much as the data it returns.
--
-- Over-reads slightly by design: a slot can be written twice if two workers race on a
-- member's first sighting, and slots outlive nothing (same TTL as their counters). Both
-- collapse harmlessly because the caller keys results by member.
local function read_index(counter_key, slot_prefix)
    local n = tonumber(analytics:get(counter_key)) or 0
    if n <= 0 then return {} end
    local out, seen = {}, {}
    for i = 1, n do
        local m = analytics:get(slot_prefix .. i)
        if m and not seen[m] then
            seen[m] = true
            out[#out + 1] = m
        end
    end
    return out
end

--- Drain a counter WITHOUT losing a concurrent increment.
--
-- Was `get` then `delete`: a request landing between the two had its count deleted along
-- with the value that had just been read. Subtracting exactly what was read leaves any
-- concurrent increment behind as a residual the next scrape collects.
local function drain(key)
    local v = tonumber(analytics:get(key)) or 0
    if v ~= 0 then analytics:incr(key, -v) end
    return v
end

--- One day's rollup for one domain, read through its indexes.
--
-- Returns the same `suffix → value` shape the old whole-zone classifier produced, so both
-- callers stayed unchanged: bare country codes, `s:{code}`, `p:{path}`, `v`, `pn`.
local function read_rollup(domain, day)
    local gpfx = "g:" .. domain .. ":" .. day .. ":"
    local out = {}

    for _, cc in ipairs(read_index(gpfx .. "cn", gpfx .. "ci:")) do
        out[cc] = tonumber(analytics:get(gpfx .. cc)) or 0
    end
    for _, code in ipairs(read_index(gpfx .. "sn", gpfx .. "si:")) do
        out["s:" .. code] = tonumber(analytics:get(gpfx .. "s:" .. code)) or 0
    end
    -- `pn` doubles as the path index's counter, so paths need no separate one. When path
    -- collection is switched off for this host there is no counter and this reads nothing.
    for _, path in ipairs(read_index(gpfx .. "pn", gpfx .. "pi:")) do
        out["p:" .. path] = tonumber(analytics:get(gpfx .. "p:" .. path)) or 0
    end
    -- The over-cap bucket has a fixed name, so it is not in the index.
    local other = tonumber(analytics:get(gpfx .. "p:other"))
    if other then out["p:other"] = other end

    local v = tonumber(analytics:get(gpfx .. "v"))
    if v then out["v"] = v end
    return out
end

local function scan_country_index(domain, from_m, to_m)
    -- Walks the requested MINUTES and reads each one's own index. Bounded by the window
    -- (capped at 1440 by the caller), not by how much is in the zone.
    local by_minute = {}
    for m = from_m, to_m do
        local mpfx = "c:" .. domain .. ":" .. m .. ":"
        local ccs = read_index(mpfx .. "n", mpfx .. "i:")
        if #ccs > 0 then
            local slot = {}
            for i = 1, #ccs do
                -- Full key, because the flush drains by key.
                slot[ccs[i]] = mpfx .. ccs[i]
            end
            by_minute[m] = slot
        end
    end
    return by_minute
end

--- Split a namespaced analytics key into kind / domain / mid / rest.
--
-- Layouts: `c:{domain}:{minute}:{CC}` and `g:{domain}:{day}:{suffix}`.
-- Positional, NOT a full split on ":", because `suffix` legitimately contains
-- colons — a normalized path key looks like `g:x.com:20260803:p:/users/:id`.
-- Hostnames cannot contain ":", so the first three separators are unambiguous.
local function split_key(k)
    local p1 = k:find(":", 1, true)
    if not p1 then return nil end
    local p2 = k:find(":", p1 + 1, true)
    if not p2 then return nil end
    local p3 = k:find(":", p2 + 1, true)
    if not p3 then
        return k:sub(1, p1 - 1), k:sub(p1 + 1, p2 - 1), k:sub(p2 + 1), nil
    end
    return k:sub(1, p1 - 1), k:sub(p1 + 1, p2 - 1), k:sub(p2 + 1, p3 - 1), k:sub(p3 + 1)
end

--- Read one minute's country counts out of a scanned index.
-- @param slot table|nil  CC → full dict key, from scan_country_index
-- @param del boolean     drain each key after reading (flush semantics)
-- @return table|nil counts, or nil when the minute had no country data
local function read_minute_countries(slot, del)
    if not slot then return nil end
    local counts, any = {}, false
    for cc, key in pairs(slot) do
        -- `drain` subtracts what it read instead of deleting, so a request arriving
        -- mid-flush is not thrown away with the value that was just read.
        counts[cc] = del and drain(key) or (tonumber(analytics:get(key)) or 0)
        any = true
    end
    return any and counts or nil
end

-- ── POST /analytics/collect - the SCRAPER's endpoint: every domain, ONE scan ──
--
-- Body: { "day": "YYYYMMDD", "domains": [ { "domain": "x.com", "from": M, "to": M } ] }
-- Returns: { "domains": { "x.com": { buckets: [...], flushed: N, rollup: {...} } } }
--
-- Why this exists rather than looping the single-domain endpoints:
--
-- `get_keys` is the only key-discovery mechanism a shared dict offers, it walks the
-- WHOLE zone, and it holds the dict lock against every nginx worker while it does.
-- The scraper needs both the per-minute countries (flush) and the daily rollup for
-- each domain, so calling the per-domain endpoints cost 2N+1 unbounded scans of a
-- 256 MB zone — plus 2N+1 SSH/exec round trips — every sweep. On a 50-domain box
-- that is 101 full scans and 101 round trips, on a schedule, to collect data that
-- one pass already has in hand.
--
-- So: one `get_keys(0)`, classify every key by (kind, domain) in a single pass, then
-- serve all domains from the in-memory index. 2N+1 scans → 1, and 2N+1 round trips
-- → 1. The per-domain GET endpoints stay for the READ path, where a page view wants
-- one domain's live tail and a single scan is the honest cost.
--
-- Flush semantics are unchanged and still atomic per key: minute counters and their
-- country keys are deleted as they are read, so a bucket is handed to exactly one
-- caller no matter how many collectors race. The daily rollup is read-only — the
-- edge keeps running totals for the day, and deleting them would lose the totals for
-- every later scrape of the same day.

if uri == "/analytics/collect" and ngx.req.get_method() == "POST" then
    ngx.req.read_body()
    local body = ngx.req.get_body_data()
    if not body then return bad("empty body") end
    local payload = cjson.decode(body)
    if type(payload) ~= "table" or type(payload.domains) ~= "table" then
        return bad('expected { day, domains: [{domain, from, to}] }')
    end

    local day = payload.day
    if type(day) ~= "string" or #day ~= 8 then day = os.date("!%Y%m%d") end

    -- Requested domains → their minute window. Also the membership test the scan
    -- uses, so an unrequested domain's keys are skipped without a string compare
    -- per domain.
    local want, order = {}, {}
    for i = 1, #payload.domains do
        local d = payload.domains[i]
        if type(d) == "table" and type(d.domain) == "string" and d.domain ~= "" then
            local name = d.domain:lower()
            local from_m, to_m = tonumber(d.from), tonumber(d.to)
            if from_m and to_m then
                if to_m - from_m > 1440 then to_m = from_m + 1440 end -- cap at 24h
                if not want[name] then order[#order + 1] = name end
                want[name] = { from = from_m, to = to_m }
            end
        end
    end
    if #order == 0 then return json({ domains = {} }) end

    -- ── Per-domain index reads ───────────────────────────────────────────────
    --
    -- Was a single `get_keys(0)` pass classifying every key in the zone. One scan is better
    -- than 2N+1, but it still walked keys belonging to domains nobody asked about, and held
    -- the zone lock while doing it. Now each requested domain reads only its own indexes.
    local countries = {}   -- domain → minute → CC → dict key
    local rollups = {}     -- domain → suffix → value
    for i = 1, #order do
        local domain = order[i]
        local w = want[domain]
        countries[domain] = scan_country_index(domain, w.from, w.to)
        rollups[domain] = read_rollup(domain, day)
    end

    -- ── Serve each domain from the index ─────────────────────────────────────
    local out = {}
    for i = 1, #order do
        local domain = order[i]
        local w = want[domain]
        local cidx = countries[domain] or {}

        local buckets, flushed = {}, 0
        for m = w.from, w.to do
            local p = "s:" .. domain .. ":" .. m
            -- Drain FIRST, then decide: `drain` returns what it took, and a counter left
            -- at 0 by an earlier flush must not emit a bucket of zeros. (Zero is truthy in
            -- Lua, so the old `if r then` would have started doing exactly that the moment
            -- keys stopped being deleted.)
            local r = drain(p .. ":r")
            if r > 0 then
                local rt_us = drain(p .. ":t")
                buckets[#buckets + 1] = {
                    minute          = m,
                    requests        = r,
                    unique_requests = drain(p .. ":u"),
                    bandwidth_in    = drain(p .. ":i"),
                    bandwidth_out   = drain(p .. ":o"),
                    response_time   = rt_us / 1000000,
                    countries       = read_minute_countries(cidx[m], true),
                }
                flushed = flushed + 1
            end
        end

        -- Daily rollup, same key classification the single-domain endpoint uses.
        local geo, paths, statuses, visitors = {}, {}, {}, 0
        for suffix, v in pairs(rollups[domain] or {}) do
            if suffix == "v" then
                visitors = v
            elseif suffix:sub(1, 2) == "p:" then
                paths[suffix:sub(3)] = v
            elseif suffix:sub(1, 2) == "s:" then
                statuses[suffix:sub(3)] = v
            elseif suffix:match("^%u%u$") then
                geo[suffix] = v
            end
            -- Anything else (`pn`) is bookkeeping: never reported as a country.
        end

        out[domain] = {
            buckets = buckets,
            flushed = flushed,
            rollup  = {
                day = day, countries = geo, visitors = visitors,
                paths = paths, statuses = statuses,
            },
        }
    end

    return json({ day = day, domains = out })
end

-- ── GET /analytics - minute-bucket time series ───────────────────────────────
-- ?domain=example.com&from=EPOCH_MIN&to=EPOCH_MIN

if uri == "/analytics" then
    local domain = ngx.var.arg_domain
    if not domain or domain == "" then return bad("missing ?domain=") end
    domain = domain:lower()

    local from_m = tonumber(ngx.var.arg_from)
    local to_m   = tonumber(ngx.var.arg_to)
    if not from_m or not to_m then
        return bad("missing ?from= and ?to= (epoch minutes)")
    end
    -- Cap at 24h
    if to_m - from_m > 1440 then to_m = from_m + 1440 end

    -- ONE scan for the whole window (see scan_country_index).
    local country_index = scan_country_index(domain, from_m, to_m)

    local buckets = {}
    for m = from_m, to_m do
        local p = "s:" .. domain .. ":" .. m
        local r = analytics:get(p .. ":r")
        if r then
            -- Response time stored as microseconds, convert to seconds (float)
            local rt_us = analytics:get(p .. ":t") or 0
            buckets[#buckets + 1] = {
                minute           = m,
                requests         = r,
                unique_requests  = analytics:get(p .. ":u") or 0,
                bandwidth_in     = analytics:get(p .. ":i") or 0,
                bandwidth_out    = analytics:get(p .. ":o") or 0,
                response_time    = rt_us / 1000000,
                countries        = read_minute_countries(country_index[m], false),
            }
        end
    end

    return json({ domain = domain, buckets = buckets })
end

-- ── POST /analytics/flush - read + delete minute buckets ─────────────────────
-- Same as GET /analytics but deletes the returned buckets from shared memory.
-- Used by the scraper to atomically move data from OpenResty → DB.
-- ?domain=example.com&from=EPOCH_MIN&to=EPOCH_MIN

if uri == "/analytics/flush" and ngx.req.get_method() == "POST" then
    local domain = ngx.var.arg_domain
    if not domain or domain == "" then return bad("missing ?domain=") end
    domain = domain:lower()

    local from_m = tonumber(ngx.var.arg_from)
    local to_m   = tonumber(ngx.var.arg_to)
    if not from_m or not to_m then
        return bad("missing ?from= and ?to= (epoch minutes)")
    end
    if to_m - from_m > 1440 then to_m = from_m + 1440 end

    -- ONE scan for the whole window (see scan_country_index).
    local country_index = scan_country_index(domain, from_m, to_m)

    local buckets = {}
    local flushed = 0
    for m = from_m, to_m do
        local p = "s:" .. domain .. ":" .. m
        -- Drain, don't delete — see `drain`. A counter already at 0 is not a bucket.
        local r = drain(p .. ":r")
        if r > 0 then
            local rt_us = drain(p .. ":t")
            buckets[#buckets + 1] = {
                minute           = m,
                requests         = r,
                unique_requests  = drain(p .. ":u"),
                bandwidth_in     = drain(p .. ":i"),
                bandwidth_out    = drain(p .. ":o"),
                response_time    = rt_us / 1000000,
                -- Drained too: this endpoint hands the minute to the DB, so the country
                -- keys must go with it or they would be counted twice.
                countries        = read_minute_countries(country_index[m], true),
            }
            flushed = flushed + 1
        end
    end

    return json({ domain = domain, buckets = buckets, flushed = flushed })
end

-- ── GET /analytics/totals - lifetime counters ────────────────────────────────
-- ?domain=example.com      → single domain
-- (no domain)              → all known domains

if uri == "/analytics/totals" then
    local domain = ngx.var.arg_domain

    if not domain or domain == "" then
        -- The scraper's domain-discovery call. Read from the `dn`/`di:` index that
        -- site_logger appends to the first time it ever sees a host, so this no longer
        -- walks the zone. It was the worst place for a scan: a cap here silently dropped
        -- whole domains from every subsequent flush.
        local domains = {}
        for _, d in ipairs(read_index("dn", "di:")) do
            -- A host can be indexed but have had its lifetime totals evicted; report it
            -- with zeros rather than omitting it, so the scraper still asks for its buckets.
            domains[#domains + 1] = {
                domain        = d,
                requests      = analytics:get("t:" .. d .. ":r") or 0,
                bandwidth_in  = analytics:get("t:" .. d .. ":i") or 0,
                bandwidth_out = analytics:get("t:" .. d .. ":o") or 0,
            }
        end
        return json({ domains = domains })
    end

    domain = domain:lower()
    return json({
        domain        = domain,
        requests      = analytics:get("t:" .. domain .. ":r") or 0,
        bandwidth_in  = analytics:get("t:" .. domain .. ":i") or 0,
        bandwidth_out = analytics:get("t:" .. domain .. ":o") or 0,
    })
end

-- ── GET /analytics/geo - daily rollup for a day ──────────────────────────────
-- ?domain=example.com&day=YYYYMMDD
--
-- Named /geo for compatibility; it now returns the whole daily rollup — countries,
-- distinct visitors, top paths, status-code mix. One scan serves all four: they
-- share the `g:{domain}:{day}:` prefix precisely so a reader never needs a second
-- pass over the zone.
--
-- Key layout under that prefix (written by site_logger.lua):
--   <CC>            EXACTLY two uppercase letters → country hit count
--   v               distinct visitors today
--   p:<path>        path counter
--   pn              distinct-path counter (cardinality cap bookkeeping)
--   s:<status>      status-code counter
--
-- Country matching is strict (^%u%u$) rather than "whatever's left": a bookkeeping
-- key like `pn` would otherwise surface as a country named "pn" and get plotted.

if uri == "/analytics/geo" then
    local domain = ngx.var.arg_domain
    if not domain or domain == "" then return bad("missing ?domain=") end
    domain = domain:lower()

    local day = ngx.var.arg_day
    if not day or #day ~= 8 then
        day = os.date("!%Y%m%d")
    end

    -- Read through the write-time indexes — same helper /analytics/collect uses, so the two
    -- endpoints cannot disagree about what a day contains. Replaces a `get_keys(0)` that
    -- walked the whole zone to find keys under one prefix.
    local rollup = read_rollup(domain, day)
    local countries, paths, statuses = {}, {}, {}
    local visitors = tonumber(rollup["v"]) or 0
    for suffix, v in pairs(rollup) do
        if suffix == "v" or suffix == "pn" then
            -- bookkeeping, not data
        elseif suffix:sub(1, 2) == "p:" then
            paths[suffix:sub(3)] = v
        elseif suffix:sub(1, 2) == "s:" then
            statuses[suffix:sub(3)] = v
        elseif suffix:match("^%u%u$") then
            -- Country codes only. Anything else under this prefix is bookkeeping, and
            -- letting one through made `pn` plot as a country and skew every percentage.
            countries[suffix] = v
        end
    end
    return json({
        domain    = domain,
        day       = day,
        countries = countries,
        visitors  = visitors,
        paths     = paths,
        statuses  = statuses,
    })
end

-- ── GET /logs/recent - raw request ring buffer ───────────────────────────────
-- ?domain=example.com&limit=50

if uri == "/logs/recent" then
    if not request_data then
        return json({ error = "request_data dict unavailable" }, 503)
    end

    local domain = ngx.var.arg_domain
    if not domain or domain == "" then return bad("missing ?domain=") end
    domain = domain:lower()

    local limit = math.min(tonumber(ngx.var.arg_limit) or 50, 1000)
    local seq   = request_data:get("rlog:" .. domain .. ":seq") or 0
    local out   = {}

    for i = 0, limit - 1 do
        local slot = (seq - i) % 1000
        if slot < 0 then slot = slot + 1000 end
        local raw = request_data:get("rlog:" .. domain .. ":" .. slot)
        if raw then out[#out + 1] = raw end
    end

    -- Return pre-encoded JSON entries as a JSON array
    ngx.header["Content-Type"] = "application/json"
    ngx.print("[")
    for idx, entry in ipairs(out) do
        if idx > 1 then ngx.print(",") end
        ngx.print(entry)
    end
    ngx.say("]")
    return ngx.exit(200)
end

-- ── 404 ──────────────────────────────────────────────────────────────────────
return json({ error = "not found" }, 404)
",
+  "pipe_stream.lua": "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",
+  "rules_guard.lua": "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",
+  "rules_lib.lua": "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",
+  "site_logger.lua": "-- site_logger.lua
-- OpenResty log_by_lua - runs AFTER the response is sent.
-- Pure shared-dict analytics.  No Redis, no timers for counters, no batching.
-- Every incr() is atomic across workers.
--
-- Shared dict key schema (analytics zone):
--   s:{domain}:{epoch_min}:r        request count               (TTL 24h)
--   s:{domain}:{epoch_min}:i        bandwidth in  bytes         (TTL 24h)
--   s:{domain}:{epoch_min}:o        bandwidth out bytes         (TTL 24h)
--   s:{domain}:{epoch_min}:t        response time sum (seconds) (TTL 24h)
--   s:{domain}:{epoch_min}:u        page (non-static) requests  (TTL 24h)
--   c:{domain}:{epoch_min}:{CC}     country per minute          (TTL 24h)
--   t:{domain}:r / :i / :o          lifetime totals             (no TTL)
--   d:{domain}                      domain index marker         (no TTL)
--
--   Daily rollup, all under one `g:{domain}:{YYYYMMDD}:` prefix so mgmt_api's
--   /analytics/geo serves the whole day in a SINGLE dict scan:
--   g:{domain}:{YYYYMMDD}:{CC}      country hit count           (TTL 48h)
--   g:{domain}:{YYYYMMDD}:v         distinct visitors           (TTL 48h)
--   g:{domain}:{YYYYMMDD}:p:{path}  path hit count              (TTL 48h)
--   g:{domain}:{YYYYMMDD}:s:{code}  status-code count           (TTL 48h)
--
-- Shared dict key schema (visitors zone):
--   vsalt:{YYYYMMDD}                per-day hash salt           (TTL 48h)
--   vd:{domain}:{YYYYMMDD}:{hash}   distinct-visitor marker     (TTL 48h)
--
-- Shared dict key schema (request_data zone):
--   rlog:{domain}:seq               monotonic write pointer
--   rlog:{domain}:{slot}            JSON entry (ring buf)       (TTL 1h)
--
-- The ring is ALSO the live source: pipe_stream.lua's SSE endpoint reads these
-- slots by a per-connection cursor, so there is no separate live queue or
-- subscriber flag — every watcher sees the full stream and steals from none.
--
-- NOTE on `:u` — it counts non-static REQUESTS, not people. It was surfaced as
-- "unique IPs" all the way to the dashboard, which it never was. Real distinct
-- visitors are the `vd:`/`:v` pair below.

local cjson = require "cjson.safe"

-- SAFE LOAD: GeoIP Module (per-worker, cached by require)
local geo_ok, geo = pcall(require, "kraft.geo_country")
if not geo_ok then
    geo = nil
    ngx.log(ngx.WARN, "[site_logger] geo_country module not available. GeoIP disabled.")
end

local analytics    = ngx.shared.analytics
local request_data = ngx.shared.request_data
-- Per-host edge config, pushed by the API (see mgmt_api's /analytics/config).
--
-- The `rules` zone, NOT `analytics`: this holds a handful of small config values and is
-- never under eviction pressure, whereas the analytics zone is a 256 MB churn of counters.
-- An evicted flag there would silently stop path collection with nothing to explain why.
local rules_dict   = ngx.shared.rules
-- Optional: a box whose nginx.conf predates this zone keeps working, just without
-- distinct-visitor counts. Never assume a dict exists.
local visitors     = ngx.shared.visitors
if not analytics or not request_data then return end

-- ── Helpers ──────────────────────────────────────────────────────────────────

local function normalize(host)
    if not host then return nil end
    local h = host:lower()
    if h:sub(1, 4) == "www." then h = h:sub(5) end
    return h
end

local _day = { str = "", ts = 0 }
local function today()
    local now = ngx.now()
    if now - _day.ts > 60 then
        _day.str = os.date("!%Y%m%d", now)
        _day.ts = now
    end
    return _day.str
end

-- Fast check if URI is a static asset (for unique_requests counter)
local function is_static_asset(u)
    local lower = u:lower()

    -- Static file extensions
    if lower:match("%.js$") or lower:match("%.css$") or
       lower:match("%.jpg$") or lower:match("%.jpeg$") or
       lower:match("%.png$") or lower:match("%.gif$") or
       lower:match("%.svg$") or lower:match("%.webp$") or
       lower:match("%.ico$") or lower:match("%.bmp$") or
       lower:match("%.woff2?$") or lower:match("%.ttf$") or
       lower:match("%.eot$") or lower:match("%.otf$") or
       lower:match("%.mp4$") or lower:match("%.webm$") or
       lower:match("%.mp3$") or lower:match("%.wav$") or
       lower:match("%.pdf$") or lower:match("%.zip$") or
       lower:match("%.tar$") or lower:match("%.gz$") or
       lower:match("%.xml$") or lower:match("%.json$") or
       lower:match("%.txt$") or lower:match("%.map$") then
        return true
    end

    -- Common static paths
    if lower:match("^/_next/static/") or
       lower:match("^/static/") or
       lower:match("^/assets/") or
       lower:match("^/public/") or
       lower:match("/favicon%.ico") then
        return true
    end

    return false
end

-- Collapse a request URI into a low-cardinality bucket suitable as a dict key.
-- Without this, "top paths" is unbounded: every ?token=, every /orders/48219, and
-- every 404 a scanner probes mints a permanent key, and the analytics zone
-- LRU-evicts real counters to store junk.
local function normalize_path(u)
    -- Query string carries ids/tokens and never identifies the route.
    local path = u:match("^([^?#]*)") or u
    if path == "" then return "/" end
    -- Numeric and UUID/hex segments are ids, not routes: /orders/48219 and
    -- /orders/48220 are one path.
    path = path:gsub("/%d+", "/:id")
    path = path:gsub("/%x%x%x%x%x%x%x%x%-?%x*%-?%x*%-?%x*%-?%x*", "/:id")
    -- Bound the key itself — a long URI must not become a long key.
    if #path > 120 then path = path:sub(1, 120) .. "…" end
    return path
end

-- Raw request telemetry must never retain credentials from a URL. Query
-- strings routinely carry OAuth codes, signed URLs and tokens, so exclude them
-- completely. Invitation claim ids are bearer credentials in the path itself;
-- collapse those two known routes before either top-path aggregation or the
-- one-hour request ring can observe them.
local function telemetry_uri(u)
    local path = u:match("^([^?#]*)") or "/"
    if path == "" then return "/" end
    if path:match("^/accept%-invite/[^/]+") then
        return "/accept-invite/:token"
    end
    if path:match("^/api/auth/invitation%-preview/[^/]+") then
        return "/api/auth/invitation-preview/:token"
    end
    return path
end

-- ── Enumerable sets, without a zone scan ─────────────────────────────────────
--
-- Reading these counters back used to need key DISCOVERY, and a shared dict offers exactly
-- one mechanism for that: `get_keys`, which walks EVERY key in the zone holding its lock.
-- Cost scaled with how much was in the 256 MB zone, not with what was being asked for, and
-- it ran on the mgmt path four different ways.
--
-- So every unbounded set now carries its own index: a counter plus numbered slots.
--
--     <counter>        how many distinct members
--     <prefix><n>      the n-th member
--
-- A reader reads the counter and then reads slots 1..n. Bounded by the answer.
--
-- The write only happens on a member's FIRST sighting, so steady state costs nothing: the
-- millionth request from Germany today takes the plain `incr` path and touches no index.
local function index_add(counter_key, slot_prefix, member, ttl)
    local n = analytics:incr(counter_key, 1, 0, ttl)
    if n then analytics:set(slot_prefix .. n, member, ttl) end
end

--- Add 1 to a counter, creating it (with TTL) and indexing it on first sighting.
--
-- `incr` with no `init` returns nil for an absent key, which doubles as the existence
-- probe — so the common case is ONE hash operation. TTL is set by the creating `safe_add`
-- rather than passed to `incr`: shdict rejects `init_ttl` without `init`, and that raises a
-- Lua error which aborts the whole log handler (it has silently zeroed every counter below
-- it before).
local function bump_indexed(key, ttl, counter_key, slot_prefix, member)
    if analytics:incr(key, 1) then return end
    if analytics:safe_add(key, 1, ttl) then
        index_add(counter_key, slot_prefix, member, ttl)
    else
        -- Another worker created it between our probe and our add; our +1 still counts.
        analytics:incr(key, 1)
    end
end

local RING   = 1000
local D24H   = 86400
local D48H   = 172800
local D1H    = 3600

-- Distinct paths tracked per domain per day. Past this the tail folds into
-- "other" rather than growing the zone — a URL-fuzzing bot is capped at one
-- extra key, not thousands.
local PATH_CARDINALITY_CAP = 2000

-- ── Capture ──────────────────────────────────────────────────────────────────

local host = normalize(ngx.var.host)
if not host then return end

local ip      = ngx.var.remote_addr    or "0.0.0.0"
local ts      = ngx.now()
local ua      = ngx.var.http_user_agent or ""
local uri     = telemetry_uri(ngx.var.request_uri or "/")
local req_len = tonumber(ngx.var.request_length) or 0
local bytes   = tonumber(ngx.var.bytes_sent)     or 0
local rt      = tonumber(ngx.var.request_time)   or 0  -- seconds (float)
local method  = ngx.var.request_method or "GET"
local status  = ngx.var.status         or "0"

-- Client country, resolved ONCE per request.
--
-- Hoisted out of the geo block because both the daily/per-minute rollups and the raw
-- ring buffer need it. The ring is the single source for the request log — /logs/recent
-- reads it directly and the live SSE stream (pipe_stream.lua) reads the same slots by
-- cursor — so resolving the country here means every row carries its flag no matter
-- which path delivered it. An earlier split (looked up in the rollup, again in a
-- separate live pipe) left the ring with no country at all.
--
-- pcall'd because a corrupt or partially-written mmdb makes the lookup raise, and an
-- error here would abort every counter below it (see the section header).
local cc = nil
if geo and geo.get_country_code then
    local ok_cc, res = pcall(geo.get_country_code, ip)
    if ok_cc and type(res) == "string" and res ~= "" then cc = res end
end

-- ── 1. Minute-bucket counters ────────────────────────────────────────────────

local minute = math.floor(ts / 60)
local p = "s:" .. host .. ":" .. minute

analytics:incr(p .. ":r", 1,      0, D24H)
analytics:incr(p .. ":i", req_len, 0, D24H)
analytics:incr(p .. ":o", bytes,   0, D24H)

-- Response time as float seconds (matches original precision)
if rt > 0 then
    -- safe_add initializes, incr adds - emulate HINCRBYFLOAT with integer micros
    local rt_us = math.floor(rt * 1000000)
    analytics:incr(p .. ":t", rt_us, 0, D24H)
end

-- Unique (non-static) request counter
if not is_static_asset(uri) then
    analytics:incr(p .. ":u", 1, 0, D24H)
end

-- ── 2. Lifetime totals ──────────────────────────────────────────────────────

analytics:incr("t:" .. host .. ":r", 1,       0)
analytics:incr("t:" .. host .. ":i", req_len, 0)
analytics:incr("t:" .. host .. ":o", bytes,   0)

-- Domain index. `safe_add` returning true means this is the first request this box has
-- ever seen for the host, which is exactly when the enumerable index needs appending —
-- so domain discovery no longer costs a zone scan either.
if analytics:safe_add("d:" .. host, 1) then
    index_add("dn", "di:", host)
end

-- ── 3. Daily rollup: geo, visitors, paths, statuses ──────────────────────────
--
-- Each sub-block is pcall'd SEPARATELY, and that is load-bearing rather than
-- defensive habit. A raised error in log_by_lua aborts the remainder of the
-- handler, so one bad shdict call silently zeroes every counter written after it —
-- which is exactly what an `incr(..., nil, ttl)` here did: paths AND statuses read
-- as "no traffic" while requests and bandwidth looked perfect. Isolating them
-- means a future edit can lose at most its own metric.

local day  = today()
local gpfx = "g:" .. host .. ":" .. day .. ":"

-- 3a. GeoIP. `cc` was resolved once above and is reused by the ring buffer and the
-- live pipe, so a request costs exactly one mmdb lookup no matter how many consumers
-- report its country.
if cc then
    pcall(function()
        -- Daily geo (for /analytics/geo endpoint)
        bump_indexed(gpfx .. cc, D48H, gpfx .. "cn", gpfx .. "ci:", cc)
        -- Per-minute geo (for the time-series country breakdown). Indexed per MINUTE, so
        -- the scraper reads only the minutes in its window.
        local mpfx = "c:" .. host .. ":" .. minute .. ":"
        bump_indexed(mpfx .. cc, D24H, mpfx .. "n", mpfx .. "i:", cc)
    end)
end

-- 3b. Distinct visitors — a COUNT, never an identity.
--
-- The address is hashed with a salt that is generated on this box, rotates daily,
-- and is never written anywhere but this shared dict, so the marker keys are not
-- reversible to an IP and are worthless the next day. Only the resulting counter
-- is ever flushed to Postgres; no per-visitor row exists at any layer. That is
-- what lets us report real visitor numbers while still not collecting behavioural
-- analytics on anyone's end users.
--
-- Per DAY, not per minute: a per-minute set is ~1440x the keys for a number
-- nobody reads, and would evict the counters it exists to annotate.
pcall(function()
if visitors then
    local salt_key = "vsalt:" .. day
    local salt = visitors:get(salt_key)
    if not salt then
        -- First writer wins; a racing worker's safe_add fails and it re-reads. The
        -- salt only has to be unpredictable and stable for the day.
        salt = tostring(ngx.now()) .. tostring(math.random(1, 2147483647))
        local ok = visitors:safe_add(salt_key, salt, D48H)
        if not ok then salt = visitors:get(salt_key) or salt end
    end
    -- safe_add is the dedup: it succeeds ONLY on this visitor's first request
    -- today, so the counter below increments exactly once per distinct visitor.
    local marker = "vd:" .. host .. ":" .. day .. ":" .. ngx.crc32_long(salt .. ip)
    if visitors:safe_add(marker, 1, D48H) then
        analytics:incr(gpfx .. "v", 1, 0, D48H)
    end
end
end)

-- 3c. Top paths — OPT-IN, non-static only, normalized and cardinality-capped.
--
-- Off unless the project turned it on, because this one block is the most expensive thing
-- the log handler does. Measured on the shipped edge image, per request:
--
--     paths (whole block)        1.72 us      <- 57% of the counter path
--       of which string work     1.38 us      normalize_path + is_static_asset
--     minute buckets (5 incr)    0.61 us
--     country (2 incr)           0.24 us
--     status (1 incr)            0.14 us
--     this flag read (1 get)     0.07 us
--
-- So the gate costs 0.07 us and saves 1.72 us — the counter path drops from ~3.0 us to
-- ~1.35 us with paths off. It is also the highest-cardinality dimension (up to
-- PATH_CARDINALITY_CAP keys per domain per day, against ~200 countries and a few dozen
-- statuses) and the largest column in the daily rollup.
--
-- Absent flag = off. A box whose dict was just restarted therefore collects nothing until
-- the API re-pushes, which is the safe direction: no data beats data nobody asked to pay
-- for. The DB is the source of truth and re-pushes on every route apply.
local collect_paths = rules_dict and rules_dict:get("cfg:" .. host .. ":paths")

pcall(function()
if collect_paths and not is_static_asset(uri) then
    -- Hoisted: normalize_path is the single most expensive call in this handler (~1.4 us
    -- of string work), so it runs exactly once even though both the counter key and the
    -- index slot need its result.
    local norm = normalize_path(uri)
    local path_key = gpfx .. "p:" .. norm
    -- incr-then-add: the hot path is ONE hash hit on an existing key. `incr` with
    -- no init returns nil for an absent key, which doubles as the existence probe,
    -- so only a path unseen today reaches the cap check below.
    --
    -- Deliberately no init_ttl here: shdict rejects init_ttl unless init is also
    -- given ("'init_ttl' must be used with 'init'"), and that raises a Lua error
    -- which aborts the whole log handler — taking the status counters below down
    -- with it. The TTL is set by the safe_add on the creating request instead.
    if not analytics:incr(path_key, 1) then
        local distinct = analytics:incr(gpfx .. "pn", 1, 0, D48H) or 0
        if distinct > PATH_CARDINALITY_CAP then
            analytics:incr(gpfx .. "p:other", 1, 0, D48H)
        else
            -- `pn` was already the distinct-path counter, so the slots just give it an
            -- enumerable side. Stored WITHOUT the "p:" prefix; the reader adds it back.
            if analytics:safe_add(path_key, 1, D48H) then
                analytics:set(gpfx .. "pi:" .. distinct, norm, D48H)
            end
        end
    end
end
end)

-- 3d. Status-code mix. Bounded by construction (a few dozen codes).
pcall(function()
    bump_indexed(gpfx .. "s:" .. status, D48H, gpfx .. "sn", gpfx .. "si:", status)
end)

-- ── 4. Raw request ring buffer (also the live SSE source) ────────────────────
--
-- `seq` is claimed BEFORE encoding so the stored JSON can carry a deterministic
-- id (`{host}:{seq}`). That id is the dedup key everywhere downstream: /logs/recent
-- returns these entries verbatim, and pipe_stream.lua streams the same slots live,
-- so the same request reaches the client with one stable id instead of a fresh
-- random one per source. `incr` with init 0 never returns nil here; guard anyway
-- so a shdict hiccup can't index a nil into the slot key.

pcall(function()
    local seq = request_data:incr("rlog:" .. host .. ":seq", 1, 0)
    if not seq then return end
    local ok_j, j = pcall(cjson.encode, {
        id     = host .. ":" .. seq,
        ip     = ip,
        -- nil is simply omitted by cjson, so a box with no GeoIP writes the same shape
        -- minus this key rather than a null the reader has to special-case.
        country = cc,
        ts     = ts,
        method = method,
        status = status,
        uri    = uri,
        ua     = ua,
        bw_in  = req_len,
        bw_out = bytes,
        rt     = rt,
    })
    if ok_j and j then
        request_data:set("rlog:" .. host .. ":" .. (seq % RING), j, D1H)
    end
end)
",
+  "webhook_handler.lua": "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"
+};
+
+// ../../packages/adapters/src/infra/cloudflare-ips.generated.ts
+var CLOUDFLARE_IPV4 = [
+  "173.245.48.0/20",
+  "103.21.244.0/22",
+  "103.22.200.0/22",
+  "103.31.4.0/22",
+  "141.101.64.0/18",
+  "108.162.192.0/18",
+  "190.93.240.0/20",
+  "188.114.96.0/20",
+  "197.234.240.0/22",
+  "198.41.128.0/17",
+  "162.158.0.0/15",
+  "104.16.0.0/13",
+  "104.24.0.0/14",
+  "172.64.0.0/13",
+  "131.0.72.0/22"
+];
+var CLOUDFLARE_IPV6 = [
+  "2400:cb00::/32",
+  "2606:4700::/32",
+  "2803:f800::/32",
+  "2405:b500::/32",
+  "2405:8100::/32",
+  "2a06:98c0::/29",
+  "2c0f:f248::/32"
+];
+
+// ../../packages/adapters/src/infra/edge-real-ip.ts
+var EDGE_REAL_IP_CONF_NAME = "kraft-real-ip.conf";
+function edgeRealIpHeader() {
+  const raw = process.env.KRAFT_EDGE_REAL_IP_HEADER?.trim();
+  if (raw && /^[A-Za-z0-9-]{1,64}$/.test(raw)) return raw;
+  return "CF-Connecting-IP";
+}
+function edgeTrustedProxies() {
+  const raw = process.env.KRAFT_EDGE_TRUSTED_PROXIES?.trim();
+  if (!raw) return [];
+  const CIDR = /^(?:(?:\d{1,3}\.){3}\d{1,3}|[0-9a-fA-F:]+)(?:\/\d{1,3})?$/;
+  return raw.split(/[,\s]+/).map((s) => s.trim()).filter((s) => s.length > 0 && s.length <= 64 && CIDR.test(s));
+}
+function edgeRealIpConf() {
+  const header = edgeRealIpHeader();
+  const extra = edgeTrustedProxies();
+  const lines = [
+    "# Kraft \u2014 recover the real client address from a trusted front proxy.",
+    "#",
+    "# GENERATED. Source: packages/adapters/src/infra/edge-real-ip.ts",
+    "#",
+    "# Without this, remote_addr is the PROXY on any box behind Cloudflare or a load",
+    "# balancer, which silently breaks four things at once: visitor country resolves to",
+    "# the PoP, distinct-visitor counts collapse toward the number of PoPs, per-IP rate",
+    "# limits put the whole planet behind one PoP in a single bucket, and IP bans ban a",
+    "# PoP instead of a visitor.",
+    "#",
+    "# set_real_ip_from does NOT mean 'trust this header'. It means 'trust this header",
+    "# only when the TCP peer is one of these addresses'. Someone hitting the origin",
+    "# directly with a forged header is not connecting FROM Cloudflare, so the header is",
+    "# ignored and their real address stands. The trust is anchored to who opened the",
+    `# socket, which a client cannot forge.`,
+    "#",
+    `# The header is ${header}.`,
+    ...header.toLowerCase() === "cf-connecting-ip" ? [
+      "# Cloudflare OVERWRITES CF-Connecting-IP, so its value holds nothing the client",
+      "# supplied. It deliberately is NOT X-Forwarded-For: Cloudflare APPENDS to that",
+      "# one, so XFF arrives as '<client-controlled>, <real client>' and reading it",
+      "# left-to-right would let a visitor choose their own apparent address \u2014 and",
+      "# with it their rate-limit bucket and which ban rules miss them."
+    ] : [
+      "# NOT the default (CF-Connecting-IP) \u2014 set via KRAFT_EDGE_REAL_IP_HEADER.",
+      "# If this is X-Forwarded-For, note that proxies APPEND to it, so the header is",
+      "# partly client-controlled; real_ip_recursive below is what makes nginx walk it",
+      "# from the right and stop at the last untrusted hop, which is the real client."
+    ],
+    "",
+    `real_ip_header ${header};`,
+    "",
+    "# Walk a multi-hop header from the RIGHT, skipping trusted addresses. Inert for a",
+    "# single-value header like CF-Connecting-IP; load-bearing for X-Forwarded-For, where",
+    "# the left-hand entries are whatever the client sent.",
+    "real_ip_recursive on;",
+    "",
+    `# Cloudflare's published edge ranges (${CLOUDFLARE_IPV4.length} v4 + ${CLOUDFLARE_IPV6.length} v6).`,
+    "# Trusted unconditionally, which is safe by construction: on a box that is not behind",
+    "# Cloudflare no peer ever matches, so every line here is inert. Refresh with",
+    "# `bun run update:cloudflare-ips`.",
+    ...CLOUDFLARE_IPV4.map((c) => `set_real_ip_from ${c};`),
+    ...CLOUDFLARE_IPV6.map((c) => `set_real_ip_from ${c};`)
+  ];
+  if (extra.length > 0) {
+    lines.push(
+      "",
+      "# Operator-declared proxies (KRAFT_EDGE_TRUSTED_PROXIES). Each of these can set",
+      "# the header above and be believed, so keep the list to hosts you control.",
+      ...extra.map((c) => `set_real_ip_from ${c};`)
+    );
+  }
+  return lines.join("\n") + "\n";
+}
+var CLOUD_EDGE_REAL_IP_HEADER = "X-Real-IP";
+function isCloudFrontedHost(hostname) {
+  const host = hostname.trim().toLowerCase().replace(/\.+$/, "");
+  const suffix = `.${SYSTEM.DOMAINS.CLOUD_DOMAIN.toLowerCase()}`;
+  return host.length > suffix.length && host.endsWith(suffix);
+}
+function cloudEdgeRealIpConf(indent = "    ") {
+  const lines = [
+    "# Kraft Cloud's edge fronts this free host, so the peer is the edge and the",
+    "# visitor is named in X-Real-IP (which that front OVERWRITES). The http-scope block",
+    "# reads CF-Connecting-IP for Cloudflare-fronted custom domains, and there is one",
+    "# real_ip_header per scope \u2014 hence this override.",
+    "#",
+    "# Trust is scoped to this VHOST instead of to a peer list, deliberately. The Cloud",
+    "# edge reaches origins from its own address, which this box has no way to know and",
+    "# which Cloudflare's ranges (the visitor\u2192edge leg) do not contain \u2014 so a peer list",
+    "# here silently ignores the header and every free-domain visitor stays the edge.",
+    "#",
+    "# What bounds it is the server_name: this block exists only inside a <slug>.kraft.io",
+    "# vhost, a hostname whose only legitimate path is that edge. Someone who reaches this",
+    "# box directly on :80 with a forged Host AND a forged X-Real-IP can choose their own",
+    "# apparent address for THIS vhost \u2014 accepted, because the alternative is the address",
+    "# being wrong for every visitor all the time. Custom domains keep the peer-anchored",
+    "# http-scope block; do not widen this to them.",
+    `real_ip_header ${CLOUD_EDGE_REAL_IP_HEADER};`,
+    // OFF, unlike the http-scope block: the Cloud edge OVERWRITES X-Real-IP with a single
+    // address, so there is no list to walk, and "skip trusted addresses from the right"
+    // has no meaning once every address is trusted.
+    "real_ip_recursive off;",
+    "set_real_ip_from 0.0.0.0/0;",
+    "set_real_ip_from ::/0;"
+  ];
+  return lines.map((l) => `${indent}${l}`).join("\n") + "\n";
+}
+
+// ../../packages/adapters/src/infra/edge-not-found.ts
+var EDGE_UNROUTED_SENTINEL = "kraft-edge-unrouted";
+var HTML_FRAGMENTS = [
+  `<!doctype html>`,
+  `<!--${EDGE_UNROUTED_SENTINEL}-->`,
+  `<html lang="en">`,
+  `<head>`,
+  `<meta charset="utf-8">`,
+  `<meta name="viewport" content="width=device-width,initial-scale=1">`,
+  // An unrouted host must never enter a search index under our page.
+  `<meta name="robots" content="noindex,nofollow">`,
+  `<title>Service not found</title>`,
+  `<style>`,
+  // Matches the dashboard's theme: a neutral black-on-white scale, mirrored for
+  // dark. No webfont, no image, no external request — the page must render on a
+  // box whose only working listener is the one serving it. Colours are `rgb()`,
+  // never `#rrggbb`: see the no-`#` invariant in the header.
+  `:root{color-scheme:light dark}`,
+  `*{box-sizing:border-box}`,
+  `body{margin:0;min-height:100vh;display:flex;align-items:center;justify-content:center;background:rgb(255,255,255);color:rgba(0,0,0,.66);font:15px/1.6 -apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Helvetica,Arial,sans-serif;-webkit-font-smoothing:antialiased}`,
+  `main{width:100%;max-width:32rem;padding:2.5rem 1.5rem;text-align:center}`,
+  // The muted scale is .56, not the .4–.52 it started at: black at .52 on white is
+  // 4.3:1 and at .4 is 2.9:1, both under WCAG AA's 4.5:1 for text this small, and
+  // this is the most-seen page the edge serves. .56 ≈ 4.75:1.
+  `.tag{display:inline-flex;align-items:center;gap:.5rem;margin-bottom:1.25rem;padding:.25rem .625rem;border:1px solid rgba(0,0,0,.1);border-radius:999px;font-size:12px;color:rgba(0,0,0,.56)}`,
+  `.dot{width:6px;height:6px;border-radius:50%;background:rgb(224,169,10)}`,
+  `h1{margin:0 0 .5rem;font-size:1.375rem;font-weight:600;letter-spacing:-.01em;color:rgba(0,0,0,.92)}`,
+  `p{margin:0 auto 1.5rem;max-width:26rem}`,
+  `ul{display:inline-block;margin:0;padding:0;list-style:none;text-align:left;font-size:13.5px;color:rgba(0,0,0,.56)}`,
+  `li{position:relative;padding:.2rem 0 .2rem 1rem}`,
+  `li::before{content:"";position:absolute;left:0;top:.75em;width:4px;height:4px;border-radius:50%;background:rgba(0,0,0,.25)}`,
+  `footer{margin-top:2.25rem;font-size:12px;color:rgba(0,0,0,.56)}`,
+  `@media(prefers-color-scheme:dark){`,
+  `body{background:rgb(10,10,10);color:rgba(255,255,255,.66)}`,
+  `.tag{border-color:rgba(255,255,255,.12);color:rgba(255,255,255,.56)}`,
+  `h1{color:rgba(255,255,255,.95)}`,
+  `ul{color:rgba(255,255,255,.56)}`,
+  `li::before{background:rgba(255,255,255,.28)}`,
+  `footer{color:rgba(255,255,255,.56)}`,
+  `}`,
+  `</style>`,
+  `</head>`,
+  `<body>`,
+  `<main>`,
+  `<span class="tag"><span class="dot"></span>404 &middot; no route</span>`,
+  `<h1>Service not found</h1>`,
+  // "reachable, but nothing is configured" is the whole message: it separates a
+  // down app from an address that was never wired up, which is the distinction a
+  // raw TLS error or a stock 404 destroys.
+  `<p>This server is reachable, but no application is configured for the address you requested.</p>`,
+  `<ul>`,
+  `<li>Check the address for a typo</li>`,
+  `<li>The deployment may have been removed or renamed</li>`,
+  `<li>A newly added domain can take a few minutes to start serving</li>`,
+  `</ul>`,
+  `<footer>Served by Kraft</footer>`,
+  `</main>`,
+  `</body>`,
+  `</html>`
+];
+var EDGE_NOT_FOUND_HTML = HTML_FRAGMENTS.join("");
+var EDGE_NOT_FOUND_LOCATION = `    server_tokens off;
+
+    location / {
+        types { }
+        default_type text/html;
+        return 404 '${EDGE_NOT_FOUND_HTML}';
+    }`;
+
+// ../../packages/adapters/src/infra/openresty-reload.ts
+var NGINX_MASTER_RE = /\b(?:nginx|openresty)\s*:\s*master process/i;
+var NGINX_WORKER_RE = /\b(?:nginx|openresty)\s*:\s*worker process/i;
+var NGINX_PROCESS_RE = /\b(?:nginx|openresty)\b/i;
+async function canonicalRemotePath(executor, path) {
+  const resolved = await executor.exec(`readlink -f ${sq(path)} 2>/dev/null || true`, { timeout: 5e3 }).catch(() => "");
+  return resolved.trim() || null;
+}
+function explicitNginxConfig(rawCommand) {
+  const match = rawCommand.match(
+    /(?:^|\s)-c(?:(?:\s+|=)(?:"([^"]+)"|'([^']+)'|(\S+))|(\S+))/
+  );
+  if (!match) return void 0;
+  const value = match[1] ?? match[2] ?? match[3] ?? match[4] ?? "";
+  return value.startsWith("/") ? value : null;
+}
+function hasExplicitNginxPrefix(rawCommand) {
+  return /(?:^|\s)-p(?:\s+|=|\S)/.test(rawCommand);
+}
+async function processStartTime(executor, pid) {
+  const value = await executor.exec(
+    `awk '{ line=$0; sub(/^.*\\) /, "", line); split(line, fields, " "); print fields[20] }' /proc/${pid}/stat 2>/dev/null || true`,
+    { timeout: 5e3 }
+  ).catch(() => "");
+  return /^\d+$/.test(value.trim()) ? value.trim() : null;
+}
+async function verifyNginxProcessIdentity(executor, occupant, paths) {
+  if (!occupant.pid) return "unknown";
+  const rawCommand = occupant.rawCommand?.trim();
+  if (!rawCommand || !NGINX_MASTER_RE.test(rawCommand)) return "unknown";
+  const [actualExe, expectedExe] = await Promise.all([
+    canonicalRemotePath(executor, `/proc/${occupant.pid}/exe`),
+    canonicalRemotePath(executor, paths.bin)
+  ]);
+  if (!actualExe || !expectedExe) return "unknown";
+  if (actualExe !== expectedExe) return "foreign";
+  if (hasExplicitNginxPrefix(rawCommand)) return "unknown";
+  const explicitConfig = explicitNginxConfig(rawCommand);
+  if (explicitConfig === null) return "unknown";
+  const effectiveConfig = explicitConfig ?? paths.compiledConfPath;
+  const [actualConfig, expectedConfig] = await Promise.all([
+    canonicalRemotePath(executor, effectiveConfig),
+    canonicalRemotePath(executor, paths.confPath)
+  ]);
+  if (!actualConfig || !expectedConfig || actualConfig !== expectedConfig)
+    return "unknown";
+  return "match";
+}
+async function resolveListeningNginxMaster(executor, occupant) {
+  const description = `${occupant.rawCommand ?? ""} ${occupant.command}`;
+  if (!occupant.pid || !NGINX_WORKER_RE.test(description)) return occupant;
+  const rawParent = await executor.exec(
+    `awk '/^PPid:/{print $2}' /proc/${occupant.pid}/status 2>/dev/null || true`
+  ).catch(() => "");
+  const parentPid = Number.parseInt(rawParent.trim(), 10);
+  if (!Number.isInteger(parentPid) || parentPid <= 1) return occupant;
+  const parent = await describeProcess(executor, parentPid).catch(() => null);
+  if (!parent) return occupant;
+  const parentDescription = `${parent.rawCommand ?? ""} ${parent.command}`;
+  return NGINX_MASTER_RE.test(parentDescription) ? parent : occupant;
+}
+async function reloadBareOpenResty(executor, paths, opts = {}) {
+  await executor.exec(`${sq(paths.bin)} -t -c ${sq(paths.confPath)} 2>&1`, {
+    timeout: 15e3
+  });
+  const listenerStates = await Promise.all([
+    probeListeningPortOwners(executor, 80),
+    probeListeningPortOwners(executor, 443)
+  ]);
+  if (listenerStates.some((state) => !state.checked)) {
+    throw new Error(
+      "OpenResty config is valid, but the port 80/443 listener probe was inconclusive; refusing to assume the managed daemon is stopped."
+    );
+  }
+  if (listenerStates.some((state) => !state.ownershipComplete)) {
+    throw new Error(
+      "OpenResty config is valid, but every listener on port 80/443 could not be identified; refusing to signal an unknown or mixed owner."
+    );
+  }
+  const occupants = listenerStates.flatMap((state) => state.occupants);
+  const verifiedMasters = /* @__PURE__ */ new Map();
+  let foreignListenerOwner = false;
+  let ambiguousNginxOwner = false;
+  let containerBackedNginxOwner = false;
+  for (const occupant of occupants) {
+    if (!occupant.rawCommand?.trim()) {
+      ambiguousNginxOwner = true;
+      continue;
+    }
+    const description = [
+      occupant.rawCommand,
+      occupant.command,
+      occupant.systemdUnit,
+      occupant.systemdDescription
+    ].filter(Boolean).join(" ");
+    if (!NGINX_PROCESS_RE.test(description)) {
+      foreignListenerOwner = true;
+      continue;
+    }
+    if (occupant.containerId) {
+      containerBackedNginxOwner = true;
+      continue;
+    }
+    const master = await resolveListeningNginxMaster(executor, occupant);
+    if (master.containerId) {
+      containerBackedNginxOwner = true;
+      continue;
+    }
+    const initialIdentity = await verifyNginxProcessIdentity(
+      executor,
+      master,
+      paths
+    );
+    if (initialIdentity === "foreign") {
+      foreignListenerOwner = true;
+      continue;
+    }
+    if (initialIdentity === "unknown" || !master.pid) {
+      ambiguousNginxOwner = true;
+      continue;
+    }
+    if (master.cgroupVerified !== true || !master.processCgroup) {
+      ambiguousNginxOwner = true;
+      continue;
+    }
+    const startTime = await processStartTime(executor, master.pid);
+    if (!startTime) {
+      ambiguousNginxOwner = true;
+      continue;
+    }
+    const refreshedMaster = await describeProcess(executor, master.pid).catch(
+      () => null
+    );
+    const confirmedStartTime = await processStartTime(executor, master.pid);
+    if (!refreshedMaster || confirmedStartTime !== startTime || refreshedMaster.cgroupVerified !== true || !refreshedMaster.processCgroup) {
+      ambiguousNginxOwner = true;
+      continue;
+    }
+    if (refreshedMaster.containerId) {
+      containerBackedNginxOwner = true;
+      continue;
+    }
+    const identity = await verifyNginxProcessIdentity(
+      executor,
+      refreshedMaster,
+      paths
+    );
+    if (identity !== "match") {
+      ambiguousNginxOwner = true;
+      continue;
+    }
+    verifiedMasters.set(master.pid, {
+      pid: master.pid,
+      startTime,
+      processCgroup: refreshedMaster.processCgroup
+    });
+  }
+  if (containerBackedNginxOwner) {
+    throw new Error(
+      "A container-backed nginx/OpenResty listener owns port 80/443; refusing to signal it from bare-host reload."
+    );
+  }
+  if (ambiguousNginxOwner) {
+    throw new Error(
+      "A live nginx/OpenResty listener was found, but its executable and configuration could not be verified, or its host ownership could not be proven; refusing to signal an ambiguous process."
+    );
+  }
+  if (foreignListenerOwner) {
+    throw new Error(
+      verifiedMasters.size > 0 ? "The managed OpenResty master shares ports 80/443 with a foreign listener; refusing a reload that cannot apply the validated configuration safely." : "A foreign listener owns port 80/443; refusing to treat a live daemon as stopped or report the managed route reload as complete."
+    );
+  }
+  if (verifiedMasters.size === 0) {
+    if (opts.allowStopped && occupants.length === 0) return;
+    const owners = occupants.map((occupant) => occupant.command).filter(Boolean);
+    throw new Error(
+      "OpenResty config is valid, but no verified bare-host master is listening on port 80/443" + (owners.length > 0 ? ` (found: ${owners.join(", ")})` : "") + "; refusing to start a second daemon."
+    );
+  }
+  if (verifiedMasters.size !== 1) {
+    throw new Error(
+      `Found ${verifiedMasters.size} verified nginx/OpenResty masters on ports 80/443; refusing an ambiguous reload.`
+    );
+  }
+  const target = [...verifiedMasters.values()][0];
+  await executor.exec(
+    `current_exe=$(readlink -f /proc/${target.pid}/exe 2>/dev/null || true); expected_exe=$(readlink -f ${sq(paths.bin)} 2>/dev/null || true); current_start=$(awk '{ line=$0; sub(/^.*\\) /, "", line); split(line, fields, " "); print fields[20] }' /proc/${target.pid}/stat 2>/dev/null || true); current_cgroup=$(cat /proc/${target.pid}/cgroup 2>/dev/null) || { echo "nginx master cgroup became unreadable; refusing reload" >&2; exit 1; }; [ -n "$current_exe" ] && [ "$current_exe" = "$expected_exe" ] && [ "$current_start" = ${sq(target.startTime)} ] && [ -n "$current_cgroup" ] && [ "$current_cgroup" = ${sq(target.processCgroup)} ] || { echo "nginx master identity changed; refusing reload" >&2; exit 1; }; kill -HUP ${target.pid}`,
+    { timeout: 5e3 }
+  ).catch((err) => {
+    throw new Error(
+      `Safe bare-host OpenResty reload failed: ${safeErrorMessage(err)}`
+    );
+  });
+}
+
+// ../../packages/adapters/src/infra/openresty-lua.ts
+var OPENRESTY_LUA_DIR = "/usr/local/openresty/site/lualib/kraft";
+var LUA_LOGGER_PATH = `${OPENRESTY_LUA_DIR}/site_logger.lua`;
+var RULES_GUARD_PATH = `${OPENRESTY_LUA_DIR}/rules_guard.lua`;
+var OPENRESTY_MGMT_PORT = 9145;
+var OPENRESTY_SITE_LUALIB = OPENRESTY_LUA_DIR.replace(/\/[^/]+$/, "");
+var EDGE_LUA_PACKAGE_PATH = `${OPENRESTY_SITE_LUALIB}/?.lua;;`;
+var EDGE_SERVER_NAMES_HASH_BUCKET_SIZE = 128;
+var EDGE_CLIENT_MAX_BODY_SIZE = "50m";
+var EDGE_SHARED_DICTS = [
+  /** Analytics counters. */
+  { name: "analytics", size: "256m" },
+  /** Raw-log ring buffers + the live-log pipe. */
+  { name: "request_data", size: "128m" },
+  /** Per-route rules cache: written reload-free by mgmt_api `POST /rules`, read
+   *  by rules_guard.lua in the access phase. The DB (route_rule) is the source
+   *  of truth, so losing this dict costs a re-push, not a ruleset. */
+  { name: "rules", size: "32m" },
+  /** Rate-limit COUNTERS, kept apart from `rules` so a high-cardinality flood (a
+   *  fresh key per source IP per second) can't LRU-evict the rulesets and
+   *  silently disable enforcement mid-attack.
+   *
+   *  32m, matching openresty module migration 1.1.0, which raises it from the
+   *  original 16m on boxes already installed. Both must state the same target: a
+   *  fresh install writes THIS value, so leaving it at 16m meant a new box got the
+   *  size the migration exists to correct — and only bare boxes that consented to
+   *  the migration would ever reach 32m. The migration stays because the
+   *  `grep || sed` convergence below is append-only and cannot resize an existing
+   *  directive; `edge-shared-dicts.test.ts` pins the two together. */
+  { name: "rl_counters", size: "32m" },
+  /**
+   * Distinct-visitor sets. One key per (domain, day, salted-IP hash) — high
+   * cardinality and short-lived, so it gets its own zone for the same reason
+   * `rl_counters` does: a busy day's visitor set must not LRU-evict the analytics
+   * counters or the rulesets.
+   *
+   * Privacy: keys hold a per-day-salted hash, never an address, and only the
+   * resulting COUNT is ever flushed to Postgres. Nothing that identifies a visitor
+   * leaves the box — see the visitor block in site_logger.lua.
+   *
+   * 64m ≈ 1M distinct visitors/day. Past that the zone LRU-evicts and the count
+   * UNDERSTATES; `GET /status` reports free_space so a reader can mark it
+   * approximate rather than present an eviction artifact as a measurement.
+   */
+  { name: "visitors", size: "64m" }
+];
+function parseNginxVersion(raw) {
+  const m = raw.match(/nginx version:\s*\S*?\/(\d+)\.(\d+)\.(\d+)/i);
+  if (!m) return void 0;
+  return [Number(m[1]), Number(m[2]), Number(m[3])];
+}
+var OPENRESTY_DEFAULT_PATHS = {
+  bin: "/usr/local/openresty/bin/openresty",
+  compiledConfPath: "/usr/local/openresty/nginx/conf/nginx.conf",
+  confPath: "/usr/local/openresty/nginx/conf/nginx.conf",
+  confDir: "/usr/local/openresty/nginx/conf",
+  sitesDir: "/usr/local/openresty/nginx/conf/sites-enabled",
+  pidPath: "/usr/local/openresty/nginx/logs/nginx.pid"
+};
+var EDGE_DEFAULT_CERT_DIRNAME = "kraft-default-cert";
+function edgeDefaultCertPaths(confDir) {
+  const dir = `${confDir}/${EDGE_DEFAULT_CERT_DIRNAME}`;
+  return {
+    dir,
+    certPath: `${dir}/fullchain.pem`,
+    keyPath: `${dir}/privkey.pem`
+  };
+}
+var EDGE_DEFAULT_CERT_CN = "kraft-edge-default";
+var EDGE_HOST_STATE_DIR = "/var/lib/kraft/edge";
+var EDGE_CONTAINER_MOUNTS = [
+  {
+    host: `${EDGE_HOST_STATE_DIR}/sites-enabled`,
+    container: OPENRESTY_DEFAULT_PATHS.sitesDir
+  },
+  { host: "/etc/letsencrypt", container: "/etc/letsencrypt" },
+  { host: `${EDGE_HOST_STATE_DIR}/acme`, container: "/var/www/acme" },
+  { host: "/opt/kraft/static", container: "/opt/kraft/static" }
+];
+var EDGE_SAME_PATH_MOUNTS = EDGE_CONTAINER_MOUNTS.filter((m) => m.host === m.container).map(
+  (m) => m.host.replace(/\/+$/, "")
+);
+var EDGE_HOST_PATHS = {
+  bin: OPENRESTY_DEFAULT_PATHS.bin,
+  compiledConfPath: OPENRESTY_DEFAULT_PATHS.compiledConfPath,
+  confPath: OPENRESTY_DEFAULT_PATHS.confPath,
+  confDir: OPENRESTY_DEFAULT_PATHS.confDir,
+  sitesDir: `${EDGE_HOST_STATE_DIR}/sites-enabled`,
+  pidPath: OPENRESTY_DEFAULT_PATHS.pidPath
+};
+var KNOWN_CONF_PATHS = [
+  "/usr/local/openresty/nginx/conf/nginx.conf",
+  "/etc/openresty/nginx.conf",
+  "/etc/nginx/nginx.conf"
+];
+async function detectOpenRestyPaths(executor) {
+  const raw = await executor.exec("openresty -V 2>&1 || true");
+  const parseFlag = (flag) => {
+    const m = raw.match(new RegExp(`--${flag}=([^\\s]+)`));
+    return m ? m[1] : null;
+  };
+  const bin = parseFlag("sbin-path") ?? OPENRESTY_DEFAULT_PATHS.bin;
+  const compiledConfPath = parseFlag("conf-path") ?? OPENRESTY_DEFAULT_PATHS.compiledConfPath;
+  let confPath = compiledConfPath;
+  const pidPath = parseFlag("pid-path") ?? OPENRESTY_DEFAULT_PATHS.pidPath;
+  if (!await executor.exists(confPath)) {
+    let found = false;
+    for (const candidate of KNOWN_CONF_PATHS) {
+      if (candidate !== confPath && await executor.exists(candidate)) {
+        confPath = candidate;
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
+    }
+  }
+  const confDir = confPath.replace(/\/[^/]+$/, "");
+  const nginxVersion = parseNginxVersion(raw);
+  return {
+    bin,
+    compiledConfPath,
+    confPath,
+    confDir,
+    sitesDir: `${confDir}/sites-enabled`,
+    pidPath,
+    ...nginxVersion ? { nginxVersion } : {}
+  };
+}
+function buildReloadCommand(paths) {
+  const bin = sq(paths?.bin || "openresty");
+  const config = sq(paths?.confPath || "/etc/openresty/nginx.conf");
+  return `${bin} -t -c ${config} 2>&1 || exit 1
+${bin} -s reload -c ${config} 2>&1 || exit 1`;
+}
+async function ensureEdgeDefaultCert(executor, confDir) {
+  const { dir, certPath, keyPath } = edgeDefaultCertPaths(confDir);
+  try {
+    if (await executor.exists(certPath) && await executor.exists(keyPath)) {
+      return { certPath, keyPath };
+    }
+  } catch {
+    return null;
+  }
+  const staging = `${dir}.staging-${process.pid}-${randomBytes(4).toString("hex")}`;
+  try {
+    await executor.mkdir(staging);
+    await executor.exec(
+      `openssl req -x509 -newkey ec -pkeyopt ec_paramgen_curve:P-256 -nodes -days 3650 -subj ${sq(`/CN=${EDGE_DEFAULT_CERT_CN}`)} -keyout ${sq(`${staging}/privkey.pem`)} -out ${sq(`${staging}/fullchain.pem`)} 2>/dev/null`
+    );
+    await executor.exec(`chmod 600 ${sq(`${staging}/privkey.pem`)}`);
+    await executor.mkdir(dir);
+    await executor.exec(
+      `mv -f ${sq(`${staging}/fullchain.pem`)} ${sq(`${staging}/privkey.pem`)} ${sq(dir)}/`
+    );
+    if (!await executor.exists(certPath) || !await executor.exists(keyPath))
+      return null;
+    return { certPath, keyPath };
+  } catch (err) {
+    console.warn(
+      `[openresty] could not create the edge's default certificate \u2014 an unrouted HTTPS host will get a TLS error instead of the "service not found" page (is openssl installed?): ${safeErrorMessage(err)}`
+    );
+    return null;
+  } finally {
+    await executor.rm(staging).catch(() => void 0);
+  }
+}
+async function ensureOpenRestyConfig(executor, paths) {
+  await executor.mkdir(paths.sitesDir);
+  await executor.mkdir("/var/www/acme");
+  const pidDir = paths.pidPath.replace(/\/[^/]+$/, "");
+  await executor.mkdir(pidDir);
+  const defaultCert = await ensureEdgeDefaultCert(executor, paths.confDir);
+  await executor.writeFile(
+    `${paths.sitesDir}/_management.conf`,
+    MANAGEMENT_BLOCK
+  );
+  await executor.writeFile(
+    `${paths.sitesDir}/_default.conf`,
+    edgeDefaultCatchAllConf(defaultCert)
+  );
+  if (!await executor.exists(paths.confPath)) {
+    await executor.mkdir(paths.confDir);
+    await executor.writeFile(
+      paths.confPath,
+      MINIMAL_NGINX_CONF(paths.confDir, paths.sitesDir)
+    );
+    return;
+  }
+  const hasCorrectInclude = await executor.exec(`grep -qF 'include ${paths.sitesDir}/' ${paths.confPath}`).then(() => true).catch(() => false);
+  if (!hasCorrectInclude) {
+    const hasWrongInclude = await executor.exec(`grep -q 'include.*sites-enabled' ${paths.confPath}`).then(() => true).catch(() => false);
+    if (hasWrongInclude) {
+      await executor.exec(
+        `sed -i 's|include.*/sites-enabled/\\*\\.conf;|include ${paths.sitesDir}/*.conf;|' ${paths.confPath}`
+      );
+    } else {
+      await executor.exec(
+        `sed -i '/http *{/a \\    include ${paths.sitesDir}/*.conf;' ${paths.confPath}`
+      );
+    }
+  }
+  const hasBodySize = await executor.exec(`grep -qE '^[[:space:]]*client_max_body_size' ${paths.confPath}`).then(() => true).catch(() => false);
+  if (!hasBodySize) {
+    await executor.exec(
+      `sed -i '/http *{/a \\    client_max_body_size ${EDGE_CLIENT_MAX_BODY_SIZE};' ${paths.confPath}`
+    );
+  }
+}
+function MINIMAL_NGINX_CONF(confDir, sitesDir) {
+  return `# Auto-generated by Kraft - safe to extend
+worker_processes auto;
+events {
+    worker_connections 1024;
+}
+http {
+    include       ${confDir}/mime.types;
+    default_type  application/octet-stream;
+    sendfile      on;
+    keepalive_timeout 65;
+    # See EDGE_SERVER_NAMES_HASH_BUCKET_SIZE \u2014 the 64-byte default fails
+    # \`nginx -t\` outright for any server_name past ~63 chars, refusing the reload
+    # and wedging every route on the box, not just the long one.
+    server_names_hash_bucket_size ${EDGE_SERVER_NAMES_HASH_BUCKET_SIZE};
+    # See EDGE_CLIENT_MAX_BODY_SIZE \u2014 nginx's 1 MB default 413s an upload before the app
+    # ever sees it. A project's own value overrides this (server beats http).
+    client_max_body_size ${EDGE_CLIENT_MAX_BODY_SIZE};
+    include ${sitesDir}/*.conf;
+}
+`;
+}
+var GEOIP_DIR = "/usr/share/GeoIP";
+var GEOIP_DB_PATH = `${GEOIP_DIR}/GeoLite2-Country.mmdb`;
+var GEOIP_DB_URL = process.env.KRAFT_GEOIP_URL?.trim() || "https://raw.githubusercontent.com/rakay-technology/kraft/main/apps/api/assets/geoip/GeoLite2-Country.mmdb";
+var LUA_SRC_DIR = process.env.KRAFT_LUA_DIR?.trim() || join(dirname(fileURLToPath(import.meta.url)), "lua");
+var VHOST_REFERENCED_LUA = [
+  "rules_guard.lua",
+  "rules_lib.lua",
+  "site_logger.lua"
+];
+function luaSourceAvailable() {
+  return VHOST_REFERENCED_LUA.every(
+    (f) => EMBEDDED_LUA[f] !== void 0 || existsSync(join(LUA_SRC_DIR, f))
+  );
+}
+function readLua(filename) {
+  const onDisk = join(LUA_SRC_DIR, filename);
+  if (existsSync(onDisk)) return readFileSync(onDisk, "utf-8");
+  const embedded = EMBEDDED_LUA[filename];
+  if (embedded !== void 0)
+    return Buffer.from(embedded, "base64").toString("utf-8");
+  throw new Error(
+    `Lua script "${filename}" not found on disk (${LUA_SRC_DIR}) or in EMBEDDED_LUA \u2014 add it to packages/adapters/src/infra/lua/ and run \`bun run embed:lua\`.`
+  );
+}
+var EDGE_MGMT_SERVER_BLOCK = `server {
+    listen 127.0.0.1:${OPENRESTY_MGMT_PORT};
+
+    # Long-running Lua content handlers need generous timeouts
+    send_timeout          3600s;
+    keepalive_timeout     3600s;
+    lua_check_client_abort on;
+
+    # SSE live-log stream (long-lived connection)
+    location = /logs/stream {
+        content_by_lua_file ${OPENRESTY_LUA_DIR}/pipe_stream.lua;
+    }
+
+    # REST analytics + health (short-lived)
+    location / {
+        content_by_lua_file ${OPENRESTY_LUA_DIR}/mgmt_api.lua;
+    }
+}`;
+var MANAGEMENT_BLOCK = `# Kraft internal management - analytics & live-log streaming
+# Auto-generated - do not edit manually
+${EDGE_MGMT_SERVER_BLOCK}
+`;
+var ACME_HTTP01_PORT = 49180;
+var ACME_CHALLENGE_LOCATION = `    location ^~ /.well-known/acme-challenge/ {
+        proxy_pass http://127.0.0.1:${ACME_HTTP01_PORT};
+        proxy_set_header Host $host;
+    }`;
+var EDGE_CHALLENGE_URL_PREFIX = "/.well-known/oblien-proxy-challenge/";
+var EDGE_CHALLENGE_ROOT = "/var/www/acme/oblien";
+var EDGE_CHALLENGE_DIR = `${EDGE_CHALLENGE_ROOT}${EDGE_CHALLENGE_URL_PREFIX}`.replace(/\/$/, "");
+var EDGE_CHALLENGE_HOST_DIR = `${EDGE_HOST_STATE_DIR}/acme/oblien${EDGE_CHALLENGE_URL_PREFIX}`.replace(
+  /\/$/,
+  ""
+);
+var EDGE_CHALLENGE_LOCATION = `    location ^~ ${EDGE_CHALLENGE_URL_PREFIX} {
+        root ${EDGE_CHALLENGE_ROOT};
+        default_type text/plain;
+        try_files $uri =404;
+    }`;
+function edgeChallengeVhostConf(host) {
+  return `# Auto-generated by Kraft - do not edit manually
+# kraft-oblien-challenge: answers ${EDGE_CHALLENGE_URL_PREFIX}<token> for
+# Host: ${host}, so Kraft Cloud's shared edge can prove this box controls that
+# routing target. Everything else gets the shared not-found page - this is
+# scaffolding, not a site.
+server {
+    listen 80;
+    server_name ${host};
+
+${EDGE_CHALLENGE_LOCATION}
+
+${EDGE_NOT_FOUND_LOCATION}
+}
+`;
+}
+var EDGE_HTTPS_REJECT_BLOCK = `# HTTPS catch-all. WITHOUT a 443 default_server, nginx serves the first-loaded
+# 443 vhost to any request whose SNI matches no server_name - so a domain we do
+# NOT route (removed / never-added / just pointed at this IP) silently gets some
+# other app's cert + backend. That is cross-serving, a security hole. Owning the
+# 443 default closes it: an unrouted host is answered HERE, never by a fallthrough.
+#
+# This is the no-certificate variant, used only when the placeholder cert could not
+# be created. It refuses the handshake, so the visitor gets a raw TLS error and a
+# Cloudflare-proxied host gets error 525 - correct, but unfriendly. See
+# edgeHttpsDefaultBlock. ssl_reject_handshake (OpenResty/nginx >= 1.19.4; our
+# installer pulls the newest LTS) needs no certificate.
+server {
+    listen 443 ssl default_server;
+    ssl_reject_handshake on;
+}`;
+function edgeHttpsDefaultBlock(cert) {
+  if (!cert) return EDGE_HTTPS_REJECT_BLOCK;
+  return `# HTTPS catch-all. WITHOUT a 443 default_server, nginx serves the first-loaded
+# 443 vhost to any request whose SNI matches no server_name - so a domain we do
+# NOT route (removed / never-added / just pointed at this IP) silently gets some
+# other app's cert + backend. That is cross-serving, a security hole. Owning the
+# 443 default closes it: an unrouted host is answered HERE, never by a fallthrough.
+#
+# The cert below belongs to no domain and is trusted by nothing - it exists so the
+# handshake COMPLETES and the request can be answered with a page instead of
+# ERR_SSL_UNRECOGNIZED_NAME_ALERT (Cloudflare "Full" reports the refusal as error
+# 525; "Full (Strict)" validates the cert and will still show 526). Keep this block a
+# dead end: no proxy_pass, no root, no HSTS, no reuse of a real certificate - that is
+# what stops it from becoming the cross-serving it prevents. And never set
+# ssl_certificate at http scope: this block would inherit a real domain's cert.
+server {
+    listen 443 ssl default_server;
+    server_name _;
+
+    ssl_certificate ${cert.certPath};
+    ssl_certificate_key ${cert.keyPath};
+
+${EDGE_NOT_FOUND_LOCATION}
+}`;
+}
+function edgeDefaultCatchAllConf(cert) {
+  return `# Kraft default catch-all - prevents the stock OpenResty welcome page AND
+# stops an unmatched Host/SNI from being served the first real vhost by default.
+# Auto-generated - do not edit manually
+server {
+    listen 80 default_server;
+    server_name _;
+
+${ACME_CHALLENGE_LOCATION}
+
+${EDGE_NOT_FOUND_LOCATION}
+}
+
+${edgeHttpsDefaultBlock(cert)}
+`;
+}
+var LUA_SCRIPTS = [
+  "site_logger.lua",
+  "pipe_stream.lua",
+  "mgmt_api.lua",
+  "geo_country.lua",
+  // Vendored FFI binding geo_country requires as `kraft.maxminddb`. Ships with
+  // the rest so a bare box needs no `opm get` (which needs perl) — see the file
+  // header. Flat, like every other script: ensureLuaScripts writes this list into
+  // one directory and its presence scan is a plain `ls -1`.
+  "maxminddb.lua",
+  "rules_lib.lua",
+  "rules_guard.lua"
+];
+var LUA_VERSION_MARKER = `${OPENRESTY_LUA_DIR}/.kraft-lua-version`;
+function luaBundleHash() {
+  const h = createHash("sha256");
+  for (const name of LUA_SCRIPTS) {
+    h.update(name);
+    h.update("\0");
+    h.update(readLua(name));
+    h.update("\0");
+  }
+  return h.digest("hex");
+}
+async function ensureLuaScripts(executor, paths) {
+  try {
+    if (!luaSourceAvailable()) {
+      console.error(
+        "[openresty] Lua unavailable in this build (not on disk or embedded) \u2014 edge rules/logging disabled. Run `bun run embed:lua` in packages/adapters."
+      );
+      return { repaired: [], available: false };
+    }
+    const expected = luaBundleHash();
+    await executor.mkdir(OPENRESTY_LUA_DIR);
+    const listing = await executor.exec(`ls -1 '${OPENRESTY_LUA_DIR}' 2>/dev/null || true`).catch(() => "");
+    const present = new Set(
+      listing.split("\n").map((s) => s.trim()).filter(Boolean)
+    );
+    const missing = LUA_SCRIPTS.filter((name) => !present.has(name));
+    const onBoxVersion = (await executor.readFile(LUA_VERSION_MARKER).catch(() => "")).trim();
+    if (missing.length === 0 && onBoxVersion === expected) {
+      return { repaired: [], available: true };
+    }
+    for (const name of LUA_SCRIPTS) {
+      await executor.writeFile(`${OPENRESTY_LUA_DIR}/${name}`, readLua(name));
+    }
+    await executor.writeFile(LUA_VERSION_MARKER, expected);
+    const reason = missing.length ? `missing: ${missing.join(", ")}` : "version changed";
+    console.warn(`[openresty] (re)installed Lua (${reason}) \u2014 reloading edge.`);
+    await reloadBareOpenResty(executor, paths).catch((err) => {
+      console.error(
+        `[openresty] reload after Lua (re)install failed: ${safeErrorMessage(err)}`
+      );
+    });
+    return {
+      repaired: missing.length ? missing : [...LUA_SCRIPTS],
+      available: true
+    };
+  } catch (err) {
+    console.error(
+      `[openresty] ensureLuaScripts failed (deploy continues): ${safeErrorMessage(err)}`
+    );
+    return { repaired: [], available: false };
+  }
+}
+async function installGeoDeps(executor) {
+  const profile = await resolveEnvironment(executor).catch(
+    (err) => safeErrorMessage(err)
+  );
+  const install = typeof profile === "string" ? refused(`the host profile could not be read: ${profile}`) : envOps(profile).pkgInstallVariants({
+    apt: answered(["libmaxminddb0", "libmaxminddb-dev"]),
+    dnf: answered(["libmaxminddb", "libmaxminddb-devel"]),
+    yum: answered(["libmaxminddb", "libmaxminddb-devel"]),
+    apk: answered(["libmaxminddb"]),
+    brew: refused(
+      "the bare edge is Linux-only, so Kraft has no macOS package for it."
+    )
+  });
+  if (install.supported) {
+    await executor.exec(opScript(install.value)).catch((err) => {
+      console.warn(
+        `[openresty] libmaxminddb install failed \u2014 geo lookups return nil: ${safeErrorMessage(err)}`
+      );
+    });
+  } else {
+    console.warn(
+      `[openresty] libmaxminddb not installed \u2014 geo lookups return nil: ${install.reason}`
+    );
+  }
+  try {
+    const exists = await executor.exists(GEOIP_DB_PATH);
+    if (!exists) {
+      await executor.mkdir(GEOIP_DIR);
+      await executor.exec(`curl -fsSL -o ${GEOIP_DB_PATH} "${GEOIP_DB_URL}"`);
+    }
+  } catch {
+  }
+}
+async function deployLuaScripts(executor, paths) {
+  await installGeoDeps(executor);
+  if (!luaSourceAvailable()) {
+    throw new Error(
+      `OpenResty Lua is unavailable in this build \u2014 not on disk (LUA_SRC_DIR=${LUA_SRC_DIR}) and not in EMBEDDED_LUA. The edge scripts (rules_guard.lua/site_logger.lua) can't be installed. Run \`bun run embed:lua\` in packages/adapters to regenerate lua-embedded.ts.`
+    );
+  }
+  await executor.mkdir(OPENRESTY_LUA_DIR);
+  for (const name of LUA_SCRIPTS) {
+    await executor.writeFile(`${OPENRESTY_LUA_DIR}/${name}`, readLua(name));
+  }
+  await ensureOpenRestyConfig(executor, paths);
+  for (const dict of EDGE_SHARED_DICTS) {
+    await executor.exec(
+      `grep -q 'lua_shared_dict ${dict.name} ' ${paths.confPath} || sed -i '/http *{/a \\    lua_shared_dict ${dict.name} ${dict.size};' ${paths.confPath}`
+    );
+  }
+  await executor.exec(
+    `grep -q 'lua_package_path' ${paths.confPath} || sed -i '/http *{/a \\    lua_package_path "${EDGE_LUA_PACKAGE_PATH}";' ${paths.confPath}`
+  );
+  const realIpPath = `${paths.confDir}/${EDGE_REAL_IP_CONF_NAME}`;
+  await executor.writeFile(realIpPath, edgeRealIpConf());
+  await executor.exec(
+    `grep -q '${EDGE_REAL_IP_CONF_NAME}' '${paths.confPath}' || sed -i '/http *{/a \\    include ${realIpPath};' '${paths.confPath}'`
+  );
+  await reloadBareOpenResty(executor, paths);
+}
+
+export {
+  isCloudFrontedHost,
+  cloudEdgeRealIpConf,
+  reloadBareOpenResty,
+  OPENRESTY_LUA_DIR,
+  LUA_LOGGER_PATH,
+  RULES_GUARD_PATH,
+  OPENRESTY_MGMT_PORT,
+  EDGE_LUA_PACKAGE_PATH,
+  EDGE_SERVER_NAMES_HASH_BUCKET_SIZE,
+  EDGE_CLIENT_MAX_BODY_SIZE,
+  EDGE_SHARED_DICTS,
+  parseNginxVersion,
+  OPENRESTY_DEFAULT_PATHS,
+  EDGE_DEFAULT_CERT_DIRNAME,
+  edgeDefaultCertPaths,
+  EDGE_DEFAULT_CERT_CN,
+  EDGE_HOST_STATE_DIR,
+  EDGE_CONTAINER_MOUNTS,
+  EDGE_SAME_PATH_MOUNTS,
+  EDGE_HOST_PATHS,
+  detectOpenRestyPaths,
+  buildReloadCommand,
+  ensureOpenRestyConfig,
+  GEOIP_DIR,
+  GEOIP_DB_PATH,
+  luaSourceAvailable,
+  EDGE_MGMT_SERVER_BLOCK,
+  ACME_HTTP01_PORT,
+  ACME_CHALLENGE_LOCATION,
+  EDGE_CHALLENGE_URL_PREFIX,
+  EDGE_CHALLENGE_ROOT,
+  EDGE_CHALLENGE_DIR,
+  EDGE_CHALLENGE_HOST_DIR,
+  EDGE_CHALLENGE_LOCATION,
+  edgeChallengeVhostConf,
+  EDGE_HTTPS_REJECT_BLOCK,
+  edgeHttpsDefaultBlock,
+  edgeDefaultCatchAllConf,
+  ensureLuaScripts,
+  deployLuaScripts
+};