reploid 0.0.0-stage → 0.1.0

package/server/fleet/service.js

@@ -0,0 +1,311 @@
+import http from 'node:http';
+import https from 'node:https';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { randomUUID } from 'node:crypto';
+import { signAsParticipant, verifyParticipantSignature } from '../../packages/reploid/src/artifacts/participant-proofs.js';
+import { assert, same, text } from './contract.js';
+import { planFleetPlacement } from './placement.js';
+import { createNativeEarningStorage } from '../native-earning.js';
+import { openFleetCredits } from './credits.js';
+import { canonicalRouteAttemptBinding } from '../../packages/reploid/src/mesh/partitions/partition-contract.js';
+
+const DOMAIN = 'reploid.fleet-service-request/v1';
+
+/** Private to enrolled signers, using TLS outside loopback. */
+export async function startFleetService({ credits, models, placementPolicy, port = 0, listenHost = '127.0.0.1', tls = null,
+  now = Date.now, maxBodyBytes = 1048576 }) {
+  assert(['127.0.0.1', '::1', 'localhost'].includes(listenHost) || tls?.key && tls?.cert,
+    'Non-loopback fleet service requires TLS');
+  const observations = new Map(), demand = new Map(), links = new Map();
+  const invoke = async (signer, operation, payload) => {
+    const owner = credits.enrollment.byPeer.get(signer);
+    assert(owner, 'Unenrolled computer');
+    switch (operation) {
+      case 'reserve': {
+        assert(payload.consumer === signer, 'Cannot reserve another computer’s credit');
+        const model = models.find(model => model.id === payload.model.id && model.identity === payload.model.identity);
+        assert(model, 'Model is not enabled for this service');
+        if (payload.mode === 'whole-model') assert(payload.providers.length === 1 && payload.providers[0].weight === 1, 'Invalid whole-model credit share');
+        else {
+          const plan = model.plans?.find(plan => plan.id === payload.route?.route?.planId);
+          assert(plan && same(plan.creditWeights, payload.providers.map(row => row.weight)), 'Stage shares differ from the operator’s terms');
+        }
+        return credits.reserve(payload);
+      }
+      case 'dispatch':
+        return credits.dispatch(payload.id, signer);
+      case 'admit': {
+        const observation = observations.get(owner.computerId);
+        if (observation) assert(observation.preferences.enabled === true
+          && observation.preferences.models.some(model => model.id === payload.model?.id && model.identity === payload.model?.identity),
+        'Provider owner no longer allows this model');
+        const row = credits.request(payload.id), request = row?.binding;
+        assert(row?.state === 'dispatched' && now() <= request.deadline && request.consumer === payload.consumer
+          && request.executionId === payload.executionId && request.mode === payload.mode
+          && request.providers.some(provider => provider.participantId === signer)
+          && same(request.model, payload.model) && Number.isSafeInteger(payload.outputLimit)
+          && payload.outputLimit > 0 && payload.outputLimit <= request.maxOutputTokens, 'No matching live credit admission');
+        if (request.mode === 'whole-model') assert(request.inputDigest === payload.inputDigest, 'Input differs from credit admission');
+        else assert(same(request.route, canonicalRouteAttemptBinding(payload.route))
+          && request.providers[payload.partitionIndex]?.participantId === signer, 'Stage differs from credit admission');
+        credits.admit(payload.id, request.mode === 'whole-model' ? 0 : payload.partitionIndex);
+        return { admitted: true, deadline: request.deadline, maximum: request.maximum };
+      }
+      case 'abandonBeforeDispatch':
+        return credits.abandonBeforeDispatch(payload.id, signer) ?? { abandoned: true };
+      case 'collect':
+      case 'fence':
+      case 'recover':
+      case 'settle': {
+        const request = credits.request(payload.id)?.binding;
+        assert(request && (request.consumer === signer || request.providers.some(row => row.participantId === signer)), 'Not a participant in this request');
+        if (operation === 'collect') return credits.collect(payload.id, payload.evidence);
+        if (operation === 'fence') return credits.fence(payload.id, signer);
+        if (operation === 'recover') return credits.recover(payload.id);
+        return credits.settle(payload.id, payload.evidence);
+      }
+      case 'recoverMine': return credits.recoverFor(signer);
+      case 'providerOpenMine': return credits.providerOpenRequests(signer);
+      case 'reconcileMine': return credits.reconcileConsumer(signer, payload?.activeIds ?? []);
+      case 'snapshot': return credits.snapshot();
+      case 'computers': return { at: now(), computers: [...credits.enrollment.byId.values()].map(computer => {
+        const observation = observations.get(computer.id);
+        const online = !!observation && now() - observation.observedAt <= placementPolicy.maxObservationAgeMs;
+        return { id: computer.id, name: computer.name, participantIds: computer.providers.map(provider => provider.participantId),
+          online, observedAt: observation?.observedAt ?? null,
+          ...(online ? { activeRequests: observation.activeRequests, preparing: observation.preparing === true, resident: observation.resident,
+            preferences: observation.preferences, freeGpuBytes: observation.freeGpuBytes, freeHostBytes: observation.freeHostBytes,
+            maxStorageBufferBindingSize: observation.maxStorageBufferBindingSize } : {}) };
+      }) };
+      case 'terms': {
+        const model = models.find(row => row.id === payload.id && row.identity === payload.identity);
+        assert(model, 'Model is not enabled for this service');
+        return { model: structuredClone(model), policy: credits.policy };
+      }
+      case 'request': {
+        const request = credits.request(payload.id);
+        assert(request && (request.binding.consumer === signer || request.binding.providers.some(row => row.participantId === signer)), 'Not a participant in this request');
+        return request;
+      }
+      case 'observe': {
+        assert(payload.id === owner.computerId && payload.participantId === signer, 'Cannot advertise another computer');
+        assert(Number.isSafeInteger(payload.observedAt) && Math.abs(payload.observedAt - now()) <= credits.policy.maxClockSkewMs,
+          'Capacity observation is outside the clock-skew bound');
+        assert(!observations.has(owner.computerId) || payload.observedAt >= observations.get(owner.computerId).reportedAt, 'Older observation cannot replace current capacity');
+        // Receipt time owns expiry; preserve the signed sender time without requiring synchronized clocks.
+        const observation = { ...structuredClone(payload), reportedAt: payload.observedAt, observedAt: now() };
+        planFleetPlacement({ computers: [observation], demand: [], models, links: [], policy: placementPolicy, now: now() });
+        observations.set(owner.computerId, observation);
+        return { accepted: true };
+      }
+      case 'demand':
+        assert(text(payload.id) && Array.isArray(payload.requests) && payload.requests.length <= credits.policy.maxPendingPerComputer, 'Bounded demand required');
+        planFleetPlacement({ computers: [], demand: payload.requests, models, links: [], policy: placementPolicy, now: now() });
+        demand.set(owner.computerId, { at: now(), requests: structuredClone(payload.requests) });
+        return { accepted: true };
+      case 'links':
+        assert(Array.isArray(payload) && payload.length <= credits.enrollment.byId.size && payload.every(row => row.from === owner.computerId), 'Own measured links only');
+        links.set(owner.computerId, structuredClone(payload));
+        return { accepted: true };
+      case 'plan': {
+        const workloads = new Map();
+        for (const item of demand.values()) {
+          if (now() - item.at > placementPolicy.maxObservationAgeMs) continue;
+          for (const row of item.requests) {
+            const id = `${row.id}:${row.identity}`, prior = workloads.get(id);
+            workloads.set(id, prior ? { ...row, queued: prior.queued + row.queued, since: Math.min(row.since, prior.since),
+              promptTokens: Math.max(row.promptTokens, prior.promptTokens), outputTokens: Math.max(row.outputTokens, prior.outputTokens) } : row);
+          }
+        }
+        return planFleetPlacement({ computers: [...observations.values()], demand: [...workloads.values()],
+          models, links: [...links.values()].flat(), policy: placementPolicy, now: now() });
+      }
+      default: throw Error('Unknown fleet operation');
+    }
+  };
+  const handle = async (request, response) => {
+    try {
+      assert(request.method === 'POST' && request.url === '/v1/fleet', 'Unknown fleet endpoint');
+      const chunks = []; let length = 0;
+      for await (const chunk of request) { length += chunk.length; assert(length <= maxBodyBytes, 'Fleet request too large'); chunks.push(chunk); }
+      const envelope = JSON.parse(Buffer.concat(chunks));
+      const { signature, ...body } = envelope;
+      assert(body.schema === DOMAIN && text(body.nonce) && text(body.operation) && Number.isSafeInteger(body.at)
+        && Math.abs(now() - body.at) <= credits.policy.maxClockSkewMs, 'Invalid or stale fleet request');
+      const registered = credits.enrollment.byPeer.get(body.participantId);
+      assert(registered && await verifyParticipantSignature(registered.publicJwk, DOMAIN, body, signature), 'Invalid fleet request signature');
+      // Mutations remain idempotent by reservation/work identity. Observations replace only the sender’s slot.
+      const result = await invoke(body.participantId, body.operation, body.payload);
+      response.writeHead(200, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+      response.end(JSON.stringify({ result }));
+    } catch (error) {
+      response.writeHead(400, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+      response.end(JSON.stringify({ error: error.message }));
+    }
+  };
+  const server = tls ? https.createServer(tls, handle) : http.createServer(handle);
+  await new Promise((resolve, reject) => { server.once('error', reject); server.listen(port, listenHost, resolve); });
+  return { url: `${tls ? 'https' : 'http'}://${listenHost.includes(':') ? '[' + listenHost + ']' : listenHost}:${server.address().port}/v1/fleet`,
+    close: () => new Promise((resolve, reject) => { server.close(error => error ? reject(error) : resolve()); server.closeIdleConnections(); }) };
+}
+
+if (process.argv[1] && pathToFileURL(path.resolve(process.argv[1])).href === import.meta.url) {
+  const configuration = JSON.parse(await fs.readFile(process.argv[2], 'utf8'));
+  assert(configuration.schema === 'reploid.fleet-service/v1', 'Explicit fleet service configuration required');
+  const computers = JSON.parse(await fs.readFile(configuration.enrollmentFile, 'utf8'));
+  const models = JSON.parse(await fs.readFile(configuration.modelsFile, 'utf8'));
+  const credits = await openFleetCredits({ file: configuration.databaseFile, computers, policy: configuration.creditPolicy });
+  let service;
+  try {
+    const tls = configuration.tls ? { key: await fs.readFile(configuration.tls.keyFile), cert: await fs.readFile(configuration.tls.certFile) } : null;
+    service = await startFleetService({ credits, models, placementPolicy: configuration.placementPolicy,
+      listenHost: configuration.listenHost, port: configuration.port, tls });
+    console.log(JSON.stringify({ ready: true, url: service.url }));
+    await new Promise(resolve => { process.once('SIGINT', resolve); process.once('SIGTERM', resolve); });
+  } finally { await service?.close(); credits.close(); }
+}
+
+function createPinnedTlsFetch(ca) {
+  return (url, options = {}) => new Promise((resolve, reject) => {
+    const target = new URL(url);
+    const bodyBuffer = options.body ? Buffer.from(options.body) : null;
+    const req = https.request(target, {
+      method: options.method || 'POST',
+      headers: { ...options.headers, ...(bodyBuffer ? { 'content-length': String(bodyBuffer.length) } : {}) },
+      ca
+    }, res => {
+      const chunks = [];
+      res.on('data', chunk => chunks.push(chunk));
+      res.on('end', () => {
+        const textBody = Buffer.concat(chunks).toString('utf8');
+        resolve({
+          ok: res.statusCode >= 200 && res.statusCode < 300,
+          status: res.statusCode || 500,
+          json: async () => JSON.parse(textBody)
+        });
+      });
+    });
+    const onAbort = () => req.destroy(options.signal?.reason || Error('Fleet TLS request aborted'));
+    options.signal?.addEventListener('abort', onAbort, { once: true });
+    if (options.signal?.aborted) { onAbort(); return; }
+    req.on('error', reject);
+    req.on('close', () => options.signal?.removeEventListener('abort', onAbort));
+    if (bodyBuffer) req.write(bodyBuffer);
+    req.end();
+  });
+}
+
+export function createFleetClient({ url, identity, fetchImpl = null, ca = null, now = Date.now, outboxFile = null }) {
+  const target = new URL(url);
+  assert(target.protocol === 'https:' || target.protocol === 'http:' && ['127.0.0.1', 'localhost', '[::1]'].includes(target.hostname),
+    'Fleet service requires HTTPS or an owned loopback tunnel');
+  const send = fetchImpl || (ca && target.protocol === 'https:' ? createPinnedTlsFetch(ca) : fetch);
+  const call = async (operation, payload) => {
+    payload = wireValue(payload);
+    const body = { schema: DOMAIN, participantId: identity.peerId, operation, payload, at: now(), nonce: randomUUID() };
+    const signature = await signAsParticipant(identity, DOMAIN, body);
+    const response = await send(url, { method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ ...body, signature }), signal: AbortSignal.timeout(30000) });
+    const answer = await response.json();
+    if (!response.ok || answer.error) throw Object.assign(Error(answer.error || 'Fleet request failed'),
+      { code: response.status === 400 ? 'FLEET_REJECTED' : 'FLEET_UNAVAILABLE' });
+    return answer.result;
+  };
+  const storage = outboxFile ? createNativeEarningStorage(outboxFile) : null;
+  let writes = Promise.resolve();
+  const update = operation => {
+    const result = writes.then(async () => {
+      const rows = await storage.get('settlements') || [];
+      await storage.set('settlements', operation(rows));
+    });
+    writes = result.catch(() => {}); return result;
+  };
+  async function settle(id, evidence) {
+    evidence = wireValue(evidence);
+    if (storage) await update(rows => {
+      const prior = rows.find(row => row.id === id);
+      assert(!prior || same(prior.evidence, evidence), 'Conflicting pending settlement');
+      return prior ? rows : [...rows, { id, evidence: structuredClone(evidence) }];
+    });
+    let result;
+    try { result = await call('settle', { id, evidence }); }
+    catch (error) {
+      if (storage && error.code === 'FLEET_REJECTED') {
+        await quarantine({ operation: 'settle', payload: { id, evidence }, error: error.message });
+        await update(rows => rows.filter(row => row.id !== id));
+      }
+      throw error;
+    }
+    if (storage) await update(rows => rows.filter(row => row.id !== id));
+    return result;
+  }
+  const quarantine = async record => {
+    // Invalid proof is retained for diagnosis, never retried as if a transient network failure.
+    const key = `rejected:${record.operation}:${record.payload.id}`;
+    await storage.set(key, record);
+  };
+  let recoveryWrites = Promise.resolve();
+  const changeRecovery = task => {
+    const run = recoveryWrites.then(async () => {
+      if (!storage) return;
+      await storage.set('recovery', task(await storage.get('recovery') || []));
+    });
+    recoveryWrites = run.catch(() => {}); return run;
+  };
+  async function recoverable(operation, payload) {
+    payload = wireValue(payload);
+    const key = JSON.stringify({ operation, payload });
+    await changeRecovery(rows => rows.some(row => row.key === key) ? rows : [...rows, { key, operation, payload }]);
+    let result;
+    try { result = await call(operation, payload); }
+    catch (error) {
+      if (storage && error.code === 'FLEET_REJECTED') {
+        await quarantine({ operation, payload, error: error.message });
+        await changeRecovery(rows => rows.filter(row => row.key !== key));
+      }
+      throw error;
+    }
+    // Collected pieces are durable at the service. A fence remains retryable until final settlement.
+    if (operation === 'collect' || result.status !== 'pending') await changeRecovery(rows => rows.filter(row => row.key !== key));
+    return result;
+  }
+  return { call, collect: (id, evidence) => recoverable('collect', { id, evidence }),
+    fence: id => recoverable('fence', { id }), reserve: payload => call('reserve', payload), dispatch: id => call('dispatch', { id }), settle,
+    abandonBeforeDispatch: id => call('abandonBeforeDispatch', { id }),
+    async reconcile({ activeIds = null } = {}) {
+      await Promise.all([writes, recoveryWrites]);
+      const pending = storage ? await storage.get('settlements') || [] : [], outcomes = [];
+      for (const row of pending) {
+        try { outcomes.push(await settle(row.id, row.evidence)); }
+        catch (error) { outcomes.push({ id: row.id, status: 'pending', error: error.message }); }
+      }
+      const recovery = storage ? await storage.get('recovery') || [] : [];
+      for (const row of recovery) {
+        try { outcomes.push(await recoverable(row.operation, row.payload)); }
+        catch (error) { outcomes.push({ id: row.payload.id, status: 'pending', error: error.message }); }
+      }
+      if (Array.isArray(activeIds)) {
+        const consumerOutcomes = await call('reconcileMine', { activeIds });
+        for (const row of consumerOutcomes) {
+          if (!outcomes.some(value => value.id === row.id)) outcomes.push(row);
+        }
+      }
+      const recovered = await call('recoverMine', {});
+      return [...outcomes, ...recovered.filter(row => !outcomes.some(value => value.id === row.id))];
+    } };
+}
+
+/** Sign and retain the exact JSON bytes' value. Sparse arrays and non-finite numbers are
+ * not valid evidence; object properties explicitly left undefined are omitted before signing. */
+function wireValue(value) {
+  const visit = (item, array = false) => {
+    assert(item !== undefined || !array, 'Undefined array entry in fleet evidence');
+    assert(typeof item !== 'number' || Number.isFinite(item), 'Non-finite fleet value');
+    if (Array.isArray(item)) for (let i = 0; i < item.length; i++) visit(item[i], true);
+    else if (item && typeof item === 'object') for (const field of Object.values(item)) visit(field);
+  };
+  visit(value);
+  return JSON.parse(JSON.stringify(value));
+}

