systemd-ts 0.0.0 → 0.1.0

package/dist/index.mjs

@@ -1,27 +1,55 @@
-import { execFile } from "node:child_process";
+import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
 import { realpathSync } from "node:fs";
-import { access, mkdir, readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { execFile } from "node:child_process";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import { promisify } from "node:util";
-//#region src/index.ts
-const REQUIRED_EXEC_KEYS = [
-	`ExecStart`,
-	`ExecStop`,
-	`ExecReload`
-];
-const execFileAsync = promisify(execFile);
+import { join } from "node:path";
+//#region src/main/executable.ts
 const currentModulePath = fileURLToPath(import.meta.url);
+/**
+* An immutable description of a runnable module entrypoint that can be used in
+* executable-valued systemd unit directives.
+*
+* `Executable` captures three pieces of information:
+* - the absolute runtime binary that should launch the module
+* - the absolute path to the module itself
+* - any additional arguments that should be passed after the module path
+*
+* Most consumers will create one via {@link defineExecutable} and then pass it
+* into a {@link SystemdService} directive such as `ExecStart`, `ExecStop`, or
+* `ExecReload`.
+*/
 var Executable = class {
+	/** Additional arguments passed after the module path. */
 	args;
+	/** Absolute path to the module that should be executed. */
 	modulePath;
+	/** Absolute path to the runtime binary that should launch the module. */
 	runtimeEntrypoint;
+	/**
+	* Creates an executable description.
+	*
+	* When `modulePath` is omitted, the calling module is inferred from the
+	* current stack so `defineExecutable()` can be used inline from the module
+	* that should become runnable.
+	*
+	* When `runtimeEntrypoint` is omitted, the current process executable is
+	* used. This works well for the common case where the same runtime that is
+	* evaluating your module should also be used by systemd.
+	*/
 	constructor(options = {}) {
 		this.runtimeEntrypoint = options.runtimeEntrypoint ?? process.execPath;
 		this.modulePath = options.modulePath ?? inferCallerModulePath();
 		this.args = Object.freeze([...options.args ?? []]);
 		Object.freeze(this);
 	}
+	/**
+	* Returns the executable as raw command parts.
+	*
+	* The first element is always the runtime entrypoint, followed by the module
+	* path and any configured arguments.
+	*/
 	toCommandParts() {
 		return [
 			this.runtimeEntrypoint,
@@ -29,16 +57,102 @@ var Executable = class {
 			...this.args
 		];
 	}
+	/**
+	* Renders the executable as a shell-quoted command string suitable for
+	* executable-valued systemd directives such as `ExecStart=`.
+	*/
 	toExecStart() {
-		return this.toCommandParts().map(shellQuote).join(` `);
+		return this.toCommandParts().map(shellQuote$1).join(` `);
 	}
 };
+/**
+* Defines a module as a runnable executable and returns its immutable
+* `Executable` description.
+*
+* This helper is designed for the pattern:
+*
+* ```ts
+* export default defineExecutable(async () => {
+*   // do work here
+* });
+* ```
+*
+* When the defining module is executed as the main entrypoint, `fn` is invoked.
+* When the module is merely imported, `fn` is not run and only the executable
+* description is returned.
+*
+* Pass `options.runtimeEntrypoint` to override the default runtime binary when
+* the current process is not the exact runtime you want systemd to use.
+*/
+function defineExecutable(fn, options = {}) {
+	const executable = new Executable(options);
+	if (isMainModule(executable.modulePath)) Promise.resolve(fn()).catch((error) => {
+		process.exitCode = 1;
+		throw error;
+	});
+	return executable;
+}
+function inferCallerModulePath() {
+	const stack = (/* @__PURE__ */ new Error()).stack ?? ``;
+	for (const line of stack.split(`\n`).slice(1)) {
+		const candidate = extractStackPath(line);
+		if (candidate === void 0 || candidate === currentModulePath) continue;
+		return candidate;
+	}
+	throw new Error(`Could not infer the calling module path for defineExecutable(); pass { modulePath } explicitly`);
+}
+function extractStackPath(line) {
+	const fileUrlMatch = line.match(/(file:\/\/\/[^)\s:]+(?:\.[cm]?[jt]s)?)/u);
+	if (fileUrlMatch !== null) return fileURLToPath(fileUrlMatch[1]);
+	const pathMatch = line.match(/(\/[^)\s:]+(?:\.[cm]?[jt]s)?)/u);
+	if (pathMatch !== null) return pathMatch[1];
+}
+function isMainModule(modulePath) {
+	const mainArg = process.argv[1];
+	if (mainArg === void 0) return false;
+	return normalizeFilePath(mainArg) === normalizeFilePath(modulePath);
+}
+function shellQuote$1(value) {
+	return `'${value.replaceAll(`'`, `'\\''`)}'`;
+}
+function normalizeFilePath(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return path;
+	}
+}
+//#endregion
+//#region src/main/systemd-service.ts
+/**
+* An immutable definition of a `.service` unit.
+*
+* `SystemdService` is a pure value object: it captures the intended unit name
+* and section contents, but it does not write files or talk to `systemd`
+* directly. Operational actions such as installation or startup belong on
+* {@link Systemd}.
+*
+* Source:
+* - https://www.freedesktop.org/software/systemd/man/latest/systemd.service.html
+*/
 var SystemdService = class {
+	/** Optional `[Install]` section for enable-time relationships. */
 	install;
+	/** The normalized base unit name, without the `.service` suffix. */
 	name;
+	/** The fully frozen original options used to construct this service. */
 	options;
+	/** The `[Service]` section payload. */
 	service;
+	/** Optional `[Unit]` section metadata and dependency configuration. */
 	unit;
+	/**
+	* Creates an immutable service definition.
+	*
+	* The constructor preserves literal types where possible and rejects unknown
+	* directive names within the provided sections, while still allowing custom
+	* `X-...` extension directives.
+	*/
 	constructor(options) {
 		this.options = freezeUnitOptions(options);
 		this.name = normalizeUnitName(options.name, `.service`);
@@ -47,9 +161,17 @@ var SystemdService = class {
 		this.install = cloneUnitSection(options.install);
 		Object.freeze(this);
 	}
+	/** The canonical unit filename, including the `.service` suffix. */
 	get filename() {
 		return `${this.name}.service`;
 	}
+	/**
+	* Renders the service as a complete unit file.
+	*
+	* Rendering also validates executable-valued directives such as `ExecStart`
+	* and `ExecStop`, ensuring they use absolute runtime entrypoints as required
+	* by systemd.
+	*/
 	render() {
 		validateServiceSection(this.service);
 		return renderUnitFile([
@@ -59,14 +181,39 @@ var SystemdService = class {
 		]);
 	}
 };
+//#endregion
+//#region src/main/systemd-timer.ts
+/**
+* An immutable definition of a `.timer` unit.
+*
+* Like {@link SystemdService}, this is a pure value object. It models the timer
+* configuration and its attachment target, but does not write files or interact
+* with the service manager directly.
+*
+* Source:
+* - https://www.freedesktop.org/software/systemd/man/latest/systemd.timer.html
+*/
 var SystemdTimer = class {
+	/** Optional `[Install]` section for enable-time relationships. */
 	install;
+	/** The normalized base unit name, without the `.timer` suffix. */
 	name;
+	/** The fully frozen original options used to construct this timer. */
 	options;
+	/** The attached service basename inferred from `targetUnit`. */
 	targetServiceName;
+	/** The unit name this timer activates, explicit or implicit. */
 	targetUnit;
+	/** The `[Timer]` section payload. */
 	timer;
+	/** Optional `[Unit]` section metadata and dependency configuration. */
 	unit;
+	/**
+	* Creates an immutable timer definition.
+	*
+	* If no explicit `timer.Unit` is provided, the target defaults to the service
+	* with the same basename, matching systemd's native timer behavior.
+	*/
 	constructor(options) {
 		this.options = freezeUnitOptions(options);
 		this.name = normalizeUnitName(options.name, `.timer`);
@@ -77,9 +224,11 @@ var SystemdTimer = class {
 		this.targetServiceName = normalizeUnitName(this.targetUnit, `.service`);
 		Object.freeze(this);
 	}
+	/** The canonical unit filename, including the `.timer` suffix. */
 	get filename() {
 		return `${this.name}.timer`;
 	}
+	/** Renders the timer as a complete unit file. */
 	render() {
 		return renderUnitFile([
 			[`Unit`, this.unit],
@@ -88,8 +237,238 @@ var SystemdTimer = class {
 		]);
 	}
 };
+//#endregion
+//#region src/main/internal.ts
+var internal_exports = /* @__PURE__ */ __exportAll({
+	assertInstallableTogether: () => assertInstallableTogether,
+	cloneUnitSection: () => cloneUnitSection,
+	defaultCommandExecutor: () => defaultCommandExecutor,
+	defaultUnitDirForScope: () => defaultUnitDirForScope,
+	fileExists: () => fileExists,
+	freezeUnitOptions: () => freezeUnitOptions,
+	normalizeUnitName: () => normalizeUnitName,
+	parseStartResult: () => parseStartResult,
+	renderUnitFile: () => renderUnitFile,
+	resolveTimerTargetUnit: () => resolveTimerTargetUnit,
+	sendNotify: () => sendNotify,
+	shellQuote: () => shellQuote,
+	validateServiceSection: () => validateServiceSection
+});
+const EXEC_DIRECTIVE_KEYS = [
+	`ExecCondition`,
+	`ExecReload`,
+	`ExecReloadPost`,
+	`ExecStart`,
+	`ExecStartPost`,
+	`ExecStartPre`,
+	`ExecStop`,
+	`ExecStopPost`
+];
+const execFileAsync = promisify(execFile);
+function normalizeUnitName(name, suffix) {
+	return name.endsWith(suffix) ? name.slice(0, -suffix.length) : name;
+}
+function resolveTimerTargetUnit(options) {
+	const explicitTarget = options.timer[`Unit`];
+	if (typeof explicitTarget === `string` && explicitTarget.length > 0) return explicitTarget;
+	return `${normalizeUnitName(options.name, `.timer`)}.service`;
+}
+function defaultUnitDirForScope(scope) {
+	if (scope === `user`) return `${process.env[`HOME`] ?? `~`}/.config/systemd/user`;
+	return `/etc/systemd/system`;
+}
+function freezeUnitOptions(options) {
+	return Object.freeze({
+		...options,
+		...options.unit === void 0 ? {} : { unit: cloneUnitSection(options.unit) },
+		...options.install === void 0 ? {} : { install: cloneUnitSection(options.install) },
+		...hasServiceSection(options) ? { service: cloneUnitSection(options.service) } : {},
+		...hasTimerSection(options) ? { timer: cloneUnitSection(options.timer) } : {}
+	});
+}
+function cloneUnitSection(section) {
+	if (section === void 0) return section;
+	const entries = Object.entries(section).map(([key, value]) => {
+		if (isUnitValueList(value)) return [key, Object.freeze([...value])];
+		return [key, value];
+	});
+	return Object.freeze(Object.fromEntries(entries));
+}
+function validateServiceSection(service) {
+	for (const key of EXEC_DIRECTIVE_KEYS) assertAbsoluteExecValue(key, service[key]);
+}
+function assertInstallableTogether(units) {
+	const installedServices = new Set(units.filter((unit) => unit instanceof SystemdService).map((unit) => unit.name));
+	if (installedServices.size === 0) return;
+	for (const unit of units) {
+		if (!(unit instanceof SystemdTimer)) continue;
+		if (!installedServices.has(unit.targetServiceName)) throw new Error(`Cannot install ${unit.filename} alongside unrelated services: expected ${unit.targetUnit}`);
+	}
+}
+function parseStartResult(unit, output) {
+	const properties = Object.fromEntries(output.split(`\n`).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => {
+		const separatorIndex = line.indexOf(`=`);
+		if (separatorIndex === -1) return [line, ``];
+		return [line.slice(0, separatorIndex), line.slice(separatorIndex + 1)];
+	}));
+	return {
+		activeState: properties[`ActiveState`] ?? `unknown`,
+		execMainStatus: properties[`ExecMainStatus`] === void 0 || properties[`ExecMainStatus`] === `` ? void 0 : Number(properties[`ExecMainStatus`]),
+		result: properties[`Result`] ?? `unknown`,
+		subState: properties[`SubState`] ?? `unknown`,
+		unit: properties[`Id`] ?? unit
+	};
+}
+function renderUnitFile(sections) {
+	const renderedSections = sections.flatMap(([sectionName, section]) => {
+		if (section === void 0) return [];
+		const lines = Object.entries(section).flatMap(([key, value]) => {
+			if (value === void 0) return [];
+			if (isUnitValueList(value)) return value.map((entry) => `${key}=${stringifyUnitValue(entry)}`);
+			return `${key}=${stringifyUnitValue(value)}`;
+		});
+		if (lines.length === 0) return [];
+		return [
+			`[${sectionName}]`,
+			...lines,
+			``
+		];
+	}).join(`\n`);
+	return renderedSections.endsWith(`\n`) ? renderedSections : `${renderedSections}\n`;
+}
+function shellQuote(value) {
+	return `'${value.replaceAll(`'`, `'\\''`)}'`;
+}
+async function defaultCommandExecutor(command, args) {
+	const result = await execFileAsync(command, [...args]);
+	return {
+		stderr: result.stderr,
+		stdout: result.stdout
+	};
+}
+async function fileExists(path) {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function sendNotify(state, options) {
+	const args = [state];
+	if (options.pid !== void 0) args.push(`MAINPID=${options.pid}`);
+	if (options.status !== void 0) args.push(`STATUS=${options.status}`);
+	if (options.executor !== void 0) {
+		const command = buildNotifyShellCommand(args, options.socketPath);
+		await options.executor(`bash`, [`-lc`, command]);
+		return;
+	}
+	await execFileAsync(`systemd-notify`, args, { env: {
+		...process.env,
+		...options.socketPath === void 0 ? {} : { NOTIFY_SOCKET: options.socketPath }
+	} });
+}
+function hasServiceSection(options) {
+	return `service` in options;
+}
+function hasTimerSection(options) {
+	return `timer` in options;
+}
+function assertAbsoluteExecValue(key, value) {
+	if (isUnitValueList(value)) {
+		for (const entry of value) assertAbsoluteExecEntry(key, entry);
+		return;
+	}
+	assertAbsoluteExecEntry(key, value);
+}
+function assertAbsoluteExecEntry(key, value) {
+	if (typeof value === `string` && value.length > 0 && !isAbsoluteExecCommand(value)) throw new Error(`${key} must use an absolute executable path for systemd`);
+	if (value instanceof Executable && !value.runtimeEntrypoint.startsWith(`/`)) throw new Error(`${key} must use an absolute executable path for systemd`);
+}
+function stringifyUnitValue(value) {
+	if (value instanceof Executable) return value.toExecStart();
+	if (typeof value === `boolean`) return value ? `true` : `false`;
+	return String(value);
+}
+function isUnitValueList(value) {
+	return Array.isArray(value);
+}
+function isAbsoluteExecCommand(value) {
+	let index = 0;
+	let hasPrivilegePrefix = false;
+	while (index < value.length) {
+		const prefix = value[index];
+		if (prefix === `@` || prefix === `-` || prefix === `:`) {
+			index += 1;
+			continue;
+		}
+		if (prefix === `+`) {
+			if (hasPrivilegePrefix) return false;
+			hasPrivilegePrefix = true;
+			index += 1;
+			continue;
+		}
+		if (prefix === `!`) {
+			if (hasPrivilegePrefix) return false;
+			hasPrivilegePrefix = true;
+			index += value[index + 1] === `!` ? 2 : 1;
+			continue;
+		}
+		break;
+	}
+	return value[index] === `/`;
+}
+function buildNotifyShellCommand(args, socketPath) {
+	return `${socketPath === void 0 ? `` : `NOTIFY_SOCKET=${shellQuote(socketPath)} `}${[`systemd-notify`, ...args].map(shellQuote).join(` `)}`;
+}
+//#endregion
+//#region src/main/notify.ts
+/**
+* Helpers for sending `sd_notify` state updates to systemd.
+*
+* These helpers send notification payloads to the socket identified by
+* `NOTIFY_SOCKET`, or to `options.socketPath` when one is provided explicitly.
+* They are useful both in real services and in tests that want to observe
+* readiness or watchdog traffic directly.
+*
+* Source:
+* - https://www.freedesktop.org/software/systemd/man/latest/sd_notify.html
+* - https://www.freedesktop.org/software/systemd/man/latest/systemd-notify.html
+*/
+const notify = {
+	/**
+	* Sends `READY=1` to systemd.
+	*
+	* Use this when a `Type=notify` service has completed its startup work and is
+	* ready to be considered fully started. If `options.status` is provided, it is
+	* sent as an additional `STATUS=...` field.
+	*/
+	async ready(options = {}) {
+		await sendNotify(`READY=1`, options);
+	},
+	/**
+	* Sends `WATCHDOG=1` to systemd.
+	*
+	* Use this when a service configured with `WatchdogSec=` needs to emit a
+	* watchdog heartbeat. If `options.pid` is provided, it is sent as
+	* `MAINPID=...`, and `options.status` is forwarded as `STATUS=...`.
+	*/
+	async watchdog(options = {}) {
+		await sendNotify(`WATCHDOG=1`, options);
+	}
+};
+//#endregion
+//#region src/main/systemd.ts
+/**
+* The result of installing one or more units with {@link Systemd.install}.
+*
+* It records the installation directory and the on-disk path associated with
+* each installed unit.
+*/
 var SystemdInstallResult = class {
+	/** The directory units were written into. */
 	directory;
+	/** The installed units together with their resolved on-disk paths. */
 	installed;
 	pathByFilename;
 	constructor(directory, installed) {
@@ -98,17 +477,39 @@ var SystemdInstallResult = class {
 		this.pathByFilename = new Map(installed.map((entry) => [entry.unit.filename, entry.path]));
 		Object.freeze(this);
 	}
+	/** Returns the installed on-disk path for a previously installed unit. */
 	pathFor(unit) {
 		const path = this.pathByFilename.get(unit.filename);
 		if (path === void 0) throw new Error(`No installed path is recorded for ${unit.filename}`);
 		return path;
 	}
 };
+/**
+* A configured interface to a specific systemd environment.
+*
+* `Systemd` combines unit-file materialization with a command execution
+* strategy. It knows which scope it is targeting, where unit files should be
+* written, and how `systemctl` should be invoked.
+*
+* This abstraction is intentionally close to `systemctl` concepts while still
+* accepting full unit definitions instead of loose unit-name strings.
+*/
 var Systemd = class {
+	/** Command executor used for `systemctl` and related subprocess calls. */
 	executor;
+	/** Whether units should be linked into systemd before manager operations. */
 	linkUnits;
+	/** The target manager scope, either `system` or `user`. */
 	scope;
+	/** The directory used when materializing unit files. */
 	unitDir;
+	/**
+	* Creates a configured `Systemd` facade.
+	*
+	* By default, this targets the system scope and `/etc/systemd/system`. Use
+	* `scope: "user"` or an explicit `unitDir` to target a different manager or
+	* unit-file location.
+	*/
 	constructor(options = {}) {
 		this.scope = options.scope ?? `system`;
 		this.unitDir = options.unitDir ?? defaultUnitDirForScope(this.scope);
@@ -116,10 +517,18 @@ var Systemd = class {
 		this.executor = options.executor ?? defaultCommandExecutor;
 		Object.freeze(this);
 	}
+	/**
+	* Renders and writes one or more units into this instance's `unitDir`.
+	*
+	* This is intentionally a file-materialization step. It does not enable or
+	* start the units on its own. When both timers and services are installed
+	* together, compile-time and runtime attachment checks ensure the timer points
+	* at one of the accompanying services.
+	*/
 	async install(...units) {
 		if (units.length === 0) throw new Error(`Systemd.install() requires at least one service or timer`);
 		assertInstallableTogether(units);
-		await mkdir(this.unitDir, { recursive: true });
+		await writeUnitDirectory(this.unitDir);
 		const installed = [];
 		for (const unit of units) {
 			const path = join(this.unitDir, unit.filename);
@@ -131,6 +540,13 @@ var Systemd = class {
 		}
 		return new SystemdInstallResult(this.unitDir, installed);
 	}
+	/**
+	* Enables one or more units via `systemctl enable`.
+	*
+	* When `linkUnits` is enabled, this first links installed unit files into the
+	* target manager and reloads systemd so the units are visible before the
+	* enable operation runs.
+	*/
 	async enable(...units) {
 		if (units.length === 0) throw new Error(`Systemd.enable() requires at least one service or timer`);
 		const scopeArgs = this.scopeArgs();
@@ -141,6 +557,13 @@ var Systemd = class {
 			unit.filename
 		]);
 	}
+	/**
+	* Starts a unit and returns a parsed `systemctl show` snapshot of its final
+	* observed state.
+	*
+	* For oneshot services, a successful result commonly means `ActiveState` is
+	* already back to `inactive` by the time the status snapshot is collected.
+	*/
 	async start(unit) {
 		const scopeArgs = this.scopeArgs();
 		await this.prepareUnits(scopeArgs, [unit]);
@@ -157,22 +580,30 @@ var Systemd = class {
 		]);
 		return parseStartResult(unit.filename, status.stdout);
 	}
-	async logs(_unit, _options) {
-		const fileLogPath = resolveUnitLogPath(_unit);
-		if (fileLogPath !== void 0) return tailLines(await readFile(fileLogPath, `utf8`), _options?.lines ?? 50);
+	/**
+	* Reads recent output for a managed unit.
+	*
+	* If the unit is configured with file-backed `StandardOutput` or
+	* `StandardError`, this reads directly from that file. Otherwise it falls back
+	* to `systemctl status --lines ...`.
+	*/
+	async logs(unit, options) {
+		const fileLogPath = resolveUnitLogPath(unit);
+		if (fileLogPath !== void 0) return tailLines(await readFile(fileLogPath, `utf8`), options?.lines ?? 50);
 		const scopeArgs = this.scopeArgs();
-		const lines = _options?.lines ?? 50;
+		const lines = options?.lines ?? 50;
 		const command = [
 			`systemctl`,
 			...scopeArgs,
 			`status`,
-			_unit.filename,
+			unit.filename,
 			`--no-pager`,
 			`--lines`,
 			String(lines)
 		].map(shellQuote).join(` `);
 		return (await this.executor(`bash`, [`-lc`, `${command} || true`])).stdout;
 	}
+	/** Returns the on-disk unit-file path this instance uses for the given unit. */
 	pathFor(unit) {
 		return join(this.unitDir, unit.filename);
 	}
@@ -202,6 +633,17 @@ var Systemd = class {
 		return [...paths];
 	}
 };
+let lazyDefaultSystemd;
+/**
+* Returns the lazily created default `Systemd` instance.
+*
+* The default instance uses the library defaults for scope, unit directory, and
+* command execution.
+*/
+function defaultSystemd() {
+	lazyDefaultSystemd ??= new Systemd();
+	return lazyDefaultSystemd;
+}
 function resolveUnitLogPath(unit) {
 	if (!(unit instanceof SystemdService)) return;
 	for (const key of [`StandardOutput`, `StandardError`]) {
@@ -217,177 +659,15 @@ function parseFileLogPath(value) {
 function tailLines(output, lines) {
 	return output.split(`\n`).slice(-lines).join(`\n`);
 }
-let lazyDefaultSystemd;
-function defaultSystemd() {
-	lazyDefaultSystemd ??= new Systemd();
-	return lazyDefaultSystemd;
-}
-const notify = {
-	async ready(options = {}) {
-		await sendNotify(`READY=1`, options);
-	},
-	async watchdog(options = {}) {
-		await sendNotify(`WATCHDOG=1`, options);
-	}
-};
-function defineExecutable(fn, options = {}) {
-	const executable = new Executable(options);
-	if (isMainModule(executable.modulePath)) Promise.resolve(fn()).catch((error) => {
-		process.exitCode = 1;
-		throw error;
-	});
-	return executable;
-}
-function normalizeUnitName(name, suffix) {
-	return name.endsWith(suffix) ? name.slice(0, -suffix.length) : name;
-}
-function resolveTimerTargetUnit(options) {
-	const explicitTarget = options.timer[`Unit`];
-	if (typeof explicitTarget === `string` && explicitTarget.length > 0) return explicitTarget;
-	return `${normalizeUnitName(options.name, `.timer`)}.service`;
-}
-function defaultUnitDirForScope(scope) {
-	if (scope === `user`) return `${process.env[`HOME`] ?? `~`}/.config/systemd/user`;
-	return `/etc/systemd/system`;
-}
-function freezeUnitOptions(options) {
-	return Object.freeze({
-		...options,
-		...options.unit === void 0 ? {} : { unit: cloneUnitSection(options.unit) },
-		...options.install === void 0 ? {} : { install: cloneUnitSection(options.install) },
-		...hasServiceSection(options) ? { service: cloneUnitSection(options.service) } : {},
-		...hasTimerSection(options) ? { timer: cloneUnitSection(options.timer) } : {}
-	});
-}
-function hasServiceSection(options) {
-	return `service` in options;
-}
-function hasTimerSection(options) {
-	return `timer` in options;
-}
-function cloneUnitSection(section) {
-	if (section === void 0) return section;
-	const entries = Object.entries(section).map(([key, value]) => {
-		if (isUnitValueList(value)) return [key, Object.freeze([...value])];
-		return [key, value];
-	});
-	return Object.freeze(Object.fromEntries(entries));
-}
-function validateServiceSection(service) {
-	for (const key of REQUIRED_EXEC_KEYS) {
-		const value = service[key];
-		if (typeof value === `string` && value.length > 0 && !value.startsWith(`/`)) throw new Error(`${key} must use an absolute executable path for systemd`);
-		if (value instanceof Executable && !value.runtimeEntrypoint.startsWith(`/`)) throw new Error(`${key} must use an absolute executable path for systemd`);
-	}
-}
-function assertInstallableTogether(units) {
-	const installedServices = new Set(units.filter((unit) => unit instanceof SystemdService).map((unit) => unit.name));
-	if (installedServices.size === 0) return;
-	for (const unit of units) {
-		if (!(unit instanceof SystemdTimer)) continue;
-		if (!installedServices.has(unit.targetServiceName)) throw new Error(`Cannot install ${unit.filename} alongside unrelated services: expected ${unit.targetUnit}`);
-	}
-}
-function parseStartResult(unit, output) {
-	const properties = Object.fromEntries(output.split(`\n`).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => {
-		const separatorIndex = line.indexOf(`=`);
-		if (separatorIndex === -1) return [line, ``];
-		return [line.slice(0, separatorIndex), line.slice(separatorIndex + 1)];
-	}));
-	return {
-		activeState: properties[`ActiveState`] ?? `unknown`,
-		execMainStatus: properties[`ExecMainStatus`] === void 0 || properties[`ExecMainStatus`] === `` ? void 0 : Number(properties[`ExecMainStatus`]),
-		result: properties[`Result`] ?? `unknown`,
-		subState: properties[`SubState`] ?? `unknown`,
-		unit: properties[`Id`] ?? unit
-	};
-}
-function renderUnitFile(sections) {
-	const renderedSections = sections.flatMap(([sectionName, section]) => {
-		if (section === void 0) return [];
-		const lines = Object.entries(section).flatMap(([key, value]) => {
-			if (value === void 0) return [];
-			if (isUnitValueList(value)) return value.map((entry) => `${key}=${stringifyUnitValue(entry)}`);
-			return `${key}=${stringifyUnitValue(value)}`;
-		});
-		if (lines.length === 0) return [];
-		return [
-			`[${sectionName}]`,
-			...lines,
-			``
-		];
-	}).join(`\n`);
-	return renderedSections.endsWith(`\n`) ? renderedSections : `${renderedSections}\n`;
-}
-function stringifyUnitValue(value) {
-	if (value instanceof Executable) return value.toExecStart();
-	if (typeof value === `boolean`) return value ? `true` : `false`;
-	return String(value);
-}
-function isUnitValueList(value) {
-	return Array.isArray(value);
-}
-function inferCallerModulePath() {
-	const stack = (/* @__PURE__ */ new Error()).stack ?? ``;
-	for (const line of stack.split(`\n`).slice(1)) {
-		const candidate = extractStackPath(line);
-		if (candidate === void 0 || candidate === currentModulePath) continue;
-		return candidate;
-	}
-	throw new Error(`Could not infer the calling module path for defineExecutable(); pass { modulePath } explicitly`);
-}
-function extractStackPath(line) {
-	const fileUrlMatch = line.match(/(file:\/\/\/[^)\s:]+(?:\.[cm]?[jt]s)?)/u);
-	if (fileUrlMatch !== null) return fileURLToPath(fileUrlMatch[1]);
-	const pathMatch = line.match(/(\/[^)\s:]+(?:\.[cm]?[jt]s)?)/u);
-	if (pathMatch !== null) return pathMatch[1];
-}
-function isMainModule(modulePath) {
-	const mainArg = process.argv[1];
-	if (mainArg === void 0) return false;
-	return normalizeFilePath(mainArg) === normalizeFilePath(modulePath);
-}
-function shellQuote(value) {
-	return `'${value.replaceAll(`'`, `'\\''`)}'`;
-}
-function normalizeFilePath(path) {
-	try {
-		return realpathSync(path);
-	} catch {
-		return path;
-	}
-}
-async function defaultCommandExecutor(command, args) {
-	const result = await execFileAsync(command, [...args]);
-	return {
-		stderr: result.stderr,
-		stdout: result.stdout
-	};
-}
-async function fileExists(path) {
-	try {
-		await access(path);
-		return true;
-	} catch {
-		return false;
-	}
-}
-async function sendNotify(state, options) {
-	const args = [state];
-	if (options.pid !== void 0) args.push(`MAINPID=${options.pid}`);
-	if (options.status !== void 0) args.push(`STATUS=${options.status}`);
-	if (options.executor !== void 0) {
-		const command = buildNotifyShellCommand(args, options.socketPath);
-		await options.executor(`bash`, [`-lc`, command]);
-		return;
-	}
-	await execFileAsync(`systemd-notify`, args, { env: {
-		...process.env,
-		...options.socketPath === void 0 ? {} : { NOTIFY_SOCKET: options.socketPath }
-	} });
-}
-function buildNotifyShellCommand(args, socketPath) {
-	return `${socketPath === void 0 ? `` : `NOTIFY_SOCKET=${shellQuote(socketPath)} `}${[`systemd-notify`, ...args].map(shellQuote).join(` `)}`;
+async function writeUnitDirectory(path) {
+	await mkdir(path, { recursive: true });
 }
 //#endregion
-export { Executable, Systemd, SystemdInstallResult, SystemdService, SystemdTimer, defaultSystemd, defineExecutable, notify };
+//#region src/main/index.ts
+/**
+* Internal helpers are exposed for advanced use, but they are not a stable public API.
+* Expect breaking changes here outside the package's normal compatibility guarantees.
+*/
+const Internal = internal_exports;
+//#endregion
+export { Executable, Internal, Systemd, SystemdInstallResult, SystemdService, SystemdTimer, defaultSystemd, defineExecutable, notify };