systemd-ts 261.3.0 → 262.1.0

package/src/main/types.ts

@@ -126,6 +126,7 @@ export type StandardOutputDirectiveValue =
   | `truncate:${string}`
   | `fd:${string}`;
 export type StandardErrorDirectiveValue = StandardOutputDirectiveValue | "inherit";
+/** Command lines for `Exec*=` directives. A `+` executable prefix bypasses per-command privilege restrictions and `Limit*=` settings, including manager-configured defaults; the command inherits the service manager's resource limits. Controls applying to the whole cgroup still apply. Source: systemd v262.1, `systemd.service(5)`. */
 export type ExecDirective = string | Executable | readonly (string | Executable)[];
 export type UnitValue = string | number | boolean | Executable;
 export type UnitValueList = readonly UnitValue[];
@@ -138,10 +139,11 @@ export interface CustomDirectiveSection {
 /**
  * Generic unit-level directives shared by service and timer units.
  *
- * References in this file are grounded in cached upstream systemd v260.1 manpages.
+ * References in this file are grounded in cached upstream systemd manpages,
+ * reviewed through v262.1. Individual directives identify their documentation source.
  *
  * Sources:
- * - systemd v260.1, `systemd.unit(5)`
+ * - systemd v262, `systemd.unit(5)`
  */
 export interface SystemdUnitSection extends CustomDirectiveSection {
   /** Units that should be ordered before this unit starts. Source: systemd v260.1, `systemd.unit(5)`. */
@@ -152,7 +154,7 @@ export interface SystemdUnitSection extends CustomDirectiveSection {
   readonly AssertACPower?: boolean | readonly boolean[];
   /** Assertion form of `ConditionArchitecture=`. Check whether the system is running on a specific architecture. Takes one of x86, x86-64, ppc, ppc-le, ppc64, ppc64-le, ia64, parisc, parisc64, s390, s390x, sparc, sparc64, mips, mips-le, mips64, mips64-le, alpha, arm, arm-be, arm64, arm64-be, sh, sh64, m68k, tilegx, cris, arc, arc-be, or native. Unlike conditions, a mismatch fails the start job instead of skipping it. Source: systemd v260.1, `systemd.unit(5)`. */
   readonly AssertArchitecture?: string | readonly string[];
-  /** Assertion form of `ConditionCPUFeature=`. Verify that a given CPU feature is available via the CPUID instruction. This condition only does something on i386 and x86-64 processors. On other processors it is assumed that the CPU does not support the given feature. It checks the leaves 1, 7, 0x80000001, and 0x80000007. Valid values are: fpu, vme, de, pse, tsc, msr, pae, mce, cx8, apic, sep, mtrr, pge, mca, cmov, pat, pse36, clflush, mmx, fxsr, sse, sse2, ht, pni, pclmul, monitor, ssse3, fma3, cx16, sse4_1, sse4_2, movbe, popcnt, aes, xsave, osxsave, avx, f16c, rdrand, bmi1, avx2, bmi2, rdseed, adx, sha_ni, syscall, rdtscp, lm, lahf_lm, abm, constant_tsc. Unlike conditions, a mismatch fails the start job instead of skipping it. Source: systemd v260.1, `systemd.unit(5)`. */
+  /** Assertion form of `ConditionCPUFeature=`. Checks CPU features via CPUID on i386 and x86-64, or ELF hardware capabilities on arm64. Accepts architecture-qualified names such as `arm64.bti`; a mismatched architecture prefix evaluates to false. On other architectures, features are assumed unsupported. Unlike conditions, a mismatch fails the start job instead of skipping it. Source: systemd v262, `systemd.unit(5)`. */
   readonly AssertCPUFeature?: string | readonly string[];
   /** Assertion form of `ConditionCPUPressure=`. Verify that the overall system (memory, CPU or IO) pressure is below or equal to a threshold. This setting takes a threshold value as argument. It can be specified as a simple percentage value, suffixed with %, in which case the pressure will be measured as an average over the last five minutes before the attempt to start the unit is performed. Alternatively, the average timespan can also be specified using / as a separator, for example: 10%/1min. The supported timespans match what the kernel provides, and are limited to 10sec, 1min and 5min. The full PSI will be checked first, and if not found some will be checked. For more details, see the documentation on PSI (Pressure Stall Information) . Unlike conditions, a mismatch fails the start job instead of skipping it. Source: systemd v260.1, `systemd.unit(5)`. */
   readonly AssertCPUPressure?: string | readonly string[];
@@ -188,7 +190,7 @@ export interface SystemdUnitSection extends CustomDirectiveSection {
   readonly AssertKernelModuleLoaded?: string | readonly string[];
   /** Assertion form of `ConditionKernelVersion=`. May be used to check whether the kernel version (as reported by uname -r) matches a certain expression, or if prefixed with the exclamation mark, does not match. The argument must be a list of (potentially quoted) expressions. Each expression starts with one of = or != for string comparisons, <, <=, ==, <>, >=, > for version comparisons, or $=, !$= for a shell-style glob match. If no operator is specified, $= is implied. Unlike conditions, a mismatch fails the start job instead of skipping it. Source: systemd v260.1, `systemd.unit(5)`. */
   readonly AssertKernelVersion?: string | readonly string[];
-  /** Assertion form of `ConditionMachineTag=`. Matches machine tags configured in `machine-info(5)`. Source: systemd v261, `systemd.unit(5)`. */
+  /** Assertion form of `ConditionMachineTag=`. Matches machine tags using shell-style patterns, optionally negated with `!`. Parameterized tags include their value in the match: `role=web` matches exactly, `role=*` matches any value for that key, and `role` does not match `role=web`. Unlike conditions, a mismatch fails the start job instead of skipping it. Source: systemd v262, `systemd.unit(5)`. */
   readonly AssertMachineTag?: string | readonly string[];
   /** Assertion form of `ConditionMemory=`. Verify that the specified amount of system memory is available to the current system. Takes a memory size in bytes as argument, optionally prefixed with a comparison operator <, <=, = (or ==), != (or <>), >=, >. On bare-metal systems compares the amount of physical memory in the system with the specified size, adhering to the specified comparison operator. In containers compares the amount of memory assigned to the container instead. Unlike conditions, a mismatch fails the start job instead of skipping it. Source: systemd v260.1, `systemd.unit(5)`. */
   readonly AssertMemory?: number | string | readonly (number | string)[];
@@ -198,7 +200,7 @@ export interface SystemdUnitSection extends CustomDirectiveSection {
   readonly AssertNeedsUpdate?: string | readonly string[];
   /** Assertion form of `ConditionOSRelease=`. Verify that a specific key=value pair is set in the host's os-release5. Unlike conditions, a mismatch fails the start job instead of skipping it. Source: systemd v260.1, `systemd.unit(5)`. */
   readonly AssertOSRelease?: string | readonly string[];
-  /** Assertion form of `ConditionPathExists=`. Check for the existence of a file. If the specified absolute path name does not exist, the condition will fail. If the absolute path name passed to ConditionPathExists= is prefixed with an exclamation mark (!), the test is negated, and the unit is only started if the path does not exist. Unlike conditions, a mismatch fails the start job instead of skipping it. Source: systemd v260.1, `systemd.unit(5)`. */
+  /** Assertion form of `ConditionPathExists=`. Checks for any file system object at an absolute path, including directories, device nodes, FIFOs, and sockets. Symbolic links are followed, so broken symbolic links do not count as existing. Prefix the path with `!` to require its absence. Unlike conditions, a mismatch fails the start job instead of skipping it. Source: systemd v262, `systemd.unit(5)`. */
   readonly AssertPathExists?: string | readonly string[];
   /** Assertion form of `ConditionPathExistsGlob=`. Similar to `ConditionPathExists=`, but checks for the existence of at least one file or directory matching the specified globbing pattern. Unlike conditions, a mismatch fails the start job instead of skipping it. Source: systemd v260.1, `systemd.unit(5)`. */
   readonly AssertPathExistsGlob?: string | readonly string[];
@@ -232,7 +234,7 @@ export interface SystemdUnitSection extends CustomDirectiveSection {
   readonly ConditionACPower?: boolean | readonly boolean[];
   /** Check whether the system is running on a specific architecture. Takes one of x86, x86-64, ppc, ppc-le, ppc64, ppc64-le, ia64, parisc, parisc64, s390, s390x, sparc, sparc64, mips, mips-le, mips64, mips64-le, alpha, arm, arm-be, arm64, arm64-be, sh, sh64, m68k, tilegx, cris, arc, arc-be, or native. Source: systemd v260.1, `systemd.unit(5)`. */
   readonly ConditionArchitecture?: string | readonly string[];
-  /** Verify that a given CPU feature is available via the CPUID instruction. This condition only does something on i386 and x86-64 processors. On other processors it is assumed that the CPU does not support the given feature. It checks the leaves 1, 7, 0x80000001, and 0x80000007. Valid values are: fpu, vme, de, pse, tsc, msr, pae, mce, cx8, apic, sep, mtrr, pge, mca, cmov, pat, pse36, clflush, mmx, fxsr, sse, sse2, ht, pni, pclmul, monitor, ssse3, fma3, cx16, sse4_1, sse4_2, movbe, popcnt, aes, xsave, osxsave, avx, f16c, rdrand, bmi1, avx2, bmi2, rdseed, adx, sha_ni, syscall, rdtscp, lm, lahf_lm, abm, constant_tsc. Source: systemd v260.1, `systemd.unit(5)`. */
+  /** Checks CPU features via CPUID on i386 and x86-64, or ELF hardware capabilities on arm64. Accepts architecture-qualified names such as `arm64.bti`; a mismatched architecture prefix evaluates to false. On other architectures, features are assumed unsupported. Source: systemd v262, `systemd.unit(5)`. */
   readonly ConditionCPUFeature?: string | readonly string[];
   /** Verify that the overall system (memory, CPU or IO) pressure is below or equal to a threshold. This setting takes a threshold value as argument. It can be specified as a simple percentage value, suffixed with %, in which case the pressure will be measured as an average over the last five minutes before the attempt to start the unit is performed. Alternatively, the average timespan can also be specified using / as a separator, for example: 10%/1min. The supported timespans match what the kernel provides, and are limited to 10sec, 1min and 5min. The full PSI will be checked first, and if not found some will be checked. For more details, see the documentation on PSI (Pressure Stall Information) . Source: systemd v260.1, `systemd.unit(5)`. */
   readonly ConditionCPUPressure?: string | readonly string[];
@@ -270,7 +272,7 @@ export interface SystemdUnitSection extends CustomDirectiveSection {
   readonly ConditionKernelModuleLoaded?: string | readonly string[];
   /** May be used to check whether the kernel version (as reported by uname -r) matches a certain expression, or if prefixed with the exclamation mark, does not match. The argument must be a list of (potentially quoted) expressions. Each expression starts with one of = or != for string comparisons, <, <=, ==, <>, >=, > for version comparisons, or $=, !$= for a shell-style glob match. If no operator is specified, $= is implied. Source: systemd v260.1, `systemd.unit(5)`. */
   readonly ConditionKernelVersion?: string | readonly string[];
-  /** Matches machine tags configured in `machine-info(5)`. Source: systemd v261, `systemd.unit(5)`. */
+  /** Matches machine tags from `machine-info(5)` using shell-style patterns, optionally negated with `!`. Parameterized tags include their value in the match: `role=web` matches exactly, `role=*` matches any value for that key, and `role` does not match `role=web`. Source: systemd v262, `systemd.unit(5)`. */
   readonly ConditionMachineTag?: string | readonly string[];
   /** Verify that the specified amount of system memory is available to the current system. Takes a memory size in bytes as argument, optionally prefixed with a comparison operator <, <=, = (or ==), != (or <>), >=, >. On bare-metal systems compares the amount of physical memory in the system with the specified size, adhering to the specified comparison operator. In containers compares the amount of memory assigned to the container instead. Source: systemd v260.1, `systemd.unit(5)`. */
   readonly ConditionMemory?: number | string | readonly (number | string)[];
@@ -280,7 +282,7 @@ export interface SystemdUnitSection extends CustomDirectiveSection {
   readonly ConditionNeedsUpdate?: string | readonly string[];
   /** Verify that a specific key=value pair is set in the host's os-release5. Source: systemd v260.1, `systemd.unit(5)`. */
   readonly ConditionOSRelease?: string | readonly string[];
-  /** Check for the existence of a file. If the specified absolute path name does not exist, the condition will fail. If the absolute path name passed to ConditionPathExists= is prefixed with an exclamation mark (!), the test is negated, and the unit is only started if the path does not exist. Source: systemd v260.1, `systemd.unit(5)`. */
+  /** Checks for any file system object at an absolute path, including directories, device nodes, FIFOs, and sockets. Symbolic links are followed, so broken symbolic links do not count as existing. Prefix the path with `!` to require its absence. Source: systemd v262, `systemd.unit(5)`. */
   readonly ConditionPathExists?: string | readonly string[];
   /** Similar to `ConditionPathExists=`, but checks for the existence of at least one file or directory matching the specified globbing pattern. Source: systemd v260.1, `systemd.unit(5)`. */
   readonly ConditionPathExistsGlob?: string | readonly string[];
@@ -362,7 +364,7 @@ export interface SystemdUnitSection extends CustomDirectiveSection {
   readonly StartLimitAction?: UnitActionDirectiveValue;
   /** See systemd.unit(5) for StartLimitBurst=. Source: systemd v260.1, `systemd.unit(5)`. */
   readonly StartLimitBurst?: number;
-  /** Configure unit start rate limiting. Units which are started more than burst times within an interval time span are not permitted to start any more. Use StartLimitIntervalSec= to configure the checking interval and StartLimitBurst= to configure how many starts per interval are allowed. Source: systemd v260.1, `systemd.unit(5)`. */
+  /** Configure unit start rate limiting. Units which are started more than burst times within an interval time span are not permitted to start any more. Use StartLimitIntervalSec= to configure the checking interval and StartLimitBurst= to configure how many starts per interval are allowed. Since systemd v262, time spent suspended counts toward the interval. Sources: systemd v262, `systemd.unit(5)` and `NEWS`. */
   readonly StartLimitIntervalSec?: number | string;
   /** Units whose stop requests should also stop this unit. Source: systemd v260.1, `systemd.unit(5)`. */
   readonly StopPropagatedFrom?: string | readonly string[];
@@ -452,7 +454,7 @@ export interface SystemdTimerSection extends CustomDirectiveSection {
  *
  * This interface includes directives from `systemd.service(5)`,
  * `systemd.exec(5)`, `systemd.kill(5)`, and
- * `systemd.resource-control(5)` as of systemd v260.1.
+ * `systemd.resource-control(5)`, reviewed through systemd v262.1.
  */
 export interface SystemdServiceSection extends CustomDirectiveSection {
   /** This setting controls the cpuset controller in the unified hierarchy. Source: systemd v260.1, `systemd.resource-control(5)`. */
@@ -625,37 +627,37 @@ export interface SystemdServiceSection extends CustomDirectiveSection {
   readonly KillMode?: "control-group" | "mixed" | "process" | "none";
   /** Specifies which signal to use when stopping a service. This controls the signal that is sent as first step of shutting down a unit (see above), and is usually followed by SIGKILL (see above and below). For a list of valid signals, see signal(7). Defaults to SIGTERM. Source: systemd v260.1, `systemd.kill(5)`. */
   readonly KillSignal?: NodeJS.Signals | number;
-  /** Maximum address-space size for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Source: systemd v260.1, `systemd.exec(5)`. */
+  /** Maximum address-space size for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Commands prefixed with `+` bypass this setting and its configured default, inheriting the service manager's resource limits instead. Source: systemd v262.1, `systemd.exec(5)`. */
   readonly LimitAS?: ProcessResourceLimitDirectiveValue;
-  /** Maximum core-file size for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Source: systemd v260.1, `systemd.exec(5)`. */
+  /** Maximum core-file size for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Commands prefixed with `+` bypass this setting and its configured default, inheriting the service manager's resource limits instead. Source: systemd v262.1, `systemd.exec(5)`. */
   readonly LimitCORE?: ProcessResourceLimitDirectiveValue;
-  /** Maximum CPU time for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Source: systemd v260.1, `systemd.exec(5)`. */
+  /** Maximum CPU time for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Commands prefixed with `+` bypass this setting and its configured default, inheriting the service manager's resource limits instead. Source: systemd v262.1, `systemd.exec(5)`. */
   readonly LimitCPU?: ProcessResourceLimitDirectiveValue;
-  /** Maximum data-segment size for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Source: systemd v260.1, `systemd.exec(5)`. */
+  /** Maximum data-segment size for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Commands prefixed with `+` bypass this setting and its configured default, inheriting the service manager's resource limits instead. Source: systemd v262.1, `systemd.exec(5)`. */
   readonly LimitDATA?: ProcessResourceLimitDirectiveValue;
-  /** Maximum created-file size for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Source: systemd v260.1, `systemd.exec(5)`. */
+  /** Maximum created-file size for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Commands prefixed with `+` bypass this setting and its configured default, inheriting the service manager's resource limits instead. Source: systemd v262.1, `systemd.exec(5)`. */
   readonly LimitFSIZE?: ProcessResourceLimitDirectiveValue;
-  /** Maximum number of file locks for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Source: systemd v260.1, `systemd.exec(5)`. */
+  /** Maximum number of file locks for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Commands prefixed with `+` bypass this setting and its configured default, inheriting the service manager's resource limits instead. Source: systemd v262.1, `systemd.exec(5)`. */
   readonly LimitLOCKS?: ProcessResourceLimitDirectiveValue;
-  /** Maximum locked-in-memory size for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Source: systemd v260.1, `systemd.exec(5)`. */
+  /** Maximum locked-in-memory size for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Commands prefixed with `+` bypass this setting and its configured default, inheriting the service manager's resource limits instead. Source: systemd v262.1, `systemd.exec(5)`. */
   readonly LimitMEMLOCK?: ProcessResourceLimitDirectiveValue;
-  /** Maximum POSIX message-queue size for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Source: systemd v260.1, `systemd.exec(5)`. */
+  /** Maximum POSIX message-queue size for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Commands prefixed with `+` bypass this setting and its configured default, inheriting the service manager's resource limits instead. Source: systemd v262.1, `systemd.exec(5)`. */
   readonly LimitMSGQUEUE?: ProcessResourceLimitDirectiveValue;
-  /** Maximum nice-priority adjustment for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Source: systemd v260.1, `systemd.exec(5)`. */
+  /** Maximum nice-priority adjustment for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Commands prefixed with `+` bypass this setting and its configured default, inheriting the service manager's resource limits instead. Source: systemd v262.1, `systemd.exec(5)`. */
   readonly LimitNICE?: ProcessResourceLimitDirectiveValue;
-  /** Maximum number of open file descriptors for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Source: systemd v260.1, `systemd.exec(5)`. */
+  /** Maximum number of open file descriptors for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Commands prefixed with `+` bypass this setting and its configured default, inheriting the service manager's resource limits instead. Source: systemd v262.1, `systemd.exec(5)`. */
   readonly LimitNOFILE?: ProcessResourceLimitDirectiveValue;
-  /** Maximum number of processes or threads for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Source: systemd v260.1, `systemd.exec(5)`. */
+  /** Maximum number of processes or threads for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Commands prefixed with `+` bypass this setting and its configured default, inheriting the service manager's resource limits instead. Source: systemd v262.1, `systemd.exec(5)`. */
   readonly LimitNPROC?: ProcessResourceLimitDirectiveValue;
-  /** Maximum resident-set size for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Source: systemd v260.1, `systemd.exec(5)`. */
+  /** Maximum resident-set size for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Commands prefixed with `+` bypass this setting and its configured default, inheriting the service manager's resource limits instead. Source: systemd v262.1, `systemd.exec(5)`. */
   readonly LimitRSS?: ProcessResourceLimitDirectiveValue;
-  /** Maximum real-time scheduling priority for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Source: systemd v260.1, `systemd.exec(5)`. */
+  /** Maximum real-time scheduling priority for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Commands prefixed with `+` bypass this setting and its configured default, inheriting the service manager's resource limits instead. Source: systemd v262.1, `systemd.exec(5)`. */
   readonly LimitRTPRIO?: ProcessResourceLimitDirectiveValue;
-  /** Maximum real-time CPU time for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Source: systemd v260.1, `systemd.exec(5)`. */
+  /** Maximum real-time CPU time for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Commands prefixed with `+` bypass this setting and its configured default, inheriting the service manager's resource limits instead. Source: systemd v262.1, `systemd.exec(5)`. */
   readonly LimitRTTIME?: ProcessResourceLimitDirectiveValue;
-  /** Maximum number of queued signals for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Source: systemd v260.1, `systemd.exec(5)`. */
+  /** Maximum number of queued signals for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Commands prefixed with `+` bypass this setting and its configured default, inheriting the service manager's resource limits instead. Source: systemd v262.1, `systemd.exec(5)`. */
   readonly LimitSIGPENDING?: ProcessResourceLimitDirectiveValue;
-  /** Maximum stack size for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Source: systemd v260.1, `systemd.exec(5)`. */
+  /** Maximum stack size for processes started by the unit. Accepts the usual `soft:hard` syntax, `infinity`, and unit suffixes where systemd allows them. Commands prefixed with `+` bypass this setting and its configured default, inheriting the service manager's resource limits instead. Source: systemd v262.1, `systemd.exec(5)`. */
   readonly LimitSTACK?: ProcessResourceLimitDirectiveValue;
   /** Pass a credential to the unit. Credentials are limited-size binary or textual objects that may be passed to unit processes. They are primarily intended for passing cryptographic keys (both public and private) or certificates, user account information or identity information from host to services, but can be freely used to pass any kind of limited-size information to a service. The data is accessible from the unit's processes via the file system, at a read-only location that (if possible and permitted) is backed by non-swappable memory. The data is only accessible to the user associated with the unit, via the User=/DynamicUser= settings (as well as the superuser). When available, the location of credentials is exported as the $CREDENTIALS_DIRECTORY environment variable to the unit's processes. Source: systemd v260.1, `systemd.exec(5)`. */
   readonly LoadCredential?: string | readonly string[];
@@ -683,6 +685,8 @@ export interface SystemdServiceSection extends CustomDirectiveSection {
   readonly LogsDirectoryMode?: string;
   /** Storage quota for directories created by `LogsDirectory=`. Source: systemd v260.1, `systemd.exec(5)`. */
   readonly LogsDirectoryQuota?: number | string;
+  /** Creates named Live Update Orchestrator (LUO) sessions and passes their file descriptors through the service's file descriptor store. Takes whitespace-separated names; repeated assignments are combined, and an empty string resets the list. Implies `FileDescriptorStoreMax=` is at least the number of sessions. Use `FileDescriptorStorePreserve=true` to preserve them across kexec. Existing sessions with the same name are reused. If `/dev/liveupdate` is unavailable, the service starts normally without sessions. Only supported by the system service manager. Source: systemd v262, `systemd.service(5)`. */
+  readonly LUOSession?: string | readonly string[];
   /** See systemd.service(5) for ManagedOOMMemoryPressure=. Source: systemd v260.1, `systemd.service(5)`. */
   readonly ManagedOOMMemoryPressure?: ManagedOOMDirectiveValue;
   /** Overrides the default memory pressure duration set by oomd.conf5 for the cgroup of this unit. The specified value supports a time unit such as ms or μs, see systemd.time(7) for details on the permitted syntax. Must be set to either empty or a value of at least 1s. Defaults to empty, which means to use the default set by oomd.conf5. This property is ignored unless ManagedOOMMemoryPressure=kill. Source: systemd v260.1, `systemd.resource-control(5)`. */
@@ -731,7 +735,7 @@ export interface SystemdServiceSection extends CustomDirectiveSection {
   readonly NFTSet?: string | readonly string[];
   /** Controls the NUMA node list which will be applied alongside with selected NUMA policy. Takes a list of NUMA nodes and has the same syntax as a list of CPUs for CPUAffinity= option or special "all" value which will include all available NUMA nodes in the mask. Note that the list of NUMA nodes is not required for default and local policies and for preferred policy we expect a single NUMA node. Source: systemd v260.1, `systemd.exec(5)`. */
   readonly NUMAMask?: string | readonly string[];
-  /** Controls the NUMA memory policy of the executed processes. Takes a policy type, one of: default, preferred, bind, interleave and local. A list of NUMA nodes that should be associated with the policy must be specified in NUMAMask=. For more details on each policy please see, set_mempolicy(2). For overall overview of NUMA support in Linux see, numa(7). Source: systemd v260.1, `systemd.exec(5)`. */
+  /** Controls the NUMA memory policy: `default`, `preferred`, `bind`, `interleave`, `local`, `preferred-many` (Linux 5.15 or newer), or `weighted-interleave` (Linux 6.9 or newer). Configure associated nodes with `NUMAMask=` and weighted-interleave weights through `/sys/kernel/mm/mempolicy/weighted_interleave/`. Unsupported kernel policies log a warning and are ignored. Source: systemd v262, `systemd.exec(5)`. */
   readonly NUMAPolicy?: string | readonly string[];
   /** Takes an absolute file system path referring to a Linux network namespace pseudo-file (i.e. a file like /proc/$PID/ns/net or a bind mount or symlink to one). When set the invoked processes are added to the network namespace referenced by that path. The path has to point to a valid namespace file at the moment the processes are forked off. If this option is used PrivateNetwork= has no effect. If this option is used together with JoinsNamespaceOf= then it only has an effect if this unit is started before any of the listed units that have PrivateNetwork= or NetworkNamespacePath= configured, as otherwise the network namespace of those units is reused. Source: systemd v260.1, `systemd.exec(5)`. */
   readonly NetworkNamespacePath?: string;
@@ -803,7 +807,7 @@ export interface SystemdServiceSection extends CustomDirectiveSection {
   readonly ReadWritePaths?: string | readonly string[];
   /** Supports either booleans or a space-separated list of refreshable resource kinds such as `extensions` and `credentials`. Source: systemd v260.1, `systemd.service(5)`. */
   readonly RefreshOnReload?: boolean | string;
-  /** Configures the UNIX process signal to send to the service's main process when asked to reload the service's configuration. Defaults to SIGHUP. This option has no effect unless Type=notify-reload is used, see above. Source: systemd v260.1, `systemd.service(5)`. */
+  /** Selects the signal sent to the main process to reload a `Type=notify-reload` service. Defaults to SIGHUP and has no effect for other service types. The main process must catch or block this signal before its initial `READY=1` notification, or startup fails. The handler is checked again before reloading; a missing handler then causes a warning, but the signal is still sent. Source: systemd v262, `systemd.service(5)`. */
   readonly ReloadSignal?: NodeJS.Signals | number;
   /** Takes a boolean value that specifies whether the service shall be considered active even when all its processes exited. Defaults to no. Source: systemd v260.1, `systemd.service(5)`. */
   readonly RemainAfterExit?: boolean;
@@ -821,6 +825,8 @@ export interface SystemdServiceSection extends CustomDirectiveSection {
   readonly RestartMode?: ServiceRestartModeDirectiveValue;
   /** Takes a list of exit status definitions that, when returned by the main service process, will prevent automatic service restarts, regardless of the restart setting configured with Restart=. Exit status definitions can be numeric termination statuses, termination status names, or termination signal names, separated by spaces. Defaults to the empty list, so that, by default, no exit status is excluded from the configured restart logic. A service with the RestartPreventExitStatus= setting RestartPreventExitStatus=TEMPFAIL 250 SIGKILL Exit status 75 (TEMPFAIL), 250, and the termination signal SIGKILL will not result in automatic service restarting. This option may appear more than once, in which case the list of restart-preventing statuses is merged. If the empty string is assigned to this option, the list is reset and all prior assignments of this option will have no effect. Source: systemd v260.1, `systemd.service(5)`. */
   readonly RestartPreventExitStatus?: string | number | readonly (string | number)[];
+  /** Adds a uniformly distributed random delay between zero and this duration to automatic restarts, on top of `RestartSec=` and any exponential backoff configured by `RestartSteps=`/`RestartMaxDelaySec=`. Accepts seconds or a time span string. Defaults to 0, disabling the extra delay. Source: systemd v262, `systemd.service(5)`. */
+  readonly RestartRandomizedDelaySec?: number | string;
   /** Configures the time to sleep before restarting a service (as configured with Restart=). Takes a unit-less value in seconds, or a time span value such as "5min 20s". Defaults to 100ms. Source: systemd v260.1, `systemd.service(5)`. */
   readonly RestartSec?: number | string;
   /** Configures the number of exponential steps to take to increase the interval of auto-restarts from RestartSec= to RestartMaxDelaySec=. Takes a positive integer or 0 to disable it. Defaults to 0. Hint: values between 3 and 5 are good choices when exponential backoff is desired. Source: systemd v260.1, `systemd.service(5)`. */
@@ -833,7 +839,7 @@ export interface SystemdServiceSection extends CustomDirectiveSection {
   readonly RestrictNamespaces?: boolean | string | readonly string[];
   /** Takes a list of space-separated network interface names. This option restricts the network interfaces that processes of this unit can use. By default, processes can only use the network interfaces listed (allow-list). If the first character of the rule is ~, the effect is inverted: the processes can only use network interfaces not listed (deny-list). Source: systemd v260.1, `systemd.resource-control(5)`. */
   readonly RestrictNetworkInterfaces?: string | readonly string[];
-  /** If set, any attempts to enable realtime scheduling in a process of the unit are refused. This restricts access to realtime task scheduling policies such as SCHED_FIFO, SCHED_RR or SCHED_DEADLINE. See sched7 for details about these scheduling policies. Realtime scheduling policies may be used to monopolize CPU time for longer periods of time, and may hence be used to lock up or otherwise trigger Denial-of-Service situations on the system. It is hence recommended to restrict access to realtime scheduling to the few programs that actually require them. Defaults to off. Source: systemd v260.1, `systemd.exec(5)`. */
+  /** If set, any attempts to enable realtime scheduling in a process of the unit are refused. This restricts access to realtime task scheduling policies such as SCHED_FIFO, SCHED_RR or SCHED_DEADLINE. See sched7 for details about these scheduling policies. Realtime scheduling policies may be used to monopolize CPU time for longer periods of time, and may hence be used to lock up or otherwise trigger Denial-of-Service situations on the system. It is hence recommended to restrict access to realtime scheduling to the few programs that actually require them. The system call filter cannot inspect the scheduling policy passed to `sched_setattr()`, so that call is blocked entirely, including for non-realtime uses. Defaults to off. Source: systemd v262.1, `systemd.exec(5)`. */
   readonly RestrictRealtime?: boolean;
   /** If set, any attempts to set the set-user-ID (SUID) or set-group-ID (SGID) bits on files or directories will be denied (for details on these bits see inode7). As the SUID/SGID bits are mechanisms to elevate privileges, and allow users to acquire the identity of other users, it is recommended to restrict creation of SUID/SGID files to the few programs that actually require them. Note that this restricts marking of any type of file system object with these bits, including both regular files and directories (where the SGID is a different meaning than for files, see documentation). This option is implied if DynamicUser= is enabled. Seccomp blocks calls with directly supplied mode bits only when SUID or SGID is requested, but blocks calls such as openat2() entirely because their mode bits cannot be inspected. Source: systemd v261.3, `systemd.exec(5)`. */
   readonly RestrictSUIDSGID?: boolean;
@@ -869,7 +875,7 @@ export interface SystemdServiceSection extends CustomDirectiveSection {
   readonly RuntimeRandomizedExtraSec?: number | string;
   /** Set the SELinux security context of the executed process. If set, this will override the automated domain transition. However, the policy still needs to authorize the transition. This directive is ignored if SELinux is disabled. If prefixed by -, failing to set the SELinux security context will be ignored, but it is still possible that the subsequent execve() may fail if the policy does not allow the transition for the non-overridden context. This does not affect commands prefixed with +. See setexeccon3 for details. Source: systemd v260.1, `systemd.exec(5)`. */
   readonly SELinuxContext?: string;
-  /** Controls the secure bits set for the executed process. Takes a space-separated combination of options from the following list: keep-caps, keep-caps-locked, no-setuid-fixup, no-setuid-fixup-locked, noroot, and noroot-locked. This option may appear more than once, in which case the secure bits are ORed. If the empty string is assigned to this option, the bits are reset to 0. This does not affect commands prefixed with +. See capabilities(7) for details. Source: systemd v260.1, `systemd.exec(5)`. */
+  /** Sets a space-separated combination of secure bits: `keep-caps`, `no-setuid-fixup`, `noroot`, `no-cap-ambient-raise`, `exec-restrict-file`, `exec-deny-interactive`, and their `-locked` variants. Repeated assignments combine the bits; an empty string resets them to zero. Commands prefixed with `+` are unaffected. See capabilities(7) and the kernel executability-check documentation. Source: systemd v262, `systemd.exec(5)`. */
   readonly SecureBits?: string | readonly string[];
   /** Specifies whether to send SIGHUP to remaining processes immediately after sending the signal configured with KillSignal=. This is useful to indicate to shells and shell-like programs that their connection has been severed. Takes a boolean value. Defaults to no. Source: systemd v260.1, `systemd.kill(5)`. */
   readonly SendSIGHUP?: boolean;
@@ -997,7 +1003,7 @@ export interface SystemdServiceSection extends CustomDirectiveSection {
   readonly UtmpIdentifier?: string;
   /** Takes one of init, login or user. If UtmpIdentifier= is set, controls which type of utmp5/wtmp entries for this service are generated. This setting has no effect unless UtmpIdentifier= is set too. If init is set, only an INIT_PROCESS entry is generated and the invoked process must implement a getty-compatible utmp/wtmp logic. If login is set, first an INIT_PROCESS entry, followed by a LOGIN_PROCESS entry is generated. In this case, the invoked process must implement a login1-compatible utmp/wtmp logic. If user is set, first an INIT_PROCESS entry, then a LOGIN_PROCESS entry and finally a USER_PROCESS entry is generated. In this case, the invoked process may be any process that is suitable to be run as session leader. Defaults to init. Source: systemd v260.1, `systemd.exec(5)`. */
   readonly UtmpMode?: UtmpModeDirectiveValue;
-  /** Configures the mechanism via which the service notifies the manager that the service start-up has finished. One of simple, exec, forking, oneshot, dbus, notify, notify-reload, or idle:. Source: systemd v260.1, `systemd.service(5)`. */
+  /** Configures how the service notifies the manager that startup has finished: `simple`, `exec`, `forking`, `oneshot`, `dbus`, `notify`, `notify-reload`, or `idle`. With `notify-reload`, the main process must catch or block `ReloadSignal=` before sending its initial `READY=1` notification, or startup fails. Source: systemd v262, `systemd.service(5)`. */
   readonly Type?: ServiceTypeDirectiveValue;
   /** Configures the watchdog timeout for a service. The watchdog is activated when the start-up is completed. The service must call sd_notify3 regularly with WATCHDOG=1 (i.e. the "keep-alive ping"). If the time between two such calls is larger than the configured time, then the service is placed in a failed state and it will be terminated with SIGABRT (or the signal specified by WatchdogSignal=). By setting Restart= to on-failure, on-watchdog, on-abnormal or always, the service will be automatically restarted. The time configured here will be passed to the executed service process in the WATCHDOG_USEC= environment variable. This allows daemons to automatically enable the keep-alive pinging logic if watchdog support is enabled for the service. If this option is used, NotifyAccess= (see below) should be set to open access to the notification socket provided by systemd. If NotifyAccess= is not set, it will be implicitly set to main. Defaults to 0, which disables this feature. The service can check whether the service manager expects watchdog keep-alive notifications. See sd_watchdog_enabled3 for details. sd_event_set_watchdog3 may be used to enable automatic watchdog notification support. Source: systemd v260.1, `systemd.service(5)`. */
   readonly WatchdogSec?: number | string;

package/dist/index-6lsBWH4h.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-6lsBWH4h.d.mts","names":[],"sources":["../src/main/internal.ts","../src/main/executable.ts","../src/main/systemd-service.ts","../src/main/systemd-timer.ts","../src/main/types.ts","../src/main/errors.ts","../src/main/notify.ts","../src/main/systemctl.ts","../src/main/systemd.ts","../src/main/index.ts"],"mappings":"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"}

package/dist/main-DqJ5f7Al.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"main-DqJ5f7Al.mjs","names":["ok","err","I"],"sources":["../src/main/errors.ts","../src/main/executable.ts","../src/main/internal.ts","../src/main/notify.ts","../src/main/systemd-service.ts","../src/main/systemd-timer.ts","../src/main/systemctl.ts","../src/main/systemd.ts","../src/main/index.ts"],"sourcesContent":["import type { StartStatus } from \"./types.ts\";\n\nexport type SystemdTsErrorCode =\n  | `SYSTEMD_TS_INVALID_EXEC_DIRECTIVE`\n  | `SYSTEMD_TS_NO_UNITS_PROVIDED`\n  | `SYSTEMD_TS_EXECUTABLE_INFERENCE`\n  | `SYSTEMD_TS_UNIT_MATERIALIZATION`\n  | `SYSTEMD_TS_UNIT_ENABLE`\n  | `SYSTEMD_TS_UNIT_START`\n  | `SYSTEMD_TS_UNIT_LOGS`\n  | `SYSTEMD_TS_SYSTEMCTL`\n  | `SYSTEMD_TS_NOTIFY_SEND`;\n\nexport interface SystemdTsErrorOptions {\n  readonly cause?: unknown;\n}\n\nexport interface SystemdCommandErrorOptions extends SystemdTsErrorOptions {\n  readonly args?: readonly string[];\n  readonly command?: string;\n  readonly environmentReason?: SystemdCommandEnvironmentReason;\n  readonly stage?: string;\n  readonly unitName?: string;\n  readonly unitPath?: string;\n}\n\nexport interface UnitStartDiagnostics {\n  readonly showOutput?: string;\n  readonly showStatus?: StartStatus;\n  readonly statusOutput?: string;\n}\n\nexport interface UnitStartErrorOptions extends SystemdCommandErrorOptions {\n  readonly diagnostics?: UnitStartDiagnostics;\n}\n\nexport interface UnitMaterializationErrorOptions extends SystemdTsErrorOptions {\n  readonly reason?: UnitMaterializationErrorReason;\n  readonly operation?: `create-directory` | `write-file`;\n  readonly unitName?: string;\n  readonly unitPath?: string;\n}\n\nexport type UnitMaterializationErrorReason =\n  | `file-system-failed`\n  | `invalid-unit-directory`\n  | `permission-denied`;\n\nexport interface UnitLogsReadErrorOptions extends SystemdCommandErrorOptions {\n  readonly reason?: UnitLogsReadErrorReason;\n  readonly unitPath?: string;\n}\n\nexport type UnitLogsReadErrorReason =\n  | `missing-log-file`\n  | `log-file-read-failed`\n  | `status-command-failed`;\n\nexport interface NotifySendErrorOptions extends SystemdCommandErrorOptions {\n  readonly reason?: NotifySendErrorReason;\n}\n\nexport type NotifySendErrorReason = `executor-failed` | `systemd-notify-failed`;\n\nexport interface SystemctlCommandErrorOptions extends SystemdCommandErrorOptions {\n  readonly operation?: string;\n  readonly reason?: SystemctlCommandErrorReason;\n}\n\nexport type SystemctlCommandErrorReason = `executor-failed` | `invalid-json`;\n\nexport type SystemdCommandEnvironmentReason =\n  | `manager-unavailable`\n  | `missing-command`\n  | `permission-denied`;\n\nexport class SystemdTsError extends Error {\n  public readonly code: SystemdTsErrorCode;\n\n  public constructor(\n    code: SystemdTsErrorCode,\n    message: string,\n    options: SystemdTsErrorOptions = {},\n  ) {\n    super(message, { cause: options.cause });\n    this.code = code;\n    this.name = new.target.name;\n  }\n}\n\nexport class InvalidExecDirectiveError extends SystemdTsError {\n  public readonly directive: string;\n\n  public constructor(directive: string, options: SystemdTsErrorOptions = {}) {\n    super(\n      `SYSTEMD_TS_INVALID_EXEC_DIRECTIVE`,\n      `${directive} must use an absolute executable path for systemd`,\n      options,\n    );\n    this.directive = directive;\n  }\n}\n\nexport class NoUnitsProvidedError extends SystemdTsError {\n  public readonly operation: string;\n\n  public constructor(operation: string, options: SystemdTsErrorOptions = {}) {\n    super(\n      `SYSTEMD_TS_NO_UNITS_PROVIDED`,\n      `${operation} requires at least one service or timer`,\n      options,\n    );\n    this.operation = operation;\n  }\n}\n\nexport class ExecutableInferenceError extends SystemdTsError {\n  public constructor(options: SystemdTsErrorOptions = {}) {\n    super(\n      `SYSTEMD_TS_EXECUTABLE_INFERENCE`,\n      `Could not infer the calling module path for defineExecutable(); pass { modulePath } explicitly`,\n      options,\n    );\n  }\n}\n\nexport class UnitMaterializationError extends SystemdTsError {\n  public readonly operation: `create-directory` | `write-file` | undefined;\n  public readonly reason: UnitMaterializationErrorReason | undefined;\n  public readonly unitName: string | undefined;\n  public readonly unitPath: string | undefined;\n\n  public constructor(message: string, options: UnitMaterializationErrorOptions = {}) {\n    super(`SYSTEMD_TS_UNIT_MATERIALIZATION`, message, options);\n    this.operation = options.operation;\n    this.reason = options.reason;\n    this.unitName = options.unitName;\n    this.unitPath = options.unitPath;\n  }\n}\n\nexport class UnitEnableError extends SystemdTsError {\n  public readonly args: readonly string[] | undefined;\n  public readonly command: string | undefined;\n  public readonly environmentReason: SystemdCommandEnvironmentReason | undefined;\n  public readonly exitCode: number | undefined;\n  public readonly stage: string | undefined;\n  public readonly stderr: string | undefined;\n  public readonly stdout: string | undefined;\n  public readonly unitName: string | undefined;\n  public readonly unitPath: string | undefined;\n\n  public constructor(message: string, options: SystemdCommandErrorOptions = {}) {\n    super(`SYSTEMD_TS_UNIT_ENABLE`, message, options);\n    const details = extractCommandErrorDetails(options.cause);\n    this.args = options.args;\n    this.command = options.command;\n    this.environmentReason =\n      options.environmentReason ?? classifyCommandEnvironmentReason(options.cause);\n    this.exitCode = details.exitCode;\n    this.stage = options.stage;\n    this.stderr = details.stderr;\n    this.stdout = details.stdout;\n    this.unitName = options.unitName;\n    this.unitPath = options.unitPath;\n  }\n}\n\nexport class UnitStartError extends SystemdTsError {\n  public readonly args: readonly string[] | undefined;\n  public readonly command: string | undefined;\n  public readonly diagnostics: UnitStartDiagnostics | undefined;\n  public readonly environmentReason: SystemdCommandEnvironmentReason | undefined;\n  public readonly exitCode: number | undefined;\n  public readonly stage: string | undefined;\n  public readonly stderr: string | undefined;\n  public readonly stdout: string | undefined;\n  public readonly unitName: string | undefined;\n  public readonly unitPath: string | undefined;\n\n  public constructor(message: string, options: UnitStartErrorOptions = {}) {\n    super(`SYSTEMD_TS_UNIT_START`, message, options);\n    const details = extractCommandErrorDetails(options.cause);\n    this.args = options.args;\n    this.command = options.command;\n    this.diagnostics = options.diagnostics;\n    this.environmentReason =\n      options.environmentReason ?? classifyCommandEnvironmentReason(options.cause);\n    this.exitCode = details.exitCode;\n    this.stage = options.stage;\n    this.stderr = details.stderr;\n    this.stdout = details.stdout;\n    this.unitName = options.unitName;\n    this.unitPath = options.unitPath;\n  }\n}\n\nexport class UnitLogsReadError extends SystemdTsError {\n  public readonly args: readonly string[] | undefined;\n  public readonly command: string | undefined;\n  public readonly environmentReason: SystemdCommandEnvironmentReason | undefined;\n  public readonly exitCode: number | undefined;\n  public readonly reason: UnitLogsReadErrorReason | undefined;\n  public readonly stage: string | undefined;\n  public readonly stderr: string | undefined;\n  public readonly stdout: string | undefined;\n  public readonly unitName: string | undefined;\n  public readonly unitPath: string | undefined;\n\n  public constructor(message: string, options: UnitLogsReadErrorOptions = {}) {\n    super(`SYSTEMD_TS_UNIT_LOGS`, message, options);\n    const details = extractCommandErrorDetails(options.cause);\n    this.args = options.args;\n    this.command = options.command;\n    this.environmentReason =\n      options.environmentReason ?? classifyCommandEnvironmentReason(options.cause);\n    this.exitCode = details.exitCode;\n    this.reason = options.reason;\n    this.stage = options.stage;\n    this.stderr = details.stderr;\n    this.stdout = details.stdout;\n    this.unitName = options.unitName;\n    this.unitPath = options.unitPath;\n  }\n}\n\nexport class NotifySendError extends SystemdTsError {\n  public readonly args: readonly string[] | undefined;\n  public readonly command: string | undefined;\n  public readonly environmentReason: SystemdCommandEnvironmentReason | undefined;\n  public readonly exitCode: number | undefined;\n  public readonly reason: NotifySendErrorReason | undefined;\n  public readonly stage: string | undefined;\n  public readonly stderr: string | undefined;\n  public readonly stdout: string | undefined;\n\n  public constructor(message: string, options: NotifySendErrorOptions = {}) {\n    super(`SYSTEMD_TS_NOTIFY_SEND`, message, options);\n    const details = extractCommandErrorDetails(options.cause);\n    this.args = options.args;\n    this.command = options.command;\n    this.environmentReason =\n      options.environmentReason ?? classifyCommandEnvironmentReason(options.cause);\n    this.exitCode = details.exitCode;\n    this.reason = options.reason;\n    this.stage = options.stage;\n    this.stderr = details.stderr;\n    this.stdout = details.stdout;\n  }\n}\n\nexport class SystemctlCommandError extends SystemdTsError {\n  public readonly args: readonly string[] | undefined;\n  public readonly command: string | undefined;\n  public readonly environmentReason: SystemdCommandEnvironmentReason | undefined;\n  public readonly exitCode: number | undefined;\n  public readonly operation: string | undefined;\n  public readonly reason: SystemctlCommandErrorReason | undefined;\n  public readonly stage: string | undefined;\n  public readonly stderr: string | undefined;\n  public readonly stdout: string | undefined;\n\n  public constructor(message: string, options: SystemctlCommandErrorOptions = {}) {\n    super(`SYSTEMD_TS_SYSTEMCTL`, message, options);\n    const details = extractCommandErrorDetails(options.cause);\n    this.args = options.args;\n    this.command = options.command;\n    this.environmentReason =\n      options.environmentReason ?? classifyCommandEnvironmentReason(options.cause);\n    this.exitCode = details.exitCode;\n    this.operation = options.operation;\n    this.reason = options.reason;\n    this.stage = options.stage;\n    this.stderr = details.stderr;\n    this.stdout = details.stdout;\n  }\n}\n\nexport function classifyCommandEnvironmentReason(\n  cause: unknown,\n): SystemdCommandEnvironmentReason | undefined {\n  if (cause === null || typeof cause !== `object`) {\n    return undefined;\n  }\n\n  const record = cause as Record<string, unknown>;\n  if (record[`code`] === `ENOENT`) {\n    return `missing-command`;\n  }\n\n  if (record[`code`] === `EACCES` || record[`code`] === `EPERM`) {\n    return `permission-denied`;\n  }\n\n  const combinedOutput = [record[`stderr`], record[`stdout`]]\n    .filter((value): value is string => typeof value === `string` && value.length > 0)\n    .join(`\\n`);\n\n  if (\n    combinedOutput.includes(`Failed to connect to bus`) ||\n    combinedOutput.includes(`System has not been booted with systemd`) ||\n    combinedOutput.includes(`Failed to get D-Bus connection`)\n  ) {\n    return `manager-unavailable`;\n  }\n\n  return undefined;\n}\n\nexport function classifyMaterializationReason(\n  cause: unknown,\n): UnitMaterializationErrorReason | undefined {\n  if (cause === null || typeof cause !== `object`) {\n    return undefined;\n  }\n\n  const record = cause as Record<string, unknown>;\n  if (record[`code`] === `EACCES` || record[`code`] === `EPERM` || record[`code`] === `EROFS`) {\n    return `permission-denied`;\n  }\n\n  if (record[`code`] === `EEXIST` || record[`code`] === `ENOTDIR` || record[`code`] === `EISDIR`) {\n    return `invalid-unit-directory`;\n  }\n\n  return `file-system-failed`;\n}\n\nfunction extractCommandErrorDetails(cause: unknown): {\n  readonly exitCode: number | undefined;\n  readonly stderr: string | undefined;\n  readonly stdout: string | undefined;\n} {\n  if (cause === null || typeof cause !== `object`) {\n    return {\n      exitCode: undefined,\n      stderr: undefined,\n      stdout: undefined,\n    };\n  }\n\n  const record = cause as Record<string, unknown>;\n  return {\n    exitCode: typeof record[`code`] === `number` ? record[`code`] : undefined,\n    stderr: typeof record[`stderr`] === `string` ? record[`stderr`] : undefined,\n    stdout: typeof record[`stdout`] === `string` ? record[`stdout`] : undefined,\n  };\n}\n","import { realpathSync } from \"node:fs\";\nimport { fileURLToPath } from \"node:url\";\n\nimport { ExecutableInferenceError } from \"./errors.ts\";\nimport type { Result } from \"./internal.ts\";\nimport type { ExecutableOptions } from \"./types.ts\";\n\nconst currentModulePath = fileURLToPath(import.meta.url);\n\n/**\n * An immutable description of a runnable module entrypoint that can be used in\n * executable-valued systemd unit directives.\n *\n * `Executable` captures three pieces of information:\n * - the absolute runtime binary that should launch the module\n * - the absolute path to the module itself\n * - any additional arguments that should be passed after the module path\n *\n * Most consumers will create one via {@link defineExecutable} and then pass it\n * into a {@link SystemdService} directive such as `ExecStart`, `ExecStop`, or\n * `ExecReload`.\n */\nexport class Executable {\n  /** Additional arguments passed after the module path. */\n  public readonly args: readonly string[];\n  /** Inference issue captured when no explicit module path was provided. */\n  public readonly inferenceError: ExecutableInferenceError | undefined;\n  /** Absolute path to the module that should be executed. */\n  public readonly modulePath: string;\n  /** Absolute path to the runtime binary that should launch the module. */\n  public readonly runtimeEntrypoint: string;\n\n  /**\n   * Creates an executable description.\n   *\n   * When `modulePath` is omitted, the calling module is inferred from the\n   * current stack so `defineExecutable()` can be used inline from the module\n   * that should become runnable.\n   *\n   * When `runtimeEntrypoint` is omitted, the current process executable is\n   * used. This works well for the common case where the same runtime that is\n   * evaluating your module should also be used by systemd.\n   */\n  public constructor(options: ExecutableOptions = {}) {\n    this.runtimeEntrypoint = options.runtimeEntrypoint ?? process.execPath;\n    const inferredModulePath = options.modulePath ?? tryInferCallerModulePath();\n    this.inferenceError =\n      inferredModulePath === undefined && options.modulePath === undefined\n        ? new ExecutableInferenceError()\n        : undefined;\n    this.modulePath = inferredModulePath ?? ``;\n    this.args = Object.freeze([...(options.args ?? [])]);\n    Object.freeze(this);\n  }\n\n  /**\n   * Returns the executable as raw command parts.\n   *\n   * The first element is always the runtime entrypoint, followed by the module\n   * path and any configured arguments.\n   */\n  public toCommandParts(): Result<readonly [string, ...string[]], ExecutableInferenceError> {\n    if (this.inferenceError !== undefined) {\n      return {\n        ok: false,\n        error: this.inferenceError,\n      };\n    }\n\n    return {\n      ok: true,\n      value: [this.runtimeEntrypoint, this.modulePath, ...this.args],\n    };\n  }\n\n  /**\n   * Renders the executable as a shell-quoted command string suitable for\n   * executable-valued systemd directives such as `ExecStart=`.\n   */\n  public toExecStart(): Result<string, ExecutableInferenceError> {\n    const commandParts = this.toCommandParts();\n    if (!commandParts.ok) {\n      return commandParts;\n    }\n\n    return {\n      ok: true,\n      value: commandParts.value.map(shellQuote).join(` `),\n    };\n  }\n}\n\n/**\n * Defines a module as a runnable executable and returns its immutable\n * `Executable` description.\n *\n * This helper is designed for the pattern:\n *\n * ```ts\n * export default defineExecutable(async () => {\n *   // do work here\n * });\n * ```\n *\n * When the defining module is executed as the main entrypoint, `fn` is invoked.\n * When the module is merely imported, `fn` is not run and only the executable\n * description is returned.\n *\n * Pass `options.runtimeEntrypoint` to override the default runtime binary when\n * the current process is not the exact runtime you want systemd to use.\n */\nexport function defineExecutable(\n  fn: () => void | Promise<void>,\n  options: ExecutableOptions = {},\n): Executable {\n  const executable = new Executable(options);\n\n  if (executable.inferenceError === undefined && isMainModule(executable.modulePath)) {\n    void Promise.resolve(fn()).catch((error: unknown) => {\n      process.exitCode = 1;\n      throw error;\n    });\n  }\n\n  return executable;\n}\n\nfunction tryInferCallerModulePath(): string | undefined {\n  const stack = new Error().stack ?? ``;\n  for (const line of stack.split(`\\n`).slice(1)) {\n    const candidate = extractStackPath(line);\n    if (candidate === undefined || candidate === currentModulePath) {\n      continue;\n    }\n\n    return candidate;\n  }\n\n  return undefined;\n}\n\nfunction extractStackPath(line: string): string | undefined {\n  const fileUrlMatch = line.match(/(file:\\/\\/\\/[^)\\s:]+(?:\\.[cm]?[jt]s)?)/u);\n  if (fileUrlMatch !== null) {\n    return fileURLToPath(fileUrlMatch[1]);\n  }\n\n  const pathMatch = line.match(/(\\/[^)\\s:]+(?:\\.[cm]?[jt]s)?)/u);\n  if (pathMatch !== null) {\n    return pathMatch[1];\n  }\n\n  return undefined;\n}\n\nfunction isMainModule(modulePath: string): boolean {\n  const mainArg = process.argv[1];\n  if (mainArg === undefined) {\n    return false;\n  }\n\n  return normalizeFilePath(mainArg) === normalizeFilePath(modulePath);\n}\n\nfunction shellQuote(value: string): string {\n  return `'${value.replaceAll(`'`, `'\\\\''`)}'`;\n}\n\nfunction normalizeFilePath(path: string): string {\n  try {\n    return realpathSync(path);\n  } catch {\n    return path;\n  }\n}\n","import { execFile } from \"node:child_process\";\nimport { access } from \"node:fs/promises\";\nimport { promisify } from \"node:util\";\n\nimport { ExecutableInferenceError, InvalidExecDirectiveError, NotifySendError } from \"./errors.ts\";\nimport { Executable } from \"./executable.ts\";\nimport type {\n  CommandExecutionOptions,\n  CommandOutput,\n  NotifyOptions,\n  SystemdServiceSection,\n  StartStatus,\n  SystemdServiceOptions,\n  SystemdTimerOptions,\n  UnitValue,\n} from \"./types.ts\";\n\nexport type Result<TValue, TError> =\n  | {\n      readonly ok: true;\n      readonly value: TValue;\n    }\n  | {\n      readonly ok: false;\n      readonly error: TError;\n    };\n\ntype ExecDirectiveKey = (typeof EXEC_DIRECTIVE_KEYS)[number];\n\nconst EXEC_DIRECTIVE_KEYS = [\n  `ExecCondition`,\n  `ExecReload`,\n  `ExecReloadPost`,\n  `ExecStart`,\n  `ExecStartPost`,\n  `ExecStartPre`,\n  `ExecStop`,\n  `ExecStopPost`,\n] as const;\nconst execFileAsync = promisify(execFile);\ntype SectionLike = object;\n\nexport function normalizeUnitName(name: string, suffix: `.service` | `.timer`): string {\n  return name.endsWith(suffix) ? name.slice(0, -suffix.length) : name;\n}\n\nexport function resolveTimerTargetUnit(options: SystemdTimerOptions): string {\n  const explicitTarget = options.timer[`Unit`];\n  if (typeof explicitTarget === `string` && explicitTarget.length > 0) {\n    return explicitTarget;\n  }\n\n  return `${normalizeUnitName(options.name, `.timer`)}.service`;\n}\n\nexport function defaultUnitDirForScope(scope: `system` | `user`): string {\n  if (scope === `user`) {\n    return `${process.env[`HOME`] ?? `~`}/.config/systemd/user`;\n  }\n\n  return `/etc/systemd/system`;\n}\n\nexport function freezeUnitOptions<TOptions extends SystemdServiceOptions | SystemdTimerOptions>(\n  options: TOptions,\n): Readonly<TOptions> {\n  return Object.freeze({\n    ...options,\n    ...(options.unit === undefined ? {} : { unit: cloneUnitSection(options.unit) }),\n    ...(options.install === undefined ? {} : { install: cloneUnitSection(options.install) }),\n    ...(hasServiceSection(options) ? { service: cloneUnitSection(options.service) } : {}),\n    ...(hasTimerSection(options) ? { timer: cloneUnitSection(options.timer) } : {}),\n  }) as Readonly<TOptions>;\n}\n\nexport function cloneUnitSection<TSection extends SectionLike | undefined>(\n  section: TSection,\n): TSection {\n  if (section === undefined) {\n    return section;\n  }\n\n  const entries = Object.entries(section).map(([key, value]) => {\n    if (isUnitValueList(value)) {\n      return [key, Object.freeze([...value])] as const;\n    }\n\n    return [key, value] as const;\n  });\n\n  return Object.freeze(Object.fromEntries(entries)) as TSection;\n}\n\nexport function validateServiceSection(\n  service: SystemdServiceSection,\n): Result<void, InvalidExecDirectiveError> {\n  for (const key of EXEC_DIRECTIVE_KEYS) {\n    const validation = assertAbsoluteExecValue(key, service[key]);\n    if (!validation.ok) {\n      return validation;\n    }\n  }\n\n  return {\n    ok: true,\n    value: undefined,\n  };\n}\n\nexport function parseStartStatus(unit: string, output: string): StartStatus {\n  const properties = Object.fromEntries(\n    output\n      .split(`\\n`)\n      .map((line) => line.trim())\n      .filter((line) => line.length > 0)\n      .map((line) => {\n        const separatorIndex = line.indexOf(`=`);\n        if (separatorIndex === -1) {\n          return [line, ``] as const;\n        }\n\n        return [line.slice(0, separatorIndex), line.slice(separatorIndex + 1)] as const;\n      }),\n  );\n\n  return {\n    activeState: properties[`ActiveState`] ?? `unknown`,\n    execMainStatus:\n      properties[`ExecMainStatus`] === undefined || properties[`ExecMainStatus`] === ``\n        ? undefined\n        : Number(properties[`ExecMainStatus`]),\n    result: properties[`Result`] ?? `unknown`,\n    subState: properties[`SubState`] ?? `unknown`,\n    unit: properties[`Id`] ?? unit,\n  };\n}\n\nexport function renderUnitFile(\n  sections: ReadonlyArray<readonly [string, SectionLike | undefined]>,\n): Result<string, ExecutableInferenceError> {\n  try {\n    const renderedSections = sections\n      .flatMap(([sectionName, section]) => {\n        if (section === undefined) {\n          return [];\n        }\n\n        const lines: string[] = [];\n        for (const [key, value] of Object.entries(section as Record<string, unknown>)) {\n          if (value === undefined) {\n            continue;\n          }\n\n          if (isUnitValueList(value)) {\n            for (const entry of value) {\n              const rendered = stringifyUnitValue(entry);\n              if (!rendered.ok) {\n                throw rendered.error;\n              }\n              lines.push(`${key}=${rendered.value}`);\n            }\n            continue;\n          }\n\n          const rendered = stringifyUnitValue(value as UnitValue);\n          if (!rendered.ok) {\n            throw rendered.error;\n          }\n          lines.push(`${key}=${rendered.value}`);\n        }\n\n        if (lines.length === 0) {\n          return [];\n        }\n\n        return [`[${sectionName}]`, ...lines, ``];\n      })\n      .join(`\\n`);\n\n    return {\n      ok: true,\n      value: renderedSections.endsWith(`\\n`) ? renderedSections : `${renderedSections}\\n`,\n    };\n  } catch (error) {\n    return {\n      ok: false,\n      error:\n        error instanceof ExecutableInferenceError\n          ? error\n          : new ExecutableInferenceError({ cause: error }),\n    };\n  }\n}\n\nexport async function defaultCommandExecutor(\n  command: string,\n  args: readonly string[],\n  options: CommandExecutionOptions = {},\n): Promise<CommandOutput> {\n  const result = await execFileAsync(\n    command,\n    [...args],\n    options.env === undefined ? {} : { env: { ...process.env, ...options.env } },\n  );\n  return {\n    stderr: result.stderr,\n    stdout: result.stdout,\n  };\n}\n\nexport async function fileExists(path: string): Promise<boolean> {\n  try {\n    await access(path);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nexport async function sendNotify(\n  state: `READY=1` | `WATCHDOG=1`,\n  options: NotifyOptions,\n): Promise<void> {\n  const args: string[] = [`--no-block`, state];\n  if (options.pid !== undefined) {\n    args.push(`MAINPID=${options.pid}`);\n  }\n  if (options.status !== undefined) {\n    args.push(`STATUS=${options.status}`);\n  }\n\n  if (options.executor !== undefined) {\n    try {\n      await options.executor(\n        `systemd-notify`,\n        args,\n        options.socketPath === undefined ? {} : { env: { NOTIFY_SOCKET: options.socketPath } },\n      );\n    } catch (cause) {\n      throw new NotifySendError(\n        `Failed to send systemd notification through the configured executor`,\n        {\n          args,\n          cause,\n          command: `systemd-notify`,\n          reason: `executor-failed`,\n          stage: `executor`,\n        },\n      );\n    }\n    return;\n  }\n\n  try {\n    const result = await execFileAsync(`systemd-notify`, args, {\n      env: {\n        ...process.env,\n        ...(options.socketPath === undefined ? {} : { NOTIFY_SOCKET: options.socketPath }),\n      },\n    });\n\n    void result;\n  } catch (cause) {\n    throw new NotifySendError(`Failed to send systemd notification with systemd-notify`, {\n      args,\n      cause,\n      command: `systemd-notify`,\n      reason: `systemd-notify-failed`,\n      stage: `systemd-notify`,\n    });\n  }\n}\n\nexport function extractCommandOutput(cause: unknown): CommandOutput | undefined {\n  if (cause === null || typeof cause !== `object`) {\n    return undefined;\n  }\n\n  const record = cause as Record<string, unknown>;\n  const stdout = typeof record[`stdout`] === `string` ? record[`stdout`] : undefined;\n  const stderr = typeof record[`stderr`] === `string` ? record[`stderr`] : undefined;\n  if (stdout === undefined && stderr === undefined) {\n    return undefined;\n  }\n\n  return {\n    stderr: stderr ?? ``,\n    stdout: stdout ?? ``,\n  };\n}\n\nfunction hasServiceSection(\n  options: SystemdServiceOptions | SystemdTimerOptions,\n): options is SystemdServiceOptions {\n  return `service` in options;\n}\n\nfunction hasTimerSection(\n  options: SystemdServiceOptions | SystemdTimerOptions,\n): options is SystemdTimerOptions {\n  return `timer` in options;\n}\n\nfunction assertAbsoluteExecValue(\n  key: ExecDirectiveKey,\n  value: unknown,\n): Result<void, InvalidExecDirectiveError> {\n  if (isUnitValueList(value)) {\n    for (const entry of value) {\n      const validation = assertAbsoluteExecEntry(key, entry);\n      if (!validation.ok) {\n        return validation;\n      }\n    }\n\n    return {\n      ok: true,\n      value: undefined,\n    };\n  }\n\n  return assertAbsoluteExecEntry(key, value as UnitValue | undefined);\n}\n\nfunction assertAbsoluteExecEntry(\n  key: ExecDirectiveKey,\n  value: UnitValue | undefined,\n): Result<void, InvalidExecDirectiveError> {\n  if (typeof value === `string` && value.length > 0 && !isAbsoluteExecCommand(value)) {\n    return {\n      ok: false,\n      error: new InvalidExecDirectiveError(key),\n    };\n  }\n\n  if (value instanceof Executable && !value.runtimeEntrypoint.startsWith(`/`)) {\n    return {\n      ok: false,\n      error: new InvalidExecDirectiveError(key),\n    };\n  }\n\n  return {\n    ok: true,\n    value: undefined,\n  };\n}\n\nfunction stringifyUnitValue(value: UnitValue): Result<string, ExecutableInferenceError> {\n  if (value instanceof Executable) {\n    return value.toExecStart();\n  }\n\n  if (typeof value === `boolean`) {\n    return {\n      ok: true,\n      value: value ? `true` : `false`,\n    };\n  }\n\n  return {\n    ok: true,\n    value: String(value),\n  };\n}\n\nfunction isUnitValueList(value: unknown): value is readonly UnitValue[] {\n  return Array.isArray(value);\n}\n\nfunction isAbsoluteExecCommand(value: string): boolean {\n  let index = 0;\n  let hasPrivilegePrefix = false;\n\n  while (index < value.length) {\n    const prefix = value[index];\n    if (prefix === `@` || prefix === `-` || prefix === `:`) {\n      index += 1;\n      continue;\n    }\n\n    if (prefix === `+`) {\n      if (hasPrivilegePrefix) {\n        return false;\n      }\n\n      hasPrivilegePrefix = true;\n      index += 1;\n      continue;\n    }\n\n    if (prefix === `!`) {\n      if (hasPrivilegePrefix) {\n        return false;\n      }\n\n      hasPrivilegePrefix = true;\n      index += value[index + 1] === `!` ? 2 : 1;\n      continue;\n    }\n\n    break;\n  }\n\n  return value[index] === `/`;\n}\n","import { NotifySendError } from \"./errors.ts\";\nimport { sendNotify, type Result } from \"./internal.ts\";\nimport type { NotifyOptions } from \"./types.ts\";\n\n/**\n * Helpers for sending `sd_notify` state updates to systemd.\n *\n * These helpers send notification payloads to the socket identified by\n * `NOTIFY_SOCKET`, or to `options.socketPath` when one is provided explicitly.\n * They are useful both in real services and in tests that want to observe\n * readiness or watchdog traffic directly.\n *\n * Source:\n * - https://www.freedesktop.org/software/systemd/man/latest/sd_notify.html\n * - https://www.freedesktop.org/software/systemd/man/latest/systemd-notify.html\n */\nexport const notify = {\n  /**\n   * Sends `READY=1` to systemd.\n   *\n   * Use this when a `Type=notify` service has completed its startup work and is\n   * ready to be considered fully started. If `options.status` is provided, it is\n   * sent as an additional `STATUS=...` field.\n   */\n  async ready(options: NotifyOptions = {}): Promise<Result<void, NotifySendError>> {\n    try {\n      await sendNotify(`READY=1`, options);\n      return { ok: true, value: undefined };\n    } catch (error) {\n      return {\n        ok: false,\n        error:\n          error instanceof NotifySendError\n            ? error\n            : new NotifySendError(`Failed to send READY=1 notification`, {\n                cause: error,\n                stage: `ready`,\n              }),\n      };\n    }\n  },\n\n  /**\n   * Sends `WATCHDOG=1` to systemd.\n   *\n   * Use this when a service configured with `WatchdogSec=` needs to emit a\n   * watchdog heartbeat. If `options.pid` is provided, it is sent as\n   * `MAINPID=...`, and `options.status` is forwarded as `STATUS=...`.\n   */\n  async watchdog(options: NotifyOptions = {}): Promise<Result<void, NotifySendError>> {\n    try {\n      await sendNotify(`WATCHDOG=1`, options);\n      return { ok: true, value: undefined };\n    } catch (error) {\n      return {\n        ok: false,\n        error:\n          error instanceof NotifySendError\n            ? error\n            : new NotifySendError(`Failed to send WATCHDOG=1 notification`, {\n                cause: error,\n                stage: `watchdog`,\n              }),\n      };\n    }\n  },\n};\n","import {\n  cloneUnitSection,\n  freezeUnitOptions,\n  normalizeUnitName,\n  renderUnitFile,\n  validateServiceSection,\n} from \"./internal.ts\";\nimport type { ExecutableInferenceError, InvalidExecDirectiveError } from \"./errors.ts\";\nimport type { Result } from \"./internal.ts\";\nimport type {\n  ExactSystemdServiceOptions,\n  ServiceBaseName,\n  ServiceFilename,\n  SystemdServiceOptions,\n} from \"./types.ts\";\n\n/**\n * An immutable definition of a `.service` unit.\n *\n * `SystemdService` is a pure value object: it captures the intended unit name\n * and section contents, but it does not write files or talk to `systemd`\n * directly. Operational actions such as installation or startup belong on\n * {@link Systemd}.\n *\n * Source:\n * - https://www.freedesktop.org/software/systemd/man/latest/systemd.service.html\n */\nexport class SystemdService<const TOptions extends SystemdServiceOptions = SystemdServiceOptions> {\n  /** Optional `[Install]` section for enable-time relationships. */\n  public readonly install: TOptions[`install`] | undefined;\n  /** The normalized base unit name, without the `.service` suffix. */\n  public readonly name: ServiceBaseName<TOptions[`name`]>;\n  /** The fully frozen original options used to construct this service. */\n  public readonly options: Readonly<TOptions>;\n  /** The `[Service]` section payload. */\n  public readonly service: TOptions[`service`];\n  /** Optional `[Unit]` section metadata and dependency configuration. */\n  public readonly unit: TOptions[`unit`] | undefined;\n\n  /**\n   * Creates an immutable service definition.\n   *\n   * The constructor preserves literal types where possible and rejects unknown\n   * directive names within the provided sections, while still allowing custom\n   * `X-...` extension directives.\n   */\n  public constructor(options: TOptions & ExactSystemdServiceOptions<TOptions>) {\n    this.options = freezeUnitOptions(options as unknown as TOptions);\n    this.name = normalizeUnitName(options.name, `.service`) as ServiceBaseName<TOptions[`name`]>;\n    this.unit = cloneUnitSection(options.unit) as TOptions[`unit`] | undefined;\n    this.service = (cloneUnitSection(options.service) ?? {}) as TOptions[`service`];\n    this.install = cloneUnitSection(options.install) as TOptions[`install`] | undefined;\n    Object.freeze(this);\n  }\n\n  /** The canonical unit filename, including the `.service` suffix. */\n  public get filename(): ServiceFilename<TOptions[`name`]> {\n    return `${this.name}.service` as ServiceFilename<TOptions[`name`]>;\n  }\n\n  /**\n   * Renders the service as a complete unit file.\n   *\n   * Rendering also validates executable-valued directives such as `ExecStart`\n   * and `ExecStop`, ensuring they use absolute runtime entrypoints as required\n   * by systemd.\n   */\n  public render(): Result<string, ExecutableInferenceError | InvalidExecDirectiveError> {\n    const validation = validateServiceSection(this.service);\n    if (!validation.ok) {\n      return validation;\n    }\n\n    return renderUnitFile([\n      [`Unit`, this.unit],\n      [`Service`, this.service],\n      [`Install`, this.install],\n    ]);\n  }\n}\n","import {\n  cloneUnitSection,\n  freezeUnitOptions,\n  normalizeUnitName,\n  renderUnitFile,\n  resolveTimerTargetUnit,\n} from \"./internal.ts\";\nimport type { ExecutableInferenceError } from \"./errors.ts\";\nimport type { Result } from \"./internal.ts\";\nimport type {\n  ExactSystemdTimerOptions,\n  SystemdTimerOptions,\n  TimerBaseName,\n  TimerFilename,\n  TimerTargetServiceName,\n  TimerTargetUnit,\n} from \"./types.ts\";\n\n/**\n * An immutable definition of a `.timer` unit.\n *\n * Like {@link SystemdService}, this is a pure value object. It models the timer\n * configuration and its attachment target, but does not write files or interact\n * with the service manager directly.\n *\n * Source:\n * - https://www.freedesktop.org/software/systemd/man/latest/systemd.timer.html\n */\nexport class SystemdTimer<const TOptions extends SystemdTimerOptions = SystemdTimerOptions> {\n  /** Optional `[Install]` section for enable-time relationships. */\n  public readonly install: TOptions[`install`] | undefined;\n  /** The normalized base unit name, without the `.timer` suffix. */\n  public readonly name: TimerBaseName<TOptions[`name`]>;\n  /** The fully frozen original options used to construct this timer. */\n  public readonly options: Readonly<TOptions>;\n  /** The attached service basename inferred from `targetUnit`. */\n  public readonly targetServiceName: TimerTargetServiceName<TOptions>;\n  /** The unit name this timer activates, explicit or implicit. */\n  public readonly targetUnit: TimerTargetUnit<TOptions>;\n  /** The `[Timer]` section payload. */\n  public readonly timer: TOptions[`timer`];\n  /** Optional `[Unit]` section metadata and dependency configuration. */\n  public readonly unit: TOptions[`unit`] | undefined;\n\n  /**\n   * Creates an immutable timer definition.\n   *\n   * If no explicit `timer.Unit` is provided, the target defaults to the service\n   * with the same basename, matching systemd's native timer behavior.\n   */\n  public constructor(options: TOptions & ExactSystemdTimerOptions<TOptions>) {\n    this.options = freezeUnitOptions(options as unknown as TOptions);\n    this.name = normalizeUnitName(options.name, `.timer`) as TimerBaseName<TOptions[`name`]>;\n    this.unit = cloneUnitSection(options.unit) as TOptions[`unit`] | undefined;\n    this.timer = (cloneUnitSection(options.timer) ?? {}) as TOptions[`timer`];\n    this.install = cloneUnitSection(options.install) as TOptions[`install`] | undefined;\n    this.targetUnit = resolveTimerTargetUnit(\n      options as unknown as TOptions,\n    ) as TimerTargetUnit<TOptions>;\n    this.targetServiceName = normalizeUnitName(\n      this.targetUnit,\n      `.service`,\n    ) as TimerTargetServiceName<TOptions>;\n    Object.freeze(this);\n  }\n\n  /** The canonical unit filename, including the `.timer` suffix. */\n  public get filename(): TimerFilename<TOptions[`name`]> {\n    return `${this.name}.timer` as TimerFilename<TOptions[`name`]>;\n  }\n\n  /** Renders the timer as a complete unit file. */\n  public render(): Result<string, ExecutableInferenceError> {\n    return renderUnitFile([\n      [`Unit`, this.unit],\n      [`Timer`, this.timer],\n      [`Install`, this.install],\n    ]);\n  }\n}\n","import { defaultCommandExecutor, parseStartStatus } from \"./internal.ts\";\nimport { SystemctlCommandError } from \"./errors.ts\";\nimport type { Result } from \"./internal.ts\";\nimport type {\n  SystemctlActiveState,\n  CommandExecutor,\n  CommandOutput,\n  StartStatus,\n  SystemctlEnablementState,\n  SystemctlIsEnabledOptions,\n  SystemctlIsSystemRunningOptions,\n  SystemctlListTimersOptions,\n  SystemctlOptions,\n  SystemctlServiceStatus,\n  SystemctlStateQueryOptions,\n  SystemctlShowOptions,\n  SystemctlStatusOptions,\n  SystemctlSystemRunningState,\n  SystemctlTimerListEntry,\n} from \"./types.ts\";\n\n/**\n * A TypeScript-first client for invoking `systemctl` with structured argument\n * vectors instead of shell-composed command strings.\n *\n * This lower-level primitive is useful both on its own and as the subprocess\n * transport underneath higher-level abstractions such as {@link Systemd}.\n */\nexport class Systemctl {\n  /** Command executor used for `systemctl` subprocesses. */\n  public readonly executor: CommandExecutor;\n  /** The target manager scope, either `system` or `user`. */\n  public readonly scope: `system` | `user`;\n\n  public constructor(options: SystemctlOptions = {}) {\n    this.scope = options.scope ?? `system`;\n    this.executor = options.executor ?? defaultCommandExecutor;\n    Object.freeze(this);\n  }\n\n  /** Reloads the targeted systemd manager. */\n  public async daemonReload(): Promise<Result<CommandOutput, SystemctlCommandError>> {\n    return this.run(`daemon-reload`);\n  }\n\n  /** Enables a unit by filename. */\n  public async enable(unit: string): Promise<Result<CommandOutput, SystemctlCommandError>> {\n    return this.run(`enable`, unit);\n  }\n\n  /** Disables a unit by filename. */\n  public async disable(unit: string): Promise<Result<CommandOutput, SystemctlCommandError>> {\n    return this.run(`disable`, unit);\n  }\n\n  /** Links a unit file path into the targeted manager. */\n  public async link(path: string): Promise<Result<CommandOutput, SystemctlCommandError>> {\n    return this.run(`link`, path);\n  }\n\n  /**\n   * Checks the install-time enablement state of a unit file.\n   *\n   * Source:\n   * - systemd v260.1, `systemctl(1)`\n   */\n  public async isEnabled(\n    unit: string,\n    options: SystemctlIsEnabledOptions = {},\n  ): Promise<Result<SystemctlEnablementState, SystemctlCommandError>> {\n    const output = await this.run(\n      `is-enabled`,\n      ...(options.full ? [`--full`] : []),\n      ...(options.quiet ? [`--quiet`] : []),\n      unit,\n    );\n    if (!output.ok) {\n      return output;\n    }\n    return ok(firstNonEmptyOutputLine(output.value) as SystemctlEnablementState);\n  }\n\n  /**\n   * Checks the runtime active state of a unit.\n   *\n   * Unless `quiet` is set, this returns the state string printed by\n   * `systemctl is-active`.\n   */\n  public async isActive(\n    unit: string,\n    options: SystemctlStateQueryOptions = {},\n  ): Promise<Result<SystemctlActiveState, SystemctlCommandError>> {\n    const output = await this.run(`is-active`, ...(options.quiet ? [`--quiet`] : []), unit);\n    if (!output.ok) {\n      return output;\n    }\n    return ok(firstNonEmptyOutputLine(output.value) as SystemctlActiveState);\n  }\n\n  /**\n   * Checks whether a unit is in the failed state.\n   *\n   * Unless `quiet` is set, this returns the state string printed by\n   * `systemctl is-failed`.\n   */\n  public async isFailed(\n    unit: string,\n    options: SystemctlStateQueryOptions = {},\n  ): Promise<Result<SystemctlActiveState, SystemctlCommandError>> {\n    const output = await this.run(`is-failed`, ...(options.quiet ? [`--quiet`] : []), unit);\n    if (!output.ok) {\n      return output;\n    }\n    return ok(firstNonEmptyOutputLine(output.value) as SystemctlActiveState);\n  }\n\n  /**\n   * Queries the overall manager state reported by `systemctl is-system-running`.\n   *\n   * Source:\n   * - systemd v260.1, `systemctl(1)`\n   */\n  public async isSystemRunning(\n    options: SystemctlIsSystemRunningOptions = {},\n  ): Promise<Result<SystemctlSystemRunningState, SystemctlCommandError>> {\n    const output = await this.run(`is-system-running`, ...(options.wait ? [`--wait`] : []));\n    if (!output.ok) {\n      return output;\n    }\n    return ok(firstNonEmptyOutputLine(output.value) as SystemctlSystemRunningState);\n  }\n\n  /**\n   * Queries `systemctl show` for a unit.\n   *\n   * When `properties` are provided, only those properties are requested.\n   */\n  public async show(\n    unit: string,\n    options: SystemctlShowOptions = {},\n  ): Promise<Result<CommandOutput, SystemctlCommandError>> {\n    const propertyFlag =\n      options.properties === undefined || options.properties.length === 0\n        ? []\n        : [`--property=${options.properties.join(`,`)}`];\n    return this.run(`show`, unit, ...propertyFlag);\n  }\n\n  /**\n   * Queries `systemctl show` and parses the result into a key-value object.\n   *\n   * Properties are returned exactly as printed by `systemctl show`.\n   */\n  public async showProperties(\n    unit: string,\n    options: SystemctlShowOptions = {},\n  ): Promise<Result<Readonly<Record<string, string>>, SystemctlCommandError>> {\n    const output = await this.show(unit, options);\n    if (!output.ok) {\n      return output;\n    }\n    return ok(parseSystemctlShowOutput(output.value.stdout));\n  }\n\n  /**\n   * Queries the standard status-related `show` properties for a unit and\n   * returns a parsed snapshot.\n   */\n  public async showStatus(unit: string): Promise<Result<StartStatus, SystemctlCommandError>> {\n    return this.showServiceStatus(unit);\n  }\n\n  /**\n   * Queries the standard service-status `show` properties for a service unit\n   * and returns a parsed snapshot.\n   */\n  public async showServiceStatus(\n    unit: string,\n  ): Promise<Result<SystemctlServiceStatus, SystemctlCommandError>> {\n    const output = await this.show(unit, {\n      properties: [`Id`, `ActiveState`, `SubState`, `Result`, `ExecMainStatus`],\n    });\n    if (!output.ok) {\n      return output;\n    }\n    return ok(parseStartStatus(unit, output.value.stdout));\n  }\n\n  /**\n   * Queries `systemctl list-timers` and returns the observed JSON payload\n   * shape directly, with raw integer timestamps left intact.\n   */\n  public async listTimers(\n    options: SystemctlListTimersOptions = {},\n  ): Promise<Result<readonly SystemctlTimerListEntry[], SystemctlCommandError>> {\n    const args = [\n      `list-timers`,\n      ...(options.all ? [`--all`] : []),\n      ...((options.noPager ?? true) ? [`--no-pager`] : []),\n      `--output=json`,\n      ...(options.patterns ?? []),\n    ] as const;\n    const output = await this.run(...args);\n    if (!output.ok) {\n      return output;\n    }\n    try {\n      return ok(JSON.parse(output.value.stdout) as readonly SystemctlTimerListEntry[]);\n    } catch (cause) {\n      return err(\n        new SystemctlCommandError(`Failed to parse JSON output from systemctl list-timers`, {\n          args: [...this.scopeArgs(), ...args],\n          cause,\n          command: `systemctl`,\n          operation: `list-timers`,\n          reason: `invalid-json`,\n        }),\n      );\n    }\n  }\n\n  /** Starts a unit by filename. */\n  public async start(unit: string): Promise<Result<CommandOutput, SystemctlCommandError>> {\n    return this.run(`start`, unit);\n  }\n\n  /** Stops a unit by filename. */\n  public async stop(unit: string): Promise<Result<CommandOutput, SystemctlCommandError>> {\n    return this.run(`stop`, unit);\n  }\n\n  /** Restarts a unit by filename. */\n  public async restart(unit: string): Promise<Result<CommandOutput, SystemctlCommandError>> {\n    return this.run(`restart`, unit);\n  }\n\n  /**\n   * Resets the failed state for matching units, or for all units when no\n   * patterns are provided.\n   */\n  public async resetFailed(\n    patterns: readonly string[] = [],\n  ): Promise<Result<CommandOutput, SystemctlCommandError>> {\n    return this.run(`reset-failed`, ...patterns);\n  }\n\n  /**\n   * Queries `systemctl status` for a unit.\n   *\n   * This is primarily a human-oriented command and is best paired with\n   * `show()` when structured state is needed.\n   */\n  public async status(\n    unit: string,\n    options: SystemctlStatusOptions = {},\n  ): Promise<Result<CommandOutput, SystemctlCommandError>> {\n    const args = [`status`, unit] as string[];\n    if (options.noPager ?? true) {\n      args.push(`--no-pager`);\n    }\n    if (options.lines !== undefined) {\n      args.push(`--lines`, String(options.lines));\n    }\n\n    return this.run(...args);\n  }\n\n  /** Executes a raw `systemctl` invocation with scope-aware arguments. */\n  public async run(\n    ...args: readonly string[]\n  ): Promise<Result<CommandOutput, SystemctlCommandError>> {\n    const scopedArgs = [...this.scopeArgs(), ...args];\n    try {\n      return ok(await this.executor(`systemctl`, scopedArgs));\n    } catch (cause) {\n      return err(\n        new SystemctlCommandError(`Failed to run systemctl ${args[0] ?? `command`}`, {\n          args: scopedArgs,\n          cause,\n          command: `systemctl`,\n          operation: args[0],\n          reason: `executor-failed`,\n        }),\n      );\n    }\n  }\n\n  private scopeArgs(): readonly string[] {\n    return this.scope === `user` ? [`--user`] : [];\n  }\n}\n\nfunction ok<TValue>(value: TValue): Result<TValue, never> {\n  return { ok: true, value };\n}\n\nfunction err<TError>(error: TError): Result<never, TError> {\n  return { ok: false, error };\n}\n\nfunction parseSystemctlShowOutput(output: string): Readonly<Record<string, string>> {\n  return Object.freeze(\n    Object.fromEntries(\n      output\n        .split(`\\n`)\n        .map((line) => line.trim())\n        .filter((line) => line.length > 0)\n        .map((line) => {\n          const separatorIndex = line.indexOf(`=`);\n          if (separatorIndex === -1) {\n            return [line, ``] as const;\n          }\n\n          return [line.slice(0, separatorIndex), line.slice(separatorIndex + 1)] as const;\n        }),\n    ),\n  );\n}\n\nfunction firstNonEmptyOutputLine(output: CommandOutput): string {\n  const line = [output.stdout, output.stderr]\n    .flatMap((value) => value.split(`\\n`))\n    .map((value) => value.trim())\n    .find((value) => value.length > 0);\n  return line ?? ``;\n}\n","import { mkdir, readFile, rm, writeFile } from \"node:fs/promises\";\nimport { join } from \"node:path\";\n\nimport {\n  defaultCommandExecutor,\n  defaultUnitDirForScope,\n  extractCommandOutput,\n  fileExists,\n  parseStartStatus,\n  type Result,\n} from \"./internal.ts\";\nimport {\n  classifyMaterializationReason,\n  NoUnitsProvidedError,\n  ExecutableInferenceError,\n  InvalidExecDirectiveError,\n  UnitEnableError,\n  UnitLogsReadError,\n  UnitMaterializationError,\n  UnitStartError,\n} from \"./errors.ts\";\nimport { SystemdService } from \"./systemd-service.ts\";\nimport { Systemctl } from \"./systemctl.ts\";\nimport { SystemdTimer } from \"./systemd-timer.ts\";\nimport type {\n  CommandExecutor,\n  MaterializedUnit,\n  LogsOptions,\n  StartStatus,\n  SystemdOptions,\n  SystemdUnit,\n  ValidInstallUnits,\n} from \"./types.ts\";\n\nexport interface SystemdTsAttachOptions {\n  readonly owner: string;\n  readonly enable?: boolean;\n  readonly start?: boolean;\n}\n\nexport interface SystemdTsDetachOptions {\n  readonly deleteUnitFiles?: boolean;\n  readonly disable?: boolean;\n  readonly stop?: boolean;\n}\n\nexport interface SystemdTsReattachOptions extends SystemdTsAttachOptions {\n  readonly disableRemoved?: boolean;\n  readonly prune?: boolean;\n  readonly restartUpdated?: boolean;\n  readonly stopRemoved?: boolean;\n}\n\nexport interface SystemdTsAttachmentSelector {\n  readonly owner: string;\n}\n\nexport interface SystemdTsAttachmentResult {\n  readonly added: readonly string[];\n  readonly directory: string;\n  readonly enabled: readonly string[];\n  readonly manifestPath: string;\n  readonly owner: string;\n  readonly removed: readonly string[];\n  readonly restarted: readonly string[];\n  readonly started: readonly string[];\n  readonly unchanged: readonly string[];\n  readonly updated: readonly string[];\n}\n\ninterface AttachmentManifest {\n  readonly owner: string;\n  readonly units: readonly {\n    readonly filename: string;\n    readonly path: string;\n  }[];\n  readonly version: 1;\n}\n\n/**\n * A successful systemd unit materialization.\n *\n * It records the target directory and the on-disk path associated with each\n * materialized unit.\n */\nexport class SystemdMaterialization<\n  TUnits extends readonly SystemdUnit[] = readonly SystemdUnit[],\n> {\n  /** The directory units were written into. */\n  public readonly directory: string;\n  /** The materialized units together with their resolved on-disk paths. */\n  public readonly materialized: readonly MaterializedUnit<TUnits[number]>[];\n\n  public constructor(directory: string, materialized: readonly MaterializedUnit<TUnits[number]>[]) {\n    this.directory = directory;\n    this.materialized = Object.freeze([...materialized]);\n    Object.freeze(this);\n  }\n}\n\n/**\n * A configured interface to a specific systemd environment.\n *\n * `Systemd` combines unit-file materialization with a command execution\n * strategy. It knows which scope it is targeting, where unit files should be\n * written, and how `systemctl` should be invoked.\n *\n * This abstraction is intentionally close to `systemctl` concepts while still\n * accepting full unit definitions instead of loose unit-name strings.\n */\nexport class Systemd {\n  /** Command executor used for `systemctl` and related subprocess calls. */\n  public readonly executor: CommandExecutor;\n  /** Whether units should be linked into systemd before manager operations. */\n  public readonly linkUnits: boolean;\n  /** The target manager scope, either `system` or `user`. */\n  public readonly scope: `system` | `user`;\n  /** The low-level `systemctl` client for this configured target. */\n  public readonly systemctl: Systemctl;\n  /** Higher-level `systemd-ts` upkeep helpers for application-owned units. */\n  public readonly ts: SystemdTs;\n  /** The directory used when materializing unit files. */\n  public readonly unitDir: string;\n\n  /**\n   * Creates a configured `Systemd` facade.\n   *\n   * By default, this targets the system scope and `/etc/systemd/system`. Use\n   * `scope: \"user\"` or an explicit `unitDir` to target a different manager or\n   * unit-file location.\n   */\n  public constructor(options: SystemdOptions = {}) {\n    this.scope = options.scope ?? `system`;\n    this.unitDir = options.unitDir ?? defaultUnitDirForScope(this.scope);\n    this.linkUnits = options.linkUnits ?? false;\n    this.executor = options.executor ?? defaultCommandExecutor;\n    this.systemctl = new Systemctl({\n      executor: this.executor,\n      scope: this.scope,\n    });\n    this.ts = new SystemdTs(this);\n    Object.freeze(this);\n  }\n\n  /**\n   * Renders and writes one or more units into this instance's `unitDir`.\n   *\n   * This is intentionally a file-materialization step. It does not enable or\n   * start the units on its own.\n   */\n  public async materialize<const TUnits extends readonly SystemdUnit[]>(\n    ...units: TUnits & ValidInstallUnits<TUnits>\n  ): Promise<\n    Result<\n      SystemdMaterialization<TUnits>,\n      | ExecutableInferenceError\n      | InvalidExecDirectiveError\n      | NoUnitsProvidedError\n      | UnitMaterializationError\n    >\n  > {\n    return this.materializeUnits(units);\n  }\n\n  /**\n   * Enables one or more units via `systemctl enable`.\n   *\n   * When `linkUnits` is enabled, this first links materialized unit files into the\n   * target manager and reloads systemd so the units are visible before the\n   * enable operation runs.\n   */\n  public async enable(\n    ...units: readonly SystemdUnit[]\n  ): Promise<Result<void, NoUnitsProvidedError | UnitEnableError>> {\n    if (units.length === 0) {\n      return err(new NoUnitsProvidedError(`Systemd.enable()`));\n    }\n\n    const scopeArgs = this.scopeArgs();\n    try {\n      await this.prepareUnits(scopeArgs, units, `enable`);\n    } catch (cause) {\n      if (cause instanceof UnitEnableError) {\n        return err(cause);\n      }\n\n      return err(\n        new UnitEnableError(`Failed to prepare units for enable`, {\n          cause,\n          stage: `prepare`,\n          unitName: units[0]?.filename,\n        }),\n      );\n    }\n\n    for (const unit of units) {\n      const args = [...scopeArgs, `enable`, unit.filename] as const;\n      const enabled = await this.systemctl.enable(unit.filename);\n      if (!enabled.ok) {\n        const errorOptions = {\n          args,\n          cause: enabled.error,\n          command: `systemctl`,\n          stage: `enable`,\n          unitName: unit.filename,\n          ...(enabled.error.environmentReason === undefined\n            ? {}\n            : { environmentReason: enabled.error.environmentReason }),\n        };\n        return err(new UnitEnableError(`Failed to enable ${unit.filename}`, errorOptions));\n      }\n    }\n\n    return ok(undefined);\n  }\n\n  /**\n   * Starts a unit and returns a parsed `systemctl show` snapshot of its final\n   * observed state.\n   *\n   * For oneshot services, a successful result commonly means `ActiveState` is\n   * already back to `inactive` by the time the status snapshot is collected.\n   */\n  public async start(unit: SystemdUnit): Promise<Result<StartStatus, UnitStartError>> {\n    const scopeArgs = this.scopeArgs();\n    try {\n      await this.prepareUnits(scopeArgs, [unit], `start`);\n    } catch (cause) {\n      if (cause instanceof UnitStartError) {\n        return err(cause);\n      }\n\n      return err(\n        new UnitStartError(`Failed to prepare ${unit.filename} for start`, {\n          cause,\n          diagnostics: await this.collectStartDiagnostics(scopeArgs, unit.filename),\n          stage: `prepare`,\n          unitName: unit.filename,\n        }),\n      );\n    }\n\n    const startArgs = [...scopeArgs, `start`, unit.filename] as const;\n    const started = await this.systemctl.start(unit.filename);\n    if (!started.ok) {\n      const errorOptions = {\n        args: startArgs,\n        cause: started.error,\n        command: `systemctl`,\n        diagnostics: await this.collectStartDiagnostics(scopeArgs, unit.filename),\n        stage: `start`,\n        unitName: unit.filename,\n        ...(started.error.environmentReason === undefined\n          ? {}\n          : { environmentReason: started.error.environmentReason }),\n      };\n      return err(new UnitStartError(`Failed to start ${unit.filename}`, errorOptions));\n    }\n\n    const status = await this.systemctl.showServiceStatus(unit.filename);\n    if (!status.ok) {\n      const errorOptions = {\n        args: [\n          ...scopeArgs,\n          `show`,\n          unit.filename,\n          `--property=Id,ActiveState,SubState,Result,ExecMainStatus`,\n        ] as const,\n        cause: status.error,\n        command: `systemctl`,\n        diagnostics: await this.collectStartDiagnostics(scopeArgs, unit.filename),\n        stage: `show-status`,\n        unitName: unit.filename,\n        ...(status.error.environmentReason === undefined\n          ? {}\n          : { environmentReason: status.error.environmentReason }),\n      };\n      return err(\n        new UnitStartError(`Started ${unit.filename} but failed to query its status`, errorOptions),\n      );\n    }\n    return ok(status.value);\n  }\n\n  /**\n   * Reads recent output for a managed unit.\n   *\n   * If the unit is configured with file-backed `StandardOutput` or\n   * `StandardError`, this reads directly from that file. Otherwise it falls back\n   * to `systemctl status --lines ...`.\n   */\n  public async logs(\n    unit: SystemdUnit,\n    options?: LogsOptions,\n  ): Promise<Result<string, UnitLogsReadError>> {\n    const fileLogPath = resolveUnitLogPath(unit);\n    if (fileLogPath !== undefined) {\n      try {\n        const output = await readFile(fileLogPath, `utf8`);\n        return ok(tailLines(output, options?.lines ?? 50));\n      } catch (cause) {\n        return err(\n          new UnitLogsReadError(`Failed to read logs for ${unit.filename} from ${fileLogPath}`, {\n            cause,\n            reason: isMissingPathError(cause) ? `missing-log-file` : `log-file-read-failed`,\n            stage: `read-log-file`,\n            unitName: unit.filename,\n            unitPath: fileLogPath,\n          }),\n        );\n      }\n    }\n\n    const scopeArgs = this.scopeArgs();\n    const lines = options?.lines ?? 50;\n    const logs = await this.systemctl.status(unit.filename, {\n      lines,\n    });\n    if (logs.ok) {\n      return ok(joinCommandOutput(logs.value));\n    }\n\n    const errorOutput = extractCommandOutput(logs.error);\n    if (errorOutput !== undefined) {\n      return ok(joinCommandOutput(errorOutput));\n    }\n\n    const args = [\n      ...scopeArgs,\n      `status`,\n      unit.filename,\n      `--no-pager`,\n      `--lines`,\n      String(lines),\n    ] as const;\n    return err(\n      new UnitLogsReadError(`Failed to query logs for ${unit.filename} from systemctl status`, {\n        args,\n        cause: logs.error,\n        command: `systemctl`,\n        reason: `status-command-failed`,\n        stage: `status`,\n        unitName: unit.filename,\n      }),\n    );\n  }\n\n  /** Returns the on-disk unit-file path this instance uses for the given unit. */\n  public pathFor(unit: SystemdUnit): string {\n    return join(this.unitDir, unit.filename);\n  }\n\n  private async prepareUnits(\n    scopeArgs: readonly string[],\n    units: readonly SystemdUnit[],\n    operation: `enable` | `start`,\n  ): Promise<void> {\n    if (this.linkUnits) {\n      const linkPaths = await this.collectLinkPaths(units);\n      for (const path of linkPaths) {\n        const args = [...scopeArgs, `link`, path] as const;\n        const linked = await this.systemctl.link(path);\n        if (!linked.ok) {\n          const linkedUnit = units.find((candidate) => this.pathFor(candidate) === path);\n          const errorContext = {\n            args,\n            cause: linked.error,\n            command: `systemctl`,\n            stage: `link`,\n            unitPath: path,\n            ...(linked.error.environmentReason === undefined\n              ? {}\n              : { environmentReason: linked.error.environmentReason }),\n            ...(linkedUnit === undefined ? {} : { unitName: linkedUnit.filename }),\n          };\n          throw operation === `enable`\n            ? new UnitEnableError(`Failed to link ${path} before enable`, errorContext)\n            : new UnitStartError(`Failed to link ${path} before start`, errorContext);\n        }\n      }\n    }\n\n    const args = [...scopeArgs, `daemon-reload`] as const;\n    const reloaded = await this.systemctl.daemonReload();\n    if (!reloaded.ok) {\n      const errorContext = {\n        args,\n        cause: reloaded.error,\n        command: `systemctl`,\n        stage: `daemon-reload`,\n        ...(reloaded.error.environmentReason === undefined\n          ? {}\n          : { environmentReason: reloaded.error.environmentReason }),\n        ...(units[0]?.filename === undefined ? {} : { unitName: units[0].filename }),\n      };\n      throw operation === `enable`\n        ? new UnitEnableError(`Failed to reload systemd before enable`, errorContext)\n        : new UnitStartError(`Failed to reload systemd before start`, errorContext);\n    }\n  }\n\n  private scopeArgs(): readonly string[] {\n    return this.scope === `user` ? [`--user`] : [];\n  }\n\n  private async collectStartDiagnostics(\n    scopeArgs: readonly string[],\n    unitName: string,\n  ): Promise<{\n    readonly showOutput?: string;\n    readonly showStatus?: StartStatus;\n    readonly statusOutput?: string;\n  }> {\n    const diagnostics: {\n      showOutput?: string;\n      showStatus?: StartStatus;\n      statusOutput?: string;\n    } = {};\n\n    const showArgs = [\n      ...scopeArgs,\n      `show`,\n      unitName,\n      `--property=Id,ActiveState,SubState,Result,ExecMainStatus`,\n    ] as const;\n    const show = await this.tryBestEffortCommand(`systemctl`, showArgs);\n    if (show !== undefined) {\n      const showOutput = joinCommandOutput(show);\n      if (showOutput.length > 0) {\n        diagnostics.showOutput = showOutput;\n      }\n      if (show.stdout.length > 0) {\n        diagnostics.showStatus = parseStartStatus(unitName, show.stdout);\n      }\n    }\n\n    const statusArgs = [...scopeArgs, `status`, unitName, `--no-pager`, `--lines`, `20`] as const;\n    const status = await this.tryBestEffortCommand(`systemctl`, statusArgs);\n    if (status !== undefined) {\n      const statusOutput = joinCommandOutput(status);\n      if (statusOutput.length > 0) {\n        diagnostics.statusOutput = statusOutput;\n      }\n    }\n\n    return diagnostics;\n  }\n\n  private async collectLinkPaths(units: readonly SystemdUnit[]): Promise<readonly string[]> {\n    const paths = new Set<string>();\n\n    for (const unit of units) {\n      paths.add(this.pathFor(unit));\n\n      if (unit instanceof SystemdTimer) {\n        const targetPath = join(this.unitDir, unit.targetUnit);\n        if (await fileExists(targetPath)) {\n          paths.add(targetPath);\n        }\n      }\n    }\n\n    return [...paths];\n  }\n\n  private async materializeUnits<const TUnits extends readonly SystemdUnit[]>(\n    units: TUnits & ValidInstallUnits<TUnits>,\n  ): Promise<\n    Result<\n      SystemdMaterialization<TUnits>,\n      | ExecutableInferenceError\n      | InvalidExecDirectiveError\n      | NoUnitsProvidedError\n      | UnitMaterializationError\n    >\n  > {\n    if (units.length === 0) {\n      return err(new NoUnitsProvidedError(`Systemd.materialize()`));\n    }\n\n    try {\n      await writeUnitDirectory(this.unitDir);\n    } catch (cause) {\n      const reason = classifyMaterializationReason(cause);\n      return err(\n        new UnitMaterializationError(`Failed to create unit directory ${this.unitDir}`, {\n          cause,\n          operation: `create-directory`,\n          ...(reason === undefined ? {} : { reason }),\n          unitPath: this.unitDir,\n        }),\n      );\n    }\n\n    const materialized: MaterializedUnit<TUnits[number]>[] = [];\n    for (const unit of units) {\n      const path = join(this.unitDir, unit.filename);\n      const rendered = unit.render();\n      if (!rendered.ok) {\n        return err(rendered.error);\n      }\n      try {\n        await writeFile(path, rendered.value, `utf8`);\n      } catch (cause) {\n        if (cause instanceof InvalidExecDirectiveError) {\n          return err(cause);\n        }\n\n        const reason = classifyMaterializationReason(cause);\n        return err(\n          new UnitMaterializationError(`Failed to materialize ${unit.filename} into ${path}`, {\n            cause,\n            operation: `write-file`,\n            ...(reason === undefined ? {} : { reason }),\n            unitName: unit.filename,\n            unitPath: path,\n          }),\n        );\n      }\n      materialized.push({ path, unit });\n    }\n\n    return ok(new SystemdMaterialization<TUnits>(this.unitDir, materialized));\n  }\n\n  private async tryBestEffortCommand(\n    command: string,\n    args: readonly string[],\n  ): Promise<\n    | {\n        readonly stderr: string;\n        readonly stdout: string;\n      }\n    | undefined\n  > {\n    try {\n      return await this.executor(command, args);\n    } catch (cause) {\n      const output = extractCommandOutput(cause);\n      if (output !== undefined) {\n        return output;\n      }\n      return undefined;\n    }\n  }\n}\n\n/**\n * Opinionated `systemd-ts` upkeep helpers for application-owned units.\n *\n * This layer is intentionally analogous to a subset of `portablectl`'s\n * ownership workflow, but it operates on regular materialized units instead of\n * portable service images.\n */\nexport class SystemdTs {\n  private readonly systemd: Systemd;\n\n  public constructor(systemd: Systemd) {\n    this.systemd = systemd;\n    Object.freeze(this);\n  }\n\n  public async attach(\n    units: readonly SystemdUnit[],\n    options: SystemdTsAttachOptions,\n  ): Promise<\n    Result<\n      SystemdTsAttachmentResult,\n      | ExecutableInferenceError\n      | InvalidExecDirectiveError\n      | NoUnitsProvidedError\n      | UnitEnableError\n      | UnitMaterializationError\n      | UnitStartError\n    >\n  > {\n    if (units.length === 0) {\n      return err(new NoUnitsProvidedError(`Systemd.ts.attach()`));\n    }\n\n    const described = await this.describeUnits(units);\n    if (!described.ok) {\n      return described;\n    }\n\n    const manifestPath = this.manifestPathFor(options.owner);\n    const prior = await this.readManifest(options.owner);\n    const diff = await this.diffManifest(prior, described.value);\n    const materialized = await this.systemd.materialize(...(units as readonly SystemdUnit[]));\n    if (!materialized.ok) {\n      return materialized;\n    }\n\n    const enabled: string[] = [];\n    if (options.enable ?? false) {\n      const result = await this.systemd.enable(...units);\n      if (!result.ok) {\n        return result;\n      }\n      enabled.push(...units.map((unit) => unit.filename));\n    }\n\n    const started: string[] = [];\n    if (options.start ?? false) {\n      for (const unit of units) {\n        const result = await this.systemd.start(unit);\n        if (!result.ok) {\n          return result;\n        }\n        started.push(unit.filename);\n      }\n    }\n\n    await this.writeManifest(options.owner, described.value);\n\n    return ok({\n      added: diff.added,\n      directory: this.systemd.unitDir,\n      enabled,\n      manifestPath,\n      owner: options.owner,\n      removed: diff.removed,\n      restarted: [],\n      started,\n      unchanged: diff.unchanged,\n      updated: diff.updated,\n    });\n  }\n\n  public async detach(\n    selector: SystemdTsAttachmentSelector,\n    options: SystemdTsDetachOptions = {},\n  ): Promise<\n    Result<\n      {\n        readonly deleted: readonly string[];\n        readonly detached: readonly string[];\n        readonly disabled: readonly string[];\n        readonly owner: string;\n        readonly stopped: readonly string[];\n      },\n      Error\n    >\n  > {\n    const manifest = await this.readManifest(selector.owner);\n    if (manifest === undefined) {\n      return ok({\n        deleted: [],\n        detached: [],\n        disabled: [],\n        owner: selector.owner,\n        stopped: [],\n      });\n    }\n\n    const filenames = manifest.units.map((unit) => unit.filename);\n    const deleted: string[] = [];\n    const disabled: string[] = [];\n    const stopped: string[] = [];\n\n    if (options.stop ?? true) {\n      await this.runSystemctl(`stop`, filenames);\n      stopped.push(...filenames);\n    }\n    if (options.disable ?? true) {\n      await this.runSystemctl(`disable`, filenames);\n      disabled.push(...filenames);\n    }\n    if (options.deleteUnitFiles ?? true) {\n      for (const unit of manifest.units) {\n        await this.removeManagedUnitPath(unit.path);\n        await rm(unit.path, { force: true });\n        deleted.push(unit.filename);\n      }\n      await this.runSystemctl(`daemon-reload`);\n    }\n\n    await rm(this.manifestPathFor(selector.owner), { force: true });\n\n    return ok({\n      deleted,\n      detached: filenames,\n      disabled,\n      owner: selector.owner,\n      stopped,\n    });\n  }\n\n  public async reattach(\n    units: readonly SystemdUnit[],\n    options: SystemdTsReattachOptions,\n  ): Promise<\n    Result<\n      SystemdTsAttachmentResult,\n      | ExecutableInferenceError\n      | InvalidExecDirectiveError\n      | NoUnitsProvidedError\n      | UnitEnableError\n      | UnitMaterializationError\n      | UnitStartError\n      | Error\n    >\n  > {\n    if (units.length === 0) {\n      return err(new NoUnitsProvidedError(`Systemd.ts.reattach()`));\n    }\n\n    const described = await this.describeUnits(units);\n    if (!described.ok) {\n      return described;\n    }\n\n    const manifestPath = this.manifestPathFor(options.owner);\n    const prior = await this.readManifest(options.owner);\n    const diff = await this.diffManifest(prior, described.value);\n\n    if ((options.stopRemoved ?? true) && diff.removed.length > 0) {\n      await this.runSystemctl(`stop`, diff.removed);\n    }\n    if ((options.disableRemoved ?? true) && diff.removed.length > 0) {\n      await this.runSystemctl(`disable`, diff.removed);\n    }\n    if ((options.prune ?? true) && prior !== undefined) {\n      for (const unit of prior.units) {\n        if (!diff.removed.includes(unit.filename)) {\n          continue;\n        }\n        await this.removeManagedUnitPath(unit.path);\n        await rm(unit.path, { force: true });\n      }\n      if (diff.removed.length > 0) {\n        await this.runSystemctl(`daemon-reload`);\n      }\n    }\n\n    const materialized = await this.systemd.materialize(...(units as readonly SystemdUnit[]));\n    if (!materialized.ok) {\n      return materialized;\n    }\n\n    const enabled: string[] = [];\n    if (options.enable ?? false) {\n      const result = await this.systemd.enable(...units);\n      if (!result.ok) {\n        return result;\n      }\n      enabled.push(...units.map((unit) => unit.filename));\n    }\n\n    const restarted: string[] = [];\n    if (options.restartUpdated ?? false) {\n      const restartable = units\n        .filter((unit) => diff.updated.includes(unit.filename))\n        .map((unit) => unit.filename);\n      if (restartable.length > 0) {\n        await this.runSystemctl(`restart`, restartable);\n        restarted.push(...restartable);\n      }\n    }\n\n    const started: string[] = [];\n    if (options.start ?? false) {\n      for (const unit of units) {\n        if (restarted.includes(unit.filename)) {\n          continue;\n        }\n        const result = await this.systemd.start(unit);\n        if (!result.ok) {\n          return result;\n        }\n        started.push(unit.filename);\n      }\n    }\n\n    await this.writeManifest(options.owner, described.value);\n\n    return ok({\n      added: diff.added,\n      directory: this.systemd.unitDir,\n      enabled,\n      manifestPath,\n      owner: options.owner,\n      removed: diff.removed,\n      restarted,\n      started,\n      unchanged: diff.unchanged,\n      updated: diff.updated,\n    });\n  }\n\n  private async describeUnits(units: readonly SystemdUnit[]): Promise<\n    Result<\n      readonly {\n        readonly filename: string;\n        readonly path: string;\n        readonly rendered: string;\n      }[],\n      ExecutableInferenceError | InvalidExecDirectiveError\n    >\n  > {\n    const described = [];\n    for (const unit of units) {\n      const rendered = unit.render();\n      if (!rendered.ok) {\n        return rendered;\n      }\n      described.push({\n        filename: unit.filename,\n        path: this.systemd.pathFor(unit),\n        rendered: rendered.value,\n      });\n    }\n\n    return ok(described);\n  }\n\n  private async diffManifest(\n    prior: AttachmentManifest | undefined,\n    desired: readonly {\n      readonly filename: string;\n      readonly path: string;\n      readonly rendered: string;\n    }[],\n  ): Promise<{\n    readonly added: readonly string[];\n    readonly removed: readonly string[];\n    readonly unchanged: readonly string[];\n    readonly updated: readonly string[];\n  }> {\n    const priorUnits = new Map(prior?.units.map((unit) => [unit.filename, unit.path]) ?? []);\n    const desiredNames = new Set(desired.map((unit) => unit.filename));\n    const added: string[] = [];\n    const removed = [...priorUnits.keys()].filter((filename) => !desiredNames.has(filename));\n    const unchanged: string[] = [];\n    const updated: string[] = [];\n\n    for (const unit of desired) {\n      const priorPath = priorUnits.get(unit.filename);\n      if (priorPath === undefined) {\n        added.push(unit.filename);\n        continue;\n      }\n\n      try {\n        const current = await readFile(priorPath, `utf8`);\n        if (current === unit.rendered) {\n          unchanged.push(unit.filename);\n          continue;\n        }\n      } catch {\n        added.push(unit.filename);\n        continue;\n      }\n\n      updated.push(unit.filename);\n    }\n\n    return {\n      added,\n      removed,\n      unchanged,\n      updated,\n    };\n  }\n\n  private async manifestDir(): Promise<string> {\n    const directory = join(this.systemd.unitDir, `.systemd-ts`);\n    await mkdir(directory, { recursive: true });\n    return directory;\n  }\n\n  private manifestPathFor(owner: string): string {\n    return join(this.systemd.unitDir, `.systemd-ts`, `${encodeURIComponent(owner)}.json`);\n  }\n\n  private async readManifest(owner: string): Promise<AttachmentManifest | undefined> {\n    try {\n      const content = await readFile(this.manifestPathFor(owner), `utf8`);\n      return JSON.parse(content) as AttachmentManifest;\n    } catch {\n      return undefined;\n    }\n  }\n\n  private async runSystemctl(action: string, units: readonly string[] = []): Promise<void> {\n    const args =\n      action === `daemon-reload`\n        ? [...this.scopeArgs(), action]\n        : [...this.scopeArgs(), action, ...units];\n    await this.systemd.executor(`systemctl`, args);\n  }\n\n  private async removeManagedUnitPath(path: string): Promise<void> {\n    await this.systemd.executor(`rm`, [`-f`, path]);\n  }\n\n  private scopeArgs(): readonly string[] {\n    return this.systemd.scope === `user` ? [`--user`] : [];\n  }\n\n  private async writeManifest(\n    owner: string,\n    units: readonly {\n      readonly filename: string;\n      readonly path: string;\n      readonly rendered: string;\n    }[],\n  ): Promise<void> {\n    await this.manifestDir();\n    const manifest: AttachmentManifest = {\n      owner,\n      units: units.map((unit) => ({\n        filename: unit.filename,\n        path: unit.path,\n      })),\n      version: 1,\n    };\n    await writeFile(this.manifestPathFor(owner), JSON.stringify(manifest, null, 2), `utf8`);\n  }\n}\n\nfunction ok<TValue>(value: TValue): Result<TValue, never> {\n  return { ok: true, value };\n}\n\nfunction err<TError>(error: TError): Result<never, TError> {\n  return { ok: false, error };\n}\n\nfunction joinCommandOutput(output: { readonly stderr: string; readonly stdout: string }): string {\n  return [output.stdout, output.stderr].filter((value) => value.length > 0).join(`\\n`);\n}\n\nlet lazyDefaultSystemd: Systemd | undefined;\n\n/**\n * Returns the lazily created default `Systemd` instance.\n *\n * The default instance uses the library defaults for scope, unit directory, and\n * command execution.\n */\nexport function defaultSystemd(): Systemd {\n  lazyDefaultSystemd ??= new Systemd();\n  return lazyDefaultSystemd;\n}\n\nfunction resolveUnitLogPath(unit: SystemdUnit): string | undefined {\n  if (!(unit instanceof SystemdService)) {\n    return undefined;\n  }\n\n  for (const key of [`StandardOutput`, `StandardError`] as const) {\n    const value = unit.service[key];\n    if (typeof value !== `string`) {\n      continue;\n    }\n\n    const path = parseFileLogPath(value);\n    if (path !== undefined) {\n      return path;\n    }\n  }\n\n  return undefined;\n}\n\nfunction parseFileLogPath(value: string): string | undefined {\n  for (const prefix of [`append:`, `file:`] as const) {\n    if (value.startsWith(prefix)) {\n      return value.slice(prefix.length);\n    }\n  }\n\n  return undefined;\n}\n\nfunction tailLines(output: string, lines: number): string {\n  return output.split(`\\n`).slice(-lines).join(`\\n`);\n}\n\nfunction isMissingPathError(cause: unknown): boolean {\n  if (cause === null || typeof cause !== `object`) {\n    return false;\n  }\n\n  return (cause as Record<string, unknown>)[`code`] === `ENOENT`;\n}\n\nasync function writeUnitDirectory(path: string): Promise<void> {\n  await mkdir(path, { recursive: true });\n}\n","export {\n  ExecutableInferenceError,\n  InvalidExecDirectiveError,\n  NoUnitsProvidedError,\n  NotifySendError,\n  SystemctlCommandError,\n  SystemdTsError,\n  UnitEnableError,\n  UnitLogsReadError,\n  UnitMaterializationError,\n  UnitStartError,\n} from \"./errors.ts\";\nexport { Executable, defineExecutable } from \"./executable.ts\";\nexport { notify } from \"./notify.ts\";\nexport { SystemdService } from \"./systemd-service.ts\";\nexport { SystemdTimer } from \"./systemd-timer.ts\";\nexport { Systemctl } from \"./systemctl.ts\";\nexport { Systemd, SystemdMaterialization, SystemdTs, defaultSystemd } from \"./systemd.ts\";\nexport type {\n  SystemdTsAttachmentSelector,\n  SystemdTsAttachOptions,\n  SystemdTsAttachmentResult,\n  SystemdTsDetachOptions,\n  SystemdTsReattachOptions,\n} from \"./systemd.ts\";\nexport type { Result } from \"./internal.ts\";\nexport type {\n  AnySystemdService,\n  AnySystemdTimer,\n  CommandExecutionOptions,\n  CommandExecutor,\n  CommandOutput,\n  ExecutableOptions,\n  MaterializedUnit,\n  LogsOptions,\n  NotifyOptions,\n  ServiceBaseName,\n  ServiceFilename,\n  StartStatus,\n  SystemdOptions,\n  SystemdServiceOptions,\n  SystemctlActiveState,\n  SystemctlEnablementState,\n  SystemctlIsEnabledOptions,\n  SystemctlIsSystemRunningOptions,\n  SystemctlListTimersOptions,\n  SystemctlOptions,\n  SystemctlServiceStatus,\n  SystemctlSystemRunningState,\n  SystemctlStateQueryOptions,\n  SystemctlShowOptions,\n  SystemctlStatusOptions,\n  SystemctlTimerListEntry,\n  SystemdTimerOptions,\n  SystemdUnit,\n  TimerBaseName,\n  TimerFilename,\n  TimerTargetServiceName,\n  TimerTargetUnit,\n  UnitValue,\n  ValidInstallUnits,\n} from \"./types.ts\";\nexport type {\n  NotifySendErrorReason,\n  SystemctlCommandErrorReason,\n  SystemdCommandEnvironmentReason,\n  UnitLogsReadErrorReason,\n  UnitMaterializationErrorReason,\n} from \"./errors.ts\";\n\nimport * as I from \"./internal.ts\";\n/**\n * Internal helpers are exposed for advanced use, but they are not a stable public API.\n * Expect breaking changes here outside the package's normal compatibility guarantees.\n */\nexport const Internal: typeof I = I;\n"],"mappings":";;;;;;;;AA4EA,IAAa,iBAAb,cAAoC,MAAM;CACxC;CAEA,YACE,MACA,SACA,UAAiC,CAAC,GAClC;EACA,MAAM,SAAS,EAAE,OAAO,QAAQ,MAAM,CAAC;EACvC,KAAK,OAAO;EACZ,KAAK,OAAO,WAAW;CACzB;AACF;AAEA,IAAa,4BAAb,cAA+C,eAAe;CAC5D;CAEA,YAAmB,WAAmB,UAAiC,CAAC,GAAG;EACzE,MACE,qCACA,GAAG,UAAU,oDACb,OACF;EACA,KAAK,YAAY;CACnB;AACF;AAEA,IAAa,uBAAb,cAA0C,eAAe;CACvD;CAEA,YAAmB,WAAmB,UAAiC,CAAC,GAAG;EACzE,MACE,gCACA,GAAG,UAAU,0CACb,OACF;EACA,KAAK,YAAY;CACnB;AACF;AAEA,IAAa,2BAAb,cAA8C,eAAe;CAC3D,YAAmB,UAAiC,CAAC,GAAG;EACtD,MACE,mCACA,kGACA,OACF;CACF;AACF;AAEA,IAAa,2BAAb,cAA8C,eAAe;CAC3D;CACA;CACA;CACA;CAEA,YAAmB,SAAiB,UAA2C,CAAC,GAAG;EACjF,MAAM,mCAAmC,SAAS,OAAO;EACzD,KAAK,YAAY,QAAQ;EACzB,KAAK,SAAS,QAAQ;EACtB,KAAK,WAAW,QAAQ;EACxB,KAAK,WAAW,QAAQ;CAC1B;AACF;AAEA,IAAa,kBAAb,cAAqC,eAAe;CAClD;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA,YAAmB,SAAiB,UAAsC,CAAC,GAAG;EAC5E,MAAM,0BAA0B,SAAS,OAAO;EAChD,MAAM,UAAU,2BAA2B,QAAQ,KAAK;EACxD,KAAK,OAAO,QAAQ;EACpB,KAAK,UAAU,QAAQ;EACvB,KAAK,oBACH,QAAQ,qBAAqB,iCAAiC,QAAQ,KAAK;EAC7E,KAAK,WAAW,QAAQ;EACxB,KAAK,QAAQ,QAAQ;EACrB,KAAK,SAAS,QAAQ;EACtB,KAAK,SAAS,QAAQ;EACtB,KAAK,WAAW,QAAQ;EACxB,KAAK,WAAW,QAAQ;CAC1B;AACF;AAEA,IAAa,iBAAb,cAAoC,eAAe;CACjD;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA,YAAmB,SAAiB,UAAiC,CAAC,GAAG;EACvE,MAAM,yBAAyB,SAAS,OAAO;EAC/C,MAAM,UAAU,2BAA2B,QAAQ,KAAK;EACxD,KAAK,OAAO,QAAQ;EACpB,KAAK,UAAU,QAAQ;EACvB,KAAK,cAAc,QAAQ;EAC3B,KAAK,oBACH,QAAQ,qBAAqB,iCAAiC,QAAQ,KAAK;EAC7E,KAAK,WAAW,QAAQ;EACxB,KAAK,QAAQ,QAAQ;EACrB,KAAK,SAAS,QAAQ;EACtB,KAAK,SAAS,QAAQ;EACtB,KAAK,WAAW,QAAQ;EACxB,KAAK,WAAW,QAAQ;CAC1B;AACF;AAEA,IAAa,oBAAb,cAAuC,eAAe;CACpD;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA,YAAmB,SAAiB,UAAoC,CAAC,GAAG;EAC1E,MAAM,wBAAwB,SAAS,OAAO;EAC9C,MAAM,UAAU,2BAA2B,QAAQ,KAAK;EACxD,KAAK,OAAO,QAAQ;EACpB,KAAK,UAAU,QAAQ;EACvB,KAAK,oBACH,QAAQ,qBAAqB,iCAAiC,QAAQ,KAAK;EAC7E,KAAK,WAAW,QAAQ;EACxB,KAAK,SAAS,QAAQ;EACtB,KAAK,QAAQ,QAAQ;EACrB,KAAK,SAAS,QAAQ;EACtB,KAAK,SAAS,QAAQ;EACtB,KAAK,WAAW,QAAQ;EACxB,KAAK,WAAW,QAAQ;CAC1B;AACF;AAEA,IAAa,kBAAb,cAAqC,eAAe;CAClD;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA,YAAmB,SAAiB,UAAkC,CAAC,GAAG;EACxE,MAAM,0BAA0B,SAAS,OAAO;EAChD,MAAM,UAAU,2BAA2B,QAAQ,KAAK;EACxD,KAAK,OAAO,QAAQ;EACpB,KAAK,UAAU,QAAQ;EACvB,KAAK,oBACH,QAAQ,qBAAqB,iCAAiC,QAAQ,KAAK;EAC7E,KAAK,WAAW,QAAQ;EACxB,KAAK,SAAS,QAAQ;EACtB,KAAK,QAAQ,QAAQ;EACrB,KAAK,SAAS,QAAQ;EACtB,KAAK,SAAS,QAAQ;CACxB;AACF;AAEA,IAAa,wBAAb,cAA2C,eAAe;CACxD;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA,YAAmB,SAAiB,UAAwC,CAAC,GAAG;EAC9E,MAAM,wBAAwB,SAAS,OAAO;EAC9C,MAAM,UAAU,2BAA2B,QAAQ,KAAK;EACxD,KAAK,OAAO,QAAQ;EACpB,KAAK,UAAU,QAAQ;EACvB,KAAK,oBACH,QAAQ,qBAAqB,iCAAiC,QAAQ,KAAK;EAC7E,KAAK,WAAW,QAAQ;EACxB,KAAK,YAAY,QAAQ;EACzB,KAAK,SAAS,QAAQ;EACtB,KAAK,QAAQ,QAAQ;EACrB,KAAK,SAAS,QAAQ;EACtB,KAAK,SAAS,QAAQ;CACxB;AACF;AAEA,SAAgB,iCACd,OAC6C;CAC7C,IAAI,UAAU,QAAQ,OAAO,UAAU,UACrC;CAGF,MAAM,SAAS;CACf,IAAI,OAAO,YAAY,UACrB,OAAO;CAGT,IAAI,OAAO,YAAY,YAAY,OAAO,YAAY,SACpD,OAAO;CAGT,MAAM,iBAAiB,CAAC,OAAO,WAAW,OAAO,SAAS,CAAC,CACxD,QAAQ,UAA2B,OAAO,UAAU,YAAY,MAAM,SAAS,CAAC,CAAC,CACjF,KAAK,IAAI;CAEZ,IACE,eAAe,SAAS,0BAA0B,KAClD,eAAe,SAAS,yCAAyC,KACjE,eAAe,SAAS,gCAAgC,GAExD,OAAO;AAIX;AAEA,SAAgB,8BACd,OAC4C;CAC5C,IAAI,UAAU,QAAQ,OAAO,UAAU,UACrC;CAGF,MAAM,SAAS;CACf,IAAI,OAAO,YAAY,YAAY,OAAO,YAAY,WAAW,OAAO,YAAY,SAClF,OAAO;CAGT,IAAI,OAAO,YAAY,YAAY,OAAO,YAAY,aAAa,OAAO,YAAY,UACpF,OAAO;CAGT,OAAO;AACT;AAEA,SAAS,2BAA2B,OAIlC;CACA,IAAI,UAAU,QAAQ,OAAO,UAAU,UACrC,OAAO;EACL,UAAU,KAAA;EACV,QAAQ,KAAA;EACR,QAAQ,KAAA;CACV;CAGF,MAAM,SAAS;CACf,OAAO;EACL,UAAU,OAAO,OAAO,YAAY,WAAW,OAAO,UAAU,KAAA;EAChE,QAAQ,OAAO,OAAO,cAAc,WAAW,OAAO,YAAY,KAAA;EAClE,QAAQ,OAAO,OAAO,cAAc,WAAW,OAAO,YAAY,KAAA;CACpE;AACF;;;ACpVA,MAAM,oBAAoB,cAAc,YAAY,GAAG;;;;;;;;;;;;;;AAevD,IAAa,aAAb,MAAwB;;CAEtB;;CAEA;;CAEA;;CAEA;;;;;;;;;;;;CAaA,YAAmB,UAA6B,CAAC,GAAG;EAClD,KAAK,oBAAoB,QAAQ,qBAAqB,QAAQ;EAC9D,MAAM,qBAAqB,QAAQ,cAAc,yBAAyB;EAC1E,KAAK,iBACH,uBAAuB,KAAA,KAAa,QAAQ,eAAe,KAAA,IACvD,IAAI,yBAAyB,IAC7B,KAAA;EACN,KAAK,aAAa,sBAAsB;EACxC,KAAK,OAAO,OAAO,OAAO,CAAC,GAAI,QAAQ,QAAQ,CAAC,CAAE,CAAC;EACnD,OAAO,OAAO,IAAI;CACpB;;;;;;;CAQA,iBAA0F;EACxF,IAAI,KAAK,mBAAmB,KAAA,GAC1B,OAAO;GACL,IAAI;GACJ,OAAO,KAAK;EACd;EAGF,OAAO;GACL,IAAI;GACJ,OAAO;IAAC,KAAK;IAAmB,KAAK;IAAY,GAAG,KAAK;GAAI;EAC/D;CACF;;;;;CAMA,cAA+D;EAC7D,MAAM,eAAe,KAAK,eAAe;EACzC,IAAI,CAAC,aAAa,IAChB,OAAO;EAGT,OAAO;GACL,IAAI;GACJ,OAAO,aAAa,MAAM,IAAI,UAAU,CAAC,CAAC,KAAK,GAAG;EACpD;CACF;AACF;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,iBACd,IACA,UAA6B,CAAC,GAClB;CACZ,MAAM,aAAa,IAAI,WAAW,OAAO;CAEzC,IAAI,WAAW,mBAAmB,KAAA,KAAa,aAAa,WAAW,UAAU,GAC/E,QAAa,QAAQ,GAAG,CAAC,CAAC,CAAC,OAAO,UAAmB;EACnD,QAAQ,WAAW;EACnB,MAAM;CACR,CAAC;CAGH,OAAO;AACT;AAEA,SAAS,2BAA+C;CACtD,MAAM,yBAAQ,IAAI,MAAM,EAAA,CAAE,SAAS;CACnC,KAAK,MAAM,QAAQ,MAAM,MAAM,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG;EAC7C,MAAM,YAAY,iBAAiB,IAAI;EACvC,IAAI,cAAc,KAAA,KAAa,cAAc,mBAC3C;EAGF,OAAO;CACT;AAGF;AAEA,SAAS,iBAAiB,MAAkC;CAC1D,MAAM,eAAe,KAAK,MAAM,yCAAyC;CACzE,IAAI,iBAAiB,MACnB,OAAO,cAAc,aAAa,EAAE;CAGtC,MAAM,YAAY,KAAK,MAAM,gCAAgC;CAC7D,IAAI,cAAc,MAChB,OAAO,UAAU;AAIrB;AAEA,SAAS,aAAa,YAA6B;CACjD,MAAM,UAAU,QAAQ,KAAK;CAC7B,IAAI,YAAY,KAAA,GACd,OAAO;CAGT,OAAO,kBAAkB,OAAO,MAAM,kBAAkB,UAAU;AACpE;AAEA,SAAS,WAAW,OAAuB;CACzC,OAAO,IAAI,MAAM,WAAW,KAAK,OAAO,EAAE;AAC5C;AAEA,SAAS,kBAAkB,MAAsB;CAC/C,IAAI;EACF,OAAO,aAAa,IAAI;CAC1B,QAAQ;EACN,OAAO;CACT;AACF;;;;;;;;;;;;;;;;;ACjJA,MAAM,sBAAsB;CAC1B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AACA,MAAM,gBAAgB,UAAU,QAAQ;AAGxC,SAAgB,kBAAkB,MAAc,QAAuC;CACrF,OAAO,KAAK,SAAS,MAAM,IAAI,KAAK,MAAM,GAAG,CAAC,OAAO,MAAM,IAAI;AACjE;AAEA,SAAgB,uBAAuB,SAAsC;CAC3E,MAAM,iBAAiB,QAAQ,MAAM;CACrC,IAAI,OAAO,mBAAmB,YAAY,eAAe,SAAS,GAChE,OAAO;CAGT,OAAO,GAAG,kBAAkB,QAAQ,MAAM,QAAQ,EAAE;AACtD;AAEA,SAAgB,uBAAuB,OAAkC;CACvE,IAAI,UAAU,QACZ,OAAO,GAAG,QAAQ,IAAI,WAAW,IAAI;CAGvC,OAAO;AACT;AAEA,SAAgB,kBACd,SACoB;CACpB,OAAO,OAAO,OAAO;EACnB,GAAG;EACH,GAAI,QAAQ,SAAS,KAAA,IAAY,CAAC,IAAI,EAAE,MAAM,iBAAiB,QAAQ,IAAI,EAAE;EAC7E,GAAI,QAAQ,YAAY,KAAA,IAAY,CAAC,IAAI,EAAE,SAAS,iBAAiB,QAAQ,OAAO,EAAE;EACtF,GAAI,kBAAkB,OAAO,IAAI,EAAE,SAAS,iBAAiB,QAAQ,OAAO,EAAE,IAAI,CAAC;EACnF,GAAI,gBAAgB,OAAO,IAAI,EAAE,OAAO,iBAAiB,QAAQ,KAAK,EAAE,IAAI,CAAC;CAC/E,CAAC;AACH;AAEA,SAAgB,iBACd,SACU;CACV,IAAI,YAAY,KAAA,GACd,OAAO;CAGT,MAAM,UAAU,OAAO,QAAQ,OAAO,CAAC,CAAC,KAAK,CAAC,KAAK,WAAW;EAC5D,IAAI,gBAAgB,KAAK,GACvB,OAAO,CAAC,KAAK,OAAO,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC;EAGxC,OAAO,CAAC,KAAK,KAAK;CACpB,CAAC;CAED,OAAO,OAAO,OAAO,OAAO,YAAY,OAAO,CAAC;AAClD;AAEA,SAAgB,uBACd,SACyC;CACzC,KAAK,MAAM,OAAO,qBAAqB;EACrC,MAAM,aAAa,wBAAwB,KAAK,QAAQ,IAAI;EAC5D,IAAI,CAAC,WAAW,IACd,OAAO;CAEX;CAEA,OAAO;EACL,IAAI;EACJ,OAAO,KAAA;CACT;AACF;AAEA,SAAgB,iBAAiB,MAAc,QAA6B;CAC1E,MAAM,aAAa,OAAO,YACxB,OACG,MAAM,IAAI,CAAC,CACX,KAAK,SAAS,KAAK,KAAK,CAAC,CAAC,CAC1B,QAAQ,SAAS,KAAK,SAAS,CAAC,CAAC,CACjC,KAAK,SAAS;EACb,MAAM,iBAAiB,KAAK,QAAQ,GAAG;EACvC,IAAI,mBAAmB,IACrB,OAAO,CAAC,MAAM,EAAE;EAGlB,OAAO,CAAC,KAAK,MAAM,GAAG,cAAc,GAAG,KAAK,MAAM,iBAAiB,CAAC,CAAC;CACvE,CAAC,CACL;CAEA,OAAO;EACL,aAAa,WAAW,kBAAkB;EAC1C,gBACE,WAAW,sBAAsB,KAAA,KAAa,WAAW,sBAAsB,KAC3E,KAAA,IACA,OAAO,WAAW,iBAAiB;EACzC,QAAQ,WAAW,aAAa;EAChC,UAAU,WAAW,eAAe;EACpC,MAAM,WAAW,SAAS;CAC5B;AACF;AAEA,SAAgB,eACd,UAC0C;CAC1C,IAAI;EACF,MAAM,mBAAmB,SACtB,SAAS,CAAC,aAAa,aAAa;GACnC,IAAI,YAAY,KAAA,GACd,OAAO,CAAC;GAGV,MAAM,QAAkB,CAAC;GACzB,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAkC,GAAG;IAC7E,IAAI,UAAU,KAAA,GACZ;IAGF,IAAI,gBAAgB,KAAK,GAAG;KAC1B,KAAK,MAAM,SAAS,OAAO;MACzB,MAAM,WAAW,mBAAmB,KAAK;MACzC,IAAI,CAAC,SAAS,IACZ,MAAM,SAAS;MAEjB,MAAM,KAAK,GAAG,IAAI,GAAG,SAAS,OAAO;KACvC;KACA;IACF;IAEA,MAAM,WAAW,mBAAmB,KAAkB;IACtD,IAAI,CAAC,SAAS,IACZ,MAAM,SAAS;IAEjB,MAAM,KAAK,GAAG,IAAI,GAAG,SAAS,OAAO;GACvC;GAEA,IAAI,MAAM,WAAW,GACnB,OAAO,CAAC;GAGV,OAAO;IAAC,IAAI,YAAY;IAAI,GAAG;IAAO;GAAE;EAC1C,CAAC,CAAC,CACD,KAAK,IAAI;EAEZ,OAAO;GACL,IAAI;GACJ,OAAO,iBAAiB,SAAS,IAAI,IAAI,mBAAmB,GAAG,iBAAiB;EAClF;CACF,SAAS,OAAO;EACd,OAAO;GACL,IAAI;GACJ,OACE,iBAAiB,2BACb,QACA,IAAI,yBAAyB,EAAE,OAAO,MAAM,CAAC;EACrD;CACF;AACF;AAEA,eAAsB,uBACpB,SACA,MACA,UAAmC,CAAC,GACZ;CACxB,MAAM,SAAS,MAAM,cACnB,SACA,CAAC,GAAG,IAAI,GACR,QAAQ,QAAQ,KAAA,IAAY,CAAC,IAAI,EAAE,KAAK;EAAE,GAAG,QAAQ;EAAK,GAAG,QAAQ;CAAI,EAAE,CAC7E;CACA,OAAO;EACL,QAAQ,OAAO;EACf,QAAQ,OAAO;CACjB;AACF;AAEA,eAAsB,WAAW,MAAgC;CAC/D,IAAI;EACF,MAAM,OAAO,IAAI;EACjB,OAAO;CACT,QAAQ;EACN,OAAO;CACT;AACF;AAEA,eAAsB,WACpB,OACA,SACe;CACf,MAAM,OAAiB,CAAC,cAAc,KAAK;CAC3C,IAAI,QAAQ,QAAQ,KAAA,GAClB,KAAK,KAAK,WAAW,QAAQ,KAAK;CAEpC,IAAI,QAAQ,WAAW,KAAA,GACrB,KAAK,KAAK,UAAU,QAAQ,QAAQ;CAGtC,IAAI,QAAQ,aAAa,KAAA,GAAW;EAClC,IAAI;GACF,MAAM,QAAQ,SACZ,kBACA,MACA,QAAQ,eAAe,KAAA,IAAY,CAAC,IAAI,EAAE,KAAK,EAAE,eAAe,QAAQ,WAAW,EAAE,CACvF;EACF,SAAS,OAAO;GACd,MAAM,IAAI,gBACR,uEACA;IACE;IACA;IACA,SAAS;IACT,QAAQ;IACR,OAAO;GACT,CACF;EACF;EACA;CACF;CAEA,IAAI;EACa,MAAM,cAAc,kBAAkB,MAAM,EACzD,KAAK;GACH,GAAG,QAAQ;GACX,GAAI,QAAQ,eAAe,KAAA,IAAY,CAAC,IAAI,EAAE,eAAe,QAAQ,WAAW;EAClF,EACF,CAAC;CAGH,SAAS,OAAO;EACd,MAAM,IAAI,gBAAgB,2DAA2D;GACnF;GACA;GACA,SAAS;GACT,QAAQ;GACR,OAAO;EACT,CAAC;CACH;AACF;AAEA,SAAgB,qBAAqB,OAA2C;CAC9E,IAAI,UAAU,QAAQ,OAAO,UAAU,UACrC;CAGF,MAAM,SAAS;CACf,MAAM,SAAS,OAAO,OAAO,cAAc,WAAW,OAAO,YAAY,KAAA;CACzE,MAAM,SAAS,OAAO,OAAO,cAAc,WAAW,OAAO,YAAY,KAAA;CACzE,IAAI,WAAW,KAAA,KAAa,WAAW,KAAA,GACrC;CAGF,OAAO;EACL,QAAQ,UAAU;EAClB,QAAQ,UAAU;CACpB;AACF;AAEA,SAAS,kBACP,SACkC;CAClC,OAAO,aAAa;AACtB;AAEA,SAAS,gBACP,SACgC;CAChC,OAAO,WAAW;AACpB;AAEA,SAAS,wBACP,KACA,OACyC;CACzC,IAAI,gBAAgB,KAAK,GAAG;EAC1B,KAAK,MAAM,SAAS,OAAO;GACzB,MAAM,aAAa,wBAAwB,KAAK,KAAK;GACrD,IAAI,CAAC,WAAW,IACd,OAAO;EAEX;EAEA,OAAO;GACL,IAAI;GACJ,OAAO,KAAA;EACT;CACF;CAEA,OAAO,wBAAwB,KAAK,KAA8B;AACpE;AAEA,SAAS,wBACP,KACA,OACyC;CACzC,IAAI,OAAO,UAAU,YAAY,MAAM,SAAS,KAAK,CAAC,sBAAsB,KAAK,GAC/E,OAAO;EACL,IAAI;EACJ,OAAO,IAAI,0BAA0B,GAAG;CAC1C;CAGF,IAAI,iBAAiB,cAAc,CAAC,MAAM,kBAAkB,WAAW,GAAG,GACxE,OAAO;EACL,IAAI;EACJ,OAAO,IAAI,0BAA0B,GAAG;CAC1C;CAGF,OAAO;EACL,IAAI;EACJ,OAAO,KAAA;CACT;AACF;AAEA,SAAS,mBAAmB,OAA4D;CACtF,IAAI,iBAAiB,YACnB,OAAO,MAAM,YAAY;CAG3B,IAAI,OAAO,UAAU,WACnB,OAAO;EACL,IAAI;EACJ,OAAO,QAAQ,SAAS;CAC1B;CAGF,OAAO;EACL,IAAI;EACJ,OAAO,OAAO,KAAK;CACrB;AACF;AAEA,SAAS,gBAAgB,OAA+C;CACtE,OAAO,MAAM,QAAQ,KAAK;AAC5B;AAEA,SAAS,sBAAsB,OAAwB;CACrD,IAAI,QAAQ;CACZ,IAAI,qBAAqB;CAEzB,OAAO,QAAQ,MAAM,QAAQ;EAC3B,MAAM,SAAS,MAAM;EACrB,IAAI,WAAW,OAAO,WAAW,OAAO,WAAW,KAAK;GACtD,SAAS;GACT;EACF;EAEA,IAAI,WAAW,KAAK;GAClB,IAAI,oBACF,OAAO;GAGT,qBAAqB;GACrB,SAAS;GACT;EACF;EAEA,IAAI,WAAW,KAAK;GAClB,IAAI,oBACF,OAAO;GAGT,qBAAqB;GACrB,SAAS,MAAM,QAAQ,OAAO,MAAM,IAAI;GACxC;EACF;EAEA;CACF;CAEA,OAAO,MAAM,WAAW;AAC1B;;;;;;;;;;;;;;;ACrYA,MAAa,SAAS;;;;;;;;CAQpB,MAAM,MAAM,UAAyB,CAAC,GAA2C;EAC/E,IAAI;GACF,MAAM,WAAW,WAAW,OAAO;GACnC,OAAO;IAAE,IAAI;IAAM,OAAO,KAAA;GAAU;EACtC,SAAS,OAAO;GACd,OAAO;IACL,IAAI;IACJ,OACE,iBAAiB,kBACb,QACA,IAAI,gBAAgB,uCAAuC;KACzD,OAAO;KACP,OAAO;IACT,CAAC;GACT;EACF;CACF;;;;;;;;CASA,MAAM,SAAS,UAAyB,CAAC,GAA2C;EAClF,IAAI;GACF,MAAM,WAAW,cAAc,OAAO;GACtC,OAAO;IAAE,IAAI;IAAM,OAAO,KAAA;GAAU;EACtC,SAAS,OAAO;GACd,OAAO;IACL,IAAI;IACJ,OACE,iBAAiB,kBACb,QACA,IAAI,gBAAgB,0CAA0C;KAC5D,OAAO;KACP,OAAO;IACT,CAAC;GACT;EACF;CACF;AACF;;;;;;;;;;;;;;ACvCA,IAAa,iBAAb,MAAkG;;CAEhG;;CAEA;;CAEA;;CAEA;;CAEA;;;;;;;;CASA,YAAmB,SAA0D;EAC3E,KAAK,UAAU,kBAAkB,OAA8B;EAC/D,KAAK,OAAO,kBAAkB,QAAQ,MAAM,UAAU;EACtD,KAAK,OAAO,iBAAiB,QAAQ,IAAI;EACzC,KAAK,UAAW,iBAAiB,QAAQ,OAAO,KAAK,CAAC;EACtD,KAAK,UAAU,iBAAiB,QAAQ,OAAO;EAC/C,OAAO,OAAO,IAAI;CACpB;;CAGA,IAAW,WAA8C;EACvD,OAAO,GAAG,KAAK,KAAK;CACtB;;;;;;;;CASA,SAAsF;EACpF,MAAM,aAAa,uBAAuB,KAAK,OAAO;EACtD,IAAI,CAAC,WAAW,IACd,OAAO;EAGT,OAAO,eAAe;GACpB,CAAC,QAAQ,KAAK,IAAI;GAClB,CAAC,WAAW,KAAK,OAAO;GACxB,CAAC,WAAW,KAAK,OAAO;EAC1B,CAAC;CACH;AACF;;;;;;;;;;;;;ACnDA,IAAa,eAAb,MAA4F;;CAE1F;;CAEA;;CAEA;;CAEA;;CAEA;;CAEA;;CAEA;;;;;;;CAQA,YAAmB,SAAwD;EACzE,KAAK,UAAU,kBAAkB,OAA8B;EAC/D,KAAK,OAAO,kBAAkB,QAAQ,MAAM,QAAQ;EACpD,KAAK,OAAO,iBAAiB,QAAQ,IAAI;EACzC,KAAK,QAAS,iBAAiB,QAAQ,KAAK,KAAK,CAAC;EAClD,KAAK,UAAU,iBAAiB,QAAQ,OAAO;EAC/C,KAAK,aAAa,uBAChB,OACF;EACA,KAAK,oBAAoB,kBACvB,KAAK,YACL,UACF;EACA,OAAO,OAAO,IAAI;CACpB;;CAGA,IAAW,WAA4C;EACrD,OAAO,GAAG,KAAK,KAAK;CACtB;;CAGA,SAA0D;EACxD,OAAO,eAAe;GACpB,CAAC,QAAQ,KAAK,IAAI;GAClB,CAAC,SAAS,KAAK,KAAK;GACpB,CAAC,WAAW,KAAK,OAAO;EAC1B,CAAC;CACH;AACF;;;;;;;;;;ACnDA,IAAa,YAAb,MAAuB;;CAErB;;CAEA;CAEA,YAAmB,UAA4B,CAAC,GAAG;EACjD,KAAK,QAAQ,QAAQ,SAAS;EAC9B,KAAK,WAAW,QAAQ,YAAY;EACpC,OAAO,OAAO,IAAI;CACpB;;CAGA,MAAa,eAAsE;EACjF,OAAO,KAAK,IAAI,eAAe;CACjC;;CAGA,MAAa,OAAO,MAAqE;EACvF,OAAO,KAAK,IAAI,UAAU,IAAI;CAChC;;CAGA,MAAa,QAAQ,MAAqE;EACxF,OAAO,KAAK,IAAI,WAAW,IAAI;CACjC;;CAGA,MAAa,KAAK,MAAqE;EACrF,OAAO,KAAK,IAAI,QAAQ,IAAI;CAC9B;;;;;;;CAQA,MAAa,UACX,MACA,UAAqC,CAAC,GAC4B;EAClE,MAAM,SAAS,MAAM,KAAK,IACxB,cACA,GAAI,QAAQ,OAAO,CAAC,QAAQ,IAAI,CAAC,GACjC,GAAI,QAAQ,QAAQ,CAAC,SAAS,IAAI,CAAC,GACnC,IACF;EACA,IAAI,CAAC,OAAO,IACV,OAAO;EAET,OAAOA,KAAG,wBAAwB,OAAO,KAAK,CAA6B;CAC7E;;;;;;;CAQA,MAAa,SACX,MACA,UAAsC,CAAC,GACuB;EAC9D,MAAM,SAAS,MAAM,KAAK,IAAI,aAAa,GAAI,QAAQ,QAAQ,CAAC,SAAS,IAAI,CAAC,GAAI,IAAI;EACtF,IAAI,CAAC,OAAO,IACV,OAAO;EAET,OAAOA,KAAG,wBAAwB,OAAO,KAAK,CAAyB;CACzE;;;;;;;CAQA,MAAa,SACX,MACA,UAAsC,CAAC,GACuB;EAC9D,MAAM,SAAS,MAAM,KAAK,IAAI,aAAa,GAAI,QAAQ,QAAQ,CAAC,SAAS,IAAI,CAAC,GAAI,IAAI;EACtF,IAAI,CAAC,OAAO,IACV,OAAO;EAET,OAAOA,KAAG,wBAAwB,OAAO,KAAK,CAAyB;CACzE;;;;;;;CAQA,MAAa,gBACX,UAA2C,CAAC,GACyB;EACrE,MAAM,SAAS,MAAM,KAAK,IAAI,qBAAqB,GAAI,QAAQ,OAAO,CAAC,QAAQ,IAAI,CAAC,CAAE;EACtF,IAAI,CAAC,OAAO,IACV,OAAO;EAET,OAAOA,KAAG,wBAAwB,OAAO,KAAK,CAAgC;CAChF;;;;;;CAOA,MAAa,KACX,MACA,UAAgC,CAAC,GACsB;EACvD,MAAM,eACJ,QAAQ,eAAe,KAAA,KAAa,QAAQ,WAAW,WAAW,IAC9D,CAAC,IACD,CAAC,cAAc,QAAQ,WAAW,KAAK,GAAG,GAAG;EACnD,OAAO,KAAK,IAAI,QAAQ,MAAM,GAAG,YAAY;CAC/C;;;;;;CAOA,MAAa,eACX,MACA,UAAgC,CAAC,GACyC;EAC1E,MAAM,SAAS,MAAM,KAAK,KAAK,MAAM,OAAO;EAC5C,IAAI,CAAC,OAAO,IACV,OAAO;EAET,OAAOA,KAAG,yBAAyB,OAAO,MAAM,MAAM,CAAC;CACzD;;;;;CAMA,MAAa,WAAW,MAAmE;EACzF,OAAO,KAAK,kBAAkB,IAAI;CACpC;;;;;CAMA,MAAa,kBACX,MACgE;EAChE,MAAM,SAAS,MAAM,KAAK,KAAK,MAAM,EACnC,YAAY;GAAC;GAAM;GAAe;GAAY;GAAU;EAAgB,EAC1E,CAAC;EACD,IAAI,CAAC,OAAO,IACV,OAAO;EAET,OAAOA,KAAG,iBAAiB,MAAM,OAAO,MAAM,MAAM,CAAC;CACvD;;;;;CAMA,MAAa,WACX,UAAsC,CAAC,GACqC;EAC5E,MAAM,OAAO;GACX;GACA,GAAI,QAAQ,MAAM,CAAC,OAAO,IAAI,CAAC;GAC/B,GAAK,QAAQ,WAAW,OAAQ,CAAC,YAAY,IAAI,CAAC;GAClD;GACA,GAAI,QAAQ,YAAY,CAAC;EAC3B;EACA,MAAM,SAAS,MAAM,KAAK,IAAI,GAAG,IAAI;EACrC,IAAI,CAAC,OAAO,IACV,OAAO;EAET,IAAI;GACF,OAAOA,KAAG,KAAK,MAAM,OAAO,MAAM,MAAM,CAAuC;EACjF,SAAS,OAAO;GACd,OAAOC,MACL,IAAI,sBAAsB,0DAA0D;IAClF,MAAM,CAAC,GAAG,KAAK,UAAU,GAAG,GAAG,IAAI;IACnC;IACA,SAAS;IACT,WAAW;IACX,QAAQ;GACV,CAAC,CACH;EACF;CACF;;CAGA,MAAa,MAAM,MAAqE;EACtF,OAAO,KAAK,IAAI,SAAS,IAAI;CAC/B;;CAGA,MAAa,KAAK,MAAqE;EACrF,OAAO,KAAK,IAAI,QAAQ,IAAI;CAC9B;;CAGA,MAAa,QAAQ,MAAqE;EACxF,OAAO,KAAK,IAAI,WAAW,IAAI;CACjC;;;;;CAMA,MAAa,YACX,WAA8B,CAAC,GACwB;EACvD,OAAO,KAAK,IAAI,gBAAgB,GAAG,QAAQ;CAC7C;;;;;;;CAQA,MAAa,OACX,MACA,UAAkC,CAAC,GACoB;EACvD,MAAM,OAAO,CAAC,UAAU,IAAI;EAC5B,IAAI,QAAQ,WAAW,MACrB,KAAK,KAAK,YAAY;EAExB,IAAI,QAAQ,UAAU,KAAA,GACpB,KAAK,KAAK,WAAW,OAAO,QAAQ,KAAK,CAAC;EAG5C,OAAO,KAAK,IAAI,GAAG,IAAI;CACzB;;CAGA,MAAa,IACX,GAAG,MACoD;EACvD,MAAM,aAAa,CAAC,GAAG,KAAK,UAAU,GAAG,GAAG,IAAI;EAChD,IAAI;GACF,OAAOD,KAAG,MAAM,KAAK,SAAS,aAAa,UAAU,CAAC;EACxD,SAAS,OAAO;GACd,OAAOC,MACL,IAAI,sBAAsB,2BAA2B,KAAK,MAAM,aAAa;IAC3E,MAAM;IACN;IACA,SAAS;IACT,WAAW,KAAK;IAChB,QAAQ;GACV,CAAC,CACH;EACF;CACF;CAEA,YAAuC;EACrC,OAAO,KAAK,UAAU,SAAS,CAAC,QAAQ,IAAI,CAAC;CAC/C;AACF;AAEA,SAASD,KAAW,OAAsC;CACxD,OAAO;EAAE,IAAI;EAAM;CAAM;AAC3B;AAEA,SAASC,MAAY,OAAsC;CACzD,OAAO;EAAE,IAAI;EAAO;CAAM;AAC5B;AAEA,SAAS,yBAAyB,QAAkD;CAClF,OAAO,OAAO,OACZ,OAAO,YACL,OACG,MAAM,IAAI,CAAC,CACX,KAAK,SAAS,KAAK,KAAK,CAAC,CAAC,CAC1B,QAAQ,SAAS,KAAK,SAAS,CAAC,CAAC,CACjC,KAAK,SAAS;EACb,MAAM,iBAAiB,KAAK,QAAQ,GAAG;EACvC,IAAI,mBAAmB,IACrB,OAAO,CAAC,MAAM,EAAE;EAGlB,OAAO,CAAC,KAAK,MAAM,GAAG,cAAc,GAAG,KAAK,MAAM,iBAAiB,CAAC,CAAC;CACvE,CAAC,CACL,CACF;AACF;AAEA,SAAS,wBAAwB,QAA+B;CAK9D,OAJa,CAAC,OAAO,QAAQ,OAAO,MAAM,CAAC,CACxC,SAAS,UAAU,MAAM,MAAM,IAAI,CAAC,CAAC,CACrC,KAAK,UAAU,MAAM,KAAK,CAAC,CAAC,CAC5B,MAAM,UAAU,MAAM,SAAS,CACxB,KAAK;AACjB;;;;;;;;;AChPA,IAAa,yBAAb,MAEE;;CAEA;;CAEA;CAEA,YAAmB,WAAmB,cAA2D;EAC/F,KAAK,YAAY;EACjB,KAAK,eAAe,OAAO,OAAO,CAAC,GAAG,YAAY,CAAC;EACnD,OAAO,OAAO,IAAI;CACpB;AACF;;;;;;;;;;;AAYA,IAAa,UAAb,MAAqB;;CAEnB;;CAEA;;CAEA;;CAEA;;CAEA;;CAEA;;;;;;;;CASA,YAAmB,UAA0B,CAAC,GAAG;EAC/C,KAAK,QAAQ,QAAQ,SAAS;EAC9B,KAAK,UAAU,QAAQ,WAAW,uBAAuB,KAAK,KAAK;EACnE,KAAK,YAAY,QAAQ,aAAa;EACtC,KAAK,WAAW,QAAQ,YAAY;EACpC,KAAK,YAAY,IAAI,UAAU;GAC7B,UAAU,KAAK;GACf,OAAO,KAAK;EACd,CAAC;EACD,KAAK,KAAK,IAAI,UAAU,IAAI;EAC5B,OAAO,OAAO,IAAI;CACpB;;;;;;;CAQA,MAAa,YACX,GAAG,OASH;EACA,OAAO,KAAK,iBAAiB,KAAK;CACpC;;;;;;;;CASA,MAAa,OACX,GAAG,OAC4D;EAC/D,IAAI,MAAM,WAAW,GACnB,OAAO,IAAI,IAAI,qBAAqB,kBAAkB,CAAC;EAGzD,MAAM,YAAY,KAAK,UAAU;EACjC,IAAI;GACF,MAAM,KAAK,aAAa,WAAW,OAAO,QAAQ;EACpD,SAAS,OAAO;GACd,IAAI,iBAAiB,iBACnB,OAAO,IAAI,KAAK;GAGlB,OAAO,IACL,IAAI,gBAAgB,sCAAsC;IACxD;IACA,OAAO;IACP,UAAU,MAAM,EAAE,EAAE;GACtB,CAAC,CACH;EACF;EAEA,KAAK,MAAM,QAAQ,OAAO;GACxB,MAAM,OAAO;IAAC,GAAG;IAAW;IAAU,KAAK;GAAQ;GACnD,MAAM,UAAU,MAAM,KAAK,UAAU,OAAO,KAAK,QAAQ;GACzD,IAAI,CAAC,QAAQ,IAAI;IACf,MAAM,eAAe;KACnB;KACA,OAAO,QAAQ;KACf,SAAS;KACT,OAAO;KACP,UAAU,KAAK;KACf,GAAI,QAAQ,MAAM,sBAAsB,KAAA,IACpC,CAAC,IACD,EAAE,mBAAmB,QAAQ,MAAM,kBAAkB;IAC3D;IACA,OAAO,IAAI,IAAI,gBAAgB,oBAAoB,KAAK,YAAY,YAAY,CAAC;GACnF;EACF;EAEA,OAAO,GAAG,KAAA,CAAS;CACrB;;;;;;;;CASA,MAAa,MAAM,MAAiE;EAClF,MAAM,YAAY,KAAK,UAAU;EACjC,IAAI;GACF,MAAM,KAAK,aAAa,WAAW,CAAC,IAAI,GAAG,OAAO;EACpD,SAAS,OAAO;GACd,IAAI,iBAAiB,gBACnB,OAAO,IAAI,KAAK;GAGlB,OAAO,IACL,IAAI,eAAe,qBAAqB,KAAK,SAAS,aAAa;IACjE;IACA,aAAa,MAAM,KAAK,wBAAwB,WAAW,KAAK,QAAQ;IACxE,OAAO;IACP,UAAU,KAAK;GACjB,CAAC,CACH;EACF;EAEA,MAAM,YAAY;GAAC,GAAG;GAAW;GAAS,KAAK;EAAQ;EACvD,MAAM,UAAU,MAAM,KAAK,UAAU,MAAM,KAAK,QAAQ;EACxD,IAAI,CAAC,QAAQ,IAAI;GACf,MAAM,eAAe;IACnB,MAAM;IACN,OAAO,QAAQ;IACf,SAAS;IACT,aAAa,MAAM,KAAK,wBAAwB,WAAW,KAAK,QAAQ;IACxE,OAAO;IACP,UAAU,KAAK;IACf,GAAI,QAAQ,MAAM,sBAAsB,KAAA,IACpC,CAAC,IACD,EAAE,mBAAmB,QAAQ,MAAM,kBAAkB;GAC3D;GACA,OAAO,IAAI,IAAI,eAAe,mBAAmB,KAAK,YAAY,YAAY,CAAC;EACjF;EAEA,MAAM,SAAS,MAAM,KAAK,UAAU,kBAAkB,KAAK,QAAQ;EACnE,IAAI,CAAC,OAAO,IAAI;GACd,MAAM,eAAe;IACnB,MAAM;KACJ,GAAG;KACH;KACA,KAAK;KACL;IACF;IACA,OAAO,OAAO;IACd,SAAS;IACT,aAAa,MAAM,KAAK,wBAAwB,WAAW,KAAK,QAAQ;IACxE,OAAO;IACP,UAAU,KAAK;IACf,GAAI,OAAO,MAAM,sBAAsB,KAAA,IACnC,CAAC,IACD,EAAE,mBAAmB,OAAO,MAAM,kBAAkB;GAC1D;GACA,OAAO,IACL,IAAI,eAAe,WAAW,KAAK,SAAS,kCAAkC,YAAY,CAC5F;EACF;EACA,OAAO,GAAG,OAAO,KAAK;CACxB;;;;;;;;CASA,MAAa,KACX,MACA,SAC4C;EAC5C,MAAM,cAAc,mBAAmB,IAAI;EAC3C,IAAI,gBAAgB,KAAA,GAClB,IAAI;GAEF,OAAO,GAAG,UAAU,MADC,SAAS,aAAa,MAAM,GACrB,SAAS,SAAS,EAAE,CAAC;EACnD,SAAS,OAAO;GACd,OAAO,IACL,IAAI,kBAAkB,2BAA2B,KAAK,SAAS,QAAQ,eAAe;IACpF;IACA,QAAQ,mBAAmB,KAAK,IAAI,qBAAqB;IACzD,OAAO;IACP,UAAU,KAAK;IACf,UAAU;GACZ,CAAC,CACH;EACF;EAGF,MAAM,YAAY,KAAK,UAAU;EACjC,MAAM,QAAQ,SAAS,SAAS;EAChC,MAAM,OAAO,MAAM,KAAK,UAAU,OAAO,KAAK,UAAU,EACtD,MACF,CAAC;EACD,IAAI,KAAK,IACP,OAAO,GAAG,kBAAkB,KAAK,KAAK,CAAC;EAGzC,MAAM,cAAc,qBAAqB,KAAK,KAAK;EACnD,IAAI,gBAAgB,KAAA,GAClB,OAAO,GAAG,kBAAkB,WAAW,CAAC;EAG1C,MAAM,OAAO;GACX,GAAG;GACH;GACA,KAAK;GACL;GACA;GACA,OAAO,KAAK;EACd;EACA,OAAO,IACL,IAAI,kBAAkB,4BAA4B,KAAK,SAAS,yBAAyB;GACvF;GACA,OAAO,KAAK;GACZ,SAAS;GACT,QAAQ;GACR,OAAO;GACP,UAAU,KAAK;EACjB,CAAC,CACH;CACF;;CAGA,QAAe,MAA2B;EACxC,OAAO,KAAK,KAAK,SAAS,KAAK,QAAQ;CACzC;CAEA,MAAc,aACZ,WACA,OACA,WACe;EACf,IAAI,KAAK,WAAW;GAClB,MAAM,YAAY,MAAM,KAAK,iBAAiB,KAAK;GACnD,KAAK,MAAM,QAAQ,WAAW;IAC5B,MAAM,OAAO;KAAC,GAAG;KAAW;KAAQ;IAAI;IACxC,MAAM,SAAS,MAAM,KAAK,UAAU,KAAK,IAAI;IAC7C,IAAI,CAAC,OAAO,IAAI;KACd,MAAM,aAAa,MAAM,MAAM,cAAc,KAAK,QAAQ,SAAS,MAAM,IAAI;KAC7E,MAAM,eAAe;MACnB;MACA,OAAO,OAAO;MACd,SAAS;MACT,OAAO;MACP,UAAU;MACV,GAAI,OAAO,MAAM,sBAAsB,KAAA,IACnC,CAAC,IACD,EAAE,mBAAmB,OAAO,MAAM,kBAAkB;MACxD,GAAI,eAAe,KAAA,IAAY,CAAC,IAAI,EAAE,UAAU,WAAW,SAAS;KACtE;KACA,MAAM,cAAc,WAChB,IAAI,gBAAgB,kBAAkB,KAAK,iBAAiB,YAAY,IACxE,IAAI,eAAe,kBAAkB,KAAK,gBAAgB,YAAY;IAC5E;GACF;EACF;EAEA,MAAM,OAAO,CAAC,GAAG,WAAW,eAAe;EAC3C,MAAM,WAAW,MAAM,KAAK,UAAU,aAAa;EACnD,IAAI,CAAC,SAAS,IAAI;GAChB,MAAM,eAAe;IACnB;IACA,OAAO,SAAS;IAChB,SAAS;IACT,OAAO;IACP,GAAI,SAAS,MAAM,sBAAsB,KAAA,IACrC,CAAC,IACD,EAAE,mBAAmB,SAAS,MAAM,kBAAkB;IAC1D,GAAI,MAAM,EAAE,EAAE,aAAa,KAAA,IAAY,CAAC,IAAI,EAAE,UAAU,MAAM,EAAE,CAAC,SAAS;GAC5E;GACA,MAAM,cAAc,WAChB,IAAI,gBAAgB,0CAA0C,YAAY,IAC1E,IAAI,eAAe,yCAAyC,YAAY;EAC9E;CACF;CAEA,YAAuC;EACrC,OAAO,KAAK,UAAU,SAAS,CAAC,QAAQ,IAAI,CAAC;CAC/C;CAEA,MAAc,wBACZ,WACA,UAKC;EACD,MAAM,cAIF,CAAC;EAEL,MAAM,WAAW;GACf,GAAG;GACH;GACA;GACA;EACF;EACA,MAAM,OAAO,MAAM,KAAK,qBAAqB,aAAa,QAAQ;EAClE,IAAI,SAAS,KAAA,GAAW;GACtB,MAAM,aAAa,kBAAkB,IAAI;GACzC,IAAI,WAAW,SAAS,GACtB,YAAY,aAAa;GAE3B,IAAI,KAAK,OAAO,SAAS,GACvB,YAAY,aAAa,iBAAiB,UAAU,KAAK,MAAM;EAEnE;EAEA,MAAM,aAAa;GAAC,GAAG;GAAW;GAAU;GAAU;GAAc;GAAW;EAAI;EACnF,MAAM,SAAS,MAAM,KAAK,qBAAqB,aAAa,UAAU;EACtE,IAAI,WAAW,KAAA,GAAW;GACxB,MAAM,eAAe,kBAAkB,MAAM;GAC7C,IAAI,aAAa,SAAS,GACxB,YAAY,eAAe;EAE/B;EAEA,OAAO;CACT;CAEA,MAAc,iBAAiB,OAA2D;EACxF,MAAM,wBAAQ,IAAI,IAAY;EAE9B,KAAK,MAAM,QAAQ,OAAO;GACxB,MAAM,IAAI,KAAK,QAAQ,IAAI,CAAC;GAE5B,IAAI,gBAAgB,cAAc;IAChC,MAAM,aAAa,KAAK,KAAK,SAAS,KAAK,UAAU;IACrD,IAAI,MAAM,WAAW,UAAU,GAC7B,MAAM,IAAI,UAAU;GAExB;EACF;EAEA,OAAO,CAAC,GAAG,KAAK;CAClB;CAEA,MAAc,iBACZ,OASA;EACA,IAAI,MAAM,WAAW,GACnB,OAAO,IAAI,IAAI,qBAAqB,uBAAuB,CAAC;EAG9D,IAAI;GACF,MAAM,mBAAmB,KAAK,OAAO;EACvC,SAAS,OAAO;GACd,MAAM,SAAS,8BAA8B,KAAK;GAClD,OAAO,IACL,IAAI,yBAAyB,mCAAmC,KAAK,WAAW;IAC9E;IACA,WAAW;IACX,GAAI,WAAW,KAAA,IAAY,CAAC,IAAI,EAAE,OAAO;IACzC,UAAU,KAAK;GACjB,CAAC,CACH;EACF;EAEA,MAAM,eAAmD,CAAC;EAC1D,KAAK,MAAM,QAAQ,OAAO;GACxB,MAAM,OAAO,KAAK,KAAK,SAAS,KAAK,QAAQ;GAC7C,MAAM,WAAW,KAAK,OAAO;GAC7B,IAAI,CAAC,SAAS,IACZ,OAAO,IAAI,SAAS,KAAK;GAE3B,IAAI;IACF,MAAM,UAAU,MAAM,SAAS,OAAO,MAAM;GAC9C,SAAS,OAAO;IACd,IAAI,iBAAiB,2BACnB,OAAO,IAAI,KAAK;IAGlB,MAAM,SAAS,8BAA8B,KAAK;IAClD,OAAO,IACL,IAAI,yBAAyB,yBAAyB,KAAK,SAAS,QAAQ,QAAQ;KAClF;KACA,WAAW;KACX,GAAI,WAAW,KAAA,IAAY,CAAC,IAAI,EAAE,OAAO;KACzC,UAAU,KAAK;KACf,UAAU;IACZ,CAAC,CACH;GACF;GACA,aAAa,KAAK;IAAE;IAAM;GAAK,CAAC;EAClC;EAEA,OAAO,GAAG,IAAI,uBAA+B,KAAK,SAAS,YAAY,CAAC;CAC1E;CAEA,MAAc,qBACZ,SACA,MAOA;EACA,IAAI;GACF,OAAO,MAAM,KAAK,SAAS,SAAS,IAAI;EAC1C,SAAS,OAAO;GACd,MAAM,SAAS,qBAAqB,KAAK;GACzC,IAAI,WAAW,KAAA,GACb,OAAO;GAET;EACF;CACF;AACF;;;;;;;;AASA,IAAa,YAAb,MAAuB;CACrB;CAEA,YAAmB,SAAkB;EACnC,KAAK,UAAU;EACf,OAAO,OAAO,IAAI;CACpB;CAEA,MAAa,OACX,OACA,SAWA;EACA,IAAI,MAAM,WAAW,GACnB,OAAO,IAAI,IAAI,qBAAqB,qBAAqB,CAAC;EAG5D,MAAM,YAAY,MAAM,KAAK,cAAc,KAAK;EAChD,IAAI,CAAC,UAAU,IACb,OAAO;EAGT,MAAM,eAAe,KAAK,gBAAgB,QAAQ,KAAK;EACvD,MAAM,QAAQ,MAAM,KAAK,aAAa,QAAQ,KAAK;EACnD,MAAM,OAAO,MAAM,KAAK,aAAa,OAAO,UAAU,KAAK;EAC3D,MAAM,eAAe,MAAM,KAAK,QAAQ,YAAY,GAAI,KAAgC;EACxF,IAAI,CAAC,aAAa,IAChB,OAAO;EAGT,MAAM,UAAoB,CAAC;EAC3B,IAAI,QAAQ,UAAU,OAAO;GAC3B,MAAM,SAAS,MAAM,KAAK,QAAQ,OAAO,GAAG,KAAK;GACjD,IAAI,CAAC,OAAO,IACV,OAAO;GAET,QAAQ,KAAK,GAAG,MAAM,KAAK,SAAS,KAAK,QAAQ,CAAC;EACpD;EAEA,MAAM,UAAoB,CAAC;EAC3B,IAAI,QAAQ,SAAS,OACnB,KAAK,MAAM,QAAQ,OAAO;GACxB,MAAM,SAAS,MAAM,KAAK,QAAQ,MAAM,IAAI;GAC5C,IAAI,CAAC,OAAO,IACV,OAAO;GAET,QAAQ,KAAK,KAAK,QAAQ;EAC5B;EAGF,MAAM,KAAK,cAAc,QAAQ,OAAO,UAAU,KAAK;EAEvD,OAAO,GAAG;GACR,OAAO,KAAK;GACZ,WAAW,KAAK,QAAQ;GACxB;GACA;GACA,OAAO,QAAQ;GACf,SAAS,KAAK;GACd,WAAW,CAAC;GACZ;GACA,WAAW,KAAK;GAChB,SAAS,KAAK;EAChB,CAAC;CACH;CAEA,MAAa,OACX,UACA,UAAkC,CAAC,GAYnC;EACA,MAAM,WAAW,MAAM,KAAK,aAAa,SAAS,KAAK;EACvD,IAAI,aAAa,KAAA,GACf,OAAO,GAAG;GACR,SAAS,CAAC;GACV,UAAU,CAAC;GACX,UAAU,CAAC;GACX,OAAO,SAAS;GAChB,SAAS,CAAC;EACZ,CAAC;EAGH,MAAM,YAAY,SAAS,MAAM,KAAK,SAAS,KAAK,QAAQ;EAC5D,MAAM,UAAoB,CAAC;EAC3B,MAAM,WAAqB,CAAC;EAC5B,MAAM,UAAoB,CAAC;EAE3B,IAAI,QAAQ,QAAQ,MAAM;GACxB,MAAM,KAAK,aAAa,QAAQ,SAAS;GACzC,QAAQ,KAAK,GAAG,SAAS;EAC3B;EACA,IAAI,QAAQ,WAAW,MAAM;GAC3B,MAAM,KAAK,aAAa,WAAW,SAAS;GAC5C,SAAS,KAAK,GAAG,SAAS;EAC5B;EACA,IAAI,QAAQ,mBAAmB,MAAM;GACnC,KAAK,MAAM,QAAQ,SAAS,OAAO;IACjC,MAAM,KAAK,sBAAsB,KAAK,IAAI;IAC1C,MAAM,GAAG,KAAK,MAAM,EAAE,OAAO,KAAK,CAAC;IACnC,QAAQ,KAAK,KAAK,QAAQ;GAC5B;GACA,MAAM,KAAK,aAAa,eAAe;EACzC;EAEA,MAAM,GAAG,KAAK,gBAAgB,SAAS,KAAK,GAAG,EAAE,OAAO,KAAK,CAAC;EAE9D,OAAO,GAAG;GACR;GACA,UAAU;GACV;GACA,OAAO,SAAS;GAChB;EACF,CAAC;CACH;CAEA,MAAa,SACX,OACA,SAYA;EACA,IAAI,MAAM,WAAW,GACnB,OAAO,IAAI,IAAI,qBAAqB,uBAAuB,CAAC;EAG9D,MAAM,YAAY,MAAM,KAAK,cAAc,KAAK;EAChD,IAAI,CAAC,UAAU,IACb,OAAO;EAGT,MAAM,eAAe,KAAK,gBAAgB,QAAQ,KAAK;EACvD,MAAM,QAAQ,MAAM,KAAK,aAAa,QAAQ,KAAK;EACnD,MAAM,OAAO,MAAM,KAAK,aAAa,OAAO,UAAU,KAAK;EAE3D,KAAK,QAAQ,eAAe,SAAS,KAAK,QAAQ,SAAS,GACzD,MAAM,KAAK,aAAa,QAAQ,KAAK,OAAO;EAE9C,KAAK,QAAQ,kBAAkB,SAAS,KAAK,QAAQ,SAAS,GAC5D,MAAM,KAAK,aAAa,WAAW,KAAK,OAAO;EAEjD,KAAK,QAAQ,SAAS,SAAS,UAAU,KAAA,GAAW;GAClD,KAAK,MAAM,QAAQ,MAAM,OAAO;IAC9B,IAAI,CAAC,KAAK,QAAQ,SAAS,KAAK,QAAQ,GACtC;IAEF,MAAM,KAAK,sBAAsB,KAAK,IAAI;IAC1C,MAAM,GAAG,KAAK,MAAM,EAAE,OAAO,KAAK,CAAC;GACrC;GACA,IAAI,KAAK,QAAQ,SAAS,GACxB,MAAM,KAAK,aAAa,eAAe;EAE3C;EAEA,MAAM,eAAe,MAAM,KAAK,QAAQ,YAAY,GAAI,KAAgC;EACxF,IAAI,CAAC,aAAa,IAChB,OAAO;EAGT,MAAM,UAAoB,CAAC;EAC3B,IAAI,QAAQ,UAAU,OAAO;GAC3B,MAAM,SAAS,MAAM,KAAK,QAAQ,OAAO,GAAG,KAAK;GACjD,IAAI,CAAC,OAAO,IACV,OAAO;GAET,QAAQ,KAAK,GAAG,MAAM,KAAK,SAAS,KAAK,QAAQ,CAAC;EACpD;EAEA,MAAM,YAAsB,CAAC;EAC7B,IAAI,QAAQ,kBAAkB,OAAO;GACnC,MAAM,cAAc,MACjB,QAAQ,SAAS,KAAK,QAAQ,SAAS,KAAK,QAAQ,CAAC,CAAC,CACtD,KAAK,SAAS,KAAK,QAAQ;GAC9B,IAAI,YAAY,SAAS,GAAG;IAC1B,MAAM,KAAK,aAAa,WAAW,WAAW;IAC9C,UAAU,KAAK,GAAG,WAAW;GAC/B;EACF;EAEA,MAAM,UAAoB,CAAC;EAC3B,IAAI,QAAQ,SAAS,OACnB,KAAK,MAAM,QAAQ,OAAO;GACxB,IAAI,UAAU,SAAS,KAAK,QAAQ,GAClC;GAEF,MAAM,SAAS,MAAM,KAAK,QAAQ,MAAM,IAAI;GAC5C,IAAI,CAAC,OAAO,IACV,OAAO;GAET,QAAQ,KAAK,KAAK,QAAQ;EAC5B;EAGF,MAAM,KAAK,cAAc,QAAQ,OAAO,UAAU,KAAK;EAEvD,OAAO,GAAG;GACR,OAAO,KAAK;GACZ,WAAW,KAAK,QAAQ;GACxB;GACA;GACA,OAAO,QAAQ;GACf,SAAS,KAAK;GACd;GACA;GACA,WAAW,KAAK;GAChB,SAAS,KAAK;EAChB,CAAC;CACH;CAEA,MAAc,cAAc,OAS1B;EACA,MAAM,YAAY,CAAC;EACnB,KAAK,MAAM,QAAQ,OAAO;GACxB,MAAM,WAAW,KAAK,OAAO;GAC7B,IAAI,CAAC,SAAS,IACZ,OAAO;GAET,UAAU,KAAK;IACb,UAAU,KAAK;IACf,MAAM,KAAK,QAAQ,QAAQ,IAAI;IAC/B,UAAU,SAAS;GACrB,CAAC;EACH;EAEA,OAAO,GAAG,SAAS;CACrB;CAEA,MAAc,aACZ,OACA,SAUC;EACD,MAAM,aAAa,IAAI,IAAI,OAAO,MAAM,KAAK,SAAS,CAAC,KAAK,UAAU,KAAK,IAAI,CAAC,KAAK,CAAC,CAAC;EACvF,MAAM,eAAe,IAAI,IAAI,QAAQ,KAAK,SAAS,KAAK,QAAQ,CAAC;EACjE,MAAM,QAAkB,CAAC;EACzB,MAAM,UAAU,CAAC,GAAG,WAAW,KAAK,CAAC,CAAC,CAAC,QAAQ,aAAa,CAAC,aAAa,IAAI,QAAQ,CAAC;EACvF,MAAM,YAAsB,CAAC;EAC7B,MAAM,UAAoB,CAAC;EAE3B,KAAK,MAAM,QAAQ,SAAS;GAC1B,MAAM,YAAY,WAAW,IAAI,KAAK,QAAQ;GAC9C,IAAI,cAAc,KAAA,GAAW;IAC3B,MAAM,KAAK,KAAK,QAAQ;IACxB;GACF;GAEA,IAAI;IAEF,IAAI,MADkB,SAAS,WAAW,MAAM,MAChC,KAAK,UAAU;KAC7B,UAAU,KAAK,KAAK,QAAQ;KAC5B;IACF;GACF,QAAQ;IACN,MAAM,KAAK,KAAK,QAAQ;IACxB;GACF;GAEA,QAAQ,KAAK,KAAK,QAAQ;EAC5B;EAEA,OAAO;GACL;GACA;GACA;GACA;EACF;CACF;CAEA,MAAc,cAA+B;EAC3C,MAAM,YAAY,KAAK,KAAK,QAAQ,SAAS,aAAa;EAC1D,MAAM,MAAM,WAAW,EAAE,WAAW,KAAK,CAAC;EAC1C,OAAO;CACT;CAEA,gBAAwB,OAAuB;EAC7C,OAAO,KAAK,KAAK,QAAQ,SAAS,eAAe,GAAG,mBAAmB,KAAK,EAAE,MAAM;CACtF;CAEA,MAAc,aAAa,OAAwD;EACjF,IAAI;GACF,MAAM,UAAU,MAAM,SAAS,KAAK,gBAAgB,KAAK,GAAG,MAAM;GAClE,OAAO,KAAK,MAAM,OAAO;EAC3B,QAAQ;GACN;EACF;CACF;CAEA,MAAc,aAAa,QAAgB,QAA2B,CAAC,GAAkB;EACvF,MAAM,OACJ,WAAW,kBACP,CAAC,GAAG,KAAK,UAAU,GAAG,MAAM,IAC5B;GAAC,GAAG,KAAK,UAAU;GAAG;GAAQ,GAAG;EAAK;EAC5C,MAAM,KAAK,QAAQ,SAAS,aAAa,IAAI;CAC/C;CAEA,MAAc,sBAAsB,MAA6B;EAC/D,MAAM,KAAK,QAAQ,SAAS,MAAM,CAAC,MAAM,IAAI,CAAC;CAChD;CAEA,YAAuC;EACrC,OAAO,KAAK,QAAQ,UAAU,SAAS,CAAC,QAAQ,IAAI,CAAC;CACvD;CAEA,MAAc,cACZ,OACA,OAKe;EACf,MAAM,KAAK,YAAY;EACvB,MAAM,WAA+B;GACnC;GACA,OAAO,MAAM,KAAK,UAAU;IAC1B,UAAU,KAAK;IACf,MAAM,KAAK;GACb,EAAE;GACF,SAAS;EACX;EACA,MAAM,UAAU,KAAK,gBAAgB,KAAK,GAAG,KAAK,UAAU,UAAU,MAAM,CAAC,GAAG,MAAM;CACxF;AACF;AAEA,SAAS,GAAW,OAAsC;CACxD,OAAO;EAAE,IAAI;EAAM;CAAM;AAC3B;AAEA,SAAS,IAAY,OAAsC;CACzD,OAAO;EAAE,IAAI;EAAO;CAAM;AAC5B;AAEA,SAAS,kBAAkB,QAAsE;CAC/F,OAAO,CAAC,OAAO,QAAQ,OAAO,MAAM,CAAC,CAAC,QAAQ,UAAU,MAAM,SAAS,CAAC,CAAC,CAAC,KAAK,IAAI;AACrF;AAEA,IAAI;;;;;;;AAQJ,SAAgB,iBAA0B;CACxC,uBAAuB,IAAI,QAAQ;CACnC,OAAO;AACT;AAEA,SAAS,mBAAmB,MAAuC;CACjE,IAAI,EAAE,gBAAgB,iBACpB;CAGF,KAAK,MAAM,OAAO,CAAC,kBAAkB,eAAe,GAAY;EAC9D,MAAM,QAAQ,KAAK,QAAQ;EAC3B,IAAI,OAAO,UAAU,UACnB;EAGF,MAAM,OAAO,iBAAiB,KAAK;EACnC,IAAI,SAAS,KAAA,GACX,OAAO;CAEX;AAGF;AAEA,SAAS,iBAAiB,OAAmC;CAC3D,KAAK,MAAM,UAAU,CAAC,WAAW,OAAO,GACtC,IAAI,MAAM,WAAW,MAAM,GACzB,OAAO,MAAM,MAAM,OAAO,MAAM;AAKtC;AAEA,SAAS,UAAU,QAAgB,OAAuB;CACxD,OAAO,OAAO,MAAM,IAAI,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,IAAI;AACnD;AAEA,SAAS,mBAAmB,OAAyB;CACnD,IAAI,UAAU,QAAQ,OAAO,UAAU,UACrC,OAAO;CAGT,OAAQ,MAAkC,YAAY;AACxD;AAEA,eAAe,mBAAmB,MAA6B;CAC7D,MAAM,MAAM,MAAM,EAAE,WAAW,KAAK,CAAC;AACvC;;;;;;;ACn5BA,MAAa,WAAqBC"}