package/server/fleet/terminal-policy.js

@@ -0,0 +1,83 @@
+/** Explicit operator acceptance of fixed whole-model terminal terms.
+ * Existing completed balances and metered rates are never reinterpreted. */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { constants } from 'node:fs';
+import { DatabaseSync } from 'node:sqlite';
+import { canonicalize } from '../../packages/reploid/src/artifacts/canonical-json.js';
+import { assert, creditPolicy, same, text } from './contract.js';
+
+export async function acceptFleetTerminalPolicy({ file, previousVersion, policy: supplied, requestIds, now = Date.now }) {
+  const policy = creditPolicy(supplied);
+  assert(path.isAbsolute(file) && text(previousVersion) && policy.version !== previousVersion
+    && policy.wholeModelTerminalCharge === 0 && Array.isArray(requestIds)
+    && requestIds.length <= 2048 && requestIds.every(text) && new Set(requestIds).size === requestIds.length,
+  'Explicit zero-charge terminal policy and reservation scope required');
+  const handle = await fs.open(file, constants.O_RDWR | constants.O_NOFOLLOW);
+  try { assert((await handle.stat()).isFile(), 'Existing credit database required'); } finally { await handle.close(); }
+  const db = new DatabaseSync(file);
+  let transactionOpen = false;
+  try {
+    db.exec('BEGIN IMMEDIATE'); transactionOpen = true;
+    const key = `terminal-policy:${policy.version}`;
+    const priorAcceptance = db.prepare('SELECT value FROM fleet_metadata WHERE id=?').get(key);
+    const acceptance = { schema: 'reploid.fleet-terminal-policy/v1', previousVersion, policy, requestIds };
+    if (priorAcceptance) {
+      const retained = JSON.parse(priorAcceptance.value);
+      assert(same(retained.acceptance, acceptance), 'Terminal policy acceptance scope changed');
+      db.exec('COMMIT'); transactionOpen = false; return retained;
+    }
+    const current = JSON.parse(db.prepare("SELECT value FROM fleet_metadata WHERE id='policy'").get().value);
+    const { version: _oldVersion, wholeModelTerminalCharge: _oldCharge, ...oldTerms } = current;
+    const { version: _newVersion, wholeModelTerminalCharge: _newCharge, ...newTerms } = policy;
+    assert(current.version === previousVersion && same(oldTerms, newTerms), 'Terminal migration cannot change metered terms');
+    for (const id of requestIds) {
+      const row = db.prepare('SELECT binding,state FROM fleet_requests WHERE id=?').get(id);
+      const binding = row && JSON.parse(row.binding);
+      assert(binding?.mode === 'whole-model' && ['reserved', 'dispatched', 'closing'].includes(row.state)
+        && binding.terminalCharge == null, 'Only explicitly listed unresolved whole-model terms may change');
+      binding.terminalCharge = 0;
+      binding.terminalPolicyVersion = policy.version;
+      db.prepare('UPDATE fleet_requests SET binding=? WHERE id=?').run(JSON.stringify(binding), id);
+    }
+    const record = { acceptance, previousPolicy: current, acceptedAt: now() };
+    db.prepare('INSERT INTO fleet_metadata VALUES (?,?)').run(key, JSON.stringify(record));
+    db.prepare("UPDATE fleet_metadata SET value=? WHERE id='policy'").run(canonicalize(policy));
+    db.exec('COMMIT'); transactionOpen = false; return record;
+  } catch (error) { if (transactionOpen) db.exec('ROLLBACK'); throw error; }
+  finally { db.close(); }
+}
+
+export async function acceptFleetOutputLimitPolicy({ file, previousVersion, policy: supplied, now = Date.now }) {
+  const policy = creditPolicy(supplied);
+  assert(path.isAbsolute(file) && text(previousVersion) && policy.version !== previousVersion,
+    'Explicit output-limit policy version change required');
+  const handle = await fs.open(file, constants.O_RDWR | constants.O_NOFOLLOW);
+  try { assert((await handle.stat()).isFile(), 'Existing credit database required'); } finally { await handle.close(); }
+  const db = new DatabaseSync(file);
+  let transactionOpen = false;
+  try {
+    db.exec('BEGIN IMMEDIATE'); transactionOpen = true;
+    const key = `output-limit-policy:${policy.version}`;
+    const priorAcceptance = db.prepare('SELECT value FROM fleet_metadata WHERE id=?').get(key);
+    const acceptance = { schema: 'reploid.fleet-output-limit-policy/v1', previousVersion, policy };
+    if (priorAcceptance) {
+      const retained = JSON.parse(priorAcceptance.value);
+      assert(same(retained.acceptance, acceptance), 'Output-limit policy acceptance scope changed');
+      db.exec('COMMIT'); transactionOpen = false; return retained;
+    }
+    const current = JSON.parse(db.prepare("SELECT value FROM fleet_metadata WHERE id='policy'").get().value);
+    const { version: _oldVersion, maxOutputTokens: _oldLimit, ...oldTerms } = current;
+    const { version: _newVersion, maxOutputTokens: _newLimit, ...newTerms } = policy;
+    assert(current.version === previousVersion && same(oldTerms, newTerms),
+      'Output-limit migration cannot change credit unit, rate, debt or terminal terms');
+    const openCount = db.prepare("SELECT COUNT(*) AS count FROM fleet_requests WHERE state IN ('reserved','dispatched','closing')").get().count;
+    const heldCount = db.prepare('SELECT COUNT(*) AS count FROM fleet_accounts WHERE held != 0').get().count;
+    assert(openCount === 0 && heldCount === 0, 'Output-limit migration requires zero open reservations and holds');
+    const record = { acceptance, previousPolicy: current, acceptedAt: now() };
+    db.prepare('INSERT INTO fleet_metadata VALUES (?,?)').run(key, JSON.stringify(record));
+    db.prepare("UPDATE fleet_metadata SET value=? WHERE id='policy'").run(canonicalize(policy));
+    db.exec('COMMIT'); transactionOpen = false; return record;
+  } catch (error) { if (transactionOpen) db.exec('ROLLBACK'); throw error; }
+  finally { db.close(); }
+}

