reploid 0.0.0-stage → 0.1.1

package/shared/vendor/reploid/adapters/doppler-session.js

@@ -0,0 +1,372 @@
+import { hashJson } from '../artifacts/signatures.js';
+import { computeManifestShardSetHash } from '../artifacts/manifest-identity.js';
+
+// The one place application adapters call Doppler's public session surface:
+// module loading, runtime exports, identity, generation, embedding, sequence
+// encoding, operation streams, reset and cancellation. Doppler owns computation;
+// hosts own module URLs, load policy, scopes, work queues, event verification
+// policy and closing. Importing this module has no side effects.
+
+const isObject = value => value && typeof value === 'object' && !Array.isArray(value);
+const hasIdentityValue = value => value !== undefined && value !== null && String(value).trim() !== '';
+const normalizeHashIdentity = value => {
+  const text = String(value || '').trim();
+  if (!text) return '';
+  return text.startsWith('sha256:') ? text : `sha256:${text}`;
+};
+const identityValuesMatch = (field, expected, actual) => field === 'modelHash' || field === 'manifestHash'
+  ? normalizeHashIdentity(expected) === normalizeHashIdentity(actual)
+  : expected === actual;
+
+/** Doppler publishes one runtime object as `dr`, `doppler` and the default export. */
+export const resolveDopplerRuntime = module => module?.dr || module?.doppler || module?.default || null;
+
+/** Memoized module loading; a failed load is forgotten so the next call retries.
+ * `loadModule` is one host loader whose own error surfaces unchanged. Otherwise
+ * host-chosen `candidates` are tried in order: objects are already-loaded modules
+ * and `importModule` imports a specifier, so the host keeps its declared loader. */
+export function createDopplerModuleLoader({ loadModule, candidates, importModule, prepare = () => {}, fallback = () => null,
+  injectedLabel = 'injected Doppler module', unavailableMessage = 'Unable to load public Doppler module.' }) {
+  const loadCandidates = async () => {
+    prepare();
+    const errors = [];
+    for (const candidate of candidates()) {
+      const label = typeof candidate === 'string' ? candidate : injectedLabel;
+      try {
+        return candidate && typeof candidate === 'object' ? candidate : await importModule(candidate);
+      } catch (error) {
+        errors.push(`${label}: ${error.message}`);
+      }
+    }
+    const loaded = fallback();
+    if (loaded && typeof loaded === 'object') return loaded;
+    throw new Error(`${unavailableMessage} Attempts: ${errors.join('; ') || 'none'}`);
+  };
+  let pending = null;
+  return Object.freeze({
+    load() {
+      pending ||= (loadModule ? Promise.resolve().then(() => loadModule()) : loadCandidates()).catch(error => {
+        pending = null;
+        throw error;
+      });
+      return pending;
+    },
+    reset() { pending = null; }
+  });
+}
+
+export function dopplerGenerateMethod(session) {
+  if (!session) return null;
+  for (const name of ['generateWithEvidence', 'generate', 'generateText', 'run']) {
+    if (typeof session[name] === 'function') return name;
+  }
+  return null;
+}
+
+export function dopplerEmbedMethod(session) {
+  if (!session) return null;
+  for (const name of ['embed', 'embedText', 'run']) {
+    if (typeof session[name] === 'function') return name;
+  }
+  return null;
+}
+
+/** Identity a loaded public session reports about itself; never the request's claim. */
+export async function readDopplerSessionIdentity(session) {
+  const manifest = session?.manifest || session?.model?.manifest || null;
+  const artifactIdentity = manifest?.artifactIdentity || session?.artifactIdentity || session?.model?.artifactIdentity || null;
+  const modelHash = manifest?.modelHash
+    || manifest?.artifactIdentity?.weightPackHash
+    || manifest?.artifactIdentity?.shardSetHash
+    || (manifest ? await computeManifestShardSetHash(manifest) : null)
+    || session?.modelHash
+    || session?.hash
+    || session?.model?.modelHash
+    || session?.model?.hash
+    || (artifactIdentity ? await hashJson(artifactIdentity) : null);
+  const declaredManifestHash = manifest?.manifestHash || manifest?.hash || null;
+  const manifestHash = declaredManifestHash
+    || session?.manifestHash
+    || session?.model?.manifestHash
+    || session?.model?.manifest?.hash
+    || null;
+  return {
+    modelId: manifest?.modelId || manifest?.id || session?.modelId || session?.id
+      || session?.model?.modelId || session?.model?.id || null,
+    modelHash,
+    manifestHash,
+    runtimeManifestHash: manifest ? await hashJson(manifest) : null,
+    declaredManifestHash,
+    artifactIdentity
+  };
+}
+
+const artifactIdentityValueMatches = (expected, actual) => {
+  if (expected === undefined) return true;
+  if (Array.isArray(expected)) {
+    return Array.isArray(actual) && expected.length === actual.length
+      && expected.every((value, index) => artifactIdentityValueMatches(value, actual[index]));
+  }
+  if (isObject(expected)) {
+    return isObject(actual) && Object.entries(expected).every(([key, value]) => artifactIdentityValueMatches(value, actual[key]));
+  }
+  return expected === actual;
+};
+
+/** Reject a session whose reported identity differs from the requested descriptor.
+ * A signed session passes `packIdentity` (its contract's session identity record),
+ * whose semantic root and envelope digest replace the manifest-derived hashes. */
+export async function assertDopplerSessionIdentity(session, descriptor = {}, options = {}) {
+  const evidence = await readDopplerSessionIdentity(session);
+  if (Object.hasOwn(options, 'packIdentity')) {
+    evidence.modelHash = options.packIdentity.semanticRoot;
+    evidence.manifestHash = options.packIdentity.envelopeDigest;
+    evidence.declaredManifestHash = options.packIdentity.envelopeDigest;
+  }
+  const assertField = (field, expected, actual) => {
+    if (!hasIdentityValue(expected)) return;
+    if (!hasIdentityValue(actual)) throw new Error(`Loaded Doppler handle must expose ${field} before provider registration`);
+    if (!identityValuesMatch(field, expected, actual)) {
+      throw new Error(`Loaded Doppler handle ${field} does not match requested model identity`);
+    }
+  };
+  assertField('modelId', descriptor?.modelId || descriptor?.id, evidence.modelId);
+  assertField('modelHash', descriptor?.modelHash || descriptor?.hash, evidence.modelHash);
+  if (hasIdentityValue(descriptor?.manifestHash)) {
+    if (hasIdentityValue(evidence.declaredManifestHash)) {
+      assertField('manifestHash', descriptor.manifestHash, evidence.declaredManifestHash);
+    } else {
+      const observed = [evidence.manifestHash, evidence.runtimeManifestHash].filter(hasIdentityValue);
+      if (observed.length === 0 && !evidence.artifactIdentity) {
+        throw new Error('Loaded Doppler handle must expose manifestHash or artifactIdentity before provider registration');
+      }
+      const canonicalHashMatches = observed.some(hash => identityValuesMatch('manifestHash', descriptor.manifestHash, hash));
+      // A preflight-verified byte hash may name the manifest Doppler later normalized.
+      const byteHashMatches = hasIdentityValue(descriptor.manifestByteHash) && hasIdentityValue(evidence.manifestHash)
+        && identityValuesMatch('manifestHash', descriptor.manifestByteHash, evidence.manifestHash);
+      if (observed.length > 0 && !canonicalHashMatches && !byteHashMatches) {
+        throw new Error('Loaded Doppler handle manifestHash does not match requested model identity');
+      }
+    }
+  }
+  if (descriptor?.artifactIdentity && !(isObject(evidence.artifactIdentity) && Object.entries(descriptor.artifactIdentity)
+    .every(([key, value]) => artifactIdentityValueMatches(value, evidence.artifactIdentity[key])))) {
+    throw new Error('Loaded Doppler handle artifactIdentity does not match requested model identity');
+  }
+}
+
+const positiveIntegerOrUndefined = value => {
+  const number = Number(value);
+  return Number.isInteger(number) && number > 0 ? number : undefined;
+};
+const finiteNumberOrUndefined = value => {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : undefined;
+};
+const stopList = (value, mapItem) => {
+  if (!Array.isArray(value)) return undefined;
+  const list = value.map(mapItem).filter(item => item != null);
+  return list.length ? list : undefined;
+};
+
+/** Translate a Reploid generation configuration into Doppler's public sampling
+ * options. Doppler validates the values and owns their meaning. */
+export function toDopplerSamplingOptions(generationConfig = {}) {
+  const options = {
+    maxTokens: positiveIntegerOrUndefined(generationConfig.maxTokens ?? generationConfig.maxOutputTokens),
+    temperature: finiteNumberOrUndefined(generationConfig.temperature),
+    topP: finiteNumberOrUndefined(generationConfig.topP),
+    topK: positiveIntegerOrUndefined(generationConfig.topK),
+    useSpeculative: typeof generationConfig.useSpeculative === 'boolean' ? generationConfig.useSpeculative : false,
+    stopTokens: stopList(generationConfig.stopTokens, token => Number.isInteger(token) ? token : null),
+    stopSequences: stopList(generationConfig.stopSequences, sequence => typeof sequence === 'string' ? sequence : null)
+  };
+  if (generationConfig.mode === 'greedy') Object.assign(options, { temperature: 0, topK: 1, topP: 1 });
+  if (typeof generationConfig.useChatTemplate === 'boolean') options.useChatTemplate = generationConfig.useChatTemplate;
+  return Object.fromEntries(Object.entries(options).filter(([, value]) => value !== undefined));
+}
+
+const isAsyncIterable = value => value && typeof value[Symbol.asyncIterator] === 'function';
+const isIterable = value => value && typeof value[Symbol.iterator] === 'function' && typeof value !== 'string';
+const collected = (chunks, stream) => {
+  const outputText = chunks.join('');
+  return { outputText, tokenIds: [], transcript: { chunks, outputText, tokenIds: [], stream } };
+};
+async function collectGeneration(value) {
+  if (isAsyncIterable(value)) {
+    const chunks = [];
+    for await (const chunk of value) chunks.push(String(chunk ?? ''));
+    return collected(chunks, true);
+  }
+  if (isIterable(value)) return collected(Array.from(value, chunk => String(chunk ?? '')), false);
+  return value;
+}
+
+async function firstSuccessful(attempts) {
+  let firstError = null;
+  for (const attempt of attempts) {
+    try {
+      return await collectGeneration(await attempt());
+    } catch (error) {
+      if (!firstError) firstError = error;
+    }
+  }
+  throw firstError || new Error('Doppler generation failed without an error');
+}
+
+/** Generate through whichever public method the session exposes. Prompt-and-options
+ * calls precede the request-object form older handles accept. */
+export async function generateWithDopplerSession(session, prompt, generationConfig, assignment) {
+  const samplingOptions = toDopplerSamplingOptions(generationConfig);
+  const requestOptions = toDopplerSamplingOptions(generationConfig);
+  const request = { prompt, assignment, generationConfig, samplingOptions: requestOptions, ...requestOptions };
+  if (typeof session.generateWithEvidence === 'function') {
+    return collectGeneration(await session.generateWithEvidence(prompt, samplingOptions));
+  }
+  for (const method of ['generateText', 'generate']) {
+    if (typeof session[method] === 'function') {
+      return firstSuccessful([() => session[method](prompt, samplingOptions), () => session[method](request)]);
+    }
+  }
+  if (typeof session.run === 'function') return collectGeneration(await session.run(request));
+  throw new Error('Doppler public handle does not expose generate, generateText, or run');
+}
+
+export async function embedWithDopplerSession(session, prompt, assignment, { workload } = {}) {
+  if (typeof session.embed === 'function') return session.embed(prompt, { assignment });
+  if (typeof session.embedText === 'function') return session.embedText(prompt, { assignment });
+  if (typeof session.run === 'function') return session.run({ prompt, input: prompt, assignment, workload });
+  throw new Error('Doppler public handle does not expose embed, embedText, or run');
+}
+
+export const dopplerSequenceMethod = session => session && typeof session.encodeSequence === 'function' ? 'encodeSequence' : null;
+
+/** Biological-sequence encoding; the host chooses the outputs it requests. */
+export async function encodeSequenceWithDopplerSession(session, sequence, options) {
+  if (!dopplerSequenceMethod(session)) throw new Error('Doppler public handle does not expose encodeSequence');
+  return session.encodeSequence(sequence, options);
+}
+
+/** The one call into a session's operation event stream. Callers verify each event. */
+export function dopplerOperationEvents(session, request, options) {
+  if (typeof session?.executeOperation !== 'function') throw new Error('Doppler session does not expose public executeOperation');
+  return session.executeOperation(request, options);
+}
+
+/** Doppler's own reconstruction of an incremental (operation request v2) stream. */
+export function createDopplerStreamAccumulator(runtime, request) {
+  if (typeof runtime?.createCapsuleStreamAccumulator !== 'function') {
+    throw new Error('Installed Doppler runtime does not support operation v2');
+  }
+  return runtime.createCapsuleStreamAccumulator(request);
+}
+
+/** Text deltas from a scoped session stream; completion events carry no new text. */
+export async function* streamDopplerText(session, input, options) {
+  for await (const event of session.stream(input, options)) {
+    if (event?.type === 'text-delta') yield event.text;
+  }
+}
+
+export function readDopplerOutputText(result) {
+  if (typeof result === 'string') return result;
+  const direct = result?.outputText ?? result?.text ?? result?.content ?? result?.completion ?? result?.response;
+  if (typeof direct === 'string') return direct;
+  const first = result?.output?.[0]?.content?.[0]?.text ?? result?.choices?.[0]?.message?.content ?? result?.choices?.[0]?.text;
+  return typeof first === 'string' ? first : '';
+}
+
+export function readDopplerTokenIds(result) {
+  const raw = [result?.tokenIds, result?.tokens, result?.generatedTokenIds, result?.outputTokenIds,
+    result?.receipt?.tokenIds, result?.receipt?.generatedTokenIds, result?.usage?.tokenIds].find(Array.isArray);
+  if (!raw) return [];
+  return raw.map(token => {
+    if (Number.isInteger(token)) return token;
+    if (Number.isInteger(token?.id)) return token.id;
+    if (Number.isInteger(token?.tokenId)) return token.tokenId;
+    return null;
+  }).filter(Number.isInteger);
+}
+
+export function readDopplerTokenCounts(result, tokenIds) {
+  const counts = result?.tokenCounts || result?.usage || result?.receipt?.tokenCounts;
+  if (!counts) return { input: 0, output: tokenIds.length };
+  return {
+    input: Number(counts.input ?? counts.promptTokens ?? counts.prompt_tokens ?? 0),
+    output: Number(counts.output ?? counts.completionTokens ?? counts.completion_tokens ?? tokenIds.length)
+  };
+}
+
+/** Embedding values as float32-rounded numbers; finiteness is the caller's check. */
+export function readDopplerEmbedding(result) {
+  const candidate = ArrayBuffer.isView(result) || Array.isArray(result) ? result
+    : result?.embedding || result?.vector || result?.values || result?.outputEmbedding
+      || result?.result?.embedding || result?.receipt?.embedding;
+  if (!(ArrayBuffer.isView(candidate) || Array.isArray(candidate))) return [];
+  return Array.from(candidate, item => Math.fround(Number(item)));
+}
+
+const DOPPLER_GENERATION_EVIDENCE_SCHEMA = 'doppler_generation_evidence/v1';
+const field = (name, expected, actual) => ({ field: name, expected, actual, matched: expected === actual });
+
+/** Check Doppler's own generation evidence against the delivered output, the requested
+ * options and the loaded model. Null when the session supplied no evidence. */
+export async function verifyDopplerGenerationEvidence({ result, generationConfig, modelId, manifestHash }) {
+  if (result?.schema !== DOPPLER_GENERATION_EVIDENCE_SCHEMA) return null;
+  if (!isObject(result.transcript) || !isObject(result.generationConfig)) {
+    throw new Error('Doppler generation evidence is missing transcript or generationConfig');
+  }
+  if (!isObject(result.runtimeProfile) || !isObject(result.backendIdentity)) {
+    throw new Error('Doppler generation evidence is missing runtimeProfile or backendIdentity');
+  }
+  const configFields = await Promise.all(Object.entries(toDopplerSamplingOptions(generationConfig))
+    .filter(([name]) => name !== 'stopTokens')
+    .map(async ([name, expected]) => field(`generationConfig.${name}`,
+      await hashJson(expected), await hashJson(result.generationConfig[name]))));
+  const fields = [
+    field('outputText', readDopplerOutputText(result), result.transcript.outputText),
+    field('tokenIdsHash', await hashJson(readDopplerTokenIds(result)), await hashJson(result.transcript.tokenIds)),
+    field('transcriptHash', await hashJson(result.transcript), result.transcriptHash),
+    field('generationConfigHash', await hashJson(result.generationConfig), result.generationConfigHash),
+    field('runtimeProfileHash', await hashJson(result.runtimeProfile), result.runtimeProfileHash),
+    field('backendIdentityHash', await hashJson(result.backendIdentity), result.backendIdentityHash),
+    field('modelId', modelId || null, result.runtimeProfile?.model?.modelId || null),
+    field('manifestHash', normalizeHashIdentity(manifestHash), normalizeHashIdentity(result.runtimeProfile?.model?.manifestHash)),
+    field('backend', 'webgpu', result.backendIdentity?.backend || null),
+    ...configFields
+  ];
+  const mismatch = fields.find(item => item.matched !== true);
+  if (mismatch) {
+    throw new Error(`Doppler generation evidence ${mismatch.field} mismatch: expected ${mismatch.expected}, got ${mismatch.actual}`);
+  }
+  return {
+    schema: 'reploid.doppler_generation_evidence_comparison/v1',
+    verified: true,
+    evidenceSchema: result.schema,
+    transcriptHash: result.transcriptHash,
+    generationConfigHash: result.generationConfigHash,
+    runtimeProfileHash: result.runtimeProfileHash,
+    backendIdentityHash: result.backendIdentityHash,
+    fields
+  };
+}
+
+/** Clear decoder state between independent requests on a resident session. */
+export async function resetDopplerSession(session) {
+  if (typeof session?.resetGenerationState === 'function') {
+    await session.resetGenerationState();
+    return;
+  }
+  if (typeof session?.resetToSeqLen === 'function') await session.resetToSeqLen(0);
+}
+
+/** Ask the session to stop. A request is not a confirmation that GPU work ended. */
+export async function cancelDopplerSession(session, reason) {
+  if (!session) return { requested: false, method: null };
+  for (const method of ['abort', 'cancel']) {
+    if (typeof session[method] !== 'function') continue;
+    await session[method]({ reason });
+    return { requested: true, method };
+  }
+  return { requested: false, method: null };
+}

