@homeflare/alchemy 0.1.0

package/dist/proxmox/ceph-osd-tree.d.ts

@@ -0,0 +1,154 @@
+/**
+ * The CRUSH tree, walked down to one OSD leaf.
+ *
+ * ★ SPLIT OUT OF ceph-osd.ts TO KEEP BOTH FILES UNDER THE 250-LINE CAP, and the seam is the same
+ *   one metric-server-form.ts cuts: this file answers "what does the cluster say about osd.N",
+ *   ceph-osd.ts answers "what is an OSD and what may a plan do about it". Nothing here calls the
+ *   API and nothing here decides a diff. `CephOsdAttributes` lives on this side of the seam
+ *   because it is a description of what the TREE says — keeping each field's
+ *   reported-never-compared reasoning against the line that builds it — and ceph-osd.ts re-exports
+ *   it so a consumer still imports one name from one place. The `import type` back for
+ *   `CephOsdProps` is a cycle on paper only: it is erased before anything runs.
+ *
+ * ⛔ `GET /nodes/{node}/ceph/osd` ANSWERS A TREE, NOT A LIST, AND IT IS THE WHOLE CLUSTER'S TREE.
+ *   MEASURED 2026-09-13: asked of n2 it answers `{"flags":…,"root":{"children":[…]}}` whose
+ *   leaves include osd.0 and osd.5 on n4; asked of n3 it answers the identical six leaves. The
+ *   `{node}` in the path chooses WHO ANSWERS, not what is listed. A provider that read it as "the
+ *   OSDs on this node" would find osd.0 through n2 and then report it as living there.
+ *
+ * ⛔ AND THE SINGLE-OBJECT PATH CANNOT BE USED INSTEAD — THIS WALK EXISTS BECAUSE IT LIES.
+ *   MEASURED: `GET /nodes/n2/ceph/osd/99`, an id with no OSD behind it, answers HTTP 200 with
+ *   `[{"name":"metadata"},{"name":"lv-info"}]` — byte for byte what `…/osd/2` answers for a real
+ *   one. It is a directory index (its schema says `permissions: {"user":"all"}`), not a read of
+ *   the OSD. Point `PveSpec.path` at it and every declared OSD is "present": `diff` reports
+ *   `noop` over a dead replica forever, and `reconcile`'s read-back guard — the one thing that
+ *   stops this package recording objects that do not exist — passes on an OSD that was never
+ *   built. The only endpoint that can tell present from absent is the tree.
+ *
+ * ★ MEASURED ON TB4 ON 2026-09-13, `GET /nodes/n2/ceph/osd`. Six leaves, all `up` and `in`, Ceph
+ *   20.2.2 tentacle:
+ *
+ *     id  name   host  device_class  crush_weight      reweight  pgs  status
+ *     0   osd.0  n4    ssd           1.86299133300781  1          99  up
+ *     5   osd.5  n4    ssd           1.86299133300781  1          94  up
+ *     1   osd.1  n3    ssd           1.86299133300781  1          96  up
+ *     4   osd.4  n3    ssd           1.81939697265625  1          97  up
+ *     2   osd.2  n2    ssd           1.81939697265625  1          88  up
+ *     3   osd.3  n2    ssd           1.81939697265625  1         105  up
+ *
+ *   `{ node: 'n2', osdid: 2, host: 'n2', device_class: 'ssd' }` plans `noop` against that row.
+ *   That is the acceptance test this file was written to pass.
+ *
+ * ⚠️ EVERY OTHER COLUMN IS REPORTED AND NEVER COMPARED, FOR FOUR DIFFERENT REASONS. `pgs` is the
+ *   autoscaler's placement rather than anybody's declaration — MEASURED, it spans 88 to 105 across
+ *   six identical disks, and Ceph moves PGs whenever it rebalances. `crush_weight` is a FLOAT
+ *   derived from device size (MEASURED: 1.86299133300781), so comparing it is float equality
+ *   against a number Ceph recomputes on `crush reweight`. `reweight` is what
+ *   `reweight-by-utilization` writes, unasked. `status` and `in` are daemon state: an OSD that
+ *   flaps down while a node reboots would otherwise put work in the plan that no write this
+ *   provider owns could ever clear. Each of those is the forever-update this package has already
+ *   been bitten by, and each is out of `settled` below.
+ *
+ * ⚠️ THE CLUSTER'S OSD FLAGS ARE NOT AN ATTRIBUTE EITHER. The read carries
+ *   `"flags":"sortbitwise,recovery_deletes,purged_snapdirs,pglog_hardlimit"` NEXT TO the root
+ *   rather than inside any leaf: they describe the OSDMap, not this OSD. Recording them per-OSD
+ *   would rewrite all six resources' state the moment somebody set `noout` for ten minutes of
+ *   maintenance — the churn-that-reads-like-drift that keeps `digest` out of storage.ts.
+ *
+ */
+import * as Effect from 'effect/Effect';
+import type { CephOsdProps } from './ceph-osd.ts';
+/** A CRUSH node. Buckets carry `children`; an OSD leaf carries `type: 'osd'`. */
+type CrushNode = Record<string, unknown>;
+/**
+ * Every OSD leaf under the tree root, at any depth.
+ *
+ * ⚠️ RECURSIVE BECAUSE THE TREE IS NOT THREE LEVELS DEEP BY LAW. TB4 measures as
+ *   root(`default`) -> host(n2|n3|n4) -> osd, but CRUSH admits datacenter, rack and chassis
+ *   buckets between them, and an OSD created outside a host bucket hangs off the root. Reaching
+ *   in as `root.children[].children[]` would read this cluster correctly and answer "absent" —
+ *   i.e. "the replica is gone" — on the first cluster that has a rack in it.
+ *
+ * ⚠️ THE OUTERMOST OBJECT IS NOT ITSELF A BUCKET. MEASURED: `root` is `{"children":[…],"leaf":0}`
+ *   with no `type` and no `name`; the bucket called `default` is its first child. So the walk
+ *   starts at `tree.root` and selects on `type === 'osd'` rather than assuming a shape.
+ */
+export declare const osdLeaves: (tree: CrushNode) => CrushNode[];
+/**
+ * The leaf for one OSD id, or undefined when nothing in the tree carries it.
+ *
+ * ⛔ `id` COMES BACK AS A STRING HERE AND AS AN INTEGER EVERYWHERE ELSE, which is the "an id
+ *   returned one way and written another" forever-diff in its most expensive form. MEASURED: the
+ *   leaf for osd.2 carries `"id":"2"` (and the host buckets carry `"id":"-7"`), while
+ *   `GET …/osd/2/metadata` carries `"id":2` and the `osdid` parameter on POST and DELETE is typed
+ *   integer. `'2' === 2` is false, so a provider comparing the raw value finds NOTHING, calls
+ *   every declared OSD absent — and, with a create path wired up, offers to build six OSDs over
+ *   six live disks. `int` from values.ts is the narrowing, and `Number.NaN` is the fallback
+ *   precisely because it equals nothing, id 0 included.
+ *
+ * ⚠️ FIRST MATCH WINS. OSD ids are unique cluster-wide, and PVE does not put the per-device-class
+ *   shadow buckets (`default~ssd`) in this tree — MEASURED: the whole tree is one `default` root,
+ *   three hosts, six leaves. If a future PVE did include them, taking the first match keeps the
+ *   answer stable instead of reporting drift depending on which copy was walked into first.
+ */
+export declare const findOsd: (tree: CrushNode, osdid: number) => CrushNode | undefined;
+export interface CephOsdAttributes {
+    /** Normalised to an integer here even though the tree spells it `"2"`. */
+    osdid: number;
+    /** `osd.2` — how Ceph, the UI and every log line name it. */
+    name: string;
+    /** COMPARED, but only when `props.host` is declared. */
+    host: string;
+    /** COMPARED, but only when `props.device_class` is declared. */
+    device_class: string;
+    /**
+     * ⚠️ REPORTED, NEVER COMPARED — `bluestore` on every live OSD and filestore has been gone for
+     *   years, so declaring it would add a field that cannot disagree. It is recorded because a
+     *   future objectstore change is exactly the kind of thing state should have caught in writing.
+     */
+    osdtype: string;
+    /** ⚠️ REPORTED, NEVER COMPARED. Daemon state — see the second ⚠️ in the header. */
+    status: string;
+    /** ⚠️ REPORTED, NEVER COMPARED. Ceph itself sets this to 0 after `mon_osd_down_out_interval`. */
+    in: boolean;
+    /** ⚠️ REPORTED, NEVER COMPARED. A float Ceph recomputes; comparing it is a permanent diff. */
+    crush_weight: number;
+    /** ⚠️ REPORTED, NEVER COMPARED. `reweight-by-utilization` owns this number, not a declaration. */
+    reweight: number;
+    /** ⚠️ REPORTED, NEVER COMPARED. The autoscaler moves PGs between OSDs whenever it likes. */
+    pgs: number;
+    /** Device capacity in bytes. Stable per disk, and the honest answer to "how big is this OSD". */
+    total_space: number;
+    /** `20.2.2`. ⚠️ Reported, never compared — an upgrade is not this resource's drift. */
+    ceph_version: string;
+}
+/**
+ * One leaf, as the attributes a plan and the state store get to see.
+ *
+ * ⚠️ THE TELEMETRY IS DELIBERATELY DROPPED, NOT FORGOTTEN. The leaf also carries `bytes_used`,
+ *   `percent_used`, `apply_latency_ms` and `commit_latency_ms`. MEASURED, AND THE MEASUREMENT SAYS
+ *   THE OPPOSITE OF WHAT YOU WOULD EXPECT: across two reads minutes apart, all four were identical
+ *   on every OSD, and both latencies read 0 — TB4 was idle, so nothing was caught in the act. That
+ *   these move is therefore REASONED, from what they count, not observed. Alchemy persists
+ *   attributes; on a cluster doing work, keeping them would rewrite all six resources' state on
+ *   every deploy and record a number that is stale by the time anybody reads it. What is kept is
+ *   what a human asking "what is this replica, and is it healthy" needs; it is not a metrics feed.
+ *
+ * ⚠️ `osdid` AND `name` ARE THE NORMALISED ID AND ITS SPELLING, taken from the leaf rather than
+ *   echoed from props, so that state records what the cluster said. They agree by construction
+ *   here — the leaf was found BY id — but echoing props into attributes is how a resource ends up
+ *   recording a declaration as though it were an observation.
+ */
+export declare const osdAttributes: (leaf: CrushNode, props: CephOsdProps) => CephOsdAttributes;
+/**
+ * The live OSD as attributes, or undefined.
+ *
+ * ★ IT LIVES HERE RATHER THAN IN ceph-osd.ts BECAUSE THE READ SIDE IS THIS FILE'S WHOLE JOB —
+ *   `findOsd` and `osdAttributes` are the two halves it composes, and keeping the caller beside
+ *   them is what let ceph-osd.ts come back under the 250-line cap when create and delete were
+ *   added. ⚠️ A 404 or a 403 both arrive here as `undefined`: see the ⛔ on `readRole` in
+ *   resource.ts for why that distinction is invisible and what it costs.
+ */
+export declare const readOsd: (props: CephOsdProps) => Effect.Effect<CephOsdAttributes | undefined, Error, import("effect/unstable/http/HttpClient").HttpClient>;
+export {};
+//# sourceMappingURL=ceph-osd-tree.d.ts.map

