@homeflare/alchemy 0.42.0 → 0.43.0

package/dist/postgres/providers.d.ts

@@ -9,6 +9,8 @@
  *   the results under whatever logical grouping it wants.
  */
 import * as Layer from 'effect/Layer';
-import { type PostgresConnectionConfig } from './connection.ts';
-export declare const postgresProviders: (config: PostgresConnectionConfig) => Layer.Layer<import("alchemy").Provider<import("./database.ts").PostgresDatabase>, never, never>;
+import { type PostgresConnectionConfig, type PostgresRunnerConfig } from './connection.ts';
+export declare const postgresProviders: (config: PostgresConnectionConfig) => Layer.Layer<import("./connection.ts").PostgresConnection | import("alchemy").Provider<import("./database.ts").PostgresDatabase>, never, never>;
+/** The same provider over a command runner (`psql-executor.ts`) — for a loopback-only cluster. */
+export declare const postgresRunnerProviders: (config: PostgresRunnerConfig) => Layer.Layer<import("./connection.ts").PostgresConnection | import("alchemy").Provider<import("./database.ts").PostgresDatabase>, never, never>;
 //# sourceMappingURL=providers.d.ts.map

package/dist/postgres/providers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../../src/postgres/providers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,KAAK,wBAAwB,EAAsB,MAAM,iBAAiB,CAAC;AAGpF,eAAO,MAAM,iBAAiB,WAAY,wBAAwB,oGACU,CAAC"}
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../../src/postgres/providers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EAG1B,MAAM,iBAAiB,CAAC;AAOzB,eAAO,MAAM,iBAAiB,WAAY,wBAAwB,mJACe,CAAC;AAElF,kGAAkG;AAClG,eAAO,MAAM,uBAAuB,WAAY,oBAAoB,mJACmB,CAAC"}

package/dist/postgres/psql-executor.d.ts

@@ -0,0 +1,21 @@
+import { type PgExecutor } from './database-sql.ts';
+export interface PsqlResult {
+    readonly code: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+/** Runs one `psql` argv (starting with `psql`) with `stdin` and answers its exit. The consumer's
+ * implementation prepends the transport (`ssh … sudo -n podman exec -i <container>`) and owns
+ * the timeout and output bound: the kit sets neither. */
+export type PsqlRunner = (call: {
+    readonly argv: readonly string[];
+    readonly stdin: string;
+}) => Promise<PsqlResult>;
+export interface PsqlTarget {
+    readonly database: string;
+    readonly username: string;
+}
+/** Replace `$1…$n` with string literals; refuses a non-string param or a missing one. */
+export declare const inlineParams: (sql: string, params: ReadonlyArray<unknown>) => string;
+export declare const makePsqlExecutor: (run: PsqlRunner, target: PsqlTarget) => PgExecutor;
+//# sourceMappingURL=psql-executor.d.ts.map

package/dist/postgres/psql-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"psql-executor.d.ts","sourceRoot":"","sources":["../../src/postgres/psql-executor.ts"],"names":[],"mappings":"AAyBA,OAAO,EAAE,KAAK,UAAU,EAAsB,MAAM,mBAAmB,CAAC;AAExE,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;yDAEyD;AACzD,MAAM,MAAM,UAAU,GAAG,CAAC,IAAI,EAAE;IAC9B,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;AAE1B,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,yFAAyF;AACzF,eAAO,MAAM,YAAY,QAAS,MAAM,UAAU,aAAa,CAAC,OAAO,CAAC,KAAG,MASnE,CAAC;AAgCT,eAAO,MAAM,gBAAgB,QAAS,UAAU,UAAU,UAAU,KAAG,UAyCrE,CAAC"}

