@@ -73,7 +73,7 @@ const DO_POST_TIMEOUT_MS = 10000;
 // build-manager test asserts against the framework submodule — this file is
 // plain JS copied into the container image, so it can't import that constant
 // and the test mirrors the literal instead.
-export const DEFAULT_VOID_CLI_VERSION = '0.10.10';
+export const DEFAULT_VOID_CLI_VERSION = '0.10.12';
 
 // --- source-download bounds --------------------------------------------------
 //
 
@@ -268,7 +268,7 @@ export function withDeadline<T>(work: Promise<T>, ms: number, reason: string): P
 // against) so a moving `void@latest` can't change deploy behavior with no repo
 // diff. The comment alone let this sit a full minor behind for the whole life of
 // the feature, so `build-manager.test.ts` now asserts the equality instead.
-export const PINNED_VOID_CLI_VERSION = '0.10.10';
+export const PINNED_VOID_CLI_VERSION = '0.10.12';
 
 // Ceiling on how long a queued build may wait for the just-in-time branch-head
 // freshness recheck to succeed. While the GitHub compare API is unreachable
 
@@ -73,6 +73,7 @@ import { presignAssetPut } from '../r2-presign.ts';
 import {
   buildRoutingJson,
   buildStaticRoutingJson,
+  computeDispatchLimits,
   projectAccountKey,
   writeProjectAccountEntry,
 } from '../routing.ts';
@@ -648,6 +649,29 @@ export function validateManifestShape(parsed: unknown): string | null {
     }
   }
 
+  // Per-project worker limit overrides (void.json `worker.limits`). Shape-only
+  // here; the plan ceiling (`maxCpuMsPerRequest`) is enforced by the deploy
+  // handler once the authenticated user's plan is in scope.
+  if (manifest.limits !== undefined) {
+    if (
+      manifest.limits == null ||
+      typeof manifest.limits !== 'object' ||
+      Array.isArray(manifest.limits)
+    ) {
+      return 'invalid manifest shape: limits must be an object';
+    }
+    const limits = manifest.limits as Record<string, unknown>;
+    if (limits.cpuMs !== undefined) {
+      if (
+        typeof limits.cpuMs !== 'number' ||
+        !Number.isSafeInteger(limits.cpuMs) ||
+        limits.cpuMs < 1
+      ) {
+        return 'invalid manifest shape: limits.cpuMs must be a positive integer';
+      }
+    }
+  }
+
   if (manifest.type !== undefined) {
     const allowed = ['void', 'spa', 'static', 'framework'];
     if (typeof manifest.type !== 'string' || !allowed.includes(manifest.type)) {
@@ -2203,6 +2227,24 @@ async function handleManifestOnlyDeploy(context: Context<ApiEnv>): Promise<Respo
     );
   }
 
+  // Plan ceiling on a requested per-project CPU limit. Rejected at ingest —
+  // before the precheck-and-claim transaction or any asset work — so an
+  // over-ceiling deploy fails fast with both numbers. Rollback deliberately
+  // clamps instead of rejecting (see `computeDispatchLimits`).
+  const requestedCpuMs = incomingManifest.limits?.cpuMs;
+  if (requestedCpuMs !== undefined) {
+    const maxCpuMs = getPlanLimits(user.plan).maxCpuMsPerRequest;
+    if (maxCpuMs > 0 && requestedCpuMs > maxCpuMs) {
+      return context.json(
+        {
+          event: 'error',
+          message: `limits.cpuMs ${requestedCpuMs} exceeds your plan maximum of ${maxCpuMs}`,
+        },
+        400,
+      );
+    }
+  }
+
   // Validate the v2 asset manifest. Each entry MUST carry a 32-hex blake3
   // (storage key), 32-hex md5 (R2 PUT integrity check), and a non-negative
   // integer size. We translate the v2 entries into the v1 shape
@@ -3878,15 +3920,7 @@ async function handleManifestOnlyDeploy(context: Context<ApiEnv>): Promise<Respo
         // Routing switch
         const existingRouting = await context.env.ROUTING.get(project.slug);
         const existingEntry = existingRouting ? JSON.parse(existingRouting) : null;
