@homeflare/alchemy 0.36.0 → 0.37.1

package/dist/proxmox/ceph-fs-wire.d.ts

@@ -48,6 +48,17 @@
  *   user needs 'Sys.Audit' permissions on '/nodes/<node>' if they are not the owner of the task."
  *   Grant it on the `read` role, or every create burns the full cap below and reports the wrong
  *   cause.
+ *
+ * ★ AS OF 2026-09-24 (decision 43's walk-down, 2c) THIS FILE IS `client.ts`'s HALF ONLY. The read
+ *   (`readRow`) moved to `ceph-fs-distilled.ts`, and so did the create — `nodes.updateNodeCephFs`
+ *   (distilled's own misnamed POST, confirmed against its `T.Http` annotation) plus a SEPARATE
+ *   distilled `settle`, using the raw `getNodeTaskStatus` operation in its own tolerant poll loop
+ *   rather than `Task.awaitTask`, which does not tolerate a poll failure the way this family needs
+ *   (network-apply-read.ts's own header has the fuller reasoning). `destroyFs` stays HERE,
+ *   unmigrated: distilled types `remove_pools`/`remove_storages` as `T.Body` on a DELETE, and the
+ *   ⛔ two paragraphs up is the MEASURED reason PVE would silently ignore both flags if sent that
+ *   way — a real protocol gap, not a judgement call. `settle` below is still shared where it can
+ *   be: `createForm`/`objectPath`/`destroyPath` are pure and reused by the distilled file too.
  */
 import * as Effect from 'effect/Effect';
 import type { CephFsAttributes, CephFsProps } from './ceph-fs.ts';
@@ -63,24 +74,22 @@ import type { CephFsAttributes, CephFsProps } from './ceph-fs.ts';
  *   `reconcile` takes the create branch on exactly that signal.
  */
 export declare const readRow: (live: Record<string, unknown>, props: CephFsProps) => CephFsAttributes | undefined;
+/**
+ * ⚠️ SHORT POLLS, LOW CAP. Ninety seconds covers two pool creates plus the ten seconds `createfs`
+ *   itself spends waiting for an MDS to go active, and is short enough that a stuck task fails the
+ *   deploy rather than parking it for the afternoon.
+ */
+export declare const POLL_SECONDS = 2;
+export declare const POLL_ATTEMPTS = 45;
 /** ⚠️ `nodes/{n}/ceph/fs/{name}` — the POST and DELETE target, and NOT where a read goes. */
 export declare const objectPath: (props: CephFsProps) => string;
+/** The vendor rules `createForm` is checked against — `guardWrite`, distilled-guard.ts. */
+export declare const CEPH_FS_CREATE = "pve:POST /nodes/{node}/ceph/fs/{name}";
 /**
  * ⚠️ `name` IS DELIBERATELY ABSENT FROM THE FORM. It is already the last segment of the path being
  *   POSTed to — the metric-server.ts case again — and a second copy can only ever disagree with it.
  */
 export declare const createForm: (props: CephFsProps) => Record<string, string>;
-/**
- * POST the create, then wait for the worker. ⛔ The caller still reads back; see ceph-fs.ts.
- *
- * ⚠️ A CREATE NEEDS A RUNNING *AND* A STANDBY MDS, and refuses BEFORE it forks -- "no running
- *   Metadata Server (MDS) found!" / "no standby Metadata Server (MDS) found!" are synchronous, so
- *   they surface as a failed POST rather than as a silent worker. C1 has three (MEASURED: node-c
- *   `up:active` for cephfs-c1, node-b and node-d `up:standby`), so this is a note for a smaller cluster.
- * ⚠️ BOTH WRITES CHECK `Sys.Modify` ON `/` -- the root, with the breadth metric-server.ts warns
- *   about: granting it buys datacenter options and every other cluster-wide config write too.
- */
-export declare const createFs: (props: CephFsProps) => Effect.Effect<undefined, Error | import("./credential-errors.ts").PveCredentialDenied, import("effect/unstable/http/HttpClient").HttpClient>;
 /**
  * DELETE the filesystem, then wait for the worker.
  *

package/dist/proxmox/ceph-fs-wire.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ceph-fs-wire.d.ts","sourceRoot":"","sources":["../../src/proxmox/ceph-fs-wire.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAKlE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,OAAO,SACZ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,SACtB,WAAW,KACjB,gBAAgB,GAAG,SAkBrB,CAAC;AAaF,6FAA6F;AAC7F,eAAO,MAAM,UAAU,UAAW,WAAW,WAAgD,CAAC;AAM9F;;;GAGG;AACH,eAAO,MAAM,UAAU,UAAW,WAAW,KAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAGnE,CAAC;AA2DH;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,UAAW,WAAW,iJAiBvC,CAAC;AAEL;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS,UAAW,WAAW,4IAQxC,CAAC;AAEL;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,UAAW,WAAW,UAK1C,CAAC;AAEJ,eAAO,MAAM,YAAY,UAAW,WAAW,UAK5C,CAAC"}
+{"version":3,"file":"ceph-fs-wire.d.ts","sourceRoot":"","sources":["../../src/proxmox/ceph-fs-wire.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAKlE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,OAAO,SACZ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,SACtB,WAAW,KACjB,gBAAgB,GAAG,SAkBrB,CAAC;AAKF;;;;GAIG;AAEH,eAAO,MAAM,YAAY,IAAI,CAAC;AAC9B,eAAO,MAAM,aAAa,KAAK,CAAC;AAEhC,6FAA6F;AAC7F,eAAO,MAAM,UAAU,UAAW,WAAW,WAAgD,CAAC;AAE9F,2FAA2F;AAC3F,eAAO,MAAM,cAAc,0CAA0C,CAAC;AAMtE;;;GAGG;AACH,eAAO,MAAM,UAAU,UAAW,WAAW,KAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAGnE,CAAC;AA2DH;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS,UAAW,WAAW,4IAQxC,CAAC;AAEL;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,UAAW,WAAW,UAK1C,CAAC;AAEJ,eAAO,MAAM,YAAY,UAAW,WAAW,UAK5C,CAAC"}

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

@@ -19,12 +19,20 @@
  *   below returns the INDEX and `attributes` picks this filesystem out of the array client-side —
  *   the shape acl.ts uses for the one flat `GET /access/acl`. The POST goes to the `{name}` path,
  *   so `collection()` is the LONGER of the two strings, the mirror of metric-server.ts.
- *   ⚠️ AND THAT IS WHY `delete` AND `reconcile` ARE HAND-WRITTEN BELOW rather than taken from
- *     `pveHandlers`. `pveOperations.destroy` deletes `spec.path`, which here is the index:
- *     `DELETE /nodes/{node}/ceph/fs` is not a route, so a factory delete would fail every destroy
- *     while the filesystem stayed exactly where it was. `reconcile` is hand-written for a second,
- *     independent reason — the forked worker — set out in ceph-fs-wire.ts. acl.ts is the
- *     precedent for a family that genuinely does not fit; this is the second.
+ *   ⚠️ AND THAT IS WHY EVERY HANDLER BELOW IS HAND-WRITTEN rather than taken from a factory. A
+ *     factory `destroy` deletes the read path, which here is the index: `DELETE /nodes/{node}/
+ *     ceph/fs` is not a route, so it would fail every destroy while the filesystem stayed exactly
+ *     where it was. `reconcile` is hand-written for a second, independent reason — the forked
+ *     worker — set out in ceph-fs-wire.ts. acl.ts is the precedent for a family that genuinely
+ *     does not fit a shared shape.
+ *
+ * ★ MIGRATED OFF `client.ts`'s generic `pve()` ONTO `@distilled.cloud/proxmox`'s typed
+ *   `nodes.listNodeCephFs`/`updateNodeCephFs` for the READ and the CREATE (2026-09-24, decision
+ *   43's walk-down, 2c — ceph-fs-distilled.ts). `destroyFs` STAYS on `client.ts`, unmigrated:
+ *   the SDK originally put `remove-pools`/`remove-storages` in a DELETE body, which PVE ignores.
+ *   SDK PR #265 fixes that protocol gap; migrating `destroyFs` remains a separate change.
+ *   The typed-read follow-up removes the catch-all fold from `readFs`: a failed index must
+ *   fail read/diff/reconcile/delete, not report a missing filesystem or a successful destroy.
  *
  * ⛔ CREATING A CephFS CREATES TWO CEPH POOLS, AND A `Proxmox.CephPool` MUST NOT ALSO DECLARE THEM.
  *   `createfs` builds `<name>_data` and `<name>_metadata` itself and refuses outright if either
@@ -120,5 +128,21 @@ export interface ProxmoxCephFs extends Resource<'Proxmox.CephFs', CephFsProps, C
 }
 /** ★ `retain` by default — a filesystem holding data cannot be rebuilt. See the ★ in resource.ts. */
 export declare const ProxmoxCephFs: import("alchemy").ResourceClass<ProxmoxCephFs>;
+/**
+ * ⛔ NOTHING IS COMPARED, AND THAT IS THE MOST DELIBERATE LINE IN THIS FILE. A CephFS has no
+ *   readable, writable field: the index returns only the name and the pools behind it, and every
+ *   prop this resource accepts is create-time or delete-time. So "present" IS "settled", and the
+ *   only honest comparison is none at all.
+ *   ⚠️ THE TEMPTING ADDITION IS `pg_num`, AND IT WOULD BE THE WORST BUG THIS PACKAGE HAS SHIPPED.
+ *     It is not in the index at all, so it can only be read from the pool endpoint — where the
+ *     autoscaler owns it. MEASURED on C1 today: created at 128, live at 32, with the metadata
+ *     pool already scheduled down to 16. Compared, that is an eternal mismatch — and since there
+ *     is no update path, treating this as a diff would plan a REPLACE. The plan would destroy and
+ *     rebuild a live filesystem on every deploy, triggered by a daemon on its own schedule.
+ *   ⚠️ `data_pools` AND `metadata_pool_id` ARE OUT FOR THE ORDINARY REASONS: a set PVE returns
+ *     in its own order, and an integer id for something written as a name. `name` is out because
+ *     it is the FILTER that produced these attributes, so comparing it is true by construction —
+ *     an identity change is handled in `diff`, not here. `node` is out because it is a route.
+ */
 export declare const ProxmoxCephFsProvider: () => import("effect/Layer").Layer<Provider.Provider<ProxmoxCephFs>, never, import("effect/unstable/http/HttpClient").HttpClient>;
 //# sourceMappingURL=ceph-fs.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ceph-fs.d.ts","sourceRoot":"","sources":["../../src/proxmox/ceph-fs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEnC,OAAO,KAAK,QAAQ,MAAM,kBAAkB,CAAC;AAW7C,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,UAAU,EAAiB,MAAM,eAAe,CAAC;AAErF,MAAM,WAAW,WAAY,SAAQ,UAAU;IAC7C,2FAA2F;IAC3F,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;;;;OAUG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,+FAA+F;IAC/F,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,4FAA4F;IAC5F,SAAS,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,aAAc,SAAQ,QAAQ,CAC7C,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,KAAK,EACL,eAAe,CAChB;CAAG;AAEJ,qGAAqG;AACrG,eAAO,MAAM,aAAa,gDAExB,CAAC;AA6BH,eAAO,MAAM,qBAAqB,mIA6E/B,CAAC"}
+{"version":3,"file":"ceph-fs.d.ts","sourceRoot":"","sources":["../../src/proxmox/ceph-fs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEnC,OAAO,KAAK,QAAQ,MAAM,kBAAkB,CAAC;AAK7C,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAEtE,MAAM,WAAW,WAAY,SAAQ,UAAU;IAC7C,2FAA2F;IAC3F,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;;;;OAUG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,+FAA+F;IAC/F,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,4FAA4F;IAC5F,SAAS,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,aAAc,SAAQ,QAAQ,CAC7C,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,KAAK,EACL,eAAe,CAChB;CAAG;AAEJ,qGAAqG;AACrG,eAAO,MAAM,aAAa,gDAExB,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,qBAAqB,mIAiF/B,CAAC"}

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

@@ -56,6 +56,7 @@
  *   maintenance — the churn-that-reads-like-drift that keeps `digest` out of storage.ts.
  *
  */
+import * as nodes from '@distilled.cloud/proxmox/nodes';
 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'`. */
@@ -146,9 +147,17 @@ export declare const osdAttributes: (leaf: CrushNode, props: CephOsdProps) => Ce
  * ★ 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.
+ *   added.
+ *
+ * ★ MIGRATED OFF `client.ts`'s `pve()` ONTO `@distilled.cloud/proxmox`'s typed `nodes.
+ *   getNodeCephOsd` (2026-09-24, decision 43, 2c) — the tree endpoint, confirmed against
+ *   distilled's own schema to still answer `{flags?, root: unknown}`, matching the shape
+ *   `osdLeaves` already walks. ⛔ STILL NO `Effect.orElseSucceed` — the ⛔ on `handlers.read` in
+ *   ceph-osd.ts is unchanged and is still the reason: this path is a collection that always
+ *   exists while Ceph is installed, so a failure here is never "the OSD is gone" and must
+ *   propagate rather than fold. This is the one migrated Ceph family that does NOT match
+ *   ceph-pool-wire.ts's/ceph-fs-distilled.ts's single-fold shape, because it never had it.
  */
-export declare const readOsd: (props: CephOsdProps) => Effect.Effect<CephOsdAttributes | undefined, Error | import("./credential-errors.ts").PveCredentialDenied, import("effect/unstable/http/HttpClient").HttpClient>;
+export declare const readOsd: (props: CephOsdProps) => Effect.Effect<CephOsdAttributes | undefined, Error | import("./distilled-pve.ts").PveClusterExhausted | import("./credential-errors.ts").PveCredentialDenied | import("effect/Cause").TimeoutError | nodes.ProxmoxOpError, import("effect/unstable/http/HttpClient").HttpClient>;
 export {};
 //# sourceMappingURL=ceph-osd-tree.d.ts.map

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

@@ -1 +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,qKAMxC,CAAC"}
+{"version":3,"file":"ceph-osd-tree.d.ts","sourceRoot":"","sources":["../../src/proxmox/ceph-osd-tree.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,OAAO,KAAK,KAAK,MAAM,gCAAgC,CAAC;AACxD,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;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,OAAO,UAAW,YAAY,qRAMxC,CAAC"}

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

@@ -11,6 +11,7 @@
  *   `defaultRemovalPolicy: 'retain'`, so removing a declaration does NOT reach `destroyOsd` — a
  *   caller opts in with `.pipe(RemovalPolicy.destroy())`.
  */
+import * as nodes from '@distilled.cloud/proxmox/nodes';
 import * as Effect from 'effect/Effect';
 import type { CephOsdProps } from './ceph-osd.ts';
 import type { EndpointKey } from './constraints.ts';
@@ -32,7 +33,7 @@ export declare const OSD_CREATE_ENDPOINT: EndpointKey;
  * ⚠️ `dev` is `string | undefined` on the props and non-optional here: `createOsd` refuses first.
  */
 export declare const createOsdForm: (props: CephOsdProps, dev: string) => Record<string, string>;
-export declare const createOsd: (news: CephOsdProps) => Effect.Effect<import("./ceph-osd-tree.ts").CephOsdAttributes, Error | import("./credential-errors.ts").PveCredentialDenied, import("effect/unstable/http/HttpClient").HttpClient>;
+export declare const createOsd: (news: CephOsdProps) => Effect.Effect<import("./ceph-osd-tree.ts").CephOsdAttributes, Error | import("effect/unstable/http/HttpClientError").HttpClientError | import("./credential-errors.ts").PveCredentialDenied, 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
@@ -50,6 +51,20 @@ export declare const createOsd: (news: CephOsdProps) => Effect.Effect<import("./
  *
  * ⚠️ `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.
+ *
+ * ⚠️ `cleanup` RIDES A DELETE BODY, ON `client.ts` AND ON DISTILLED ALIKE — PRE-EXISTING, NOT
+ *   INTRODUCED HERE. `client.ts`'s own `buildRequest` (client.ts) puts `form` in the body for
+ *   every method, DELETE included, and CHECKED against distilled's generated
+ *   `DeleteNodeCephOsdRequest`: `cleanup` carries no `T.Query()` annotation either, so it also
+ *   defaults to a body field. ceph-fs-wire.ts's own ⛔ (measured from PVE's `AnyEvent.pm`) is that
+ *   PVE's server never reads a body on DELETE — so `cleanup=1` was ALREADY silently ignored by
+ *   the live cluster before this migration, on the unmigrated code too. Migrating carries the
+ *   SAME behaviour forward exactly, byte-for-byte, rather than introducing a new gap; unlike
+ *   `Proxmox.CephFs`'s delete, this is not a reason to keep the call on the hand client. It has
+ *   zero practical effect today regardless, since the whole DELETE 403s for this package's
+ *   credential either way (the root-only ⛔ at the top of ceph-osd.ts) — flagged separately as a
+ *   pre-existing, out-of-scope bug worth its own fix (move `cleanup` into the query string, the
+ *   way `destroyPath` in ceph-fs-wire.ts already does).
  */
-export declare const destroyOsd: (olds: CephOsdProps) => Effect.Effect<unknown, Error | import("./credential-errors.ts").PveCredentialDenied, import("effect/unstable/http/HttpClient").HttpClient>;
+export declare const destroyOsd: (olds: CephOsdProps) => Effect.Effect<string, Error | import("./distilled-pve.ts").PveClusterExhausted | import("./credential-errors.ts").PveCredentialDenied | import("effect/Cause").TimeoutError | nodes.ProxmoxOpError, import("effect/unstable/http/HttpClient").HttpClient>;
 //# sourceMappingURL=ceph-osd-write.d.ts.map

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

@@ -1 +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;AAGlD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,EAAE,WAA+C,CAAC;AAIlF;;;GAGG;AACH,eAAO,MAAM,aAAa,UAAW,YAAY,OAAO,MAAM,KAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAGpF,CAAC;AAEH,eAAO,MAAM,SAAS,2MA6BpB,CAAC;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,UAAU,SAAU,YAAY,+IAO1C,CAAC"}
+{"version":3,"file":"ceph-osd-write.d.ts","sourceRoot":"","sources":["../../src/proxmox/ceph-osd-write.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,KAAK,MAAM,gCAAgC,CAAC;AACxD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAGpD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,EAAE,WAA+C,CAAC;AAIlF;;;GAGG;AACH,eAAO,MAAM,aAAa,UAAW,YAAY,OAAO,MAAM,KAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAGpF,CAAC;AAEH,eAAO,MAAM,SAAS,4QAsCpB,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,UAAU,SAAU,YAAY,8PAU1C,CAAC"}

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

@@ -33,6 +33,12 @@
  *   `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.
+ *
+ * ★ MIGRATED OFF `client.ts` ONTO `@distilled.cloud/proxmox` (2026-09-24, decision 43, 2c) — this
+ *   file itself never called `pve()` directly, so nothing here changed; ceph-osd-tree.ts's own
+ *   header has the read side (still no `Effect.orElseSucceed`, unlike every other migrated Ceph
+ *   family), ceph-osd-write.ts's has the write side and the one pre-existing, out-of-scope gap
+ *   this migration carries forward rather than fixes.
  */
 import { Resource } from 'alchemy';
 import * as Provider from 'alchemy/Provider';

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

@@ -1 +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"}
+{"version":3,"file":"ceph-osd.d.ts","sourceRoot":"","sources":["../../src/proxmox/ceph-osd.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;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-settle.d.ts

@@ -6,25 +6,32 @@
  *   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 nodes from '@distilled.cloud/proxmox/nodes';
 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.
+ *   separable at all. `ops.read` — now `readPoolStatus` (ceph-pool-wire.ts) — is a module-level
+ *   binding in ceph-pool.ts; importing it back would be a runtime cycle, and duplicating it would
+ *   be two definitions of one path. Passing it is the pattern zfs-pool-write.ts already uses.
+ *   The error parameter preserves the reader's typed failures through settle; it is not `never`.
  */
-export type PoolRead = (props: CephPoolProps) => Effect.Effect<CephPoolAttributes | undefined, never, PveRequirements>;
+export type PoolRead<E> = (props: CephPoolProps) => Effect.Effect<CephPoolAttributes | undefined, E, 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.
+ * ⛔ THE GUARD ON THE CREATE. The original read folded 403s/timeouts into absence, so this
+ *   independent index check prevented creating over a live pool. The typed reader now
+ *   propagates those failures, but a `CephPoolNotFound` must still not override a listed pool:
+ *   the measured PG-merge risk warrants keeping both observations. Failed index reads also
+ *   propagate. An empty list is trusted: the collection refuses a narrow role with 403 rather
+ *   than filtering, so `[]` really does mean a cluster with no pools.
+ *
+ * ⚠️ `describe` IS STILL A PLAIN STRING (ceph-pool.ts builds it from `object`/`collection` in
+ *   ceph-pool-form.ts) — this function no longer takes a `collection` PATH, since
+ *   `nodes.listNodeCephPool` addresses the endpoint itself; the parameter list keeps `describe`
+ *   only, to name the object in the refusal message.
  */
-export declare const confirmAbsent: (props: CephPoolProps, collection: string, describe: string) => Effect.Effect<void, Error | import("./credential-errors.ts").PveCredentialDenied, import("effect/unstable/http/HttpClient").HttpClient>;
+export declare const confirmAbsent: (props: CephPoolProps, describe: string) => Effect.Effect<void, Error | import("./distilled-pve.ts").PveClusterExhausted | import("./credential-errors.ts").PveCredentialDenied | import("effect/Cause").TimeoutError | nodes.ProxmoxOpError, import("effect/unstable/http/HttpClient").HttpClient>;
 /**
  * Wait for the cluster to agree, then answer the last thing it said.
  *
@@ -35,5 +42,5 @@ export declare const confirmAbsent: (props: CephPoolProps, collection: string, d
  * ⚠️ 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>;
+export declare const settle: <E>(props: CephPoolProps, read: PoolRead<E>, done: (live: CephPoolAttributes | undefined) => boolean) => Effect.Effect<CephPoolAttributes | undefined, E, import("effect/unstable/http/HttpClient").HttpClient>;
 //# sourceMappingURL=ceph-pool-settle.d.ts.map

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

@@ -1 +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,4IAcrF,CAAC;AAEJ;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,UACV,aAAa,QACd,QAAQ,QACR,CAAC,IAAI,EAAE,kBAAkB,GAAG,SAAS,KAAK,OAAO,+GASrD,CAAC"}
+{"version":3,"file":"ceph-pool-settle.d.ts","sourceRoot":"","sources":["../../src/proxmox/ceph-pool-settle.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,KAAK,MAAM,gCAAgC,CAAC;AACxD,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;;;;;;GAMG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CACxB,KAAK,EAAE,aAAa,KACjB,MAAM,CAAC,MAAM,CAAC,kBAAkB,GAAG,SAAS,EAAE,CAAC,EAAE,eAAe,CAAC,CAAC;AAEvE;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,aAAa,UAAW,aAAa,YAAY,MAAM,4PAcjE,CAAC;AAEJ;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,SACf,aAAa,QACd,QAAQ,CAAC,CAAC,CAAC,QACX,CAAC,IAAI,EAAE,kBAAkB,GAAG,SAAS,KAAK,OAAO,2GASrD,CAAC"}

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

@@ -0,0 +1,37 @@
+/**
+ * `Proxmox.CephPool`'s distilled wire lane: the status read, and the two request translations.
+ *
+ * ★ SPLIT OUT OF ceph-pool-form.ts FOR THE 250-LINE CAP (that file is already near it) — the seam
+ *   is "touches the cluster or not", the same one ceph-pool-form.ts itself draws against
+ *   ceph-pool.ts. Nothing in ceph-pool-form.ts changed: `createBody`/`updateBody` still build the
+ *   PVE form, unaware distilled exists: this file is the ONLY place that translates one into a
+ *   typed distilled request.
+ *
+ * ⛔ ONLY TYPED ABSENCE MAY REACH A CREATE. The transport migration deliberately preserved
+ *   `pveOperations.read`'s catch-all `Effect.orElseSucceed(() => undefined)` to avoid changing
+ *   behavior during the swap. That also hid refused credentials and transient failures, risking
+ *   a false update/create. SDK PR #265 added the measured `CephPoolNotFound` tag; the follow-up
+ *   now catches only it. One reader serves read/diff/reconcile/settle, so all propagate other
+ *   failures. `confirmAbsent` still checks the index before create: a missing status alone must
+ *   never override a pool that the index lists (the PG-merge incident, ceph-pool-settle.ts).
+ */
+import * as nodes from '@distilled.cloud/proxmox/nodes';
+import * as Effect from 'effect/Effect';
+import { type CephPoolAttributes, type CephPoolProps } from './ceph-pool-form.ts';
+/**
+ * The live pool, or `undefined` only for the SDK's measured `CephPoolNotFound`. The initial
+ * transport swap preserved `ops.read`'s catch-all fold; the 2026-09-24 follow-up removes that ambiguity.
+ * Read, reconcile and settle now propagate every other failure instead of assuming absence.
+ *
+ * ⛔ `verbose=1` IS WHAT MAKES `applications` VISIBLE AT ALL — ceph-pool.ts's own header has the
+ *   measured reason and the cost (two extra, unguarded mon commands PVE runs to answer it).
+ */
+export declare const readPoolStatus: (props: CephPoolProps) => Effect.Effect<CephPoolAttributes | undefined, Error | import("./distilled-pve.ts").PveClusterExhausted | import("./credential-errors.ts").PveCredentialDenied | import("effect/Cause").TimeoutError | nodes.ProxmoxOpError, import("effect/unstable/http/HttpClient").HttpClient>;
+/** The two endpoints, as the keys `guardWrite` (distilled-guard.ts) checks both forms against. */
+export declare const CEPH_POOL_CREATE = "pve:POST /nodes/{node}/ceph/pool";
+export declare const CEPH_POOL_UPDATE = "pve:PUT /nodes/{node}/ceph/pool/{name}";
+/** The actual `createNodeCephPool` call body — `createBody`, translated. No field is renamed. */
+export declare const toDistilledCreate: (props: CephPoolProps) => nodes.CreateNodeCephPoolRequest;
+/** The actual `putNodeCephPool` call body — `updateBody`, translated. No field is renamed. */
+export declare const toDistilledUpdate: (props: CephPoolProps) => nodes.PutNodeCephPoolRequest;
+//# sourceMappingURL=ceph-pool-wire.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ceph-pool-wire.d.ts","sourceRoot":"","sources":["../../src/proxmox/ceph-pool-wire.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,KAAK,MAAM,gCAAgC,CAAC;AACxD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,aAAa,EAKnB,MAAM,qBAAqB,CAAC;AAqC7B;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,UAAW,aAAa,sRAShD,CAAC;AAEJ,kGAAkG;AAClG,eAAO,MAAM,gBAAgB,qCAAqC,CAAC;AACnE,eAAO,MAAM,gBAAgB,2CAA2C,CAAC;AAEzE,iGAAiG;AACjG,eAAO,MAAM,iBAAiB,UAAW,aAAa,KAAG,KAAK,CAAC,yBAIb,CAAC;AAEnD,8FAA8F;AAC9F,eAAO,MAAM,iBAAiB,UAAW,aAAa,KAAG,KAAK,CAAC,sBAKhB,CAAC"}

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

@@ -5,11 +5,16 @@
  * ⛔ 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`.
+ *   further down, at `.../status` (`getpool`), which accepts no PUT and no DELETE. Every handler
+ *   below is hand-written for that reason, on `client.ts` and now on distilled alike — acl.ts is
+ *   the precedent for hand-writing over the factory.
+ *
+ * ★ MIGRATED OFF `client.ts`'s generic `pve()` ONTO `@distilled.cloud/proxmox`'s typed
+ *   `nodes.getNodeCephPoolStatus`/`createNodeCephPool`/`putNodeCephPool`/`deleteNodeCephPool`/
+ *   `listNodeCephPool` (2026-09-24, decision 43's walk-down, 2c). `distilled-pve.ts`'s `runPve`
+ *   replaces `pve()`; `readPoolStatus` (ceph-pool-wire.ts) keeps the SAME single-fold shape this
+ *   family always had — see that file's own header for why this migration does not also add the
+ *   newer dual-path pattern `Proxmox.NodeNetwork` carries.
  *
  * ⛔ 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.

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

@@ -1 +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;AAIlF,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;AAsEH,eAAO,MAAM,uBAAuB,qIAuFjC,CAAC"}
+{"version":3,"file":"ceph-pool.d.ts","sourceRoot":"","sources":["../../src/proxmox/ceph-pool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEnC,OAAO,KAAK,QAAQ,MAAM,kBAAkB,CAAC;AAG7C,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,aAAa,EAMnB,MAAM,qBAAqB,CAAC;AAW7B,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AAGrD,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;AAqBH,eAAO,MAAM,uBAAuB,qIAkHjC,CAAC"}

package/dist/proxmox/group-wire.d.ts

@@ -48,21 +48,16 @@ export declare const matches: (attributes: GroupAttributes, props: GroupProps) =
  *   release that does answer `{}`, but this function is what actually carries the "not found"
  *   case, as a thrown error — `readGroup` below is the one that folds it.
  */
-export declare const readGroupOrFail: (props: GroupProps) => Effect.Effect<typeof UNREADABLE | GroupAttributes | undefined, import("@distilled.cloud/caddy").BadGateway | import("@distilled.cloud/caddy").BadRequest | import("@distilled.cloud/caddy").ConfigError | Error | import("@distilled.cloud/caddy").GatewayTimeout | import("effect/unstable/http/HttpClientError").HttpClientError | import("@distilled.cloud/caddy").InternalServerError | import("@distilled.cloud/proxmox/Errors").ParameterVerificationFailed | import("@distilled.cloud/proxmox/Errors").ProxmoxParseError | import("./distilled-pve.ts").PveClusterExhausted | import("@distilled.cloud/caddy").ServiceUnavailable | import("effect/Cause").TimeoutError | import("@distilled.cloud/caddy").TooManyRequests | import("@distilled.cloud/caddy").Unauthorized | import("@distilled.cloud/proxmox/Errors").UnknownProxmoxError, import("effect/unstable/http/HttpClient").HttpClient>;
+export declare const readGroupOrFail: (props: GroupProps) => Effect.Effect<typeof UNREADABLE | GroupAttributes | undefined, import("@distilled.cloud/caddy").BadGateway | import("@distilled.cloud/caddy").BadRequest | import("@distilled.cloud/caddy").ConfigError | Error | import("@distilled.cloud/caddy").GatewayTimeout | access.GroupNotFound | import("effect/unstable/http/HttpClientError").HttpClientError | import("@distilled.cloud/caddy").InternalServerError | import("@distilled.cloud/proxmox/Errors").ParameterVerificationFailed | import("@distilled.cloud/proxmox/Errors").ProxmoxParseError | import("./distilled-pve.ts").PveClusterExhausted | import("@distilled.cloud/caddy").ServiceUnavailable | import("effect/Cause").TimeoutError | import("@distilled.cloud/caddy").TooManyRequests | import("@distilled.cloud/caddy").Unauthorized | import("@distilled.cloud/proxmox/Errors").UnknownProxmoxError, import("effect/unstable/http/HttpClient").HttpClient>;
 /**
- * ⛔ FOLDS A GENUINE READ FAILURE TO `undefined` TOO, AND ONLY `read`/`reconcile` MAY USE IT.
- *   PVE's OWN missing-group answer is a thrown 500 (the ⛔ above), so `reconcile`'s create branch
- *   NEEDS "absent" from a failure to ever run at all — without this fold, a brand-new group could
- *   never be created, because its very-first read would always fail loudly. Safe here because a
- *   wrongful fold costs at most a redundant `createAccessGroup` POST, which PVE refuses loudly
- *   ("group already exists") rather than silently corrupting anything.
- * ⛔ `group.ts`'s `diff` does **NOT** use this — found 2026-09-24, the SAME bug class as the
- *   credential denial fix: folding a TRANSIENT failure (a `PveClusterExhausted`, the encoding bug
- *   above) into "absent" at PLAN TIME is exactly what forced a false `update` with nothing
- *   compared. `diff` calls `readGroupOrFail` directly instead, so a genuine failure there
- *   propagates and fails the whole plan loudly — never silently misreports one row.
+ * ⛔ ONLY `GroupNotFound` MEANS ABSENT. The initial distilled transport swap preserved a
+ *   catch-all fold because PVE reports missing objects as HTTP 500. SDK PR 265 now types that
+ *   measured message, so permission errors, unrelated 500s and exhausted transports propagate
+ *   instead of triggering a speculative create (decision 49 follow-up, 2026-09-24).
+ * ★ `readGroupOrFail` remains the strict path used for an already-confirmed state row. This
+ *   change narrows cold reads/reconcile without changing that existing drift/diff contract.
  */
-export declare const readGroup: (props: GroupProps) => Effect.Effect<typeof UNREADABLE | GroupAttributes | undefined, never, import("effect/unstable/http/HttpClient").HttpClient>;
+export declare const readGroup: (props: GroupProps) => Effect.Effect<typeof UNREADABLE | GroupAttributes | undefined, import("@distilled.cloud/caddy").BadGateway | import("@distilled.cloud/caddy").BadRequest | import("@distilled.cloud/caddy").ConfigError | Error | import("@distilled.cloud/caddy").GatewayTimeout | import("effect/unstable/http/HttpClientError").HttpClientError | import("@distilled.cloud/caddy").InternalServerError | import("@distilled.cloud/proxmox/Errors").ParameterVerificationFailed | import("@distilled.cloud/proxmox/Errors").ProxmoxParseError | import("./distilled-pve.ts").PveClusterExhausted | import("@distilled.cloud/caddy").ServiceUnavailable | import("effect/Cause").TimeoutError | import("@distilled.cloud/caddy").TooManyRequests | import("@distilled.cloud/caddy").Unauthorized | import("@distilled.cloud/proxmox/Errors").UnknownProxmoxError, import("effect/unstable/http/HttpClient").HttpClient>;
 /** `read`/`reconcile` return `Attributes | undefined`; only `diff` tells `UNREADABLE` apart. */
 export declare const dropUnreadable: (live: GroupAttributes | Unreadable | undefined) => GroupAttributes | undefined;
 //# sourceMappingURL=group-wire.d.ts.map

package/dist/proxmox/group-wire.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"group-wire.d.ts","sourceRoot":"","sources":["../../src/proxmox/group-wire.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,MAAM,MAAM,iCAAiC,CAAC;AAC1D,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC9D,OAAO,EAAE,UAAU,EAAE,KAAK,UAAU,EAAoB,MAAM,sBAAsB,CAAC;AAGrF,eAAO,MAAM,YAAY,4BAA4B,CAAC;AACtD,eAAO,MAAM,YAAY,qCAAqC,CAAC;AAE/D;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,YAAa,MAAM,GAAG,SAAS,WAGxD,CAAC;AAQF,eAAO,MAAM,UAAU,UAAW,UAAU,KAAG,MAAM,CAAC,wBAGpD,CAAC;AAEH,iGAAiG;AACjG,eAAO,MAAM,UAAU,UAAW,UAAU,KAAG,MAAM,CAAC,qBAGpD,CAAC;AAaH;;;GAGG;AACH,eAAO,MAAM,OAAO,eAAgB,eAAe,SAAS,UAAU,YACjB,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,eAAe,UAAW,UAAU,62BAW9C,CAAC;AAEJ;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,SAAS,UAAW,UAAU,gIACyB,CAAC;AAErE,gGAAgG;AAChG,eAAO,MAAM,cAAc,SAAU,eAAe,GAAG,UAAU,GAAG,SAAS,gCACrC,CAAC"}
+{"version":3,"file":"group-wire.d.ts","sourceRoot":"","sources":["../../src/proxmox/group-wire.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,MAAM,MAAM,iCAAiC,CAAC;AAC1D,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC9D,OAAO,EAAE,UAAU,EAAE,KAAK,UAAU,EAAoB,MAAM,sBAAsB,CAAC;AAGrF,eAAO,MAAM,YAAY,4BAA4B,CAAC;AACtD,eAAO,MAAM,YAAY,qCAAqC,CAAC;AAE/D;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,YAAa,MAAM,GAAG,SAAS,WAGxD,CAAC;AAQF,eAAO,MAAM,UAAU,UAAW,UAAU,KAAG,MAAM,CAAC,wBAGpD,CAAC;AAEH,iGAAiG;AACjG,eAAO,MAAM,UAAU,UAAW,UAAU,KAAG,MAAM,CAAC,qBAGpD,CAAC;AAaH;;;GAGG;AACH,eAAO,MAAM,OAAO,eAAgB,eAAe,SAAS,UAAU,YACjB,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,eAAe,UAAW,UAAU,o4BAW9C,CAAC;AAEJ;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,UAAW,UAAU,62BACqD,CAAC;AAEjG,gGAAgG;AAChG,eAAO,MAAM,cAAc,SAAU,eAAe,GAAG,UAAU,GAAG,SAAS,gCACrC,CAAC"}