@plitzi/sdk-server 0.38.9 → 0.38.11

package/dist/modules/actions/tasks/flow.js

@@ -131,65 +131,143 @@ var emit = {
 		return { emitted: true };
 	}
 };
+/**
+* Refuses the run once a caller has asked too often — a contact form, a vote, a comment box, anything public.
+*
+* A fixed window per bucket: at most `limit` runs every `windowSeconds`, counted in the space's `kv` (shared by every
+* replica that shares it). `per: caller` gives each person their own count — the signed-in account, or the address of
+* whoever is not signed in — which is what a public action wants; `per: everyone` is one count for all of them, a
+* ceiling on the action itself. Refused with the message, which the caller sees as the run's `error`.
+*/
+var rateLimit = {
+	namespace: "flow",
+	action: "rateLimit",
+	title: "Rate Limit",
+	params: {
+		bucket: {
+			type: "text",
+			canBind: true,
+			defaultValue: "",
+			label: "Name (what is counted — \"comments\")"
+		},
+		limit: {
+			type: "text",
+			canBind: true,
+			defaultValue: "10",
+			label: "At most"
+		},
+		windowSeconds: {
+			type: "text",
+			canBind: true,
+			defaultValue: "60",
+			label: "Every (seconds)"
+		},
+		per: {
+			type: "select",
+			canBind: true,
+			defaultValue: "caller",
+			label: "Counted",
+			options: [{
+				label: "For each person",
+				value: "caller"
+			}, {
+				label: "For everyone together",
+				value: "everyone"
+			}]
+		},
+		message: {
+			type: "text",
+			canBind: true,
+			defaultValue: "",
+			label: "Refusal (what the caller is told)"
+		}
+	},
+	run: async ({ bucket, limit, windowSeconds, per, message }, ctx) => {
+		const perSeconds = Number(windowSeconds);
+		const { allowed, count, remaining } = await countRate(ctx.kv, ctx.callerId, bucket, {
+			most: Number(limit),
+			perSeconds,
+			per: per === "everyone" ? "everyone" : "caller"
+		});
+		if (!allowed) throw new ActionRefusal(message || `Too many at once — try again in ${String(perSeconds)} seconds`);
+		return {
+			count,
+			remaining
+		};
+	}
+};
+var jsonInput = (value) => {
+	if (typeof value !== "string") return value;
+	try {
+		return JSON.parse(value || "{}");
+	} catch {
+		throw new Error("The input of a run set for later is JSON: `{ \"room\": \"{{ input.room }}\" }`");
+	}
+};
 var flowTasks = [
 	delay,
 	fail,
 	output,
 	onFailure,
+	rateLimit,
 	{
 		namespace: "flow",
-		action: "rateLimit",
-		title: "Rate Limit",
+		action: "later",
+		title: "Run Later",
+		description: "Starts one of the space’s actions — one with a “later” trigger — in so many seconds, on the server.",
 		params: {
-			bucket: {
+			action: {
 				type: "text",
 				canBind: true,
 				defaultValue: "",
-				label: "Name (what is counted — \"comments\")"
+				label: "Action (its identifier)"
 			},
-			limit: {
+			in: {
 				type: "text",
 				canBind: true,
-				defaultValue: "10",
-				label: "At most"
+				defaultValue: "30",
+				label: "In (seconds)"
 			},
-			windowSeconds: {
-				type: "text",
+			input: {
+				type: "codemirror-json",
 				canBind: true,
-				defaultValue: "60",
-				label: "Every (seconds)"
+				defaultValue: "{}",
+				label: "Its input"
 			},
-			per: {
-				type: "select",
-				canBind: true,
-				defaultValue: "caller",
-				label: "Counted",
-				options: [{
-					label: "For each person",
-					value: "caller"
-				}, {
-					label: "For everyone together",
-					value: "everyone"
-				}]
-			},
-			message: {
+			key: {
 				type: "text",
 				canBind: true,
 				defaultValue: "",
-				label: "Refusal (what the caller is told)"
+				label: "Known as (replaces what waits under it)"
 			}
 		},
-		run: async ({ bucket, limit, windowSeconds, per, message }, ctx) => {
-			const perSeconds = Number(windowSeconds);
-			const { allowed, count, remaining } = await countRate(ctx.kv, ctx.callerId, bucket, {
-				most: Number(limit),
-				perSeconds,
-				per: per === "everyone" ? "everyone" : "caller"
+		run: async ({ action, in: seconds, input, key }, ctx) => {
+			if (!ctx.later) throw new Error("This server runs no jobs: nothing can be set to run later");
+			const given = jsonInput(input);
+			return ctx.later({
+				action,
+				in: Number(seconds),
+				input: typeof given === "object" && given !== null && !Array.isArray(given) ? { ...given } : {},
+				...key === "" ? {} : { key }
 			});
-			if (!allowed) throw new ActionRefusal(message || `Too many at once — try again in ${String(perSeconds)} seconds`);
+		}
+	},
+	{
+		namespace: "flow",
+		action: "cancelLater",
+		title: "Cancel Later",
+		description: "Drops the runs set for later under a key that are still waiting.",
+		params: { key: {
+			type: "text",
+			canBind: true,
+			defaultValue: "",
+			label: "Known as"
+		} },
+		run: async ({ key }, ctx) => {
+			if (!ctx.cancelLater) throw new Error("This server runs no jobs: nothing was set to run later");
 			return {
-				count,
-				remaining
+				key,
+				cancelled: await ctx.cancelLater(key)
 			};
 		}
 	}

package/dist/modules/actions/types.d.ts

@@ -1,3 +1,4 @@
+import { LaterAnswer, LaterRequest } from './jobs/later';
 import { ActionEmailSender } from './runtime/email';
 import { FunctionsConfig } from '../functions/config';
 import { SpaceFunctions } from '../functions/protocol';
@@ -196,6 +197,13 @@ export type ActionTaskContext = {
     grant?: (topic: string, ttlSeconds?: number) => Promise<string>;
     /** Revokes `grant` for `topic` — or every grant for it, naming none — and lets go whoever is on it with one. */
     revoke?: (topic: string, grant?: string) => Promise<void>;
+    /**
+     * Starts one of this space's actions in so many seconds, by its `later` trigger (`jobs/later.ts`) — `undefined` when
+     * the server runs no jobs. What `flow.later` and a function's `ctx.later` go through.
+     */
+    later?: (request: LaterRequest) => Promise<LaterAnswer>;
+    /** Drops the runs waiting under `key`, and answers how many. */
+    cancelLater?: (key: string) => Promise<number>;
     /** Signs with the space's own key (`ActionsConfig.signingSecret`) — `undefined` when the deployment gave none. */
     sign?: SpaceSigning['sign'];
     verify?: SpaceSigning['verify'];

package/dist/modules/functions/build.js

@@ -55,7 +55,7 @@ var sourcePlugin = (files) => ({
 				path: CONTRACT_SPECIFIER,
 				namespace: "contract"
 			};
-			if (args.kind !== "entry-point" && !args.path.startsWith(".")) return { errors: [{ text: `"${args.path}" cannot be imported: functions import their own files and ${CONTRACT_SPECIFIER}, nothing else` }] };
+			if (args.kind !== "entry-point" && !args.path.startsWith(".")) return { errors: [{ text: `"${args.path}" cannot be imported: functions import their own files and ${CONTRACT_SPECIFIER}, nothing else — a package of web APIs is bundled in as one of their files with \`plitzi functions add ${args.path.startsWith("node:") ? "<package>" : args.path}\`` }] };
 			const base = args.kind === "entry-point" ? "." : path.posix.dirname(args.importer);
 			const wanted = normalize(path.posix.join(base, args.path));
 			if (wanted === ".." || wanted.startsWith("../")) return { errors: [{ text: outsideFunctions(args.path, wanted) }] };

package/dist/modules/functions/capabilities.js

@@ -129,6 +129,17 @@ var fetchInitOf = (value) => {
 	};
 };
 var optionalString = (value, what) => value === void 0 || value === null ? void 0 : stringArg(value, what);
+/** What a run set for later is checked against where it is queued (`laterFor`); here only that it is what it claims. */
+var laterOf = (value) => {
+	const request = recordArg(value, "A run set for later");
+	const key = optionalString(request.key, "A key");
+	return {
+		action: stringArg(request.action, "An action"),
+		in: numberArg(request.in, "in"),
+		...request.input === void 0 ? {} : { input: recordArg(request.input, "An input") },
+		...key === void 0 ? {} : { key }
+	};
+};
 /** A limit's numbers are checked where it is counted (`countRate`); here only that they are what they claim. */
 var rateLimitOf = (value) => {
 	const limit = recordArg(value, "A rate limit");
@@ -177,6 +188,14 @@ var readCall = (value) => {
 				...grant === void 0 ? {} : { grant }
 			};
 		}
+		case "later": return {
+			op: "later",
+			request: laterOf(call.request)
+		};
+		case "cancelLater": return {
+			op: "cancelLater",
+			key: stringArg(call.key, "A key")
+		};
 		case "rateLimit": return {
 			op: "rateLimit",
 			bucket: stringArg(call.bucket, "A bucket"),
@@ -217,6 +236,8 @@ var answerCall = async (ctx, call) => {
 		case "publish": return ctx.publish(call.topic, call.type, call.data);
 		case "grant": return ctx.grant(call.topic, call.ttlSeconds);
 		case "revoke": return ctx.revoke(call.topic, call.grant);
+		case "later": return ctx.later(call.request);
+		case "cancelLater": return ctx.cancelLater(call.key);
 		case "rateLimit": return ctx.rateLimit(call.bucket, call.limit);
 		case "sign": return ctx.sign(call.value);
 		case "verify": return ctx.verify(call.value, call.signature);

package/dist/modules/functions/context.js

@@ -64,6 +64,7 @@ var lineOf = (values) => values.map((value) => {
 }).join(" ");
 var unavailable = (what) => () => Promise.reject(/* @__PURE__ */ new Error(`This server has no realtime channels (${what})`));
 var unsigned = () => Promise.reject(/* @__PURE__ */ new Error("This server signs nothing: its actions were given no signingSecret"));
+var noJobs = () => Promise.reject(/* @__PURE__ */ new Error("This server runs no jobs: nothing can be set to run later"));
 /**
 * A plugin reads none of its space's data. The space keeps there what its pages must not carry, and a plugin was trusted
 * to draw, not with what the space keeps — the same line as its credentials: handed the data, its `fetch` could send
@@ -97,11 +98,14 @@ var functionContextFor = (ctx, hosts, scope) => {
 		publish: ctx.publish ?? unavailable("publish"),
 		grant: ctx.grant ?? unavailable("grant"),
 		revoke: ctx.revoke ?? unavailable("revoke"),
+		later: ctx.later ?? noJobs,
+		cancelLater: ctx.cancelLater ?? noJobs,
 		data: ctx.data
 	};
 	const kv = prefixKv(ctx.kv, pluginKvPrefix(scope.plugin));
 	const { sign, verify } = ctx;
 	const noChannel = () => Promise.reject(/* @__PURE__ */ new Error("The functions of a plugin reach none of the realtime channels of its space"));
+	const noLater = () => Promise.reject(/* @__PURE__ */ new Error("The functions of a plugin set none of the actions of its space to run"));
 	return {
 		...shared,
 		kv,
@@ -111,6 +115,8 @@ var functionContextFor = (ctx, hosts, scope) => {
 		publish: noChannel,
 		grant: noChannel,
 		revoke: noChannel,
+		later: noLater,
+		cancelLater: noLater,
 		data: noData
 	};
 };

package/dist/modules/functions/contract.d.ts

@@ -1,3 +1,4 @@
+import { LaterAnswer, LaterRequest } from '../actions/jobs/later';
 import { RateCount, RateLimit } from '../actions/runtime/rateLimit';
 import { ActionKvStore } from '../actions/types';
 import { Environment, FunctionTimeLimits, InteractionCallbackParam } from '@plitzi/sdk-shared';
@@ -67,6 +68,15 @@ export type FunctionContext = {
     grant: (topic: string, ttlSeconds?: number) => Promise<string>;
     /** Takes a grant back — or every grant for the topic, naming none. */
     revoke: (topic: string, grant?: string) => Promise<void>;
+    /**
+     * Starts one of the space's actions — one with a `later` trigger — in so many seconds, on the server, whether or not a
+     * page is still open: a turn that runs out, a bot's move, a hold that lapses. A `key` names it: set again under the
+     * same key, the one still waiting is replaced. Answers the job and when it is due (epoch ms, by the queue's clock).
+     * `ctx.later({ action: 'game.timeout', in: 45, input: { room }, key: 'turn:' + room })`.
+     */
+    later: (request: LaterRequest) => Promise<LaterAnswer>;
+    /** Drops what waits under `key` — the timer of a game that ended — and answers how many. */
+    cancelLater: (key: string) => Promise<number>;
     /**
      * One file of the space's data — a project's `src/data/<file>` — parsed, as of the version the run belongs to: what
      * a page must not carry, read here and answered only as far as it is shown. Read-only. `ctx.data('products.json')`.

package/dist/modules/functions/driver.js

@@ -99,6 +99,14 @@ var createFunctionsDriver = (environment) => {
 					grant
 				});
 			},
+			later: (request) => call({
+				op: "later",
+				request
+			}),
+			cancelLater: (key) => call({
+				op: "cancelLater",
+				key
+			}),
 			rateLimit: (bucket, limit) => call({
 				op: "rateLimit",
 				bucket,

package/dist/modules/functions/local.d.ts

@@ -3,7 +3,7 @@ import { FunctionLimits } from './protocol';
 import { ActionRunResult } from '../actions';
 import { FunctionsProblem } from '@plitzi/sdk-shared';
 export type LocalFunctionsOptions = {
-    /** Credentials `ctx.fetch` may name, by id — a project's own, from its environment; none by default. */
+    /** Credentials `ctx.fetch` may name, by id — by default the project's own, from its environment (`PLITZI_CREDENTIALS`). */
     credentials?: Record<string, Record<string, string>>;
     /** As the platform's: a plan's limits, for code that must fit them there. */
     limits?: Partial<FunctionLimits>;

package/dist/modules/functions/local.js

@@ -3,6 +3,7 @@ import { functionsInHand } from "./space.js";
 import { createActionsModule } from "../actions/index.js";
 import { functionTryEntry } from "./tryEntry.js";
 import { createIsolateRunner } from "./sandbox/isolate.js";
+import { credentialsFromEnv } from "../actions/runtime/credentials.js";
 import { randomUUID } from "node:crypto";
 //#region src/modules/functions/local.ts
 /** Who a local run is for: somebody signed in, with nothing to forward. */
@@ -20,7 +21,7 @@ var LOCAL_USER = {
 * isolates and limits, `ctx` over the same actions module — so what works here works there. `kv` lives as long as this
 * does. What `plitzi functions dev` is made of; needs `isolated-vm` and `core-js` installed, as any runner does.
 */
-var createLocalFunctions = ({ credentials = {}, limits, dataDir, fetchImpl } = {}) => {
+var createLocalFunctions = ({ credentials = credentialsFromEnv(), limits, dataDir, fetchImpl } = {}) => {
 	const runner = createIsolateRunner({ concurrency: 1 });
 	let loaded;
 	const module = createActionsModule({

package/dist/modules/functions/manifest.js

@@ -57,6 +57,11 @@ var paramOf = (value) => {
 			type: value.type,
 			...typeof defaultValue === "string" || typeof defaultValue === "number" ? { defaultValue } : {}
 		};
+		case "number": return {
+			...base,
+			type: "number",
+			...typeof defaultValue === "number" ? { defaultValue } : {}
+		};
 		case "codemirror-text":
 		case "codemirror-json": return {
 			...base,
@@ -84,7 +89,7 @@ var paramOf = (value) => {
 				...typeof defaultValue === "string" ? { defaultValue } : {}
 			};
 		}
-		default: return `has a type the builder cannot draw ("${String(value.type)}"): text, textarea, codemirror-text, codemirror-json, boolean, elements or select`;
+		default: return `has a type the builder cannot draw ("${String(value.type)}"): text, number, textarea, codemirror-text, codemirror-json, boolean, elements or select`;
 	}
 };
 /** What each asked limit is, in words a problem is written in. */

package/dist/modules/functions/protocol.d.ts

@@ -1,4 +1,5 @@
 import { FunctionContext, FunctionFetchInit } from './contract';
+import { LaterRequest } from '../actions/jobs/later';
 import { RateLimit } from '../actions/runtime/rateLimit';
 import { FunctionsManifest } from '@plitzi/sdk-shared';
 /**
@@ -93,6 +94,12 @@ export type FunctionCall = {
     op: 'revoke';
     topic: string;
     grant?: string;
+} | {
+    op: 'later';
+    request: LaterRequest;
+} | {
+    op: 'cancelLater';
+    key: string;
 } | {
     op: 'rateLimit';
     bucket: string;

package/dist/modules/mongo/jobQueue.js

@@ -86,6 +86,11 @@ var createMongoJobQueue = ({ db, collections: names = {}, retentionDays = 90 })
 				actionId: 1,
 				updatedAt: -1
 			}),
+			jobsOf().createIndex({
+				spaceId: 1,
+				key: 1,
+				status: 1
+			}, { partialFilterExpression: { key: { $exists: true } } }),
 			jobsOf().createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0 }),
 			schedulesOf().createIndex({
 				enabled: 1,
@@ -328,6 +333,27 @@ var createMongoJobQueue = ({ db, collections: names = {}, retentionDays = 90 })
 				cancelRequested: true,
 				updatedAt: at
 			} })).matchedCount === 1;
+		},
+		cancelPending: async ({ spaceId, key, olderThan }) => {
+			const { jobs } = await collections();
+			const newest = olderThan === void 0 ? void 0 : await jobs.findOne({ _id: olderThan });
+			const at = await clock.now();
+			return (await jobs.updateMany({
+				spaceId,
+				key,
+				status: "pending",
+				...newest ? { $or: [{ createdAt: { $lt: newest.createdAt } }, {
+					createdAt: newest.createdAt,
+					_id: { $lt: newest._id }
+				}] } : {}
+			}, {
+				$set: {
+					status: "cancelled",
+					updatedAt: at,
+					expiresAt: expiryOf(at)
+				},
+				$unset: { workerId: "" }
+			})).modifiedCount;
 		}
 	};
 };

package/dist/modules/mysql/jobs/jobQueue.js

@@ -28,6 +28,7 @@ var toJob = (row) => ({
 	dueAt: Number(row.due_at),
 	maxAttempts: Number(row.max_attempts),
 	...row.missed === null ? {} : { missed: Number(row.missed) },
+	...row.job_key === null ? {} : { key: row.job_key },
 	status: row.status,
 	runAt: Number(row.run_at),
 	attempts: Number(row.attempts),
@@ -128,8 +129,8 @@ var createMysqlJobQueue = ({ pool, tablePrefix = "", createTables = true, retent
 			const at = await clock.now();
 			try {
 				await execute(conn, `INSERT INTO ${t.jobs} (id, space_id, action_id, environment, trigger_type, input, due_at, max_attempts,
-            missed, status, run_at, attempts, created_at, updated_at, history)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?, 0, ?, ?, '[]')`, [
+            missed, job_key, status, run_at, attempts, created_at, updated_at, history)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?, 0, ?, ?, '[]')`, [
 					job.id,
 					job.spaceId,
 					job.actionId,
@@ -139,6 +140,7 @@ var createMysqlJobQueue = ({ pool, tablePrefix = "", createTables = true, retent
 					job.dueAt,
 					job.maxAttempts,
 					job.missed ?? null,
+					job.key ?? null,
 					job.dueAt,
 					at,
 					at
@@ -368,6 +370,23 @@ var createMysqlJobQueue = ({ pool, tablePrefix = "", createTables = true, retent
 				jobId,
 				spaceIds
 			])).affectedRows === 1;
+		},
+		cancelPending: async ({ spaceId, key, olderThan }) => {
+			const conn = await db();
+			const newest = olderThan === void 0 ? void 0 : await selectOne(conn, `SELECT id, created_at FROM ${t.jobs} WHERE id = ?`, [olderThan]);
+			const at = await clock.now();
+			return (await execute(conn, `UPDATE ${t.jobs} SET status = 'cancelled', updated_at = ?, expires_at = ?, worker_id = NULL
+        WHERE space_id = ? AND job_key = ? AND status = 'pending'${newest ? " AND (created_at < ? OR (created_at = ? AND id < ?))" : ""}`, [
+				at,
+				expiryOf(at),
+				spaceId,
+				key,
+				...newest ? [
+					newest.created_at,
+					newest.created_at,
+					newest.id
+				] : []
+			])).affectedRows;
 		}
 	};
 };

package/dist/modules/mysql/jobs/schema.d.ts

@@ -23,8 +23,9 @@ export declare const jobTables: (prefix?: string) => JobTables;
  */
 export declare const mysqlJobSchemaStatements: (prefix?: string) => string[];
 /**
- * What brings a `kv` table made before the columns above up to them — for a deployment that runs its own migrations,
- * once. `ensureJobTables` does it by itself, and only when the table needs it: the `ALTER` copies the table.
+ * What brings tables made before the columns above up to them — for a deployment that runs its own migrations: each
+ * statement once, the ones its tables still lack. `ensureJobTables` does it by itself, and only where a table needs
+ * it: an `ALTER` copies the table.
  */
 export declare const mysqlJobSchemaUpgrades: (prefix?: string) => string[];
 /** The server's now, in epoch ms, as an SQL expression — what every comparison reads instead of a caller's clock. */

package/dist/modules/mysql/jobs/schema.js

@@ -38,6 +38,7 @@ var mysqlJobSchemaStatements = (prefix = "") => {
       due_at BIGINT NOT NULL,
       max_attempts INT NOT NULL,
       missed INT NULL,
+      job_key VARCHAR(191) NULL,
       status VARCHAR(16) NOT NULL,
       run_at BIGINT NOT NULL,
       attempts INT NOT NULL DEFAULT 0,
@@ -54,6 +55,7 @@ var mysqlJobSchemaStatements = (prefix = "") => {
       KEY action_jobs_pending (status, run_at),
       KEY action_jobs_lease (status, lease_until),
       KEY action_jobs_space (space_id, updated_at),
+      KEY action_jobs_key (space_id, job_key, status),
       KEY action_jobs_expires (expires_at)
     ) ${CHARSET}`,
 		`CREATE TABLE IF NOT EXISTS ${t.schedules} (
@@ -80,18 +82,29 @@ var mysqlJobSchemaStatements = (prefix = "") => {
     ) ${CHARSET}`
 	];
 };
-/**
-* What brings a `kv` table made before the columns above up to them — for a deployment that runs its own migrations,
-* once. `ensureJobTables` does it by itself, and only when the table needs it: the `ALTER` copies the table.
-*/
-var mysqlJobSchemaUpgrades = (prefix = "") => [`ALTER TABLE ${jobTables(prefix).kv} MODIFY k VARBINARY(764) NOT NULL, MODIFY v MEDIUMTEXT NOT NULL`];
-/** Whether the `kv` table still has the columns it was first made with. */
-var kvNeedsUpgrade = async (db, prefix) => {
+/** The columns a table of this database has, by name, with their types. */
+var columnsOf = async (db, table) => {
 	const columns = await selectRows(db, `SELECT COLUMN_NAME AS name, DATA_TYPE AS type FROM INFORMATION_SCHEMA.COLUMNS
-    WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ? AND COLUMN_NAME IN ('k', 'v')`, [`${prefix}action_kv`]);
-	const typeOf = (name) => columns.find((column) => column.name === name)?.type.toLowerCase();
-	return typeOf("k") !== "varbinary" || typeOf("v") !== "mediumtext";
+    WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?`, [table]);
+	return new Map(columns.map((column) => [column.name, column.type.toLowerCase()]));
 };
+var UPGRADES = [{
+	needed: async (db, prefix) => {
+		const columns = await columnsOf(db, `${prefix}action_kv`);
+		return columns.get("k") !== "varbinary" || columns.get("v") !== "mediumtext";
+	},
+	statements: (prefix) => [`ALTER TABLE ${jobTables(prefix).kv} MODIFY k VARBINARY(764) NOT NULL, MODIFY v MEDIUMTEXT NOT NULL`]
+}, {
+	needed: async (db, prefix) => !(await columnsOf(db, `${prefix}action_jobs`)).has("job_key"),
+	statements: (prefix) => [`ALTER TABLE ${jobTables(prefix).jobs} ADD COLUMN job_key VARCHAR(191) NULL AFTER missed,
+      ADD KEY action_jobs_key (space_id, job_key, status)`]
+}];
+/**
+* What brings tables made before the columns above up to them — for a deployment that runs its own migrations: each
+* statement once, the ones its tables still lack. `ensureJobTables` does it by itself, and only where a table needs
+* it: an `ALTER` copies the table.
+*/
+var mysqlJobSchemaUpgrades = (prefix = "") => UPGRADES.flatMap((upgrade) => upgrade.statements(prefix));
 /** The server's now, in epoch ms, as an SQL expression — what every comparison reads instead of a caller's clock. */
 var NOW_MS = "CAST(ROUND(UNIX_TIMESTAMP(NOW(3)) * 1000) AS SIGNED)";
 /** Creates the tables once per process, on first use; a failure is retried by the next call rather than remembered. */
@@ -101,7 +114,7 @@ var ensureJobTables = (db, prefix, create) => {
 		if (!create) return;
 		ready ??= (async () => {
 			for (const statement of mysqlJobSchemaStatements(prefix)) await execute(db, statement);
-			if (await kvNeedsUpgrade(db, prefix)) for (const statement of mysqlJobSchemaUpgrades(prefix)) await execute(db, statement);
+			for (const upgrade of UPGRADES) if (await upgrade.needed(db, prefix)) for (const statement of upgrade.statements(prefix)) await execute(db, statement);
 		})().catch((error) => {
 			ready = void 0;
 			throw error;

package/dist/modules/project/serveProject.d.ts

@@ -3,11 +3,14 @@ import { ServerConfig } from '../../core/createServer';
 import { ConnectorManifest } from '../connectors';
 import { ActionEntry, SSRServer } from '@plitzi/sdk-shared';
 /** What `serveProject` sets itself, from the project's layout — so never the project's options'. */
-type SetByProject = 'port' | 'devMode' | 'devReload' | 'health' | 'adapters' | 'plugins' | 'publicDir' | 'dataDir' | 'functions' | 'action';
+type SetByProject = 'port' | 'health' | 'adapters' | 'plugins' | 'publicDir' | 'dataDir' | 'functions' | 'action';
 /**
  * What a project's server does besides serving its space — its `src/config/serverOptions.ts`: what `createServer`
  * takes, but for what `serveProject` wires from the project's layout, and an action's `lookups`, which are the
- * project's `src/actions/`. `logLevel` and `logger` are the project's to change; `action.kv` too.
+ * project's `src/actions/`. `logLevel` and `logger` are the project's to change; `action.kv` too. So are `devMode` and
+ * `devReload`, which follow `NODE_ENV` when left out — on unless it is `production`. A deployment started without it (a
+ * container's `CMD`, a process manager with no environment) says `devMode: false` here, and a public action answers
+ * with its output alone, never the trace of every step.
  */
 export type ProjectServerOptions = Partial<Omit<ServerConfig, SetByProject>> & {
     action?: Omit<NonNullable<ServerConfig['action']>, 'lookups'>;