@serverkgg/bridge 0.0.3 → 0.0.5

package/README.md

@@ -41,7 +41,7 @@ bunx serverk-bridge validate
 bunx serverk-bridge compile
 ```
 
-`validate` checks `serverk.yml` against the real platform schema, verifies the logo and banner, and validates the driver's panel wiring. `compile` produces `dist/bridge-amd64` and `dist/bridge-arm64`.
+`validate` checks `serverk.yml` against the real platform schema, verifies the logo and banner, and validates the driver's panel wiring. `compile` produces `dist/bridge`, an amd64 binary — serverk publishes game images for `linux/amd64` only.
 
 ## Compatibility
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@serverkgg/bridge",
-	"version": "0.0.3",
+	"version": "0.0.5",
 	"description": "Serverk game bridge — driver runtime, wire protocol, manifest schema, and maintainer CLI",
 	"homepage": "https://serverk.gg",
 	"license": "SEE LICENSE IN LICENSE.md",

package/src/cli/compile.ts

@@ -1,14 +1,10 @@
 import { parseArgs } from "node:util";
 
-const TARGETS: Record<string, string> = {
-	amd64: "bun-linux-x64",
-	arm64: "bun-linux-arm64",
-};
+const TARGET = "bun-linux-x64";
 
 const HELP = `serverk-bridge compile [options]
 
 options:
-  --arch <amd64|arm64>   architecture to compile (repeatable, default: both)
   --entry <path>         entrypoint (default: src/main.ts)
   --outdir <path>        output directory (default: dist)
   --help                 show this help`;
@@ -17,10 +13,6 @@ export const runCompile = async (args: string[]) => {
 	const { values } = parseArgs({
 		args,
 		options: {
-			arch: {
-				type: "string",
-				multiple: true,
-			},
 			entry: {
 				type: "string",
 				default: "src/main.ts",
@@ -42,34 +34,24 @@ export const runCompile = async (args: string[]) => {
 		return;
 	}
 
-	const arches = values.arch?.length ? values.arch : Object.keys(TARGETS);
-
-	for (const arch of arches) {
-		const target = TARGETS[arch];
-
-		if (!target) {
-			throw new Error(`unknown arch "${arch}" — expected amd64 or arm64`);
-		}
-
-		const outfile = `${values.outdir}/bridge-${arch}`;
-		const child = Bun.spawn(
-			[
-				"bun",
-				"build",
-				"--compile",
-				`--target=${target}`,
-				values.entry,
-				"--outfile",
-				outfile,
-			],
-			{
-				stderr: "inherit",
-				stdout: "inherit",
-			},
-		);
+	const outfile = `${values.outdir}/bridge`;
+	const child = Bun.spawn(
+		[
+			"bun",
+			"build",
+			"--compile",
+			`--target=${TARGET}`,
+			values.entry,
+			"--outfile",
+			outfile,
+		],
+		{
+			stderr: "inherit",
+			stdout: "inherit",
+		},
+	);
 
-		if ((await child.exited) !== 0) {
-			throw new Error(`compile failed for ${arch}`);
-		}
+	if ((await child.exited) !== 0) {
+		throw new Error("compile failed");
 	}
 };

package/src/cli/main.ts

@@ -11,7 +11,7 @@ const USAGE = `serverk-bridge <command>
 commands:
   validate   validate serverk.yml, assets, and driver wiring
   schema     write the serverk.yml JSON Schema for editor tooling