package/dist/proxmox/ceph-osd-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ceph-osd-tree.d.ts","sourceRoot":"","sources":["../../src/proxmox/ceph-osd-tree.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAIlD,iFAAiF;AACjF,KAAK,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAOzC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,SAAS,SAAU,SAAS,KAAG,SAAS,EAQpD,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,OAAO,SAAU,SAAS,SAAS,MAAM,0BACiB,CAAC;AAExE,MAAM,WAAW,iBAAiB;IAChC,0EAA0E;IAC1E,KAAK,EAAE,MAAM,CAAC;IACd,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAC;IACb,gEAAgE;IAChE,YAAY,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB,mFAAmF;IACnF,MAAM,EAAE,MAAM,CAAC;IACf,iGAAiG;IACjG,EAAE,EAAE,OAAO,CAAC;IACZ,8FAA8F;IAC9F,YAAY,EAAE,MAAM,CAAC;IACrB,kGAAkG;IAClG,QAAQ,EAAE,MAAM,CAAC;IACjB,4FAA4F;IAC5F,GAAG,EAAE,MAAM,CAAC;IACZ,iGAAiG;IACjG,WAAW,EAAE,MAAM,CAAC;IACpB,uFAAuF;IACvF,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,aAAa,SAAU,SAAS,SAAS,YAAY,KAAG,iBAanE,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,UAAW,YAAY,8GAMxC,CAAC"}

