@holoscript/core 6.0.4 → 7.0.0

package/dist/chunk-CDPGV4DN.js

@@ -1,114 +0,0 @@
-import { __export, __esm } from './chunk-2CWOLHTE.js';
-import { getRBAC, WorkflowStep, ResourceType } from '@holoscript/platform';
-
-// src/compiler/StateCompiler.ts
-var StateCompiler_exports = {};
-__export(StateCompiler_exports, {
-  StateCompiler: () => StateCompiler,
-  UnauthorizedStateCompilerAccessError: () => UnauthorizedStateCompilerAccessError
-});
-var StateCompiler, UnauthorizedStateCompilerAccessError;
-var init_StateCompiler = __esm({
-  "src/compiler/StateCompiler.ts"() {
-    StateCompiler = class {
-      /**
-       * Walk an entire HSPlusAST and extract all per-node stateBlocks.
-       *
-       * @param ast - The parse result returned by HoloScriptPlusParser.
-       * @param agentToken - JWT token proving agent identity (optional for backwards compatibility).
-       * @returns A StateShapeMap keyed by node.name (or a generated id).
-       * @throws UnauthorizedStateCompilerAccessError if token is provided but invalid.
-       */
-      compile(ast, agentToken) {
-        this.validateAccess(agentToken);
-        const shapes = /* @__PURE__ */ new Map();
-        this.walkNode(ast.root, shapes);
-        return shapes;
-      }
-      // ---------------------------------------------------------------------------
-      // RBAC enforcement
-      // ---------------------------------------------------------------------------
-      /**
-       * Validate agent has permission to compile state blocks.
-       * Skips validation when no token is provided (backwards compatibility / testing).
-       */
-      validateAccess(agentToken) {
-        if (!agentToken) return;
-        const rbac = getRBAC();
-        const decision = rbac.checkAccess({
-          token: agentToken,
-          resourceType: ResourceType.AST,
-          operation: "read",
-          expectedWorkflowStep: WorkflowStep.GENERATE_ASSEMBLY
-        });
-        if (!decision.allowed) {
-          throw new UnauthorizedStateCompilerAccessError(decision, "StateCompiler");
-        }
-      }
-      /**
-       * Compile a single HSPlusNode subtree.
-       * Useful when only a portion of the AST is being (re-)compiled.
-       */
-      compileNode(node) {
-        if (!node.stateBlock || Object.keys(node.stateBlock).length === 0) {
-          return null;
-        }
-        return this.buildShape(node);
-      }
-      // ---------------------------------------------------------------------------
-      // Private helpers
-      // ---------------------------------------------------------------------------
-      walkNode(node, out) {
-        if (!node) return;
-        if (node.stateBlock && Object.keys(node.stateBlock).length > 0) {
-          const shape = this.buildShape(node);
-          out.set(shape.nodeId, shape);
-        }
-        if (Array.isArray(node.children)) {
-          for (const child of node.children) {
-            this.walkNode(child, out);
-          }
-        }
-        if (node.body && typeof node.body === "object" && !Array.isArray(node.body)) {
-          if (node.body.type) {
-            this.walkNode(node.body, out);
-          }
-        }
-      }
-      buildShape(node) {
-        const nodeId = this.resolveNodeId(node);
-        const stateBlock = node.stateBlock ?? {};
-        const vars = [];
-        const initialState = {};
-        for (const [key, value] of Object.entries(stateBlock)) {
-          if (key.startsWith("__spread_")) continue;
-          vars.push({ name: key, initialValue: value });
-          initialState[key] = value;
-        }
-        return { nodeId, initialState, vars };
-      }
-      resolveNodeId(node) {
-        if (node.name) return node.name;
-        const loc = node.loc;
-        if (loc) return `${node.type}@${loc.start.line}:${loc.start.column}`;
-        return `${node.type}_${Math.random().toString(36).slice(2, 7)}`;
-      }
-    };
-    UnauthorizedStateCompilerAccessError = class extends Error {
-      constructor(decision, compilerName) {
-        super(
-          `[${compilerName}] Unauthorized access: ${decision.reason || "Access denied"}
-Agent Role: ${decision.agentRole || "unknown"}
-Required Permission: ${decision.requiredPermission || "unknown"}`
-        );
-        this.decision = decision;
-        this.compilerName = compilerName;
-        this.name = "UnauthorizedStateCompilerAccessError";
-      }
-    };
-  }
-});
-
-export { StateCompiler, StateCompiler_exports, UnauthorizedStateCompilerAccessError, init_StateCompiler };
-//# sourceMappingURL=chunk-CDPGV4DN.js.map
-//# sourceMappingURL=chunk-CDPGV4DN.js.map

package/dist/chunk-CLYEIWA5.cjs

