@gajae-code/coding-agent 0.16.7 → 0.17.1

package/src/cli/doctor/files.ts

@@ -0,0 +1,149 @@
+import type { Stats } from "node:fs";
+import { constants } from "node:fs";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { NativeExactFileIdentity } from "@gajae-code/natives";
+
+export const DOCTOR_FILE_LIMIT = 1024 * 1024;
+
+export interface DoctorFileIdentity {
+	readonly device: number;
+	readonly inode: number;
+	readonly size: number;
+	readonly modifiedMs: number;
+	readonly changedMs: number;
+	readonly mode: number;
+	readonly owner: number;
+	readonly links: number;
+}
+
+export type DoctorFileObservation =
+	| {
+			readonly status: "read";
+			readonly text: string;
+			readonly identity: DoctorFileIdentity;
+			/** Private commit authority, never serialized into the public diagnostic report. */
+			readonly exactIdentity: NativeExactFileIdentity;
+	  }
+	| {
+			readonly status: "missing" | "unreadable" | "symlink" | "not_regular" | "limit_exceeded" | "changed";
+			readonly errno?: string;
+	  };
+
+const SAFE_ERRNOS = new Set([
+	"ENOENT",
+	"EACCES",
+	"EPERM",
+	"EISDIR",
+	"ENOTDIR",
+	"ELOOP",
+	"EMFILE",
+	"ENFILE",
+	"EIO",
+	"ESTALE",
+	"EINVAL",
+	"ENOSPC",
+	"EROFS",
+	"EBUSY",
+]);
+
+export function doctorErrno(error: unknown): string {
+	if (typeof error !== "object" || error === null || !("code" in error)) return "unknown_io_error";
+	return typeof error.code === "string" && SAFE_ERRNOS.has(error.code) ? error.code : "unknown_io_error";
+}
+
+function identity(stat: Stats): DoctorFileIdentity {
+	return {
+		device: stat.dev,
+		inode: stat.ino,
+		size: stat.size,
+		modifiedMs: stat.mtimeMs,
+		changedMs: stat.ctimeMs,
+		mode: stat.mode,
+		owner: stat.uid,
+		links: stat.nlink,
+	};
+}
+
+export function sameDoctorFile(left: DoctorFileIdentity, right: DoctorFileIdentity): boolean {
+	return (
+		left.device === right.device &&
+		left.inode === right.inode &&
+		left.size === right.size &&
+		left.modifiedMs === right.modifiedMs &&
+		left.changedMs === right.changedMs &&
+		left.mode === right.mode &&
+		left.owner === right.owner &&
+		left.links === right.links
+	);
+}
+
+/** Read one bounded regular file; absence is never inferred from access failure. */
+export async function readDoctorFile(filePath: string, limit = DOCTOR_FILE_LIMIT): Promise<DoctorFileObservation> {
+	let handle: fs.FileHandle | undefined;
+	try {
+		const before = await fs.lstat(filePath);
+		if (before.isSymbolicLink()) return { status: "symlink" };
+		if (!before.isFile()) return { status: "not_regular" };
+		if (before.size > limit) return { status: "limit_exceeded" };
+		handle = await fs.open(filePath, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+		const opened = await handle.stat();
+		const openedExact = await handle.stat({ bigint: true });
+		const parent = await fs.lstat(path.dirname(filePath), { bigint: true });
+		if (parent.isSymbolicLink() || !parent.isDirectory()) return { status: "symlink" };
+		if (!opened.isFile() || !sameDoctorFile(identity(before), identity(opened))) return { status: "changed" };
+		// Read at most one byte past the bound, including when a concurrent writer grows the file.
+		const bytes = new Uint8Array(limit + 1);
+		let length = 0;
+		while (length < bytes.length) {
+			const result = await handle.read(bytes, length, bytes.length - length, length);
+			if (result.bytesRead === 0) break;
+			length += result.bytesRead;
+		}
+		if (length > limit) return { status: "limit_exceeded" };
+		const after = await handle.stat();
+		const afterExact = await handle.stat({ bigint: true });
+		const lexical = await fs.lstat(filePath);
+		const parentAfter = await fs.lstat(path.dirname(filePath), { bigint: true });
+		if (
+			lexical.isSymbolicLink() ||
+			parentAfter.isSymbolicLink() ||
+			parent.dev !== parentAfter.dev ||
+			parent.ino !== parentAfter.ino ||
+			openedExact.dev !== afterExact.dev ||
+			openedExact.ino !== afterExact.ino ||
+			openedExact.mtimeNs !== afterExact.mtimeNs ||
+			openedExact.ctimeNs !== afterExact.ctimeNs ||
+			!sameDoctorFile(identity(opened), identity(after)) ||
+			!sameDoctorFile(identity(after), identity(lexical))
+		)
+			return { status: "changed" };
+		const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, length));
+		return {
+			status: "read",
+			text,
+			identity: identity(after),
+			exactIdentity: {
+				dev: afterExact.dev,
+				ino: afterExact.ino,
+				nlink: afterExact.nlink,
+				size: afterExact.size,
+				mtimeNs: afterExact.mtimeNs,
+				parentDev: parent.dev,
+				parentIno: parent.ino,
+				sha256: new Bun.CryptoHasher("sha256").update(bytes.subarray(0, length)).digest("hex"),
+			},
+		};
+	} catch (error) {
+		const errno = doctorErrno(error);
+		return { status: errno === "ENOENT" ? "missing" : "unreadable", errno };
+	} finally {
+		await handle?.close();
+	}
+}
+
+export function doctorMapping(value: unknown): Record<string, unknown> | undefined {
+	return value !== null && typeof value === "object" && !Array.isArray(value)
+		? (value as Record<string, unknown>)
+		: undefined;
+}