package/dist/proxmox/ceph-osd-write.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The two operations that change a disk: building an OSD and removing one.
+ *
+ * ★ SPLIT OUT OF ceph-osd.ts FOR THE 250-LINE CAP, and the seam is the honest one — this file is
+ *   everything that WRITES, and ceph-osd.ts is the declaration and the assertion. A reader asking
+ *   "can this destroy my data" has one file to read.
+ *
+ * ⛔ BOTH OF THESE ARE IRREVERSIBLE. `create` hands a block device to `ceph-volume lvm create`,
+ *   which zaps it; `delete` takes a replica out of a live pool and Ceph immediately begins
+ *   rewriting the missing copies across the remaining nodes. `Proxmox.CephOsd` therefore declares
+ *   `defaultRemovalPolicy: 'retain'`, so removing a declaration does NOT reach `destroyOsd` — a
+ *   caller opts in with `.pipe(RemovalPolicy.destroy())`.
+ */
+import * as Effect from 'effect/Effect';
+import type { CephOsdProps } from './ceph-osd.ts';
+export declare const createOsd: (news: CephOsdProps) => Effect.Effect<import("./ceph-osd-tree.ts").CephOsdAttributes, Error, import("effect/unstable/http/HttpClient").HttpClient>;
+/**
+ * ⛔ REMOVING THE DECLARATION REMOVES THE ASSERTION, NOT THE REPLICA, AND THAT ASYMMETRY IS THE
+ *   POINT. `DELETE /nodes/{node}/ceph/osd/{osdid}` takes a replica out of a live pool — with
+ *   `nobackfill`/`norecover` unset, Ceph immediately starts rewriting the missing copies across
+ *   the two remaining nodes — and with `cleanup=1` it zaps the LVs as well. A stack file is
+ *   edited by people in a hurry; a disk is not a thing a deleted line gets to destroy. Take an
+ *   OSD out by hand, with the cluster healthy and `ceph -s` in front of you: `ceph osd out N`,
+ *   wait for the backfill to finish, then `pveceph osd destroy N`.
+ *
+ * ★ SO IT IS IMPLEMENTED, AND THE RESOURCE DEFAULTS TO `retain` INSTEAD. Removing a declaration
+ *   drops the state row and leaves the replica alone; a caller who really means it opts in with
+ *   `.pipe(RemovalPolicy.destroy())`. That is the same shape Terraform gives `prevent_destroy`,
+ *   and it beats a `delete` that silently does nothing — which is a lie to anyone reading the
+ *   plan.
+ *
+ * ⚠️ `cleanup` DEFAULTS TO FALSE, so the logical volumes survive and the disk can be re-added
+ *   without a rebuild. Ceph still starts backfilling the missing copies the moment the OSD goes.
+ */
+export declare const destroyOsd: (olds: CephOsdProps) => Effect.Effect<unknown, Error, import("effect/unstable/http/HttpClient").HttpClient>;
+//# sourceMappingURL=ceph-osd-write.d.ts.map

package/dist/proxmox/ceph-osd-write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ceph-osd-write.d.ts","sourceRoot":"","sources":["../../src/proxmox/ceph-osd-write.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAKlD,eAAO,MAAM,SAAS,oJA4BpB,CAAC;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,UAAU,SAAU,YAAY,wFAO1C,CAAC"}

package/dist/proxmox/ceph-osd.d.ts

