@runeditrun/rer 0.0.0-stage → 0.1.1

package/modules/ai/dev/index.mjs

@@ -0,0 +1,64 @@
+import { devGate, devNotFound } from '../../operator-auth/dev-gate.mjs';
+import { createAiClient, AiError } from '../index.mjs';
+import { createFakeTransport, DEV_AI_MARKER } from '../fake/index.mjs';
+import { createAiOutbox } from './outbox.mjs';
+
+export { createAiOutbox } from './outbox.mjs';
+export { DEV_AI_MARKER } from '../fake/index.mjs';
+const headers = { 'cache-control': 'no-store', 'x-content-type-options': 'nosniff', 'x-robots-tag': 'noindex, nofollow', 'content-security-policy': "default-src 'none'; frame-ancestors 'none'", 'x-rer-ai-dev': DEV_AI_MARKER };
+
+/** The originating product request must pass operator-auth's gate, too. */
+export function createDevAiClient(config, { request, key, origin, local, outbox, live, fetch: send = globalThis.fetch, script }) {
+  const gate = devGate({ key, origin, local });
+  const capture = async record => {
+    try { await outbox.put(record); }
+    catch { throw new AiError('dev_outbox_unavailable', 503); }
+  };
+  const fake = createFakeTransport({ script, capture });
+  const selected = live ? { ...config, direct: undefined, models: live, features: {} } : { ...config, direct: { baseUrl: origin, apiKey: 'dev-double' }, models: undefined, features: {} };
+  const client = createAiClient(selected, live ? { fetch: send } : { transport: fake });
+  return Object.freeze(Object.fromEntries(['chat', 'responses', 'embeddings', 'receipt'].map(operation => [operation, async (body, options) => {
+    if (!gate || !await gate.admits(request)) throw new AiError('dev_access_denied', 404);
+    if (!live) return client[operation](body, options);
+    let response;
+    try {
+      response = await client[operation](body, options);
+      // Live dev retains receipt headers only. Never read/tee the response body.
+      const receipt = Object.fromEntries(['x-models-request', 'x-models-target', 'x-models-attempts', 'x-models-cost-microusd'].map(name => [name, response.headers.get(name)]).filter(([, value]) => value !== null));
+      await capture({ feature: options?.feature ?? 'default', operation, receipt });
+      return response;
+    } catch (error) {
+      if (response) {
+        try { await response.body?.cancel(); } catch {}
+      } else await capture({ feature: options?.feature ?? 'default', operation, error: { code: error instanceof AiError ? error.code : 'ai_unavailable' } });
+      throw error;
+    }
+  }])));
+}
+
+/** Mount only in server.dev; production has neither this route nor the double. */
+export function withDevAi(worker, { bindings = env => env } = {}) {
+  return {
+    ...worker,
+    async fetch(request, original, execution) {
+      const path = new URL(request.url).pathname;
+      if (path !== '/__dev/ai' && !path.startsWith('/__dev/ai/')) return worker.fetch(request, original, execution);
+      const env = bindings(original), origin = env.RER_DEV_ORIGIN ?? env.AUTH_ORIGIN;
+      const gate = devGate({ key: env.RER_DEV_KEY, origin, local: env.AUTH_LOCAL === 'true' });
+      if (!gate || !await gate.admits(request)) return devNotFound();
+      try {
+        const outbox = createAiOutbox({ db: env.DB });
+        if (path === '/__dev/ai' && ['GET', 'HEAD'].includes(request.method)) return new Response(request.method === 'HEAD' ? null : JSON.stringify(await outbox.list()), { headers: { ...headers, 'content-type': 'application/json' } });
+        const operation = { '/__dev/ai/v1/chat/completions': 'chat', '/__dev/ai/v1/responses': 'responses', '/__dev/ai/v1/embeddings': 'embeddings' }[path];
+        if (!operation || request.method !== 'POST') return devNotFound();
+        let body; try { body = await request.json(); } catch { throw new AiError('ai_invalid_request', 400); }
+        const live = env.RER_MODELS_SERVICE || env.RER_MODELS_KEY ? { baseUrl: env.RER_MODELS_SERVICE, apiKey: env.RER_MODELS_KEY } : undefined;
+        const client = createDevAiClient({ enabled: true }, { request, key: env.RER_DEV_KEY, origin, local: true, outbox, live });
+        return await client[operation](body, { feature: request.headers.get('x-models-feature') ?? undefined, signal: request.signal });
+      } catch (error) {
+        const safe = error instanceof AiError ? error : new AiError('ai_unavailable');
+        return Response.json({ error: { code: safe.code, message: safe.message } }, { status: safe.status, headers });
+      }
+    },
+  };
+}

package/modules/ai/dev/outbox.mjs

@@ -0,0 +1,33 @@
+const schema = `CREATE TABLE IF NOT EXISTS rer_ai_development_outbox (
+  sequence INTEGER PRIMARY KEY AUTOINCREMENT, id TEXT NOT NULL UNIQUE,
+  created_at INTEGER NOT NULL, record TEXT NOT NULL
+)`;
+
+/** Uses the seed's real local D1; no memory-storage alternative. */
+export function createAiOutbox({ db, clock = Date.now, maxRequests = 100, maxAgeMs = 7 * 86400000 }) {
+  if (!db?.prepare || !db?.batch || !Number.isSafeInteger(maxRequests) || maxRequests < 1 || !Number.isSafeInteger(maxAgeMs) || maxAgeMs < 1) throw new TypeError('Invalid AI outbox');
+  let initialized;
+  const statement = (sql, ...values) => db.prepare(sql).bind(...values);
+  async function ready() {
+    initialized ??= db.prepare(schema).run().then(result => { if (!result.success) throw new Error('AI outbox unavailable'); }).catch(error => { initialized = undefined; throw error; });
+    await initialized;
+  }
+  return {
+    async put(record) {
+      await ready();
+      const time = clock();
+      const results = await db.batch([
+        statement('INSERT INTO rer_ai_development_outbox(id,created_at,record) VALUES(?,?,?)', crypto.randomUUID(), time, JSON.stringify(record)),
+        statement('DELETE FROM rer_ai_development_outbox WHERE created_at <= ?', time - maxAgeMs),
+        statement('DELETE FROM rer_ai_development_outbox WHERE sequence NOT IN (SELECT sequence FROM rer_ai_development_outbox ORDER BY sequence DESC LIMIT ?)', maxRequests),
+      ]);
+      if (results.some(result => result.success !== true)) throw new Error('AI outbox unavailable');
+    },
+    async list() {
+      await ready();
+      const result = await statement('SELECT id,created_at,record FROM rer_ai_development_outbox WHERE created_at > ? ORDER BY sequence DESC LIMIT ?', clock() - maxAgeMs, maxRequests).all();
+      if (!result.success) throw new Error('AI outbox unavailable');
+      return result.results.map(row => ({ id: row.id, createdAt: row.created_at, ...JSON.parse(row.record) }));
+    },
+  };
+}

