@kaminos/webgpu-inference-kit 0.1.3 → 0.1.5

package/README.md

@@ -31,7 +31,7 @@ import {
 - What route is being invoked, such as MoGE depth/normal or SHARP image-to-splat.
 - Which browser WebGPU adapter, device features, limits, and timestamp capabilities were actually available.
 - Which kernel/profile variant ran, and which stages are required for a useful runtime profile.
-- How a route was scheduled: throughput mode, cooperative/yield posture, phase chunk sizes, submitted-work waits, and unsupported scheduler fields.
+- How a route was scheduled: throughput mode, cooperative/yield posture, breathability spans, yield checkpoints, phase chunk sizes, submitted-work waits, and unsupported scheduler fields.
 - Which artifacts went in and out, so downstream consumers can join routes without losing identity.
 
 The immediate goal is practical composition inside Kaminos: MoGE can become a local geometry/depth route, SHARP can emit splat candidates, Kimodo can emit motion clips, SF3D can emit meshes, and pipeline/commoner code can consume those outputs through one route grammar. The longer-term opportunity is a browser-native inference runtime kit that makes future image generators, 3D generators, and possibly language-model routes easier to seat without rebuilding the same WebGPU plumbing from scratch.
@@ -46,7 +46,7 @@ So the intended stack is:
 
 1. **Route boundary:** define callable browser-local inference routes with stable input/output roles.
 2. **Runtime profile:** preserve adapter/device/kernel/stage identity for the run that actually happened.
-3. **Scheduler/backpressure profile:** expose whether the route is throughput-oriented, cooperative, furnace-class, warm, cached, or frame-tail-sensitive.
+3. **Scheduler/backpressure profile:** expose whether the route is throughput-oriented, cooperative, furnace-class, warm, cached, frame-tail-sensitive, and where it can honestly yield.
 4. **Receipt and classification:** reject stale, fallback, partial, mismatched, or invalid route output before another system treats it as authoritative.
 
 The fourth layer protects the first three. It should not swallow the whole story.
@@ -63,7 +63,7 @@ The fourth layer protects the first three. It should not swallow the whole story
 - `createStagedSubmitProfile(input)`, `addStagedSubmitStage(profile, stage)`, `finishStagedSubmitProfile(profile)`, and `validateStagedSubmitProfile(profile)`: describe staged queue-submit timing in a way that can be compared across routes.
 - `createKernelProfileMetadata(input)` and `createRouteKernelProfileMetadata(input)`: normalize kit version, kernel profile, commit, required stages, and timing-source metadata for route definitions and receipts.
 - `createWebGpuRuntimeProfileInput(input)`, `createWebGpuRuntimeProfile(input)`, and `validateWebGpuRuntimeProfile(profile)`: combine effective backend identity, kernel metadata, staged profile, and route mode into one producer-side runtime profile object.
-- `createWebGpuRouteSchedulerProfile(input)` and `validateWebGpuRouteSchedulerProfile(profile)`: preserve requested versus effective scheduling, including throughput/cooperative mode, route-specific phase chunk sizes, submitted-work waits, yield cadence, and unsupported fields.
+- `createWebGpuRouteSchedulerProfile(input)` and `validateWebGpuRouteSchedulerProfile(profile)`: preserve requested versus effective scheduling, including throughput/cooperative mode, route-specific phase chunk sizes, submitted-work waits, yield cadence, breathability spans, yieldable checkpoints, non-preemptible GPU-submit spans, and unsupported fields.
 - `createWebGpuRouteBackpressureProfile(input)` and `validateWebGpuRouteBackpressureProfile(profile)`: record visible-wait/furnace pressure, warm/cache posture, memory-sharing posture, and frame-tail impact.
 - `defineTensorManifest(input)` and `validateTensorManifest(manifest)`: normalize tensor metadata including dtype sizes and byte lengths.
 - `createWebGpuLocalRouteReceipt(input)`, `createWebGpuRouteReceiptFromArtifacts(input)`, `createRouteReceiptArtifacts(input)`, `finishAndValidateRouteProfile(input)`, `validateRouteReceipt(receipt)`, and `assertAuthoritativeRouteReceipt(receipt)`: shared receipt construction and validation helpers.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaminos/webgpu-inference-kit",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "private": false,
   "type": "module",
   "description": "Composable browser WebGPU inference route contracts, runtime profiles, and scheduler envelopes.",
@@ -21,6 +21,6 @@
     ".": "./src/index.js"
   },
   "scripts": {
-    "test": "node tests/receipt-contracts.mjs && node tests/tensor-manifest-contracts.mjs && node tests/gpu-environment-contracts.mjs && node tests/browser-device-context-contracts.mjs && node tests/staged-profile-contracts.mjs && node tests/kernel-profile-contracts.mjs && node tests/runtime-profile-contracts.mjs && node tests/scheduler-backpressure-contracts.mjs && node tests/route-schema-contracts.mjs && node tests/route-receipt-helper-contracts.mjs && node tests/route-receipt-consumer-contracts.mjs && node tests/moge-route-contracts.mjs && node tests/sharp-route-contracts.mjs && node tests/kimodo-route-contracts.mjs && node tests/sf3d-route-contracts.mjs && node tests/route-boundary-contracts.mjs"
+    "test": "node tests/receipt-contracts.mjs && node tests/tensor-manifest-contracts.mjs && node tests/gpu-environment-contracts.mjs && node tests/browser-device-context-contracts.mjs && node tests/staged-profile-contracts.mjs && node tests/kernel-profile-contracts.mjs && node tests/runtime-profile-contracts.mjs && node tests/scheduler-backpressure-contracts.mjs && node tests/scheduler-verification-receipt-contracts.mjs && node tests/route-schema-contracts.mjs && node tests/route-receipt-helper-contracts.mjs && node tests/route-receipt-consumer-contracts.mjs && node tests/moge-route-contracts.mjs && node tests/sharp-route-contracts.mjs && node tests/kimodo-route-contracts.mjs && node tests/sf3d-route-contracts.mjs && node tests/route-boundary-contracts.mjs"
   }
 }

package/src/index.js

@@ -49,6 +49,14 @@ export {
   WEBGPU_ROUTE_SCHEDULER_SCHEMA,
 } from './scheduler-backpressure.js';
 
