@holoscript/core 8.0.8 → 8.0.9

package/dist/{chunk-LYJJI7ZK.cjs → chunk-XCUDDFKC.cjs}

@@ -1,11 +1,11 @@
 'use strict';
 
-var chunkM7K4LE66_cjs = require('./chunk-M7K4LE66.cjs');
-var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+var chunkCI33NINL_cjs = require('./chunk-CI33NINL.cjs');
+var chunkZHPMP447_cjs = require('./chunk-ZHPMP447.cjs');
 
 // src/hololand/index.ts
 var hololand_exports = {};
-chunkHCCQLAA4_cjs.__export(hololand_exports, {
+chunkZHPMP447_cjs.__export(hololand_exports, {
   CrossValidationRegistry: () => CrossValidationRegistry,
   DEFAULT_ENVELOPES: () => DEFAULT_ENVELOPES,
   DEFAULT_ITEM_AUTONOMOUS_AGENDA: () => DEFAULT_ITEM_AUTONOMOUS_AGENDA,
@@ -21,6 +21,7 @@ chunkHCCQLAA4_cjs.__export(hololand_exports, {
   PhysicsBoundsRegistry: () => PhysicsBoundsRegistry,
   StreamProtocol: () => StreamProtocol,
   TIMEOUT_INTERVAL: () => TIMEOUT_INTERVAL,
+  VRRLiveDataSync: () => VRRLiveDataSync,
   computeConsensus: () => computeConsensus,
   connectToHololand: () => connectToHololand,
   createHoloLandItem: () => createHoloLandItem,
@@ -652,7 +653,7 @@ function disconnectFromHololand() {
 }
 
 // src/hololand/PhysicsBoundsRegistry.ts
-chunkM7K4LE66_cjs.init_AgentRiskRegistry();
+chunkCI33NINL_cjs.init_AgentRiskRegistry();
 var DEFAULT_ENVELOPES = {
   ["low" /* LOW */]: {
     maxForceN: 1e3,
@@ -723,7 +724,7 @@ function resetPhysicsBoundsRegistry() {
   globalBoundsRegistry = null;
 }
 function wrapPhysicsService(service, agentId, options = {}) {
-  const riskRegistry = options.riskRegistry ?? chunkM7K4LE66_cjs.getAgentRiskRegistry();
+  const riskRegistry = options.riskRegistry ?? chunkCI33NINL_cjs.getAgentRiskRegistry();
   const boundsRegistry = options.boundsRegistry ?? getPhysicsBoundsRegistry();
   const onViolation = options.onViolation;
   function currentEnvelope() {
@@ -939,7 +940,7 @@ function clampVector(v, maxMagnitude) {
 }
 
 // src/hololand/CrossValidationRegistry.ts
-chunkM7K4LE66_cjs.init_AgentRiskRegistry();
+chunkCI33NINL_cjs.init_AgentRiskRegistry();
 var DEFAULT_MIN_OBSERVERS = 3;
 var DEFAULT_NUMERIC_TOLERANCE = 1;
 var DEFAULT_AGREEMENT_SEVERITY = 15;
@@ -959,7 +960,7 @@ var CrossValidationRegistry = class {
       perField: config.tolerance?.perField
     };
     this.agreementSeverityThreshold = config.agreementSeverityThreshold ?? DEFAULT_AGREEMENT_SEVERITY;
-    this.riskRegistry = config.riskRegistry ?? chunkM7K4LE66_cjs.getAgentRiskRegistry();
+    this.riskRegistry = config.riskRegistry ?? chunkCI33NINL_cjs.getAgentRiskRegistry();
     this.maxRounds = config.maxRounds ?? DEFAULT_MAX_ROUNDS;
     this.now = config.now ?? (() => Date.now());
     if (this.defaultMinObservers < 2) {
@@ -1944,6 +1945,211 @@ function createMessage(type, payload, options = {}) {
   };
 }
 
+// src/hololand/VRRLiveDataSync.ts
+var PRIORITY_BY_KIND = {
+  weather: 144,
+  events: 160,
+  inventory: 176,
+  sensor: 192
+};
+var VRRLiveDataSync = class {
+  constructor(transport, options) {
+    this.unsubscribers = [];
+    this.transport = transport;
+    this.twinId = options.twinId;
+    this.worldId = options.worldId;
+    this.channel = options.channel ?? `vrr:${options.twinId}:live-data`;
+    this.clock = options.clock ?? Date.now;
+    this.lastPublishAt = this.clock();
+    this.state = {
+      twinId: this.twinId,
+      updatedAt: this.lastPublishAt,
+      events: [],
+      sensors: {},
+      sources: {}
+    };
+  }
+  getState() {
+    return {
+      ...this.state,
+      events: [...this.state.events],
+      sensors: { ...this.state.sensors },
+      sources: { ...this.state.sources }
+    };
+  }
+  publishWeather(weather, source = { sourceId: "weather", providerId: "manual" }) {
+    return this.applySnapshot({ source: { ...source, kind: "weather" }, data: weather });
+  }
+  publishEvents(events, source = { sourceId: "events", providerId: "manual" }) {
+    return this.applySnapshot({ source: { ...source, kind: "events" }, data: events });
+  }
+  publishInventory(inventory, source = { sourceId: "inventory", providerId: "manual" }) {
+    return this.applySnapshot({ source: { ...source, kind: "inventory" }, data: inventory });
+  }
+  publishSensor(sensor, source = {
+    sourceId: sensor.sensorId,
+    providerId: "manual"
+  }) {
+    return this.applySnapshot({ source: { ...source, kind: "sensor" }, data: sensor });
+  }
+  applySnapshot(snapshot) {
+    const observedAt = snapshot.observedAt ?? this.clock();
+    const sourceKey = this.sourceKey(snapshot.source);
+    this.state.sources[sourceKey] = { ...snapshot.source };
+    this.state.updatedAt = observedAt;
+    if (snapshot.source.kind === "weather") {
+      this.state.weather = snapshot.data;
+    } else if (snapshot.source.kind === "events") {
+      this.state.events = [...snapshot.data];
+    } else if (snapshot.source.kind === "inventory") {
+      this.state.inventory = snapshot.data;
+    } else {
+      const sensor = snapshot.data;
+      this.state.sensors[sensor.sensorId] = { ...sensor };
+    }
+    const delta = this.buildEntityDelta(snapshot, observedAt);
+    const event = this.buildWorldEvent(snapshot, observedAt);
+    const message = {
+      type: "world_update",
+      reliable: false,
+      priority: PRIORITY_BY_KIND[snapshot.source.kind],
+      channel: this.channel,
+      payload: {
+        deltaTime: Math.max(0, observedAt - this.lastPublishAt),
+        entities: [delta],
+        events: [event]
+      }
+    };
+    this.lastPublishAt = observedAt;
+    this.transport.send(message);
+    return message;
+  }
+  async syncFromProviders(providers) {
+    if (providers.weather) {
+      const { provider, location, sourceId, entityId, staleAfterMs } = providers.weather;
+      const weather = await provider.fetchWeather(location);
+      this.publishWeather(weather, {
+        sourceId: sourceId ?? location,
+        providerId: provider.id,
+        locationId: location,
+        entityId,
+        staleAfterMs
+      });
+      this.unsubscribers.push(
+        provider.subscribeToWeather(
+          location,
+          (next) => this.publishWeather(next, {
+            sourceId: sourceId ?? location,
+            providerId: provider.id,
+            locationId: location,
+            entityId,
+            staleAfterMs
+          })
+        )
+      );
+    }
+    if (providers.events) {
+      const { provider, location, sourceId, entityId, staleAfterMs } = providers.events;
+      const events = await provider.fetchEvents(location);
+      this.publishEvents(events, {
+        sourceId: sourceId ?? location,
+        providerId: provider.id,
+        locationId: location,
+        entityId,
+        staleAfterMs
+      });
+      this.unsubscribers.push(
+        provider.subscribeToEvents(
+          location,
+          (next) => this.publishEvents(next, {
+            sourceId: sourceId ?? location,
+            providerId: provider.id,
+            locationId: location,
+            entityId,
+            staleAfterMs
+          })
+        )
+      );
+    }
+    if (providers.inventory) {
+      const { provider, businessId, sourceId, entityId, staleAfterMs } = providers.inventory;
+      const inventory = await provider.fetchInventory(businessId);
+      this.publishInventory(inventory, {
+        sourceId: sourceId ?? businessId,
+        providerId: provider.id,
+        locationId: businessId,
+        entityId,
+        staleAfterMs
+      });
+      this.unsubscribers.push(
+        provider.subscribeToInventory(
+          businessId,
+          (next) => this.publishInventory(next, {
+            sourceId: sourceId ?? businessId,
+            providerId: provider.id,
+            locationId: businessId,
+            entityId,
+            staleAfterMs
+          })
+        )
+      );
+    }
+  }
+  dispose() {
+    while (this.unsubscribers.length) {
+      const unsubscribe = this.unsubscribers.pop();
+      try {
+        unsubscribe?.();
+      } catch {
+      }
+    }
+  }
+  sourceKey(source) {
+    return `${source.kind}:${source.providerId}:${source.sourceId}`;
+  }
+  entityIdFor(source) {
+    return source.entityId ?? `vrr:${this.twinId}:${source.kind}:${source.sourceId}`;
+  }
+  buildEntityDelta(snapshot, observedAt) {
+    const source = snapshot.source;
+    return {
+      id: this.entityIdFor(source),
+      timestamp: observedAt,
+      changes: {
+        [`components.vrrLiveData.${source.kind}`]: snapshot.data,
+        [`properties.vrrLiveData.${source.kind}.sourceId`]: source.sourceId,
+        [`properties.vrrLiveData.${source.kind}.providerId`]: source.providerId,
+        [`properties.vrrLiveData.${source.kind}.observedAt`]: observedAt,
+        [`properties.vrrLiveData.${source.kind}.staleAfterMs`]: source.staleAfterMs
+      }
+    };
+  }
+  buildWorldEvent(snapshot, observedAt) {
+    const { source } = snapshot;
+    return {
+      id: `vrr_live_${source.kind}_${source.sourceId}_${observedAt}`,
+      type: this.eventType(source.kind),
+      source: "system",
+      sourceId: source.sourceId,
+      timestamp: observedAt,
+      data: {
+        twinId: this.twinId,
+        worldId: this.worldId,
+        kind: source.kind,
+        providerId: source.providerId,
+        locationId: source.locationId,
+        staleAfterMs: source.staleAfterMs,
+        count: Array.isArray(snapshot.data) ? snapshot.data.length : void 0,
+        data: snapshot.data
+      }
+    };
+  }
+  eventType(kind) {
+    if (kind === "events") return "vrr.live_data.events.synced";
+    return `vrr.live_data.${kind}.updated`;
+  }
+};
+
 exports.CrossValidationRegistry = CrossValidationRegistry;
 exports.DEFAULT_ENVELOPES = DEFAULT_ENVELOPES;
 exports.DEFAULT_ITEM_AUTONOMOUS_AGENDA = DEFAULT_ITEM_AUTONOMOUS_AGENDA;
@@ -1959,6 +2165,7 @@ exports.PROTOCOL_VERSION = PROTOCOL_VERSION;
 exports.PhysicsBoundsRegistry = PhysicsBoundsRegistry;
 exports.StreamProtocol = StreamProtocol;
 exports.TIMEOUT_INTERVAL = TIMEOUT_INTERVAL;
+exports.VRRLiveDataSync = VRRLiveDataSync;
 exports.computeConsensus = computeConsensus;
 exports.connectToHololand = connectToHololand;
 exports.createHoloLandItem = createHoloLandItem;
@@ -1979,5 +2186,5 @@ exports.resetCrossValidationRegistry = resetCrossValidationRegistry;
 exports.resetPhysicsBoundsRegistry = resetPhysicsBoundsRegistry;
 exports.suggestedQuorum = suggestedQuorum;
 exports.wrapPhysicsService = wrapPhysicsService;
-//# sourceMappingURL=chunk-LYJJI7ZK.cjs.map
-//# sourceMappingURL=chunk-LYJJI7ZK.cjs.map
+//# sourceMappingURL=chunk-XCUDDFKC.cjs.map
+//# sourceMappingURL=chunk-XCUDDFKC.cjs.map

package/dist/chunk-YAO4HPJL.cjs

@@ -0,0 +1,120 @@
+'use strict';
+
+// src/receipts/hash-policy.ts
+var RECEIPT_HASH_POLICY_DEFAULT = "fast";
+function fnv1a32String(value) {
+  let hash = 2166136261;
+  for (const cp of value) {
+    hash ^= cp.codePointAt(0);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+var TEXT_ENCODER = new TextEncoder();
+async function sha256StringAsync(value) {
+  const bytes = TEXT_ENCODER.encode(value);
+  const buf = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+  return Array.from(new Uint8Array(buf)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function hashReceiptPayload(canonicalized, policy = RECEIPT_HASH_POLICY_DEFAULT) {
+  if (policy === "fast") {
+    return `fnv1a32:${fnv1a32String(canonicalized)}`;
+  }
+  return sha256StringAsync(canonicalized).then((hex) => `sha256:${hex}`);
+}
+async function hashReceiptPayloadAsync(canonicalized, policy = RECEIPT_HASH_POLICY_DEFAULT) {
+  if (policy === "fast") {
+    return `fnv1a32:${fnv1a32String(canonicalized)}`;
+  }
+  const hex = await sha256StringAsync(canonicalized);
+  return `sha256:${hex}`;
+}
+function parseReceiptHash(tagged) {
+  if (tagged.startsWith("fnv1a32:")) {
+    return { policy: "fast", hex: tagged.slice(8) };
+  }
+  if (tagged.startsWith("sha256:")) {
+    return { policy: "secure", hex: tagged.slice(7) };
+  }
+  return null;
+}
+function receiptHashMatchesPolicy(tagged, policy) {
+  const parsed = parseReceiptHash(tagged);
+  return parsed !== null && parsed.policy === policy;
+}
+
+// src/proof-composition/ProofCompositionLaw.ts
+var PROOF_COMPOSITION_LAWS = [
+  "empty-identity",
+  "and-monotone",
+  "schema-null-coalescing-and",
+  "violation-union",
+  "flat-associativity"
+];
+function composeReceipts(components) {
+  const composedVerified = components.length === 0 || components.every((c) => c.contractVerified);
+  const nonNullSchema = components.filter((c) => c.schemaValid !== null);
+  const composedSchemaValid = nonNullSchema.length === 0 ? null : nonNullSchema.every((c) => c.schemaValid === true);
+  const allViolations = components.flatMap((c) => c.clauseViolations);
+  const allSchemaViolations = components.flatMap((c) => c.schemaViolations);
+  const pluginIds = [
+    ...new Set(
+      components.map((c) => c.pluginId).filter((id) => id !== null)
+    )
+  ];
+  const contractIds = [
+    ...new Set(
+      components.map((c) => c.contractId).filter((id) => id !== null)
+    )
+  ];
+  const canonical = JSON.stringify({
+    laws: PROOF_COMPOSITION_LAWS,
+    components: components.map((c) => ({
+      contractId: c.contractId,
+      contractVerified: c.contractVerified,
+      schemaId: c.schemaId,
+      schemaValid: c.schemaValid,
+      violations: c.clauseViolations.map((v) => v.clauseId).sort()
+    }))
+  });
+  const hash = hashReceiptPayload(canonical);
+  return {
+    components,
+    composedVerified,
+    composedSchemaValid,
+    allViolations,
+    allSchemaViolations,
+    pluginIds,
+    contractIds,
+    hash
+  };
+}
+function flattenForRecompose(composed, additional = []) {
+  return [...composed.components, ...additional];
+}
+function verifyCompositionLaws(receipt) {
+  const failing = [];
+  const expectedVerified = receipt.components.length === 0 || receipt.components.every((c) => c.contractVerified);
+  if (receipt.composedVerified !== expectedVerified) failing.push("and-monotone");
+  const nonNull = receipt.components.filter((c) => c.schemaValid !== null);
+  const expectedSchema = nonNull.length === 0 ? null : nonNull.every((c) => c.schemaValid === true);
+  if (receipt.composedSchemaValid !== expectedSchema) failing.push("schema-null-coalescing-and");
+  const expectedViolationCount = receipt.components.reduce(
+    (n, c) => n + c.clauseViolations.length,
+    0
+  );
+  if (receipt.allViolations.length !== expectedViolationCount) failing.push("violation-union");
+  return failing;
+}
+
+exports.PROOF_COMPOSITION_LAWS = PROOF_COMPOSITION_LAWS;
+exports.RECEIPT_HASH_POLICY_DEFAULT = RECEIPT_HASH_POLICY_DEFAULT;
+exports.composeReceipts = composeReceipts;
+exports.flattenForRecompose = flattenForRecompose;
+exports.hashReceiptPayload = hashReceiptPayload;
+exports.hashReceiptPayloadAsync = hashReceiptPayloadAsync;
+exports.parseReceiptHash = parseReceiptHash;
+exports.receiptHashMatchesPolicy = receiptHashMatchesPolicy;
+exports.verifyCompositionLaws = verifyCompositionLaws;
+//# sourceMappingURL=chunk-YAO4HPJL.cjs.map
+//# sourceMappingURL=chunk-YAO4HPJL.cjs.map