@serverkgg/bridge 0.1.3 → 0.1.5

package/src/cli/validate.ts

@@ -21,6 +21,7 @@ import {
 } from "../manifest";
 import type { BridgeDriver, BridgeSetupModule } from "../modules";
 import {
+	BridgeConfirm,
 	BridgeLayout,
 	BridgePlace,
 	type BridgeSection,
@@ -313,6 +314,39 @@ const reportAvailability = (driver: BridgeDriver) => {
 	}
 };
 
+const RESTORE_POINT_LAYOUTS: ReadonlySet<BridgeLayout> = new Set([
+	BridgeLayout.Form,
+	BridgeLayout.Catalog,
+]);
+
+export const confirmReportLines = (driver: BridgeDriver): string[] => {
+	const lines: string[] = [];
+
+	for (const tab of driver.panel?.tabs ?? []) {
+		for (const section of tab.sections) {
+			if (!("confirm" in section) || section.confirm !== BridgeConfirm.Strong) {
+				continue;
+			}
+
+			if (RESTORE_POINT_LAYOUTS.has(section.layout)) {
+				lines.push(
+					`  error: tab "${tab.id}" section "${section.id}" is a ${section.layout} with \`confirm: strong\` — the platform takes a restore point before applying it, so declare \`normal\`; \`strong\` is only for what nothing brings back`,
+				);
+
+				continue;
+			}
+
+			if ("reinstall" in section && section.reinstall === true) {
+				lines.push(
+					`  error: tab "${tab.id}" section "${section.id}" reinstalls with \`confirm: strong\` — the platform takes a restore point before every reinstall, so declare \`normal\`; \`strong\` is only for what nothing brings back`,
+				);
+			}
+		}
+	}
+
+	return lines;
+};
+
 const openTargetOf = (target: GuideOpenTarget) => {
 	if (target.tab === GuideOpenTab.Panel) {
 		return `panel tab "${target.tabId}"`;
@@ -434,6 +468,14 @@ const validateRunnablePackage = async (
 	validateDriver(driver);
 	validatePortActivation(manifest.container.ports, driver);
 
+	const confirmLines = confirmReportLines(driver);
+
+	if (confirmLines.length > 0) {
+		throw new Error(
+			`the panel asks for a strong confirmation where a restore point is taken:\n${confirmLines.join("\n")}`,
+		);
+	}
+
 	const conditionalPorts = manifest.container.ports.filter((port) => port.activeWhen.length > 0).length;
 	const pairedPorts = manifest.container.ports.filter((port) => port.protocol === PortProtocol.TcpUdp).length;
 	const blockPorts = manifest.container.ports.filter((port) => port.count > 1).length;

package/src/manifest/manifest.ts

@@ -224,7 +224,8 @@ export type ManifestFileNote = z.infer<typeof manifestFileNoteSchema>;
 
 const manifestFilesSchema = z.object({
 	protected: z.array(zGlob).max(64).default([]).meta({
-		description: "Paths the player cannot edit, rename or delete from the file manager.",
+		description:
+			"Platform state inside the server directory: hidden from the file manager and left out of archives and copies. Only what the bridge cannot manage without and cannot detect losing.",
 	}),
 	notable: z.array(manifestFileNoteSchema).max(32).default([]).meta({
 		description: "Paths the file manager annotates with a label, note and icon.",

package/src/modules/bridge.ts

@@ -39,6 +39,7 @@ import type {
 	BridgeCatalogProvider,
 	BridgeCatalogQuery,
 } from "../protocol/bridgeCatalog";
+import type { BridgeCrashReport } from "../protocol/bridgeCrash";
 import type { BridgePendingFile } from "../protocol/bridgeFrame";
 import type { BridgePreview } from "../protocol/bridgePreview";
 import type {
@@ -96,6 +97,7 @@ export namespace Bridge {
 	export type Collection<Row extends BridgeRow = BridgeRow> = BridgeCollectionModule<Row>;
 	export type Context = BridgeContext;
 	export type Copy = BridgeCopy;
+	export type CrashReport = BridgeCrashReport;
 	export type Detail = BridgeDetailModule;
 	export type DetailAction = BridgeDetailAction;
 	export type DetailBadge = BridgeDetailBadge;

package/src/modules/bridgeModule.ts

@@ -15,6 +15,7 @@ import type {
 	BridgeCatalogQuery,
 	BridgeCatalogRelease,
 } from "../protocol/bridgeCatalog";
+import type { BridgeCrashReport } from "../protocol/bridgeCrash";
 import type { BridgeBackupSnapshot, BridgeDescribeResult, BridgePendingFile } from "../protocol/bridgeFrame";
 import type { BridgePreview } from "../protocol/bridgePreview";
 import type { BridgeSetupStep } from "../protocol/bridgeSetup";
@@ -34,6 +35,8 @@ export interface BridgeLifecycleModule {
 	kind: BridgeKind.Lifecycle;
 	ready?: RegExp;
 	failed?: RegExp;
+	graceSeconds?: number;
+	stableLine?: RegExp;
 	stopTimeoutSeconds?: number;
 	readyTimeoutSeconds?: number;
 	stopSignal?: BridgeStopSignal;
@@ -42,6 +45,8 @@ export interface BridgeLifecycleModule {
 	environment?(context: BridgeContext): Promise<Record<string, string>>;
 	stop?(context: BridgeContext): Promise<void>;
 	onReady?(context: BridgeContext): Promise<void>;
+	onStable?(context: BridgeContext): Promise<void>;
+	onExit?(context: BridgeContext, report: BridgeCrashReport): Promise<void>;
 }
 
 export interface BridgeAnnounceModule {

package/src/protocol/bridgeCrash.ts

@@ -8,6 +8,15 @@ export enum BridgeCrashCause {
 	WorldCorrupt = "world-corrupt",
 	MissingDependency = "missing-dependency",
 	ModCrashed = "mod-crashed",
+	TokenInvalid = "token-invalid",
+	IntentsDisallowed = "intents-disallowed",
+	TokenInUse = "token-in-use",
+	WrongTelegramPackage = "wrong-telegram-package",
+	WrongDiscordPackage = "wrong-discord-package",
+	BuildTools = "build-tools",
+	FfmpegMissing = "ffmpeg-missing",
+	AudioopRemoved = "audioop-removed",
+	RateLimited = "rate-limited",
 	Unknown = "unknown",
 }
 
@@ -38,6 +47,22 @@ export const BRIDGE_CRASH_EVIDENCE: readonly BridgeCrashEvidence[] = [
 		name: BridgeEventName.WorldCorrupt,
 		cause: BridgeCrashCause.WorldCorrupt,
 	},
+	{
+		name: BridgeEventName.AudioopRemoved,
+		cause: BridgeCrashCause.AudioopRemoved,
+	},
+	{
+		name: BridgeEventName.WrongTelegramPackage,
+		cause: BridgeCrashCause.WrongTelegramPackage,
+	},
+	{
+		name: BridgeEventName.WrongDiscordPackage,
+		cause: BridgeCrashCause.WrongDiscordPackage,
+	},
+	{
+		name: BridgeEventName.BuildToolsMissing,
+		cause: BridgeCrashCause.BuildTools,
+	},
 	{
 		name: BridgeEventName.MissingDependency,
 		cause: BridgeCrashCause.MissingDependency,
@@ -46,6 +71,26 @@ export const BRIDGE_CRASH_EVIDENCE: readonly BridgeCrashEvidence[] = [
 		name: BridgeEventName.ModCrashed,
 		cause: BridgeCrashCause.ModCrashed,
 	},
+	{
+		name: BridgeEventName.FfmpegMissing,
+		cause: BridgeCrashCause.FfmpegMissing,
+	},
+	{
+		name: BridgeEventName.IntentsDisallowed,
+		cause: BridgeCrashCause.IntentsDisallowed,
+	},
+	{
+		name: BridgeEventName.TokenInvalid,
+		cause: BridgeCrashCause.TokenInvalid,
+	},
+	{
+		name: BridgeEventName.TokenInUse,
+		cause: BridgeCrashCause.TokenInUse,
+	},
+	{
+		name: BridgeEventName.RateLimited,
+		cause: BridgeCrashCause.RateLimited,
+	},
 ];
 
 const BRIDGE_CRASH_EVIDENCE_NAMES: ReadonlySet<string> = new Set(BRIDGE_CRASH_EVIDENCE.map((entry) => entry.name));
@@ -81,3 +126,7 @@ export interface BridgeCrashRecord {
 	restarts: number;
 	lastLine: string | null;
 }
+
+export interface BridgeCrashReport extends BridgeCrashRecord {
+	cause: BridgeCrashCause;
+}

package/src/protocol/bridgeEvents.ts

@@ -1,11 +1,15 @@
 export enum BridgeEventName {
 	AccessGranted = "AccessGranted",
 	AccessRevoked = "AccessRevoked",
+	AudioopRemoved = "AudioopRemoved",
 	BroadcastSent = "BroadcastSent",
+	BuildToolsMissing = "BuildToolsMissing",
+	FfmpegMissing = "FfmpegMissing",
 	GameInstalled = "GameInstalled",
 	GameModeChanged = "GameModeChanged",
 	GameplayChanged = "GameplayChanged",
 	InstallFailed = "InstallFailed",
+	IntentsDisallowed = "IntentsDisallowed",
 	MemoryUndersized = "MemoryUndersized",
 	MissingDependency = "MissingDependency",
 	ModCrashed = "ModCrashed",
@@ -28,6 +32,7 @@ export enum BridgeEventName {
 	PlayerLeft = "PlayerLeft",
 	PlayerUnbanned = "PlayerUnbanned",
 	PortBindFailed = "PortBindFailed",
+	RateLimited = "RateLimited",
 	SecretRotated = "SecretRotated",
 	ServerCrashed = "ServerCrashed",
 	ServerStarted = "ServerStarted",
@@ -40,6 +45,8 @@ export enum BridgeEventName {
 	SetupRejected = "SetupRejected",
 	SignInExpired = "SignInExpired",
 	TickLagging = "TickLagging",
+	TokenInUse = "TokenInUse",
+	TokenInvalid = "TokenInvalid",
 	WorldActivated = "WorldActivated",
 	WorldCloned = "WorldCloned",
 	WorldCorrupt = "WorldCorrupt",
@@ -48,7 +55,9 @@ export enum BridgeEventName {
 	WorldImported = "WorldImported",
 	WorldSaved = "WorldSaved",
 	WorldWiped = "WorldWiped",
+	WrongDiscordPackage = "WrongDiscordPackage",
 	WrongJavaVersion = "WrongJavaVersion",
+	WrongTelegramPackage = "WrongTelegramPackage",
 }
 
 export const BRIDGE_EVENT_NAMES: readonly string[] = Object.values(BridgeEventName);

package/src/protocol/bridgePreview.ts

@@ -5,4 +5,5 @@ export interface BridgePreview {
 	variables?: Record<string, string>;
 	confirm: BridgeConfirm;
 	lines: LocalizedText[];
+	blocked?: boolean;
 }

package/src/rcon/rconAccess.ts

@@ -249,7 +249,7 @@ export const rconAccessSections = (options: RconAccessSectionsOptions = {}): Bri
 						ar: "غيّر كلمة المرور",
 						en: "Rotate the password",
 					},
-					confirm: BridgeConfirm.Strong,
+					confirm: BridgeConfirm.Normal,
 					confirmText: {
 						ar: "ستتوقف كل أداة خارجية تستخدمها حتى تضيف إليها كلمة المرور الجديدة.",
 						en: "Every external tool you use stops working until you paste the new password into it.",

package/src/runtime/bridgeDriver.test.ts

@@ -1899,6 +1899,51 @@ describe("the lifecycle module", () => {
 		}
 	});
 
+	it("accepts a grace from one second to ten minutes and a stable line", () => {
+		for (const graceSeconds of [
+			1,
+			20,
+			600,
+		]) {
+			expect(() =>
+				validateDriver(
+					lifecycleDriver({
+						graceSeconds,
+						stableLine: /logged in as/i,
+					}),
+				),
+			).not.toThrow();
+		}
+	});
+
+	it("refuses a grace outside one second to ten minutes", () => {
+		for (const graceSeconds of [
+			0,
+			601,
+			2.5,
+		]) {
+			expect(() =>
+				validateDriver(
+					lifecycleDriver({
+						graceSeconds,
+					}),
+				),
+			).toThrow(
+				`the lifecycle module declares a grace of ${graceSeconds} seconds — it must be a whole number from 1 to 600`,
+			);
+		}
+	});
+
+	it("refuses a stable line that is not a regular expression", () => {
+		expect(() =>
+			validateDriver(
+				lifecycleDriver({
+					stableLine: "logged in as",
+				}),
+			),
+		).toThrow("the lifecycle module declares a stable line that is not a regular expression");
+	});
+
 	it("accepts each lifecycle subject the bridge names", () => {
 		for (const subject of Object.values(BridgeLifecycleSubject)) {
 			expect(() =>

package/src/runtime/bridgeDriver.ts

@@ -62,6 +62,10 @@ const READY_TIMEOUT_MIN_SECONDS = 1;
 
 const READY_TIMEOUT_MAX_SECONDS = 3600;
 
+const GRACE_MIN_SECONDS = 1;
+
+const GRACE_MAX_SECONDS = 600;
+
 const RESERVED_MODULE_IDS = new Set([
 	"announce",
 	"backup",
@@ -635,6 +639,27 @@ const validateLifecycle = (driver: BridgeDriver) => {
 		);
 	}
 
+	const graceSeconds: unknown = driver.lifecycle.graceSeconds;
+
+	if (
+		graceSeconds !== undefined
+		&& !(
+			Number.isInteger(graceSeconds)
+			&& (graceSeconds as number) >= GRACE_MIN_SECONDS
+			&& (graceSeconds as number) <= GRACE_MAX_SECONDS
+		)
+	) {
+		fail(
+			`the lifecycle module declares a grace of ${String(graceSeconds)} seconds — it must be a whole number from ${GRACE_MIN_SECONDS} to ${GRACE_MAX_SECONDS}`,
+		);
+	}
+
+	const stableLine: unknown = driver.lifecycle.stableLine;
+
+	if (stableLine !== undefined && !(stableLine instanceof RegExp)) {
+		fail("the lifecycle module declares a stable line that is not a regular expression");
+	}
+
 	const subject: unknown = driver.lifecycle.subject;
 
 	if (subject !== undefined && !isBridgeLifecycleSubject(subject)) {

package/src/runtime/bridgeEvents.ts

@@ -111,6 +111,8 @@ export const createEventRing = (events: BridgeEventsModule | undefined, supervis
 			push(BridgeEventName.ServerCrashed, payload);
 
 			evidence.clear();
+
+			return cause;
 		},
 
 		discard() {

package/src/runtime/bridgeRegistry.test.ts

@@ -550,6 +550,38 @@ describe("preview modules", () => {
 		});
 	});
 
+	it("passes a blocked preview through untouched", async () => {
+		const registry = registryFor({
+			...baseDriver(),
+			modules: {
+				transition: {
+					kind: BridgeKind.Preview,
+					preview: async () => ({
+						confirm: BridgeConfirm.Strong,
+						blocked: true,
+						lines: [
+							{
+								ar: "لا يوجد بيلد مستقر لهذا الإصدار بعد",
+								en: "There is no stable build for this version yet",
+							},
+						],
+					}),
+				},
+			},
+		});
+
+		expect((await registry.invoke("transition", BridgeAction.Preview)).result).toEqual({
+			confirm: BridgeConfirm.Strong,
+			blocked: true,
+			lines: [
+				{
+					ar: "لا يوجد بيلد مستقر لهذا الإصدار بعد",
+					en: "There is no stable build for this version yet",
+				},
+			],
+		});
+	});
+
 	it("refuses an action a preview module does not answer", async () => {
 		const registry = registryFor({
 			...baseDriver(),

package/src/runtime/bridgeSupervisor.test.ts

@@ -1,12 +1,14 @@
 import { afterEach, beforeEach, describe, expect, it, spyOn } from "bun:test";
 import { tmpdir } from "node:os";
-import { BridgeRuntime } from "../core";
+import { BOT_CRASH_EVIDENCE, LOGIN_LINE } from "../bot";
+import { BridgeKind, BridgeRuntime } from "../core";
 import { BridgeLifecycleSubject, BridgeStopSignal } from "../modules";
-import { BridgeCrashPhase, type BridgeCrashRecord } from "../protocol";
+import { BridgeCrashCause, BridgeCrashPhase, type BridgeCrashRecord } from "../protocol";
+import { createEventRing } from "./bridgeEvents";
 import type { BridgeLeveledLogger } from "./bridgeLog";
 import { createBridgeRedaction, REDACTED } from "./bridgeRedaction";
 import { readProcessGroup } from "./bridgeSignal";
-import { type BridgeSupervisor, createSupervisor } from "./bridgeSupervisor";
+import { type BridgeSupervisor, createSupervisor, type SupervisorOptions } from "./bridgeSupervisor";
 
 const CHILD_PATTERN = /child=(?<pid>\d+)/;
 
@@ -1277,3 +1279,161 @@ describe("the lifecycle subject", () => {
 		await expect(supervisor.start()).rejects.toThrow('the bot environment names "BAD-KEY"');
 	});
 });
+
+const GRACE_SECONDS = 1;
+
+const READY_THEN_ALIVE = "echo ready; exec sleep 300";
+
+const READY_THEN_LOGIN = "echo ready; sleep 0.2; echo 'Logged in as serverk-bot#0001'; exec sleep 300";
+
+const READY_THEN_TOKEN_CRASH =
+	"echo ready; sleep 0.3; echo 'Error [TokenInvalid]: An invalid token was provided.' >&2; exit 1";
+
+const graceSupervisor = (script: string, grace: Partial<Pick<SupervisorOptions, "graceSeconds" | "stableLine">>) => {
+	const records: BridgeCrashRecord[] = [];
+	const causes: BridgeCrashCause[] = [];
+
+	let stables = 0;
+
+	const supervisor: BridgeSupervisor = createSupervisor({
+		cwd: tmpdir(),
+		uid: process.getuid?.() ?? 0,
+		gid: process.getgid?.() ?? 0,
+		stopTimeoutSeconds: 1,
+		ready: READY,
+		...grace,
+		onLog: silent,
+		resolveCommand: async () => {
+			return [
+				"bash",
+				"-c",
+				script,
+			];
+		},
+		onReady() {
+			ring.discard();
+		},
+		onStable() {
+			stables += 1;
+		},
+		onExit(record) {
+			records.push(record);
+			causes.push(ring.crash(record));
+		},
+	});
+
+	const ring = createEventRing(
+		{
+			kind: BridgeKind.Events,
+			patterns: [
+				...BOT_CRASH_EVIDENCE,
+			],
+		},
+		supervisor,
+	);
+
+	return {
+		supervisor,
+		records,
+		causes,
+		stables: () => stables,
+	};
+};
+
+describe("the grace window", () => {
+	it("marks a driver from an older bridge that declares no grace stable at its ready line", async () => {
+		const { supervisor, stables } = graceSupervisor(READY_THEN_ALIVE, {});
+
+		await supervisor.start();
+
+		expect(await waitFor(() => stables() === 1, 5000)).toBe(true);
+		expect(supervisor.runtime).toBe(BridgeRuntime.Running);
+
+		await supervisor.stop();
+	}, 30_000);
+
+	it("holds a bot that printed no login line at booting until the grace passes", async () => {
+		const { supervisor, stables } = graceSupervisor(READY_THEN_ALIVE, {
+			graceSeconds: GRACE_SECONDS,
+			stableLine: LOGIN_LINE,
+		});
+
+		await supervisor.start();
+
+		expect(await waitFor(() => supervisor.runtime === BridgeRuntime.Running, 5000)).toBe(true);
+
+		await Bun.sleep(400);
+
+		expect(stables(), "the bot was stable before the grace passed").toBe(0);
+		expect(await waitFor(() => stables() === 1, 5000)).toBe(true);
+
+		await Bun.sleep(GRACE_SECONDS * 1000);
+
+		expect(stables(), "the bot was reported stable twice").toBe(1);
+
+		await supervisor.stop();
+	}, 30_000);
+
+	it("marks a bot stable at its login line, before the grace passes", async () => {
+		const { supervisor, stables } = graceSupervisor(READY_THEN_LOGIN, {
+			graceSeconds: 30,
+			stableLine: LOGIN_LINE,
+		});
+
+		await supervisor.start();
+
+		expect(await waitFor(() => stables() === 1, 5000)).toBe(true);
+
+		await supervisor.stop();
+	}, 30_000);
+
+	it("counts an exit inside the grace as a boot failure with the cause the bot printed", async () => {
+		const { supervisor, records, causes, stables } = graceSupervisor(READY_THEN_TOKEN_CRASH, {
+			graceSeconds: 30,
+			stableLine: LOGIN_LINE,
+		});
+
+		await supervisor.start();
+
+		expect(await waitFor(() => records.length > 0, 10_000)).toBe(true);
+		expect(records.at(0)?.phase).toBe(BridgeCrashPhase.Booting);
+		expect(records.at(0)?.restarting).toBe(false);
+		expect(causes).toEqual([
+			BridgeCrashCause.TokenInvalid,
+		]);
+		expect(stables()).toBe(0);
+		expect(supervisor.runtime).toBe(BridgeRuntime.Crashed);
+	}, 30_000);
+
+	it("forgets what the install printed once the launcher hands over, so only the bot's own lines name the cause", async () => {
+		const { supervisor, records, causes } = graceSupervisor(
+			"echo 'gyp ERR! stack Error: not found: make'; echo ready; sleep 0.3; exit 1",
+			{
+				graceSeconds: 30,
+				stableLine: LOGIN_LINE,
+			},
+		);
+
+		await supervisor.start();
+
+		expect(await waitFor(() => records.length > 0, 10_000)).toBe(true);
+		expect(records.at(0)?.phase).toBe(BridgeCrashPhase.Booting);
+		expect(causes).toEqual([
+			BridgeCrashCause.Unknown,
+		]);
+	}, 30_000);
+
+	it("restarts the same exit when it comes after the grace", async () => {
+		const { supervisor, records } = graceSupervisor("echo ready; sleep 0.5; exit 1", {
+			graceSeconds: 0.2,
+		});
+
+		await supervisor.start();
+
+		expect(await waitFor(() => records.length > 0, 10_000)).toBe(true);
+		expect(records.at(0)?.phase).toBe(BridgeCrashPhase.Running);
+		expect(records.at(0)?.restarting).toBe(true);
+
+		await supervisor.stop();
+	}, 30_000);
+});

package/src/runtime/bridgeSupervisor.ts

@@ -46,6 +46,8 @@ export interface SupervisorOptions {
 	subject?: BridgeLifecycleSubject;
 	ready?: RegExp;
 	failed?: RegExp;
+	graceSeconds?: number;
+	stableLine?: RegExp;
 	resolveCommand: () => Promise<string[]>;
 	resolveEnvironment?: () => Promise<Record<string, string>>;
 	redact?: (text: string) => string;
@@ -208,6 +210,11 @@ export const createSupervisor = (options: SupervisorOptions) => {
 
 	const readyTimeoutMs = (options.readyTimeoutSeconds ?? options.stopTimeoutSeconds * READY_TIMEOUT_STOP_FACTOR) * 1000;
 
+	const graceMs =
+		options.graceSeconds === undefined ? (options.stableAfterMs ?? STABLE_UPTIME_MS) : options.graceSeconds * 1000;
+
+	const deferred = options.graceSeconds !== undefined || options.stableLine !== undefined;
+
 	const awaitingReady = () => {
 		return options.readyTimeoutSeconds !== undefined && runtime === BridgeRuntime.Starting;
 	};
@@ -241,6 +248,36 @@ export const createSupervisor = (options: SupervisorOptions) => {
 		options.onStable?.();
 	};
 
+	const settle = (launchStamp: number) => {
+		if (!deferred) {
+			markStable();
+
+			return;
+		}
+
+		const current = () => launchStamp === launchedAt && child !== null;
+
+		if (stableTimer) {
+			clearTimeout(stableTimer);
+		}
+
+		stableTimer = setTimeout(() => {
+			if (current()) {
+				markStable();
+			}
+		}, graceMs);
+
+		if (!options.stableLine) {
+			return;
+		}
+
+		void watch(options.stableLine, graceMs).then((match) => {
+			if (match && current()) {
+				markStable();
+			}
+		});
+	};
+
 	const emit = (raw: SupervisorLine) => {
 		const entry = options.redact
 			? {
@@ -491,6 +528,10 @@ export const createSupervisor = (options: SupervisorOptions) => {
 		if (!options.ready) {
 			runtime = BridgeRuntime.Running;
 
+			if (deferred) {
+				settle(launchStamp);
+			}
+
 			return;
 		}
 
@@ -509,7 +550,7 @@ export const createSupervisor = (options: SupervisorOptions) => {
 					options.onReady?.();
 				}
 
-				markStable();
+				settle(launchStamp);
 
 				return;
 			}