@push.rocks/smartnftables 1.7.0 → 1.8.0

package/changelog.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 2026-09-14 - 1.8.0
+
+### Features
+
+- Add terminal policy detachment with exact PERSIST verification, retained-intent recovery and failure-safe native process cleanup.
+
 ## 2026-09-14 - 1.7.0
 
 ### Features

package/dist_rust/smartnftables_linux_amd64_musl.tsrust-build.json

@@ -1,12 +1,12 @@
 {
   "format": "tsrust.build-provenance.v2",
-  "binarySha256": "d220f9e5399c394467c212c9c29a01d56395bde551a7a1af7bd233ae313bbf21",
+  "binarySha256": "e7f3f755b5f9579969e94d70442710a8b2ebde0aa8dda4c0b312094b8771caf6",
   "buildInfo": {
     "projectName": "@push.rocks/smartnftables",
-    "projectVersion": "1.7.0",
-    "gitCommit": "9f206a95e42e76d6a4a61ecce11cf5d02927fb41",
+    "projectVersion": "1.8.0",
+    "gitCommit": "63a819de3661273bd4df2cea457f9fb3c4131cc9",
     "gitDirty": false,
-    "builtAt": "2026-09-14T02:54:17.256Z",
+    "builtAt": "2026-09-14T03:26:32.636Z",
     "tsrustVersion": "1.13.0",
     "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": "a282a800a9782297af8e7862ef2b8abbbc1aefcc79d50b5d0f453feecc874e36",
+  "binarySha256": "f80787be41352d19daf0b3916cb285fe29aa3e88f637180109a07ab8ec609b14",
   "buildInfo": {
     "projectName": "@push.rocks/smartnftables",
-    "projectVersion": "1.7.0",
-    "gitCommit": "9f206a95e42e76d6a4a61ecce11cf5d02927fb41",
+    "projectVersion": "1.8.0",
+    "gitCommit": "63a819de3661273bd4df2cea457f9fb3c4131cc9",
     "gitDirty": false,
-    "builtAt": "2026-09-14T02:54:17.376Z",
+    "builtAt": "2026-09-14T03:26:32.863Z",
     "tsrustVersion": "1.13.0",
     "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: '1.7.0',
+    version: '1.8.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.managednftables.d.ts

@@ -18,6 +18,13 @@ export declare class ManagedNftables<TPolicy extends TManagedNftPolicy = IManage
     release(expected: IAppliedManagedNftPolicy<TPolicy>): Promise<{
         released: true;
     }>;
-    /** Join policy operations and owned-table deletion, then native termination; packet/allocation fencing belongs to the caller. */
+    /** Permanently selects retention cleanup, verifies exact PERSIST retention, and
+     * joins the native process. Retain the full applied value before this call.
+     * After any failure close() only terminates; it never deletes the table. */
+    detach(expected: IAppliedManagedNftPolicy<TPolicy>): Promise<{
+        detached: true;
+    }>;
+    /** Join policy operations, then delete and terminate unless detach selected retention.
+     * Packet/allocation fencing belongs to the caller; already-admitted close cannot be undone. */
     close(): Promise<void>;
 }

package/dist_ts/classes.managednftables.js

@@ -62,6 +62,9 @@ export class ManagedNftables {
     #work = null;
     #close = null;
     #nativeMayOwn = false;
+    #retaining = false;
+    #detachExpected = null;
+    #detach = null;
     constructor(options) {
         this.#options = snapshot(options);
         if (Object.keys(this.#options).some((key) => !['ownerId', 'instanceId', 'tableName', 'binaryPath', 'networkNamespaceFd'].includes(key))
@@ -78,7 +81,7 @@ export class ManagedNftables {
     get state() { return this.#state; }
     /** Starts only the compiler/IPC owner. The returned idle status is not enforcement. */
     start() {
-        if (this.#state !== 'new')
+        if (this.#state !== 'new' || this.#retaining)
             return Promise.reject(new ManagedNftablesError('UNAVAILABLE'));
         this.#state = 'starting';
         const work = (async () => {
@@ -92,7 +95,7 @@ export class ManagedNftables {
                 cliArgs: ['--management', ...(this.#options.networkNamespaceFd === undefined ? [] : ['--network-namespace-fd', '3'])],
                 inheritedFileDescriptors: this.#options.networkNamespaceFd === undefined ? undefined : [this.#options.networkNamespaceFd],
                 readyTimeoutMs: 3000, requestTimeoutMs: 30_000, maxPayloadSize: 262_144,
-                maxPendingRequestsByMethod: { preparePolicy: 1, openOwner: 1, reconcilePolicy: 1, inspectPolicy: 1, releasePolicy: 1, closeOwner: 1 },
+                maxPendingRequestsByMethod: { preparePolicy: 1, openOwner: 1, reconcilePolicy: 1, inspectPolicy: 1, releasePolicy: 1, detachPolicy: 1, closeOwner: 1 },
             });
             this.#bridge.on('exit', () => {
                 if (!['closing', 'stopped'].includes(this.#state))
@@ -119,17 +122,50 @@ export class ManagedNftables {
     release(expected) {
         return this.#invoke('releasePolicy', expected);
     }
-    /** Join policy operations and owned-table deletion, then native termination; packet/allocation fencing belongs to the caller. */
+    /** Permanently selects retention cleanup, verifies exact PERSIST retention, and
+     * joins the native process. Retain the full applied value before this call.
+     * After any failure close() only terminates; it never deletes the table. */
+    detach(expected) {
+        this.#retaining = true;
+        let captured;
+        try {
+            captured = snapshot(expected);
+            if (this.#detachExpected && !plugins.util.isDeepStrictEqual(this.#detachExpected, captured))
+                throw new ManagedNftablesError('CONFLICT');
+            if (this.#detach)
+                return this.#detach;
+            if (!['ready', 'failed-owned'].includes(this.#state) || !this.#bridge || this.#work || this.#close)
+                throw new ManagedNftablesError('UNAVAILABLE');
+            this.#detachExpected = captured;
+        }
+        catch (error) {
+            return Promise.reject(error instanceof ManagedNftablesError ? error : new ManagedNftablesError('INVALID'));
+        }
+        const work = this.#track(this.#bridge.sendCommand('detachPolicy', captured).then((value) => {
+            const result = snapshot(value);
+            if (result?.detached !== true || Object.keys(result).length !== 1)
+                throw new ManagedNftablesError('PROTOCOL');
+            this.#nativeMayOwn = false;
+            return result;
+        }));
+        const detached = (async () => { const result = await work; await this.close(); return result; })();
+        this.#detach = detached;
+        void detached.catch(() => { this.#detach = null; });
+        return detached;
+    }
+    /** Join policy operations, then delete and terminate unless detach selected retention.
+     * Packet/allocation fencing belongs to the caller; already-admitted close cannot be undone. */
     close() {
         if (this.#close)
             return this.#close;
         if (this.#state === 'stopped')
             return Promise.resolve();
+        const retaining = this.#retaining;
         this.#state = 'closing';
         this.#close = (async () => {
             await this.#work?.catch(() => undefined);
             if (this.#bridge) {
-                if (this.#nativeMayOwn) {
+                if (this.#nativeMayOwn && !retaining) {
                     const result = await this.#bridge.sendCommand('closeOwner', {});
                     if (result.released !== true)
                         throw new ManagedNftablesError('PROTOCOL');
@@ -146,7 +182,7 @@ export class ManagedNftables {
         return this.#close;
     }
     #invoke(method, params) {
-        if (!['ready', 'failed-owned'].includes(this.#state) || !this.#bridge || this.#work)
+        if (this.#retaining || !['ready', 'failed-owned'].includes(this.#state) || !this.#bridge || this.#work)
             return Promise.reject(new ManagedNftablesError('UNAVAILABLE'));
         let captured;
         try {
@@ -179,4 +215,4 @@ export class ManagedNftables {
         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":"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"}

package/dist_ts/managed.types.d.ts

@@ -53,7 +53,7 @@ export interface IManagedNftTransition<TPolicy extends TManagedNftPolicy = IMana
 }
 export interface IManagedNftStatus<TPolicy extends TManagedNftPolicy = IManagedNftPolicy> {
     identity: IManagedNftIdentity;
-    state: 'idle' | 'applied' | 'failed-owned' | 'released';
+    state: 'idle' | 'applied' | 'failed-owned' | 'released' | 'retained';
     enforced: boolean;
     applied: IAppliedManagedNftPolicy<TPolicy> | null;
     pending: IManagedNftTransition<TPolicy> | null;
@@ -96,6 +96,12 @@ export type TManagedNftCommands<TPolicy extends TManagedNftPolicy = IManagedNftP
             released: true;
         };
     };
+    detachPolicy: {
+        params: IAppliedManagedNftPolicy<TPolicy>;
+        result: {
+            detached: true;
+        };
+    };
     closeOwner: {
         params: Record<string, never>;
         result: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartnftables",
-  "version": "1.7.0",
+  "version": "1.8.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",

package/readme.md

@@ -113,7 +113,8 @@ grants remain outstanding.
 | `reconcile({ previous, target })` | Creates or replaces the entire policy in one kernel transaction. `previous` is null initially, otherwise the full prior applied result. |
 | `inspect()` | Reads the current owned graph and reports `enforced`, pending intent and a bounded error code. |
 | `release(applied)` | Verifies the exact retained graph and confirms deletion; repeats are idempotent. |
-| `close()` | Stops command admission, joins admitted policy operations, confirms owned-table deletion, then joins the native process. Failure retains the owner for explicit recovery. |
+| `detach(applied)` | Selects terminal retention, verifies the same graph with PERSIST-only flags after dropping socket ownership, then joins the native process. Returns `{ detached: true }`; retain the full applied result. |
+| `close()` | Stops command admission, joins admitted policy operations, confirms owned-table deletion unless `detach()` selected retention, then joins the native process. Failure retains the owner for explicit recovery. |
 
 Schema-v1 policies are directed. Return traffic requires its own grant; there is no broad
 connection-tracking bypass. A null endpoint denotes the actual local host, with an
@@ -154,6 +155,33 @@ invalidates the old boot receipt; the caller must fence its old link/workload
 lifecycle before starting a new owner instance. Cleanup failures and uncertain
 operations must not be reported as successful release or used to transfer authority.
 
+For an orderly restart that must preserve policy, persist the complete applied
+result and call `await owner.detach(applied)` before calling `close()`. The native
+operation validates the exact receipt, graph, interfaces, boot and namespace. It
+accepts this socket's OWNER/PERSIST table or an exact orphan; it never adopts a
+foreign owner. After closing the owner socket it reads the graph again and requires
+the same handle and compiled body with PERSIST-only flags. Native inspection then
+reports `state: 'retained'`. The facade returns success only after child termination.
+
+Calling `detach()` irreversibly selects retention cleanup, including invalid input,
+transport failure, timeout, native rejection or malformed acknowledgement. Subsequent
+`close()` only joins and terminates; it never sends a table-deletion command. It
+cannot undo a `close()` already admitted earlier. Other policy operations reject.
+Resolve any pending policy transition by exact replay before requesting detachment.
+If a detach ACK is lost while the process remains available, only the same captured
+body may be retried. After process loss, start a fresh owner with identical options
+and retry `detach(applied)` against the exact orphan. Absent graphs, foreign active
+owners, changed interfaces, handles, bodies or boot/namespace identities reject.
+Native release/reconcile/close commands reject after a valid detach intent, even
+when post-drop verification fails; explicit recovery requires the retained body.
+
+Detachment confirms retention at observation time. A completed facade retry returns
+its existing acknowledgement; it is not a fresh kernel inspection. Retention does
+not guarantee future enforcement, namespace survival or reboot ordering, and does
+not withdraw external authority, drain packets, clear conntrack or release leases.
+A separately created owner can later recover the full policy and perform an
+explicit release after the caller has fenced that authority and packet lifecycle.
+
 Apply and release receipts describe this owner's table and policy operations.
 They do not certify that packets admitted under an earlier graph have drained:
 foreign NFQUEUE or other deferred packet owners may still hold such packets.
@@ -201,7 +229,8 @@ kernel reboot. It does not fence foreign packet queues, later packet rewrites,
 offloads or proxies, and supplies no quarantine release, conntrack drainage or
 allocation-reuse evidence. Historical leases remain the caller's durable ownership
 responsibility. PERSIST retains this table only while its network namespace exists;
-`close()` still deletes it, so revoke any external protection claim before release.
+`release()` and ordinary `close()` delete it, so revoke any external protection
+claim before release, or use the verified retention operation described above.
 
 Local bindings include name, index, kind, MAC (null for L3 TUN), interface-link
 index, and required IPv4 addresses. RTM_GETLINK/RTM_GETADDR verify those local

package/rust/src/main.rs

@@ -91,6 +91,10 @@ fn dispatch(owner: &mut Option<owner::Owner>, request: Request) -> Result<serde_
                 .release(decode(request.params)?)?;
             Ok(serde_json::json!({"released":true}))
         }
+        "detachPolicy" => {
+            owner.as_mut().ok_or(Error::Conflict)?.detach(decode(request.params)?)?;
+            Ok(serde_json::json!({"detached":true}))
+        }
         "closeOwner" => {
             if decode::<serde_json::Value>(request.params)? != serde_json::json!({}) {
                 return Err(Error::Invalid);

package/rust/src/owner.detach.rs

@@ -0,0 +1,73 @@
+use super::*;
+
+impl Owner {
+    /// Terminal retention, never adoption/deletion. Exact retry may observe an
+    /// orphan after an ACK was lost, including through a fresh native process.
+    pub fn detach(&mut self, expected: Applied) -> Result<()> {
+        self.validate_receipt(&expected)?;
+        if self.released || self.pending.is_some() {
+            return Err(Error::Conflict);
+        }
+        if let Some(retention) = &self.retention {
+            if retention.expected != expected {
+                return Err(Error::Conflict);
+            }
+        } else {
+            self.retention = Some(Retention {
+                expected: expected.clone(),
+                confirmed: false,
+            });
+        }
+        let result = (|| {
+            self.verify_retention(&expected, false)?;
+            // OWNER disappears with this socket; PERSIST must retain exactly
+            // the same table. The fresh verification socket never adopts it.
+            self.socket = None;
+            self.verify_retention(&expected, true)?;
+            self.socket = None;
+            Ok(())
+        })();
+        self.retention.as_mut().unwrap().confirmed = result.is_ok();
+        match result {
+            Ok(()) => {
+                self.applied = Some(expected);
+                self.error = None;
+                Ok(())
+            }
+            Err(error) => {
+                self.error = Some(error);
+                Err(error)
+            }
+        }
+    }
+
+    fn verify_retention(&mut self, expected: &Applied, orphan_only: bool) -> Result<()> {
+        let graph = self.graph()?.ok_or(Error::Conflict)?;
+        self.binding(&graph, Some(expected))?;
+        let flags = wire::number(&graph.table, 2)?;
+        if (orphan_only && flags != 4)
+            || (flags == 6 && wire::number(&graph.table, 7)? != self.socket()?.port)
+            || !self.matches(&graph, &expected.prepared)?
+        {
+            return Err(Error::Conflict);
+        }
+        expected.prepared.validate_interfaces()
+    }
+
+    pub(super) fn inspect_retained(&mut self) -> Status {
+        let expected = self.retention.as_ref().unwrap().expected.clone();
+        if let Err(error) = self.verify_retention(&expected, true) {
+            self.retention.as_mut().unwrap().confirmed = false;
+            self.error = Some(error);
+        }
+        let enforced = self.retention.as_ref().unwrap().confirmed && self.error.is_none();
+        Status {
+            identity: self.identity.clone(),
+            state: if enforced { "retained" } else { "failed-owned" }.into(),
+            enforced,
+            applied: self.applied.clone(),
+            pending: self.pending.clone(),
+            error: self.error.map(|error| error.code().into()),
+        }
+    }
+}

package/rust/src/owner.rs

@@ -68,8 +68,17 @@ pub struct Owner {
     pending: Option<Transition>,
     error: Option<Error>,
     released: bool,
+    retention: Option<Retention>,
 }
 
+struct Retention {
+    expected: Applied,
+    confirmed: bool,
+}
+
+#[path = "owner.detach.rs"]
+mod detach;
+
 pub(crate) fn context() -> Result<(String, String, String)> {
     let boot = std::fs::read_to_string("/proc/sys/kernel/random/boot_id")
         .map_err(|_| Error::Unavailable)?
@@ -154,6 +163,7 @@ impl Owner {
             pending: None,
             error: None,
             released: false,
+            retention: None,
         })
     }
     fn socket(&mut self) -> Result<&mut Socket> {
@@ -350,7 +360,7 @@ impl Owner {
         })
     }
     pub fn reconcile(&mut self, transition: Transition) -> Result<Applied> {
-        if self.released {
+        if self.released || self.retention.is_some() {
             return Err(Error::Conflict);
         }
         transition.target.validate()?;
@@ -453,6 +463,9 @@ impl Owner {
         self.applied(&graph, transition.target.clone())
     }
     pub fn inspect(&mut self) -> Status {
+        if self.retention.is_some() {
+            return self.inspect_retained();
+        }
         let mut enforced = false;
         if let Some(applied) = self.applied.clone().filter(|_| !self.released) {
             match self.graph().and_then(|graph| {
@@ -490,6 +503,9 @@ impl Owner {
         }
     }
     pub fn release(&mut self, expected: Applied) -> Result<()> {
+        if self.retention.is_some() {
+            return Err(Error::Conflict);
+        }
         self.validate_receipt(&expected)?;
         if self.pending.is_some() {
             return Err(Error::Conflict);
@@ -545,6 +561,9 @@ impl Owner {
         }
     }
     pub fn close(&mut self) -> Result<()> {
+        if self.retention.is_some() {
+            return Err(Error::Conflict);
+        }
         if self.released {
             return Ok(());
         }

package/rust/src/owner_detach_tests.rs

@@ -0,0 +1,252 @@
+use super::namespace_tests::NativeOwner;
+use super::*;
+use crate::egress;
+use serde_json::json;
+use std::io::Write;
+use std::time::{Duration, Instant};
+
+fn pool_target(revision: u64) -> Prepared {
+    let mut policy = egress::tests::pool_guard();
+    policy["revision"] = json!(revision);
+    serde_json::from_value::<egress::Policy>(policy)
+        .unwrap()
+        .prepare()
+        .unwrap()
+        .into()
+}
+fn apply(name: &str) -> (Owner, Applied) {
+    let mut owner = Owner::new(options(name)).unwrap();
+    let applied = owner
+        .reconcile(Transition {
+            previous: None,
+            target: pool_target(1),
+        })
+        .unwrap();
+    (owner, applied)
+}
+fn retained(owner: &mut Owner, applied: &Applied) {
+    let status = owner.inspect();
+    assert_eq!(status.state, "retained");
+    assert!(status.enforced);
+    assert_eq!(status.applied, Some(applied.clone()));
+    let graph = owner.graph().unwrap().unwrap();
+    assert_eq!(wire::number(&graph.table, 2).unwrap(), 4);
+    assert_eq!(
+        wire::handle(&graph.table, 4).unwrap().to_string(),
+        applied.receipt.table_handle
+    );
+    assert!(owner.matches(&graph, &applied.prepared).unwrap());
+}
+
+#[test]
+#[ignore = "requires disposable isolated native qualification guest"]
+fn detach_retains_exact_graph_is_terminal_and_replays_without_adoption() {
+    isolated();
+    let (mut owner, applied) = apply("detach_replay");
+    owner.detach(applied.clone()).unwrap();
+    retained(&mut owner, &applied);
+    owner.detach(applied.clone()).unwrap();
+    assert_eq!(owner.close(), Err(Error::Conflict));
+    assert_eq!(owner.release(applied.clone()), Err(Error::Conflict));
+    assert_eq!(
+        owner.reconcile(Transition {
+            previous: Some(applied.clone()),
+            target: pool_target(2)
+        }),
+        Err(Error::Conflict)
+    );
+    let mut different = applied.clone();
+    different.prepared = pool_target(2);
+    different.receipt.revision = 2;
+    different.receipt.digest = different.prepared.digest.clone();
+    assert_eq!(owner.detach(different), Err(Error::Conflict));
+    retained(&mut owner, &applied);
+    drop(owner);
+    let mut fresh = Owner::new(options("detach_replay")).unwrap();
+    fresh.detach(applied.clone()).unwrap();
+    retained(&mut fresh, &applied);
+    // A separate active owner invalidates retention inspection. It is never
+    // detached by this reader, even with the same full logical identity.
+    let mut active = Owner::new(options("detach_replay")).unwrap();
+    active
+        .reconcile(Transition {
+            previous: None,
+            target: applied.prepared.clone(),
+        })
+        .unwrap();
+    assert_eq!(fresh.detach(applied.clone()), Err(Error::Conflict));
+    assert!(!fresh.inspect().enforced);
+    assert!(active.inspect().enforced);
+    assert_eq!(fresh.close(), Err(Error::Conflict));
+    drop(active);
+    fresh.detach(applied.clone()).unwrap();
+    retained(&mut fresh, &applied);
+    drop(fresh);
+    Owner::new(options("detach_replay"))
+        .unwrap()
+        .release(applied)
+        .unwrap();
+}
+
+#[test]
+#[ignore = "requires disposable isolated native qualification guest"]
+fn detach_rejects_pending_wrong_receipts_foreign_mutation_and_absence() {
+    isolated();
+    let (mut owner, applied) = apply("detach_faults");
+    let pending = Transition {
+        previous: Some(applied.clone()),
+        target: pool_target(2),
+    };
+    owner.pending = Some(pending.clone());
+    assert_eq!(owner.detach(applied.clone()), Err(Error::Conflict));
+    assert!(owner.retention.is_none());
+    let applied = owner.reconcile(pending).unwrap();
+    for field in ["boot", "namespace", "handle", "digest"] {
+        let mut invalid = applied.clone();
+        match field {
+            "boot" => {
+                invalid.receipt.identity.boot_id = "00000000-0000-0000-0000-000000000000".into()
+            }
+            "namespace" => invalid.receipt.identity.namespace_inode = "0".into(),
+            "handle" => invalid.receipt.table_handle = "18446744073709551615".into(),
+            _ => invalid.receipt.digest = format!("sha256:{}", "0".repeat(64)),
+        }
+        let mut reader = Owner::new(options("detach_faults")).unwrap();
+        assert_eq!(reader.detach(invalid), Err(Error::Conflict));
+        assert!(owner.inspect().enforced);
+    }
+    owner.detach(applied.clone()).unwrap();
+    // Mutation after detachment is observed on exact retry and permanently
+    // retains the failed owner. No failure cleanup adopts or deletes the graph.
+    let mut foreign = Socket::open().unwrap();
+    let generation = foreign.generation().unwrap();
+    foreign
+        .batch(
+            generation,
+            vec![(
+                3,
+                0x600,
+                vec![
+                    Attr::string(1, "snft_detach_faults"),
+                    Attr::string(3, "foreign"),
+                ],
+            )],
+        )
+        .unwrap();
+    assert_eq!(owner.detach(applied.clone()), Err(Error::Conflict));
+    assert!(!owner.inspect().enforced);
+    assert_eq!(owner.close(), Err(Error::Conflict));
+    assert_eq!(owner.release(applied.clone()), Err(Error::Conflict));
+    assert!(owner
+        .graph()
+        .unwrap()
+        .unwrap()
+        .chains
+        .iter()
+        .any(|chain| wire::text(chain, 3).unwrap() == "foreign"));
+    drop(owner);
+    // This disposable fixture's foreign owner deletes only its exact orphan.
+    let generation = foreign.generation().unwrap();
+    foreign
+        .batch(
+            generation,
+            vec![(2, 0, vec![Attr::string(1, "snft_detach_faults")])],
+        )
+        .unwrap();
+    let mut absent = Owner::new(options("detach_faults")).unwrap();
+    assert_eq!(absent.detach(applied), Err(Error::Conflict));
+    assert!(!absent.inspect().enforced);
+    assert_eq!(absent.close(), Err(Error::Conflict));
+    assert!(absent.graph().unwrap().is_none());
+}
+
+#[test]
+#[ignore = "requires disposable isolated native qualification guest"]
+fn detach_rechecks_interface_bindings_without_releasing_on_drift() {
+    isolated();
+    let endpoint = endpoint("a", 71);
+    let policy = crate::policy::Policy {
+        schema_version: 1,
+        revision: 1,
+        endpoints: vec![endpoint],
+        rules: vec![],
+    };
+    let mut owner = Owner::new(options("detach_links")).unwrap();
+    let applied = owner
+        .reconcile(Transition {
+            previous: None,
+            target: policy.prepare().unwrap().into(),
+        })
+        .unwrap();
+    ip(&["link", "set", "worka", "name", "renameda"]);
+    assert_eq!(owner.detach(applied.clone()), Err(Error::Conflict));
+    assert_eq!(owner.close(), Err(Error::Conflict));
+    let graph = owner.graph().unwrap().unwrap();
+    assert_eq!(
+        wire::handle(&graph.table, 4).unwrap().to_string(),
+        applied.receipt.table_handle
+    );
+    ip(&["link", "set", "renameda", "name", "worka"]);
+    owner.detach(applied.clone()).unwrap();
+    retained(&mut owner, &applied);
+    drop(owner);
+    Owner::new(options("detach_links"))
+        .unwrap()
+        .release(applied)
+        .unwrap();
+}
+
+#[test]
+#[ignore = "requires disposable isolated native qualification guest"]
+fn detach_recovers_lost_response_and_undelivered_request_across_real_native_processes() {
+    isolated();
+    let namespace = std::fs::File::open("/proc/thread-self/ns/net").unwrap();
+    for delivered in [true, false] {
+        let name = if delivered {
+            "detach_ack"
+        } else {
+            "detach_unsent"
+        };
+        let mut native = NativeOwner::start(&namespace);
+        native.call("openOwner", serde_json::to_value(options(name)).unwrap());
+        let applied: Applied = serde_json::from_value(native.call(
+            "reconcilePolicy",
+            json!({"previous":null,"target":pool_target(1)}),
+        ))
+        .unwrap();
+        let mut reader = Owner::new(options(name)).unwrap();
+        reader.validate_receipt(&applied).unwrap();
+        if delivered {
+            writeln!(
+                native.child.stdin.as_mut().unwrap(),
+                "{}",
+                json!({"id":"lost-detach","method":"detachPolicy","params":applied})
+            )
+            .unwrap();
+            let until = Instant::now() + Duration::from_secs(3);
+            loop {
+                let graph = reader.graph().unwrap().unwrap();
+                if wire::number(&graph.table, 2).unwrap() == 4 {
+                    break;
+                }
+                assert!(Instant::now() < until);
+                std::thread::sleep(Duration::from_millis(5));
+            }
+            // Do not read the detach response: terminate the actual process
+            // after observing its kernel effect but before recording an ACK.
+        }
+        drop(native);
+        let mut fresh = NativeOwner::start(&namespace);
+        fresh.call("openOwner", serde_json::to_value(options(name)).unwrap());
+        assert_eq!(
+            fresh.call("detachPolicy", serde_json::to_value(&applied).unwrap()),
+            json!({"detached":true})
+        );
+        assert_eq!(fresh.call("inspectPolicy", json!({}))["state"], "retained");
+        drop(fresh);
+        let graph = reader.graph().unwrap().unwrap();
+        assert_eq!(wire::number(&graph.table, 2).unwrap(), 4);
+        assert!(reader.matches(&graph, &applied.prepared).unwrap());
+        reader.release(applied).unwrap();
+    }
+}

package/rust/src/owner_namespace_tests.rs

@@ -30,13 +30,13 @@ fn command(namespace: &File) -> Command {
     command
 }
 
-struct NativeOwner {
-    child: Child,
+pub(super) struct NativeOwner {
+    pub(super) child: Child,
     messages: Receiver<Value>,
     reader: Option<JoinHandle<()>>,
 }
 impl NativeOwner {
-    fn start(namespace: &File) -> Self {
+    pub(super) fn start(namespace: &File) -> Self {
         let mut child = command(namespace).spawn().unwrap();
         let output = child.stdout.take().unwrap();
         let (send, messages) = mpsc::channel();
@@ -76,7 +76,7 @@ impl NativeOwner {
         assert_eq!(response["id"], method);
         response
     }
-    fn call(&mut self, method: &str, params: Value) -> Value {
+    pub(super) fn call(&mut self, method: &str, params: Value) -> Value {
         let response = self.response(method, params);
         assert_eq!(response["success"], true, "{response}");
         response["result"].clone()

package/rust/src/owner_poolguard_tests.rs

@@ -234,6 +234,8 @@ fn allocation_pool_guard_covers_all_host_hooks_dnat_untracked_and_reply_directio
             })
             .unwrap();
         assert!(owner.inspect().enforced);
+        owner.detach(applied.clone()).unwrap();
+        assert_eq!(owner.inspect().state, "retained");
         (owner, applied)
     });
     for ((destination, _, _), target) in cases.iter().zip(&targets) {
@@ -254,7 +256,8 @@ fn allocation_pool_guard_covers_all_host_hooks_dnat_untracked_and_reply_directio
     in_namespace(HOST, move || {
         let mut owner = owner;
         assert!(owner.inspect().enforced);
-        owner.release(applied).unwrap();
+        drop(owner);
+        Owner::new(options("pool_traffic")).unwrap().release(applied).unwrap();
     });
     // Positive control after release proves the denials were this guard.
     for ((destination, _, _), target) in cases.iter().zip(&targets) {

package/rust/src/owner_tests.rs

@@ -24,6 +24,9 @@ mod host_traffic_tests;
 #[path = "owner_poolguard_tests.rs"]
 mod poolguard_tests;
 
+#[path = "owner_detach_tests.rs"]
+mod detach_tests;
+
 #[path = "owner_coexistence_tests.rs"]
 mod coexistence_tests;
 

package/ts/00_commitinfo_data.ts

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

package/ts/classes.managednftables.ts

@@ -50,6 +50,9 @@ export class ManagedNftables<TPolicy extends TManagedNftPolicy = IManagedNftPoli
   #work: Promise<unknown> | null = null;
   #close: Promise<void> | null = null;
   #nativeMayOwn = false;
+  #retaining = false;
+  #detachExpected: IAppliedManagedNftPolicy<TPolicy> | null = null;
+  #detach: Promise<{ detached: true }> | null = null;
 
   constructor(options: IManagedNftOptions) {
     this.#options = snapshot(options);
@@ -68,7 +71,7 @@ export class ManagedNftables<TPolicy extends TManagedNftPolicy = IManagedNftPoli
 
   /** Starts only the compiler/IPC owner. The returned idle status is not enforcement. */
   public start(): Promise<IManagedNftStatus<TPolicy>> {
-    if (this.#state !== 'new') return Promise.reject(new ManagedNftablesError('UNAVAILABLE'));
+    if (this.#state !== 'new' || this.#retaining) return Promise.reject(new ManagedNftablesError('UNAVAILABLE'));
     this.#state = 'starting';
     const work = (async () => {
       if (process.platform !== 'linux' || !['x64', 'arm64'].includes(process.arch)) throw new ManagedNftablesError('UNSUPPORTED_PLATFORM');
@@ -80,7 +83,7 @@ export class ManagedNftables<TPolicy extends TManagedNftPolicy = IManagedNftPoli
         cliArgs: ['--management', ...(this.#options.networkNamespaceFd === undefined ? [] : ['--network-namespace-fd', '3'])],
         inheritedFileDescriptors: this.#options.networkNamespaceFd === undefined ? undefined : [this.#options.networkNamespaceFd],
         readyTimeoutMs: 3000, requestTimeoutMs: 30_000, maxPayloadSize: 262_144,
-        maxPendingRequestsByMethod: { preparePolicy: 1, openOwner: 1, reconcilePolicy: 1, inspectPolicy: 1, releasePolicy: 1, closeOwner: 1 },
+        maxPendingRequestsByMethod: { preparePolicy: 1, openOwner: 1, reconcilePolicy: 1, inspectPolicy: 1, releasePolicy: 1, detachPolicy: 1, closeOwner: 1 },
       });
       this.#bridge.on('exit', () => {
         if (!['closing', 'stopped'].includes(this.#state)) this.#state = 'failed-owned';
@@ -105,15 +108,42 @@ export class ManagedNftables<TPolicy extends TManagedNftPolicy = IManagedNftPoli
     return this.#invoke('releasePolicy', expected);
   }
 
-  /** Join policy operations and owned-table deletion, then native termination; packet/allocation fencing belongs to the caller. */
+  /** Permanently selects retention cleanup, verifies exact PERSIST retention, and
+   * joins the native process. Retain the full applied value before this call.
+   * After any failure close() only terminates; it never deletes the table. */
+  public detach(expected: IAppliedManagedNftPolicy<TPolicy>): Promise<{ detached: true }> {
+    this.#retaining = true;
+    let captured: IAppliedManagedNftPolicy<TPolicy>;
+    try {
+      captured = snapshot(expected);
+      if (this.#detachExpected && !plugins.util.isDeepStrictEqual(this.#detachExpected, captured)) throw new ManagedNftablesError('CONFLICT');
+      if (this.#detach) return this.#detach;
+      if (!['ready', 'failed-owned'].includes(this.#state) || !this.#bridge || this.#work || this.#close) throw new ManagedNftablesError('UNAVAILABLE');
+      this.#detachExpected = captured;
+    } catch (error) { return Promise.reject(error instanceof ManagedNftablesError ? error : new ManagedNftablesError('INVALID')); }
+    const work = this.#track(this.#bridge.sendCommand('detachPolicy', captured).then((value) => {
+      const result = snapshot(value);
+      if (result?.detached !== true || Object.keys(result).length !== 1) throw new ManagedNftablesError('PROTOCOL');
+      this.#nativeMayOwn = false;
+      return result;
+    }));
+    const detached = (async () => { const result = await work; await this.close(); return result; })();
+    this.#detach = detached;
+    void detached.catch(() => { this.#detach = null; });
+    return detached;
+  }
+
+  /** Join policy operations, then delete and terminate unless detach selected retention.
+   * Packet/allocation fencing belongs to the caller; already-admitted close cannot be undone. */
   public close(): Promise<void> {
     if (this.#close) return this.#close;
     if (this.#state === 'stopped') return Promise.resolve();
+    const retaining = this.#retaining;
     this.#state = 'closing';
     this.#close = (async () => {
       await this.#work?.catch(() => undefined);
       if (this.#bridge) {
-        if (this.#nativeMayOwn) {
+        if (this.#nativeMayOwn && !retaining) {
           const result = await this.#bridge.sendCommand('closeOwner', {});
           if (result.released !== true) throw new ManagedNftablesError('PROTOCOL');
         }
@@ -128,7 +158,7 @@ export class ManagedNftables<TPolicy extends TManagedNftPolicy = IManagedNftPoli
   }
 
   #invoke<K extends keyof TManagedNftCommands<TPolicy>>(method: K, params: TManagedNftCommands<TPolicy>[K]['params']): Promise<TManagedNftCommands<TPolicy>[K]['result']> {
-    if (!['ready', 'failed-owned'].includes(this.#state) || !this.#bridge || this.#work) return Promise.reject(new ManagedNftablesError('UNAVAILABLE'));
+    if (this.#retaining || !['ready', 'failed-owned'].includes(this.#state) || !this.#bridge || this.#work) return Promise.reject(new ManagedNftablesError('UNAVAILABLE'));
     let captured: TManagedNftCommands<TPolicy>[K]['params'];
     try { captured = snapshot(params); } catch { return Promise.reject(new ManagedNftablesError('INVALID')); }
     if (method === 'reconcilePolicy' || method === 'releasePolicy') this.#nativeMayOwn = true;

package/ts/managed.types.ts

@@ -62,7 +62,7 @@ export interface IManagedNftTransition<TPolicy extends TManagedNftPolicy = IMana
 
 export interface IManagedNftStatus<TPolicy extends TManagedNftPolicy = IManagedNftPolicy> {
   identity: IManagedNftIdentity;
-  state: 'idle' | 'applied' | 'failed-owned' | 'released';
+  state: 'idle' | 'applied' | 'failed-owned' | 'released' | 'retained';
   enforced: boolean;
   applied: IAppliedManagedNftPolicy<TPolicy> | null;
   pending: IManagedNftTransition<TPolicy> | null;
@@ -91,5 +91,6 @@ export type TManagedNftCommands<TPolicy extends TManagedNftPolicy = IManagedNftP
   reconcilePolicy: { params: IManagedNftTransition<TPolicy>; result: IAppliedManagedNftPolicy<TPolicy> };
   inspectPolicy: { params: Record<string, never>; result: IManagedNftStatus<TPolicy> };
   releasePolicy: { params: IAppliedManagedNftPolicy<TPolicy>; result: { released: true } };
+  detachPolicy: { params: IAppliedManagedNftPolicy<TPolicy>; result: { detached: true } };
   closeOwner: { params: Record<string, never>; result: { released: true } };
 };