package/dist/proxmox/ceph-flag-types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Flag names, props and attributes for `Proxmox.CephFlag`.
+ *
+ * ★ SPLIT OUT OF ceph-flag.ts FOR THE 250-LINE CAP. The comments stay with the types they
+ *   explain; nothing here talks to the cluster.
+ */
+import type { WithTarget } from './resource-spec.ts';
+/**
+ * PVE's eleven flags, spelled as `PVE::Ceph::Tools::get_possible_osd_flags` spells them.
+ *
+ * ⚠️ THE ENUM IS CLOSED AND A TYPO IS A 400, WHICH IS WHY THIS IS A UNION AND NOT `string`. Both
+ *   the GET and the PUT declare `additionalProperties => 0` over exactly this list.
+ * ⚠️ CEPH HAS FLAGS PVE DOES NOT MODEL, and four of them are always on. MEASURED on C1:
+ *   `ceph osd dump` reports `flags sortbitwise,recovery_deletes,purged_snapdirs,pglog_hardlimit`.
+ *   PVE reads that same string and answers only about its own eleven, so the others can neither
+ *   leak in here nor be set from here — `noautoscale` and `nosnaptrim` included.
+ *   ⛔ IF SOMEBODY LATER "IMPROVES" THE READ BY PARSING `osd dump` DIRECTLY, those four become
+ *     permanently-set flags that nothing declares: a forever-diff on a brand new cluster.
+ */
+export type CephFlagName = 'nobackfill' | 'nodeep-scrub' | 'nodown' | 'noin' | 'noout' | 'norebalance' | 'norecover' | 'noscrub' | 'notieragent' | 'noup' | 'pause';
+export interface CephFlagProps extends WithTarget {
+    /**
+     * Which flag. PVE's primary key here, and the last segment of the path.
+     *
+     * ⚠️ EDITING IT IN PLACE ORPHANS THE OLD FLAG RATHER THAN MOVING ANYTHING. `diff` reads the NEW
+     *   path and reconcile writes it, while the old flag keeps whatever this stack last put there.
+     *   There is deliberately no replace override for it — acl.ts needs one because its `delete`
+     *   removes a real grant, and `delete` here is inert by design, so a replace would do exactly
+     *   what an update already does. Declare a second resource and set the old one to `value: false`
+     *   rather than renaming this one.
+     * ⛔ TWO RESOURCES DECLARING THE SAME FLAG ARE ONE CLUSTER OBJECT, and Alchemy sees two ids
+     *   rather than a collision — the acl.ts hazard exactly. Disagreeing, they take turns winning
+     *   and BOTH plan `update` for ever; agreeing, deleting either leaves the flag where the other
+     *   put it. One declaration per flag per cluster.
+     */
+    flag: CephFlagName;
+    /**
+     * Set the flag (`true`) or clear it (`false`).
+     *
+     * ⛔ REQUIRED, WITH NO DEFAULT — see the second ⛔ in the header, which is the whole safety
+     *   argument for this family. It is also the only field PVE accepts on this endpoint, and it is
+     *   not optional in the schema either: omitting it from the form is a 400, not an untouched
+     *   flag. (The BULK endpoint is the one where omission means "leave it alone"; this is not it.)
+     */
+    value: boolean;
+}
+export interface CephFlagAttributes {
+    /**
+     * ⚠️ REPORTED, NEVER COMPARED. It is the path key the read was made WITH, copied back out of
+     *   props, so comparing it against props would be true by construction — the same reasoning
+     *   acl.ts gives for the four identity fields it also declines to diff.
+     */
+    flag: CephFlagName;
+    /** Whether ceph has the flag set right now. The only field `matches` looks at. */
+    value: boolean;
+}
+//# sourceMappingURL=ceph-flag-types.d.ts.map

package/dist/proxmox/ceph-flag-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ceph-flag-types.d.ts","sourceRoot":"","sources":["../../src/proxmox/ceph-flag-types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,YAAY,GACpB,YAAY,GACZ,cAAc,GACd,QAAQ,GACR,MAAM,GACN,OAAO,GACP,aAAa,GACb,WAAW,GACX,SAAS,GACT,aAAa,GACb,MAAM,GACN,OAAO,CAAC;AAEZ,MAAM,WAAW,aAAc,SAAQ,UAAU;IAC/C;;;;;;;;;;;;;OAaG;IACH,IAAI,EAAE,YAAY,CAAC;IACnB;;;;;;;OAOG;IACH,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,IAAI,EAAE,YAAY,CAAC;IACnB,kFAAkF;IAClF,KAAK,EAAE,OAAO,CAAC;CAChB"}

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

