@stim-cli/core 1.20.2 → 1.22.0

package/dist/index.d.mts

@@ -1,13 +1,59 @@
+import { N as BuildSwiftpmArtifactQuery, j as BuildReactNativeArtifactQuery, m as BuildArtifactIdentity } from "./protocol-BjJt4ghB.mjs";
 import { Server } from "node:net";
 //#region dir-lock.d.ts
 interface DirLockOptions {
-  /** @deprecated Occupied locks are never expired. */
-  staleMs?: number;
   waitMs?: number;
   pollMs?: number;
   ensureParent?: () => void;
 }
 declare function withDirLock<T>(lockPath: string, fn: () => T, { waitMs, pollMs, ensureParent }?: DirLockOptions): T;
+/**
+ * `withDirLock` that waits for a contended lock on a timer instead of blocking the thread. `fn` still runs
+ * synchronously: nothing awaits between taking the lock, running `fn` and releasing the lock, so the held
+ * transaction and reentrant nesting behave exactly as with `withDirLock`.
+ * An optional signal cancels acquisition; it cannot interrupt the synchronous transaction.
+ */
+declare function withDirLockAsync<T>(lockPath: string, fn: () => T, options?: DirLockOptions & {
+  signal?: AbortSignal;
+}): Promise<T>;
+/**
+ * Holds the directory lock and its ownership claim until the body settles. Transactions are exclusive even
+ * within one process and are not reentrant. Cancellation stops acquisition; the body owns cancellation after admission.
+ */
+declare function withDirLockTransaction<T>(lockPath: string, fn: () => T | Promise<T>, options?: DirLockOptions & {
+  signal?: AbortSignal;
+}): Promise<T>;
+//#endregion
+//#region context.d.ts
+/** Where an operation writes progress that the CLI prints and an API client receives through `onProgress`. */
+type StimOutput = (stream: "stdout" | "stderr", text: string) => void;
+/**
+ * Everything one Stim operation takes from its caller instead of from `process`. The CLI builds one per command
+ * from `process`; `createStim` builds one per operation from the client's options. Engine code receives it as a
+ * parameter.
+ */
+interface StimContext {
+  home: string;
+  buildCache: string | null;
+  projectRoot: string;
+  env: NodeJS.ProcessEnv;
+  cwd: string;
+  runId: string;
+  signal: AbortSignal;
+  output: StimOutput;
+}
+/**
+ * Runs `fn` with `context` reachable through `ambientContext()`, including after an `await` inside it. A temporary
+ * bridge for call sites that are not passed a context yet: `configDir()`, `runId()` and the exec wrapper's base
+ * environment.
+ */
+declare function withAmbientContext<T>(context: StimContext, fn: () => T): T;
+/** The context set by `withAmbientContext`, for call sites that are not passed one yet. */
+declare function ambientContext(): StimContext | undefined;
+/** Writes `text` to the ambient context's output, or to the process stream outside one. */
+declare function ambientWrite(stream: "stdout" | "stderr", text: string): void;
+/** The environment of the ambient context, or `process.env` outside one. */
+declare function ambientEnv(): NodeJS.ProcessEnv;
 //#endregion
 //#region macos-resources.d.ts
 /** Whether a resource destination is a contained, non-empty path under Contents/Resources. */
@@ -17,6 +63,22 @@ declare function validMacosResourceDestination(value: unknown): value is string;
 /** Quote a path for a shell command Stim prints for a human to copy and run. */
 declare function quotedPath(path: string): string;
 //#endregion