package/server/fleet/text-api.js

@@ -0,0 +1,94 @@
+import http from 'node:http';
+import https from 'node:https';
+import { createTextApi } from '../text-api.js';
+import { tokensEqual } from '../token-auth.js';
+import { createFleetBrowserBridgeHandler } from './browser-bridge.js';
+import { assert } from './contract.js';
+
+function previewRecipients(preview) {
+  return [...new Set([...(preview?.recipients || []), ...(preview?.input?.recipients || []),
+    ...(preview?.route?.stages?.map(stage => stage.participantId) || []),
+    ...[preview?.participantA, preview?.participantB, preview?.recipientIdentity || preview?.providerId].filter(Boolean)])];
+}
+
+/** Authenticated HTTP text API (/v1/models, /v1/chat/completions, /v1/responses)
+ * over an enrolled native fleet requester. Non-loopback binding requires TLS;
+ * every execution reserves and settles non-cash fleet service credits and checks
+ * disclosed provider keys against the coordinator's enrolled computers. */
+export async function startFleetTextApi({ host, token, listenHost = '127.0.0.1', port = 0, tls = null, allowedRecipients = null, browserBridge = null }) {
+  assert(typeof token === 'string' && token.length >= 32, 'Strong API bearer secret required');
+  assert(host?.textParticipant && typeof host.runAccountedGeneration === 'function'
+    && typeof host.enrolledRecipients === 'function' && host.identity?.peerId,
+  'Configured fleet host with service-credit accounting required');
+  const loopback = ['127.0.0.1', '::1'].includes(listenHost);
+  assert(loopback || Boolean(tls?.key && tls?.cert), 'Non-loopback fleet text API requires TLS');
+  let pinned = null;
+  if (allowedRecipients !== null && allowedRecipients !== undefined) {
+    assert(Array.isArray(allowedRecipients) && allowedRecipients.length > 0 && allowedRecipients.length <= 32
+      && new Set(allowedRecipients).size === allowedRecipients.length
+      && allowedRecipients.every(id => typeof id === 'string' && /^peer:[a-f0-9]{24,64}$/i.test(id)),
+    'Allowed recipients must be distinct enrolled peer identities');
+    pinned = new Set(allowedRecipients);
+  }
+  const bridge = browserBridge ? createFleetBrowserBridgeHandler({
+    host,
+    token: browserBridge.token,
+    origins: browserBridge.origins,
+    basePath: browserBridge.basePath ?? '/bridge',
+    ...(browserBridge.maxBodyBytes !== undefined ? { maxBodyBytes: browserBridge.maxBodyBytes } : {}),
+    ...(browserBridge.maxConcurrent !== undefined ? { maxConcurrent: browserBridge.maxConcurrent } : {})
+  }) : null;
+  const expectedHeader = `Bearer ${token}`;
+  const api = createTextApi({
+    participant: host.textParticipant,
+    production: true,
+    authenticate: async req => tokensEqual(req.headers.authorization, expectedHeader)
+      ? { subject: `fleet-api:${host.identity.peerId}` } : null,
+    authorize: async check => {
+      if (host.textParticipant.executionClass !== 'private-pool') return false;
+      if (check.action === 'models.list') return true;
+      if (check.action === 'chat.execute') return host.allowsModel(check.request?.model);
+      if (check.action === 'chat.recover') return typeof host.recoverAccountedGeneration === 'function';
+      if (check.action === 'chat.disclose') {
+        const enrolled = await host.enrolledRecipients();
+        const recipients = previewRecipients(check.preview);
+        return recipients.length > 0 && recipients.every(id => enrolled.has(id) && (!pinned || pinned.has(id)));
+      }
+      return false;
+    },
+    accounting: {
+      run: (request, controls, execute) => host.runAccountedGeneration(request, controls, execute),
+      ...(typeof host.recoverAccountedGeneration === 'function'
+        ? { recover: (input, controls, recoverExecution) => host.recoverAccountedGeneration(input, controls, recoverExecution) }
+        : {})
+    }
+  });
+  const handle = (req, res) => {
+    res.setHeader('cache-control', 'no-store');
+    res.setHeader('x-content-type-options', 'nosniff');
+    if (bridge) {
+      let pathname = '';
+      try { pathname = new URL(req.url || '/', 'http://127.0.0.1').pathname; }
+      catch { pathname = ''; }
+      if (pathname === bridge.prefix || pathname.startsWith(bridge.prefix + '/')) {
+        return bridge.handle(req, res);
+      }
+    }
+    return api.handle(req, res);
+  };
+  const server = tls ? https.createServer(tls, handle) : http.createServer(handle);
+  await new Promise((resolve, reject) => { server.once('error', reject); server.listen(port, listenHost, resolve); });
+  const address = server.address();
+  const hostText = listenHost.includes(':') ? `[${listenHost}]` : listenHost;
+  const baseUrl = `${tls ? 'https' : 'http'}://${hostText}:${address.port}`;
+  return Object.freeze({
+    url: `${baseUrl}/v1`,
+    ...(bridge ? { bridgeUrl: `${baseUrl}${bridge.prefix}` } : {}),
+    async close() {
+      await Promise.all([api.close(), bridge?.close()]);
+      server.closeIdleConnections();
+      server.closeAllConnections();
+      await new Promise(resolve => server.close(resolve));
+    }
+  });
+}

