@holoscript/core 8.0.8 → 8.0.9

package/dist/{chunk-GW3LKD5C.js → chunk-DJNH4HFW.js}

@@ -1,4 +1,4 @@
-import { __esm } from './chunk-OL46QLBJ.js';
+import { __esm } from './chunk-W4GABFCR.js';
 
 // src/compiler/platform/PlatformConditional.ts
 function platformCategory(target) {
@@ -527,5 +527,5 @@ var init_PlatformConditionalCompilerMixin = __esm({
 });
 
 export { ALL_PLATFORMS, DEFAULT_EMBODIMENT, PLATFORM_CAPABILITIES, PLATFORM_CATEGORIES, PlatformConditionalCompilerMixin, agentBudgetFor, createPlatformTarget, embodimentFor, filterCompositionForPlatform, hasCapability, init_PlatformConditional, init_PlatformConditionalCompilerMixin, matchesPlatform, matchesPlatformConstraint, normalizePlatformName, platformCategory, resolvePlatforms, selectBlock };
-//# sourceMappingURL=chunk-GW3LKD5C.js.map
-//# sourceMappingURL=chunk-GW3LKD5C.js.map
+//# sourceMappingURL=chunk-DJNH4HFW.js.map
+//# sourceMappingURL=chunk-DJNH4HFW.js.map

package/dist/{chunk-2GCNOI2U.cjs → chunk-DN6F4DHH.cjs}

@@ -326,9 +326,15 @@ var OnnxNodeInferenceAdapter = class {
       );
     }
     this.ort = await import('onnxruntime-node');
-    this.session = await this.ort.InferenceSession.create(path);
+    const wantCuda = this.preferredProvider === "cuda" || typeof process !== "undefined" && process.env?.HOLOSCRIPT_CUDA_EP === "1";
+    const executionProviders = wantCuda ? ["cuda", "cpu"] : ["cpu"];
+    this.session = await this.ort.InferenceSession.create(path, { executionProviders });
     this.resolvedPath = path;
     this.loaded = true;