@@ -0,0 +1,77 @@
+/**
+ * `Proxmox.CephFlag`'s distilled wire lane: the read and the single-flag write.
+ *
+ * ★ SPLIT OUT OF ceph-flag.ts FOR THE 250-LINE CAP, mirroring ceph-pool-wire.ts's split by "touches
+ *   the cluster or not" — ceph-flag.ts keeps the header, the props/attributes shapes, `matches` and
+ *   the provider wiring; this file is the only place that calls `runPve` for this family.
+ *
+ * ⛔ NEITHER OPERATION HERE DECLARES A TYPED ABSENCE (`errors: []` on both `getClusterCephFlag` and
+ *   `putClusterCephFlag`, MEASURED in distilled-proxmox/src/services/cluster.ts) — UNLIKE
+ *   ceph-pool-wire.ts's `CephPoolNotFound`. All eleven flags always exist (ceph-flag.ts's own ⛔ on
+ *   `CephFlagName` and on the old unreachable create branch), so there is no absence case to fold
+ *   here. `readClusterCephFlag` therefore has no `catchTag` at all and lets every failure — a
+ *   refused credential, a timeout, cluster exhaustion — propagate to the caller exactly as it
+ *   arrived, rather than inventing an "absent" this family does not have. Simpler than
+ *   ceph-pool-wire.ts's case, not harder.
+ *   ⚠️ THIS IS A BEHAVIOR CHANGE FROM THE PRE-MIGRATION FACTORY, AND A DELIBERATE ONE. The old
+ *     `pveOperations.read` folded EVERY failure into `undefined` via `Effect.orElseSucceed`, so an
+ *     expired lease or node-b being down looked identical to "the flag is absent" (which cannot
+ *     happen — see ceph-flag.ts). Now such a failure propagates as itself: a caller sees the real
+ *     error (an expired 300s lease, node-b down, ceph not configured) rather than a misleading
+ *     "absent" that would have sent `diff`/`reconcile` down a create path this endpoint has never
+ *     implemented. Same advice as the old comment gave, sharper because the failure is no longer
+ *     disguised.
+ *
+ * ⛔ THE PER-FLAG PUT IS SYNCHRONOUS (`$rados->mon_command` inline, MEASURED in Ceph.pm — see
+ *   ceph-flag.ts's header), which is what makes reading back immediately after
+ *   `writeClusterCephFlag` fair rather than a race against a worker task, unlike ceph-pool.ts's
+ *   forked-worker writes.
+ */
+import * as cluster from '@distilled.cloud/proxmox/cluster';
+import * as Effect from 'effect/Effect';
+import type { CephFlagAttributes, CephFlagProps } from './ceph-flag.ts';
+/** The one endpoint this family writes, as `guardWrite` (distilled-guard.ts) keys it. */
+export declare const CEPH_FLAG_UPDATE = "pve:PUT /cluster/ceph/flags/{flag}";
+/**
+ * ⛔ DIE ON THE POST-TRANSFORM SHAPE, NOT THE PRE-TRANSFORM ONE. `bool` treats a missing value as
+ *   `false` because most callers hand it an optional PVE form field where that is correct — but
+ *   here it would read an unmeasured "no answer" as "flag is clear". distilled's
+ *   `transformResponse` maps a `{"data":null}` body to `{}` BEFORE this function sees it (a shape
+ *   `get_flag`'s `type => 'boolean'` schema does not document and this PVE has never produced).
+ *   Guarding only `null`/`undefined` lets that `{}` through, and `bool({})` is `false` — a plan
+ *   of `noop` over a set brake, with no read-back guard, because `reconcile`'s guard only fires
+ *   on a write. A success here is a scalar (`true`/`false`/`0`/`1`/`'0'`/`'1'`). Anything else,
+ *   including the empty object the protocol substitutes for null, is the unmeasured shape.
+ */
+export declare const scalarFlagOrDie: (live: unknown, props: CephFlagProps) => Effect.Effect<string | number | boolean, never, never>;
+/**
+ * The live flag, as attributes.
+ *
+ * ⚠️ NO ABSENCE TAG, ON PURPOSE. Both operations declare `errors: []` (see the file header), so
+ *   there is nothing to `catchTag` except `PveCredentialDenied`, and that one is caught by the
+ *   caller that plans (`readClusterCephFlagForDiff`) — not here. `read` and `reconcile` must
+ *   still see a refused mint as itself.
+ */
+export declare const readClusterCephFlag: (props: CephFlagProps) => Effect.Effect<CephFlagAttributes, Error | import("./distilled-pve.ts").PveClusterExhausted | import("./credential-errors.ts").PveCredentialDenied | import("effect/Cause").TimeoutError | cluster.ProxmoxOpError, import("effect/unstable/http/HttpClient").HttpClient>;
+/**
+ * The same read, with a refused mint turned into `UNREADABLE`.
+ *
+ * ⛔ `diff` MUST NOT FAIL ON A REFUSED READ. Alchemy runs every resource's `diff` under
+ *   `Effect.exit` and fails the whole plan if one fails (unreadable-read.ts). A lane that cannot
+ *   mint `read` would otherwise abort every other row, not just this flag. `read` and
+ *   `reconcile` keep the propagating form above.
+ */
+export declare const readClusterCephFlagForDiff: (props: CephFlagProps) => Effect.Effect<typeof import("./unreadable-read.ts").UNREADABLE | CephFlagAttributes, import("@distilled.cloud/caddy").BadGateway | import("@distilled.cloud/caddy").BadRequest | import("@distilled.cloud/caddy").ConfigError | import("@distilled.cloud/caddy").Conflict | Error | import("@distilled.cloud/caddy").Forbidden | import("@distilled.cloud/caddy").GatewayTimeout | import("effect/unstable/http/HttpClientError").HttpClientError | import("@distilled.cloud/caddy").InternalServerError | import("@distilled.cloud/caddy").Locked | import("@distilled.cloud/caddy").NotFound | 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("@distilled.cloud/caddy").UnprocessableEntity, import("effect/unstable/http/HttpClient").HttpClient>;
+/**
+ * ⚠️ ONLY `value` GOES IN THE BODY. `flag` is already bound by the path and the PUT declares
+ *   `additionalProperties => 0`, so a second copy in the form could only disagree with the URL.
+ * ⚠️ THE `?? '0'` IS UNREACHABLE, AND IS WRITTEN RATHER THAN CAST AWAY. `flag()` types its answer
+ *   `string | undefined` because it serves OPTIONAL props, and `value` here is required, so the
+ *   branch cannot be taken; a cast would claim a proof the type system has not made.
+ */
+export declare const updateForm: (props: CephFlagProps) => {
+    value: string;
+};
+/** The actual `putClusterCephFlag` call — `updateForm`'s own `value`, so the two cannot disagree. */
+export declare const writeClusterCephFlag: (props: CephFlagProps) => Effect.Effect<cluster.PutClusterCephFlagResponse, Error | import("./distilled-pve.ts").PveClusterExhausted | import("./credential-errors.ts").PveCredentialDenied | import("effect/Cause").TimeoutError | cluster.ProxmoxOpError, import("effect/unstable/http/HttpClient").HttpClient>;
+//# sourceMappingURL=ceph-flag-wire.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ceph-flag-wire.d.ts","sourceRoot":"","sources":["../../src/proxmox/ceph-flag-wire.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,KAAK,OAAO,MAAM,kCAAkC,CAAC;AAC5D,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAKxE,yFAAyF;AACzF,eAAO,MAAM,gBAAgB,uCAAuC,CAAC;AAkBrE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,SAAU,OAAO,SAAS,aAAa,2DAalE,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,UAAW,aAAa,4QAIrD,CAAC;AAEJ;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B,UAAW,aAAa,ymCACjB,CAAC;AAE/C;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,UAAW,aAAa;;CAA0C,CAAC;AAE1F,qGAAqG;AACrG,eAAO,MAAM,oBAAoB,UAAW,aAAa,4RAMtD,CAAC"}

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

