@kya-os/checkpoint-wasm-runtime 1.1.1 → 1.1.3

package/dist/edge.d.ts

@@ -1,6 +1,533 @@
-import { I as IDetectorOptions, a as IDetector, d as IDetectionInput } from './rules-detector-DjbTJ1-Q.js';
-export { C as CONFIDENCE, D as DetectionClass, F as ForgeabilityRisk, b as ICustomerPolicy, c as IDetectedAgent, e as IDetectionResult, g as IPolicyLoader, i as IWasmLoader, j as PolicyLoader, R as RulesDetector, V as VerificationMethod, W as WasmDetector, l as createPolicyLoader, m as createRulesDetector } from './rules-detector-DjbTJ1-Q.js';
-export { S as StaticWasmLoader, c as createStaticLoader } from './static-loader-C1hUlksK.js';
+/**
+ * AgentShield WASM Runtime Types
+ *
+ * Core interfaces following SOLID principles:
+ * - Interface Segregation: Small, focused interfaces
+ * - Dependency Inversion: Depend on abstractions
+ */
+/**
+ * Detection input - information about the request to analyze
+ */
+interface IDetectionInput {
+    /** User-Agent header value */
+    userAgent?: string;
+    /** Client IP address */
+    ipAddress?: string;
+    /** All request headers */
+    headers: Record<string, string>;
+    /** Request URL path */
+    url?: string;
+    /** HTTP method (GET, POST, etc.) */
+    method?: string;
+    /** Client fingerprint data (for browser detection) */
+    clientFingerprint?: string;
+    /** Request timestamp */
+    timestamp?: Date;
+}
+/**
+ * Verification method used to detect the agent
+ */
+type VerificationMethod = 'signature' | 'pattern' | 'behavioral' | 'network' | 'mcp_i_handshake' | 'none';
+/**
+ * Detection class - categorization of the detected entity
+ */
+type DetectionClass = {
+    type: 'Human';
+} | {
+    type: 'AiAgent';
+    agentType: string;
+} | {
+    type: 'Bot';
+    botType?: string;
+} | {
+    type: 'Automation';
+    toolType?: string;
+} | {
+    type: 'Unknown';
+};
+/**
+ * Forgeability risk level
+ * How easy it is to spoof the detection signals
+ */
+type ForgeabilityRisk = 'low' | 'medium' | 'high';
+/**
+ * Detected agent information
+ */
+interface IDetectedAgent {
+    /** Agent type identifier (e.g., 'openai', 'anthropic') */
+    type: string;
+    /** Human-readable agent name (e.g., 'ChatGPT', 'Claude') */
+    name: string;
+    /** Vendor/company name */
+    vendor?: string;
+    /** Model identifier if known */
+    model?: string;
+    /** Version if known */
+    version?: string;
+}
+/**
+ * Detection result - output from the detection engine
+ * Confidence is ALWAYS on 0-100 scale
+ */
+interface IDetectionResult {
+    /** Whether the request was identified as coming from an agent */
+    isAgent: boolean;
+    /** Confidence score on 0-100 scale (NOT 0-1) */
+    confidence: number;
+    /** Detection classification */
+    detectionClass: DetectionClass;
+    /** Detected agent details if identified */
+    detectedAgent?: IDetectedAgent;
+    /** Method used for verification */
+    verificationMethod: VerificationMethod;
+    /** Risk level of signal forgeability */
+    forgeabilityRisk: ForgeabilityRisk;
+    /** Reasons/signals that contributed to detection */
+    reasons: string[];
+    /** Detection timestamp */
+    timestamp: Date;
+    /** Whether the request should be blocked (set by policy) */
+    shouldBlock?: boolean;
+    /** Reason for blocking (set by policy) */
+    blockReason?: string;
+}
+/**
+ * WASM bindings interface - functions exposed by the WASM module
+ */
+interface IWasmBindings {
+    /** Detect an agent from request metadata */
+    detect_agent(metadata: IWasmRequestMetadata): IWasmDetectionResult;
+    /** Get WASM module version */
+    get_version(): string;
+    /** Get build information */
+    get_build_info(): string;
+}
+/**
+ * WASM request metadata - input to WASM detect_agent function
+ */
+interface IWasmRequestMetadata {
+    user_agent: string | null;
+    ip_address: string | null;
+    headers: string;
+    timestamp: string;
+    url: string | null;
+    method: string | null;
+    client_fingerprint: string | null;
+    free(): void;
+}
+/**
+ * WASM detection result - output from WASM detect_agent function
+ */
+interface IWasmDetectionResult {
+    is_agent: boolean;
+    confidence: number;
+    agent: string | null;
+    verification_method: string;
+    risk_level: string;
+    timestamp: string;
+}
+/**
+ * WASM loader interface - abstracts WASM loading strategy
+ */
+interface IWasmLoader {
+    /** Load the WASM module */
+    load(): Promise<void>;
+    /** Get the WASM bindings after loading */
+    getBindings(): IWasmBindings;
+    /** Check if WASM is loaded */
+    isLoaded(): boolean;
+    /** Get the loading strategy name */
+    getStrategy(): string;
+}
+/**
+ * Agent detector interface - main detection API
+ */
+interface IDetector {
+    /** Analyze a request and detect if it's from an agent */
+    detect(input: IDetectionInput): Promise<IDetectionResult>;
+    /** Check if the detector is ready */
+    isReady(): boolean;
+    /** Ensure the detector is initialized */
+    ensureReady(): Promise<void>;
+    /** Get detector version */
+    getVersion(): Promise<string>;
+}
+/**
+ * Customer policy - rules for agent handling
+ */
+interface ICustomerPolicy {
+    /** Project ID */
+    projectId: string;
+    /** Agents to always block */
+    denyList?: string[];
+    /** Agents to always allow (if set, blocks all others) */
+    allowList?: string[];
+    /** Minimum confidence to trigger blocking */
+    blockThreshold?: number;
+    /** Path-based rules */
+    pathRules?: IPathRule[];
+    /** Policy version for cache invalidation */
+    version?: string;
+    /** Last updated timestamp */
+    updatedAt?: Date;
+}
+/**
+ * Path-based rule for policy
+ */
+interface IPathRule {
+    /** Path pattern (glob or regex) */
+    pattern: string;
+    /** Action for matching paths */
+    action: 'allow' | 'block' | 'challenge';
+    /** Specific agents this rule applies to */
+    agents?: string[];
+}
+/**
+ * Policy loader interface - loads customer policies
+ */
+interface IPolicyLoader {
+    /** Load policy for an API key */
+    loadPolicy(apiKey: string): Promise<ICustomerPolicy>;
+    /** Get cached policy if available */
+    getCachedPolicy(apiKey: string): ICustomerPolicy | null;
+    /** Invalidate cached policy */
+    invalidateCache(apiKey: string): void;
+}
+/**
+ * Detector configuration options
+ */
+interface IDetectorOptions {
+    /** API key for loading customer policies */
+    apiKey?: string;
+    /** Custom WASM loader (for Edge Runtime static imports) */
+    wasmLoader?: IWasmLoader;
+    /** Whether to fall back to JavaScript if WASM fails */
+    fallbackToJS?: boolean;
+    /** Whether to cache policies */
+    cachePolicy?: boolean;
+    /** Policy cache TTL in milliseconds */
+    policyTTL?: number;
+    /** Base URL for policy API */
+    policyApiUrl?: string;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/**
+ * Confidence thresholds - centralized constants
+ */
+declare const CONFIDENCE: {
+    /** Minimum confidence for isAgent=true */
+    readonly THRESHOLD_AGENT: 30;
+    /** Cryptographic signature verified */
+    readonly SIGNATURE_VERIFIED: 100;
+    /** Signature header present but not verified */
+    readonly SIGNATURE_PRESENT: 85;
+    /** Strong pattern match */
+    readonly PATTERN_HIGH: 85;
+    /** Moderate pattern match */
+    readonly PATTERN_MEDIUM: 60;
+    /** Weak pattern match */
+    readonly PATTERN_LOW: 40;
+    /** Cloud IP detection only */
+    readonly CLOUD_IP: 30;
+};
+
+/**
+ * Unified WASM Detector
+ *
+ * Single implementation of the AgentShield detection engine used by all packages.
+ * Follows the Single Responsibility Principle: this class only handles detection.
+ *
+ * Key design decisions:
+ * - Confidence is ALWAYS on 0-100 scale (no conversions needed)
+ * - WASM output is used directly (no post-processing adjustments)
+ * - Policy application is optional and happens after detection
+ */
+
+/**
+ * Unified WASM Detector
+ *
+ * Main detection class that wraps the WASM engine and provides
+ * a consistent interface across all AgentShield packages.
+ */
+declare class WasmDetector implements IDetector {
+    private readonly loader;
+    private readonly policyLoader?;
+    private readonly options;
+    private ready;
+    private loadPromise;
+    /**
+     * Create a new WasmDetector
+     * @param loader - WASM loader (static for Edge, dynamic for Node.js)
+     * @param policyLoader - Optional policy loader for API key support
+     * @param options - Detector configuration options
+     */
+    constructor(loader: IWasmLoader, policyLoader?: IPolicyLoader | undefined, options?: IDetectorOptions);
+    /**
+     * Analyze a request and detect if it's from an agent
+     */
+    detect(input: IDetectionInput): Promise<IDetectionResult>;
+    /**
+     * Check if the detector is ready
+     */
+    isReady(): boolean;
+    /**
+     * Ensure the detector is initialized
+     */
+    ensureReady(): Promise<void>;
+    /**
+     * Get detector version
+     */
+    getVersion(): Promise<string>;
+    /**
+     * Initialize the detector
+     */
+    private initialize;
+    /**
+     * Apply customer policy to detection result
+     */
+    private applyPolicy;
+    /**
+     * Check if agent name matches a policy list entry
+     * Uses exact match or word-boundary prefix match to avoid false positives
+     * e.g., "gpt" matches "ChatGPT" and "GPT-4" but not "EgyptBot"
+     */
+    private matchesPolicyEntry;
+    /**
+     * Escape special regex characters in a string
+     */
+    private escapeRegex;
+    /**
+     * Apply policy rules to detection result
+     */
+    private applyPolicyRules;
+    /**
+     * Infer agent type from name
+     */
+    private inferAgentType;
+    /**
+     * Extract reasons from WASM result
+     */
+    private extractReasons;
+    /**
+     * Create default result (assumed human)
+     */
+    private createDefaultResult;
+}
+
+/**
+ * Static WASM Loader for Edge Runtime
+ *
+ * This loader is designed for environments that require static WASM imports,
+ * such as Vercel Edge Runtime and Cloudflare Workers.
+ *
+ * Usage:
+ * ```typescript
+ * // In your middleware.ts:
+ * import wasmModule from '@kya-os/checkpoint-wasm-runtime/wasm?module';
+ * import { StaticWasmLoader, WasmDetector } from '@kya-os/checkpoint-wasm-runtime/edge';
+ *
+ * const loader = new StaticWasmLoader(wasmModule);
+ * const detector = new WasmDetector(loader);
+ * ```
+ *
+ * The `?module` suffix tells bundlers (webpack, esbuild) to import the WASM
+ * as a pre-compiled WebAssembly.Module, which is required for Edge Runtime.
+ */
+
+/**
+ * Static WASM Loader
+ *
+ * For Edge Runtime environments that require pre-compiled WASM modules.
+ * The consumer must provide the WASM module via a static import with `?module` suffix.
+ *
+ * This loader uses the wasm-bindgen generated JS glue code to properly
+ * initialize the WASM module with all required imports.
+ */
+declare class StaticWasmLoader implements IWasmLoader {
+    private readonly wasmModule;
+    private bindings;
+    private loadPromise;
+    private wasmExports;
+    /**
+     * Create a new StaticWasmLoader
+     * @param wasmModule - Pre-compiled WebAssembly.Module from static import
+     */
+    constructor(wasmModule: WebAssembly.Module);
+    /**
+     * Load and instantiate the WASM module
+     */
+    load(): Promise<void>;
+    /**
+     * Internal load implementation using wasm-bindgen initSync
+     */
+    private doLoad;
+    /**
+     * Get the WASM bindings after loading
+     */
+    getBindings(): IWasmBindings;
+    /**
+     * Check if WASM is loaded
+     */
+    isLoaded(): boolean;
+    /**
+     * Get the loading strategy name
+     */
+    getStrategy(): string;
+    /**
+     * Create bindings wrapper using wasm-bindgen exports
+     */
+    private createBindings;
+}
+/**
+ * Create a static loader with validation
+ */
+declare function createStaticLoader(wasmModule: WebAssembly.Module): StaticWasmLoader;
+
+/**
+ * Policy Loader
+ *
+ * Loads customer policies from the AgentShield API.
+ * Supports LRU caching with background refresh.
+ */
+
+/**
+ * Policy loader configuration
+ */
+interface PolicyLoaderConfig {
+    /** Base URL for the policy API */
+    apiUrl?: string;
+    /** Cache TTL in milliseconds (default: 5 minutes) */
+    cacheTTL?: number;
+    /** Maximum number of policies to cache (default: 100) */
+    maxCacheSize?: number;
+    /** Enable background refresh (default: true) */
+    backgroundRefresh?: boolean;
+    /** Timeout for API requests in milliseconds (default: 5000) */
+    timeout?: number;
+}
+/**
+ * Policy Loader
+ *
+ * Loads and caches customer policies from the AgentShield API.
+ * Follows Single Responsibility Principle: only handles policy loading.
+ */
+declare class PolicyLoader implements IPolicyLoader {
+    private cache;
+    private config;
+    constructor(config?: PolicyLoaderConfig);
+    /**
+     * Load policy for an API key
+     */
+    loadPolicy(apiKey: string): Promise<ICustomerPolicy>;
+    /**
+     * Get cached policy if available and not expired
+     */
+    getCachedPolicy(apiKey: string): ICustomerPolicy | null;
+    /**
+     * Invalidate cached policy
+     */
+    invalidateCache(apiKey: string): void;
+    /**
+     * Fetch policy from API and cache it
+     */
+    private fetchPolicy;
+    /**
+     * Fetch policy from API without caching
+     * Used internally for both direct fetches and background refreshes
+     */
+    private fetchPolicyFromApi;
+    /**
+     * Cache a policy
+     */
+    private cachePolicy;
+    /**
+     * Check if cached entry is expired
+     */
+    private isExpired;
+    /**
+     * Check if cache entry should be refreshed
+     */
+    private shouldRefresh;
+    /**
+     * Refresh policy in background
+     */
+    private refreshInBackground;
+    /**
+     * Get default policy for a project
+     */
+    private getDefaultPolicy;
+}
+/**
+ * Create a policy loader with default configuration
+ */
+declare function createPolicyLoader(config?: PolicyLoaderConfig): PolicyLoader;
+
+/**
+ * Rules-Based Fallback Detector
+ *
+ * JavaScript fallback detector that uses merged-rules.json when WASM is unavailable.
+ * This provides consistent detection using the same rules as WASM, just implemented in JS.
+ */
+
+/**
+ * Rules-Based Fallback Detector
+ *
+ * Uses the same merged-rules.json as the WASM engine to provide
+ * consistent detection when WASM is not available.
+ */
+declare class RulesDetector implements IDetector {
+    private rules;
+    private ready;
+    /**
+     * Analyze a request and detect if it's from an agent
+     */
+    detect(input: IDetectionInput): Promise<IDetectionResult>;
+    /**
+     * Check if the detector is ready
+     */
+    isReady(): boolean;
+    /**
+     * Ensure the detector is initialized
+     */
+    ensureReady(): Promise<void>;
+    /**
+     * Get detector version
+     */
+    getVersion(): Promise<string>;
+    /**
+     * Normalize headers to lowercase keys
+     */
+    private normalizeHeaders;
+    /**
+     * Match user agent against rules
+     */
+    private matchUserAgent;
+    /**
+     * Match headers against suspicious header rules
+     */
+    private matchHeaders;
+    /**
+     * Check if signature headers are present
+     */
+    private hasSignatureHeaders;
+    /**
+     * Get human-readable agent name from rule key
+     */
+    private getAgentName;
+    /**
+     * Infer agent type from name
+     */
+    private inferAgentType;
+    /**
+     * Determine detection class
+     */
+    private determineDetectionClass;
+}
+/**
+ * Create a rules-based fallback detector
+ */
+declare function createRulesDetector(): RulesDetector;
 
 /**
  * Create a detector for Edge Runtime with static WASM import
@@ -19,4 +546,4 @@ declare function createFallbackDetector(): IDetector;
  */
 declare function extractInputFromRequest(request: Request): IDetectionInput;
 
-export { IDetectionInput, IDetector, IDetectorOptions, createEdgeDetector, createFallbackDetector, extractInputFromRequest };
+export { CONFIDENCE, type DetectionClass, type ForgeabilityRisk, type ICustomerPolicy, type IDetectedAgent, type IDetectionInput, type IDetectionResult, type IDetector, type IDetectorOptions, type IPolicyLoader, type IWasmLoader, PolicyLoader, RulesDetector, StaticWasmLoader, type VerificationMethod, WasmDetector, createEdgeDetector, createFallbackDetector, createPolicyLoader, createRulesDetector, createStaticLoader, extractInputFromRequest };

package/dist/edge.js

@@ -1218,7 +1218,7 @@ var RulesDetector = class {
       return;
     }
     try {
-      this.rules = checkpointShared.loadRulesSync();
+      this.rules = checkpointShared.RuleLoader.loadSync();
       this.ready = true;
     } catch (error) {
       console.warn("[RulesDetector] Failed to load rules:", error);

package/dist/edge.mjs

@@ -1,4 +1,4 @@
-import { loadRulesSync } from '@kya-os/checkpoint-shared';
+import { RuleLoader } from '@kya-os/checkpoint-shared';
 
 // src/types.ts
 var CONFIDENCE = {
@@ -1216,7 +1216,7 @@ var RulesDetector = class {
       return;
     }
     try {
-      this.rules = loadRulesSync();
+      this.rules = RuleLoader.loadSync();
       this.ready = true;
     } catch (error) {
       console.warn("[RulesDetector] Failed to load rules:", error);

package/dist/engine.js

@@ -12,6 +12,9 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -32,9 +35,16 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// ../../node_modules/.pnpm/tsup@8.5.0_@swc+core@1.15.32_jiti@2.6.1_postcss@8.5.8_tsx@4.21.0_typescript@5.9.3_yaml@2.8.3/node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.5.0_@swc+core@1.15.32_jiti@2.6.1_postcss@8.5.8_tsx@4.21.0_typescript@5.9.3_yaml@2.8.3/node_modules/tsup/assets/cjs_shims.js"() {
+  }
+});
+
 // wasm/kya-os-engine/kya_os_engine.js
 var require_kya_os_engine = __commonJS({
   "wasm/kya-os-engine/kya_os_engine.js"(exports$1, module) {
+    init_cjs_shims();
     var imports = {};
     imports["__wbindgen_placeholder__"] = module.exports;
     var cachedUint8ArrayMemory0 = null;
@@ -445,6 +455,7 @@ ${val.stack}`;
 });
 
 // src/engine/index.ts
+init_cjs_shims();
 var wasmModule = __toESM(require_kya_os_engine());
 function engineVerify(input, ctx) {
   const verify2 = wasmModule.verify;

package/dist/engine.mjs

@@ -1,15 +1,23 @@
+import { createRequire } from 'module';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const require$1 = createRequire(import.meta.url);
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+var __require = /* @__PURE__ */ ((x) => typeof require$1 !== "undefined" ? require$1 : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require$1 !== "undefined" ? require$1 : a)[b]
 }) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
+  if (typeof require$1 !== "undefined") return require$1.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -29,10 +37,19 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var getFilename, getDirname, __dirname$1;
+var init_esm_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.5.0_@swc+core@1.15.32_jiti@2.6.1_postcss@8.5.8_tsx@4.21.0_typescript@5.9.3_yaml@2.8.3/node_modules/tsup/assets/esm_shims.js"() {
+    getFilename = () => fileURLToPath(import.meta.url);
+    getDirname = () => path.dirname(getFilename());
+    __dirname$1 = /* @__PURE__ */ getDirname();
+  }
+});
 
 // wasm/kya-os-engine/kya_os_engine.js
 var require_kya_os_engine = __commonJS({
   "wasm/kya-os-engine/kya_os_engine.js"(exports$1, module) {
+    init_esm_shims();
     var imports = {};
     imports["__wbindgen_placeholder__"] = module.exports;
     var cachedUint8ArrayMemory0 = null;
@@ -435,7 +452,7 @@ ${val.stack}`;
     exports$1.__wbindgen_object_drop_ref = function(arg0) {
       takeObject(arg0);
     };
-    var wasmPath = `${__dirname}/kya_os_engine_bg.wasm`;
+    var wasmPath = `${__dirname$1}/kya_os_engine_bg.wasm`;
     var wasmBytes = __require("fs").readFileSync(wasmPath);
     var wasmModule2 = new WebAssembly.Module(wasmBytes);
     var wasm = exports$1.__wasm = new WebAssembly.Instance(wasmModule2, imports).exports;
@@ -443,6 +460,7 @@ ${val.stack}`;
 });
 
 // src/engine/index.ts
+init_esm_shims();
 var wasmModule = __toESM(require_kya_os_engine());
 function engineVerify(input, ctx) {
   const verify2 = wasmModule.verify;