@homeflare/alchemy 0.31.1 → 0.32.0

package/README.md

@@ -7,7 +7,6 @@ bun add @homeflare/alchemy alchemy@2.0.0-beta.79 effect@4.0.0-rc.115 \
         @effect/platform-node@4.0.0-rc.115 mime@4.1.0 \
         @distilled.cloud/cloudflare@1.0.0-rc.12 @distilled.cloud/forgejo@1.0.0-rc.12 \
         @distilled.cloud/discord@1.0.0-rc.12 @distilled.cloud/google-workspace@1.0.0-rc.12 \
-        @distilled.cloud/grafana@1.0.0-rc.12 \
         @effect/sql-pg@4.0.0-rc.115
 ```
 
@@ -149,14 +148,16 @@ one is logged (argv only, never content) before it runs. A plan never calls sudo
 
 ## Linux hosts — `@homeflare/alchemy/linux`
 
-The same `HostRunner` seam, over ssh, plus the three families the launchd subpath had no Linux twin
+The same `HostRunner` seam, over ssh, plus the four families the launchd subpath had no Linux twin
 for: `HostDirectory` (because no file resource creates a parent), `RemoteFile` (a whole file, or one
-**managed block** inside a file somebody else owns) and `SystemdUnit` / `SystemdTimer`.
-`linuxProviders(await sshRunner({ host }))` provides all four.
+**managed block** inside a file somebody else owns), `SystemdUnit` / `SystemdTimer`, and
+`PodmanContainer` (one Quadlet `.container` file and the systemd unit its generator produces).
+`linuxProviders(await sshRunner({ host }))` provides all five.
 
 ```ts
 RemoteFile('block', { path: '/etc/example.conf', region: { name: 'homeflare' }, content: 'a line\n' });
 SystemdUnit('thing', { name: 'thing.service', sections: [...], restartOn: [config.sha256] });
+PodmanContainer('thing', { name: 'thing', container: { image: 'example/thing:1', network: 'host' } });
 ```
 
 - ⛔ **A deploy never mass-restarts.** A unit restarts only when its own file changed, when state or
@@ -167,7 +168,12 @@ SystemdUnit('thing', { name: 'thing.service', sections: [...], restartOn: [confi
   without its framing marker is an Error — never "nothing is there".
 - ⛔ **No silent sudo:** a root-owned path needs a root ssh destination or your own privileged runner.
 - ⛔ **The directive set is systemd's:** unit files render verbatim; nothing here invents a schema.
+- ⛔ **`PodmanContainer`'s `[Container]` section IS typed and doc-checked** (Podman 5.4,
+  `podman-systemd.unit(5)`) — Quadlet's own schema, unlike bare `systemd.unit(5)`. It has no
+  `enabled` prop and never calls `systemctl enable`: Quadlet applies `[Install]` itself at every
+  `daemon-reload`, and a generator failure is a typed `QuadletGeneratorError`, never "absent".
 - Guide, the measured `systemctl` shapes and the limits: [docs/linux-host.md](./docs/linux-host.md).
+  `PodmanContainer`'s own guide: [docs/quadlet-container.md](./docs/quadlet-container.md).
 
 ## Release binaries — `@homeflare/alchemy/release`
 
@@ -249,6 +255,17 @@ endpoint lives in ONE `general_settings` field (a whole-list read-modify-write),
 declared in `config.yaml` is refused rather than silently overridden, and a literal secret in a
 forwarded header is refused at plan: [docs/litellm.md](./docs/litellm.md).
 
+## OPNsense — `@homeflare/alchemy/opnsense`
+
+`Opnsense.Firewall.Alias`, `.Category` and `.Group` — READ-ONLY BY DESIGN, generated
+from `@distilled.cloud/opnsense` (an interim alias, like NetBox/Proxmox above — not a
+peer, `bun add` resolves it from the tarball). ⛔ `reconcile` and `delete` always
+refuse with a typed error; there is no flag that lifts it, and no write operation is
+reachable from any handler (`write-refusal.test.ts` proves it against a fake that
+fails on any non-GET). `read` answers `Unowned` on every match, `adopt(true)` is on
+by default, and a pure declaration renderer turns one live read into the props a
+noop declaration needs: [docs/opnsense.md](./docs/opnsense.md).
+
 ## Discord — `@homeflare/alchemy/discord`
 
 `Discord.ApplicationCommand` (global) and `Discord.GuildApplicationCommand` (guild-scoped)
@@ -271,6 +288,24 @@ export const help =
   });
 ```
 
+## UniFi Network — `@homeflare/alchemy/unifi`
+
+`Unifi.Network` and `Unifi.FirewallZone`, generated from Ubiquiti's own UniFi Network
+Integration API 10.4.57 via `@distilled.cloud/unifi-network`. ⛔ **READ-ONLY, by Tim's rule
+(2026-09-24):** `reconcile`/`delete` both fail with a typed `UnifiWriteRefused` naming the
+policy — this family never calls a write operation, only `getNetworkDetails`/`getFirewallZone`
+and their list counterparts. ⛔ `read` answers `Unowned` on every match (never a silent adopt —
+`adopt(true)` is on by default via the `network`/`firewallZone` constructors), and a UniFi
+**Console ID** (part of a cloud-connector base URL) is never logged, committed or written to
+state: [docs/unifi.md](./docs/unifi.md).
+
+```ts
+import { declareNetwork, network, providers } from '@homeflare/alchemy/unifi';
+
+// A later import script writes rows like this one from a live read:
+export const lan = network('lan', declareNetwork(liveNetworkDetails, 'site-id'));
+```
+
 ## Google Workspace — `@homeflare/alchemy/google-workspace`
 
 `Group`, `GroupMember`, `DomainAlias` and `OrgUnit` over the Admin SDK Directory API, generated
