@plitzi/sdk-server 0.37.2 → 0.37.4

package/dist/modules/ssr/template.js

@@ -1,6 +1,6 @@
+import path from "node:path";
 import { fileURLToPath } from "node:url";
 import fs from "node:fs";
-import path from "node:path";
 import ejs from "ejs";
 //#region src/modules/ssr/template.ts
 var __dirname = path.dirname(fileURLToPath(import.meta.url));

package/dist/modules/ssr/views/template.ejs

@@ -122,18 +122,21 @@
     <noscript>You need to enable JavaScript to run this app.</noscript>
     <div id="plitzi" class="plitzi-root-container"><%- locals.html || '' %></div>
     <% if (!locals.ssrOnly) { %>
+    <%# The payload is data, so it travels as JSON: parsing it as a JavaScript literal cost the browser several times
+        what JSON.parse does, on megabytes of it. Escaped by the server — no `<` reaches this block. %>
+    <script type="application/json" id="plitzi-ssr-data"><%- locals.offlineData || '{}' %></script>
     <script type="module">
       import { render } from '<%= locals.jsPath || '' %>';
       <% const activePlugins = (locals.plugins || []).filter(p => p.js); %>
-      <% if (activePlugins.length > 0) { %>
       <% for (const plugin of activePlugins) { %>
       import { default as <%= plugin.varName %> } from '<%= plugin.js %>';
       <% } %>
       const __plitziPlugins = { <%- activePlugins.map(p => `'${p.keyName}': {component: ${p.varName}, props: ${JSON.stringify(p.props)}, clientOnly: ${p.ssr === false}}`).join(', ') %> };
-      render('plitzi', <%- locals.offlineData || '{}' %>, __plitziPlugins, <%= locals.debugMode ? true : false %>, true);
-      <% } else { %>
-      render('plitzi', <%- locals.offlineData || '{}' %>, {}, <%= locals.debugMode ? true : false %>, true);
-      <% } %>
+      const __plitziData = document.getElementById('plitzi-ssr-data');
+      const __plitziParams = JSON.parse(__plitziData.textContent);
+      // Read once: the page would otherwise hold the space twice, as this text and as what it was parsed into.
+      __plitziData.remove();
+      render('plitzi', __plitziParams, __plitziPlugins, <%= locals.debugMode ? true : false %>, true);
     </script>
     <% } %>
   </body>

package/dist/mysql.d.ts