package/server/hashing.js

@@ -0,0 +1,35 @@
+/**
+ * @fileoverview The hosted services' one SHA-256 and canonical JSON, over
+ * node:crypto. Keys, record ids and evidence digests written by server code
+ * come from here, so retained hashes have one definition. The browser
+ * library's Web Crypto twin is packages/reploid/src/artifacts/signatures.js.
+ */
+
+import { createHash } from 'node:crypto';
+
+/** Lowercase hex SHA-256 with no prefix: bytes as given, any other value as the UTF-8 of String(value). */
+export const sha256Hex = (value) => createHash('sha256')
+  .update(typeof value === 'string' || ArrayBuffer.isView(value) ? value : String(value))
+  .digest('hex');
+
+/** `sha256:`-prefixed form of sha256Hex. */
+export const sha256Digest = (value) => `sha256:${sha256Hex(value)}`;
+
+/**
+ * Sorted-key JSON. Object members whose value is undefined are left out; any
+ * other undefined (array items, the top-level value) serializes as null, as
+ * JSON.stringify would.
+ */
+export const canonicalJson = (value) => {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort()
+      .filter((key) => value[key] !== undefined)
+      .map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`)
+      .join(',')}}`;
+  }
+  return JSON.stringify(value ?? null);
+};
+
+/** `sha256:` digest of canonicalJson(value). */
+export const hashCanonical = (value) => sha256Digest(canonicalJson(value));

