@holoscript/core 6.0.4 → 6.1.1

package/dist/chunk-OSYNRVOV.cjs

@@ -0,0 +1,243 @@
+'use strict';
+
+// src/resilience/ResiliencePatterns.ts
+var CircuitBreakerState = /* @__PURE__ */ ((CircuitBreakerState2) => {
+  CircuitBreakerState2["CLOSED"] = "CLOSED";
+  CircuitBreakerState2["OPEN"] = "OPEN";
+  CircuitBreakerState2["HALF_OPEN"] = "HALF_OPEN";
+  return CircuitBreakerState2;
+})(CircuitBreakerState || {});
+var CircuitBreaker = class {
+  constructor(config = {}) {
+    this.state = "CLOSED" /* CLOSED */;
+    this.failureCount = 0;
+    this.successCount = 0;
+    this.lastFailureTime = null;
+    this.failures = [];
+    this.config = {
+      failureThreshold: 5,
+      successThreshold: 2,
+      resetTimeoutMs: 6e4,
+      // 1 minute
+      windowMs: 3e4,
+      // 30 seconds
+      isRetryable: (err) => err instanceof Error,
+      ...config
+    };
+  }
+  /**
+   * Execute function with circuit breaker protection
+   */
+  async execute(fn) {
+    if (this.state === "OPEN" /* OPEN */) {
+      if (Date.now() - (this.lastFailureTime || 0) > this.config.resetTimeoutMs) {
+        this.state = "HALF_OPEN" /* HALF_OPEN */;
+        this.successCount = 0;
+      } else {
+        throw new Error(`Circuit breaker is OPEN. Retry after ${this.config.resetTimeoutMs}ms`);
+      }
+    }
+    try {
+      const result = await fn();
+      this.onSuccess();
+      return result;
+    } catch (error) {
+      this.onFailure(error);
+      throw error;
+    }
+  }
+  onSuccess() {
+    this.failureCount = 0;
+    this.failures = this.failures.filter((f) => Date.now() - f.timestamp < this.config.windowMs);
+    if (this.state === "HALF_OPEN" /* HALF_OPEN */) {
+      this.successCount++;
+      if (this.successCount >= this.config.successThreshold) {
+        this.state = "CLOSED" /* CLOSED */;
+      }
+    }
+  }
+  onFailure(error) {
+    this.lastFailureTime = Date.now();
+    this.failureCount++;
+    this.failures.push({ timestamp: Date.now(), error });
+    this.failures = this.failures.filter((f) => Date.now() - f.timestamp < this.config.windowMs);
+    if (this.state === "HALF_OPEN" /* HALF_OPEN */) {
+      this.state = "OPEN" /* OPEN */;
+    } else if (this.failureCount >= this.config.failureThreshold) {
+      this.state = "OPEN" /* OPEN */;
+      console.error(`Circuit breaker OPEN after ${this.failureCount} failures: ${error.message}`);
+    }
+  }
+  get currentState() {
+    return this.state;
+  }
+  /**
+   * Get current circuit breaker state (accessor method)
+   */
+  getState() {
+    if (this.state === "OPEN" /* OPEN */ && Date.now() - (this.lastFailureTime || 0) > this.config.resetTimeoutMs) {
+      return "HALF_OPEN" /* HALF_OPEN */;
+    }
+    return this.state;
+  }
+  /**
+   * Get circuit breaker metrics
+   */
+  getMetrics() {
+    return {
+      state: this.state,
+      totalFailures: this.failureCount,
+      totalSuccesses: this.successCount,
+      lastFailureTime: this.lastFailureTime,
+      totalRequests: this.failureCount + this.successCount
+    };
+  }
+};
+async function retryWithBackoff(fn, config = {}) {
+  const cfg = {
+    maxAttempts: 3,
+    initialBackoffMs: 100,
+    maxBackoffMs: 1e4,
+    multiplier: 2,
+    jitter: true,
+    isRetryable: (err, attempt) => attempt < cfg.maxAttempts,
+    ...config
+  };
+  let lastError = null;
+  for (let attempt = 1; attempt <= cfg.maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (!cfg.isRetryable(lastError, attempt)) {
+        throw lastError;
+      }
+      if (attempt < cfg.maxAttempts) {
+        const backoff = Math.min(
+          cfg.initialBackoffMs * Math.pow(cfg.multiplier, attempt - 1),
+          cfg.maxBackoffMs
+        );
+        const jitteredBackoff = cfg.jitter ? backoff * (0.5 + Math.random() * 0.5) : backoff;
+        console.warn(
+          `Attempt ${attempt} failed: ${lastError.message}. Retrying in ${Math.round(jitteredBackoff)}ms`
+        );
+        await sleep(jitteredBackoff);
+      }
+    }
+  }
+  throw lastError || new Error("Max retry attempts exceeded");
+}
+var Bulkhead = class {
+  constructor(config = {}) {
+    this.running = 0;
+    this.queue = [];
+    this.config = {
+      maxConcurrent: 10,
+      queueSize: 100,
+      timeoutMs: 3e4,
+      ...config
+    };
+  }
+  /**
+   * Execute function within bulkhead
+   */
+  async execute(fn) {
+    if (this.queue.length >= this.config.queueSize) {
+      throw new Error("Bulkhead queue full - too many pending operations");
+    }
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        const idx = this.queue.findIndex((item) => item.resolve === resolve);
+        if (idx !== -1) {
+          this.queue.splice(idx, 1);
+        }
+        reject(new Error("Bulkhead operation timeout"));
+      }, this.config.timeoutMs);
+      this.queue.push({
+        fn,
+        // @ts-expect-error
+        resolve,
+        reject,
+        timeoutId
+      });
+      this.processQueue();
+    });
+  }
+  processQueue() {
+    while (this.running < this.config.maxConcurrent && this.queue.length > 0) {
+      const item = this.queue.shift();
+      if (!item) break;
+      this.running++;
+      item.fn().then((result) => {
+        clearTimeout(item.timeoutId);
+        item.resolve(result);
+      }).catch((error) => {
+        clearTimeout(item.timeoutId);
+        item.reject(error);
+      }).finally(() => {
+        this.running--;
+        this.processQueue();
+      });
+    }
+  }
+  get stats() {
+    return {
+      running: this.running,
+      queued: this.queue.length
+    };
+  }
+  /**
+   * Get bulkhead state (accessor method)
+   */
+  getState() {
+    return {
+      running: this.running,
+      queued: this.queue.length,
+      maxConcurrent: this.config.maxConcurrent
+    };
+  }
+  /**
+   * Get bulkhead metrics
+   */
+  getMetrics() {
+    return {
+      running: this.running,
+      queued: this.queue.length,
+      utilizationPercent: this.running / this.config.maxConcurrent * 100,
+      queueUtilizationPercent: this.queue.length / this.config.queueSize * 100
+    };
+  }
+};
+async function fallbackChain(strategies) {
+  let lastError = null;
+  for (let i = 0; i < strategies.length; i++) {
+    try {
+      const result = await strategies[i]();
+      return result;
+    } catch (error) {
+      lastError = error;
+      console.warn(`Strategy ${i + 1} failed: ${lastError.message}`);
+    }
+  }
+  throw lastError || new Error("All fallback strategies failed");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withTimeout(promise, timeoutMs) {
+  return Promise.race([
+    promise,
+    new Promise(
+      (_, reject) => setTimeout(() => reject(new Error(`Operation timeout after ${timeoutMs}ms`)), timeoutMs)
+    )
+  ]);
+}
+
+exports.Bulkhead = Bulkhead;
+exports.CircuitBreaker = CircuitBreaker;
+exports.CircuitBreakerState = CircuitBreakerState;
+exports.fallbackChain = fallbackChain;
+exports.retryWithBackoff = retryWithBackoff;
+exports.withTimeout = withTimeout;
+//# sourceMappingURL=chunk-OSYNRVOV.cjs.map
+//# sourceMappingURL=chunk-OSYNRVOV.cjs.map

package/dist/{chunk-TEWCN33Y.js → chunk-P7YIA5LN.js}

@@ -1,7 +1,8 @@
-import { init_DomainBlockCompilerMixin, compileDomainBlocks, inputToUnity, compileInputBlock, navigationToUnity, compileNavigationBlock, renderingToUnity, compileRenderingBlock, proceduralToUnity, compileProceduralBlock, web3ToUnity, compileWeb3Block, architectureToUnity, compileArchitectureBlock, musicToUnity, compileMusicBlock, educationToUnity, compileEducationBlock, datavizToUnity, compileDataVizBlock, iotToUnity, compileIoTBlock, compileRoboticsBlock, roboticsToUnity, compileHealthcareBlock, healthcareToUnity, compilePaymentBlock, paymentToUnity, compileNarrativeBlock, narrativeToUnity, compileWeatherBlock, weatherToUnity, compileAudioSourceBlock, audioSourceToUnity, compilePostProcessingBlock, postProcessingToUnity, compileParticleBlock, particlesToUnity, compilePhysicsBlock, physicsToUnity, compileMaterialBlock, materialToUnity } from './chunk-YQK5JNFK.js';
-import { init_CompilerBase, CompilerBase } from './chunk-6XSERL6L.js';
-import { __export, __esm } from './chunk-2CWOLHTE.js';
-import { ANSCapabilityPath } from '@holoscript/platform';
+import { init_PlatformConditionalCompilerMixin, createPlatformTarget, PlatformConditionalCompilerMixin } from './chunk-GZG4KA4E.js';
+import { init_DomainBlockCompilerMixin, compileDomainBlocks, inputToUnity, compileInputBlock, navigationToUnity, compileNavigationBlock, renderingToUnity, compileRenderingBlock, proceduralToUnity, compileProceduralBlock, web3ToUnity, compileWeb3Block, architectureToUnity, compileArchitectureBlock, musicToUnity, compileMusicBlock, educationToUnity, compileEducationBlock, datavizToUnity, compileDataVizBlock, iotToUnity, compileIoTBlock, compileRoboticsBlock, roboticsToUnity, compileHealthcareBlock, healthcareToUnity, compilePaymentBlock, paymentToUnity, compileNarrativeBlock, narrativeToUnity, compileWeatherBlock, weatherToUnity, compileAudioSourceBlock, audioSourceToUnity, compilePostProcessingBlock, postProcessingToUnity, compileParticleBlock, particlesToUnity, compilePhysicsBlock, physicsToUnity, compileMaterialBlock, materialToUnity } from './chunk-W55Z7QIX.js';
+import { init_CompilerBase, CompilerBase } from './chunk-QTPMJRGS.js';
+import { __export, __esm } from './chunk-OL46QLBJ.js';
+import { ANSCapabilityPath } from '@holoscript/core-types/ans';
 
 // src/compiler/UnityCompiler.ts
 var UnityCompiler_exports = {};
@@ -13,6 +14,7 @@ var init_UnityCompiler = __esm({
   "src/compiler/UnityCompiler.ts"() {
     init_CompilerBase();
     init_DomainBlockCompilerMixin();
+    init_PlatformConditionalCompilerMixin();
     UnityCompiler = class extends CompilerBase {
       constructor(options = {}) {
         super();
@@ -23,14 +25,23 @@ var init_UnityCompiler = __esm({
           namespace: options.namespace || "HoloScene",
           className: options.className || "GeneratedScene",
           useURP: options.useURP ?? true,
-          indent: options.indent || "    "
+          indent: options.indent || "    ",
+          provenanceHash: options.provenanceHash ?? "",
+          holomapPointCloud: options.holomapPointCloud
         };
+        if (options.platformTarget) {
+          this._platformTarget = typeof options.platformTarget === "string" ? createPlatformTarget(options.platformTarget) : options.platformTarget;
+        }
       }
       getRequiredCapability() {
         return ANSCapabilityPath.UNITY;
       }
       compile(composition, agentToken, outputPath) {
         this.validateCompilerAccess(agentToken, outputPath);
+        if (this._platformTarget) {
+          const platformMixin = new PlatformConditionalCompilerMixin();
+          composition = platformMixin.filterForPlatform(composition, this._platformTarget);
+        }
         this.lines = [];
         this.indentLevel = 0;
         this.emit("// Auto-generated by HoloScript UnityCompiler");
@@ -38,6 +49,9 @@ var init_UnityCompiler = __esm({
           `// Source: composition "${this.escapeStringValue(composition.name, "CSharp")}"`
         );
         this.emit("// Do not edit manually \u2014 regenerate from .holo source");
+        if (this.options.provenanceHash) {
+          this.emit(`// Provenance Hash: ${this.options.provenanceHash}`);
+        }
         this.emit("");
         this.emit("using UnityEngine;");
         this.emit("using UnityEngine.UI;");
@@ -101,6 +115,7 @@ var init_UnityCompiler = __esm({
             }
           }
         }
+        this.emitHolomapPointCloudLoader();
         this.indentLevel--;
         this.emit("}");
         this.emit("");
@@ -127,6 +142,75 @@ var init_UnityCompiler = __esm({
         this.emit("}");
         return this.lines.join("\n");
       }
+      emitHolomapPointCloudLoader() {
+        const h = this.options.holomapPointCloud;
+        if (!h || h.pointCount < 1) return;
+        this.emit("    // --- HoloMap point cloud (base64 \u2192 Mesh topology Points) ---");
+        this.emit("    {");
+        const posLit = this.chunkBase64CSharpLiteral(h.positionsB64);
+        const colLit = this.chunkBase64CSharpLiteral(h.colorsB64);
+        this.emit(`      string holomapPosB64 = ${posLit};`);
+        this.emit(`      string holomapColB64 = ${colLit};`);
+        this.emit(`      int holomapN = ${h.pointCount};`);
+        this.emit(
+          "      byte[] holomapPos = System.Convert.FromBase64String(holomapPosB64);"
+        );
+        this.emit(
+          "      byte[] holomapCol = System.Convert.FromBase64String(holomapColB64);"
+        );
+        this.emit("      if (holomapPos.Length >= holomapN * 12 && holomapCol.Length >= holomapN * 3)");
+        this.emit("      {");
+        this.emit(
+          '        var holomapGo = new GameObject("HoloMapReconstructionPoints");'
+        );
+        this.emit("        holomapGo.transform.SetParent(transform, false);");
+        this.emit("        var mesh = new Mesh();");
+        this.emit(
+          "        mesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;"
+        );
+        this.emit("        var verts = new Vector3[holomapN];");
+        this.emit("        var cols = new Color32[holomapN];");
+        this.emit("        var idx = new int[holomapN];");
+        this.emit("        for (int i = 0; i < holomapN; i++)");
+        this.emit("        {");
+        this.emit(
+          "          int p = i * 12; int c = i * 3;"
+        );
+        this.emit(
+          "          verts[i] = new Vector3(System.BitConverter.ToSingle(holomapPos, p), System.BitConverter.ToSingle(holomapPos, p + 4), System.BitConverter.ToSingle(holomapPos, p + 8));"
+        );
+        this.emit(
+          "          cols[i] = new Color32(holomapCol[c], holomapCol[c + 1], holomapCol[c + 2], 255);"
+        );
+        this.emit("          idx[i] = i;");
+        this.emit("        }");
+        this.emit("        mesh.vertices = verts;");
+        this.emit("        mesh.colors32 = cols;");
+        this.emit("        mesh.SetIndices(idx, MeshTopology.Points, 0, true);");
+        this.emit("        mesh.RecalculateBounds();");
+        this.emit("        var mf = holomapGo.AddComponent<MeshFilter>();");
+        this.emit("        mf.sharedMesh = mesh;");
+        this.emit("        var mr = holomapGo.AddComponent<MeshRenderer>();");
+        this.emit(
+          '        var sh = Shader.Find("Universal Render Pipeline/Unlit");'
+        );
+        this.emit(
+          '        if (sh == null) sh = Shader.Find("Unlit/Color");'
+        );
+        this.emit('        mr.sharedMaterial = sh != null ? new Material(sh) : new Material(Shader.Find("Hidden/InternalErrorShader"));');
+        this.emit("      }");
+        this.emit("    }");
+      }
+      /** Concatenated string literals so very large MCP payloads stay valid C#. */
+      chunkBase64CSharpLiteral(b64) {
+        const chunk = 4096;
+        if (b64.length <= chunk) return `"${b64}"`;
+        const parts = [];
+        for (let i = 0; i < b64.length; i += chunk) {
+          parts.push(`"${b64.slice(i, i + chunk)}"`);
+        }
+        return parts.join(" + ");
+      }
       compileDomainBlocks(composition) {
         const domainBlocks = composition.domainBlocks ?? [];
         if (domainBlocks.length === 0) return;
@@ -690,5 +774,5 @@ var init_UnityCompiler = __esm({
 });
 
 export { UnityCompiler, UnityCompiler_exports, init_UnityCompiler };
-//# sourceMappingURL=chunk-TEWCN33Y.js.map
-//# sourceMappingURL=chunk-TEWCN33Y.js.map
+//# sourceMappingURL=chunk-P7YIA5LN.js.map
+//# sourceMappingURL=chunk-P7YIA5LN.js.map

package/dist/chunk-PGANYCAG.cjs

@@ -0,0 +1,220 @@
+'use strict';
+
+// src/testing/DeterminismHarness.ts
+function getGlobal() {
+  return globalThis ?? {};
+}
+function detectRuntime() {
+  const g = getGlobal();
+  if (typeof g.window !== "undefined" && typeof g.document !== "undefined") {
+    return "browser";
+  }
+  if (typeof g.process !== "undefined" && g.process.versions?.node) {
+    return "node";
+  }
+  return "unknown";
+}
+function detectBrowserFromUserAgent(ua) {
+  if (!ua) return {};
+  let browser;
+  let os;
+  if (/Firefox\//.test(ua)) browser = "firefox";
+  else if (/Edg\//.test(ua)) browser = "edge";
+  else if (/Chrome\//.test(ua)) browser = "chromium";
+  else if (/Safari\//.test(ua)) browser = "safari";
+  if (/Windows NT/.test(ua)) os = "windows";
+  else if (/Mac OS X/.test(ua)) os = "macos";
+  else if (/Linux/.test(ua)) os = "linux";
+  else if (/Android/.test(ua)) os = "android";
+  else if (/iPhone|iPad/.test(ua)) os = "ios";
+  return { browser, os };
+}
+async function captureEnvironment(annotations = {}) {
+  const runtime = detectRuntime();
+  const g = getGlobal();
+  const info = { runtime };
+  if (Object.keys(annotations).length > 0) info.annotations = { ...annotations };
+  if (runtime === "browser") {
+    const nav = g.navigator;
+    const ua = nav?.userAgent;
+    info.browser = { userAgent: ua, ...detectBrowserFromUserAgent(ua) };
+    if (nav?.gpu?.requestAdapter) {
+      try {
+        const adapter = await nav.gpu.requestAdapter();
+        let gpuInfo = adapter?.info;
+        if (!gpuInfo && adapter?.requestAdapterInfo) {
+          gpuInfo = await adapter.requestAdapterInfo();
+        }
+        if (gpuInfo) {
+          info.gpu = {
+            vendor: gpuInfo.vendor,
+            architecture: gpuInfo.architecture,
+            device: gpuInfo.device,
+            description: gpuInfo.description,
+            backend: "webgpu"
+          };
+        }
+      } catch {
+      }
+    }
+  } else if (runtime === "node") {
+    const proc = g.process;
+    if (proc) {
+      info.node = {
+        version: proc.versions?.node ?? "unknown",
+        arch: proc.arch ?? "unknown",
+        platform: proc.platform ?? "unknown"
+      };
+    }
+  }
+  return info;
+}
+function toUint8Array(input) {
+  if (input instanceof Uint8Array) return input;
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(input);
+  }
+  const bytes = new Uint8Array(input.length);
+  for (let i = 0; i < input.length; i++) bytes[i] = input.charCodeAt(i) & 255;
+  return bytes;
+}
+function fnv1a64Hex(bytes) {
+  let hash = 0xcbf29ce484222325n;
+  const prime = 0x100000001b3n;
+  const mask = 0xffffffffffffffffn;
+  for (let i = 0; i < bytes.length; i++) {
+    hash = (hash ^ BigInt(bytes[i])) & mask;
+    hash = hash * prime & mask;
+  }
+  return hash.toString(16).padStart(16, "0");
+}
+async function hashBytes(input, algo = "sha256") {
+  const bytes = toUint8Array(input);
+  if (algo === "sha256") {
+    const g = getGlobal();
+    const subtle = g.crypto?.subtle;
+    if (subtle && typeof subtle.digest === "function") {
+      try {
+        const digest = await subtle.digest("SHA-256", bytes);
+        const view = new Uint8Array(digest);
+        let hex = "";
+        for (let i = 0; i < view.length; i++) hex += view[i].toString(16).padStart(2, "0");
+        return `sha256:${hex}`;
+      } catch {
+      }
+    }
+  }
+  return `fnv1a-64:${fnv1a64Hex(bytes)}`;
+}
+var DeterminismHarness = class {
+  constructor(options = {}) {
+    this.options = {
+      captureOutput: options.captureOutput ?? false,
+      hashAlgorithm: options.hashAlgorithm ?? "sha256",
+      annotations: options.annotations ?? {}
+    };
+  }
+  /**
+   * Run a probe function, capture environment, hash the output,
+   * return a structured ProbeResult. Never throws — errors are
+   * caught and reported on the result's `error` field with a
+   * sentinel outputHash of `error:<message>`.
+   */
+  async probe(name, fn, annotations = {}) {
+    const timestamp = Date.now();
+    const mergedAnnotations = { ...this.options.annotations, ...annotations };
+    const environment = await captureEnvironment(mergedAnnotations);
+    const started = typeof performance !== "undefined" ? performance.now() : timestamp;
+    let output;
+    let error;
+    try {
+      output = await fn();
+    } catch (err) {
+      error = err instanceof Error ? err.message : String(err);
+    }
+    const ended = typeof performance !== "undefined" ? performance.now() : Date.now();
+    const durationMs = Math.max(0, ended - started);
+    if (error !== void 0 || output === void 0) {
+      return {
+        name,
+        timestamp,
+        environment,
+        durationMs,
+        outputHash: `error:${error ?? "no-output"}`,
+        outputSize: 0,
+        error
+      };
+    }
+    const outputHash = await hashBytes(output, this.options.hashAlgorithm);
+    const outputSize = output instanceof Uint8Array ? output.byteLength : toUint8Array(output).byteLength;
+    const result = {
+      name,
+      timestamp,
+      environment,
+      durationMs,
+      outputHash,
+      outputSize
+    };
+    if (this.options.captureOutput) result.output = output;
+    return result;
+  }
+  /**
+   * Compare a collection of probe results and report whether they
+   * agree. Groups results by hash so the caller can see which
+   * environments produced which outputs.
+   */
+  static compareResults(results) {
+    if (results.length === 0) {
+      return {
+        probeName: "(empty)",
+        totalResults: 0,
+        uniqueHashes: 0,
+        divergent: false,
+        groups: [],
+        summary: "No results supplied to compare."
+      };
+    }
+    const probeName = results[0].name;
+    const byHash = /* @__PURE__ */ new Map();
+    for (const r of results) {
+      const existing = byHash.get(r.outputHash);
+      if (existing) existing.push(r);
+      else byHash.set(r.outputHash, [r]);
+    }
+    const groups = Array.from(byHash.entries()).map(([hash, rs]) => ({
+      hash,
+      results: rs,
+      environments: rs.map((r) => describeEnvironment(r.environment))
+    }));
+    const divergent = groups.length > 1;
+    const summary = divergent ? `DIVERGENT: ${groups.length} distinct hashes across ${results.length} runs of "${probeName}".` : `CONVERGENT: all ${results.length} runs of "${probeName}" produced hash ${groups[0].hash}.`;
+    return {
+      probeName,
+      totalResults: results.length,
+      uniqueHashes: groups.length,
+      divergent,
+      groups,
+      summary
+    };
+  }
+};
+function describeEnvironment(env) {
+  const parts = [env.runtime];
+  if (env.browser?.browser) parts.push(env.browser.browser);
+  if (env.browser?.os) parts.push(env.browser.os);
+  if (env.node) parts.push(`node ${env.node.version} ${env.node.platform}/${env.node.arch}`);
+  if (env.gpu?.vendor) parts.push(`gpu:${env.gpu.vendor}${env.gpu.architecture ? "/" + env.gpu.architecture : ""}`);
+  if (env.annotations) {
+    for (const [k, v] of Object.entries(env.annotations)) {
+      parts.push(`${k}=${v}`);
+    }
+  }
+  return parts.join(" | ");
+}
+
+exports.DeterminismHarness = DeterminismHarness;
+exports.captureEnvironment = captureEnvironment;
+exports.describeEnvironment = describeEnvironment;
+exports.hashBytes = hashBytes;
+//# sourceMappingURL=chunk-PGANYCAG.cjs.map
+//# sourceMappingURL=chunk-PGANYCAG.cjs.map