@@ -31,7 +31,7 @@ export { createMysqlStore, mysqlSchemaStatements } from './modules/mysql';
  *  createServer({ action: { lookups, kv: createMysqlKv({ pool }), jobs: { queue: createMysqlJobQueue({ pool }) } } });
  *  ```
  */
-export { createMysqlJobQueue, createMysqlKv, mysqlJobSchemaStatements } from './modules/mysql/jobs';
+export { createMysqlJobQueue, createMysqlKv, mysqlJobSchemaStatements, mysqlJobSchemaUpgrades } from './modules/mysql/jobs';
 export type { MysqlJobQueue, MysqlJobQueueOptions, MysqlKvOptions } from './modules/mysql/jobs';
 export { SCHEMA_VERSION, TABLE_NAMES, tableNames } from './modules/mysql';
 export type { AccountSeed, MysqlAdmin, MysqlConfig, IdentityStore, LinkedIdentity, MysqlStore, SessionStore, SessionSummary, SpaceTokenSeed, TableKey, Tables } from './modules/mysql';

package/dist/mysql.js

@@ -1,7 +1,7 @@
 import { TABLE_NAMES, tableNames } from "./modules/mysql/config.js";
 import { SCHEMA_VERSION } from "./modules/mysql/schema.js";
 import { createMysqlStore, mysqlSchemaStatements } from "./modules/mysql/index.js";
-import { mysqlJobSchemaStatements } from "./modules/mysql/jobs/schema.js";
+import { mysqlJobSchemaStatements, mysqlJobSchemaUpgrades } from "./modules/mysql/jobs/schema.js";
 import { createMysqlJobQueue } from "./modules/mysql/jobs/jobQueue.js";
 import { createMysqlKv } from "./modules/mysql/jobs/kv.js";
-export { SCHEMA_VERSION, TABLE_NAMES, createMysqlJobQueue, createMysqlKv, createMysqlStore, mysqlJobSchemaStatements, mysqlSchemaStatements, tableNames };
+export { SCHEMA_VERSION, TABLE_NAMES, createMysqlJobQueue, createMysqlKv, createMysqlStore, mysqlJobSchemaStatements, mysqlJobSchemaUpgrades, mysqlSchemaStatements, tableNames };

package/dist/oauth.js

@@ -1,10 +1,10 @@
+import { dropPending, getAccess, getClient, getPending, putCode, putPending } from "./core/oauth/records.js";
 import { AUTHORIZATION_SERVER_PATH, AUTHORIZE_PATH, PROTECTED_RESOURCE_PATH, REGISTER_PATH, TOKEN_PATH, authorizationServerMetadata, protectedResourceMetadata } from "./core/oauth/metadata.js";
 import { randomId, verifyChallenge } from "./core/oauth/pkce.js";
-import { dropPending, getAccess, getClient, getPending, putCode, putPending } from "./core/oauth/records.js";
 import { redirectToSignIn, redirectWithCode, redirectWithError, sendErrorJson, sendJson } from "./core/oauth/respond.js";
+import { handleRegister } from "./core/oauth/register.js";
 import { handleAuthorizeStart, handleAuthorizeSubmit } from "./core/oauth/authorize.js";
 import { bearerOf, sendChallenge } from "./core/oauth/challenge.js";
-import { handleRegister } from "./core/oauth/register.js";
 import { handleRevoke, handleToken } from "./core/oauth/token.js";
 import { createOAuthGuardStage, createOAuthStage } from "./core/http/stages/oauth.js";
 export { AUTHORIZATION_SERVER_PATH, AUTHORIZE_PATH, PROTECTED_RESOURCE_PATH, REGISTER_PATH, TOKEN_PATH, authorizationServerMetadata, bearerOf, createOAuthGuardStage, createOAuthStage, dropPending, getAccess, getClient, getPending, handleAuthorizeStart, handleAuthorizeSubmit, handleRegister, handleRevoke, handleToken, protectedResourceMetadata, putCode, putPending, randomId, redirectToSignIn, redirectWithCode, redirectWithError, sendChallenge, sendErrorJson, sendJson, verifyChallenge };

package/dist/plugins/compile.js

@@ -1,6 +1,7 @@
+import { writeFileAtomic } from "../helpers/atomicFile.js";
 import path from "node:path";
-import fs from "node:fs/promises";
 import esbuild from "esbuild";
+import fs from "node:fs/promises";
 //#region src/plugins/compile.ts
 var EXTERNAL = [
 	"react",
@@ -29,7 +30,8 @@ var ASSET_LOADERS = {
 	".woff2": "dataurl"
 };
 /**
-* Everything that went into the bundle, so a dev server can tell when any of it has moved on.
+* Everything that went into the bundle, so a server can tell when any of it has moved on: a dev server as it is
+* edited, and any server — a deployment — when it finds a bundle built from something else (its content digest).
 *
 * The entry file is one file and a plugin is a directory: a component edited beside its `index.ts` leaves the entry's
 * timestamp exactly where it was, and a watcher looking only at that never rebuilds. esbuild already knows the answer
@@ -52,10 +54,13 @@ var compilePlugin = async (jsPath, outDir, devMode = false) => {
 		minify: !devMode,
 		splitting: false,
 		logLevel: "warning",
-		metafile: devMode
+		metafile: true,
+		write: false
 	});
+	await fs.mkdir(outDir, { recursive: true });
+	await Promise.all(result.outputFiles.map((output) => writeFileAtomic(output.path, output.contents)));
 	return {
-		hasCSS: await fs.access(path.join(outDir, "index.css")).then(() => true).catch(() => false),
+		hasCSS: result.outputFiles.some((output) => path.basename(output.path) === "index.css"),
 		inputs: sourceInputs(result.metafile)
 	};
 };

package/dist/plugins/copy.js

@@ -1,13 +1,13 @@
+import { copyFileAtomic, writeFileAtomic } from "../helpers/atomicFile.js";
 import path from "node:path";
-import fs from "node:fs/promises";
 //#region src/plugins/copy.ts
 var copyPlugin = async (src, destDir, filename) => {
 	const dest = path.join(destDir, filename);
 	if (src.startsWith("http://") || src.startsWith("https://")) {
 		const res = await fetch(src);
 		if (!res.ok) throw new Error(`[SSR] Plugin fetch failed ${src}: ${res.status}`);
-		await fs.writeFile(dest, await res.text(), "utf-8");
-	} else await fs.copyFile(src, dest);
+		await writeFileAtomic(dest, await res.text());
+	} else await copyFileAtomic(src, dest);
 };
 //#endregion
 export { copyPlugin };

package/dist/plugins/manager.d.ts

@@ -14,9 +14,18 @@ export declare class PluginManager {
     hasPlugin(name: string): boolean;
     register(name: string, source: PluginSource): void;
     /**
-     * Registers a plugin only if it is not yet known under its effective key.
-     * Returns the effective key (`name@version` when version is set, `name` otherwise)
-     * so the caller can pass it directly to getEntries().
+     * Keeps a source a render names, and returns the key to pass to getEntries(): `name@version+<identity>`, or
+     * `name@<identity>` without a version.
+     *
+     * The identity is what the source IS — where its files are, how they are served, the props it carries — because a
+     * name and a version are only what its author said about it. Keyed on those alone, the first source to arrive held
+     * the key for as long as the process ran: a plugin published again under the same version kept its old, now missing
+     * URLs, and two spaces each with a `board@1.0.0` of their own were served whichever this process had met first.
+     * Worked out from the source rather than handed out in order of arrival, so every worker names one source the same
+     * way — the key is also the folder a built bundle is written to, and all of them share it.
+     *
+     * Never taken as what a bare name means: {@link resolveKey} answers for the plugins this server was set up with, not
+     * for whichever space rendered last.
      */
     ensure(name: string, source: PluginSource): string;
     /**
@@ -46,6 +55,18 @@ export declare class PluginManager {
      * `checkedAt` is stamped on the cached entry rather than kept in a second map, so it cannot outlive what it is about.
      */
     private isStaleInMemory;
+    /**
+     * Whether what a bundle on disk was built from reads differently now — asked once, when a process first finds the
+     * bundle, in production as much as in development.
+     *
+     * A version names a release, and a release is only as good as whoever bumps it: a deployment rebuilt from new source
+     * under the same version found last deployment's bundle in its cache folder and served it, with nothing anywhere
+     * saying so. The content decides instead. A bundle written before digests were recorded has none, and is built again
+     * once. What this server does not build from files — a download, a CDN, a component — is its version's business.
+     */
+    private contentChanged;
+    /** The local files a bundle is built from: what the compiler reported, or the files it was copied from. */
+    private inputsOf;
     private isStale;
     /**
      * The bundle's URL, stamped with when it was built.
@@ -68,10 +89,21 @@ export declare class PluginManager {
      */
     private toRemoteEntry;
     private isWebUrl;
+    /**
+     * Builds every registered plugin now rather than on first use. A primary does it before starting its workers, so
+     * the workers find each one built — instead of all of them compiling the same plugin into the same folder at once.
+     */
+    prepareAll(): Promise<void>;
     prepare(name: string): Promise<PluginEntry | null>;
     private build;
     getEntries(names: string[]): Promise<PluginEntry[]>;
     getComponents(): Record<string, unknown>;
+    /**
+     * Drops what this process remembers of a plugin — its entry, its failure, which version its name means — and
+     * leaves the disk alone. What an invalidation elsewhere in the fleet does here: that process removes the files,
+     * and each of the others only has to stop pointing at them.
+     */
+    forget(name?: string, version?: string): void;
     invalidate(name?: string, version?: string): Promise<void>;
     destroy(): void;
     private readMeta;

package/dist/plugins/manager.js

@@ -1,13 +1,34 @@
+import { serverLog } from "../helpers/serverLog.js";
+import { writeFileAtomic } from "../helpers/atomicFile.js";
 import { compilePlugin } from "./compile.js";
 import { copyPlugin } from "./copy.js";
 import { detectAction, isComponentSource } from "./detect.js";
 import { assertPluginSources } from "./validate.js";
+import { createHash } from "node:crypto";
 import path from "node:path";
 import fs from "node:fs/promises";
 //#region src/plugins/manager.ts
 var META_FILE = "meta.json";
 var DEFAULT_TTL_MS = 6048e5;
 var DEFAULT_CACHE_DIR = ".sdk-plugins";
+/** One hash over every input's path and content — a file gone counts as changed, like a file edited. */
+var digestOf = async (files) => {
+	const hash = createHash("sha256");
+	for (const file of [...files].sort()) {
+		hash.update(file);
+		hash.update("\0");
+		hash.update(await fs.readFile(file).catch(() => Buffer.from("\0missing")));
+	}
+	return hash.digest("hex");
+};
+/**
+* Whether a key is this plugin — every version of it, or with `version` that one release — counting the sources a
+* render named under it (`name@1.0.0+<identity>`, see {@link PluginManager.ensure}).
+*/
+var isKeyOf = (key, name, version) => {
+	if (version) return key === `${name}@${version}` || key.startsWith(`${name}@${version}+`);
+	return key === name || key.startsWith(`${name}@`);
+};
 /**
 * How often a dev server re-asks whether a cached plugin is still current.
 *
@@ -48,13 +69,28 @@ var PluginManager = class {
 		this.nameIndex.set(baseName, name);
 	}
 	/**
-	* Registers a plugin only if it is not yet known under its effective key.
-	* Returns the effective key (`name@version` when version is set, `name` otherwise)
-	* so the caller can pass it directly to getEntries().
+	* Keeps a source a render names, and returns the key to pass to getEntries(): `name@version+<identity>`, or
+	* `name@<identity>` without a version.
+	*
+	* The identity is what the source IS — where its files are, how they are served, the props it carries — because a
+	* name and a version are only what its author said about it. Keyed on those alone, the first source to arrive held
+	* the key for as long as the process ran: a plugin published again under the same version kept its old, now missing
+	* URLs, and two spaces each with a `board@1.0.0` of their own were served whichever this process had met first.
+	* Worked out from the source rather than handed out in order of arrival, so every worker names one source the same
+	* way — the key is also the folder a built bundle is written to, and all of them share it.
+	*
+	* Never taken as what a bare name means: {@link resolveKey} answers for the plugins this server was set up with, not
+	* for whichever space rendered last.
 	*/
 	ensure(name, source) {
-		const key = source.version ? `${name}@${source.version}` : name;
-		if (!(key in this.plugins)) this.register(key, source);
+		const identity = createHash("sha256").update(JSON.stringify([
+			source.js,
+			source.css,
+			isComponentSource(source) ? void 0 : source.action,
+			source.props
+		])).digest("hex").slice(0, 12);
+		const key = `${name}@${source.version ? `${source.version}+` : ""}${identity}`;
+		if (!(key in this.plugins)) this.plugins[key] = source;
 		return key;
 	}
 	/**
@@ -102,10 +138,34 @@ var PluginManager = class {
 			inputs: cached.inputs
 		}, source);
 	}
+	/**
+	* Whether what a bundle on disk was built from reads differently now — asked once, when a process first finds the
+	* bundle, in production as much as in development.
+	*
+	* A version names a release, and a release is only as good as whoever bumps it: a deployment rebuilt from new source
+	* under the same version found last deployment's bundle in its cache folder and served it, with nothing anywhere
+	* saying so. The content decides instead. A bundle written before digests were recorded has none, and is built again
+	* once. What this server does not build from files — a download, a CDN, a component — is its version's business.
+	*/
+	async contentChanged(meta, source) {
+		const inputs = this.inputsOf(source, meta.inputs ?? []);
+		if (inputs.length === 0) return false;
+		return meta.digest !== await digestOf(inputs);
+	}
+	/** The local files a bundle is built from: what the compiler reported, or the files it was copied from. */
+	inputsOf(source, compiled) {
+		if (isComponentSource(source) || source.action === "download" || source.action === "cdn") return [];
+		if (compiled.length > 0) return compiled;
+		return [source.js, source.css].filter((file) => typeof file === "string" && file !== "" && !/^https?:\/\//.test(file));
+	}
 	async isStale(meta, source) {
 		if (!this.devMode || !source.js || /^https?:\/\//.test(source.js) || isComponentSource(source)) return false;
 		const watched = meta.inputs?.length ? meta.inputs : [source.js];
-		return (await Promise.all(watched.map((file) => fs.stat(file).then((stats) => stats.mtimeMs).catch(() => 0)))).some((modifiedAt) => modifiedAt > meta.compiledAt);
+		if (meta.inputs?.length) {
+			const entry = await fs.realpath(source.js).catch(() => path.resolve(source.js));
+			if (!meta.inputs.includes(entry)) return true;
+		}
+		return (await Promise.all(watched.map((file) => fs.stat(file).then((stats) => stats.mtimeMs).catch(() => Number.POSITIVE_INFINITY)))).some((modifiedAt) => modifiedAt > meta.compiledAt);
 	}
 	/**
 	* The bundle's URL, stamped with when it was built.
@@ -153,6 +213,13 @@ var PluginManager = class {
 	isWebUrl(s) {
 		return s.startsWith("/") || s.startsWith("http://") || s.startsWith("https://");
 	}
+	/**
+	* Builds every registered plugin now rather than on first use. A primary does it before starting its workers, so
+	* the workers find each one built — instead of all of them compiling the same plugin into the same folder at once.
+	*/
+	async prepareAll() {
+		await Promise.all(Object.keys(this.plugins).map((key) => this.prepare(key)));
+	}
 	async prepare(name) {
 		const key = this.resolveKey(name) ?? name;
 		if (this.failed.has(key)) return null;
@@ -172,28 +239,28 @@ var PluginManager = class {
 				* does not even restart the watcher.
 				*/
 				if (!await this.isStaleInMemory(cached, source)) return cached.entry;
-				console.log(`[SSR] Plugin "${key}" source changed since it was built, rebuilding…`);
+				serverLog.info("SSR", `Plugin "${key}" source changed since it was built, rebuilding…`);
 				this.mem.delete(key);
 				await fs.rm(this.pluginDir(key), {
 					recursive: true,
 					force: true
 				});
 			} else {
-				console.warn(`[SSR] Plugin "${key}" cache invalidated: output file missing, rebuilding…`);
+				serverLog.warn("SSR", `Plugin "${key}" cache invalidated: output file missing, rebuilding…`);
 				this.mem.delete(key);
 			}
 		}
 		const meta = await this.readMeta(key);
 		if (meta) {
 			const sourceVersion = source.version;
-			if (await this.isStale(meta, source)) {
-				console.log(`[SSR] Plugin "${key}" source changed since it was built, rebuilding…`);
+			if (await this.isStale(meta, source) || await this.contentChanged(meta, source)) {
+				serverLog.info("SSR", `Plugin "${key}" source changed since it was built, rebuilding…`);
 				await fs.rm(this.pluginDir(key), {
 					recursive: true,
 					force: true
 				});
 			} else if (sourceVersion && meta.version !== sourceVersion) {
-				console.log(`[SSR] Plugin "${key}" version changed (${meta.version ?? "none"} → ${sourceVersion}), rebuilding…`);
+				serverLog.info("SSR", `Plugin "${key}" version changed (${meta.version ?? "none"} → ${sourceVersion}), rebuilding…`);
 				await fs.rm(this.pluginDir(key), {
 					recursive: true,
 					force: true
@@ -225,7 +292,7 @@ var PluginManager = class {
 		const cssPath = source.css;
 		const action = isComponentSource(source) ? source.js ? detectAction(source.js) : void 0 : source.action ?? detectAction(source.js);
 		if (!jsPath || !action) return this.toEntry(name, false, void 0, source.props);
-		console.log(`[SSR] Plugin "${name}" building (${action}: ${jsPath})…`);
+		serverLog.info("SSR", `Plugin "${name}" building (${action}: ${jsPath})…`);
 		try {
 			let cssUrl;
 			let buildInputs = [];
@@ -243,12 +310,12 @@ var PluginManager = class {
 			} else if (action === "download") {
 				const jsRes = await fetch(jsPath);
 				if (!jsRes.ok) throw new Error(`HTTP ${jsRes.status} downloading ${jsPath}`);
-				await fs.writeFile(path.join(dir, "index.js"), await jsRes.text());
+				await writeFileAtomic(path.join(dir, "index.js"), await jsRes.text());
 				if (cssPath) {
 					if (cssPath.startsWith("http://") || cssPath.startsWith("https://")) {
 						const cssRes = await fetch(cssPath);
 						if (!cssRes.ok) throw new Error(`HTTP ${cssRes.status} downloading ${cssPath}`);
-						await fs.writeFile(path.join(dir, "index.css"), await cssRes.text());
+						await writeFileAtomic(path.join(dir, "index.css"), await cssRes.text());
 					} else if (this.isWebUrl(cssPath)) cssUrl = cssPath;
 					else await copyPlugin(cssPath, dir, "index.css");
 					cssUrl = `${this.urlPrefix}/${name}/index.css`;
@@ -264,10 +331,12 @@ var PluginManager = class {
 				}
 			}
 			const compiledAt = Date.now();
+			const inputs = this.inputsOf(source, buildInputs);
 			await this.writeMeta(name, {
 				compiledAt,
 				version: source.version,
-				inputs: buildInputs
+				inputs: buildInputs,
+				...inputs.length > 0 ? { digest: await digestOf(inputs) } : {}
 			});
 			if (cssUrl?.startsWith(this.urlPrefix)) cssUrl = this.assetUrl(name, "index.css", compiledAt);
 			const entry = this.toEntry(name, true, cssUrl, source.props, compiledAt);
@@ -276,10 +345,10 @@ var PluginManager = class {
 				entry,
 				inputs: buildInputs
 			});
-			console.log(`[SSR] Plugin "${name}" ready → ${entry.js}`);
+			serverLog.info("SSR", `Plugin "${name}" ready → ${entry.js}`);
 			return entry;
 		} catch (err) {
-			console.error(`[SSR] Plugin "${name}" build failed (js: ${source.js ?? "none"}):`, err);
+			serverLog.error("SSR", `Plugin "${name}" build failed (js: ${source.js ?? "none"})`, err);
 			this.failed.add(name);
 			return null;
 		}
@@ -293,41 +362,43 @@ var PluginManager = class {
 		for (const [name, source] of Object.entries(this.plugins)) if (isComponentSource(source)) out[name.replace(/@[^@]*$/, "")] = source.component;
 		return out;
 	}
-	async invalidate(name, version) {
+	/**
+	* Drops what this process remembers of a plugin — its entry, its failure, which version its name means — and
+	* leaves the disk alone. What an invalidation elsewhere in the fleet does here: that process removes the files,
+	* and each of the others only has to stop pointing at them.
+	*/
+	forget(name, version) {
 		if (!name) {
 			this.mem.clear();
 			this.failed.clear();
 			this.nameIndex.clear();
-			await fs.rm(this.outputDir, {
-				recursive: true,
-				force: true
-			});
 			return;
 		}
-		if (version) {
-			const key = `${name}@${version}`;
+		const keysToEvict = /* @__PURE__ */ new Set();
+		for (const key of [
+			...Object.keys(this.plugins),
+			...this.mem.keys(),
+			...this.failed
+		]) if (isKeyOf(key, name, version)) keysToEvict.add(key);
+		for (const key of keysToEvict) {
 			this.mem.delete(key);
 			this.failed.delete(key);
-			if (this.nameIndex.get(name) === key) this.nameIndex.delete(name);
-			await fs.rm(this.pluginDir(key), {
+		}
+		const indexed = this.nameIndex.get(name);
+		if (indexed !== void 0 && isKeyOf(indexed, name, version)) this.nameIndex.delete(name);
+	}
+	async invalidate(name, version) {
+		this.forget(name, version);
+		if (!name) {
+			await fs.rm(this.outputDir, {
 				recursive: true,
 				force: true
 			});
 			return;
 		}
-		const prefix = `${name}@`;
-		const keysToEvict = /* @__PURE__ */ new Set();
-		keysToEvict.add(name);
-		for (const key of Object.keys(this.plugins)) if (key.startsWith(prefix)) keysToEvict.add(key);
-		for (const key of this.mem.keys()) if (key.startsWith(prefix)) keysToEvict.add(key);
-		for (const key of keysToEvict) {
-			this.mem.delete(key);
-			this.failed.delete(key);
-		}
-		this.nameIndex.delete(name);
 		try {
 			const entries = await fs.readdir(this.outputDir);
-			await Promise.all(entries.filter((e) => e === name || e.startsWith(prefix)).map((e) => fs.rm(path.join(this.outputDir, e), {
+			await Promise.all(entries.filter((entry) => isKeyOf(entry, name, version)).map((entry) => fs.rm(path.join(this.outputDir, entry), {
 				recursive: true,
 				force: true
 			})));
@@ -347,7 +418,7 @@ var PluginManager = class {
 		}
 	}
 	async writeMeta(name, meta) {
-		await fs.writeFile(path.join(this.pluginDir(name), META_FILE), JSON.stringify(meta), "utf-8");
+		await writeFileAtomic(path.join(this.pluginDir(name), META_FILE), JSON.stringify(meta));
 	}
 	async fileExists(p) {
 		return fs.access(p).then(() => true).catch(() => false);

package/dist/runtime.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Space runtimes: a space's own server code run as code of its own, beside the platform that serves the space — for
+ * what the sandbox's functions cannot be (Node, its dependencies, connections that stay open, endpoints that stream).
+ * The contract a runtime module is written against, the host that runs one for the platform, how one is packed to
+ * travel, and the stages that serve one: on a server of its own (`serveRuntime`), or forwarded to (`createRuntimeProxyStage`).
+ */
+export { defineRuntime, endpointFor, endpointProblem } from './modules/runtime/contract';
+export type { SpaceRuntime, SpaceRuntimeContext, SpaceRuntimeEndpoint, SpaceRuntimeParts } from './modules/runtime/contract';
+export { RUNTIME_DESCRIBE_PATH, startSpaceRuntime } from './modules/runtime/host';
+export type { SpaceRuntimeDescription, SpaceRuntimeHost, SpaceRuntimeHostOptions } from './modules/runtime/host';
+export { inspectRuntime, loadRuntime, MAX_RUNTIME_BUNDLE_BYTES, packRuntime, runtimeBundleId } from './modules/runtime/bundle';
+export { reachSpaceInside } from './modules/runtime/inside';
+export { createRuntimeRunner } from './modules/runtime/runner';
+export { createRuntimeProxyStage, runtimeEndpointsStage, serveRuntime } from './modules/runtime/stages';
+export type { RuntimeProxyConfig, RuntimeTarget, ServedRuntime } from './modules/runtime/stages';

package/dist/runtime.js

@@ -0,0 +1,7 @@
+import { defineRuntime, endpointFor, endpointProblem } from "./modules/runtime/contract.js";
+import { reachSpaceInside } from "./modules/runtime/inside.js";
+import { createRuntimeRunner } from "./modules/runtime/runner.js";
+import { RUNTIME_DESCRIBE_PATH, startSpaceRuntime } from "./modules/runtime/host.js";
+import { MAX_RUNTIME_BUNDLE_BYTES, inspectRuntime, loadRuntime, packRuntime, runtimeBundleId } from "./modules/runtime/bundle.js";
+import { createRuntimeProxyStage, runtimeEndpointsStage, serveRuntime } from "./modules/runtime/stages.js";
+export { MAX_RUNTIME_BUNDLE_BYTES, RUNTIME_DESCRIBE_PATH, createRuntimeProxyStage, createRuntimeRunner, defineRuntime, endpointFor, endpointProblem, inspectRuntime, loadRuntime, packRuntime, reachSpaceInside, runtimeBundleId, runtimeEndpointsStage, serveRuntime, startSpaceRuntime };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plitzi/sdk-server",
-  "version": "0.37.2",
+  "version": "0.37.4",
   "license": "AGPL-3.0",
   "files": [
     "dist",
@@ -54,7 +54,23 @@
       "types": "./dist/actions.d.ts",
       "import": "./dist/actions.js",
       "default": "./dist/actions.js"
-    }
+    },
+    "./functions": {
+      "types": "./dist/functions.d.ts",
+      "import": "./dist/functions.js",
+      "default": "./dist/functions.js"
+    },
+    "./functions-runner": {
+      "types": "./dist/functionsRunner.d.ts",
+      "import": "./dist/functionsRunner.js",
+      "default": "./dist/functionsRunner.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "import": "./dist/runtime.js",
+      "default": "./dist/runtime.js"
+    },
+    "./functions-api.d.ts": "./dist/functions-api.d.ts"
   },
   "repository": {
     "type": "https",
@@ -63,20 +79,30 @@
   "type": "module",
   "sideEffects": false,
   "dependencies": {
-    "@plitzi/plitzi-sdk": "0.37.2",
-    "@plitzi/sdk-shared": "0.37.2",
+    "@plitzi/plitzi-sdk": "0.37.4",
+    "@plitzi/sdk-shared": "0.37.4",
     "ejs": "^6.0.1",
     "esbuild": "^0.28.2",
     "jsonwebtoken": "^9.0.3",
-    "nodemailer": "^10.0.10"
+    "nodemailer": "^10.0.10",
+    "undici": "^8.11.2",
+    "ws": "^8.21.1"
   },
   "peerDependencies": {
+    "core-js": "^3.50.0",
+    "isolated-vm": "^7.0.1",
     "mongodb": "^6 || ^7",
     "mysql2": "^3",
     "react": "^19",
     "react-dom": "^19"
   },
   "peerDependenciesMeta": {
+    "core-js": {
+      "optional": true
+    },
+    "isolated-vm": {
+      "optional": true
+    },
     "mongodb": {
       "optional": true
     },
@@ -85,22 +111,27 @@
     }
   },
   "devDependencies": {
+    "@microsoft/api-extractor": "^7.59.2",
     "@types/ejs": "^3.1.5",
     "@types/jsonwebtoken": "^9.0.10",
     "@types/node": "^26.6.2",
     "@types/nodemailer": "^8.0.2",
     "@types/react": "^19.3.0",
+    "@types/ws": "^8.18.1",
     "@vitejs/plugin-react": "^6.1.1",
     "@vitest/coverage-v8": "^5.0.1",
+    "core-js": "^3.50.0",
     "eslint": "^9.39.5",
     "eslint-plugin-import": "^2.32.0",
+    "ioredis": "^6.0.0",
+    "isolated-vm": "^7.0.1",
     "mongodb": "^7.6.0",
     "mysql2": "^3.24.4",
     "react": "^19.3.0",
     "react-dom": "^19.3.0",
     "tsx": "^4.23.15",
     "typescript": "^6.0.3",
-    "vite": "^8.3.0",
+    "vite": "^8.3.1",
     "vite-plugin-dts": "^5.1.1",
     "vitest": "^5.0.1"
   },
@@ -110,8 +141,8 @@
     "start": "TSX_TSCONFIG_PATH=tsconfig.app.json node --import tsx dev/main.ts",
     "start:watch": "TSX_TSCONFIG_PATH=tsconfig.app.json node --import tsx --watch dev/main.ts",
     "start:inspect": "TSX_TSCONFIG_PATH=tsconfig.app.json node --import tsx --inspect dev/main.ts",
-    "build:dev": "vite build --mode development",
-    "build:prod": "vite build",
+    "build:dev": "vite build --mode development && node scripts/functions-api.mjs",
+    "build:prod": "vite build && node scripts/functions-api.mjs",
     "lint": "TIMING=1 eslint ./src ./dev",
     "typecheck": "tsc -p tsconfig.app.json --noEmit",
     "test": "vitest run",