@push.rocks/smartnftables 1.2.0 → 1.3.1

package/changelog.md

@@ -1,5 +1,42 @@
 # Changelog
 
+## 2026-09-09 - 1.3.1
+
+### Fixes
+
+- rename managed policy hints document (docs)
+  - Moves managed policy implementation guidance from readme.hints.md to hints.md without content changes.
+
+## 2026-09-09 - 1.3.0
+
+### Features
+
+- add native managed nftables policy engine (managednftables)
+  - Export ManagedNftables, ManagedNftablesError, and managed policy types from the TypeScript entrypoint.
+  - Implement a Rust management binary for policy preparation, reconciliation, inspection, release, and cleanup.
+  - Bridge the TypeScript manager to the native binary with bounded IPC payloads and serialized request admission.
+  - Add Node and isolated native qualification tests for managed policy behavior.
+  - Integrate Rust targets into the build and published package contents.
+
+### Fixes
+
+- update package publishing configuration and toolchain versions (package)
+  - Add publish metadata for native executable artifacts
+  - Update release preflight configuration and development tool versions
+  - Clarify close and release cleanup semantics in documentation
+- bump @git.zone/tstest to 5.0.0 (dev-deps)
+  - Updates the @git.zone/tstest dev dependency from 4.1.1 to 5.0.0.
+
+## 2026-07-31 - 1.2.1
+
+### Fixes
+
+- normalize command execution and firewall rule generation (nft)
+  - Preserve quoted values and escaped semicolons when executing nft commands.
+  - Default port-only firewall rules to TCP and use meta l4proto for protocol-only rules.
+  - Escape rule comments so generated nft commands remain parseable.
+  - Update tests, documentation, release configuration, and package tooling dependencies.
+
 ## 2026-04-26 - 1.2.0 - feat(firewall)
 add IP set blocking convenience API with CIDR interval support and optional rule comments
 
@@ -22,4 +59,4 @@ no changes to commit
 ## 2026-03-26 - 1.0.0 - project
 Initial release.
 
-- Project initialized with first commit.
+- Project initialized with first commit.

package/dist_rust/smartnftables_linux_amd64_musl.tsrust-build.json

@@ -0,0 +1,14 @@
+{
+  "format": "tsrust.build-provenance.v2",
+  "binarySha256": "ca5b8c77de7f91f0027f95f1a83e54a3b41af724ca7e0e2f49f422538c628687",
+  "buildInfo": {
+    "projectName": "@push.rocks/smartnftables",
+    "projectVersion": "1.3.1",
+    "gitCommit": "454e4d4c44300f5ca67c3afd9d4507040ed674be",
+    "gitDirty": false,
+    "builtAt": "2026-09-09T13:04:41.744Z",
+    "tsrustVersion": "1.13.0",
+    "binary": "smartnftables",
+    "target": "linux_amd64_musl"
+  }
+}

package/dist_rust/smartnftables_linux_arm64_musl.tsrust-build.json

