@holoscript/core 6.0.4 → 6.1.1

package/dist/chunk-NW5G5FBQ.js

@@ -0,0 +1,215 @@
+// 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(" | ");
+}
+
+export { DeterminismHarness, captureEnvironment, describeEnvironment, hashBytes };
+//# sourceMappingURL=chunk-NW5G5FBQ.js.map
+//# sourceMappingURL=chunk-NW5G5FBQ.js.map

package/dist/{chunk-E3FWRT3Z.js → chunk-OEFY723R.js}

@@ -1,7 +1,7 @@
-import { init_DomainBlockCompilerMixin, compileDomainBlocks, inputToVRChat, compileInputBlock, navigationToVRChat, compileNavigationBlock, renderingToVRChat, compileRenderingBlock, proceduralToVRChat, compileProceduralBlock, web3ToVRChat, compileWeb3Block, architectureToVRChat, compileArchitectureBlock, musicToVRChat, compileMusicBlock, educationToVRChat, compileEducationBlock, datavizToVRChat, compileDataVizBlock, iotToVRChat, compileIoTBlock, compileRoboticsBlock, roboticsToVRChat, compileHealthcareBlock, healthcareToVRChat, compilePaymentBlock, paymentToVRChat, compileNarrativeBlock, narrativeToVRChat, compileWeatherBlock, weatherToUnity, compileAudioSourceBlock, audioSourceToUnity, compilePostProcessingBlock, postProcessingToUnity, compileParticleBlock, particlesToUnity, compilePhysicsBlock, physicsToUnity, compileMaterialBlock, materialToVRChat } 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_DomainBlockCompilerMixin, compileDomainBlocks, inputToVRChat, compileInputBlock, navigationToVRChat, compileNavigationBlock, renderingToVRChat, compileRenderingBlock, proceduralToVRChat, compileProceduralBlock, web3ToVRChat, compileWeb3Block, architectureToVRChat, compileArchitectureBlock, musicToVRChat, compileMusicBlock, educationToVRChat, compileEducationBlock, datavizToVRChat, compileDataVizBlock, iotToVRChat, compileIoTBlock, compileRoboticsBlock, roboticsToVRChat, compileHealthcareBlock, healthcareToVRChat, compilePaymentBlock, paymentToVRChat, compileNarrativeBlock, narrativeToVRChat, compileWeatherBlock, weatherToUnity, compileAudioSourceBlock, audioSourceToUnity, compilePostProcessingBlock, postProcessingToUnity, compileParticleBlock, particlesToUnity, compilePhysicsBlock, physicsToUnity, compileMaterialBlock, materialToVRChat } 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/VRChatCompiler.ts
 var VRChatCompiler_exports = {};
@@ -26,13 +26,17 @@ var init_VRChatCompiler = __esm({
         this.indentLevel = 0;
         this.udonScripts = /* @__PURE__ */ new Map();
         this.interactableObjects = [];
+        this.worldIdCounter = 0;
+        const outputFormat = options.outputFormat ?? (options.useUdonSharp === false ? "udon-assembly" : "udonsharp-csharp");
         this.options = {
           namespace: options.namespace || "HoloWorld",
           className: options.className || "GeneratedWorld",
           worldName: options.worldName || "HoloScript World",
           indent: options.indent || "    ",
           sdkVersion: options.sdkVersion || "3.5",
-          useUdonSharp: options.useUdonSharp ?? true
+          outputFormat,
+          useUdonSharp: options.useUdonSharp ?? outputFormat === "udonsharp-csharp",
+          provenanceHash: options.provenanceHash ?? ""
         };
       }
       getRequiredCapability() {
@@ -40,6 +44,7 @@ var init_VRChatCompiler = __esm({
       }
       compile(composition, agentToken, outputPath) {
         this.validateCompilerAccess(agentToken, outputPath);
+        this.assertSupportedOutputFormat();
         this.lines = [];
         this.udonScripts.clear();
         this.interactableObjects = [];
@@ -49,12 +54,22 @@ var init_VRChatCompiler = __esm({
         const prefabHierarchy = this.generatePrefabHierarchy(composition);
         const worldDescriptor = this.generateWorldDescriptor(composition);
         return {
+          outputFormat: this.options.outputFormat,
           mainScript,
           udonScripts: this.udonScripts,
           prefabHierarchy,
           worldDescriptor
         };
       }
+      assertSupportedOutputFormat() {
+        if (this.options.outputFormat === "udonsharp-csharp" && this.options.useUdonSharp) {
+          return;
+        }
+        const requested = this.options.outputFormat === "udonsharp-csharp" ? "non-UdonSharp Udon output" : this.options.outputFormat;
+        throw new Error(
+          `VRChat ${requested} output is gated: founder direction is Byte/Udon output, but the artifact contract must be confirmed before implementation (Udon Assembly text vs serialized Udon bytecode asset). The current compiler only emits legacy UdonSharp C# with outputFormat: 'udonsharp-csharp' and useUdonSharp: true.`
+        );
+      }
       generateMainScript(composition) {
         this.lines = [];
         this.indentLevel = 0;
@@ -64,6 +79,9 @@ var init_VRChatCompiler = __esm({
         );
         this.emit(`// VRChat SDK: ${this.options.sdkVersion}`);
         this.emit("// Do not edit manually \xE2\u20AC\u201D regenerate from .holo source");
+        if (this.options.provenanceHash) {
+          this.emit(`// Provenance Hash: ${this.options.provenanceHash}`);
+        }
         this.emit("");
         this.emit("using UdonSharp;");
         this.emit("using UnityEngine;");
@@ -510,12 +528,9 @@ var init_VRChatCompiler = __esm({
         this.emit("");
       }
       generateWorldId() {
-        const chars = "abcdef0123456789";
-        let id = "";
-        for (let i = 0; i < 8; i++) {
-          id += chars[Math.floor(Math.random() * chars.length)];
-        }
-        return id + "-0000-0000-0000-000000000000";
+        const seq = this.worldIdCounter++;
+        const hex = seq.toString(16).padStart(8, "0");
+        return `${hex}-0000-0000-0000-000000000000`;
       }
       // === Utility Methods ===
       emit(line) {
@@ -604,5 +619,5 @@ var init_VRChatCompiler = __esm({
 });
 
 export { VRChatCompiler, VRChatCompiler_exports, compileToVRChat, init_VRChatCompiler };
-//# sourceMappingURL=chunk-E3FWRT3Z.js.map
-//# sourceMappingURL=chunk-E3FWRT3Z.js.map
+//# sourceMappingURL=chunk-OEFY723R.js.map
+//# sourceMappingURL=chunk-OEFY723R.js.map