@holoscript/core 6.0.3 → 6.1.1

package/dist/traits/index.d.ts

@@ -67,6 +67,16 @@ export type TraitEvent = {
   [key: string]: any;
 };
 
+export interface TraitHandler<T = any> {
+  name: string;
+  defaultConfig?: T;
+  onAttach?: (node: any, config: T, context: TraitContext) => void | Promise<void>;
+  onDetach?: (node: any, config: T, context: TraitContext) => void | Promise<void>;
+  onUpdate?: (node: any, config: T, context: TraitContext, delta: number) => void | Promise<void>;
+  onEvent?: (node: any, config: T, context: TraitContext, event: TraitEvent) => void | Promise<void>;
+  [key: string]: any;
+}
+
 export interface AccessibilityContext {
   screenReader?: boolean;
   highContrast?: boolean;
@@ -83,6 +93,7 @@ export class VRTraitRegistry {
   register(handler: TraitHandler): void;
   unregister(name: string): void;
   get(name: string): TraitHandler | undefined;
+  getHandler(name: string): TraitHandler | undefined;
   getAll(): TraitHandler[];
   handleEventForAllTraits(node: any, ctx: TraitContext, event: TraitEvent): void;
 }
@@ -109,6 +120,78 @@ export function generateTraitSupportMatrix(traitDir: string): Promise<TraitSuppo
 export function matrixToJSON(matrix: TraitSupportMatrixData): string;
 export function matrixToYAML(matrix: TraitSupportMatrixData): string;
 
+export interface Memory {
+  id: string;
+  key: string;
+  content: string;
+  tags: string[];
+  embedding: number[] | null;
+  createdAt: number;
+  accessedAt: number;
+  accessCount: number;
+  ttl: number | null;
+  source: string;
+}
+
+export interface MemoryRecallResult {
+  memory: Memory;
+  score: number;
+}
+
+export interface AgentMemoryConfig {
+  max_memories: number;
+  default_ttl: number | null;
+  embedding_model: 'local' | 'openai' | 'none';
+  embedding_dim: number;
+  auto_compress: boolean;
+  compress_prompt: string;
+  sync_to_postgres: boolean;
+  postgres_url: string;
+  db_name: string;
+}
+
+export interface AgentMemoryState {
+  memories: Map<string, Memory>;
+  db: IDBDatabase | null;
+  isReady: boolean;
+  totalStored: number;
+  totalRecalled: number;
+  totalCompressed: number;
+}
+
+export const agentMemoryHandler: TraitHandler<AgentMemoryConfig>;
+
+export interface JEPAPredictorConfig {
+  latentDim: number;
+  condDim: number;
+}
+
+export interface JEPAPredictorWeights {
+  W1: Float32Array;
+  b1: Float32Array;
+  W2: Float32Array;
+  b2: Float32Array;
+}
+
+export interface JEPAPredictorForwardResult {
+  predicted: Float32Array;
+  hidden: Float32Array;
+}
+
+export class JEPAPredictor {
+  readonly latentDim: number;
+  readonly condDim: number;
+  constructor(config: JEPAPredictorConfig, weights?: JEPAPredictorWeights);
+  forward(contextEmb: Float32Array, conditioning?: Float32Array | null): JEPAPredictorForwardResult;
+  setWeights(weights: JEPAPredictorWeights): void;
+  getWeights(): Readonly<JEPAPredictorWeights>;
+  plan(currentState: string, candidateActions: string[]): {
+    action: string;
+    predicted: Float32Array;
+    confidence: number;
+  };
+}
+
 export class TraitCompositor {
   [key: string]: any;
 }
@@ -124,3 +207,117 @@ export declare const ComponentType: any;
 export class MoMETraitDatabase {
   [key: string]: any;
 }
+
+export interface EmergentSpacetimeConfig {
+  initial_voxels?: number;
+  max_voxels?: number;
+  seed?: number;
+  force_layout_guard?: boolean;
+  ricci_error_bound?: number;
+  ricci_heatmap?: boolean;
+  loop_threshold?: number;
+  real_time_budget_ms?: number;
+}
+
+export interface EmergentSpacetimeState {
+  network: {
+    voxels: Map<string, any>;
+    edges: any[];
+    loopCount: number;
+  };
+  hubbleCorrection: number;
+  violationCount: number;
+  lastRicciError: number;
+  isSimulating: boolean;
+}
+
+export const emergentSpacetimeHandler: TraitHandler<EmergentSpacetimeConfig>;
+
+export interface NormalizedFaceLandmark {
+  x: number;
+  y: number;
+  z?: number;
+  visibility?: number;
+  presence?: number;
+}
+export interface WebcamGazeSample {
+  gaze_x: number;
+  gaze_y: number;
+  foveal_center: [number, number];
+  confidence: number;
+  timestamp: number;
+  source: 'webcam';
+}
+export interface WebcamGazeConfig {
+  auto_start: boolean;
+  video_width: number;
+  video_height: number;
+  sample_rate_hz: number;
+  confidence_threshold: number;
+  wasm_base_path: string;
+  model_asset_path: string;
+  gaze_gain_x: number;
+  gaze_gain_y: number;
+  max_ray_angle_degrees: number;
+}
+export const DEFAULT_WEBCAM_GAZE_CONFIG: WebcamGazeConfig;
+export class WebcamGazeTracker {
+  constructor(options: {
+    config: WebcamGazeConfig;
+    videoElement?: HTMLVideoElement | null;
+    onSample: (sample: WebcamGazeSample) => void;
+    onError?: (error: Error) => void;
+  });
+  getStream(): MediaStream | null;
+  getVideoElement(): HTMLVideoElement | null;
+  start(): Promise<void>;
+  stop(): void;
+}
+export function estimateWebcamGazeFromLandmarks(
+  landmarks: readonly NormalizedFaceLandmark[],
+  config?: Partial<WebcamGazeConfig>
+): WebcamGazeSample | null;
+export function webcamGazeToRay(
+  sample: Pick<WebcamGazeSample, 'foveal_center'>,
+  maxAngleDegrees?: number
+): [number, number, number];
+export const webcamGazeHandler: TraitHandler<WebcamGazeConfig>;
+
+// ── Domain plugins are NOT re-exported from core ──────────────────────────────
+// Core must not statically depend on domain plugins — plugins are data, not code
+// (CLAUDE.md / NORTH_STAR). Re-exporting them (even type-only) forced every
+// consumer of '@holoscript/core/traits' to resolve each plugin's types, which
+// point at source, dragging ~189 plugin source files (incl. .tsx importing
+// react/three) into slim builds → TS2307 (broke Studio deploy 2026-05-26).
+// Import a plugin directly from its own package, e.g. '@holoscript/radio-astronomy-plugin'.
+
+// ── Quantum-Inspired optimization trait ──────────────────────────────────────
+// (packages/core/src/traits/QuantumInspiredTrait.ts)
+
+/** Minimal subset of SnnAccelerator the trait depends on. */
+export interface SnnAcceleratorLike {
+  readonly available: boolean;
+  initialize(opts?: { enableSnn?: boolean; snnTimesteps?: number }): Promise<void>;
+  encode(histogram: Float32Array): Promise<Float32Array>;
+  dispose(): void;
+}
+
+/** Factory that constructs an SnnAcceleratorLike instance on demand. */
+export type SnnAcceleratorProvider = () => SnnAcceleratorLike;
+
+export interface QuantumInspiredConfig {
+  /** Number of LIF neurons for population coding. Default: 128. */
+  numNeurons: number;
+  /** Scalar learning-rate exposed to .hs authors. Default: 0.01. */
+  learningRate: number;
+  /** LIF simulation timesteps per encode call. Default: 50. */
+  snnTimesteps: number;
+  /**
+   * Optional factory for a concrete SnnAcceleratorLike.
+   * Inject () => new SnnAccelerator() from @holoscript/holoembed for GPU.
+   * Omit for pure-CPU sigmoid fallback.
+   */
+  acceleratorProvider?: SnnAcceleratorProvider;
+}
+
+export declare const quantumInspiredHandler: TraitHandler<QuantumInspiredConfig>;