@@ -74,58 +74,23 @@
  */
 import { Resource } from 'alchemy';
 import * as Provider from 'alchemy/Provider';
-import { type PveRequirements, type WithTarget } from './resource.ts';
-/**
- * PVE's eleven flags, spelled as `PVE::Ceph::Tools::get_possible_osd_flags` spells them.
- *
- * ⚠️ THE ENUM IS CLOSED AND A TYPO IS A 400, WHICH IS WHY THIS IS A UNION AND NOT `string`. Both
- *   the GET and the PUT declare `additionalProperties => 0` over exactly this list.
- * ⚠️ CEPH HAS FLAGS PVE DOES NOT MODEL, and four of them are always on. MEASURED on C1:
- *   `ceph osd dump` reports `flags sortbitwise,recovery_deletes,purged_snapdirs,pglog_hardlimit`.
- *   PVE reads that same string and answers only about its own eleven, so the others can neither
- *   leak in here nor be set from here — `noautoscale` and `nosnaptrim` included.
- *   ⛔ IF SOMEBODY LATER "IMPROVES" THE READ BY PARSING `osd dump` DIRECTLY, those four become
- *     permanently-set flags that nothing declares: a forever-diff on a brand new cluster.
- */
-export type CephFlagName = 'nobackfill' | 'nodeep-scrub' | 'nodown' | 'noin' | 'noout' | 'norebalance' | 'norecover' | 'noscrub' | 'notieragent' | 'noup' | 'pause';
-export interface CephFlagProps extends WithTarget {
-    /**
-     * Which flag. PVE's primary key here, and the last segment of the path.
-     *
-     * ⚠️ EDITING IT IN PLACE ORPHANS THE OLD FLAG RATHER THAN MOVING ANYTHING. `diff` reads the NEW
-     *   path and reconcile writes it, while the old flag keeps whatever this stack last put there.
-     *   There is deliberately no replace override for it — acl.ts needs one because its `delete`
-     *   removes a real grant, and `delete` here is inert by design, so a replace would do exactly
-     *   what an update already does. Declare a second resource and set the old one to `value: false`
-     *   rather than renaming this one.
-     * ⛔ TWO RESOURCES DECLARING THE SAME FLAG ARE ONE CLUSTER OBJECT, and Alchemy sees two ids
-     *   rather than a collision — the acl.ts hazard exactly. Disagreeing, they take turns winning
-     *   and BOTH plan `update` for ever; agreeing, deleting either leaves the flag where the other
-     *   put it. One declaration per flag per cluster.
-     */
-    flag: CephFlagName;
-    /**
-     * Set the flag (`true`) or clear it (`false`).
-     *
-     * ⛔ REQUIRED, WITH NO DEFAULT — see the second ⛔ in the header, which is the whole safety
-     *   argument for this family. It is also the only field PVE accepts on this endpoint, and it is
-     *   not optional in the schema either: omitting it from the form is a 400, not an untouched
-     *   flag. (The BULK endpoint is the one where omission means "leave it alone"; this is not it.)
-     */
-    value: boolean;
-}
-export interface CephFlagAttributes {
-    /**
-     * ⚠️ REPORTED, NEVER COMPARED. It is the path key the read was made WITH, copied back out of
-     *   props, so comparing it against props would be true by construction — the same reasoning
-     *   acl.ts gives for the four identity fields it also declines to diff.
-     */
-    flag: CephFlagName;
-    /** Whether ceph has the flag set right now. The only field `matches` looks at. */
-    value: boolean;
-}
+import type { CephFlagAttributes, CephFlagProps } from './ceph-flag-types.ts';
+import type { PveRequirements } from './resource-spec.ts';
+export type { CephFlagAttributes, CephFlagName, CephFlagProps } from './ceph-flag-types.ts';
 export interface ProxmoxCephFlag extends Resource<'Proxmox.CephFlag', CephFlagProps, CephFlagAttributes, never, PveRequirements> {
 }
 export declare const ProxmoxCephFlag: import("alchemy").ResourceClass<ProxmoxCephFlag>;
