reploid 0.0.0-stage → 0.1.0

package/packages/reploid/src/mesh/partitions/partition-step-receiver.js

@@ -0,0 +1,291 @@
+import canonicalPolicy from './partition-receiver-policy.json' with { type: 'json' };
+import { canonicalPartitionBinding, samePartitionIdentity, canonicalRouteAttemptBinding, sameRouteAttemptIdentity, canonicalPartitionJson } from './partition-contract.js';
+
+/** Receiver-side ordering/idempotency. Execution and verified identity remain host ports. */
+export function createPartitionStepReceiver({ executeStep, authorize, fingerprint, settleAttempt, limits, canonical, ordered }) {
+  for (const port of [executeStep, authorize, fingerprint, settleAttempt]) {
+    if (typeof port !== 'function') throw new Error('Partition receiver requires execution, authorization, digest and settlement ports');
+  }
+  if (!Number.isSafeInteger(limits?.maxAttempts) || limits.maxAttempts <= 0
+    || !Number.isSafeInteger(limits?.maxSteps) || limits.maxSteps <= 0) {
+    throw new Error('Explicit receiver attempt and step limits required');
+  }
+  if (ordered && canonical) throw new Error('Ordered canonical receiver is unsupported');
+  const orderedStage = ordered ? structuredClone(ordered.stage) : null;
+  if (ordered && (!Number.isSafeInteger(orderedStage?.index) || orderedStage.index < 0
+    || !['participantId', 'transportId', 'residentId', 'executionId'].every(key => typeof orderedStage[key] === 'string' && orderedStage[key]))) {
+    throw new Error('Explicit ordered receiver stage required');
+  }
+  const snapshotIdentity = value => {
+    if (!orderedStage) return canonicalPartitionBinding(value);
+    const binding = canonicalRouteAttemptBinding(value);
+    if (canonicalPartitionJson(binding.route.stages[orderedStage.index]) !== canonicalPartitionJson(orderedStage)) {
+      throw new Error('Ordered receiver stage differs from route');
+    }
+    return binding;
+  };
+  const sameIdentity = orderedStage ? sameRouteAttemptIdentity : samePartitionIdentity;
+  const { maxAttempts, maxSteps } = limits;
+  const attempts = new Map();
+  const operations = new Set();
+  let closed = false;
+  const canonicalAttempts = new Map();
+  const canonicalStage = canonical ? structuredClone(canonical.stage) : null;
+  const runtime = canonical?.runtime;
+  if (canonical && (typeof canonical.execute !== 'function' || typeof canonical.verifyPublication !== 'function' || typeof canonical.now !== 'function'
+    || !['metadataDigest', 'validateResidentAttemptIdentity', 'residentAttemptDigest'].every(name => typeof runtime?.[name] === 'function')
+    || canonicalStage?.partitionIndex !== 1)) throw new Error('Explicit canonical output-stage receiver ports required');
+  const canonicalError = (code, message) => Object.assign(new Error(message), { code });
+  const expired = () => canonicalError('RESULT_EXPIRED', 'Canonical result expired; never reexecute');
+  const controlBytes = value => {
+    runtime.metadataDigest('reploid.partition-control/v1', value);
+    const size = new TextEncoder().encode(JSON.stringify(value)).byteLength;
+    if (size > canonicalPolicy.maxControlBytes) throw new Error('Canonical control message budget exceeded');
+    return size;
+  };
+  const prune = state => {
+    const completed = [...state.completed.keys()];
+    while (completed.length) {
+      const sequence = completed[0];
+      if (completed.length <= canonicalPolicy.maxCompletedSequences
+        && canonical.now() - state.completed.get(sequence) < canonicalPolicy.maxRetentionMs) break;
+      completed.shift(); state.completed.delete(sequence);
+      for (const [key, record] of state.records) if (record.sequence === sequence && !record.pending) {
+        state.bytes -= record.bytes; state.records.delete(key);
+      }
+      state.retiredThrough = Math.max(state.retiredThrough, sequence);
+    }
+  };
+  const registerCanonical = (identity, attempt, digest) => {
+    if (attempts.has(identity.attemptId) || canonicalAttempts.size + attempts.size >= maxAttempts) {
+      throw new Error('Partition receiver attempt budget exhausted or identity collision');
+    }
+    const state = { identity, attempt, digest, records: new Map(), completed: new Map(), nextSequence: 0,
+      nextPosition: 0, admitted: false, terminal: false, awaitingPublication: null, retired: false, retiredThrough: -1,
+      bytes: 0, controller: new AbortController(), pending: null, settlement: null, settled: false };
+    canonicalAttempts.set(identity.attemptId, state); return state;
+  };
+  async function receiveCanonical(input, { signal } = {}) {
+    if (!canonical || closed) throw new Error('Canonical receiver unavailable or closed');
+    signal?.throwIfAborted();
+    const { payload, ...metadata } = input;
+    controlBytes(metadata);
+    const request = structuredClone(input);
+    request.identity = canonicalPartitionBinding(request.identity);
+    const attempt = runtime.validateResidentAttemptIdentity(request.canonicalAttempt);
+    if (attempt.routeKind !== 'two-stage-layer' || attempt.attemptId !== request.identity.attemptId
+      || attempt.stages[0].participantId !== request.identity.participantA || attempt.stages[1].participantId !== request.identity.participantB
+      || runtime.metadataDigest('reploid.partition-stage/v1', attempt.stages[1]) !== runtime.metadataDigest('reploid.partition-stage/v1', canonicalStage)
+      || request.generationId !== attempt.generationId || !['admit', 'step', 'published'].includes(request.phase)
+      || !Number.isSafeInteger(request.sequence) || request.sequence < 0 || request.sequence >= maxSteps
+      || request.step !== request.sequence || !Number.isSafeInteger(request.tokenPosition) || request.tokenPosition < 0
+      || !Number.isSafeInteger(request.inputTokenCount) || request.inputTokenCount <= 0
+      || request.phase === 'admit' && (request.sequence !== 0 || request.tokenPosition !== 0)) {
+      throw new Error('Invalid canonical receiver binding');
+    }
+    const attemptDigest = runtime.residentAttemptDigest(attempt);
+    const operation = (async () => {
+      await permit(request); signal?.throwIfAborted();
+      const digest = await fingerprint(structuredClone(request));
+      if (!/^sha256:[a-f0-9]{64}$/.test(digest)) throw new Error('Partition input fingerprint required');
+      signal?.throwIfAborted();
+      if (closed) throw new Error('Partition receiver closed');
+      let state = canonicalAttempts.get(attempt.attemptId);
+      if (!state) {
+        if (request.phase !== 'admit') throw new Error('Canonical attempt must start with admission');
+        state = registerCanonical(request.identity, attempt, attemptDigest);
+      }
+      if (state.digest !== attemptDigest || !samePartitionIdentity(state.identity, request.identity)) throw new Error('Canonical attempt identity collision');
+      if (state.retired) throw new Error('Canonical attempt retired');
+      prune(state);
+      if (request.sequence <= state.retiredThrough) throw expired();
+      const key = `${request.sequence}:${request.phase}`;
+      let record = state.records.get(key);
+      if (record) {
+        if (record.digest !== digest) throw new Error('Canonical phase payload collision');
+      } else {
+        const publication = request.phase === 'published';
+        if (!publication && (state.terminal || request.sequence < state.nextSequence)) throw expired();
+        if (state.pending || (publication ? state.awaitingPublication !== request.sequence
+          : state.awaitingPublication !== null || request.sequence !== state.nextSequence || request.tokenPosition !== state.nextPosition
+            || request.phase === 'admit' && state.admitted || request.phase === 'step' && !state.admitted
+            || request.sequence > 0 && request.inputTokenCount !== 1)) throw new Error('Out-of-order canonical phase');
+        record = { sequence: request.sequence, digest, pending: true, bytes: 0, result: null };
+        state.records.set(key, record);
+        const combined = signal ? AbortSignal.any([signal, state.controller.signal]) : state.controller.signal;
+        record.result = (async () => {
+          try {
+            await permit(request); combined.throwIfAborted();
+            let result;
+            if (publication) {
+              const retained = state.records.get(`${request.sequence}:${state.terminal && state.nextSequence === 0 ? 'admit' : 'step'}`);
+              const original = await retained.result;
+              if (await canonical.verifyPublication(structuredClone(request), structuredClone(original)) !== true) {
+                throw new Error('Canonical publication acknowledgment rejected');
+              }
+              result = structuredClone(request.receipt);
+            } else result = structuredClone(await canonical.execute(structuredClone(request), { signal: combined }));
+            combined.throwIfAborted(); record.bytes = controlBytes(result);
+            if (state.bytes + record.bytes > canonicalPolicy.maxRetainedBytes) throw new Error('Canonical retained control budget exceeded');
+            state.bytes += record.bytes;
+            if (publication) {
+              state.awaitingPublication = null; state.completed.set(request.sequence, canonical.now());
+            } else if (request.phase === 'admit') {
+              state.admitted = true; state.terminal = !Object.hasOwn(result, 'kind');
+              if (state.terminal) state.awaitingPublication = request.sequence;
+            } else {
+              state.nextSequence++; state.nextPosition += request.inputTokenCount;
+              state.terminal = result.transition?.successor?.terminal === true;
+              state.awaitingPublication = request.sequence;
+            }
+            return result;
+          } catch (error) { state.retired = true; throw error; }
+          finally { record.pending = false; state.pending = null; prune(state); }
+        })();
+        state.pending = record.result;
+      }
+      const result = await record.result;
+      signal?.throwIfAborted(); await permit(request);
+      if (state.retired) throw new Error('Canonical attempt retired');
+      prune(state);
+      if (!state.records.has(key)) throw expired();
+      return structuredClone(result);
+    })();
+    operations.add(operation);
+    try { return await operation; } finally { operations.delete(operation); }
+  }
+  function closeCanonical(state) {
+    if (state.settlement) return state.settlement;
+    if (state.settled) return Promise.resolve();
+    state.retired = true; state.controller.abort(new Error('Canonical attempt closed'));
+    const operation = (async () => {
+      await state.pending?.catch(() => {});
+      await settleAttempt(structuredClone(state.identity));
+      state.records.clear(); state.completed.clear(); state.bytes = 0; state.settled = true;
+    })();
+    state.settlement = operation;
+    operation.finally(() => { if (state.settlement === operation) state.settlement = null; }).catch(() => {});
+    return operation;
+  }
+  const registerAttempt = identity => {
+    if (canonicalAttempts.has(identity.attemptId) || attempts.size + canonicalAttempts.size >= maxAttempts) throw new Error('Partition receiver attempt budget exhausted');
+    const state = { identity: snapshotIdentity(identity), nextStep: 0, nextPosition: 0, maxTokens: null,
+      last: null, retired: false, controller: new AbortController(), settlement: null };
+    attempts.set(identity.attemptId, state);
+    return state;
+  };
+  const permit = async request => {
+    if (closed || await authorize(structuredClone(request)) !== true) throw new Error('Partition receiver authorization declined');
+    if (closed) throw new Error('Partition receiver closed');
+  };
+
+  async function receive(input, { signal } = {}) {
+    signal?.throwIfAborted();
+    if (closed) throw new Error('Partition receiver closed');
+    // Host ingress validates payload shape/byte budgets before this copy or hashing.
+    const request = structuredClone(input);
+    request.identity = snapshotIdentity(request.identity);
+    if (orderedStage && request.partitionIndex !== orderedStage.index) throw new Error('Ordered receiver stage mismatch');
+    if (!Number.isSafeInteger(request.step) || request.step < 0 || request.step >= maxSteps
+      || !Number.isSafeInteger(request.maxTokens) || request.maxTokens <= 0 || request.step >= request.maxTokens
+      || !Number.isSafeInteger(request.tokenPosition) || request.tokenPosition < 0
+      || !Number.isSafeInteger(request.inputTokenCount) || request.inputTokenCount <= 0) {
+      throw new Error('Invalid partition step binding');
+    }
+    const operation = (async () => {
+      await permit(request);
+      signal?.throwIfAborted();
+      const digest = await fingerprint(structuredClone(request));
+      if (!/^sha256:[a-f0-9]{64}$/.test(digest)) throw new Error('Partition input fingerprint required');
+      signal?.throwIfAborted();
+      if (closed) throw new Error('Partition receiver closed');
+      const key = request.identity.attemptId;
+      let state = attempts.get(key);
+      if (!state) {
+        if (request.step !== 0 || request.tokenPosition !== 0) throw new Error('Partition attempt must start with prefill');
+        state = registerAttempt(request.identity);
+        state.maxTokens = request.maxTokens;
+      }
+      if (!sameIdentity(state.identity, request.identity)) throw new Error('Partition attempt identity collision');
+      if (state.retired) throw new Error('Partition attempt retired; start a new attempt');
+      if (state.maxTokens !== request.maxTokens) throw new Error('Partition request token limit changed');
+      if (state.last?.step === request.step) {
+        if (state.last.digest !== digest) throw new Error('Partition step payload collision');
+      } else {
+        if (state.last?.pending || request.step !== state.nextStep || request.tokenPosition !== state.nextPosition) {
+          throw new Error('Out-of-order partition step');
+        }
+        if (request.step > 0 && request.inputTokenCount !== 1) throw new Error('Decode consumes one token');
+        const current = { step: request.step, digest, pending: true, result: null };
+        state.last = current;
+        const combined = signal ? AbortSignal.any([signal, state.controller.signal]) : state.controller.signal;
+        current.result = (async () => {
+          try {
+            await permit(request);
+            combined.throwIfAborted();
+            const result = await executeStep(structuredClone(request), { signal: combined });
+            combined.throwIfAborted();
+            state.nextStep++;
+            state.nextPosition += request.inputTokenCount;
+            return structuredClone(result);
+          } catch (error) {
+            // A failed compute may already have mutated KV state. Never run it again.
+            state.retired = true;
+            throw error;
+          } finally { current.pending = false; }
+        })();
+      }
+      const result = await state.last.result;
+      signal?.throwIfAborted();
+      // A replay still requires current disclosure permission.
+      await permit(request);
+      if (state.retired) throw new Error('Partition attempt retired');
+      return structuredClone(result);
+    })();
+    operations.add(operation);
+    try { return await operation; } finally { operations.delete(operation); }
+  }
+
+  function closeAttempt(identity) {
+    try { identity = snapshotIdentity(identity); }
+    catch (error) { return Promise.reject(error); }
+    const canonicalState = canonicalAttempts.get(identity.attemptId);
+    if (canonicalState) {
+      if (!samePartitionIdentity(canonicalState.identity, identity)) return Promise.reject(new Error('Partition settlement identity collision'));
+      return closeCanonical(canonicalState);
+    }
+    let state = attempts.get(identity.attemptId);
+    if (!state) {
+      if (closed) return Promise.resolve();
+      try { state = registerAttempt(identity); }
+      catch (error) { return Promise.reject(error); }
+      // Cancellation may overtake the first step's authorization or hashing.
+      // Keep a bounded tombstone so that delayed ingress cannot acquire state.
+      state.retired = true;
+      state.settlement = Promise.resolve();
+      return state.settlement;
+    }
+    if (!sameIdentity(state.identity, identity)) {
+      return Promise.reject(new Error('Partition settlement identity collision'));
+    }
+    if (state.settlement) return state.settlement;
+    state.retired = true;
+    state.controller.abort(new Error('Partition attempt closed'));
+    state.settlement = (async () => {
+      await state.last?.result?.catch(() => {});
+      try { await settleAttempt(structuredClone(state.identity)); }
+      finally { state.last = null; }
+    })().catch(error => { state.settlement = null; throw error; });
+    return state.settlement;
+  }
+
+  return Object.freeze({ receive, receiveCanonical, closeAttempt,
+    async close() {
+      closed = true;
+      const results = await Promise.allSettled([...attempts.values(), ...canonicalAttempts.values()].map(state => closeAttempt(state.identity)));
+      await Promise.allSettled([...operations]);
+      const failures = results.filter(result => result.status === 'rejected').map(result => result.reason);
+      if (failures.length) throw new AggregateError(failures, 'Partition receiver settlement failed');
+    }
+  });
+}