@@ -0,0 +1,102 @@
+/**
+ * `Proxmox.CephOsd` — one OSD in the cluster's CRUSH tree.
+ *
+ * ⛔ CREATE AND DELETE ARE IMPLEMENTED AND `root@pam` IS THE ONLY IDENTITY THAT CAN RUN THEM.
+ *   That is PVE's restriction, not this package's caution, and it is MEASURED from the cluster's
+ *   own schema (`/usr/share/pve-docs/api-viewer/apidoc.js`, 2026-09-13):
+ *
+ *     GET    /nodes/{node}/ceph/osd          -> {"check":["perm","/",["Sys.Audit","Datastore.Audit"],"any",1]}
+ *     POST   /nodes/{node}/ceph/osd          -> *** no permissions block at all ***
+ *     DELETE /nodes/{node}/ceph/osd/{osdid}  -> *** no permissions block at all ***
+ *
+ *   A PVE method with no permissions block is refused to every identity except `root@pam`, so an
+ *   OpenBao-minted `hf-provision@pve!…` token is answered 403 however wide its role — widening
+ *   `LXCProvisioner` cannot fix it. Compare the sibling families, which DO carry a check and
+ *   therefore do work with a token: `ceph/fs`, `ceph/mon` and `disks/zfs` all want `Sys.Modify`.
+ *
+ * ⚠️ SO THE WRITE PATH IS HONEST RATHER THAN USEFUL. It is written out properly in
+ *   `ceph-osd-write.ts` — read that file for what each verb destroys — and it will work for an
+ *   operator running as root@pam. Through this package's credential it will 403, and a 403 is a
+ *   better answer than a `delete` that silently does nothing while the plan claims otherwise.
+ *
+ * ★ WHAT IT IS ACTUALLY FOR, THEN: ASSERTION. It turns "n2, n3 and n4 each hold two ssd OSDs"
+ *   into a line a plan checks, and it gives Ceph-backed resources something real to depend on —
+ *   read `osd.osdid` into an `rbd` storage's props and Alchemy orders that storage after the
+ *   assertion, so a stack can no longer report a healthy Ceph storage on a cluster whose OSDs are
+ *   gone. A replica that disappears becomes work in `plan` and a loud failure on the deploy.
+ *
+ * ⛔ THE WRITE VERBS MAY NOT EVEN BE REACHABLE FOR THIS PACKAGE'S CREDENTIAL. MEASURED from the
+ *   cluster's own schema (`/usr/share/pve-docs/api-viewer/apidoc.js`, 2026-09-13): `index`,
+ *   `osdindex`, `metadata` and `lv-info` each declare a `permissions` block, while `createosd`
+ *   and `destroyosd` declare NONE — the key is absent, not empty. REASONED, NOT MEASURED: PVE
+ *   refuses a method with no permissions block to everyone but `root@pam`, so an OpenBao-minted
+ *   `hf-provision@pve!…` token would likely be answered 403 however wide its role. That is a
+ *   reason to leave the write lane closed, not something to confirm by trying: if the reasoning
+ *   is wrong, the confirmation costs a disk.
+ */
+import { Resource } from 'alchemy';
+import * as Provider from 'alchemy/Provider';
+import type { CephOsdAttributes } from './ceph-osd-tree.ts';
+import type { PveRequirements } from './resource.ts';
+import type { WithTarget } from './resource.ts';
+/**
+ * ⚠️ RE-EXPORTED, NOT DECLARED HERE — it is built in ceph-osd-tree.ts, next to the walk that fills
+ *   it in and to the reasoning for which of its fields may be compared. One name, one import.
+ */
+export type { CephOsdAttributes };
+export interface CephOsdProps extends WithTarget {
+    /**
+     * Which node ANSWERS the read — not where the OSD lives. MEASURED: the tree n2 returns and the
+     * tree n3 returns are the same six leaves, n4's included. Point this at any node that is up;
+     * `host` is the field that says where the disk is.
+     */
+    node: string;
+    /** `2` for `osd.2`. Identity, and an INTEGER — see the ⛔ on `findOsd` in ceph-osd-tree.ts. */
+    osdid: number;
+    /**
+     * The CRUSH host bucket this OSD must sit in. Undeclared means unmanaged, as in storage.ts.
+     *
+     * ⚠️ DECLARING IT IS AN ASSERTION WITH NO REPAIR. If osd.2 turns up under n3, the plan reports
+     *   work every time and the deploy fails, because moving an OSD between failure domains is a
+     *   `ceph osd crush move` this provider will not perform. That is the intent: a replica in the
+     *   wrong failure domain is not something to converge quietly past.
+     */
+    host?: string;
+    /**
+     * `ssd` | `hdd` | `nvme`, asserted the same way as `host`.
+     *
+     * ⚠️ THE READ'S SPELLING IS KEPT rather than the create parameter's (`crush-device-class`).
+     *   This resource never writes, so the tree's name is the only one it has, and inventing a
+     *   second name for one field is exactly what values.ts exists to stop.
+     */
+    device_class?: string;
+    /**
+     * The block device to build this OSD from, e.g. `/dev/nvme1n1`. Declaring it makes the resource
+     * able to CREATE; leaving it out keeps the resource a pure assertion over an OSD that exists.
+     *
+     * ⛔ EVERYTHING ON THIS DEVICE IS DESTROYED BY A CREATE. `POST /nodes/{node}/ceph/osd` hands it
+     *   to `ceph-volume lvm create`, which zaps it. Declare it only for a disk that is genuinely
+     *   blank, and read the ⛔ about id allocation below before assuming the create will land as the
+     *   `osdid` written above.
+     */
+    dev?: string;
+    /**
+     * Zap the OSD's logical volumes on destroy (`cleanup=1`). Default false: the LVs are left behind
+     * so the disk can be re-added without a rebuild, which is the recoverable choice.
+     */
+    cleanup?: boolean;
+}
+export interface ProxmoxCephOsd extends Resource<'Proxmox.CephOsd', CephOsdProps, CephOsdAttributes, never, PveRequirements> {
+}
+/**
+ * ★ `retain` BY DEFAULT, FOLLOWING ALCHEMY'S OWN PRECEDENT. `GitHub.Repository` and
+ *   `Cloudflare.Zone` default to retain "because their contents are irreplaceable"; an OSD is a
+ *   replica of live data and qualifies twice over. Retain means DELETING THE DECLARATION DOES NOT
+ *   DELETE THE OSD — Alchemy drops its state row and leaves the disk alone. `destroyOsd` is fully
+ *   implemented in ceph-osd-write.ts and runs when the caller opts in with
+ *   `.pipe(RemovalPolicy.destroy())`, so this is the Terraform `prevent_destroy` shape rather than
+ *   a missing operation — and through a minted token it 403s anyway, per the ⛔ at the top.
+ */
+export declare const ProxmoxCephOsd: import("alchemy").ResourceClass<ProxmoxCephOsd>;
+export declare const ProxmoxCephOsdProvider: () => import("effect/Layer").Layer<Provider.Provider<ProxmoxCephOsd>, never, import("effect/unstable/http/HttpClient").HttpClient>;
+//# sourceMappingURL=ceph-osd.d.ts.map

package/dist/proxmox/ceph-osd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ceph-osd.d.ts","sourceRoot":"","sources":["../../src/proxmox/ceph-osd.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGnC,OAAO,KAAK,QAAQ,MAAM,kBAAkB,CAAC;AAE7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAG5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD;;;GAGG;AACH,YAAY,EAAE,iBAAiB,EAAE,CAAC;AAElC,MAAM,WAAW,YAAa,SAAQ,UAAU;IAC9C;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,8FAA8F;IAC9F,KAAK,EAAE,MAAM,CAAC;IACd;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;;;OAQG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,cAAe,SAAQ,QAAQ,CAC9C,iBAAiB,EACjB,YAAY,EACZ,iBAAiB,EACjB,KAAK,EACL,eAAe,CAChB;CAAG;AAEJ;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,iDAEzB,CAAC;AA+HH,eAAO,MAAM,sBAAsB,oIACoD,CAAC"}

package/dist/proxmox/ceph-pool-form.d.ts

