@void/deploy-core 0.26.0 → 0.26.1

package/README.md

@@ -1,7 +1,11 @@
 # @void/deploy-core
 
-Shared deployment contracts for Void runtimes and deployment adapters. Includes manifests, progress events, routing rules, resource plans, and SQL and Durable Object migration metadata.
+Shared deployment contracts for [Void](https://void.cloud) runtimes and deployment adapters. Includes manifests, progress events, routing rules, resource plans, and SQL and Durable Object migration metadata.
 
-This package works in Node.js and Cloudflare Workers. Applications normally use the `void` CLI rather than these contracts directly.
+This package works in Node.js and Cloudflare Workers. To deploy an application, use the `void` CLI.
 
-See [Deployment](https://void.cloud/guide/deployment) for deploying an app and [Platform Development](https://void.cloud/guide/platform-development) for working on a runtime or adapter.
+## Documentation
+
+See [Deployment](https://void.cloud/guide/deployment) for deploying an app and [Platform Development](https://void.cloud/guide/platform-development) for building a runtime or adapter.
+
+Read the [Void documentation](https://void.cloud) online or use the Markdown guides and references in `node_modules/void/docs/`, included with the `void` package.

package/dist/index.d.mts

@@ -2,6 +2,14 @@
 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.
+ */
 export declare function validateManifestShape(parsed: unknown): string | null;
 //#endregion
 //#region src/resource-plan.d.ts
@@ -175,8 +183,8 @@ export declare function isRecord(value: unknown): value is Record<string, unknow
 //#endregion
 //#region src/sql-tokenize.d.ts
 /**
- * Char-by-char SQL tokenizer shared by the destructive-SQL guard
- * (projects.ts) and the single-statement classifier (remote-runner.ts).
+ * Char-by-char SQL tokenizer shared by the migration classifier, the
+ * destructive-SQL guard, and the remote migration runner.
  *
  * Walks the input and yields contiguous segments. `sql` runs are
  * emitted as `{ kind: 'sql', start, end }` so callers can `sql.slice`
@@ -192,12 +200,12 @@ export declare function isRecord(value: unknown): value is Record<string, unknow
  *                          `]` closes the identifier (SQLite semantics;
  *                          differs from MS SQL)
  *
- * Not handled — intentional, both current callers target SQLite only:
+ * Not handled — intentional, every caller targets SQLite only:
  *   - Postgres `$tag$ ... $tag$` dollar-quoting
  *   - Postgres `E'...'` extended string literals
  *
- * Adding a new quoting form anywhere should land here so both callers
- * stay in lockstep.
+ * Adding a new quoting form anywhere should land here so every caller
+ * stays in lockstep.
  */
 type SqlSegment = {
   kind: "sql";
@@ -291,7 +299,10 @@ export type RedirectRule = {
 export type AssetConfig = {
   not_found_handling?: "none" | "single-page-application" | "404-page";
   html_handling?: "auto-trailing-slash" | "force-trailing-slash" | "drop-trailing-slash" | "none";
-  /** Native Cloudflare Workers Assets routing; ignored by managed dispatch. */
+  /**
+   * Native Cloudflare Workers Assets routing. Managed dispatch does not route
+   * by it; it reads it only to tell whether the app's worker answered a request.
+   */
   run_worker_first?: boolean | Array<string>;
 };
 export type WebSocketRouteMeta = {

package/dist/index.mjs

@@ -1,3 +1,9 @@
+//#region src/is-record.ts
+/** Narrow object-shaped input without accepting null or arrays. */
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
 //#region src/validate.ts
 const MANIFEST_REDIRECT_RULE_STATUSES = /* @__PURE__ */ new Set([
 	200,
@@ -10,6 +16,8 @@ const MANIFEST_REDIRECT_RULE_STATUSES = /* @__PURE__ */ new Set([
 const MAX_ROUTING_RULES = 2e3;
 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
@@ -35,11 +43,19 @@ function validateRuleHost(ruleObject, ruleKind, sourceRef) {
 	ruleObject.host = normalized;
 	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.
+*/
 function validateManifestShape(parsed) {
-	if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) return "invalid manifest shape: expected a JSON object";
+	if (!isRecord(parsed)) return "invalid manifest shape: expected a JSON object";
 	const manifest = parsed;
 	if (manifest.emailProtocolVersion !== void 0 && manifest.emailProtocolVersion !== 1) return "invalid manifest shape: emailProtocolVersion must be 1";
-	if (manifest.bindings == null || typeof manifest.bindings !== "object" || Array.isArray(manifest.bindings)) return "invalid manifest shape: bindings must be an object";
+	if (!isRecord(manifest.bindings)) return "invalid manifest shape: bindings must be an object";
 	const bindings = manifest.bindings;
 	for (const key of [
 		"d1",
@@ -54,7 +70,7 @@ function validateManifestShape(parsed) {
 	if (manifest.queues !== void 0) {
 		if (!Array.isArray(manifest.queues)) return "invalid manifest shape: queues must be an array";
 		for (const queue of manifest.queues) {
-			if (queue == null || typeof queue !== "object" || Array.isArray(queue)) return "invalid manifest shape: queues entries must be objects";
+			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";
 			for (const tuning of [
@@ -71,21 +87,25 @@ function validateManifestShape(parsed) {
 	}
 	if (manifest.schedules !== void 0) {
 		if (!Array.isArray(manifest.schedules)) return "invalid manifest shape: schedules must be an array";
+		if (manifest.schedules.length > MAX_SCHEDULES) return `invalid manifest shape: schedules has ${manifest.schedules.length} entries, exceeds the ${MAX_SCHEDULES} per-project limit`;
+		const cronExpressions = /* @__PURE__ */ new Set();
 		for (const schedule of manifest.schedules) {
-			if (schedule == null || typeof schedule !== "object" || Array.isArray(schedule)) return "invalid manifest shape: schedules entries must be objects";
+			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 (cronExpressions.size > MAX_CRON_EXPRESSIONS) return `invalid manifest shape: schedules has ${cronExpressions.size} distinct cron expressions, exceeds the ${MAX_CRON_EXPRESSIONS} per-project limit`;
 	}
 	if (manifest.prerender !== void 0) {
 		if (!Array.isArray(manifest.prerender) || !manifest.prerender.every((x) => typeof x === "string")) return "invalid manifest shape: prerender must be an array of strings";
 	}
 	if (manifest.vars !== void 0) {
-		if (manifest.vars == null || typeof manifest.vars !== "object" || Array.isArray(manifest.vars)) return "invalid manifest shape: vars must be an object";
+		if (!isRecord(manifest.vars)) return "invalid manifest shape: vars must be an object";
 		for (const [k, v] of Object.entries(manifest.vars)) if (typeof v !== "string") return `invalid manifest shape: vars.${k} must be a string`;
 	}
 	if (manifest.migrations !== void 0) {
-		if (manifest.migrations == null || typeof manifest.migrations !== "object" || Array.isArray(manifest.migrations)) return "invalid manifest shape: migrations must be an object";
+		if (!isRecord(manifest.migrations)) return "invalid manifest shape: migrations must be an object";
 		const mig = manifest.migrations;
 		if (mig.dialect !== void 0) {
 			const allowed = [
@@ -118,7 +138,7 @@ function validateManifestShape(parsed) {
 		if (!Array.isArray(manifest.compatibilityFlags) || !manifest.compatibilityFlags.every((x) => typeof x === "string")) return "invalid manifest shape: compatibilityFlags must be an array of strings";
 	}
 	if (manifest.limits !== void 0) {
-		if (manifest.limits == null || typeof manifest.limits !== "object" || Array.isArray(manifest.limits)) return "invalid manifest shape: limits must be an object";
+		if (!isRecord(manifest.limits)) return "invalid manifest shape: limits must be an object";
 		const limits = manifest.limits;
 		if (limits.cpuMs !== void 0) {
 			if (typeof limits.cpuMs !== "number" || !Number.isSafeInteger(limits.cpuMs) || limits.cpuMs < 1) return "invalid manifest shape: limits.cpuMs must be a positive integer";
@@ -134,7 +154,7 @@ function validateManifestShape(parsed) {
 		if (typeof manifest.type !== "string" || !allowed.includes(manifest.type)) return `invalid manifest shape: type must be one of ${allowed.join(", ")}`;
 	}
 	if (manifest.assetConfig !== void 0) {
-		if (manifest.assetConfig == null || typeof manifest.assetConfig !== "object" || Array.isArray(manifest.assetConfig)) return "invalid manifest shape: assetConfig must be an object";
+		if (!isRecord(manifest.assetConfig)) return "invalid manifest shape: assetConfig must be an object";
 		const assetConfig = manifest.assetConfig;
 		if (assetConfig.not_found_handling !== void 0 && ![
 			"none",
@@ -149,13 +169,13 @@ function validateManifestShape(parsed) {
 		].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 (manifest.revalidate == null || typeof manifest.revalidate !== "object" || Array.isArray(manifest.revalidate)) return "invalid manifest shape: revalidate must be a number or object";
+		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.headerRules !== void 0) {
 		if (!Array.isArray(manifest.headerRules)) return "invalid manifest shape: headerRules must be an array";
 		for (const rule of manifest.headerRules) {
-			if (rule == null || typeof rule !== "object" || Array.isArray(rule)) return "invalid manifest shape: headerRules entries must be objects";
+			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";
@@ -166,7 +186,7 @@ function validateManifestShape(parsed) {
 		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 (rule == null || typeof rule !== "object" || Array.isArray(rule)) return "invalid manifest shape: redirectRules entries must be objects";
+			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);
@@ -181,7 +201,7 @@ function validateManifestShape(parsed) {
 		}
 	}
 	if (manifest.revalidateQueryAllowlist !== void 0) {
-		if (manifest.revalidateQueryAllowlist == null || typeof manifest.revalidateQueryAllowlist !== "object" || Array.isArray(manifest.revalidateQueryAllowlist)) return "invalid manifest shape: revalidateQueryAllowlist must be an object";
+		if (!isRecord(manifest.revalidateQueryAllowlist)) return "invalid manifest shape: revalidateQueryAllowlist must be an object";
 		const entries = Object.entries(manifest.revalidateQueryAllowlist);
 		if (entries.length > 2e3) return `invalid manifest shape: revalidateQueryAllowlist has ${entries.length} entries, exceeds the ${MAX_REVALIDATE_QUERY_ALLOWLIST_ENTRIES} entry limit`;
 		for (const [pattern, value] of entries) {
@@ -194,21 +214,21 @@ function validateManifestShape(parsed) {
 		if (!Array.isArray(manifest.pages)) return "invalid manifest shape: pages must be an array";
 		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 (entry == null || typeof entry !== "object" || Array.isArray(entry)) return "invalid manifest shape: each pages entry must be an object";
+			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 (manifest.pathRevalidate !== void 0) {
-		if (manifest.pathRevalidate == null || typeof manifest.pathRevalidate !== "object" || Array.isArray(manifest.pathRevalidate)) return "invalid manifest shape: pathRevalidate must be an object";
+		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 (rule == null || typeof rule !== "object" || Array.isArray(rule)) return "invalid manifest shape: fallbackRules entries must be objects";
+			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);
@@ -222,11 +242,11 @@ function validateManifestShape(parsed) {
 		}
 	}
 	if (manifest.websocket !== void 0) {
-		if (manifest.websocket == null || typeof manifest.websocket !== "object" || Array.isArray(manifest.websocket)) return "invalid manifest shape: websocket must be an object";
+		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 (route == null || typeof route !== "object" || Array.isArray(route)) return "invalid manifest shape: websocket.routes entries must be objects";
+			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";
@@ -235,7 +255,7 @@ function validateManifestShape(parsed) {
 		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 (migration == null || typeof migration !== "object" || Array.isArray(migration)) return "invalid manifest shape: websocket.migrations entries must be objects";
+				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 [
@@ -251,7 +271,7 @@ function validateManifestShape(parsed) {
 	}
 	if (manifest.sandbox !== void 0) {
 		if (manifest.type === "static" || manifest.type === "spa") return "sandbox is not supported for static/spa deployments";
-		if (manifest.sandbox == null || typeof manifest.sandbox !== "object" || Array.isArray(manifest.sandbox)) return "invalid manifest shape: sandbox must be an object";
+		if (!isRecord(manifest.sandbox)) return "invalid manifest shape: sandbox must be an object";
 		const sandbox = manifest.sandbox;
 		for (const key of [
 			"bindingName",
@@ -265,7 +285,7 @@ function validateManifestShape(parsed) {
 		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 (migration == null || typeof migration !== "object" || Array.isArray(migration)) return "invalid manifest shape: sandbox.migrations entries must be objects";
+				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";
@@ -274,7 +294,7 @@ function validateManifestShape(parsed) {
 		}
 	}
 	if (manifest.live !== void 0) {
-		if (manifest.live == null || typeof manifest.live !== "object" || Array.isArray(manifest.live)) return "invalid manifest shape: live must be an object";
+		if (!isRecord(manifest.live)) return "invalid manifest shape: live must be an object";
 		const live = manifest.live;
 		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\"";
@@ -282,7 +302,7 @@ function validateManifestShape(parsed) {
 		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 (migration == null || typeof migration !== "object" || Array.isArray(migration)) return "invalid manifest shape: live.migrations entries must be objects";
+				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";
@@ -292,8 +312,7 @@ function validateManifestShape(parsed) {
 	return null;
 }
 function isLocalImageReference(image) {
-	const lowerImage = image.toLowerCase();
-	return image.startsWith(".") || image.startsWith("/") || lowerImage === "dockerfile" || lowerImage.includes("dockerfile") || lowerImage.endsWith("/dockerfile") || lowerImage.endsWith("\\dockerfile");
+	return image.startsWith(".") || image.startsWith("/") || image.toLowerCase().includes("dockerfile");
 }
 //#endregion
 //#region src/resource-plan.ts
@@ -407,12 +426,6 @@ function canonicalJson(value) {
 	throw new TypeError(`Unsupported canonical JSON value: ${typeof value}`);
 }
 //#endregion
-//#region src/is-record.ts
-/** Narrow object-shaped input without accepting null or arrays. */
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-//#endregion
 //#region src/sql-tokenize.ts
 function* tokenizeSql(sql) {
 	const sqlLength = sql.length;
@@ -519,38 +532,28 @@ const UNSPLIT_MULTI_STATEMENT_PRAGMA = "-- void:allow-unsplit-multi-statement";
 function canonicalSql(sql) {
 	return (sql.charCodeAt(0) === 65279 ? sql.slice(1) : sql).replace(/\r\n?/g, "\n");
 }
-function isStandalonePragmaLine(line, pragma) {
-	return line.trim() === pragma;
-}
 function hasStandalonePragma(sql, pragma) {
-	return canonicalSql(sql).split("\n").some((line) => isStandalonePragmaLine(line, pragma));
+	return canonicalSql(sql).split("\n").some((line) => line.trim() === pragma);
 }
-function isBreakpointComment(text) {
-	return text.trim() === "--> statement-breakpoint";
+/** Yield `--> statement-breakpoint` line comments outside literals. */
+function* breakpointComments(normalized) {
+	for (const segment of tokenizeSql(normalized)) if (segment.kind === "line-comment" && normalized.slice(segment.start, segment.end).trim() === "--> statement-breakpoint") yield segment;
 }
 function splitBreakpointFramedSql(sql) {
 	const normalized = canonicalSql(sql);
 	const statements = [];
 	let cursor = 0;
-	for (const segment of tokenizeSql(normalized)) {
-		if (segment.kind !== "line-comment") continue;
-		if (isBreakpointComment(normalized.slice(segment.start, segment.end))) {
-			const statement = normalized.slice(cursor, segment.start).trim();
-			if (statement) statements.push(statement);
-			cursor = segment.end;
-		}
+	for (const segment of breakpointComments(normalized)) {
+		const statement = normalized.slice(cursor, segment.start).trim();
+		if (statement) statements.push(statement);
+		cursor = segment.end;
 	}
 	const statement = normalized.slice(cursor).trim();
 	if (statement) statements.push(statement);
 	return statements;
 }
 function hasStatementBreakpointOutsideLiterals(sql) {
-	const normalized = canonicalSql(sql);
-	for (const segment of tokenizeSql(normalized)) {
-		if (segment.kind !== "line-comment") continue;
-		if (isBreakpointComment(normalized.slice(segment.start, segment.end))) return true;
-	}
-	return false;
+	return !breakpointComments(canonicalSql(sql)).next().done;
 }
 function scanStatements(sql) {
 	const normalized = canonicalSql(sql);

package/package.json

@@ -1,6 +1,12 @@
 {
   "name": "@void/deploy-core",
-  "version": "0.26.0",
+  "version": "0.26.1",
+  "description": "Shared deployment contracts, manifests, and resource plans for Void.",
+  "homepage": "https://void.cloud",
+  "bugs": {
+    "url": "https://github.com/voidzero-dev/void/issues"
+  },
+  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/voidzero-dev/void.git",
@@ -21,7 +27,7 @@
   },
   "devDependencies": {
     "typescript": "7.0.2",
-    "vite-plus": "1.0.0"
+    "vite-plus": "1.1.0"
   },
   "scripts": {
     "build": "vp pack",