+    const activeProviders = this.session.executionProviders ?? executionProviders;
+    console.log(
+      `[OnnxNodeInferenceAdapter] loaded "${path}" \u2014 requested: [${executionProviders.join(", ")}], active: [${activeProviders.join(", ")}]`
+    );
   }
   async run(request) {
     if (!this.loaded || !this.session || !this.ort) {
@@ -428,5 +434,5 @@ exports.createTensor = createTensor;
 exports.eluInPlace = eluInPlace;
 exports.matmul = matmul;
 exports.resolveOnnxModelPath = resolveOnnxModelPath;
-//# sourceMappingURL=chunk-2GCNOI2U.cjs.map
-//# sourceMappingURL=chunk-2GCNOI2U.cjs.map
+//# sourceMappingURL=chunk-DN6F4DHH.cjs.map
+//# sourceMappingURL=chunk-DN6F4DHH.cjs.map

package/dist/chunk-DQRJ5RJG.js

@@ -0,0 +1,432 @@
+// src/compiler/traits/Semiring.ts
+function minPlusMul(a, b) {
+  return !Number.isFinite(a) || !Number.isFinite(b) ? Number.POSITIVE_INFINITY : a + b;
+}
+function maxPlusMul(a, b) {
+  return !Number.isFinite(a) || !Number.isFinite(b) ? Number.NEGATIVE_INFINITY : a + b;
+}
+var MinPlusSemiring = {
+  zero: Number.POSITIVE_INFINITY,
+  one: 0,
+  add: (a, b) => Math.min(a, b),
+  mul: minPlusMul
+};
+var MaxPlusSemiring = {
+  zero: Number.NEGATIVE_INFINITY,
+  one: 0,
+  add: (a, b) => Math.max(a, b),
+  mul: maxPlusMul
+};
+var SumProductSemiring = {
+  zero: 0,
+  one: 1,
+  add: (a, b) => a + b,
+  mul: (a, b) => a * b
+};
+function strategyToSemiring(strategy) {
+  switch (strategy) {
+    case "sum":
+    case "multiply":
+      return SumProductSemiring;
+    case "tropical-min-plus":
+      return MinPlusSemiring;
+    case "tropical-max-plus":
+      return MaxPlusSemiring;
+    default:
+      return null;
+  }
+}
+
+// src/compiler/traits/ProvenanceSemiring.ts
+var TRAIT_ZERO = /* @__PURE__ */ Symbol.for("HoloScript::TraitZero");
+function isDeadElement(value) {
+  return value === TRAIT_ZERO;
+}
+function createDeadElement(subsystem, elementId, reason, originalValue) {
+  return {
+    subsystem,
+    reason,
+    determinedAt: Date.now(),
+    elementId,
+    originalValue
+  };
+}
+var AuthorityTier = /* @__PURE__ */ ((AuthorityTier2) => {
+  AuthorityTier2[AuthorityTier2["GUEST"] = 0] = "GUEST";
+  AuthorityTier2[AuthorityTier2["AGENT"] = 25] = "AGENT";
+  AuthorityTier2[AuthorityTier2["MEMBER"] = 50] = "MEMBER";
+  AuthorityTier2[AuthorityTier2["ADMIN"] = 75] = "ADMIN";
+  AuthorityTier2[AuthorityTier2["FOUNDER"] = 100] = "FOUNDER";
+  return AuthorityTier2;
+})(AuthorityTier || {});
+function authorityWeight(level, reputationScore) {
+  const clamped = Math.max(0, Math.min(100, level));
+  let baseWeight = 0.5 + clamped / 100 * 1.5;
+  if (reputationScore !== void 0 && reputationScore > 0) {
+    if (reputationScore >= 100)
+      baseWeight *= 3;
+    else if (reputationScore >= 30)
+      baseWeight *= 2;
+    else if (reputationScore >= 5) baseWeight *= 1.5;
+  }
+  return baseWeight;
+}
+function tieBreakProvenance(a, b) {
+  const aid = String(a.context?.agentId ?? "");
+  const bid = String(b.context?.agentId ?? "");
+  if (aid !== bid) return aid < bid ? a : b;
+  const opA = String(a.context?.opId ?? "");
+  const opB = String(b.context?.opId ?? "");
+  if (opA !== opB) return opA < opB ? a : b;
+  const srcA = String(a.source ?? "");
+  const srcB = String(b.source ?? "");
+  if (srcA !== srcB) return srcA < srcB ? a : b;
+  const ja = canonicalTieValue(a.value);
+  const jb = canonicalTieValue(b.value);
+  if (ja !== jb) return ja <= jb ? a : b;
+  return a;
+}
+function canonicalTieValue(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null) return "null";
+  switch (typeof value) {
+    case "string":
+      return `string:${JSON.stringify(value)}`;
+    case "number":
+      return Number.isFinite(value) ? `number:${value}` : `number:${String(value)}`;
+    case "bigint":
+      return `bigint:${value.toString()}`;
+    case "boolean":
+      return `boolean:${value}`;
+    case "undefined":
+      return "undefined";
+    case "symbol":
+      return `symbol:${String(value)}`;
+    case "function":
+      return `function:${value.name}`;
+  }
+  if (seen.has(value)) return "[Circular]";
+  seen.add(value);
+  let canonical;
+  if (value instanceof Date) {
+    const millis = value.getTime();
+    canonical = Number.isNaN(millis) ? "date:Invalid" : `date:${value.toISOString()}`;
+  } else if (Array.isArray(value)) {
+    canonical = `array:[${value.map((item) => canonicalTieValue(item, seen)).join(",")}]`;
+  } else {
+    const entries = Object.entries(value).sort(
+      ([left], [right]) => left.localeCompare(right)
+    );
+    canonical = `object:{${entries.map(([key, item]) => `${JSON.stringify(key)}:${canonicalTieValue(item, seen)}`).join(",")}}`;
+  }
+  seen.delete(value);
+  return canonical;
+}
+function isVectorValue(v) {
+  return Array.isArray(v) && v.length > 0 && v.every((x) => typeof x === "number");
+}
+function vecMagnitude(v) {
+  let sum = 0;
+  for (const x of v) sum += x * x;
+  return Math.sqrt(sum);
+}
+function vecAdd(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`Vector dimensionality mismatch: ${a.length} vs ${b.length}`);
+  }
+  return a.map((ai, i) => ai + b[i]);
+}
+function vecComponentMax(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`Vector dimensionality mismatch: ${a.length} vs ${b.length}`);
+  }
+  return a.map((ai, i) => Math.max(ai, b[i]));
+}
+function vecComponentMin(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`Vector dimensionality mismatch: ${a.length} vs ${b.length}`);
+  }
+  return a.map((ai, i) => Math.min(ai, b[i]));
+}
+function vecAuthorityPick(a, weightA, b, weightB) {
+  const eps = 1e-12;
+  if (Math.abs(weightA - weightB) > eps) return weightA > weightB ? a : b;
+  const magA = vecMagnitude(a);
+  const magB = vecMagnitude(b);
+  if (Math.abs(magA - magB) > eps) return magA >= magB ? a : b;
+  return JSON.stringify(a) <= JSON.stringify(b) ? a : b;
+}
+var ProvenanceSemiring = class {
+  constructor(rules) {
+    this.rules = /* @__PURE__ */ new Map();
+    if (rules) {
+      for (const rule of rules) {
+        this.rules.set(rule.property, rule);
+      }
+    } else {
+      this.loadDefaultRules();
+    }
+  }
+  loadDefaultRules() {
+    this.rules.set("type", {
+      property: "type",
+      strategy: "domain-override",
+      precedence: ["kinematic", "physics", "collidable", "static"]
+    });
+    this.rules.set("mass", { property: "mass", strategy: "authority-weighted" });
+    this.rules.set("friction", { property: "friction", strategy: "max" });
+    this.rules.set("restitution", { property: "restitution", strategy: "min" });
+    this.rules.set("color", {
+      property: "color",
+      strategy: "domain-override",
+      precedence: ["material", "color", "hoverable", "glowing"]
+    });
+    this.rules.set("opacity", { property: "opacity", strategy: "min" });
+    this.rules.set("velocity", { property: "velocity", strategy: "vec-component-sum" });
+    this.rules.set("acceleration", { property: "acceleration", strategy: "vec-component-sum" });
+    this.rules.set("angularVelocity", {
+      property: "angularVelocity",
+      strategy: "vec-component-sum"
+    });
+    this.rules.set("stressTensor", { property: "stressTensor", strategy: "vec-component-max" });
+    this.rules.set("displacementField", {
+      property: "displacementField",
+      strategy: "vec-magnitude-max"
+    });
+    this.rules.set("forceField", { property: "forceField", strategy: "vec-authority-weighted" });
+  }
+  /**
+   * Commutative addition (⊕)
+   * Merges multiple traits into a unified provenanced configuration map.
+   */
+  add(traits) {
+    const acc = {};
+    const conflicts = [];
+    const errors = [];
+    const deadElements = [];
+    for (const trait of traits) {
+      for (const [key, value] of Object.entries(trait.config)) {
+        if (value === TRAIT_ZERO) {
+          deadElements.push(
+            createDeadElement(
+              "semiring",
+              `${trait.name}.${key}`,
+              `TRAIT_ZERO encountered during addition: property '${key}' from @${trait.name}`
+            )
+          );
+          continue;
+        }
+        if (!(key in acc)) {
+          acc[key] = { value, source: trait.name, context: trait.context };
+        } else {
+          const existing = acc[key];
+          try {
+            acc[key] = this.multiply(
+              existing,
+              { value, source: trait.name, context: trait.context },
+              key
+            );
+            conflicts.push(
+              `Resolved conflict on property '${key}' between @${existing.source} and @${trait.name}`
+            );
+          } catch (err) {
+            errors.push(err instanceof Error ? err.message : String(err));
+          }
+        }
+      }
+    }
+    const finalConfig = {};
+    for (const [k, v] of Object.entries(acc)) {
+      finalConfig[k] = v.value;
+    }
+    return {
+      config: finalConfig,
+      provenance: acc,
+      conflicts,
+      errors,
+      deadElements
+    };
+  }
+  /**
+   * Semiring multiplication (⊗)
+   * Resolves conflicts based on loaded domain rules, enforcing commutativity.
+   *
+   * C1 FIX: Authority no longer bypasses rules. Instead, authority modulates
+   * the weight within rule resolution. Higher authority = higher weight in
+   * numeric strategies, tiebreaker in domain-override. This ensures the
+   * algebraic structure is preserved — crossing an authority threshold
+   * changes the WEIGHT of a resolution, not the MECHANISM.
+   */
+  multiply(a, b, property) {
+    if (a.value === TRAIT_ZERO) return a;
+    if (b.value === TRAIT_ZERO) return b;
+    if (a.value === b.value) return tieBreakProvenance(a, b);
+    const rule = this.rules.get(property);
+    if (!rule) {
+      const authA = a.context?.authorityLevel ?? 0;
+      const authB = b.context?.authorityLevel ?? 0;
+      if (authA !== authB) {
+        return authA > authB ? a : b;
+      }
+      throw new Error(
+        `Unresolved conflict on '${property}': @${a.source} (${a.value}) vs @${b.source} (${b.value})`
+      );
+    }
+    const weightA = authorityWeight(a.context?.authorityLevel ?? 0, a.context?.reputationScore);
+    const weightB = authorityWeight(b.context?.authorityLevel ?? 0, b.context?.reputationScore);
+    if (rule && (rule.strategy === "tropical-min-plus" || rule.strategy === "tropical-max-plus")) {
+      const semiring = strategyToSemiring(rule.strategy);
+      if (!semiring) {
+        throw new Error(`No semiring adapter available for strategy '${rule.strategy}'`);
+      }
+      const srcA = String(a.source);
+      const srcB = String(b.source);
+      const selectedContext = weightA > weightB ? a.context : weightA < weightB ? b.context : tieBreakProvenance(a, b).context;
+      return {
+        value: semiring.mul(a.value, b.value),
+        source: srcA < srcB ? `${srcA}\u2297${srcB}` : `${srcB}\u2297${srcA}`,
+        context: selectedContext
+      };
+    }
+    switch (rule.strategy) {
+      case "max": {
+        const valA = a.value;
+        const valB = b.value;
+        if (valA === valB) return tieBreakProvenance(a, b);
+        return {
+          value: Math.max(valA, valB),
+          source: valA > valB ? a.source : b.source
+        };
+      }
+      case "min": {
+        const valA = a.value;
+        const valB = b.value;
+        if (valA === valB) return tieBreakProvenance(a, b);
+        return {
+          value: Math.min(valA, valB),
+          source: valA < valB ? a.source : b.source
+        };
+      }
+      case "sum": {
+        const srcA = String(a.source);
+        const srcB = String(b.source);
+        return {
+          value: a.value + b.value,
+          source: srcA < srcB ? `${srcA}+${srcB}` : `${srcB}+${srcA}`
+        };
+      }
+      case "multiply": {
+        const srcA = String(a.source);
+        const srcB = String(b.source);
+        return {
+          value: a.value * b.value,
+          source: srcA < srcB ? `${srcA}*${srcB}` : `${srcB}*${srcA}`
+        };
+      }
+      case "authority-weighted": {
+        const scaledA = a.value * weightA;
+        const scaledB = b.value * weightB;
+        const eps = 1e-12;
+        if (Math.abs(scaledA - scaledB) <= eps) {
+          return tieBreakProvenance(a, b);
+        }
+        return scaledA > scaledB ? { value: a.value, source: a.source, context: a.context } : { value: b.value, source: b.source, context: b.context };
+      }
+      case "domain-override": {
+        const precedence = rule.precedence || [];
+        const aIndex = precedence.indexOf(a.source);
+        const bIndex = precedence.indexOf(b.source);
+        if (aIndex !== -1 && bIndex !== -1) {
+          if (aIndex === bIndex) {
+            if (weightA !== weightB) return weightA > weightB ? a : b;
+            return tieBreakProvenance(a, b);
+          }
+          return aIndex < bIndex ? a : b;
+        } else if (aIndex !== -1) {
+          return a;
+        } else if (bIndex !== -1) {
+          return b;
+        } else {
+          if (weightA !== weightB) {
+            return weightA > weightB ? a : b;
+          }
+          return tieBreakProvenance(a, b);
+        }
+      }
+      // ── vector strategies (paper-3 §5.2) ────────────────────────────────
+      case "vec-component-max": {
+        if (!isVectorValue(a.value) || !isVectorValue(b.value)) {
+          throw new Error(
+            `vec-component-max requires VectorValue on property '${property}': got ${JSON.stringify(a.value)} and ${JSON.stringify(b.value)}`
+          );
+        }
+        const srcA = String(a.source);
+        const srcB = String(b.source);
+        return {
+          value: vecComponentMax(a.value, b.value),
+          source: srcA < srcB ? `${srcA}\u2295max${srcB}` : `${srcB}\u2295max${srcA}`
+        };
+      }
+      case "vec-component-min": {
+        if (!isVectorValue(a.value) || !isVectorValue(b.value)) {
+          throw new Error(
+            `vec-component-min requires VectorValue on property '${property}': got ${JSON.stringify(a.value)} and ${JSON.stringify(b.value)}`
+          );
+        }
+        const srcA = String(a.source);
+        const srcB = String(b.source);
+        return {
+          value: vecComponentMin(a.value, b.value),
+          source: srcA < srcB ? `${srcA}\u2295min${srcB}` : `${srcB}\u2295min${srcA}`
+        };
+      }
+      case "vec-component-sum": {
+        if (!isVectorValue(a.value) || !isVectorValue(b.value)) {
+          throw new Error(
+            `vec-component-sum requires VectorValue on property '${property}': got ${JSON.stringify(a.value)} and ${JSON.stringify(b.value)}`
+          );
+        }
+        const srcA = String(a.source);
+        const srcB = String(b.source);
+        return {
+          value: vecAdd(a.value, b.value),
+          source: srcA < srcB ? `${srcA}+${srcB}` : `${srcB}+${srcA}`
+        };
+      }
+      case "vec-magnitude-max": {
+        if (!isVectorValue(a.value) || !isVectorValue(b.value)) {
+          throw new Error(
+            `vec-magnitude-max requires VectorValue on property '${property}': got ${JSON.stringify(a.value)} and ${JSON.stringify(b.value)}`
+          );
+        }
+        const magA = vecMagnitude(a.value);
+        const magB = vecMagnitude(b.value);
+        const eps = 1e-12;
+        if (Math.abs(magA - magB) <= eps) {
+          const srcA = String(a.source);
+          const srcB = String(b.source);
+          return srcA <= srcB ? a : b;
+        }
+        return magA > magB ? a : b;
+      }
+      case "vec-authority-weighted": {
+        if (!isVectorValue(a.value) || !isVectorValue(b.value)) {
+          throw new Error(
+            `vec-authority-weighted requires VectorValue on property '${property}': got ${JSON.stringify(a.value)} and ${JSON.stringify(b.value)}`
+          );
+        }
+        const winner = vecAuthorityPick(a.value, weightA, b.value, weightB);
+        const isA = winner === a.value;
+        return isA ? { value: a.value, source: a.source, context: a.context } : { value: b.value, source: b.source, context: b.context };
+      }
+      case "strict-error":
+      default:
+        throw new Error(
+          `Composition conflict: @${a.source} and @${b.source} both supply '${property}' = ${a.value} vs ${b.value}`
+        );
+    }
+  }
+};
+
+export { AuthorityTier, MaxPlusSemiring, MinPlusSemiring, ProvenanceSemiring, SumProductSemiring, TRAIT_ZERO, authorityWeight, createDeadElement, isDeadElement, strategyToSemiring };
+//# sourceMappingURL=chunk-DQRJ5RJG.js.map
+//# sourceMappingURL=chunk-DQRJ5RJG.js.map