reploid 0.0.0-stage → 0.1.0

package/shared/config/reploid-library.json

@@ -0,0 +1,49 @@
+{
+  "schema": "reploid.application-library-profile/v1",
+  "profile": {
+    "schema": "reploid.profile/v1",
+    "id": "legacy-application",
+    "config": {
+      "tools": {
+        "allowed": [
+          "ReadFile",
+          "WriteFile",
+          "Promote",
+          "LoadModule"
+        ],
+        "allowDynamic": true
+      },
+      "mesh": {
+        "executeJobs": true,
+        "generationTimeoutMs": 300000,
+        "routing": "local-first"
+      },
+      "webrtc": {
+        "protocol": "swarm/v1",
+        "maxMessageBytes": 262144,
+        "rtcConfig": {
+          "iceServers": [
+            {
+              "urls": "stun:stun.l.google.com:19302"
+            },
+            {
+              "urls": "stun:stun1.l.google.com:19302"
+            }
+          ],
+          "iceTransportPolicy": "all"
+        },
+        "maxPendingRemoteIceCandidates": 32,
+        "dataChannelOptions": {
+          "ordered": true,
+          "maxRetransmits": null
+        }
+      }
+    }
+  },
+  "persistence": {
+    "storeName": "files",
+    "version": 1,
+    "keyPath": "path",
+    "openTimeoutMs": 10000
+  }
+}

package/shared/config/swarm-bootstrap.json

@@ -0,0 +1,21 @@
+{
+  "schema": "reploid.swarm-bootstrap/v1",
+  "publicRoomId": "reploid-swarm-public",
+  "publicJoinMarker": "reploid-public-namespace-not-a-secret-v1",
+  "path": "/swarm",
+  "signalingUrl": "wss://reploid-swarm.reploid.workers.dev/swarm",
+  "rtcConfigUrl": "https://reploid-swarm.reploid.workers.dev/rtc-config",
+  "rtcRefreshSkewMs": 60000,
+  "autoConnect": true,
+  "retryMs": [1000, 2000, 4000, 8000, 16000, 30000],
+  "healthCheckMs": 10000,
+  "allowLoopbackOrigins": true,
+  "allowedOrigins": ["https://replo.id", "https://reploid.web.app", "https://reploid.firebaseapp.com", "http://localhost:8000", "http://127.0.0.1:8000"],
+  "server": {
+    "heartbeatInterval": 30000, "peerTimeout": 60000, "maxMessageBytes": 65536,
+    "maxPeersPerRoom": 64, "maxPeersTotal": 256, "maxRooms": 128,
+    "maxMessagesPerWindow": 512, "rateLimitWindowMs": 1000,
+    "maxConnections": 320, "maxConnectionsPerWindow": 128,
+    "connectionWindowMs": 1000, "joinTimeoutMs": 10000
+  }
+}

package/shared/infrastructure/doppler-runtime-service.js

