reploid 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,277 @@
+import { createPeerIdFromPublicJwk, importSigningKey, importVerificationKey, getIdentitySignAlgorithm,
+  toBase64Url, fromBase64Url } from '../../artifacts/identity.js';
+import { assertPartition as assert, canonicalPartitionJson, validatePartitionIdentity,
+  samePartitionIdentity, partitionActions, partitionIdentityKeys, canonicalRouteAttemptBinding, sameRouteAttemptIdentity } from './partition-contract.js';
+
+const SCHEMA = 'reploid.partition-grant/v2';
+const CANONICAL_SCHEMA = 'reploid.partition-grant/v3';
+const ORDERED_SCHEMA = 'reploid.partition-grant/v4';
+const bytes = value => new TextEncoder().encode(canonicalPartitionJson(value));
+const bounds = ['maxTokens', 'maxPromptTokens', 'maxActivationBytes', 'maxOutputCharacters'];
+
+/** Explicit disclosure closure for the ordinary stage-zero coordinator path. */
+export function orderedPartitionDisclosure(identity) {
+  const binding = canonicalRouteAttemptBinding(identity), stages = binding.route.stages;
+  const coordinator = stages[0].participantId, unique = values => [...new Set(values)];
+  return { kind: 'coordinator-mediated-activations-and-tokens',
+    activationPaths: stages.slice(1).map((stage, index) => unique([stages[index].participantId, coordinator, stage.participantId])),
+    tokenRecipients: stages.map(stage => stage.participantId),
+    outputRecipients: unique([stages.at(-1).participantId, coordinator, binding.requesterId]) };
+}
+
+/** The host calls issue only after disclosure approval. B separately consents by preparing its resident. */
+export function createPartitionGrantAuthority({ identity, meshId, maxGrants, maxTtlMs, maxClockSkewMs = 0, now = Date.now, canonicalRuntime }) {
+  assert(identity?.privateJwk && identity?.publicJwk && typeof meshId === 'string' && meshId
+    && Number.isSafeInteger(maxGrants) && maxGrants > 0 && Number.isSafeInteger(maxTtlMs) && maxTtlMs > 0
+    && Number.isSafeInteger(maxClockSkewMs) && maxClockSkewMs >= 0,
+  'Explicit partition signing identity, mesh and grant budgets required');
+  const signer = structuredClone(identity);
+  const issued = new Map();
+  let closed = false;
+  // Signatures already verified, keyed by signature and bound to the exact canonical grant record.
+  // Later checks of the same grant skip only the key derivation, import and signature verification;
+  // binding, scope, expiry and revocation are evaluated on every call. Bounded like issuance.
+  const verified = new Map();
+  const OK = Object.freeze({ ok: true, reason: null });
+  const refused = reason => ({ ok: false, reason });
+  const DECLINED = Object.freeze(refused('declined'));
+  async function signatureValid(record, signerId, signed) {
+    const json = canonicalPartitionJson(record);
+    const known = verified.get(record.signature);
+    if (known?.json === json && known.signerId === signerId) return true;
+    if (await createPeerIdFromPublicJwk(record.publicJwk) !== signerId) return false;
+    const key = await importVerificationKey(record.publicJwk);
+    if (!await crypto.subtle.verify(getIdentitySignAlgorithm(record.publicJwk), key, fromBase64Url(record.signature), signed)) return false;
+    const at = now();
+    for (const [signature, entry] of verified) if (entry.expiresAt <= at) verified.delete(signature);
+    while (verified.size >= maxGrants) verified.delete(verified.keys().next().value);
+    verified.set(record.signature, { json, signerId, expiresAt: record.claim.expiresAt });
+    return true;
+  }
+  // Expiry and revocation are re-evaluated after the asynchronous signature check.
+  const current = (claim, settlement) => closed ? DECLINED : settlement ? OK
+    : issued.get(claim.id)?.revoked === true ? refused('revoked') : claim.expiresAt <= now() ? refused('expired') : OK;
+  const canonicalCapability = () => assert(['metadataDigest', 'canonicalGenerationIdentity', 'validateResidentAttemptIdentity', 'residentAttemptDigest']
+    .every(method => typeof canonicalRuntime?.[method] === 'function'), 'Canonical Doppler grant capability required');
+  const exact = (value, keys) => assert(value && typeof value === 'object' && !Array.isArray(value)
+    && Object.keys(value).length === keys.length && keys.every(key => Object.hasOwn(value, key)), 'Invalid canonical grant fields');
+  const canonicalDigest = value => canonicalRuntime.metadataDigest(CANONICAL_SCHEMA, value);
+  const canonicalBytes = value => new TextEncoder().encode(canonicalDigest(value));
+  const canonicalScope = ({ identity: binding, limits, disclosure, generationId }) => {
+    canonicalCapability(); validatePartitionIdentity(binding);
+    exact(binding, [...partitionIdentityKeys, 'requesterId', 'placementGeneration']);
+    assert(typeof binding.requesterId === 'string' && bounds.every(key => Number.isSafeInteger(limits?.[key]) && limits[key] > 0)
+      && disclosure === 'partition-activations-and-tokens' && /^sha256:[a-f0-9]{64}$/.test(generationId),
+    'Explicit canonical route, disclosure and allocation required');
+    return canonicalRuntime.metadataDigest('reploid.partition-authorization/v1', { meshId, identity: binding,
+      limits: Object.fromEntries(bounds.map(key => [key, limits[key]])), disclosure, generationId });
+  };
+  const canonicalClaim = claim => {
+    canonicalCapability();
+    canonicalDigest(claim);
+    exact(claim, ['schema', 'id', 'meshId', 'identity', 'canonicalAttempt', 'generation', 'vocabSize',
+      'disclosure', 'issuedAt', 'expiresAt', 'limits']);
+    exact(claim.limits, bounds); exact(claim.generation, ['policy', 'executionIdentity', 'generationId']);
+    assert(claim.schema === CANONICAL_SCHEMA && claim.meshId === meshId, 'Canonical grant scope mismatch');
+    const generation = canonicalRuntime.canonicalGenerationIdentity(claim.generation.policy,
+      claim.generation.executionIdentity, claim.vocabSize);
+    assert(canonicalDigest(generation) === canonicalDigest(claim.generation), 'Canonical generation identity mismatch');
+    const attempt = canonicalRuntime.validateResidentAttemptIdentity(claim.canonicalAttempt);
+    assert(attempt.attemptId === claim.identity.attemptId && attempt.requesterId === claim.identity.requesterId
+      && attempt.generationId === generation.generationId && attempt.routeKind === 'two-stage-layer'
+      && attempt.stages[0].participantId === claim.identity.participantA
+      && attempt.stages[1].participantId === claim.identity.participantB
+      && attempt.stages.every(stage => stage.executionId === generation.executionIdentity), 'Canonical attempt route binding mismatch');
+    assert(attempt.authorizationScope === canonicalScope({ ...claim, generationId: generation.generationId }),
+      'Canonical authorization scope mismatch');
+    assert(generation.policy.maxGeneratedTokens <= claim.limits.maxTokens
+      && generation.policy.maxRawOutputUtf16 <= claim.limits.maxOutputCharacters
+      && generation.policy.maxVisibleOutputUtf16 <= claim.limits.maxOutputCharacters,
+    'Canonical generation exceeds grant allocation');
+    assert(typeof claim.id === 'string' && claim.id.length > 0 && claim.id.length <= 128
+      && Number.isSafeInteger(claim.issuedAt) && claim.issuedAt >= 0 && Number.isSafeInteger(claim.expiresAt)
+      && claim.issuedAt <= now() + maxClockSkewMs && claim.expiresAt > claim.issuedAt
+      && claim.expiresAt - claim.issuedAt <= maxTtlMs, 'Invalid canonical grant lifetime');
+    return { generation, attempt };
+  };
+  async function checkCanonical(grant, request, settlement) {
+    try {
+      if (closed) return DECLINED;
+      canonicalCapability(); canonicalDigest({ grant, request });
+      const record = structuredClone(grant), input = structuredClone(request), claim = record.claim;
+      exact(record, ['claim', 'publicJwk', 'signature']);
+      const { generation, attempt } = canonicalClaim(claim);
+      const requested = canonicalRuntime.validateResidentAttemptIdentity(input.canonicalAttempt);
+      if (!samePartitionIdentity(claim.identity, input.identity)
+        || canonicalRuntime.residentAttemptDigest(attempt) !== canonicalRuntime.residentAttemptDigest(requested)) return DECLINED;
+      if (!settlement) {
+        if (input.generationId !== generation.generationId || !partitionActions.includes(input.action)
+          || !['admit', 'step'].includes(input.phase) || !Number.isSafeInteger(input.step) || input.step < 0
+          || !Number.isSafeInteger(input.inputTokenCount) || input.inputTokenCount < 1
+          || input.inputTokenCount > (input.step === 0 ? Math.min(claim.limits.maxPromptTokens,
+            generation.policy.materializedInputCapacity, generation.policy.totalAcceptedTokenLimit) : 1)
+          || input.phase === 'admit' && (input.step !== 0 || input.activationBytes != null && input.activationBytes !== 0)
+          || input.phase === 'step' && input.step >= generation.policy.maxGeneratedTokens
+          || input.activationBytes != null && (!Number.isSafeInteger(input.activationBytes)
+            || input.activationBytes < 0 || input.activationBytes > claim.limits.maxActivationBytes)) return DECLINED;
+      }
+      if (!await signatureValid(record, claim.identity.participantA, canonicalBytes(claim))) return DECLINED;
+      return current(claim, settlement);
+    } catch { return DECLINED; }
+  }
+  const orderedClaim = claim => {
+    exact(claim, ['schema', 'id', 'meshId', 'identity', 'coordinatorId', 'disclosure', 'generationDigest', 'issuedAt', 'expiresAt', 'limits']);
+    const binding = canonicalRouteAttemptBinding(claim.identity);
+    exact(claim.limits, bounds);
+    assert(claim.schema === ORDERED_SCHEMA && claim.meshId === meshId
+      && claim.coordinatorId === binding.route.stages[0].participantId
+      && canonicalPartitionJson(claim.disclosure) === canonicalPartitionJson(orderedPartitionDisclosure(binding)),
+    'Explicit ordered route disclosure mismatch');
+    assert(typeof claim.id === 'string' && claim.id.length > 0 && claim.id.length <= 128
+      && /^sha256:[a-f0-9]{64}$/.test(claim.generationDigest)
+      && bounds.every(key => Number.isSafeInteger(claim.limits[key]) && claim.limits[key] > 0)
+      && Number.isSafeInteger(claim.issuedAt) && claim.issuedAt >= 0 && Number.isSafeInteger(claim.expiresAt)
+      && claim.issuedAt <= now() + maxClockSkewMs && claim.expiresAt > claim.issuedAt
+      && claim.expiresAt - claim.issuedAt <= maxTtlMs, 'Invalid ordered grant allocation or lifetime');
+    return binding;
+  };
+  async function checkOrdered(grant, request, settlement) {
+    try {
+      if (closed) return DECLINED;
+      const record = structuredClone(grant), claim = record.claim;
+      // Host authorization calls also carry borrowed AbortSignals/ports. Snapshot
+      // only the signed protocol inputs, before any asynchronous verification.
+      const input = structuredClone(Object.fromEntries(['identity', 'coordinatorId', 'action', 'partitionIndex',
+        'fromStage', 'toStage', 'recipients', 'step', 'inputTokenCount', 'activationBytes', 'generationDigest']
+        .filter(key => Object.hasOwn(request, key)).map(key => [key, request[key]])));
+      exact(record, ['claim', 'publicJwk', 'signature']);
+      const binding = orderedClaim(claim), stages = binding.route.stages;
+      if (!sameRouteAttemptIdentity(binding, input.identity) || input.coordinatorId !== claim.coordinatorId) return DECLINED;
+      const validStage = Number.isSafeInteger(input.partitionIndex) && input.partitionIndex >= 0 && input.partitionIndex < stages.length;
+      if (settlement) {
+        if (input.action !== 'mesh.execute_partition_stage' || !validStage) return DECLINED;
+      } else {
+        if (input.generationDigest !== claim.generationDigest || !Number.isSafeInteger(input.step)
+          || input.step < 0 || input.step >= claim.limits.maxTokens || !Number.isSafeInteger(input.inputTokenCount)
+          || input.inputTokenCount < 1 || input.inputTokenCount > (input.step === 0 ? claim.limits.maxPromptTokens : 1)
+          || input.activationBytes != null && (!Number.isSafeInteger(input.activationBytes)
+            || input.activationBytes < 0 || input.activationBytes > claim.limits.maxActivationBytes)) return DECLINED;
+        let recipients;
+        if (input.action === 'mesh.execute_partition_stage') { if (!validStage) return DECLINED; }
+        else if (input.action === 'mesh.transfer_token_context') {
+          if (!validStage) return DECLINED;
+          recipients = [...new Set([claim.coordinatorId, stages[input.partitionIndex].participantId])];
+        } else if (input.action === 'mesh.transfer_intermediate_activation') {
+          if (!Number.isSafeInteger(input.fromStage) || input.fromStage < 0 || input.toStage !== input.fromStage + 1
+            || input.toStage >= stages.length) return DECLINED;
+          recipients = claim.disclosure.activationPaths[input.fromStage];
+        } else if (input.action === 'mesh.transfer_partition_output') {
+          if (input.partitionIndex !== stages.length - 1) return DECLINED;
+          recipients = claim.disclosure.outputRecipients;
+        } else return DECLINED;
+        if (recipients && canonicalPartitionJson(input.recipients) !== canonicalPartitionJson(recipients)) return DECLINED;
+      }
+      if (!await signatureValid(record, claim.coordinatorId, bytes(claim))) return DECLINED;
+      return current(claim, settlement);
+    } catch { return DECLINED; }
+  }
+  /** `{ ok, reason }`: reason is 'expired', 'revoked' or 'declined' (any other mismatch) when refused. */
+  async function check(grant, request, { settlement = false } = {}) {
+    if (grant?.claim?.schema === ORDERED_SCHEMA) return checkOrdered(grant, request, settlement);
+    if (grant?.claim?.schema === CANONICAL_SCHEMA) return checkCanonical(grant, request, settlement);
+    try {
+      if (closed) return DECLINED;
+      validatePartitionIdentity(request.identity);
+      const record = structuredClone(grant), claim = record.claim;
+      if (claim?.schema !== SCHEMA || claim.meshId !== meshId || !samePartitionIdentity(claim.identity, request.identity)
+        || !['partition-activations', 'partition-activations-and-tokens'].includes(claim.disclosure)
+        || !/^sha256:[a-f0-9]{64}$/.test(claim.generationDigest)
+        || !Number.isSafeInteger(claim.issuedAt) || !Number.isSafeInteger(claim.expiresAt)
+        || claim.issuedAt > now() + maxClockSkewMs || claim.expiresAt <= claim.issuedAt || claim.expiresAt - claim.issuedAt > maxTtlMs
+        || typeof claim.id !== 'string' || claim.id.length > 128
+        || bounds.some(key => !Number.isSafeInteger(claim.limits?.[key]) || claim.limits[key] <= 0)) return DECLINED;
+      if (!settlement && (!partitionActions.includes(request.action) || !Number.isSafeInteger(request.step)
+        || request.generationDigest !== claim.generationDigest
+        || request.action === 'mesh.transfer_token_context' && claim.disclosure !== 'partition-activations-and-tokens'
+        || request.step < 0 || request.step >= claim.limits.maxTokens
+        || !Number.isSafeInteger(request.inputTokenCount) || request.inputTokenCount < 1
+        || request.inputTokenCount > (request.step === 0 ? claim.limits.maxPromptTokens : 1)
+        || request.activationBytes != null && (!Number.isSafeInteger(request.activationBytes)
+          || request.activationBytes < 0 || request.activationBytes > claim.limits.maxActivationBytes))) return DECLINED;
+      if (!await signatureValid(record, request.identity.participantA, bytes(claim))) return DECLINED;
+      return current(claim, settlement);
+    } catch { return DECLINED; }
+  }
+  const verify = async (grant, request, options) => (await check(grant, request, options)).ok;
+  return Object.freeze({
+    participantId: signer.peerId, meshId, verify, check,
+    /** The declared clock allowance between participants that check this authority's grants. */
+    maxClockSkewMs,
+    canonicalScope,
+    async issueOrdered(identity, limits, { approved, ttlMs, disclosure, generationDigest, expiresAt }) {
+      assert(!closed && approved === true, 'Explicit ordered partition disclosure approval required');
+      assert(Number.isSafeInteger(ttlMs) && ttlMs > 0 && ttlMs <= maxTtlMs, 'Invalid ordered grant lifetime');
+      const binding = canonicalRouteAttemptBinding(identity), issuedAt = now();
+      assert(expiresAt === undefined || Number.isSafeInteger(expiresAt) && expiresAt > issuedAt, 'Ordered disclosure deadline expired or invalid');
+      const claim = structuredClone({ schema: ORDERED_SCHEMA, id: crypto.randomUUID(), meshId, identity: binding,
+        coordinatorId: binding.route.stages[0].participantId, disclosure, generationDigest, issuedAt,
+        expiresAt: Math.min(issuedAt + ttlMs, expiresAt ?? Infinity), limits: Object.fromEntries(bounds.map(key => [key, limits[key]])) });
+      orderedClaim(claim);
+      assert(claim.coordinatorId === signer.peerId && await createPeerIdFromPublicJwk(signer.publicJwk) === signer.peerId,
+        'Only the authenticated stage-zero coordinator grants ordered execution');
+      assert(!closed && issued.size < maxGrants, 'Partition grant budget exhausted');
+      const entry = { revoked: false }; issued.set(claim.id, entry);
+      try {
+        const key = await importSigningKey(signer);
+        const signature = await crypto.subtle.sign(getIdentitySignAlgorithm(signer), key, bytes(claim));
+        assert(!closed && !entry.revoked, 'Partition authority closed');
+        return { claim, publicJwk: structuredClone(signer.publicJwk), signature: toBase64Url(signature) };
+      } catch (error) { entry.revoked = true; throw error; }
+    },
+    async issueCanonical(binding, limits, { approved, ttlMs, disclosure, generation, canonicalAttempt, vocabSize }) {
+      canonicalCapability();
+      assert(!closed && approved === true, 'Explicit canonical partition disclosure approval required');
+      assert(Number.isSafeInteger(ttlMs) && ttlMs > 0 && ttlMs <= maxTtlMs, 'Invalid canonical grant lifetime');
+      const issuedAt = now();
+      const claim = structuredClone({ schema: CANONICAL_SCHEMA, id: crypto.randomUUID(), meshId, identity: binding,
+        canonicalAttempt, generation, vocabSize, disclosure, issuedAt, expiresAt: issuedAt + ttlMs,
+        limits: Object.fromEntries(bounds.map(key => [key, limits[key]])) });
+      canonicalClaim(claim);
+      assert(claim.identity.participantA === signer.peerId && await createPeerIdFromPublicJwk(signer.publicJwk) === signer.peerId,
+        'Only the authenticated input owner grants canonical execution');
+      assert(!closed && issued.size < maxGrants, 'Partition grant budget exhausted');
+      const entry = { revoked: false }; issued.set(claim.id, entry);
+      try {
+        const key = await importSigningKey(signer);
+        const signature = await crypto.subtle.sign(getIdentitySignAlgorithm(signer), key, canonicalBytes(claim));
+        assert(!closed && !entry.revoked, 'Partition authority closed');
+        return { claim, publicJwk: structuredClone(signer.publicJwk), signature: toBase64Url(signature) };
+      } catch (error) { entry.revoked = true; throw error; }
+    },
+    async issue(binding, limits, { approved, ttlMs, disclosure, generationDigest }) {
+      binding = structuredClone(binding); limits = structuredClone(limits);
+      assert(!closed && approved === true, 'Explicit partition disclosure approval required');
+      validatePartitionIdentity(binding);
+      assert(binding.participantA === signer.peerId && await createPeerIdFromPublicJwk(signer.publicJwk) === signer.peerId,
+        'Only the authenticated input owner can grant partition execution');
+      assert(Number.isSafeInteger(ttlMs) && ttlMs > 0 && ttlMs <= maxTtlMs, 'Invalid partition grant lifetime');
+      assert(['partition-activations', 'partition-activations-and-tokens'].includes(disclosure)
+        && /^sha256:[a-f0-9]{64}$/.test(generationDigest), 'Explicit partition disclosure and generation identity required');
+      assert(bounds.every(key => Number.isSafeInteger(limits?.[key]) && limits[key] > 0), 'Explicit partition grant allocations required');
+      assert(issued.size < maxGrants, 'Partition grant budget exhausted');
+      const issuedAt = now();
+      const claim = { schema: SCHEMA, id: crypto.randomUUID(), meshId, identity: binding,
+        disclosure, generationDigest, issuedAt, expiresAt: issuedAt + ttlMs,
+        limits: Object.fromEntries(bounds.map(key => [key, limits[key]])) };
+      const entry = { revoked: false }; issued.set(claim.id, entry);
+      try {
+        const key = await importSigningKey(signer);
+        const signature = await crypto.subtle.sign(getIdentitySignAlgorithm(signer), key, bytes(claim));
+        assert(!closed && !entry.revoked, 'Partition authority closed');
+        return { claim, publicJwk: structuredClone(signer.publicJwk), signature: toBase64Url(signature) };
+      } catch (error) { entry.revoked = true; throw error; }
+    },
+    revoke(grant) { const entry = issued.get(grant?.claim?.id); if (entry) entry.revoked = true; },
+    close() { closed = true; verified.clear(); for (const entry of issued.values()) entry.revoked = true; }
+  });
+}

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

