@holoscript/core 6.0.4 → 7.0.0

package/dist/chunk-A7PIMZGU.js

@@ -1,263 +0,0 @@
-import { __esm } from './chunk-2CWOLHTE.js';
-
-// 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;
-}
-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;
-  }
-}
-var MinPlusSemiring, MaxPlusSemiring, SumProductSemiring;
-var init_Semiring = __esm({
-  "src/compiler/traits/Semiring.ts"() {
-    MinPlusSemiring = {
-      zero: Number.POSITIVE_INFINITY,
-      one: 0,
-      add: (a, b) => Math.min(a, b),
-      mul: minPlusMul
-    };
-    MaxPlusSemiring = {
-      zero: Number.NEGATIVE_INFINITY,
-      one: 0,
-      add: (a, b) => Math.max(a, b),
-      mul: maxPlusMul
-    };
-    SumProductSemiring = {
-      zero: 0,
-      one: 1,
-      add: (a, b) => a + b,
-      mul: (a, b) => a * b
-    };
-  }
-});
-
-// src/compiler/traits/ProvenanceSemiring.ts
-function isDeadElement(value) {
-  return value === TRAIT_ZERO;
-}
-function createDeadElement(subsystem, elementId, reason, originalValue) {
-  return {
-    subsystem,
-    reason,
-    determinedAt: Date.now(),
-    elementId,
-    originalValue
-  };
-}
-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;
-}
-var TRAIT_ZERO, AuthorityTier, ProvenanceSemiring;
-var init_ProvenanceSemiring = __esm({
-  "src/compiler/traits/ProvenanceSemiring.ts"() {
-    init_Semiring();
-    TRAIT_ZERO = /* @__PURE__ */ Symbol.for("HoloScript::TraitZero");
-    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 || {});
-    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" });
-      }
-      /**
-       * 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 a;
-        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}'`);
-          }
-          return {
-            value: semiring.mul(a.value, b.value),
-            source: `${a.source}\u2297${b.source}`,
-            context: weightA >= weightB ? a.context : b.context
-          };
-        }
-        switch (rule.strategy) {
-          case "max":
-            return {
-              value: Math.max(a.value, b.value),
-              source: a.value > b.value ? a.source : b.source
-            };
-          case "min":
-            return {
-              value: Math.min(a.value, b.value),
-              source: a.value < b.value ? a.source : b.source
-            };
-          case "sum":
-            return {
-              value: a.value + b.value,
-              source: `${a.source}+${b.source}`
-            };
-          case "multiply":
-            return {
-              value: a.value * b.value,
-              source: `${a.source}*${b.source}`
-            };
-          case "authority-weighted": {
-            const scaledA = a.value * weightA;
-            const scaledB = b.value * weightB;
-            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) {
-                return weightA >= weightB ? 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;
-              }
-              throw new Error(
-                `Unresolved domain override on '${property}': @${a.source} vs @${b.source}`
-              );
-            }
-          }
-          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, init_ProvenanceSemiring, init_Semiring, isDeadElement, strategyToSemiring };
-//# sourceMappingURL=chunk-A7PIMZGU.js.map
-//# sourceMappingURL=chunk-A7PIMZGU.js.map