@void/platform 0.20.0

package/dist/installer.d.mts

@@ -0,0 +1,49 @@
+//#region src/installer.d.ts
+export type PlatformRuntimeArtifact = Readonly<{
+  path: string;
+  sha256: string;
+  size: number;
+}>;
+export type PlatformRuntimeMigration = Readonly<{
+  index: number;
+  sha256: string;
+  tag: string;
+  timestampMillis: number;
+}>;
+export type PlatformRuntimeDatabaseCompatibility = Readonly<{
+  platformVersion: string;
+  schemaDigest: string;
+}>;
+export type PlatformRuntimeDatabaseManifest = Readonly<{
+  journalSha256: string;
+  lineage: string;
+  migrations: ReadonlyArray<PlatformRuntimeMigration>;
+  protocolVersion: 1;
+  rollbackSafeFrom: ReadonlyArray<PlatformRuntimeDatabaseCompatibility>;
+  schemaDigest: string;
+}>;
+export type PlatformRuntimeManifest = Readonly<{
+  applicationRoutingVersion?: 1;
+  artifacts: Readonly<Record<"api" | "dispatch" | "proxy" | "tail", PlatformRuntimeArtifact>>;
+  database: PlatformRuntimeDatabaseManifest;
+  platformVersion: string;
+  safetyProtocols: Readonly<{
+    sandboxDrain: 0 | 1 | 2;
+  }>;
+  schemaVersion: 2;
+  sourceRevision: string | null;
+  /** Queue payload contract shared by the API consumer and trusted producers. */
+  usageProtocolVersion: 0 | 1;
+}>;
+export type PlatformRuntime = Readonly<{
+  directory: string;
+  manifest: PlatformRuntimeManifest;
+  manifestSha256: string;
+  source: "custom" | "package";
+}>;
+export declare function platformDatabaseSchemaDigest(lineage: string, migrations: ReadonlyArray<PlatformRuntimeMigration>): string;
+export declare function parsePlatformRuntimeManifest(value: unknown): PlatformRuntimeManifest;
+export declare function getPlatformRuntimeDirectory(): string;
+export declare function readPlatformRuntimeManifest(runtimeDirectory?: string): PlatformRuntimeManifest;
+export declare function resolvePlatformRuntime(customRuntimeDirectory?: string, baseDirectory?: string): PlatformRuntime;
+//#endregion

package/dist/installer.mjs

