@agimon-ai/po-runner 0.0.0-alpha.0

package/dist/services/lifeline/client.mjs

@@ -0,0 +1,48 @@
+import net from "node:net";
+//#region src/services/lifeline/client.ts
+/** Environment variable carrying the lifeline socket path to every runner supervisor. */
+const LIFELINE_ENV = "DOOM_RUNNER_LIFELINE";
+/**
+* Reports the owning pi process dying to a runner's supervisor.
+*
+* A connected Unix socket drops the moment the owner's descriptors close, which
+* happens on every exit path including SIGKILL, so it is the one death signal a
+* graceful shutdown handler cannot provide. Connecting never blocks, the close
+* edge arrives through the event loop rather than a poll, and an unref'd socket
+* can never keep the supervisor alive: the watcher is therefore incapable of
+* outliving the process that installed it.
+*
+* A refused or missing socket means the owner died before this runner started,
+* which is reported the same way as a later death rather than left to hang.
+*
+* Runners run unwatched when no lifeline is armed, so a missing environment
+* variable can never be mistaken for a dead owner.
+*/
+function watchOwner(onOwnerLost, target = process.env[LIFELINE_ENV]) {
+	if (!target) return () => void 0;
+	let settled = false;
+	const settle = () => {
+		if (settled) return;
+		settled = true;
+		onOwnerLost();
+	};
+	let connection;
+	try {
+		connection = net.connect(target);
+	} catch (error) {
+		process.emitWarning(`Could not watch the doom-runner lifeline: ${String(error)}`);
+		return () => void 0;
+	}
+	connection.unref();
+	connection.on("connect", () => connection.resume());
+	connection.on("error", settle);
+	connection.on("close", settle);
+	return () => {
+		settled = true;
+		connection.destroy();
+	};
+}
+//#endregion
+export { LIFELINE_ENV, watchOwner };
+
+//# sourceMappingURL=client.mjs.map