@@ -0,0 +1,14 @@
+{
+  "format": "tsrust.build-provenance.v2",
+  "binarySha256": "65913ced75089fa08d77913b22aa13f8ad2804d1e742aeca749ff23a6aeca4d7",
+  "buildInfo": {
+    "projectName": "@push.rocks/smartnftables",
+    "projectVersion": "1.3.1",
+    "gitCommit": "454e4d4c44300f5ca67c3afd9d4507040ed674be",
+    "gitDirty": false,
+    "builtAt": "2026-09-09T13:04:41.873Z",
+    "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.2.0',
+    version: '1.3.1',
     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

@@ -0,0 +1,21 @@
+import type { IManagedNftOptions, IManagedNftPolicy, IManagedNftTransition, IAppliedManagedNftPolicy, IPreparedManagedNftPolicy, IManagedNftStatus } from './managed.types.js';
+export declare class ManagedNftablesError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+/** One private native/netlink owner. Persistence and workload link lifetimes belong to its caller. */
+export declare class ManagedNftables {
+    #private;
+    constructor(options: IManagedNftOptions);
+    get state(): string;
+    /** Starts only the compiler/IPC owner. The returned idle status is not enforcement. */
+    start(): Promise<IManagedNftStatus>;
+    prepare(policy: IManagedNftPolicy): Promise<IPreparedManagedNftPolicy>;
+    reconcile(transition: IManagedNftTransition): Promise<IAppliedManagedNftPolicy>;
+    inspect(): Promise<IManagedNftStatus>;
+    release(expected: IAppliedManagedNftPolicy): Promise<{
+        released: true;
+    }>;
+    /** Join policy operations and owned-table deletion, then native termination; packet/allocation fencing belongs to the caller. */
+    close(): Promise<void>;
+}

package/dist_ts/classes.managednftables.js

@@ -0,0 +1,176 @@
+import * as plugins from './plugins.js';
+export class ManagedNftablesError extends Error {
+    constructor(code) {
+        super(`Managed nftables ${code}.`);
+        this.code = code;
+    }
+}
+/** Capture inert input without evaluating getters, proxies, coercions or toJSON. */
+function snapshot(input) {
+    let count = 0;
+    let stringBytes = 0;
+    const string = (value) => {
+        if (value.length > 240_000 || (stringBytes += Buffer.byteLength(value)) > 240_000)
+            throw new ManagedNftablesError('INVALID');
+        return value;
+    };
+    const copy = (value, depth) => {
+        if (++count > 16_384 || depth > 20)
+            throw new ManagedNftablesError('INVALID');
+        if (typeof value === 'string')
+            return string(value);
+        if (value === null || typeof value === 'boolean')
+            return value;
+        if (typeof value === 'number' && Number.isSafeInteger(value))
+            return value;
+        if (typeof value !== 'object' || plugins.util.types.isProxy(value))
+            throw new ManagedNftablesError('INVALID');
+        const array = Array.isArray(value);
+        if (Object.getPrototypeOf(value) !== (array ? Array.prototype : Object.prototype))
+            throw new ManagedNftablesError('INVALID');
+        const keys = Reflect.ownKeys(value);
+        if (keys.length > 16_384 - count)
+            throw new ManagedNftablesError('INVALID');
+        for (const key of keys)
+            if (typeof key === 'string')
+                string(key);
+        const descriptors = Object.getOwnPropertyDescriptors(value);
+        const result = array ? [] : {};
+        if (array && keys.length !== value.length + 1)
+            throw new ManagedNftablesError('INVALID');
+        for (const key of keys) {
+            if (array && key === 'length')
+                continue;
+            const descriptor = descriptors[key];
+            if (typeof key !== 'string' || !descriptor.enumerable || !('value' in descriptor)
+                || array && !/^(0|[1-9][0-9]*)$/.test(key))
+                throw new ManagedNftablesError('INVALID');
+            Object.defineProperty(result, key, { value: copy(descriptor.value, depth + 1), enumerable: true, configurable: true, writable: true });
+        }
+        return result;
+    };
+    const result = copy(input, 0);
+    if (Buffer.byteLength(JSON.stringify(result)) > 240_000)
+        throw new ManagedNftablesError('INVALID');
+    return result;
+}
+/** One private native/netlink owner. Persistence and workload link lifetimes belong to its caller. */
+export class ManagedNftables {
+    #options;
+    #bridge = null;
+    #state = 'new';
+    #work = null;
+    #close = null;
+    #nativeMayOwn = false;
+    constructor(options) {
+        this.#options = snapshot(options);
+        if (Object.keys(this.#options).some((key) => !['ownerId', 'instanceId', 'tableName', 'binaryPath'].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');
+        }
+    }
+    get state() { return this.#state; }
+    /** Starts only the compiler/IPC owner. The returned idle status is not enforcement. */
+    start() {
+        if (this.#state !== 'new')
+            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');
+            const root = plugins.url.fileURLToPath(new URL('../', import.meta.url));
+            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'],
+                readyTimeoutMs: 3000, requestTimeoutMs: 30_000, maxPayloadSize: 262_144,
+                maxPendingRequestsByMethod: { preparePolicy: 1, openOwner: 1, reconcilePolicy: 1, inspectPolicy: 1, releasePolicy: 1, closeOwner: 1 },
+            });
+            this.#bridge.on('exit', () => {
+                if (!['closing', 'stopped'].includes(this.#state))
+                    this.#state = 'failed-owned';
+            });
+            if (!await this.#bridge.spawn())
+                throw new ManagedNftablesError('UNAVAILABLE');
+            const { ownerId, instanceId, tableName } = this.#options;
+            const status = snapshot(await this.#bridge.sendCommand('openOwner', { ownerId, instanceId, tableName }));
+            if (this.#state !== 'starting')
+                throw new ManagedNftablesError('UNAVAILABLE');
+            this.#state = 'ready';
+            return status;
+        })();
+        return this.#track(work);
+    }
+    prepare(policy) {
+        return this.#invoke('preparePolicy', policy);
+    }
+    reconcile(transition) {
+        return this.#invoke('reconcilePolicy', transition);
+    }
+    inspect() { return this.#invoke('inspectPolicy', {}); }
+    release(expected) {
+        return this.#invoke('releasePolicy', expected);
+    }
+    /** Join policy operations and owned-table deletion, then native termination; packet/allocation fencing belongs to the caller. */
+    close() {
+        if (this.#close)
+            return this.#close;
+        if (this.#state === 'stopped')
+            return Promise.resolve();
+        this.#state = 'closing';
+        this.#close = (async () => {
+            await this.#work?.catch(() => undefined);
+            if (this.#bridge) {
+                if (this.#nativeMayOwn) {
+                    const result = await this.#bridge.sendCommand('closeOwner', {});
+                    if (result.released !== true)
+                        throw new ManagedNftablesError('PROTOCOL');
+                }
+                await this.#bridge.terminate({ gracePeriodMs: 1000 });
+            }
+            this.#bridge = null;
+            this.#state = 'stopped';
+        })().catch(() => {
+            this.#state = 'failed-owned';
+            this.#close = null;
+            throw new ManagedNftablesError('CLEANUP_UNCONFIRMED');
+        });
+        return this.#close;
+    }
+    #invoke(method, params) {
+        if (!['ready', 'failed-owned'].includes(this.#state) || !this.#bridge || this.#work)
+            return Promise.reject(new ManagedNftablesError('UNAVAILABLE'));
+        let captured;
+        try {
+            captured = snapshot(params);
+        }
+        catch {
+            return Promise.reject(new ManagedNftablesError('INVALID'));
+        }
+        if (method === 'reconcilePolicy' || method === 'releasePolicy')
+            this.#nativeMayOwn = true;
+        return this.#track(this.#bridge.sendCommand(method, captured).then((result) => {
+            const capturedResult = snapshot(result);
+            if (method === 'releasePolicy')
+                this.#nativeMayOwn = false;
+            if (this.#state !== 'closing' && (method === 'reconcilePolicy' || method === 'releasePolicy'
+                || method === 'inspectPolicy' && capturedResult.error === null))
+                this.#state = 'ready';
+            return capturedResult;
+        }));
+    }
+    #track(work) {
+        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');
+        });
+        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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"}

package/dist_ts/index.d.ts

@@ -1,4 +1,6 @@
 export { SmartNftables } from './nft.manager.js';
+export { ManagedNftables, ManagedNftablesError } from './classes.managednftables.js';
+export type * from './managed.types.js';
 export { NatManager } from './nft.manager.nat.js';
 export { FirewallManager } from './nft.manager.firewall.js';
 export { RateLimitManager } from './nft.manager.ratelimit.js';

package/dist_ts/index.js

@@ -1,5 +1,6 @@
 // Main facade
 export { SmartNftables } from './nft.manager.js';
+export { ManagedNftables, ManagedNftablesError } from './classes.managednftables.js';
 // Sub-managers
 export { NatManager } from './nft.manager.nat.js';
 export { FirewallManager } from './nft.manager.firewall.js';
@@ -11,4 +12,4 @@ export { buildTableSetup, buildFilterChains, buildTableCleanup, } from './nft.ru
 export { buildDnatRules, buildSnatRule, buildMasqueradeRule, } from './nft.rulebuilder.nat.js';
 export { buildRateLimitRule, buildPerIpRateLimitRule, buildConnectionRateRule, } from './nft.rulebuilder.ratelimit.js';
 export { buildFirewallRule, buildIPSetCreate, buildIPSetAddElements, buildIPSetRemoveElements, buildIPSetDelete, buildIPSetMatchRule, } from './nft.rulebuilder.firewall.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjO0FBQ2QsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRWpELGVBQWU7QUFDZixPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDbEQsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQzVELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBRTlELFdBQVc7QUFDWCxPQUFPLEVBQUUsV0FBVyxFQUFFLGVBQWUsRUFBRSxlQUFlLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUVsRixxQ0FBcUM7QUFDckMsT0FBTyxFQUNMLGVBQWUsRUFDZixpQkFBaUIsRUFDakIsaUJBQWlCLEdBQ2xCLE1BQU0sNEJBQTRCLENBQUM7QUFFcEMsT0FBTyxFQUNMLGNBQWMsRUFDZCxhQUFhLEVBQ2IsbUJBQW1CLEdBQ3BCLE1BQU0sMEJBQTBCLENBQUM7QUFFbEMsT0FBTyxFQUNMLGtCQUFrQixFQUNsQix1QkFBdUIsRUFDdkIsdUJBQXVCLEdBQ3hCLE1BQU0sZ0NBQWdDLENBQUM7QUFFeEMsT0FBTyxFQUNMLGlCQUFpQixFQUNqQixnQkFBZ0IsRUFDaEIscUJBQXFCLEVBQ3JCLHdCQUF3QixFQUN4QixnQkFBZ0IsRUFDaEIsbUJBQW1CLEdBQ3BCLE1BQU0sK0JBQStCLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjO0FBQ2QsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ2pELE9BQU8sRUFBRSxlQUFlLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUdyRixlQUFlO0FBQ2YsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ2xELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUM1RCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUU5RCxXQUFXO0FBQ1gsT0FBTyxFQUFFLFdBQVcsRUFBRSxlQUFlLEVBQUUsZUFBZSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFbEYscUNBQXFDO0FBQ3JDLE9BQU8sRUFDTCxlQUFlLEVBQ2YsaUJBQWlCLEVBQ2pCLGlCQUFpQixHQUNsQixNQUFNLDRCQUE0QixDQUFDO0FBRXBDLE9BQU8sRUFDTCxjQUFjLEVBQ2QsYUFBYSxFQUNiLG1CQUFtQixHQUNwQixNQUFNLDBCQUEwQixDQUFDO0FBRWxDLE9BQU8sRUFDTCxrQkFBa0IsRUFDbEIsdUJBQXVCLEVBQ3ZCLHVCQUF1QixHQUN4QixNQUFNLGdDQUFnQyxDQUFDO0FBRXhDLE9BQU8sRUFDTCxpQkFBaUIsRUFDakIsZ0JBQWdCLEVBQ2hCLHFCQUFxQixFQUNyQix3QkFBd0IsRUFDeEIsZ0JBQWdCLEVBQ2hCLG1CQUFtQixHQUNwQixNQUFNLCtCQUErQixDQUFDIn0=

package/dist_ts/managed.types.d.ts

@@ -0,0 +1,99 @@
+/** The caller owns these workload links and keeps them disabled until apply is confirmed. */
+export interface IManagedNftEndpoint {
+    id: string;
+    interfaceIndex: number;
+    interfaceName: string;
+    /** Routed, unbridged veth or L3 TUN; TAP/bridge/uplink interfaces reject. */
+    interfaceKind: 'veth' | 'tun';
+    sourcePrefixes: string[];
+}
+/** Null selects the actual local host (input/output only), never an unbound forwarding side. */
+export interface IManagedNftRule {
+    sourceEndpoint: string | null;
+    destinationEndpoint: string | null;
+    sourcePrefix: string;
+    destinationPrefix: string;
+    protocol: 'any' | 'tcp' | 'udp';
+    sourcePort: number | null;
+    destinationPort: number | null;
+}
+export interface IManagedNftPolicy {
+    schemaVersion: 1;
+    revision: number;
+    endpoints: IManagedNftEndpoint[];
+    rules: IManagedNftRule[];
+}
+export interface IPreparedManagedNftPolicy {
+    policy: IManagedNftPolicy;
+    digest: string;
+}
+export interface IManagedNftIdentity {
+    ownerId: string;
+    instanceId: string;
+    tableName: string;
+    bootId: string;
+    namespaceDevice: string;
+    namespaceInode: string;
+}
+export interface IManagedNftReceipt {
+    identity: IManagedNftIdentity;
+    tableHandle: string;
+    revision: number;
+    digest: string;
+}
+export interface IAppliedManagedNftPolicy {
+    receipt: IManagedNftReceipt;
+    prepared: IPreparedManagedNftPolicy;
+}
+/** Persist this complete command before reconcile, then retain its complete result. */
+export interface IManagedNftTransition {
+    previous: IAppliedManagedNftPolicy | null;
+    target: IPreparedManagedNftPolicy;
+}
+export interface IManagedNftStatus {
+    identity: IManagedNftIdentity;
+    state: 'idle' | 'applied' | 'failed-owned' | 'released';
+    enforced: boolean;
+    applied: IAppliedManagedNftPolicy | null;
+    pending: IManagedNftTransition | null;
+    error: string | null;
+}
+export interface IManagedNftOptions {
+    ownerId: string;
+    /** Caller-retained unique operation identity, at least 16 identifier characters. */
+    instanceId: string;
+    /** Dedicated name beginning snft_; existing foreign tables always reject. */
+    tableName: string;
+    /** Explicit executable selection for qualified distributions and isolated tests. */
+    binaryPath?: string;
+}
+export type TManagedNftCommands = {
+    preparePolicy: {
+        params: IManagedNftPolicy;
+        result: IPreparedManagedNftPolicy;
+    };
+    openOwner: {
+        params: Omit<IManagedNftOptions, 'binaryPath'>;
+        result: IManagedNftStatus;
+    };
+    reconcilePolicy: {
+        params: IManagedNftTransition;
+        result: IAppliedManagedNftPolicy;
+    };
+    inspectPolicy: {
+        params: Record<string, never>;
+        result: IManagedNftStatus;
+    };
+    releasePolicy: {
+        params: IAppliedManagedNftPolicy;
+        result: {
+            released: true;
+        };
+    };
+    closeOwner: {
+        params: Record<string, never>;
+        result: {
+            released: true;
+        };
+    };
+};

package/dist_ts/managed.types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFuYWdlZC50eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL21hbmFnZWQudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist_ts/nft.executor.d.ts

@@ -1,3 +1,4 @@
+export declare function normalizeNftCommand(command: string): string;
 export declare class NftNotRootError extends Error {
     constructor();
 }

package/dist_ts/nft.executor.js

@@ -1,5 +1,68 @@
 import * as plugins from './plugins.js';
 const execFile = plugins.util.promisify(plugins.childProcess.execFile);
+export function normalizeNftCommand(command) {
+    let input = command.trim();
+    if (!input) {
+        throw new Error('Invalid nft command: command is empty');
+    }
+    if (input === 'nft') {
+        throw new Error('Invalid nft command: command is empty');
+    }
+    if (/^nft\s/.test(input)) {
+        input = input.slice(3).trimStart();
+    }
+    let normalized = '';
+    let quote;
+    for (let index = 0; index < input.length; index++) {
+        const character = input[index];
+        if (quote === 'single') {
+            normalized += character;
+            if (character === "'") {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (quote === 'double') {
+            normalized += character;
+            if (character === '"') {
+                quote = undefined;
+                continue;
+            }
+            if (character === '\\') {
+                const nextCharacter = input[index + 1];
+                if (nextCharacter === undefined) {
+                    throw new Error('Invalid nft command: trailing escape in double-quoted string');
+                }
+                normalized += nextCharacter;
+                index++;
+                continue;
+            }
+            continue;
+        }
+        if (character === "'") {
+            quote = 'single';
+        }
+        else if (character === '"') {
+            quote = 'double';
+        }
+        else if (character === '\\') {
+            const nextCharacter = input[index + 1];
+            if (nextCharacter === undefined) {
+                throw new Error('Invalid nft command: trailing escape');
+            }
+            if (nextCharacter === ';') {
+                normalized += ';';
+                index++;
+                continue;
+            }
+        }
+        normalized += character;
+    }
+    if (quote) {
+        throw new Error(`Invalid nft command: unterminated ${quote}-quoted string`);
+    }
+    return normalized;
+}
 export class NftNotRootError extends Error {
     constructor() {
         super('Not running as root — nftables commands require root privileges');
@@ -31,12 +94,11 @@ export class NftExecutor {
      * Returns stdout on success.
      */
     async exec(command) {
+        const normalizedCommand = normalizeNftCommand(command);
         if (this.dryRun) {
             return '';
         }
-        // Strip "nft " prefix if present
-        const args = command.startsWith('nft ') ? command.slice(4) : command;
-        const { stdout } = await execFile('nft', args.split(/\s+/));
+        const { stdout } = await execFile('nft', [normalizedCommand]);
         return stdout;
     }
     /**
@@ -56,4 +118,4 @@ export class NftExecutor {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmZ0LmV4ZWN1dG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvbmZ0LmV4ZWN1dG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBRXhDLE1BQU0sUUFBUSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FBQyxZQUFZLENBQUMsUUFBUSxDQUFDLENBQUM7QUFFdkUsTUFBTSxPQUFPLGVBQWdCLFNBQVEsS0FBSztJQUN4QztRQUNFLEtBQUssQ0FBQyxpRUFBaUUsQ0FBQyxDQUFDO1FBQ3pFLElBQUksQ0FBQyxJQUFJLEdBQUcsaUJBQWlCLENBQUM7SUFDaEMsQ0FBQztDQUNGO0FBRUQsTUFBTSxPQUFPLGVBQWdCLFNBQVEsS0FBSztJQUl4QyxZQUFZLE9BQWUsRUFBRSxNQUFjO1FBQ3pDLEtBQUssQ0FBQyx1QkFBdUIsT0FBTyxNQUFNLE1BQU0sRUFBRSxDQUFDLENBQUM7UUFDcEQsSUFBSSxDQUFDLElBQUksR0FBRyxpQkFBaUIsQ0FBQztRQUM5QixJQUFJLENBQUMsT0FBTyxHQUFHLE9BQU8sQ0FBQztRQUN2QixJQUFJLENBQUMsTUFBTSxHQUFHLE1BQU0sQ0FBQztJQUN2QixDQUFDO0NBQ0Y7QUFFRDs7R0FFRztBQUNILE1BQU0sT0FBTyxXQUFXO0lBR3RCLFlBQVksT0FBOEI7UUFDeEMsSUFBSSxDQUFDLE1BQU0sR0FBRyxPQUFPLEVBQUUsTUFBTSxJQUFJLEtBQUssQ0FBQztJQUN6QyxDQUFDO0lBRUQseUNBQXlDO0lBQ2xDLE1BQU07UUFDWCxPQUFPLE9BQU8sQ0FBQyxNQUFNLEVBQUUsRUFBRSxLQUFLLENBQUMsQ0FBQztJQUNsQyxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNJLEtBQUssQ0FBQyxJQUFJLENBQUMsT0FBZTtRQUMvQixJQUFJLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQztZQUNoQixPQUFPLEVBQUUsQ0FBQztRQUNaLENBQUM7UUFFRCxpQ0FBaUM7UUFDakMsTUFBTSxJQUFJLEdBQUcsT0FBTyxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDO1FBRXJFLE1BQU0sRUFBRSxNQUFNLEVBQUUsR0FBRyxNQUFNLFFBQVEsQ0FBQyxLQUFLLEVBQUUsSUFBSSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO1FBQzVELE9BQU8sTUFBTSxDQUFDO0lBQ2hCLENBQUM7SUFFRDs7O09BR0c7SUFDSSxLQUFLLENBQUMsU0FBUyxDQUNwQixRQUFrQixFQUNsQixPQUF1QztRQUV2QyxLQUFLLE1BQU0sR0FBRyxJQUFJLFFBQVEsRUFBRSxDQUFDO1lBQzNCLElBQUksQ0FBQztnQkFDSCxNQUFNLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7WUFDdkIsQ0FBQztZQUFDLE9BQU8sR0FBRyxFQUFFLENBQUM7Z0JBQ2IsSUFBSSxDQUFDLE9BQU8sRUFBRSxlQUFlLEVBQUUsQ0FBQztvQkFDOUIsTUFBTSxHQUFHLENBQUM7Z0JBQ1osQ0FBQztZQUNILENBQUM7UUFDSCxDQUFDO0lBQ0gsQ0FBQztDQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,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