+//#region systemd-unit.d.ts
+/**
+ * One double-quoted word as systemd.syntax(7) reads it: C escapes inside the quotes, `%` doubled because unit files
+ * expand specifiers, and in `ExecStart=` `$` doubled because systemd expands variables in command lines.
+ */
+declare function quoteUnitWord(value: string, exec: boolean): string;
+/** The words of a unit value `quoteUnitWord` wrote, or null when the value is not in that form. */
+declare function unitWords(line: string, exec: boolean): string[] | null;
+interface UnitLine {
+  section: string;
+  key: string;
+  value: string;
+}
+/** The `key=value` lines of a unit file with the section each is in, skipping comments and blank lines. */
+declare function unitLines(text: string): UnitLine[];
+//#endregion
 //#region artifact-store.d.ts
 declare function artifactIn(dir: string): string | null;
 declare function resolveArtifact(dir: string): string | null;
@@ -28,21 +90,42 @@ interface StoreArtifactOptions {
 }
 declare function storeArtifact(dest: string, buildPath: string, { runFile, overwrite, writeMetadata, onRenameError }: StoreArtifactOptions): string | null;
 //#endregion
+//#region artifact-store-async.d.ts
+interface AsyncStoreArtifactOptions extends Omit<StoreArtifactOptions, "runFile"> {
+  /** Resolves after the copy and its owned child work have ended. */
+  runFile: (file: string, args: string[]) => Promise<unknown>;
+  signal?: AbortSignal;
+}
+/** Awaits copying before atomic publication; cancellation before publication preserves the previous entry. */
+declare function storeArtifactAsync(dest: string, buildPath: string, { runFile, overwrite, writeMetadata, onRenameError, signal }: AsyncStoreArtifactOptions): Promise<string | null>;
+//#endregion
 //#region compiled-helper.d.ts
 /**
  * Returns `<dir>/<name>-<hash>`, compiling it with `compile` first when it is missing. The hash covers `version` and
  * each input's name and bytes, so a changed source or compiler builds a new helper beside the old one. `compile`
  * writes to a private temporary path that is renamed into place, so concurrent builders never expose a partial file.
- * Pruning is best effort and keeps this helper, the newest previous build, helpers modified in the last ten minutes and running helpers. It runs after a build and on the first call per process.
+ * Pruning is best effort and keeps this helper, the newest previous build, helpers modified in the last ten minutes and running helpers. It runs after a build and on the first call per process unless `prune` is false.
  */
