@void/deploy-core 0.27.0 → 1.0.3

package/dist/index.d.mts

@@ -3,14 +3,10 @@ export declare const MANIFEST_REDIRECT_RULE_STATUSES: ReadonlySet<number>;
 export declare const MAX_ROUTING_RULES = 2e3;
 export declare const MAX_REVALIDATE_QUERY_ALLOWLIST_ENTRIES: number;
 /**
- * Runtime shape validation for incoming deploy manifests. Downstream code
- * indexes deeply into the manifest (bindings.d1, queues[i].name,
- * websocket.classes, etc.) without re-guarding, so a malformed-but-JSON-valid
- * payload would otherwise crash with a 500 — sometimes after a deployment row
- * or CF resources were created. Everything the deploy pipeline reads must be
- * validated here BEFORE createDeployment runs.
+ * Check the shape of an incoming deploy manifest. Returns an error message, or `null` when valid.
+ * Deploy code reads the manifest without re-checking, so run this before creating any deploy state.
  */
-export declare function validateManifestShape(parsed: unknown): string | null;
+export declare function validateManifestShape(manifest: unknown): string | null;
 //#endregion
 //#region src/resource-plan.d.ts
 type DeployResource = {
@@ -177,6 +173,10 @@ export declare function createDeployUploadPayload(artifact: DeployArtifact, meta
 //#region src/canonical-json.d.ts
 export declare function canonicalJson(value: unknown): string;
 //#endregion
+//#region src/artifact-digest.d.ts
+/** Commit to all executable bytes, asset hashes, bindings, migrations, and routing. */
+export declare function deployArtifactDigest(artifact: DeployArtifact): Promise<string>;
+//#endregion
 //#region src/is-record.d.ts
 /** Narrow object-shaped input without accepting null or arrays. */
 export declare function isRecord(value: unknown): value is Record<string, unknown>;
@@ -394,6 +394,18 @@ export type LiveManifestMeta = {
   classes: ReadonlyArray<string>;
   migrations?: ReadonlyArray<LiveMigrationMeta>;
 };
+export type DurableObjectManifestMeta = {
+  bindings: ReadonlyArray<{
+    bindingName: string;
+    className: string;
+    storage: "sqlite";
+  }>;
+  /** Verified by the platform; never accepted from a deployment client. */
+  runtime?: {
+    protocol: 1;
+    namespaces: Record<string, string>;
+  };
+};
 export type DeployManifest = {
   version: number;
   assetManifestVersion?: 1 | 2;
@@ -445,6 +457,7 @@ export type DeployManifest = {
   websocket?: WebSocketManifestMeta;
   sandbox?: SandboxManifestMeta;
   live?: LiveManifestMeta;
+  durableObjects?: DurableObjectManifestMeta;
 };
 export type DeployEvent = {
   event: "start";

package/dist/index.mjs

@@ -18,42 +18,56 @@ const MAX_REVALIDATE_QUERY_ALLOWLIST_ENTRIES = MAX_ROUTING_RULES;
 const MAX_PAGES = 5e3;
 const MAX_CRON_EXPRESSIONS = 100;
 const MAX_SCHEDULES = 1e3;
-/**
-* Strict literal-hostname regex used to validate `redirectRules[].host` /
-* `fallbackRules[].host` on the deploy manifest. Mirrors the regex in
-* `routes/domains.ts` (custom-domain create endpoint) — the source of truth
-* for what counts as a valid project-owned hostname. Rejects scheme prefixes,
-* ports, paths, whitespace, control chars, wildcards, single-label hosts,
-* IPv4 literals, and userinfo. Hostnames are lowercased before testing so
-* the same byte-exact form is what dispatch compares against `url.hostname`
-* (also lowercase per WHATWG).
-*/
 const LITERAL_HOSTNAME_REGEX = /^([a-z0-9]([a-z0-9-]*[a-z0-9])?\.)+[a-z]{2,}$/;
-/**
-* Validate and lowercase-normalize an optional `host` field on a redirect or
-* fallback rule. Mutates `ruleObject.host` in place so the persisted manifest carries
-* the canonical form. Returns an error message string on failure, or `null`
-* on success (including the absent-field case).
-*/
-function validateRuleHost(ruleObject, ruleKind, sourceRef) {
-	if (ruleObject.host === void 0) return null;
-	if (typeof ruleObject.host !== "string") return `invalid manifest shape: ${ruleKind} entry ${sourceRef} host must be a string`;
-	const normalized = ruleObject.host.toLowerCase();
-	if (!LITERAL_HOSTNAME_REGEX.test(normalized)) return `invalid manifest shape: ${ruleKind} entry ${sourceRef} host must be a literal hostname (e.g. "www.example.com"; no scheme, port, path, or wildcards): ${JSON.stringify(ruleObject.host)}`;
-	ruleObject.host = normalized;
+function validateRuleHost(rule, kind, sourceRef) {
+	if (rule.host === void 0) return null;
+	if (typeof rule.host !== "string") return `invalid manifest shape: ${kind} entry ${sourceRef} host must be a string`;
+	const normalized = rule.host.toLowerCase();
+	if (!LITERAL_HOSTNAME_REGEX.test(normalized)) return `invalid manifest shape: ${kind} entry ${sourceRef} host must be a literal hostname (e.g. "www.example.com"; no scheme, port, path, or wildcards): ${JSON.stringify(rule.host)}`;
+	rule.host = normalized;
+	return null;
+}
+function validateRoutingRules(rules, kind) {
+	if (rules === void 0) return null;
+	if (!Array.isArray(rules)) return `invalid manifest shape: ${kind} must be an array`;
+	if (rules.length > 2e3) return `invalid manifest shape: ${kind} has ${rules.length} entries, exceeds the ${MAX_ROUTING_RULES} per-list limit`;
+	const rewritesOnly = kind === "fallbackRules";
+	for (const rule of rules) {
+		if (!isRecord(rule)) return `invalid manifest shape: ${kind} entries must be objects`;
+		if (typeof rule.source !== "string" || typeof rule.destination !== "string" || typeof rule.status !== "number") return `invalid manifest shape: ${kind} entries must have string source, string destination, and numeric status`;
+		const sourceRef = JSON.stringify(rule.source);
+		if (rewritesOnly && rule.status !== 200) return `invalid manifest shape: ${kind} entry ${sourceRef} status must be 200 (fallbacks are rewrites only)`;
+		if (!rewritesOnly && !MANIFEST_REDIRECT_RULE_STATUSES.has(rule.status)) return `invalid manifest shape: ${kind} entry ${sourceRef} status must be one of ${[...MANIFEST_REDIRECT_RULE_STATUSES].join(", ")} (200 = rewrite, 3xx = redirect)`;
+		if (rule.status === 200) {
+			const condition = rewritesOnly ? "" : " when status is 200";
+			if (rule.destination.includes("?")) return `invalid manifest shape: ${kind} entry ${sourceRef} destination must not contain a query string${condition}`;
+			if (!rule.destination.startsWith("/")) return `invalid manifest shape: ${kind} entry ${sourceRef} destination must be path-absolute (start with "/")${condition}`;
+			if (rule.destination.startsWith("//")) return `invalid manifest shape: ${kind} entry ${sourceRef} destination must not start with "//" (protocol-relative URLs parse cross-origin; use a single-slash path-absolute destination)`;
+		}
+		const hostError = validateRuleHost(rule, kind, sourceRef);
+		if (hostError) return hostError;
+	}
+	return null;
+}
+function validateClassMigrations(path, migrations, fields, requireNonEmptyTag = false) {
+	if (migrations === void 0) return null;
+	if (!Array.isArray(migrations)) return `invalid manifest shape: ${path} must be an array`;
+	for (const migration of migrations) {
+		if (!isRecord(migration)) return `invalid manifest shape: ${path} entries must be objects`;
+		if (typeof migration.tag !== "string" || requireNonEmptyTag && migration.tag.length === 0) return `invalid manifest shape: ${path} entries must have a ${requireNonEmptyTag ? "non-empty " : ""}string tag`;
+		for (const field of fields) {
+			const value = migration[field];
+			if (value !== void 0 && (!Array.isArray(value) || !value.every((className) => typeof className === "string"))) return `invalid manifest shape: ${path} ${field} must be an array of strings`;
+		}
+	}
 	return null;
 }
 /**
-* Runtime shape validation for incoming deploy manifests. Downstream code
-* indexes deeply into the manifest (bindings.d1, queues[i].name,
-* websocket.classes, etc.) without re-guarding, so a malformed-but-JSON-valid
-* payload would otherwise crash with a 500 — sometimes after a deployment row
-* or CF resources were created. Everything the deploy pipeline reads must be
-* validated here BEFORE createDeployment runs.
+* Check the shape of an incoming deploy manifest. Returns an error message, or `null` when valid.
+* Deploy code reads the manifest without re-checking, so run this before creating any deploy state.
 */
-function validateManifestShape(parsed) {
-	if (!isRecord(parsed)) return "invalid manifest shape: expected a JSON object";
-	const manifest = parsed;
+function validateManifestShape(manifest) {
+	if (!isRecord(manifest)) return "invalid manifest shape: expected a JSON object";
 	if (manifest.emailProtocolVersion !== void 0 && manifest.emailProtocolVersion !== 1) return "invalid manifest shape: emailProtocolVersion must be 1";
 	if (!isRecord(manifest.bindings)) return "invalid manifest shape: bindings must be an object";
 	const bindings = manifest.bindings;
@@ -71,15 +85,14 @@ function validateManifestShape(parsed) {
 		if (!Array.isArray(manifest.queues)) return "invalid manifest shape: queues must be an array";
 		for (const queue of manifest.queues) {
 			if (!isRecord(queue)) return "invalid manifest shape: queues entries must be objects";
-			const queueObject = queue;
-			if (typeof queueObject.name !== "string" || typeof queueObject.bindingName !== "string") return "invalid manifest shape: queues entries must have string name and bindingName";
+			if (typeof queue.name !== "string" || typeof queue.bindingName !== "string") return "invalid manifest shape: queues entries must have string name and bindingName";
 			for (const tuning of [
 				"maxBatchSize",
 				"maxBatchTimeout",
 				"maxRetries",
 				"retryDelay"
 			]) {
-				const tuningValue = queueObject[tuning];
+				const tuningValue = queue[tuning];
 				if (tuningValue === void 0) continue;
 				if (typeof tuningValue !== "number" || !Number.isFinite(tuningValue)) return `invalid manifest shape: queues entry ${tuning} must be a finite number`;
 			}
@@ -91,9 +104,8 @@ function validateManifestShape(parsed) {
 		const cronExpressions = /* @__PURE__ */ new Set();
 		for (const schedule of manifest.schedules) {
 			if (!isRecord(schedule)) return "invalid manifest shape: schedules entries must be objects";
-			const scheduleObject = schedule;
-			if (typeof scheduleObject.name !== "string" || typeof scheduleObject.cron !== "string") return "invalid manifest shape: schedules entries must have string name and cron";
-			cronExpressions.add(scheduleObject.cron);
+			if (typeof schedule.name !== "string" || typeof schedule.cron !== "string") return "invalid manifest shape: schedules entries must have string name and cron";
+			cronExpressions.add(schedule.cron);
 		}
 		if (cronExpressions.size > MAX_CRON_EXPRESSIONS) return `invalid manifest shape: schedules has ${cronExpressions.size} distinct cron expressions, exceeds the ${MAX_CRON_EXPRESSIONS} per-project limit`;
 	}
@@ -168,38 +180,21 @@ function validateManifestShape(parsed) {
 			"none"
 		].includes(assetConfig.html_handling)) return "invalid manifest shape: assetConfig.html_handling must be one of auto-trailing-slash, force-trailing-slash, drop-trailing-slash, none";
 	}
-	if (manifest.revalidate !== void 0) {
-		if (typeof manifest.revalidate === "number") {} else if (!isRecord(manifest.revalidate)) return "invalid manifest shape: revalidate must be a number or object";
-		else for (const [pathname, value] of Object.entries(manifest.revalidate)) if (typeof value !== "number") return `invalid manifest shape: revalidate.${pathname} must be a number`;
+	if (manifest.revalidate !== void 0 && typeof manifest.revalidate !== "number") {
+		if (!isRecord(manifest.revalidate)) return "invalid manifest shape: revalidate must be a number or object";
+		for (const [pathname, value] of Object.entries(manifest.revalidate)) if (typeof value !== "number") return `invalid manifest shape: revalidate.${pathname} must be a number`;
 	}
 	if (manifest.headerRules !== void 0) {
 		if (!Array.isArray(manifest.headerRules)) return "invalid manifest shape: headerRules must be an array";
 		for (const rule of manifest.headerRules) {
 			if (!isRecord(rule)) return "invalid manifest shape: headerRules entries must be objects";
-			const ruleObject = rule;
-			if (typeof ruleObject.pattern !== "string") return "invalid manifest shape: headerRules entries must have a string pattern";
-			if (!Array.isArray(ruleObject.headers)) return "invalid manifest shape: headerRules entries must have a headers array";
-			for (const pair of ruleObject.headers) if (!Array.isArray(pair) || pair.length !== 2 || typeof pair[0] !== "string" || typeof pair[1] !== "string") return "invalid manifest shape: headerRules headers entries must be [name, value] string pairs";
-		}
-	}
-	if (manifest.redirectRules !== void 0) {
-		if (!Array.isArray(manifest.redirectRules)) return "invalid manifest shape: redirectRules must be an array";
-		if (manifest.redirectRules.length > 2e3) return `invalid manifest shape: redirectRules has ${manifest.redirectRules.length} entries, exceeds the ${MAX_ROUTING_RULES} per-list limit`;
-		for (const rule of manifest.redirectRules) {
-			if (!isRecord(rule)) return "invalid manifest shape: redirectRules entries must be objects";
-			const ruleObject = rule;
-			if (typeof ruleObject.source !== "string" || typeof ruleObject.destination !== "string" || typeof ruleObject.status !== "number") return "invalid manifest shape: redirectRules entries must have string source, string destination, and numeric status";
-			const sourceRef = JSON.stringify(ruleObject.source);
-			if (!MANIFEST_REDIRECT_RULE_STATUSES.has(ruleObject.status)) return `invalid manifest shape: redirectRules entry ${sourceRef} status must be one of ${[...MANIFEST_REDIRECT_RULE_STATUSES].join(", ")} (200 = rewrite, 3xx = redirect)`;
-			const destination = ruleObject.destination;
-			const isRewrite = ruleObject.status === 200;
-			if (isRewrite && destination.includes("?")) return `invalid manifest shape: redirectRules entry ${sourceRef} destination must not contain a query string when status is 200`;
-			if (isRewrite && !destination.startsWith("/")) return `invalid manifest shape: redirectRules entry ${sourceRef} destination must be path-absolute (start with "/") when status is 200`;
-			if (isRewrite && destination.startsWith("//")) return `invalid manifest shape: redirectRules entry ${sourceRef} destination must not start with "//" (protocol-relative URLs parse cross-origin; use a single-slash path-absolute destination)`;
-			const hostError = validateRuleHost(ruleObject, "redirectRules", sourceRef);
-			if (hostError) return hostError;
+			if (typeof rule.pattern !== "string") return "invalid manifest shape: headerRules entries must have a string pattern";
+			if (!Array.isArray(rule.headers)) return "invalid manifest shape: headerRules entries must have a headers array";
+			for (const pair of rule.headers) if (!Array.isArray(pair) || pair.length !== 2 || typeof pair[0] !== "string" || typeof pair[1] !== "string") return "invalid manifest shape: headerRules headers entries must be [name, value] string pairs";
 		}
 	}
+	const redirectRulesError = validateRoutingRules(manifest.redirectRules, "redirectRules");
+	if (redirectRulesError) return redirectRulesError;
 	if (manifest.revalidateQueryAllowlist !== void 0) {
 		if (!isRecord(manifest.revalidateQueryAllowlist)) return "invalid manifest shape: revalidateQueryAllowlist must be an object";
 		const entries = Object.entries(manifest.revalidateQueryAllowlist);
@@ -215,59 +210,32 @@ function validateManifestShape(parsed) {
 		if (manifest.pages.length > MAX_PAGES) return `invalid manifest shape: pages has ${manifest.pages.length} entries, exceeds the ${MAX_PAGES} entry limit`;
 		for (const entry of manifest.pages) {
 			if (!isRecord(entry)) return "invalid manifest shape: each pages entry must be an object";
-			const e = entry;
-			if (typeof e.pattern !== "string" || e.pattern === "") return "invalid manifest shape: pages entry pattern must be a string";
-			if (e.revalidate !== void 0 && typeof e.revalidate !== "number") return "invalid manifest shape: pages entry revalidate must be a number";
+			if (typeof entry.pattern !== "string" || entry.pattern === "") return "invalid manifest shape: pages entry pattern must be a string";
+			if (entry.revalidate !== void 0 && typeof entry.revalidate !== "number") return "invalid manifest shape: pages entry revalidate must be a number";
 		}
 	}
 	if (manifest.pathRevalidate !== void 0) {
 		if (!isRecord(manifest.pathRevalidate)) return "invalid manifest shape: pathRevalidate must be an object";
 		for (const [pathname, value] of Object.entries(manifest.pathRevalidate)) if (typeof value !== "number") return `invalid manifest shape: pathRevalidate.${pathname} must be a number`;
 	}
-	if (manifest.fallbackRules !== void 0) {
-		if (!Array.isArray(manifest.fallbackRules)) return "invalid manifest shape: fallbackRules must be an array";
-		if (manifest.fallbackRules.length > 2e3) return `invalid manifest shape: fallbackRules has ${manifest.fallbackRules.length} entries, exceeds the ${MAX_ROUTING_RULES} per-list limit`;
-		for (const rule of manifest.fallbackRules) {
-			if (!isRecord(rule)) return "invalid manifest shape: fallbackRules entries must be objects";
-			const ruleObject = rule;
-			if (typeof ruleObject.source !== "string" || typeof ruleObject.destination !== "string" || typeof ruleObject.status !== "number") return "invalid manifest shape: fallbackRules entries must have string source, string destination, and numeric status";
-			const sourceRef = JSON.stringify(ruleObject.source);
-			if (ruleObject.status !== 200) return `invalid manifest shape: fallbackRules entry ${sourceRef} status must be 200 (fallbacks are rewrites only)`;
-			const destination = ruleObject.destination;
-			if (destination.includes("?")) return `invalid manifest shape: fallbackRules entry ${sourceRef} destination must not contain a query string`;
-			if (!destination.startsWith("/")) return `invalid manifest shape: fallbackRules entry ${sourceRef} destination must be path-absolute (start with "/")`;
-			if (destination.startsWith("//")) return `invalid manifest shape: fallbackRules entry ${sourceRef} destination must not start with "//" (protocol-relative URLs parse cross-origin; use a single-slash path-absolute destination)`;
-			const hostError = validateRuleHost(ruleObject, "fallbackRules", sourceRef);
-			if (hostError) return hostError;
-		}
-	}
+	const fallbackRulesError = validateRoutingRules(manifest.fallbackRules, "fallbackRules");
+	if (fallbackRulesError) return fallbackRulesError;
 	if (manifest.websocket !== void 0) {
 		if (!isRecord(manifest.websocket)) return "invalid manifest shape: websocket must be an object";
 		const websocket = manifest.websocket;
 		if (!Array.isArray(websocket.routes)) return "invalid manifest shape: websocket.routes must be an array";
 		for (const route of websocket.routes) {
 			if (!isRecord(route)) return "invalid manifest shape: websocket.routes entries must be objects";
-			const routeObject = route;
-			if (typeof routeObject.className !== "string") return "invalid manifest shape: websocket.routes entries must have a string className";
-			if (routeObject.bindingName !== void 0 && typeof routeObject.bindingName !== "string") return "invalid manifest shape: websocket.routes entry bindingName must be a string";
+			if (typeof route.className !== "string") return "invalid manifest shape: websocket.routes entries must have a string className";
+			if (route.bindingName !== void 0 && typeof route.bindingName !== "string") return "invalid manifest shape: websocket.routes entry bindingName must be a string";
 		}
 		if (!Array.isArray(websocket.classes) || !websocket.classes.every((x) => typeof x === "string")) return "invalid manifest shape: websocket.classes must be an array of strings";
-		if (websocket.migrations !== void 0) {
-			if (!Array.isArray(websocket.migrations)) return "invalid manifest shape: websocket.migrations must be an array";
-			for (const migration of websocket.migrations) {
-				if (!isRecord(migration)) return "invalid manifest shape: websocket.migrations entries must be objects";
-				const migrationObject = migration;
-				if (typeof migrationObject.tag !== "string" || migrationObject.tag.length === 0) return "invalid manifest shape: websocket.migrations entries must have a non-empty string tag";
-				for (const field of [
-					"newClasses",
-					"newSqliteClasses",
-					"deletedClasses"
-				]) {
-					const value = migrationObject[field];
-					if (value !== void 0 && (!Array.isArray(value) || !value.every((className) => typeof className === "string"))) return `invalid manifest shape: websocket.migrations ${field} must be an array of strings`;
-				}
-			}
-		}
+		const migrationsError = validateClassMigrations("websocket.migrations", websocket.migrations, [
+			"newClasses",
+			"newSqliteClasses",
+			"deletedClasses"
+		], true);
+		if (migrationsError) return migrationsError;
 	}
 	if (manifest.sandbox !== void 0) {
 		if (manifest.type === "static" || manifest.type === "spa") return "sandbox is not supported for static/spa deployments";
@@ -282,16 +250,8 @@ function validateManifestShape(parsed) {
 		if (isLocalImageReference(sandbox.image)) return "invalid manifest shape: sandbox.image must be a registry image reference";
 		if (sandbox.instanceType !== void 0 && typeof sandbox.instanceType !== "string") return "invalid manifest shape: sandbox.instanceType must be a string";
 		if (sandbox.maxInstances !== void 0 && (typeof sandbox.maxInstances !== "number" || !Number.isInteger(sandbox.maxInstances) || sandbox.maxInstances < 1)) return "invalid manifest shape: sandbox.maxInstances must be a positive integer";
-		if (sandbox.migrations !== void 0) {
-			if (!Array.isArray(sandbox.migrations)) return "invalid manifest shape: sandbox.migrations must be an array";
-			for (const migration of sandbox.migrations) {
-				if (!isRecord(migration)) return "invalid manifest shape: sandbox.migrations entries must be objects";
-				const migrationObject = migration;
-				if (typeof migrationObject.tag !== "string") return "invalid manifest shape: sandbox.migrations entries must have a string tag";
-				if (migrationObject.newSqliteClasses !== void 0 && (!Array.isArray(migrationObject.newSqliteClasses) || !migrationObject.newSqliteClasses.every((value) => typeof value === "string"))) return "invalid manifest shape: sandbox.migrations newSqliteClasses must be an array of strings";
-				if (migrationObject.deletedClasses !== void 0 && (!Array.isArray(migrationObject.deletedClasses) || !migrationObject.deletedClasses.every((value) => typeof value === "string"))) return "invalid manifest shape: sandbox.migrations deletedClasses must be an array of strings";
-			}
-		}
+		const migrationsError = validateClassMigrations("sandbox.migrations", sandbox.migrations, ["newSqliteClasses", "deletedClasses"]);
+		if (migrationsError) return migrationsError;
 	}
 	if (manifest.live !== void 0) {
 		if (!isRecord(manifest.live)) return "invalid manifest shape: live must be an object";
@@ -299,14 +259,35 @@ function validateManifestShape(parsed) {
 		for (const key of ["bindingName", "className"]) if (typeof live[key] !== "string" || live[key].length === 0) return `invalid manifest shape: live.${key} must be a non-empty string`;
 		if (live.storage !== "sqlite") return "invalid manifest shape: live.storage must be \"sqlite\"";
 		if (!Array.isArray(live.classes) || !live.classes.every((x) => typeof x === "string")) return "invalid manifest shape: live.classes must be an array of strings";
-		if (live.migrations !== void 0) {
-			if (!Array.isArray(live.migrations)) return "invalid manifest shape: live.migrations must be an array";
-			for (const migration of live.migrations) {
-				if (!isRecord(migration)) return "invalid manifest shape: live.migrations entries must be objects";
-				const migrationObject = migration;
-				if (typeof migrationObject.tag !== "string") return "invalid manifest shape: live.migrations entries must have a string tag";
-				if (migrationObject.newSqliteClasses !== void 0 && (!Array.isArray(migrationObject.newSqliteClasses) || !migrationObject.newSqliteClasses.every((value) => typeof value === "string"))) return "invalid manifest shape: live.migrations newSqliteClasses must be an array of strings";
-			}
+		const migrationsError = validateClassMigrations("live.migrations", live.migrations, ["newSqliteClasses"]);
+		if (migrationsError) return migrationsError;
+	}
+	if (manifest.durableObjects !== void 0) {
+		const durable = manifest.durableObjects;
+		if (manifest.version !== 4 || !isRecord(durable) || !Array.isArray(durable.bindings)) return "invalid manifest shape: durableObjects requires manifest version 4 and a bindings array";
+		if (durable.bindings.length > 32) return "invalid manifest shape: at most 32 custom Durable Objects are supported";
+		const names = /* @__PURE__ */ new Set();
+		const classes = /* @__PURE__ */ new Set();
+		const otherBindings = /* @__PURE__ */ new Set([
+			...Object.values(bindings).filter(Array.isArray).flat(),
+			...Object.keys(isRecord(manifest.vars) ? manifest.vars : {}),
+			...Array.isArray(manifest.queues) ? manifest.queues.map((q) => q.bindingName) : [],
+			...isRecord(manifest.websocket) && Array.isArray(manifest.websocket.routes) ? manifest.websocket.routes.map((r) => r.bindingName ?? r.className) : [],
+			...isRecord(manifest.live) ? [manifest.live.bindingName] : []
+		]);
+		for (const binding of durable.bindings) {
+			if (!isRecord(binding) || Object.keys(binding).some((key) => ![
+				"bindingName",
+				"className",
+				"storage"
+			].includes(key)) || typeof binding.bindingName !== "string" || !/^[A-Za-z_$][\w$]{0,127}$/.test(binding.bindingName) || binding.bindingName.startsWith("__") || [
+				"ASSETS",
+				"SEND_EMAIL",
+				"USAGE_EVENTS_QUEUE"
+			].includes(binding.bindingName) || typeof binding.className !== "string" || !/^[A-Za-z_$][\w$]{0,127}$/.test(binding.className) || binding.storage !== "sqlite") return "invalid manifest shape: custom Durable Objects require local SQLite classes and valid binding names";
+			if (names.has(binding.bindingName) || classes.has(binding.className) || otherBindings.has(binding.bindingName)) return "invalid manifest shape: custom Durable Object bindings and classes must be unique";
+			names.add(binding.bindingName);
+			classes.add(binding.className);
 		}
 	}
 	return null;
@@ -426,6 +407,19 @@ function canonicalJson(value) {
 	throw new TypeError(`Unsupported canonical JSON value: ${typeof value}`);
 }
 //#endregion
+//#region src/artifact-digest.ts
+/** Commit to all executable bytes, asset hashes, bindings, migrations, and routing. */
+async function deployArtifactDigest(artifact) {
+	const host = globalThis;
+	const data = canonicalJson({
+		manifest: artifact.manifest,
+		assetManifest: artifact.assetManifest,
+		workerFiles: artifact.workerFiles ?? {}
+	});
+	const bytes = await host.crypto.subtle.digest("SHA-256", new host.TextEncoder().encode(data));
+	return Array.from(new Uint8Array(bytes), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+//#endregion
 //#region src/sql-tokenize.ts
 function* tokenizeSql(sql) {
 	const sqlLength = sql.length;
@@ -639,7 +633,7 @@ function getMigrationPlanHashInput(plan) {
 }
 //#endregion
 //#region src/index.ts
-const SUPPORTED_MANIFEST_VERSIONS = [3];
+const SUPPORTED_MANIFEST_VERSIONS = [3, 4];
 /**
 * Preserve an existing WebSocket class history while assigning every genuinely
 * new class to SQLite-backed Durable Object storage.
@@ -718,4 +712,4 @@ function isSandboxRegistryImage(image) {
 	return /^registry\.cloudflare\.com\/[^/@\s]+\/[^@\s]+@sha256:[a-f\d]{64}$/.test(image);
 }
 //#endregion
-export { DEPLOY_ARTIFACT_VERSION, MANIFEST_REDIRECT_RULE_STATUSES, MAX_REVALIDATE_QUERY_ALLOWLIST_ENTRIES, MAX_ROUTING_RULES, MIGRATION_CLASSIFIER_VERSION, SUPPORTED_MANIFEST_VERSIONS, UNSPLIT_MULTI_STATEMENT_PRAGMA, appendSqliteClassMigration, canonicalJson, canonicalSql, classifySqlMigration, createDeployArtifact, createDeployIntent, createDeployResourcePlan, createDeployUploadPayload, getMigrationPlanHashInput, hasStandalonePragma, isRecord, isSandboxRegistryImage, isSingleStatement, planWebSocketMigrations, splitSqlStatements, tokenizeSql, validateManifestShape };
+export { DEPLOY_ARTIFACT_VERSION, MANIFEST_REDIRECT_RULE_STATUSES, MAX_REVALIDATE_QUERY_ALLOWLIST_ENTRIES, MAX_ROUTING_RULES, MIGRATION_CLASSIFIER_VERSION, SUPPORTED_MANIFEST_VERSIONS, UNSPLIT_MULTI_STATEMENT_PRAGMA, appendSqliteClassMigration, canonicalJson, canonicalSql, classifySqlMigration, createDeployArtifact, createDeployIntent, createDeployResourcePlan, createDeployUploadPayload, deployArtifactDigest, getMigrationPlanHashInput, hasStandalonePragma, isRecord, isSandboxRegistryImage, isSingleStatement, planWebSocketMigrations, splitSqlStatements, tokenizeSql, validateManifestShape };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@void/deploy-core",
-  "version": "0.27.0",
+  "version": "1.0.3",
   "description": "Shared deployment contracts, manifests, and resource plans for Void.",
   "homepage": "https://void.cloud",
   "bugs": {
@@ -27,7 +27,7 @@
   },
   "devDependencies": {
     "typescript": "7.0.2",
-    "vite-plus": "1.1.0"
+    "vite-plus": "1.2.0"
   },
   "scripts": {
     "build": "vp pack",