@holoscript/core 8.0.8 → 8.0.10

package/dist/chunk-SLHLXUMO.js

@@ -1,445 +0,0 @@
-import { __esm } from './chunk-OL46QLBJ.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;
-}
-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 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" });
-        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);
-          let 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, init_ProvenanceSemiring, init_Semiring, isDeadElement, strategyToSemiring };
-//# sourceMappingURL=chunk-SLHLXUMO.js.map
-//# sourceMappingURL=chunk-SLHLXUMO.js.map