@plitzi/sdk-server 0.38.10 → 0.38.12

package/dist/modules/actions/runtime/runAction.js

@@ -1,5 +1,6 @@
 import { serverLog } from "../../../helpers/serverLog.js";
-import { ActionRunError, isActionRefusal } from "./errors.js";
+import "../jobs/schedules.js";
+import { ActionRefusal, ActionRunError, isActionRefusal } from "./errors.js";
 import { runCancelKey } from "./guards.js";
 import { createKvStore } from "./kvStore.js";
 import { resolveLimits } from "./limits.js";
@@ -150,10 +151,12 @@ var MAX_LOG_LINES = 100;
 var MAX_LOG_LINE = 1e3;
 /**
 * A value written as text, read as the type its task declares: a `number` param written `5` — or bound to text that says
-* it — arrives as 5, a `boolean` one written `'true'` as `true`, an empty number as nothing (so the default applies). The
-* browser reads a callback's params the same way (`coerceDeclaredParams`): a task's author never writes `Number(…)`.
+* it — arrives as 5, a `boolean` one written `'true'` as `true`, an empty number as nothing (so the default applies), and
+* a `text` one bound to a number as its digits. The browser reads a callback's params the same way
+* (`coerceDeclaredParams`): a task's author never writes `Number(…)` or `String(…)`.
 */
 var asDeclared = (type, value) => {
+	if (typeof value === "number" && (type === "text" || type === "textarea")) return String(value);
 	if (typeof value !== "string") return value;
 	if (type === "number") {
 		const parsed = Number(value.trim());
@@ -161,11 +164,36 @@ var asDeclared = (type, value) => {
 	}
 	return type === "boolean" && (value === "true" || value === "false") ? value === "true" : value;
 };
-var withDefaults = (task, params) => Object.entries(task.params).reduce((acum, [key, param]) => {
-	const value = asDeclared(typeof param.type === "function" ? param.type(acum) : param.type, acum[key]);
-	acum[key] = value === void 0 || value === "" ? param.defaultValue ?? "" : value;
-	return acum;
-}, { ...params });
+/**
+* Why a value does not fit the rules its param declares — `required`, a text's `maxLength`, a number's `min` and `max` —
+* in the words the page shows: what a task's code otherwise checked by hand before doing anything. A param that
+* declares none is never judged.
+*/
+var paramProblem = (key, param, value) => {
+	const name = param.label ?? key;
+	if (value === void 0 || value === null || typeof value === "string" && value.trim() === "") {
+		const defaulted = param.defaultValue !== void 0 && param.defaultValue !== "";
+		return param.required && !defaulted ? `${name} is required` : void 0;
+	}
+	if ((param.type === "text" || param.type === "textarea") && param.maxLength !== void 0) return typeof value === "string" && value.length > param.maxLength ? `${name} is longer than ${String(param.maxLength)} characters` : void 0;
+	if (param.type === "number" && (param.min !== void 0 || param.max !== void 0)) {
+		if (typeof value !== "number") return `${name} is not a number`;
+		if (param.min !== void 0 && value < param.min) return `${name} is at least ${String(param.min)}`;
+		if (param.max !== void 0 && value > param.max) return `${name} is at most ${String(param.max)}`;
+	}
+};
+var withDefaults = (task, params) => {
+	const problems = [];
+	const values = Object.entries(task.params).reduce((acum, [key, param]) => {
+		const value = asDeclared(typeof param.type === "function" ? param.type(acum) : param.type, acum[key]);
+		const problem = paramProblem(key, param, value);
+		if (problem) problems.push(problem);
+		acum[key] = value === void 0 || value === "" ? param.defaultValue ?? "" : value;
+		return acum;
+	}, { ...params });
+	if (problems.length > 0) throw new ActionRefusal(problems.join("; "));
+	return values;
+};
 var runNode = async (node, scope, registry, buildContext) => {
 	if (!node.action || !node.enabled) return {
 		status: "disabled",
@@ -194,13 +222,18 @@ var runNode = async (node, scope, registry, buildContext) => {
 * input contract — lives HERE rather than in a transport, because a deployment mounting its own trigger calls this
 * directly. A check in the endpoint would be a check a custom trigger silently skips.
 */
-var createActionRunner = (config, registryFor, baseFetch = fetch) => {
+var createActionRunner = (config, registryFor, baseFetch = fetch, jobsQueue = () => void 0) => {
 	const kv = createKvStore(config.kv ?? createMemoryKv());
 	const emailSender = createEmailSender({
 		...config.email,
 		kv
 	});
 	const signing = config.signingSecret ? createSigning(config.signingSecret) : void 0;
+	const later = {
+		queue: jobsQueue,
+		lookups: config.lookups,
+		maxAttempts: (config.jobs === false ? void 0 : config.jobs?.maxAttempts) ?? 3
+	};
 	/** Never allowed to fail a run: a logging outage must not take an action down, the same rule metering follows. */
 	const record = async (entry) => {
 		try {
@@ -236,7 +269,8 @@ var createActionRunner = (config, registryFor, baseFetch = fetch) => {
 			kv,
 			email: emailSender,
 			redactor,
-			signing
+			signing,
+			later
 		}, request, signal, runFetch);
 		/** The request budget ran out: said on the server's log at once, and in the step that hit it. */
 		let budgetSpent;
@@ -548,7 +582,8 @@ var createActionRunner = (config, registryFor, baseFetch = fetch) => {
 		kv,
 		email: emailSender,
 		redactor: createRedactor(),
-		signing
+		signing,
+		later
 	}, contextRequest, signal, createRunFetch(baseFetch, signal, resolveLimits(config.limits, void 0), lineage))({});
 	return {
 		runAction,

package/dist/modules/actions/runtime/taskContext.d.ts

@@ -1,6 +1,7 @@
 import { createEmailSender } from './email';
 import { createRedactor } from './scope';
 import { createSigning } from './signing';
+import { LaterDeps } from '../jobs/later';
 import { ActionKvStore, ActionRunRequest, ActionsConfig, ActionTaskContext, ResolvedActionLimits } from '../types';
 /**
  * Counts outbound calls, refuses past the budget, caps what one answer may carry back, and stamps the run's
@@ -28,6 +29,8 @@ export type TaskContextDeps = {
     redactor: ReturnType<typeof createRedactor>;
     /** Absent when the deployment gave no `signingSecret`: its spaces then sign nothing. */
     signing?: ReturnType<typeof createSigning>;
+    /** What runs set for later go through: the module's queue, read when asked. */
+    later: LaterDeps;
 };
 /** Who and what the context is for — a run's request, or anything shaped like one (a function's route). */
 export type TaskContextRequest = Pick<ActionRunRequest, 'runId' | 'spaceId' | 'environment' | 'trigger' | 'user' | 'callerId' | 'at' | 'emit'>;
@@ -36,4 +39,4 @@ export type TaskContextRequest = Pick<ActionRunRequest, 'runId' | 'spaceId' | 'e
  * every secret it resolves registered with the redactor, the space's `kv` namespace, the run's outbound budget, the
  * space's channels. Everything but `log`, which is the STEP's: each step keeps what it logged.
  */
-export declare const taskContextFor: (config: ActionsConfig, { kv, email, redactor, signing }: TaskContextDeps, request: TaskContextRequest, signal: AbortSignal, runFetch: typeof fetch) => ((scope: Record<string, unknown>) => Omit<ActionTaskContext, "log">);
+export declare const taskContextFor: (config: ActionsConfig, { kv, email, redactor, signing, later }: TaskContextDeps, request: TaskContextRequest, signal: AbortSignal, runFetch: typeof fetch) => ((scope: Record<string, unknown>) => Omit<ActionTaskContext, "log">);

package/dist/modules/actions/runtime/taskContext.js

@@ -1,6 +1,7 @@
 import { ActionRunError } from "./errors.js";
 import { namespaceKv } from "./namespaceKv.js";
 import { projectDataReader } from "./projectData.js";
+import { laterFor } from "../jobs/later.js";
 //#region src/modules/actions/runtime/taskContext.ts
 /**
 * Holds an answer to what the run is allowed to carry.
@@ -66,7 +67,7 @@ var createRunFetch = (base, signal, limits, lineage, onBudgetSpent) => {
 * every secret it resolves registered with the redactor, the space's `kv` namespace, the run's outbound budget, the
 * space's channels. Everything but `log`, which is the STEP's: each step keeps what it logged.
 */
-var taskContextFor = (config, { kv, email, redactor, signing }, request, signal, runFetch) => {
+var taskContextFor = (config, { kv, email, redactor, signing, later }, request, signal, runFetch) => {
 	const { realtime } = config;
 	const readData = projectDataReader(config.lookups.getData, request.spaceId, request.at);
 	return (scope) => ({
@@ -111,6 +112,11 @@ var taskContextFor = (config, { kv, email, redactor, signing }, request, signal,
 			spaceId: request.spaceId,
 			environment: request.environment
 		}),
+		...later.queue() ? laterFor(later, {
+			spaceId: request.spaceId,
+			environment: request.environment,
+			...request.at ? { at: request.at } : {}
+		}) : {},
 		...realtime ? {
 			publish: (topic, type, data) => realtime.publish({
 				spaceId: request.spaceId,

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

@@ -1,6 +1,6 @@
 import { prefixKv } from "../actions/runtime/namespaceKv.js";
 import { fetchOutbound } from "../../helpers/outboundGuard.js";
-import { countRate } from "../actions/runtime/rateLimit.js";
+import { countRate, refusedOver } from "../actions/runtime/rateLimit.js";
 import { pluginKvPrefix, pluginSigned } from "./scope.js";
 import { processTwigParam } from "@plitzi/sdk-shared/helpers/twigWrapper";
 //#region src/modules/functions/context.ts
@@ -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
@@ -91,26 +92,31 @@ var functionContextFor = (ctx, hosts, scope) => {
 	if (!scope) return {
 		...shared,
 		kv: ctx.kv,
-		rateLimit: (bucket, limit) => countRate(ctx.kv, ctx.callerId, bucket, limit),
+		rateLimit: async (bucket, limit) => refusedOver(await countRate(ctx.kv, ctx.callerId, bucket, limit), limit),
 		sign: ctx.sign ?? unsigned,
 		verify: ctx.verify ?? unsigned,
 		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,
-		rateLimit: (bucket, limit) => countRate(kv, ctx.callerId, bucket, limit),
+		rateLimit: async (bucket, limit) => refusedOver(await countRate(kv, ctx.callerId, bucket, limit), limit),
 		sign: sign ? (value) => sign(pluginSigned(scope.plugin, value)) : unsigned,
 		verify: verify ? (value, signature) => verify(pluginSigned(scope.plugin, value), signature) : unsigned,
 		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,11 +99,23 @@ var createFunctionsDriver = (environment) => {
 					grant
 				});
 			},
-			rateLimit: (bucket, limit) => call({
-				op: "rateLimit",
-				bucket,
-				limit
+			later: (request) => call({
+				op: "later",
+				request
 			}),
+			cancelLater: (key) => call({
+				op: "cancelLater",
+				key
+			}),
+			rateLimit: async (bucket, limit) => {
+				const count = await call({
+					op: "rateLimit",
+					bucket,
+					limit
+				});
+				if (isRecord(limit) && typeof limit.refuse === "string" && isRecord(count) && count.allowed === false) throw refusal(limit.refuse);
+				return count;
+			},
 			sign: (value) => call({
 				op: "sign",
 				value

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

@@ -47,20 +47,25 @@ var paramOf = (value) => {
 	const base = {
 		...typeof value.canBind === "boolean" ? { canBind: value.canBind } : {},
 		...typeof value.label === "string" ? { label: value.label } : {},
-		...typeof value.when === "boolean" ? { when: value.when } : {}
+		...typeof value.when === "boolean" ? { when: value.when } : {},
+		...typeof value.required === "boolean" ? { required: value.required } : {}
 	};
+	const bound = (key) => typeof value[key] === "number" && Number.isFinite(value[key]) ? { [key]: value[key] } : {};
 	const defaultValue = value.defaultValue;
 	switch (value.type) {
 		case "text":
 		case "textarea": return {
 			...base,
 			type: value.type,
-			...typeof defaultValue === "string" || typeof defaultValue === "number" ? { defaultValue } : {}
+			...typeof defaultValue === "string" || typeof defaultValue === "number" ? { defaultValue } : {},
+			...bound("maxLength")
 		};
 		case "number": return {
 			...base,
 			type: "number",
-			...typeof defaultValue === "number" ? { defaultValue } : {}
+			...typeof defaultValue === "number" ? { defaultValue } : {},
+			...bound("min"),
+			...bound("max")
 		};
 		case "codemirror-text":
 		case "codemirror-json": return {

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;
 		}
 	};
 };