@@ -0,0 +1,261 @@
+/**
+ * Shared Reploid infrastructure owner for Doppler module imports and scoped sessions.
+ *
+ * Callers own policy. This service owns runtime identity, session lifetime,
+ * and one session per explicit Reploid scope.
+ */
+
+import {
+  DOPPLER_BROWSER_RUNTIME_VERSION,
+  DOPPLER_KERNEL_BASE_URL,
+  DOPPLER_MODULE_URL
+} from '../config/doppler-local-models.js';
+import { resolveDopplerExecutionContract } from '../config/doppler-execution-contracts.js';
+import { createDopplerModuleLoader, createDopplerStreamAccumulator, resolveDopplerRuntime } from '../vendor/reploid/adapters/doppler-session.js';
+import { GENERATION_CONTRACT, validateGenerationInput, resolveGenerationOptions } from '../config/doppler-generation-contract.js';
+
+// This generated, validation-only bundle comes from Doppler's installed public
+// export. Reploid authors no sampling fields, defaults, or range rules.
+export const DOPPLER_GENERATION_CONTRACT = GENERATION_CONTRACT;
+export function validateDopplerGenerationRequest({ input, options }) {
+  validateGenerationInput(input);
+  return resolveGenerationOptions(options);
+}
+export function assertDopplerGenerationContract(session) {
+  if (JSON.stringify(session.generationContract) !== JSON.stringify(GENERATION_CONTRACT)) {
+    throw new Error('Doppler generation contract mismatch; install the qualified package matching Reploid before generation.');
+  }
+}
+
+const DEFAULT_SCOPE = 'reploid-default';
+
+const normalizedScope = (value) => {
+  const scope = String(value || DEFAULT_SCOPE).trim();
+  if (!scope) throw new Error('Doppler session scope must be a non-empty string');
+  return scope;
+};
+
+const normalizedVersion = (module) => (
+  module?.DOPPLER_VERSION
+  || module?.default?.DOPPLER_VERSION
+  || null
+);
+
+const isVitestRuntime = () => (
+  globalThis.process?.env?.VITEST === 'true'
+  || Boolean(globalThis.__POOL_DOPPLER_RUNTIME_TEST)
+);
+
+const legacyTestSession = (handle) => ({
+  ...handle,
+  schema: 'doppler.scoped-session/v1',
+  async generate(input, options = {}) {
+    if (typeof handle.generate === 'function') return handle.generate(input, options);
+    if (typeof handle.chatText === 'function') return handle.chatText(input, options);
+    throw new Error('Legacy Doppler test handle does not expose generation');
+  },
+  async *stream(input, options = {}) {
+    const iterable = typeof handle.chat === 'function'
+      ? handle.chat(input, options)
+      : handle.generate(input, options);
+    for await (const chunk of iterable) {
+      if (typeof chunk !== 'string') {
+        throw new Error('Doppler chat stream emitted a non-text chunk');
+      }
+      yield {
+        schema: 'doppler.generation-event/v1',
+        type: 'text-delta',
+        text: chunk,
+        observationPolicyId: 'demo/always-on'
+      };
+    }
+    yield {
+      schema: 'doppler.generation-event/v1',
+      type: 'complete',
+      outputText: '',
+      observationPolicyId: 'demo/always-on'
+    };
+  },
+  async close() {
+    await handle.close?.();
+    await handle.unload?.();
+  }
+});
+
+const resolveLegacyTestRuntime = (module) => {
+  if (!isVitestRuntime()) return null;
+  const load = module?.load || module?.doppler?.load;
+  if (typeof load !== 'function') return null;
+  return {
+    async open(source, options) {
+      const loaded = await load(source, options);
+      return legacyTestSession(
+        loaded?.handle || loaded?.model || loaded?.session || loaded?.pipeline || loaded
+      );
+    }
+  };
+};
+
+const defaultLoadModule = async () => {
+  const kernelBase = globalThis.REPLOID_DOPPLER_KERNEL_BASE_URL
+    || DOPPLER_KERNEL_BASE_URL;
+  globalThis.__DOPPLER_KERNEL_BASE_PATH__ = String(kernelBase).replace(/\/+$/, '');
+  const moduleUrl = globalThis.REPLOID_DOPPLER_MODULE_URL
+    || DOPPLER_MODULE_URL;
+
+  try {
+    return await import(moduleUrl);
+  } catch (cause) {
+    throw new Error(`Doppler import failed at ${moduleUrl}. Inspect the first failed module request.`, { cause });
+  }
+};
+
+export function createReploidDopplerRuntimeService({
+  loadModule = defaultLoadModule,
+  expectedVersion = DOPPLER_BROWSER_RUNTIME_VERSION
+} = {}) {
+  // The library's session contract memoizes the module and retries after a failed load.
+  const modules = createDopplerModuleLoader({ loadModule });
+  const sessions = new Map();
+  const inFlight = new Map();
+
+  const getModule = async (provided = null) => provided || modules.load();
+
+  const assertModule = (module) => {
+    const version = normalizedVersion(module);
+    const legacyTestRuntime = resolveLegacyTestRuntime(module);
+    if (legacyTestRuntime) {
+      return { runtime: legacyTestRuntime, version };
+    }
+    if (expectedVersion && version !== expectedVersion) {
+      throw new Error(
+        `Reploid requires Doppler ${expectedVersion}; loaded ${version || 'unidentified'}`
+      );
+    }
+    const runtime = resolveDopplerRuntime(module);
+    if (typeof runtime?.open !== 'function') {
+      throw new Error('Doppler runtime does not expose the scoped dr.open API');
+    }
+    return { runtime, version };
+  };
+
+  const releaseEntry = async (key) => {
+    const entry = sessions.get(key);
+    if (!entry) return;
+    entry.quarantined = true;
+    await entry.session.close?.();
+    if (sessions.get(key) === entry) sessions.delete(key);
+  };
+
+  const close = (scope = DEFAULT_SCOPE) => {
+    const key = normalizedScope(scope);
+    const pending = inFlight.get(key);
+    const task = (async () => {
+      if (pending) await pending.catch(() => null);
+      await releaseEntry(key);
+    })();
+    inFlight.set(key, task);
+    task.finally(() => { if (inFlight.get(key) === task) inFlight.delete(key); }).catch(() => null);
+    return task;
+  };
+
+  const open = async ({
+    scope = DEFAULT_SCOPE,
+    source,
+    options = {},
+    module = null
+  } = {}) => {
+    const key = normalizedScope(scope);
+    if (source == null) throw new Error('Doppler scoped session source is required');
+    const previous = inFlight.get(key);
+    const task = (async () => {
+      if (previous) await previous.catch(() => null);
+      const sourceKey = typeof source === 'string' ? source : JSON.stringify(source);
+      const current = sessions.get(key);
+      if (current?.session?.loaded && !current.quarantined && current.sourceKey === sourceKey) return current.session;
+      await releaseEntry(key);
+      const loadedModule = await getModule(module);
+      const { runtime } = assertModule(loadedModule);
+      const session = await runtime.open(source, options);
+      if (!session || session.schema !== 'doppler.scoped-session/v1') {
+        await session?.close?.();
+        throw new Error('Doppler dr.open returned an invalid scoped session');
+      }
+      sessions.set(key, { session, sourceKey });
+      return session;
+    })();
+    inFlight.set(key, task);
+    task.finally(() => { if (inFlight.get(key) === task) inFlight.delete(key); }).catch(() => null);
+    return task;
+  };
+
+  const signedRuntime = (module, contract) => {
+    const version = normalizedVersion(module);
+    if (expectedVersion && version !== expectedVersion) throw new Error(`Reploid requires Doppler ${expectedVersion}; loaded ${version || 'unidentified'}`);
+    const runtime = typeof module?.[contract.openMethod] === 'function' ? module : resolveDopplerRuntime(module);
+    if (typeof runtime?.[contract.openMethod] !== 'function') throw new Error(`Doppler runtime does not expose public ${contract.openMethod}; signed model loading cannot fall back to dr.open`);
+    return { runtime, version };
+  };
+
+  const openSigned = (contract, { scope = DEFAULT_SCOPE, source, options = {}, module = null } = {}) => {
+    const key = normalizedScope(scope);
+    const previous = inFlight.get(key);
+    const task = (async () => {
+      if (previous) await previous.catch(() => null);
+      if (source == null) throw new Error('Signed Pack source is required');
+      const loadedModule = await getModule(module);
+      const { runtime } = signedRuntime(loadedModule, contract);
+      await releaseEntry(key);
+      const session = await runtime[contract.openMethod](source, options);
+      if (session?.schema !== contract.sessionSchema || !session.loaded) {
+        await session?.close?.();
+        throw new Error(`Doppler ${contract.openMethod} returned an invalid signed model session`);
+      }
+      sessions.set(key, { session, sourceKey: null });
+      return session;
+    })();
+    inFlight.set(key, task);
+    task.finally(() => { if (inFlight.get(key) === task) inFlight.delete(key); }).catch(() => null);
+    return task;
+  };
+
+  return Object.freeze({
+    open,
+    // Reverify lifecycle policy on every Pack opening; never reuse stale eligibility.
+    openPack: options => openSigned(resolveDopplerExecutionContract('doppler.pack/v2'), options),
+    openCapsule: options => openSigned(resolveDopplerExecutionContract('doppler.capsule/v2'), options),
+    async createStreamAccumulator(request, { bindingSchema, runtimeVersion }) {
+      const module = await getModule();
+      const { runtime, version } = signedRuntime(module, resolveDopplerExecutionContract(bindingSchema));
+      if (version !== runtimeVersion) throw new Error('Stream consumer runtime version mismatch');
+      return createDopplerStreamAccumulator(runtime, request);
+    },
+    close,
+    get(scope = DEFAULT_SCOPE) {
+      const entry = sessions.get(normalizedScope(scope));
+      return entry?.quarantined ? null : entry?.session || null;
+    },
+    async closeAll() {
+      const pending = [...inFlight.values()];
+      if (pending.length) await Promise.allSettled(pending);
+      const results = await Promise.allSettled([...sessions.keys()].map(close));
+      const errors = results.filter(result => result.status === 'rejected').map(result => result.reason);
+      if (errors.length) throw new AggregateError(errors, 'Doppler session cleanup failed');
+    },
+    async prepare(module = null, { bindingSchema = null } = {}) {
+      const loadedModule = await getModule(module);
+      const { version } = bindingSchema === null ? assertModule(loadedModule)
+        : signedRuntime(loadedModule, resolveDopplerExecutionContract(bindingSchema));
+      return { ok: true, version };
+    },
+    resetModuleForTests() {
+      modules.reset();
+      const active = [...sessions.values()].map((entry) => entry.session);
+      sessions.clear();
+      inFlight.clear();
+      void Promise.allSettled(active.map((session) => session.close?.()));
+    }
+  });
+}
+
+export const DopplerRuntimeService = createReploidDopplerRuntimeService();

