@holoscript/core 6.0.4 → 7.0.0

package/dist/chunk-IWI6J7FX.js

@@ -1,421 +0,0 @@
-import { init_CompilerBase, CompilerBase } from './chunk-6XSERL6L.js';
-import { __export, __esm } from './chunk-2CWOLHTE.js';
-import { ANSCapabilityPath } from '@holoscript/platform';
-
-// src/compiler/DTDLCompiler.ts
-var DTDLCompiler_exports = {};
-__export(DTDLCompiler_exports, {
-  DTDLCompiler: () => DTDLCompiler,
-  DTDL_TRAIT_COMPONENTS: () => DTDL_TRAIT_COMPONENTS,
-  default: () => DTDLCompiler_default
-});
-var DTDLCompiler, DTDL_TRAIT_COMPONENTS, DTDLCompiler_default;
-var init_DTDLCompiler = __esm({
-  "src/compiler/DTDLCompiler.ts"() {
-    init_CompilerBase();
-    DTDLCompiler = class extends CompilerBase {
-      constructor(options = {}) {
-        super();
-        this.compilerName = "DTDLCompiler";
-        this.generatedInterfaces = [];
-        this.options = {
-          dtdlVersion: options.dtdlVersion ?? 3,
-          namespace: options.namespace || "dtmi:holoscript",
-          modelVersion: options.modelVersion ?? 1,
-          includeDescriptions: options.includeDescriptions ?? true,
-          includeTraitComponents: options.includeTraitComponents ?? true
-        };
-      }
-      getRequiredCapability() {
-        return ANSCapabilityPath.DTDL;
-      }
-      /**
-       * Get trait name from either string or { name: string } format
-       */
-      getTraitName(trait) {
-        return typeof trait === "string" ? trait : trait.name;
-      }
-      /**
-       * Check if traits include a specific trait name
-       */
-      hasTrait(traits, targetTrait) {
-        return traits?.some((t) => this.getTraitName(t) === targetTrait) ?? false;
-      }
-      compile(composition, agentToken, outputPath) {
-        this.validateCompilerAccess(agentToken, outputPath);
-        this.generatedInterfaces = [];
-        if (composition.templates) {
-          for (const template of composition.templates) {
-            this.generatedInterfaces.push(this.compileTemplate(template));
-          }
-        }
-        const mainInterface = this.compileComposition(composition);
-        this.generatedInterfaces.push(mainInterface);
-        if (composition.objects) {
-          for (const obj of composition.objects) {
-            if (this.objectNeedsInterface(obj)) {
-              this.generatedInterfaces.push(this.compileObject(obj));
-            }
-          }
-        }
-        return JSON.stringify(this.generatedInterfaces, null, 2);
-      }
-      compileComposition(composition) {
-        const modelId = this.generateModelId(composition.name);
-        const contents = [];
-        if (composition.environment) {
-          contents.push(...this.compileEnvironmentProperties(composition.environment));
-        }
-        if (composition.state) {
-          contents.push(...this.compileStateProperties(composition.state));
-        }
-        if (composition.logic) {
-          contents.push(...this.compileLogicCommands(composition.logic));
-        }
-        if (composition.objects) {
-          for (const obj of composition.objects) {
-            contents.push(this.createObjectRelationship(obj));
-          }
-        }
-        if (composition.spatialGroups) {
-          for (const group of composition.spatialGroups) {
-            contents.push({
-              "@type": "Relationship",
-              name: this.sanitizeName(group.name),
-              displayName: group.name,
-              description: `Spatial group containing ${group.objects?.length || 0} objects`
-            });
-          }
-        }
-        const iface = {
-          "@context": this.getDtdlContext(),
-          "@type": "Interface",
-          "@id": modelId,
-          displayName: composition.name,
-          contents
-        };
-        if (this.options.includeDescriptions) {
-          iface.description = `Generated from HoloScript composition "${this.escapeStringValue(composition.name, "TypeScript")}"`;
-        }
-        return iface;
-      }
-      compileTemplate(template) {
-        const modelId = this.generateModelId(template.name);
-        const contents = [];
-        if (template.state) {
-          contents.push(...this.compileStateProperties(template.state));
-        }
-        if (template.actions) {
-          for (const action of template.actions) {
-            contents.push({
-              "@type": "Command",
-              name: action.name,
-              displayName: action.name,
-              description: `Action defined in template ${this.escapeStringValue(template.name, "TypeScript")}`
-            });
-          }
-        }
-        if (template.traits && this.options.includeTraitComponents) {
-          for (const trait of template.traits) {
-            const traitName = typeof trait === "string" ? trait : trait.name;
-            const component = this.traitToComponent(traitName);
-            if (component) {
-              contents.push(component);
-            }
-          }
-        }
-        const iface = {
-          "@context": this.getDtdlContext(),
-          "@type": "Interface",
-          "@id": modelId,
-          displayName: template.name,
-          contents
-        };
-        const templateExt = template;
-        if (templateExt.extends) {
-          iface.extends = [this.generateModelId(templateExt.extends)];
-        }
-        return iface;
-      }
-      compileObject(obj) {
-        const modelId = this.generateModelId(obj.name);
-        const contents = [];
-        const posProp = obj.properties.find((p) => p.key === "position");
-        if (posProp) {
-          contents.push({
-            "@type": ["Property", "Location"],
-            name: "position",
-            schema: {
-              "@type": "Object",
-              fields: [
-                { name: "x", schema: "double" },
-                { name: "y", schema: "double" },
-                { name: "z", schema: "double" }
-              ]
-            },
-            writable: true
-          });
-        }
-        for (const prop of obj.properties) {
-          if (prop.key !== "position" && prop.key !== "geometry") {
-            contents.push(this.propertyToContent(prop.key, prop.value));
-          }
-        }
-        if (this.hasTrait(obj.traits, "sensor") || this.hasTrait(obj.traits, "observable")) {
-          contents.push({
-            "@type": "Telemetry",
-            name: "sensorReading",
-            schema: "double",
-            description: "Sensor telemetry data"
-          });
-        }
-        if (obj.traits && this.options.includeTraitComponents) {
-          for (const trait of obj.traits) {
-            const traitName = this.getTraitName(trait);
-            const component = this.traitToComponent(traitName);
-            if (component) {
-              contents.push(component);
-            }
-          }
-        }
-        const iface = {
-          "@context": this.getDtdlContext(),
-          "@type": "Interface",
-          "@id": modelId,
-          displayName: obj.name,
-          contents
-        };
-        if (obj.template) {
-          iface.extends = this.generateModelId(obj.template);
-        }
-        return iface;
-      }
-      compileEnvironmentProperties(env) {
-        const props = [];
-        const envExt = env;
-        if (Array.isArray(envExt.properties)) {
-          for (const prop of envExt.properties) {
-            this.addEnvironmentProperty(props, prop.key, prop.value);
-          }
-        } else {
-          for (const key of Object.keys(envExt)) {
-            if (key !== "type") {
-              this.addEnvironmentProperty(props, key, envExt[key]);
-            }
-          }
-        }
-        return props;
-      }
-      addEnvironmentProperty(props, key, _value) {
-        if (key === "skybox") {
-          props.push({
-            "@type": "Property",
-            name: "skybox",
-            schema: "string",
-            displayName: "Skybox",
-            description: "Environment skybox setting"
-          });
-        } else if (key === "ambient_light") {
-          props.push({
-            "@type": "Property",
-            name: "ambientLight",
-            schema: "double",
-            displayName: "Ambient Light",
-            description: "Ambient light level"
-          });
-        } else if (key === "fog") {
-          props.push({
-            "@type": "Property",
-            name: "fogEnabled",
-            schema: "boolean",
-            displayName: "Fog Enabled"
-          });
-        }
-      }
-      compileStateProperties(state) {
-        const props = [];
-        for (const prop of state.properties) {
-          props.push(this.propertyToContent(prop.key, prop.value));
-        }
-        return props;
-      }
-      compileLogicCommands(logic) {
-        const commands = [];
-        const logicExt = logic;
-        const items = logicExt.handlers || logicExt.rules || [];
-        for (const item of items) {
-          const event = item.event;
-          if (event?.startsWith("on_")) {
-            commands.push({
-              "@type": "Command",
-              name: event.replace("on_", ""),
-              displayName: this.formatEventName(event),
-              description: `Event handler for ${event}`
-            });
-          }
-        }
-        return commands;
-      }
-      propertyToContent(key, value) {
-        return {
-          "@type": "Property",
-          name: this.sanitizeName(key),
-          schema: this.inferSchema(value),
-          displayName: this.formatDisplayName(key),
-          writable: true
-        };
-      }
-      createObjectRelationship(obj) {
-        return {
-          "@type": "Relationship",
-          name: `has${this.pascalCase(obj.name)}`,
-          displayName: obj.name,
-          target: this.objectNeedsInterface(obj) ? this.generateModelId(obj.name) : void 0,
-          maxMultiplicity: 1
-        };
-      }
-      traitToComponent(trait) {
-        const traitComponents = {
-          grabbable: {
-            schema: `${this.options.namespace}:component:Grabbable;${this.options.modelVersion}`,
-            description: "Allows object to be grabbed/manipulated"
-          },
-          networked: {
-            schema: `${this.options.namespace}:component:Networked;${this.options.modelVersion}`,
-            description: "Enables network synchronization"
-          },
-          physics: {
-            schema: `${this.options.namespace}:component:Physics;${this.options.modelVersion}`,
-            description: "Enables physics simulation"
-          },
-          collidable: {
-            schema: `${this.options.namespace}:component:Collidable;${this.options.modelVersion}`,
-            description: "Enables collision detection"
-          },
-          sensor: {
-            schema: `${this.options.namespace}:component:Sensor;${this.options.modelVersion}`,
-            description: "IoT sensor capabilities"
-          },
-          observable: {
-            schema: `${this.options.namespace}:component:Observable;${this.options.modelVersion}`,
-            description: "State observation capabilities"
-          }
-        };
-        const config = traitComponents[trait];
-        if (!config) return null;
-        return {
-          "@type": "Component",
-          name: trait,
-          schema: config.schema,
-          description: config.description
-        };
-      }
-      inferSchema(value) {
-        if (typeof value === "boolean") return "boolean";
-        if (typeof value === "number") {
-          return Number.isInteger(value) ? "integer" : "double";
-        }
-        if (typeof value === "string") return "string";
-        if (Array.isArray(value)) {
-          if (value.length > 0) {
-            return {
-              "@type": "Array",
-              elementSchema: this.inferSchema(value[0])
-            };
-          }
-          return { "@type": "Array", elementSchema: "double" };
-        }
-        if (typeof value === "object" && value !== null) {
-          const fields = Object.entries(value).map(([k, v]) => ({
-            name: k,
-            schema: this.inferSchema(v)
-          }));
-          return { "@type": "Object", fields };
-        }
-        return "string";
-      }
-      getDtdlContext() {
-        return this.options.dtdlVersion === 3 ? "dtmi:dtdl:context;3" : "dtmi:dtdl:context;2";
-      }
-      generateModelId(name) {
-        const sanitized = this.sanitizeName(name);
-        return `${this.options.namespace}:${sanitized};${this.options.modelVersion}`;
-      }
-      objectNeedsInterface(obj) {
-        const hasState = obj.properties.some((p) => p.key === "state" || typeof p.value === "object");
-        const complexTraitList = ["networked", "sensor", "observable", "state"];
-        const hasComplexTraits = obj.traits?.some(
-          (t) => complexTraitList.includes(this.getTraitName(t))
-        );
-        return hasState || hasComplexTraits || false;
-      }
-      sanitizeName(name) {
-        return name.replace(/[^a-zA-Z0-9_]/g, "_").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
-      }
-      formatDisplayName(name) {
-        return name.replace(/_/g, " ").replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase()).trim();
-      }
-      formatEventName(event) {
-        return event.replace(/^on_/, "").replace(/_/g, " ").replace(/^./, (s) => s.toUpperCase());
-      }
-      pascalCase(name) {
-        return name.replace(/[^a-zA-Z0-9]/g, " ").split(" ").map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
-      }
-    };
-    DTDL_TRAIT_COMPONENTS = [
-      {
-        "@context": "dtmi:dtdl:context;3",
-        "@type": "Interface",
-        "@id": "dtmi:holoscript:component:Grabbable;1",
-        displayName: "Grabbable",
-        description: "Component for objects that can be grabbed in VR/AR",
-        contents: [
-          { "@type": "Property", name: "isGrabbed", schema: "boolean", writable: false },
-          { "@type": "Property", name: "grabDistance", schema: "double", writable: true }
-        ]
-      },
-      {
-        "@context": "dtmi:dtdl:context;3",
-        "@type": "Interface",
-        "@id": "dtmi:holoscript:component:Networked;1",
-        displayName: "Networked",
-        description: "Component for network-synchronized objects",
-        contents: [
-          { "@type": "Property", name: "networkId", schema: "string", writable: false },
-          { "@type": "Property", name: "syncRate", schema: "integer", writable: true },
-          { "@type": "Property", name: "ownerId", schema: "string", writable: false }
-        ]
-      },
-      {
-        "@context": "dtmi:dtdl:context;3",
-        "@type": "Interface",
-        "@id": "dtmi:holoscript:component:Physics;1",
-        displayName: "Physics",
-        description: "Component for physics-enabled objects",
-        contents: [
-          { "@type": "Property", name: "mass", schema: "double", writable: true },
-          { "@type": "Property", name: "friction", schema: "double", writable: true },
-          { "@type": "Property", name: "restitution", schema: "double", writable: true },
-          { "@type": "Property", name: "isKinematic", schema: "boolean", writable: true }
-        ]
-      },
-      {
-        "@context": "dtmi:dtdl:context;3",
-        "@type": "Interface",
-        "@id": "dtmi:holoscript:component:Sensor;1",
-        displayName: "Sensor",
-        description: "Component for IoT sensor capabilities",
-        contents: [
-          { "@type": "Property", name: "sensorType", schema: "string", writable: false },
-          { "@type": "Telemetry", name: "value", schema: "double" },
-          { "@type": "Telemetry", name: "timestamp", schema: "dateTime" }
-        ]
-      }
-    ];
-    DTDLCompiler_default = DTDLCompiler;
-  }
-});
-
-export { DTDLCompiler, DTDLCompiler_default, DTDLCompiler_exports, DTDL_TRAIT_COMPONENTS, init_DTDLCompiler };
-//# sourceMappingURL=chunk-IWI6J7FX.js.map
-//# sourceMappingURL=chunk-IWI6J7FX.js.map

package/dist/chunk-K3JDKWGI.cjs

@@ -1,270 +0,0 @@
-'use strict';
-
-var chunk3SAK5KFL_cjs = require('./chunk-3SAK5KFL.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 = chunk3SAK5KFL_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;
-}
-exports.TRAIT_ZERO = void 0; exports.AuthorityTier = void 0; exports.ProvenanceSemiring = void 0;
-var init_ProvenanceSemiring = chunk3SAK5KFL_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" });
-      }
-      /**
-       * 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 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}`
-            );
-        }
-      }
-    };
-  }
-});
-
-exports.authorityWeight = authorityWeight;
-exports.createDeadElement = createDeadElement;
-exports.init_ProvenanceSemiring = init_ProvenanceSemiring;
-exports.init_Semiring = init_Semiring;
-exports.isDeadElement = isDeadElement;
-exports.strategyToSemiring = strategyToSemiring;
-//# sourceMappingURL=chunk-K3JDKWGI.cjs.map
-//# sourceMappingURL=chunk-K3JDKWGI.cjs.map