@@ -0,0 +1,103 @@
+import { createP2PTransport } from '../../transport/assignment.js';
+import { createMeshPeerIdentity } from '../peer-identity.js';
+import { assertPartition as assert } from './partition-contract.js';
+
+/** Manual signaling adapter with certificate-bound identities. Reuses Poolday's
+ * transport and identity challenge; a signaling code grants no compute permission.
+ */
+export function createPartitionLink({ identity, roomId, kind, initiator, config, rtcConfig,
+  timeoutMs, createEndpoint, onChange = () => {} }) {
+  assert(['entry', 'stage'].includes(kind) && Number.isSafeInteger(timeoutMs) && timeoutMs > 0,
+    'Explicit partition link kind and timeout required');
+  let remoteId = null, receiver, endpoint = null, channel = null, disposed = false, codeSignals = [], connecting = null;
+  const handlers = new Map(), lifetime = new AbortController();
+  const signal = (type, payload) => { codeSignals.push({ type, payload }); };
+  const fingerprint = description => description?.sdp?.split(/\r?\n/)
+    .find(line => line.startsWith('a=fingerprint:sha-256 '))?.slice(14);
+  const transport = createP2PTransport({ config, initiator, rtcConfig,
+    signaling: { subscribe: fn => { receiver = fn; return () => { receiver = null; }; },
+      sendOffer: payload => signal('offer', payload), sendAnswer: payload => signal('answer', payload),
+      sendIceCandidate: payload => signal('ice-candidate', payload), sendClose() {} },
+    onMessage: message => handlers.get(message.type)?.(remoteId, message.payload),
+    onAuxiliaryChannel: accepted => {
+      if (initiator || channel || accepted.label !== 'reploid-partition-' + kind) return false;
+      channel = accepted; attach(channel).catch(failed); return true;
+    },
+    onStateChange: state => {
+      if (state === 'connected' && initiator) {
+        channel = transport.getPeerConnection().createDataChannel('reploid-partition-' + kind, { ordered: true });
+        attach(channel).catch(failed);
+      }
+      if (['failed', 'closed'].includes(state)) {
+        lifetime.abort(new Error('Partition link lost'));
+        Promise.resolve(endpoint?.close()).catch(failed);
+      }
+      onChange();
+    },
+  });
+  const peerIdentity = createMeshPeerIdentity({ transport: {
+    _getPeerId: () => identity.peerId,
+    getPeerBinding: () => {
+      const pc = transport.getPeerConnection();
+      return transport.getState() === 'connected' ? { local: fingerprint(pc.localDescription), remote: fingerprint(pc.remoteDescription) } : null;
+    },
+    onMessage: (type, handler) => handlers.set(type, handler),
+    sendToPeer: (_peer, type, payload) => { transport.send({ type, payload }); return true; },
+  }, getIdentity: () => identity, roomId, timeoutMs, maxPending: 2 });
+  let error = null;
+  function failed(cause) { error = String(cause.message); lifetime.abort(cause); channel?.close(); onChange(); }
+  async function attach(accepted) {
+    const deadline = AbortSignal.any([lifetime.signal, AbortSignal.timeout(timeoutMs)]);
+    const wait = (event, predicate) => new Promise((resolve, reject) => {
+      const done = (error) => { accepted.removeEventListener(event, received); deadline.removeEventListener('abort', aborted); error ? reject(error) : resolve(); };
+      const received = input => { if (!predicate || predicate(input)) done(); };
+      const aborted = () => done(deadline.reason);
+      accepted.addEventListener(event, received); deadline.addEventListener('abort', aborted, { once: true });
+      if (deadline.aborted) aborted(); else if (event === 'open' && accepted.readyState === 'open') done();
+    });
+    const ready = initiator ? wait('message', e => e.data === 'partition-entry-ready') : wait('open');
+    ready.catch(() => {});
+    await wait('open');
+    const verified = await peerIdentity.verify(remoteId, deadline);
+    assert(verified === remoteId, 'Partition link signing identity differs from signaling code');
+    if (initiator) await ready;
+    deadline.throwIfAborted();
+    endpoint = await createEndpoint({ channel: accepted, localParticipantId: identity.peerId, remoteParticipantId: verified, kind, initiator });
+    if (!initiator) accepted.send('partition-entry-ready');
+    onChange();
+  }
+  return Object.freeze({
+    get endpoint() { return endpoint; },
+    get remoteId() { return remoteId; },
+    getState: () => ({ state: transport.getState(), kind, remoteId, ready: !!endpoint && !lifetime.signal.aborted, error }),
+    async connect() {
+      if (connecting) return connecting;
+      connecting = transport.connect(); connecting.catch(failed);
+      assert(transport.getPeerConnection(), 'Transport did not create its connection');
+    },
+    async exportCode() {
+      const deadline = performance.now() + timeoutMs;
+      while (!codeSignals.some(s => s.type === (initiator ? 'offer' : 'answer'))
+        || transport.getPeerConnection().iceGatheringState !== 'complete') {
+        lifetime.signal.throwIfAborted();
+        if (performance.now() >= deadline) throw new Error('Partition signaling timed out');
+        await new Promise(resolve => setTimeout(resolve, 50));
+      }
+      return btoa(JSON.stringify({ schema: 'reploid.partition-link/v1', peerId: identity.peerId, roomId, kind, signals: codeSignals }));
+    },
+    acceptCode(code) {
+      assert(typeof code === 'string' && code.length <= 90000, 'Invalid partition connection code');
+      const packet = JSON.parse(atob(code.trim()));
+      assert(packet.schema === 'reploid.partition-link/v1' && packet.roomId === roomId && packet.kind === kind
+        && /^peer:[a-f0-9]{24}$/.test(packet.peerId) && packet.peerId !== identity.peerId
+        && (!remoteId || remoteId === packet.peerId) && Array.isArray(packet.signals) && packet.signals.length <= 70,
+      'Partition signaling identity mismatch');
+      remoteId = packet.peerId;
+      for (const item of packet.signals) { assert(['offer', 'answer', 'ice-candidate'].includes(item.type), 'Invalid signal'); receiver(item); }
+    },
+    async close() {
+      if (disposed) return; disposed = true; lifetime.abort(); peerIdentity.close();
+      await endpoint?.close(); await transport.close();
+    },
+  });
+}

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

