@holoscript/core 8.0.7 → 8.0.9

package/dist/{chunk-W6RW64BB.cjs → chunk-HSWBIDZM.cjs}

@@ -1,6 +1,7 @@
 'use strict';
 
-var chunkC37BHB7N_cjs = require('./chunk-C37BHB7N.cjs');
+var chunkESBXUYOC_cjs = require('./chunk-ESBXUYOC.cjs');
+var chunkP26YYPOO_cjs = require('./chunk-P26YYPOO.cjs');
 
 // src/types/AdvancedTypeSystem.ts
 var ExhaustivenessChecker = class {
@@ -148,7 +149,204 @@ var TypeAliasRegistry = class {
   }
 };
 
+// src/compiler/safety/AuthorityEffectBridge.ts
+chunkESBXUYOC_cjs.init_effects();
+var AUTHORITY_WORLD_EFFECT = "authority:world";
+var KNOWN_EFFECTS = new Set(Object.values(chunkESBXUYOC_cjs.EFFECTS_BY_CATEGORY).flat());
+function extractAuthorityEffectNodes(nodes, options = {}) {
+  const effectNodes = [];
+  for (const node of nodes) {
+    visitNode(node, effectNodes, options);
+  }
+  return effectNodes;
+}
+function visitNode(node, effectNodes, options) {
+  const traitConfigs = collectTraitConfigs(node);
+  const sandboxConfig = traitConfigs.get("sandbox_execution");
+  if (sandboxConfig && sandboxRequiresWorldAuthority(sandboxConfig)) {
+    effectNodes.push({
+      type: node.type,
+      name: nodeName(node),
+      traits: ["@sandbox_execution"],
+      calls: [],
+      declaredEffects: extractDeclaredEffects(node, traitConfigs),
+      inferredEffects: [AUTHORITY_WORLD_EFFECT],
+      effectSources: {
+        [AUTHORITY_WORLD_EFFECT]: [
+          '@sandbox_execution allow_native_modules=true with permissions.filesystem="all"'
+        ]
+      },
+      line: sourceLine(node),
+      column: sourceColumn(node),
+      file: options.file
+    });
+  }
+  for (const child of childNodes(node)) {
+    visitNode(child, effectNodes, options);
+  }
+}
+function collectTraitConfigs(node) {
+  const configs = /* @__PURE__ */ new Map();
+  if (node.traits instanceof Map) {
+    for (const [name, config] of node.traits) {
+      if (isRecord(config)) {
+        configs.set(normalizeTraitName(String(name)), config);
+      }
+    }
+  }
+  for (const directive of directiveRecords(node)) {
+    if (directive.type === "trait" && typeof directive.name === "string") {
+      configs.set(normalizeTraitName(directive.name), directiveConfig(directive));
+    }
+  }
+  return configs;
+}
+function extractDeclaredEffects(node, traitConfigs) {
+  const effects = /* @__PURE__ */ new Set();
+  const record = node;
+  for (const effect of readEffects(record.declaredEffects)) {
+    effects.add(effect);
+  }
+  for (const directive of directiveRecords(node)) {
+    if (directive.type === "authority") {
+      for (const effect of readEffectsFromRecord(directiveConfig(directive))) {
+        effects.add(effect);
+      }
+    }
+    if (directive.type === "trait" && typeof directive.name === "string" && isEffectDeclarationTrait(directive.name)) {
+      for (const effect of readEffectsFromRecord(directiveConfig(directive))) {
+        effects.add(effect);
+      }
+    }
+  }
+  for (const [name, config] of traitConfigs) {
+    if (isEffectDeclarationTrait(name) || name === "authority") {
+      for (const effect of readEffectsFromRecord(config)) {
+        effects.add(effect);
+      }
+    }
+  }
+  return [...effects];
+}
+function sandboxRequiresWorldAuthority(config) {
+  const permissions = asRecord(config.permissions);
+  const filesystemValue = permissions?.filesystem;
+  const filesystem = typeof filesystemValue === "string" ? filesystemValue : "";
+  return asBoolean(config.allow_native_modules) && filesystem.toLowerCase() === "all";
+}
+function readEffectsFromRecord(record) {
+  return [
+    ...readEffects(record.effect),
+    ...readEffects(record.effects),
+    ...readEffects(record.allow),
+    ...readEffects(record.declaredEffects),
+    ...readEffects(record.authority_effects),
+    ...readEffects(record.authorityEffects)
+  ];
+}
+function readEffects(value) {
+  if (typeof value === "string") {
+    return isVREffect(value) ? [value] : [];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap((entry) => readEffects(entry));
+  }
+  return [];
+}
+function isVREffect(value) {
+  return KNOWN_EFFECTS.has(value);
+}
+function isEffectDeclarationTrait(name) {
+  const normalized = normalizeTraitName(name);
+  return normalized === "effect" || normalized === "effects" || normalized === "authority_effect" || normalized === "authority_effects";
+}
+function directiveRecords(node) {
+  const record = node;
+  const directives = record.directives;
+  if (!Array.isArray(directives)) {
+    return [];
+  }
+  return directives.filter(isRecord);
+}
+function directiveConfig(directive) {
+  const config = isRecord(directive.config) ? directive.config : {};
+  const topLevel = {};
+  for (const [key, value] of Object.entries(directive)) {
+    if (key !== "type" && key !== "name" && key !== "config") {
+      topLevel[key] = value;
+    }
+  }
+  return { ...topLevel, ...config };
+}
+function childNodes(node) {
+  const record = node;
+  const children = [];
+  for (const key of ["children", "body"]) {
+    const value = record[key];
+    if (!Array.isArray(value)) {
+      continue;
+    }
+    for (const child of value) {
+      if (isAstNodeLike(child)) {
+        children.push(child);
+      }
+    }
+  }
+  return children;
+}
+function nodeName(node) {
+  const record = node;
+  const value = record.name || record.id || record.label;
+  return typeof value === "string" ? value : "<anonymous>";
+}
+function sourceLine(node) {
+  const record = node;
+  if (typeof record.line === "number") {
+    return record.line;
+  }
+  if (Array.isArray(record.position) && typeof record.position[0] === "number") {
+    return record.position[0];
+  }
+  const loc = asRecord(record.loc);
+  const start = asRecord(loc?.start);
+  if (typeof start?.line === "number") {
+    return start.line;
+  }
+  return void 0;
+}
+function sourceColumn(node) {
+  const record = node;
+  if (typeof record.column === "number") {
+    return record.column;
+  }
+  if (Array.isArray(record.position) && typeof record.position[1] === "number") {
+    return record.position[1];
+  }
+  const loc = asRecord(record.loc);
+  const start = asRecord(loc?.start);
+  if (typeof start?.column === "number") {
+    return start.column;
+  }
+  return void 0;
+}
+function normalizeTraitName(name) {
+  return name.startsWith("@") ? name.slice(1) : name;
+}
+function asBoolean(value) {
+  return value === true || value === "true";
+}
+function asRecord(value) {
+  return isRecord(value) ? value : void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isAstNodeLike(value) {
+  return isRecord(value) && typeof value.type === "string";
+}
+
 // src/HoloScriptTypeChecker.ts
+chunkESBXUYOC_cjs.init_EffectChecker();
 var BUILTIN_FUNCTIONS = /* @__PURE__ */ new Map([
   [
     "add",
@@ -393,7 +591,7 @@ var HoloScriptTypeChecker = class {
    * Call before check() when you have a holoscript.config.json.
    */
   loadConfig(config) {
-    this.customConstraints = chunkC37BHB7N_cjs.loadConstraintsFromConfig(config);
+    this.customConstraints = chunkP26YYPOO_cjs.loadConstraintsFromConfig(config);
   }
   /**
    * Register a type alias (e.g. from a `type Foo = ...` declaration in source).
@@ -420,6 +618,7 @@ var HoloScriptTypeChecker = class {
       this.collectDeclaration(node);
     }
     this.checkBlock(ast);
+    this.validateAuthorityEffects(ast);
     return {
       valid: this.diagnostics.filter((d) => d.severity === "error").length === 0,
       diagnostics: this.diagnostics,
@@ -1084,7 +1283,7 @@ var HoloScriptTypeChecker = class {
       return;
     }
     const traitNames = Array.from(traitsMap.keys());
-    const allConstraints = [...chunkC37BHB7N_cjs.BUILTIN_CONSTRAINTS, ...this.customConstraints];
+    const allConstraints = [...chunkP26YYPOO_cjs.BUILTIN_CONSTRAINTS, ...this.customConstraints];
     for (const constraint of allConstraints) {
       if (constraint.type === "requires") {
         if (traitNames.includes(constraint.source)) {
@@ -1128,6 +1327,30 @@ var HoloScriptTypeChecker = class {
       }
     }
   }
+  validateAuthorityEffects(ast) {
+    const effectNodes = extractAuthorityEffectNodes(ast);
+    if (effectNodes.length === 0) {
+      return;
+    }
+    const checker = chunkESBXUYOC_cjs.createEffectChecker({
+      ignoredCategories: ["io"],
+      unusedDeclaredSeverity: "info"
+    });
+    const result = checker.checkModule(effectNodes);
+    for (const violation of result.violations) {
+      this.diagnostics.push({
+        severity: violation.severity,
+        message: `Compile-time Authority effect violation: ${violation.message}`,
+        line: violation.source.line ?? 0,
+        column: violation.source.column ?? 0,
+        code: "HSP030",
+        suggestions: [
+          'Declare @authority { effects: ["authority:world"] } on the same node.',
+          'Or remove allow_native_modules=true / permissions.filesystem="all" from @sandbox_execution.'
+        ]
+      });
+    }
+  }
   /**
    * Add a diagnostic
    */
@@ -1215,5 +1438,5 @@ function createTypeChecker() {
 
 exports.HoloScriptTypeChecker = HoloScriptTypeChecker;
 exports.createTypeChecker = createTypeChecker;
-//# sourceMappingURL=chunk-W6RW64BB.cjs.map
-//# sourceMappingURL=chunk-W6RW64BB.cjs.map
+//# sourceMappingURL=chunk-HSWBIDZM.cjs.map
+//# sourceMappingURL=chunk-HSWBIDZM.cjs.map