@stim-cli/core 1.20.2 → 1.22.0

package/dist/noise.mjs

@@ -0,0 +1,393 @@
+import { createCipheriv, createDecipheriv, createHash, createHmac, createPrivateKey, createPublicKey, diffieHellman, generateKeyPairSync } from "node:crypto";
+//#region noise.ts
+const NOISE_XX = "Noise_XX_25519_ChaChaPoly_SHA256";
+const NOISE_XX_PSK2 = "Noise_XXpsk2_25519_ChaChaPoly_SHA256";
+/** Largest handshake message either side writes or reads, payload included. */
+const MAX_HANDSHAKE_MESSAGE_BYTES = 1024;
+const KEY_BYTES = 32;
+const HASH_BYTES = 32;
+const TAG_BYTES = 16;
+const MAX_NONCE = 2n ** 64n - 1n;
+const EMPTY = Buffer.alloc(0);
+const TEXT = 1;
+const BINARY = 2;
+const PKCS8_X25519 = Buffer.from("302e020100300506032b656e04220420", "hex");
+const SPKI_X25519 = Buffer.from("302a300506032b656e032100", "hex");
+/** Thrown for any handshake or transport failure; the handshake or transport is unusable afterwards. */
+var NoiseError = class extends Error {
+	name = "NoiseError";
+};
+function generateNoiseKeyPair() {
+	const { privateKey } = generateKeyPairSync("x25519");
+	return noiseKeyPairFromPrivateKey(privateKey.export({
+		format: "der",
+		type: "pkcs8"
+	}).subarray(-32));
+}
+function noiseKeyPairFromPrivateKey(privateKey) {
+	if (privateKey.length !== KEY_BYTES) throw new RangeError("An X25519 private key is 32 bytes");
+	const key = createPrivateKey({
+		key: Buffer.concat([PKCS8_X25519, privateKey]),
+		format: "der",
+		type: "pkcs8"
+	});
+	return {
+		publicKey: createPublicKey(key).export({
+			format: "der",
+			type: "spki"
+		}).subarray(-32),
+		privateKey: Buffer.from(privateKey)
+	};
+}
+const nodeDh = (privateKey, publicKey) => diffieHellman({
+	privateKey: createPrivateKey({
+		key: Buffer.concat([PKCS8_X25519, privateKey]),
+		format: "der",
+		type: "pkcs8"
+	}),
+	publicKey: createPublicKey({
+		key: Buffer.concat([SPKI_X25519, publicKey]),
+		format: "der",
+		type: "spki"
+	})
+});
+function nonceBytes(n) {
+	const nonce = Buffer.alloc(12);
+	nonce.writeBigUInt64LE(n, 4);
+	return nonce;
+}
+function aeadEncrypt(k, n, ad, plaintext) {
+	const cipher = createCipheriv("chacha20-poly1305", k, nonceBytes(n), { authTagLength: TAG_BYTES });
+	cipher.setAAD(ad, { plaintextLength: plaintext.length });
+	return Buffer.concat([
+		cipher.update(plaintext),
+		cipher.final(),
+		cipher.getAuthTag()
+	]);
+}
+function aeadDecrypt(k, n, ad, ciphertext) {
+	if (ciphertext.length < TAG_BYTES) throw new NoiseError("Message is shorter than its authentication tag");
+	const body = ciphertext.subarray(0, ciphertext.length - TAG_BYTES);
+	const decipher = createDecipheriv("chacha20-poly1305", k, nonceBytes(n), { authTagLength: TAG_BYTES });
+	decipher.setAAD(ad, { plaintextLength: body.length });
+	decipher.setAuthTag(ciphertext.subarray(ciphertext.length - TAG_BYTES));
+	try {
+		return Buffer.concat([decipher.update(body), decipher.final()]);
+	} catch {
+		throw new NoiseError("Message failed authentication");
+	}
+}
+function sha256(...parts) {
+	const hash = createHash("sha256");
+	for (const part of parts) hash.update(part);
+	return hash.digest();
+}
+function hmac(key, ...parts) {
+	const mac = createHmac("sha256", key);
+	for (const part of parts) mac.update(part);
+	return mac.digest();
+}
+function hkdf(chainingKey, input) {
+	const temp = hmac(chainingKey, input);
+	const first = hmac(temp, Uint8Array.of(1));
+	const second = hmac(temp, first, Uint8Array.of(2));
+	return [
+		first,
+		second,
+		hmac(temp, second, Uint8Array.of(3))
+	];
+}
+/** Noise's CipherState: a key and a 64-bit counter used as the nonce. */
+var CipherState = class {
+	#k;
+	#n = 0n;
+	constructor(key) {
+		if (key && key.length !== KEY_BYTES) throw new RangeError("A cipher key is 32 bytes");
+		this.#k = key && Buffer.from(key);
+	}
+	hasKey() {
+		return this.#k !== void 0;
+	}
+	setNonce(n) {
+		this.#n = n;
+	}
+	encryptWithAd(ad, plaintext) {
+		if (!this.#k) return Buffer.from(plaintext);
+		if (this.#n >= MAX_NONCE) throw new NoiseError("Nonce exhausted");
+		const ciphertext = aeadEncrypt(this.#k, this.#n, ad, plaintext);
+		this.#n++;
+		return ciphertext;
+	}
+	decryptWithAd(ad, ciphertext) {
+		if (!this.#k) return Buffer.from(ciphertext);
+		if (this.#n >= MAX_NONCE) throw new NoiseError("Nonce exhausted");
+		const plaintext = aeadDecrypt(this.#k, this.#n, ad, ciphertext);
+		this.#n++;
+		return plaintext;
+	}
+};
+var SymmetricState = class {
+	#ck;
+	#h;
+	cipher = new CipherState();
+	constructor(protocol) {
+		const name = Buffer.from(protocol, "ascii");
+		this.#h = name.length <= HASH_BYTES ? Buffer.concat([name, Buffer.alloc(HASH_BYTES - name.length)]) : sha256(name);
+		this.#ck = this.#h;
+	}
+	get handshakeHash() {
+		return Buffer.from(this.#h);
+	}
+	mixKey(input) {
+		const [ck, k] = hkdf(this.#ck, input);
+		this.#ck = ck;
+		this.cipher = new CipherState(k);
+	}
+	mixHash(data) {
+		this.#h = sha256(this.#h, data);
+	}
+	mixKeyAndHash(input) {
+		const [ck, h, k] = hkdf(this.#ck, input);
+		this.#ck = ck;
+		this.mixHash(h);
+		this.cipher = new CipherState(k);
+	}
+	encryptAndHash(plaintext) {
+		const ciphertext = this.cipher.encryptWithAd(this.#h, plaintext);
+		this.mixHash(ciphertext);
+		return ciphertext;
+	}
+	decryptAndHash(ciphertext) {
+		const plaintext = this.cipher.decryptWithAd(this.#h, ciphertext);
+		this.mixHash(ciphertext);
+		return plaintext;
+	}
+	split() {
+		const [first, second] = hkdf(this.#ck, EMPTY);
+		return [new CipherState(first), new CipherState(second)];
+	}
+};
+const PATTERNS = {
+	[NOISE_XX]: [
+		["e"],
+		[
+			"e",
+			"ee",
+			"s",
+			"es"
+		],
+		["s", "se"]
+	],
+	[NOISE_XX_PSK2]: [
+		["e"],
+		[
+			"e",
+			"ee",
+			"s",
+			"es",
+			"psk"
+		],
+		["s", "se"]
+	]
+};
+/**
+* Noise's HandshakeState for {@link NOISE_XX} and {@link NOISE_XX_PSK2}. The initiator writes messages 1 and 3. Any
+* error from {@link writeMessage} or {@link readMessage}, including an out-of-turn call, a call after the last
+* message, or an invalid or oversized message, ends the handshake: every later call throws {@link NoiseError}.
+*/
+var HandshakeState = class {
+	#symmetric;
+	#messages;
+	#initiator;
+	#s;
+	#psk;
+	#dh;
+	#e;
+	#re;
+	#rs;
+	#index = 0;
+	#failed = false;
+	#split = false;
+	constructor(options) {
+		if (options.protocol === "Noise_XXpsk2_25519_ChaChaPoly_SHA256" !== (options.psk !== void 0)) throw new TypeError(`${options.protocol} psk mismatch`);
+		if (options.psk && options.psk.length !== KEY_BYTES) throw new RangeError("A PSK is 32 bytes");
+		this.#symmetric = new SymmetricState(options.protocol);
+		this.#symmetric.mixHash(options.prologue);
+		this.#messages = PATTERNS[options.protocol];
+		this.#initiator = options.initiator;
+		this.#s = options.staticKeyPair;
+		this.#psk = options.psk && Buffer.from(options.psk);
+		this.#e = options.ephemeralKeyPair;
+		this.#dh = options.dh ?? nodeDh;
+	}
+	get isComplete() {
+		return this.#index === this.#messages.length;
+	}
+	/** The peer's static public key, once the message that carries it has been read and authenticated. */
+	get remoteStaticPublicKey() {
+		return this.#failed || !this.#rs ? void 0 : Buffer.from(this.#rs);
+	}
+	get handshakeHash() {
+		if (!this.isComplete) throw new NoiseError("The handshake is not complete");
+		return this.#symmetric.handshakeHash;
+	}
+	writeMessage(payload = EMPTY) {
+		return this.#step(true, (tokens) => {
+			const parts = [];
+			for (const token of tokens) if (token === "e") {
+				this.#e ??= generateNoiseKeyPair();
+				parts.push(this.#e.publicKey);
+				this.#mixEphemeral(this.#e.publicKey);
+			} else if (token === "s") parts.push(this.#symmetric.encryptAndHash(this.#s.publicKey));
+			else this.#mixToken(token);
+			parts.push(this.#symmetric.encryptAndHash(payload));
+			const message = Buffer.concat(parts);
+			if (message.length > 1024) throw new NoiseError("Handshake message is too large");
+			return message;
+		});
+	}
+	readMessage(message) {
+		return this.#step(false, (tokens) => {
+			if (message.length > 1024) throw new NoiseError("Handshake message is too large");
+			let offset = 0;
+			const take = (length) => {
+				if (message.length - offset < length) throw new NoiseError("Handshake message is truncated");
+				const part = Buffer.from(message.subarray(offset, offset + length));
+				offset += length;
+				return part;
+			};
+			for (const token of tokens) if (token === "e") {
+				this.#re = take(KEY_BYTES);
+				this.#mixEphemeral(this.#re);
+			} else if (token === "s") {
+				const length = KEY_BYTES + (this.#symmetric.cipher.hasKey() ? TAG_BYTES : 0);
+				this.#rs = this.#symmetric.decryptAndHash(take(length));
+			} else this.#mixToken(token);
+			return this.#symmetric.decryptAndHash(message.subarray(offset));
+		});
+	}
+	/** Noise's Split(), returning this side's sending and receiving cipher states. It can be called once. */
+	split() {
+		if (this.#failed || !this.isComplete) throw new NoiseError("The handshake is not complete");
+		if (this.#split) throw new NoiseError("The handshake has already been split");
+		this.#split = true;
+		const [initiatorToResponder, responderToInitiator] = this.#symmetric.split();
+		return this.#initiator ? {
+			send: initiatorToResponder,
+			receive: responderToInitiator
+		} : {
+			send: responderToInitiator,
+			receive: initiatorToResponder
+		};
+	}
+	#step(writing, run) {
+		if (this.#failed) throw new NoiseError("The handshake has failed");
+		try {
+			const tokens = this.#messages[this.#index];
+			if (!tokens) throw new NoiseError("The handshake is complete");
+			if (writing !== (this.#initiator === (this.#index % 2 === 0))) throw new NoiseError(`It is not this side's turn to ${writing ? "write" : "read"}`);
+			const result = run(tokens);
+			this.#index++;
+			return result;
+		} catch (error) {
+			this.#failed = true;
+			throw error instanceof NoiseError ? error : new NoiseError("Handshake failed", { cause: error });
+		}
+	}
+	#mixEphemeral(publicKey) {
+		this.#symmetric.mixHash(publicKey);
+		if (this.#psk) this.#symmetric.mixKey(publicKey);
+	}
+	#x25519(keyPair, publicKey) {
+		try {
+			return Buffer.from(this.#dh(keyPair.privateKey, publicKey));
+		} catch {
+			throw new NoiseError("X25519 failed; the peer sent an invalid public key");
+		}
+	}
+	#mixToken(token) {
+		if (token === "psk") {
+			if (!this.#psk) throw new NoiseError("Pattern needs a PSK");
+			this.#symmetric.mixKeyAndHash(this.#psk);
+			return;
+		}
+		const remote = (key) => {
+			if (!key) throw new NoiseError(`Token ${token} needs a remote key`);
+			return key;
+		};
+		const e = this.#e;
+		if (!e) throw new NoiseError(`Token ${token} needs an ephemeral key`);
+		if (token === "ee") this.#symmetric.mixKey(this.#x25519(e, remote(this.#re)));
+		else if (token === "es") this.#symmetric.mixKey(this.#initiator ? this.#x25519(e, remote(this.#rs)) : this.#x25519(this.#s, remote(this.#re)));
+		else this.#symmetric.mixKey(this.#initiator ? this.#x25519(this.#s, remote(this.#re)) : this.#x25519(e, remote(this.#rs)));
+	}
+};
+const utf8 = new TextDecoder("utf-8", {
+	fatal: true,
+	ignoreBOM: true
+});
+/**
+* Stim's transport framing after the handshake: each WebSocket message is one ChaCha20-Poly1305 message with empty
+* associated data under the next counter value. The first plaintext byte is the message type, 0x01 text or 0x02
+* binary. Counters are not sent, so a reordered, replayed, dropped or altered message fails to decrypt. Any decryption
+* failure closes the transport: every later call throws {@link NoiseError}. Nonce 2^64-1 is reserved and never used:
+* after a direction's last usable message, at counter 2^64-2, the next call in that direction closes the transport.
+*/
+var NoiseTransport = class {
+	#send;
+	#receive;
+	#maxSend;
+	#maxReceive;
+	#closed = false;
+	constructor(options) {
+		if (!options.send.hasKey() || !options.receive.hasKey()) throw new TypeError("Transport cipher states need keys");
+		this.#send = options.send;
+		this.#receive = options.receive;
+		this.#maxSend = options.maxSendBytes;
+		this.#maxReceive = options.maxReceiveBytes;
+	}
+	get closed() {
+		return this.#closed;
+	}
+	/**
+	* Encrypts a string as a text message or bytes as a binary message. Data over `maxSendBytes` (UTF-8 bytes for text)
+	* throws a `RangeError`, consumes no counter, and leaves the transport open: it is the caller's own error and nothing
+	* was sent.
+	*/
+	encrypt(data) {
+		this.#assertOpen();
+		const body = typeof data === "string" ? Buffer.from(data, "utf8") : data;
+		if (body.length > this.#maxSend) throw new RangeError(`Message exceeds ${this.#maxSend} bytes`);
+		try {
+			return this.#send.encryptWithAd(EMPTY, Buffer.concat([Uint8Array.of(typeof data === "string" ? TEXT : BINARY), body]));
+		} catch (error) {
+			this.#closed = true;
+			throw error;
+		}
+	}
+	decrypt(message) {
+		this.#assertOpen();
+		try {
+			if (message.length > this.#maxReceive + 1 + TAG_BYTES) throw new NoiseError("Message is too large");
+			const plaintext = this.#receive.decryptWithAd(EMPTY, message);
+			const body = plaintext.subarray(1);
+			if (plaintext[0] === TEXT) return {
+				type: "text",
+				data: utf8.decode(body)
+			};
+			if (plaintext[0] === BINARY) return {
+				type: "binary",
+				data: body
+			};
+			throw new NoiseError("Unknown message type");
+		} catch (error) {
+			this.#closed = true;
+			throw error instanceof NoiseError ? error : new NoiseError("Message is not valid", { cause: error });
+		}
+	}
+	#assertOpen() {
+		if (this.#closed) throw new NoiseError("The transport is closed");
+	}
+};
+//#endregion
+export { CipherState, HandshakeState, MAX_HANDSHAKE_MESSAGE_BYTES, NOISE_XX, NOISE_XX_PSK2, NoiseError, NoiseTransport, generateNoiseKeyPair, noiseKeyPairFromPrivateKey };

package/dist/oversight.mjs

@@ -389,12 +389,13 @@ function overseeMerge(run, { env, entry, notify }, prev) {
 * handles is left out. The allowance returns when the workspace stops being idle or has no item left.
 */
 function overseeAttention(run, { env, entry, notify }, prev) {
-	const items = workspaceItems(env, {
+	const { items, wakeAt } = workspaceAttention(env, {
 		now: run.now,
 		stuckMinutes: run.prefs.stuckMinutes,
 		easSessionMinutes: EAS_SESSION_MINUTES,
 		ownLeases: run.input.ownLeases
 	});
+	if (wakeAt !== null) wake(run, wakeAt);
 	const pending = [];
 	for (const item of items) {
 		if (item.category !== "attention") continue;
@@ -558,9 +559,10 @@ const SIGNING_CODES = [
 /** A failed run older than this on an idle workspace is history, not a problem. */
 const STALE_MS = 864e5;
 const recent = (env, at, now) => env.live || now - time(at) < 864e5;
-function workspaceItems(env, input, format = attentionBody) {
+function workspaceAttention(env, input, format = attentionBody) {
 	const { now } = input;
 	const items = [];
+	let wakeAt = null;
 	for (const issue of env.issues ?? []) {
 		if (issue.severity === "info" || !PERSON_ISSUES.has(issue.code)) continue;
 		items.push({
@@ -610,7 +612,9 @@ function workspaceItems(env, input, format = attentionBody) {
 		});
 	}
 	for (const device of env.physicalDevices ?? []) {
-		if (!(time(device.lease.expiresAt) <= now)) continue;
+		const expiresAt = time(device.lease.expiresAt);
+		if (expiresAt > now) wakeAt = Math.min(wakeAt ?? expiresAt, expiresAt);
+		if (!(expiresAt <= now)) continue;
 		const slot = device.slot === "default" ? "" : ` --slot ${device.slot}`;
 		items.push({
 			id: `lease-${device.platform}-${device.slot}:${env.path}`,
@@ -628,7 +632,10 @@ function workspaceItems(env, input, format = attentionBody) {
 	const driven = devices.find((d) => d.running && agentDriven(d, input.ownLeases ?? []));
 	for (const session of env.remoteDevices ?? []) {
 		const started = time(session.startedAt);
-		if (driven || !(now - started >= input.easSessionMinutes * 6e4)) continue;
+		const due = started + input.easSessionMinutes * 6e4;
+		if (driven) continue;
+		if (due > now) wakeAt = Math.min(wakeAt ?? due, due);
+		if (!(due <= now)) continue;
 		items.push({
 			id: `eas-${session.sessionId}:${env.path}`,
 			category: "attention",
@@ -659,7 +666,10 @@ function workspaceItems(env, input, format = attentionBody) {
 			remedy: null
 		});
 	}
-	return items;
+	return {
+		items,
+		wakeAt
+	};
 }
 const severityRank = (item) => item.severity === "error" ? 0 : 1;
 /**
@@ -683,7 +693,7 @@ function needsAttention(input, format = attentionBody) {
 			remedy: null
 		}
 	});
-	for (const env of input.environments) for (const item of workspaceItems(env, input, format)) ranked.push({
+	for (const env of input.environments) for (const item of workspaceAttention(env, input, format).items) ranked.push({
 		item,
 		scope: env.live ? 1 : 2
 	});

package/dist/{ownership-claim-O31Y5iIb.mjs → ownership-claim-DHUs_Dir.mjs}

@@ -659,4 +659,4 @@ function writeChild(handle, body) {
 	}
 }
 //#endregion
-export { quotedPath as S, releaseClaim as _, claimFailure as a, sharedClaimDir as b, clearClaimChild as c, inspectClaimSet as d, isClaimRefusal as f, readClaimSet as g, processGroupAlive as h, ClaimUnavailableError as i, clearFreeClaimSet as l, markClaimChildPending as m, CLAIM_UNAVAILABLE as n, claimLiveness as o, isClaimUnavailable as p, ClaimRefusedError as r, claimRemoveCommand as s, CLAIM_REFUSED as t, exclusiveClaimDir as u, setClaimChild as v, tryAcquireClaim as x, settleClaim as y };
+export { quotedPath as C, tryAcquireClaim as S, releaseClaim as _, claimFailure as a, sharedClaimDir as b, clearClaimChild as c, inspectClaimSet as d, isClaimRefusal as f, readClaimSet as g, processGroupAlive as h, ClaimUnavailableError as i, clearFreeClaimSet as l, markClaimChildPending as m, CLAIM_UNAVAILABLE as n, claimLiveness as o, isClaimUnavailable as p, ClaimRefusedError as r, claimRemoveCommand as s, CLAIM_REFUSED as t, exclusiveClaimDir as u, setClaimChild as v, sleepSync as x, settleClaim as y };

package/dist/{ownership-claim-Xxxr9MPp.d.mts → ownership-claim-RY3fbm1D.d.mts}

@@ -1,4 +1,4 @@
-import { r as ProcessRecord } from "./process-identity-BTyww2Xj.mjs";
+import { r as ProcessRecord } from "./process-identity-DVNGpF5c.mjs";
 //#region ownership-claim.d.ts
 type ClaimMode = "exclusive" | "shared";
 interface ClaimDetails {
@@ -96,6 +96,7 @@ interface ClaimFailure {
 declare function claimFailure(err: unknown, retryCommand: string | null): ClaimFailure | null;
 declare function exclusiveClaimDir(root: string): string;
 declare function sharedClaimDir(root: string): string;
+declare function sleepSync(ms: number): void;
 /**
  * Whether any member of the process group `pid` leads is alive. A recorded child is resolved through
  * its group rather than through the one process, so a package manager's postinstall descendant keeps
@@ -149,4 +150,4 @@ declare function markClaimChildPending(handle: ClaimHandle): void;
 declare function setClaimChild(handle: ClaimHandle, record: ProcessRecord): void;
 declare function clearClaimChild(handle: ClaimHandle): void;
 //#endregion
-export { setClaimChild as A, inspectClaimSet as C, processGroupAlive as D, markClaimChildPending as E, sharedClaimDir as M, tryAcquireClaim as N, readClaimSet as O, exclusiveClaimDir as S, isClaimUnavailable as T, claimFailure as _, ClaimFailure as a, clearClaimChild as b, ClaimMode as c, ClaimProblem as d, ClaimRefusedError as f, ClaimUnavailableError as g, ClaimSurvey as h, ClaimDetails as i, settleClaim as j, releaseClaim as k, ClaimOptions as l, ClaimSetState as m, CLAIM_UNAVAILABLE as n, ClaimHandle as o, ClaimSetClearance as p, ClaimAttempt as r, ClaimHolder as s, CLAIM_REFUSED as t, ClaimOwner as u, claimLiveness as v, isClaimRefusal as w, clearFreeClaimSet as x, claimRemoveCommand as y };
+export { setClaimChild as A, inspectClaimSet as C, processGroupAlive as D, markClaimChildPending as E, sharedClaimDir as M, sleepSync as N, readClaimSet as O, tryAcquireClaim as P, exclusiveClaimDir as S, isClaimUnavailable as T, claimFailure as _, ClaimFailure as a, clearClaimChild as b, ClaimMode as c, ClaimProblem as d, ClaimRefusedError as f, ClaimUnavailableError as g, ClaimSurvey as h, ClaimDetails as i, settleClaim as j, releaseClaim as k, ClaimOptions as l, ClaimSetState as m, CLAIM_UNAVAILABLE as n, ClaimHandle as o, ClaimSetClearance as p, ClaimAttempt as r, ClaimHolder as s, CLAIM_REFUSED as t, ClaimOwner as u, claimLiveness as v, isClaimRefusal as w, clearFreeClaimSet as x, claimRemoveCommand as y };

package/dist/ownership-claim.d.mts

@@ -1,2 +1,2 @@
-import { A as setClaimChild, C as inspectClaimSet, D as processGroupAlive, E as markClaimChildPending, M as sharedClaimDir, N as tryAcquireClaim, O as readClaimSet, S as exclusiveClaimDir, T as isClaimUnavailable, _ as claimFailure, a as ClaimFailure, b as clearClaimChild, c as ClaimMode, d as ClaimProblem, f as ClaimRefusedError, g as ClaimUnavailableError, h as ClaimSurvey, i as ClaimDetails, j as settleClaim, k as releaseClaim, l as ClaimOptions, m as ClaimSetState, n as CLAIM_UNAVAILABLE, o as ClaimHandle, p as ClaimSetClearance, r as ClaimAttempt, s as ClaimHolder, t as CLAIM_REFUSED, u as ClaimOwner, v as claimLiveness, w as isClaimRefusal, x as clearFreeClaimSet, y as claimRemoveCommand } from "./ownership-claim-Xxxr9MPp.mjs";
-export { CLAIM_REFUSED, CLAIM_UNAVAILABLE, ClaimAttempt, ClaimDetails, ClaimFailure, ClaimHandle, ClaimHolder, ClaimMode, ClaimOptions, ClaimOwner, ClaimProblem, ClaimRefusedError, ClaimSetClearance, ClaimSetState, ClaimSurvey, ClaimUnavailableError, claimFailure, claimLiveness, claimRemoveCommand, clearClaimChild, clearFreeClaimSet, exclusiveClaimDir, inspectClaimSet, isClaimRefusal, isClaimUnavailable, markClaimChildPending, processGroupAlive, readClaimSet, releaseClaim, setClaimChild, settleClaim, sharedClaimDir, tryAcquireClaim };
+import { A as setClaimChild, C as inspectClaimSet, D as processGroupAlive, E as markClaimChildPending, M as sharedClaimDir, N as sleepSync, O as readClaimSet, P as tryAcquireClaim, S as exclusiveClaimDir, T as isClaimUnavailable, _ as claimFailure, a as ClaimFailure, b as clearClaimChild, c as ClaimMode, d as ClaimProblem, f as ClaimRefusedError, g as ClaimUnavailableError, h as ClaimSurvey, i as ClaimDetails, j as settleClaim, k as releaseClaim, l as ClaimOptions, m as ClaimSetState, n as CLAIM_UNAVAILABLE, o as ClaimHandle, p as ClaimSetClearance, r as ClaimAttempt, s as ClaimHolder, t as CLAIM_REFUSED, u as ClaimOwner, v as claimLiveness, w as isClaimRefusal, x as clearFreeClaimSet, y as claimRemoveCommand } from "./ownership-claim-RY3fbm1D.mjs";
+export { CLAIM_REFUSED, CLAIM_UNAVAILABLE, ClaimAttempt, ClaimDetails, ClaimFailure, ClaimHandle, ClaimHolder, ClaimMode, ClaimOptions, ClaimOwner, ClaimProblem, ClaimRefusedError, ClaimSetClearance, ClaimSetState, ClaimSurvey, ClaimUnavailableError, claimFailure, claimLiveness, claimRemoveCommand, clearClaimChild, clearFreeClaimSet, exclusiveClaimDir, inspectClaimSet, isClaimRefusal, isClaimUnavailable, markClaimChildPending, processGroupAlive, readClaimSet, releaseClaim, setClaimChild, settleClaim, sharedClaimDir, sleepSync, tryAcquireClaim };

package/dist/ownership-claim.mjs

@@ -1,2 +1,2 @@
-import { _ as releaseClaim, a as claimFailure, b as sharedClaimDir, c as clearClaimChild, d as inspectClaimSet, f as isClaimRefusal, g as readClaimSet, h as processGroupAlive, i as ClaimUnavailableError, l as clearFreeClaimSet, m as markClaimChildPending, n as CLAIM_UNAVAILABLE, o as claimLiveness, p as isClaimUnavailable, r as ClaimRefusedError, s as claimRemoveCommand, t as CLAIM_REFUSED, u as exclusiveClaimDir, v as setClaimChild, x as tryAcquireClaim, y as settleClaim } from "./ownership-claim-O31Y5iIb.mjs";
-export { CLAIM_REFUSED, CLAIM_UNAVAILABLE, ClaimRefusedError, ClaimUnavailableError, claimFailure, claimLiveness, claimRemoveCommand, clearClaimChild, clearFreeClaimSet, exclusiveClaimDir, inspectClaimSet, isClaimRefusal, isClaimUnavailable, markClaimChildPending, processGroupAlive, readClaimSet, releaseClaim, setClaimChild, settleClaim, sharedClaimDir, tryAcquireClaim };
+import { S as tryAcquireClaim, _ as releaseClaim, a as claimFailure, b as sharedClaimDir, c as clearClaimChild, d as inspectClaimSet, f as isClaimRefusal, g as readClaimSet, h as processGroupAlive, i as ClaimUnavailableError, l as clearFreeClaimSet, m as markClaimChildPending, n as CLAIM_UNAVAILABLE, o as claimLiveness, p as isClaimUnavailable, r as ClaimRefusedError, s as claimRemoveCommand, t as CLAIM_REFUSED, u as exclusiveClaimDir, v as setClaimChild, x as sleepSync, y as settleClaim } from "./ownership-claim-DHUs_Dir.mjs";
+export { CLAIM_REFUSED, CLAIM_UNAVAILABLE, ClaimRefusedError, ClaimUnavailableError, claimFailure, claimLiveness, claimRemoveCommand, clearClaimChild, clearFreeClaimSet, exclusiveClaimDir, inspectClaimSet, isClaimRefusal, isClaimUnavailable, markClaimChildPending, processGroupAlive, readClaimSet, releaseClaim, setClaimChild, settleClaim, sharedClaimDir, sleepSync, tryAcquireClaim };