+export {
+  SCHEDULER_EVENT_TRACE_SCHEMA,
+  SCHEDULER_VERIFICATION_RECEIPT_SCHEMA,
+  classifySchedulerVerificationReceipt,
+  createSchedulerVerificationReceipt,
+  validateSchedulerVerificationReceipt,
+} from './scheduler-verification-receipt.js';
+
 export {
   classifyWebGpuRouteReceiptEvidence,
   classifyWebGpuRouteWorkerResultEvidence,

package/src/kernel-profile.js

@@ -1,4 +1,4 @@
-export const WEBGPU_INFERENCE_KIT_VERSION = '0.1.3';
+export const WEBGPU_INFERENCE_KIT_VERSION = '0.1.5';
 const DEFAULT_KIT_VERSION = WEBGPU_INFERENCE_KIT_VERSION;
 const DEFAULT_TIMING_SOURCE = 'queue-submit-wait';
 

package/src/kimodo-route.js

@@ -8,6 +8,10 @@ import {
   createRouteReceiptInputArtifact,
   createWebGpuRouteReceiptFromArtifacts,
 } from './route-receipt-helper.js';
+import {
+  createWebGpuRouteBackpressureProfile,
+  createWebGpuRouteSchedulerProfile,
+} from './scheduler-backpressure.js';
 
 export const KIMODO_TEXT_TO_MOTION_ROUTE_ID = 'kimodo.text-to-motion.webgpu-local.v0';
 const KIMODO_MODEL_ID = 'NVIDIA/Kimodo-SOMA-RP-v1.1';
@@ -19,6 +23,100 @@ const OUTPUT_ROLES = [
   { key: 'filmstrip', role: 'filmstrip', required: false },
 ];
 
+function createDefaultKimodoScheduler() {
+  return createWebGpuRouteSchedulerProfile({
+    requestedScheduler: {
+      mode: 'cooperative',
+      yieldMs: 4,
+      waitForSubmittedWorkDone: true,
+      phaseChunkSize: {
+        'text-embedding': 1,
+        'ddim-sampling': 1,
+        'fk-decode': 1,
+        'output-capture': 1,
+      },
+    },
+    effectiveScheduler: {
+      mode: 'cooperative',
+      yieldMs: 4,
+      waitForSubmittedWorkDone: true,
+      phaseChunkSize: {
+        'text-embedding': 1,
+        'ddim-sampling': 1,
+        'fk-decode': 1,
+        'output-capture': 1,
+      },
+      unsupportedFields: [],
+    },
+    verificationState: 'scheduler-unverified',
+    breathability: {
+      spans: [
+        {
+          name: 'text-embedding',
+          stage: 'text-embedding',
+          kind: 'external-bound',
+          interruptible: false,
+          canYieldBefore: true,
+          canYieldAfter: true,
+        },
+        {
+          name: 'ddim-sampling-loop',
+          stage: 'ddim-sampling',
+          kind: 'gpu-submit-loop',
+          interruptible: false,
+          canYieldBefore: true,
+          canYieldAfter: true,
+          nonInterruptibleReason: 'Each diffusion step submit is non-preemptible; cooperative yielding occurs between steps.',
+          metadata: { checkpointCadence: 'per-diffusion-step' },
+        },
+        {
+          name: 'fk-decode',
+          stage: 'fk-decode',
+          kind: 'cpu-bound',
+          interruptible: true,
+          canYieldBefore: true,
+          canYieldAfter: true,
+        },
+        {
+          name: 'output-capture',
+          stage: 'output-capture',
+          kind: 'readback-bound',
+          interruptible: false,
+          canYieldBefore: true,
+          canYieldAfter: true,
+        },
+      ],
+      checkpoints: [
+        {
+          name: 'between-diffusion-steps',
+          kind: 'diffusion-step',
+          afterStage: 'ddim-sampling',
+          yieldable: true,
+          waitsForSubmittedWorkDone: true,
+          metadata: { cadence: 'per-step' },
+        },
+        {
+          name: 'after-output-capture',
+          kind: 'readback',
+          afterStage: 'output-capture',
+          yieldable: true,
+          waitsForSubmittedWorkDone: true,
+        },
+      ],
+      notes: 'Kimodo can expose useful cooperative pressure between diffusion steps; each submitted step remains non-preemptible.',
+    },
+  });
+}
+
+function createDefaultKimodoBackpressure() {
+  return createWebGpuRouteBackpressureProfile({
+    requestedBudget: 'visible-wait',
+    effectiveBudget: 'visible-wait',
+    memoryExclusivity: 'shared',
+    warmCacheState: 'unknown',
+  });
+}
+
 export function createKimodoTextToMotionRouteReceipt(input) {
   if (!input || typeof input !== 'object') throw new Error('input must be an object');
   if (!input.input?.artifactId || !input.input?.sha256) {
@@ -75,6 +173,8 @@ export function createKimodoTextToMotionRouteDefinition(input = {}) {
     requiredFeatures: input.requiredFeatures || [],
     requiredStages: routeMetadata.requiredStages,
     timingSource: routeMetadata.timingSource,
+    scheduler: input.scheduler || createDefaultKimodoScheduler(),
+    backpressure: input.backpressure || createDefaultKimodoBackpressure(),
     worker: input.worker || {
       exportName: 'runKimodoTextToMotionRoute',
       textEmbedding: 'external-llama3-8b',

package/src/moge-route.js

@@ -8,6 +8,10 @@ import {
   createRouteReceiptInputArtifact,
   createWebGpuRouteReceiptFromArtifacts,
 } from './route-receipt-helper.js';
+import {
+  createWebGpuRouteBackpressureProfile,
+  createWebGpuRouteSchedulerProfile,
+} from './scheduler-backpressure.js';
 
 export const MOGE_DEPTH_NORMAL_ROUTE_ID = 'moge.depth-normal.webgpu-local.v0';
 const MOGE_MODEL_ID = 'Ruicheng/moge-2-vitl-normal';
@@ -20,6 +24,80 @@ const OUTPUT_ROLES = [
   { key: 'mask', role: 'mask', required: false },
 ];
 
+function createDefaultMogeScheduler() {
+  return createWebGpuRouteSchedulerProfile({
+    requestedScheduler: {
+      mode: 'cooperative',
+      yieldMs: 4,
+      waitForSubmittedWorkDone: true,
+      phaseChunkSize: {
+        backbone: 1,
+        'decoder-heads': 1,
+        'output-readback': 1,
+      },
+    },
+    effectiveScheduler: {
+      mode: 'cooperative',
+      yieldMs: 4,
+      waitForSubmittedWorkDone: true,
+      phaseChunkSize: {
+        backbone: 1,
+        'decoder-heads': 1,
+        'output-readback': 1,
+      },
+      unsupportedFields: [],
+    },
+    verificationState: 'scheduler-unverified',
+    breathability: {
+      spans: [
+        {
+          name: 'backbone-submit',
+          stage: 'backbone',
+          kind: 'gpu-submit-bound',
+          interruptible: false,
+          canYieldBefore: true,
+          canYieldAfter: true,
+          nonInterruptibleReason: 'GPU command buffers cannot be preempted after submit',
+        },
+        {
+          name: 'decoder-heads-submit',
+          stage: 'decoder-heads',
+          kind: 'gpu-submit-bound',
+          interruptible: false,
+          canYieldBefore: true,
+          canYieldAfter: true,
+          nonInterruptibleReason: 'GPU command buffers cannot be preempted after submit',
+        },
+        {
+          name: 'output-readback',
+          stage: 'output-readback',
+          kind: 'readback-bound',
+          interruptible: false,
+          canYieldBefore: true,
+          canYieldAfter: true,
+        },
+      ],
+      checkpoints: REQUIRED_STAGES.map(stage => ({
+        name: `after-${stage}`,
+        kind: stage === 'output-readback' ? 'readback' : 'stage-boundary',
+        afterStage: stage,
+        yieldable: true,
+        waitsForSubmittedWorkDone: true,
+      })),
+      notes: 'MoGE can cooperate between staged submits and readback, not inside a submitted GPU pass.',
+    },
+  });
+}
+
+function createDefaultMogeBackpressure() {
+  return createWebGpuRouteBackpressureProfile({
+    requestedBudget: 'visible-wait',
+    effectiveBudget: 'visible-wait',
+    memoryExclusivity: 'shared',
+    warmCacheState: 'unknown',
+  });
+}
+
 export function createMogeDepthNormalRouteReceipt(input) {
   if (!input || typeof input !== 'object') throw new Error('input must be an object');
   if (!input.input?.artifactId || !input.input?.sha256) {
@@ -77,6 +155,8 @@ export function createMogeDepthNormalRouteDefinition(input = {}) {
     requiredFeatures: input.requiredFeatures || [],
     requiredStages: routeMetadata.requiredStages,
     timingSource: routeMetadata.timingSource,
+    scheduler: input.scheduler || createDefaultMogeScheduler(),
+    backpressure: input.backpressure || createDefaultMogeBackpressure(),
     worker: input.worker || {
       exportName: 'runMogeDepthNormalRoute',
     },

package/src/route-boundary.js

@@ -3,6 +3,10 @@ import {
   assertAuthoritativeRouteReceipt,
   validateRouteReceipt,
 } from './route-receipt.js';
+import {
+  validateWebGpuRouteBackpressureProfile,
+  validateWebGpuRouteSchedulerProfile,
+} from './scheduler-backpressure.js';
 
 export const WEBGPU_ROUTE_DEFINITION_SCHEMA = 'kaminos.webgpu-route-definition.v0';
 export const WEBGPU_ROUTE_REQUEST_SCHEMA = 'kaminos.webgpu-route-request.v0';
@@ -12,6 +16,18 @@ function clone(value) {
   return value == null ? value : JSON.parse(JSON.stringify(value));
 }
 
+function stableJson(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map(key => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function deepEqual(a, b) {
+  return stableJson(a) === stableJson(b);
+}
+
 function isNonEmptyString(value) {
   return typeof value === 'string' && value.trim().length > 0;
 }
@@ -190,6 +206,8 @@ export function defineWebGpuRoute(input) {
     requiredFeatures: Array.isArray(input.requiredFeatures) ? [...input.requiredFeatures].map(String).sort() : [],
     requiredStages: Array.isArray(input.requiredStages) ? [...input.requiredStages] : [],
     timingSource: input.timingSource || 'queue-submit-wait',
+    scheduler: clone(input.scheduler || null),
+    backpressure: clone(input.backpressure || null),
     worker: clone(input.worker || null),
   };
 }
@@ -237,6 +255,16 @@ export function validateRouteDefinition(route) {
   }
   if (!isNonEmptyString(route.timingSource)) errors.push('timingSource must be a non-empty string');
 
+  if (route.scheduler != null) {
+    const schedulerResult = validateWebGpuRouteSchedulerProfile(route.scheduler);
+    if (!schedulerResult.ok) errors.push(...schedulerResult.errors.map(error => `scheduler.${error}`));
+  }
+
+  if (route.backpressure != null) {
+    const backpressureResult = validateWebGpuRouteBackpressureProfile(route.backpressure);
+    if (!backpressureResult.ok) errors.push(...backpressureResult.errors.map(error => `backpressure.${error}`));
+  }
+
   return { ok: errors.length === 0, errors };
 }
 
@@ -293,6 +321,8 @@ export function createRouteInvocationRequest(route, input) {
     routeConfig: clone(input.routeConfig || {}),
     model: clone(route.model),
     kernel: clone(route.kernel),
+    scheduler: clone(route.scheduler || null),
+    backpressure: clone(route.backpressure || null),
     createdAt: input.createdAt || new Date().toISOString(),
   };
 }
@@ -315,6 +345,30 @@ export function validateRouteInvocationRequest(request, route) {
     validateArtifacts(errors, request.outputs, route.outputRoles, 'outputs', { requireHash: false });
   }
 
+  if (request.scheduler != null) {
+    const schedulerResult = validateWebGpuRouteSchedulerProfile(request.scheduler);
+    if (!schedulerResult.ok) errors.push(...schedulerResult.errors.map(error => `scheduler.${error}`));
+  }
+  if (route?.scheduler != null) {
+    if (request.scheduler == null) {
+      errors.push('scheduler must match route definition');
+    } else if (!deepEqual(request.scheduler, route.scheduler)) {
+      errors.push('scheduler must match route definition');
+    }
+  }
+
+  if (request.backpressure != null) {
+    const backpressureResult = validateWebGpuRouteBackpressureProfile(request.backpressure);
+    if (!backpressureResult.ok) errors.push(...backpressureResult.errors.map(error => `backpressure.${error}`));
+  }
+  if (route?.backpressure != null) {
+    if (request.backpressure == null) {
+      errors.push('backpressure must match route definition');
+    } else if (!deepEqual(request.backpressure, route.backpressure)) {
+      errors.push('backpressure must match route definition');
+    }
+  }
+
   return { ok: errors.length === 0, errors };
 }
 

package/src/route-receipt-consumer.js

@@ -20,6 +20,77 @@ function parseTime(value) {
   return Number.isFinite(ms) ? ms : null;
 }
 
+function clone(value) {
+  return value == null ? value : JSON.parse(JSON.stringify(value));
+}
+
+const FALSE_VERIFIED_SCHEDULER_DOWNGRADES = new Set([
+  'yield-events-missing',
+  'event-trace-missing',
+  'queue-wait-events-missing',
+  'boundary-assertion-event-mismatch',
+  'requested-boundary-assertion-missing',
+  'requested-field-dropped-without-unsupported',
+  'boundary-assertions-missing',
+  'timing-proxy-only',
+  'route-identity-missing',
+  'scheduler-envelope-missing',
+  'backpressure-envelope-missing',
+]);
+
+function nestedSchedulerDowngrades(schedulerVerification) {
+  return Array.isArray(schedulerVerification?.downgrades)
+    ? [...schedulerVerification.downgrades]
+    : [];
+}
+
+function hasVerifiedBoundaryAssertion(schedulerVerification) {
+  return Array.isArray(schedulerVerification?.boundaryAssertions)
+    && schedulerVerification.boundaryAssertions.some(assertion => assertion?.status === 'verified');
+}
+
+function hasEventTraceEvents(schedulerVerification) {
+  return Array.isArray(schedulerVerification?.eventTrace?.events)
+    && schedulerVerification.eventTrace.events.length > 0;
+}
+
+function normalizeNestedSchedulerVerification(schedulerVerification) {
+  if (!schedulerVerification) {
+    return {
+      receipt: null,
+      reportedStatus: null,
+      status: null,
+      classification: null,
+      observationClass: null,
+      downgrades: [],
+      timingAuthority: null,
+    };
+  }
+  const receipt = clone(schedulerVerification);
+  const downgrades = nestedSchedulerDowngrades(schedulerVerification);
+  const reportedStatus = schedulerVerification.status || null;
+  const falseVerifiedDowngrade = downgrades.some(downgrade => FALSE_VERIFIED_SCHEDULER_DOWNGRADES.has(downgrade));
+  const falseVerifiedShape = reportedStatus === 'verified'
+    && (!hasEventTraceEvents(schedulerVerification) || !hasVerifiedBoundaryAssertion(schedulerVerification));
+  const status = reportedStatus === 'verified' && (falseVerifiedDowngrade || falseVerifiedShape)
+    ? 'scheduler-unverified'
+    : reportedStatus;
+  if (status !== reportedStatus) {
+    receipt.reportedStatus = reportedStatus;
+    receipt.status = status;
+    if (receipt.classification === 'observed-boundary') receipt.classification = 'config-only';
+  }
+  return {
+    receipt,
+    reportedStatus,
+    status,
+    classification: receipt.classification || null,
+    observationClass: receipt.observationClass || null,
+    downgrades,
+    timingAuthority: receipt.eventTrace?.timingAuthority || null,
+  };
+}
+
 function staleReason(receipt, options) {
   if (!Number.isFinite(options.maxAgeMs)) return null;
   const createdMs = parseTime(receipt.createdAt);
@@ -119,6 +190,7 @@ export function classifyWebGpuRouteReceiptEvidence(receipt, options = {}) {
   const base = baseClassification(receipt, options);
   const scheduler = receipt?.runtime?.scheduler || null;
   const backpressure = receipt?.runtime?.backpressure || null;
+  const schedulerVerification = normalizeNestedSchedulerVerification(receipt?.runtime?.schedulerVerification || null);
   return {
     schema: WEBGPU_ROUTE_EVIDENCE_CLASSIFICATION_SCHEMA,
     classification: base.classification,
@@ -131,7 +203,14 @@ export function classifyWebGpuRouteReceiptEvidence(receipt, options = {}) {
     adapterName: receipt?.backend?.adapterName || null,
     timingSource: receipt?.timings?.source || receipt?.timings?.profile?.timingSource || null,
     totalMs: Number.isFinite(receipt?.timings?.totalMs) ? receipt.timings.totalMs : null,
-    schedulerVerificationState: scheduler?.verificationState || null,
+    schedulerVerification: schedulerVerification.receipt,
+    schedulerVerificationState: schedulerVerification.status || scheduler?.verificationState || null,
+    schedulerVerificationStatus: schedulerVerification.status,
+    schedulerVerificationReportedStatus: schedulerVerification.reportedStatus,
+    schedulerVerificationClassification: schedulerVerification.classification,
+    schedulerVerificationObservationClass: schedulerVerification.observationClass,
+    schedulerVerificationDowngrades: schedulerVerification.downgrades,
+    schedulerVerificationEventTraceTimingAuthority: schedulerVerification.timingAuthority,
     schedulerMode: scheduler?.effectiveScheduler?.mode || scheduler?.requestedScheduler?.mode || null,
     schedulerUnsupportedFields: Array.isArray(scheduler?.effectiveScheduler?.unsupportedFields)
       ? [...scheduler.effectiveScheduler.unsupportedFields]

package/src/scheduler-backpressure.js

@@ -6,6 +6,24 @@ const VERIFICATION_STATES = new Set(['verified', 'scheduler-unverified', 'unsupp
 const BUDGETS = new Set(['interactive', 'visible-wait', 'furnace', 'batch', 'unknown']);
 const MEMORY_EXCLUSIVITY = new Set(['shared', 'exclusive', 'unknown']);
 const WARM_CACHE_STATES = new Set(['cold', 'warm', 'hot', 'unknown']);
+const BREATHABILITY_SPAN_KINDS = new Set([
+  'gpu-submit-bound',
+  'gpu-submit-loop',
+  'readback-bound',
+  'js-yieldable',
+  'cpu-bound',
+  'external-bound',
+  'unknown',
+]);
+const BREATHABILITY_CHECKPOINT_KINDS = new Set([
+  'pre-submit',
+  'post-submit',
+  'stage-boundary',
+  'diffusion-step',
+  'readback',
+  'external-callback',
+  'unknown',
+]);
 
 function clone(value) {
   return value == null ? value : JSON.parse(JSON.stringify(value));
@@ -53,6 +71,41 @@ function normalizeEffectiveScheduler(input = {}, requestedScheduler) {
   };
 }
 
+function normalizeBreathabilitySpan(input = {}) {
+  return {
+    name: input.name,
+    stage: input.stage || null,
+    kind: input.kind || 'unknown',
+    interruptible: Boolean(input.interruptible),
+    canYieldBefore: Boolean(input.canYieldBefore),
+    canYieldAfter: Boolean(input.canYieldAfter),
+    nonInterruptibleReason: input.nonInterruptibleReason || null,
+    metadata: isPlainObject(input.metadata) ? clone(input.metadata) : {},
+  };
+}
+
+function normalizeBreathabilityCheckpoint(input = {}) {
+  return {
+    name: input.name,
+    kind: input.kind || 'unknown',
+    beforeStage: input.beforeStage || null,
+    afterStage: input.afterStage || null,
+    yieldable: Boolean(input.yieldable),
+    waitsForSubmittedWorkDone: Boolean(input.waitsForSubmittedWorkDone),
+    metadata: isPlainObject(input.metadata) ? clone(input.metadata) : {},
+  };
+}
+
+function normalizeBreathability(input = {}) {
+  return {
+    spans: Array.isArray(input.spans) ? input.spans.map(normalizeBreathabilitySpan) : [],
+    checkpoints: Array.isArray(input.checkpoints)
+      ? input.checkpoints.map(normalizeBreathabilityCheckpoint)
+      : [],
+    notes: input.notes || null,
+  };
+}
+
 function validateSchedulerShape(errors, scheduler, label) {
   if (!isPlainObject(scheduler)) {
     errors.push(`${label} must be an object`);
@@ -79,6 +132,59 @@ function validateSchedulerShape(errors, scheduler, label) {
   }
 }
 
+function validateBreathability(errors, breathability) {
+  if (breathability == null) return;
+  if (!isPlainObject(breathability)) {
+    errors.push('breathability must be an object');
+    return;
+  }
+  if (!Array.isArray(breathability.spans)) {
+    errors.push('breathability.spans must be an array');
+  } else {
+    breathability.spans.forEach((span, index) => {
+      const path = `breathability.spans[${index}]`;
+      if (!isNonEmptyString(span?.name)) errors.push(`${path}.name must be a non-empty string`);
+      if (span?.stage != null && !isNonEmptyString(span.stage)) errors.push(`${path}.stage must be null or a non-empty string`);
+      if (!BREATHABILITY_SPAN_KINDS.has(span?.kind)) errors.push(`${path}.kind has unsupported value`);
+      if (typeof span?.interruptible !== 'boolean') errors.push(`${path}.interruptible must be a boolean`);
+      if (typeof span?.canYieldBefore !== 'boolean') errors.push(`${path}.canYieldBefore must be a boolean`);
+      if (typeof span?.canYieldAfter !== 'boolean') errors.push(`${path}.canYieldAfter must be a boolean`);
+      if (span?.nonInterruptibleReason != null && !isNonEmptyString(span.nonInterruptibleReason)) {
+        errors.push(`${path}.nonInterruptibleReason must be null or a non-empty string`);
+      }
+      if (!isPlainObject(span?.metadata)) errors.push(`${path}.metadata must be an object`);
+      if ((span?.kind === 'gpu-submit-bound' || span?.kind === 'gpu-submit-loop') && span.interruptible) {
+        errors.push(`${path}.${span.kind} cannot be interruptible after GPU submit`);
+      }
+    });
+  }
+
+  if (!Array.isArray(breathability.checkpoints)) {
+    errors.push('breathability.checkpoints must be an array');
+  } else {
+    breathability.checkpoints.forEach((checkpoint, index) => {
+      const path = `breathability.checkpoints[${index}]`;
+      if (!isNonEmptyString(checkpoint?.name)) errors.push(`${path}.name must be a non-empty string`);
+      if (!BREATHABILITY_CHECKPOINT_KINDS.has(checkpoint?.kind)) errors.push(`${path}.kind has unsupported value`);
+      if (checkpoint?.beforeStage != null && !isNonEmptyString(checkpoint.beforeStage)) {
+        errors.push(`${path}.beforeStage must be null or a non-empty string`);
+      }
+      if (checkpoint?.afterStage != null && !isNonEmptyString(checkpoint.afterStage)) {
+        errors.push(`${path}.afterStage must be null or a non-empty string`);
+      }
+      if (typeof checkpoint?.yieldable !== 'boolean') errors.push(`${path}.yieldable must be a boolean`);
+      if (typeof checkpoint?.waitsForSubmittedWorkDone !== 'boolean') {
+        errors.push(`${path}.waitsForSubmittedWorkDone must be a boolean`);
+      }
+      if (!isPlainObject(checkpoint?.metadata)) errors.push(`${path}.metadata must be an object`);
+    });
+  }
+
+  if (breathability.notes != null && !isNonEmptyString(breathability.notes)) {
+    errors.push('breathability.notes must be null or a non-empty string');
+  }
+}
+
 function missingUnsupportedField(effectiveScheduler, field) {
   return !effectiveScheduler.unsupportedFields.includes(field)
     && !effectiveScheduler.unsupportedFields.includes('phaseChunkSize');
@@ -98,6 +204,7 @@ export function createWebGpuRouteSchedulerProfile(input = {}) {
     requestedScheduler,
     effectiveScheduler,
     verificationState,
+    breathability: normalizeBreathability(input.breathability),
   };
 
   const result = validateWebGpuRouteSchedulerProfile(profile);
@@ -115,6 +222,7 @@ export function validateWebGpuRouteSchedulerProfile(profile) {
   }
   validateSchedulerShape(errors, profile.requestedScheduler, 'requestedScheduler');
   validateSchedulerShape(errors, profile.effectiveScheduler, 'effectiveScheduler');
+  validateBreathability(errors, profile.breathability);
 
   if (!Array.isArray(profile.effectiveScheduler?.unsupportedFields)) {
     errors.push('effectiveScheduler.unsupportedFields must be an array');

package/src/scheduler-verification-receipt.js

@@ -0,0 +1,442 @@
+export const SCHEDULER_VERIFICATION_RECEIPT_SCHEMA = 'kaminos.webgpu-scheduler-verification-receipt.v0';
+export const SCHEDULER_EVENT_TRACE_SCHEMA = 'kaminos.webgpu-scheduler-event-trace.v0';
+
+const LEGACY_PHASE_FIELD_ALIASES = {
+  spnPatch: ['phaseChunkSize.spnPatch', 'spnPatchChunkSize'],
+  vitBlock: ['phaseChunkSize.vitBlock', 'vitBlockChunkSize'],
+};
+
+function cloneJson(value) {
+  return value == null ? value : JSON.parse(JSON.stringify(value));
+}
+
+function uniq(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+
+function asObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function legacyDirectKey(key) {
+  if (key === 'spnPatch') return 'spnPatchChunkSize';
+  if (key === 'vitBlock') return 'vitBlockChunkSize';
+  return null;
+}
+
+function canonicalPhaseField(key) {
+  return `phaseChunkSize.${key}`;
+}
+
+function knownPhaseKeys(scheduler = {}) {
+  const phaseChunkSize = asObject(scheduler.phaseChunkSize);
+  return uniq([
+    ...Object.keys(phaseChunkSize),
+    ...Object.keys(LEGACY_PHASE_FIELD_ALIASES).filter(key => Number.isFinite(scheduler[legacyDirectKey(key)])),
+  ]);
+}
+
+function phaseValue(scheduler = {}, key) {
+  const phaseChunkSize = asObject(scheduler.phaseChunkSize);
+  if (Number.isFinite(phaseChunkSize[key])) return phaseChunkSize[key];
+  const directKey = legacyDirectKey(key);
+  return directKey && Number.isFinite(scheduler[directKey]) ? scheduler[directKey] : undefined;
+}
+
+function requestedPhaseFields(requestedScheduler = {}) {
+  return knownPhaseKeys(requestedScheduler)
+    .map(key => {
+      const value = phaseValue(requestedScheduler, key);
+      return Number.isFinite(value) && value > 0 ? { key, field: canonicalPhaseField(key), value } : null;
+    })
+    .filter(Boolean);
+}
+
+function unsupportedFieldsFrom(input = {}) {
+  const scheduler = asObject(input.scheduler);
+  const effectiveScheduler = asObject(scheduler.effectiveScheduler);
+  return uniq([
+    ...(Array.isArray(input.unsupportedFields) ? input.unsupportedFields : []),
+    ...(Array.isArray(scheduler.unsupportedFields) ? scheduler.unsupportedFields : []),
+    ...(Array.isArray(effectiveScheduler.unsupportedFields) ? effectiveScheduler.unsupportedFields : []),
+  ]);
+}
+
+function aliasesForPhaseKey(key) {
+  return uniq([
+    canonicalPhaseField(key),
+    ...(LEGACY_PHASE_FIELD_ALIASES[key] || []),
+  ]);
+}
+
+function unsupportedCovers(fieldKey, unsupportedFields = []) {
+  const aliases = aliasesForPhaseKey(fieldKey);
+  return unsupportedFields.some(field => aliases.includes(field) || field === fieldKey || field === 'phaseChunkSize');
+}
+
+function eventKindCounts(events = []) {
+  return {
+    eventCount: events.length,
+    queueStartCount: events.filter(event => event?.kind === 'queue-work-done-start').length,
+    queueEndCount: events.filter(event => event?.kind === 'queue-work-done-end').length,
+    yieldStartCount: events.filter(event => event?.kind === 'js-yield-start').length,
+    yieldEndCount: events.filter(event => event?.kind === 'js-yield-end').length,
+    chunkCount: events.filter(event => event?.kind === 'chunk-start' || event?.boundary || event?.phase).length,
+  };
+}
+
+function normalizeEventTrace(eventTrace = {}) {
+  const events = Array.isArray(eventTrace.events) ? cloneJson(eventTrace.events) : [];
+  return {
+    schema: eventTrace.schema || SCHEDULER_EVENT_TRACE_SCHEMA,
+    clock: eventTrace.clock || 'performance.now',
+    timingAuthority: eventTrace.timingAuthority || 'not-observed',
+    events,
+  };
+}
+
+function normalizeFrameTail(frameTail = {}, eventTrace = {}) {
+  const evidenceSource = eventTrace.timingAuthority === 'raf-and-queue-proxy'
+    ? 'raf-and-queue-proxy'
+    : (frameTail.evidenceSource || eventTrace.timingAuthority || 'not-observed');
+  return {
+    evidenceSource,
+    disclaimer: frameTail.disclaimer || 'not-gpu-exclusive-or-present-latency',
+    rafFps: frameTail.rafFps ?? null,
+    frameP95Ms: frameTail.frameP95Ms ?? null,
+    queueDoneP95Ms: frameTail.queueDoneP95Ms ?? null,
+  };
+}
+
+function legacyBoundaryForPhaseKey(key) {
+  if (key === 'spnPatch') return 'spn-patch-chunk';
+  if (key === 'vitBlock') return 'vit-block-chunk';
+  return null;
+}
+
+function eventMatchesBoundary(event = {}, boundary) {
+  if (!boundary) return false;
+  return event.boundary === boundary
+    || event.phase === boundary
+    || event.stage === boundary
+    || event.name === boundary;
+}
+
+function eventMatchesPhaseKey(event = {}, key) {
+  return event.phase === key
+    || event.stage === key
+    || event.boundary === key
+    || event.boundary === `moge-stage:${key}`
+    || event.boundary === `stage:${key}`;
+}
+
+function observedBoundaryForPhaseKey(key, events = []) {
+  const legacyBoundary = legacyBoundaryForPhaseKey(key);
+  if (legacyBoundary) return legacyBoundary;
+  const event = events.find(candidate => eventMatchesPhaseKey(candidate, key));
+  return event?.boundary || event?.phase || key;
+}
+
+function observedCountForPhaseKey(key, observedBoundary, events = []) {
+  return events.filter(event => eventMatchesBoundary(event, observedBoundary) || eventMatchesPhaseKey(event, key)).length;
+}
+
+function derivedAssertionStatus(key, observedCount, unsupported) {
+  if (unsupported) return 'unsupported';
+  if (observedCount <= 0) return 'unverified';
+  return legacyBoundaryForPhaseKey(key) ? 'verified' : 'observed';
+}
+
+function deriveBoundaryAssertions({
+  boundaryAssertions,
+  requestedScheduler,
+  effectiveScheduler,
+  unsupportedFields,
+  events,
+}) {
+  if (Array.isArray(boundaryAssertions) && boundaryAssertions.length) {
+    return cloneJson(boundaryAssertions).map(normalizeCallerBoundaryAssertion);
+  }
+  const counts = eventKindCounts(events);
+  return requestedPhaseFields(requestedScheduler).map(({ key, field, value }) => {
+    const effective = phaseValue(effectiveScheduler, key);
+    const unsupported = unsupportedCovers(key, unsupportedFields);
+    const observedBoundary = observedBoundaryForPhaseKey(key, events);
+    const observedCount = observedCountForPhaseKey(key, observedBoundary, events);
+    return {
+      field,
+      requested: value,
+      effective: Number.isFinite(effective) ? effective : null,
+      status: derivedAssertionStatus(key, observedCount, unsupported),
+      observedBoundary,
+      observedCount,
+      expectedMinimumCount: 1,
+      observedQueueWaitCount: Math.min(counts.queueStartCount, counts.queueEndCount),
+      observedYieldCount: Math.min(counts.yieldStartCount, counts.yieldEndCount),
+      unsupportedReason: unsupported ? 'effective scheduler declared this field unsupported' : null,
+    };
+  });
+}
+
+function fieldKeyForAssertion(assertion = {}) {
+  const field = assertion.field;
+  if (typeof field !== 'string') return null;
+  for (const [key, aliases] of Object.entries(LEGACY_PHASE_FIELD_ALIASES)) {
+    if (aliases.includes(field)) return key;
+  }
+  if (field.startsWith('phaseChunkSize.')) return field.slice('phaseChunkSize.'.length);
+  return null;
+}
+
+function fieldBoundaryForAssertion(assertion = {}) {
+  const key = fieldKeyForAssertion(assertion);
+  return key ? legacyBoundaryForPhaseKey(key) : null;
+}
+
+function expectedBoundaryForAssertion(assertion = {}) {
+  return fieldBoundaryForAssertion(assertion) || assertion.observedBoundary || null;
+}
+
+function assertionBoundaryConflictsWithField(assertion = {}) {
+  const fieldBoundary = fieldBoundaryForAssertion(assertion);
+  return Boolean(fieldBoundary && assertion.observedBoundary && assertion.observedBoundary !== fieldBoundary);
+}
+
+function assertionHasMatchingEvent(assertion = {}, events = []) {
+  const expectedBoundary = expectedBoundaryForAssertion(assertion);
+  if (!expectedBoundary) return false;
+  return events.some(event => eventMatchesBoundary(event, expectedBoundary));
+}
+
+function assertionObservesRequestedKey(assertion = {}, key, events = []) {
+  return (assertion?.status === 'verified' || assertion?.status === 'observed')
+    && fieldKeyForAssertion(assertion) === key
+    && !assertionBoundaryConflictsWithField(assertion)
+    && assertionHasMatchingEvent(assertion, events);
+}
+
+function assertionVerifiesRequestedKey(assertion = {}, key, events = []) {
+  return assertion?.status === 'verified'
+    && assertionObservesRequestedKey(assertion, key, events);
+}
+
+function normalizeCallerBoundaryAssertion(assertion = {}) {
+  const normalized = { ...assertion };
+  const key = fieldKeyForAssertion(normalized);
+  if (normalized.status === 'verified' && key && !legacyBoundaryForPhaseKey(key)) {
+    normalized.reportedStatus = normalized.reportedStatus || normalized.status;
+    normalized.status = 'observed';
+  }
+  return normalized;
+}
+
+function routeIsPresent(route = {}) {
+  return Boolean(route.pipelineId || route.requestedRouteId || route.effectiveRouteId || route.adapterReport?.path);
+}
+
+function waitRequested(scheduler = {}) {
+  return Boolean(scheduler.waitForSubmittedWorkDone);
+}
+
+function yieldRequested(scheduler = {}) {
+  return Number(scheduler.yieldMs || 0) > 0 || Number(scheduler.gaussianPhaseYieldMs || 0) > 0;
+}
+
+function droppedRequestedFields(requestedScheduler = {}, effectiveScheduler = {}, unsupportedFields = []) {
+  return requestedPhaseFields(requestedScheduler)
+    .filter(({ key }) => !Number.isFinite(phaseValue(effectiveScheduler, key)) && !unsupportedCovers(key, unsupportedFields))
+    .map(({ field }) => field);
+}
+
+function normalizeDowngrades(values) {
+  return uniq(values);
+}
+
+function deriveObservationClass({
+  status,
+  boundaryAssertions,
+  falseAuthorityChecks,
+  events,
+}) {
+  if (status === 'verified') return 'observed-scheduler-boundary';
+  if (falseAuthorityChecks.timingProxyOnly) return 'proxy-only';
+  if (!events.length) return 'config-only';
+  if (boundaryAssertions.some(assertion => assertion?.status === 'observed' || assertion?.status === 'verified')) {
+    return 'observed-stage-boundary';
+  }
+  return 'event-trace-only';
+}
+
+export function createSchedulerVerificationReceipt(input = {}) {
+  const route = cloneJson(asObject(input.route));
+  const scheduler = cloneJson(asObject(input.scheduler));
+  const backpressure = cloneJson(asObject(input.backpressure));
+  const requestedScheduler = asObject(scheduler.requestedScheduler);
+  const effectiveScheduler = asObject(scheduler.effectiveScheduler);
+  const unsupportedFields = unsupportedFieldsFrom({ ...input, scheduler });
+  const eventTrace = normalizeEventTrace(input.eventTrace);
+  const frameTail = normalizeFrameTail(input.frameTail || {}, eventTrace);
+  const events = eventTrace.events;
+  const counts = eventKindCounts(events);
+  const boundaryAssertions = deriveBoundaryAssertions({
+    boundaryAssertions: input.boundaryAssertions,
+    requestedScheduler,
+    effectiveScheduler,
+    unsupportedFields,
+    events,
+  });
+  const downgrades = Array.isArray(input.downgrades) ? [...input.downgrades] : [];
+  const falseAuthorityChecks = {
+    eventTraceMissing: false,
+    verifiedWithoutObservedBoundary: false,
+    timingProxyOnly: false,
+    queueWaitEventsMissing: false,
+    boundaryAssertionEventMismatch: false,
+    requestedBoundaryAssertionMissing: false,
+    requestedFieldDroppedWithoutUnsupported: false,
+    ...(asObject(input.falseAuthorityChecks)),
+  };
+
+  if (!routeIsPresent(route)) downgrades.push('route-identity-missing');
+  if (!scheduler.schema && !scheduler.requestedScheduler && !scheduler.effectiveScheduler) downgrades.push('scheduler-envelope-missing');
+  if (!backpressure.schema && Object.keys(backpressure).length === 0) downgrades.push('backpressure-envelope-missing');
+
+  const droppedFields = droppedRequestedFields(requestedScheduler, effectiveScheduler, unsupportedFields);
+  if (droppedFields.length) {
+    downgrades.push('requested-field-dropped-without-unsupported');
+    falseAuthorityChecks.requestedFieldDroppedWithoutUnsupported = true;
+  }
+
+  if (!events.length) {
+    downgrades.push('event-trace-missing');
+    falseAuthorityChecks.eventTraceMissing = true;
+  }
+
+  const verifiedAssertions = boundaryAssertions.filter(assertion => assertion?.status === 'verified');
+  const mismatchedVerifiedAssertions = verifiedAssertions.filter(assertion => (
+    assertionBoundaryConflictsWithField(assertion) || !assertionHasMatchingEvent(assertion, events)
+  ));
+  if (mismatchedVerifiedAssertions.length) {
+    downgrades.push('boundary-assertion-event-mismatch');
+    falseAuthorityChecks.boundaryAssertionEventMismatch = true;
+  }
+
+  const requestedBoundaryKeys = requestedPhaseFields(requestedScheduler)
+    .map(({ key }) => key)
+    .filter(key => !unsupportedCovers(key, unsupportedFields));
+  const missingRequestedBoundaryAssertions = requestedBoundaryKeys
+    .filter(key => !boundaryAssertions.some(assertion => assertionObservesRequestedKey(assertion, key, events)));
+  if (missingRequestedBoundaryAssertions.length) {
+    downgrades.push('requested-boundary-assertion-missing');
+    falseAuthorityChecks.requestedBoundaryAssertionMissing = true;
+  }
+  if (scheduler.verificationState === 'verified' && !verifiedAssertions.length) {
+    downgrades.push('boundary-assertions-missing');
+    falseAuthorityChecks.verifiedWithoutObservedBoundary = true;
+  }
+
+  if (eventTrace.timingAuthority === 'raf-and-queue-proxy') {
+    downgrades.push('timing-proxy-only');
+    falseAuthorityChecks.timingProxyOnly = true;
+  }
+
+  if (waitRequested(requestedScheduler) || waitRequested(effectiveScheduler)) {
+    const hasQueuePair = counts.queueStartCount > 0 && counts.queueEndCount > 0;
+    if (!hasQueuePair) {
+      downgrades.push('queue-wait-events-missing');
+      falseAuthorityChecks.queueWaitEventsMissing = true;
+    }
+  }
+
+  if (yieldRequested(requestedScheduler) || yieldRequested(effectiveScheduler)) {
+    const hasYieldPair = counts.yieldStartCount > 0 && counts.yieldEndCount > 0;
+    if (!hasYieldPair) downgrades.push('yield-events-missing');
+  }
+
+  const invalid = droppedFields.length > 0 || !routeIsPresent(route);
+  const unsupported = unsupportedFields.length > 0 || boundaryAssertions.some(assertion => assertion?.status === 'unsupported');
+  const verified = events.length > 0
+    && requestedBoundaryKeys.length > 0
+    && verifiedAssertions.length > 0
+    && requestedBoundaryKeys.every(key => verifiedAssertions.some(assertion => assertionVerifiesRequestedKey(assertion, key, events)))
+    && !falseAuthorityChecks.timingProxyOnly
+    && !falseAuthorityChecks.queueWaitEventsMissing
+    && !falseAuthorityChecks.boundaryAssertionEventMismatch
+    && !falseAuthorityChecks.requestedBoundaryAssertionMissing
+    && !falseAuthorityChecks.requestedFieldDroppedWithoutUnsupported
+    && !downgrades.includes('yield-events-missing');
+
+  let status = input.status || 'scheduler-unverified';
+  if (invalid) status = 'invalid';
+  else if (unsupported) status = 'unsupported';
+  else if (verified) status = 'verified';
+  else status = 'scheduler-unverified';
+
+  const classification = status === 'verified'
+    ? 'observed-boundary'
+    : (status === 'unsupported'
+        ? 'unsupported'
+        : (status === 'invalid'
+            ? 'invalid'
+            : (falseAuthorityChecks.timingProxyOnly ? 'damage-only' : 'config-only')));
+  const observationClass = deriveObservationClass({
+    status,
+    boundaryAssertions,
+    falseAuthorityChecks,
+    events,
+  });
+
+  return {
+    schema: SCHEDULER_VERIFICATION_RECEIPT_SCHEMA,
+    status,
+    classification,
+    observationClass,
+    route,
+    scheduler: {
+      ...scheduler,
+      unsupportedFields,
+    },
+    backpressure,
+    eventTrace,
+    boundaryAssertions,
+    frameTail,
+    downgrades: normalizeDowngrades(downgrades),
+    falseAuthorityChecks,
+  };
+}
+
+export function validateSchedulerVerificationReceipt(receipt = {}) {
+  const errors = [];
+  if (receipt.schema !== SCHEDULER_VERIFICATION_RECEIPT_SCHEMA) errors.push('schema-mismatch');
+  if (!routeIsPresent(receipt.route || {})) errors.push('route-identity-missing');
+  if (!receipt.scheduler || typeof receipt.scheduler !== 'object') errors.push('scheduler-envelope-missing');
+  if (!receipt.backpressure || typeof receipt.backpressure !== 'object') errors.push('backpressure-envelope-missing');
+  if (receipt.status === 'verified') {
+    if (!Array.isArray(receipt.eventTrace?.events) || !receipt.eventTrace.events.length) errors.push('verified-without-event-trace');
+    if (!Array.isArray(receipt.boundaryAssertions) || !receipt.boundaryAssertions.some(assertion => assertion?.status === 'verified')) {
+      errors.push('verified-without-boundary-assertion');
+    }
+    if (receipt.falseAuthorityChecks?.timingProxyOnly) errors.push('verified-from-proxy-timing');
+    if (receipt.falseAuthorityChecks?.queueWaitEventsMissing) errors.push('verified-without-queue-wait-events');
+    if (receipt.falseAuthorityChecks?.boundaryAssertionEventMismatch) errors.push('verified-with-mismatched-boundary-assertion');
+    if (receipt.falseAuthorityChecks?.requestedBoundaryAssertionMissing) errors.push('verified-without-requested-boundary-assertion');
+    if (receipt.falseAuthorityChecks?.requestedFieldDroppedWithoutUnsupported) errors.push('verified-with-dropped-requested-field');
+    if (Array.isArray(receipt.downgrades) && receipt.downgrades.includes('yield-events-missing')) {
+      errors.push('verified-without-yield-events');
+    }
+  }
+  if (receipt.status === 'invalid') errors.push('receipt-invalid');
+  return {
+    ok: errors.length === 0,
+    errors,
+  };
+}
+
+export function classifySchedulerVerificationReceipt(receipt = {}) {
+  return {
+    status: receipt.status || 'unknown',
+    classification: receipt.classification || 'unknown',
+    observationClass: receipt.observationClass || 'unknown',
+    downgrades: Array.isArray(receipt.downgrades) ? receipt.downgrades : [],
+  };
+}

package/src/sf3d-route.js

@@ -8,6 +8,10 @@ import {
   createRouteReceiptInputArtifact,
   createWebGpuRouteReceiptFromArtifacts,
 } from './route-receipt-helper.js';
+import {
+  createWebGpuRouteBackpressureProfile,
+  createWebGpuRouteSchedulerProfile,
+} from './scheduler-backpressure.js';
 
 export const SF3D_IMAGE_TO_MESH_ROUTE_ID = 'sf3d.image-to-mesh.webgpu-local.v0';
 const SF3D_MODEL_ID = 'stabilityai/stable-fast-3d';
@@ -28,6 +32,55 @@ const OUTPUT_ROLES = [
   { key: 'meshObj', role: 'mesh-obj', required: false },
 ];
 
+function createDefaultSf3dScheduler() {
+  return createWebGpuRouteSchedulerProfile({
+    requestedScheduler: {
+      mode: 'throughput',
+      yieldMs: 0,
+      waitForSubmittedWorkDone: true,
+      phaseChunkSize: {},
+    },
+    effectiveScheduler: {
+      mode: 'throughput',
+      yieldMs: 0,
+      waitForSubmittedWorkDone: true,
+      phaseChunkSize: {},
+      unsupportedFields: [],
+    },
+    verificationState: 'scheduler-unverified',
+    breathability: {
+      spans: REQUIRED_STAGES.map(stage => ({
+        name: `${stage}-phase`,
+        stage,
+        kind: stage === 'glb-export' ? 'cpu-bound' : 'gpu-submit-bound',
+        interruptible: false,
+        canYieldBefore: true,
+        canYieldAfter: true,
+        nonInterruptibleReason: stage === 'glb-export'
+          ? null
+          : 'SF3D browser phases are treated as non-preemptible GPU work until finer receipts prove step boundaries.',
+      })),
+      checkpoints: REQUIRED_STAGES.map(stage => ({
+        name: `after-${stage}`,
+        kind: 'stage-boundary',
+        afterStage: stage,
+        yieldable: true,
+        waitsForSubmittedWorkDone: stage !== 'glb-export',
+      })),
+      notes: 'SF3D remains furnace-class until attention/triplane/marching phases expose finer cooperative boundaries.',
+    },
+  });
+}
+
+function createDefaultSf3dBackpressure() {
+  return createWebGpuRouteBackpressureProfile({
+    requestedBudget: 'visible-wait',
+    effectiveBudget: 'furnace',
+    memoryExclusivity: 'exclusive',
+    warmCacheState: 'unknown',
+  });
+}
+
 export function createSf3dImageToMeshRouteReceipt(input) {
   if (!input || typeof input !== 'object') throw new Error('input must be an object');
   if (!input.input?.artifactId || !input.input?.sha256) {
@@ -86,6 +139,8 @@ export function createSf3dImageToMeshRouteDefinition(input = {}) {
     requiredFeatures: input.requiredFeatures || [],
     requiredStages: routeMetadata.requiredStages,
     timingSource: routeMetadata.timingSource,
+    scheduler: input.scheduler || createDefaultSf3dScheduler(),
+    backpressure: input.backpressure || createDefaultSf3dBackpressure(),
     worker: input.worker || {
       exportName: 'runSf3dImageToMeshRoute',
       meshFormat: 'glb',

package/src/sharp-route.js

@@ -8,6 +8,10 @@ import {
   createRouteReceiptInputArtifact,
   createWebGpuRouteReceiptFromArtifacts,
 } from './route-receipt-helper.js';
+import {
+  createWebGpuRouteBackpressureProfile,
+  createWebGpuRouteSchedulerProfile,
+} from './scheduler-backpressure.js';
 
 export const SHARP_IMAGE_TO_SPLAT_ROUTE_ID = 'sharp.image-to-splat.webgpu-local.v0';
 const SHARP_MODEL_ID = 'apple/ml-sharp';
@@ -20,6 +24,55 @@ const OUTPUT_ROLES = [
   { key: 'autoCropEvidence', role: 'splat-autocrop-evidence', required: false },
 ];
 
+function createDefaultSharpScheduler() {
+  return createWebGpuRouteSchedulerProfile({
+    requestedScheduler: {
+      mode: 'throughput',
+      yieldMs: 0,
+      waitForSubmittedWorkDone: true,
+      phaseChunkSize: {},
+    },
+    effectiveScheduler: {
+      mode: 'throughput',
+      yieldMs: 0,
+      waitForSubmittedWorkDone: true,
+      phaseChunkSize: {},
+      unsupportedFields: [],
+    },
+    verificationState: 'scheduler-unverified',
+    breathability: {
+      spans: REQUIRED_STAGES.map(stage => ({
+        name: `${stage}-phase`,
+        stage,
+        kind: stage === 'output-capture' ? 'readback-bound' : 'gpu-submit-bound',
+        interruptible: false,
+        canYieldBefore: true,
+        canYieldAfter: true,
+        nonInterruptibleReason: stage === 'output-capture'
+          ? null
+          : 'Browser WebGPU cannot preempt a submitted SHARP adapter phase.',
+      })),
+      checkpoints: REQUIRED_STAGES.map(stage => ({
+        name: `after-${stage}`,
+        kind: stage === 'output-capture' ? 'readback' : 'stage-boundary',
+        afterStage: stage,
+        yieldable: true,
+        waitsForSubmittedWorkDone: true,
+      })),
+      notes: 'SHARP is furnace-class until finer adapter receipts prove smaller cooperative boundaries.',
+    },
+  });
+}
+
+function createDefaultSharpBackpressure() {
+  return createWebGpuRouteBackpressureProfile({
+    requestedBudget: 'visible-wait',
+    effectiveBudget: 'furnace',
+    memoryExclusivity: 'exclusive',
+    warmCacheState: 'unknown',
+  });
+}
+
 export function createSharpImageToSplatRouteReceipt(input) {
   if (!input || typeof input !== 'object') throw new Error('input must be an object');
   if (!input.input?.artifactId || !input.input?.sha256) {
@@ -78,6 +131,8 @@ export function createSharpImageToSplatRouteDefinition(input = {}) {
     requiredFeatures: input.requiredFeatures || [],
     requiredStages: routeMetadata.requiredStages,
     timingSource: routeMetadata.timingSource,
+    scheduler: input.scheduler || createDefaultSharpScheduler(),
+    backpressure: input.backpressure || createDefaultSharpBackpressure(),
     worker: input.worker || {
       exportName: 'runSharpImageToSplatRoute',
       adapterReportSchema: 'kaminos.sharp-webgpu-adapter-report.v0',