@@ -0,0 +1,217 @@
+/**
+ * What a Ceph pool IS as a declaration, and the two different forms PVE wants it in.
+ *
+ * ★ SPLIT OUT OF ceph-pool.ts TO KEEP BOTH FILES UNDER THE 250-LINE CAP, and the seam is
+ *   "does this touch the cluster" — the same one metric-server-form.ts draws, just with more on
+ *   this side because this family needs it. Here: the declared shape, the reported shape, and the
+ *   coercions that turn one into the other. There: reading TB4, deciding a diff, and the four
+ *   handlers. Nothing in this file makes a call or decides an action.
+ * ⚠️ THE PROPS LIVE HERE RATHER THAN IN THE RESOURCE FILE, which is the one place this pair
+ *   differs from metric-server / notification-target. There is no `import type` cycle back as a
+ *   result; ceph-pool.ts re-exports both interfaces so the public surface is unchanged.
+ *
+ * ⛔ POST AND PUT DO NOT TAKE THE SAME PARAMETERS, AND BOTH EXTRAS ARE DESTRUCTIVE. MEASURED from
+ *   the cluster's own schema (/usr/share/pve-docs/api-viewer/apidoc.js on n2, pve-manager 9.2.11,
+ *   2026-09-13): POST adds `add_storages` and `erasure-coding` to the shared set, PUT takes
+ *   neither. Both are refused below, so what is left between the two bodies is `name`, which PUT
+ *   reads from the path, and `pg_num`.
+ *
+ * ⛔ `pg_num` IS IN THE CREATE BODY AND NOT IN THE UPDATE BODY, AND THAT IS THE MOST IMPORTANT
+ *   LINE IN THIS FILE. MEASURED in PVE::API2::Ceph::Pool::createpool on n2: a POST carrying no
+ *   `pg_num` gets 128 substituted (`$param->{pg_num} //= 128`), and PVE::Ceph::Tools::create_pool
+ *   then runs `osd pool create` — which Ceph answers with SUCCESS for a pool that already exists,
+ *   before applying the rest of the body to it. So a create fired at a live pool SETS its pg_num,
+ *   and lowering pg_num starts a PG MERGE: hours of backfill across every OSD, on a cluster whose
+ *   Ceph traffic shares vmbr1.11 with everything else. ceph-pool.ts guards the create for exactly
+ *   that reason; this half simply never offers pg_num to an update.
+ */
+import type { WithTarget } from './resource.ts';
+export interface CephPoolProps extends WithTarget {
+    /**
+     * ⚠️ WHICH NODE THE CALL GOES THROUGH, NOT WHERE THE POOL LIVES. A pool is cluster-wide: n2 and
+     *   n3 answer byte-identically for `cephtb4` (measured). The endpoint is node-scoped only
+     *   because PVE talks to the local RADOS socket, so this is a door, not a location — it is never
+     *   compared, and moving a declaration from n2 to n3 plans noop. Point it at a node you expect
+     *   to be up: a node that is down makes the read fail, and a failed read reads as "absent".
+     */
+    node: string;
+    /**
+     * Ceph's primary key, cluster-wide.
+     * ⛔ CHANGING IT DOES NOT RENAME ANYTHING. There is no rename in this API: the plan reads the new
+     *   name, finds nothing, and CREATES AN EMPTY POOL, leaving the old one and its data behind,
+     *   untracked. `replace` was considered and rejected — it would DELETE the old pool and every
+     *   image in it to satisfy an edited string. Rename by hand, deliberately, or not at all.
+     */
+    name: string;
+    /** Replicas per object, 1-7. ⚠️ Frozen when the pool carries Ceph's `nosizechange`. */
+    size?: number;
+    /** Replicas required to accept writes, 1-7. ⚠️ Frozen by `nosizechange` too. */
+    min_size?: number;
+    /**
+     * ⛔ CREATE-TIME ONLY, AND NEVER COMPARED — the single biggest noop hazard in this family. With
+     *   `pg_autoscale_mode` on or warn the autoscaler owns this number: MEASURED on TB4, `cephtb4`
+     *   sits at pg_num 128 while the autoscaler's own `pg_num_final` is 256, so a declaration
+     *   diffing it reports an update the moment Ceph decides to act. A split is gradual even with
+     *   the autoscaler off, and `nopgchange` can refuse the write outright — which kills the WHOLE
+     *   PUT, not just this field. Declare it as the birth size; steer it afterwards with
+     *   `pg_num_min`, or by hand.
+     */
+    pg_num?: number;
+    /** The floor the autoscaler may not go below. Operator-owned and stable, so it IS compared. */
+    pg_num_min?: number;
+    /** ⚠️ PVE's create default is `warn`; Ceph's own is `on`, which is what all four TB4 pools have. */
+    pg_autoscale_mode?: 'off' | 'on' | 'warn';
+    /**
+     * The CRUSH rule BY NAME, e.g. `replicated_rule`.
+     * ★ THE SUSPECTED INTEGER-VS-NAME TRAP IS REAL BUT NOT ON THE PATH THIS RESOURCE READS, AND THAT
+     *   IS MEASURED BOTH WAYS. `GET .../ceph/pool` (the collection) reports `crush_rule: 0` with the
+     *   name beside it in `crush_rule_name`; `GET .../ceph/pool/{name}/status` reports
+     *   `crush_rule: "replicated_rule"` — the same spelling POST and PUT accept. Reading the
+     *   collection instead would reintroduce the forever-diff in a single edit.
+     */
+    crush_rule?: string;
+    /**
+     * ⛔ CREATE-TIME ONLY, AND NEVER COMPARED. PVE's PUT turns this into
+     *   `osd pool application enable` (Tools.pm:250-255), which ADDS a tag and never removes one,
+     *   and Ceph refuses a second application without `--yes-i-really-mean-it` — so an update would
+     *   either leave the pool tagged twice or die, and comparing one declared string against the
+     *   LIST that comes back is the set-in-arbitrary-order forever-diff. The live list is reported
+     *   as `applications` instead.
+     */
+    application?: 'cephfs' | 'rbd' | 'rgw';
+    /** Autoscaler size hint, ⚠️ IN BYTES — see the ⚠️ on `updateBody`. A `1T` string is not accepted. */
+    target_size?: number;
+    /**
+     * Autoscaler share of total capacity, 0-1.
+     * ⚠️ WRITTEN BUT NEVER DIFFED, because a float is not a safe equality: Ceph stores a double and
+     *   PVE prints about 15 significant digits, so a ratio that is not exactly representable would
+     *   report an update on every plan for a pool nobody touched.
+     */
+    target_size_ratio?: number;
+    /**
+     * ⛔ `never` ON PURPOSE, BOTH OF THEM, AND THE COMPILE ERROR IS THE FEATURE.
+     *   `erasure-coding` does not configure this pool — it makes PVE build TWO pools and name
+     *   neither of them what you declared: `<name>-data` for the EC data and `<name>-metadata` for
+     *   the replicated half (Pool.pm:517-530). Nothing would then exist at `{name}`, so every plan
+     *   would read absent and try to create it again, forever.
+     *   `add_storages` writes a section into storage.cfg that this graph does not own; declare a
+     *   `Proxmox.Storage` and pass this pool's `name` into it instead, which makes the link real.
+     */
+    'erasure-coding'?: never;
+    add_storages?: never;
+}
+/**
+ * ⚠️ THE THREE `no*` FLAGS ARE REPORTED BECAUSE THEY EXPLAIN A REFUSAL. Ceph can freeze a pool's
+ *   size or its PG shape, and `set_pool` dies on the whole PUT when any one parameter will not
+ *   apply (Tools.pm:310). `matches` refuses to diff the fields they freeze, so these attributes
+ *   are the only place a plan can show WHY a declared size is not being enforced. All three read
+ *   false on all four TB4 pools.
+ * ⚠️ `pg_num`, `id` AND `applications` ARE REPORTED AND NEVER COMPARED — see the props above.
+ * ⛔ NO `statistics` AND NO `autoscale_status`, though the verbose read returns both. They change
+ *   every few seconds; persisting them would rewrite this resource's state on every deploy and
+ *   read like drift. `UNSET` means the pool carries no value for that field.
+ */
+export interface CephPoolAttributes {
+    name: string;
+    /** The node the read went through. A debugging aid, not a property of the pool. */
+    node: string;
+    id: number;
+    size: number;
+    min_size: number;
+    pg_num: number;
+    pg_num_min: number;
+    pg_autoscale_mode: string;
+    /** ⚠️ Empty when PVE answered with a rule id instead of a name; `matches` then stops diffing it. */
+    crush_rule: string;
+    /** Sorted comma list, e.g. `rbd` or `cephfs`. Readable only under `?verbose=1`. */
+    applications: string;
+    target_size: number;
+    target_size_ratio: number;
+    nodelete: boolean;
+    nopgchange: boolean;
+    nosizechange: boolean;
+}
+/**
+ * Where one pool is WRITTEN, and where a new one is POSTed.
+ *
+ * ⚠️ NEITHER IS WHERE IT IS READ — the read path is a segment longer and lives in ceph-pool.ts
+ *   next to the ⛔ that explains it. These two are here because a path is wire knowledge, and
+ *   because the create guard needs the collection without needing anything else from the spec.
+ */
+export declare const object: (props: CephPoolProps) => string;
+export declare const collection: (props: CephPoolProps) => string;
+/**
+ * ⚠️ "NOT SET" IS -1 AND NOT 0, for the reason metric-server-form.ts gives: `pg_num_min`,
+ *   `target_size` and `target_size_ratio` each take 0 as a REAL value meaning "no floor, no hint",
+ *   so a provider using 0 as its absent-marker cannot tell a declared zero from an undeclared
+ *   field. Every one of these is >= 0, so -1 sits outside all of their ranges.
+ */
+export declare const UNSET = -1;
+/** ⚠️ PVE returns the tags as an ARRAY in Ceph's order, so `csv` sorts before anything sees them. */
+export declare const applications: (value: unknown) => string;
+/**
+ * Declared? compare it. Undeclared, or frozen by a flag the pool carries? leave it alone.
+ *
+ * ⚠️ `frozen` IS THE WHOLE ANSWER TO "A FIELD PVE WILL NOT ACCEPT ON WRITE". Comparing one can only
+ *   plan an update that no write can satisfy: work reported on every run, forever.
+ */
+export declare const same: <T>(declared: T | undefined, live: T, frozen?: boolean) => boolean;
+/**
+ * A declared autoscaler hint, or nothing when it is zero.
+ *
+ * ⚠️ A DECLARED ZERO IS "NO FLOOR, NO HINT", AND IT IS DELIBERATELY LEFT UNCOMPARED. REASONED, NOT
+ *   MEASURED: all four TB4 pools carry null for both `pg_num_min` and `target_size`, and finding
+ *   out for certain would mean writing to the cluster. Ceph CLEARS both when they are set to 0 and
+ *   `osd pool get all` then omits the key, which PVE reports as null and this pair reads as UNSET
+ *   — so a declared 0 would compare 0 against -1 on every plan, forever. Mapping 0 to UNSET
+ *   instead would be a guess in the OTHER direction, and wrong the same way if Ceph does report
+ *   the zero. Neither guess is made: a zero is still written, and then left unmanaged exactly like
+ *   an undeclared field.
+ */
+export declare const hint: (value: number | undefined) => number | undefined;
+/**
+ * The PUT body: everything POST and PUT both accept, `pg_num` excepted. `createBody` builds on it,
+ * the way storage.ts's `mutable` serves both of its forms. `name` is the path's last segment on an
+ * update and is not repeated here.
+ *
+ * ⚠️ SAFE TO RE-APPLY TO A POOL THAT ALREADY MATCHES, which reconcile relies on. MEASURED in
+ *   PVE::Ceph::Tools::set_pool (Tools.pm:293-300): it reads `osd pool get all` first and SKIPS
+ *   every setting whose value did not change, so re-sending the declared set costs one mon read.
+ * ⛔ BUT A SETTING THAT DID CHANGE AND CANNOT BE APPLIED KILLS THE WHOLE PUT. Tools.pm:310 dies
+ *   with "Could not set: <fields>" if any parameter is left unapplied, so a pool carrying Ceph's
+ *   `nosizechange` fails an entire update over one field. That is why the `no*` flags are reported
+ *   and why `matches` refuses to diff what they freeze.
+ *
+ * ⚠️ AN UNDECLARED FIELD IS NEITHER SENT NOR COMPARED — storage.ts's rule, and the opposite of
+ *   Proxmox.Pool's. Undeclared means UNMANAGED here, because a pool has no one set of defaults to
+ *   fall back on: PVE's POST fills in size 3, min_size 2, application rbd and pg_autoscale_mode
+ *   'warn' (MEASURED in createpool), while Ceph's own defaults — which is what every pool on TB4
+ *   was actually born with — put pg_autoscale_mode at 'on'. Guessing either set would rewrite a
+ *   pool somebody tuned by hand.
+ *
+ * ⛔ THERE IS NO `delete=` HERE AND THERE MUST NOT BE ONE. `setpool` is not a SectionConfig write:
+ *   it turns each parameter into an `osd pool set`, and Ceph has no "unset" for size, min_size or
+ *   crush_rule. metric-server-form.ts clears an undeclared optional because status.cfg supports
+ *   it; the same move here would send a parameter PVE has no verb for.
+ *
+ * ⚠️ `target_size` IS BYTES ON THE WIRE IN BOTH DIRECTIONS, WHICH IS WHY THE PROP IS A NUMBER AND
+ *   NOT PVE's `1T` STRING. MEASURED: the API parses the string with PVE::JSONSchema::parse_size
+ *   and stores Ceph's `target_size_bytes` (Pool.pm:474-477 for POST, 683-686 for PUT), and
+ *   `GET .../status` hands that integer back under the name `target_size` (Pool.pm:878). Run on
+ *   n2, `parse_size('1099511627776')` returns 1099511627776 — bare digits are bytes, no
+ *   multiplier — so a byte count survives the round trip exactly, while a declared `1T` would read
+ *   back as 1099511627776 and diff against itself on every plan, forever.
+ */
+export declare const updateBody: (props: CephPoolProps) => Record<string, string>;
+/**
+ * The POST body.
+ *
+ * ⛔ `add_storages=0` IS SENT EXPLICITLY RATHER THAN LEFT OUT, AND THE DEFAULT IS NOT WHAT IT LOOKS
+ *   LIKE. MEASURED at Pool.pm:481 — `$add_storages = 1 if $ec && !defined($add_storages)` — so for
+ *   an erasure-coded pool PVE turns it ON when the parameter is absent. A pool created with it
+ *   writes a NEW SECTION INTO storage.cfg that this graph does not own: `Proxmox.Storage` would
+ *   not know about it, `alchemy destroy` would leave it behind, and the first person to notice
+ *   would be whoever found a storage nobody declared.
+ */
+export declare const createBody: (props: CephPoolProps) => Record<string, string>;
+//# sourceMappingURL=ceph-pool-form.d.ts.map

