reploid 0.0.0-stage → 0.1.1

package/packages/reploid/src/mesh/gpu-signature.js

@@ -0,0 +1,136 @@
+import policy from './gpu-signature.policy.json' with { type: 'json' };
+import { gpuSignatureShader } from './gpu-signature-shader.js';
+import { publicProviderHardware } from './provider-hardware.js';
+
+const active = new WeakSet();
+const permutation = row => Array.isArray(row) && row.length === policy.workgroups
+  && row.every(value => Number.isInteger(value) && value >= 0 && value < policy.workgroups)
+  && new Set(row).size === policy.workgroups;
+
+function summarize(signature) {
+  if (!signature || signature.schema !== policy.schema || signature.profile !== policy.profile
+    || signature.status !== 'measured' || signature.workgroups !== policy.workgroups
+    || signature.trials !== policy.trials || !Array.isArray(signature.samples)
+    || signature.samples.length !== policy.seeds.length) throw new TypeError('Invalid GPU signature');
+  const means = [], deviations = [];
+  for (const [index, sample] of signature.samples.entries()) {
+    if (sample.seed !== policy.seeds[index] || sample.workload !== index
+      || !Array.isArray(sample.orders) || sample.orders.length !== policy.trials
+      || !sample.orders.every(permutation)) throw new TypeError('Invalid GPU signature samples');
+    for (let group = 0; group < policy.workgroups; group++) {
+      const values = sample.orders.map(row => row[group] / (policy.workgroups - 1));
+      const mean = values.reduce((a, b) => a + b, 0) / values.length;
+      means.push(mean);
+      deviations.push(Math.sqrt(values.reduce((sum, value) => sum + (value - mean) ** 2, 0) / values.length));
+    }
+  }
+  return { means, deviations };
+}
+
+/** Measures the LOCAL GPU only. No identifier, storage write, or network upload.
+ * The caller must opt in. Cancellation stops new dispatches; submitted work is bounded,
+ * not forcibly preempted. A borrowed device is never destroyed.
+ */
+export async function captureGpuSignature(device = null, { consent = false, signal,
+  gpu = globalThis.navigator?.gpu } = {}) {
+  if (consent !== true) throw new Error('GPU signature collection requires explicit consent');
+  signal?.throwIfAborted();
+  if (!device && !gpu?.requestAdapter) return { status: 'unavailable', reason: 'webgpu-unavailable' };
+  if (device && active.has(device)) throw new Error('GPU signature measurement is already running on this device');
+  const started = performance.now(), buffers = [];
+  const owned = !device;
+  let timer, cancel, finished = false, hardware = null;
+  const interrupted = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error('GPU signature measurement timed out')), policy.timeoutMs);
+    cancel = () => reject(signal.reason || new Error('GPU signature measurement cancelled'));
+    signal?.addEventListener('abort', cancel, { once: true });
+  });
+  // Attach a rejection handler even if setup fails before the first await.
+  interrupted.catch(() => {});
+  let lost;
+  const wait = promise => Promise.race([promise, interrupted, ...(lost ? [lost] : [])]);
+  try {
+    if (!device) {
+      const adapter = await wait(gpu.requestAdapter());
+      if (!adapter) return { status: 'unavailable', reason: 'adapter-unavailable' };
+      if (adapter.info?.isFallbackAdapter) return { status: 'unavailable', reason: 'software-adapter' };
+      hardware = publicProviderHardware(adapter.info);
+      device = await wait(adapter.requestDevice().then(created => {
+        if (finished) { created.destroy(); throw new Error('GPU signature acquisition expired'); }
+        return created;
+      }));
+    } else hardware = publicProviderHardware(device.adapterInfo);
+    active.add(device);
+    lost = device.lost.then(info => { throw new Error('GPU device lost: ' + info.reason); });
+    lost.catch(() => {});
+    const makeBuffer = (size, usage) => {
+      const buffer = device.createBuffer({ size, usage }); buffers.push(buffer); return buffer;
+    };
+    const outputBytes = (1 + 2 * policy.workgroups) * 4;
+    const params = makeBuffer(16, GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST);
+    const input = makeBuffer(policy.dataWords * 4, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST);
+    const result = makeBuffer(outputBytes, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST);
+    const readback = makeBuffer(outputBytes, GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST);
+    const data = Uint32Array.from({ length: policy.dataWords }, (_, i) => Math.imul(i + 1, 2654435761) >>> 0);
+    device.queue.writeBuffer(input, 0, data);
+    const module = device.createShaderModule({ code: gpuSignatureShader });
+    const pipeline = await wait(device.createComputePipelineAsync({ layout: 'auto', compute: { module, entryPoint: 'main' } }));
+    const bindings = device.createBindGroup({ layout: pipeline.getBindGroupLayout(0),
+      entries: [params, input, result].map((buffer, binding) => ({ binding, resource: { buffer } })) });
+    const samples = [];
+    for (let workload = 0; workload < policy.seeds.length; workload++) {
+      const seed = policy.seeds[workload], orders = [], checksums = [];
+      // Discard one dispatch per workload for compilation/initial scheduling effects.
+      for (let trial = -1; trial < policy.trials; trial++) {
+        signal?.throwIfAborted();
+        device.queue.writeBuffer(params, 0, new Uint32Array([seed, workload, 0, 0]));
+        device.queue.writeBuffer(result, 0, new Uint32Array(outputBytes / 4));
+        const encoder = device.createCommandEncoder(), pass = encoder.beginComputePass();
+        pass.setPipeline(pipeline); pass.setBindGroup(0, bindings); pass.dispatchWorkgroups(policy.workgroups); pass.end();
+        encoder.copyBufferToBuffer(result, 0, readback, 0, outputBytes);
+        device.queue.submit([encoder.finish()]);
+        await wait(readback.mapAsync(GPUMapMode.READ));
+        const words = new Uint32Array(readback.getMappedRange()).slice();
+        readback.unmap();
+        const order = Array.from(words.slice(1, 1 + policy.workgroups));
+        if (words[0] !== policy.workgroups || !permutation(order)) throw new Error('GPU signature dispatch returned incomplete results');
+        if (trial >= 0) { orders.push(order); checksums.push(Array.from(words.slice(1 + policy.workgroups))); }
+      }
+      samples.push({ workload, seed, orders, checksums });
+    }
+    signal?.throwIfAborted();
+    const signature = { schema: policy.schema, profile: policy.profile, status: 'measured',
+      source: 'local-webgpu', hardware, workgroups: policy.workgroups, trials: policy.trials,
+      collectedAt: new Date().toISOString(), elapsedMs: performance.now() - started,
+      allocationBytes: buffers.reduce((sum, buffer) => sum + buffer.size, 0), samples };
+    return { ...signature, statistics: summarize(signature) };
+  } finally {
+    finished = true;
+    clearTimeout(timer); signal?.removeEventListener('abort', cancel);
+    for (const buffer of buffers) buffer.destroy();
+    if (device) { active.delete(device); if (owned) device.destroy(); }
+  }
+}
+
+/** Distance is descriptive. Thresholds must be supplied with a calibration reference;
+ * no default threshold claims that a signature identifies a physical GPU.
+ */
+export function compareGpuSignatures(baseline, candidate, thresholds = null) {
+  if (!baseline || !candidate || baseline.status !== 'measured' || candidate.status !== 'measured') {
+    return { status: 'unmeasured', distance: null, reason: 'missing-measurement' };
+  }
+  if (baseline.profile !== candidate.profile || baseline.schema !== candidate.schema) {
+    return { status: 'uncertain', distance: null, reason: 'incompatible-profiles' };
+  }
+  const a = summarize(baseline), b = summarize(candidate);
+  const distance = Math.sqrt(a.means.reduce((sum, mean, i) => sum + (mean - b.means[i]) ** 2, 0) / a.means.length);
+  const variability = Math.sqrt([...a.deviations, ...b.deviations].reduce((sum, value) => sum + value ** 2, 0) / (a.means.length * 2));
+  if (!thresholds) return { status: 'uncertain', distance, variability, reason: 'calibration-required' };
+  const { calibrationId, consistentMax, changedMin } = thresholds;
+  if (typeof calibrationId !== 'string' || !calibrationId.trim() || !Number.isFinite(consistentMax)
+    || !Number.isFinite(changedMin) || consistentMax < 0 || changedMin <= consistentMax || changedMin > 1) {
+    throw new TypeError('GPU comparison needs calibrated distance thresholds and a calibrationId');
+  }
+  const status = distance <= consistentMax ? 'consistent' : distance >= changedMin ? 'changed' : 'uncertain';
+  return { status, distance, variability, calibrationId, consistentMax, changedMin, reason: 'signature-distance-only' };
+}