package/modules/ai/errors.mjs

@@ -0,0 +1,28 @@
+const messages = {
+  ai_disabled: 'AI is off for this feature.',
+  ai_misconfigured: 'Configure exactly one AI transport for this feature.',
+  ai_unavailable: 'The AI provider is unavailable.',
+  ai_target_mismatch: 'The served target differs from the pinned model requested.',
+  ai_invalid_response: 'The AI provider returned an invalid response.',
+  ai_invalid_request: 'The AI request is invalid.',
+  dev_fake_cannot_answer: 'The dev double cannot answer schema-typed outputs or forced tool calls. Use live dev with a capped Models dev app.',
+  dev_access_denied: 'Not found',
+  dev_outbox_unavailable: 'The local AI outbox is unavailable.',
+};
+
+/** Fixed messages only: credentials and upstream exception bodies never escape. */
+export class AiError extends Error {
+  constructor(code, status = 502) {
+    super(messages[code] ?? 'The AI request was refused.');
+    this.name = 'AiError';
+    this.code = code;
+    this.status = status;
+  }
+}
+
+export const serviceErrorCodes = new Set([
+  'ai_unavailable', 'ai_misconfigured', 'no_eligible_target', 'field_not_allowed',
+  'budget_exhausted', 'upstream_limited', 'upstream_unavailable', 'upstream_auth',
+  'upstream_policy_unmet', 'upstream_uncertain', 'upstream_error',
+  'response_too_large', 'dev_fake_cannot_answer',
+]);

package/modules/ai/fake/index.d.mts

@@ -0,0 +1,3 @@
+import type { AiTransport, AiRequest } from '../index.mjs';
+export const DEV_AI_MARKER: string;
+export function createFakeTransport(options?: { script?: AiTransport['request']; capture?: (record: { feature: string; operation: string; request?: AiRequest; response?: unknown; usage?: unknown; error?: { code: string; status: number } }) => Promise<void> }): AiTransport;

package/modules/ai/fake/index.mjs

