graphlin 0.1.0

package/runtime/daemon/server.mjs

@@ -0,0 +1,292 @@
+import http from 'node:http';
+import net from 'node:net';
+import { readFile, chmod, rm } from 'node:fs/promises';
+import { createPipeline } from '../pipeline.mjs';
+import { createPolicy, materializeBundle, buildRelationProposals } from '../core/index.mjs';
+import { createDecisionService } from '../jev/index.mjs';
+import { projectPaths, canonicalProjectRoot, MAX_IPC_BYTES, MAX_STATE_BYTES, PROTOCOL, runtimeError } from './paths.mjs';
+import { acquireLock } from './lock.mjs';
+import { createAuth } from './auth.mjs';
+import { createPersistence } from './persistence.mjs';
+import { exportSnapshot } from './export.mjs';
+import { createDiagnostics } from './diagnostics.mjs';
+
+const WEB = new URL('../web/', import.meta.url);
+const assets = new Map([
+  ['/', ['index.html', 'text/html; charset=utf-8']],
+  ['/app.js', ['app.js', 'text/javascript; charset=utf-8']],
+  ['/sidebar.js', ['sidebar.js', 'text/javascript; charset=utf-8']],
+  ['/layout.js', ['layout.js', 'text/javascript; charset=utf-8']],
+  ['/sketch.js', ['sketch.js', 'text/javascript; charset=utf-8']],
+  ['/style.css', ['style.css', 'text/css; charset=utf-8']],
+]);
+const HOSTS = new Set(['claude', 'codex', 'kiro']);
+const CSP = "default-src 'none'; script-src 'self'; style-src 'self'; connect-src 'self'; img-src 'self' data:; base-uri 'none'; form-action 'none'; frame-ancestors 'none'; object-src 'none'";
+
+function headers(res) {
+  res.setHeader('Cache-Control', 'no-store');
+  res.setHeader('Content-Security-Policy', CSP);
+  res.setHeader('X-Content-Type-Options', 'nosniff');
+  res.setHeader('X-Frame-Options', 'DENY');
+  res.setHeader('Referrer-Policy', 'no-referrer');
+  res.setHeader('Cross-Origin-Opener-Policy', 'same-origin');
+}
+function json(res, status, value) {
+  res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8' });
+  res.end(JSON.stringify(value));
+}
+async function bodyJSON(req) {
+  if (!/^application\/json(?:;|$)/i.test(req.headers['content-type'] ?? '')) throw runtimeError('invalid_content_type');
+  const chunks = []; let bytes = 0;
+  const timer = setTimeout(() => req.destroy(), 1000);
+  try {
+    for await (const chunk of req) {
+      bytes += chunk.length;
+      if (bytes > 4096) throw runtimeError('input_too_large');
+      chunks.push(chunk);
+    }
+    const value = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    if (!value || typeof value !== 'object' || Array.isArray(value)) throw runtimeError('invalid_input');
+    return value;
+  } finally { clearTimeout(timer); }
+}
+
+export async function startServer({ projectRoot, dataDir, policy: policyOptions,
+  decisionService, apiKey: configuredKey, mode = 'live', port = 0 } = {}) {
+  if (!Number.isInteger(port) || port < 0 || port > 65535) throw runtimeError('invalid_port');
+  if (!['live', 'demo'].includes(mode)) throw runtimeError('invalid_mode');
+  const paths = await projectPaths(projectRoot, dataDir, { create: true });
+  const lock = await acquireLock(paths);
+  let finished;
+  const whenClosed = new Promise(resolve => { finished = resolve; });
+  let web, ipc, pipeline, auth, diagnostics, interval, ping, closing, reconciling = false;
+  let drops = 0, intake = 0;
+  const receivedHooks = { claude: 0, codex: 0, kiro: 0 };
+  const clients = new Set(), connections = new Set(), ipcConnections = new Set();
+  const persistence = createPersistence(paths.state);
+  const policy = createPolicy(policyOptions ?? {});
+  const apiKey = !decisionService && policy.transmitSource && mode === 'live'
+    ? configuredKey ?? process.env.TYPESAFE_API_KEY : undefined;
+  const missingKey = !decisionService && policy.transmitSource && mode === 'live' && !apiKey;
+  function snapshot(persistent = false) {
+    const state = pipeline.getState({ persistent });
+    return { ...state, status: { ...state.status,
+      classifier: missingKey && !state.paused ? 'missing_key' : state.status.classifier,
+      dropped: (state.status?.dropped ?? 0) + drops } };
+  }
+  function stream(res, state) {
+    const message = `event: snapshot\ndata: ${JSON.stringify(state)}\n\n`;
+    if (Buffer.byteLength(message) > MAX_STATE_BYTES || res.writableLength > MAX_STATE_BYTES) {
+      res.destroy(); clients.delete(res); return;
+    }
+    res.write(message);
+  }
+  function notify() {
+    if (!pipeline || closing) return;
+    persistence.schedule(snapshot(true));
+    const state = snapshot();
+    for (const res of clients) stream(res, state);
+  }
+  async function reconcile() {
+    if (reconciling || closing || !pipeline) return;
+    reconciling = true;
+    try { await pipeline.reconcile(); }
+    catch { drops++; }
+    finally { reconciling = false; }
+  }
+  async function close() {
+    if (closing) return closing;
+    closing = (async () => {
+      clearInterval(interval); clearInterval(ping);
+      auth?.clear();
+      for (const res of clients) res.end();
+      for (const socket of [...connections, ...ipcConnections]) socket.destroy();
+      await Promise.all([web, ipc].filter(Boolean).map(server =>
+        new Promise(resolve => server.close(() => resolve()))));
+      try {
+        await pipeline?.close();
+        if (pipeline) persistence.schedule(snapshot(true));
+        await persistence.close();
+      } finally {
+        try { await diagnostics?.close(); }
+        finally {
+          await rm(paths.socket, { force: true }).catch(() => {});
+          await lock.release();
+        }
+      }
+    })();
+    closing.then(() => finished({ ok: true }), () => finished({ ok: false, code: 'shutdown_failed' }));
+    return closing;
+  }
+  try {
+    diagnostics = await createDiagnostics({ directory: paths.directory, projectRoot: paths.projectRoot, policy });
+    // Reading the key is conditional on explicit source-transmission permission.
+    // Test/demo services are injected; this module never logs request bodies.
+    const service = decisionService ?? createDecisionService({
+      apiKey,
+      materializeBundle, buildRelationProposals,
+      limits: { eventDeadlineMs: 5000 },
+    });
+    pipeline = createPipeline({ projectRoot: paths.projectRoot, policy, decisionService: service,
+      classificationDeadlineMs: 5000,
+      mode, restoredState: await persistence.load(), onChange: notify, onDiagnostic: diagnostics.record });
+    web = http.createServer({ maxHeaderSize: 8192, requestTimeout: 2000, headersTimeout: 2000 }, (req, res) => {
+      headers(res);
+      void (async () => {
+        if (!auth || !auth.validRequest(req, { mutation: req.method !== 'GET' })) {
+          return json(res, 403, { error: 'forbidden_origin' });
+        }
+        if (typeof req.url !== 'string' || req.url.length > 1024 || req.url.includes('?')) {
+          return json(res, 400, { error: 'invalid_route' });
+        }
+        if (req.method === 'POST' && req.url === '/api/auth') {
+          const input = await bodyJSON(req);
+          if (Object.keys(input).some(key => key !== 'token')) return json(res, 400, { error: 'invalid_input' });
+          const cookie = auth.exchange(input.token);
+          if (!cookie) return json(res, 401, { error: 'invalid_token' });
+          res.setHeader('Set-Cookie', cookie);
+          return json(res, 200, { ok: true });
+        }
+        if (req.method === 'GET' && assets.has(req.url)) {
+          const [filename, contentType] = assets.get(req.url);
+          try {
+            const body = await readFile(new URL(filename, WEB));
+            if (body.length > 1024 * 1024) throw runtimeError('asset_too_large');
+            res.writeHead(200, { 'Content-Type': contentType }); res.end(body);
+          } catch { json(res, 503, { error: 'viewer_unavailable' }); }
+          return;
+        }
+        if (!auth.authorized(req)) return json(res, 401, { error: 'authentication_required' });
+        if (req.method === 'GET' && req.url === '/api/diagnostics') {
+          return json(res, 200, diagnostics.snapshot());
+        }
+        if (req.method === 'GET' && req.url === '/api/connection-info') {
+          try {
+            const { createConnectionInfo } = await import('./connection-info.mjs');
+            const info = await createConnectionInfo({ projectRoot: paths.projectRoot, dataDir: paths.dataDir, mode });
+            if (Buffer.byteLength(JSON.stringify(info)) > 64 * 1024) throw runtimeError('connection_info_too_large');
+            return json(res, 200, info);
+          } catch { return json(res, 503, { error: 'connection_info_unavailable' }); }
+        }
+        if (req.method === 'GET' && ['/api/state', '/api/export'].includes(req.url)) {
+          const state = req.url === '/api/export' ? exportSnapshot(snapshot()) : snapshot();
+          if (Buffer.byteLength(JSON.stringify(state)) > MAX_STATE_BYTES) return json(res, 503, { error: 'snapshot_too_large' });
+          if (req.url === '/api/export') res.setHeader('Content-Disposition', 'attachment; filename="graphlin-export.json"');
+          return json(res, 200, state);
+        }
+        if (req.method === 'GET' && req.url === '/api/events') {
+          if (clients.size >= 16) return json(res, 503, { error: 'viewer_limit' });
+          res.writeHead(200, { 'Content-Type': 'text/event-stream', Connection: 'keep-alive', 'X-Accel-Buffering': 'no' });
+          res.flushHeaders(); clients.add(res);
+          stream(res, snapshot());
+          req.on('close', () => clients.delete(res));
+          return;
+        }
+        if (req.method === 'POST' && req.url === '/api/control') {
+          const input = await bodyJSON(req);
+          if (Object.keys(input).some(key => !['action', 'sessionId'].includes(key))) return json(res, 400, { error: 'invalid_control' });
+          if (input.action === 'pause' || input.action === 'resume') pipeline.setPaused(input.action === 'pause');
+          else if (input.action === 'session' && typeof input.sessionId === 'string' &&
+            input.sessionId.length <= 100 && pipeline.selectSession(input.sessionId)) { /* selected */ }
+          else return json(res, 400, { error: 'invalid_control' });
+          return json(res, 200, { ok: true });
+        }
+        return json(res, 404, { error: 'not_found' });
+      })().catch(() => {
+        if (!res.headersSent && !res.destroyed) json(res, 400, { error: 'invalid_input' });
+        else if (!res.destroyed) res.destroy();
+      });
+    });
+    web.on('connection', socket => {
+      if (connections.size >= 64) return socket.destroy();
+      connections.add(socket); socket.on('close', () => connections.delete(socket));
+    });
+    web.on('clientError', (_error, socket) => socket.destroy());
+    web.keepAliveTimeout = 5000;
+    await new Promise((resolve, reject) => { web.once('error', reject); web.listen(port, '127.0.0.1', resolve); });
+    const actualPort = web.address().port, origin = `http://127.0.0.1:${actualPort}`;
+    auth = createAuth({ origin, instanceId: lock.owner.instanceId });
+    const launchURL = () => `${origin}/#token=${auth.launchToken()}`;
+    function describe() {
+      return { ok: true, protocol: PROTOCOL, instanceId: lock.owner.instanceId,
+        projectId: paths.projectId, pid: process.pid, port: actualPort, mode,
+        policy: { transmitSource: policy.transmitSource, displayEvidence: policy.displayEvidence,
+          persistEvidence: policy.persistEvidence, version: policy.version },
+        status: snapshot().status, ...persistence.stats(), captureDropped: drops,
+        observations: { hooks: { ...receivedHooks }, shapes: pipeline.getState().graph.nodes.length },
+        logPath: diagnostics.stats().logPath, diagnostics: diagnostics.stats() };
+    }
+    // Only the exclusive owner may remove a stale socket from a prior process.
+    await rm(paths.socket, { force: true });
+    ipc = net.createServer(socket => {
+      if (ipcConnections.size >= 32) { drops++; socket.destroy(); return; }
+      ipcConnections.add(socket);
+      let bytes = 0, chunks = [], handled = false;
+      const timer = setTimeout(() => { drops++; socket.destroy(); }, 500);
+      socket.on('error', () => {});
+      socket.on('close', () => { clearTimeout(timer); ipcConnections.delete(socket); });
+      const reply = value => { if (!socket.destroyed) socket.end(`${JSON.stringify(value)}\n`); };
+      socket.on('data', chunk => {
+        if (handled) return;
+        bytes += chunk.length;
+        if (bytes > MAX_IPC_BYTES) { drops++; socket.destroy(); return; }
+        chunks.push(chunk);
+        if (!chunk.includes(10)) return;
+        handled = true; clearTimeout(timer);
+        void (async () => {
+          const raw = Buffer.concat(chunks).toString('utf8');
+          chunks = [];
+          // A connection carries one bounded message, never an unbounded stream.
+          if (raw.slice(raw.indexOf('\n') + 1).trim()) throw runtimeError('invalid_input');
+          const input = JSON.parse(raw.slice(0, raw.indexOf('\n')));
+          if (!input || typeof input !== 'object' || Array.isArray(input)) throw runtimeError('invalid_input');
+          if (input.op) {
+            if (input.instanceId !== lock.owner.instanceId) return reply({ ok: false, code: 'wrong_instance' });
+            if (input.op === 'health') return reply(describe());
+            if (input.op === 'launch') return reply({ ...describe(), url: launchURL() });
+            if (input.op === 'shutdown') {
+              reply({ ok: true });
+              // whenClosed reports the failure; also observe the outer async
+              // close() promise so a rejected shutdown is never unhandled.
+              setImmediate(() => { void close().catch(() => {}); });
+              return;
+            }
+            if (input.op === 'export') return reply({ ok: true, snapshot: exportSnapshot(snapshot()) });
+            if (input.op === 'diagnostics') {
+              if (Object.keys(input).some(key => !['op', 'instanceId', 'artifactId'].includes(key))) {
+                return reply({ ok: false, code: 'invalid_input' });
+              }
+              return reply({ ok: true, ...diagnostics.snapshot({ artifactId: input.artifactId }) });
+            }
+            return reply({ ok: false, code: 'invalid_operation' });
+          }
+          if (!HOSTS.has(input.host) || !input.payload || Array.isArray(input.payload) ||
+              typeof input.payload !== 'object' || typeof input.payload.cwd !== 'string') throw runtimeError('invalid_input');
+          if (intake >= 32) { drops++; return reply({ ok: false, code: 'overloaded' }); }
+          intake++;
+          try {
+            if (await canonicalProjectRoot(input.payload.cwd) !== paths.projectRoot) throw runtimeError('wrong_project');
+            const result = await pipeline.ingest(input.payload, { host: input.host });
+            if (result?.accepted !== false) receivedHooks[input.host]++;
+            reply({ ok: result?.accepted !== false });
+          } finally { intake--; }
+        })().catch(() => { drops++; reply({ ok: false, code: 'invalid_input' }); });
+      });
+    });
+    await new Promise((resolve, reject) => { ipc.once('error', reject); ipc.listen(paths.socket, resolve); });
+    await chmod(paths.socket, 0o600);
+    interval = setInterval(() => { void reconcile(); }, 2000);
+    ping = setInterval(() => {
+      for (const res of clients) {
+        if (res.writableLength > MAX_STATE_BYTES) { res.destroy(); clients.delete(res); }
+        else res.write(': heartbeat\n\n');
+      }
+    }, 15_000);
+    await reconcile();
+    notify();
+    return { url: launchURL(), port: actualPort, close, pipeline, whenClosed };
+  } catch (error) {
+    await close();
+    throw error;
+  }
+}