package/shared/pool/executable-pack.js

@@ -0,0 +1,87 @@
+/** Poolday's exact execution requirement. Doppler owns signature and byte verification. */
+import { resolveDopplerExecutionContract } from '../config/doppler-execution-contracts.js';
+
+const DIGEST = /^sha256:[0-9a-f]{64}$/;
+
+// Doppler canonical observation encoding, including typed arrays as value arrays.
+const canonical = (value) => {
+  if (value === null || typeof value !== 'object') {
+    if (typeof value === 'number' && !Number.isFinite(value)) throw new Error('Non-finite Pack evidence');
+    return JSON.stringify(value);
+  }
+  if (ArrayBuffer.isView(value)) return canonical(Array.from(value));
+  if (Array.isArray(value)) return `[${value.map((item) => canonical(item) ?? 'null').join(',')}]`;
+  return `{${Object.keys(value).filter((key) => value[key] !== undefined).sort((a, b) => a.localeCompare(b)).map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(',')}}`;
+};
+export const hashDopplerEvidence = async (value) => {
+  const bytes = new Uint8Array(await crypto.subtle.digest('SHA-256', new TextEncoder().encode(canonical(value))));
+  return `sha256:${Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('')}`;
+};
+
+export function validateExecutablePack(binding) {
+  const reasons = [];
+  if (!binding || typeof binding !== 'object' || Array.isArray(binding)) return { ok: false, reasons: ['Signed executable Pack binding is required'] };
+  let contract;
+  try { contract = resolveDopplerExecutionContract(binding.schema); }
+  catch { return { ok: false, reasons: ['Unsupported executable Pack schema'] }; }
+  const IDENTITY_FIELDS = contract.identityFields;
+  if (Object.keys(binding).some((key) => ![...IDENTITY_FIELDS, 'requiredOperation', 'acceptedTargetPlanDigests', 'artifacts'].includes(key))) reasons.push('Unknown executable Pack binding field');
+  if (typeof binding[IDENTITY_FIELDS[1]] !== 'string' || !binding[IDENTITY_FIELDS[1]]) reasons.push('Pack id is required');
+  for (const field of IDENTITY_FIELDS.slice(2)) if (!DIGEST.test(binding[field])) reasons.push(`Invalid Pack ${field}`);
+  // Custody binds an operation name; the installed execution adapter admits it.
+  // Serving model bytes must not imply that a peer can execute their operations.
+  if (typeof binding.requiredOperation !== 'string' || !/^[a-zA-Z][a-zA-Z0-9_.-]*$/.test(binding.requiredOperation)) reasons.push('A public Pack operation name is required');
+  if (!Array.isArray(binding.acceptedTargetPlanDigests) || !binding.acceptedTargetPlanDigests.length
+    || binding.acceptedTargetPlanDigests.some((digest) => !DIGEST.test(digest))
+    || new Set(binding.acceptedTargetPlanDigests).size !== binding.acceptedTargetPlanDigests.length) reasons.push('Accepted TargetPlan digests must be explicit and unique');
+  if (!Array.isArray(binding.artifacts) || !binding.artifacts.length) reasons.push('Pack artifact closure is required');
+  else {
+    const ids = new Set();
+    for (const artifact of binding.artifacts) {
+      if (!artifact || typeof artifact.artifactId !== 'string' || !artifact.artifactId || ids.has(artifact.artifactId)
+        || !DIGEST.test(artifact.hash) || !Number.isSafeInteger(artifact.sizeBytes) || artifact.sizeBytes < 0
+        || typeof artifact.path !== 'string' || typeof artifact.role !== 'string') reasons.push('Invalid or duplicated Pack artifact');
+      ids.add(artifact?.artifactId);
+    }
+  }
+  return { ok: !reasons.length, reasons };
+}
+
+export function executablePacksMatch(left, right) {
+  return canonical(left ?? null) === canonical(right ?? null);
+}
+
+export async function assertPackExecutionEvidence(binding, evidence) {
+  const validation = validateExecutablePack(binding);
+  if (!validation.ok) throw new Error(validation.reasons.join('; '));
+  if (await hashDopplerEvidence(binding.artifacts) !== binding.artifactClosureDigest) throw new Error('Pack artifact closure digest mismatch');
+  const contract = resolveDopplerExecutionContract(binding.schema);
+  if (contract.identityFields.some((field) => binding[field] !== evidence?.[contract.receiptIdentity]?.[field])) throw new Error('Doppler did not execute the required exact Pack');
+  if (!binding.acceptedTargetPlanDigests.includes(evidence.targetPlanDigest)) throw new Error('Doppler selected an unaccepted TargetPlan');
+  const expected = binding.artifacts.map(({ artifactId, hash, sizeBytes }) => ({ artifactId, hash, sizeBytes }));
+  if (canonical(expected) !== canonical(evidence.artifactReceipts)) throw new Error('Doppler artifact receipts do not close the required Pack');
+}
+
+export async function assertPackSession(binding, session) {
+  const contract = resolveDopplerExecutionContract(binding?.schema);
+  if (session?.schema !== contract.sessionSchema || !session.loaded
+    || (typeof session.executeOperation !== 'function' && typeof session[binding?.requiredOperation] !== 'function')) throw new Error('Doppler did not open the required public Pack session');
+  await assertPackExecutionEvidence(binding, { [contract.receiptIdentity]: session[contract.sessionIdentity], targetPlanDigest: session.selectedTargetPlanDigest, artifactReceipts: session.verification?.artifactReceipts });
+}
+
+export async function assertPackReceipt(binding, receipt, { assignment = null, sequence, options, result } = {}) {
+  await assertPackExecutionEvidence(binding, receipt);
+  if (receipt.schema !== resolveDopplerExecutionContract(binding.schema).sequenceReceiptSchema || binding.requiredOperation !== 'encodeSequence'
+    || receipt.operation !== binding.requiredOperation) throw new Error('Invalid Doppler Pack operation receipt');
+  const { receiptDigest, ...payload } = receipt;
+  if (receiptDigest !== await hashDopplerEvidence(payload)) throw new Error('Doppler Pack receipt digest mismatch');
+  if (assignment && receipt.assignmentHash !== await hashDopplerEvidence(assignment)) throw new Error('Doppler Pack receipt assignment mismatch');
+  if (sequence !== undefined) {
+    const { signal, ...request } = options;
+    if (receipt.inputHash !== await hashDopplerEvidence({ sequence, options: request })) throw new Error('Doppler Pack receipt input mismatch');
+  }
+  if (result) {
+    const { phase, receipt: ignoredReceipt, dopplerProviderReceipt, ...output } = result;
+    if (receipt.outputHash !== await hashDopplerEvidence(output)) throw new Error('Doppler Pack receipt output mismatch');
+  }
+}