@@ -0,0 +1,82 @@
+import { AiError } from '../errors.mjs';
+
+export const DEV_AI_MARKER = 'rer-ai-dev:local-only-never-deploy';
+const encoder = new TextEncoder();
+async function hash(input) {
+  const bytes = await crypto.subtle.digest('SHA-256', encoder.encode(JSON.stringify(input)));
+  return [...new Uint8Array(bytes)];
+}
+const hex = bytes => bytes.map(b => b.toString(16).padStart(2, '0')).join('');
+const headers = { 'cache-control': 'no-store', 'x-rer-ai-dev': DEV_AI_MARKER };
+function sse(events, signal) {
+  return new Response(new ReadableStream({
+    pull(controller) {
+      if (signal?.aborted) { controller.error(new AiError('upstream_uncertain', 504)); return; }
+      const event = events.shift();
+      if (event === undefined) { controller.close(); return; }
+      controller.enqueue(encoder.encode(event));
+    },
+  }), { headers: { ...headers, 'content-type': 'text/event-stream' } });
+}
+const data = value => `data: ${JSON.stringify(value)}\n\n`;
+const event = (type, value) => `event: ${type}\n${data({ type, ...value })}`;
+
+/** Explicit provider-edge double. Scripted mode never invents an answer. */
+export function createFakeTransport({ script, capture = async () => {} } = {}) {
+  return {
+    async request({ operation, body, feature, signal }) {
+      if (signal?.aborted) throw new AiError('upstream_uncertain', 504);
+      try {
+        if (script) {
+          const response = await script({ operation, body, feature, signal });
+          if (!response.headers.get('content-type')?.includes('text/event-stream')) await capture({ feature, operation, request: body, response: await response.clone().json() });
+          return response;
+        }
+        const format = body.response_format?.type ?? body.text?.format?.type;
+        const forcedTool = body.tool_choice !== undefined && !['auto', 'none'].includes(body.tool_choice);
+        if (format === 'json_schema' || forcedTool) throw new AiError('dev_fake_cannot_answer', 422);
+        if (format !== undefined && !['text', 'json_object'].includes(format)) throw new AiError('ai_invalid_request', 400);
+        const { stream: _stream, stream_options: _streamOptions, ...content } = body;
+        const digest = await hash(content), id = 'dev_' + hex(digest).slice(0, 16);
+        const text = format === 'json_object' ? '{}' : `[dev] ${feature} ${hex(digest).slice(0, 8)}`;
+        const tokens = Math.ceil(encoder.encode(JSON.stringify(body)).length / 4);
+        let answer, usage, events;
+        if (operation === 'embeddings') {
+          const inputs = typeof body.input === 'string' || (Array.isArray(body.input) && body.input.every(x => typeof x === 'number')) ? [body.input] : body.input;
+          const dimensions = body.dimensions ?? 8;
+          if (!Array.isArray(inputs) || !inputs.length || !Number.isInteger(dimensions) || dimensions < 1 || dimensions > 4096) throw new AiError('ai_invalid_request', 400);
+          const vectors = await Promise.all(inputs.map(async (input, index) => {
+            const bytes = await hash(input);
+            const embedding = Array.from({ length: dimensions }, (_, i) => (bytes[i % bytes.length] - 127.5) / 127.5);
+            if (body.encoding_format !== undefined && !['float', 'base64'].includes(body.encoding_format)) throw new AiError('ai_invalid_request', 400);
+            if (body.encoding_format === 'base64') {
+              const binary = new Uint8Array(dimensions * 4), view = new DataView(binary.buffer);
+              embedding.forEach((value, i) => view.setFloat32(i * 4, value, true));
+              return { object: 'embedding', index, embedding: btoa(String.fromCharCode(...binary)) };
+            }
+            return { object: 'embedding', index, embedding };
+          }));
+          usage = { prompt_tokens: tokens, total_tokens: tokens };
+          answer = { object: 'list', model: body.model, data: vectors, usage };
+        } else if (operation === 'chat') {
+          usage = { prompt_tokens: tokens, completion_tokens: Math.ceil(text.length / 4), total_tokens: tokens + Math.ceil(text.length / 4) };
+          answer = { id, object: 'chat.completion', model: body.model, choices: [{ index: 0, message: { role: 'assistant', content: text }, finish_reason: 'stop' }], usage };
+          const split = Math.ceil(text.length / 2);
+          events = [text.slice(0, split), text.slice(split)].map(content => data({ id, object: 'chat.completion.chunk', model: body.model, choices: [{ index: 0, delta: { content }, finish_reason: null }] }));
+          events.push(data({ id, object: 'chat.completion.chunk', model: body.model, choices: [{ index: 0, delta: {}, finish_reason: 'stop' }], usage }), 'data: [DONE]\n\n');
+        } else if (operation === 'responses') {
+          usage = { input_tokens: tokens, output_tokens: Math.ceil(text.length / 4), total_tokens: tokens + Math.ceil(text.length / 4) };
+          answer = { id, object: 'response', status: 'completed', model: body.model, output: [{ id: id + '_message', type: 'message', role: 'assistant', status: 'completed', content: [{ type: 'output_text', text, annotations: [] }] }], usage };
+          const split = Math.ceil(text.length / 2);
+          events = [event('response.created', { response: { ...answer, status: 'in_progress', output: [], usage: null } }), ...[text.slice(0, split), text.slice(split)].map(delta => event('response.output_text.delta', { item_id: id + '_message', output_index: 0, content_index: 0, delta })), event('response.completed', { response: answer })];
+        } else throw new AiError('ai_invalid_request', 400);
+        await capture({ feature, operation, request: body, response: answer, usage });
+        return body.stream && events ? sse(events, signal) : Response.json(answer, { headers });
+      } catch (error) {
+        const safe = error instanceof AiError ? error : new AiError('ai_unavailable');
+        await capture({ feature, operation, request: body, error: { code: safe.code, status: safe.status } });
+        throw safe;
+      }
+    },
+  };
+}

package/modules/ai/index.d.mts

@@ -0,0 +1,10 @@
+export type AiErrorCode = 'ai_disabled' | 'ai_misconfigured' | 'ai_unavailable' | 'ai_target_mismatch' | 'ai_invalid_request' | 'ai_invalid_response' | 'dev_fake_cannot_answer' | 'dev_access_denied' | 'dev_outbox_unavailable' | 'no_eligible_target' | 'field_not_allowed' | 'budget_exhausted' | 'upstream_limited' | 'upstream_unavailable' | 'upstream_auth' | 'upstream_policy_unmet' | 'upstream_uncertain' | 'upstream_error' | 'response_too_large';
+export class AiError extends Error { readonly code: AiErrorCode; readonly status: number; constructor(code: AiErrorCode, status?: number); }
+export interface AiConfig { enabled?: boolean; model?: string; direct?: { baseUrl?: string; apiKey?: string }; models?: { baseUrl?: string; apiKey?: string }; features?: Record<string, 'direct' | 'models'>; }
+export interface AiOptions { feature?: string; signal?: AbortSignal; subject?: string; }
+export interface AiRequest { model?: string; stream?: boolean; [field: string]: unknown; }
+export interface AiClient { chat(body: AiRequest, options?: AiOptions): Promise<Response>; responses(body: AiRequest, options?: AiOptions): Promise<Response>; embeddings(body: AiRequest, options?: AiOptions): Promise<Response>; receipt(id: string, options?: AiOptions): Promise<Response>; }
+export interface AiTransport { request(input: { operation: 'chat' | 'responses' | 'embeddings' | 'receipt'; body?: AiRequest; feature: string; signal?: AbortSignal; selected: { name: string; baseUrl: string; apiKey: string } }): Promise<Response>; }
+export function createAiClient(config?: AiConfig, dependencies?: { fetch?: typeof fetch; transport?: AiTransport }): AiClient;
+export function aiConfig(env?: Record<string, unknown>, features?: AiConfig['features']): AiConfig;
+export function aiDiagnostics(config?: AiConfig): Array<{ feature: string; code: AiErrorCode; message: string }>;

package/modules/ai/index.mjs

@@ -0,0 +1,3 @@
+export { createAiClient } from './client.mjs';
+export { aiConfig, aiDiagnostics } from './config.mjs';
+export { AiError } from './errors.mjs';

package/modules/ai/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@runeditrun/base-ai",
+  "private": true,
+  "type": "module",
+  "exports": { ".": "./index.mjs", "./dev": "./dev/index.mjs", "./fake": "./fake/index.mjs" }
+}

package/modules/container/README.md