package/server/http-request-owner.js

@@ -0,0 +1,49 @@
+/** HTTP lifetime only. Callers retain protocol, authorization and settlement policy. */
+export function createHttpRequestOwner({ timeoutMs }) {
+  const active = new Set();
+  let closed = false;
+  return {
+    get closed() { return closed; },
+    get size() { return active.size; },
+    begin(req, res, { disconnectError, deadlineError, onFinish = () => {} }) {
+      if (closed) throw new Error('HTTP request owner is closed');
+      const controller = new AbortController();
+      let resolve;
+      const item = { controller, completion: new Promise(done => { resolve = done; }) };
+      active.add(item);
+      let finished = false;
+      const socket = req.socket ?? null;
+      const cancel = () => {
+        if (!finished && !res.writableEnded) controller.abort(disconnectError());
+      };
+      req.once('aborted', cancel);
+      res.once('close', cancel);
+      socket?.once('close', cancel);
+      const timer = setTimeout(() => controller.abort(deadlineError()), timeoutMs);
+      return {
+        controller, signal: controller.signal, item,
+        clearDeadline() { clearTimeout(timer); },
+        finish() {
+          if (finished) return;
+          finished = true;
+          clearTimeout(timer);
+          req.removeListener('aborted', cancel);
+          res.removeListener('close', cancel);
+          socket?.removeListener('close', cancel);
+          active.delete(item);
+          try { onFinish(item); } finally { resolve(); }
+        }
+      };
+    },
+    async close(reason, unsettledError) {
+      closed = true;
+      for (const item of active) item.controller.abort(reason());
+      let timer;
+      try {
+        await Promise.race([Promise.all([...active].map(item => item.completion)), new Promise((_, reject) => {
+          timer = setTimeout(() => reject(unsettledError()), timeoutMs);
+        })]);
+      } finally { clearTimeout(timer); }
+    }
+  };
+}