+/**
+ * ★ MIGRATED OFF `pveHandlers`/`client.ts`'s generic `pve()` ONTO `@distilled.cloud/proxmox`'s
+ *   typed `cluster.getClusterCephFlag`/`cluster.putClusterCephFlag` (ceph-flag-wire.ts).
+ *   `pveHandlers` cannot run a distilled operation, so `diff`/`reconcile` are hand-written here,
+ *   the same way ceph-pool.ts and backup-job.ts hand-write theirs for the same reason.
+ *
+ * ⛔ THIS FAMILY HAS NO CREATE KEY, AND THAT IS THE VENDOR'S DOING, NOT AN OMISSION HERE. PVE
+ *   registers only `PUT /cluster/ceph/flags/{flag}`; `POST /cluster/ceph/flags` does not exist
+ *   (constraints-forms.test.ts's own regression test), which is why the second ⛔ in the header
+ *   above calls the create branch unreachable — there is no create form and no create endpoint to
+ *   guard, only `CEPH_FLAG_UPDATE`.
+ */
 export declare const ProxmoxCephFlagProvider: () => import("effect/Layer").Layer<Provider.Provider<ProxmoxCephFlag>, never, import("effect/unstable/http/HttpClient").HttpClient>;
 //# sourceMappingURL=ceph-flag.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ceph-flag.d.ts","sourceRoot":"","sources":["../../src/proxmox/ceph-flag.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACnC,OAAO,KAAK,QAAQ,MAAM,kBAAkB,CAAC;AAE7C,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,UAAU,EAAe,MAAM,eAAe,CAAC;AAGnF;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,YAAY,GACpB,YAAY,GACZ,cAAc,GACd,QAAQ,GACR,MAAM,GACN,OAAO,GACP,aAAa,GACb,WAAW,GACX,SAAS,GACT,aAAa,GACb,MAAM,GACN,OAAO,CAAC;AAEZ,MAAM,WAAW,aAAc,SAAQ,UAAU;IAC/C;;;;;;;;;;;;;OAaG;IACH,IAAI,EAAE,YAAY,CAAC;IACnB;;;;;;;OAOG;IACH,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,IAAI,EAAE,YAAY,CAAC;IACnB,kFAAkF;IAClF,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,eAAgB,SAAQ,QAAQ,CAC/C,kBAAkB,EAClB,aAAa,EACb,kBAAkB,EAClB,KAAK,EACL,eAAe,CAChB;CAAG;AAEJ,eAAO,MAAM,eAAe,kDAAgD,CAAC;AAsD7E,eAAO,MAAM,uBAAuB,qIA4CjC,CAAC"}