@@ -0,0 +1,156 @@
+# Portable container hosting
+
+An image contains the seed's real Vite server/client build, migrations and the
+shared host. Workers remains the default. Opt in with `platforms` in `deploy.json`:
+
+```json
+{"platforms":["workers","container"],"container":{"engine":"node"}}
+```
+
+Choose the engine for the adopting seed's runtime requirements and qualify it
+at the intended memory limit. A retained-public-snapshot cache contract is
+selected through `cacheContract` when the seed implements that contract. This
+is not a general Durable Object adapter. A seed requiring KV or other
+Cloudflare-only APIs cannot use Node.
+The import boundary rejects those APIs and new Cloudflare imports outside the
+platform binding/cache boundary.
+
+The entrypoint holds a Linux kernel `flock` for the lifetime of the host. Each
+installation has one local data volume and one writer. The lock inode retains
+PID/heartbeat diagnostics and is never unlinked. The host applies hashed
+migrations using a separately committed claim, followed by atomic SQL plus
+completion. Changed or uncertain history stops startup. Cron uses Base's five
+numeric-field grammar and dispatches matching handlers at minute boundaries.
+Node queues retain pending/claimed/dead messages across restarts; expired claims
+are delivered again. Consumers must already be idempotent. Dead jobs make health
+unhealthy. `/health` reports the container platform and the image ID supplied by
+the launcher. No image ID is invented when an operator starts an image manually.
+
+`rer build --platform container` builds the image. `rer dev` and `rer preview`
+with that flag use it with local settings and a persistent Docker volume named for the checkout.
+SQLite stays on the Docker host's local filesystem; host-shared checkout mounts
+are not used for database storage. Back up with export before deleting a volume. Build
+uses the ordinary private-file custody and command admission boundary. Secrets
+are provided at runtime, never baked into the image or transferred in archives.
+
+`rer deploy --platform container --host ssh://user@host --env-file FILE` uses
+strict SSH host-key checking and a Linux host with Python 3 and Docker. FILE must
+be owned and private (0600); local-only keys are rejected. Settings travel as a
+raw Docker env file so dollar signs and other secret bytes are not interpolated. Caddy terminates production TLS; only its
+peer can supply forwarded origin/address facts. Inbound Cloudflare and forwarded
+headers from other peers are discarded. `RER_SSH_IDENTITY` and
+`RER_SSH_KNOWN_HOSTS` select explicit SSH files; neither key contents nor settings
+are logged. Local loopback origins support a disposable SSH Docker host for
+qualification. Owner hosting/account setup remains an owner step.
+
+A seed can package its own scoped Node runner with a declaration such as:
+
+```json
+{"engine":"workerd","runner":{"entry":"runners/src/private-runner.mjs","files":["runners/src","src/domain","src/base","scripts/runner-config.mjs"]}}
+```
+
+The entrypoint, supporting files and `scripts/runner-config.mjs` belong to the
+adopting seed; replace these example paths with its actual runner dependencies.
+Provide the configuration names that runner reads (for example,
+`APP_CONTROL_ORIGIN` and `APP_RUNNER_KEY` if the adopter defines them). The host
+supervises the process; an unexpected runner exit stops the host so Compose can
+restart the complete unit. The runner owns its transport's public-address
+validation and TLS behavior.
+
+Local container export/import uses the same Base archive service and exclusion
+policy as Workers. Stop the serving process first: one-shot transfers acquire
+the same volume lock. `rer archive diff BEFORE AFTER` verifies both entire
+archives, then reports added/removed/changed row keys, objects and payloads.
+It never merges writes and does not print row values.
+
+## Qualification
+
+`tests/conformance.mjs SEED SOURCE RESULTS` runs the same native public journey
+against local Workers and the selected container image. It uses real migrations,
+D1, object storage, queues and handlers. Test-only helpers are mounted separately;
+the only fakes are paid mail/network edges. It checks ingress, health, assets,
+SIGKILL recovery, exclusive volume custody, same-volume upgrades and public-only
+egress. Run with the host's Docker socket and an admitted machine budget.
+
+`tests/differential.mjs` compares real local Workers D1 with Node SQLite. Run it
+on Node 26.8.1 (the image runtime), with Base's pinned Miniflare dependency.
+`node --test modules/container/tests/command.test.mjs` covers the public archive
+command. Product source paths are explicit inputs; this suite never downloads
+private products, opens provider accounts or performs a provider deployment.
+
+### SSH installation custody and ingress bindings
+
+The remote Linux account requires Python 3, Docker, and permission to use its
+Docker daemon. HTTPS deployment acquires `caddy:2.10.2` from its standard registry
+if absent, then pins its resolved image ID before shutting down anything. Preload
+that image on isolated hosts. `--image IMAGE` deploys an
+already built local image; the CLI resolves it once and transfers/runs that exact
+image ID, so moving a shared tag cannot substitute another image.
+
+The installation key hashes the full project and environment as a structured
+pair. Every app, Caddy container, data/config volume and ingress network carries
+that identity plus the complete project/environment and resource role labels.
+Missing, mismatched or unexpected resources are refused before replacement;
+legacy last-segment namespaces are never taken over. Same-identity redeployment
+preserves its volumes. There is no remote `deploy --stop` command. Internal
+replacement verifies labels and stops/removes only the inspected container IDs;
+it never executes stored Compose files or deletes volumes.
+
+Remote settings live below the account's `.rer-host/INSTALLATION/` in private,
+immutable generations. The account home must be owned by the login UID. System
+ancestors may be owned by that UID or root, and must not be writable by group or
+others; links are refused throughout. Installation directories/files must be
+owned by the UID with no group/other permissions. Files must be regular with one
+hard link. Pre-existing unmarked directories, unsafe paths and unexpected files
+are refused without chmod, truncation or adoption. Exclusive dirfd-relative
+writes create a complete generation; one atomic manifest replacement commits it
+before shutdown. Interrupted staging leaves the previous generation intact.
+A private account lock serializes deployments. Before shutdown the CLI checks
+that every ancestor still names the original owned directory and that the
+generation still contains its exclusively written files and exact content.
+This catches path substitution by the login UID as well as unsafe permissions.
+Failure cleanup and removal of previous generations also require the retained
+directory and file identities; replacement paths and unexpected files are left
+untouched. Previous-generation identities are captured before Docker work and
+checked again before shutdown. The current manifest is retained the same way
+(identity and exact bytes); the commit replaces only that retained manifest, then
+checks that the committed manifest is its own exclusively written file before
+any shutdown. A transplanted manifest is refused and left untouched.
+Verified settings go to the Docker client on stdin; verified Caddy configuration
+goes through the daemon's archive API into the stopped replacement container.
+Neither client nor daemon reopens a host configuration pathname after shutdown.
+
+Multiple HTTPS installations can use distinct bindings in `deploy.json`:
+
+```json
+{"container":{"engine":"node","ingress":{"address":"127.0.0.1","httpPort":18080,"httpsPort":18443}}}
+```
+
+The matching CLI overrides are `--bind-address 127.0.0.1 --http-port 18080
+--https-port 18443`. The defaults are `0.0.0.0:80` and `0.0.0.0:443`; duplicate
+ports are rejected. These bindings apply to production Caddy ingress. Loopback
+HTTP qualification binds the app to the origin's loopback port. Occupied bindings
+are refused before stopping the currently installed service.
+
+Place a shared TCP/SNI proxy in front of distinct Caddy TLS ports. Route each
+hostname's TLS (including TLS-ALPN certificate challenges) and HTTP challenge
+traffic to its installation. Caddy still terminates TLS and remains the app's
+only trusted forwarding peer on a separate labeled network. Preserve Host/SNI
+when routing. A public non-default port belongs in the origin setting; bindings
+alone do not change the public origin. Certificate issuance needs a reachable
+public challenge path; private tests should supply a local certificate authority
+at that network edge. Changing to a proxy that terminates TLS itself requires a
+separate reviewed trust/certificate configuration.
+
+Run the real SSH safety suite with an isolated local Docker/SSH host and a built
+reference image:
+
+```sh
+RER_SSH_TEST_HOST=ssh://root@127.0.0.1:60420 \
+RER_SSH_TEST_IMAGE=host1-fix-probe-app:latest \
+node --test --test-concurrency=1 modules/container/tests/ssh.test.mjs modules/container/tests/ssh-tls.test.mjs
+```
+
+Set `DOCKER_HOST`, `RER_SSH_IDENTITY` and `RER_SSH_KNOWN_HOSTS` for that fixture.
+The suite uses public source and packaged CLI commands and removes only its own
+labeled test resources. It never supplies real provider credentials.

