@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-5S7RKFGR.cjs

@@ -0,0 +1,446 @@
+'use strict';
+
+var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+
+// 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 exports.SumProductSemiring;
+    case "tropical-min-plus":
+      return exports.MinPlusSemiring;
+    case "tropical-max-plus":
+      return exports.MaxPlusSemiring;
+    default:
+      return null;
+  }
+}
+exports.MinPlusSemiring = void 0; exports.MaxPlusSemiring = void 0; exports.SumProductSemiring = void 0;
+var init_Semiring = chunkHCCQLAA4_cjs.__esm({
+  "src/compiler/traits/Semiring.ts"() {
+    exports.MinPlusSemiring = {
+      zero: Number.POSITIVE_INFINITY,
+      one: 0,
+      add: (a, b) => Math.min(a, b),
+      mul: minPlusMul
+    };
+    exports.MaxPlusSemiring = {
+      zero: Number.NEGATIVE_INFINITY,
+      one: 0,
+      add: (a, b) => Math.max(a, b),
+      mul: maxPlusMul
+    };
+    exports.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 === exports.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;
+}
+exports.TRAIT_ZERO = void 0; exports.AuthorityTier = void 0; exports.ProvenanceSemiring = void 0;
+var init_ProvenanceSemiring = chunkHCCQLAA4_cjs.__esm({
+  "src/compiler/traits/ProvenanceSemiring.ts"() {
+    init_Semiring();
+    exports.TRAIT_ZERO = /* @__PURE__ */ Symbol.for("HoloScript::TraitZero");
+    exports.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;
+    })(exports.AuthorityTier || {});
+    exports.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 === exports.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 === exports.TRAIT_ZERO) return a;
+        if (b.value === exports.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}`
+            );
+        }
+      }
+    };
+  }
+});
+
+exports.authorityWeight = authorityWeight;
+exports.createDeadElement = createDeadElement;
+exports.init_ProvenanceSemiring = init_ProvenanceSemiring;
+exports.init_Semiring = init_Semiring;
+exports.isDeadElement = isDeadElement;
+exports.strategyToSemiring = strategyToSemiring;
+//# sourceMappingURL=chunk-5S7RKFGR.cjs.map
+//# sourceMappingURL=chunk-5S7RKFGR.cjs.map