@@ -0,0 +1,109 @@
+import { createRoutePartitionNetwork } from './partition-route-network.js';
+import { assertPartition as assert } from './partition-contract.js';
+
+const LABEL = 'reploid-partitions';
+const READY = 'reploid.partition-channel-ready/v1';
+
+/** Uses the existing mesh certificate/signature verifier; never trusts an advertised peer ID. */
+export function createPartitionNetwork({ transport, verifyPeer, createEndpoint, maxPeers, timeoutMs, onPeer = () => {}, label = LABEL, ordered = null }) {
+  if (ordered !== null) return createRoutePartitionNetwork({ transport, verifyPeer, createEndpoint, maxPeers, timeoutMs, onPeer, label, ordered });
+  assert((/^reploid-partitions(?:-[a-z-]+)?$/.test(label) || label === 'reploid-training') && label.length <= 80, 'Invalid partition channel label');
+  assert(typeof transport?.onDataChannel === 'function' && typeof transport.getPeerBinding === 'function'
+    && typeof verifyPeer === 'function' && typeof createEndpoint === 'function'
+    && Number.isSafeInteger(maxPeers) && maxPeers > 0 && Number.isSafeInteger(timeoutMs) && timeoutMs > 0
+    && timeoutMs <= 2147483647, 'Partition network ports and budgets required');
+  const entries = new Map(), retiring = new Set();
+  let closed = false, closing = null, settlementFailure = null;
+  const settleEntry = entry => {
+    if (!entry.settlement) {
+      entry.settlement = Promise.resolve().then(() => entry.endpoint?.close());
+      retiring.add(entry.settlement);
+      entry.settlement.then(() => retiring.delete(entry.settlement), error => {
+        retiring.delete(entry.settlement); settlementFailure ||= error;
+      });
+    }
+    return entry.settlement;
+  };
+  const wait = (entry, handshake) => new Promise((resolve, reject) => {
+    const finish = error => {
+      clearTimeout(timer); entry.channel.removeEventListener('open', opened);
+      entry.channel.removeEventListener('message', message); entry.channel.removeEventListener('close', lost);
+      entry.controller.signal.removeEventListener('abort', lost);
+      error ? reject(error) : resolve();
+    };
+    const opened = () => { if (!handshake) finish(); };
+    const message = event => finish(event.data === READY ? null : new Error('Invalid partition channel handshake'));
+    const lost = () => finish(new Error('Partition channel closed during authentication'));
+    const timer = setTimeout(() => finish(new Error('Partition channel authentication timed out')), timeoutMs);
+    entry.channel.addEventListener('open', opened);
+    if (handshake) entry.channel.addEventListener('message', message, { once: true });
+    entry.channel.addEventListener('close', lost, { once: true });
+    entry.controller.signal.addEventListener('abort', lost, { once: true });
+    if (entry.controller.signal.aborted || entry.channel.readyState === 'closed') lost();
+    else if (!handshake && entry.channel.readyState === 'open') finish();
+  });
+  const attach = (peerId, channel, incoming) => {
+    assert(!closed && !entries.has(peerId) && entries.size < maxPeers, 'Partition peer limit or duplicate connection');
+    const entry = { channel, controller: new AbortController(), endpoint: null, promise: null };
+    entries.set(peerId, entry);
+    channel.addEventListener('close', () => {
+      entry.controller.abort();
+      if (entries.get(peerId) === entry) entries.delete(peerId);
+      settleEntry(entry);
+    }, { once: true });
+    // Install the handshake listener before any asynchronous certificate verification.
+    const ready = wait(entry, !incoming);
+    ready.catch(() => {});
+    entry.promise = (async () => {
+      const timer = setTimeout(() => entry.controller.abort(), timeoutMs);
+      try {
+        const before = transport.getPeerBinding(peerId);
+        assert(before, 'Authenticated WebRTC certificate binding required');
+        const verifiedId = await verifyPeer(peerId, entry.controller.signal);
+        entry.controller.signal.throwIfAborted();
+        const after = transport.getPeerBinding(peerId);
+        assert(/^peer:[a-f0-9]{24}$/.test(verifiedId) && before.local === after?.local && before.remote === after?.remote,
+          'Partition peer identity or certificate changed');
+        await ready;
+        entry.controller.signal.throwIfAborted();
+        entry.endpoint = createEndpoint({ channel, remoteParticipantId: verifiedId });
+        if (incoming) channel.send(READY);
+        onPeer(peerId, entry.endpoint);
+        return entry.endpoint;
+      } catch (error) {
+        entry.controller.abort(); channel.close();
+        if (entries.get(peerId) === entry) entries.delete(peerId);
+        await settleEntry(entry).catch(() => {});
+        throw error;
+      } finally { clearTimeout(timer); }
+    })();
+    return entry.promise;
+  };
+  const unsubscribe = transport.onDataChannel(label, (peerId, channel) => {
+    try { attach(peerId, channel, true).catch(() => {}); } catch { channel.close(); }
+  });
+  return Object.freeze({
+    connect(peerId) {
+      assert(!closed, 'Partition network closed');
+      if (entries.has(peerId)) return entries.get(peerId).promise;
+      assert(entries.size < maxPeers, 'Partition peer limit');
+      const channel = transport.openDataChannel(peerId, label);
+      try { return attach(peerId, channel, false); } catch (error) { channel.close(); throw error; }
+    },
+    close() {
+      if (closing) return closing;
+      closed = true; unsubscribe();
+      const pending = [...entries.values()];
+      closing = Promise.resolve().then(async () => {
+        for (const entry of pending) { entry.controller.abort(); entry.channel.close(); }
+        await Promise.allSettled(pending.map(entry => entry.promise));
+        const results = await Promise.allSettled([...retiring, ...pending.map(settleEntry)]);
+        entries.clear();
+        const failures = results.filter(result => result.status === 'rejected').map(result => result.reason);
+        if (settlementFailure && !failures.includes(settlementFailure)) failures.push(settlementFailure);
+        if (failures.length) throw new AggregateError(failures, 'Partition network settlement failed');
+      });
+      return closing;
+    }
+  });
+}