package/modules/container/adapters/d1.mjs

@@ -0,0 +1,34 @@
+import { Worker } from 'node:worker_threads';
+const value=input=>{
+ if(typeof input==='boolean')return Number(input);
+ if(input===null||typeof input==='string'||typeof input==='number'||input instanceof ArrayBuffer||ArrayBuffer.isView(input))return input instanceof ArrayBuffer?new Uint8Array(input):input;
+ if(Array.isArray(input)&&input.every(x=>Number.isInteger(x)&&x>=0&&x<=255))return new Uint8Array(input);
+ throw new Error(`D1_TYPE_ERROR: Type '${typeof input}' not supported for value '${input}'`);
+};
+export class D1 {
+ constructor(path){this.path=path;this.pending=new Map();this.next=0;this.start();}
+ start(){
+  this.worker=new Worker(new URL('./sqlite-worker.mjs',import.meta.url),{workerData:{path:this.path}});
+  this.worker.on('message',message=>{
+   const pending=this.pending.get(message.id);if(!pending)return;
+   if(message.started){pending.timer=setTimeout(()=>{void this.worker.terminate();this.fail(new Error('D1_ERROR: query timed out: SQLITE_INTERRUPT'));},30000);return;}
+   clearTimeout(pending.timer);this.pending.delete(message.id);message.error?pending.reject(new Error(message.error)):pending.resolve(message.result);
+  });
+  this.worker.on('error',cause=>this.fail(cause));this.worker.on('exit',code=>{this.worker=null;if(this.pending.size)this.fail(new Error('D1_ERROR: database worker stopped'));});
+ }
+ fail(cause){for(const pending of this.pending.values()){clearTimeout(pending.timer);pending.reject(cause);}this.pending.clear();}
+ call(operation,statements,sql){if(!this.worker)this.start();const id=++this.next;return new Promise((resolve,reject)=>{this.pending.set(id,{resolve,reject});this.worker.postMessage({id,operation,statements,sql});});}
+ prepare(sql){return new Statement(this,sql);}
+ async batch(statements){if(statements.some(item=>item.db!==this))throw new Error('Foreign statement');const results=await this.call('batch',statements.map(({sql,args})=>({sql,args})));return results.map(({columns,rawResults,...result})=>result);}
+ exec(sql){return this.call('exec',undefined,sql);}
+ async close(){this.fail(new Error('D1 database closed'));await this.worker?.terminate();this.worker=null;}
+}
+class Statement {
+ constructor(db,sql,args=[]){this.db=db;this.sql=sql;this.args=args;}
+ bind(...args){return new Statement(this.db,this.sql,args.map(value));}
+ execute(){return this.db.call('statement',[{sql:this.sql,args:this.args}]);}
+ async all(){const {columns,rawResults,...result}=await this.execute();return result;}
+ run(){return this.all();}
+ async first(column){const first=(await this.execute()).results[0];if(!first)return null;if(column!==undefined){if(!Object.hasOwn(first,column))throw new Error(`D1_COLUMN_NOTFOUND: Column not found (${column})`);return first[column];}return first;}
+ async raw({columnNames=false}={}){const {rawResults,columns}=await this.execute();return columnNames?[columns,...rawResults]:rawResults;}
+}

package/modules/container/adapters/egress.mjs

