@mediamonks/canopy-cli 0.7.11 → 0.7.12

package/dist/{deploy-BCtEY1is.mjs → deploy-B1WrPq5W.mjs}

@@ -113,6 +113,12 @@ const deployCommand = defineCommand({
 			type: "boolean",
 			default: false,
 			description: "Deploy to the project's staging channel (created on first use, database cloned from live)"
+		},
+		worker: {
+			type: "boolean",
+			default: true,
+			description: "Include the backend worker from canopy.json",
+			negativeDescription: "Deploy the frontend only — for sites whose target hosts no per-project backends"
 		}
 	},
 	run: reportErrors("deploy", async ({ args }) => {
@@ -145,7 +151,8 @@ const deployCommand = defineCommand({
 			});
 		}
 		let workerBytes = null;
-		if (config.worker) {
+		if (config.worker && !args.worker) p.log.warn(`Skipping the backend (${config.worker}) — deploying the frontend only.`);
+		if (config.worker && args.worker) {
 			const spinWorker = p.spinner();
 			spinWorker.start(`Bundling worker ${config.worker}`);
 			try {

package/dist/{dev-DtoZrexp.mjs → dev-BnUYGQQm.mjs}

@@ -37,7 +37,7 @@ async function workerPlugin(flags, slug) {
 		console.log(`note: canopy.json points "worker" at ${entry}, which does not exist — skipping.`);
 		return;
 	}
-	const { missingSecretNames, readDevVars, workerDevPlugin } = await import("./dev-worker-BZgtEM9V.mjs");
+	const { missingSecretNames, readDevVars, workerDevPlugin } = await import("./dev-worker-IWnHvQ1f.mjs");
 	const secrets = readDevVars(flags.dir);
 	const email = siteConfig().email;
 	const plugin = workerDevPlugin({
@@ -165,7 +165,7 @@ async function devRemote(flags, slug) {
 async function devLocal(flags, slug) {
 	let dump;
 	if (flags.pull) {
-		const { fetchProjectDump } = await import("./local-C5AhA4GM.mjs");
+		const { fetchProjectDump } = await import("./local-BGRd_FMZ.mjs");
 		console.log(`Pulling a fresh export of ${slug}${flags.staging ? " [staging]" : ""}…`);
 		dump = await fetchProjectDump(slug, flags.staging ? "staging" : "live");
 	}
@@ -180,7 +180,7 @@ async function devLocal(flags, slug) {
 		const reason = err instanceof ApiError ? err.explain().why : String(err);
 		console.log(`Note: ai/services will be unavailable — could not reach the platform (${reason}).`);
 	}
-	const { createSandbox } = await import("./local-C5AhA4GM.mjs");
+	const { createSandbox } = await import("./local-BGRd_FMZ.mjs");
 	const sandbox = await createSandbox({
 		slug,
 		persistDir: join(flags.dir, ".canopy", "local"),
@@ -233,7 +233,8 @@ async function devLocal(flags, slug) {
 	const server = await startVite(flags, { proxy: {
 		...remoteEntry && {
 			"/_api/data/v1/ai": remoteEntry,
-			"/_api/data/v1/services": remoteEntry
+			"/_api/data/v1/services": remoteEntry,
+			"/_api/data/v1/google": remoteEntry
 		},
 		"/_api": {
 			target: `http://127.0.0.1:${apiAddress.port}`,

package/dist/dev-CySBxW7I.mjs

@@ -0,0 +1,2 @@
+import { t as devCommand } from "./dev-BnUYGQQm.mjs";
+export { devCommand };

package/dist/{dev-worker-BZgtEM9V.mjs → dev-worker-IWnHvQ1f.mjs}

@@ -1,5 +1,43 @@
+import "./src-Bu4Ze32I.mjs";
 import { readFileSync } from "node:fs";
 import { relative, resolve, sep } from "node:path";
+//#region ../data-plane/src/worker-request.ts
+/**
+* How a project's backend addresses the platform — the one definition.
+*
+* Three hosts run project workers and each builds this request itself: the
+* Workers-for-Platforms shim (apps/api/src/platform/wfp-shim.ts), the Node
+* runtime (apps/project-runtime/src/canopy-fetch.ts), and `canopy dev`
+* (packages/cli/src/dev-worker.ts). They had three copies of the header
+* shaping, and the two that hold a worker token had two copies of the
+* credential rule — which is exactly how the Google project grant came to
+* work on one target and not the other.
+*
+* The shim cannot import this: it ships as a standalone module uploaded
+* beside the user bundle, so it may only import `./bundle.mjs`. It keeps a
+* transcription, and `wfp-shim.test.ts` runs it against the table in
+* `worker-request.cases.ts` alongside this implementation, so the two cannot
+* drift silently.
+*/
+/** Gateway-stamped identity, for the worker's own `env.USER` — never relayed. */
+const IDENTITY_STAMP_HEADERS = [
+	"x-canopy-user-sub",
+	"x-canopy-user-email",
+	"x-canopy-user-name"
+];
+/**
+* Strip what must never travel upstream and stamp who is calling. Common to
+* every host; says nothing about credentials.
+*/
+function stampWorkerHeaders(headers, ctx) {
+	headers.delete("host");
+	for (const stamp of IDENTITY_STAMP_HEADERS) headers.delete(stamp);
+	headers.set("x-canopy-project", ctx.projectSlug);
+	if (ctx.channel === "staging") headers.set("x-canopy-channel", "staging");
+	else headers.delete("x-canopy-channel");
+	return headers;
+}
+//#endregion
 //#region src/dev-worker.ts
 /**
 * Paths that belong to the worker rather than the SPA — the gateway's rule
@@ -79,15 +117,12 @@ function rewriteCanopyUrl(raw, base) {
 function createCanopyFetch(apiBase, slug, channel, fetchImpl = fetch) {
 	return async (input, init) => {
 		const url = rewriteCanopyUrl(typeof input === "string" ? input : input instanceof URL ? input.href : input.url, apiBase());
-		const headers = new Headers(input instanceof Request ? input.headers : init?.headers);
-		headers.delete("host");
-		headers.delete("x-canopy-user-sub");
-		headers.delete("x-canopy-user-email");
-		headers.delete("x-canopy-user-name");
+		const headers = stampWorkerHeaders(new Headers(input instanceof Request ? input.headers : init?.headers), {
+			projectSlug: slug,
+			channel
+		});
 		headers.delete("authorization");
 		headers.delete("cookie");
-		headers.set("x-canopy-project", slug);
-		if (channel === "staging") headers.set("x-canopy-channel", "staging");
 		const method = (input instanceof Request ? input.method : init?.method) ?? "GET";
 		const body = input instanceof Request ? input.body : init?.body;
 		const outbound = {

package/dist/{docs-BV9qhLJx.mjs → docs-DxB7NhZs.mjs}

@@ -1,4 +1,4 @@
-import { t as version } from "./package-BBpw-n7k.mjs";
+import { t as version } from "./package-CDLufecy.mjs";
 import { n as siteConfig } from "./site-BUlQR117.mjs";
 import { i as latestKnownVersion, r as compareSemver } from "./version-check-CcsA1QjI.mjs";
 import { n as reportErrors } from "./ui-2mrJcjYC.mjs";

package/dist/{feedback-Cb8ccQ_R.mjs → feedback-B-GXUBPs.mjs}

@@ -1,4 +1,4 @@
-import { t as version } from "./package-BBpw-n7k.mjs";
+import { t as version } from "./package-CDLufecy.mjs";
 import { a as projectDirArgs, c as resolveProject, n as siteConfig, u as tryReadCanopyJson } from "./site-BUlQR117.mjs";
 import { c as apiRequest, l as apiUpload, n as reportErrors, s as apiDownload } from "./ui-2mrJcjYC.mjs";
 import { defineCommand } from "citty";

package/dist/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as version } from "./package-BBpw-n7k.mjs";
+import { t as version } from "./package-CDLufecy.mjs";
 import { r as siteHeaderLine, t as setInvocationProfile } from "./site-BUlQR117.mjs";
 import { a as notifyOfUpdate, o as runRefresh } from "./version-check-CcsA1QjI.mjs";
 import { defineCommand, runMain } from "citty";
@@ -67,21 +67,21 @@ const main = defineCommand({
 		init: () => import("./projects-C6JQjVqg.mjs").then((m) => m.initCommand),
 		projects: () => import("./projects-C6JQjVqg.mjs").then((m) => m.projectsCommand),
 		delete: () => import("./projects-C6JQjVqg.mjs").then((m) => m.deleteCommand),
-		dev: () => import("./dev-BYxSHUH6.mjs").then((m) => m.devCommand),
-		deploy: () => import("./deploy-BCtEY1is.mjs").then((m) => m.deployCommand),
-		promote: () => import("./deploy-BCtEY1is.mjs").then((m) => m.promoteCommand),
+		dev: () => import("./dev-CySBxW7I.mjs").then((m) => m.devCommand),
+		deploy: () => import("./deploy-B1WrPq5W.mjs").then((m) => m.deployCommand),
+		promote: () => import("./deploy-B1WrPq5W.mjs").then((m) => m.promoteCommand),
 		staging: () => import("./staging-Bw1D_J8M.mjs").then((m) => m.stagingCommand),
-		rollback: () => import("./deploy-BCtEY1is.mjs").then((m) => m.rollbackCommand),
-		download: () => import("./deploy-BCtEY1is.mjs").then((m) => m.downloadCommand),
+		rollback: () => import("./deploy-B1WrPq5W.mjs").then((m) => m.rollbackCommand),
+		download: () => import("./deploy-B1WrPq5W.mjs").then((m) => m.downloadCommand),
 		token: () => import("./token-D7zrIF8G.mjs").then((m) => m.tokenCommand),
 		egress: () => import("./egress-CN_axsAN.mjs").then((m) => m.egressCommand),
-		feedback: () => import("./feedback-Cb8ccQ_R.mjs").then((m) => m.feedbackCommand),
+		feedback: () => import("./feedback-B-GXUBPs.mjs").then((m) => m.feedbackCommand),
 		db: () => import("./db-8Etjmzxh.mjs").then((m) => m.dbCommand),
 		usage: () => import("./usage-CX1Izj_l.mjs").then((m) => m.usageCommand),
 		open: () => import("./open-DRPp4QJg.mjs").then((m) => m.openCommand),
-		docs: () => import("./docs-BV9qhLJx.mjs").then((m) => m.docsCommand),
-		skill: () => import("./skill-DJHlTEhS.mjs").then((m) => m.skillCommand),
-		upgrade: () => import("./upgrade-B86Ao6T5.mjs").then((m) => m.upgradeCommand),
+		docs: () => import("./docs-DxB7NhZs.mjs").then((m) => m.docsCommand),
+		skill: () => import("./skill-BOWfqwr2.mjs").then((m) => m.skillCommand),
+		upgrade: () => import("./upgrade-fhfrid_O.mjs").then((m) => m.upgradeCommand),
 		logs: () => import("./logs-DNiZquki.mjs").then((m) => m.logsCommand)
 	}
 });

package/dist/{local-C5AhA4GM.mjs → local-BGRd_FMZ.mjs}

@@ -1,477 +1,10 @@
 import { o as apiDataRequest } from "./ui-2mrJcjYC.mjs";
-import { n as rewriteApiPath } from "./dev-DtoZrexp.mjs";
+import { n as META_COLUMNS, r as blobRouter, t as dbRouter } from "./src-Bu4Ze32I.mjs";
+import { n as rewriteApiPath } from "./dev-BnUYGQQm.mjs";
 import { createRequire } from "node:module";
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, relative, sep } from "node:path";
 import { Hono } from "hono";
-//#region ../data-plane/src/blob.ts
-/**
-* /blob — the SDK's file storage over an injectable BlobStore (a bucket
-* plus the project's isolated key prefix). Same single-implementation deal as
-* db.ts: canopy-api and the CLI's local sandbox mount this exact router.
-*
-* Authorization is the HOST's job (canopy-api enforces session-or-signature
-* ahead of this router; the local sandbox has no auth wall). This router only
-* mints download URLs via the injected signer — verification lives with the
-* host's auth middleware (see signing.ts).
-*/
-const MAX_BLOB_BYTES = 25 * 1024 * 1024;
-const MAX_LIST_KEYS = 1e3;
-const URL_TTL_SECONDS = 600;
-/** Keys may nest with `/`, but never escape the prefix or surprise a URL. */
-function safeBlobKey(raw) {
-	if (raw.length === 0 || raw.length > 512) return null;
-	if (raw.includes("\\") || raw.includes("\0")) return null;
-	if (raw.split("/").some((seg) => seg === "" || seg === "." || seg === "..")) return null;
-	return raw;
-}
-function blobRouter(config) {
-	const blob = new Hono();
-	const resolve = async (c) => config.store(c);
-	blob.put("/blob/:key", async (c) => {
-		const resolved = await resolve(c);
-		if (resolved instanceof Response) return resolved;
-		const { store } = resolved;
-		const key = safeBlobKey(c.req.param("key"));
-		if (!key) return c.json({ error: "invalid_key" }, 400);
-		if (Number(c.req.header("content-length") ?? 0) > MAX_BLOB_BYTES) return c.json({
-			error: "blob_too_large",
-			maxBytes: MAX_BLOB_BYTES
-		}, 413);
-		const body = await c.req.raw.arrayBuffer();
-		if (body.byteLength > MAX_BLOB_BYTES) return c.json({
-			error: "blob_too_large",
-			maxBytes: MAX_BLOB_BYTES
-		}, 413);
-		const contentType = c.req.header("content-type") ?? "application/octet-stream";
-		await store.bucket.put(store.prefix + key, body, { httpMetadata: { contentType } });
-		return c.json({
-			key,
-			size: body.byteLength,
-			contentType,
-			uploadedAt: (/* @__PURE__ */ new Date()).toISOString()
-		}, 201);
-	});
-	blob.get("/blob", async (c) => {
-		const resolved = await resolve(c);
-		if (resolved instanceof Response) return resolved;
-		const { store } = resolved;
-		const prefix = c.req.query("prefix") ?? "";
-		if (prefix.length > 512 || prefix.includes("\0")) return c.json({ error: "invalid_prefix" }, 400);
-		const base = store.prefix;
-		const objects = [];
-		let cursor;
-		do {
-			const page = await store.bucket.list({
-				prefix: base + prefix,
-				cursor,
-				include: ["httpMetadata"]
-			});
-			for (const o of page.objects) objects.push({
-				key: o.key.slice(base.length),
-				size: o.size,
-				contentType: o.httpMetadata?.contentType ?? "application/octet-stream",
-				uploadedAt: o.uploaded.toISOString()
-			});
-			cursor = page.truncated && objects.length < MAX_LIST_KEYS ? page.cursor : void 0;
-		} while (cursor);
-		return c.json(objects.slice(0, MAX_LIST_KEYS));
-	});
-	blob.get("/blob/:key/url", async (c) => {
-		const resolved = await resolve(c);
-		if (resolved instanceof Response) return resolved;
-		const { slug, store } = resolved;
-		const key = safeBlobKey(c.req.param("key"));
-		if (!key) return c.json({ error: "invalid_key" }, 400);
-		if (!await store.bucket.head(store.prefix + key)) return c.json({ error: "not_found" }, 404);
-		const exp = Math.floor(Date.now() / 1e3) + URL_TTL_SECONDS;
-		const sig = await config.signDownload(c, slug, key, exp);
-		return c.json({
-			url: `/_api/data/v1/blob/${encodeURIComponent(key)}?project=${encodeURIComponent(slug)}&exp=${exp}&sig=${sig}`,
-			expiresAt: (/* @__PURE__ */ new Date(exp * 1e3)).toISOString()
-		});
-	});
-	blob.get("/blob/:key", async (c) => {
-		const resolved = await resolve(c);
-		if (resolved instanceof Response) return resolved;
-		const { store } = resolved;
-		const key = safeBlobKey(c.req.param("key"));
-		if (!key) return c.json({ error: "invalid_key" }, 400);
-		const object = await store.bucket.get(store.prefix + key);
-		if (!object) return c.json({ error: "not_found" }, 404);
-		return new Response(object.body, { headers: {
-			"content-type": object.httpMetadata?.contentType ?? "application/octet-stream",
-			"cache-control": "private, no-store"
-		} });
-	});
-	blob.delete("/blob/:key", async (c) => {
-		const resolved = await resolve(c);
-		if (resolved instanceof Response) return resolved;
-		const { store } = resolved;
-		const key = safeBlobKey(c.req.param("key"));
-		if (!key) return c.json({ error: "invalid_key" }, 400);
-		const fullKey = store.prefix + key;
-		const existed = await store.bucket.head(fullKey) !== null;
-		await store.bucket.delete(fullKey);
-		return c.json({ deleted: existed });
-	});
-	return blob;
-}
-//#endregion
-//#region ../data-plane/src/dialect.ts
-/** Platform-managed fields map to real columns instead of JSON extraction. */
-const META_COLUMNS = {
-	_id: "id",
-	_createdAt: "created_at",
-	_updatedAt: "updated_at"
-};
-//#endregion
-//#region ../data-plane/src/schema.ts
-/** Platform/system tables never shown to users. */
-const RESERVED = /^(_canopy_|_cf_|sqlite_|pg_)/;
-/** Single-quoted SQL string literal (introspection args ride inline, not bound). */
-const lit = (value) => `'${value.replaceAll("'", "''")}'`;
-async function sqliteSchema(store) {
-	const names = (await store.query(`SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name`)).results.map((r) => String(r.name)).filter((n) => !RESERVED.test(n));
-	return Promise.all(names.map(async (name) => {
-		const [cols, idxList] = await Promise.all([store.query(`SELECT name, type, "notnull" AS not_null, pk FROM pragma_table_info(${lit(name)})`), store.query(`SELECT name, "unique" AS is_unique FROM pragma_index_list(${lit(name)})`)]);
-		const indexes = await Promise.all(idxList.results.filter((idx) => !RESERVED.test(String(idx.name))).map(async (idx) => ({
-			name: String(idx.name),
-			unique: Boolean(Number(idx.is_unique)),
-			columns: (await store.query(`SELECT name FROM pragma_index_info(${lit(String(idx.name))})`)).results.map((r) => String(r.name))
-		})));
-		return {
-			name,
-			columns: cols.results.map((col) => ({
-				name: String(col.name),
-				type: String(col.type),
-				nullable: !Number(col.not_null),
-				pk: Number(col.pk) > 0
-			})),
-			indexes
-		};
-	}));
-}
-async function postgresSchema(store) {
-	const [tables, columns, pks, indexes] = await Promise.all([
-		store.query(`SELECT table_name AS name FROM information_schema.tables
-        WHERE table_schema = current_schema() AND table_type = 'BASE TABLE'
-        ORDER BY table_name`),
-		store.query(`SELECT table_name, column_name, data_type, is_nullable
-         FROM information_schema.columns
-        WHERE table_schema = current_schema()
-        ORDER BY table_name, ordinal_position`),
-		store.query(`SELECT tc.table_name, kcu.column_name
-         FROM information_schema.table_constraints tc
-         JOIN information_schema.key_column_usage kcu
-           ON kcu.constraint_name = tc.constraint_name
-          AND kcu.table_schema = tc.table_schema
-        WHERE tc.constraint_type = 'PRIMARY KEY' AND tc.table_schema = current_schema()`),
-		store.query(`SELECT t.relname AS table_name, i.relname AS index_name,
-              ix.indisunique AS is_unique, a.attname AS column_name
-         FROM pg_index ix
-         JOIN pg_class i ON i.oid = ix.indexrelid
-         JOIN pg_class t ON t.oid = ix.indrelid
-         JOIN pg_namespace n ON n.oid = t.relnamespace
-         JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
-        WHERE n.nspname = current_schema() AND NOT ix.indisprimary`)
-	]);
-	const pkSet = new Set(pks.results.map((r) => `${String(r.table_name)}.${String(r.column_name)}`));
-	const byTable = /* @__PURE__ */ new Map();
-	for (const row of tables.results) {
-		const name = String(row.name);
-		if (!RESERVED.test(name)) byTable.set(name, {
-			name,
-			columns: [],
-			indexes: []
-		});
-	}
-	for (const col of columns.results) {
-		const table = byTable.get(String(col.table_name));
-		if (!table) continue;
-		table.columns.push({
-			name: String(col.column_name),
-			type: String(col.data_type),
-			nullable: col.is_nullable === "YES",
-			pk: pkSet.has(`${String(col.table_name)}.${String(col.column_name)}`)
-		});
-	}
-	for (const idx of indexes.results) {
-		const table = byTable.get(String(idx.table_name));
-		if (!table) continue;
-		const name = String(idx.index_name);
-		let index = table.indexes.find((i) => i.name === name);
-		if (!index) {
-			index = {
-				name,
-				unique: Boolean(idx.is_unique),
-				columns: []
-			};
-			table.indexes.push(index);
-		}
-		index.columns.push(String(idx.column_name));
-	}
-	return [...byTable.values()];
-}
-async function introspectSchema(store, dialect) {
-	const [tables, collections] = await Promise.all([dialect === "postgres" ? postgresSchema(store) : sqliteSchema(store), store.query("SELECT collection, COUNT(*) AS docs FROM _canopy_docs GROUP BY collection ORDER BY collection").then((r) => r.results.map((row) => ({
-		name: String(row.collection),
-		docs: Number(row.docs)
-	}))).catch(() => [])]);
-	return {
-		dialect,
-		collections,
-		tables
-	};
-}
-//#endregion
-//#region ../data-plane/src/db.ts
-/**
-* /db — the SDK's document API + raw-SQL escape hatch, over an injectable
-* DocStore. This is THE data-plane implementation: canopy-api mounts it under
-* /data/v1 against project D1s (or Postgres on GCP), and `canopy dev --local`
-* mounts the very same router against PGlite — one place to change when the
-* API surface moves.
-*
-* Paths carry no project: hosts wrap the router with their own auth/scope
-* middleware, resolve the project themselves (gateway-stamped
-* X-Canopy-Project or token scope — see canopy-api's session.ts), and hand
-* back the store in `config.store` (returning a Response for not-found/paused…).
-*/
-const COLLECTION_RE = /^[a-z][a-z0-9_]{0,63}$/;
-const FIELD_RE = /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$/;
-const MAX_DOC_BYTES = 256 * 1024;
-const MAX_LIMIT = 1e3;
-/** Row cap for versioned /db/sql responses (the legacy shape is uncapped). */
-const MAX_SQL_ROWS = 1e3;
-/**
-* Statement classifier for read-only /db/sql runs. First keyword must be a
-* read; WITH additionally may not smuggle DML in a CTE (impossible on SQLite,
-* possible on Postgres — where hosts also enforce `SET TRANSACTION READ ONLY`
-* at the engine, making this the belt to that suspender).
-*/
-function readOnlySqlViolation(query) {
-	const bare = query.replace(/--[^\n]*/g, " ").replace(/\/\*[\s\S]*?\*\//g, " ").replace(/'(?:[^']|'')*'/g, "''").replace(/"(?:[^"]|"")*"/g, "\"\"");
-	const first = /^\s*([A-Za-z]+)/.exec(bare)?.[1]?.toUpperCase();
-	if (first === void 0) return "empty statement";
-	if (![
-		"SELECT",
-		"EXPLAIN",
-		"VALUES",
-		"WITH"
-	].includes(first)) return `${first} is not allowed in read-only mode`;
-	const dml = /\b(INSERT|UPDATE|DELETE|MERGE|REPLACE|CREATE|ALTER|DROP|TRUNCATE|GRANT|REVOKE|VACUUM|ATTACH|REINDEX)\b/i.exec(bare);
-	if (first === "WITH" && dml) return `${dml[1].toUpperCase()} is not allowed in read-only mode`;
-	if (first === "EXPLAIN" && dml && /\bANALYZE\b/i.test(bare)) return "EXPLAIN ANALYZE on a write is not allowed in read-only mode";
-	return null;
-}
-function toDoc(row) {
-	return {
-		...JSON.parse(row.data),
-		_id: row.id,
-		_createdAt: row.created_at,
-		_updatedAt: row.updated_at
-	};
-}
-function isPlainObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/** User fields only — `_`-prefixed keys are platform-managed. */
-function stripMetaKeys(doc) {
-	return Object.fromEntries(Object.entries(doc).filter(([key]) => !key.startsWith("_")));
-}
-function isScalar(value) {
-	return value === null || [
-		"string",
-		"number",
-		"boolean"
-	].includes(typeof value);
-}
-var BadQuery = class extends Error {};
-/** Validate a where object: known meta keys / dot-path fields, scalar values. */
-function validateWhere(where) {
-	for (const [field, value] of Object.entries(where)) {
-		if (!isScalar(value)) throw new BadQuery(`where.${field}: only string/number/boolean/null values are supported`);
-		if (!META_COLUMNS[field] && !FIELD_RE.test(field)) throw new BadQuery(`where.${field}: invalid field name`);
-	}
-	return where;
-}
-function intParam(raw, name, fallback, max) {
-	if (raw === void 0) return fallback;
-	if (!/^\d{1,9}$/.test(raw)) throw new BadQuery(`${name} must be a non-negative integer`);
-	return Math.min(Number(raw), max);
-}
-function dbRouter(config) {
-	const db = new Hono();
-	const resolve = async (c) => config.store(c);
-	db.post("/db/sql", async (c) => {
-		const resolved = await resolve(c);
-		if (resolved instanceof Response) return resolved;
-		const { store } = resolved;
-		const body = await c.req.json().catch(() => ({}));
-		const params = body.params ?? [];
-		if (typeof body.query !== "string" || body.query.trim() === "" || !Array.isArray(params) || !params.every(isScalar) || !(body.readonly === void 0 || typeof body.readonly === "boolean")) return c.json({
-			error: "invalid_query",
-			detail: "expected { query: string, params?: (string|number|boolean|null)[], readonly?: boolean }"
-		}, 400);
-		if (body.readonly === void 0) {
-			const result = await store.query(body.query, params).catch((err) => err);
-			if (result instanceof Error) return c.json({
-				error: "sql_error",
-				detail: result.message
-			}, 400);
-			return c.json(result.results);
-		}
-		if (body.readonly) {
-			const violation = readOnlySqlViolation(body.query);
-			if (violation) return c.json({
-				error: "read_only",
-				detail: violation
-			}, 400);
-		}
-		const result = await store.query(body.query, params, { readonly: body.readonly }).catch((err) => err);
-		if (result instanceof Error) return c.json({
-			error: "sql_error",
-			detail: result.message
-		}, 400);
-		if (!body.readonly) await config.onSqlWrite?.(c, body.query);
-		const truncated = result.results.length > MAX_SQL_ROWS;
-		const rows = truncated ? result.results.slice(0, MAX_SQL_ROWS) : result.results;
-		return c.json({
-			rows,
-			rowCount: rows.length,
-			truncated
-		});
-	});
-	db.get("/db/schema", async (c) => {
-		const resolved = await resolve(c);
-		if (resolved instanceof Response) return resolved;
-		const schema = await introspectSchema(resolved.store, resolved.dialect.name).catch((err) => err);
-		if (schema instanceof Error) return c.json({
-			error: "sql_error",
-			detail: schema.message
-		}, 400);
-		return c.json(schema);
-	});
-	db.post("/db/:collection", async (c) => {
-		const resolved = await resolve(c);
-		if (resolved instanceof Response) return resolved;
-		const { store, dialect } = resolved;
-		const collection = c.req.param("collection");
-		if (!COLLECTION_RE.test(collection)) return c.json({ error: "invalid_collection" }, 400);
-		const body = await c.req.json().catch(() => void 0);
-		if (!isPlainObject(body)) return c.json({
-			error: "invalid_document",
-			detail: "expected a JSON object"
-		}, 400);
-		const fields = stripMetaKeys(body);
-		const data = JSON.stringify(fields);
-		if (data.length > MAX_DOC_BYTES) return c.json({
-			error: "document_too_large",
-			maxBytes: MAX_DOC_BYTES
-		}, 413);
-		const id = crypto.randomUUID();
-		const now = (/* @__PURE__ */ new Date()).toISOString();
-		const insert = dialect.insert(collection, id, data, now);
-		await store.query(insert.sql, insert.params);
-		return c.json({
-			...fields,
-			_id: id,
-			_createdAt: now,
-			_updatedAt: now
-		}, 201);
-	});
-	db.get("/db/:collection", async (c) => {
-		const resolved = await resolve(c);
-		if (resolved instanceof Response) return resolved;
-		const { store, dialect } = resolved;
-		const collection = c.req.param("collection");
-		if (!COLLECTION_RE.test(collection)) return c.json({ error: "invalid_collection" }, 400);
-		const q = c.req.query();
-		try {
-			const limit = intParam(q.limit, "limit", 100, MAX_LIMIT);
-			const offset = intParam(q.offset, "offset", 0, 1e9);
-			let whereRaw = {};
-			if (q.where !== void 0) {
-				try {
-					whereRaw = JSON.parse(q.where);
-				} catch {
-					throw new BadQuery("where must be a JSON object");
-				}
-				if (!isPlainObject(whereRaw)) throw new BadQuery("where must be a JSON object");
-			}
-			const where = validateWhere(whereRaw);
-			let query;
-			if (q.search !== void 0) {
-				query = dialect.search({
-					collection,
-					text: q.search,
-					where,
-					limit,
-					offset
-				});
-				if (query === null) return c.json([]);
-			} else {
-				if (q.orderBy !== void 0 && !META_COLUMNS[q.orderBy] && !FIELD_RE.test(q.orderBy)) throw new BadQuery("orderBy: invalid field name");
-				if (q.order !== void 0 && q.order !== "asc" && q.order !== "desc") throw new BadQuery("order must be 'asc' or 'desc'");
-				query = dialect.find({
-					collection,
-					where,
-					orderBy: q.orderBy,
-					order: q.order === "desc" ? "desc" : "asc",
-					limit,
-					offset
-				});
-			}
-			const result = await store.query(query.sql, query.params);
-			return c.json(result.results.map(toDoc));
-		} catch (err) {
-			if (err instanceof BadQuery) return c.json({
-				error: "invalid_query",
-				detail: err.message
-			}, 400);
-			throw err;
-		}
-	});
-	db.get("/db/:collection/:id", async (c) => {
-		const resolved = await resolve(c);
-		if (resolved instanceof Response) return resolved;
-		const { store, dialect } = resolved;
-		const collection = c.req.param("collection");
-		if (!COLLECTION_RE.test(collection)) return c.json({ error: "invalid_collection" }, 400);
-		const get = dialect.get(collection, c.req.param("id"));
-		const row = (await store.query(get.sql, get.params)).results[0];
-		return c.json(row ? toDoc(row) : null);
-	});
-	db.patch("/db/:collection/:id", async (c) => {
-		const resolved = await resolve(c);
-		if (resolved instanceof Response) return resolved;
-		const { store, dialect } = resolved;
-		const collection = c.req.param("collection");
-		if (!COLLECTION_RE.test(collection)) return c.json({ error: "invalid_collection" }, 400);
-		const body = await c.req.json().catch(() => void 0);
-		if (!isPlainObject(body)) return c.json({
-			error: "invalid_patch",
-			detail: "expected a JSON object"
-		}, 400);
-		const patch = dialect.patch(collection, c.req.param("id"), JSON.stringify(stripMetaKeys(body)), (/* @__PURE__ */ new Date()).toISOString());
-		const row = (await store.query(patch.sql, patch.params)).results[0];
-		if (!row) return c.json({ error: "not_found" }, 404);
-		return c.json(toDoc(row));
-	});
-	db.delete("/db/:collection/:id", async (c) => {
-		const resolved = await resolve(c);
-		if (resolved instanceof Response) return resolved;
-		const { store, dialect } = resolved;
-		const collection = c.req.param("collection");
-		if (!COLLECTION_RE.test(collection)) return c.json({ error: "invalid_collection" }, 400);
-		const del = dialect.del(collection, c.req.param("id"));
-		const result = await store.query(del.sql, del.params);
-		return c.json({ deleted: (result.meta.changes ?? 0) > 0 });
-	});
-	return db;
-}
-//#endregion
 //#region ../data-plane/src/dialect-postgres.ts
 /**
 * Postgres doc-store dialect (Cloud SQL, PGlite). Same table shape as SQLite
@@ -1270,6 +803,10 @@ async function createSandbox(options) {
 		error: "not_available_in_local_dev",
 		detail: "services need the platform — log in (`canopy login`) so --local can proxy them."
 	}, 501));
+	app.all("/data/v1/google/*", (c) => c.json({
+		error: "not_available_in_local_dev",
+		detail: "google needs the platform — log in (`canopy login`) so --local can proxy it. The account itself is connected in the dashboard, not on your laptop."
+	}, 501));
 	app.notFound((c) => c.json({
 		error: "not_available_in_local_dev",
 		detail: "the local sandbox serves the data plane only (db, blob, auth.user, sdk.js) — control-plane calls need `canopy dev` against the platform."

package/dist/{package-BBpw-n7k.mjs → package-CDLufecy.mjs}

@@ -1,4 +1,4 @@
 //#region package.json
-var version = "0.7.11";
+var version = "0.7.12";
 //#endregion
 export { version as t };