package/shared/vendor/reploid/artifacts/binary.js

@@ -0,0 +1,25 @@
+/** Binary encodings shared by signed artifacts and host transport adapters. */
+export function bytesToBase64(value) {
+  const bytes = value instanceof Uint8Array ? value : new Uint8Array(value);
+  if (typeof Buffer !== 'undefined') return Buffer.from(bytes).toString('base64');
+  let binary = '';
+  for (let offset = 0; offset < bytes.length; offset += 0x8000) {
+    binary += String.fromCharCode(...bytes.subarray(offset, offset + 0x8000));
+  }
+  return btoa(binary);
+}
+
+export function base64ToBytes(value) {
+  const text = String(value || '');
+  if (typeof Buffer !== 'undefined') return new Uint8Array(Buffer.from(text, 'base64'));
+  return Uint8Array.from(atob(text), character => character.charCodeAt(0));
+}
+
+export function toBase64Url(value) {
+  return bytesToBase64(value).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
+}
+
+export function fromBase64Url(value) {
+  const text = String(value || '').replace(/-/g, '+').replace(/_/g, '/');
+  return base64ToBytes(text.padEnd(Math.ceil(text.length / 4) * 4, '='));
+}

package/shared/vendor/reploid/artifacts/canonical-json.js

@@ -0,0 +1,23 @@
+/**
+ * @fileoverview Canonical JSON serialization shared across Poolday runtimes.
+ */
+
+/**
+ * Canonical JSON whose object keys follow `compare`; without one, keys sort by
+ * UTF-16 code units, as Array.prototype.sort does.
+ */
+export function canonicalizeWith(compare) {
+  const serialize = (value) => {
+    if (value === null || typeof value !== 'object') return JSON.stringify(value);
+    if (Array.isArray(value)) {
+      return `[${value.map((item) => serialize(item)).join(',')}]`;
+    }
+    const keys = Object.keys(value).sort(compare);
+    return `{${keys.map((key) => `${JSON.stringify(key)}:${serialize(value[key])}`).join(',')}}`;
+  };
+  return serialize;
+}
+
+export const canonicalize = canonicalizeWith();
+
+export default canonicalize;