package/packages/reploid/src/mesh/partitions/partition-summary.js

@@ -0,0 +1,122 @@
+import { canonicalRouteAttemptBinding, sameRouteAttemptIdentity } from './partition-contract.js';
+
+// Doppler resident stage metrics (PartitionTiming plus execution, readback and
+// sampling). Contributors report them; only finite non-negative numbers count.
+const STAGE_RUNTIME_KEYS = Object.freeze(['executionMs', 'inputUploadMs', 'encodeMs', 'submitWaitMs',
+  'activationReadbackMs', 'logitsMs', 'gpuKernelsMs', 'logitsReadbackMs', 'samplingMs']);
+const measuredMs = value => typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : null;
+
+/** Step 0 carries the whole prompt (prefill and the first sampled token); later
+ * steps decode one token each. Keep them apart so prompt length, prefill and
+ * decode are never averaged together. */
+function summarizeOrderedPhases(steps) {
+  const aggregate = () => ({ count: 0, total: 0, min: null, max: null });
+  const add = (row, value) => {
+    if (value === null) return;
+    row.count++; row.total += value;
+    row.min = row.min === null ? value : Math.min(row.min, value); row.max = row.max === null ? value : Math.max(row.max, value);
+  };
+  const first = steps[0];
+  const prompt = first ? { inputTokens: Number.isSafeInteger(first.inputTokenCount) ? first.inputTokenCount : null,
+    stages: (first.stages || []).map(stage => ({ partitionIndex: stage.partitionIndex, elapsedMs: measuredMs(stage.elapsedMs),
+      runtime: Object.fromEntries(STAGE_RUNTIME_KEYS.map(key => [key, measuredMs(stage.metrics?.[key])])) })) } : null;
+  const decodeStages = new Map();
+  for (const step of steps.slice(1)) for (const stage of step.stages || []) {
+    const row = decodeStages.get(stage.partitionIndex) || { partitionIndex: stage.partitionIndex, elapsedMs: aggregate(),
+      runtime: Object.fromEntries(STAGE_RUNTIME_KEYS.map(key => [key, aggregate()])) };
+    add(row.elapsedMs, measuredMs(stage.elapsedMs));
+    for (const key of STAGE_RUNTIME_KEYS) add(row.runtime[key], measuredMs(stage.metrics?.[key]));
+    decodeStages.set(stage.partitionIndex, row);
+  }
+  return { prompt, decode: { steps: Math.max(steps.length - 1, 0), stages: [...decodeStages.values()] } };
+}
+
+/** Fixed-size timing projection for a completed requester response. Detailed
+ * per-step observations belong to the executing runner, not its control frame. */
+export function summarizePartitionExecution(execution) {
+  if (execution.schema === 'reploid.mesh.partition-execution/v3') {
+    const stages = new Map();
+    for (const step of execution.steps || []) for (const stage of step.stages || []) {
+      const row = stages.get(stage.partitionIndex) || { partitionIndex: stage.partitionIndex, steps: 0,
+        stepMs: { count: 0, total: 0 } };
+      if (Number.isFinite(stage.elapsedMs) && stage.elapsedMs >= 0) {
+        row.stepMs.count++; row.stepMs.total += stage.elapsedMs;
+      }
+      row.steps++; stages.set(stage.partitionIndex, row);
+    }
+    return structuredClone({ schema: 'reploid.mesh.partition-summary/v2', identity: execution.identity,
+      activationBytes: execution.activationBytes, stopReason: execution.stopReason, settlement: execution.settlement,
+      stepSummary: { count: execution.steps?.length || 0, stages: [...stages.values()],
+        phases: summarizeOrderedPhases(execution.steps || []), detail: 'aggregate; no per-step trace transferred' },
+      // A ranking coordinator's unsigned record of the decision that chose this attempt's route.
+      ...(execution.routeSelection ? { routeSelection: execution.routeSelection } : {}),
+      // The coordinator's unsigned admission wait, kept apart from prefill and decode timing.
+      ...(Number.isFinite(execution.admission?.queuedMs) ? { admission: { queuedMs: execution.admission.queuedMs } } : {}) });
+  }
+  if (execution.schema === 'reploid.mesh.canonical-partition-execution/v1') {
+    // Signed records are already retained by the requester transaction owner.
+    // Do not transfer the full history again in a bounded final control frame.
+    const { publications: _publications, ...summary } = execution;
+    execution = summary;
+  }
+  if (!Array.isArray(execution.steps)) return structuredClone(execution);
+  const { steps, transport, ...binding } = execution;
+  const metrics = {};
+  const add = (name, value) => {
+    if (typeof value !== 'number' || !Number.isFinite(value)) return;
+    const row = metrics[name] ||= { count: 0, total: 0, min: value, max: value };
+    row.count++; row.total += value; row.min = Math.min(row.min, value); row.max = Math.max(row.max, value);
+  };
+  for (const step of steps) {
+    for (const key of ['leaseWaitMs', 'outputDeliveryMs', 'localStepMs', 'serializationMs',
+      'transferMs', 'remoteStepMs', 'elapsedMs']) add(key, step[key]);
+    for (const owner of ['computationA', 'computationB']) {
+      for (const key of ['inputUploadMs', 'encodeMs', 'submitWaitMs', 'activationReadbackMs', 'logitsMs',
+        'gpuKernelsMs', 'executionMs', 'logitsReadbackMs', 'samplingMs']) {
+        add(`${owner}.${key}`, step[owner]?.[key]);
+      }
+    }
+    for (const key of ['authorizationMs', 'readyWaitMs', 'payloadUploadMs', 'responseWaitMs', 'acceptanceMs', 'totalMs']) {
+      add(`transportTiming.${key}`, step.transportTiming?.[key]);
+    }
+  }
+  const { lastFailure: _localFailure, ...delivery } = transport || {};
+  const memoryAtLastStep = {};
+  const number = value => typeof value === 'number' && Number.isFinite(value) ? value : null;
+  for (const owner of ['computationA', 'computationB']) {
+    const memory = steps.at(-1)?.[owner]?.memory;
+    if (memory) memoryAtLastStep[owner] = {
+      maxBytes: number(memory.maxBytes), liveBytes: number(memory.liveBytes), peakBytes: number(memory.peakBytes),
+      categories: Object.fromEntries(['weights', 'attention', 'recurrent', 'other'].map(key => [key, number(memory.categories?.[key])]))
+    };
+  }
+  return { ...structuredClone(binding), schema: 'reploid.mesh.partition-summary/v1',
+    stepSummary: { count: steps.length, metrics, detail: 'aggregate; no per-step trace transferred' },
+    memoryAtLastStep, transport: delivery };
+}
+
+/** Bounded completed-token observations measured on the coordinator clock.
+ * These describe execution only; they are never text or publication records. */
+export function partitionActivity(value, identity, previous = null, coalesced = false) {
+  const fail = () => { throw new Error('Invalid or out-of-order partition activity'); };
+  const expected = canonicalRouteAttemptBinding(identity);
+  if (!value || value.schema !== 'reploid.partition-activity/v1'
+    || !sameRouteAttemptIdentity(value.identity, expected)
+    || (coalesced ? value.sequence < (previous ? previous.sequence + 1 : 0)
+      : value.sequence !== (previous ? previous.sequence + 1 : 0))) fail();
+  const summary = value.stepSummary;
+  if (!Number.isSafeInteger(value.sequence) || value.sequence < 0
+    || !Number.isSafeInteger(summary?.count) || summary.count !== value.sequence + 1 || !Array.isArray(summary.stages)
+    || summary.stages.length !== expected.route.stages.length) fail();
+  let measuredTotal = 0;
+  const stages = summary.stages.map((row, index) => {
+    if (row.partitionIndex !== index || row.steps !== summary.count
+      || row.stepMs?.count !== summary.count || !Number.isFinite(row.stepMs.total) || row.stepMs.total < 0
+      || previous && row.stepMs.total < previous.stepSummary.stages[index].stepMs.total) fail();
+    measuredTotal += row.stepMs.total;
+    if (!Number.isFinite(measuredTotal)) fail();
+    return { partitionIndex: index, steps: row.steps, stepMs: { count: row.stepMs.count, total: row.stepMs.total } };
+  });
+  return { schema: 'reploid.partition-activity/v1', identity: expected, sequence: value.sequence,
+    stepSummary: { count: summary.count, stages } };
+}

