@cleocode/cant 2026.4.5 → 2026.4.6

package/dist/document.d.ts

@@ -0,0 +1,103 @@
+/**
+ * High-level CANT document API.
+ *
+ * @remarks
+ * Replaces the standalone `cant-cli` Rust binary that was previously
+ * spawned by `cleo cant`. All operations now run in-process via the
+ * cant-napi binding, avoiding subprocess overhead and shared-binary
+ * lookup logic.
+ *
+ * The functions here return plain TypeScript values (no LAFS envelope)
+ * so that callers can wrap them in whatever response shape they need.
+ * The CLEO CLI uses `cliOutput` for envelope formatting.
+ */
+import { type NativeDiagnostic, type NativeParseError, type NativePipelineResult } from './native-loader';
+/** The kind of section to enumerate via {@link listSections}. */
+export type SectionKind = 'agent' | 'pipeline' | 'workflow';
+/** Result of {@link parseDocument}. */
+export interface CantDocumentResult {
+    /** The file path that was parsed. */
+    file: string;
+    /** Whether parsing succeeded. */
+    success: boolean;
+    /** The parsed document AST as a JSON-compatible object (null on failure). */
+    document: unknown;
+    /** Parse errors (empty when `success` is true). */
+    errors: NativeParseError[];
+}
+/** Result of {@link validateDocument}. */
+export interface CantValidationResult {
+    /** The file path that was validated. */
+    file: string;
+    /** Whether validation passed (no errors; warnings allowed). */
+    valid: boolean;
+    /** Total diagnostic count. */
+    total: number;
+    /** Number of error-severity diagnostics. */
+    errorCount: number;
+    /** Number of warning-severity diagnostics. */
+    warningCount: number;
+    /** All diagnostics emitted by the 42-rule validator. */
+    diagnostics: NativeDiagnostic[];
+}
+/** Result of {@link listSections}. */
+export interface CantListResult {
+    /** The file path that was inspected. */
+    file: string;
+    /** The section filter that was applied. */
+    filter: SectionKind;
+    /** Number of matching sections. */
+    count: number;
+    /** Names of the matching sections (in source order). */
+    names: string[];
+}
+/** Result of {@link executePipeline}. */
+export interface CantPipelineResult {
+    /** The file path that was executed. */
+    file: string;
+    /** The pipeline name that was requested. */
+    pipeline: string;
+    /** Whether the pipeline ran to completion with all steps succeeding. */
+    success: boolean;
+    /** Total wall-clock duration in milliseconds. */
+    durationMs: number;
+    /** Per-step results in execution order. */
+    steps: NativePipelineResult['steps'];
+    /** Optional error message describing why the pipeline did not run. */
+    error?: string | null;
+}
+/**
+ * Parse a `.cant` file and return its AST.
+ *
+ * @param filePath - Absolute path to the `.cant` file.
+ * @returns A {@link CantDocumentResult} with either the AST or parse errors.
+ */
+export declare function parseDocument(filePath: string): Promise<CantDocumentResult>;
+/**
+ * Validate a `.cant` file using the 42-rule validation engine.
+ *
+ * @param filePath - Absolute path to the `.cant` file.
+ * @returns A {@link CantValidationResult} with all diagnostics.
+ */
+export declare function validateDocument(filePath: string): Promise<CantValidationResult>;
+/**
+ * Enumerate the agents, pipelines, or workflows defined in a `.cant` file.
+ *
+ * @param filePath - Absolute path to the `.cant` file.
+ * @param kind - Which section type to enumerate (default: `"agent"`).
+ * @returns A {@link CantListResult} with the matching section names.
+ */
+export declare function listSections(filePath: string, kind?: SectionKind): Promise<CantListResult>;
+/**
+ * Execute a deterministic pipeline from a `.cant` file via the Rust runtime.
+ *
+ * @remarks
+ * Wraps the napi-rs `cantExecutePipeline` async export. Logical failures
+ * (file not found, parse errors, missing pipeline, runtime errors) are
+ * surfaced via the `success: false` + `error` fields rather than thrown.
+ *
+ * @param filePath - Absolute path to the `.cant` file.
+ * @param pipelineName - The name of the `pipeline { ... }` block to execute.
+ * @returns A {@link CantPipelineResult} describing the pipeline outcome.
+ */
+export declare function executePipeline(filePath: string, pipelineName: string): Promise<CantPipelineResult>;