package/packages/reploid/src/mesh/gpu-signature.policy.json

@@ -0,0 +1,11 @@
+{
+  "schema": "reploid.gpu-order-signature/v1",
+  "profile": "atomic-finish-order-v1",
+  "workgroups": 64,
+  "lanes": 32,
+  "iterations": 128,
+  "trials": 16,
+  "seeds": [305419896, 2654435769],
+  "dataWords": 4096,
+  "timeoutMs": 5000
+}

package/packages/reploid/src/mesh/index.js

@@ -0,0 +1,66 @@
+export { createPeerGenerationMesh } from './peer-generation.js';
+export { identifyComputer, participantLabel } from './computer-identity.js';
+export { captureGpuSignature, compareGpuSignatures } from './gpu-signature.js';
+export { projectPlacementBeliefs, resolvePlacementBeliefPolicy } from './placement-beliefs.js';
+export * from './swarm-coordination.js';
+export * from './partitions/partition-runner.js';
+export * from './partitions/partition-step-receiver.js';
+export * from './contribution.js';
+export { default as contributionPolicy } from './contribution.js';
+export { default as swarmCoordination } from './swarm-coordination.js';
+import routing from '../rules/routing.rules.json' with { type: 'json' };
+import { requireResolvedConfig, snapshotJson } from '../config/index.js';
+
+export function createIntelligenceMesh({ config, ports }) {
+  const policy = requireResolvedConfig(config);
+  if (typeof ports?.authorize !== 'function') throw new TypeError('Mesh host authorization is required');
+  const order = routing.rules.find(rule => rule.id === policy.mesh.routing).order;
+  let closed = false;
+  return Object.freeze({
+    async connect() {
+      if (closed || !policy.mesh.enabled) throw new Error('Mesh connection is disabled');
+      if (await ports.authorize({ action: 'mesh.connect', roomId: policy.mesh.roomId }) !== true) throw new Error('Host denied mesh connection');
+      if (!ports.remote?.connect) throw new Error('A configured protocol adapter is required');
+      return ports.remote.connect();
+    },
+    async generate(messages, onUpdate, { signal } = {}) {
+      if (closed) throw new Error('Mesh is closed');
+      signal?.throwIfAborted();
+      for (const placement of order) {
+        const provider = ports[placement];
+        if (!provider) continue;
+        if (placement === 'remote' && (!policy.mesh.enabled || !provider.hasAvailableProvider?.())) continue;
+        if (await ports.authorize({ action: 'mesh.place', placement, contract: policy.models.contract }) !== true) continue;
+        // Placement is chosen before execution. Execution failure never silently
+        // retries private data on another provider.
+        return provider.generate(snapshotJson(messages), onUpdate, { signal });
+      }
+      throw new Error('No authorized compatible execution placement');
+    },
+    describe() {
+      return snapshotJson({ schema: 'reploid.mesh-state/v1', enabled: policy.mesh.enabled,
+        permissions: { executeJobs: policy.mesh.executeJobs, supplyArtifacts: policy.mesh.supplyArtifacts, shareCandidates: policy.mesh.shareCandidates },
+        local: !!ports.local, remote: ports.remote?.getSwarmSnapshot?.() || null, modelContract: policy.models.contract,
+        publicQualification: null });
+    },
+    async close() { closed = true; }
+  });
+}
+
+export * from './partitions/resident-partition.js';
+export * from './partitions/partition-grants.js';
+export * from './partitions/partition-stage-commit.js';
+export * from './partitions/partition-peer.js';
+export * from './partitions/partition-network.js';
+export * from './partitions/partition-chat.js';
+export { partitionFingerprint, PARTITION_ROUTE_SCHEMA, ROUTE_ATTEMPT_SCHEMA, validatePartitionRoute,
+  canonicalRouteAttemptBinding, sameRouteAttemptIdentity } from './partitions/partition-contract.js';
+export { selectPartitionRoute, validateOrderedPartitionCapability } from './partitions/partition-placement.js';
+
+export * from './partitions/partition-entry.js';
+export * from './partitions/partition-attempt-evidence.js';
+export * from './partitions/partition-link.js';
+
+export * from './partitions/automatic-partitions.js';
+export * from './partitions/signed-resident-factory.js';
+export * from './partitions/partition-preparation-progress.js';