package/dist/proxmox/ceph-pool-form.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ceph-pool-form.d.ts","sourceRoot":"","sources":["../../src/proxmox/ceph-pool-form.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGhD,MAAM,WAAW,aAAc,SAAQ,UAAU;IAC/C;;;;;;OAMG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,uFAAuF;IACvF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,gFAAgF;IAChF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+FAA+F;IAC/F,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,oGAAoG;IACpG,iBAAiB,CAAC,EAAE,KAAK,GAAG,IAAI,GAAG,MAAM,CAAC;IAC1C;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,QAAQ,GAAG,KAAK,GAAG,KAAK,CAAC;IACvC,qGAAqG;IACrG,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;;;;;OAQG;IACH,gBAAgB,CAAC,EAAE,KAAK,CAAC;IACzB,YAAY,CAAC,EAAE,KAAK,CAAC;CACtB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,mFAAmF;IACnF,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,oGAAoG;IACpG,UAAU,EAAE,MAAM,CAAC;IACnB,mFAAmF;IACnF,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,QAAQ,EAAE,OAAO,CAAC;IAClB,UAAU,EAAE,OAAO,CAAC;IACpB,YAAY,EAAE,OAAO,CAAC;CACvB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,UAAW,aAAa,WAAkD,CAAC;AAC9F,eAAO,MAAM,UAAU,UAAW,aAAa,WAAoC,CAAC;AAEpF;;;;;GAKG;AACH,eAAO,MAAM,KAAK,KAAK,CAAC;AAExB,qGAAqG;AACrG,eAAO,MAAM,YAAY,UAAW,OAAO,WACoC,CAAC;AAEhF;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,YAAY,CAAC,GAAG,SAAS,QAAQ,CAAC,8BACD,CAAC;AAExD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,IAAI,UAAW,MAAM,GAAG,SAAS,uBAAsC,CAAC;AASrF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,UAAU,UAAW,aAAa,KAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAQrE,CAAC;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU,UAAW,aAAa,KAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAMrE,CAAC"}