package/dist/document.js

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * High-level CANT document API.
+ *
+ * @remarks
+ * Replaces the standalone `cant-cli` Rust binary that was previously
+ * spawned by `cleo cant`. All operations now run in-process via the
+ * cant-napi binding, avoiding subprocess overhead and shared-binary
+ * lookup logic.
+ *
+ * The functions here return plain TypeScript values (no LAFS envelope)
+ * so that callers can wrap them in whatever response shape they need.
+ * The CLEO CLI uses `cliOutput` for envelope formatting.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDocument = parseDocument;
+exports.validateDocument = validateDocument;
+exports.listSections = listSections;
+exports.executePipeline = executePipeline;
+const promises_1 = require("node:fs/promises");
+const native_loader_1 = require("./native-loader");
+/**
+ * Parse a `.cant` file and return its AST.
+ *
+ * @param filePath - Absolute path to the `.cant` file.
+ * @returns A {@link CantDocumentResult} with either the AST or parse errors.
+ */
+async function parseDocument(filePath) {
+    const content = await (0, promises_1.readFile)(filePath, 'utf-8');
+    const result = (0, native_loader_1.cantParseDocumentNative)(content);
+    return {
+        file: filePath,
+        success: result.success,
+        document: result.document ?? null,
+        errors: result.errors,
+    };
+}
+/**
+ * Validate a `.cant` file using the 42-rule validation engine.
+ *
+ * @param filePath - Absolute path to the `.cant` file.
+ * @returns A {@link CantValidationResult} with all diagnostics.
+ */
+async function validateDocument(filePath) {
+    const content = await (0, promises_1.readFile)(filePath, 'utf-8');
+    const result = (0, native_loader_1.cantValidateDocumentNative)(content);
+    return {
+        file: filePath,
+        valid: result.valid,
+        total: result.total,
+        errorCount: result.errorCount,
+        warningCount: result.warningCount,
+        diagnostics: result.diagnostics,
+    };
+}
+/**
+ * Enumerate the agents, pipelines, or workflows defined in a `.cant` file.
+ *
+ * @param filePath - Absolute path to the `.cant` file.
+ * @param kind - Which section type to enumerate (default: `"agent"`).
+ * @returns A {@link CantListResult} with the matching section names.
+ */
+async function listSections(filePath, kind = 'agent') {
+    const content = await (0, promises_1.readFile)(filePath, 'utf-8');
+    const parsed = (0, native_loader_1.cantParseDocumentNative)(content);
+    if (!parsed.success || parsed.document == null) {
+        return { file: filePath, filter: kind, count: 0, names: [] };
+    }
+    const doc = parsed.document;
+    const sections = Array.isArray(doc.sections) ? doc.sections : [];
+    const names = [];
+    for (const section of sections) {
+        if (typeof section !== 'object' || section === null)
+            continue;
+        const wrapper = section;
+        const inner = wrapper[capitalize(kind)];
+        if (!inner)
+            continue;
+        const nameField = inner['name'];
+        if (typeof nameField === 'object' && nameField !== null) {
+            const value = nameField['value'];
+            if (typeof value === 'string')
+                names.push(value);
+        }
+        else if (typeof nameField === 'string') {
+            names.push(nameField);
+        }
+    }
+    return { file: filePath, filter: kind, count: names.length, names };
+}
+/**
+ * Execute a deterministic pipeline from a `.cant` file via the Rust runtime.
+ *
+ * @remarks
+ * Wraps the napi-rs `cantExecutePipeline` async export. Logical failures
+ * (file not found, parse errors, missing pipeline, runtime errors) are
+ * surfaced via the `success: false` + `error` fields rather than thrown.
+ *
+ * @param filePath - Absolute path to the `.cant` file.
+ * @param pipelineName - The name of the `pipeline { ... }` block to execute.
+ * @returns A {@link CantPipelineResult} describing the pipeline outcome.
+ */
+async function executePipeline(filePath, pipelineName) {
+    const result = await (0, native_loader_1.cantExecutePipelineNative)(filePath, pipelineName);
+    return {
+        file: filePath,
+        pipeline: pipelineName,
+        success: result.success,
+        durationMs: result.durationMs,
+        steps: result.steps,
+        error: result.error ?? null,
+    };
+}
+/** Capitalize the first character of a string (used for AST section keys). */
+function capitalize(s) {
+    return s.length === 0 ? s : s[0].toUpperCase() + s.slice(1);
+}