package/src/cli/doctor/ids.ts

@@ -0,0 +1,115 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { DoctorScope } from "./types";
+
+export type RootKind = "config-user" | "config-project" | "agent" | "install";
+export interface ResolvedRoot {
+	readonly kind: RootKind;
+	readonly locator: string;
+	readonly rootId: string;
+	readonly resolution: "resolved" | "resolution_unknown";
+}
+
+export function canonicalDigest(parts: readonly string[]): string {
+	return createHash("sha256")
+		.update(JSON.stringify(["gjc-doctor-logical-id-v1", ...parts]))
+		.digest("hex");
+}
+function rootToken(rootId: string): string {
+	if (!/^r[0-9a-f]{64}$/.test(rootId))
+		throw new TypeError("rootId must be r followed by 64 lowercase hexadecimal characters");
+	return rootId;
+}
+export function resolveDoctorRoot(kind: RootKind, locator: string): ResolvedRoot {
+	const absolute = path.resolve(locator);
+	let current = absolute;
+	let resolution: ResolvedRoot["resolution"] = "resolved";
+	const missing: string[] = [];
+	try {
+		while (true) {
+			try {
+				fs.lstatSync(current);
+				break;
+			} catch (error) {
+				if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+					resolution = "resolution_unknown";
+					break;
+				}
+				const parent = path.dirname(current);
+				if (parent === current) {
+					resolution = "resolution_unknown";
+					break;
+				}
+				missing.unshift(path.basename(current));
+				current = parent;
+			}
+		}
+		if (resolution === "resolved") current = path.join(fs.realpathSync.native(current), ...missing);
+	} catch {
+		resolution = "resolution_unknown";
+	}
+	const normalizedCurrent = process.platform === "win32" ? current.replaceAll("\\", "/").toLowerCase() : current;
+	const normalizedAbsolute = process.platform === "win32" ? absolute.replaceAll("\\", "/").toLowerCase() : absolute;
+	const normalized = resolution === "resolved" ? normalizedCurrent : normalizedAbsolute;
+	return { kind, locator: normalized, rootId: `r${canonicalDigest([kind, normalized])}`, resolution };
+}
+export function configTargetId(rootId: string, scope: DoctorScope, schemaKey: string): string {
+	if (schemaKey !== "skills.enabled" && schemaKey !== "skills.enableSkillCommands")
+		throw new RangeError(`unsupported schema key: ${schemaKey}`);
+	return `t1:config:${rootToken(rootId)}:${scope}:${schemaKey}`;
+}
+export function mcpTargetId(
+	rootId: string,
+	scope: DoctorScope,
+	serverLogicalName: string,
+	field: "autoload" | "enabled",
+): string {
+	return `t1:mcp:${rootToken(rootId)}:${scope}:n${canonicalDigest([serverLogicalName])}:${field}`;
+}
+export function permissionTargetId(rootId: string): string {
+	return `t1:permission:${rootToken(rootId)}:user:config-yml`;
+}
+export function binaryTargetId(rootId: string, locator: string): string {
+	return `t1:binary:${rootToken(rootId)}:standalone:p${canonicalDigest([locator])}`;
+}
+export function linkTargetId(rootId: string, linkName: string): string {
+	return `t1:link:${rootToken(rootId)}:p${canonicalDigest([linkName])}`;
+}
+export function pluginTargetId(
+	rootId: string,
+	family: "gjc" | "npm" | "marketplace",
+	scope: DoctorScope,
+	name: string,
+): string {
+	return `t1:plugin:${rootToken(rootId)}:${family}:${scope}:n${canonicalDigest([name])}`;
+}
+export function serviceTargetId(rootId: string, service: "broker" | "telegram" | "discord" | "slack"): string {
+	return `t1:service:${rootToken(rootId)}:${service}`;
+}
+export function artifactTargetId(
+	rootId: string,
+	service: "broker" | "telegram" | "discord" | "slack",
+	slot: "discovery" | "owner-lock" | "startup-marker",
+): string {
+	return `t1:artifact:${rootToken(rootId)}:${service}:${slot}`;
+}
+export function candidateLinkId(rootId: string, kind: "source" | "wrapper" | "binary", locator: string): string {
+	return `c1:link:${rootToken(rootId)}:${kind}:p${canonicalDigest([locator])}`;
+}
+export function isDoctorTargetId(value: string): boolean {
+	const digest = "[0-9a-f]{64}";
+	const root = `r${digest}`;
+	return (
+		new RegExp(`^t1:config:${root}:(user|project):(skills\\.(enabled|enableSkillCommands))$`).test(value) ||
+		new RegExp(`^t1:mcp:${root}:(user|project):n${digest}:(autoload|enabled)$`).test(value) ||
+		new RegExp(`^t1:permission:${root}:user:config-yml$`).test(value) ||
+		new RegExp(`^t1:binary:${root}:standalone:p${digest}$`).test(value) ||
+		new RegExp(`^t1:link:${root}:p${digest}$`).test(value) ||
+		new RegExp(`^t1:plugin:${root}:(gjc|npm|marketplace):(user|project):n${digest}$`).test(value) ||
+		new RegExp(`^t1:service:${root}:(broker|telegram|discord|slack)$`).test(value) ||
+		new RegExp(`^t1:artifact:${root}:(broker|telegram|discord|slack):(discovery|owner-lock|startup-marker)$`).test(
+			value,
+		)
+	);
+}

