@push.rocks/smartnftables 3.0.0 → 4.0.0

package/changelog.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 2026-09-28 - 4.0.0
+
+### Breaking Changes
+
+- Distinguish capacity exhaustion from invalid input: a well-formed policy that does not fit one atomic replacement is refused with the new `ManagedNftablesError` code `EXHAUSTED` instead of `INVALID`. That covers the compiled target budget (`ruleBytes` 100,000, `targetBytes` 212,000, `operations` 768) and the input counts that exist to hold it (schema-v1 32 endpoints and 128 rules; router 128 endpoints and links, 1024 rules and 1024 egress grants; 1024 host grants, workload grants and publications per scope; 8 loopback TCP port owners), and the Docker forwarding contribution's 192 rules and 100,000 command bytes. Bounds of the topology's shape (identifier and interface-name lengths, protected prefixes, platform endpoints, generations, handoffs, allocations, ranges, guarded pools, IPC and capture limits) stay `INVALID`. The accept/reject set, digests and compiled bytes are unchanged. Consumers that treat `INVALID` from `prepare()` as "too big, retry smaller" must switch to `EXHAUSTED`, which is now the only code for that case. The message of an `INVALID` or `EXHAUSTED` error now ends in `: <reason>` (for example `Managed nftables INVALID: Managed policy input is invalid.`), so a consumer matching on the message sees a different text.
+
+### Features
+
+- Carry the native refusal on `ManagedNftablesError` for `INVALID` and `EXHAUSTED`: `reason` holds the bounded native text (also appended to the message), and `EXHAUSTED` names its bound in `details` as `{ bound, limit, actual }` (`TManagedNftCapacityBound`, `IManagedNftCapacity`). A native refusal outside that shape is `PROTOCOL`. Other codes and the facade's local rejections keep their previous shape and message. Like `INVALID`, `EXHAUSTED` is effect-free and does not abort `failureSignal`.
+
+### Maintenance
+
+- Update `@push.rocks/smartrust` from 2.3.0 to 2.5.0, keeping the exact pin, for `RustBridgeRequestError.responseErrorData` (2.4.0), which carries the refusal's bound. The 2.5.0 cancellation protocol is opt-in and the native owner does not announce it, so requests behave as before.
+
 ## 2026-09-28 - 3.0.0
 
 ### Breaking Changes

package/dist_rust/smartnftables_linux_amd64_musl.tsrust-build.json