package/shared/vendor/reploid/artifacts/delivery-attestation.js

@@ -0,0 +1,64 @@
+/**
+ * @fileoverview Custody delivery attestations.
+ *
+ * After a verified acquisition, the acquirer signs the exact custody receipt
+ * with the custody key its grant names. The statement says the bytes arrived
+ * and verified; supplier-held records cannot say that. A verifier attributes
+ * the custody key to a participant only through that participant's custody
+ * certificate, so an uncertified host's attestation names no one and hosts
+ * without an identity sign none. `hash` is the evidence digest the custody
+ * records use (canonical JSON, sha256), supplied by the caller so signer and
+ * verifier share one function. WebCrypto only.
+ */
+
+import { sha256Hex, signCanonical } from './signatures.js';
+
+export const DELIVERY_ATTESTATION_SCHEMA = 'reploid.custody-delivery-attestation/v1';
+
+/** The statement an acquirer signs over one completed receipt. */
+export async function deliveryAttestationBody({ receipt, attestedAt, hash }) {
+  return {
+    schema: DELIVERY_ATTESTATION_SCHEMA,
+    authorizationHash: receipt.authorizationHash,
+    transferId: receipt.transferId,
+    receiptDigest: await hash(receipt),
+    completed: receipt.completed,
+    attestedAt
+  };
+}
+
+/** Sign the attestation with the acquirer's custody private key (ECDSA P-256 CryptoKey). */
+export async function signDeliveryAttestation({ receipt, attestedAt, privateKey, hash }) {
+  const body = await deliveryAttestationBody({ receipt, attestedAt, hash });
+  return { ...body, signature: await signCanonical(body, privateKey, { domain: DELIVERY_ATTESTATION_SCHEMA }) };
+}
+
+/** One identifier per delivered artifact of one grant; the supplier derives it from its own grant. */
+export async function deliveryEvidenceId({ authorizationHash, artifactId }) {
+  return `dlv_${(await sha256Hex(`${authorizationHash}|${artifactId}`)).slice(7, 39)}`;
+}
+
+/**
+ * The delivery evidence a certified acquirer submits for one artifact of a
+ * requester record from the custody exchange; null without an attestation.
+ */
+export function deliveryEvidenceFromRecord(record, artifactId = record?.authorization?.artifactSet?.artifacts?.[0]?.artifactId) {
+  if (record?.role !== 'requester' || !record.attestation || !record.certificates?.requester || typeof artifactId !== 'string') return null;
+  return structuredClone({
+    artifactId,
+    authorization: record.authorization,
+    index: record.index,
+    receipt: record.receipt,
+    attestation: record.attestation,
+    supplierCertificate: record.certificates.supplier,
+    acquirerCertificate: record.certificates.requester
+  });
+}
+
+export default {
+  DELIVERY_ATTESTATION_SCHEMA,
+  deliveryAttestationBody,
+  signDeliveryAttestation,
+  deliveryEvidenceId,
+  deliveryEvidenceFromRecord
+};