-        const dispatchLimits =
-          planLimits.cpuMsPerRequest > 0 || planLimits.subRequestsPerInvocation > 0
-            ? {
-                ...(planLimits.cpuMsPerRequest > 0 ? { cpuMs: planLimits.cpuMsPerRequest } : {}),
-                ...(planLimits.subRequestsPerInvocation > 0
-                  ? { subRequests: planLimits.subRequestsPerInvocation }
-                  : {}),
-              }
-            : null;
+        const dispatchLimits = computeDispatchLimits(planLimits, manifest.limits);
         const routingJson = buildRoutingJson({
           workerName,
           projectId,
 
@@ -45,7 +45,7 @@ import {
   InvalidHyperdriveConnectionStringError,
   getDispatchWorkerProxyToken,
 } from '../provisioning/cloudflare-api.ts';
-import { buildRoutingJson, buildStaticRoutingJson } from '../routing.ts';
+import { buildRoutingJson, buildStaticRoutingJson, computeDispatchLimits } from '../routing.ts';
 import { tokenizeSql } from '../sql/tokenize.ts';
 import { getPlanLimits } from '../tiers.ts';
 import type { Build, DeployManifest } from '../types.ts';
@@ -300,10 +300,10 @@ type LineComment = Readonly<{
  *      on data like `VALUES('DROP TABLE users')` and on `-- DROP TABLE`
  *      in a line comment, which could block legitimate migrations.
  *   3. Block comments are intentionally NOT counted toward the pragma. A
- *      docstring like `/* use -- void:allow-destructive to permit drops */`
+ *      docstring like `/* use -- void:allow-destructive to permit drops *\/`
  *      is documentation, not authorization. They are also replaced with a
  *      single space rather than deleted outright so that token boundaries
- *      are preserved — `DROP/**/TABLE` must not collapse to `DROPTABLE`,
+ *      are preserved — `DROP/**\/TABLE` must not collapse to `DROPTABLE`,
  *      which would slip the destructive keyword regex entirely.
  *   4. The standalone bit on each line comment lets the caller require
  *      that the destructive pragma occupies its own raw line. Trailing
@@ -312,7 +312,7 @@ type LineComment = Readonly<{
  *
  * Only the SQLite lexical forms are handled: `'...'` strings with `''`
  * escape, `"..."` / `` `...` `` / `[...]` identifier quotes with doubled
- * closing-quote escape, `-- line` comments, and `/* block */` comments.
+ * closing-quote escape, `-- line` comments, and `/* block *\/` comments.
  */
 function stripSqlStringsAndComments(sql: string): {
   code: string;
@@ -330,7 +330,7 @@ function stripSqlStringsAndComments(sql: string): {
         // Walk backwards from the `--` to the previous newline (or start of
         // input). The comment is "standalone" iff every character in that
         // raw-source prefix is whitespace — anything else (a SQL token, the
-        // closing `*/` of a block comment, a string literal, etc.) means the
+        // closing `*/` of a block comment, a string literal, etc.) means the
         // pragma is sharing its line with content and must not authorize.
         let standalone = true;
         for (let k = seg.start - 1; k >= 0; k--) {
@@ -350,7 +350,7 @@ function stripSqlStringsAndComments(sql: string): {
       }
       case 'block-comment':
         // Replace the block comment with a single space so token boundaries
-        // are preserved — `DROP/**/TABLE` must NOT collapse to `DROPTABLE`,
+        // are preserved — `DROP/**/TABLE` must NOT collapse to `DROPTABLE`,
         // which would slip past the destructive regex entirely. The space
         // is sufficient because every destructive pattern requires `\b` /
         // `\s+` between keywords.
@@ -698,15 +698,6 @@ const app = new Hono<ApiEnv>()
     }
 
     const planLimits = getPlanLimits(context.get('user').plan);
-    const dispatchLimits =
-      planLimits.cpuMsPerRequest > 0 || planLimits.subRequestsPerInvocation > 0
-        ? {
-            ...(planLimits.cpuMsPerRequest > 0 ? { cpuMs: planLimits.cpuMsPerRequest } : {}),
-            ...(planLimits.subRequestsPerInvocation > 0
-              ? { subRequests: planLimits.subRequestsPerInvocation }
-              : {}),
-          }
-        : null;
 
     // The entire rollback cutover runs inside a single row-locked tx so
     // concurrent rollbacks / applies / renames serialize and no external
@@ -818,6 +809,12 @@ const app = new Hono<ApiEnv>()
         const manifest: DeployManifest | null = target.manifest
           ? JSON.parse(target.manifest)
           : null;
+        // Effective dispatch limits honor the TARGET manifest's per-project
+        // override, clamped to the CURRENT plan ceiling — a rollback under a
+        // downgraded plan clamps, never rejects. Computed here (pure CPU, no
+        // I/O added inside the lock) because the manifest is re-read inside
+        // the lock; `planLimits` itself is resolved before the tx.
+        const dispatchLimits = computeDispatchLimits(planLimits, manifest?.limits);
         // Rollback external-write pass depends only on authoritative
         // persistent sources (pg deployments table for queue activation
         // history; target's manifest + unconditional DO reconciliation
 
@@ -1,4 +1,5 @@
 import { getDomainsByProjectIds, getProjectsByUserId, getUser, type Db } from './db.ts';
+import type { PlanLimits } from './tiers.ts';
 import type { AssetConfig, DeployManifest } from './types.ts';
 
 /**
@@ -168,6 +169,54 @@ export async function setProjectsRoutingSuspension(
   }
 }
 
+/**
+ * Compute the `dispatchLimits` blob `buildRoutingJson` embeds in a routing
+ * entry, honoring an optional per-project `manifest.limits.cpuMs` override.
+ *
+ * - Override present: clamp to the plan's `maxCpuMsPerRequest` when that
+ *   ceiling is non-zero (rollback under a downgraded plan clamps, never
+ *   rejects — ingest is where over-ceiling requests get a 400), otherwise
+ *   pass it through verbatim.
+ * - No override: fall back to the plan default `cpuMsPerRequest` (0 = no
+ *   cpuMs key), byte-identical in shape to the historical inline expression.
+ * - An override that is not a safe integer >= 1 is treated as absent and
+ *   falls back to the plan default. A rollback replays a stored manifest,
+ *   and a manifest stored before ingest validated `limits` can carry an
+ *   out-of-domain value that must not erase or corrupt the plan cap.
+ * - `subRequests` always comes from the plan (0 = no key).
+ *
+ * Returns `null` when neither limit is set so the routing entry omits the
+ * `limits` key entirely.
+ */
+export function computeDispatchLimits(
+  planLimits: PlanLimits,
+  manifestLimits: DeployManifest['limits'] | null | undefined,
+): { cpuMs?: number; subRequests?: number } | null {
+  const rawRequested = manifestLimits?.cpuMs;
+  const requested =
+    typeof rawRequested === 'number' && Number.isSafeInteger(rawRequested) && rawRequested >= 1
+      ? rawRequested
+      : undefined;
+  const max = planLimits.maxCpuMsPerRequest;
+  const cpuMs =
+    requested !== undefined
+      ? max > 0
+        ? Math.min(requested, max)
+        : requested
+      : planLimits.cpuMsPerRequest > 0
+        ? planLimits.cpuMsPerRequest
+        : undefined;
+  const subRequests =
+    planLimits.subRequestsPerInvocation > 0 ? planLimits.subRequestsPerInvocation : undefined;
+  if (!cpuMs && !subRequests) {
+    return null;
+  }
+  return {
+    ...(cpuMs ? { cpuMs } : {}),
+    ...(subRequests ? { subRequests } : {}),
+  };
+}
+
 export function buildRoutingJson(opts: {
   workerName: string;
   projectId: string;
 
@@ -9,7 +9,7 @@
  *
  * Lexical forms handled (SQLite / drizzle-kit SQLite output):
  *   - `-- line`            line comments (terminate at `\n` or EOF)
- *   - `/* block */`        block comments (tolerate unterminated — span to EOF)
+ *   - `/* block *\/`        block comments (tolerate unterminated — span to EOF)
  *   - `'...'`              string literals with `''` doubled-quote escape
  *   - `"..."` / `` `...` `` identifier quotes with `""` / `` `` `` escape
  *   - `[...]`              bracket identifiers, NO `]]` escape — a single
 
@@ -5,6 +5,8 @@ export type PlanLimits = Readonly<{
   requestsPerMonth: number;
   /** Max CPU milliseconds per request (0 = unlimited) */
   cpuMsPerRequest: number;
+  /** Highest cpuMs a project may request via its deploy manifest (0 = no ceiling) */
+  maxCpuMsPerRequest: number;
   /** Max sub-requests per invocation (0 = unlimited) */
   subRequestsPerInvocation: number;
   /** Max deploys per day (0 = unlimited) */
@@ -35,6 +37,7 @@ export const PLAN_LIMITS: Record<PlanId, PlanLimits> = {
   free: {
     requestsPerMonth: 3_000_000,
     cpuMsPerRequest: 10,
+    maxCpuMsPerRequest: 10,
     subRequestsPerInvocation: 50,
     deploysPerDay: 100,
     d1StorageBytes: 1 * GB,
@@ -51,6 +54,7 @@ export const PLAN_LIMITS: Record<PlanId, PlanLimits> = {
   solo: {
     requestsPerMonth: 10_000_000,
     cpuMsPerRequest: 30,
+    maxCpuMsPerRequest: 30_000,
     subRequestsPerInvocation: 50,
     deploysPerDay: 500,
     d1StorageBytes: 5 * GB,
@@ -66,6 +70,7 @@ export const PLAN_LIMITS: Record<PlanId, PlanLimits> = {
   pro: {
     requestsPerMonth: 100_000_000,
     cpuMsPerRequest: 50,
+    maxCpuMsPerRequest: 30_000,
     subRequestsPerInvocation: 1000,
     deploysPerDay: 3000,
     d1StorageBytes: 10 * GB,
@@ -81,6 +86,7 @@ export const PLAN_LIMITS: Record<PlanId, PlanLimits> = {
   sponsored: {
     requestsPerMonth: 0,
     cpuMsPerRequest: 50,
+    maxCpuMsPerRequest: 30_000,
     subRequestsPerInvocation: 1000,
     deploysPerDay: 0,
     d1StorageBytes: 0,
@@ -96,6 +102,7 @@ export const PLAN_LIMITS: Record<PlanId, PlanLimits> = {
   custom: {
     requestsPerMonth: 0,
     cpuMsPerRequest: 0,
+    maxCpuMsPerRequest: 0,
     subRequestsPerInvocation: 0,
     deploysPerDay: 0,
     d1StorageBytes: 0,
 
@@ -218,6 +218,13 @@ export type DeployManifest = Readonly<{
   workerMain?: string;
   compatibilityDate?: string;
   compatibilityFlags?: ReadonlyArray<string>;
+  /**
+   * Per-project worker limit overrides (void.json `worker.limits`, snake_case
+   * `cpu_ms` on the config surface — camelCase here like other manifest
+   * fields). Ingest rejects a `cpuMs` above the plan's `maxCpuMsPerRequest`;
+   * rollback clamps instead (see `computeDispatchLimits`).
+   */
+  limits?: Readonly<{ cpuMs?: number }>;
   hashedAssetsPrefix?: string;
   headerRules?: ReadonlyArray<HeaderRule>;
   redirectRules?: ReadonlyArray<RedirectRule>;
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@`
`9`	`9`	`*`
`10`	`10`	`* Lexical forms handled (SQLite / drizzle-kit SQLite output):`
`11`	`11`	* - `-- line` line comments (terminate at `\n` or EOF)
`12`		- * - `/* block */` block comments (tolerate unterminated — span to EOF)
	`12`	+ * - `/* block *\/` block comments (tolerate unterminated — span to EOF)
`13`	`13`	* - `'...'` string literals with `''` doubled-quote escape
`14`	`14`	* - `"..."` / `` `...` `` identifier quotes with `""` / `` `` `` escape
`15`	`15`	* - `[...]` bracket identifiers, NO `]]` escape — a single