+{"version":3,"file":"ceph-flag.d.ts","sourceRoot":"","sources":["../../src/proxmox/ceph-flag.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEnC,OAAO,KAAK,QAAQ,MAAM,kBAAkB,CAAC;AAY7C,OAAO,KAAK,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAG1D,YAAY,EAAE,kBAAkB,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE5F,MAAM,WAAW,eAAgB,SAAQ,QAAQ,CAC/C,kBAAkB,EAClB,aAAa,EACb,kBAAkB,EAClB,KAAK,EACL,eAAe,CAChB;CAAG;AAEJ,eAAO,MAAM,eAAe,kDAAgD,CAAC;AAc7E;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,uBAAuB,qIAoEjC,CAAC"}

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

@@ -52,19 +52,16 @@ 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).
+ * ★ CORRECTED 2026-09-28: `cleanup` IS QUERY-BOUND ON DISTILLED, NOT BODY. This comment previously
+ *   claimed `DeleteNodeCephOsdRequest.cleanup` carried no `T.Query()` annotation and so rode the
+ *   DELETE body, silently ignored by PVE's server (which never reads a body on DELETE, per
+ *   ceph-fs-wire.ts's measurement of `AnyEvent.pm`). That was true of the old `client.ts` hand
+ *   client, but distilled-proxmox's generated schema
+ *   (`packages/distilled-proxmox/src/services/nodes.ts`) declares
+ *   `cleanup: S.optional(S.String.pipe(T.Query()))` — query-bound — as of SDK 0.3.0, the same fix
+ *   that landed for the sibling `Proxmox.CephFs`'s `destroyFs`. Since this file already runs on
+ *   distilled (`import * as nodes from '@distilled.cloud/proxmox/nodes'`), `cleanup: '1'` below
+ *   reaches PVE correctly today. No code change needed here; this was a stale doc claim only.
  */
 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,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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,UAAU,SAAU,YAAY,8PAU1C,CAAC"}