package/dist/services/lifeline/client.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.mjs","names":[],"sources":["../../../src/services/lifeline/client.ts"],"sourcesContent":["import net from 'node:net';\n\n/** Environment variable carrying the lifeline socket path to every runner supervisor. */\nexport const LIFELINE_ENV = 'DOOM_RUNNER_LIFELINE';\n\n/**\n * Reports the owning pi process dying to a runner's supervisor.\n *\n * A connected Unix socket drops the moment the owner's descriptors close, which\n * happens on every exit path including SIGKILL, so it is the one death signal a\n * graceful shutdown handler cannot provide. Connecting never blocks, the close\n * edge arrives through the event loop rather than a poll, and an unref'd socket\n * can never keep the supervisor alive: the watcher is therefore incapable of\n * outliving the process that installed it.\n *\n * A refused or missing socket means the owner died before this runner started,\n * which is reported the same way as a later death rather than left to hang.\n *\n * Runners run unwatched when no lifeline is armed, so a missing environment\n * variable can never be mistaken for a dead owner.\n */\nexport function watchOwner(\n  onOwnerLost: () => void,\n  target: string | undefined = process.env[LIFELINE_ENV],\n): () => void {\n  if (!target) return () => undefined;\n\n  let settled = false;\n  const settle = (): void => {\n    if (settled) return;\n    settled = true;\n    onOwnerLost();\n  };\n\n  let connection: net.Socket;\n  try {\n    connection = net.connect(target);\n  } catch (error) {\n    process.emitWarning(`Could not watch the doom-runner lifeline: ${String(error)}`);\n    return () => undefined;\n  }\n\n  // The supervisor's own exit must never wait on this socket.\n  connection.unref();\n  // The owner never sends anything, so drain rather than accumulate.\n  connection.on('connect', () => connection.resume());\n  connection.on('error', settle);\n  connection.on('close', settle);\n\n  return () => {\n    settled = true;\n    connection.destroy();\n  };\n}\n"],"mappings":";;;AAGA,MAAa,eAAe;;;;;;;;;;;;;;;;;AAkB5B,SAAgB,WACd,aACA,SAA6B,QAAQ,IAAI,eAC7B;CACZ,IAAI,CAAC,QAAQ,aAAa,KAAA;CAE1B,IAAI,UAAU;CACd,MAAM,eAAqB;EACzB,IAAI,SAAS;EACb,UAAU;EACV,YAAY;CACd;CAEA,IAAI;CACJ,IAAI;EACF,aAAa,IAAI,QAAQ,MAAM;CACjC,SAAS,OAAO;EACd,QAAQ,YAAY,6CAA6C,OAAO,KAAK,GAAG;EAChF,aAAa,KAAA;CACf;CAGA,WAAW,MAAM;CAEjB,WAAW,GAAG,iBAAiB,WAAW,OAAO,CAAC;CAClD,WAAW,GAAG,SAAS,MAAM;CAC7B,WAAW,GAAG,SAAS,MAAM;CAE7B,aAAa;EACX,UAAU;EACV,WAAW,QAAQ;CACrB;AACF"}

package/dist/services/runnerSupervisor/index.cjs

@@ -0,0 +1,207 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rolldown_runtime = require("../../rolldown-runtime-VH7oDXx4.cjs");
+let node_fs = require("node:fs");
+node_fs = require_rolldown_runtime.__toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path, 1);
+let node_url = require("node:url");
+//#region src/services/runnerSupervisor/index.ts
+/**
+* Settings that make a terminal safe for a caller with no keyboard.
+*
+* Commands run inside an rmux pane, so their stdout is a real tty. Git and
+* friends take that as permission to open a pager, and `less` then waits at
+* `(END)` for a keypress nobody is there to send, so the run hangs until its
+* timeout. The same tty invites credential prompts, which hang the same way.
+* A conventional piped stdout disables both automatically; a pane has to be
+* told. A command that genuinely wants a pager can still ask for one, as in
+* `git -c core.pager=less log`.
+*/
+const NO_TERMINAL_INPUT_ENV = {
+	GIT_PAGER: "cat",
+	PAGER: "cat",
+	GIT_TERMINAL_PROMPT: "0"
+};
+const SPEC_MODE = 384;
+const NOT_FOUND_ERROR_CODE = "ENOENT";
+function supervisorPaths(directory, id) {
+	return {
+		spec: node_path.default.join(directory, `${id}.command.json`),
+		gate: node_path.default.join(directory, `${id}.gate`),
+		exit: node_path.default.join(directory, `${id}.exit.json`),
+		logDone: node_path.default.join(directory, `${id}.log.done`)
+	};
+}
+function writeCommandSpec(target, spec) {
+	node_fs.default.writeFileSync(target, `${JSON.stringify(spec)}\n`, { mode: SPEC_MODE });
+}
+function readExitMetadata(target) {
+	try {
+		const value = JSON.parse(node_fs.default.readFileSync(target, "utf8"));
+		if (typeof value !== "object" || value === null) return void 0;
+		const metadata = value;
+		return {
+			code: typeof metadata.code === "number" ? metadata.code : null,
+			signal: typeof metadata.signal === "string" ? metadata.signal : null,
+			...metadata.reason === "stopped" ? { reason: metadata.reason } : {},
+			...metadata.terminationReason === "owner_lost" ? { terminationReason: metadata.terminationReason } : {},
+			...typeof metadata.stopReason === "string" ? { stopReason: metadata.stopReason } : {}
+		};
+	} catch (error) {
+		if (error.code !== NOT_FOUND_ERROR_CODE) process.emitWarning(`Could not read runner exit metadata ${target}: ${String(error)}`);
+		return;
+	}
+}
+function cleanupSupervisorFiles(paths) {
+	for (const target of Object.values(paths)) try {
+		node_fs.default.unlinkSync(target);
+	} catch (error) {
+		if (error.code !== NOT_FOUND_ERROR_CODE) process.emitWarning(String(error));
+	}
+}
+/**
+* Resolves an executable entry point by walking up to the `bin` directory that
+* ships beside this module. Source and published layouts nest services at
+* different depths. Source modules select built subprocess entries so Node can resolve their imports. A hardcoded depth stays silent
+* until the shell tries to exec it.
+*/
+function runtimeEntry(name, moduleUrl = require("url").pathToFileURL(__filename).href) {
+	const modulePath = (0, node_url.fileURLToPath)(moduleUrl);
+	const source = node_path.default.extname(modulePath) === ".ts";
+	const extension = "mjs";
+	let directory = node_path.default.dirname(modulePath);
+	while (true) {
+		const entry = source ? node_path.default.join(directory, "dist", "bin", `${name}.${extension}`) : node_path.default.join(directory, "bin", `${name}.${extension}`);
+		if (node_fs.default.existsSync(entry)) return node_fs.default.realpathSync(entry);
+		const parent = node_path.default.dirname(directory);
+		if (parent === directory) break;
+		directory = parent;
+	}
+	throw new Error(`Cannot find bin/${name}.${extension} by walking up from ${modulePath}.`);
+}
+/**
+* Replaces the shell rather than nesting under it, so the pid handed back is the
+* supervisor's and a group signal reaches it directly.
+*/
+function supervisorCommand(paths) {
+	return `exec ${shellJoin([
+		process.execPath,
+		runtimeEntry("runnerHost"),
+		paths.spec,
+		paths.gate,
+		paths.exit
+	])}`;
+}
+function shellJoin(values) {
+	return values.map((value) => `'${value.replaceAll("'", `'"'"'`)}'`).join(" ");
+}
+/**
+* One watcher per directory, shared by every waiter inside it.
+*
+* A session's runners share a runs directory, and `PO_LOG_DIR` makes every
+* session using it share one. A watcher per waited file would then put a watcher
+* per in-flight runner on the same directory, each woken by every other runner's
+* sidecar writes, so the watchers are pooled and reference counted instead.
+*/
+const directoryWatches = /* @__PURE__ */ new Map();
+function acquireDirectoryWatch(directory) {
+	const existing = directoryWatches.get(directory);
+	if (existing) {
+		existing.references += 1;
+		return existing;
+	}
+	const entry = {
+		watcher: void 0,
+		waiters: /* @__PURE__ */ new Map(),
+		references: 1
+	};
+	try {
+		entry.watcher = node_fs.default.watch(directory, (_event, changed) => {
+			const named = changed === null ? void 0 : String(changed);
+			const targets = named === void 0 ? [...entry.waiters.values()] : [entry.waiters.get(named)];
+			for (const listeners of targets) {
+				if (!listeners) continue;
+				for (const listener of listeners) listener();
+			}
+		});
+		entry.watcher.on("error", () => void 0);
+	} catch {
+		entry.watcher = void 0;
+	}
+	directoryWatches.set(directory, entry);
+	return entry;
+}
+function releaseDirectoryWatch(directory, entry) {
+	entry.references -= 1;
+	if (entry.references > 0) return;
+	entry.watcher?.close();
+	entry.watcher = void 0;
+	entry.waiters.clear();
+	directoryWatches.delete(directory);
+}
+/**
+* Reports a supervisor sidecar landing on disk without polling for it.
+*
+* The sidecars are written once and never rewritten, so the directory's own
+* create event answers the only question a waiter has. Polling for them costs a
+* full poll interval on every run that finishes inside one, and the runs that
+* finish fastest are the ones that pay that tax most often.
+*
+* The watch is best effort: a platform or a directory that cannot deliver events
+* leaves every slice to time out, which is exactly the poll the caller already
+* runs as its fallback.
+*/
+function watchForFile(filePath) {
+	const directory = node_path.default.dirname(filePath);
+	const name = node_path.default.basename(filePath);
+	const entry = acquireDirectoryWatch(directory);
+	let released = false;
+	let found = false;
+	let notify;
+	const settle = () => {
+		if (found || !node_fs.default.existsSync(filePath)) return;
+		found = true;
+		notify?.();
+	};
+	const listeners = entry.waiters.get(name) ?? /* @__PURE__ */ new Set();
+	listeners.add(settle);
+	entry.waiters.set(name, listeners);
+	settle();
+	return {
+		async appeared(withinMs) {
+			if (found) return true;
+			return await new Promise((resolve) => {
+				const timer = setTimeout(() => {
+					notify = void 0;
+					settle();
+					resolve(found);
+				}, withinMs);
+				notify = () => {
+					clearTimeout(timer);
+					notify = void 0;
+					resolve(true);
+				};
+			});
+		},
+		close() {
+			if (released) return;
+			released = true;
+			notify = void 0;
+			listeners.delete(settle);
+			if (listeners.size === 0) entry.waiters.delete(name);
+			releaseDirectoryWatch(directory, entry);
+		}
+	};
+}
+//#endregion
+exports.NO_TERMINAL_INPUT_ENV = NO_TERMINAL_INPUT_ENV;
+exports.cleanupSupervisorFiles = cleanupSupervisorFiles;
+exports.readExitMetadata = readExitMetadata;
+exports.runtimeEntry = runtimeEntry;
+exports.shellJoin = shellJoin;
+exports.supervisorCommand = supervisorCommand;
+exports.supervisorPaths = supervisorPaths;
+exports.watchForFile = watchForFile;
+exports.writeCommandSpec = writeCommandSpec;
+
+//# sourceMappingURL=index.cjs.map

package/dist/services/runnerSupervisor/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["path","fs","fileURLToPath"],"sources":["../../../src/services/runnerSupervisor/index.ts"],"sourcesContent":["import fs from 'node:fs';\nimport path from 'node:path';\nimport { fileURLToPath } from 'node:url';\n\nimport type { ExitResult } from '../../types/spawner';\n/** What a supervisor needs to run one command. */\nexport interface CommandSpec {\n  command: string;\n  cwd: string;\n  env: Record<string, string>;\n}\n\n/** Exit status the supervisor records once its command is gone. */\nexport type ExitMetadata = ExitResult;\n\n/** Sidecars a supervised run reads and writes beside its log. */\nexport interface SupervisorPaths {\n  spec: string;\n  gate: string;\n  exit: string;\n  logDone: string;\n}\n\n/**\n * Settings that make a terminal safe for a caller with no keyboard.\n *\n * Commands run inside an rmux pane, so their stdout is a real tty. Git and\n * friends take that as permission to open a pager, and `less` then waits at\n * `(END)` for a keypress nobody is there to send, so the run hangs until its\n * timeout. The same tty invites credential prompts, which hang the same way.\n * A conventional piped stdout disables both automatically; a pane has to be\n * told. A command that genuinely wants a pager can still ask for one, as in\n * `git -c core.pager=less log`.\n */\nexport const NO_TERMINAL_INPUT_ENV = {\n  GIT_PAGER: 'cat',\n  PAGER: 'cat',\n  GIT_TERMINAL_PROMPT: '0',\n};\n\nconst SPEC_MODE = 0o600;\nconst NOT_FOUND_ERROR_CODE = 'ENOENT';\n\nexport function supervisorPaths(directory: string, id: string): SupervisorPaths {\n  return {\n    spec: path.join(directory, `${id}.command.json`),\n    gate: path.join(directory, `${id}.gate`),\n    exit: path.join(directory, `${id}.exit.json`),\n    logDone: path.join(directory, `${id}.log.done`),\n  };\n}\n\nexport function writeCommandSpec(target: string, spec: CommandSpec): void {\n  fs.writeFileSync(target, `${JSON.stringify(spec)}\\n`, { mode: SPEC_MODE });\n}\n\nexport function readExitMetadata(target: string): ExitMetadata | undefined {\n  try {\n    const value: unknown = JSON.parse(fs.readFileSync(target, 'utf8'));\n    if (typeof value !== 'object' || value === null) return undefined;\n    const metadata = value as Partial<ExitMetadata>;\n    const code = typeof metadata.code === 'number' ? metadata.code : null;\n    const signal = typeof metadata.signal === 'string' ? (metadata.signal as NodeJS.Signals) : null;\n    return {\n      code,\n      signal,\n      ...(metadata.reason === 'stopped' ? { reason: metadata.reason } : {}),\n      ...(metadata.terminationReason === 'owner_lost' ? { terminationReason: metadata.terminationReason } : {}),\n      ...(typeof metadata.stopReason === 'string' ? { stopReason: metadata.stopReason } : {}),\n    };\n  } catch (error) {\n    if ((error as NodeJS.ErrnoException).code !== NOT_FOUND_ERROR_CODE) {\n      process.emitWarning(`Could not read runner exit metadata ${target}: ${String(error)}`);\n    }\n    return undefined;\n  }\n}\n\nexport function cleanupSupervisorFiles(paths: SupervisorPaths): void {\n  for (const target of Object.values(paths)) {\n    try {\n      fs.unlinkSync(target);\n    } catch (error) {\n      if ((error as NodeJS.ErrnoException).code !== NOT_FOUND_ERROR_CODE) process.emitWarning(String(error));\n    }\n  }\n}\n\n/**\n * Resolves an executable entry point by walking up to the `bin` directory that\n * ships beside this module. Source and published layouts nest services at\n * different depths. Source modules select built subprocess entries so Node can resolve their imports. A hardcoded depth stays silent\n * until the shell tries to exec it.\n */\nexport function runtimeEntry(name: 'runnerHost' | 'logSink', moduleUrl = import.meta.url): string {\n  const modulePath = fileURLToPath(moduleUrl);\n  const source = path.extname(modulePath) === '.ts';\n  const extension = 'mjs';\n  let directory = path.dirname(modulePath);\n\n  while (true) {\n    const entry = source\n      ? path.join(directory, 'dist', 'bin', `${name}.${extension}`)\n      : path.join(directory, 'bin', `${name}.${extension}`);\n    if (fs.existsSync(entry)) return fs.realpathSync(entry);\n\n    const parent = path.dirname(directory);\n    if (parent === directory) break;\n    directory = parent;\n  }\n\n  throw new Error(`Cannot find bin/${name}.${extension} by walking up from ${modulePath}.`);\n}\n\n/**\n * Replaces the shell rather than nesting under it, so the pid handed back is the\n * supervisor's and a group signal reaches it directly.\n */\nexport function supervisorCommand(paths: SupervisorPaths): string {\n  return `exec ${shellJoin([process.execPath, runtimeEntry('runnerHost'), paths.spec, paths.gate, paths.exit])}`;\n}\n\nexport function shellJoin(values: readonly string[]): string {\n  return values.map((value) => `'${value.replaceAll(\"'\", `'\"'\"'`)}'`).join(' ');\n}\n\n/** A pending appearance of one supervisor sidecar, watched rather than polled for. */\nexport interface FileWatch {\n  /** Resolves true once the file exists, or false when the slice elapses. */\n  appeared(withinMs: number): Promise<boolean>;\n  close(): void;\n}\n\ninterface DirectoryWatch {\n  watcher: fs.FSWatcher | undefined;\n  readonly waiters: Map<string, Set<() => void>>;\n  references: number;\n}\n\n/**\n * One watcher per directory, shared by every waiter inside it.\n *\n * A session's runners share a runs directory, and `PO_LOG_DIR` makes every\n * session using it share one. A watcher per waited file would then put a watcher\n * per in-flight runner on the same directory, each woken by every other runner's\n * sidecar writes, so the watchers are pooled and reference counted instead.\n */\nconst directoryWatches = new Map<string, DirectoryWatch>();\n\nfunction acquireDirectoryWatch(directory: string): DirectoryWatch {\n  const existing = directoryWatches.get(directory);\n  if (existing) {\n    existing.references += 1;\n    return existing;\n  }\n  const entry: DirectoryWatch = { watcher: undefined, waiters: new Map(), references: 1 };\n  try {\n    entry.watcher = fs.watch(directory, (_event, changed) => {\n      // A rename can arrive without a name, and then the only safe reading is\n      // that any waiter in this directory might be the one it belongs to.\n      const named = changed === null ? undefined : String(changed);\n      const targets = named === undefined ? [...entry.waiters.values()] : [entry.waiters.get(named)];\n      for (const listeners of targets) {\n        if (!listeners) continue;\n        for (const listener of listeners) listener();\n      }\n    });\n    // A watcher that cannot report is a watcher whose slices time out, which the\n    // caller's own probe already covers.\n    entry.watcher.on('error', () => undefined);\n  } catch {\n    entry.watcher = undefined;\n  }\n  directoryWatches.set(directory, entry);\n  return entry;\n}\n\nfunction releaseDirectoryWatch(directory: string, entry: DirectoryWatch): void {\n  entry.references -= 1;\n  if (entry.references > 0) return;\n  entry.watcher?.close();\n  entry.watcher = undefined;\n  entry.waiters.clear();\n  directoryWatches.delete(directory);\n}\n\n/**\n * Reports a supervisor sidecar landing on disk without polling for it.\n *\n * The sidecars are written once and never rewritten, so the directory's own\n * create event answers the only question a waiter has. Polling for them costs a\n * full poll interval on every run that finishes inside one, and the runs that\n * finish fastest are the ones that pay that tax most often.\n *\n * The watch is best effort: a platform or a directory that cannot deliver events\n * leaves every slice to time out, which is exactly the poll the caller already\n * runs as its fallback.\n */\nexport function watchForFile(filePath: string): FileWatch {\n  const directory = path.dirname(filePath);\n  const name = path.basename(filePath);\n  const entry = acquireDirectoryWatch(directory);\n  let released = false;\n  let found = false;\n  let notify: (() => void) | undefined;\n\n  const settle = (): void => {\n    if (found || !fs.existsSync(filePath)) return;\n    found = true;\n    notify?.();\n  };\n  const listeners = entry.waiters.get(name) ?? new Set<() => void>();\n  listeners.add(settle);\n  entry.waiters.set(name, listeners);\n\n  // The file can land between opening the watcher and the first wait, and that\n  // create event has nobody listening for it yet.\n  settle();\n\n  return {\n    async appeared(withinMs: number): Promise<boolean> {\n      if (found) return true;\n      return await new Promise<boolean>((resolve) => {\n        const timer = setTimeout(() => {\n          notify = undefined;\n          // The watcher is an optimisation, not the answer. A create event that\n          // was coalesced, reported under the temporary name of a rename, or\n          // never delivered at all must not outlive the slice it belongs to, so\n          // every slice ends by asking the filesystem itself.\n          settle();\n          resolve(found);\n        }, withinMs);\n        // Deliberately left holding the event loop. A run still being waited on\n        // is work, and a process that exits during the gap between two probes\n        // drops the result its caller is awaiting.\n        notify = () => {\n          clearTimeout(timer);\n          notify = undefined;\n          resolve(true);\n        };\n      });\n    },\n    close(): void {\n      if (released) return;\n      released = true;\n      notify = undefined;\n      listeners.delete(settle);\n      if (listeners.size === 0) entry.waiters.delete(name);\n      releaseDirectoryWatch(directory, entry);\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/services/runnerSupervisor/index.d.mts

@@ -0,0 +1,71 @@
+import { t as ExitResult } from "../../spawner-CdrN_HNk.mjs";
+//#region src/services/runnerSupervisor/index.d.ts
+/** What a supervisor needs to run one command. */
+export interface CommandSpec {
+  command: string;
+  cwd: string;
+  env: Record<string, string>;
+}
+/** Exit status the supervisor records once its command is gone. */
+export type ExitMetadata = ExitResult;
+/** Sidecars a supervised run reads and writes beside its log. */
+export interface SupervisorPaths {
+  spec: string;
+  gate: string;
+  exit: string;
+  logDone: string;
+}
+/**
+ * Settings that make a terminal safe for a caller with no keyboard.
+ *
+ * Commands run inside an rmux pane, so their stdout is a real tty. Git and
+ * friends take that as permission to open a pager, and `less` then waits at
+ * `(END)` for a keypress nobody is there to send, so the run hangs until its
+ * timeout. The same tty invites credential prompts, which hang the same way.
+ * A conventional piped stdout disables both automatically; a pane has to be
+ * told. A command that genuinely wants a pager can still ask for one, as in
+ * `git -c core.pager=less log`.
+ */
+export declare const NO_TERMINAL_INPUT_ENV: {
+  GIT_PAGER: string;
+  PAGER: string;
+  GIT_TERMINAL_PROMPT: string;
+};
+export declare function supervisorPaths(directory: string, id: string): SupervisorPaths;
+export declare function writeCommandSpec(target: string, spec: CommandSpec): void;
+export declare function readExitMetadata(target: string): ExitMetadata | undefined;
+export declare function cleanupSupervisorFiles(paths: SupervisorPaths): void;
+/**
+ * Resolves an executable entry point by walking up to the `bin` directory that
+ * ships beside this module. Source and published layouts nest services at
+ * different depths. Source modules select built subprocess entries so Node can resolve their imports. A hardcoded depth stays silent
+ * until the shell tries to exec it.
+ */
+export declare function runtimeEntry(name: 'runnerHost' | 'logSink', moduleUrl?: string): string;
+/**
+ * Replaces the shell rather than nesting under it, so the pid handed back is the
+ * supervisor's and a group signal reaches it directly.
+ */
+export declare function supervisorCommand(paths: SupervisorPaths): string;
+export declare function shellJoin(values: readonly string[]): string;
+/** A pending appearance of one supervisor sidecar, watched rather than polled for. */
+export interface FileWatch {
+  /** Resolves true once the file exists, or false when the slice elapses. */
+  appeared(withinMs: number): Promise<boolean>;
+  close(): void;
+}
+/**
+ * Reports a supervisor sidecar landing on disk without polling for it.
+ *
+ * The sidecars are written once and never rewritten, so the directory's own
+ * create event answers the only question a waiter has. Polling for them costs a
+ * full poll interval on every run that finishes inside one, and the runs that
+ * finish fastest are the ones that pay that tax most often.
+ *
+ * The watch is best effort: a platform or a directory that cannot deliver events
+ * leaves every slice to time out, which is exactly the poll the caller already
+ * runs as its fallback.
+ */
+export declare function watchForFile(filePath: string): FileWatch;
+//#endregion
+//# sourceMappingURL=index.d.mts.map

package/dist/services/runnerSupervisor/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../../src/services/runnerSupervisor/index.ts"],"mappings":";;;iBAMiB;EACf;EACA;EACA,KAAK;;;YAIK,eAAe;;iBAGV;EACf;EACA;EACA;EACA;;;;;;;;;;;;;qBAcW;EACX;EACA;EACA;;wBAMc,gBAAgB,mBAAmB,aAAa;wBAShD,iBAAiB,gBAAgB,MAAM;wBAIvC,iBAAiB,iBAAiB;wBAsBlC,uBAAuB,OAAO;;;;;;;wBAgB9B,aAAa,gCAAgC;;;;;wBAwB7C,kBAAkB,OAAO;wBAIzB,UAAU;;iBAKT;;EAEf,SAAS,mBAAmB;EAC5B;;;;;;;;;;;;;;wBAoEc,aAAa,mBAAmB"}

package/dist/services/runnerSupervisor/index.mjs

@@ -0,0 +1,195 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/services/runnerSupervisor/index.ts
+/**
+* Settings that make a terminal safe for a caller with no keyboard.
+*
+* Commands run inside an rmux pane, so their stdout is a real tty. Git and
+* friends take that as permission to open a pager, and `less` then waits at
+* `(END)` for a keypress nobody is there to send, so the run hangs until its
+* timeout. The same tty invites credential prompts, which hang the same way.
+* A conventional piped stdout disables both automatically; a pane has to be
+* told. A command that genuinely wants a pager can still ask for one, as in
+* `git -c core.pager=less log`.
+*/
+const NO_TERMINAL_INPUT_ENV = {
+	GIT_PAGER: "cat",
+	PAGER: "cat",
+	GIT_TERMINAL_PROMPT: "0"
+};
+const SPEC_MODE = 384;
+const NOT_FOUND_ERROR_CODE = "ENOENT";
+function supervisorPaths(directory, id) {
+	return {
+		spec: path.join(directory, `${id}.command.json`),
+		gate: path.join(directory, `${id}.gate`),
+		exit: path.join(directory, `${id}.exit.json`),
+		logDone: path.join(directory, `${id}.log.done`)
+	};
+}
+function writeCommandSpec(target, spec) {
+	fs.writeFileSync(target, `${JSON.stringify(spec)}\n`, { mode: SPEC_MODE });
+}
+function readExitMetadata(target) {
+	try {
+		const value = JSON.parse(fs.readFileSync(target, "utf8"));
+		if (typeof value !== "object" || value === null) return void 0;
+		const metadata = value;
+		return {
+			code: typeof metadata.code === "number" ? metadata.code : null,
+			signal: typeof metadata.signal === "string" ? metadata.signal : null,
+			...metadata.reason === "stopped" ? { reason: metadata.reason } : {},
+			...metadata.terminationReason === "owner_lost" ? { terminationReason: metadata.terminationReason } : {},
+			...typeof metadata.stopReason === "string" ? { stopReason: metadata.stopReason } : {}
+		};
+	} catch (error) {
+		if (error.code !== NOT_FOUND_ERROR_CODE) process.emitWarning(`Could not read runner exit metadata ${target}: ${String(error)}`);
+		return;
+	}
+}
+function cleanupSupervisorFiles(paths) {
+	for (const target of Object.values(paths)) try {
+		fs.unlinkSync(target);
+	} catch (error) {
+		if (error.code !== NOT_FOUND_ERROR_CODE) process.emitWarning(String(error));
+	}
+}
+/**
+* Resolves an executable entry point by walking up to the `bin` directory that
+* ships beside this module. Source and published layouts nest services at
+* different depths. Source modules select built subprocess entries so Node can resolve their imports. A hardcoded depth stays silent
+* until the shell tries to exec it.
+*/
+function runtimeEntry(name, moduleUrl = import.meta.url) {
+	const modulePath = fileURLToPath(moduleUrl);
+	const source = path.extname(modulePath) === ".ts";
+	const extension = "mjs";
+	let directory = path.dirname(modulePath);
+	while (true) {
+		const entry = source ? path.join(directory, "dist", "bin", `${name}.${extension}`) : path.join(directory, "bin", `${name}.${extension}`);
+		if (fs.existsSync(entry)) return fs.realpathSync(entry);
+		const parent = path.dirname(directory);
+		if (parent === directory) break;
+		directory = parent;
+	}
+	throw new Error(`Cannot find bin/${name}.${extension} by walking up from ${modulePath}.`);
+}
+/**
+* Replaces the shell rather than nesting under it, so the pid handed back is the
+* supervisor's and a group signal reaches it directly.
+*/
+function supervisorCommand(paths) {
+	return `exec ${shellJoin([
+		process.execPath,
+		runtimeEntry("runnerHost"),
+		paths.spec,
+		paths.gate,
+		paths.exit
+	])}`;
+}
+function shellJoin(values) {
+	return values.map((value) => `'${value.replaceAll("'", `'"'"'`)}'`).join(" ");
+}
+/**
+* One watcher per directory, shared by every waiter inside it.
+*
+* A session's runners share a runs directory, and `PO_LOG_DIR` makes every
+* session using it share one. A watcher per waited file would then put a watcher
+* per in-flight runner on the same directory, each woken by every other runner's
+* sidecar writes, so the watchers are pooled and reference counted instead.
+*/
+const directoryWatches = /* @__PURE__ */ new Map();
+function acquireDirectoryWatch(directory) {
+	const existing = directoryWatches.get(directory);
+	if (existing) {
+		existing.references += 1;
+		return existing;
+	}
+	const entry = {
+		watcher: void 0,
+		waiters: /* @__PURE__ */ new Map(),
+		references: 1
+	};
+	try {
+		entry.watcher = fs.watch(directory, (_event, changed) => {
+			const named = changed === null ? void 0 : String(changed);
+			const targets = named === void 0 ? [...entry.waiters.values()] : [entry.waiters.get(named)];
+			for (const listeners of targets) {
+				if (!listeners) continue;
+				for (const listener of listeners) listener();
+			}
+		});
+		entry.watcher.on("error", () => void 0);
+	} catch {
+		entry.watcher = void 0;
+	}
+	directoryWatches.set(directory, entry);
+	return entry;
+}
+function releaseDirectoryWatch(directory, entry) {
+	entry.references -= 1;
+	if (entry.references > 0) return;
+	entry.watcher?.close();
+	entry.watcher = void 0;
+	entry.waiters.clear();
+	directoryWatches.delete(directory);
+}
+/**
+* Reports a supervisor sidecar landing on disk without polling for it.
+*
+* The sidecars are written once and never rewritten, so the directory's own
+* create event answers the only question a waiter has. Polling for them costs a
+* full poll interval on every run that finishes inside one, and the runs that
+* finish fastest are the ones that pay that tax most often.
+*
+* The watch is best effort: a platform or a directory that cannot deliver events
+* leaves every slice to time out, which is exactly the poll the caller already
+* runs as its fallback.
+*/
+function watchForFile(filePath) {
+	const directory = path.dirname(filePath);
+	const name = path.basename(filePath);
+	const entry = acquireDirectoryWatch(directory);
+	let released = false;
+	let found = false;
+	let notify;
+	const settle = () => {
+		if (found || !fs.existsSync(filePath)) return;
+		found = true;
+		notify?.();
+	};
+	const listeners = entry.waiters.get(name) ?? /* @__PURE__ */ new Set();
+	listeners.add(settle);
+	entry.waiters.set(name, listeners);
+	settle();
+	return {
+		async appeared(withinMs) {
+			if (found) return true;
+			return await new Promise((resolve) => {
+				const timer = setTimeout(() => {
+					notify = void 0;
+					settle();
+					resolve(found);
+				}, withinMs);
+				notify = () => {
+					clearTimeout(timer);
+					notify = void 0;
+					resolve(true);
+				};
+			});
+		},
+		close() {
+			if (released) return;
+			released = true;
+			notify = void 0;
+			listeners.delete(settle);
+			if (listeners.size === 0) entry.waiters.delete(name);
+			releaseDirectoryWatch(directory, entry);
+		}
+	};
+}
+//#endregion
+export { NO_TERMINAL_INPUT_ENV, cleanupSupervisorFiles, readExitMetadata, runtimeEntry, shellJoin, supervisorCommand, supervisorPaths, watchForFile, writeCommandSpec };
+
+//# sourceMappingURL=index.mjs.map

package/dist/services/runnerSupervisor/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../src/services/runnerSupervisor/index.ts"],"sourcesContent":["import fs from 'node:fs';\nimport path from 'node:path';\nimport { fileURLToPath } from 'node:url';\n\nimport type { ExitResult } from '../../types/spawner';\n/** What a supervisor needs to run one command. */\nexport interface CommandSpec {\n  command: string;\n  cwd: string;\n  env: Record<string, string>;\n}\n\n/** Exit status the supervisor records once its command is gone. */\nexport type ExitMetadata = ExitResult;\n\n/** Sidecars a supervised run reads and writes beside its log. */\nexport interface SupervisorPaths {\n  spec: string;\n  gate: string;\n  exit: string;\n  logDone: string;\n}\n\n/**\n * Settings that make a terminal safe for a caller with no keyboard.\n *\n * Commands run inside an rmux pane, so their stdout is a real tty. Git and\n * friends take that as permission to open a pager, and `less` then waits at\n * `(END)` for a keypress nobody is there to send, so the run hangs until its\n * timeout. The same tty invites credential prompts, which hang the same way.\n * A conventional piped stdout disables both automatically; a pane has to be\n * told. A command that genuinely wants a pager can still ask for one, as in\n * `git -c core.pager=less log`.\n */\nexport const NO_TERMINAL_INPUT_ENV = {\n  GIT_PAGER: 'cat',\n  PAGER: 'cat',\n  GIT_TERMINAL_PROMPT: '0',\n};\n\nconst SPEC_MODE = 0o600;\nconst NOT_FOUND_ERROR_CODE = 'ENOENT';\n\nexport function supervisorPaths(directory: string, id: string): SupervisorPaths {\n  return {\n    spec: path.join(directory, `${id}.command.json`),\n    gate: path.join(directory, `${id}.gate`),\n    exit: path.join(directory, `${id}.exit.json`),\n    logDone: path.join(directory, `${id}.log.done`),\n  };\n}\n\nexport function writeCommandSpec(target: string, spec: CommandSpec): void {\n  fs.writeFileSync(target, `${JSON.stringify(spec)}\\n`, { mode: SPEC_MODE });\n}\n\nexport function readExitMetadata(target: string): ExitMetadata | undefined {\n  try {\n    const value: unknown = JSON.parse(fs.readFileSync(target, 'utf8'));\n    if (typeof value !== 'object' || value === null) return undefined;\n    const metadata = value as Partial<ExitMetadata>;\n    const code = typeof metadata.code === 'number' ? metadata.code : null;\n    const signal = typeof metadata.signal === 'string' ? (metadata.signal as NodeJS.Signals) : null;\n    return {\n      code,\n      signal,\n      ...(metadata.reason === 'stopped' ? { reason: metadata.reason } : {}),\n      ...(metadata.terminationReason === 'owner_lost' ? { terminationReason: metadata.terminationReason } : {}),\n      ...(typeof metadata.stopReason === 'string' ? { stopReason: metadata.stopReason } : {}),\n    };\n  } catch (error) {\n    if ((error as NodeJS.ErrnoException).code !== NOT_FOUND_ERROR_CODE) {\n      process.emitWarning(`Could not read runner exit metadata ${target}: ${String(error)}`);\n    }\n    return undefined;\n  }\n}\n\nexport function cleanupSupervisorFiles(paths: SupervisorPaths): void {\n  for (const target of Object.values(paths)) {\n    try {\n      fs.unlinkSync(target);\n    } catch (error) {\n      if ((error as NodeJS.ErrnoException).code !== NOT_FOUND_ERROR_CODE) process.emitWarning(String(error));\n    }\n  }\n}\n\n/**\n * Resolves an executable entry point by walking up to the `bin` directory that\n * ships beside this module. Source and published layouts nest services at\n * different depths. Source modules select built subprocess entries so Node can resolve their imports. A hardcoded depth stays silent\n * until the shell tries to exec it.\n */\nexport function runtimeEntry(name: 'runnerHost' | 'logSink', moduleUrl = import.meta.url): string {\n  const modulePath = fileURLToPath(moduleUrl);\n  const source = path.extname(modulePath) === '.ts';\n  const extension = 'mjs';\n  let directory = path.dirname(modulePath);\n\n  while (true) {\n    const entry = source\n      ? path.join(directory, 'dist', 'bin', `${name}.${extension}`)\n      : path.join(directory, 'bin', `${name}.${extension}`);\n    if (fs.existsSync(entry)) return fs.realpathSync(entry);\n\n    const parent = path.dirname(directory);\n    if (parent === directory) break;\n    directory = parent;\n  }\n\n  throw new Error(`Cannot find bin/${name}.${extension} by walking up from ${modulePath}.`);\n}\n\n/**\n * Replaces the shell rather than nesting under it, so the pid handed back is the\n * supervisor's and a group signal reaches it directly.\n */\nexport function supervisorCommand(paths: SupervisorPaths): string {\n  return `exec ${shellJoin([process.execPath, runtimeEntry('runnerHost'), paths.spec, paths.gate, paths.exit])}`;\n}\n\nexport function shellJoin(values: readonly string[]): string {\n  return values.map((value) => `'${value.replaceAll(\"'\", `'\"'\"'`)}'`).join(' ');\n}\n\n/** A pending appearance of one supervisor sidecar, watched rather than polled for. */\nexport interface FileWatch {\n  /** Resolves true once the file exists, or false when the slice elapses. */\n  appeared(withinMs: number): Promise<boolean>;\n  close(): void;\n}\n\ninterface DirectoryWatch {\n  watcher: fs.FSWatcher | undefined;\n  readonly waiters: Map<string, Set<() => void>>;\n  references: number;\n}\n\n/**\n * One watcher per directory, shared by every waiter inside it.\n *\n * A session's runners share a runs directory, and `PO_LOG_DIR` makes every\n * session using it share one. A watcher per waited file would then put a watcher\n * per in-flight runner on the same directory, each woken by every other runner's\n * sidecar writes, so the watchers are pooled and reference counted instead.\n */\nconst directoryWatches = new Map<string, DirectoryWatch>();\n\nfunction acquireDirectoryWatch(directory: string): DirectoryWatch {\n  const existing = directoryWatches.get(directory);\n  if (existing) {\n    existing.references += 1;\n    return existing;\n  }\n  const entry: DirectoryWatch = { watcher: undefined, waiters: new Map(), references: 1 };\n  try {\n    entry.watcher = fs.watch(directory, (_event, changed) => {\n      // A rename can arrive without a name, and then the only safe reading is\n      // that any waiter in this directory might be the one it belongs to.\n      const named = changed === null ? undefined : String(changed);\n      const targets = named === undefined ? [...entry.waiters.values()] : [entry.waiters.get(named)];\n      for (const listeners of targets) {\n        if (!listeners) continue;\n        for (const listener of listeners) listener();\n      }\n    });\n    // A watcher that cannot report is a watcher whose slices time out, which the\n    // caller's own probe already covers.\n    entry.watcher.on('error', () => undefined);\n  } catch {\n    entry.watcher = undefined;\n  }\n  directoryWatches.set(directory, entry);\n  return entry;\n}\n\nfunction releaseDirectoryWatch(directory: string, entry: DirectoryWatch): void {\n  entry.references -= 1;\n  if (entry.references > 0) return;\n  entry.watcher?.close();\n  entry.watcher = undefined;\n  entry.waiters.clear();\n  directoryWatches.delete(directory);\n}\n\n/**\n * Reports a supervisor sidecar landing on disk without polling for it.\n *\n * The sidecars are written once and never rewritten, so the directory's own\n * create event answers the only question a waiter has. Polling for them costs a\n * full poll interval on every run that finishes inside one, and the runs that\n * finish fastest are the ones that pay that tax most often.\n *\n * The watch is best effort: a platform or a directory that cannot deliver events\n * leaves every slice to time out, which is exactly the poll the caller already\n * runs as its fallback.\n */\nexport function watchForFile(filePath: string): FileWatch {\n  const directory = path.dirname(filePath);\n  const name = path.basename(filePath);\n  const entry = acquireDirectoryWatch(directory);\n  let released = false;\n  let found = false;\n  let notify: (() => void) | undefined;\n\n  const settle = (): void => {\n    if (found || !fs.existsSync(filePath)) return;\n    found = true;\n    notify?.();\n  };\n  const listeners = entry.waiters.get(name) ?? new Set<() => void>();\n  listeners.add(settle);\n  entry.waiters.set(name, listeners);\n\n  // The file can land between opening the watcher and the first wait, and that\n  // create event has nobody listening for it yet.\n  settle();\n\n  return {\n    async appeared(withinMs: number): Promise<boolean> {\n      if (found) return true;\n      return await new Promise<boolean>((resolve) => {\n        const timer = setTimeout(() => {\n          notify = undefined;\n          // The watcher is an optimisation, not the answer. A create event that\n          // was coalesced, reported under the temporary name of a rename, or\n          // never delivered at all must not outlive the slice it belongs to, so\n          // every slice ends by asking the filesystem itself.\n          settle();\n          resolve(found);\n        }, withinMs);\n        // Deliberately left holding the event loop. A run still being waited on\n        // is work, and a process that exits during the gap between two probes\n        // drops the result its caller is awaiting.\n        notify = () => {\n          clearTimeout(timer);\n          notify = undefined;\n          resolve(true);\n        };\n      });\n    },\n    close(): void {\n      if (released) return;\n      released = true;\n      notify = undefined;\n      listeners.delete(settle);\n      if (listeners.size === 0) entry.waiters.delete(name);\n      releaseDirectoryWatch(directory, entry);\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/session-BC43uEyG.cjs

@@ -0,0 +1,29 @@
+const require_session = require("./session-SfIPtdZO.cjs");
+//#region src/services/session/index.ts
+/** Session identity inherited by commands launched from a Pi session. */
+/** Returns a usable inherited session id, failing closed on blank values. */
+function inheritedSessionId(env = process.env) {
+	const value = env[require_session.PI_SESSION_ID_ENV]?.trim();
+	return value ? value : void 0;
+}
+/** Returns the inherited Pi session id or fails closed outside a session. */
+function requiredSessionId(env = process.env) {
+	const sessionId = inheritedSessionId(env);
+	if (!sessionId) throw new Error(`${require_session.PI_SESSION_ID_ENV} is required for doom-runner`);
+	return sessionId;
+}
+//#endregion
+Object.defineProperty(exports, "inheritedSessionId", {
+	enumerable: true,
+	get: function() {
+		return inheritedSessionId;
+	}
+});
+Object.defineProperty(exports, "requiredSessionId", {
+	enumerable: true,
+	get: function() {
+		return requiredSessionId;
+	}
+});
+
+//# sourceMappingURL=session-BC43uEyG.cjs.map

package/dist/session-BC43uEyG.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-BC43uEyG.cjs","names":["PI_SESSION_ID_ENV"],"sources":["../src/services/session/index.ts"],"sourcesContent":["import { PI_SESSION_ID_ENV } from '../../constants/session';\n/** Session identity inherited by commands launched from a Pi session. */\n\n/** Returns a usable inherited session id, failing closed on blank values. */\nexport function inheritedSessionId(env: NodeJS.ProcessEnv = process.env): string | undefined {\n  const value = env[PI_SESSION_ID_ENV]?.trim();\n  return value ? value : undefined;\n}\n\n/** Returns the inherited Pi session id or fails closed outside a session. */\nexport function requiredSessionId(env: NodeJS.ProcessEnv = process.env): string {\n  const sessionId = inheritedSessionId(env);\n  if (!sessionId) throw new Error(`${PI_SESSION_ID_ENV} is required for doom-runner`);\n  return sessionId;\n}\n"],"mappings":";;;;AAIA,SAAgB,mBAAmB,MAAyB,QAAQ,KAAyB;CAC3F,MAAM,QAAQ,IAAIA,gBAAAA,kBAAkB,EAAE,KAAK;CAC3C,OAAO,QAAQ,QAAQ,KAAA;AACzB;;AAGA,SAAgB,kBAAkB,MAAyB,QAAQ,KAAa;CAC9E,MAAM,YAAY,mBAAmB,GAAG;CACxC,IAAI,CAAC,WAAW,MAAM,IAAI,MAAM,GAAGA,gBAAAA,kBAAkB,6BAA6B;CAClF,OAAO;AACT"}

package/dist/session-Chsb_Nh2.mjs

@@ -0,0 +1,18 @@
+import { t as PI_SESSION_ID_ENV } from "./session-DE2Acesp.mjs";
+//#region src/services/session/index.ts
+/** Session identity inherited by commands launched from a Pi session. */
+/** Returns a usable inherited session id, failing closed on blank values. */
+function inheritedSessionId(env = process.env) {
+	const value = env[PI_SESSION_ID_ENV]?.trim();
+	return value ? value : void 0;
+}
+/** Returns the inherited Pi session id or fails closed outside a session. */
+function requiredSessionId(env = process.env) {
+	const sessionId = inheritedSessionId(env);
+	if (!sessionId) throw new Error(`${PI_SESSION_ID_ENV} is required for doom-runner`);
+	return sessionId;
+}
+//#endregion
+export { requiredSessionId as n, inheritedSessionId as t };
+
+//# sourceMappingURL=session-Chsb_Nh2.mjs.map

package/dist/session-Chsb_Nh2.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-Chsb_Nh2.mjs","names":[],"sources":["../src/services/session/index.ts"],"sourcesContent":["import { PI_SESSION_ID_ENV } from '../../constants/session';\n/** Session identity inherited by commands launched from a Pi session. */\n\n/** Returns a usable inherited session id, failing closed on blank values. */\nexport function inheritedSessionId(env: NodeJS.ProcessEnv = process.env): string | undefined {\n  const value = env[PI_SESSION_ID_ENV]?.trim();\n  return value ? value : undefined;\n}\n\n/** Returns the inherited Pi session id or fails closed outside a session. */\nexport function requiredSessionId(env: NodeJS.ProcessEnv = process.env): string {\n  const sessionId = inheritedSessionId(env);\n  if (!sessionId) throw new Error(`${PI_SESSION_ID_ENV} is required for doom-runner`);\n  return sessionId;\n}\n"],"mappings":";;;;AAIA,SAAgB,mBAAmB,MAAyB,QAAQ,KAAyB;CAC3F,MAAM,QAAQ,IAAI,kBAAkB,EAAE,KAAK;CAC3C,OAAO,QAAQ,QAAQ,KAAA;AACzB;;AAGA,SAAgB,kBAAkB,MAAyB,QAAQ,KAAa;CAC9E,MAAM,YAAY,mBAAmB,GAAG;CACxC,IAAI,CAAC,WAAW,MAAM,IAAI,MAAM,GAAG,kBAAkB,6BAA6B;CAClF,OAAO;AACT"}

package/dist/session-DE2Acesp.mjs

@@ -0,0 +1,6 @@
+//#region src/constants/session.ts
+const PI_SESSION_ID_ENV = "PI_SESSION_ID";
+//#endregion
+export { PI_SESSION_ID_ENV as t };
+
+//# sourceMappingURL=session-DE2Acesp.mjs.map