package/shared/pool/pack-operation-adapters.js

@@ -0,0 +1,124 @@
+/** Implementation functions bound to checked operation policy; no networking imports. */
+import poolConfig from './pool-config.json' with { type: 'json' };
+import { resolvePackOperationDefinitions, assertOperationFields } from './pack-operation-policy.js';
+import { validateDopplerGenerationRequest } from '../infrastructure/doppler-runtime-service.js';
+const requireValue = (value, message) => { if (!value) throw new Error(`Pack operation: ${message}`); };
+const text = (value) => typeof value === 'string' && value.trim().length > 0;
+const vector = (value) => Array.isArray(value) && value.length > 0 && value.every(Number.isFinite);
+const tokenIds = (value) => Array.isArray(value) && value.every((id) => Number.isSafeInteger(id) && id >= 0);
+const closeVector = (left, right, policy) => vector(left) && vector(right) && left.length === right.length
+  && left.every((value, index) => Math.abs(value - right[index]) <= policy.absoluteTolerance + policy.relativeTolerance * Math.abs(right[index]));
+
+export const PACK_OPERATION_IMPLEMENTATIONS = Object.freeze({
+  'generate.v1': {
+    contractVersion: 1,
+    validateRequest: validateDopplerGenerationRequest,
+    validateOutput(output, request) {
+      requireValue(typeof output.text === 'string' && tokenIds(output.tokenIds) && output.tokenIds.length <= request.options.maxTokens, 'invalid generation output');
+    },
+    compare(output, reference, policy) {
+      return output.text === reference.text;
+    }
+  },
+  'embed.v1': {
+    contractVersion: 1,
+    validateRequest({ input, options }) {
+      requireValue(Array.isArray(input.texts) && input.texts.length > 0 && input.texts.every(text), 'texts required');
+      requireValue(input.application && typeof input.application === 'object'
+        && !Array.isArray(input.application), 'signed embedding application required');
+    },
+    validateOutput(output, request, { completed }) {
+      requireValue(Array.isArray(output.embeddings) && output.embeddings.length > 0
+        && output.embeddings.length <= request.input.texts.length
+        && (!completed || output.embeddings.length === request.input.texts.length)
+        && output.embeddings.every((item) => vector(item.embedding)
+          && item.embedding.length === output.embeddings[0].embedding.length), 'invalid embedding batch');
+    },
+    compare(output, reference, policy) {
+      return output.embeddings.length === reference.embeddings.length
+        && output.embeddings.every((item, index) => closeVector(item.embedding, reference.embeddings[index].embedding, policy));
+    }
+  },
+  'rerank.v1': {
+    contractVersion: 1,
+    validateRequest({ input, options }) {
+      requireValue(text(input.query) && Array.isArray(input.documents) && input.documents.length > 0
+        && input.documents.every(text) && input.application && typeof input.application === 'object', 'rerank input and signed application required');
+    },
+    validateOutput(output, request) {
+      const evidence = output.evidence;
+      const count = request.input.documents.length;
+      requireValue(evidence?.schema === 'doppler_rerank_evidence/v1'
+        && Array.isArray(evidence.scores) && evidence.scores.length === count
+        && evidence.scores.every((item, index) => item.index === index && Number.isFinite(item.score))
+        && Array.isArray(evidence.ranking) && evidence.ranking.length === count
+        && new Set(evidence.ranking.map((item) => item.index)).size === count
+        && evidence.ranking.every((item, index) => Number.isSafeInteger(item.index) && item.index >= 0 && item.index < count
+          && item.rank === index + 1 && item.score === evidence.scores[item.index].score), 'invalid rerank output');
+    },
+    compare(output, reference, policy) {
+      return JSON.stringify(output.evidence.ranking.map((item) => item.index)) === JSON.stringify(reference.evidence.ranking.map((item) => item.index))
+        && closeVector(output.evidence.scores.map((item) => item.score), reference.evidence.scores.map((item) => item.score), policy);
+    }
+  },
+  'encodeSequence.v1': {
+    contractVersion: 1,
+    validateRequest({ input, options }) {
+      requireValue(text(input.sequence) && typeof options.includeTokenEmbeddings === 'boolean'
+        && typeof options.includeLogits === 'boolean', 'sequence and explicit output flags required');
+    },
+    validateOutput(output, request) {
+      requireValue(tokenIds(output.tokens) && output.tokens.length > 0
+        && Number.isSafeInteger(output.embeddingDim) && output.embeddingDim > 0
+        && vector(output.pooledEmbedding) && output.pooledEmbedding.length === output.embeddingDim, 'invalid sequence geometry');
+      requireValue(Array.isArray(output.tokenMask) && output.tokenMask.length === output.tokens.length
+        && output.tokenMask.every((value) => value === 0 || value === 1), 'invalid sequence token mask');
+      requireValue(request.options.includeTokenEmbeddings
+        ? vector(output.tokenEmbeddings) && output.tokenEmbeddings.length === output.tokens.length * output.embeddingDim
+        : output.tokenEmbeddings === null, 'sequence token output disagrees with requested outputs');
+      requireValue(request.options.includeLogits
+        ? Number.isSafeInteger(output.vocabSize) && output.vocabSize > 0 && vector(output.logits) && output.logits.length === output.tokens.length * output.vocabSize
+        : output.logits === null, 'sequence logits disagree with requested outputs');
+    },
+    compare(output, reference, policy) {
+      return JSON.stringify(output.tokens) === JSON.stringify(reference.tokens)
+        && JSON.stringify(output.tokenMask) === JSON.stringify(reference.tokenMask)
+        && ['pooledEmbedding', 'tokenEmbeddings', 'logits'].every((key) => output[key] === null || reference[key] === null
+          ? output[key] === reference[key] : closeVector(output[key], reference[key], policy));
+    }
+  }
+});
+
+export function createPackOperationRegistry({ definitions = poolConfig.operations,
+  comparisons = poolConfig.operationComparisonPolicies, implementations = PACK_OPERATION_IMPLEMENTATIONS } = {}) {
+  const resolved = resolvePackOperationDefinitions(definitions, comparisons);
+  const entries = Object.entries(resolved.definitions).map(([id, definition]) => {
+    const implementation = implementations[definition.adapterId] && Object.freeze({ ...implementations[definition.adapterId] });
+    requireValue(implementation && ['validateRequest', 'validateOutput', 'compare'].every(method => typeof implementation[method] === 'function'),
+      `unknown configured adapter ${definition.adapterId}`);
+    requireValue(['inputContract', 'optionsContract', 'outputContract'].every(name => definition[name].version === implementation.contractVersion),
+      `unsupported contract version for ${definition.adapterId}`);
+    const policy = Object.freeze({ definition, comparisons: Object.freeze(Object.fromEntries(
+      definition.comparisonPolicyIds.map(id => [id, resolved.comparisons[id]]))) });
+    const adapter = Object.freeze({ definition, policy, implementation, version: definition.version, workload: definition.workload,
+      validateRequest(request) {
+        assertOperationFields(request.input, definition.inputContract, 'input');
+        assertOperationFields(request.options, definition.optionsContract, 'options');
+        return implementation.validateRequest(request, definition);
+      },
+      validateOutput(output, request, context) { return implementation.validateOutput(output, request, context, definition); },
+      compare(output, reference, policy) {
+        requireValue(definition.comparisonPolicyIds.includes(policy.rule), 'comparison rule is outside configured operation policy');
+        const rule = resolved.comparisons[policy.rule];
+        for (const field of rule.requiredFields) requireValue(Object.hasOwn(policy, field), `${field} required`);
+        for (const field of rule.nonnegativeFields) requireValue(Number.isFinite(policy[field]) && policy[field] >= 0, `${field} must be finite and nonnegative`);
+        return implementation.compare(output, reference, policy, definition);
+      }
+    });
+    return [id, adapter];
+  });
+  return Object.freeze(Object.fromEntries(entries));
+}
+
+// Missing implementations and malformed checked-in definitions fail at module startup.
+createPackOperationRegistry();