-  compile    compile the bridge binary for amd64 and arm64
+  compile    compile the bridge binary for amd64
   link       use a local bridge checkout while developing
 
 run "serverk-bridge <command> --help" for options`;

package/src/core/bridgePort.ts

@@ -2,3 +2,8 @@ export enum PortProtocol {
 	Tcp = "tcp",
 	Udp = "udp",
 }
+
+export enum PortJoin {
+	Combined = "combined",
+	Separate = "separate",
+}

package/src/manifest/manifest.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import { z } from "zod";
+import { PortJoin } from "../core";
 import { GameCategory } from "./category";
 import { guidePackageSchema, MANIFEST_SCHEMA_VERSION, manifestSchema, packageSchema } from "./manifest";
 
@@ -55,6 +56,34 @@ const failure = (input: unknown) => {
 	}));
 };
 
+const withPort = (extra: Record<string, unknown>) => {
+	const manifest = base();
+	const [game] = manifest.container.ports;
+
+	if (!game) {
+		throw new Error("fixture is missing its port");
+	}
+
+	return {
+		...manifest,
+		container: {
+			...manifest.container,
+			ports: [
+				{
+					...game,
+					...extra,
+				},
+			],
+		},
+	};
+};
+
+const withPortSrv = (srv: unknown) => {
+	return withPort({
+		srv,
+	});
+};
+
 describe("defaults", () => {
 	test("fills in the optional sections so consumers never guard", () => {
 		const manifest = manifestSchema.parse(base());
@@ -72,6 +101,81 @@ describe("defaults", () => {
 		});
 		expect(manifest.guides).toEqual([]);
 		expect(manifest.secrets).toEqual([]);
+		expect(manifest.container.ports[0]?.srv).toBeUndefined();
+		expect(manifest.container.ports[0]?.name).toBeUndefined();
+		expect(manifest.container.ports[0]?.hint).toBeUndefined();
+		expect(manifest.container.ports[0]?.join).toBe(PortJoin.Combined);
+	});
+});
+
+describe("port presentation", () => {
+	test("keeps the localized name, hint and join style a port declares", () => {
+		const manifest = manifestSchema.parse(
+			withPort({
+				name: {
+					ar: "بيدروك",
+					en: "Bedrock",
+				},
+				hint: {
+					ar: "العنوان في خانة والمنفذ في خانة ثانية",
+					en: "Address and port go in separate fields",
+				},
+				join: "separate",
+			}),
+		);
+
+		expect(manifest.container.ports[0]?.name).toEqual({
+			ar: "بيدروك",
+			en: "Bedrock",
+		});
+		expect(manifest.container.ports[0]?.hint?.en).toBe("Address and port go in separate fields");
+		expect(manifest.container.ports[0]?.join).toBe(PortJoin.Separate);
+	});
+
+	test("rejects a port name missing one language", () => {
+		expect(
+			failure(
+				withPort({
+					name: {
+						en: "Bedrock",
+					},
+				}),
+			),
+		).toEqual([
+			{
+				path: "container.ports.0.name.ar",
+				message: "Invalid input: expected string, received undefined",
+			},
+		]);
+	});
+});
+
+describe("port srv", () => {
+	test("keeps the service label a port declares", () => {
+		const manifest = manifestSchema.parse(
+			withPortSrv({
+				service: "_minecraft",
+			}),
+		);
+
+		expect(manifest.container.ports[0]?.srv).toEqual({
+			service: "_minecraft",
+		});
+	});
+
+	test("rejects a service label without its underscore", () => {
+		expect(
+			failure(
+				withPortSrv({
+					service: "minecraft",
+				}),
+			),
+		).toEqual([
+			{
+				path: "container.ports.0.srv.service",
+				message: "must be an underscore-prefixed service label such as _minecraft",
+			},
+		]);
 	});
 });
 

package/src/manifest/manifest.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { PortProtocol } from "../core";
+import { PortJoin, PortProtocol } from "../core";
 import { BridgeIcon } from "../panel/bridgeIcon";
 import { GameCategory } from "./category";
 import { type GuideEntry, type GuideTag, guideEntrySchema, guideTagSchema } from "./guide";
@@ -43,6 +43,26 @@ const manifestPortSchema = z.object({
 	containerPort: zPort,
 	protocol: z.enum(PortProtocol).default(PortProtocol.Tcp),
 	hostRange: manifestHostRangeSchema,
+	name: localizedText(48).optional().meta({
+		description: "Player-facing name of this port, such as Java or Bedrock. The key is shown when omitted.",
+	}),
+	hint: localizedText(160).optional().meta({
+		description: "One short line telling the player where this address goes in the game client.",
+	}),
+	join: z.enum(PortJoin).default(PortJoin.Combined).meta({
+		description: "How the game client takes the address: combined as host:port, or separate address and port fields.",
+	}),
+	srv: z
+		.object({
+			service: z
+				.string()
+				.regex(/^_[a-z0-9-]{1,15}$/, "must be an underscore-prefixed service label such as _minecraft"),
+		})
+		.optional()
+		.meta({
+			description:
+				"Publishes this port as an SRV record under the server hostname, so players join by name with no port.",
+		}),
 });
 
 export type ManifestPort = z.infer<typeof manifestPortSchema>;