@holoscript/core 8.0.8 → 8.0.9

package/dist/{chunk-UGXHYIWT.cjs → chunk-QUJ3ZB55.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkWFKVS2K4_cjs = require('./chunk-WFKVS2K4.cjs');
+var chunkAUZRKIHQ_cjs = require('./chunk-AUZRKIHQ.cjs');
 
 // src/reconstruction/FusedAttentionKernel.ts
 var FUSED_ATTENTION_WGSL = `
@@ -247,13 +247,6 @@ async function createFusedAttentionBackend() {
   return new CpuFusedAttentionBackend();
 }
 
-// src/reconstruction/PagedKVCache.ts
-function createPagedKVCache(_config) {
-  throw new Error(
-    "PagedKVCache is scaffolded in Sprint 1; implementation lands in Sprint 2. See reconstruction/RFC-HoloMap.md \xA7KV-Cache"
-  );
-}
-
 // src/reconstruction/TrajectoryMemory.ts
 var TRAJECTORY_DEFAULTS = {
   maxKeyframes: 512,
@@ -278,20 +271,6 @@ function createAnchorContext(_config) {
   );
 }
 
-// src/reconstruction/holoMapAnchoredManifest.ts
-function mergeAnchoredProvenance(manifest, urls) {
-  return {
-    ...manifest,
-    provenance: {
-      ...manifest.provenance,
-      anchorHash: urls.anchorHash,
-      opentimestampsProof: urls.opentimestampsProof,
-      baseCalldataTx: urls.baseCalldataTx,
-      capturedAtIso: manifest.provenance.capturedAtIso
-    }
-  };
-}
-
 // src/reconstruction/mobileSensorBundle.ts
 var HOLOMAP_MOBILE_SENSOR_BUNDLE_VERSION = "holomap-mobile-sensor-bundle/v1";
 var ARCORE_DEPTH_RECOMMENDED_RANGE_MILLIMETERS = {
@@ -414,6 +393,7 @@ function arCoreDepthFrameToMobileSensorFrame(frame, depthRangeMillimeters) {
   }
   const pixelCount = frame.width * frame.height;
   const normalizedDepth = new Float32Array(pixelCount);
+  const metricDepthMeters = new Float32Array(pixelCount);
   const normalizedConfidence = new Float32Array(pixelCount);
   for (let y = 0; y < frame.height; y += 1) {
     for (let x = 0; x < frame.width; x += 1) {
@@ -428,6 +408,7 @@ function arCoreDepthFrameToMobileSensorFrame(frame, depthRangeMillimeters) {
       );
       const depthMillimeters = Number(depth.millimeters[srcIndex]);
       normalizedDepth[dstIndex] = arCoreDepthMillimetersToUnit(depthMillimeters, range);
+      metricDepthMeters[dstIndex] = arCoreDepthCellIsTrusted(depthMillimeters, range) ? depthMillimeters / 1e3 : 0;
       const sensorConfidence = frame.rawDepthConfidenceImage ? clampUnit(Number(frame.rawDepthConfidenceImage.values[srcIndex]) / 255) : 1;
       normalizedConfidence[dstIndex] = arCoreDepthCellIsTrusted(depthMillimeters, range) ? sensorConfidence : 0;
     }
@@ -444,6 +425,11 @@ function arCoreDepthFrameToMobileSensorFrame(frame, depthRangeMillimeters) {
       height: frame.height,
       values: normalizedDepth
     },
+    sceneDepthMeters: {
+      width: frame.width,
+      height: frame.height,
+      values: metricDepthMeters
+    },
     sceneDepthConfidence: {
       width: frame.width,
       height: frame.height,
@@ -550,6 +536,13 @@ function validateMobileSensorBundle(bundle) {
       if (!finiteArray(frame.sceneDepth.values, pixelCount))
         errors.push(`${prefix}.sceneDepth values invalid`);
     }
+    if (frame.sceneDepthMeters) {
+      if (frame.sceneDepthMeters.width !== frame.width || frame.sceneDepthMeters.height !== frame.height) {
+        errors.push(`${prefix}.sceneDepthMeters dimensions must match frame`);
+      }
+      if (!finiteArray(frame.sceneDepthMeters.values, pixelCount))
+        errors.push(`${prefix}.sceneDepthMeters values invalid`);
+    }
     if (frame.sceneDepthConfidence) {
       if (frame.sceneDepthConfidence.width !== frame.width || frame.sceneDepthConfidence.height !== frame.height) {
         errors.push(`${prefix}.sceneDepthConfidence dimensions must match frame`);
@@ -576,7 +569,16 @@ function mobileSensorBundleToFrames(bundle) {
     stride: frame.stride,
     rgb: toUint8Array(frame.rgb, `frame[${frame.index}].rgb`),
     depth: frame.sceneDepth ? toFloat32UnitArray(frame.sceneDepth.values, `frame[${frame.index}].sceneDepth`) : void 0,
+    depthMeters: frame.sceneDepthMeters ? new Float32Array(Array.from(frame.sceneDepthMeters.values, Number)) : void 0,
     depthConfidence: frame.sceneDepthConfidence ? confidenceToUnitArray(frame.sceneDepthConfidence) : void 0,
+    cameraIntrinsics: {
+      width: bundle.capture.intrinsics.width,
+      height: bundle.capture.intrinsics.height,
+      fx: bundle.capture.intrinsics.fx,
+      fy: bundle.capture.intrinsics.fy,
+      cx: bundle.capture.intrinsics.cx,
+      cy: bundle.capture.intrinsics.cy
+    },
     devicePose: frame.cameraTransformColumnMajor4x4 ? cameraPoseFromColumnMajorTransform(
       frame.cameraTransformColumnMajor4x4,
       frame.devicePose?.confidence ?? 1
@@ -585,9 +587,9 @@ function mobileSensorBundleToFrames(bundle) {
 }
 async function replayMobileSensorBundle(bundle, config = {}) {
   const frames = mobileSensorBundleToFrames(bundle);
-  const runtime = chunkWFKVS2K4_cjs.createHoloMapRuntime();
+  const runtime = chunkAUZRKIHQ_cjs.createHoloMapRuntime();
   await runtime.init({
-    ...chunkWFKVS2K4_cjs.HOLOMAP_DEFAULTS,
+    ...chunkAUZRKIHQ_cjs.HOLOMAP_DEFAULTS,
     seed: 0,
     modelHash: bundle.bundleId,
     videoHash: bundle.bundleId,
@@ -629,11 +631,9 @@ exports.cameraPoseFromColumnMajorTransform = cameraPoseFromColumnMajorTransform;
 exports.createAnchorContext = createAnchorContext;
 exports.createArCoreDepthMobileSensorBundle = createArCoreDepthMobileSensorBundle;
 exports.createFusedAttentionBackend = createFusedAttentionBackend;
-exports.createPagedKVCache = createPagedKVCache;
 exports.createTrajectoryMemory = createTrajectoryMemory;
-exports.mergeAnchoredProvenance = mergeAnchoredProvenance;
 exports.mobileSensorBundleToFrames = mobileSensorBundleToFrames;
 exports.replayMobileSensorBundle = replayMobileSensorBundle;
 exports.validateMobileSensorBundle = validateMobileSensorBundle;
-//# sourceMappingURL=chunk-UGXHYIWT.cjs.map
-//# sourceMappingURL=chunk-UGXHYIWT.cjs.map
+//# sourceMappingURL=chunk-QUJ3ZB55.cjs.map
+//# sourceMappingURL=chunk-QUJ3ZB55.cjs.map

package/dist/{chunk-2YSNA2F2.cjs → chunk-QVJMDVYZ.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkE7JP3BS3_cjs = require('./chunk-E7JP3BS3.cjs');
+var chunkQ47JEE2C_cjs = require('./chunk-Q47JEE2C.cjs');
 var path = require('path');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -582,7 +582,7 @@ function stdlibPermissionPreviewHasPublicLeak(value) {
 }
 
 // src/traits/TestTrait.ts
-chunkE7JP3BS3_cjs.init_safeJsonParse();
+chunkQ47JEE2C_cjs.init_safeJsonParse();
 var CompositionTestRunner = class {
   constructor(initialState, computedDefs = [], config = {}) {
     this.initialState = { ...initialState };
@@ -924,7 +924,7 @@ function parseNestedBlock(body) {
       }
       const arrStr = body.substring(arrStart, i).trim();
       try {
-        result[key] = chunkE7JP3BS3_cjs.readJson(arrStr);
+        result[key] = chunkQ47JEE2C_cjs.readJson(arrStr);
       } catch {
         result[key] = arrStr;
       }
@@ -1270,5 +1270,5 @@ exports.testHandler = testHandler;
 exports.toStringArray = toStringArray;
 exports.truncateText = truncateText;
 exports.weiToEth = weiToEth;
-//# sourceMappingURL=chunk-2YSNA2F2.cjs.map
-//# sourceMappingURL=chunk-2YSNA2F2.cjs.map
+//# sourceMappingURL=chunk-QVJMDVYZ.cjs.map
+//# sourceMappingURL=chunk-QVJMDVYZ.cjs.map

package/dist/chunk-RAJMAX6D.js

@@ -0,0 +1,131 @@
+// src/keyword-registry/PluginKeywordRegistry.ts
+var NODE_TYPE_FAMILIES = [
+  // ── Existing reaction categories (from ReactionCategory) ──────────────────
+  "movement",
+  // locomotion: move, turn, strafe, jump, land
+  "interaction",
+  // object interaction verbs
+  "collision",
+  // physics collision response
+  "lifecycle",
+  // attach, detach, spawn, destroy
+  "combat",
+  // combat/attack verbs
+  "signal",
+  // event emission verbs
+  // ── H2 additions ─────────────────────────────────────────────────────────
+  "cognitive",
+  // AI/LLM: llm_call, recall, rag_query, plan, reflect
+  "control",
+  // actuate, drive, set_joint, emit_gcode (ControlLoopTrait)
+  "sensor",
+  // measure, read, sample, measure_qubits (robotics/IoT/QM)
+  "transaction"
+  // pay, transfer, stake (x402 economic)
+];
+var PluginKeywordRegistry = class {
+  constructor() {
+    this.table = /* @__PURE__ */ new Map();
+    this._sealed = false;
+    this._registerBuiltins();
+  }
+  _registerBuiltins() {
+    for (const verb of ["move", "turn", "strafe", "jump", "land"]) {
+      this.table.set(verb, { verb, family: "movement", registeredBy: "core" });
+    }
+    for (const verb of ["llm_call", "recall", "rag_query", "plan", "reflect"]) {
+      this.table.set(verb, { verb, family: "cognitive", registeredBy: "core" });
+    }
+  }
+  /**
+   * Register a plugin-supplied verb.
+   *
+   * @param verb      The .hs verb (e.g., `'actuate'`, `'emit_gcode'`). Must be
+   *                  a non-empty string containing only `[a-z0-9_]`.
+   * @param family    Must be a known `NodeTypeFamily`. Conformance gate rejects
+   *                  anything outside the fixed set.
+   * @param pluginId  The registering plugin's manifest id (e.g., `'robotics'`).
+   *
+   * @throws If the registry is sealed, the family is unknown, or the verb is
+   *         already registered by a DIFFERENT plugin (idempotent for same plugin).
+   */
+  register(verb, family, pluginId) {
+    if (this._sealed) {
+      throw new Error(
+        `[PluginKeywordRegistry] Registry is sealed \u2014 cannot register verb "${verb}" after scene init.`
+      );
+    }
+    if (!verb || !/^[a-z][a-z0-9_]*$/.test(verb)) {
+      throw new Error(
+        `[PluginKeywordRegistry] Invalid verb "${verb}". Must match [a-z][a-z0-9_]*.`
+      );
+    }
+    if (!NODE_TYPE_FAMILIES.includes(family)) {
+      throw new Error(
+        `[PluginKeywordRegistry] Unknown node-type family "${family}". Must be one of: ${NODE_TYPE_FAMILIES.join(", ")}.`
+      );
+    }
+    const existing = this.table.get(verb);
+    if (existing) {
+      if (existing.registeredBy === pluginId) {
+        return;
+      }
+      throw new Error(
+        `[PluginKeywordRegistry] Verb "${verb}" is already registered by plugin "${existing.registeredBy}". Cannot be re-registered by "${pluginId}".`
+      );
+    }
+    this.table.set(verb, { verb, family, registeredBy: pluginId });
+  }
+  /**
+   * Seal the registry after scene init. All plugin verbs must be registered
+   * before this call. After sealing, `register()` throws.
+   *
+   * Idempotent — calling seal() on an already-sealed registry is a no-op.
+   */
+  seal() {
+    this._sealed = true;
+  }
+  /** Whether the registry has been sealed. */
+  get isSealed() {
+    return this._sealed;
+  }
+  /**
+   * Look up the `NodeTypeFamily` for a verb.
+   * Returns `undefined` for unregistered verbs.
+   */
+  lookupFamily(verb) {
+    return this.table.get(verb)?.family;
+  }
+  /** Returns `true` if the verb is registered (built-in or plugin-supplied). */
+  isKnownVerb(verb) {
+    return this.table.has(verb);
+  }
+  /**
+   * Return all registered `VerbEntry` objects — the flat machine-introspectable
+   * table. Safe for LSP / marketplace / Brittney to read without importing TS.
+   */
+  entries() {
+    return [...this.table.values()];
+  }
+  /** Return all registered verbs for a given family. */
+  verbsInFamily(family) {
+    return [...this.table.values()].filter((e) => e.family === family).map((e) => e.verb);
+  }
+  /** Total number of registered verbs. */
+  get size() {
+    return this.table.size;
+  }
+};
+var globalKeywordRegistry = new PluginKeywordRegistry();
+function registerPluginVerb(verb, family, pluginId) {
+  globalKeywordRegistry.register(verb, family, pluginId);
+}
+function registerPluginVerbs(pluginId, verbs) {
+  for (const { verb, family } of verbs) {
+    globalKeywordRegistry.register(verb, family, pluginId);
+  }
+}
+
+export { NODE_TYPE_FAMILIES, PluginKeywordRegistry, globalKeywordRegistry, registerPluginVerb, registerPluginVerbs };
+//# sourceMappingURL=chunk-RAJMAX6D.js.map
+//# sourceMappingURL=chunk-RAJMAX6D.js.map

package/dist/{chunk-VVKVQZI6.js → chunk-RAN3ECAS.js}

@@ -1,4 +1,4 @@
-import { __esm } from './chunk-OL46QLBJ.js';
+import { __esm } from './chunk-W4GABFCR.js';
 import { z } from 'zod';
 
 function safeJsonParse(s, schema) {
@@ -51,5 +51,5 @@ var init_safeJsonParse = __esm({
 });
 
 export { init_safeJsonParse, jsonClone, readJson, safeJsonParse, safeJsonParseSchema, tryParseJson };
-//# sourceMappingURL=chunk-VVKVQZI6.js.map
-//# sourceMappingURL=chunk-VVKVQZI6.js.map
+//# sourceMappingURL=chunk-RAN3ECAS.js.map
+//# sourceMappingURL=chunk-RAN3ECAS.js.map

package/dist/chunk-RKGUZBOC.js

@@ -0,0 +1,79 @@
+import { readdirSync, existsSync, readFileSync } from 'fs';
+import { join, resolve } from 'path';
+import { pathToFileURL } from 'url';
+
+// src/plugin-manifest/PluginManifest.ts
+function traitName(entry) {
+  return typeof entry === "string" ? entry : entry.name;
+}
+function manifestTraitNames(manifest) {
+  return manifest.traits.map(traitName);
+}
+function combinePluginRegistrations(registrar, plugins) {
+  const pluginIds = [];
+  const traitNames = [];
+  for (const registration of plugins) {
+    registration.register(registrar);
+    pluginIds.push(registration.manifest.id);
+    traitNames.push(...manifestTraitNames(registration.manifest));
+  }
+  return { pluginIds, traitNames };
+}
+async function autoLoadPluginsFromManifests(pluginsDir, registrar) {
+  const loaded = [];
+  const skipped = [];
+  const failed = [];
+  let dirs;
+  try {
+    dirs = readdirSync(pluginsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch (e) {
+    return { loaded, skipped, failed: [{ id: "<root>", error: e.message }] };
+  }
+  for (const dir of dirs) {
+    const manifestPath = join(pluginsDir, dir, "plugin.manifest.json");
+    if (!existsSync(manifestPath)) continue;
+    let manifest;
+    try {
+      manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+    } catch (e) {
+      failed.push({ id: dir, error: `manifest parse: ${e.message}` });
+      continue;
+    }
+    if (!manifest.autoRegister) {
+      skipped.push(manifest.id);
+      continue;
+    }
+    const entry = manifest.runtimeEntry ?? "./src/runtime.ts";
+    const entryAbs = resolve(join(pluginsDir, dir), entry);
+    if (!existsSync(entryAbs)) {
+      failed.push({ id: manifest.id, error: `runtimeEntry not found: ${entryAbs}` });
+      continue;
+    }
+    try {
+      const mod = await import(pathToFileURL(entryAbs).href);
+      let fn = mod["registerTraitHandlers"];
+      if (typeof fn !== "function") {
+        const found = Object.entries(mod).find(
+          ([k, v]) => typeof v === "function" && /^register\w+TraitHandlers$/.test(k)
+        );
+        fn = found?.[1];
+      }
+      if (typeof fn !== "function") {
+        failed.push({
+          id: manifest.id,
+          error: `no registerTraitHandlers export in ${entry}`
+        });
+        continue;
+      }
+      fn(registrar);
+      loaded.push(manifest.id);
+    } catch (e) {
+      failed.push({ id: manifest.id, error: e.message });
+    }
+  }
+  return { loaded, skipped, failed };
+}
+
+export { autoLoadPluginsFromManifests, combinePluginRegistrations, manifestTraitNames, traitName };
+//# sourceMappingURL=chunk-RKGUZBOC.js.map
+//# sourceMappingURL=chunk-RKGUZBOC.js.map

package/dist/{chunk-HLFDZ35S.cjs → chunk-RRQIAJLQ.cjs}

@@ -1,21 +1,21 @@
 'use strict';
 
-var chunkLODTHGST_cjs = require('./chunk-LODTHGST.cjs');
-var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+var chunkZK7KX5CD_cjs = require('./chunk-ZK7KX5CD.cjs');
+var chunkZHPMP447_cjs = require('./chunk-ZHPMP447.cjs');
 var ans = require('@holoscript/core-types/ans');
 
 // src/compiler/DTDLCompiler.ts
 var DTDLCompiler_exports = {};
-chunkHCCQLAA4_cjs.__export(DTDLCompiler_exports, {
+chunkZHPMP447_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 = chunkHCCQLAA4_cjs.__esm({
+var init_DTDLCompiler = chunkZHPMP447_cjs.__esm({
   "src/compiler/DTDLCompiler.ts"() {
-    chunkLODTHGST_cjs.init_CompilerBase();
-    exports.DTDLCompiler = class extends chunkLODTHGST_cjs.CompilerBase {
+    chunkZK7KX5CD_cjs.init_CompilerBase();
+    exports.DTDLCompiler = class extends chunkZK7KX5CD_cjs.CompilerBase {
       constructor(options = {}) {
         super();
         this.compilerName = "DTDLCompiler";
@@ -420,5 +420,5 @@ var init_DTDLCompiler = chunkHCCQLAA4_cjs.__esm({
 
 exports.DTDLCompiler_exports = DTDLCompiler_exports;
 exports.init_DTDLCompiler = init_DTDLCompiler;
-//# sourceMappingURL=chunk-HLFDZ35S.cjs.map
-//# sourceMappingURL=chunk-HLFDZ35S.cjs.map
+//# sourceMappingURL=chunk-RRQIAJLQ.cjs.map
+//# sourceMappingURL=chunk-RRQIAJLQ.cjs.map

package/dist/{chunk-PABONWKI.js → chunk-RXQNRZ5F.js}

@@ -1,4 +1,4 @@
-import { init_CompilerBase, CompilerBase } from './chunk-C7ZBSV2Q.js';
+import { init_CompilerBase, CompilerBase } from './chunk-DUG3OQAS.js';
 import { ANSCapabilityPath } from '@holoscript/core-types/ans';
 
 // src/compiler/LLMProviderCapabilitiesCompiler.ts
@@ -734,5 +734,5 @@ function daysBetween(earlier, later) {
 }
 
 export { LLMCapabilityCompileError, LLMProviderCapabilitiesCompiler, createLLMProviderCapabilitiesCompiler };
-//# sourceMappingURL=chunk-PABONWKI.js.map
-//# sourceMappingURL=chunk-PABONWKI.js.map
+//# sourceMappingURL=chunk-RXQNRZ5F.js.map
+//# sourceMappingURL=chunk-RXQNRZ5F.js.map

package/dist/{chunk-7ZHYEITD.cjs → chunk-S4O7CFHQ.cjs}

@@ -1,12 +1,11 @@
 'use strict';
 
-var chunkUVFI7XIR_cjs = require('./chunk-UVFI7XIR.cjs');
-var chunkLODTHGST_cjs = require('./chunk-LODTHGST.cjs');
+var chunkV6GXFSK7_cjs = require('./chunk-V6GXFSK7.cjs');
+var chunkZK7KX5CD_cjs = require('./chunk-ZK7KX5CD.cjs');
 
 // src/compiler/TraitCompositionCompiler.ts
-chunkLODTHGST_cjs.init_AgentRBAC();
-chunkLODTHGST_cjs.init_CompilerBase();
-chunkUVFI7XIR_cjs.init_ProvenanceSemiring();
+chunkZK7KX5CD_cjs.init_AgentRBAC();
+chunkZK7KX5CD_cjs.init_CompilerBase();
 var CompositionConflictError = class extends Error {
   constructor(traitA, traitB, conflictKey) {
     super(
@@ -63,7 +62,7 @@ var TraitCompositionCompiler = class {
    */
   validateAccess(agentToken) {
     if (!agentToken) return;
-    const rbac = chunkLODTHGST_cjs.getRBAC();
+    const rbac = chunkZK7KX5CD_cjs.getRBAC();
     const decision = rbac.checkAccess({
       token: agentToken,
       resourceType: "ast" /* AST */,
@@ -83,12 +82,12 @@ var TraitCompositionCompiler = class {
       if (!handler) throw new MissingComponentError(decl.name, name);
       return { name, handler };
     });
-    if (chunkUVFI7XIR_cjs.authorityWeight(
+    if (chunkV6GXFSK7_cjs.authorityWeight(
       decl.provenance?.context?.authorityLevel ?? 0
     ) < 100) {
       this.detectConflicts(handlers);
     }
-    const semiring = new chunkUVFI7XIR_cjs.ProvenanceSemiring();
+    const semiring = new chunkV6GXFSK7_cjs.ProvenanceSemiring();
     const applications = [];
     for (const { name, handler } of handlers) {
       let configAccumulator = {};
@@ -154,7 +153,7 @@ var TraitCompositionCompiler = class {
     }
   }
 };
-var UnauthorizedTraitCompositionAccessError = class extends chunkLODTHGST_cjs.UnauthorizedCompilerAccessError {
+var UnauthorizedTraitCompositionAccessError = class extends chunkZK7KX5CD_cjs.UnauthorizedCompilerAccessError {
   constructor(decision, compilerName) {
     super(decision, "trait composition", compilerName);
     this.name = "UnauthorizedTraitCompositionAccessError";
@@ -165,5 +164,5 @@ exports.CompositionConflictError = CompositionConflictError;
 exports.MissingComponentError = MissingComponentError;
 exports.TraitCompositionCompiler = TraitCompositionCompiler;
 exports.UnauthorizedTraitCompositionAccessError = UnauthorizedTraitCompositionAccessError;
-//# sourceMappingURL=chunk-7ZHYEITD.cjs.map
-//# sourceMappingURL=chunk-7ZHYEITD.cjs.map
+//# sourceMappingURL=chunk-S4O7CFHQ.cjs.map
+//# sourceMappingURL=chunk-S4O7CFHQ.cjs.map

package/dist/chunk-SE7ANBGN.js

@@ -0,0 +1,128 @@
+import { HoloScriptPlusParser } from './chunk-DBH3D2MU.js';
+
+// 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 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();
+
+export { GrammarModuleRegistry, TypeScriptHsplusGrammar, normalizeHsplusGrammarErrors };
+//# sourceMappingURL=chunk-SE7ANBGN.js.map
+//# sourceMappingURL=chunk-SE7ANBGN.js.map