package/dist/index.d.ts

@@ -1,7 +1,10 @@
-export type { LAFSEnvelope, LAFSError, LAFSMeta, MVILevel, } from '@cleocode/lafs';
+export type { LAFSEnvelope, LAFSError, LAFSMeta, MVILevel } from '@cleocode/lafs';
+export type { CantDocumentResult, CantListResult, CantPipelineResult, CantValidationResult, SectionKind, } from './document';
+export { executePipeline, listSections, parseDocument, validateDocument, } from './document';
 export type { ConvertedFile, MigrationOptions, MigrationResult, UnconvertedSection, } from './migrate/index';
 export { migrateMarkdown, serializeCantDocument, showDiff, showSummary } from './migrate/index';
-export { initWasm, isNativeAvailable, isWasmAvailable } from './native-loader';
+export type { NativeDiagnostic, NativeParseDocumentResult, NativeParseError, NativeParseResult, NativePipelineResult, NativePipelineStep, NativeValidateResult, } from './native-loader';
+export { cantClassifyDirectiveNative, cantExecutePipelineNative, cantExtractAgentProfilesNative, cantParseDocumentNative, cantParseNative, cantValidateDocumentNative, initWasm, isNativeAvailable, isWasmAvailable, } from './native-loader';
 export type { ParsedCANTMessage } from './parse';
 export { initCantParser, parseCANTMessage } from './parse';
 export type { DirectiveType } from './types';

package/dist/index.js

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseCANTMessage = exports.initCantParser = exports.isWasmAvailable = exports.isNativeAvailable = exports.initWasm = exports.showSummary = exports.showDiff = exports.serializeCantDocument = exports.migrateMarkdown = void 0;
+exports.parseCANTMessage = exports.initCantParser = exports.isWasmAvailable = exports.isNativeAvailable = exports.initWasm = exports.cantValidateDocumentNative = exports.cantParseNative = exports.cantParseDocumentNative = exports.cantExtractAgentProfilesNative = exports.cantExecutePipelineNative = exports.cantClassifyDirectiveNative = exports.showSummary = exports.showDiff = exports.serializeCantDocument = exports.migrateMarkdown = exports.validateDocument = exports.parseDocument = exports.listSections = exports.executePipeline = void 0;
+// High-level API (replaces standalone cant-cli binary)
+var document_1 = require("./document");
+Object.defineProperty(exports, "executePipeline", { enumerable: true, get: function () { return document_1.executePipeline; } });
+Object.defineProperty(exports, "listSections", { enumerable: true, get: function () { return document_1.listSections; } });
+Object.defineProperty(exports, "parseDocument", { enumerable: true, get: function () { return document_1.parseDocument; } });
+Object.defineProperty(exports, "validateDocument", { enumerable: true, get: function () { return document_1.validateDocument; } });
 // Migration engine
 var index_1 = require("./migrate/index");
 Object.defineProperty(exports, "migrateMarkdown", { enumerable: true, get: function () { return index_1.migrateMarkdown; } });
