@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-5GLCTO44.js

@@ -0,0 +1,161 @@
+// src/compiler/ReproducibilityMode.ts
+var DEFAULT_FIXED_TIMESTAMP = "2026-01-01T00:00:00.000Z";
+var DEFAULT_SEED = 42;
+var DEFAULT_GENERATOR = "holoscript-compiler";
+var COMPILER_VERSION = "6.0.0";
+function createSeededRNG(seed = DEFAULT_SEED) {
+  let state = seed | 0;
+  const initialSeed = state;
+  function next() {
+    state = state + 1831565813 | 0;
+    let t = Math.imul(state ^ state >>> 15, 1 | state);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  }
+  function nextInt(min, max) {
+    return Math.floor(next() * (max - min + 1)) + min;
+  }
+  function nextUUID() {
+    const hex = (n, len) => Array.from({ length: len }, () => nextInt(0, 15).toString(16)).join("");
+    return `${hex(0, 8)}-${hex(0, 4)}-4${hex(0, 3)}-${(8 + nextInt(0, 3)).toString(16)}${hex(0, 3)}-${hex(0, 12)}`;
+  }
+  function reset() {
+    state = initialSeed;
+  }
+  function getState() {
+    return state;
+  }
+  return { next, nextInt, nextUUID, reset, getState };
+}
+function sortKeysDeep(value) {
+  if (value === null || value === void 0) return value;
+  if (Array.isArray(value)) {
+    return value.map((item) => sortKeysDeep(item));
+  }
+  if (typeof value === "object") {
+    const sorted = {};
+    const keys = Object.keys(value).sort();
+    for (const key of keys) {
+      sorted[key] = sortKeysDeep(value[key]);
+    }
+    return sorted;
+  }
+  return value;
+}
+function fnv1a32(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function hashComposition(composition) {
+  const sorted = sortKeysDeep(composition);
+  const serialized = JSON.stringify(sorted);
+  const h1 = fnv1a32(serialized);
+  const h2 = fnv1a32(serialized + h1);
+  const h3 = fnv1a32(serialized + h2);
+  const h4 = fnv1a32(serialized + h3);
+  const h5 = fnv1a32(serialized + h4);
+  const h6 = fnv1a32(serialized + h5);
+  const h7 = fnv1a32(serialized + h6);
+  const h8 = fnv1a32(serialized + h7);
+  return `${h1}${h2}${h3}${h4}${h5}${h6}${h7}${h8}`;
+}
+function createReproducibilityContext(config) {
+  const fullConfig = {
+    enabled: config.enabled,
+    fixedTimestamp: config.fixedTimestamp ?? DEFAULT_FIXED_TIMESTAMP,
+    randomSeed: config.randomSeed ?? DEFAULT_SEED,
+    sortKeys: config.sortKeys ?? config.enabled,
+    deterministicIds: config.deterministicIds ?? config.enabled,
+    generatorString: config.generatorString ?? DEFAULT_GENERATOR,
+    includeManifest: config.includeManifest ?? false
+  };
+  const rng = createSeededRNG(fullConfig.randomSeed);
+  function random() {
+    return fullConfig.enabled ? rng.next() : Math.random();
+  }
+  function randomInt(min, max) {
+    return fullConfig.enabled ? rng.nextInt(min, max) : Math.floor(Math.random() * (max - min + 1)) + min;
+  }
+  function timestamp() {
+    return fullConfig.enabled ? fullConfig.fixedTimestamp : (/* @__PURE__ */ new Date()).toISOString();
+  }
+  function timestampDate() {
+    return fullConfig.enabled ? new Date(fullConfig.fixedTimestamp) : /* @__PURE__ */ new Date();
+  }
+  function uuid() {
+    if (!fullConfig.enabled || !fullConfig.deterministicIds) {
+      return crypto?.randomUUID?.() ?? rng.nextUUID();
+    }
+    return rng.nextUUID();
+  }
+  function generator() {
+    return fullConfig.generatorString;
+  }
+  function stabilize(value) {
+    if (!fullConfig.enabled || !fullConfig.sortKeys) return value;
+    return sortKeysDeep(value);
+  }
+  function manifest(composition) {
+    return {
+      reproducible: true,
+      seed: fullConfig.randomSeed,
+      timestamp: fullConfig.fixedTimestamp,
+      inputHash: hashComposition(composition),
+      compilerVersion: COMPILER_VERSION
+    };
+  }
+  function reset() {
+    rng.reset();
+  }
+  function stringify(value, indent = 2) {
+    const processed = fullConfig.enabled && fullConfig.sortKeys ? sortKeysDeep(value) : value;
+    return JSON.stringify(processed, null, indent);
+  }
+  return {
+    enabled: fullConfig.enabled,
+    config: fullConfig,
+    random,
+    randomInt,
+    timestamp,
+    timestampDate,
+    uuid,
+    generator,
+    stabilize,
+    manifest,
+    reset,
+    stringify
+  };
+}
+function parseReproducibilityFlags(args) {
+  const config = { enabled: false };
+  for (const arg of args) {
+    if (arg === "--reproducible") {
+      config.enabled = true;
+    }
+    if (arg === "--no-reproducible") {
+      config.enabled = false;
+    }
+    if (arg.startsWith("--reproducible-seed=")) {
+      config.enabled = true;
+      config.randomSeed = parseInt(arg.split("=")[1], 10);
+      if (isNaN(config.randomSeed)) config.randomSeed = DEFAULT_SEED;
+    }
+    if (arg.startsWith("--reproducible-timestamp=")) {
+      config.enabled = true;
+      config.fixedTimestamp = arg.split("=")[1].replace(/"/g, "");
+    }
+    if (arg === "--reproducible-manifest") {
+      config.includeManifest = true;
+    }
+  }
+  return config;
+}
+var ReproducibilityMode_default = createReproducibilityContext;
+
+export { ReproducibilityMode_default, createReproducibilityContext, createSeededRNG, fnv1a32, hashComposition, parseReproducibilityFlags, sortKeysDeep };
+//# sourceMappingURL=chunk-5GLCTO44.js.map
+//# sourceMappingURL=chunk-5GLCTO44.js.map

package/dist/chunk-5JEU52DW.js

@@ -0,0 +1,382 @@
+import { init_safeJsonParse, readJson } from './chunk-VVKVQZI6.js';
+import * as path from 'path';
+import * as fs from 'fs';
+
+// src/interop/Interoperability.ts
+init_safeJsonParse();
+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.dirname(fromPath) : this.basePath;
+      const resolved = path.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.dirname(current)) {
+      const nodeModulesPath = path.join(current, "node_modules", modulePath);
+      if (fs.existsSync(nodeModulesPath)) {
+        return nodeModulesPath;
+      }
+      const packageJsonPath = path.join(nodeModulesPath, "package.json");
+      if (fs.existsSync(packageJsonPath)) {
+        const packageJson = readJson(fs.readFileSync(packageJsonPath, "utf-8"));
+        return this.findModuleFile(path.join(nodeModulesPath, packageJson.main || "index.js"));
+      }
+      current = path.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.existsSync(basePath)) {
+      return basePath;
+    }
+    for (const ext of extensions) {
+      const withExt = basePath + ext;
+      if (fs.existsSync(withExt)) {
+        return withExt;
+      }
+    }
+    const indexPath = path.join(basePath, "index");
+    for (const ext of extensions) {
+      const withExt = indexPath + ext;
+      if (fs.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;
+  }
+};
+
+export { AsyncFunctionHandler, ErrorBoundary, ExportImportHandler, InteropContext, ModuleResolver, TypeScriptTypeLoader };
+//# sourceMappingURL=chunk-5JEU52DW.js.map
+//# sourceMappingURL=chunk-5JEU52DW.js.map