@@ -0,0 +1,40 @@
+import { lookup } from 'node:dns/promises';
+import { isIP } from 'node:net';
+import { request as https } from 'node:https';
+import { request as http } from 'node:http';
+import { Readable } from 'node:stream';
+import { isPublicAddress } from '../../integrations/core/public-address.ts';
+export async function publicFetch(input, init, redirects = 0) {
+ const request = new Request(input, init), url = new URL(request.url), host = url.hostname.replace(/^\[|\]$/g, '');
+ if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || host === 'localhost' || /\.(?:localhost|local|internal)$/.test(host)) throw new Error('Egress destination refused');
+ const addresses = isIP(host) ? [{ address: host, family: isIP(host) }] : await lookup(host, { all: true, verbatim: true });
+ if (!addresses.length || addresses.some(item => !isPublicAddress(item.address))) throw new Error('Egress destination is not public');
+ const pinned = addresses[0], headers = Object.fromEntries(request.headers);
+ for (const name of ['host', 'connection', 'proxy-authorization', 'transfer-encoding', 'content-length']) delete headers[name];
+ const body = ['GET', 'HEAD'].includes(request.method) ? undefined : Buffer.from(await request.arrayBuffer());
+ if (body) headers['content-length'] = String(body.length);
+ const response = await new Promise((resolve, reject) => {
+  const outgoing = (url.protocol === 'https:' ? https : http)(url, { method: request.method, headers, agent: false, rejectUnauthorized: true,
+   lookup: (_host, options, done) => options.all ? done(null, [pinned]) : done(null, pinned.address, pinned.family),
+  }, incoming => {
+   const responseHeaders = new Headers();
+   for (let i = 0; i < incoming.rawHeaders.length; i += 2) responseHeaders.append(incoming.rawHeaders[i], incoming.rawHeaders[i + 1]);
+   incoming.once('end', () => request.signal.removeEventListener('abort', abort));
+   incoming.once('close', () => request.signal.removeEventListener('abort', abort));
+   resolve(new Response(request.method === 'HEAD' || [204, 304].includes(incoming.statusCode) ? null : Readable.toWeb(incoming), { status: incoming.statusCode, headers: responseHeaders }));
+  });
+  const abort = () => outgoing.destroy(new Error('Egress aborted')); request.signal.addEventListener('abort', abort, { once: true });
+  if (request.signal.aborted) abort();
+  outgoing.setTimeout(30000, () => outgoing.destroy(new Error('Egress timeout'))); outgoing.once('error', reject); outgoing.end(body);
+ });
+ if ([301, 302, 303, 307, 308].includes(response.status) && response.headers.has('location')) {
+  if (request.redirect === 'manual') return response;
+  await response.body?.cancel();
+  if (request.redirect === 'error' || redirects >= 10) throw new Error('Egress redirect refused');
+  const destination = new URL(response.headers.get('location'), url), nextHeaders = new Headers(request.headers);
+  if (destination.origin !== url.origin) for (const name of ['authorization', 'cookie']) nextHeaders.delete(name);
+  const get = response.status === 303 || ([301, 302].includes(response.status) && request.method === 'POST');
+  return publicFetch(destination, { method: get ? 'GET' : request.method, headers: nextHeaders, signal: request.signal, redirect: request.redirect, ...(!get && body ? { body } : {}) }, redirects + 1);
+ }
+ return response;
+}

package/modules/container/adapters/jobs.mjs

@@ -0,0 +1,47 @@
+import { randomUUID } from 'node:crypto';
+function jsonBody(body,seen=new Set()){
+ if(body===null||typeof body==='string'||typeof body==='boolean'||(typeof body==='number'&&Number.isFinite(body)))return;
+ if(typeof body!=='object'||seen.has(body)||(!Array.isArray(body)&&![Object.prototype,null].includes(Object.getPrototypeOf(body))))throw new Error('Queue body must be JSON');
+ seen.add(body);for(const value of Object.values(body))jsonBody(value,seen);seen.delete(body);
+}
+export class Jobs {
+ constructor(sqlite, queue, { maxRetries = 3, batchSize = 10, visibilitySeconds = 60 } = {}) {
+  this.sqlite = sqlite; this.queue = queue; this.maxRetries = maxRetries; this.batchSize = batchSize; this.visibilitySeconds = visibilitySeconds;
+  sqlite.exec("CREATE TABLE IF NOT EXISTS platform_jobs (id TEXT PRIMARY KEY, queue TEXT NOT NULL, body TEXT NOT NULL, state TEXT NOT NULL CHECK(state IN ('pending','claimed','dead')), attempts INTEGER NOT NULL DEFAULT 0, available_at INTEGER NOT NULL, claimed_until INTEGER, token TEXT)");
+ }
+ record(body,{delaySeconds=0,contentType='json'}={}){
+  jsonBody(body);if(contentType!=='json'||!Number.isInteger(delaySeconds)||delaySeconds<0)throw new Error('Unsupported queue options');return[randomUUID(),this.queue,JSON.stringify(body),Date.now()+delaySeconds*1000];
+ }
+ insert(record){this.sqlite.prepare("INSERT INTO platform_jobs(id,queue,body,state,available_at) VALUES(?,?,?,'pending',?)").run(...record);}
+ async send(body,options){this.insert(this.record(body,options));}
+ async sendBatch(messages) {const records=messages.map(message=>this.record(message.body,message));this.sqlite.exec('BEGIN');try{records.forEach(record=>this.insert(record));this.sqlite.exec('COMMIT');}catch(cause){this.sqlite.exec('ROLLBACK');throw cause;}}
+ async drain(consumer, bindings, execution) {
+  if (this.running) return; this.running = true;
+  try {
+   const now = Date.now(); this.sqlite.prepare("UPDATE platform_jobs SET state='pending',token=NULL WHERE queue=? AND state='claimed' AND claimed_until<=?").run(this.queue, now);
+   const rows = this.sqlite.prepare("SELECT * FROM platform_jobs WHERE queue=? AND state='pending' AND available_at<=? ORDER BY available_at LIMIT ?").all(this.queue, now, this.batchSize);
+   const messages = [];
+   for (const row of rows) {
+    const token = randomUUID(); const claim = this.sqlite.prepare("UPDATE platform_jobs SET state='claimed',token=?,attempts=attempts+1,claimed_until=? WHERE id=? AND state='pending'").run(token, now + this.visibilitySeconds * 1000, row.id);
+    if (!claim.changes) continue;
+    let disposition;
+    const message = { id: row.id, timestamp: new Date(row.available_at), body: JSON.parse(row.body), attempts: row.attempts + 1, ack() { disposition = 'ack'; }, retry(options = {}) { disposition = options; } };
+    messages.push({ row, token, message, disposition: () => disposition });
+   }
+   if (!messages.length) return;
+   let failed = false;
+   try { await consumer({ queue: this.queue, messages: messages.map(x => x.message), ackAll() { messages.forEach(x => x.message.ack()); }, retryAll(options) { messages.forEach(x => x.message.retry(options)); } }, bindings, execution); }
+   catch { failed = true; }
+   for (const item of messages) {
+    const disposition = item.disposition();
+    if (disposition === 'ack' || (!failed && disposition === undefined)) this.sqlite.prepare('DELETE FROM platform_jobs WHERE id=? AND token=?').run(item.row.id, item.token);
+    else {
+     const dead = item.message.attempts > this.maxRetries;
+     const delay = disposition?.delaySeconds ?? Math.min(3600, 2 ** item.message.attempts);
+     this.sqlite.prepare('UPDATE platform_jobs SET state=?,available_at=?,claimed_until=NULL,token=NULL WHERE id=? AND token=?').run(dead ? 'dead' : 'pending', Date.now() + delay * 1000, item.row.id, item.token);
+    }
+   }
+  } finally { this.running = false; }
+ }
+ dead() { return this.sqlite.prepare("SELECT count(*) AS n FROM platform_jobs WHERE queue=? AND state='dead'").get(this.queue).n; }
+}

