@a-company/paradigm 5.10.0 → 5.21.0

package/dist/test-566CP5KC.js

@@ -1,1017 +0,0 @@
-#!/usr/bin/env node
-import {
-  parseGateConfig
-} from "./chunk-IRKUEJVW.js";
-import "./chunk-PDX44BCA.js";
-
-// src/commands/portal/test.ts
-import * as path3 from "path";
-import * as fs3 from "fs";
-import chalk from "chalk";
-
-// ../portal/sdk/dist/chunk-BRTWJEZU.js
-var globalGateClient = null;
-function setGateClient(client) {
-  globalGateClient = client;
-}
-function getGateClient() {
-  return globalGateClient;
-}
-
-// ../portal/manager/dist/index.js
-import * as fs from "fs";
-import * as path from "path";
-import * as fs2 from "fs";
-import * as path2 from "path";
-async function validateGateway(gateId, testCases, client) {
-  const gateClient = client || getGateClient();
-  if (!gateClient) {
-    return {
-      passed: false,
-      results: [],
-      errors: ["No gate client configured"]
-    };
-  }
-  const results = [];
-  const errors = [];
-  for (const testCase of testCases) {
-    try {
-      const result = await gateClient.check(gateId, testCase.entity);
-      const passed = result.passed === testCase.expected;
-      if (testCase.expectedPrizes && result.passed) {
-        const triggeredPrizeIds = result.triggeredPrizes.map((p) => p.id);
-        const missingPrizes = testCase.expectedPrizes.filter(
-          (id) => !triggeredPrizeIds.includes(id)
-        );
-        if (missingPrizes.length > 0) {
-          errors.push(
-            `Test "${testCase.name}": Expected prizes not triggered: ${missingPrizes.join(", ")}`
-          );
-        }
-      }
-      results.push({
-        testCase,
-        result,
-        passed
-      });
-      if (!passed) {
-        errors.push(
-          `Test "${testCase.name}": Expected ${testCase.expected ? "pass" : "fail"}, got ${result.passed ? "pass" : "fail"}`
-        );
-      }
-    } catch (error) {
-      errors.push(`Test "${testCase.name}": ${error.message}`);
-      results.push({
-        testCase,
-        result: {
-          gate: { id: gateId, locks: [], prizes: [] },
-          passed: false,
-          lockResults: [],
-          triggeredPrizes: [],
-          timestamp: Date.now()
-        },
-        passed: false
-      });
-    }
-  }
-  return {
-    passed: errors.length === 0,
-    results,
-    errors
-  };
-}
-async function generateTests(gateConfigPath, options = {}) {
-  const {
-    outputDir = "tests/gates",
-    framework = "jest",
-    includeFlows = true
-  } = options;
-  const gateConfig = await parseGateConfig(gateConfigPath);
-  const generatedFiles = [];
-  const absOutputDir = path.resolve(outputDir);
-  if (!fs.existsSync(absOutputDir)) {
-    fs.mkdirSync(absOutputDir, { recursive: true });
-  }
-  for (const gate of gateConfig.gates) {
-    const testFile = generateGateTest(gate, framework);
-    const fileName = `${gate.id.replace(/[^a-z0-9]/gi, "-")}.test.ts`;
-    const filePath = path.join(absOutputDir, fileName);
-    fs.writeFileSync(filePath, testFile, "utf8");
-    generatedFiles.push(filePath);
-  }
-  if (includeFlows && gateConfig.flows.length > 0) {
-    const flowsDir = path.join(absOutputDir, "..", "flows");
-    if (!fs.existsSync(flowsDir)) {
-      fs.mkdirSync(flowsDir, { recursive: true });
-    }
-    for (const flow of gateConfig.flows) {
-      const testFile = generateFlowTest(flow, gateConfig.gates, framework);
-      const fileName = `${flow.id.replace(/[^a-z0-9]/gi, "-")}.test.ts`;
-      const filePath = path.join(flowsDir, fileName);
-      fs.writeFileSync(filePath, testFile, "utf8");
-      generatedFiles.push(filePath);
-    }
-  }
-  return generatedFiles;
-}
-function generateGateTest(gate, framework) {
-  const testFn = framework === "mocha" ? "it" : framework === "vitest" ? "it" : "test";
-  const gateId = gate.id;
-  const gateName = gate.description || gateId;
-  const lockTests = gate.locks.map((lock) => {
-    const lockTests2 = lock.keys.map((key, idx) => {
-      return `    ${testFn}('should check key: ${key.description || `Key ${idx + 1}`}', async () => {
-      const entity = {
-        // TODO: Add entity properties needed for this key
-        // Key expression: ${key.expression}
-      };
-
-      const result = await checkGateway('${gateId}', entity);
-      // TODO: Assert expected result
-      expect(result.passed).toBeDefined();
-    });`;
-    });
-    return `  describe('Lock: ${lock.description || lock.id}', () => {
-${lockTests2.join("\n\n")}
-  });`;
-  });
-  return `/**
- * Generated test file for gate: ${gateName}
- * Gate ID: ${gateId}
- * 
- * TODO: Fill in entity mock data and expected results
- */
-
-import { checkGateway, validateGateway } from '@a-company/portal-manager';
-import { createGate, setGateClient } from '@a-company/portal-sdk';
-import { parseGateConfig } from '@a-company/portal-core';
-
-${framework === "vitest" ? "import { describe, it, expect, beforeAll } from 'vitest';" : framework === "mocha" ? "import { describe, it } from 'mocha';" : "import { describe, test as it, expect, beforeAll } from '@jest/globals';"}
-
-describe('Gate: ${gateName}', () => {
-  beforeAll(async () => {
-    // Load gate configuration
-    const config = await parseGateConfig('./portal.yaml');
-    const client = createGate(config);
-    setGateClient(client);
-  });
-
-${lockTests.join("\n\n")}
-
-  ${testFn}('should trigger prizes when gate passes', async () => {
-    const entity = {
-      // TODO: Add entity that passes all locks
-    };
-
-    const result = await checkGateway('${gateId}', entity);
-    
-    if (result.passed) {
-      expect(result.triggeredPrizes.length).toBeGreaterThan(0);
-      // TODO: Assert specific prizes
-      ${gate.prizes.map((p) => `// expect(result.triggeredPrizes).toContainEqual(expect.objectContaining({ id: '${p.id}' }));`).join("\n      ")}
-    }
-  });
-});
-`;
-}
-function generateFlowTest(flow, _gates, framework) {
-  const testFn = framework === "mocha" ? "it" : framework === "vitest" ? "it" : "test";
-  const flowName = flow.description || flow.id;
-  const gateTests = flow.gates.map((gateId, idx) => {
-    return `    ${testFn}('should pass gate ${idx + 1}: ${gateId}', async () => {
-      const entity = {
-        // TODO: Add entity properties
-      };
-
-      const result = await checkGateway('${gateId}', entity);
-      expect(result.passed).toBe(true);
-    });`;
-  });
-  return `/**
- * Generated test file for flow: ${flowName}
- * Flow ID: ${flow.id}
- * 
- * TODO: Fill in entity mock data for each gate in the flow
- */
-
-import { checkGateway } from '@a-company/portal-manager';
-import { createGate, setGateClient } from '@a-company/portal-sdk';
-import { parseGateConfig } from '@a-company/portal-core';
-
-${framework === "vitest" ? "import { describe, it, expect, beforeAll } from 'vitest';" : framework === "mocha" ? "import { describe, it } from 'mocha';" : "import { describe, test as it, expect, beforeAll } from '@jest/globals';"}
-
-describe('Flow: ${flowName}', () => {
-  beforeAll(async () => {
-    const config = await parseGateConfig('./portal.yaml');
-    const client = createGate(config);
-    setGateClient(client);
-  });
-
-  ${testFn}('should complete entire flow', async () => {
-    const entity = {
-      // TODO: Add entity that passes all gates in flow
-    };
-
-${gateTests.join("\n\n")}
-  });
-});
-`;
-}
-async function scanComponents(options) {
-  const { rootDir, patterns = ["**/*.tsx", "**/*.jsx"] } = options;
-  const components = [];
-  const scannedFiles = /* @__PURE__ */ new Set();
-  function scanDirectory(dir) {
-    try {
-      const entries = fs2.readdirSync(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = path2.join(dir, entry.name);
-        if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist" || entry.name === "build") {
-          continue;
-        }
-        if (entry.isDirectory()) {
-          scanDirectory(fullPath);
-        } else if (entry.isFile()) {
-          const matchesPattern = patterns.some((pattern) => {
-            if (pattern.includes("**")) {
-              const ext = pattern.split(".").pop();
-              return fullPath.endsWith(`.${ext}`);
-            }
-            return fullPath.endsWith(pattern);
-          });
-          if (matchesPattern && !scannedFiles.has(fullPath)) {
-            scannedFiles.add(fullPath);
-            const info = analyzeComponent(fullPath);
-            if (info) {
-              components.push(info);
-            }
-          }
-        }
-      }
-    } catch (error) {
-    }
-  }
-  scanDirectory(rootDir);
-  return components;
-}
-function analyzeComponent(filePath) {
-  try {
-    const content = fs2.readFileSync(filePath, "utf8");
-    const componentName = path2.basename(filePath, path2.extname(filePath));
-    const gatePatterns = [
-      /@Gate\(['"]([^'"]+)['"]\)/g,
-      /@Gateway\(['"]([^'"]+)['"]\)/g,
-      /GateGuard\(['"]([^'"]+)['"]\)/g,
-      /checkGateway\(['"]([^'"]+)['"]/g,
-      /gate:\s*['"]([^'"]+)['"]/g
-    ];
-    const requiredGates = /* @__PURE__ */ new Set();
-    const missingChecks = [];
-    for (const pattern of gatePatterns) {
-      let match;
-      while ((match = pattern.exec(content)) !== null) {
-        const gateId = match[1];
-        if (gateId && gateId.startsWith("^")) {
-          requiredGates.add(gateId);
-        }
-      }
-    }
-    const hasGateCheck = content.includes("checkGateway") || content.includes("GateGuard") || content.includes("Gateway") || content.includes("useGate");
-    if (requiredGates.size > 0 && !hasGateCheck) {
-      missingChecks.push(...Array.from(requiredGates));
-    }
-    return {
-      filePath,
-      componentName,
-      requiredGates: Array.from(requiredGates),
-      missingChecks
-    };
-  } catch (error) {
-    return null;
-  }
-}
-function generateComponentReport(components) {
-  const lines = [];
-  lines.push("# Component Access Report\n");
-  lines.push(`Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
-`);
-  lines.push(`Total Components: ${components.length}
-`);
-  const withMissingChecks = components.filter((c) => c.missingChecks.length > 0);
-  if (withMissingChecks.length > 0) {
-    lines.push(`
-## Components Missing Gate Checks (${withMissingChecks.length})
-`);
-    for (const component of withMissingChecks) {
-      lines.push(`### ${component.componentName}`);
-      lines.push(`File: ${component.filePath}`);
-      lines.push(`Missing checks for gates: ${component.missingChecks.join(", ")}
-`);
-    }
-  } else {
-    lines.push("\n\u2705 All components have proper gate checks!\n");
-  }
-  return lines.join("\n");
-}
-
-// ../portal/sdk/dist/index.js
-function tokenize(expr) {
-  const tokens = [];
-  let i = 0;
-  while (i < expr.length) {
-    const char = expr[i];
-    if (/\s/.test(char)) {
-      i++;
-      continue;
-    }
-    if (char === '"' || char === "'") {
-      const quote = char;
-      let str = "";
-      i++;
-      while (i < expr.length && expr[i] !== quote) {
-        if (expr[i] === "\\" && i + 1 < expr.length) {
-          i++;
-          str += expr[i];
-        } else {
-          str += expr[i];
-        }
-        i++;
-      }
-      i++;
-      tokens.push({ type: "STRING", value: str });
-      continue;
-    }
-    if (/\d/.test(char)) {
-      let num = "";
-      while (i < expr.length && /[\d.]/.test(expr[i])) {
-        num += expr[i];
-        i++;
-      }
-      tokens.push({ type: "NUMBER", value: num });
-      continue;
-    }
-    if (/[a-zA-Z_]/.test(char)) {
-      let ident = "";
-      while (i < expr.length && /[a-zA-Z0-9_]/.test(expr[i])) {
-        ident += expr[i];
-        i++;
-      }
-      if (ident === "true" || ident === "false") {
-        tokens.push({ type: "BOOLEAN", value: ident });
-      } else if (ident === "null" || ident === "undefined") {
-        tokens.push({ type: "NULL", value: ident });
-      } else if (["and", "or", "not", "includes", "in"].includes(ident)) {
-        tokens.push({ type: "OPERATOR", value: ident });
-      } else {
-        tokens.push({ type: "IDENTIFIER", value: ident });
-      }
-      continue;
-    }
-    if (expr.slice(i, i + 3) === "===" || expr.slice(i, i + 3) === "!==") {
-      tokens.push({ type: "OPERATOR", value: expr.slice(i, i + 3) });
-      i += 3;
-      continue;
-    }
-    if (expr.slice(i, i + 2) === "==" || expr.slice(i, i + 2) === "!=" || expr.slice(i, i + 2) === "<=" || expr.slice(i, i + 2) === ">=" || expr.slice(i, i + 2) === "&&" || expr.slice(i, i + 2) === "||") {
-      tokens.push({ type: "OPERATOR", value: expr.slice(i, i + 2) });
-      i += 2;
-      continue;
-    }
-    if ("<>=!".includes(char)) {
-      tokens.push({ type: "OPERATOR", value: char });
-      i++;
-      continue;
-    }
-    if (char === "(") {
-      tokens.push({ type: "LPAREN", value: char });
-      i++;
-      continue;
-    }
-    if (char === ")") {
-      tokens.push({ type: "RPAREN", value: char });
-      i++;
-      continue;
-    }
-    if (char === ".") {
-      tokens.push({ type: "DOT", value: char });
-      i++;
-      continue;
-    }
-    if (char === ",") {
-      tokens.push({ type: "COMMA", value: char });
-      i++;
-      continue;
-    }
-    i++;
-  }
-  tokens.push({ type: "EOF", value: "" });
-  return tokens;
-}
-var ExpressionEvaluator = class {
-  tokens;
-  pos;
-  context;
-  constructor(tokens, context) {
-    this.tokens = tokens;
-    this.pos = 0;
-    this.context = context;
-  }
-  current() {
-    return this.tokens[this.pos] || { type: "EOF", value: "" };
-  }
-  advance() {
-    const token = this.current();
-    this.pos++;
-    return token;
-  }
-  evaluate() {
-    return this.parseOr();
-  }
-  parseOr() {
-    let left = this.parseAnd();
-    while (this.current().value === "||" || this.current().value === "or") {
-      this.advance();
-      const right = this.parseAnd();
-      left = Boolean(left) || Boolean(right);
-    }
-    return left;
-  }
-  parseAnd() {
-    let left = this.parseNot();
-    while (this.current().value === "&&" || this.current().value === "and") {
-      this.advance();
-      const right = this.parseNot();
-      left = Boolean(left) && Boolean(right);
-    }
-    return left;
-  }
-  parseNot() {
-    if (this.current().value === "!" || this.current().value === "not") {
-      this.advance();
-      return !Boolean(this.parseNot());
-    }
-    return this.parseComparison();
-  }
-  parseComparison() {
-    let left = this.parsePrimary();
-    const op = this.current();
-    if (op.type === "OPERATOR") {
-      switch (op.value) {
-        case "==":
-        case "===":
-          this.advance();
-          return left === this.parsePrimary();
-        case "!=":
-        case "!==":
-          this.advance();
-          return left !== this.parsePrimary();
-        case "<":
-          this.advance();
-          return left < this.parsePrimary();
-        case ">":
-          this.advance();
-          return left > this.parsePrimary();
-        case "<=":
-          this.advance();
-          return left <= this.parsePrimary();
-        case ">=":
-          this.advance();
-          return left >= this.parsePrimary();
-        case "includes":
-          this.advance();
-          const includesValue = this.parsePrimary();
-          if (Array.isArray(left)) {
-            return left.includes(includesValue);
-          }
-          if (typeof left === "string") {
-            return left.includes(String(includesValue));
-          }
-          return false;
-        case "in":
-          this.advance();
-          const inArray = this.parsePrimary();
-          if (Array.isArray(inArray)) {
-            return inArray.includes(left);
-          }
-          return false;
-      }
-    }
-    return left;
-  }
-  parsePrimary() {
-    const token = this.current();
-    if (token.type === "LPAREN") {
-      this.advance();
-      const value = this.parseOr();
-      if (this.current().type === "RPAREN") {
-        this.advance();
-      }
-      return value;
-    }
-    if (token.type === "STRING") {
-      this.advance();
-      return token.value;
-    }
-    if (token.type === "NUMBER") {
-      this.advance();
-      return parseFloat(token.value);
-    }
-    if (token.type === "BOOLEAN") {
-      this.advance();
-      return token.value === "true";
-    }
-    if (token.type === "NULL") {
-      this.advance();
-      return null;
-    }
-    if (token.type === "IDENTIFIER") {
-      return this.parseIdentifier();
-    }
-    return null;
-  }
-  parseIdentifier() {
-    let value = this.context;
-    while (this.current().type === "IDENTIFIER" || this.current().type === "DOT") {
-      if (this.current().type === "DOT") {
-        this.advance();
-        continue;
-      }
-      const key = this.advance().value;
-      if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-        value = value[key];
-      } else {
-        value = void 0;
-      }
-      if (this.current().type === "LPAREN") {
-        this.advance();
-        const args = [];
-        while (this.current().type !== "RPAREN" && this.current().type !== "EOF") {
-          args.push(this.parseOr());
-          if (this.current().type === "COMMA") {
-            this.advance();
-          }
-        }
-        if (this.current().type === "RPAREN") {
-          this.advance();
-        }
-        return this.callMethod(key, value, args);
-      }
-      if (this.current().type !== "DOT") {
-        break;
-      }
-    }
-    return value;
-  }
-  callMethod(method, target, args) {
-    switch (method) {
-      case "includes":
-        if (Array.isArray(target)) {
-          return target.includes(args[0]);
-        }
-        if (typeof target === "string") {
-          return target.includes(String(args[0]));
-        }
-        return false;
-      case "startsWith":
-        if (typeof target === "string") {
-          return target.startsWith(String(args[0]));
-        }
-        return false;
-      case "endsWith":
-        if (typeof target === "string") {
-          return target.endsWith(String(args[0]));
-        }
-        return false;
-      case "length":
-        if (Array.isArray(target) || typeof target === "string") {
-          return target.length;
-        }
-        return 0;
-      default:
-        return null;
-    }
-  }
-};
-function evaluateExpression(expression, context) {
-  try {
-    const tokens = tokenize(expression);
-    const evaluator = new ExpressionEvaluator(tokens, context);
-    const result = evaluator.evaluate();
-    return {
-      passed: Boolean(result)
-    };
-  } catch (error) {
-    return {
-      passed: false,
-      error: error.message
-    };
-  }
-}
-var GateClient = class {
-  config;
-  prizeHandlers = /* @__PURE__ */ new Map();
-  firedPrizes = [];
-  ws = null;
-  options;
-  entityIdResolver;
-  constructor(config, options = {}) {
-    this.config = config;
-    this.options = options;
-    this.entityIdResolver = options.entityIdResolver || this.defaultEntityIdResolver;
-    if (options.devMode) {
-      this.connectWatcher();
-    }
-  }
-  /**
-   * Default entity ID resolver - looks for id, _id, userId, entityId
-   */
-  defaultEntityIdResolver(entity) {
-    return entity.id || entity._id || entity.userId || entity.entityId || "anonymous";
-  }
-  /**
-   * Connect to the Gate watcher server
-   */
-  connectWatcher() {
-    const url = this.options.watcherUrl || `ws://localhost:${this.config.settings.dev.watcherPort}`;
-    try {
-      if (typeof WebSocket !== "undefined") {
-        this.ws = new WebSocket(url);
-        this.ws.onopen = () => {
-          console.log("[Gate SDK] Connected to watcher");
-        };
-        this.ws.onerror = () => {
-          console.warn("[Gate SDK] Failed to connect to watcher");
-        };
-        this.ws.onclose = () => {
-          setTimeout(() => this.connectWatcher(), 5e3);
-        };
-      }
-    } catch {
-      console.warn("[Gate SDK] WebSocket not available for watcher connection");
-    }
-  }
-  /**
-   * Send event to watcher
-   */
-  sendWatcherEvent(event) {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify(event));
-    }
-  }
-  /**
-   * Register a handler for a prize
-   */
-  onPrize(prizeId, handler) {
-    if (!this.prizeHandlers.has(prizeId)) {
-      this.prizeHandlers.set(prizeId, []);
-    }
-    this.prizeHandlers.get(prizeId).push(handler);
-    return () => {
-      const handlers = this.prizeHandlers.get(prizeId);
-      if (handlers) {
-        const index = handlers.indexOf(handler);
-        if (index >= 0) {
-          handlers.splice(index, 1);
-        }
-      }
-    };
-  }
-  /**
-   * Check if an entity can pass through a gate
-   */
-  async check(gateId, entity) {
-    const gate = this.config.gates.find((g) => g.id === gateId);
-    if (!gate) {
-      throw new Error(`Gate not found: ${gateId}`);
-    }
-    const entityId = this.entityIdResolver(entity);
-    const timestamp = Date.now();
-    this.sendWatcherEvent({
-      type: "gate:check",
-      timestamp,
-      entityId,
-      data: { gate, entitySnapshot: entity }
-    });
-    const lockResults = [];
-    let allLocksPassed = true;
-    for (const lock of gate.locks) {
-      const keyResults = [];
-      let lockPassed;
-      if (lock.mode === "any") {
-        lockPassed = false;
-        for (const key of lock.keys) {
-          const { passed, error } = evaluateExpression(key.expression, entity);
-          keyResults.push({ key, passed, error });
-          if (passed) {
-            lockPassed = true;
-          }
-        }
-      } else {
-        lockPassed = true;
-        for (const key of lock.keys) {
-          const { passed, error } = evaluateExpression(key.expression, entity);
-          keyResults.push({ key, passed, error });
-          if (!passed) {
-            lockPassed = false;
-          }
-        }
-      }
-      lockResults.push({
-        lock,
-        passed: lockPassed,
-        keyResults
-      });
-      if (!lockPassed) {
-        allLocksPassed = false;
-      }
-    }
-    const triggeredPrizes = [];
-    if (allLocksPassed) {
-      for (const prize of gate.prizes) {
-        if (prize.oneTime) {
-          const alreadyFired = this.firedPrizes.some(
-            (fp) => fp.entityId === entityId && fp.prizeId === prize.id
-          );
-          if (alreadyFired) {
-            continue;
-          }
-        }
-        triggeredPrizes.push(prize);
-        if (prize.oneTime) {
-          this.firedPrizes.push({
-            entityId,
-            prizeId: prize.id,
-            timestamp
-          });
-        }
-        const handlers = this.prizeHandlers.get(prize.id) || [];
-        for (const handler of handlers) {
-          try {
-            await handler(entity, {
-              gate,
-              prize,
-              timestamp
-            });
-          } catch (error) {
-            console.error(`[Gate SDK] Prize handler error for ${prize.id}:`, error);
-          }
-        }
-        this.sendWatcherEvent({
-          type: "prize:fire",
-          timestamp: Date.now(),
-          entityId,
-          data: { prizeId: prize.id, metadata: prize.metadata }
-        });
-      }
-    }
-    const result = {
-      gate,
-      passed: allLocksPassed,
-      lockResults,
-      triggeredPrizes,
-      timestamp,
-      entitySnapshot: entity
-    };
-    this.sendWatcherEvent({
-      type: allLocksPassed ? "gate:pass" : "gate:fail",
-      timestamp: Date.now(),
-      entityId,
-      data: result
-    });
-    return result;
-  }
-  /**
-   * Get a gate by ID
-   */
-  getGate(gateId) {
-    return this.config.gates.find((g) => g.id === gateId);
-  }
-  /**
-   * Get all gates
-   */
-  getGates() {
-    return this.config.gates;
-  }
-  /**
-   * Get all flows
-   */
-  getFlows() {
-    return this.config.flows;
-  }
-  /**
-   * Reset fired prizes for an entity (useful for testing)
-   */
-  resetPrizes(entityId) {
-    if (entityId) {
-      this.firedPrizes = this.firedPrizes.filter((fp) => fp.entityId !== entityId);
-    } else {
-      this.firedPrizes = [];
-    }
-  }
-  /**
-   * Disconnect from watcher
-   */
-  disconnect() {
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-};
-async function createGate(configPath, options = {}) {
-  const config = await parseGateConfig(configPath);
-  const devMode = options.devMode ?? process.env.NODE_ENV !== "production";
-  return new GateClient(config, {
-    ...options,
-    devMode
-  });
-}
-var isProduction = typeof process !== "undefined" ? process.env.NODE_ENV === "production" : typeof import.meta !== "undefined" && import.meta.env?.PROD;
-var enableValidation = typeof process !== "undefined" ? process.env.PORTAL_VALIDATION === "true" : typeof import.meta !== "undefined" && import.meta.env?.VITE_ENABLE_PORTAL_VALIDATION === "true";
-var isTestMode = typeof process !== "undefined" ? process.env.PORTAL_TEST_MODE === "true" : typeof import.meta !== "undefined" && import.meta.env?.VITE_TEST_MODE === "true";
-
-// src/commands/portal/test.ts
-function extractPropertiesFromExpression(expr) {
-  const propPattern = /\b([a-zA-Z_$][\w$]*(?:\.[a-zA-Z_$][\w$]*)+)/g;
-  const matches = /* @__PURE__ */ new Set();
-  let match;
-  while ((match = propPattern.exec(expr)) !== null) {
-    matches.add(match[1]);
-  }
-  return [...matches];
-}
-function buildEntityFromPath(path4) {
-  const parts = path4.split(".");
-  const root = {};
-  let current = root;
-  for (let i = 0; i < parts.length; i++) {
-    const part = parts[i];
-    if (i === parts.length - 1) {
-      current[part] = "test-value";
-    } else {
-      const next = {};
-      current[part] = next;
-      current = next;
-    }
-  }
-  return root;
-}
-function deepMerge(target, source) {
-  const result = { ...target };
-  for (const [key, value] of Object.entries(source)) {
-    if (value && typeof value === "object" && !Array.isArray(value) && result[key] && typeof result[key] === "object" && !Array.isArray(result[key])) {
-      result[key] = deepMerge(
-        result[key],
-        value
-      );
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-function generateTestCasesFromLocks(gate) {
-  const cases = [];
-  if (!gate.locks || gate.locks.length === 0) {
-    cases.push({
-      name: `${gate.id}: no locks (should pass)`,
-      entity: { user: { id: "test-user" } },
-      expected: true
-    });
-    return cases;
-  }
-  let fullEntity = {};
-  for (const lock of gate.locks) {
-    for (const key of lock.keys) {
-      const paths = extractPropertiesFromExpression(key.expression);
-      for (const p of paths) {
-        const partial = buildEntityFromPath(p);
-        fullEntity = deepMerge(fullEntity, partial);
-      }
-    }
-  }
-  cases.push({
-    name: `${gate.id}: entity satisfying all locks (should pass)`,
-    entity: fullEntity,
-    expected: true
-  });
-  for (const lock of gate.locks) {
-    const lockPaths = [];
-    for (const key of lock.keys) {
-      lockPaths.push(...extractPropertiesFromExpression(key.expression));
-    }
-    if (lockPaths.length > 0) {
-      const missingEntity = {};
-      for (const otherLock of gate.locks) {
-        if (otherLock.id === lock.id) continue;
-        for (const key of otherLock.keys) {
-          const paths = extractPropertiesFromExpression(key.expression);
-          for (const p of paths) {
-            const partial = buildEntityFromPath(p);
-            Object.assign(missingEntity, deepMerge(missingEntity, partial));
-          }
-        }
-      }
-      cases.push({
-        name: `${gate.id}: missing lock "${lock.id}" properties (should fail)`,
-        entity: gate.locks.length === 1 ? {} : missingEntity,
-        expected: false
-      });
-    }
-  }
-  return cases;
-}
-async function gateTestCommand(targetPath, options) {
-  const rootDir = targetPath ? path3.resolve(targetPath) : process.cwd();
-  const gateConfigPath = path3.join(rootDir, "portal.yaml");
-  if (!fs3.existsSync(gateConfigPath)) {
-    console.error(chalk.red(`\u274C portal.yaml not found at ${gateConfigPath}`));
-    console.error(chalk.gray("   Run `paradigm init` or create portal.yaml manually"));
-    process.exit(1);
-  }
-  if (options.generate) {
-    console.log(chalk.blue("\n\u{1F527} Generating test files...\n"));
-    try {
-      const generatedFiles = await generateTests(gateConfigPath, {
-        outputDir: options.output || "tests/gates",
-        framework: options.framework || "jest",
-        includeFlows: true
-      });
-      console.log(chalk.green(`\u2705 Generated ${generatedFiles.length} test files:`));
-      for (const file of generatedFiles) {
-        console.log(chalk.gray(`   ${path3.relative(rootDir, file)}`));
-      }
-      console.log("");
-    } catch (error) {
-      console.error(chalk.red(`\u274C Error generating tests: ${error.message}`));
-      process.exit(1);
-    }
-    return;
-  }
-  if (options.component) {
-    console.log(chalk.blue("\n\u{1F50D} Scanning components for gate checks...\n"));
-    try {
-      const components = await scanComponents({
-        rootDir,
-        gateConfigPath
-      });
-      const report = generateComponentReport(components);
-      console.log(report);
-      const withMissing = components.filter((c) => c.missingChecks.length > 0);
-      if (withMissing.length > 0) {
-        process.exit(1);
-      }
-    } catch (error) {
-      console.error(chalk.red(`\u274C Error scanning components: ${error.message}`));
-      process.exit(1);
-    }
-    return;
-  }
-  if (options.gate) {
-    console.log(chalk.blue(`
-\u{1F9EA} Testing gate: ${options.gate}
-`));
-    try {
-      const config = await parseGateConfig(gateConfigPath);
-      const client = await createGate(gateConfigPath);
-      setGateClient(client);
-      const gate = config.gates.find((g) => g.id === options.gate);
-      if (!gate) {
-        console.error(chalk.red(`\u274C Gate "${options.gate}" not found`));
-        process.exit(1);
-      }
-      const testCases = [
-        {
-          name: "Empty entity (should fail)",
-          entity: {},
-          expected: false
-        },
-        ...generateTestCasesFromLocks(gate)
-      ];
-      const result = await validateGateway(options.gate, testCases, client);
-      if (result.passed) {
-        console.log(chalk.green("\u2705 All tests passed\n"));
-      } else {
-        console.log(chalk.red("\u274C Some tests failed\n"));
-        for (const error of result.errors) {
-          console.log(chalk.red(`   ${error}`));
-        }
-        console.log("");
-        process.exit(1);
-      }
-    } catch (error) {
-      console.error(chalk.red(`\u274C Error testing gate: ${error.message}`));
-      process.exit(1);
-    }
-    return;
-  }
-  console.log(chalk.blue("\n\u{1F9EA} Portal Testing\n"));
-  console.log("Usage:");
-  console.log("  paradigm portal test --generate             Generate test files");
-  console.log("  paradigm portal test --portal ^auth-required  Test specific portal");
-  console.log("  paradigm portal test --component             Validate component access");
-  console.log("");
-}
-export {
-  gateTestCommand
-};