package/shared/pool/pack-operation-policy.js

@@ -0,0 +1,75 @@
+/** Pure configuration validation. No execution, networking, or inferred policy. */
+import { DOPPLER_GENERATION_CONTRACT } from '../infrastructure/doppler-runtime-service.js';
+const assert = (ok, message) => { if (!ok) throw new Error(`Pack operation policy: ${message}`); };
+const identifier = value => typeof value === 'string' && /^[a-zA-Z][a-zA-Z0-9_.-]*$/.test(value);
+const strings = value => Array.isArray(value) && value.every(identifier) && new Set(value).size === value.length;
+const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+const positive = value => Number.isSafeInteger(value) && value > 0;
+const fieldTypes = Object.freeze({ 'positive-integer': positive, 'finite-number': Number.isFinite,
+  boolean: value => typeof value === 'boolean' });
+
+export function freezeOperationPolicy(value, depth = 0) {
+  assert(depth <= 64, 'configuration depth exceeded');
+  if (value === null || ['string', 'boolean'].includes(typeof value)) return value;
+  if (typeof value === 'number') { assert(Number.isFinite(value), 'non-finite configuration'); return value; }
+  assert(object(value) || Array.isArray(value), 'JSON configuration required');
+  assert(Array.isArray(value) || [Object.prototype, null].includes(Object.getPrototypeOf(value)), 'plain configuration required');
+  return Object.freeze(Array.isArray(value) ? value.map(child => freezeOperationPolicy(child, depth + 1))
+    : Object.fromEntries(Object.entries(value).map(([key, child]) => [key, freezeOperationPolicy(child, depth + 1)])));
+}
+
+export function resolvePackOperationDefinitions(definitions, comparisons) {
+  const resolved = freezeOperationPolicy(definitions), rules = freezeOperationPolicy(comparisons);
+  assert(object(resolved) && Object.keys(resolved).length > 0 && object(rules), 'operation definitions and comparison policies required');
+  for (const [id, rule] of Object.entries(rules)) {
+    assert(identifier(id) && object(rule) && strings(rule.requiredFields) && strings(rule.nonnegativeFields)
+      && rule.nonnegativeFields.every(field => rule.requiredFields.includes(field)), `invalid comparison policy ${id}`);
+  }
+  for (const [id, definition] of Object.entries(resolved)) {
+    assert(identifier(id) && definition.schema === 'reploid.pool.operation-definition/v1'
+      && positive(definition.version) && identifier(definition.adapterId) && identifier(definition.workload), `invalid definition ${id}`);
+    assert(definition.dopplerOperation?.name === id && definition.dopplerOperation.version === definition.version,
+      `${id}: operation aliases require an explicit Doppler contract; implicit renaming forbidden`);
+    for (const name of ['inputContract', 'optionsContract']) {
+      const contract = definition[name];
+      if (contract?.runtimeContract !== undefined) {
+        assert(id === 'generate' && positive(contract.version)
+          && contract.runtimeContract === DOPPLER_GENERATION_CONTRACT.schema
+          && Object.keys(contract).every(key => ['version', 'runtimeContract'].includes(key)), `${id}: invalid runtime-owned ${name}`);
+        continue;
+      }
+      assert(positive(contract?.version) && strings(contract.allowedFields) && strings(contract.requiredFields)
+        && contract.requiredFields.every(field => contract.allowedFields.includes(field)), `${id}: invalid ${name}`);
+      assert(object(contract.fieldTypes) && Object.entries(contract.fieldTypes).every(([field, type]) => contract.allowedFields.includes(field)
+        && Object.hasOwn(fieldTypes, type)), `${id}: unknown field type`);
+    }
+    assert(positive(definition.outputContract?.version) && typeof definition.streaming?.partial === 'boolean', `${id}: output and streaming contracts required`);
+    for (const field of ['maxInputBytes', 'maxOutputBytes', 'maxStreamBytes', 'maxEvents', 'maxJobMs']) {
+      assert(positive(definition.maximumLimits?.[field]), `${id}: maximumLimits.${field} required`);
+    }
+    assert(strings(definition.comparisonPolicyIds) && definition.comparisonPolicyIds.length > 0
+      && definition.comparisonPolicyIds.every(policyId => Object.hasOwn(rules, policyId)), `${id}: unknown comparison policy`);
+    assert(strings(definition.inputClasses?.local) && definition.inputClasses.local.length > 0 && strings(definition.inputClasses.remote)
+      && definition.inputClasses.remote.every(value => definition.inputClasses.local.includes(value)), `${id}: explicit input classes required`);
+    assert(definition.inputClasses.defaultRemote === null || definition.inputClasses.remote.includes(definition.inputClasses.defaultRemote), `${id}: explicit remote input class or null required`);
+  }
+  return Object.freeze({ definitions: resolved, comparisons: rules });
+}
+
+export function assertOperationFields(value, contract, name) {
+  if (contract.runtimeContract === DOPPLER_GENERATION_CONTRACT.schema) {
+    assert(object(value), `${name}: object required`);
+    return; // The operation adapter delegates input/options validation to Doppler.
+  }
+  assert(object(value) && Object.keys(value).every(field => contract.allowedFields.includes(field)), `${name}: unexpected input or option fields`);
+  for (const field of contract.requiredFields) assert(Object.hasOwn(value, field), `${name}.${field} required`);
+  for (const [field, type] of Object.entries(contract.fieldTypes)) {
+    if (Object.hasOwn(value, field)) assert(fieldTypes[type](value[field]), `${name}.${field}: ${type} required`);
+  }
+}
+
+export function assertOperationLimits(limits, definition) {
+  for (const [field, maximum] of Object.entries(definition.maximumLimits)) {
+    if (Object.hasOwn(limits, field)) assert(positive(limits[field]) && limits[field] <= maximum, `${field} exceeds configured operation limit`);
+  }
+}