@@ -1,12 +1,12 @@
 {
   "format": "tsrust.build-provenance.v2",
-  "binarySha256": "17c4308039280f584cd51d6cf9030e3c4512746d316561925b6da95bb3c67ff8",
+  "binarySha256": "e879efc88997e38bb45c045fae690c3a07a3ff515c2a2581689466e3088ca236",
   "buildInfo": {
     "projectName": "@push.rocks/smartnftables",
-    "projectVersion": "3.0.0",
-    "gitCommit": "61c5a8be9c99a83cecde6509fb31c47f43e15bff",
+    "projectVersion": "4.0.0",
+    "gitCommit": "7c66795f5e0edea87f2c9f7f1f70455cdf7e6bab",
     "gitDirty": false,
-    "builtAt": "2026-09-28T00:27:05.031Z",
+    "builtAt": "2026-09-28T03:45:45.694Z",
     "tsrustVersion": "1.15.1",
     "binary": "smartnftables",
     "target": "linux_amd64_musl"

package/dist_rust/smartnftables_linux_arm64_musl.tsrust-build.json

@@ -1,12 +1,12 @@
 {
   "format": "tsrust.build-provenance.v2",
-  "binarySha256": "3756fe460edc3bdea00c7f598a683081d8238f5172dad9776304a030508d4276",
+  "binarySha256": "268d3371a7986e7f1efcd6fb7fdd02b04635060a3e845c0ef45baec75e16a32a",
   "buildInfo": {
     "projectName": "@push.rocks/smartnftables",
-    "projectVersion": "3.0.0",
-    "gitCommit": "61c5a8be9c99a83cecde6509fb31c47f43e15bff",
+    "projectVersion": "4.0.0",
+    "gitCommit": "7c66795f5e0edea87f2c9f7f1f70455cdf7e6bab",
     "gitDirty": false,
-    "builtAt": "2026-09-28T00:27:15.164Z",
+    "builtAt": "2026-09-28T03:45:55.540Z",
     "tsrustVersion": "1.15.1",
     "binary": "smartnftables",
     "target": "linux_arm64_musl"

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartnftables',
-    version: '3.0.0',
+    version: '4.0.0',
     description: 'A TypeScript module for managing nftables rules including NAT, firewall, and rate limiting with a high-level API.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSwyQkFBMkI7SUFDakMsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLG1IQUFtSDtDQUNqSSxDQUFBIn0=

package/dist_ts/classes.manageddockerforwarding.js

@@ -1,5 +1,5 @@
 import * as plugins from './plugins.js';
-import { snapshot, managedIpcBytes, ManagedNftablesError } from './classes.managednftables.js';
+import { snapshot, managedIpcBytes, ManagedNftablesError, nativeError } from './classes.managednftables.js';
 /** One node-level Docker DOCKER-USER contribution. Caller owns durable intents and handoff lifetimes. */
 export class ManagedDockerForwarding {
     #options;
@@ -117,12 +117,11 @@ export class ManagedDockerForwarding {
         const owned = work.catch((error) => {
             if (this.#state !== 'closing')
                 this.#state = 'failed-owned';
-            const code = error instanceof plugins.smartrust.RustBridgeRequestError ? error.responseErrorCode : undefined;
-            throw new ManagedNftablesError(typeof code === 'string' && /^[A-Z_]{1,64}$/.test(code) ? code : 'UNAVAILABLE');
+            throw nativeError(error);
         });
         this.#work = owned;
         void owned.then(() => { this.#work = null; }, () => { this.#work = null; });
         return owned;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.manageddockerforwarding.js","sourceRoot":"","sources":["../ts/classes.manageddockerforwarding.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAG/F,yGAAyG;AACzG,MAAM,OAAO,uBAAuB;IACzB,QAAQ,CAA4C;IAC7D,OAAO,GAA0E,IAAI,CAAC;IACtF,MAAM,GAA0E,KAAK,CAAC;IACtF,KAAK,GAA4B,IAAI,CAAC;IACtC,MAAM,GAAyB,IAAI,CAAC;IACpC,aAAa,GAAG,KAAK,CAAC;IAEtB,YAAY,OAAwC;QAClD,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;QAClC,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,oBAAoB,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;eACrH,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,uBAAuB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;eACrI,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,MAAM,GAAG,EAAE;eACpC,IAAI,CAAC,QAAQ,CAAC,UAAU,KAAK,SAAS,IAAI,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;YAC/I,MAAM,IAAI,oBAAoB,CAAC,SAAS,CAAC,CAAC;QAC5C,CAAC;QACD,IAAI,IAAI,CAAC,QAAQ,CAAC,kBAAkB,KAAK,SAAS,IAAI,CAAC,OAAO,CAAC,QAAQ,KAAK,OAAO;eAC9E,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,kBAAkB,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,kBAAkB,GAAG,CAAC;eAC3F,IAAI,CAAC,QAAQ,CAAC,kBAAkB,GAAG,WAAW,CAAC;YAAE,MAAM,IAAI,oBAAoB,CAAC,SAAS,CAAC,CAAC;IAClG,CAAC;IAED,IAAW,KAAK,KAAa,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAElD,uFAAuF;IAChF,KAAK;QACV,IAAI,IAAI,CAAC,MAAM,KAAK,KAAK;YAAE,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,oBAAoB,CAAC,aAAa,CAAC,CAAC,CAAC;QAC1F,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC;QACzB,MAAM,IAAI,GAAG,CAAC,KAAK,IAAI,EAAE;YACvB,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO,IAAI,CAAC,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC;gBAAE,MAAM,IAAI,oBAAoB,CAAC,sBAAsB,CAAC,CAAC;YACrI,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,IAAI,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;YACxE,IAAI,CAAC,OAAO,GAAG,IAAI,OAAO,CAAC,SAAS,CAAC,UAAU,CAAmC;gBAChF,UAAU,EAAE,eAAe,EAAE,UAAU,EAAE,IAAI,CAAC,QAAQ,CAAC,UAAU;uBAC5D,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,WAAW,EAAE,uBAAuB,OAAO,CAAC,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,OAAO,CAAC;gBACnH,UAAU,EAAE,EAAE,EAAE,gBAAgB,EAAE,KAAK;gBACvC,OAAO,EAAE,CAAC,qBAAqB,EAAE,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,kBAAkB,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,wBAAwB,EAAE,GAAG,CAAC,CAAC,CAAC;gBAC5H,wBAAwB,EAAE,IAAI,CAAC,QAAQ,CAAC,kBAAkB,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,kBAAkB,CAAC;gBACzH,cAAc,EAAE,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,cAAc,EAAE,eAAe;gBAC/E,0BAA0B,EAAE,EAAE,uBAAuB,EAAE,CAAC,EAAE,oBAAoB,EAAE,CAAC,EAAE,yBAAyB,EAAE,CAAC,EAAE,uBAAuB,EAAE,CAAC,EAAE,uBAAuB,EAAE,CAAC,EAAE,qBAAqB,EAAE,CAAC,EAAE;aACpM,CAAC,CAAC;YACH,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE;gBAC3B,IAAI,CAAC,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC;oBAAE,IAAI,CAAC,MAAM,GAAG,cAAc,CAAC;YAClF,CAAC,CAAC,CAAC;YACH,IAAI,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE;gBAAE,MAAM,IAAI,oBAAoB,CAAC,aAAa,CAAC,CAAC;YAC/E,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC;YAC9C,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,sBAAsB,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC;YACzG,IAAI,IAAI,CAAC,MAAM,KAAK,UAAU;gBAAE,MAAM,IAAI,oBAAoB,CAAC,aAAa,CAAC,CAAC;YAC9E,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC;YAAC,OAAO,MAAM,CAAC;QACvC,CAAC,CAAC,EAAE,CAAC;QACL,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC3B,CAAC;IAEM,OAAO,CAAC,MAAsC;QACnD,OAAO,IAAI,CAAC,OAAO,CAAC,yBAAyB,EAAE,MAAM,CAAC,CAAC;IACzD,CAAC;IACM,SAAS,CAAC,UAA8C;QAC7D,OAAO,IAAI,CAAC,OAAO,CAAC,2BAA2B,EAAE,UAAU,CAAC,CAAC;IAC/D,CAAC;IACM,OAAO,KAA8C,OAAO,IAAI,CAAC,OAAO,CAAC,yBAAyB,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;IAC1G,OAAO,CAAC,QAA+C;QAC5D,OAAO,IAAI,CAAC,OAAO,CAAC,yBAAyB,EAAE,QAAQ,CAAC,CAAC;IAC3D,CAAC;IAED,sIAAsI;IAC/H,KAAK;QACV,IAAI,IAAI,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC,MAAM,CAAC;QACpC,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS;YAAE,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;QACxD,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;QACxB,IAAI,CAAC,MAAM,GAAG,CAAC,KAAK,IAAI,EAAE;YACxB,MAAM,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;YACzC,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;gBACjB,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;oBACvB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,uBAAuB,EAAE,EAAE,CAAC,CAAC;oBAC3E,IAAI,MAAM,CAAC,QAAQ,KAAK,IAAI;wBAAE,MAAM,IAAI,oBAAoB,CAAC,UAAU,CAAC,CAAC;gBAC3E,CAAC;gBACD,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;YACxD,CAAC;YACD,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;YAAC,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;QAC/C,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,MAAM,GAAG,cAAc,CAAC;YAAC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;YACjD,MAAM,IAAI,oBAAoB,CAAC,qBAAqB,CAAC,CAAC;QACxD,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED,OAAO,CAAmD,MAAS,EAAE,MAAqD;QACxH,IAAI,CAAC,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,KAAK;YAAE,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,oBAAoB,CAAC,aAAa,CAAC,CAAC,CAAC;QACpJ,IAAI,QAAuD,CAAC;QAC5D,IAAI,CAAC;YAAC,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;QAAC,CAAC;QAAC,MAAM,CAAC;YAAC,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,oBAAoB,CAAC,SAAS,CAAC,CAAC,CAAC;QAAC,CAAC;QAC1G,IAAI,MAAM,KAAK,2BAA2B,IAAI,MAAM,KAAK,yBAAyB;YAAE,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC9G,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;YAC5E,MAAM,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;YACxC,IAAI,MAAM,KAAK,yBAAyB;gBAAE,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;YACrE,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,MAAM,KAAK,2BAA2B,IAAI,MAAM,KAAK,yBAAyB;mBAC3G,MAAM,KAAK,yBAAyB,IAAK,cAAiD,CAAC,KAAK,KAAK,IAAI,CAAC;gBAAE,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC;YACvI,OAAO,cAAc,CAAC;QACxB,CAAC,CAAC,CAAC,CAAC;IACN,CAAC;IACD,MAAM,CAAI,IAAgB;QACxB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;YACjC,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS;gBAAE,IAAI,CAAC,MAAM,GAAG,cAAc,CAAC;YAC5D,MAAM,IAAI,GAAG,KAAK,YAAY,OAAO,CAAC,SAAS,CAAC,sBAAsB,CAAC,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC,SAAS,CAAC;YAC7G,MAAM,IAAI,oBAAoB,CAAC,OAAO,IAAI,KAAK,QAAQ,IAAI,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC;QACjH,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,KAAK,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QAC5E,OAAO,KAAK,CAAC;IACf,CAAC;CACF"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.manageddockerforwarding.js","sourceRoot":"","sources":["../ts/classes.manageddockerforwarding.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.managednftables.d.ts

@@ -1,8 +1,20 @@
-import type { IManagedNftOptions, IManagedNftPolicy, IManagedNftTransition, IAppliedManagedNftPolicy, IPreparedManagedNftPolicy, IManagedNftStatus, IManagedNftTransitionRelease, TManagedNftPolicy } from './managed.types.js';
+import type { IManagedNftOptions, IManagedNftPolicy, IManagedNftTransition, IAppliedManagedNftPolicy, IPreparedManagedNftPolicy, IManagedNftStatus, IManagedNftTransitionRelease, TManagedNftPolicy, IManagedNftCapacity } from './managed.types.js';
+/** `INVALID`: the input is outside the contract. `EXHAUSTED`: the policy exceeds a
+ * capacity bound of the atomic replacement budget, and a smaller policy may fit.
+ * Both carry the native refusal text in `reason`; `EXHAUSTED` also names its
+ * bound in `details`. Every other code, and the facade's own rejections, carry
+ * neither. */
 export declare class ManagedNftablesError extends Error {
     readonly code: string;
-    constructor(code: string);
+    readonly reason: string | null;
+    readonly details: Readonly<IManagedNftCapacity> | null;
+    constructor(code: string, reason?: string | null, details?: Readonly<IManagedNftCapacity> | null);
 }
+/** Maps a failed native request. An `INVALID` or `EXHAUSTED` response keeps the
+ * bounded native refusal text and, for `EXHAUSTED`, its bound; a refusal outside
+ * that shape is `PROTOCOL`. Other responses keep only their code, and a failure
+ * without a native code is `UNAVAILABLE`. */
+export declare function nativeError(error: unknown): ManagedNftablesError;
 /** Bounds of the private native IPC. A status carries up to three complete policies (applied,
  * pending previous and pending target); a policy with the maximum 1024 host grants serializes to
  * about 111 KB and 5,300 values, so these bounds hold three of them with room for the rest of a

package/dist_ts/classes.managednftables.js

@@ -1,10 +1,49 @@
 import * as plugins from './plugins.js';
+/** `INVALID`: the input is outside the contract. `EXHAUSTED`: the policy exceeds a
+ * capacity bound of the atomic replacement budget, and a smaller policy may fit.
+ * Both carry the native refusal text in `reason`; `EXHAUSTED` also names its
+ * bound in `details`. Every other code, and the facade's own rejections, carry
+ * neither. */
 export class ManagedNftablesError extends Error {
-    constructor(code) {
-        super(`Managed nftables ${code}.`);
+    constructor(code, reason = null, details = null) {
+        super(reason === null ? `Managed nftables ${code}.` : `Managed nftables ${code}: ${reason}`);
         this.code = code;
+        this.reason = reason;
+        this.details = details;
     }
 }
+const capacityBounds = new Set(['ruleBytes', 'targetBytes', 'operations',
+    'endpoints', 'links', 'rules', 'grants', 'hostGrants', 'workloadGrants', 'publishedPorts', 'localTcpPortOwners',
+    'restoreRules', 'restoreBytes']);
+function capacity(value) {
+    if (typeof value !== 'object' || value === null || Object.getPrototypeOf(value) !== Object.prototype
+        || Object.keys(value).sort().join(',') !== 'actual,bound,limit')
+        return null;
+    const { bound, limit, actual } = value;
+    if (typeof bound !== 'string' || !capacityBounds.has(bound) || typeof limit !== 'number' || typeof actual !== 'number'
+        || !Number.isSafeInteger(limit) || !Number.isSafeInteger(actual) || limit < 0 || actual <= limit)
+        return null;
+    return Object.freeze({ bound: bound, limit, actual });
+}
+/** Maps a failed native request. An `INVALID` or `EXHAUSTED` response keeps the
+ * bounded native refusal text and, for `EXHAUSTED`, its bound; a refusal outside
+ * that shape is `PROTOCOL`. Other responses keep only their code, and a failure
+ * without a native code is `UNAVAILABLE`. */
+export function nativeError(error) {
+    if (!(error instanceof plugins.smartrust.RustBridgeRequestError))
+        return new ManagedNftablesError('UNAVAILABLE');
+    const { responseErrorCode: code, message: reason, responseErrorData: data } = error;
+    if (typeof code !== 'string' || !/^[A-Z_]{1,64}$/.test(code))
+        return new ManagedNftablesError('UNAVAILABLE');
+    if (code !== 'INVALID' && code !== 'EXHAUSTED')
+        return new ManagedNftablesError(code);
+    if (!/^[\x20-\x7e]{1,256}$/.test(reason))
+        return new ManagedNftablesError('PROTOCOL');
+    if (code === 'INVALID')
+        return data === undefined ? new ManagedNftablesError(code, reason) : new ManagedNftablesError('PROTOCOL');
+    const details = capacity(data);
+    return details ? new ManagedNftablesError(code, reason, details) : new ManagedNftablesError('PROTOCOL');
+}
 /** Bounds of the private native IPC. A status carries up to three complete policies (applied,
  * pending previous and pending target); a policy with the maximum 1024 host grants serializes to
  * about 111 KB and 5,300 values, so these bounds hold three of them with room for the rest of a
@@ -275,21 +314,22 @@ export class ManagedNftables {
         const owned = work.catch((error) => {
             if (this.#state !== 'closing')
                 this.#state = 'failed-owned';
-            const code = error instanceof plugins.smartrust.RustBridgeRequestError ? error.responseErrorCode : undefined;
-            // Only a native compiler rejection or explicit INVALID response proves
-            // effect-free validation. Other native errors can follow lost ownership
+            const failure = nativeError(error);
+            // Only a native compiler rejection or explicit INVALID or EXHAUSTED
+            // response proves effect-free validation: the native owner refuses both
+            // before any kernel work. Other native errors can follow lost ownership
             // or admitted kernel work. Recovery stays available; confidence is lost.
             const validation = error instanceof plugins.smartrust.RustBridgeRequestError
                 && error.code === 'ERR_RUST_BRIDGE_REQUEST_RUST_RESPONSE'
-                && (method === 'preparePolicy' || code === 'INVALID');
+                && (method === 'preparePolicy' || failure.code === 'INVALID' || failure.code === 'EXHAUSTED');
             if (!validation && (this.#state !== 'closing'
                 || ['reconcilePolicy', 'releasePolicy', 'releasePolicyTransition', 'detachPolicy'].includes(method)))
                 this.#fail();
-            throw new ManagedNftablesError(typeof code === 'string' && /^[A-Z_]{1,64}$/.test(code) ? code : 'UNAVAILABLE');
+            throw failure;
         });
         this.#work = owned;
         void owned.then(() => { this.#work = null; }, () => { this.#work = null; });
         return owned;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.managednftables.js","sourceRoot":"","sources":["../ts/classes.managednftables.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.managednftables.js","sourceRoot":"","sources":["../ts/classes.managednftables.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AAKxC;;;;cAIc;AACd,MAAM,OAAO,oBAAqB,SAAQ,KAAK;IAC7C,YAA4B,IAAY,EAAkB,SAAwB,IAAI,EACpE,UAAgD,IAAI;QACpE,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,oBAAoB,IAAI,GAAG,CAAC,CAAC,CAAC,oBAAoB,IAAI,KAAK,MAAM,EAAE,CAAC,CAAC;QAFnE,SAAI,GAAJ,IAAI,CAAQ;QAAkB,WAAM,GAAN,MAAM,CAAsB;QACpE,YAAO,GAAP,OAAO,CAA6C;IAEtE,CAAC;CACF;AAED,MAAM,cAAc,GAAwB,IAAI,GAAG,CAA2B,CAAC,WAAW,EAAE,aAAa,EAAE,YAAY;IACrH,WAAW,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,oBAAoB;IAC/G,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC;AAEnC,SAAS,QAAQ,CAAC,KAAc;IAC9B,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,SAAS;WAC/F,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,oBAAoB;QAAE,OAAO,IAAI,CAAC;IAC/E,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,KAAgC,CAAC;IAClE,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,MAAM,KAAK,QAAQ;WACjH,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,MAAM,IAAI,KAAK;QAAE,OAAO,IAAI,CAAC;IAChH,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,KAAiC,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;AACpF,CAAC;AAED;;;6CAG6C;AAC7C,MAAM,UAAU,WAAW,CAAC,KAAc;IACxC,IAAI,CAAC,CAAC,KAAK,YAAY,OAAO,CAAC,SAAS,CAAC,sBAAsB,CAAC;QAAE,OAAO,IAAI,oBAAoB,CAAC,aAAa,CAAC,CAAC;IACjH,MAAM,EAAE,iBAAiB,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,IAAI,EAAE,GAAG,KAAK,CAAC;IACpF,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,oBAAoB,CAAC,aAAa,CAAC,CAAC;IAC7G,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,WAAW;QAAE,OAAO,IAAI,oBAAoB,CAAC,IAAI,CAAC,CAAC;IACtF,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,MAAM,CAAC;QAAE,OAAO,IAAI,oBAAoB,CAAC,UAAU,CAAC,CAAC;IACtF,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,oBAAoB,CAAC,UAAU,CAAC,CAAC;IAClI,MAAM,OAAO,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC/B,OAAO,OAAO,CAAC,CAAC,CAAC,IAAI,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,oBAAoB,CAAC,UAAU,CAAC,CAAC;AAC1G,CAAC;AAED;;;kBAGkB;AAClB,MAAM,CAAC,MAAM,eAAe,GAAG,SAAS,CAAC;AACzC,MAAM,aAAa,GAAG,SAAS,CAAC;AAChC,MAAM,cAAc,GAAG,MAAM,CAAC;AAE9B,oFAAoF;AACpF,MAAM,UAAU,QAAQ,CAAI,KAAQ;IAClC,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,WAAW,GAAG,CAAC,CAAC;IACpB,MAAM,MAAM,GAAG,CAAC,KAAa,EAAU,EAAE;QACvC,IAAI,KAAK,CAAC,MAAM,GAAG,aAAa,IAAI,CAAC,WAAW,IAAI,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,GAAG,aAAa;YAAE,MAAM,IAAI,oBAAoB,CAAC,SAAS,CAAC,CAAC;QACzI,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;IACF,MAAM,IAAI,GAAG,CAAC,KAAc,EAAE,KAAa,EAAW,EAAE;QACtD,IAAI,EAAE,KAAK,GAAG,cAAc,IAAI,KAAK,GAAG,EAAE;YAAE,MAAM,IAAI,oBAAoB,CAAC,SAAS,CAAC,CAAC;QACtF,IAAI,OAAO,KAAK,KAAK,QAAQ;YAAE,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;QACpD,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,SAAS;YAAE,OAAO,KAAK,CAAC;QAC/D,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;QAC3E,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;YAAE,MAAM,IAAI,oBAAoB,CAAC,SAAS,CAAC,CAAC;QAC9G,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACnC,IAAI,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC;YAAE,MAAM,IAAI,oBAAoB,CAAC,SAAS,CAAC,CAAC;QAC7H,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACpC,IAAI,IAAI,CAAC,MAAM,GAAG,cAAc,GAAG,KAAK;YAAE,MAAM,IAAI,oBAAoB,CAAC,SAAS,CAAC,CAAC;QACpF,KAAK,MAAM,GAAG,IAAI,IAAI;YAAE,IAAI,OAAO,GAAG,KAAK,QAAQ;gBAAE,MAAM,CAAC,GAAG,CAAC,CAAC;QACjE,MAAM,WAAW,GAAG,MAAM,CAAC,yBAAyB,CAAC,KAAK,CAAC,CAAC;QAC5D,MAAM,MAAM,GAAwC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACpE,IAAI,KAAK,IAAI,IAAI,CAAC,MAAM,KAAM,KAAmB,CAAC,MAAM,GAAG,CAAC;YAAE,MAAM,IAAI,oBAAoB,CAAC,SAAS,CAAC,CAAC;QACxG,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;YACvB,IAAI,KAAK,IAAI,GAAG,KAAK,QAAQ;gBAAE,SAAS;YACxC,MAAM,UAAU,GAAG,WAAW,CAAC,GAAa,CAAC,CAAC;YAC9C,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,CAAC,UAAU,CAAC,UAAU,IAAI,CAAC,CAAC,OAAO,IAAI,UAAU,CAAC;mBAC5E,KAAK,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,GAAG,CAAC;gBAAE,MAAM,IAAI,oBAAoB,CAAC,SAAS,CAAC,CAAC;YACxF,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,GAAG,CAAC,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;QACzI,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;IACF,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,CAAM,CAAC;IACnC,IAAI,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,GAAG,aAAa;QAAE,MAAM,IAAI,oBAAoB,CAAC,SAAS,CAAC,CAAC;IACzG,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,sGAAsG;AACtG,MAAM,OAAO,eAAe;IACjB,QAAQ,CAA+B;IAChD,OAAO,GAAsE,IAAI,CAAC;IAClF,MAAM,GAA0E,KAAK,CAAC;IACtF,KAAK,GAA4B,IAAI,CAAC;IACtC,MAAM,GAAyB,IAAI,CAAC;IACpC,UAAU,GAA+B,IAAI,CAAC;IAC9C,uBAAuB,GAAG,KAAK,CAAC;IAChC,aAAa,GAAG,KAAK,CAAC;IACtB,UAAU,GAAG,KAAK,CAAC;IACnB,eAAe,GAA6C,IAAI,CAAC;IACjE,OAAO,GAAuC,IAAI,CAAC;IACnD,kBAAkB,GAA8D,IAAI,CAAC;IAC5E,QAAQ,GAAG,IAAI,eAAe,EAAE,CAAC;IAC1C,YAAY,GAAG,KAAK,CAAC;IAErB,YAAY,OAA2B;QACrC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;QAClC,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,oBAAoB,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;eAClI,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,uBAAuB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;eAC9J,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,MAAM,GAAG,EAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC;eACpF,IAAI,CAAC,QAAQ,CAAC,UAAU,KAAK,SAAS,IAAI,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;YAC/I,MAAM,IAAI,oBAAoB,CAAC,SAAS,CAAC,CAAC;QAC5C,CAAC;QACD,IAAI,IAAI,CAAC,QAAQ,CAAC,kBAAkB,KAAK,SAAS,IAAI,CAAC,OAAO,CAAC,QAAQ,KAAK,OAAO;eAC9E,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,kBAAkB,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,kBAAkB,GAAG,CAAC;eAC3F,IAAI,CAAC,QAAQ,CAAC,kBAAkB,GAAG,WAAW,CAAC;YAAE,MAAM,IAAI,oBAAoB,CAAC,SAAS,CAAC,CAAC;IAClG,CAAC;IAED,IAAW,KAAK,KAAa,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAElD;;8EAE0E;IAC1E,IAAW,aAAa,KAAkB,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;IAExE,KAAK;QACH,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS;YAAE,IAAI,CAAC,MAAM,GAAG,cAAc,CAAC;QAC5D,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO;YAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,oBAAoB,CAAC,YAAY,CAAC,CAAC,CAAC;IACjG,CAAC;IAED,uFAAuF;IAChF,KAAK;QACV,IAAI,IAAI,CAAC,MAAM,KAAK,KAAK,IAAI,IAAI,CAAC,UAAU;YAAE,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,oBAAoB,CAAC,aAAa,CAAC,CAAC,CAAC;QAC7G,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC;QACzB,MAAM,IAAI,GAAG,CAAC,KAAK,IAAI,EAAE;YACvB,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO,IAAI,CAAC,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC;gBAAE,MAAM,IAAI,oBAAoB,CAAC,sBAAsB,CAAC,CAAC;YACrI,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,IAAI,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;YACxE,IAAI,CAAC,OAAO,GAAG,IAAI,OAAO,CAAC,SAAS,CAAC,UAAU,CAA+B;gBAC5E,UAAU,EAAE,eAAe,EAAE,UAAU,EAAE,IAAI,CAAC,QAAQ,CAAC,UAAU;uBAC5D,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,WAAW,EAAE,uBAAuB,OAAO,CAAC,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,OAAO,CAAC;gBACnH,UAAU,EAAE,EAAE,EAAE,gBAAgB,EAAE,KAAK;gBACvC,OAAO,EAAE,CAAC,cAAc,EAAE,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,kBAAkB,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,wBAAwB,EAAE,GAAG,CAAC,CAAC,CAAC;gBACrH,wBAAwB,EAAE,IAAI,CAAC,QAAQ,CAAC,kBAAkB,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,kBAAkB,CAAC;gBACzH,cAAc,EAAE,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,cAAc,EAAE,eAAe;gBAC/E,0BAA0B,EAAE,EAAE,aAAa,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,uBAAuB,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE;aACnL,CAAC,CAAC;YACH,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE;gBAC3B,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;gBACzB,IAAI,CAAC,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC;oBAAE,IAAI,CAAC,KAAK,EAAE,CAAC;YAClE,CAAC,CAAC,CAAC;YACH,IAAI,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE;gBAAE,MAAM,IAAI,oBAAoB,CAAC,aAAa,CAAC,CAAC;YAC/E,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC;YACzD,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,WAAW,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;YACzG,IAAI,IAAI,CAAC,MAAM,KAAK,UAAU;gBAAE,MAAM,IAAI,oBAAoB,CAAC,aAAa,CAAC,CAAC;YAC9E,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC;YAAC,OAAO,MAAM,CAAC;QACvC,CAAC,CAAC,EAAE,CAAC;QACL,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;IACxC,CAAC;IAEM,OAAO,CAAC,MAAe;QAC5B,OAAO,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC;IAC/C,CAAC;IACM,SAAS,CAAC,UAA0C;QACzD,OAAO,IAAI,CAAC,OAAO,CAAC,iBAAiB,EAAE,UAAU,CAAC,CAAC;IACrD,CAAC;IACM,OAAO,KAA0C,OAAO,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;IAC5F,OAAO,CAAC,QAA2C;QACxD,OAAO,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,QAAQ,CAAC,CAAC;IACjD,CAAC;IAED;;;;mFAI+E;IACxE,iBAAiB,CAAC,OAA8C;QACrE,OAAO,IAAI,CAAC,OAAO,CAAC,yBAAyB,EAAE,OAAO,CAAC,CAAC;IAC1D,CAAC;IAED;;gFAE4E;IACrE,MAAM,CAAC,QAA2C;QACvD,IAAI,IAAI,CAAC,uBAAuB,IAAI,IAAI,CAAC,UAAU,KAAK,QAAQ,IAAI,IAAI,CAAC,kBAAkB;YAAE,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,oBAAoB,CAAC,aAAa,CAAC,CAAC,CAAC;QAC5J,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACvB,IAAI,QAA2C,CAAC;QAChD,IAAI,CAAC;YACH,QAAQ,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC;YAC9B,IAAI,IAAI,CAAC,eAAe,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,eAAe,EAAE,QAAQ,CAAC;gBAAE,MAAM,IAAI,oBAAoB,CAAC,UAAU,CAAC,CAAC;YACxI,IAAI,IAAI,CAAC,OAAO;gBAAE,OAAO,IAAI,CAAC,OAAO,CAAC;YACtC,IAAI,CAAC,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,MAAM;gBAAE,MAAM,IAAI,oBAAoB,CAAC,aAAa,CAAC,CAAC;YAClJ,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAC;QAClC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YAAC,OAAO,OAAO,CAAC,MAAM,CAAC,KAAK,YAAY,oBAAoB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,oBAAoB,CAAC,SAAS,CAAC,CAAC,CAAC;QAAC,CAAC;QAC/H,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;YACzF,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;YAC/B,IAAI,MAAM,EAAE,QAAQ,KAAK,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC;gBAAE,MAAM,IAAI,oBAAoB,CAAC,UAAU,CAAC,CAAC;YAC9G,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;YAC3B,OAAO,MAAM,CAAC;QAChB,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC;QACpB,MAAM,QAAQ,GAAG,CAAC,KAAK,IAAI,EAAE,GAAG,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACnG,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAC;QACxB,KAAK,QAAQ,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QACpD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;;2EAIuE;IAChE,cAAc;QACnB,IAAI,IAAI,CAAC,UAAU,KAAK,QAAQ;YAAE,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,oBAAoB,CAAC,UAAU,CAAC,CAAC,CAAC;QAC9F,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC;QACpC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACvB,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC;IACtB,CAAC;IAED;mGAC+F;IACxF,KAAK;QACV,IAAI,IAAI,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC,MAAM,CAAC;QACpC,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS;YAAE,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;QACxD,IAAI,CAAC,UAAU,KAAK,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC;QAC1D,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,KAAK,QAAQ,CAAC;QAC/C,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;QACxB,IAAI,CAAC,MAAM,GAAG,CAAC,KAAK,IAAI,EAAE;YACxB,MAAM,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;YACzC,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;gBACjB,IAAI,IAAI,CAAC,aAAa,IAAI,CAAC,SAAS,EAAE,CAAC;oBACrC,oEAAoE;oBACpE,oEAAoE;oBACpE,oEAAoE;oBACpE,MAAM,MAAM,GAAG,IAAI,CAAC,kBAAkB;wBACpC,CAAC,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,yBAAyB,EAAE,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC;wBAC5F,CAAC,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,YAAY,EAAE,EAAE,CAAC,CAAC;oBACrD,IAAI,MAAM,CAAC,QAAQ,KAAK,IAAI,IAAI,IAAI,CAAC,kBAAkB,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC;wBAAE,MAAM,IAAI,oBAAoB,CAAC,UAAU,CAAC,CAAC;gBAC1I,CAAC;gBACD,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;YACxD,CAAC;YACD,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;YAAC,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;QAC/C,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,MAAM,GAAG,cAAc,CAAC;YAAC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;YACjD,IAAI,CAAC,KAAK,EAAE,CAAC;YACb,MAAM,IAAI,oBAAoB,CAAC,qBAAqB,CAAC,CAAC;QACxD,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED,OAAO,CAA+C,MAAS,EAAE,MAAiD;QAChH,IAAI,IAAI,CAAC,UAAU,IAAI,CAAC,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,KAAK;YAAE,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,oBAAoB,CAAC,aAAa,CAAC,CAAC,CAAC;QACvK,IAAI,QAAmD,CAAC;QACxD,IAAI,CAAC;YAAC,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;QAAC,CAAC;QAAC,MAAM,CAAC;YAAC,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,oBAAoB,CAAC,SAAS,CAAC,CAAC,CAAC;QAAC,CAAC;QAC1G,IAAI,IAAI,CAAC,kBAAkB,IAAI,CAAC,MAAM,KAAK,eAAe,IAAI,MAAM,KAAK,yBAAyB;eAC7F,MAAM,KAAK,yBAAyB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC;YACzH,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,oBAAoB,CAAC,UAAU,CAAC,CAAC,CAAC;QAC9D,CAAC;QACD,IAAI,MAAM,KAAK,yBAAyB;YAAE,IAAI,CAAC,kBAAkB,GAAG,EAAE,OAAO,EAAE,QAAiD,EAAE,CAAC;QACnI,IAAI,MAAM,KAAK,iBAAiB,IAAI,MAAM,KAAK,eAAe,IAAI,MAAM,KAAK,yBAAyB;YAAE,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAClI,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;YAC5E,MAAM,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;YACxC,IAAI,MAAM,KAAK,eAAe,IAAI,MAAM,KAAK,yBAAyB,EAAE,CAAC;gBACvE,IAAI,MAAM,KAAK,yBAAyB,IAAI,CAAE,cAAqC,EAAE,QAAQ,KAAK,IAAI;uBACjG,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC;oBAAE,MAAM,IAAI,oBAAoB,CAAC,UAAU,CAAC,CAAC;gBAC3F,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;YAC7B,CAAC;YACD,IAAI,MAAM,KAAK,eAAe,EAAE,CAAC;gBAC/B,MAAM,MAAM,GAAG,cAA4C,CAAC;gBAC5D,IAAI,MAAM,CAAC,KAAK,KAAK,cAAc,IAAI,MAAM,CAAC,KAAK,KAAK,IAAI;oBAAE,IAAI,CAAC,KAAK,EAAE,CAAC;YAC7E,CAAC;YACD,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,MAAM,KAAK,iBAAiB,IAAI,MAAM,KAAK,eAAe,IAAI,MAAM,KAAK,yBAAyB;mBACrJ,MAAM,KAAK,eAAe,IAAK,cAA6C,CAAC,KAAK,KAAK,IAAI;uBACxF,cAA6C,CAAC,KAAK,KAAK,cAAc,CAAC;gBAAE,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC;YACvG,OAAO,cAAc,CAAC;QACxB,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;IACd,CAAC;IACD,MAAM,CAAI,IAAgB,EAAE,MAA0C;QACpE,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;YACjC,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS;gBAAE,IAAI,CAAC,MAAM,GAAG,cAAc,CAAC;YAC5D,MAAM,OAAO,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;YACnC,oEAAoE;YACpE,wEAAwE;YACxE,wEAAwE;YACxE,yEAAyE;YACzE,MAAM,UAAU,GAAG,KAAK,YAAY,OAAO,CAAC,SAAS,CAAC,sBAAsB;mBACvE,KAAK,CAAC,IAAI,KAAK,uCAAuC;mBACtD,CAAC,MAAM,KAAK,eAAe,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS,IAAI,OAAO,CAAC,IAAI,KAAK,WAAW,CAAC,CAAC;YAChG,IAAI,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,MAAM,KAAK,SAAS;mBACxC,CAAC,iBAAiB,EAAE,eAAe,EAAE,yBAAyB,EAAE,cAAc,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;gBAAE,IAAI,CAAC,KAAK,EAAE,CAAC;YACrH,MAAM,OAAO,CAAC;QAChB,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,KAAK,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QAC5E,OAAO,KAAK,CAAC;IACf,CAAC;CACF"}

package/dist_ts/managed.types.d.ts

@@ -80,6 +80,20 @@ export interface IManagedNftOptions {
     networkNamespaceFd?: number;
 }
 export type TManagedNftPolicy = IManagedNftPolicy | IManagedNftPolicyV2;
+/** Capacity bounds of the atomic replacement budget. The compiled target's
+ * `ruleBytes` (100,000), `targetBytes` (212,000) and `operations` (768), the input
+ * counts that exist to hold it (`endpoints`, `links`, `rules`, `grants`,
+ * `hostGrants`, `workloadGrants`, `publishedPorts`, `localTcpPortOwners`) and the
+ * Docker forwarding contribution's `restoreRules` (192) and `restoreBytes` (100,000). */
+export type TManagedNftCapacityBound = 'ruleBytes' | 'targetBytes' | 'operations' | 'endpoints' | 'links' | 'rules' | 'grants' | 'hostGrants' | 'workloadGrants' | 'publishedPorts' | 'localTcpPortOwners' | 'restoreRules' | 'restoreBytes';
+/** The bound an `EXHAUSTED` refusal names. `actual` is always above `limit`. It is
+ * exact for input counts and the schema-v1 budget; the other compiled budgets stop
+ * at the first message or rule past the limit, so the policy needs at least `actual`. */
+export interface IManagedNftCapacity {
+    bound: TManagedNftCapacityBound;
+    limit: number;
+    actual: number;
+}
 export type TManagedNftCommands<TPolicy extends TManagedNftPolicy = IManagedNftPolicy> = {
     preparePolicy: {
         params: TPolicy;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartnftables",
-  "version": "3.0.0",
+  "version": "4.0.0",
   "private": false,
   "description": "A TypeScript module for managing nftables rules including NAT, firewall, and rate limiting with a high-level API.",
   "main": "dist_ts/index.js",
@@ -20,7 +20,7 @@
   "dependencies": {
     "@push.rocks/smartlog": "^3.2.2",
     "@push.rocks/smartpromise": "^4.2.5",
-    "@push.rocks/smartrust": "2.3.0"
+    "@push.rocks/smartrust": "2.5.0"
   },
   "files": [
     "ts/**/*",

package/readme.md

@@ -163,7 +163,7 @@ Subscribe to `failureSignal` before starting or admitting policy work, and check
 exit, ambiguous operation failures, native inspection reporting failed ownership,
 and unconfirmed cleanup abort the signal once with `ManagedNftablesError` code
 `OWNER_LOST`. Local input rejection, effect-free native compiler validation and
-native `INVALID` responses do not abort it. Other native errors can occur after
+native `INVALID` and `EXHAUSTED` responses do not abort it. Other native errors can occur after
 kernel effects or ownership loss and conservatively abort it. Successful orderly
 close, including a cancelled startup, does not signal an unexpected failure;
 ambiguous mutations still signal loss while close is draining them.
@@ -253,6 +253,62 @@ workload before treating revocation as complete or reusing its addresses and
 interfaces. Table deletion does not release IP allocation authority or clean up
 conntrack/NAT state. This restriction also applies to private veth/TUN forwarding.
 
+### Refusals: `INVALID` and `EXHAUSTED`
+
+Every failure is a `ManagedNftablesError` with a stable `code`. Two codes are
+refusals of the input itself, raised by the facade's capture or by the native owner
+before any kernel work:
+
+- `INVALID`: the input is outside the contract (schema, identifiers, addresses,
+  overlaps, authority, or a bound of the topology's shape). A smaller policy does
+  not help; the input must change.
+- `EXHAUSTED`: the policy is too big for one atomic replacement. It exceeds the
+  compiled budget described under the router below, or an input count that exists
+  to hold that budget. A smaller policy may fit.
+
+Both carry the native refusal text in `reason` (bounded, printable ASCII, never
+policy content) and in the message, `Managed nftables EXHAUSTED: <reason>`.
+`EXHAUSTED` also names its bound in `details`, `{ bound, limit, actual }`:
+
+| `bound` | `limit` | Counts |
+| --- | --- | --- |
+| `ruleBytes` | 100,000 | encoded rules, chains and sets of the target |
+| `targetBytes` | 212,000 | the complete target with its set elements |
+| `operations` | 768 | messages of the target |
+| `endpoints` | 32 (v1), 128 (router) | private endpoints |
+| `links` | 128 | router links |
+| `rules` | 128 (v1), 1024 (router) | private directed rules |
+| `grants` | 1024 | router egress grants across every generation |
+| `hostGrants` | 1024 | host grants of one scope |
+| `workloadGrants` | 1024 | router workload grants |
+| `publishedPorts` | 1024 | publications of one scope |
+| `localTcpPortOwners` | 8 | loopback TCP port owners of the pool guard |
+| `restoreRules` | 192 | Docker forwarding contribution rules |
+| `restoreBytes` | 100,000 | Docker forwarding contribution command bytes |
+
+`actual` is always above `limit`. It is exact for input counts and for the
+schema-v1 budget, which measures its complete program. For the other compiled
+budgets (`ruleBytes`, `targetBytes`, `operations`, `restoreRules`, `restoreBytes`)
+compilation stops at the first message or rule past the limit, so the complete
+policy needs at least `actual`. Input counts are checked
+before their entries are validated, so a smaller policy can still be `INVALID`.
+Every other bound (identifier and interface-name lengths, source prefixes per
+endpoint, addresses per link, protected prefixes, platform endpoints, active
+generations, handoffs and allocations, ranges per allocation, guarded pools, the
+IPC and capture limits) describes the shape of the topology and stays `INVALID`.
+Other codes, and the facade's own local rejections, carry neither `reason` nor
+`details`. A native refusal outside this shape is `PROTOCOL`.
+
+```typescript
+try {
+  prepared = await owner.prepare(policy);
+} catch (error) {
+  if (error instanceof ManagedNftablesError && error.code === 'EXHAUSTED' && error.details?.bound === 'publishedPorts') {
+    // Publish fewer ports and prepare again.
+  } else throw error;
+}
+```
+
 ### Combined router egress and host transit
 
 `ManagedNftables<IManagedNftPolicyV2>` accepts the exported schema-v2 policy.
@@ -677,7 +733,7 @@ graph (fewer than 768 rules, chains and sets of at most 140 bytes each), and
 212,000 bytes for the complete target, of which rules, chains and sets may take at
 most 100,000 and set elements the rest. Scopes that grow with their inputs keep
 those inputs in set elements, so the element share grows where the rule share
-shrinks; `prepare()` refuses a target beyond either bound before any kernel work. The private facade IPC carries up to three complete policies in one
+shrinks; `prepare()` refuses a target beyond either bound with `EXHAUSTED` before any kernel work. The private facade IPC carries up to three complete policies in one
 status and is bounded at 1,048,576 bytes per line; the facade captures at most
 1,000,000 JSON bytes and 65,536 values per request or result. The caller owns the host route
 to the workload through the handoff, selecting the transit host address as the

package/rust/src/docker.policy.rs

@@ -129,7 +129,8 @@ impl Prepared {
                         let comment = format!("snftd1:{}:{}:{}:{}",options.owner_id,options.instance_id,self.digest.strip_prefix("sha256:").ok_or(Error::Invalid)?,result.len());
                         args.push(comment.clone());args.extend(["-j","ACCEPT"].map(String::from));
                         bytes += args.iter().map(|arg|arg.len()+1).sum::<usize>()+32;
-                        if result.len() >= 192 || bytes > 100_000 { return Err(Error::Invalid); }
+                        crate::capacity("restoreRules", 192, result.len() + 1)?;
+                        crate::capacity("restoreBytes", 100_000, bytes)?;
                         result.push(Rule {comment,args});
                     }
                 }

package/rust/src/egress.compile.rs

@@ -61,22 +61,20 @@ impl<'a> Program<'a> {
         // Same atomic replacement reserve as v1: a previous bounded graph must
         // fit its handle-only deletions beside the complete target, and the
         // target's set elements, in one `wire::BATCH_BYTES` batch.
-        require(
-            self.bytes <= RULE_BYTES
-                && self.bytes + self.element_bytes <= TARGET_BYTES
-                && self.operations.len() < OPERATIONS,
-        )?;
+        crate::capacity("ruleBytes", RULE_BYTES, self.bytes)?;
+        self.admit(operation, attributes)
+    }
+    /// Admits one message within the target and operation budgets.
+    fn admit(&mut self, operation: u16, attributes: Vec<Attr>) -> Result<()> {
+        crate::capacity("targetBytes", TARGET_BYTES, self.bytes + self.element_bytes)?;
+        crate::capacity("operations", OPERATIONS, self.operations.len() + 1)?;
         self.operations.push((operation, attributes));
         Ok(())
     }
     /// Element messages count against the target, beside the rules.
     fn push_elements(&mut self, attributes: Vec<Attr>) -> Result<()> {
         self.element_bytes += wire::encode_attrs(&attributes).len() + 20;
-        require(
-            self.bytes + self.element_bytes <= TARGET_BYTES && self.operations.len() < OPERATIONS,
-        )?;
-        self.operations.push((12, attributes));
-        Ok(())
+        self.admit(12, attributes)
     }
     /// One named exact-key hash set, or a map to `data_length` bytes. CONSTANT
     /// like every set here.

package/rust/src/egress.rs

@@ -484,7 +484,7 @@ pub fn destination(grant: &Grant, protection: &Protection) -> Result<String> {
 /// with the leased outbound source ports translated to that same transit address.
 fn normalize_router_published(value: &mut RouterScope) -> Result<()> {
     let mut ports = std::mem::take(&mut value.published_ports);
-    require(ports.len() <= PUBLISHED_PORTS)?;
+    crate::capacity("publishedPorts", PUBLISHED_PORTS, ports.len())?;
     ports.sort();
     for (index, port) in ports.iter().enumerate() {
         require(
@@ -599,11 +599,12 @@ fn exclusive_symmetric<'a>(
 /// the enclosing scope.
 fn normalize_host_grants(
     grants: &mut [HostGrant],
+    name: &'static str,
     bound: impl Fn(&HostGrant) -> Result<()>,
 ) -> Result<()> {
     // The contract maximum per projection; set lookups keep the rule graph
     // constant, and the element budget holds this many in every scope.
-    require(grants.len() <= 1024)?;
+    crate::capacity(name, HOST_GRANTS, grants.len())?;
     grants.sort();
     for (index, grant) in grants.iter().enumerate() {
         require(
@@ -648,7 +649,7 @@ fn normalize_router_host_grants(value: &mut RouterScope) -> Result<()> {
                 .any(|source| covers(source, &target) == Ok(true))
         })
     };
-    normalize_host_grants(&mut grants, |grant| {
+    normalize_host_grants(&mut grants, "hostGrants", |grant| {
         let endpoint = workload(&grant.destination_address).ok_or(Error::Invalid)?;
         require(
             endpoint.interface_kind == "veth"
@@ -695,7 +696,7 @@ fn normalize_router_workload_grants(value: &mut RouterScope) -> Result<()> {
         require(endpoint.interface_kind == "veth" && !local && !platform)?;
         Ok(endpoint)
     };
-    normalize_host_grants(&mut grants, |grant| {
+    normalize_host_grants(&mut grants, "workloadGrants", |grant| {
         let source = workload(&grant.source_address)?;
         let destination = workload(&grant.destination_address)?;
         require(source.id != destination.id)
@@ -711,8 +712,11 @@ pub const ROUTER_RULES: usize = 1024;
 pub const ROUTER_GRANTS: usize = 1024;
 /// Publications per scope; they are set elements on both hops.
 pub const PUBLISHED_PORTS: usize = 1024;
+/// Host grants per scope and workload grants per router, each a set element.
+pub const HOST_GRANTS: usize = 1024;
 fn normalize_router(value: &mut RouterScope, revision: u64) -> Result<()> {
-    require(value.links.len() <= ROUTER_LINKS && value.generations.len() <= 32)?;
+    crate::capacity("links", ROUTER_LINKS, value.links.len())?;
+    require(value.generations.len() <= 32)?;
     let private = policy::Policy {
         schema_version: 1,
         revision,
@@ -779,7 +783,11 @@ fn normalize_router(value: &mut RouterScope, revision: u64) -> Result<()> {
     let mut zones = BTreeSet::new();
     let mut labels = BTreeSet::new();
     let mut classifiers: Vec<(&Grant, String)> = Vec::new();
-    let mut count = 0;
+    crate::capacity(
+        "grants",
+        ROUTER_GRANTS,
+        value.generations.iter().map(|item| item.grants.len()).sum(),
+    )?;
     value
         .generations
         .sort_by(|a, b| (&a.lease.id, a.lease.generation).cmp(&(&b.lease.id, b.lease.generation)));
@@ -805,8 +813,6 @@ fn normalize_router(value: &mut RouterScope, revision: u64) -> Result<()> {
                 && generation.conntrack_label.bytes().any(|item| item != b'0')
                 && labels.insert(generation.conntrack_label.clone()),
         )?;
-        count += generation.grants.len();
-        require(count <= ROUTER_GRANTS)?;
         generation.grants.sort();
         for grant in &generation.grants {
             require(
@@ -903,7 +909,7 @@ fn normalize_pool_guard(value: &mut AllocationPoolGuardScope) -> Result<()> {
     }
     // An exception is only ever an exact flow into a guarded pool.
     let mut grants = std::mem::take(&mut value.host_grants);
-    normalize_host_grants(&mut grants, |grant| {
+    normalize_host_grants(&mut grants, "hostGrants", |grant| {
         require(covers_address(&value.prefixes, &grant.destination_address)?)
     })?;
     value.host_grants = grants;
@@ -913,7 +919,7 @@ fn normalize_pool_guard(value: &mut AllocationPoolGuardScope) -> Result<()> {
 /// wildcard or range, each with exactly one owning uid. `(uid_t)-1` is not a
 /// user; it is the kernel's "unchanged" sentinel.
 fn normalize_local_tcp_port_owners(owners: &mut [LocalTcpPortOwner]) -> Result<()> {
-    require(owners.len() <= LOCAL_TCP_PORT_OWNERS)?;
+    crate::capacity("localTcpPortOwners", LOCAL_TCP_PORT_OWNERS, owners.len())?;
     owners.sort();
     for (index, owner) in owners.iter().enumerate() {
         let ip = address(&owner.address)?;
@@ -939,7 +945,7 @@ const LOCAL_TCP_PORT_OWNERS: usize = 8;
 fn normalize_host_host_grants(value: &mut HostScope) -> Result<()> {
     let mut grants = std::mem::take(&mut value.host_grants);
     let scope = &*value;
-    normalize_host_grants(&mut grants, |grant| {
+    normalize_host_grants(&mut grants, "hostGrants", |grant| {
         let destination = &grant.destination_address;
         require(
             scope
@@ -984,7 +990,7 @@ fn normalize_host_host_grants(value: &mut HostScope) -> Result<()> {
 /// overlap with the leased outbound source ports translated to that same address.
 fn normalize_published(value: &mut HostScope) -> Result<()> {
     let mut ports = std::mem::take(&mut value.published_ports);
-    require(ports.len() <= PUBLISHED_PORTS)?;
+    crate::capacity("publishedPorts", PUBLISHED_PORTS, ports.len())?;
     ports.sort();
     for (index, port) in ports.iter().enumerate() {
         require(

package/rust/src/egress_hostgrant_tests.rs

@@ -1051,8 +1051,15 @@ fn host_grants_meet_the_atomic_reserve_at_the_contract_maximum() {
             program.len() < 768 && graph <= super::compile::RULE_BYTES && graph + elements <= super::compile::TARGET_BYTES
         );
         assert!(deletion + graph + elements + 64 <= crate::wire::BATCH_BYTES);
-        // The contract maximum is the validation bound.
-        assert!(normalized(granted(fixture, many(1025))).is_err());
+        // The contract maximum is a capacity bound.
+        assert_eq!(
+            normalized(granted(fixture, many(1025))).unwrap_err(),
+            crate::Error::Exhausted(crate::Bound {
+                name: "hostGrants",
+                limit: 1024,
+                actual: 1025
+            })
+        );
         println!(
             "HOST_GRANT_MAX scope={name} grants=1024 operations={} rule_bytes={graph} element_bytes={elements} batch_bound={}",
             program.len(),

package/rust/src/egress_localport_tests.rs

@@ -262,5 +262,12 @@ fn local_tcp_port_owners_meet_the_atomic_reserve_at_the_contract_maximum() {
         .as_array_mut()
         .unwrap()
         .push(owner("127.0.0.1", 10008, 0));
-    assert!(normalized(value).is_err());
+    assert_eq!(
+        normalized(value).unwrap_err(),
+        crate::Error::Exhausted(crate::Bound {
+            name: "localTcpPortOwners",
+            limit: 8,
+            actual: 9
+        })
+    );
 }

package/rust/src/egress_tests.rs

@@ -992,3 +992,160 @@ fn router_v2_published_endpoint_traffic_is_classified_before_the_leased_grants()
         );
     }
 }
+
+fn exhausted(value: super::Result<Prepared>) -> crate::Bound {
+    match value {
+        Err(crate::Error::Exhausted(bound)) => bound,
+        other => panic!("expected a capacity refusal, got {other:?}"),
+    }
+}
+fn bound(name: &'static str, limit: usize, actual: usize) -> crate::Bound {
+    crate::Bound {
+        name,
+        limit,
+        actual,
+    }
+}
+fn prepare(value: Value) -> super::Result<Prepared> {
+    normalized(value)?.prepare()
+}
+
+/// The compiled budget and the input counts that exist to hold it refuse with
+/// EXHAUSTED and their bound; bounds of the topology's shape stay INVALID.
+#[test]
+fn v2_capacity_refusals_name_their_bound_and_shape_bounds_stay_invalid() {
+    // Router rules grow with protected prefixes: 128 exceed the rule reserve.
+    let mut value = router();
+    let mut prefixes = vec![
+        json!("10.0.0.0/8"),
+        json!("192.0.2.0/24"),
+        json!("203.0.113.10/32"),
+    ];
+    prefixes.extend((0..125).map(|index| json!(format!("172.16.{index}.0/24"))));
+    value["scope"]["protection"]["prefixes"] = json!(prefixes);
+    let refused = exhausted(prepare(value.clone()));
+    assert_eq!((refused.name, refused.limit), ("ruleBytes", 100_000));
+    assert!(refused.actual > refused.limit);
+    // 129 protected prefixes are outside the schema, not over capacity.
+    value["scope"]["protection"]["prefixes"]
+        .as_array_mut()
+        .unwrap()
+        .push(json!("172.17.0.0/24"));
+    assert_eq!(prepare(value).unwrap_err(), crate::Error::Invalid);
+
+    // Host transit rules grow with its handoffs and their leased ranges.
+    let handoff = |index: u32, ranges: u32| {
+        let mut item = allocation();
+        item["lease"]["id"] = json!(format!("lease-{index}"));
+        item["transitSourceAddress"] = json!(format!("10.240.{index}.2"));
+        item["sourcePortRanges"] = json!((0..ranges)
+            .map(
+                |range| json!({"protocol":if range % 2 == 0 { "tcp" } else { "udp" },
+                "first":10000 + range * 100,"last":10099 + range * 100})
+            )
+            .collect::<Vec<_>>());
+        json!({"link":link(10 + index, &format!("h{index}"), "veth", &format!("10.240.{index}.1")),
+            "allocations":[item]})
+    };
+    let handoffs = |count: u32, ranges: u32| {
+        json!((0..count)
+            .map(|index| handoff(index, ranges))
+            .collect::<Vec<_>>())
+    };
+    let mut value = host();
+    value["scope"]["handoffs"] = handoffs(4, 2);
+    assert_eq!(prepare(value.clone()).map(|_| ()), Ok(()));
+    value["scope"]["handoffs"] = handoffs(32, 16);
+    let refused = exhausted(prepare(value.clone()));
+    assert_eq!((refused.name, refused.limit), ("ruleBytes", 100_000));
+    assert!(refused.actual > refused.limit);
+    // 33 handoffs are outside the schema, not over capacity.
+    value["scope"]["handoffs"] = handoffs(33, 2);
+    assert_eq!(prepare(value).unwrap_err(), crate::Error::Invalid);
+
+    // Router input counts.
+    let mut value = router();
+    let template = value["scope"]["links"][0].clone();
+    value["scope"]["links"] = json!((0..129u32)
+        .map(|index| {
+            let mut item = template.clone();
+            item["interfaceIndex"] = json!(10 + index);
+            item["interfaceName"] = json!(format!("l{index}"));
+            item
+        })
+        .collect::<Vec<_>>());
+    assert_eq!(exhausted(prepare(value)), bound("links", 128, 129));
+    let mut value = router();
+    let template = value["scope"]["endpoints"][0].clone();
+    value["scope"]["endpoints"] = json!((0..129u32)
+        .map(|index| {
+            let mut item = template.clone();
+            item["id"] = json!(format!("e{index}"));
+            item
+        })
+        .collect::<Vec<_>>());
+    assert_eq!(exhausted(prepare(value)), bound("endpoints", 128, 129));
+    let mut value = router();
+    let template = value["scope"]["rules"][0].clone();
+    value["scope"]["rules"] = json!((0..1025u16)
+        .map(|index| {
+            let mut item = template.clone();
+            item["destinationPort"] = json!(1 + index);
+            item
+        })
+        .collect::<Vec<_>>());
+    assert_eq!(exhausted(prepare(value)), bound("rules", 1024, 1025));
+    // Egress grants count across every generation.
+    let mut value = router();
+    let generation = value["scope"]["generations"][0].clone();
+    let template = generation["grants"][0].clone();
+    value["scope"]["generations"] = json!((0..2u16)
+        .map(|part| {
+            let mut item = generation.clone();
+            item["grants"] = json!((0..(512 + part))
+                .map(|index| {
+                    let mut grant = template.clone();
+                    grant["destinationPort"] = json!(1 + index);
+                    grant
+                })
+                .collect::<Vec<_>>());
+            item
+        })
+        .collect::<Vec<_>>());
+    assert_eq!(exhausted(prepare(value)), bound("grants", 1024, 1025));
+    // Active generations are lease lifecycle, not capacity.
+    let mut value = router();
+    let generation = value["scope"]["generations"][0].clone();
+    value["scope"]["generations"] = json!(vec![generation; 33]);
+    assert_eq!(prepare(value).unwrap_err(), crate::Error::Invalid);
+
+    // Publications on both hops.
+    let ports = json!((0..1025u16)
+        .map(|index| published_port("tcp", 20000 + index, 20000 + index))
+        .collect::<Vec<_>>());
+    assert_eq!(
+        exhausted(prepare(published_host(ports.clone()))),
+        bound("publishedPorts", 1024, 1025)
+    );
+    let ports = json!((0..1025u16)
+        .map(|index| router_published_port("tcp", 20000 + index, 20000 + index))
+        .collect::<Vec<_>>());
+    assert_eq!(
+        exhausted(prepare(published_router(ports))),
+        bound("publishedPorts", 1024, 1025)
+    );
+
+    // Within the input bound, the grant elements exceed the target budget.
+    let mut value = router();
+    let template = value["scope"]["generations"][0]["grants"][0].clone();
+    value["scope"]["generations"][0]["grants"] = json!((0..1024u16)
+        .map(|index| {
+            let mut grant = template.clone();
+            grant["destinationPort"] = json!(1000 + index);
+            grant
+        })
+        .collect::<Vec<_>>());
+    let refused = exhausted(prepare(value));
+    assert_eq!((refused.name, refused.limit), ("targetBytes", 212_000));
+    assert!(refused.actual > refused.limit);
+}

package/rust/src/egress_workloadgrant_tests.rs

@@ -241,12 +241,6 @@ fn workload_grants_reject_unbound_same_link_local_platform_and_tun_ends() {
             json!([{"protocol":"tcp","sourceAddress":"10.241.0.2","destinationAddress":"10.241.1.2",
                 "destinationPort":80,"bidirectional":true}]),
         ),
-        granted(
-            two_workloads(),
-            json!((0..1025_u16)
-                .map(|port| workload_grant("tcp", "10.241.0.2", "10.241.1.2", 1 + port))
-                .collect::<Vec<_>>()),
-        ),
     ] {
         assert!(
             normalized(invalid.clone()).is_err(),
@@ -254,6 +248,21 @@ fn workload_grants_reject_unbound_same_link_local_platform_and_tun_ends() {
             invalid["scope"]["workloadGrants"]
         );
     }
+    // The contract maximum is a capacity bound.
+    assert_eq!(
+        normalized(granted(
+            two_workloads(),
+            json!((0..1025_u16)
+                .map(|port| workload_grant("tcp", "10.241.0.2", "10.241.1.2", 1 + port))
+                .collect::<Vec<_>>()),
+        ))
+        .unwrap_err(),
+        crate::Error::Exhausted(crate::Bound {
+            name: "workloadGrants",
+            limit: 1024,
+            actual: 1025
+        })
+    );
     // Both directions between two workloads are two separate grants.
     assert!(normalized(granted(
         two_workloads(),

package/rust/src/main.rs

@@ -15,9 +15,22 @@ use std::io::{BufRead, Read, Write};
 /// same lines. A transition carries two complete policies.
 pub(crate) const IPC_BYTES: usize = 1_048_576;
 
+/// A capacity bound of the atomic replacement budget that a policy exceeded: the
+/// stable bound name, its limit and the size the policy reached. Input counts and
+/// the schema-v1 budget are exact; the other compiled budgets stop at the first
+/// message or rule past the limit, so the complete policy needs at least `actual`.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Bound {
+    pub name: &'static str,
+    pub limit: usize,
+    pub actual: usize,
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum Error {
     Invalid,
+    /// The policy does not fit a capacity bound; a smaller policy may fit.
+    Exhausted(Bound),
     Unsupported,
     UnsupportedBackend,
     Permission,
@@ -28,10 +41,23 @@ pub enum Error {
     Unavailable,
 }
 pub type Result<T> = std::result::Result<T, Error>;
+/// Refuses `actual` above the capacity bound `name`.
+pub fn capacity(name: &'static str, limit: usize, actual: usize) -> Result<()> {
+    if actual > limit {
+        Err(Error::Exhausted(Bound {
+            name,
+            limit,
+            actual,
+        }))
+    } else {
+        Ok(())
+    }
+}
 impl Error {
     pub fn code(self) -> &'static str {
         match self {
             Self::Invalid => "INVALID",
+            Self::Exhausted(_) => "EXHAUSTED",
             Self::Unsupported => "UNSUPPORTED_KERNEL",
             Self::UnsupportedBackend => "UNSUPPORTED_BACKEND",
             Self::Permission => "PERMISSION",
@@ -42,6 +68,26 @@ impl Error {
             Self::Unavailable => "UNAVAILABLE",
         }
     }
+    /// The bounded, non-secret refusal text of the response.
+    pub fn message(self) -> String {
+        match self {
+            Self::Invalid => "Managed policy input is invalid.".into(),
+            Self::Exhausted(bound) => format!(
+                "Managed policy exceeds the {} capacity of {}: it reached {}.",
+                bound.name, bound.limit, bound.actual
+            ),
+            _ => "Managed policy operation failed.".into(),
+        }
+    }
+    /// The structured refusal details of the response, if any.
+    pub fn data(self) -> Option<serde_json::Value> {
+        match self {
+            Self::Exhausted(bound) => Some(
+                serde_json::json!({"bound":bound.name,"limit":bound.limit,"actual":bound.actual}),
+            ),
+            _ => None,
+        }
+    }
     pub fn kernel(code: i32) -> Self {
         match -code {
             libc::ENOENT => Self::Absent,
@@ -114,6 +160,16 @@ fn dispatch(owner: &mut Option<owner::Owner>, request: Request) -> Result<serde_
     }
 }
 
+/// The failure response line: the refusal text, the stable code and, for a
+/// capacity refusal, its bound.
+fn failure(id: &str, error: Error) -> serde_json::Value {
+    let mut value = serde_json::json!({"id":id,"success":false,"error":error.message(),"errorCode":error.code()});
+    if let Some(data) = error.data() {
+        value["errorData"] = data;
+    }
+    value
+}
+
 fn main() {
     let arguments = std::env::args().skip(1).collect::<Vec<_>>();
     let (docker_mode, descriptor) = match arguments.as_slice() {
@@ -163,9 +219,7 @@ fn main() {
         let id = request.id.clone();
         let response = match if docker_mode { docker::dispatch(&mut docker, request) } else { dispatch(&mut owner, request) } {
             Ok(result) => serde_json::json!({"id":id,"success":true,"result":result}),
-            Err(error) => {
-                serde_json::json!({"id":id,"success":false,"error":"Managed policy operation failed.","errorCode":error.code()})
-            }
+            Err(error) => failure(&id, error),
         };
         if writeln!(output, "{response}")
             .and_then(|_| output.flush())

package/rust/src/policy.rs

@@ -101,29 +101,26 @@ impl Policy {
         let program = prepared.program(&format!("snft_{}", "x".repeat(59)))?;
         // Reserve enough of the batch for deleting a previous maximum
         // graph, then installing this complete graph in the same transaction.
-        if program.len() > 768
-            || program
+        crate::capacity("operations", 768, program.len())?;
+        crate::capacity(
+            "ruleBytes",
+            100_000,
+            program
                 .iter()
                 .map(|(_, attrs)| wire::encode_attrs(attrs).len() + 20)
-                .sum::<usize>()
-                > 100_000
-        {
-            return Err(Error::Invalid);
-        }
+                .sum(),
+        )?;
         Ok(prepared)
     }
     /// Validates and orders the endpoints and rules. Schema v1 compiles one rule
     /// per endpoint and grant, so it admits 32 endpoints and 128 rules; the
     /// set-backed router scope of schema v2 admits more.
     pub(crate) fn normalize(mut self, endpoints: usize, rules: usize) -> Result<Self> {
-        if self.schema_version != 1
-            || self.revision == 0
-            || self.revision > 9_007_199_254_740_991
-            || self.endpoints.len() > endpoints
-            || self.rules.len() > rules
-        {
+        if self.schema_version != 1 || self.revision == 0 || self.revision > 9_007_199_254_740_991 {
             return Err(Error::Invalid);
         }
+        crate::capacity("endpoints", endpoints, self.endpoints.len())?;
+        crate::capacity("rules", rules, self.rules.len())?;
         let mut ids = BTreeSet::new();
         let mut indices = BTreeSet::new();
         let mut names = BTreeSet::new();

package/rust/src/tests.rs

@@ -117,3 +117,103 @@ fn compiler_bounds_full_policy_and_keeps_directed_port_grants() {
     value.revision = 9_007_199_254_740_992;
     assert_eq!(value.prepare(), Err(Error::Invalid));
 }
+
+fn exhausted<T>(name: &'static str, limit: usize, actual: usize) -> crate::Result<T> {
+    Err(Error::Exhausted(crate::Bound {
+        name,
+        limit,
+        actual,
+    }))
+}
+
+/// Every endpoint with 16 prefixes and `rules` distinct directed rules between
+/// them: well-formed input whose only fault can be its size.
+fn sized(endpoints: u32, rules: u16) -> Policy {
+    let mut value = policy();
+    let template = value.endpoints[0].clone();
+    value.endpoints = (0..endpoints)
+        .map(|index| {
+            let mut endpoint = template.clone();
+            endpoint.id = format!("e{index}");
+            endpoint.interface_index = 10 + index;
+            endpoint.interface_name = format!("w{index}");
+            endpoint.source_prefixes = (0..16)
+                .map(|part| format!("10.{}.{part}.0/24", 100 + index))
+                .collect();
+            endpoint
+        })
+        .collect();
+    let template = value.rules[0].clone();
+    value.rules = (0..rules)
+        .map(|index| {
+            let (from, to) = (
+                u32::from(index) % endpoints,
+                (u32::from(index) + 1) % endpoints,
+            );
+            let mut rule = template.clone();
+            rule.source_endpoint = Some(format!("e{from}"));
+            rule.destination_endpoint = Some(format!("e{to}"));
+            rule.source_prefix = format!("10.{}.0.0/24", 100 + from);
+            rule.destination_prefix = format!("10.{}.0.0/24", 100 + to);
+            rule.destination_port = Some(1000 + index);
+            rule
+        })
+        .collect();
+    value
+}
+
+#[test]
+fn v1_capacity_refusals_name_their_bound_and_invalid_input_stays_invalid() {
+    assert_eq!(sized(2, 2).prepare().map(|_| ()), Ok(()));
+    // Within the schema's counts, the complete graph exceeds the byte and the
+    // operation budget; the complete program is measured, so both are exact.
+    assert_eq!(
+        sized(8, 16).prepare(),
+        exhausted("ruleBytes", 100_000, 186_952)
+    );
+    assert_eq!(sized(32, 128).prepare(), exhausted("operations", 768, 1667));
+    assert_eq!(sized(33, 16).prepare(), exhausted("endpoints", 32, 33));
+    assert_eq!(sized(8, 129).prepare(), exhausted("rules", 128, 129));
+    // Invalid input is never reported as capacity, whatever its size.
+    let mut value = sized(33, 129);
+    value.schema_version = 2;
+    assert_eq!(value.prepare(), Err(Error::Invalid));
+    let mut value = sized(2, 2);
+    value.endpoints[0].interface_name = "w".repeat(16);
+    assert_eq!(value.prepare(), Err(Error::Invalid));
+    let mut value = sized(2, 2);
+    value.endpoints[0]
+        .source_prefixes
+        .push("10.200.0.0/24".into());
+    assert_eq!(value.prepare(), Err(Error::Invalid));
+}
+
+#[test]
+fn failure_responses_carry_the_refusal_reason_and_capacity_bound() {
+    let bound = crate::Bound {
+        name: "targetBytes",
+        limit: 212_000,
+        actual: 212_345,
+    };
+    assert_eq!(
+        crate::failure("7", Error::Exhausted(bound)),
+        serde_json::json!({"id":"7","success":false,
+            "error":"Managed policy exceeds the targetBytes capacity of 212000: it reached 212345.",
+            "errorCode":"EXHAUSTED","errorData":{"bound":"targetBytes","limit":212_000,"actual":212_345}})
+    );
+    assert_eq!(
+        crate::failure("8", Error::Invalid),
+        serde_json::json!({"id":"8","success":false,"error":"Managed policy input is invalid.","errorCode":"INVALID"})
+    );
+    for error in [
+        Error::Conflict,
+        Error::Permission,
+        Error::Protocol,
+        Error::Unavailable,
+    ] {
+        assert_eq!(
+            crate::failure("9", error),
+            serde_json::json!({"id":"9","success":false,"error":"Managed policy operation failed.","errorCode":error.code()})
+        );
+    }
+}

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartnftables',
-  version: '3.0.0',
+  version: '4.0.0',
   description: 'A TypeScript module for managing nftables rules including NAT, firewall, and rate limiting with a high-level API.'
 }

package/ts/classes.manageddockerforwarding.ts

@@ -1,5 +1,5 @@
 import * as plugins from './plugins.js';
-import { snapshot, managedIpcBytes, ManagedNftablesError } from './classes.managednftables.js';
+import { snapshot, managedIpcBytes, ManagedNftablesError, nativeError } from './classes.managednftables.js';
 import type { IManagedDockerForwardingOptions, IManagedDockerForwardingStatus, IManagedDockerForwardingPolicy, IPreparedManagedDockerForwardingPolicy, IManagedDockerForwardingTransition, IAppliedManagedDockerForwardingPolicy, TManagedDockerForwardingCommands } from './managed.docker.types.js';
 
 /** One node-level Docker DOCKER-USER contribution. Caller owns durable intents and handoff lifetimes. */
@@ -103,8 +103,7 @@ export class ManagedDockerForwarding {
   #track<T>(work: Promise<T>): Promise<T> {
     const owned = work.catch((error) => {
       if (this.#state !== 'closing') this.#state = 'failed-owned';
-      const code = error instanceof plugins.smartrust.RustBridgeRequestError ? error.responseErrorCode : undefined;
-      throw new ManagedNftablesError(typeof code === 'string' && /^[A-Z_]{1,64}$/.test(code) ? code : 'UNAVAILABLE');
+      throw nativeError(error);
     });
     this.#work = owned;
     void owned.then(() => { this.#work = null; }, () => { this.#work = null; });

package/ts/classes.managednftables.ts

@@ -1,9 +1,46 @@
 import * as plugins from './plugins.js';
-import type { IManagedNftOptions, IManagedNftPolicy, IManagedNftTransition, IAppliedManagedNftPolicy,
-  IPreparedManagedNftPolicy, IManagedNftStatus, IManagedNftTransitionRelease, TManagedNftCommands, TManagedNftPolicy } from './managed.types.js';
+import type { IManagedNftOptions, IManagedNftPolicy, IManagedNftTransition, IAppliedManagedNftPolicy, IPreparedManagedNftPolicy,
+  IManagedNftStatus, IManagedNftTransitionRelease, TManagedNftCommands, TManagedNftPolicy, IManagedNftCapacity,
+  TManagedNftCapacityBound } from './managed.types.js';
 
+/** `INVALID`: the input is outside the contract. `EXHAUSTED`: the policy exceeds a
+ * capacity bound of the atomic replacement budget, and a smaller policy may fit.
+ * Both carry the native refusal text in `reason`; `EXHAUSTED` also names its
+ * bound in `details`. Every other code, and the facade's own rejections, carry
+ * neither. */
 export class ManagedNftablesError extends Error {
-  constructor(public readonly code: string) { super(`Managed nftables ${code}.`); }
+  constructor(public readonly code: string, public readonly reason: string | null = null,
+    public readonly details: Readonly<IManagedNftCapacity> | null = null) {
+    super(reason === null ? `Managed nftables ${code}.` : `Managed nftables ${code}: ${reason}`);
+  }
+}
+
+const capacityBounds: ReadonlySet<string> = new Set<TManagedNftCapacityBound>(['ruleBytes', 'targetBytes', 'operations',
+  'endpoints', 'links', 'rules', 'grants', 'hostGrants', 'workloadGrants', 'publishedPorts', 'localTcpPortOwners',
+  'restoreRules', 'restoreBytes']);
+
+function capacity(value: unknown): Readonly<IManagedNftCapacity> | null {
+  if (typeof value !== 'object' || value === null || Object.getPrototypeOf(value) !== Object.prototype
+    || Object.keys(value).sort().join(',') !== 'actual,bound,limit') return null;
+  const { bound, limit, actual } = value as Record<string, unknown>;
+  if (typeof bound !== 'string' || !capacityBounds.has(bound) || typeof limit !== 'number' || typeof actual !== 'number'
+    || !Number.isSafeInteger(limit) || !Number.isSafeInteger(actual) || limit < 0 || actual <= limit) return null;
+  return Object.freeze({ bound: bound as TManagedNftCapacityBound, limit, actual });
+}
+
+/** Maps a failed native request. An `INVALID` or `EXHAUSTED` response keeps the
+ * bounded native refusal text and, for `EXHAUSTED`, its bound; a refusal outside
+ * that shape is `PROTOCOL`. Other responses keep only their code, and a failure
+ * without a native code is `UNAVAILABLE`. */
+export function nativeError(error: unknown): ManagedNftablesError {
+  if (!(error instanceof plugins.smartrust.RustBridgeRequestError)) return new ManagedNftablesError('UNAVAILABLE');
+  const { responseErrorCode: code, message: reason, responseErrorData: data } = error;
+  if (typeof code !== 'string' || !/^[A-Z_]{1,64}$/.test(code)) return new ManagedNftablesError('UNAVAILABLE');
+  if (code !== 'INVALID' && code !== 'EXHAUSTED') return new ManagedNftablesError(code);
+  if (!/^[\x20-\x7e]{1,256}$/.test(reason)) return new ManagedNftablesError('PROTOCOL');
+  if (code === 'INVALID') return data === undefined ? new ManagedNftablesError(code, reason) : new ManagedNftablesError('PROTOCOL');
+  const details = capacity(data);
+  return details ? new ManagedNftablesError(code, reason, details) : new ManagedNftablesError('PROTOCOL');
 }
 
 /** Bounds of the private native IPC. A status carries up to three complete policies (applied,
@@ -240,16 +277,17 @@ export class ManagedNftables<TPolicy extends TManagedNftPolicy = IManagedNftPoli
   #track<T>(work: Promise<T>, method: keyof TManagedNftCommands<TPolicy>): Promise<T> {
     const owned = work.catch((error) => {
       if (this.#state !== 'closing') this.#state = 'failed-owned';
-      const code = error instanceof plugins.smartrust.RustBridgeRequestError ? error.responseErrorCode : undefined;
-      // Only a native compiler rejection or explicit INVALID response proves
-      // effect-free validation. Other native errors can follow lost ownership
+      const failure = nativeError(error);
+      // Only a native compiler rejection or explicit INVALID or EXHAUSTED
+      // response proves effect-free validation: the native owner refuses both
+      // before any kernel work. Other native errors can follow lost ownership
       // or admitted kernel work. Recovery stays available; confidence is lost.
       const validation = error instanceof plugins.smartrust.RustBridgeRequestError
         && error.code === 'ERR_RUST_BRIDGE_REQUEST_RUST_RESPONSE'
-        && (method === 'preparePolicy' || code === 'INVALID');
+        && (method === 'preparePolicy' || failure.code === 'INVALID' || failure.code === 'EXHAUSTED');
       if (!validation && (this.#state !== 'closing'
         || ['reconcilePolicy', 'releasePolicy', 'releasePolicyTransition', 'detachPolicy'].includes(method))) this.#fail();
-      throw new ManagedNftablesError(typeof code === 'string' && /^[A-Z_]{1,64}$/.test(code) ? code : 'UNAVAILABLE');
+      throw failure;
     });
     this.#work = owned;
     void owned.then(() => { this.#work = null; }, () => { this.#work = null; });

package/ts/managed.types.ts

@@ -93,6 +93,23 @@ export interface IManagedNftOptions {
 
 export type TManagedNftPolicy = IManagedNftPolicy | IManagedNftPolicyV2;
 
+/** Capacity bounds of the atomic replacement budget. The compiled target's
+ * `ruleBytes` (100,000), `targetBytes` (212,000) and `operations` (768), the input
+ * counts that exist to hold it (`endpoints`, `links`, `rules`, `grants`,
+ * `hostGrants`, `workloadGrants`, `publishedPorts`, `localTcpPortOwners`) and the
+ * Docker forwarding contribution's `restoreRules` (192) and `restoreBytes` (100,000). */
+export type TManagedNftCapacityBound = 'ruleBytes' | 'targetBytes' | 'operations' | 'endpoints' | 'links' | 'rules'
+  | 'grants' | 'hostGrants' | 'workloadGrants' | 'publishedPorts' | 'localTcpPortOwners' | 'restoreRules' | 'restoreBytes';
+
+/** The bound an `EXHAUSTED` refusal names. `actual` is always above `limit`. It is
+ * exact for input counts and the schema-v1 budget; the other compiled budgets stop
+ * at the first message or rule past the limit, so the policy needs at least `actual`. */
+export interface IManagedNftCapacity {
+  bound: TManagedNftCapacityBound;
+  limit: number;
+  actual: number;
+}
+
 export type TManagedNftCommands<TPolicy extends TManagedNftPolicy = IManagedNftPolicy> = {
   preparePolicy: { params: TPolicy; result: IPreparedManagedNftPolicy<TPolicy> };
   openOwner: { params: Pick<IManagedNftOptions, 'ownerId' | 'instanceId' | 'tableName'>; result: IManagedNftStatus<TPolicy> };