@@ -9,6 +15,12 @@ Object.defineProperty(exports, "showDiff", { enumerable: true, get: function ()
 Object.defineProperty(exports, "showSummary", { enumerable: true, get: function () { return index_1.showSummary; } });
 // Native loader (replaces wasm-loader)
 var native_loader_1 = require("./native-loader");
+Object.defineProperty(exports, "cantClassifyDirectiveNative", { enumerable: true, get: function () { return native_loader_1.cantClassifyDirectiveNative; } });
+Object.defineProperty(exports, "cantExecutePipelineNative", { enumerable: true, get: function () { return native_loader_1.cantExecutePipelineNative; } });
+Object.defineProperty(exports, "cantExtractAgentProfilesNative", { enumerable: true, get: function () { return native_loader_1.cantExtractAgentProfilesNative; } });
+Object.defineProperty(exports, "cantParseDocumentNative", { enumerable: true, get: function () { return native_loader_1.cantParseDocumentNative; } });
+Object.defineProperty(exports, "cantParseNative", { enumerable: true, get: function () { return native_loader_1.cantParseNative; } });
+Object.defineProperty(exports, "cantValidateDocumentNative", { enumerable: true, get: function () { return native_loader_1.cantValidateDocumentNative; } });
 Object.defineProperty(exports, "initWasm", { enumerable: true, get: function () { return native_loader_1.initWasm; } });
 Object.defineProperty(exports, "isNativeAvailable", { enumerable: true, get: function () { return native_loader_1.isNativeAvailable; } });
 Object.defineProperty(exports, "isWasmAvailable", { enumerable: true, get: function () { return native_loader_1.isWasmAvailable; } });

package/dist/native-loader.d.ts

@@ -1,32 +1,160 @@
 /**
- * Native addon loader for cant-core via napi-rs
+ * Native addon loader for cant-core via napi-rs.
  *
- * Loads the napi-rs native addon synchronously. Falls back gracefully
- * if the native addon is not available (e.g., unsupported platform).
+ * @remarks
+ * Loads the napi-rs native addon synchronously on first use. Tries the
+ * package-local binary first (`packages/cant/napi/cant.linux-x64-gnu.node`),
+ * then falls back to the workspace `cant-napi` crate's `index.cjs` for
+ * dev-mode builds where the package binary may not be present yet.
  *
- * Replaces the previous wasm-loader.ts which used async WASM initialization.
+ * Replaces the previous WASM loader. Follows the same pattern as
+ * `packages/lafs/src/native-loader.ts`.
  */
-/**
- * Check if the native addon is available
- */
-export declare function isNativeAvailable(): boolean;
-/** Shape returned by the native Rust WASM cantParse function. */
+/** Shape of a parsed CANT message returned by the native binding. */
 export interface NativeParseResult {
+    /** The directive verb if present (e.g., `"done"`), or `undefined`. */
     directive?: string;
+    /** The classification of the directive as a lowercase string. */
     directiveType?: string;
+    /** All `@`-addresses found in the message, without the `@` prefix. */
     addresses?: string[];
+    /** All task references found in the message, including the `T` prefix. */
     taskRefs?: string[];
+    /** All `#`-tags found in the message, without the `#` prefix. */
     tags?: string[];
+    /** The raw text of the first line (the header). */
     headerRaw?: string;
+    /** Everything after the first newline (the body). */
     body?: string;
 }
+/** A parse error from document parsing, exposed by the native binding. */
+export interface NativeParseError {
+    /** Human-readable error message. */
+    message: string;
+    /** Line number (1-based) where the error occurred. */
+    line: number;
+    /** Column number (1-based) where the error occurred. */
+    col: number;
+    /** Byte offset of the error start. */
+    start: number;
+    /** Byte offset of the error end. */
+    end: number;
+    /** Severity: "error" or "warning". */
+    severity: string;
+}
+/** Result of parsing a `.cant` document via the native binding. */
+export interface NativeParseDocumentResult {
+    /** Whether parsing succeeded. */
+    success: boolean;
+    /** Parsed AST as a JSON-compatible object (null if parsing failed). */
+    document: unknown;
+    /** Parse errors (empty if parsing succeeded). */
+    errors: NativeParseError[];
+}
+/** A validation diagnostic from the 42-rule validation engine. */
+export interface NativeDiagnostic {
+    /** The rule ID (e.g., "S01", "P06", "W08"). */
+    ruleId: string;
+    /** Human-readable diagnostic message. */
+    message: string;
+    /** Severity: "error", "warning", "info", or "hint". */
+    severity: string;
+    /** Line number (1-based). */
+    line: number;
+    /** Column number (1-based). */
+    col: number;
+}
+/** Result of validating a `.cant` document via the native binding. */
+export interface NativeValidateResult {
+    /** Whether validation passed (no errors; warnings allowed). */
+    valid: boolean;
+    /** Total number of diagnostics. */
+    total: number;
+    /** Number of errors. */
+    errorCount: number;
+    /** Number of warnings. */
+    warningCount: number;
+    /** All diagnostics from the validation engine. */
+    diagnostics: NativeDiagnostic[];
+}
+/** A single step result from a pipeline run via the native binding. */
+export interface NativePipelineStep {
+    /** The step name from the pipeline definition. */
+    name: string;
+    /** Subprocess exit code (0 = success). */
+    exitCode: number;
+    /** Length in bytes of captured stdout. */
+    stdoutLen: number;
+    /** Length in bytes of captured stderr. */
+    stderrLen: number;
+    /** Wall-clock duration of the step in milliseconds. */
+    durationMs: number;
+    /** Whether the step was skipped due to a condition. */
+    skipped: boolean;
+}
+/** The aggregate result of a pipeline run via the native binding. */
+export interface NativePipelineResult {
+    /** The pipeline name. */
+    name: string;
+    /** Whether all steps completed with exit code 0. */
+    success: boolean;
+    /** Total wall-clock duration in milliseconds. */
+    durationMs: number;
+    /** Per-step results in execution order. */
+    steps: NativePipelineStep[];
+    /** Optional error message describing why the pipeline did not run. */
+    error?: string | null;
+}
 /**
- * Parse a CANT message using the native addon
+ * Check if the native addon is available.
+ *
+ * @returns `true` if the native Rust binding loaded successfully.
+ */
+export declare function isNativeAvailable(): boolean;
+/**
+ * Parse a CANT message using the native addon.
+ *
+ * @param content - The CANT message content to parse.
  */
 export declare function cantParseNative(content: string): NativeParseResult;
 /**
- * Classify a directive using the native addon
+ * Classify a directive verb using the native addon.
+ *
+ * @param verb - The directive verb to classify.
  */
 export declare function cantClassifyDirectiveNative(verb: string): string;
+/**
+ * Parse a `.cant` document via the native addon (Layer 2/3).
+ *
+ * @param content - The raw `.cant` file content to parse.
+ */
+export declare function cantParseDocumentNative(content: string): NativeParseDocumentResult;
+/**
+ * Parse and validate a `.cant` document via the native addon (42 rules).
+ *
+ * @param content - The raw `.cant` file content to parse and validate.
+ */
+export declare function cantValidateDocumentNative(content: string): NativeValidateResult;
+/**
+ * Extract agent profiles from a `.cant` document via the native addon.
+ *
+ * @param content - The raw `.cant` file content.
+ */
+export declare function cantExtractAgentProfilesNative(content: string): unknown[];
+/**
+ * Execute a deterministic pipeline from a `.cant` file via the native addon.
+ *
+ * @param filePath - Absolute or relative path to a `.cant` file.
+ * @param pipelineName - The name of the `pipeline { ... }` block to run.
+ */
+export declare function cantExecutePipelineNative(filePath: string, pipelineName: string): Promise<NativePipelineResult>;
 export declare const isWasmAvailable: typeof isNativeAvailable;
+/**
+ * Backward-compatible no-op initializer.
+ *
+ * @remarks
+ * The previous WASM loader required an async `init()` call. With napi-rs
+ * the binding loads synchronously, so this exists only to keep older
+ * callers (e.g. test fixtures) compiling without changes.
+ */
 export declare const initWasm: () => Promise<void>;

package/dist/native-loader.js

@@ -1,17 +1,27 @@
 "use strict";
 /**
- * Native addon loader for cant-core via napi-rs
+ * Native addon loader for cant-core via napi-rs.
  *
- * Loads the napi-rs native addon synchronously. Falls back gracefully
- * if the native addon is not available (e.g., unsupported platform).
+ * @remarks
+ * Loads the napi-rs native addon synchronously on first use. Tries the
+ * package-local binary first (`packages/cant/napi/cant.linux-x64-gnu.node`),
+ * then falls back to the workspace `cant-napi` crate's `index.cjs` for
+ * dev-mode builds where the package binary may not be present yet.
  *
- * Replaces the previous wasm-loader.ts which used async WASM initialization.
+ * Replaces the previous WASM loader. Follows the same pattern as
+ * `packages/lafs/src/native-loader.ts`.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initWasm = exports.isWasmAvailable = void 0;
 exports.isNativeAvailable = isNativeAvailable;
 exports.cantParseNative = cantParseNative;
 exports.cantClassifyDirectiveNative = cantClassifyDirectiveNative;
+exports.cantParseDocumentNative = cantParseDocumentNative;
+exports.cantValidateDocumentNative = cantValidateDocumentNative;
+exports.cantExtractAgentProfilesNative = cantExtractAgentProfilesNative;
+exports.cantExecutePipelineNative = cantExecutePipelineNative;
+/* eslint-disable @typescript-eslint/no-require-imports */
+const node_path_1 = require("node:path");
 let nativeModule = null;
 let loadAttempted = false;
 /**
@@ -22,51 +32,106 @@ function ensureLoaded() {
     if (loadAttempted)
         return;
     loadAttempted = true;
+    // The compiled file lives at packages/cant/dist/native-loader.js, so
+    // ../napi resolves to packages/cant/napi/cant.linux-x64-gnu.node.
+    const packageBinary = (0, node_path_1.join)(__dirname, '..', 'napi', 'cant.linux-x64-gnu.node');
     try {
-        // Try loading the napi-rs native addon
-        // The package name will be @cleocode/cant-native once published
-        nativeModule = require('@cleocode/cant-native');
+        nativeModule = require(packageBinary);
+        return;
+    }
+    catch {
+        // Fall through to workspace dev fallback.
+    }
+    try {
+        // Development fallback: load via the cant-napi crate's index.cjs.
+        // From packages/cant/dist/ -> ../../../crates/cant-napi/index.cjs.
+        nativeModule = require('../../../crates/cant-napi/index.cjs');
     }
     catch {
-        try {
-            // Development fallback: try loading from the crate build output
-            nativeModule = require('../../crates/cant-napi');
-        }
-        catch {
-            // Native addon not available — JS fallback will be used
-            nativeModule = null;
-        }
+        nativeModule = null;
     }
 }
 /**
- * Check if the native addon is available
+ * Check if the native addon is available.
+ *
+ * @returns `true` if the native Rust binding loaded successfully.
  */
 function isNativeAvailable() {
     ensureLoaded();
     return nativeModule !== null;
 }
 /**
- * Parse a CANT message using the native addon
+ * Get the native module, throwing if it failed to load.
+ *
+ * @internal
+ * @throws Error when the native addon could not be loaded.
  */
-function cantParseNative(content) {
+function requireNative() {
     ensureLoaded();
     if (!nativeModule) {
-        throw new Error('Native addon not available.');
+        throw new Error('cant-napi native addon not available. Build it with: cargo build --release -p cant-napi');
     }
-    return nativeModule.cantParse(content);
+    return nativeModule;
+}
+/**
+ * Parse a CANT message using the native addon.
+ *
+ * @param content - The CANT message content to parse.
+ */
+function cantParseNative(content) {
+    return requireNative().cantParse(content);
 }
 /**
- * Classify a directive using the native addon
+ * Classify a directive verb using the native addon.
+ *
+ * @param verb - The directive verb to classify.
  */
 function cantClassifyDirectiveNative(verb) {
-    ensureLoaded();
-    if (!nativeModule) {
-        throw new Error('Native addon not available.');
-    }
-    return nativeModule.cantClassifyDirective(verb);
+    return requireNative().cantClassifyDirective(verb);
+}
+/**
+ * Parse a `.cant` document via the native addon (Layer 2/3).
+ *
+ * @param content - The raw `.cant` file content to parse.
+ */
+function cantParseDocumentNative(content) {
+    return requireNative().cantParseDocument(content);
+}
+/**
+ * Parse and validate a `.cant` document via the native addon (42 rules).
+ *
+ * @param content - The raw `.cant` file content to parse and validate.
+ */
+function cantValidateDocumentNative(content) {
+    return requireNative().cantValidateDocument(content);
+}
+/**
+ * Extract agent profiles from a `.cant` document via the native addon.
+ *
+ * @param content - The raw `.cant` file content.
+ */
+function cantExtractAgentProfilesNative(content) {
+    return requireNative().cantExtractAgentProfiles(content);
 }
-// Backward compatibility aliases
+/**
+ * Execute a deterministic pipeline from a `.cant` file via the native addon.
+ *
+ * @param filePath - Absolute or relative path to a `.cant` file.
+ * @param pipelineName - The name of the `pipeline { ... }` block to run.
+ */
+function cantExecutePipelineNative(filePath, pipelineName) {
+    return requireNative().cantExecutePipeline(filePath, pipelineName);
+}
+// Backward compatibility aliases (kept so existing callers compile).
 exports.isWasmAvailable = isNativeAvailable;
+/**
+ * Backward-compatible no-op initializer.
+ *
+ * @remarks
+ * The previous WASM loader required an async `init()` call. With napi-rs
+ * the binding loads synchronously, so this exists only to keep older
+ * callers (e.g. test fixtures) compiling without changes.
+ */
 const initWasm = async () => {
     ensureLoaded();
 };

package/package.json

@@ -1,27 +1,39 @@
 {
   "name": "@cleocode/cant",
-  "version": "2026.4.5",
-  "description": "CANT protocol parser and interpreter for CLEO - wraps cant-core WASM",
+  "version": "2026.4.6",
+  "description": "CANT protocol parser and runtime for CLEO — wraps cant-core via napi-rs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
     "dist/",
-    "wasm/"
+    "napi/"
   ],
   "dependencies": {
-    "@cleocode/contracts": "2026.4.5",
-    "@cleocode/lafs": "2026.4.5"
+    "@cleocode/contracts": "2026.4.6",
+    "@cleocode/lafs": "2026.4.6"
   },
   "devDependencies": {
     "typescript": "^5.0.0",
     "vitest": "^1.0.0"
   },
+  "napi": {
+    "name": "cant",
+    "package": {
+      "name": "@cleocode/cant"
+    },
+    "triples": {
+      "defaults": false,
+      "additional": [
+        "x86_64-unknown-linux-gnu"
+      ]
+    }
+  },
   "keywords": [
     "cleo",
     "cant",
     "agent",
     "parser",
-    "wasm"
+    "napi-rs"
   ],
   "license": "MIT",
   "repository": {
@@ -34,7 +46,7 @@
   },
   "scripts": {
     "build": "tsc",
-    "build:wasm": "cd ../../crates/cant-core && wasm-pack build --target web --features wasm --out-dir ../../packages/cant/wasm",
+    "build:napi": "cargo build --release -p cant-napi && mkdir -p napi && cp ../../target/release/libcant_napi.so napi/cant.linux-x64-gnu.node",
     "test": "vitest run",
     "test:watch": "vitest"
   }

package/dist/wasm-loader.d.ts

@@ -1,27 +0,0 @@
-/**
- * WASM loader for cant-core
- *
- * Loads the WASM module and provides access to CANT parsing functions
- */
-/** Shape of the CANT WASM module exports. */
-type CantWasmModule = typeof import('../wasm/cant_core');
-declare let wasmModule: CantWasmModule | null;
-/**
- * Initialize the WASM module
- * Must be called before using any WASM functions
- */
-export declare function initWasm(): Promise<void>;
-/**
- * Check if WASM is available
- */
-export declare function isWasmAvailable(): boolean;
-/**
- * Parse a CANT message using WASM
- */
-export declare function cantParseWASM(content: string): unknown;
-/**
- * Classify a directive using WASM
- */
-export declare function cantClassifyDirectiveWASM(verb: string): string;
-export type { CantWasmModule };
-export { wasmModule };

package/dist/wasm-loader.js

@@ -1,100 +0,0 @@
-"use strict";
-/**
- * WASM loader for cant-core
- *
- * Loads the WASM module and provides access to CANT parsing functions
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.wasmModule = void 0;
-exports.initWasm = initWasm;
-exports.isWasmAvailable = isWasmAvailable;
-exports.cantParseWASM = cantParseWASM;
-exports.cantClassifyDirectiveWASM = cantClassifyDirectiveWASM;
-// Dynamic import of the WASM module
-let wasmModule = null;
-exports.wasmModule = wasmModule;
-let isInitializing = false;
-let initPromise = null;
-/**
- * Initialize the WASM module
- * Must be called before using any WASM functions
- */
-async function initWasm() {
-    if (wasmModule)
-        return;
-    if (isInitializing) {
-        return initPromise;
-    }
-    isInitializing = true;
-    initPromise = (async () => {
-        try {
-            // Try to load the WASM module
-            const wasm = await Promise.resolve().then(() => __importStar(require('../wasm/cant_core.js')));
-            await wasm.default();
-            exports.wasmModule = wasmModule = wasm;
-        }
-        catch (_error) {
-            console.warn('WASM module not available, falling back to stub implementation');
-            exports.wasmModule = wasmModule = null;
-        }
-    })();
-    await initPromise;
-    isInitializing = false;
-}
-/**
- * Check if WASM is available
- */
-function isWasmAvailable() {
-    return wasmModule !== null;
-}
-/**
- * Parse a CANT message using WASM
- */
-function cantParseWASM(content) {
-    if (!wasmModule) {
-        throw new Error('WASM not initialized. Call initWasm() first.');
-    }
-    return wasmModule.cant_parse(content);
-}
-/**
- * Classify a directive using WASM
- */
-function cantClassifyDirectiveWASM(verb) {
-    if (!wasmModule) {
-        throw new Error('WASM not initialized. Call initWasm() first.');
-    }
-    return wasmModule.cant_classify_directive(verb);
-}