-declare function compiledHelper({ dir, name, inputs, version, compile }: {
+declare function compiledHelper({ dir, name, inputs, version, compile, prune }: {
   dir: string;
   name: string;
   inputs: readonly string[];
   version: string;
   compile: (output: string) => Promise<void>;
+  prune?: boolean;
 }): Promise<string>;
 //#endregion
+//#region dependency-install.d.ts
+/** The existing worker install command and marker identity for a repository's selected lockfile. */
+declare function dependencyInstall(root: string, packageName: string | null): {
+  command: "pnpm" | "yarn" | "npm";
+  args: string[];
+  lockfile: string;
+  digest: string;
+} | null;
+/** Whether the worker can reuse this project's dependency install without running the package manager. */
+declare function reusableDependencies(area: string, project: string, packageName: string | null, lockfile: string): boolean;
+//#endregion
 //#region metro-bridge.d.ts
 interface MetroBridge {
   server: Server;
@@ -61,6 +144,19 @@ declare function createMetroBridge({ gatewayPort, peer, secret }: {
   secret: string;
 }): MetroBridge;
 //#endregion
+//#region react-native-artifact.d.ts
+/** Validates and canonicalizes the choices used by completed React Native peer artifacts. */
+declare function reactNativeArtifactQuery(value: unknown): BuildReactNativeArtifactQuery | null;
+/** The identity of a canonical React Native query and the toolchain verified around its build. */
+declare function reactNativeArtifactIdentity(receipt: {
+  query: BuildReactNativeArtifactQuery;
+  toolchain: object;
+}): BuildArtifactIdentity;
+//#endregion
+//#region swiftpm-artifact.d.ts
+/** Validates and canonicalizes the source and build choices of a completed SwiftPM peer artifact. */
+declare function swiftpmArtifactQuery(value: unknown): BuildSwiftpmArtifactQuery | null;
+//#endregion
 //#region index.d.ts
 declare function configDir(): string;
 /** Creates `dir` and its missing parents owner-only, and narrows an existing `dir` that grants group or other access when the filesystem and owner allow it. */
@@ -125,4 +221,4 @@ declare function updateCacheManifest(file: string, mutate: (caches: Array<Record
 declare function cacheDirRefusal(dir: string): string | null;
 declare function registerCache({ dir, name, prune, note, entriesDepth, layout, replaces }: RegisterOptions): void;
 //#endregion
-export { BuildRunOptions, CacheManifest, CacheRegistrationMatch, type DirLockOptions, LOG_ROTATE_BYTES, METRO_NAMED_CACHE_LAYOUT, type MetroBridge, RegisterOptions, STORE_ROOT_TAG, type StoreArtifactOptions, artifactIn, buildCacheKey, buildCacheRoot, cacheDirRefusal, cacheManifestLockPath, cacheNameSegment, cachePathSetting, compiledHelper, configDir, createMetroBridge, createMetroGateway, ensurePrivateDir, hostSimulatorArch, metroCacheRoot, quotedPath, readCacheManifest, registerCache, resolveArtifact, rotateLog, rotatedLogPath, sharedStoreRoot, storeArtifact, tagSharedStore, updateCacheManifest, validMacosResourceDestination, withDirLock, workspaceId, workspaceLogDir, workspaceName, workspaceSlug, workspaceStateDir };
+export { type AsyncStoreArtifactOptions, BuildRunOptions, CacheManifest, CacheRegistrationMatch, type DirLockOptions, LOG_ROTATE_BYTES, METRO_NAMED_CACHE_LAYOUT, type MetroBridge, RegisterOptions, STORE_ROOT_TAG, type StimContext, type StimOutput, type StoreArtifactOptions, type UnitLine, ambientContext, ambientEnv, ambientWrite, artifactIn, buildCacheKey, buildCacheRoot, cacheDirRefusal, cacheManifestLockPath, cacheNameSegment, cachePathSetting, compiledHelper, configDir, createMetroBridge, createMetroGateway, dependencyInstall, ensurePrivateDir, hostSimulatorArch, metroCacheRoot, quoteUnitWord, quotedPath, reactNativeArtifactIdentity, reactNativeArtifactQuery, readCacheManifest, registerCache, resolveArtifact, reusableDependencies, rotateLog, rotatedLogPath, sharedStoreRoot, storeArtifact, storeArtifactAsync, swiftpmArtifactQuery, tagSharedStore, unitLines, unitWords, updateCacheManifest, validMacosResourceDestination, withAmbientContext, withDirLock, withDirLockAsync, withDirLockTransaction, workspaceId, workspaceLogDir, workspaceName, workspaceSlug, workspaceStateDir };

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { S as quotedPath } from "./ownership-claim-O31Y5iIb.mjs";
-import { A as resolveArtifact, C as workspaceName, D as createMetroGateway, E as createMetroBridge, M as validMacosResourceDestination, O as compiledHelper, R as withDirLock, S as workspaceLogDir, T as workspaceStateDir, _ as rotatedLogPath, a as buildCacheRoot, b as updateCacheManifest, c as cacheNameSegment, d as ensurePrivateDir, f as hostSimulatorArch, g as rotateLog, h as registerCache, i as buildCacheKey, j as storeArtifact, k as artifactIn, l as cachePathSetting, m as readCacheManifest, n as METRO_NAMED_CACHE_LAYOUT, o as cacheDirRefusal, p as metroCacheRoot, r as STORE_ROOT_TAG, s as cacheManifestLockPath, t as LOG_ROTATE_BYTES, u as configDir, v as sharedStoreRoot, w as workspaceSlug, x as workspaceId, y as tagSharedStore } from "./core-BkgfKqJ8.mjs";
-export { LOG_ROTATE_BYTES, METRO_NAMED_CACHE_LAYOUT, STORE_ROOT_TAG, artifactIn, buildCacheKey, buildCacheRoot, cacheDirRefusal, cacheManifestLockPath, cacheNameSegment, cachePathSetting, compiledHelper, configDir, createMetroBridge, createMetroGateway, ensurePrivateDir, hostSimulatorArch, metroCacheRoot, quotedPath, readCacheManifest, registerCache, resolveArtifact, rotateLog, rotatedLogPath, sharedStoreRoot, storeArtifact, tagSharedStore, updateCacheManifest, validMacosResourceDestination, withDirLock, workspaceId, workspaceLogDir, workspaceName, workspaceSlug, workspaceStateDir };
+import { C as quotedPath } from "./ownership-claim-DHUs_Dir.mjs";
+import { $ as withDirLockTransaction, A as createMetroGateway, B as unitWords, C as workspaceName, D as reactNativeArtifactIdentity, E as swiftpmArtifactQuery, F as artifactIn, G as withAmbientContext, H as ambientContext, I as resolveArtifact, L as storeArtifact, M as reusableDependencies, N as compiledHelper, O as reactNativeArtifactQuery, P as storeArtifactAsync, Q as withDirLockAsync, R as quoteUnitWord, S as workspaceLogDir, T as workspaceStateDir, U as ambientEnv, V as validMacosResourceDestination, W as ambientWrite, Z as withDirLock, _ as rotatedLogPath, a as buildCacheRoot, b as updateCacheManifest, c as cacheNameSegment, d as ensurePrivateDir, f as hostSimulatorArch, g as rotateLog, h as registerCache, i as buildCacheKey, j as dependencyInstall, k as createMetroBridge, l as cachePathSetting, m as readCacheManifest, n as METRO_NAMED_CACHE_LAYOUT, o as cacheDirRefusal, p as metroCacheRoot, r as STORE_ROOT_TAG, s as cacheManifestLockPath, t as LOG_ROTATE_BYTES, u as configDir, v as sharedStoreRoot, w as workspaceSlug, x as workspaceId, y as tagSharedStore, z as unitLines } from "./core-BTsCO1nW.mjs";
+export { LOG_ROTATE_BYTES, METRO_NAMED_CACHE_LAYOUT, STORE_ROOT_TAG, ambientContext, ambientEnv, ambientWrite, artifactIn, buildCacheKey, buildCacheRoot, cacheDirRefusal, cacheManifestLockPath, cacheNameSegment, cachePathSetting, compiledHelper, configDir, createMetroBridge, createMetroGateway, dependencyInstall, ensurePrivateDir, hostSimulatorArch, metroCacheRoot, quoteUnitWord, quotedPath, reactNativeArtifactIdentity, reactNativeArtifactQuery, readCacheManifest, registerCache, resolveArtifact, reusableDependencies, rotateLog, rotatedLogPath, sharedStoreRoot, storeArtifact, storeArtifactAsync, swiftpmArtifactQuery, tagSharedStore, unitLines, unitWords, updateCacheManifest, validMacosResourceDestination, withAmbientContext, withDirLock, withDirLockAsync, withDirLockTransaction, workspaceId, workspaceLogDir, workspaceName, workspaceSlug, workspaceStateDir };

package/dist/keyed-delta-BBoOeR2J.mjs

@@ -0,0 +1,289 @@
+//#region state/status-derived.ts
+const PLATFORMS = ["ios", "android"];
+function isRunning(platform, device) {
+	if (platform === "ios") return device.state === "Booted";
+	return device.state === "detected" && !device.physical;
+}
+function appPresence(env, platform, device) {
+	if (!isRunning(platform, device) || device.app?.state === "running") return null;
+	const everBuilt = env.builds?.[platform]?.some((entry) => entry.result === "succeeded") ?? true;
+	if (env.lastBuilds?.[platform]?.status === "failed" && !everBuilt) return "none";
+	return device.app?.state === "stopped" ? "closed" : null;
+}
+function deviceSlots(env) {
+	return [{
+		slot: "default",
+		ios: env.ios,
+		android: env.android
+	}, ...env.slots ?? []];
+}
+function latestBuild(env) {
+	let latest = null;
+	for (const platform of PLATFORMS) {
+		const build = env.lastBuilds?.[platform];
+		if (build && (latest === null || Date.parse(build.startedAt) > Date.parse(latest.startedAt))) latest = build;
+	}
+	return latest;
+}
+function stage(kind, since, platform = null) {
+	return {
+		kind,
+		since: since ?? null,
+		platform,
+		closedApps: []
+	};
+}
+function workspaceStage(env) {
+	if (env.macos?.build.state === "running") return stage("building", env.macos.build.startedAt, "macos");
+	if (env.macos?.build.state === "failed") return stage("build-failed", env.macos.build.finishedAt ?? env.macos.build.startedAt, "macos");
+	if (env.build?.state === "running") return stage("building", env.build.startedAt, env.build.platform);
+	const macosApp = env.macos?.state === "running" || env.macos?.state === "orphaned" ? env.macos : null;
+	const live = env.live || macosApp !== null;
+	if (!live && env.phase === "warming") return stage("warming", env.phaseSince);
+	if (!live && env.phase === "ready") return stage("ready", env.phaseSince);
+	const latest = latestBuild(env);
+	if (latest?.status === "failed") return stage("build-failed", latest.finishedAt ?? latest.startedAt, latest.platform);
+	if (live || (env.remoteDevices?.length ?? 0) > 0) {
+		const closedApps = deviceSlots(env).flatMap(({ slot, ...devices }) => PLATFORMS.flatMap((platform) => {
+			const device = devices[platform];
+			return device && appPresence(env, platform, device) === "closed" ? [{
+				platform,
+				slot
+			}] : [];
+		}));
+		return {
+			...stage("running", env.supervisor?.startedAt ?? macosApp?.build.finishedAt ?? macosApp?.build.startedAt),
+			closedApps
+		};
+	}
+	const lastStop = env.metro?.lastStop;
+	return stage("stopped", lastStop && "at" in lastStop ? lastStop.at : null);
+}
+function checksState(checks) {
+	if (!checks) return null;
+	if (checks.failing > 0) return "failing";
+	if (checks.pending > 0) return "pending";
+	return checks.passing > 0 ? "passing" : null;
+}
+function gitChip(worktree) {
+	const git = worktree.git;
+	if (!git) return null;
+	const pull = worktree.pullRequest;
+	const parts = [];
+	const ahead = git.ahead ?? 0;
+	const behind = git.behind ?? 0;
+	if (ahead || behind) parts.push({
+		kind: "arrows",
+		ahead,
+		behind
+	});
+	const uncommitted = git.changed + git.untracked;
+	if (uncommitted) parts.push({
+		kind: "changed",
+		count: uncommitted
+	});
+	if (git.mergedInto !== null) {
+		if (pull?.state !== "merged") parts.push({
+			kind: "merged",
+			into: git.mergedInto
+		});
+	} else if (git.upstream === null) parts.push({ kind: "no-upstream" });
+	return {
+		parts,
+		ci: pull ? checksState(pull.checks) : null
+	};
+}
+function buildCause(build) {
+	if (("result" in build ? build.result : build.status) !== "failed") return null;
+	const at = build.diagnostics?.find((d) => d.file && d.line !== null && d.line !== void 0);
+	if (at) return {
+		key: `${at.file}:${at.line}`,
+		file: at.file,
+		line: at.line
+	};
+	return {
+		key: build.errorCode ?? "failed",
+		file: null,
+		line: null
+	};
+}
+function withCauses(builds) {
+	if (!builds) return builds;
+	return Object.fromEntries(Object.entries(builds).map(([platform, list]) => [platform, list?.map((build) => withCause(build))]));
+}
+function withCause(build) {
+	const cause = buildCause(build);
+	return cause ? {
+		...build,
+		cause
+	} : build;
+}
+function withGitChip(worktree) {
+	const chip = gitChip(worktree);
+	return chip ? {
+		...worktree,
+		gitChip: chip
+	} : worktree;
+}
+/** The environment with the conclusions clients draw from it: `stage`, `appPresence`, `gitChip` and `cause`. */
+function withDerivedFacts(env) {
+	const device = (platform, record) => record ? {
+		...record,
+		appPresence: appPresence(env, platform, record)
+	} : record;
+	const derived = {
+		...env,
+		stage: workspaceStage(env)
+	};
+	if (env.ios) derived.ios = device("ios", env.ios);
+	if (env.android) derived.android = device("android", env.android);
+	if (env.slots) derived.slots = env.slots.map((slot) => ({
+		...slot,
+		ios: device("ios", slot.ios),
+		android: device("android", slot.android)
+	}));
+	if (env.worktree) derived.worktree = withGitChip(env.worktree);
+	if (env.lastBuilds) derived.lastBuilds = Object.fromEntries(Object.entries(env.lastBuilds).map(([platform, build]) => [platform, withCause(build)]));
+	if (env.builds) derived.builds = withCauses(env.builds);
+	return derived;
+}
+//#endregion
+//#region state/status-views.ts
+/** How many of the newest archives the workspace list names. */
+const SUMMARY_ARCHIVES = 10;
+function summaryBuild({ fingerprint: _fingerprint, missReason: _missReason, diagnostics, ...build }) {
+	const located = diagnostics?.find((diagnostic) => diagnostic.file && diagnostic.line !== null);
+	const kept = build;
+	if (located) kept.diagnostics = [located];
+	return kept;
+}
+function summaryHistory(entries) {
+	const streak = entries.findIndex((entry) => entry.result !== "failed");
+	return entries.slice(0, Math.max(1, streak === -1 ? entries.length : streak)).map(({ result, slot, phases, configuration: _configuration, cacheKey: _cacheKey, compileSteps: _steps, ...build }) => Object.assign(summaryBuild(build), {
+		result,
+		slot,
+		phases
+	}));
+}
+function summaryWorktree({ pullRequest, ...worktree }) {
+	if (!pullRequest) return pullRequest === void 0 ? worktree : {
+		...worktree,
+		pullRequest
+	};
+	const { reviewDecision: _reviewDecision, checkedAt: _checkedAt, ...kept } = pullRequest;
+	return {
+		...worktree,
+		pullRequest: kept
+	};
+}
+/** The summary of one environment of a status payload. */
+function workspaceSummary(environment) {
+	const { logs, builds, lastBuilds, macos, agentDevice, worktree, ...rest } = environment;
+	const summary = rest;
+	if (worktree !== void 0) summary.worktree = worktree && summaryWorktree(worktree);
+	if (logs !== void 0) summary.logs = logs && { errorsSinceMarker: logs.errorsSinceMarker };
+	if (lastBuilds) {
+		summary.lastBuilds = {};
+		if (lastBuilds.ios) summary.lastBuilds.ios = summaryBuild(lastBuilds.ios);
+		if (lastBuilds.android) summary.lastBuilds.android = summaryBuild(lastBuilds.android);
+	}
+	if (builds) {
+		summary.builds = {};
+		for (const platform of [
+			"ios",
+			"android",
+			"macos"
+		]) {
+			const entries = builds[platform];
+			if (entries) summary.builds[platform] = summaryHistory(entries);
+		}
+	}
+	if (macos !== void 0) summary.macos = macos && (({ arguments: _arguments, ...app }) => app)(macos);
+	if (environment.tutorial && agentDevice) summary.agentDevice = agentDevice;
+	return summary;
+}
+function worktreeRow({ path, branch, repository, git, gitChip, pullRequest }) {
+	const row = { path };
+	if (branch !== void 0) row.branch = branch;
+	if (repository !== void 0) row.repository = repository;
+	if (git !== void 0) row.git = git;
+	if (gitChip !== void 0) row.gitChip = gitChip;
+	if (pullRequest !== void 0) row.pullRequest = pullRequest && (({ reviewDecision: _review, checkedAt: _checked, ...kept }) => kept)(pullRequest);
+	return row;
+}
+/** The live views of a status payload as `stim status --json` prints it. */
+function statusViews(payload) {
+	const archived = payload.archived ?? [];
+	return {
+		workspaces: payload.environments.map(workspaceSummary),
+		worktrees: payload.unprovisionedWorktrees.map(worktreeRow),
+		archived: {
+			count: payload.archivedUsage?.count ?? archived.length,
+			bytes: payload.archivedUsage?.bytes ?? 0,
+			newest: archived.toSorted((a, b) => b.removedAt.localeCompare(a.removedAt)).slice(0, 10).map(({ id, projectRoot, project, workspace, removedAt }) => ({
+				id,
+				projectRoot,
+				project,
+				workspace,
+				removedAt
+			}))
+		},
+		machine: {
+			capacity: payload.capacity,
+			machine: payload.machine ?? null,
+			deviceLeases: payload.deviceLeases,
+			simctlAvailable: payload.simctlAvailable,
+			maintenance: payload.maintenance ? (({ recent: _recent, sizes: _sizes, ...rest }) => rest)(payload.maintenance) : null
+		},
+		details: new Map(payload.environments.map((environment) => [environment.path, environment]))
+	};
+}
+//#endregion
+//#region state/keyed-delta.ts
+/**
+* Tracks the JSON of the entities last sent on one subscription, so the next emit carries only what changed. An
+* entity counts as changed when its JSON differs, so the order of its fields matters and producers build entities
+* with a stable field order.
+*/
+var KeyedEntities = class {
+	sent = /* @__PURE__ */ new Map();
+	key;
+	constructor(key) {
+		this.key = key;
+	}
+	/** Records `entities` as sent in full, for a snapshot. */
+	reset(entities) {
+		this.sent = new Map(entities.map((entity) => [this.key(entity), JSON.stringify(entity)]));
+	}
+	/** The delta from what was last sent to `entities`, recorded as sent; null when nothing changed. */
+	next(entities) {
+		const sent = /* @__PURE__ */ new Map();
+		const upsert = [];
+		for (const entity of entities) {
+			const key = this.key(entity);
+			const json = JSON.stringify(entity);
+			sent.set(key, json);
+			if (this.sent.get(key) !== json) upsert.push(entity);
+		}
+		const remove = [...this.sent.keys()].filter((key) => !sent.has(key));
+		this.sent = sent;
+		return upsert.length || remove.length ? {
+			upsert,
+			remove
+		} : null;
+	}
+};
+/** Applies `delta` to `entities` keyed by `key`, keeping the order of `entities` and appending new keys. */
+function applyKeyedDelta(entities, delta, key) {
+	const removed = new Set(delta.remove);
+	const replaced = new Map(delta.upsert.map((entity) => [key(entity), entity]));
+	return [...entities.flatMap((entity) => {
+		const id = key(entity);
+		if (removed.has(id)) return [];
+		const replacement = replaced.get(id);
+		replaced.delete(id);
+		return [replacement ?? entity];
+	}), ...replaced.values()];
+}
+//#endregion
+export { workspaceSummary as a, statusViews as i, applyKeyedDelta as n, withDerivedFacts as o, SUMMARY_ARCHIVES as r, withGitChip as s, KeyedEntities as t };

package/dist/noise-DYIbymAJ.d.mts

@@ -0,0 +1,100 @@
+//#region noise.d.ts
+declare const NOISE_XX = "Noise_XX_25519_ChaChaPoly_SHA256";
+declare const NOISE_XX_PSK2 = "Noise_XXpsk2_25519_ChaChaPoly_SHA256";
+type NoiseProtocolName = typeof NOISE_XX | typeof NOISE_XX_PSK2;
+/** Largest handshake message either side writes or reads, payload included. */
+declare const MAX_HANDSHAKE_MESSAGE_BYTES = 1024;
+/** Thrown for any handshake or transport failure; the handshake or transport is unusable afterwards. */
+declare class NoiseError extends Error {
+  override name: string;
+}
+/** A raw 32-byte X25519 key pair. */
+interface NoiseKeyPair {
+  readonly publicKey: Buffer;
+  readonly privateKey: Buffer;
+}
+declare function generateNoiseKeyPair(): NoiseKeyPair;
+declare function noiseKeyPairFromPrivateKey(privateKey: Uint8Array): NoiseKeyPair;
+/** X25519 of a raw 32-byte private key and a peer's raw 32-byte public key; it throws for a low-order key. */
+type NoiseDh = (privateKey: Buffer, publicKey: Buffer) => Uint8Array;
+/** Noise's CipherState: a key and a 64-bit counter used as the nonce. */
+declare class CipherState {
+  #private;
+  constructor(key?: Uint8Array);
+  hasKey(): boolean;
+  setNonce(n: bigint): void;
+  encryptWithAd(ad: Uint8Array, plaintext: Uint8Array): Buffer;
+  decryptWithAd(ad: Uint8Array, ciphertext: Uint8Array): Buffer;
+}
+interface HandshakeOptions {
+  protocol: NoiseProtocolName;
+  initiator: boolean;
+  prologue: Uint8Array;
+  staticKeyPair: NoiseKeyPair;
+  /** 32 bytes, required for {@link NOISE_XX_PSK2} and refused for {@link NOISE_XX}. */
+  psk?: Uint8Array;
+  /** Fixed ephemeral key, only for reproducing published test vectors. */
+  ephemeralKeyPair?: NoiseKeyPair;
+  /**
+   * X25519 in place of node:crypto's, for a runtime whose node:crypto cannot derive with an imported raw public key,
+   * such as Cloudflare workerd.
+   */
+  dh?: NoiseDh;
+}
+/**
+ * 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}.
+ */
+declare class HandshakeState {
+  #private;
+  constructor(options: HandshakeOptions);
+  get isComplete(): boolean;
+  /** The peer's static public key, once the message that carries it has been read and authenticated. */
+  get remoteStaticPublicKey(): Buffer | undefined;
+  get handshakeHash(): Buffer;
+  writeMessage(payload?: Uint8Array): Buffer;
+  readMessage(message: Uint8Array): Buffer;
+  /** Noise's Split(), returning this side's sending and receiving cipher states. It can be called once. */
+  split(): {
+    send: CipherState;
+    receive: CipherState;
+  };
+}
+interface NoiseTransportOptions {
+  send: CipherState;
+  receive: CipherState;
+  /** Largest message, in bytes (UTF-8 bytes for text), this side may send. */
+  maxSendBytes: number;
+  /** Largest message, in bytes (UTF-8 bytes for text), this side accepts. */
+  maxReceiveBytes: number;
+}
+/** A message carried by one WebSocket message: text or binary, as the sender passed it. */
+type NoiseMessage = {
+  type: "text";
+  data: string;
+} | {
+  type: "binary";
+  data: Buffer;
+};
+/**
+ * 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.
+ */
+declare class NoiseTransport {
+  #private;
+  constructor(options: NoiseTransportOptions);
+  get closed(): boolean;
+  /**
+   * 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: string | Uint8Array): Buffer;
+  decrypt(message: Uint8Array): NoiseMessage;
+}
+//#endregion
+export { NOISE_XX as a, NoiseError as c, NoiseProtocolName as d, NoiseTransport as f, noiseKeyPairFromPrivateKey as h, MAX_HANDSHAKE_MESSAGE_BYTES as i, NoiseKeyPair as l, generateNoiseKeyPair as m, HandshakeOptions as n, NOISE_XX_PSK2 as o, NoiseTransportOptions as p, HandshakeState as r, NoiseDh as s, CipherState as t, NoiseMessage as u };