@@ -1,408 +0,0 @@
-'use strict';
-
-var path = require('path');
-var fs = require('fs');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
-var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
-
-// src/interop/Interoperability.ts
-var ModuleResolver = class {
-  constructor(basePath = process.cwd()) {
-    this.cache = /* @__PURE__ */ new Map();
-    this.resolvedPaths = /* @__PURE__ */ new Map();
-    this.basePath = basePath;
-  }
-  /**
-   * Resolve module path
-   */
-  resolveModule(modulePath, fromPath) {
-    const cacheKey = `${modulePath}:${fromPath || "root"}`;
-    if (this.resolvedPaths.has(cacheKey)) {
-      return this.resolvedPaths.get(cacheKey);
-    }
-    const resolved = this.performResolve(modulePath, fromPath);
-    this.resolvedPaths.set(cacheKey, resolved);
-    return resolved;
-  }
-  /**
-   * Perform actual module resolution
-   */
-  performResolve(modulePath, fromPath) {
-    if (this.isBuiltinModule(modulePath)) {
-      return modulePath;
-    }
-    if (modulePath.startsWith(".")) {
-      const basePath = fromPath ? path__namespace.dirname(fromPath) : this.basePath;
-      const resolved = path__namespace.resolve(basePath, modulePath);
-      return this.findModuleFile(resolved);
-    }
-    if (modulePath.startsWith("@")) {
-      return this.resolveNodeModule(modulePath);
-    }
-    return this.resolveNodeModule(modulePath);
-  }
-  /**
-   * Check if built-in module
-   */
-  isBuiltinModule(modulePath) {
-    const builtins = ["fs", "path", "crypto", "util", "stream", "events"];
-    return builtins.includes(modulePath);
-  }
-  /**
-   * Resolve from node_modules
-   */
-  resolveNodeModule(modulePath) {
-    let current = this.basePath;
-    while (current !== path__namespace.dirname(current)) {
-      const nodeModulesPath = path__namespace.join(current, "node_modules", modulePath);
-      if (fs__namespace.existsSync(nodeModulesPath)) {
-        return nodeModulesPath;
-      }
-      const packageJsonPath = path__namespace.join(nodeModulesPath, "package.json");
-      if (fs__namespace.existsSync(packageJsonPath)) {
-        const packageJson = JSON.parse(fs__namespace.readFileSync(packageJsonPath, "utf-8"));
-        return this.findModuleFile(path__namespace.join(nodeModulesPath, packageJson.main || "index.js"));
-      }
-      current = path__namespace.dirname(current);
-    }
-    throw new Error(`Module not found: ${modulePath}`);
-  }
-  /**
-   * Find module file with various extensions
-   */
-  findModuleFile(basePath) {
-    const extensions = [".ts", ".tsx", ".js", ".jsx", ".json"];
-    if (fs__namespace.existsSync(basePath)) {
-      return basePath;
-    }
-    for (const ext of extensions) {
-      const withExt = basePath + ext;
-      if (fs__namespace.existsSync(withExt)) {
-        return withExt;
-      }
-    }
-    const indexPath = path__namespace.join(basePath, "index");
-    for (const ext of extensions) {
-      const withExt = indexPath + ext;
-      if (fs__namespace.existsSync(withExt)) {
-        return withExt;
-      }
-    }
-    throw new Error(`Cannot resolve file: ${basePath}`);
-  }
-  /**
-   * Load module (with caching)
-   */
-  loadModule(modulePath, fromPath) {
-    const resolved = this.resolveModule(modulePath, fromPath);
-    const cacheKey = resolved;
-    if (this.cache.has(cacheKey)) {
-      return this.cache.get(cacheKey);
-    }
-    const module = {
-      path: resolved,
-      exports: {}
-    };
-    this.cache.set(cacheKey, module);
-    return module;
-  }
-  /**
-   * Clear cache
-   */
-  clearCache() {
-    this.cache.clear();
-    this.resolvedPaths.clear();
-  }
-};
-var ExportImportHandler = class {
-  constructor() {
-    this.exports = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Define named export
-   */
-  defineExport(modulePath, name, value) {
-    if (!this.exports.has(modulePath)) {
-      this.exports.set(modulePath, /* @__PURE__ */ new Map());
-    }
-    this.exports.get(modulePath).set(name, value);
-  }
-  /**
-   * Get named export
-   */
-  getExport(modulePath, name) {
-    const moduleExports = this.exports.get(modulePath);
-    if (!moduleExports) {
-      throw new Error(`Module not found: ${modulePath}`);
-    }
-    if (!moduleExports.has(name)) {
-      throw new Error(`Named export '${name}' not found in ${modulePath}`);
-    }
-    return moduleExports.get(name);
-  }
-  /**
-   * Get all exports from module
-   */
-  getAllExports(modulePath) {
-    const moduleExports = this.exports.get(modulePath);
-    if (!moduleExports) {
-      return {};
-    }
-    const result = {};
-    for (const [name, value] of moduleExports) {
-      result[name] = value;
-    }
-    return result;
-  }
-  /**
-   * Check if export exists
-   */
-  hasExport(modulePath, name) {
-    return this.exports.has(modulePath) && this.exports.get(modulePath).has(name);
-  }
-};
-var AsyncFunctionHandler = class {
-  /**
-   * Wrap async function for HoloScript
-   */
-  wrapAsyncFunction(fn) {
-    return async (...args) => {
-      try {
-        return await fn(...args);
-      } catch (error) {
-        throw this.normalizeError(error);
-      }
-    };
-  }
-  /**
-   * Check if function is async
-   */
-  isAsync(fn) {
-    if (typeof fn !== "function") {
-      return false;
-    }
-    const fnStr = fn.toString().trim();
-    return fnStr.startsWith("async ") || fn.constructor.name === "AsyncFunction";
-  }
-  /**
-   * Convert callback to promise
-   */
-  callbackToPromise(fn) {
-    return new Promise((resolve2, reject) => {
-      fn((err, result) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve2(result);
-        }
-      });
-    });
-  }
-  /**
-   * Normalize error from async function
-   */
-  normalizeError(error) {
-    if (error instanceof Error) {
-      return error;
-    }
-    if (typeof error === "string") {
-      return new Error(error);
-    }
-    return new Error(JSON.stringify(error));
-  }
-};
-var ErrorBoundary = class {
-  constructor(onError) {
-    this.errors = [];
-    this.onError = onError;
-  }
-  /**
-   * Wrap function with error boundary
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  wrap(fn) {
-    return ((...args) => {
-      try {
-        const result = fn(...args);
-        if (result instanceof Promise) {
-          return result.catch((error) => {
-            this.handleError(error);
-            throw error;
-          });
-        }
-        return result;
-      } catch (error) {
-        this.handleError(error);
-        throw error;
-      }
-    });
-  }
-  /**
-   * Wrap async function with error boundary
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  wrapAsync(fn) {
-    return (async (...args) => {
-      try {
-        return await fn(...args);
-      } catch (error) {
-        this.handleError(error);
-        throw error;
-      }
-    });
-  }
-  /**
-   * Execute function in boundary
-   */
-  execute(fn) {
-    try {
-      return fn();
-    } catch (error) {
-      this.handleError(error);
-      throw error;
-    }
-  }
-  /**
-   * Execute async function in boundary
-   */
-  async executeAsync(fn) {
-    try {
-      return await fn();
-    } catch (error) {
-      this.handleError(error);
-      throw error;
-    }
-  }
-  /**
-   * Handle error
-   */
-  handleError(error) {
-    const normalized = this.normalizeError(error);
-    this.errors.push(normalized);
-    if (this.onError) {
-      this.onError(normalized);
-    }
-  }
-  /**
-   * Get errors
-   */
-  getErrors() {
-    return [...this.errors];
-  }
-  /**
-   * Clear errors
-   */
-  clearErrors() {
-    this.errors = [];
-  }
-  /**
-   * Normalize error
-   */
-  normalizeError(error) {
-    if (error instanceof Error) {
-      return error;
-    }
-    if (typeof error === "string") {
-      return new Error(error);
-    }
-    return new Error(JSON.stringify(error));
-  }
-};
-var TypeScriptTypeLoader = class {
-  /**
-   * Load types from TypeScript declaration file
-   */
-  loadTypes(_filePath) {
-    const types = /* @__PURE__ */ new Map();
-    return types;
-  }
-  /**
-   * Convert TypeScript type to HoloScript type
-   */
-  convertType(tsType) {
-    const mapping = {
-      string: "text",
-      number: "numeric",
-      boolean: "logical",
-      void: "void",
-      any: "dynamic",
-      unknown: "dynamic",
-      null: "null",
-      undefined: "void"
-    };
-    if (typeof tsType === "string") {
-      return mapping[tsType] || tsType;
-    }
-    if (Array.isArray(tsType)) {
-      return {
-        kind: "array",
-        elementType: this.convertType(tsType[0])
-      };
-    }
-    if (typeof tsType === "object") {
-      return {
-        kind: "object",
-        properties: Object.entries(tsType).reduce(
-          (acc, [key, val]) => {
-            acc[key] = this.convertType(val);
-            return acc;
-          },
-          {}
-        )
-      };
-    }
-    return tsType;
-  }
-};
-var InteropContext = class {
-  constructor(basePath) {
-    this.moduleResolver = new ModuleResolver(basePath);
-    this.exportImportHandler = new ExportImportHandler();
-    this.asyncHandler = new AsyncFunctionHandler();
-    this.errorBoundary = new ErrorBoundary();
-    this.typeLoader = new TypeScriptTypeLoader();
-  }
-  getModuleResolver() {
-    return this.moduleResolver;
-  }
-  getExportImportHandler() {
-    return this.exportImportHandler;
-  }
-  getAsyncHandler() {
-    return this.asyncHandler;
-  }
-  getErrorBoundary() {
-    return this.errorBoundary;
-  }
-  getTypeLoader() {
-    return this.typeLoader;
-  }
-};
-
-exports.AsyncFunctionHandler = AsyncFunctionHandler;
-exports.ErrorBoundary = ErrorBoundary;
-exports.ExportImportHandler = ExportImportHandler;
-exports.InteropContext = InteropContext;
-exports.ModuleResolver = ModuleResolver;
-exports.TypeScriptTypeLoader = TypeScriptTypeLoader;
-//# sourceMappingURL=chunk-CLYEIWA5.cjs.map
-//# sourceMappingURL=chunk-CLYEIWA5.cjs.map