@holoscript/core 8.0.8 → 8.0.10

package/dist/{chunk-VMLKSV26.js → chunk-MDDWEBCX.js}

@@ -1,4 +1,5 @@
-import { loadConstraintsFromConfig, BUILTIN_CONSTRAINTS } from './chunk-XSFNHP2E.js';
+import { init_effects, EFFECTS_BY_CATEGORY, init_EffectChecker, createEffectChecker } from './chunk-ZVFHPMC5.js';
+import { loadConstraintsFromConfig, BUILTIN_CONSTRAINTS } from './chunk-KB26H447.js';
 
 // src/types/AdvancedTypeSystem.ts
 var ExhaustivenessChecker = class {
@@ -146,7 +147,204 @@ var TypeAliasRegistry = class {
   }
 };
 
+// src/compiler/safety/AuthorityEffectBridge.ts
+init_effects();
+var AUTHORITY_WORLD_EFFECT = "authority:world";
+var KNOWN_EFFECTS = new Set(Object.values(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
+init_EffectChecker();
 var BUILTIN_FUNCTIONS = /* @__PURE__ */ new Map([
   [
     "add",
@@ -418,6 +616,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,
@@ -1126,6 +1325,30 @@ var HoloScriptTypeChecker = class {
       }
     }
   }
+  validateAuthorityEffects(ast) {
+    const effectNodes = extractAuthorityEffectNodes(ast);
+    if (effectNodes.length === 0) {
+      return;
+    }
+    const checker = 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
    */
@@ -1212,5 +1435,5 @@ function createTypeChecker() {
 }
 
 export { HoloScriptTypeChecker, createTypeChecker };
-//# sourceMappingURL=chunk-VMLKSV26.js.map
-//# sourceMappingURL=chunk-VMLKSV26.js.map
+//# sourceMappingURL=chunk-MDDWEBCX.js.map
+//# sourceMappingURL=chunk-MDDWEBCX.js.map

package/dist/chunk-MUWH4QK5.cjs

@@ -0,0 +1,94 @@
+'use strict';
+
+// src/matter/StagedMatter.ts
+function consolidate(unitA, unitB) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const mergedHashes = Array.from(
+    /* @__PURE__ */ new Set([...unitA.manifest.provenanceHashes, ...unitB.manifest.provenanceHashes])
+  ).sort();
+  if (!mergedHashes.includes(unitA.provenanceHash)) {
+    mergedHashes.push(unitA.provenanceHash);
+  }
+  if (!mergedHashes.includes(unitB.provenanceHash)) {
+    mergedHashes.push(unitB.provenanceHash);
+  }
+  mergedHashes.sort();
+  const newEdgeA = {
+    from: unitA.provenanceHash,
+    to: "",
+    operation: "consolidate",
+    timestamp: ""
+  };
+  const newEdgeB = {
+    from: unitB.provenanceHash,
+    to: "",
+    operation: "consolidate",
+    timestamp: ""
+  };
+  const hashManifest = {
+    schema: "matter-manifest/v1",
+    provenanceHashes: mergedHashes,
+    derivationEdges: [
+      ...unitA.manifest.derivationEdges,
+      ...unitB.manifest.derivationEdges,
+      newEdgeA,
+      newEdgeB
+    ]
+  };
+  const resultHash = computeProvenanceHash(hashManifest);
+  newEdgeA.to = resultHash;
+  newEdgeA.timestamp = now;
+  newEdgeB.to = resultHash;
+  newEdgeB.timestamp = now;
+  const finalManifest = {
+    schema: "matter-manifest/v1",
+    provenanceHashes: mergedHashes,
+    derivationEdges: [
+      ...unitA.manifest.derivationEdges,
+      ...unitB.manifest.derivationEdges,
+      newEdgeA,
+      newEdgeB
+    ]
+  };
+  return {
+    id: `cons_${resultHash.slice(0, 16)}`,
+    provenanceHash: resultHash,
+    manifest: finalManifest,
+    payload: void 0
+  };
+}
+function computeProvenanceHash(manifest, salt) {
+  const input = (salt ?? "") + JSON.stringify(manifest, Object.keys(manifest).sort());
+  let h0 = 2166136261;
+  let h1 = 3521423859;
+  for (let i = 0; i < input.length; i++) {
+    const c = input.charCodeAt(i);
+    h0 = Math.imul(h0 ^ c, 16777619) >>> 0;
+    h1 = Math.imul(h1 ^ c, 16777619) >>> 0;
+  }
+  const hex0 = h0.toString(16).padStart(8, "0");
+  const hex1 = h1.toString(16).padStart(8, "0");
+  return (hex0 + hex1).repeat(4).slice(0, 64);
+}
+function createMatterUnit(id, payload) {
+  const manifest = {
+    schema: "matter-manifest/v1",
+    provenanceHashes: [],
+    derivationEdges: []
+  };
+  const hash = computeProvenanceHash(manifest, id);
+  return {
+    id,
+    provenanceHash: hash,
+    manifest: {
+      ...manifest,
+      provenanceHashes: [hash]
+    },
+    payload
+  };
+}
+
+exports.consolidate = consolidate;
+exports.createMatterUnit = createMatterUnit;
+//# sourceMappingURL=chunk-MUWH4QK5.cjs.map
+//# sourceMappingURL=chunk-MUWH4QK5.cjs.map

package/dist/{chunk-T6W3Z3SH.cjs → chunk-N2ILK7BF.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+var chunkZHPMP447_cjs = require('./chunk-ZHPMP447.cjs');
 
 // src/reconstruction/contractConstants.ts
 var HOLOMAP_SIMULATION_CONTRACT_KIND = "holomap.reconstruction.v1";
@@ -11,7 +11,7 @@ function ensureNodeWebGpuSync() {
   const nav = globalThis.navigator;
   if (nav?.gpu) return true;
   try {
-    const mod = chunkHCCQLAA4_cjs.__require("webgpu");
+    const mod = chunkZHPMP447_cjs.__require("webgpu");
     const gpu = typeof mod.create === "function" ? mod.create([]) : void 0;
     if (gpu && typeof gpu.requestAdapter === "function") {
       const g = globalThis;
@@ -46,5 +46,5 @@ function isWebGpuEnvironmentPresent() {
 exports.HOLOMAP_SIMULATION_CONTRACT_KIND = HOLOMAP_SIMULATION_CONTRACT_KIND;
 exports.ensureNodeWebGpuSync = ensureNodeWebGpuSync;
 exports.isWebGpuEnvironmentPresent = isWebGpuEnvironmentPresent;
-//# sourceMappingURL=chunk-T6W3Z3SH.cjs.map
-//# sourceMappingURL=chunk-T6W3Z3SH.cjs.map
+//# sourceMappingURL=chunk-N2ILK7BF.cjs.map
+//# sourceMappingURL=chunk-N2ILK7BF.cjs.map

package/dist/{chunk-6EX3I5P4.cjs → chunk-N74QRJGP.cjs}

@@ -1,10 +1,10 @@
 'use strict';
 
-var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+var chunkZHPMP447_cjs = require('./chunk-ZHPMP447.cjs');
 
 // src/traits/constants/mobile/npu-scene.ts
 exports.NPU_SCENE_TRAITS = void 0; exports.NPU_SCENE_DEFAULTS = void 0;
-var init_npu_scene = chunkHCCQLAA4_cjs.__esm({
+var init_npu_scene = chunkZHPMP447_cjs.__esm({
   "src/traits/constants/mobile/npu-scene.ts"() {
     exports.NPU_SCENE_TRAITS = [
       // --- Classification ---
@@ -51,7 +51,7 @@ var init_npu_scene = chunkHCCQLAA4_cjs.__esm({
 
 // src/traits/constants/mobile/camera-hand-tracking.ts
 exports.CAMERA_HAND_TRACKING_TRAITS = void 0;
-var init_camera_hand_tracking = chunkHCCQLAA4_cjs.__esm({
+var init_camera_hand_tracking = chunkZHPMP447_cjs.__esm({
   "src/traits/constants/mobile/camera-hand-tracking.ts"() {
     exports.CAMERA_HAND_TRACKING_TRAITS = [
       // --- Core ---
@@ -81,7 +81,7 @@ var init_camera_hand_tracking = chunkHCCQLAA4_cjs.__esm({
 
 // src/traits/constants/mobile/portal-ar.ts
 exports.PORTAL_AR_TRAITS = void 0;
-var init_portal_ar = chunkHCCQLAA4_cjs.__esm({
+var init_portal_ar = chunkZHPMP447_cjs.__esm({
   "src/traits/constants/mobile/portal-ar.ts"() {
     exports.PORTAL_AR_TRAITS = [
       // --- Mode ---
@@ -126,5 +126,5 @@ var init_portal_ar = chunkHCCQLAA4_cjs.__esm({
 exports.init_camera_hand_tracking = init_camera_hand_tracking;
 exports.init_npu_scene = init_npu_scene;
 exports.init_portal_ar = init_portal_ar;
-//# sourceMappingURL=chunk-6EX3I5P4.cjs.map
-//# sourceMappingURL=chunk-6EX3I5P4.cjs.map
+//# sourceMappingURL=chunk-N74QRJGP.cjs.map
+//# sourceMappingURL=chunk-N74QRJGP.cjs.map

package/dist/chunk-NFFHLX37.cjs

@@ -0,0 +1,132 @@
+'use strict';
+
+var chunkCANAL6CT_cjs = require('./chunk-CANAL6CT.cjs');
+
+// src/parser/HsplusGrammar.ts
+function normalizeHsplusGrammarErrors(errors) {
+  if (!Array.isArray(errors)) return [];
+  return errors.map((error) => {
+    const record = error && typeof error === "object" ? error : {};
+    return {
+      message: typeof record.message === "string" ? record.message : String(error),
+      line: typeof record.line === "number" ? record.line : 0,
+      column: typeof record.column === "number" ? record.column : 0
+    };
+  });
+}
+var TypeScriptHsplusGrammar = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.source = "typescript-fallback";
+  }
+  parse(source) {
+    const result = this.parseWithTypeScript(source);
+    return {
+      success: result.success,
+      ast: result.ast,
+      errors: normalizeHsplusGrammarErrors(result.errors),
+      raw: result
+    };
+  }
+  validate(source) {
+    return this.validateDetailed(source).valid;
+  }
+  validateDetailed(source) {
+    const parsed = this.parse(source);
+    return {
+      valid: parsed.success,
+      errors: parsed.errors,
+      raw: parsed.raw
+    };
+  }
+  version() {
+    return "typescript-hsplus";
+  }
+  parseWithTypeScript(source) {
+    const parser = new chunkCANAL6CT_cjs.HoloScriptPlusParser(this.options);
+    return parser.parse(source);
+  }
+};
+
+// src/parser/GrammarModuleRegistry.ts
+var GrammarModuleRegistryImpl = class {
+  constructor() {
+    this.modules = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a new grammar module.
+   * @throws Error if a module with the same name already exists
+   */
+  register(descriptor) {
+    if (this.modules.has(descriptor.name)) {
+      throw new Error(
+        `Grammar module "${descriptor.name}" is already registered. Use GrammarModuleRegistry.override() to replace an existing module.`
+      );
+    }
+    this.modules.set(descriptor.name, descriptor);
+  }
+  /**
+   * Override an existing grammar module registration.
+   */
+  override(descriptor) {
+    this.modules.set(descriptor.name, descriptor);
+  }
+  /**
+   * Unregister a grammar module.
+   */
+  unregister(name) {
+    return this.modules.delete(name);
+  }
+  /**
+   * Check if a grammar module is registered.
+   */
+  has(name) {
+    return this.modules.has(name);
+  }
+  /**
+   * Get a registered grammar module descriptor (includes the callable parse fn).
+   */
+  get(name) {
+    return this.modules.get(name);
+  }
+  /**
+   * Parse source using a registered grammar module.
+   * @throws Error if module not found
+   */
+  parseWith(name, source) {
+    const desc = this.modules.get(name);
+    if (!desc) {
+      const available = [...this.modules.keys()].join(", ");
+      throw new Error(`Unknown grammar module "${name}". Available: ${available}`);
+    }
+    return desc.parse(source);
+  }
+  /**
+   * List all registered grammar modules (discovery info only, no parse fn).
+   */
+  list() {
+    return [...this.modules.values()].map((desc) => ({
+      name: desc.name,
+      description: desc.description
+    }));
+  }
+  /**
+   * Get all registered grammar module names.
+   */
+  names() {
+    return [...this.modules.keys()];
+  }
+  /**
+   * Get count of registered grammar modules.
+   */
+  get size() {
+    return this.modules.size;
+  }
+};
+var GrammarModuleRegistry = new GrammarModuleRegistryImpl();
+
+exports.GrammarModuleRegistry = GrammarModuleRegistry;
+exports.TypeScriptHsplusGrammar = TypeScriptHsplusGrammar;
+exports.normalizeHsplusGrammarErrors = normalizeHsplusGrammarErrors;
+//# sourceMappingURL=chunk-NFFHLX37.cjs.map
+//# sourceMappingURL=chunk-NFFHLX37.cjs.map