package/server/messages.js

@@ -0,0 +1,57 @@
+/** Stateless Anthropic-shaped text Messages over declared local token semantics. */
+import policy from '../apps/poolday/config/partition-policy.json' with { type: 'json' };
+import { parseTextChatCompletion } from './chat-completions.js';
+import { createTextRequester, fail, object, freeze } from './text-requester.js';
+
+export function parseTextMessage(body) {
+  if (!object(body)) throw fail(400, 'A JSON object is required');
+  for (const key of Object.keys(body)) if (!['model','messages','system','max_tokens','stream'].includes(key)) throw fail(400, `Unsupported parameter: ${key}`, key);
+  if (!Number.isSafeInteger(body.max_tokens) || body.max_tokens <= 0 || body.max_tokens > policy.limits.maxTokens) {
+    throw fail(400, 'max_tokens must be a positive integer within the route budget; cache-only requests are unsupported', 'max_tokens');
+  }
+  if (!Array.isArray(body.messages) || !body.messages.length || body.messages.some((value,index) => !object(value)
+    || !['user','assistant'].includes(value.role) || value.role === body.messages[index-1]?.role)
+    || body.messages[0].role !== 'user' || body.messages.at(-1).role !== 'user') {
+    throw fail(400, 'Require alternating user/assistant text ending in user; assistant prefill is unsupported', 'messages');
+  }
+  if (body.system !== undefined && typeof body.system !== 'string') throw fail(400, 'system must be text', 'system');
+  const messages = [...(body.system === undefined ? [] : [{role:'system',content:body.system}]), ...body.messages];
+  return freeze({ ...parseTextChatCompletion({model:body.model,messages,stream:body.stream}), generationRequest: {
+    schema:'reploid.partition-generation-request/v1',maxOutputTokens:body.max_tokens,usage:'raw-model-tokens/v1' } });
+}
+const errorBody = error => ({type:'error',error:{type: error.status===401?'authentication_error':error.status===403?'permission_error'
+  :error.status===429?'rate_limit_error':error.status<500?'invalid_request_error':'api_error', message:String(error.message).slice(0,1024)}});
+export function createMessages(options) {
+  return createTextRequester(options,{path:'/v1/messages',idPrefix:'msg_',parse:parseTextMessage,errorBody,
+    validateRequest(req) {
+      if (req.headers['anthropic-version'] !== undefined && req.headers['anthropic-version'] !== '2023-06-01') throw fail(400,'Unsupported anthropic-version');
+      if (req.headers['anthropic-beta'] !== undefined) throw fail(400,'Anthropic beta features are unsupported');
+    },
+    output({id,model,input,write,end,json}) {
+      let started=false;
+      const usage = value => ({input_tokens:value.inputTokens,output_tokens:value.outputTokens});
+      const message = (content,stopReason,counts) => ({id,type:'message',role:'assistant',model,
+        content:content===null?[]:[{type:'text',text:content}],stop_reason:stopReason,stop_sequence:null,usage:usage(counts)});
+      const frame = (type,value) => `event: ${type}\ndata: ${JSON.stringify({type,...value})}\n\n`;
+      const event = (type,value) => write(frame(type,value));
+      return {
+        usage(value) {
+          if (started) throw fail(502,'Duplicate input token observation'); started=true;
+          event('message_start',{message:message(null,null,value)});
+          event('content_block_start',{index:0,content_block:{type:'text',text:''}});
+        },
+        delta(text) { if(!started)throw fail(502,'Input token usage unavailable'); event('content_block_delta',{index:0,delta:{type:'text_delta',text}}); },
+        complete(content,finishReason,reason,counts) {
+          if (!counts) throw fail(502,'Actual provider token usage unavailable');
+          if (reason==='context-limit' || reason==='stop-sequence') throw fail(502,'Requester stopping reason lacks a supported Messages mapping');
+          const stopReason=finishReason==='length'?'max_tokens':'end_turn';
+          if (!input.stream) {json(message(content,stopReason,counts));return;}
+          event('content_block_stop',{index:0});
+          event('message_delta',{delta:{stop_reason:stopReason,stop_sequence:null},usage:{output_tokens:counts.outputTokens}});
+          end(frame('message_stop',{}));
+        },
+        error(error) {end(frame('error',{error}));}
+      };
+    }
+  });
+}