@@ -283,9 +318,11 @@ schema carries a `password` field, and Alchemy persists props unencrypted. Crede
 
 `Grafana.Datasource` declares one data source, keyed by `uid`, generated from
 `@distilled.cloud/grafana`'s own typed `addDataSource`/`getDataSourceByUID`/
-`updateDataSourceByUID`/`deleteDataSourceByUID` operations. ⛔ The SDK at `1.0.0-rc.12` has no
-folder, dashboard, alert-rule or contact-point CRUD — only `Datasource` ships, and the gap is
-recorded rather than worked around: [docs/grafana.md](./docs/grafana.md).
+`updateDataSourceByUID`/`deleteDataSourceByUID` operations. The SDK's earlier folder/dashboard/
+alerting-provisioning gap is fixed (`@distilled.cloud/grafana`, aliased onto
+`@homeflare/distilled-grafana` — see [docs/distilled-interim.md](./docs/distilled-interim.md)); only
+`Datasource` ships as a house resource so far, the rest is follow-up work:
+[docs/grafana.md](./docs/grafana.md).
 
 ## GitHub — `@homeflare/alchemy/github`
 

package/dist/grafana/index.d.ts

@@ -5,11 +5,12 @@
  *   the symbols a real stack consumes; the rest of the files (resource.ts's engine, fake-grafana.ts)
  *   are internals a provider needs but a consumer should not depend on.
  *
- * ⛔ ONLY `Grafana.Datasource` SHIPS HERE. `@distilled.cloud/grafana@1.0.0-rc.12` has no folder,
- *   dashboard, alert-rule or contact-point CRUD operations — see docs/grafana.md and
- *   docs/upstream-conformance.md for the measured gap. Adding those resources now would mean
- *   hand-rolling an `HttpClient` client for them, which S23 forbids for a vendor distilled
- *   already covers in part; the right fix is upstream, in distilled, not a house workaround here.
+ * ⛔ ONLY `Grafana.Datasource` SHIPS HERE. `@distilled.cloud/grafana` (aliased onto
+ *   `@homeflare/distilled-grafana` — see docs/distilled-interim.md) now HAS folder, dashboard and
+ *   alerting-provisioning CRUD operations — the SDK-level gap docs/grafana.md and
+ *   docs/upstream-conformance.md recorded is fixed. Building `Grafana.Folder`, `Grafana.Dashboard`,
+ *   `Grafana.AlertRule` etc. on top of them is follow-up work this PR deliberately does not do —
+ *   see docs/grafana.md for what changed and what is still open.
  */
 export { type DatasourceAttributes, type DatasourceProps, GrafanaDatasource, GrafanaDatasourceProvider, GrafanaSecretRefUnsetError, } from './datasource.ts';
 export { type GrafanaTarget, grafanaCredentials } from './credentials.ts';

package/dist/grafana/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/grafana/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,eAAe,EACpB,iBAAiB,EACjB,yBAAyB,EACzB,0BAA0B,GAC3B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,KAAK,aAAa,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC1E,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/grafana/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,eAAe,EACpB,iBAAiB,EACjB,yBAAyB,EACzB,0BAA0B,GAC3B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,KAAK,aAAa,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC1E,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/linux/container-form.d.ts

@@ -0,0 +1,129 @@
+/**
+ * `Podman.Container` props, attributes and the `.container` file renderer — the pure half of the
+ * family, mirroring unit-form.ts's split for Systemd.Unit.
+ *
+ * ★ WHY THE `[Container]` SECTION IS TYPED, UNLIKE `Systemd.Unit`'s SECTIONS. unit-form.ts renders
+ *   `[Unit]`/`[Service]`/`[Install]` verbatim because there is no machine-readable schema of
+ *   `systemd.unit(5)` to check a key against. Quadlet's `[Container]` section is different: it is
+ *   ONE vendor's documented, versioned surface — `podman-systemd.unit(5)`, Podman 5.4 (checked
+ *   against `containers/podman` tag `v5.4.0`,
+ *   `docs/source/markdown/podman-systemd.unit.5.md`, read 2026-09-24) — so every key below is
+ *   checked against that page, not invented. `[Unit]`/`[Service]`/`[Install]` stay close to
+ *   unit-form.ts's own verbatim-lines approach, because THOSE three sections are still systemd's
+ *   own directive set, which Quadlet passes straight through (same doc, "All options and tables
+ *   available in standard systemd unit files are supported").
+ * ⛔ `[Container] Environment=` IS NEVER A SECRET — enforced in container-secrets.ts, called from
+ *   `containerProblems` below. A container that needs a secret takes `EnvironmentFile=` pointing at
+ *   a host path an out-of-band secret renderer (openbao-agent) maintains; this family never reads
+ *   or renders that file's contents.
+ * ⛔ `[Install]` SUPPORTS ONLY `Alias=`/`WantedBy=`/`RequiredBy=` FOR A `.container` FILE (same doc,
+ *   "Currently, only the Alias, WantedBy and RequiredBy keys are supported") — NOT `Also=`, which
+ *   plain `systemd.unit(5)` allows and unit-form.ts's `INSTALL_KEYS` therefore lists. See
+ *   container-generator.ts's header for why there is no `enabled` prop at all.
+ */
+import { configDigest, digestOf } from './unit-form.ts';
+/** ★ Reused, not redefined: same digest and `restartOn`-join contract as Systemd.Unit. */
+export { configDigest, digestOf };
+export type UnitLine = readonly [key: string, value: string];
+/**
+ * The `[Container]` keys this family supports — a deliberate SUBSET of the ~80 keys
+ * `podman-systemd.unit(5)` documents (task scope: `Image`, `ContainerName`, `Network`, `Volume`,
+ * `EnvironmentFile`, `Environment`, `PublishPort`, `Exec`, `User`, `AutoUpdate`, `PodmanArgs`).
+ * Adding another key means adding a field here and checking it against the same doc — never a
+ * free-text escape hatch, or `Environment=` secret-checking (below) could be bypassed through it.
+ */
+export type ContainerSection = {
+    /** `Image=`. Required. "recommended to use a fully qualified image name" (doc). */
+    readonly image: string;
+    /** `ContainerName=`. @default quadlet's own `systemd-<name>` (doc) when omitted. */
+    readonly containerName?: string;
+    /** `Network=`. MUST support `'host'` — every container this rollout declares runs host netns. */
+    readonly network?: string;
+    /** `Volume=`, repeatable. */
+    readonly volume?: readonly string[];
+    /** `EnvironmentFile=`, repeatable. The ONLY way a secret reaches the container — see file header. */
+    readonly environmentFile?: readonly string[];
+    /** `Environment=`, repeatable `KEY=VALUE`. NEVER a secret — see container-secrets.ts. */
+    readonly environment?: Readonly<Record<string, string>>;
+    /** `PublishPort=`, repeatable. Refused together with `network: 'host'` — see `containerProblems`. */
+    readonly publishPort?: readonly string[];
+    /** `Exec=`. Appended after the image's entrypoint, "the same way as ... a Kubernetes pod" (doc). */
+    readonly exec?: string;
+    /** `User=`. The numeric UID inside the container (doc: "does not need to match the UID on the host"). */
+    readonly user?: string;
+    /** `AutoUpdate=`. Podman's own two values (doc): `'registry'` or `'local'`. */
+    readonly autoUpdate?: 'registry' | 'local';
+    /** `PodmanArgs=`, repeatable. Doc: "not recommended" — the generator does not understand it. */
+    readonly podmanArgs?: readonly string[];
+};
+export type ContainerProps = {
+    /** The Quadlet file's basename, WITHOUT `.container`. Written as `<name>.container`. */
+    name: string;
+    /** @default QUADLET_DEFAULT_DIRECTORY. Must be one of QUADLET_SEARCH_DIRECTORIES (below). */
+    directory?: string;
+    /** `[Unit]` — `Description=`/`Documentation=` typed, everything else verbatim (see file header). */
+    unit?: {
+        description?: string;
+        documentation?: string;
+        lines?: readonly UnitLine[];
+    };
+    /** `[Container]` — Quadlet's own, typed and doc-checked. */
+    container: ContainerSection;
+    /** `[Service]` — `Restart=`/`RestartSec=` typed, everything else verbatim. */
+    service?: {
+        restart?: string;
+        restartSec?: string;
+        lines?: readonly UnitLine[];
+    };
+    /** `[Install]` — the three keys Quadlet honours for a `.container` file (see file header). */
+    install?: {
+        wantedBy?: readonly string[];
+        requiredBy?: readonly string[];
+        alias?: readonly string[];
+    };
+    /** `systemctl start`/`stop` the GENERATED `<name>.service`. @default true. No `enabled` prop —
+     *  see container-generator.ts's header for why boot-time enablement is not a systemctl call here. */
+    started?: boolean;
+    /** Same contract as Systemd.Unit's `restartOn`: digests of things read outside the `.container` file. */
+    restartOn?: readonly string[];
+};
+export type ContainerAttributes = {
+    name: string;
+    /** The GENERATED unit's name: `<name>.service`. Never `.container` — systemctl never sees that. */
+    serviceName: string;
+    containerPath: string;
+    /** SHA-256 of the `.container` file this resource wrote. */
+    containerSha256: string;
+    configSha256: string;
+    loadState: string;
+    activeState: string;
+    unitFileState?: string;
+    /** `systemctl show`'s `SourcePath=` on the generated unit — measured on CT100 2026-09-24 to be
+     *  the `.container` file's own path; used to prove the generated unit is really ours. */
+    sourcePath?: string;
+    active: boolean;
+};
+/**
+ * Podman's OWN rootful search path, most specific first — `podman-systemd.unit(5)`, "Podman Unit
+ * Search Path", Podman 5.4, read 2026-09-24: "Quadlet files for the root user can be placed in the
+ * following directories ordered in precedence" (`/run` over `/etc` over `/usr/share`).
+ * ★ CT100's `caddy.container` lives in the middle one — measured live, `cat` over `ssh ct100`,
+ *   2026-09-24: `/etc/containers/systemd/caddy.container`.
+ * ⛔ A directory outside this list is invisible to Quadlet: the generator only reads these three, so
+ *   a file elsewhere is a `.container` file with no `.service` ever generated from it — silently,
+ *   unlike `Systemd.Unit`'s directory check, which at least writes a unit systemd could load if only
+ *   it were enabled. See `containerProblems`.
+ */
+export declare const QUADLET_SEARCH_DIRECTORIES: readonly ['/run/containers/systemd', '/etc/containers/systemd', '/usr/share/containers/systemd'];
+export declare const QUADLET_DEFAULT_DIRECTORY = "/etc/containers/systemd";
+/** ★ A conservative subset of what Quadlet itself accepts as a unit name: no template `@`, no `/`. */
+export declare const NAME: RegExp;
+export declare const containerPathFor: (props: Pick<ContainerProps, 'name' | 'directory'>) => string;
+/** The unit Quadlet generates FROM the `.container` file — systemctl only ever sees this name. */
+export declare const serviceNameFor: (props: Pick<ContainerProps, 'name'>) => string;
+/** The whole `.container` file. ★ Reuses unit-form.ts's `renderUnit` — same `[Section]` INI shape. */
+export declare const renderContainerFile: (props: ContainerProps) => string;
+export declare const refuseContainer: (name: string, message: string) => Error;
+/** Every refusal at once, so one plan shows the whole list — mirrors `unitProblems`'s shape. */
+export declare const containerProblems: (props: ContainerProps) => string[];
+//# sourceMappingURL=container-form.d.ts.map

package/dist/linux/container-form.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container-form.d.ts","sourceRoot":"","sources":["../../src/linux/container-form.ts"],"names":[],"mappings":"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"}

package/dist/linux/container-generator.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Quadlet is a systemd GENERATOR (`systemd.generator(7)`, tag `v257`, `man/systemd.generator.xml`,
+ * read 2026-09-24), not a unit reader — this is the one fact the whole lifecycle is built around.
+ *
+ * ★ "Generator output is supposed to last only until the next `daemon-reload`... Units written by
+ *   generators are removed when the configuration is reloaded" (same doc). `daemon-reload` DELETES
+ *   `/run/systemd/generator` wholesale and reruns every generator from the `.container` files
+ *   currently on disk. So a `.container` file the generator refuses produces NO generated unit —
+ *   even one that generated fine a moment ago, if `daemon-reload` runs again over a now-broken file.
+ *   That is why `container-lifecycle.ts` restores the LAST-KNOWN-GOOD file and reloads again on a
+ *   failed update, rather than leaving the bad file in place the way `Systemd.Unit` leaves a bad
+ *   update for the next deploy to retry (unit-lifecycle.ts): here, "the next deploy" might be a
+ *   reboot, and by then the container this resource already promised running has no systemd unit
+ *   at all, not merely a stale one.
+ * ⛔ THE GENERATED UNIT CANNOT BE `systemctl enable`D — `podman-systemd.unit(5)`, Podman 5.4, "Podman
+ *   unit files": "The services created by Podman are considered transient by systemd... it is not
+ *   possible to 'systemctl enable' them... To compensate... the generator manually applies the
+ *   [Install] section... during generation, in the same way `systemctl enable` does when run
+ *   later." MEASURED on CT100 2026-09-24 (`ssh ct100`, read-only): `caddy.container` declares
+ *   `[Install] WantedBy=multi-user.target` and nothing ever ran `systemctl enable caddy`; yet
+ *   `systemctl is-enabled caddy.service` prints `generated`, `UnitFileState=generated`, and
+ *   `/run/systemd/generator/multi-user.target.wants/caddy.service` is a symlink the GENERATOR put
+ *   there. So `Podman.Container` has no `enabled` prop and never calls `enableUnit`/`disableUnit`
+ *   (systemctl.ts) — declaring `install.wantedBy` IS the enablement, applied by the generator on
+ *   every `daemon-reload`, exactly the way `Systemd.Unit`'s enable/disable calls are applied by
+ *   this family's own `settle` step. That is the one place this family's "enable logic" differs.
+ * ★ SourcePath TIES THE GENERATED UNIT BACK TO OUR FILE. MEASURED on CT100 2026-09-24:
+ *   `systemctl show caddy.service -p SourcePath` -> `/etc/containers/systemd/caddy.container`.
+ *   `verifyGenerated` below uses it the way `unit-preflight.ts`'s `assertUnclaimed` uses a file
+ *   digest: a generated unit whose SourcePath is NOT our path belongs to a same-named `.container`
+ *   file earlier in `QUADLET_SEARCH_DIRECTORIES` (container-form.ts) — a takeover, not a success.
+ * ⚠️ REASONED, NOT MEASURED — THE ONE GAP THIS VERIFICATION HAS: whether an ALREADY-ACTIVE unit's
+ *   `LoadState` stays `loaded` (systemd does not garbage-collect a referenced/active unit object
+ *   merely because a reload failed to reproduce it) even when the UPDATED `.container` file the
+ *   generator just refused would, on its own, generate nothing. Measuring this needs writing a
+ *   broken file to a live host, which read-only access forbids. If that is how a live host
+ *   behaves, `LoadState`/`SourcePath` alone would not catch a failed update to a container that
+ *   was already running — only a CREATE, or an update to an already-INACTIVE one, is verified with
+ *   full confidence by this check alone. Restoring the last-known-good file on ANY verification
+ *   failure (container-lifecycle.ts) does not depend on this gap: it always leaves the host at the
+ *   file that is known to generate, closing the risk window even where detection is uncertain.
+ * ⛔ `needsVerificationReload` (below) is what stops a NEW resource from getting stuck — found on
+ *   adversarial review. `container-lifecycle.ts`'s `needsReload` used to be `wrote || stale ||
+ *   preStatus.needDaemonReload`; for an INTERRUPTED CREATE (the write landed, the apply crashed
+ *   before `daemon-reload` ran) the retry sees `wrote: false` (the file already holds `desired`)
+ *   and `stale: false` (there is no PRIOR state to disagree with — this is a create), so nothing
+ *   ever reloaded and `verifyGenerated` threw on the still-missing generated unit, forever: loud,
+ *   but stuck, since nothing about a plain retry ever changed. The same holds for adopting a file
+ *   whose generated unit is missing or does not match. `needsVerificationReload` shares
+ *   `generatedMatches` with `verifyGenerated` itself, so the reload gate and the verification it
+ *   is gating can never disagree about what "already proven" means.
+ */
+import type { UnitStatus } from './systemctl.ts';
+/** MEASURED on CT100 2026-09-24: `systemctl show caddy.service -p FragmentPath`. */
+export declare const GENERATED_UNIT_DIRECTORY = "/run/systemd/generator";
+export declare class QuadletGeneratorError extends Error {
+    constructor(name: string, detail: string);
+}
+/**
+ * Whether `container-lifecycle.ts` must `daemon-reload` before trusting `status` as proof of
+ * anything — true whenever `status` does not already show a matching generation. Called on the
+ * PRE-write status, so it costs nothing when `wrote`/`stale`/`NeedDaemonReload` already force a
+ * reload; it earns its keep exactly when none of them do but nothing has actually been proven yet
+ * (a fresh create or adopt with no prior state to compare against).
+ */
+export declare const needsVerificationReload: (containerPath: string, status: UnitStatus) => boolean;
+/**
+ * Throws a typed, loud `QuadletGeneratorError` — never lets a generator failure read as "the
+ * resource is simply absent", which is what a plain `LoadState=not-found` would otherwise look
+ * like to a caller that only knows the `Systemd.Unit` shape (a unit that has genuinely never been
+ * declared also reads `not-found`).
+ */
+export declare const verifyGenerated: (name: string, containerPath: string, serviceName: string, status: UnitStatus) => void;
+//# sourceMappingURL=container-generator.d.ts.map

package/dist/linux/container-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container-generator.d.ts","sourceRoot":"","sources":["../../src/linux/container-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD,oFAAoF;AACpF,eAAO,MAAM,wBAAwB,2BAA2B,CAAC;AAEjE,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,YAAY,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAGvC;CACF;AAUD;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,kBAAmB,MAAM,UAAU,UAAU,KAAG,OAC1C,CAAC;AAE3C;;;;;GAKG;AACH,eAAO,MAAM,eAAe,SACpB,MAAM,iBACG,MAAM,eACR,MAAM,UACX,UAAU,KACjB,IAmBF,CAAC"}

package/dist/linux/container-handlers.d.ts

@@ -0,0 +1,15 @@
+import type { Diff } from 'alchemy/Diff';
+import type { Input } from 'alchemy/Input';
+import * as Effect from 'effect/Effect';
+import type { HostRunner } from '../launchd/runner.ts';
+import type { ContainerAttributes, ContainerProps } from './container-form.ts';
+export declare const readHandler: (runner: HostRunner, olds: ContainerProps, output: ContainerAttributes | undefined) => Effect.Effect<ContainerAttributes | undefined, Error>;
+export declare const diffHandler: (runner: HostRunner, instanceId: string, news: Input<ContainerProps>, output: ContainerAttributes | undefined) => Effect.Effect<Diff | undefined, Error>;
+export declare const reconcileHandler: (runner: HostRunner, args: {
+    fqn: string;
+    instanceId: string;
+    news: ContainerProps;
+    output: ContainerAttributes | undefined;
+}) => Effect.Effect<ContainerAttributes, Error>;
+export declare const deleteHandler: (runner: HostRunner, output: ContainerAttributes) => Effect.Effect<void, Error>;
+//# sourceMappingURL=container-handlers.d.ts.map

package/dist/linux/container-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container-handlers.d.ts","sourceRoot":"","sources":["../../src/linux/container-handlers.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAGvD,OAAO,KAAK,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAS/E,eAAO,MAAM,WAAW,WACd,UAAU,QACZ,cAAc,UACZ,mBAAmB,GAAG,SAAS,KACtC,MAAM,CAAC,MAAM,CAAC,mBAAmB,GAAG,SAAS,EAAE,KAAK,CAKnD,CAAC;AAEL,eAAO,MAAM,WAAW,WACd,UAAU,cACN,MAAM,QACZ,KAAK,CAAC,cAAc,CAAC,UACnB,mBAAmB,GAAG,SAAS,KACtC,MAAM,CAAC,MAAM,CAAC,IAAI,GAAG,SAAS,EAAE,KAAK,CAgBvC,CAAC;AAEF,eAAO,MAAM,gBAAgB,WACnB,UAAU,QACZ;IACJ,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,cAAc,CAAC;IACrB,MAAM,EAAE,mBAAmB,GAAG,SAAS,CAAC;CACzC,KACA,MAAM,CAAC,MAAM,CAAC,mBAAmB,EAAE,KAAK,CAGxC,CAAC;AAEJ,eAAO,MAAM,aAAa,WAChB,UAAU,UACV,mBAAmB,KAC1B,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAgD,CAAC"}

package/dist/linux/container-lifecycle.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `Podman.Container`'s read / diff / reconcile / delete as plain async functions over a
+ * HostRunner — same split as `unit-lifecycle.ts`, so the whole lifecycle runs against a fake host
+ * (fake-quadlet.ts) with no real systemd or Podman.
+ *
+ * ⛔ WHAT A DEPLOY DOES NOT DO — same rule `Systemd.Unit` was built around (unit-lifecycle.ts
+ *   header): it NEVER mass-restarts. A container is restarted only when THIS resource's rendered
+ *   `.container` file changed, or a digest the declaration listed in `restartOn` changed.
+ * ★ THE ORDER IS WRITE, RELOAD, VERIFY THE GENERATOR, THEN START OR RESTART. `daemon-reload` is
+ *   where Quadlet turns the `.container` file into `<name>.service` (container-generator.ts) —
+ *   writing it changes nothing on its own, and a write that fails leaves the old file (and its
+ *   already-generated unit) exactly as they were.
+ * ⛔ A GENERATOR FAILURE IS ROLLED BACK, NOT LEFT FOR THE NEXT DEPLOY. `container-generator.ts`'s
+ *   header explains why: `daemon-reload` deletes ALL generator output before regenerating, so a
+ *   `.container` file the generator refuses has NO generated unit at all, even if the file it
+ *   replaced generated one fine. An UPDATE that fails verification restores the previous file and
+ *   reloads again, so the container this resource already promised running never loses its unit; a
+ *   CREATE that fails removes the file it wrote, same as `Systemd.Unit`'s undo.
+ * ⛔ NO ENABLE/DISABLE — see container-generator.ts and container-settle.ts headers.
+ */
+import type { Diff } from 'alchemy/Diff';
+import type { HostRunner } from '../launchd/runner.ts';
+import { type ContainerAttributes, type ContainerProps } from './container-form.ts';
+/** What is on the host now: the `.container` file's digest and the GENERATED unit's status. */
+export declare const readContainer: (runner: HostRunner, props: ContainerProps) => Promise<ContainerAttributes | undefined>;
+export declare const diffContainer: (runner: HostRunner, news: ContainerProps, output: ContainerAttributes) => Promise<Diff>;
+/**
+ * `adopt` is whether adoption is on AND this apply is a create or an unfinished generation of our
+ * own — same meaning as `Systemd.Unit`'s (unit-lifecycle.ts reconcileUnit).
+ */
+export declare const reconcileContainer: (runner: HostRunner, props: ContainerProps, output: ContainerAttributes | undefined, adopt?: boolean) => Promise<ContainerAttributes>;
+/**
+ * Stop, remove the `.container` file, reload — clearing the orphaned generated unit. Idempotent.
+ * No `disableUnit`: never enabled through systemctl in the first place (container-settle.ts).
+ */
+export declare const deleteContainer: (runner: HostRunner, output: ContainerAttributes) => Promise<void>;
+//# sourceMappingURL=container-lifecycle.d.ts.map

package/dist/linux/container-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container-lifecycle.d.ts","sourceRoot":"","sources":["../../src/linux/container-lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAIvD,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,cAAc,EAOpB,MAAM,qBAAqB,CAAC;AAY7B,+FAA+F;AAC/F,eAAO,MAAM,aAAa,WAChB,UAAU,SACX,cAAc,KACpB,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAczC,CAAC;AAEF,eAAO,MAAM,aAAa,WAChB,UAAU,QACZ,cAAc,UACZ,mBAAmB,KAC1B,OAAO,CAAC,IAAI,CAwBd,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,WACrB,UAAU,SACX,cAAc,UACb,mBAAmB,GAAG,SAAS,sBAEtC,OAAO,CAAC,mBAAmB,CAyF7B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,eAAe,WAClB,UAAU,UACV,mBAAmB,KAC1B,OAAO,CAAC,IAAI,CAad,CAAC"}

package/dist/linux/container-preflight.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Everything `Podman.Container` checks before it touches the host — split from
+ * container-lifecycle.ts so a reconcile and a plan-time REPLACE run the very same checks, exactly
+ * the reason unit-preflight.ts exists (see that file's header; this mirrors it).
+ *
+ * ★ EVERY CHECK HERE IS READ-ONLY: validation, `systemctl show`, a file read and
+ *   `HostRunner.checkWrite`. Nothing here writes, reloads or drives Podman.
+ */
+import { type HostRunner } from '../launchd/runner.ts';
+import { type UnitStatus } from './systemctl.ts';
+import { type ContainerAttributes, type ContainerProps } from './container-form.ts';
+/** Throw every refusal at once, so one plan shows the whole list. */
+export declare const assertValid: (props: ContainerProps) => void;
+/** ⛔ Writing the file and driving systemctl/Podman are root's — refuse up front, not mid-apply. */
+export declare const assertMayWrite: (runner: HostRunner, name: string) => void;
+/**
+ * ⛔ A MASKED GENERATED UNIT IS SOMEONE'S DECISION, NOT DRIFT — same rule as `Systemd.Unit`
+ *   (unit-preflight.ts `assertUsable`). Masking a generated unit is done the ordinary way, by
+ *   symlinking its name to `/dev/null` in a directory Quadlet's generator output does not win
+ *   against (`/etc/systemd/system` outranks `/run/systemd/generator`); unmasking here would
+ *   silently overrule that.
+ */
+export declare const assertUsable: (props: Pick<ContainerProps, 'name'>, status: UnitStatus) => void;
+/**
+ * ⛔ A `.container` FILE THIS RESOURCE DOES NOT OWN IS NEVER OVERWRITTEN — same rule and same
+ *   exemption as `unit-preflight.ts`'s `assertUnclaimed`: a file byte-identical to our render is
+ *   this declaration's own leftover, not someone else's.
+ */
+export declare const assertUnclaimed: (runner: HostRunner, props: ContainerProps) => Promise<void>;
+/** The half of a rename check that needs only the NEW NAME — mirrors `assertRenameTarget`. */
+export declare const assertRenameTarget: (runner: HostRunner, old: ContainerAttributes, name: string) => Promise<void>;
+/** A rename, checked at plan time, before the plan may promise a delete-first replace. */
+export declare const assertReplaceable: (runner: HostRunner, next: ContainerProps, old: ContainerAttributes) => Promise<void>;
+//# sourceMappingURL=container-preflight.d.ts.map

package/dist/linux/container-preflight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container-preflight.d.ts","sourceRoot":"","sources":["../../src/linux/container-preflight.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,KAAK,UAAU,EAAgB,MAAM,sBAAsB,CAAC;AAErE,OAAO,EAAE,KAAK,UAAU,EAAY,MAAM,gBAAgB,CAAC;AAC3D,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,cAAc,EAMpB,MAAM,qBAAqB,CAAC;AAI7B,qEAAqE;AACrE,eAAO,MAAM,WAAW,UAAW,cAAc,KAAG,IAGnD,CAAC;AAEF,mGAAmG;AACnG,eAAO,MAAM,cAAc,WAAY,UAAU,QAAQ,MAAM,KAAG,IAQjE,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,UAAW,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,UAAU,UAAU,KAAG,IAQtF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe,WAAkB,UAAU,SAAS,cAAc,KAAG,OAAO,CAAC,IAAI,CAW7F,CAAC;AAEF,8FAA8F;AAC9F,eAAO,MAAM,kBAAkB,WACrB,UAAU,OACb,mBAAmB,QAClB,MAAM,KACX,OAAO,CAAC,IAAI,CAId,CAAC;AAEF,0FAA0F;AAC1F,eAAO,MAAM,iBAAiB,WACpB,UAAU,QACZ,cAAc,OACf,mBAAmB,KACvB,OAAO,CAAC,IAAI,CAKd,CAAC"}

package/dist/linux/container-secrets.d.ts

@@ -0,0 +1,37 @@
+/**
+ * A best-effort refusal of an inline secret ANYWHERE in a rendered `.container` file — checked
+ * from `containerProblems` (container-form.ts), so it runs at plan AND apply time, before anything
+ * is written.
+ *
+ * ⛔ THIS IS NOT A SECRET SCANNER. It cannot prove a value is safe, only refuse the OBVIOUS cases: a
+ *   key whose name says what it holds, or a value shaped like a real vendor token. The actual
+ *   contract is `EnvironmentFile=` (container-form.ts's header): a secret belongs in a host file an
+ *   out-of-band renderer (openbao-agent) maintains, never in a prop, because the WHOLE file is
+ *   rendered into a 0644 file (`unit-form.ts` `UNIT_WRITE`) AND persisted unencrypted in Alchemy
+ *   state — the same two reasons `Systemd.Unit`'s `content` is never secret. A determined caller can
+ *   still name a variable `CFG` and put a token in it; this check is a guardrail against the common
+ *   mistake, not a boundary a hostile caller cannot cross.
+ * ★ KEY-NAME FIRST, VALUE SECOND. The name check catches the overwhelming majority of real
+ *   mistakes (copying a `docker run -e SECRET=...` line verbatim) and has no false-negative risk
+ *   from an unfamiliar token format; the value check is defense in depth for a handful of
+ *   widely-recognised vendor prefixes, not an attempt at general entropy detection — an entropy
+ *   check has enough false positives on ordinary config (long image digests, base64 Caddyfile
+ *   snippets) that it would train callers to ignore the refusal.
+ * ⛔ CHECKED EVERYWHERE, NOT ONLY `container.environment` — found on adversarial review.
+ *   `container.environment` is the field most likely to carry one BY ACCIDENT, and gets the
+ *   precise per-key `secretLikeEnvironment` check below with the best error message. But every
+ *   other free-text field renders into the SAME 0644 file and the SAME state row: `exec`,
+ *   `podmanArgs` (each entry rendered verbatim), and the escape-hatch `unit.lines`/`service.lines`
+ *   — a `service.lines` entry can spell a native systemd `Environment=` directly, which never goes
+ *   through the typed `container.environment` map at all. `secretLikeLines` below runs the same two
+ *   heuristics — value-shape, and an embedded `KEY=VALUE` whose KEY looks like a secret — over every
+ *   OTHER rendered line, and `container-form.ts`'s `containerProblems` calls both, so nothing
+ *   rendered escapes either check.
+ */
+export declare const secretLikeEnvironment: (environment: Readonly<Record<string, string>>) => string[];
+/** The same two heuristics as `secretLikeEnvironment`, over any OTHER rendered `[key, value]` line
+ *  (`Exec=`, `PodmanArgs=`, and the `unit.lines`/`service.lines` escape hatches) — see file header. */
+export declare const secretLikeLines: (lines: readonly (readonly [key: string, value: string])[]) => string[];
+/** `PodmanArgs=` entries that try to set a container env var outright — see `ENV_FLAG`'s comment. */
+export declare const podmanArgsProblems: (args: readonly string[]) => string[];
+//# sourceMappingURL=container-secrets.d.ts.map

package/dist/linux/container-secrets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container-secrets.d.ts","sourceRoot":"","sources":["../../src/linux/container-secrets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AA6BH,eAAO,MAAM,qBAAqB,gBAAiB,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,KAAG,MAAM,EAkB3F,CAAC;AAEF;uGACuG;AACvG,eAAO,MAAM,eAAe,UACnB,SAAS,CAAC,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,EAAE,KACxD,MAAM,EAkBR,CAAC;AAEF,qGAAqG;AACrG,eAAO,MAAM,kBAAkB,SAAU,SAAS,MAAM,EAAE,KAAG,MAAM,EAQ9D,CAAC"}

package/dist/linux/container-settle.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The step that decides whether the GENERATED `<name>.service` actually moves: running state and —
+ * only for a real change — a restart. Split out for the same reason unit-settle.ts is split from
+ * unit-lifecycle.ts: it is the restart contract, and it should be readable on its own.
+ *
+ * ⛔ THE RESTART CONDITION IS THE WHOLE CONTRACT, same as `Systemd.Unit`'s (unit-settle.ts):
+ *   `changed` comes from the caller (container-lifecycle.ts `reconcileContainer`), `configChanged`
+ *   is a digest the DECLARATION itself listed. Nothing else restarts a container.
+ * ★ NO ENABLE/DISABLE HERE — the one place this file is SHORTER than unit-settle.ts, not longer.
+ *   Quadlet's generator applies `[Install]` itself on every `daemon-reload` (container-generator.ts
+ *   header); calling `systemctl enable`/`disable` on a generated unit does not work at all (same
+ *   header, doc-cited). So there is no enablement branch to settle — only started/stopped and the
+ *   restart-on-change rule.
+ */
+import type { HostRunner } from '../launchd/runner.ts';
+import { type UnitStatus } from './systemctl.ts';
+import { type ContainerAttributes, type ContainerProps } from './container-form.ts';
+export declare const attributesOf: (props: ContainerProps, configSha256: string, containerSha256: string, containerPath: string, serviceName: string, status: UnitStatus) => ContainerAttributes;
+export type Settle = {
+    readonly before: Uint8Array | undefined;
+    /** The `.container` file or systemd's view of it changed in a way that earns a restart. */
+    readonly changed: boolean;
+    readonly configChanged: boolean;
+    readonly desired: string;
+    readonly path: string;
+    readonly serviceName: string;
+    readonly status: UnitStatus;
+};
+/**
+ * Bring running state to the declaration, restarting ONLY for a real change. No enable/disable —
+ * see file header.
+ */
+export declare const settle: (runner: HostRunner, props: ContainerProps, configSha256: string, step: Settle) => Promise<ContainerAttributes>;
+//# sourceMappingURL=container-settle.d.ts.map

package/dist/linux/container-settle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container-settle.d.ts","sourceRoot":"","sources":["../../src/linux/container-settle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEvD,OAAO,EACL,KAAK,UAAU,EAMhB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,cAAc,EAEpB,MAAM,qBAAqB,CAAC;AAE7B,eAAO,MAAM,YAAY,UAChB,cAAc,gBACP,MAAM,mBACH,MAAM,iBACR,MAAM,eACR,MAAM,UACX,UAAU,KACjB,mBAWD,CAAC;AAEH,MAAM,MAAM,MAAM,GAAG;IACnB,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,SAAS,CAAC;IACxC,2FAA2F;IAC3F,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;CAC7B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,MAAM,WACT,UAAU,SACX,cAAc,gBACP,MAAM,QACd,MAAM,KACX,OAAO,CAAC,mBAAmB,CA0B7B,CAAC"}

package/dist/linux/container.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `Podman.Container` — one Quadlet `.container` file, declared, plus the systemd unit Podman's own
+ * generator turns it into.
+ *
+ * - create / update — render, write the `.container` file atomically, `daemon-reload`, VERIFY the
+ *   generator actually produced `<name>.service` (container-generator.ts), then start or RESTART
+ *   the generated unit only when something changed (container-lifecycle.ts, container-settle.ts).
+ * - read — the `.container` file's SHA-256 plus `systemctl show <name>.service`.
+ * - diff — the rendered digest against stored and on-disk, running state against the declaration,
+ *   and systemd's own `NeedDaemonReload`.
+ * - replace — only when the file's name or directory changes, delete-first.
+ * - delete — stop the generated unit, remove the `.container` file, reload.
+ *
+ * ⛔ A DEPLOY NEVER MASS-RESTARTS — see container-lifecycle.ts's header.
+ * ⛔ THE `.container` FILE IS NEVER A SECRET, and `[Container] Environment=` is refused if it looks
+ *   like one — see container-form.ts and container-secrets.ts.
+ * ⛔ THE GENERATED UNIT IS NEVER `systemctl enable`D — see container-generator.ts's header for why,
+ *   measured and doc-cited, and what stands in for it (`install.wantedBy`).
+ * ⚠️ NOTHING IS ADOPTED WITHOUT `--adopt` — same contract as every family here.
+ */
+import { Resource } from 'alchemy';
+import * as Provider from 'alchemy/Provider';
+import { HostRunnerService } from '../launchd/runner.ts';
+import type { ContainerAttributes, ContainerProps } from './container-form.ts';
+export type { ContainerAttributes as PodmanContainerAttributes, ContainerProps as PodmanContainerProps, ContainerSection, UnitLine as PodmanUnitLine, } from './container-form.ts';
+export interface PodmanContainer extends Resource<'Podman.Container', ContainerProps, ContainerAttributes> {
+}
+export declare const PodmanContainer: import("alchemy").ResourceClass<PodmanContainer>;
+export declare const PodmanContainerProvider: () => import("effect/Layer").Layer<Provider.Provider<PodmanContainer>, never, HostRunnerService>;
+//# sourceMappingURL=container.d.ts.map

package/dist/linux/container.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container.d.ts","sourceRoot":"","sources":["../../src/linux/container.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACnC,OAAO,KAAK,QAAQ,MAAM,kBAAkB,CAAC;AAE7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAG/E,YAAY,EACV,mBAAmB,IAAI,yBAAyB,EAChD,cAAc,IAAI,oBAAoB,EACtC,gBAAgB,EAChB,QAAQ,IAAI,cAAc,GAC3B,MAAM,qBAAqB,CAAC;AAE7B,MAAM,WAAW,eAAgB,SAAQ,QAAQ,CAC/C,kBAAkB,EAClB,cAAc,EACd,mBAAmB,CACpB;CAAG;AAEJ,eAAO,MAAM,eAAe,kDAAgD,CAAC;AAE7E,eAAO,MAAM,uBAAuB,kGAiBjC,CAAC"}

package/dist/linux/fake-quadlet.d.ts

@@ -0,0 +1,25 @@
+import { type FakeLinuxOptions } from './fake-linux-host.ts';
+import type { HostRunner } from '../launchd/runner.ts';
+/** A line no real Quadlet key ever spells, so a test can force the (fake) generator to refuse a file. */
+export declare const FAIL_GENERATOR_MARKER = "X-Test-Fail-Generator=1";
+export declare const fakeQuadletHost: (options?: FakeLinuxOptions) => {
+    calls: string[][];
+    dirs: Map<string, number>;
+    expectUnit: (path: string) => void;
+    files: Map<string, {
+        bytes: Uint8Array;
+        mode: number;
+        uid: number;
+        gid: number;
+        kind: import("./index.ts").FileStat['kind'];
+    }>;
+    modes: Map<string, {
+        mode: number;
+        uid: number;
+        gid: number;
+    }>;
+    placeUnit: (path: string, text: string, state?: Partial<import("./fake-systemd.ts").UnitState>) => void;
+    units: Map<string, import("./fake-systemd.ts").UnitState>;
+    runner: HostRunner;
+};
+//# sourceMappingURL=fake-quadlet.d.ts.map

package/dist/linux/fake-quadlet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-quadlet.d.ts","sourceRoot":"","sources":["../../src/linux/fake-quadlet.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,KAAK,gBAAgB,EAAiB,MAAM,sBAAsB,CAAC;AAG5E,OAAO,KAAK,EAAc,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEnE,yGAAyG;AACzG,eAAO,MAAM,qBAAqB,4BAA4B,CAAC;AAO/D,eAAO,MAAM,eAAe,aAAa,gBAAgB;;;;;;;;;;;;;;;;;;;CAiGxD,CAAC"}