package/runtime/daemon/settings.mjs

@@ -0,0 +1,103 @@
+import path from 'node:path';
+import { lstat } from 'node:fs/promises';
+import { projectPaths, privateDirectory, readPrivateJSON, atomicJSON, runtimeError, uid } from './paths.mjs';
+import { withPublicationGuard } from './lock.mjs';
+
+const LIMIT = 16 * 1024;
+const record = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+const validKey = value => typeof value === 'string' && value.length > 0 &&
+  value.length <= 4096 && !/[\s\u0000-\u001f\u007f]/u.test(value);
+const validPolicy = value => record(value) && Object.keys(value).length === 3 &&
+  ['allowSource', 'persistEvidence', 'displayEvidence'].every(key => typeof value[key] === 'boolean');
+const validHosts = value => Array.isArray(value) && value.length <= 2 &&
+  new Set(value).size === value.length && value.every(host => ['claude', 'codex'].includes(host));
+const validInstallation = value => record(value) &&
+  Object.keys(value).every(key => ['hosts', 'version', 'pendingHosts'].includes(key)) &&
+  validHosts(value.hosts) && (!('pendingHosts' in value) || validHosts(value.pendingHosts)) &&
+  typeof value.version === 'string' && /^\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$/.test(value.version);
+
+async function readFile(filename, allowed) {
+  try {
+    // Refuse unsafe settings instead of silently losing a user's consent choice.
+    // No settings data or filesystem error text becomes a public error.
+    const file = await lstat(filename);
+    if (!file.isFile() || file.isSymbolicLink()) throw runtimeError('unsafe_settings');
+    const info = await lstat(path.dirname(filename));
+    if (!info.isDirectory() || info.isSymbolicLink() || (info.mode & 0o077) !== 0 ||
+        (uid() !== undefined && info.uid !== uid())) throw runtimeError('unsafe_settings');
+    const value = await readPrivateJSON(filename, LIMIT);
+    if (!record(value) || value.schemaVersion !== 1 ||
+        Object.keys(value).some(key => !['schemaVersion', ...Object.keys(allowed)].includes(key)) ||
+        Object.entries(allowed).some(([key, validate]) => key in value && !validate(value[key]))) {
+      throw runtimeError('unsafe_settings');
+    }
+    return value;
+  } catch (error) {
+    if (error.code === 'ENOENT') return {};
+    throw runtimeError('unsafe_settings');
+  }
+}
+
+/**
+ * User credentials/installation are shared by projects in one data directory.
+ * Consent is scoped to the canonical project. Never serialize this result into
+ * a diagnostic, MCP response, snapshot, browser payload, or subprocess argument.
+ */
+export async function readSettings(context = {}) {
+  const paths = await projectPaths(context.projectRoot, context.dataDir);
+  const [user, project] = await Promise.all([
+    readFile(path.join(paths.dataDir, 'settings.json'), { apiKey: validKey, installation: validInstallation }),
+    readFile(path.join(paths.directory, 'settings.json'), { policy: validPolicy }),
+  ]);
+  return {
+    ...(user.apiKey ? { apiKey: user.apiKey } : {}),
+    ...(user.installation ? { installation: user.installation } : {}),
+    ...(project.policy ? { policy: project.policy } : {}),
+  };
+}
+
+export async function saveSettings(context, patch) {
+  if (!record(patch) || Object.keys(patch).some(key => !['apiKey', 'policy', 'installation'].includes(key)) ||
+      ('apiKey' in patch && patch.apiKey !== null && !validKey(patch.apiKey)) ||
+      ('policy' in patch && !validPolicy(patch.policy)) ||
+      ('installation' in patch && !validInstallation(patch.installation))) throw runtimeError('invalid_settings');
+  const paths = await projectPaths(context.projectRoot, context.dataDir, { create: true });
+  await privateDirectory(paths.dataDir);
+  // Reuse the daemon's cross-process bakery guard. Each claim has a unique
+  // PID/UUID name before its ticket is written, so interrupted setup can be
+  // recovered without racing to delete a shared lock pathname.
+  await withPublicationGuard({ lock: path.join(paths.dataDir, '.settings') }, async () => {
+    const current = await readSettings(paths);
+    if ('apiKey' in patch || 'installation' in patch) {
+      const user = { schemaVersion: 1 };
+      const key = 'apiKey' in patch ? patch.apiKey : current.apiKey;
+      const installation = patch.installation ?? current.installation;
+      if (key) user.apiKey = key;
+      if (installation) user.installation = installation;
+      await atomicJSON(path.join(paths.dataDir, 'settings.json'), user, LIMIT);
+    }
+    if ('policy' in patch) await atomicJSON(path.join(paths.directory, 'settings.json'),
+      { schemaVersion: 1, policy: patch.policy }, LIMIT);
+  }).catch(error => {
+    if (error.code === 'daemon_busy') throw runtimeError('settings_busy');
+    throw error;
+  });
+}
+
+export function savedPolicy(policy) {
+  return policy ? {
+    allowSource: policy.transmitSource,
+    persistEvidence: policy.persistEvidence,
+    displayEvidence: policy.displayEvidence,
+  } : {};
+}
+
+// An omitted field means reuse consent, while false is an explicit opt-out.
+export function resolvePolicy(options, { current, saved } = {}) {
+  const fallback = current ? savedPolicy(current) : saved ?? {};
+  return {
+    allowSource: options.allowSource ?? fallback.allowSource ?? false,
+    persistEvidence: options.persistEvidence ?? fallback.persistEvidence ?? false,
+    displayEvidence: options.displayEvidence ?? fallback.displayEvidence ?? true,
+  };
+}