package/dist/proxmox/ceph-pool-settle.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Waiting for Ceph to finish, which is a concern of its own.
+ *
+ * ★ SPLIT OUT OF ceph-pool.ts FOR THE 250-LINE CAP, and the seam is real: every other PVE family
+ *   in this package writes and reads back in one breath, because PVE's config endpoints are
+ *   synchronous. Ceph's are not — a pool delete returns before the PGs are gone — so this file is
+ *   the polling that difference forces, and ceph-pool.ts is the declaration.
+ */
+import * as Effect from 'effect/Effect';
+import type { CephPoolAttributes, CephPoolProps } from './ceph-pool-form.ts';
+import type { PveRequirements } from './resource.ts';
+/**
+ * ⚠️ THE DEPENDENCIES ARE PASSED IN RATHER THAN IMPORTED, and that is what made this file
+ *   separable at all. `collection`, `object` and `ops.read` are module-level bindings in
+ *   ceph-pool.ts; importing them back would be a runtime cycle, and duplicating them would be two
+ *   definitions of one path. Passing them is the pattern zfs-pool-write.ts already uses.
+ */
+export type PoolRead = (props: CephPoolProps) => Effect.Effect<CephPoolAttributes | undefined, never, PveRequirements>;
+/**
+ * ⛔ THE GUARD ON THE CREATE. `read` folds a 403, a timeout and a node that is down into the same
+ *   `undefined` as a pool that is genuinely missing — so "absent" is not evidence. This asks a
+ *   second, different question: does the cluster LIST this pool? A failure is left to propagate
+ *   rather than folded, so "I could not ask" fails the deploy instead of creating over live data.
+ *   An empty list is trusted: the collection 403s when the role is too narrow rather than
+ *   filtering, so `[]` really does mean a cluster with no pools.
+ */
+export declare const confirmAbsent: (props: CephPoolProps, collection: string, describe: string) => Effect.Effect<void, Error, import("effect/unstable/http/HttpClient").HttpClient>;
+/**
+ * Wait for the cluster to agree, then answer the last thing it said.
+ *
+ * ★ IT POLLS `matches`, THE SAME PREDICATE `diff` USES, so "settled" has exactly one definition in
+ *   this file. Polling `/nodes/{node}/tasks/{upid}/status` instead would read the worker's own
+ *   exit status, but it needs `Sys.Audit` on the node for a token that is NOT the one that started
+ *   the task — every `pve` call mints a fresh token, so the task's owner check cannot pass.
+ * ⚠️ SHORT POLLS, LOW CAP: 2s apart, 30 tries, about a minute. A pool create takes seconds; one
+ *   still unsettled after a minute is a fault to surface, not a wait to lengthen.
+ */
+export declare const settle: (props: CephPoolProps, read: PoolRead, done: (live: CephPoolAttributes | undefined) => boolean) => Effect.Effect<CephPoolAttributes | undefined, never, import("effect/unstable/http/HttpClient").HttpClient>;
+//# sourceMappingURL=ceph-pool-settle.d.ts.map

