@push.rocks/smartnftables 1.3.1 → 1.4.0

package/changelog.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 2026-09-13 - 1.4.0
+
+### Maintenance
+
+- Update release, build and test tooling with explicit development build-script policy.
+
+### Features
+
+- Add Linux namespace descriptor entry before native policy ownership, with isolated persistence and recovery qualification.
+
 ## 2026-09-09 - 1.3.1
 
 ### Fixes

package/dist_rust/smartnftables_linux_amd64_musl.tsrust-build.json

@@ -1,12 +1,12 @@
 {
   "format": "tsrust.build-provenance.v2",
-  "binarySha256": "ca5b8c77de7f91f0027f95f1a83e54a3b41af724ca7e0e2f49f422538c628687",
+  "binarySha256": "a97fc50e1f566505de1a412ee316f66996fd2f8450d07f6919c242dfd1746f0a",
   "buildInfo": {
     "projectName": "@push.rocks/smartnftables",
-    "projectVersion": "1.3.1",
-    "gitCommit": "454e4d4c44300f5ca67c3afd9d4507040ed674be",
+    "projectVersion": "1.4.0",
+    "gitCommit": "4cd43db6efa140559ba87b90b4cdddf758239e42",
     "gitDirty": false,
-    "builtAt": "2026-09-09T13:04:41.744Z",
+    "builtAt": "2026-09-13T12:15:55.817Z",
     "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": "65913ced75089fa08d77913b22aa13f8ad2804d1e742aeca749ff23a6aeca4d7",
+  "binarySha256": "029d5e31ef6656bfb45588179dc75cd211a6d66254b7104da62c9fd9c687e61c",
   "buildInfo": {
     "projectName": "@push.rocks/smartnftables",
-    "projectVersion": "1.3.1",
-    "gitCommit": "454e4d4c44300f5ca67c3afd9d4507040ed674be",
+    "projectVersion": "1.4.0",
+    "gitCommit": "4cd43db6efa140559ba87b90b4cdddf758239e42",
     "gitDirty": false,
-    "builtAt": "2026-09-09T13:04:41.873Z",
+    "builtAt": "2026-09-13T12:15:56.577Z",
     "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.3.1',
+    version: '1.4.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.js

@@ -64,12 +64,16 @@ export class ManagedNftables {
     #nativeMayOwn = false;
     constructor(options) {
         this.#options = snapshot(options);
-        if (Object.keys(this.#options).some((key) => !['ownerId', 'instanceId', 'tableName', 'binaryPath'].includes(key))
+        if (Object.keys(this.#options).some((key) => !['ownerId', 'instanceId', 'tableName', 'binaryPath', 'networkNamespaceFd'].includes(key))
             || ![this.#options.ownerId, this.#options.instanceId, this.#options.tableName].every((value) => typeof value === 'string' && /^[A-Za-z0-9_-]{1,64}$/.test(value))
             || this.#options.instanceId.length < 16 || !this.#options.tableName.startsWith('snft_')
             || this.#options.binaryPath !== undefined && (!plugins.path.isAbsolute(this.#options.binaryPath) || this.#options.binaryPath.includes('\0'))) {
             throw new ManagedNftablesError('INVALID');
         }
+        if (this.#options.networkNamespaceFd !== undefined && (process.platform !== 'linux'
+            || !Number.isInteger(this.#options.networkNamespaceFd) || this.#options.networkNamespaceFd < 0
+            || this.#options.networkNamespaceFd > 0x7fff_ffff))
+            throw new ManagedNftablesError('INVALID');
     }
     get state() { return this.#state; }
     /** Starts only the compiler/IPC owner. The returned idle status is not enforcement. */
@@ -84,7 +88,9 @@ export class ManagedNftables {
             this.#bridge = new plugins.smartrust.RustBridge({
                 binaryName: 'smartnftables', binaryPath: this.#options.binaryPath
                     ?? plugins.path.join(root, 'dist_rust', `smartnftables_linux_${process.arch === 'x64' ? 'amd64' : 'arm64'}_musl`),
-                localPaths: [], searchSystemPath: false, cliArgs: ['--management'],
+                localPaths: [], searchSystemPath: false,
+                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 },
             });
@@ -173,4 +179,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

@@ -66,6 +66,10 @@ export interface IManagedNftOptions {
     tableName: string;
     /** Explicit executable selection for qualified distributions and isolated tests. */
     binaryPath?: string;
+    /** Linux network namespace descriptor, owned by the caller and valid through start().
+     * The native process enters before readiness or netlink activity. Keep a namespace
+     * owner alive for policy lifetime and recovery; this process option is not durable authority. */
+    networkNamespaceFd?: number;
 }
 export type TManagedNftCommands = {
     preparePolicy: {
@@ -73,7 +77,7 @@ export type TManagedNftCommands = {
         result: IPreparedManagedNftPolicy;
     };
     openOwner: {
-        params: Omit<IManagedNftOptions, 'binaryPath'>;
+        params: Pick<IManagedNftOptions, 'ownerId' | 'instanceId' | 'tableName'>;
         result: IManagedNftStatus;
     };
     reconcilePolicy: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartnftables",
-  "version": "1.3.1",
+  "version": "1.4.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",
@@ -9,11 +9,11 @@
   "author": "Lossless GmbH",
   "license": "MIT",
   "devDependencies": {
-    "@git.zone/cli": "6.7.3",
-    "@git.zone/tsbuild": "^4.4.2",
+    "@git.zone/cli": "6.13.2",
+    "@git.zone/tsbuild": "^4.4.3",
     "@git.zone/tsrun": "^2.0.6",
     "@git.zone/tsrust": "1.13.0",
-    "@git.zone/tstest": "5.0.0",
+    "@git.zone/tstest": "6.0.0",
     "@types/node": "26.4.1",
     "typescript": "^7.0.2"
   },

package/readme.md

@@ -26,6 +26,29 @@ namespace, and working nftables OWNER/PERSIST support. The published native matr
 is Linux x86_64 and arm64, statically linked with musl. Actual kernel support is
 checked when applying policy; starting the compiler does not establish enforcement.
 
+An optional caller-owned `networkNamespaceFd` selects an already-created Linux
+network namespace. Keep that descriptor valid through `start()`. The native
+process validates and enters its inherited copy before readiness, owner identity
+capture or netlink activity, then closes the copy. Invalid descriptors and denied
+entry fail before readiness. The option is process configuration and never enters
+`openOwner`, policy commands or durable receipts. Native callers use
+`--management --network-namespace-fd 3` with an inherited descriptor at FD 3.
+
+The caller owns the namespace lifetime, links and routes. Retain a namespace
+owner across process loss and recovery: PERSIST retains policy only while its
+namespace exists. An entered process keeps its namespace membership if the source
+descriptor is closed, but a replacement process requires a valid descriptor.
+Receipts bind the actual target namespace device and inode; recovery in another
+namespace rejects. Await complete policy and process cleanup before releasing
+the caller's final namespace owner. Namespace entry does not create uplink
+authority, drain conntrack flows or authorize address and port reuse.
+
+The Linux x86_64 musl candidate passed nine isolated Linux 6.18.35 kernel tests,
+including inherited namespace entry, retained policy after process loss, recovery
+in the original namespace, rejection in another namespace, and denied entry
+before readiness. ARM binaries are built; privileged ARM and complete Pallet
+workload integration remain separate qualification requirements.
+
 The caller owns workload links and durable state. Keep links disabled until their
 policy is confirmed, serialize link changes with policy operations, and disable
 them before cleanup. Persist the full prepared transition before calling

package/rust/src/main.rs

@@ -1,3 +1,4 @@
+mod namespace;
 mod owner;
 mod policy;
 #[cfg(test)]
@@ -97,9 +98,26 @@ fn dispatch(owner: &mut Option<owner::Owner>, request: Request) -> Result<serde_
 }
 
 fn main() {
-    if std::env::args().skip(1).collect::<Vec<_>>() != ["--management"] {
-        std::process::exit(2);
+    let arguments = std::env::args().skip(1).collect::<Vec<_>>();
+    let descriptor = match arguments.as_slice() {
+        [management] if management == "--management" => None,
+        [management, option, fd]
+            if management == "--management" && option == "--network-namespace-fd" =>
+        {
+            match fd.parse::<i32>() {
+                Ok(value) => Some(value),
+                Err(_) => std::process::exit(2),
+            }
+        }
+        _ => std::process::exit(2),
+    };
+    if let Some(fd) = descriptor {
+        if let Err(error) = namespace::enter(fd) {
+            eprintln!("Network namespace startup failed: {error}");
+            std::process::exit(1);
+        }
     }
+    // The single native owner must enter before readiness, context capture or sockets.
     let mut output = std::io::stdout().lock();
     writeln!(output, "{{\"event\":\"ready\",\"data\":{{}}}}").unwrap();
     output.flush().unwrap();

package/rust/src/namespace.rs

@@ -0,0 +1,51 @@
+//! Startup-only entry. No thread, runtime, socket or ready event may precede it.
+use std::io;
+
+#[cfg(target_os = "linux")]
+pub fn enter(fd: i32) -> io::Result<()> {
+    use std::os::fd::{AsRawFd, FromRawFd, OwnedFd};
+
+    // Only an explicitly inherited extra descriptor is accepted. Never consume IPC.
+    if fd < 3 {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidInput,
+            "network namespace descriptor must be at least 3",
+        ));
+    }
+    if unsafe { libc::fcntl(fd, libc::F_GETFD) } < 0 {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidInput,
+            "network namespace descriptor is not open",
+        ));
+    }
+    // Startup is single-threaded; this is the child's owned copy, not the parent's.
+    let descriptor = unsafe { OwnedFd::from_raw_fd(fd) };
+    let namespace_type = unsafe { libc::ioctl(descriptor.as_raw_fd(), libc::NS_GET_NSTYPE) };
+    if namespace_type != libc::CLONE_NEWNET {
+        return Err(io::Error::new(
+            io::ErrorKind::InvalidInput,
+            "descriptor is not a Linux network namespace",
+        ));
+    }
+    if unsafe { libc::setns(descriptor.as_raw_fd(), libc::CLONE_NEWNET) } != 0 {
+        return Err(io::Error::new(
+            io::ErrorKind::PermissionDenied,
+            format!(
+                "network namespace entry failed: {}",
+                io::Error::last_os_error()
+            ),
+        ));
+    }
+    // Close the inherited capability before creating threads. Namespace membership
+    // itself keeps the namespace alive until the complete process has exited.
+    drop(descriptor);
+    Ok(())
+}
+
+#[cfg(not(target_os = "linux"))]
+pub fn enter(_fd: i32) -> io::Result<()> {
+    Err(io::Error::new(
+        io::ErrorKind::Unsupported,
+        "network namespace entry requires Linux",
+    ))
+}

package/rust/src/owner_namespace_tests.rs

@@ -0,0 +1,242 @@
+use super::{empty, in_namespace, ip, isolated, options};
+use crate::owner::{Applied, Owner, Transition};
+use serde_json::{json, Value};
+use std::fs::{self, File};
+use std::io::{BufRead, BufReader, Read, Write};
+use std::os::fd::AsRawFd;
+use std::os::unix::fs::MetadataExt;
+use std::os::unix::process::CommandExt;
+use std::process::{Child, Command, Stdio};
+use std::sync::mpsc::{self, Receiver};
+use std::thread::{self, JoinHandle};
+use std::time::{Duration, Instant};
+
+fn command(namespace: &File) -> Command {
+    let fd = namespace.as_raw_fd();
+    let mut command = Command::new("/bin/managed");
+    command
+        .args(["--management", "--network-namespace-fd", "3"])
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::inherit());
+    unsafe {
+        command.pre_exec(move || {
+            if libc::dup2(fd, 3) < 0 || libc::fcntl(3, libc::F_SETFD, 0) < 0 {
+                return Err(std::io::Error::last_os_error());
+            }
+            Ok(())
+        });
+    }
+    command
+}
+
+struct NativeOwner {
+    child: Child,
+    messages: Receiver<Value>,
+    reader: Option<JoinHandle<()>>,
+}
+impl NativeOwner {
+    fn start(namespace: &File) -> Self {
+        let mut child = command(namespace).spawn().unwrap();
+        let output = child.stdout.take().unwrap();
+        let (send, messages) = mpsc::channel();
+        let reader = thread::spawn(move || {
+            for line in BufReader::new(output.take(1024 * 1024)).lines() {
+                let Ok(line) = line else { break };
+                if line.len() > 262_144 {
+                    break;
+                }
+                let Ok(value) = serde_json::from_str(&line) else {
+                    break;
+                };
+                if send.send(value).is_err() {
+                    break;
+                }
+            }
+        });
+        let owner = Self {
+            child,
+            messages,
+            reader: Some(reader),
+        };
+        assert_eq!(
+            owner.messages.recv_timeout(Duration::from_secs(5)).unwrap()["event"],
+            "ready"
+        );
+        owner
+    }
+    fn response(&mut self, method: &str, params: Value) -> Value {
+        writeln!(
+            self.child.stdin.as_mut().unwrap(),
+            "{}",
+            json!({"id":method,"method":method,"params":params})
+        )
+        .unwrap();
+        let response = self.messages.recv_timeout(Duration::from_secs(5)).unwrap();
+        assert_eq!(response["id"], method);
+        response
+    }
+    fn call(&mut self, method: &str, params: Value) -> Value {
+        let response = self.response(method, params);
+        assert_eq!(response["success"], true, "{response}");
+        response["result"].clone()
+    }
+}
+impl Drop for NativeOwner {
+    fn drop(&mut self) {
+        let _ = self.child.kill();
+        let _ = self.child.wait();
+        if let Some(reader) = self.reader.take() {
+            let _ = reader.join();
+        }
+    }
+}
+
+#[test]
+#[ignore = "requires the explicitly isolated QEMU qualification guest"]
+fn inherited_namespace_binds_policy_and_persistent_recovery() {
+    isolated();
+    ip(&["netns", "add", "fdtarget"]);
+    let namespace = File::open("/run/netns/fdtarget").unwrap();
+    let metadata = namespace.metadata().unwrap();
+    let initial = fs::metadata("/proc/thread-self/ns/net").unwrap();
+    assert_ne!(metadata.ino(), initial.ino());
+    let mut child = NativeOwner::start(&namespace);
+    let pid = child.child.id();
+    let status = child.call("openOwner", serde_json::to_value(options("nsfd")).unwrap());
+    assert_eq!(
+        status["identity"]["namespaceDevice"],
+        metadata.dev().to_string()
+    );
+    assert_eq!(
+        status["identity"]["namespaceInode"],
+        metadata.ino().to_string()
+    );
+    assert_eq!(
+        fs::read_dir(format!("/proc/{pid}/task")).unwrap().count(),
+        1
+    );
+    let target_link = fs::read_link(format!("/proc/{pid}/ns/net")).unwrap();
+    for fd in fs::read_dir(format!("/proc/{pid}/fd")).unwrap() {
+        if let Ok(target) = fs::read_link(fd.unwrap().path()) {
+            assert_ne!(
+                target, target_link,
+                "child namespace descriptor must be closed"
+            );
+        }
+    }
+    let first = child.call(
+        "reconcilePolicy",
+        serde_json::to_value(Transition {
+            previous: None,
+            target: empty(1),
+        })
+        .unwrap(),
+    );
+    assert!(Owner::new(options("nsfd"))
+        .unwrap()
+        .graph()
+        .unwrap()
+        .is_none());
+    assert!(in_namespace("fdtarget", || Owner::new(options("nsfd"))
+        .unwrap()
+        .graph()
+        .unwrap()
+        .is_some()));
+    assert_eq!(
+        unsafe { libc::ioctl(namespace.as_raw_fd(), libc::NS_GET_NSTYPE) },
+        libc::CLONE_NEWNET
+    );
+    drop(child); // PERSIST must retain the target graph after native process loss.
+    assert!(!std::path::Path::new(&format!("/proc/{pid}")).exists());
+    assert!(in_namespace("fdtarget", || Owner::new(options("nsfd"))
+        .unwrap()
+        .graph()
+        .unwrap()
+        .is_some()));
+
+    let previous: Applied = serde_json::from_value(first).unwrap();
+    let transition = serde_json::to_value(Transition {
+        previous: Some(previous),
+        target: empty(2),
+    })
+    .unwrap();
+    let wrong_namespace = File::open("/proc/thread-self/ns/net").unwrap();
+    let mut wrong = NativeOwner::start(&wrong_namespace);
+    wrong.call("openOwner", serde_json::to_value(options("nsfd")).unwrap());
+    let denied = wrong.response("reconcilePolicy", transition.clone());
+    assert_eq!(denied["success"], false);
+    assert_eq!(denied["errorCode"], "CONFLICT");
+    assert!(Owner::new(options("nsfd"))
+        .unwrap()
+        .graph()
+        .unwrap()
+        .is_none());
+    drop(wrong);
+    assert!(in_namespace("fdtarget", || Owner::new(options("nsfd"))
+        .unwrap()
+        .graph()
+        .unwrap()
+        .is_some()));
+
+    let mut recovered = NativeOwner::start(&namespace);
+    recovered.call("openOwner", serde_json::to_value(options("nsfd")).unwrap());
+    drop(namespace); // The entered child keeps membership; caller capability is not consumed by it.
+    let applied = recovered.call("reconcilePolicy", transition);
+    assert_eq!(applied["receipt"]["revision"], 2);
+    assert_eq!(
+        applied["receipt"]["identity"]["namespaceInode"],
+        metadata.ino().to_string()
+    );
+    assert_eq!(recovered.call("inspectPolicy", json!({}))["enforced"], true);
+    assert_eq!(recovered.call("closeOwner", json!({}))["released"], true);
+    drop(recovered);
+    assert!(in_namespace("fdtarget", || Owner::new(options("nsfd"))
+        .unwrap()
+        .graph()
+        .unwrap()
+        .is_none()));
+    assert!(Owner::new(options("nsfd"))
+        .unwrap()
+        .graph()
+        .unwrap()
+        .is_none());
+    assert_eq!(
+        fs::metadata("/proc/thread-self/ns/net").unwrap().ino(),
+        initial.ino()
+    );
+    ip(&["netns", "delete", "fdtarget"]);
+}
+
+#[test]
+#[ignore = "requires the explicitly isolated QEMU qualification guest"]
+fn valid_descriptor_without_entry_permission_never_becomes_ready() {
+    isolated();
+    let namespace = File::open("/proc/thread-self/ns/net").unwrap();
+    let mut child = command(&namespace)
+        .uid(65534)
+        .gid(65534)
+        .stdin(Stdio::null())
+        .stderr(Stdio::piped())
+        .spawn()
+        .unwrap();
+    let deadline = Instant::now() + Duration::from_secs(5);
+    while child.try_wait().unwrap().is_none() {
+        if Instant::now() >= deadline {
+            let _ = child.kill();
+            let _ = child.wait();
+            panic!("denied namespace entry did not exit");
+        }
+        thread::sleep(Duration::from_millis(10));
+    }
+    let output = child.wait_with_output().unwrap();
+    assert_eq!(output.status.code(), Some(1));
+    assert!(output.stdout.is_empty());
+    assert!(String::from_utf8(output.stderr)
+        .unwrap()
+        .contains("network namespace entry failed"));
+    assert_eq!(
+        unsafe { libc::ioctl(namespace.as_raw_fd(), libc::NS_GET_NSTYPE) },
+        libc::CLONE_NEWNET
+    );
+}

package/rust/src/owner_tests.rs

@@ -1,5 +1,8 @@
 use super::*;
 
+#[path = "owner_namespace_tests.rs"]
+mod namespace_tests;
+
 fn isolated() {
     assert_eq!(
         std::env::var("SMARTNFTABLES_ISOLATED_NATIVE").as_deref(),

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartnftables',
-  version: '1.3.1',
+  version: '1.4.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

@@ -53,12 +53,15 @@ export class ManagedNftables {
 
   constructor(options: IManagedNftOptions) {
     this.#options = snapshot(options);
-    if (Object.keys(this.#options).some((key) => !['ownerId', 'instanceId', 'tableName', 'binaryPath'].includes(key))
+    if (Object.keys(this.#options).some((key) => !['ownerId', 'instanceId', 'tableName', 'binaryPath', 'networkNamespaceFd'].includes(key))
       || ![this.#options.ownerId, this.#options.instanceId, this.#options.tableName].every((value) => typeof value === 'string' && /^[A-Za-z0-9_-]{1,64}$/.test(value))
       || this.#options.instanceId.length < 16 || !this.#options.tableName.startsWith('snft_')
       || this.#options.binaryPath !== undefined && (!plugins.path.isAbsolute(this.#options.binaryPath) || this.#options.binaryPath.includes('\0'))) {
       throw new ManagedNftablesError('INVALID');
     }
+    if (this.#options.networkNamespaceFd !== undefined && (process.platform !== 'linux'
+      || !Number.isInteger(this.#options.networkNamespaceFd) || this.#options.networkNamespaceFd < 0
+      || this.#options.networkNamespaceFd > 0x7fff_ffff)) throw new ManagedNftablesError('INVALID');
   }
 
   public get state(): string { return this.#state; }
@@ -73,7 +76,9 @@ export class ManagedNftables {
       this.#bridge = new plugins.smartrust.RustBridge<TManagedNftCommands>({
         binaryName: 'smartnftables', binaryPath: this.#options.binaryPath
           ?? plugins.path.join(root, 'dist_rust', `smartnftables_linux_${process.arch === 'x64' ? 'amd64' : 'arm64'}_musl`),
-        localPaths: [], searchSystemPath: false, cliArgs: ['--management'],
+        localPaths: [], searchSystemPath: false,
+        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 },
       });

package/ts/managed.types.ts

@@ -75,11 +75,15 @@ export interface IManagedNftOptions {
   tableName: string;
   /** Explicit executable selection for qualified distributions and isolated tests. */
   binaryPath?: string;
+  /** Linux network namespace descriptor, owned by the caller and valid through start().
+   * The native process enters before readiness or netlink activity. Keep a namespace
+   * owner alive for policy lifetime and recovery; this process option is not durable authority. */
+  networkNamespaceFd?: number;
 }
 
 export type TManagedNftCommands = {
   preparePolicy: { params: IManagedNftPolicy; result: IPreparedManagedNftPolicy };
-  openOwner: { params: Omit<IManagedNftOptions, 'binaryPath'>; result: IManagedNftStatus };
+  openOwner: { params: Pick<IManagedNftOptions, 'ownerId' | 'instanceId' | 'tableName'>; result: IManagedNftStatus };
   reconcilePolicy: { params: IManagedNftTransition; result: IAppliedManagedNftPolicy };
   inspectPolicy: { params: Record<string, never>; result: IManagedNftStatus };
   releasePolicy: { params: IAppliedManagedNftPolicy; result: { released: true } };