package/modules/container/adapters/objects.mjs

@@ -0,0 +1,84 @@
+import { mkdir, readFile, open, rename, readdir, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+const hash = bytes => createHash('sha256').update(bytes).digest('hex');
+const bytes = async body => body === null ? Buffer.alloc(0) : typeof body === 'string' ? Buffer.from(body) : body instanceof Blob ? Buffer.from(await body.arrayBuffer()) : body?.getReader ? Buffer.from(await new Response(body).arrayBuffer()) : Buffer.from(body);
+export class Objects {
+ constructor(sqlite, directory, bucket) {
+  this.sqlite = sqlite; this.directory = directory; this.bucket = bucket;
+  sqlite.exec('CREATE TABLE IF NOT EXISTS platform_objects(bucket TEXT NOT NULL,key TEXT NOT NULL,file TEXT NOT NULL,size INTEGER NOT NULL,etag TEXT NOT NULL,uploaded TEXT NOT NULL,metadata TEXT NOT NULL,PRIMARY KEY(bucket,key)); CREATE TABLE IF NOT EXISTS platform_multipart(id TEXT PRIMARY KEY,bucket TEXT NOT NULL,key TEXT NOT NULL,metadata TEXT NOT NULL); CREATE TABLE IF NOT EXISTS platform_parts(id TEXT NOT NULL,part INTEGER NOT NULL,file TEXT NOT NULL,etag TEXT NOT NULL,PRIMARY KEY(id,part))');
+ }
+ async recover() {
+  await mkdir(this.directory, { recursive: true });
+  const live = new Set([...this.sqlite.prepare('SELECT file FROM platform_objects').all(), ...this.sqlite.prepare('SELECT file FROM platform_parts').all()].map(row => row.file));
+  for (const file of await readdir(this.directory)) if (!live.has(file)) await unlink(join(this.directory, file));
+ }
+ async writeImmutable(data) {
+  await mkdir(this.directory,{recursive:true});const file=hash(data),temporary=join(this.directory,randomUUID()+'.partial');
+  const handle=await open(temporary,'wx',0o600);
+  try{await handle.writeFile(data);await handle.sync();}finally{await handle.close();}
+  await rename(temporary,join(this.directory,file));const directory=await open(this.directory,'r');try{await directory.sync();}finally{await directory.close();}
+  return file;
+ }
+ record(key) { return this.sqlite.prepare('SELECT * FROM platform_objects WHERE bucket=? AND key=?').get(this.bucket, key); }
+ view(row, data) {
+  const metadata = JSON.parse(row.metadata);if(metadata.httpMetadata?.cacheExpiry)metadata.httpMetadata.cacheExpiry=new Date(metadata.httpMetadata.cacheExpiry);
+  const object = { key: row.key, version: row.file, size: row.size, etag: row.etag, httpEtag: `"${row.etag}"`, uploaded: new Date(row.uploaded), httpMetadata: metadata.httpMetadata ?? {}, customMetadata: metadata.customMetadata ?? {}, checksums: { sha256: Buffer.from(row.file, 'hex').buffer }, storageClass: 'Standard', writeHttpMetadata(headers) { for (const [key, value] of Object.entries(this.httpMetadata)) { const name = { contentType: 'content-type', contentLanguage: 'content-language', contentDisposition: 'content-disposition', contentEncoding: 'content-encoding', cacheControl: 'cache-control', cacheExpiry: 'expires' }[key]; if (name) headers.set(name, value instanceof Date ? value.toUTCString() : value); } } };
+  object.checksums.sha256=Uint8Array.from(Buffer.from(row.file,'hex')).buffer;
+  if (data !== undefined) {const response=new Response(data);Object.assign(object,{body:response.body,arrayBuffer:()=>response.arrayBuffer(),text:()=>response.text(),json:()=>response.json(),blob:()=>response.blob()});Object.defineProperty(object,'bodyUsed',{enumerable:true,get:()=>response.bodyUsed});}
+  return object;
+ }
+ matches(row, condition) {
+  if (!condition) return true;
+  if (condition instanceof Headers) condition = { etagMatches: condition.get('if-match') ?? undefined, etagDoesNotMatch: condition.get('if-none-match') ?? undefined };
+  const equals = value => value === '*' ? Boolean(row) : Boolean(row && value.replaceAll('"', '') === row.etag);
+  return (condition.etagMatches === undefined || equals(condition.etagMatches)) && (condition.etagDoesNotMatch === undefined || !equals(condition.etagDoesNotMatch)) && (!condition.uploadedBefore || !row || new Date(row.uploaded) < condition.uploadedBefore) && (!condition.uploadedAfter || row && new Date(row.uploaded) > condition.uploadedAfter);
+ }
+ async head(key) { const row = this.record(key); return row ? this.view(row) : null; }
+ async get(key, options = {}) {
+  const row = this.record(key); if (!row) return null;
+  if (!this.matches(row, options.onlyIf)) return this.view(row);
+  let data = await readFile(join(this.directory, row.file)); let range;
+  if(options.range instanceof Headers){const value=options.range.get('range');const match=/^bytes=(\d*)-(\d*)$/.exec(value??'');if(match)options={...options,range:match[1]?{offset:Number(match[1]),...(match[2]?{length:Number(match[2])-Number(match[1])+1}:{})}:{suffix:Number(match[2])}};else options={...options,range:undefined};}
+  if (options.range) {
+   const offset = options.range.suffix ? Math.max(0, data.length - options.range.suffix) : options.range.offset ?? 0;
+   const length = options.range.length ?? data.length - offset; data = data.subarray(offset, offset + length); range = { offset, length: data.length };
+  }
+  return Object.assign(this.view(row,data),range?{range}:{});
+ }
+ async put(key, body, options = {}) {
+  const data = await bytes(body), file = await this.writeImmutable(data);
+  // Immutable files precede the committed pointer. A crash never leaves a pointer to unfinished bytes.
+  this.sqlite.exec('BEGIN IMMEDIATE');
+  try {
+   const old = this.record(key); if (!this.matches(old, options.onlyIf)) { this.sqlite.exec('ROLLBACK'); return null; }
+   const metadata = JSON.stringify({ httpMetadata: options.httpMetadata ?? {}, customMetadata: options.customMetadata ?? {} }), etag = createHash('md5').update(data).digest('hex');
+   this.sqlite.prepare('INSERT OR REPLACE INTO platform_objects VALUES(?,?,?,?,?,?,?)').run(this.bucket, key, file, data.length, etag, new Date().toISOString(), metadata);
+   this.sqlite.exec('COMMIT'); return this.head(key);
+  } catch (cause) { this.sqlite.exec('ROLLBACK'); throw cause; }
+ }
+ async delete(keys) { for (const key of Array.isArray(keys) ? keys : [keys]) this.sqlite.prepare('DELETE FROM platform_objects WHERE bucket=? AND key=?').run(this.bucket, key); }
+ async list({ prefix = '', cursor, limit = 1000, delimiter, startAfter = '' } = {}) {
+  const after = cursor ? Buffer.from(cursor, 'base64url').toString() : startAfter;
+  const rows = this.sqlite.prepare('SELECT * FROM platform_objects WHERE bucket=? AND key>? ORDER BY key').all(this.bucket, after).filter(row => row.key.startsWith(prefix));
+  const objects = [], delimitedPrefixes = new Set(); let last, consumed = 0;
+  for (const row of rows) {
+   const tail = row.key.slice(prefix.length), separator = delimiter ? tail.indexOf(delimiter) : -1;
+   const group=separator>=0?prefix+tail.slice(0,separator+delimiter.length):null;
+   if (objects.length + delimitedPrefixes.size >= limit && !delimitedPrefixes.has(group)) break;
+   last = row.key; consumed++;
+   if (group) delimitedPrefixes.add(group); else objects.push(this.view(row));
+  }
+  const truncated = consumed < rows.length;
+  return { objects, delimitedPrefixes: [...delimitedPrefixes], truncated, ...(truncated ? { cursor: Buffer.from(last).toString('base64url') } : {}) };
+ }
+ async createMultipartUpload(key, options = {}) { const uploadId = randomUUID(); this.sqlite.prepare('INSERT INTO platform_multipart VALUES(?,?,?,?)').run(uploadId, this.bucket, key, JSON.stringify(options)); return this.resumeMultipartUpload(key, uploadId); }
+ resumeMultipartUpload(key, uploadId) {
+  const check = () => { const row = this.sqlite.prepare('SELECT * FROM platform_multipart WHERE id=? AND bucket=? AND key=?').get(uploadId, this.bucket, key); if (!row) throw new Error('Multipart upload missing'); return row; };
+  return { key, uploadId,
+   uploadPart: async (partNumber, body) => { check(); if (!Number.isInteger(partNumber) || partNumber < 1 || partNumber > 10000) throw new Error('Invalid multipart part'); const data = await bytes(body), file = await this.writeImmutable(data), etag = hash(data); this.sqlite.prepare('INSERT OR REPLACE INTO platform_parts VALUES(?,?,?,?)').run(uploadId, partNumber, file, etag); return { partNumber, etag }; },
+   abort: async () => { check(); this.sqlite.prepare('DELETE FROM platform_parts WHERE id=?').run(uploadId); this.sqlite.prepare('DELETE FROM platform_multipart WHERE id=?').run(uploadId); },
+   complete: async parts => { const upload = check(); const data = []; let previous = 0; for (const part of parts) { if (part.partNumber <= previous) throw new Error('Multipart order'); previous = part.partNumber; const row = this.sqlite.prepare('SELECT * FROM platform_parts WHERE id=? AND part=? AND etag=?').get(uploadId, part.partNumber, part.etag); if (!row) throw new Error('Multipart part missing'); data.push(await readFile(join(this.directory, row.file))); } const result = await this.put(key, Buffer.concat(data), JSON.parse(upload.metadata)); this.sqlite.prepare('DELETE FROM platform_parts WHERE id=?').run(uploadId); this.sqlite.prepare('DELETE FROM platform_multipart WHERE id=?').run(uploadId); return result; },
+  };
+ }
+}