package/packages/reploid/src/mesh/partitions/preparation-owner.js

@@ -0,0 +1,40 @@
+/** Retain preparation resources until each close succeeds; failed closes remain retryable. */
+export function createPartitionPreparationOwner({ source, registerCleanup, onSettled = () => {}, errorMessage = 'Partition preparation cleanup failed' }) {
+  let resident = null, release = null, commitAuthority = null, cleaning = null;
+  let sourceSettled = false, releaseSettled = false, residentSettled = false;
+  const sessions = new Set();
+  const closeSources = async failures => {
+    if (!sourceSettled) {
+      try { await source.storage.close(); sourceSettled = true; } catch (error) { failures.push(error); }
+    }
+    if (release && !releaseSettled) {
+      try { await release.close(); releaseSettled = true; } catch (error) { failures.push(error); }
+    }
+  };
+  const owner = {
+    set resident(value) { resident = value; },
+    set release(value) { release = value; },
+    set commitAuthority(value) { commitAuthority = value; },
+    closeSources,
+    trackSession(session) { sessions.add(session); return () => sessions.delete(session); },
+    close() {
+      return cleaning ||= (async () => {
+        const failures = [];
+        try { await commitAuthority?.close(); } catch (error) { failures.push(error); }
+        if (!residentSettled) {
+          try { await resident?.close(); residentSettled = true; } catch (error) { failures.push(error); }
+        }
+        for (const session of sessions) {
+          try { await session.close(); sessions.delete(session); } catch (error) { failures.push(error); }
+        }
+        await closeSources(failures);
+        if (failures.length === 1) throw failures[0];
+        if (failures.length) throw new AggregateError(failures, errorMessage);
+        await onSettled();
+        releaseCleanup?.();
+      })().catch(error => { cleaning = null; throw error; });
+    }
+  };
+  const releaseCleanup = registerCleanup?.(owner);
+  return owner;
+}

package/packages/reploid/src/mesh/partitions/resident-error-codes.json

@@ -0,0 +1,10 @@
+{
+  "codes": {
+    "DOPPLER_RESIDENT_OUTPUT_LIMIT": "OUTPUT_LIMIT_EXCEEDED",
+    "DOPPLER_GENERATION_OUTPUT_INVALID": "GENERATION_OUTPUT_INVALID",
+    "DOPPLER_GPU_OOM": "RESOURCE_EXHAUSTED"
+  },
+  "legacyMessages": {
+    "Resident output exceeds its character allocation.": "OUTPUT_LIMIT_EXCEEDED"
+  }
+}