package/runtime/jev/fixture.mjs

@@ -0,0 +1,99 @@
+import { ROLES, RELATIONS, ACTIVITIES } from './questions.mjs';
+import { JevFault, isProbability, isRecord } from './wire.mjs';
+
+export const FIXTURE_TRANSPORT = Symbol.for('graphlin.jev.recorded-fixture');
+
+const recordedCandidates = Object.freeze({
+  'Notes API': { role: 'service', relevant: 0.98, sensitive: 0.01, support: 0.97 },
+  'Notes repository': { role: 'module', relevant: 0.98, sensitive: 0.01, support: 0.97 },
+  saveNote: { role: 'function', relevant: 0.98, sensitive: 0.01, support: 0.97 },
+  PostgreSQL: { role: 'datastore', relevant: 0.98, sensitive: 0.01, support: 0.97 },
+});
+const recordedRelations = Object.freeze([
+  { sourceLabel: 'Notes API', targetLabel: 'Notes repository', relation: 'calls',
+    support: 0.97, missingContext: 0.02 },
+  { sourceLabel: 'Notes repository', targetLabel: 'PostgreSQL', relation: 'writes',
+    support: 0.97, missingContext: 0.02 },
+  { sourceLabel: 'saveNote', targetLabel: 'PostgreSQL', relation: 'writes',
+    support: 0.97, missingContext: 0.02 },
+]);
+
+/**
+ * An OFFLINE DEMO recording lookup, never a source-code classifier.
+ * Explicit mode:"demo" is required. Unknown labels are withheld. Source text is
+ * never interpreted and this function never delegates to fetch or opens a socket.
+ */
+export function createFixtureTransport({
+  mode,
+  candidates = recordedCandidates,
+  relations = recordedRelations,
+  activity = 'implement',
+  relevance = 0.98,
+} = {}) {
+  if (mode !== 'demo') throw new JevFault('fixture_requires_demo_mode');
+  if (!isRecord(candidates) || !Array.isArray(relations)
+    || !ACTIVITIES.includes(activity) || !isProbability(relevance)) {
+    throw new JevFault('invalid_fixture');
+  }
+  const candidateRecords = structuredClone(candidates);
+  const relationRecords = structuredClone(relations);
+  for (const record of Object.values(candidateRecords)) {
+    if (!isRecord(record) || !ROLES.includes(record.role)
+      || !['relevant', 'sensitive', 'support'].every((key) => isProbability(record[key]))) {
+      throw new JevFault('invalid_fixture');
+    }
+  }
+  for (const record of relationRecords) {
+    if (!isRecord(record) || typeof record.sourceLabel !== 'string'
+      || typeof record.targetLabel !== 'string' || !RELATIONS.includes(record.relation)
+      || !isProbability(record.support) || !isProbability(record.missingContext)) {
+      throw new JevFault('invalid_fixture');
+    }
+  }
+  const fetchImpl = async (_url, options) => {
+    const request = JSON.parse(options.body);
+    const { entities } = request.state;
+    const recordFor = entity => entity && Object.hasOwn(candidateRecords, entity.name)
+      ? candidateRecords[entity.name]
+      : { role: 'unknown', relevant: 0.01, sensitive: 1, support: 0.01 };
+    const answers = {};
+    for (const [id, question] of Object.entries(request.questions)) {
+      const index = Number(id.slice(id.lastIndexOf('_') + 1));
+      const record = recordFor(entities[index]);
+      if (question.type === 'choice') {
+        const choice = id === 'a_activity' ? activity : record.role;
+        answers[id] = {
+          type: 'choice', choice, confidence: 0.98,
+          probabilities: Object.fromEntries(Object.keys(question.criteria)
+            .map((key) => [key, key === choice ? 1 : 0])),
+        };
+      } else if (question.type === 'noul') {
+        let noul;
+        if (id.startsWith('a_sensitive_')) {
+          // A shared snippet has one safety verdict. Conflicting/unknown demo
+          // records withhold the whole snippet; they never certify its contents.
+          const members = entities.filter(entity => entity.sourceIndex === index);
+          noul = members.length ? Math.max(...members.map(entity => recordFor(entity).sensitive)) : 1;
+        }
+        else if (id.startsWith('a_relevant_')) noul = record.relevant;
+        else if (id === 'b_relevance') noul = relevance;
+        else if (id.startsWith('b_support_')) noul = record.support;
+        else if (id.startsWith('b_relation_') || id.startsWith('b_context_')) {
+          const target = request.state.proposals[index];
+          const relation = relationRecords.find((entry) =>
+            entry.sourceLabel === entities[target.sourceEntityIndex]?.name
+            && entry.targetLabel === entities[target.targetEntityIndex]?.name
+            && entry.relation === target.relation);
+          noul = id.startsWith('b_relation_')
+            ? (relation?.support ?? 0.01) : (relation?.missingContext ?? 1);
+        } else throw new JevFault('unknown_fixture_question');
+        answers[id] = { type: 'noul', noul };
+      } else throw new JevFault('unknown_fixture_question');
+    }
+    return new Response(JSON.stringify({
+      model: request.model, answers, usage: { input_tokens: 0, output_tokens: 0 },
+    }), { status: 200, headers: { 'content-type': 'application/json' } });
+  };
+  Object.defineProperty(fetchImpl, FIXTURE_TRANSPORT, { value: true });
+  return fetchImpl;
+}