package/src/cli/doctor/install-repairs.ts

@@ -0,0 +1,335 @@
+/**
+ * `install.restore-binary` (D4) domain logic: read-only descriptor plus the
+ * bounded standalone-binary restore transaction.
+ *
+ * All mutation flows through the shared `install-activation.ts` authority so
+ * `gjc doctor` and `gjc update` never maintain competing activation state:
+ * this module never calls the native `exactReplaceRetained` primitive
+ * directly, it only builds/writes the v1 record and then delegates the
+ * actual promotion (and every retry of an interrupted one) to
+ * `reconcileActivationRecord`.
+ */
+
+import { randomUUID } from "node:crypto";
+import { realpathSync } from "node:fs";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { isCompiledBinary, VERSION } from "@gajae-code/utils";
+import { isUpdateChannel } from "../../config/update-channel";
+import {
+	activationRecordPath,
+	type DirectoryIdentity,
+	type FileIdentity,
+	readActivationRecord,
+	sameDirectoryIdentity,
+	sameFileIdentity,
+	snapshotDirectory,
+	snapshotRegularFile,
+} from "../install-activation";
+import {
+	acquireBinaryUpdateLock,
+	fetchAndVerifyOfficialPinnedCandidate,
+	isProtectedSourcePathForInstall,
+	replaceBinaryForUpdate,
+	smokeTestPinnedCandidate,
+} from "../update-cli";
+
+export type InstallSourceKind = "standalone" | "source" | "npm-wrapper" | "unknown";
+
+/**
+ * The trust anchor for "this target is the exact binary the current process
+ * was dispatched from": a real ELF/PE/Mach-O header on disk proves nothing
+ * about ownership by itself. Only the currently-running compiled image's own
+ * resolved path counts. Injectable so tests can simulate a compiled dispatch
+ * without spawning a real binary.
+ */
+export interface InstallDispatchAuthority {
+	readonly compiled: boolean;
+	/** Realpath of the currently dispatched compiled image (process.execPath). */
+	readonly selfPath: string;
+	readonly version: string;
+}
+
+export function currentInstallDispatchAuthority(): InstallDispatchAuthority {
+	let selfPath: string;
+	try {
+		selfPath = realpathSync(process.execPath);
+	} catch {
+		selfPath = path.resolve(process.execPath);
+	}
+	return { compiled: isCompiledBinary(), selfPath, version: VERSION };
+}
+
+export interface InstallRestoreDescriptorV1 {
+	readonly schemaVersion: 1;
+	readonly kind: "install.restore-binary";
+	readonly targetPath: string;
+	readonly channel: string;
+	readonly version: string;
+	readonly ref?: string;
+	readonly owned: boolean;
+	readonly sourceKind: InstallSourceKind;
+	readonly targetIdentity?: FileIdentity;
+	readonly parentIdentity?: DirectoryIdentity;
+	readonly targetDigest?: string;
+	readonly platform: NodeJS.Platform;
+	readonly arch: string;
+	readonly writes: false;
+	readonly fetch: false;
+	readonly execute: false;
+}
+
+export interface RestoreCandidate {
+	readonly ref: string;
+	readonly channel: string;
+	readonly sha256: string;
+	readonly version: string;
+	readonly os: NodeJS.Platform;
+	readonly arch: string;
+}
+
+export interface InstallRepairDependencies {
+	readonly fetchCandidate: (candidate: RestoreCandidate, stagingPath: string) => Promise<void>;
+	readonly verifyCandidate: (stagingPath: string, candidate: RestoreCandidate) => Promise<void>;
+	readonly smokeCandidate: (stagingPath: string, candidate: RestoreCandidate) => Promise<void>;
+}
+
+const DEFAULT_INSTALL_REPAIR_DEPENDENCIES: InstallRepairDependencies = {
+	fetchCandidate: fetchAndVerifyOfficialPinnedCandidate,
+	verifyCandidate: async (stagingPath, candidate) => {
+		const snapshot = await snapshotRegularFile(stagingPath);
+		if (!snapshot || snapshot.identity.sha256.toLowerCase() !== candidate.sha256.toLowerCase())
+			throw new Error("candidate_digest_mismatch");
+	},
+	smokeCandidate: (stagingPath, candidate) => smokeTestPinnedCandidate(candidate, stagingPath),
+};
+
+export type InstallRepairState = "verified" | "not_needed" | "pending_activation" | "blocked" | "conflict" | "failed";
+
+export interface InstallRepairResult {
+	readonly state: InstallRepairState;
+	readonly reason?: string;
+	readonly recordPath?: string;
+	readonly sideEffectStarted: boolean;
+	/** Present only for a pre-mutation Windows sharing violation (nothing was renamed). */
+	readonly windowsErrorCode?: string;
+	readonly before?: { readonly identity?: FileIdentity; readonly digest?: string };
+	readonly after?: { readonly identity?: FileIdentity; readonly digest?: string; readonly version?: string };
+}
+
+function isNpmWrapper(targetPath: string): boolean {
+	return (
+		/\.(cmd|ps1)$/i.test(targetPath) &&
+		path
+			.basename(targetPath)
+			.replace(/\.(cmd|ps1)$/i, "")
+			.toLowerCase() === "gjc"
+	);
+}
+
+async function classifySource(
+	targetPath: string,
+	authority: InstallDispatchAuthority,
+	targetSnapshotOk: boolean,
+): Promise<InstallSourceKind> {
+	if (isNpmWrapper(targetPath)) return "npm-wrapper";
+	if (isProtectedSourcePathForInstall(targetPath)) return "source";
+	if (!authority.compiled || !targetSnapshotOk) return "unknown";
+	try {
+		const real = await fs.realpath(path.resolve(targetPath));
+		return real === authority.selfPath ? "standalone" : "unknown";
+	} catch {
+		return "unknown";
+	}
+}
+
+/**
+ * Read-only restore preview. Never writes, fetches, or executes anything.
+ * Tolerant of any on-disk state: a missing/symlinked/foreign target reports
+ * `sourceKind: "unknown"` with `owned: false` rather than throwing, since a
+ * dry-run/diagnostic descriptor must never fail on account of the very
+ * conditions it exists to report.
+ */
+export async function describeInstallRestore(
+	targetPath: string,
+	authority: InstallDispatchAuthority = currentInstallDispatchAuthority(),
+	channel = "stable",
+	ref?: string,
+): Promise<InstallRestoreDescriptorV1> {
+	const resolvedTarget = path.resolve(targetPath);
+	let targetSnapshot: { readonly header: Uint8Array; readonly identity: FileIdentity } | undefined;
+	try {
+		targetSnapshot = await snapshotRegularFile(resolvedTarget);
+	} catch {
+		targetSnapshot = undefined;
+	}
+	let parentIdentity: DirectoryIdentity | undefined;
+	try {
+		parentIdentity = await snapshotDirectory(path.dirname(resolvedTarget));
+	} catch {
+		parentIdentity = undefined;
+	}
+	const sourceKind = await classifySource(resolvedTarget, authority, targetSnapshot !== undefined);
+	return {
+		schemaVersion: 1,
+		kind: "install.restore-binary",
+		targetPath: resolvedTarget,
+		channel,
+		version: authority.version,
+		...(ref ? { ref } : {}),
+		owned: sourceKind === "standalone",
+		sourceKind,
+		targetIdentity: targetSnapshot?.identity,
+		parentIdentity,
+		targetDigest: targetSnapshot?.identity.sha256,
+		platform: process.platform,
+		arch: process.arch,
+		writes: false,
+		fetch: false,
+		execute: false,
+	};
+}
+
+/**
+ * Repair a proven-standalone target by staging, verifying, and promoting a
+ * pinned candidate through the shared activation authority.
+ *
+ * An unresolved transaction is resumed only for the identical explicit pin.
+ * Both fresh and resumed publication use the normal updater's mandatory
+ * installed verification and identity-bound compensation; no second candidate
+ * is activated implicitly.
+ */
+export async function repairStandaloneBinary(
+	targetPath: string,
+	descriptor: InstallRestoreDescriptorV1,
+	candidate: RestoreCandidate,
+	authorizations: readonly string[],
+	deps: InstallRepairDependencies = DEFAULT_INSTALL_REPAIR_DEPENDENCIES,
+): Promise<InstallRepairResult> {
+	const before = { identity: descriptor.targetIdentity, digest: descriptor.targetDigest };
+	const recordPath = activationRecordPath(targetPath);
+	const blocked = (reason: string): InstallRepairResult => ({
+		state: "blocked",
+		reason,
+		sideEffectStarted: false,
+		before,
+		recordPath,
+	});
+	if (
+		!authorizations.includes("install-replace") ||
+		!authorizations.includes("network") ||
+		!authorizations.includes("external-execution")
+	)
+		return blocked("authorization_missing");
+	if (!isUpdateChannel(candidate.channel) || candidate.os !== process.platform || candidate.arch !== process.arch)
+		return blocked("candidate_platform_or_channel_mismatch");
+	if (!/^[a-f0-9]{64}$/i.test(candidate.sha256)) return blocked("candidate_digest_invalid");
+	if (
+		!descriptor.owned ||
+		descriptor.sourceKind !== "standalone" ||
+		descriptor.targetPath !== path.resolve(targetPath)
+	)
+		return blocked("source_not_owned_standalone");
+	if (
+		candidate.version !== descriptor.version ||
+		candidate.channel !== descriptor.channel ||
+		(descriptor.ref && candidate.ref !== descriptor.ref)
+	)
+		return blocked("candidate_provenance_mismatch");
+	if (!descriptor.targetIdentity || !descriptor.parentIdentity || !descriptor.targetDigest)
+		return blocked("original_snapshot_incomplete");
+	const current = await snapshotRegularFile(targetPath);
+	const parent = await snapshotDirectory(path.dirname(path.resolve(targetPath)));
+	if (
+		!current ||
+		!sameFileIdentity(current.identity, descriptor.targetIdentity) ||
+		!sameDirectoryIdentity(parent, descriptor.parentIdentity)
+	)
+		return { ...blocked("target_or_parent_changed"), state: "conflict" };
+	const observedRecord = await readActivationRecord(targetPath);
+	if (observedRecord.status === "malformed" || observedRecord.status === "foreign")
+		return blocked("activation_record_untrusted");
+	const pending =
+		observedRecord.status === "valid" &&
+		observedRecord.record.phase !== "verified" &&
+		observedRecord.record.phase !== "rolled_back";
+	if (!pending && descriptor.targetDigest === candidate.sha256.toLowerCase())
+		return {
+			state: "not_needed",
+			sideEffectStarted: false,
+			before,
+			after: { identity: current.identity, digest: current.identity.sha256, version: candidate.version },
+			recordPath,
+		};
+	if (
+		pending &&
+		observedRecord.status === "valid" &&
+		(observedRecord.record.candidate.digest !== candidate.sha256.toLowerCase() ||
+			observedRecord.record.candidate.version !== candidate.version ||
+			observedRecord.record.candidate.ref !== candidate.ref ||
+			observedRecord.record.candidate.channel !== candidate.channel)
+	)
+		return blocked("candidate_provenance_mismatch");
+	const release = await acquireBinaryUpdateLock(targetPath);
+	let started = false;
+	try {
+		const rechecked = await snapshotRegularFile(targetPath);
+		const parentNow = await snapshotDirectory(path.dirname(path.resolve(targetPath)));
+		if (
+			!rechecked ||
+			!sameFileIdentity(rechecked.identity, descriptor.targetIdentity) ||
+			!sameDirectoryIdentity(parentNow, descriptor.parentIdentity)
+		)
+			return { ...blocked("target_or_parent_changed"), state: "conflict" };
+		const stagingPath =
+			pending && observedRecord.status === "valid"
+				? observedRecord.record.stagingPath
+				: `${path.resolve(targetPath)}.restore.${randomUUID()}`;
+		started = true;
+		if (!pending) await deps.fetchCandidate(candidate, stagingPath);
+		const verification = await replaceBinaryForUpdate({
+			targetPath,
+			tempPath: stagingPath,
+			backupPath: `${path.resolve(targetPath)}.restore-backup.${randomUUID()}`,
+			expectedVersion: candidate.version,
+			originalTarget: descriptor.targetIdentity,
+			originalParent: descriptor.parentIdentity,
+			candidate: { channel: candidate.channel, ref: candidate.ref, sha256: candidate.sha256.toLowerCase() },
+			verifyStagedVersion: async file => {
+				await deps.verifyCandidate(file, candidate);
+				await deps.smokeCandidate(file, candidate);
+			},
+			verifyInstalledVersion: async version => {
+				await deps.verifyCandidate(targetPath, candidate);
+				await deps.smokeCandidate(targetPath, candidate);
+				return { ok: true, actual: version, path: targetPath };
+			},
+		});
+		const after = await snapshotRegularFile(targetPath);
+		if (!verification.ok || !after || after.identity.sha256 !== candidate.sha256.toLowerCase())
+			return { state: "failed", reason: "postcheck_failed", sideEffectStarted: true, before, recordPath };
+		return {
+			state: "verified",
+			sideEffectStarted: true,
+			before,
+			after: { identity: after.identity, digest: after.identity.sha256, version: candidate.version },
+			recordPath,
+		};
+	} catch (error) {
+		const pendingActivation = error instanceof Error && error.message === "installation_pending_activation";
+		const reason = pendingActivation
+			? "sharing_violation"
+			: error instanceof Error && /^[a-z][a-z0-9_]{0,63}$/.test(error.message)
+				? error.message
+				: "installation_execution_unverified";
+		return {
+			state: pendingActivation ? "pending_activation" : started ? "failed" : "blocked",
+			reason,
+			sideEffectStarted: started,
+			before,
+			recordPath,
+		};
+	} finally {
+		await release();
+	}
+}