@@ -0,0 +1,176 @@
+import { createHash } from "node:crypto";
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, isAbsolute, join, resolve } from "pathslash";
+//#region src/installer.ts
+const SHA256_PATTERN = /^[0-9a-f]{64}$/;
+const TAG_PATTERN = /^[0-9]{4}_[a-z0-9_]+$/;
+function platformDatabaseSchemaDigest(lineage, migrations) {
+	return createHash("sha256").update(JSON.stringify({
+		lineage,
+		migrations: migrations.map(({ index, sha256, tag, timestampMillis }) => ({
+			index,
+			sha256,
+			tag,
+			timestampMillis
+		}))
+	})).digest("hex");
+}
+function parsePlatformRuntimeManifest(value) {
+	const root = record(value, "runtime manifest");
+	if (root.schemaVersion !== 2) throw new Error("runtime manifest schemaVersion must be 2");
+	const artifactsValue = record(root.artifacts, "runtime manifest artifacts");
+	const artifacts = Object.fromEntries([
+		"api",
+		"dispatch",
+		"proxy",
+		"tail"
+	].map((name) => [name, parseArtifact(artifactsValue[name], name)]));
+	const databaseValue = record(root.database, "runtime manifest database");
+	if (databaseValue.protocolVersion !== 1) throw new Error("runtime manifest database protocolVersion must be 1");
+	const lineage = nonemptyString(databaseValue.lineage, "database lineage");
+	const migrations = array(databaseValue.migrations, "database migrations").map((migration, position) => parseMigration(migration, position));
+	const seenIndexes = /* @__PURE__ */ new Set();
+	const seenTags = /* @__PURE__ */ new Set();
+	const seenTimestamps = /* @__PURE__ */ new Set();
+	let previousIndex = -1;
+	let previousTimestamp = -1;
+	for (const migration of migrations) {
+		if (seenIndexes.has(migration.index) || seenTags.has(migration.tag) || seenTimestamps.has(migration.timestampMillis)) throw new Error("runtime manifest database migrations must be unique");
+		if (migration.index <= previousIndex || migration.timestampMillis <= previousTimestamp) throw new Error("runtime manifest database migrations must be strictly ordered");
+		seenIndexes.add(migration.index);
+		seenTags.add(migration.tag);
+		seenTimestamps.add(migration.timestampMillis);
+		previousIndex = migration.index;
+		previousTimestamp = migration.timestampMillis;
+	}
+	const schemaDigest = sha256(databaseValue.schemaDigest, "database schema digest");
+	if (schemaDigest !== platformDatabaseSchemaDigest(lineage, migrations)) throw new Error("runtime manifest database schema digest does not match its migrations");
+	const rollbackSafeFrom = array(databaseValue.rollbackSafeFrom, "database rollback compatibility entries").map((entry, position) => {
+		const compatibility = record(entry, `database rollback compatibility entry ${position}`);
+		return {
+			platformVersion: nonemptyString(compatibility.platformVersion, `database rollback compatibility entry ${position} platformVersion`),
+			schemaDigest: sha256(compatibility.schemaDigest, `database rollback compatibility entry ${position} schemaDigest`)
+		};
+	});
+	const compatibilityKeys = rollbackSafeFrom.map(({ platformVersion, schemaDigest: digest }) => `${platformVersion}\0${digest}`);
+	if (new Set(compatibilityKeys).size !== compatibilityKeys.length) throw new Error("runtime manifest database rollback compatibility entries must be unique");
+	const prefixDigests = new Set(Array.from({ length: migrations.length + 1 }, (_, length) => platformDatabaseSchemaDigest(lineage, migrations.slice(0, length))));
+	if (rollbackSafeFrom.some((entry) => !prefixDigests.has(entry.schemaDigest))) throw new Error("runtime manifest database rollback compatibility must reference this migration lineage");
+	return {
+		artifacts,
+		...root.applicationRoutingVersion === 1 ? { applicationRoutingVersion: 1 } : {},
+		database: {
+			journalSha256: sha256(databaseValue.journalSha256, "database journal digest"),
+			lineage,
+			migrations,
+			protocolVersion: 1,
+			rollbackSafeFrom,
+			schemaDigest
+		},
+		platformVersion: nonemptyString(root.platformVersion, "runtime manifest platformVersion"),
+		safetyProtocols: parseSafetyProtocols(root.safetyProtocols),
+		schemaVersion: 2,
+		sourceRevision: root.sourceRevision === void 0 || root.sourceRevision === null ? null : sourceRevision(root.sourceRevision),
+		usageProtocolVersion: usageProtocolVersion(root.usageProtocolVersion)
+	};
+}
+function parseSafetyProtocols(value) {
+	if (value === void 0) return { sandboxDrain: 0 };
+	const protocols = record(value, "runtime manifest safetyProtocols");
+	if (protocols.sandboxDrain !== 0 && protocols.sandboxDrain !== 1 && protocols.sandboxDrain !== 2) throw new Error("runtime manifest safetyProtocols.sandboxDrain must be 0, 1, or 2");
+	return { sandboxDrain: protocols.sandboxDrain };
+}
+function usageProtocolVersion(value) {
+	if (value === void 0 || value === 0) return 0;
+	if (value === 1) return 1;
+	throw new Error("runtime manifest usageProtocolVersion must be 0 or 1");
+}
+function getPlatformRuntimeDirectory() {
+	return join(dirname(fileURLToPath(import.meta.url)), "runtime");
+}
+function readPlatformRuntimeManifest(runtimeDirectory = getPlatformRuntimeDirectory()) {
+	const path = join(runtimeDirectory, "manifest.json");
+	try {
+		return parsePlatformRuntimeManifest(JSON.parse(readFileSync(path, "utf8")));
+	} catch (error) {
+		throw new Error(`Void Platform deployment artifacts are missing or invalid at ${path}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+function resolvePlatformRuntime(customRuntimeDirectory, baseDirectory = process.cwd()) {
+	const source = customRuntimeDirectory ? "custom" : "package";
+	const requestedDirectory = customRuntimeDirectory ? isAbsolute(customRuntimeDirectory) ? customRuntimeDirectory : resolve(baseDirectory, customRuntimeDirectory) : getPlatformRuntimeDirectory();
+	let directory;
+	try {
+		directory = realpathSync(requestedDirectory);
+		if (!statSync(directory).isDirectory()) throw new Error("not a directory");
+	} catch (error) {
+		throw new Error(`Void Platform runtime directory is unavailable at ${requestedDirectory}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const manifestPath = join(directory, "manifest.json");
+	let manifestContents;
+	try {
+		manifestContents = readFileSync(manifestPath);
+	} catch (error) {
+		throw new Error(`Void Platform deployment artifacts are missing or invalid at ${manifestPath}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	return {
+		directory,
+		manifest: readPlatformRuntimeManifest(directory),
+		manifestSha256: createHash("sha256").update(manifestContents).digest("hex"),
+		source
+	};
+}
+function parseArtifact(value, name) {
+	const artifact = record(value, `runtime manifest artifact ${name}`);
+	const path = nonemptyString(artifact.path, `runtime manifest artifact ${name} path`);
+	if (path.startsWith("/") || path.split(/[\\/]/u).includes("..")) throw new Error(`runtime manifest artifact ${name} path must stay inside the package`);
+	const size = safeInteger(artifact.size, `runtime manifest artifact ${name} size`);
+	if (size < 0) throw new Error(`runtime manifest artifact ${name} size must not be negative`);
+	return {
+		path,
+		sha256: sha256(artifact.sha256, `runtime manifest artifact ${name} digest`),
+		size
+	};
+}
+function parseMigration(value, position) {
+	const migration = record(value, `database migration ${position}`);
+	const tag = nonemptyString(migration.tag, `database migration ${position} tag`);
+	if (!TAG_PATTERN.test(tag)) throw new Error(`database migration ${position} tag is invalid`);
+	const index = safeInteger(migration.index, `database migration ${position} index`);
+	const timestampMillis = safeInteger(migration.timestampMillis, `database migration ${position} timestampMillis`);
+	if (index < 0 || timestampMillis < 0) throw new Error(`database migration ${position} index and timestampMillis must be positive`);
+	return {
+		index,
+		sha256: sha256(migration.sha256, `database migration ${position} digest`),
+		tag,
+		timestampMillis
+	};
+}
+function record(value, name) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${name} must be an object`);
+	return value;
+}
+function array(value, name) {
+	if (!Array.isArray(value)) throw new Error(`${name} must be an array`);
+	return value;
+}
+function nonemptyString(value, name) {
+	if (typeof value !== "string" || value.trim() === "") throw new Error(`${name} must be a non-empty string`);
+	return value;
+}
+function sourceRevision(value) {
+	const revision = nonemptyString(value, "runtime manifest sourceRevision");
+	if (revision.length > 200 || !/^[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(revision)) throw new Error("runtime manifest sourceRevision is invalid");
+	return revision;
+}
+function safeInteger(value, name) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value)) throw new Error(`${name} must be a safe integer`);
+	return value;
+}
+function sha256(value, name) {
+	if (typeof value !== "string" || !SHA256_PATTERN.test(value)) throw new Error(`${name} must be a lowercase SHA-256 digest`);
+	return value;
+}
+//#endregion
+export { getPlatformRuntimeDirectory, parsePlatformRuntimeManifest, platformDatabaseSchemaDigest, readPlatformRuntimeManifest, resolvePlatformRuntime };

package/dist/runtime/api/README.md

@@ -0,0 +1 @@
+This folder contains the built output assets for the worker "void-runtime-build-api" generated at 2026-09-17T22:53:24.336Z.