@holoscript/core 6.0.3 → 7.0.0

package/dist/chunk-WFJIDI2N.cjs

@@ -1,424 +0,0 @@
-'use strict';
-
-var chunkQHVVVN47_cjs = require('./chunk-QHVVVN47.cjs');
-var chunkEGIZHYJP_cjs = require('./chunk-EGIZHYJP.cjs');
-
-// src/compiler/DTDLCompiler.ts
-var DTDLCompiler_exports = {};
-chunkEGIZHYJP_cjs.__export(DTDLCompiler_exports, {
-  DTDLCompiler: () => exports.DTDLCompiler,
-  DTDL_TRAIT_COMPONENTS: () => exports.DTDL_TRAIT_COMPONENTS,
-  default: () => exports.DTDLCompiler_default
-});
-exports.DTDLCompiler = void 0; exports.DTDL_TRAIT_COMPONENTS = void 0; exports.DTDLCompiler_default = void 0;
-var init_DTDLCompiler = chunkEGIZHYJP_cjs.__esm({
-  "src/compiler/DTDLCompiler.ts"() {
-    chunkQHVVVN47_cjs.init_CompilerBase();
-    chunkQHVVVN47_cjs.init_ANSNamespace();
-    exports.DTDLCompiler = class extends chunkQHVVVN47_cjs.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 chunkQHVVVN47_cjs.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("");
-      }
-    };
-    exports.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" }
-        ]
-      }
-    ];
-    exports.DTDLCompiler_default = exports.DTDLCompiler;
-  }
-});
-
-exports.DTDLCompiler_exports = DTDLCompiler_exports;
-exports.init_DTDLCompiler = init_DTDLCompiler;
-//# sourceMappingURL=chunk-WFJIDI2N.cjs.map
-//# sourceMappingURL=chunk-WFJIDI2N.cjs.map

package/dist/chunk-WN3YF33G.cjs

@@ -1,118 +0,0 @@
-'use strict';
-
-var chunkAIUXRS74_cjs = require('./chunk-AIUXRS74.cjs');
-var chunkEGIZHYJP_cjs = require('./chunk-EGIZHYJP.cjs');
-
-// src/compiler/StateCompiler.ts
-var StateCompiler_exports = {};
-chunkEGIZHYJP_cjs.__export(StateCompiler_exports, {
-  StateCompiler: () => exports.StateCompiler,
-  UnauthorizedStateCompilerAccessError: () => exports.UnauthorizedStateCompilerAccessError
-});
-exports.StateCompiler = void 0; exports.UnauthorizedStateCompilerAccessError = void 0;
-var init_StateCompiler = chunkEGIZHYJP_cjs.__esm({
-  "src/compiler/StateCompiler.ts"() {
-    chunkAIUXRS74_cjs.init_AgentRBAC();
-    exports.StateCompiler = class {
-      /**
-       * Walk an entire HSPlusAST and extract all per-node stateBlocks.
-       *
-       * @param ast - The parse result returned by HoloScriptPlusParser.
-       * @param agentToken - JWT token proving agent identity (optional for backwards compatibility).
-       * @returns A StateShapeMap keyed by node.name (or a generated id).
-       * @throws UnauthorizedStateCompilerAccessError if token is provided but invalid.
-       */
-      compile(ast, agentToken) {
-        this.validateAccess(agentToken);
-        const shapes = /* @__PURE__ */ new Map();
-        this.walkNode(ast.root, shapes);
-        return shapes;
-      }
-      // ---------------------------------------------------------------------------
-      // RBAC enforcement
-      // ---------------------------------------------------------------------------
-      /**
-       * Validate agent has permission to compile state blocks.
-       * Skips validation when no token is provided (backwards compatibility / testing).
-       */
-      validateAccess(agentToken) {
-        if (!agentToken) return;
-        const rbac = chunkAIUXRS74_cjs.getRBAC();
-        const decision = rbac.checkAccess({
-          token: agentToken,
-          resourceType: "ast" /* AST */,
-          operation: "read",
-          expectedWorkflowStep: "generate_assembly" /* GENERATE_ASSEMBLY */
-        });
-        if (!decision.allowed) {
-          throw new exports.UnauthorizedStateCompilerAccessError(decision, "StateCompiler");
-        }
-      }
-      /**
-       * Compile a single HSPlusNode subtree.
-       * Useful when only a portion of the AST is being (re-)compiled.
-       */
-      compileNode(node) {
-        if (!node.stateBlock || Object.keys(node.stateBlock).length === 0) {
-          return null;
-        }
-        return this.buildShape(node);
-      }
-      // ---------------------------------------------------------------------------
-      // Private helpers
-      // ---------------------------------------------------------------------------
-      walkNode(node, out) {
-        if (!node) return;
-        if (node.stateBlock && Object.keys(node.stateBlock).length > 0) {
-          const shape = this.buildShape(node);
-          out.set(shape.nodeId, shape);
-        }
-        if (Array.isArray(node.children)) {
-          for (const child of node.children) {
-            this.walkNode(child, out);
-          }
-        }
-        if (node.body && typeof node.body === "object" && !Array.isArray(node.body)) {
-          if (node.body.type) {
-            this.walkNode(node.body, out);
-          }
-        }
-      }
-      buildShape(node) {
-        const nodeId = this.resolveNodeId(node);
-        const stateBlock = node.stateBlock ?? {};
-        const vars = [];
-        const initialState = {};
-        for (const [key, value] of Object.entries(stateBlock)) {
-          if (key.startsWith("__spread_")) continue;
-          vars.push({ name: key, initialValue: value });
-          initialState[key] = value;
-        }
-        return { nodeId, initialState, vars };
-      }
-      resolveNodeId(node) {
-        if (node.name) return node.name;
-        const loc = node.loc;
-        if (loc) return `${node.type}@${loc.start.line}:${loc.start.column}`;
-        return `${node.type}_${Math.random().toString(36).slice(2, 7)}`;
-      }
-    };
-    exports.UnauthorizedStateCompilerAccessError = class extends Error {
-      constructor(decision, compilerName) {
-        super(
-          `[${compilerName}] Unauthorized access: ${decision.reason || "Access denied"}
-Agent Role: ${decision.agentRole || "unknown"}
-Required Permission: ${decision.requiredPermission || "unknown"}`
-        );
-        this.decision = decision;
-        this.compilerName = compilerName;
-        this.name = "UnauthorizedStateCompilerAccessError";
-      }
-    };
-  }
-});
-
-exports.StateCompiler_exports = StateCompiler_exports;
-exports.init_StateCompiler = init_StateCompiler;
-//# sourceMappingURL=chunk-WN3YF33G.cjs.map
-//# sourceMappingURL=chunk-WN3YF33G.cjs.map