package/shared/vendor/reploid/artifacts/identity.js

@@ -0,0 +1,91 @@
+import { toBase64Url, fromBase64Url } from './binary.js';
+import { canonicalize as stableJson } from './canonical-json.js';
+import { sha256HexUnprefixed } from './signatures.js';
+const encoder = new TextEncoder();
+
+
+const getCryptoApi = (cryptoApi) => {
+  const api = cryptoApi || globalThis.crypto;
+  if (!api?.subtle) {
+    throw new Error('WebCrypto unavailable');
+  }
+  return api;
+};
+
+
+function inferIdentityAlgorithm(bundleOrJwk = {}) {
+  const algorithm = String(bundleOrJwk?.algorithm || '').trim();
+  const crv = String(bundleOrJwk?.crv || bundleOrJwk?.publicJwk?.crv || '').trim();
+  if (algorithm === 'Ed25519' || crv === 'Ed25519') {
+    return 'Ed25519';
+  }
+  return 'ECDSA';
+}
+
+export function getIdentityImportAlgorithm(bundleOrJwk = {}) {
+  return inferIdentityAlgorithm(bundleOrJwk) === 'Ed25519'
+    ? { name: 'Ed25519' }
+    : { name: 'ECDSA', namedCurve: 'P-256' };
+}
+
+export function getIdentitySignAlgorithm(bundleOrJwk = {}) {
+  return inferIdentityAlgorithm(bundleOrJwk) === 'Ed25519'
+    ? { name: 'Ed25519' }
+    : { name: 'ECDSA', hash: 'SHA-256' };
+}
+
+export async function createPeerIdFromPublicJwk(publicJwk, cryptoApi = globalThis.crypto) {
+  const publicShape = publicJwk ? {
+    kty: publicJwk.kty || null,
+    crv: publicJwk.crv || null,
+    x: publicJwk.x || null,
+    y: publicJwk.y || null,
+    n: publicJwk.n || null,
+    e: publicJwk.e || null
+  } : {};
+  const digest = await sha256HexUnprefixed(stableJson(publicShape), getCryptoApi(cryptoApi));
+  return `peer:${digest.slice(0, 24)}`;
+}
+
+export async function importSigningKey(bundle, cryptoApi = globalThis.crypto) {
+  if (!bundle?.privateJwk) {
+    throw new Error('Missing private JWK');
+  }
+  return getCryptoApi(cryptoApi).subtle.importKey(
+    'jwk',
+    bundle.privateJwk,
+    getIdentityImportAlgorithm(bundle),
+    false,
+    ['sign']
+  );
+}
+
+export async function importVerificationKey(bundleOrJwk, cryptoApi = globalThis.crypto) {
+  const publicJwk = bundleOrJwk?.publicJwk || bundleOrJwk;
+  if (!publicJwk) {
+    throw new Error('Missing public JWK');
+  }
+  return getCryptoApi(cryptoApi).subtle.importKey(
+    'jwk',
+    publicJwk,
+    getIdentityImportAlgorithm(publicJwk),
+    false,
+    ['verify']
+  );
+}
+
+export function encodeBytes(value) {
+  return encoder.encode(String(value || ''));
+}
+
+export { fromBase64Url, toBase64Url };
+
+
+export async function createSigningIdentity({ algorithm, cryptoApi = globalThis.crypto }) {
+  if (!['Ed25519', 'ECDSA'].includes(algorithm)) throw new TypeError('Explicit supported signing algorithm required');
+  const params = algorithm === 'Ed25519' ? { name: algorithm } : { name: algorithm, namedCurve: 'P-256' };
+  const keys = await cryptoApi.subtle.generateKey(params, true, ['sign', 'verify']);
+  const publicJwk = await cryptoApi.subtle.exportKey('jwk', keys.publicKey);
+  const privateJwk = await cryptoApi.subtle.exportKey('jwk', keys.privateKey);
+  return { version: 1, algorithm, peerId: await createPeerIdFromPublicJwk(publicJwk, cryptoApi), publicJwk, privateJwk };
+}

package/shared/vendor/reploid/artifacts/manifest-identity.js

@@ -0,0 +1,17 @@
+import { sha256Hex } from './signatures.js';
+
+export const computeManifestShardSetHash = async (manifest = {}) => {
+  const shards = Array.isArray(manifest?.shards) ? manifest.shards : [];
+  if (shards.length === 0) return null;
+  const shardHashInput = shards
+    .map((shard) => {
+      const filename = typeof shard?.filename === 'string' ? shard.filename : '';
+      const size = Number.isFinite(Number(shard?.size)) ? Number(shard.size) : '';
+      const hash = typeof shard?.hash === 'string'
+        ? shard.hash
+        : (typeof shard?.blake3 === 'string' ? shard.blake3 : '');
+      return `${filename}:${size}:${hash}`;
+    })
+    .join('\n');
+  return sha256Hex(shardHashInput);
+};