package/dist/proxmox/ceph-pool-settle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ceph-pool-settle.d.ts","sourceRoot":"","sources":["../../src/proxmox/ceph-pool-settle.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAE7E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG,CACrB,KAAK,EAAE,aAAa,KACjB,MAAM,CAAC,MAAM,CAAC,kBAAkB,GAAG,SAAS,EAAE,KAAK,EAAE,eAAe,CAAC,CAAC;AAE3E;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,UAAW,aAAa,cAAc,MAAM,YAAY,MAAM,qFAcrF,CAAC;AAEJ;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,UACV,aAAa,QACd,QAAQ,QACR,CAAC,IAAI,EAAE,kBAAkB,GAAG,SAAS,KAAK,OAAO,+GASrD,CAAC"}

package/dist/proxmox/ceph-pool.d.ts

@@ -0,0 +1,48 @@
+/**
+ * `Proxmox.CephPool` — a Ceph RADOS pool, declared. The richest Ceph family and the one a stack is
+ * most likely to reach for, because every RBD disk in the cluster lives inside one.
+ *
+ * ⛔ IT DOES NOT USE `pveHandlers`, AND THE REASON IS MEASURED RATHER THAN STYLISTIC: THE READ AND
+ *   THE WRITES SIT AT DIFFERENT PATHS. `GET /nodes/{node}/ceph/pool/{name}` is `poolindex` and
+ *   answers `[{"name":"status"}]` — an INDEX OF CHILDREN, not the pool. The pool is one level
+ *   further down, at `.../status` (`getpool`), which accepts no PUT and no DELETE. A `PveSpec`
+ *   carries ONE `path` for read, update and delete, so this family cannot be spelled in it. `path`
+ *   below is therefore the READ path and nothing else consumes it: `ops.reconcile` and
+ *   `ops.destroy` go unused and the two write handlers name their own path. acl.ts is the
+ *   precedent for hand-writing the five handlers over `pveOperations`.
+ *
+ * ⛔ A CREATE FIRED AT A POOL THAT ALREADY EXISTS IS NOT A NO-OP, IT IS A PG MERGE — the second ⛔
+ *   in ceph-pool-form.ts has the evidence, and `confirmAbsent` below is the guard that stops it.
+ *
+ * ⛔ EVERY WRITE HERE IS A FORKED WORKER. createpool, setpool and destroypool each return a UPID
+ *   string, so HTTP 200 means "the task started" — an immediate read-back can see a pool that does
+ *   not exist yet, or values that have not landed. `settle` waits for the cluster to agree.
+ *
+ * ⛔ THE FOUR POOLS ON TB4 INCLUDE CEPH'S OWN, AND NONE OF THEM MAY BE ADOPTED. Measured
+ *   2026-09-13: `.mgr` (application `mgr`, created and owned by the manager daemons),
+ *   `cephfs-tb4_data` and `cephfs-tb4_metadata` (the two halves of the `cephfs-tb4` filesystem —
+ *   destroying either destroys the filesystem), and `cephtb4`, the rbd pool the guests sit on.
+ *   `list` answers empty like every resource in this package, so adoption stays an explicit act;
+ *   the `applications` attribute is reported so that a plan SHOWS which of those a declaration hit.
+ *
+ * ⚠️ DELETING A POOL DESTROYS EVERY OBJECT IN IT AND CEPH DOES NOT ASK TWICE. Neither `force` nor
+ *   `remove_storages` is ever sent, so PVE's refusal while a storage on the pool still lists RBD
+ *   images is left standing. That refusal does NOT cover an RBD user outside storage.cfg.
+ *
+ * ⚠️ PRIVILEGES, AND THE WRITE LANE IS A BIG ASK. Read is `Sys.Audit` OR `Datastore.Audit` on `/`
+ *   (PVEAuditor holds both, so the mount's `read` role covers read, diff and the guard). Create,
+ *   update and delete each check `Sys.Modify` on `/` — there is no `/ceph` object to scope to, so
+ *   granting it also buys datacenter options and every other cluster-wide write. Widen
+ *   deliberately, the way `Pool.Allocate` was widened for `Proxmox.Pool`.
+ */
+import { Resource } from 'alchemy';
+import * as Provider from 'alchemy/Provider';
+import { type CephPoolAttributes, type CephPoolProps } from './ceph-pool-form.ts';
+import { type PveRequirements } from './resource.ts';
+export type { CephPoolAttributes, CephPoolProps };
+export interface ProxmoxCephPool extends Resource<'Proxmox.CephPool', CephPoolProps, CephPoolAttributes, never, PveRequirements> {
+}
+/** ★ `retain` by default — a pool holding objects cannot be rebuilt. See the ★ in resource.ts. */
+export declare const ProxmoxCephPool: import("alchemy").ResourceClass<ProxmoxCephPool>;
+export declare const ProxmoxCephPoolProvider: () => import("effect/Layer").Layer<Provider.Provider<ProxmoxCephPool>, never, import("effect/unstable/http/HttpClient").HttpClient>;
+//# sourceMappingURL=ceph-pool.d.ts.map

package/dist/proxmox/ceph-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ceph-pool.d.ts","sourceRoot":"","sources":["../../src/proxmox/ceph-pool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACnC,OAAO,KAAK,QAAQ,MAAM,kBAAkB,CAAC;AAE7C,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,aAAa,EASnB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,KAAK,eAAe,EAA+B,MAAM,eAAe,CAAC;AAGlF,YAAY,EAAE,kBAAkB,EAAE,aAAa,EAAE,CAAC;AAElD,MAAM,WAAW,eAAgB,SAAQ,QAAQ,CAC/C,kBAAkB,EAClB,aAAa,EACb,kBAAkB,EAClB,KAAK,EACL,eAAe,CAChB;CAAG;AAEJ,kGAAkG;AAClG,eAAO,MAAM,eAAe,kDAE1B,CAAC;AAiEH,eAAO,MAAM,uBAAuB,qIA4EjC,CAAC"}