@plitzi/sdk-server 0.38.10 → 0.38.11

package/dist/helpers/cache/keys.js

@@ -63,22 +63,67 @@ var buildHtmlCacheKey = (accessToken = "anonymous", spaceId, environment, revisi
 	};
 	return HTML_KEY_FIELDS.map((field) => fields[field]).join("\0");
 };
+/** One field of a key joined from `fields`, read back by the same list: never by a position written down twice. */
+var fieldOf = (fields, key, field) => key.split("\0")[fields.indexOf(field)] ?? "";
 /**
 * What an HTML key says about the page it holds, read by the one list that also writes it. `server.cache.invalidate`
 * filters on these; it used to split the key by positions of its own, and when the key grew a field in front the
 * filter went on reading the wrong ones — every invalidation by space matched nothing.
 */
-var readHtmlCacheKey = (key) => {
-	const parts = key.split("\0");
-	const at = (field) => parts[HTML_KEY_FIELDS.indexOf(field)] ?? "";
-	return {
-		spaceId: at("spaceId"),
-		environment: at("environment"),
-		hostname: at("hostname")
+var readHtmlCacheKey = (key) => ({
+	spaceId: fieldOf(HTML_KEY_FIELDS, key, "spaceId"),
+	environment: fieldOf(HTML_KEY_FIELDS, key, "environment"),
+	hostname: fieldOf(HTML_KEY_FIELDS, key, "hostname")
+});
+var OFFLINE_DATA_KEY_FIELDS = [
+	"spaceId",
+	"environment",
+	"revision",
+	"flags"
+];
+/** The space as read for a render: its revision, and what its flags are at when they change apart from it. */
+var buildOfflineDataCacheKey = (spaceId, environment, revision, flagsVersion) => {
+	const fields = {
+		spaceId: String(spaceId),
+		environment,
+		revision: String(revision),
+		flags: flagsVersion ?? ""
 	};
+	return OFFLINE_DATA_KEY_FIELDS.map((field) => fields[field]).join("\0");
 };
-/** The space as read for a render: its revision, and what its flags are at when they change apart from it. */
-var buildOfflineDataCacheKey = (spaceId, environment, revision, flagsVersion) => `${spaceId}|${environment}|${revision}|${flagsVersion ?? ""}`;
-var buildRscCacheKey = (spaceId, environment, revision, userId, idsParam, req) => `${spaceId}\0${environment}\0${revision}\0${flagsVersionOf(req)}\0${userId ?? "anon"}\0${idsParam ?? ""}\0${req.hostname}\0${req.path}\0${req.search}`;
+var readOfflineDataCacheKey = (key) => ({
+	spaceId: fieldOf(OFFLINE_DATA_KEY_FIELDS, key, "spaceId"),
+	environment: fieldOf(OFFLINE_DATA_KEY_FIELDS, key, "environment")
+});
+var RSC_KEY_FIELDS = [
+	"spaceId",
+	"environment",
+	"revision",
+	"flags",
+	"user",
+	"ids",
+	"hostname",
+	"path",
+	"search"
+];
+var buildRscCacheKey = (spaceId, environment, revision, userId, idsParam, req) => {
+	const fields = {
+		spaceId: String(spaceId),
+		environment,
+		revision: String(revision),
+		flags: flagsVersionOf(req),
+		user: userId === void 0 ? "anon" : String(userId),
+		ids: idsParam ?? "",
+		hostname: req.hostname,
+		path: req.path,
+		search: req.search
+	};
+	return RSC_KEY_FIELDS.map((field) => fields[field]).join("\0");
+};
+var readRscCacheKey = (key) => ({
+	spaceId: fieldOf(RSC_KEY_FIELDS, key, "spaceId"),
+	environment: fieldOf(RSC_KEY_FIELDS, key, "environment"),
+	hostname: fieldOf(RSC_KEY_FIELDS, key, "hostname")
+});
 //#endregion
-export { buildHtmlCacheKey, buildOfflineDataCacheKey, buildRscCacheKey, readHtmlCacheKey };
+export { buildHtmlCacheKey, buildOfflineDataCacheKey, buildRscCacheKey, readHtmlCacheKey, readOfflineDataCacheKey, readRscCacheKey };

package/dist/modules/actions/index.js

@@ -64,7 +64,8 @@ var createActionsModule = (given) => {
 		return spaceRegistries.registryFor(functions, plugins);
 	};
 	const registryForRun = (request) => Object.values(request.entry.document.nodes).every((node) => node.type !== "task" || !node.action || registry.get(node.action)) ? registry : registryFor(request.spaceId, request.at);
-	const { runAction, taskContext } = createActionRunner(config, registryForRun, config.fetchImpl);
+	let jobsQueue;
+	const { runAction, taskContext } = createActionRunner(config, registryForRun, config.fetchImpl, () => jobsQueue);
 	const routes = createRoutes({
 		config: config.functions ?? {},
 		plugins: () => plugins,
@@ -105,7 +106,10 @@ var createActionsModule = (given) => {
 			next.forEach((value, key) => plugins.set(key, value));
 		}
 	};
-	if (config.jobs !== false && config.lookups.listActions) module.jobs = createActionJobs(config.jobs ?? {}, module, config.lookups);
+	if (config.jobs !== false && config.lookups.listActions) {
+		module.jobs = createActionJobs(config.jobs ?? {}, module, config.lookups);
+		jobsQueue = module.jobs.queue;
+	}
 	return module;
 };
 //#endregion

package/dist/modules/actions/jobs/later.d.ts

@@ -0,0 +1,43 @@
+import { ActionLookups } from '../types';
+import { ActionJobQueue, Environment, SpaceRevision } from '@plitzi/sdk-shared';
+/** A month: past it, a run set for later is a schedule, and a cron says it better. */
+export declare const MAX_LATER_SECONDS: number;
+/** What a run asks to start later: one of the space's actions, in so many seconds, with its input — and a name. */
+export type LaterRequest = {
+    /** The action, by its identifier. It says it may be started this way with a `later` trigger. */
+    action: string;
+    /** Seconds from now, by the queue's clock — whole or not, from 0 to a month. */
+    in: number;
+    input?: Record<string, unknown>;
+    /**
+     * What it is known by in this space: setting another under the same key replaces the one still waiting — a turn's
+     * timer moved on by a move — and `cancelLater(key)` drops it. The one already running is left be.
+     */
+    key?: string;
+};
+/** The job it became, and when it is due — epoch ms, by the queue's clock. */
+export type LaterAnswer = {
+    id: string;
+    at: number;
+};
+export type LaterDeps = {
+    /** Read when asked: the queue is made after the runner, and a server may run none. */
+    queue: () => ActionJobQueue | undefined;
+    lookups: Pick<ActionLookups, 'getAction'>;
+    maxAttempts: number;
+};
+export type LaterScope = {
+    spaceId: number;
+    environment: Environment;
+    at?: SpaceRevision;
+};
+/**
+ * Runs of a space's actions that start in a while — a turn that runs out, a bot's move, a hold that lapses — held by the
+ * same queue as its schedules: they outlive a restart where the queue does, run once across replicas, retry, and show
+ * in the queue an operator reads. Every refusal says why, before anything is queued.
+ */
+export declare const laterFor: ({ queue, lookups, maxAttempts }: LaterDeps, { spaceId, environment, at }: LaterScope) => {
+    later: ({ action, in: seconds, input, key }: LaterRequest) => Promise<LaterAnswer>;
+    /** Drops what is waiting under `key`, and answers how many. */
+    cancelLater: (key: string) => Promise<number>;
+};

package/dist/modules/actions/jobs/later.js

@@ -0,0 +1,66 @@
+import { findTriggerNode } from "../runtime/triggers.js";
+import { randomUUID } from "node:crypto";
+//#region src/modules/actions/jobs/later.ts
+/** A month: past it, a run set for later is a schedule, and a cron says it better. */
+var MAX_LATER_SECONDS = 2592e3;
+/** A name a run set for later is known by, as a topic is written: what it is replaced and cancelled by. */
+var KEY = /^[A-Za-z0-9:_.-]{1,128}$/;
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+* Runs of a space's actions that start in a while — a turn that runs out, a bot's move, a hold that lapses — held by the
+* same queue as its schedules: they outlive a restart where the queue does, run once across replicas, retry, and show
+* in the queue an operator reads. Every refusal says why, before anything is queued.
+*/
+var laterFor = ({ queue, lookups, maxAttempts }, { spaceId, environment, at }) => {
+	const queueOrThrow = () => {
+		const found = queue();
+		if (!found) throw new Error("This server runs no jobs — its actions have no queue (`jobs: false`, or no way to list actions)");
+		return found;
+	};
+	const keyOrThrow = (key) => {
+		if (typeof key !== "string" || !KEY.test(key)) throw new Error("A key is 1 to 128 letters, digits and `:_.-` — `turn:ABCD`");
+		return key;
+	};
+	return {
+		later: async ({ action, in: seconds, input = {}, key }) => {
+			const jobs = queueOrThrow();
+			if (typeof seconds !== "number" || !Number.isFinite(seconds) || seconds < 0 || seconds > 2592e3) throw new Error(`"in" is a number of seconds from 0 to ${String(MAX_LATER_SECONDS)}: ${JSON.stringify(seconds)}`);
+			if (!isRecord(input)) throw new Error("A run set for later is handed an object as its input");
+			const named = key === void 0 ? void 0 : keyOrThrow(key);
+			const entry = typeof action === "string" && action !== "" ? await lookups.getAction(spaceId, action, at) : void 0;
+			if (!entry) throw new Error(`Action "${action}" is not one of this space's`);
+			const trigger = findTriggerNode(entry.document.nodes, "later");
+			if (!trigger) throw new Error(`Action "${action}" cannot be set to run later: give it a "later" trigger, which says it may be started this way`);
+			if (!trigger.enabled) throw new Error(`Action "${action}" has its "later" trigger switched off: nothing set for later would run`);
+			const dueAt = (await jobs.now()).getTime() + Math.round(seconds * 1e3);
+			const id = `later:${String(spaceId)}:${randomUUID()}`;
+			await jobs.enqueue({
+				id,
+				spaceId,
+				actionId: entry.id,
+				environment,
+				trigger: "later",
+				input,
+				dueAt,
+				maxAttempts,
+				...named === void 0 ? {} : { key: named }
+			});
+			if (named !== void 0) await jobs.cancelPending({
+				spaceId,
+				key: named,
+				olderThan: id
+			});
+			return {
+				id,
+				at: dueAt
+			};
+		},
+		/** Drops what is waiting under `key`, and answers how many. */
+		cancelLater: (key) => queueOrThrow().cancelPending({
+			spaceId,
+			key: keyOrThrow(key)
+		})
+	};
+};
+//#endregion
+export { MAX_LATER_SECONDS, laterFor };

package/dist/modules/actions/jobs/later.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/actions/jobs/memoryQueue.js

@@ -19,7 +19,8 @@ var JOB_QUEUE_METHODS = {
 	getJob: true,
 	listSchedules: true,
 	requeue: true,
-	cancel: true
+	cancel: true,
+	cancelPending: true
 };
 /**
 * The default queue: one process's Maps.
@@ -187,6 +188,18 @@ var createMemoryJobQueue = ({ retainFinished = 500, clock = Date.now } = {}) =>
 			} else job.cancelRequested = true;
 			job.updatedAt = now();
 			return Promise.resolve(true);
+		},
+		cancelPending: ({ spaceId, key, olderThan }) => {
+			const newest = olderThan === void 0 ? void 0 : jobs.get(olderThan);
+			const isOlder = (job) => newest === void 0 || job.createdAt < newest.createdAt || job.createdAt === newest.createdAt && job.id < newest.id;
+			const at = now();
+			let dropped = 0;
+			for (const job of jobs.values()) if (job.spaceId === spaceId && job.key === key && job.status === "pending" && job.id !== olderThan && isOlder(job)) {
+				job.status = "cancelled";
+				job.updatedAt = at;
+				dropped += 1;
+			}
+			return Promise.resolve(dropped);
 		}
 	};
 };

package/dist/modules/actions/jobs/worker.js

@@ -104,7 +104,7 @@ var createJobWorker = ({ queue, lookups, module, workers = 4, pollMs = 1e3, leas
 			run = await module.guards.begin({
 				spaceId: job.spaceId,
 				actionId: job.actionId,
-				callerId: "schedule",
+				callerId: job.trigger,
 				input: job.input,
 				idempotencyKey: job.id,
 				sharedKey: true,
@@ -139,7 +139,7 @@ var createJobWorker = ({ queue, lookups, module, workers = 4, pollMs = 1e3, leas
 				spaceId: job.spaceId,
 				environment: job.environment,
 				trigger: job.trigger,
-				callerId: "schedule",
+				callerId: job.trigger,
 				runId: run.runId,
 				signal: run.controller.signal
 			});

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

@@ -0,0 +1,10 @@
+import { ActionCredential } from '../types';
+/** Where a project's server — and `plitzi functions dev` — reads the credentials its space's code names. */
+export declare const CREDENTIALS_ENV = "PLITZI_CREDENTIALS";
+/**
+ * The credentials a deployment with no credential store keeps in its environment: one JSON object, credential id → its
+ * keys, each a string — what `ctx.fetch({ credential })`, a connector and an `http.request` step name. Read whole or
+ * refused with why: a value that does not read would otherwise leave every credential missing, and the integration
+ * failing far from the cause.
+ */
+export declare const credentialsFromEnv: (env?: NodeJS.ProcessEnv) => Record<string, ActionCredential>;

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

@@ -0,0 +1,28 @@
+//#region src/modules/actions/runtime/credentials.ts
+/** Where a project's server — and `plitzi functions dev` — reads the credentials its space's code names. */
+var CREDENTIALS_ENV = "PLITZI_CREDENTIALS";
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var EXAMPLE = "{\"google\":{\"clientId\":\"…\",\"clientSecret\":\"…\"}}";
+/**
+* The credentials a deployment with no credential store keeps in its environment: one JSON object, credential id → its
+* keys, each a string — what `ctx.fetch({ credential })`, a connector and an `http.request` step name. Read whole or
+* refused with why: a value that does not read would otherwise leave every credential missing, and the integration
+* failing far from the cause.
+*/
+var credentialsFromEnv = (env = process.env) => {
+	const raw = env[CREDENTIALS_ENV];
+	if (raw === void 0 || raw.trim() === "") return {};
+	let value;
+	try {
+		value = JSON.parse(raw);
+	} catch (error) {
+		throw new Error(`${CREDENTIALS_ENV} is not JSON: write one object, credential id → its keys — ${EXAMPLE}`, { cause: error });
+	}
+	if (!isRecord(value)) throw new Error(`${CREDENTIALS_ENV} is one object, credential id → its keys — ${EXAMPLE}`);
+	return Object.fromEntries(Object.entries(value).map(([id, keys]) => {
+		if (!isRecord(keys) || !Object.values(keys).every((key) => typeof key === "string")) throw new Error(`${CREDENTIALS_ENV}: "${id}" is an object of strings, its keys by name — ${EXAMPLE}`);
+		return [id, Object.fromEntries(Object.entries(keys).map(([name, key]) => [name, String(key)]))];
+	}));
+};
+//#endregion
+export { CREDENTIALS_ENV, credentialsFromEnv };

package/dist/modules/actions/runtime/credentials.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -2,10 +2,14 @@ import { ActionKvAdapter } from '../types';
 export type FileKvOptions = {
     /** The JSON file the store lives in — created, with its folder, on the first write. */
     file: string;
+    /** Who holds it, said to a second process that tries: `this project's server, on port 8080`. */
+    owner?: string;
 };
 export type FileKv = ActionKvAdapter & {
     /** Resolves once everything written so far is on disk: for a shutdown, or a test that reads the file. */
     flush: () => Promise<void>;
+    /** Writes what is pending and lets go of the file, for the next process to take. */
+    close: () => Promise<void>;
 };
 /**
  * A key/value store in one JSON file: the `kv` server actions keep — saved layouts, counters, a source's cached answer —
@@ -21,8 +25,9 @@ export type FileKv = ActionKvAdapter & {
  * that arrive while a write is under way are written together right after it, so a crash loses at most the writes
  * of that instant and never leaves half a file. Entries past their lifetime are not written.
  *
- * ONE process: it reads the file when it starts and owns it after. Two processes on one file overwrite each other —
- * replicas, or a server started with `workers`, use `createSqliteKv` (`@plitzi/sdk-server/sqlite`) or a database.
+ * ONE process: it reads the file when it starts and holds it after (`<file>.lock`, with its pid) — a second process is
+ * refused, naming the first, because two would write over each other's changes. The workers of one server reach the
+ * primary's through the fleet (`fleetKv`); replicas use `createSqliteKv` (`@plitzi/sdk-server/sqlite`) or a database.
  * And a whole file per change: right for what a site keeps, not for a counter bumped thousands of times a second.
  */
-export declare const createFileKv: ({ file }: FileKvOptions) => FileKv;
+export declare const createFileKv: ({ file, owner }: FileKvOptions) => FileKv;

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

@@ -4,6 +4,62 @@ import { writeFileAtomic } from "../../../helpers/atomicFile.js";
 import path from "node:path";
 import fs from "node:fs";
 //#region src/modules/actions/runtime/fileKv.ts
+var holderIn = (lock) => {
+	try {
+		const parsed = JSON.parse(fs.readFileSync(lock, "utf8"));
+		return typeof parsed === "object" && parsed !== null && "pid" in parsed && typeof parsed.pid === "number" ? {
+			pid: parsed.pid,
+			since: "since" in parsed && typeof parsed.since === "string" ? parsed.since : "?",
+			..."owner" in parsed && typeof parsed.owner === "string" ? { owner: parsed.owner } : {}
+		} : void 0;
+	} catch {
+		return;
+	}
+};
+/** Whether a process is still running: signal 0 asks without sending anything, and `EPERM` is one that is not ours. */
+var running = (pid) => {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code === "EPERM";
+	}
+};
+/** The files this process holds, let go of together when it exits — however it does. */
+var held = /* @__PURE__ */ new Set();
+var letGo = (lock) => {
+	held.delete(lock);
+	if (holderIn(lock)?.pid === process.pid) fs.rmSync(lock, { force: true });
+};
+process.once("exit", () => held.forEach(letGo));
+/**
+* Takes the file for this process, or says who has it.
+*
+* Two processes on one file each load it and then write their whole map over it: every change one makes, the other
+* erases with its next write, and nothing anywhere says so — a second server started beside the first, a `--watch`
+* left running after a restart. So a file has one holder: a second is refused, naming the first. A lock whose process is
+* gone — killed, crashed — is taken over.
+*/
+var take = (file, owner) => {
+	const lock = `${file}.lock`;
+	fs.mkdirSync(path.dirname(file), { recursive: true });
+	const mine = {
+		pid: process.pid,
+		since: (/* @__PURE__ */ new Date()).toISOString(),
+		...owner ? { owner } : {}
+	};
+	for (let attempt = 0; attempt < 2; attempt += 1) try {
+		fs.writeFileSync(lock, JSON.stringify(mine), { flag: "wx" });
+		held.add(lock);
+		return lock;
+	} catch (error) {
+		if (error.code !== "EEXIST") throw error;
+		const holder = holderIn(lock);
+		if (holder && running(holder.pid)) throw new Error(`createFileKv: ${file} is in use by process ${String(holder.pid)}${holder.owner ? ` — ${holder.owner}` : ""}, since ${holder.since}. Two processes on one file write over each other's changes: stop that one first, or point \`file\` elsewhere.`, { cause: error });
+		fs.rmSync(lock, { force: true });
+	}
+	throw new Error(`createFileKv: ${lock} could not be taken`);
+};
 var isEntry = (value) => typeof value === "object" && value !== null && "value" in value && typeof value.value === "string" && (!("expiresAt" in value) || typeof value.expiresAt === "number");
 var load = (file) => {
 	if (!fs.existsSync(file)) return /* @__PURE__ */ new Map();
@@ -35,12 +91,20 @@ var load = (file) => {
 * that arrive while a write is under way are written together right after it, so a crash loses at most the writes
 * of that instant and never leaves half a file. Entries past their lifetime are not written.
 *
-* ONE process: it reads the file when it starts and owns it after. Two processes on one file overwrite each other —
-* replicas, or a server started with `workers`, use `createSqliteKv` (`@plitzi/sdk-server/sqlite`) or a database.
+* ONE process: it reads the file when it starts and holds it after (`<file>.lock`, with its pid) — a second process is
+* refused, naming the first, because two would write over each other's changes. The workers of one server reach the
+* primary's through the fleet (`fleetKv`); replicas use `createSqliteKv` (`@plitzi/sdk-server/sqlite`) or a database.
 * And a whole file per change: right for what a site keeps, not for a counter bumped thousands of times a second.
 */
-var createFileKv = ({ file }) => {
-	const entries = load(file);
+var createFileKv = ({ file, owner }) => {
+	const lock = take(file, owner);
+	let entries;
+	try {
+		entries = load(file);
+	} catch (error) {
+		letGo(lock);
+		throw error;
+	}
 	let dirty = false;
 	let failed = false;
 	/** The write under way, resolving to whether everything it took on reached the disk. */
@@ -83,11 +147,19 @@ var createFileKv = ({ file }) => {
 		failed = false;
 		write();
 	};
+	const flush = async () => {
+		failed = false;
+		while (writing !== void 0 || dirty) if (!await (writing ?? write())) throw new Error(`createFileKv: ${file} could not be written; the reason is in the log.`);
+	};
 	return {
 		...createMapKv(entries, changed),
-		flush: async () => {
-			failed = false;
-			while (writing !== void 0 || dirty) if (!await (writing ?? write())) throw new Error(`createFileKv: ${file} could not be written; the reason is in the log.`);
+		flush,
+		close: async () => {
+			try {
+				await flush();
+			} finally {
+				letGo(lock);
+			}
 		}
 	};
 };

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

@@ -4,7 +4,7 @@ import { applyFields } from "./scope.js";
 import { accessRefusal, triggerAccess, triggerInput } from "@plitzi/sdk-shared/actions";
 //#region src/modules/actions/runtime/precheck.ts
 var authorize = (access, kind, user) => {
-	if (kind === "schedule") return;
+	if (kind === "schedule" || kind === "later") return;
 	const refusal = accessRefusal(access, user);
 	if (refusal === "unauthenticated") throw new ActionRunError("unauthenticated", "This action requires a signed-in visitor");
 	if (refusal) throw new ActionRunError("forbidden", access ? "This action requires permissions the caller does not hold" : "This trigger declares no access rule");

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

@@ -1,5 +1,6 @@
 import { TaskContextRequest } from './taskContext';
 import { ActionRunRequest, ActionRunResult, ActionsConfig, ActionTaskContext, ActionTaskRegistry } from '../types';
+import { ActionJobQueue } from '@plitzi/sdk-shared';
 export type ActionRunner = {
     runAction: (request: ActionRunRequest) => Promise<ActionRunResult>;
 };
@@ -15,6 +16,8 @@ export type TaskContextSource = (request: TaskContextRequest, signal: AbortSigna
  * 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.
  */
-export declare const createActionRunner: (config: ActionsConfig, registryFor: (request: ActionRunRequest) => ActionTaskRegistry | Promise<ActionTaskRegistry>, baseFetch?: typeof fetch) => ActionRunner & {
+export declare const createActionRunner: (config: ActionsConfig, registryFor: (request: ActionRunRequest) => ActionTaskRegistry | Promise<ActionTaskRegistry>, baseFetch?: typeof fetch, 
+/** The queue runs set for later go into, read when asked: it is made after the runner, and a server may run none. */
+jobsQueue?: () => ActionJobQueue | undefined) => ActionRunner & {
     taskContext: TaskContextSource;
 };

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

@@ -1,4 +1,5 @@
 import { serverLog } from "../../../helpers/serverLog.js";
+import "../jobs/schedules.js";
 import { ActionRunError, isActionRefusal } from "./errors.js";
 import { runCancelKey } from "./guards.js";
 import { createKvStore } from "./kvStore.js";
@@ -194,13 +195,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 +242,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 +555,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,