@holoscript/core 8.0.8 → 8.0.10

package/dist/index.d.ts

@@ -29,6 +29,222 @@ export interface TraitHandler<T = any> {
   [key: string]: any;
 }
 
+export type SRGB = readonly [r: number, g: number, b: number];
+export type LinearRGB = readonly [r: number, g: number, b: number];
+export type XYZ = readonly [x: number, y: number, z: number];
+
+export interface Lab {
+  L: number;
+  a: number;
+  b: number;
+}
+
+export interface PerceptualDistanceOptions {
+  dampening?: number;
+  steps?: number;
+}
+export type LabMetricTensor = readonly [
+  readonly [number, number, number],
+  readonly [number, number, number],
+  readonly [number, number, number],
+];
+export interface DeltaE2000MetricTensorOptions {
+  epsilon?: number;
+  regularization?: number;
+}
+export interface DeltaE2000GeodesicOptions extends DeltaE2000MetricTensorOptions {
+  segments?: number;
+  iterations?: number;
+  stepSize?: number;
+  gradientStep?: number;
+  maxCoordinateStep?: number;
+  clampLab?: boolean;
+}
+export interface DeltaE2000GeodesicResult {
+  path: Lab[];
+  length: number;
+  straightLength: number;
+  energy: number;
+  iterations: number;
+}
+export interface LanlGrayAchromaticAggregate {
+  Ls: number;
+  Lt1: number;
+  Lt2: number;
+  count: number;
+  choseT2: number;
+}
+export interface LanlGrayChoiceModelOptions {
+  dampening?: number;
+  noise?: number;
+}
+export interface LanlGrayFitOptions {
+  dampeningCandidates?: readonly number[];
+  noiseCandidates?: readonly number[];
+}
+export interface LanlGrayFitResult {
+  dampening: number;
+  noise: number;
+  negativeLogLikelihood: number;
+  meanAccuracy: number;
+  rows: number;
+}
+
+export const DAMPENING_OFF: number;
+export const DEFAULT_DAMPENING: number;
+export const DEFAULT_LANL_GRAY_NOISE: number;
+
+export function srgbToLinearChannel(c: number): number;
+export function linearToSrgbChannel(c: number): number;
+export function srgbToLinear(rgb: SRGB): LinearRGB;
+export function linearToSrgb(rgb: LinearRGB): SRGB;
+export function linearRgbToXyz(rgb: LinearRGB): XYZ;
+export function xyzToLinearRgb(xyz: XYZ): LinearRGB;
+export function xyzToLab(xyz: XYZ): Lab;
+export function labToXyz(lab: Lab): XYZ;
+export function srgbToLab(rgb: SRGB): Lab;
+export function labToSrgb(lab: Lab): SRGB;
+export function deltaE2000(lab1: Lab, lab2: Lab): number;
+export function dampen(x: number, tau?: number): number;
+export function arcLengthDeltaE2000(A: Lab, B: Lab, steps?: number): number;
+export function metricTensorDeltaE2000(center: Lab, options?: DeltaE2000MetricTensorOptions): LabMetricTensor;
+export function labMetricQuadraticForm(vector: readonly [number, number, number], metric: LabMetricTensor): number;
+export function metricTensorArcLengthDeltaE2000(A: Lab, B: Lab, steps?: number, options?: DeltaE2000MetricTensorOptions): number;
+export function solveDeltaE2000Geodesic(A: Lab, B: Lab, options?: DeltaE2000GeodesicOptions): DeltaE2000GeodesicResult;
+export function lanlGrayChoiceProbability(row: Pick<LanlGrayAchromaticAggregate, 'Ls' | 'Lt1' | 'Lt2'>, options?: LanlGrayChoiceModelOptions): number;
+export function lanlGrayNegativeLogLikelihood(rows: readonly LanlGrayAchromaticAggregate[], options?: LanlGrayChoiceModelOptions): number;
+export function lanlGrayMeanAccuracy(rows: readonly LanlGrayAchromaticAggregate[], options?: LanlGrayChoiceModelOptions): number;
+export function fitLanlGrayAchromaticModel(rows: readonly LanlGrayAchromaticAggregate[], options?: LanlGrayFitOptions): LanlGrayFitResult;
+export function perceptualDistance(a: SRGB, b: SRGB, options?: PerceptualDistanceOptions): number;
+export function nearestNeutral(c: SRGB): SRGB;
+export function lightness(c: SRGB): number;
+export function chroma(c: SRGB): number;
+export function hue(c: SRGB): number;
+export function perceptualLerp(a: SRGB, b: SRGB, t: number): SRGB;
+export const LANL_GRAY_ACHROMATIC_SOURCE: {
+  readonly repo: string;
+  readonly dataUrl: string;
+  readonly path: string;
+  readonly sha: string;
+  readonly columns: readonly string[];
+  readonly license: string;
+  readonly deposited: string;
+  readonly note: string;
+};
+export const LANL_GRAY_ACHROMATIC_AGGREGATES: readonly LanlGrayAchromaticAggregate[];
+
+export type PerceptualColorPassSource = 'palette' | 'gradient' | 'color_map';
+export type PerceptualColorMode = 'auto' | 'palette' | 'gradient' | 'color_map';
+export interface PerceptualGradientStop { t: number; color: string; }
+export interface PerceptualColorPassOptions {
+  steps?: number;
+  dampening?: number;
+  arcSteps?: number;
+  targetDeltaE?: number;
+  neutralAxis?: boolean;
+}
+export interface PerceptualColorPassInput {
+  palette?: readonly string[];
+  gradient?: readonly (string | PerceptualGradientStop)[];
+  colorMap?: string | readonly (string | PerceptualGradientStop)[];
+  steps?: number;
+  dampening?: number;
+  arcSteps?: number;
+  targetDeltaE?: number;
+  neutralAxis?: boolean;
+  scientific?: boolean;
+}
+export interface PerceptualPaletteResult {
+  colors: string[];
+  pairwiseDeltaE: number[];
+  minDeltaE: number;
+  maxDeltaE: number;
+  meanDeltaE: number;
+  nearestNeutral?: string[];
+}
+export interface PerceptualGradientResult {
+  stops: PerceptualGradientStop[];
+  colors: string[];
+  deltaE: number[];
+  minDeltaE: number;
+  maxDeltaE: number;
+  meanDeltaE: number;
+}
+export interface PerceptualColorMapResult extends PerceptualGradientResult { name: string; }
+export interface PerceptualColorPassResult {
+  algorithm: 'perceptual_lerp_delta_e2000';
+  source: PerceptualColorPassSource;
+  scientific: boolean;
+  targetDeltaE: number;
+  dampening: number;
+  palette?: PerceptualPaletteResult;
+  gradient?: PerceptualGradientResult;
+  colorMap?: PerceptualColorMapResult;
+  warnings: string[];
+}
+export interface PerceptualColorAnalysis {
+  color: string;
+  lightness: number;
+  chroma: number;
+  hue: number;
+  nearestNeutral: string;
+}
+export interface PerceptualColorConfig {
+  mode: PerceptualColorMode;
+  palette: string[];
+  gradient: PerceptualGradientStop[];
+  color_map: string;
+  steps: number;
+  dampening: number;
+  target_delta_e: number;
+  neutral_axis: boolean;
+  scientific: boolean;
+  emit_analysis: boolean;
+}
+export interface PerceptualColorTraitOutput {
+  mode: PerceptualColorMode;
+  palette?: string[];
+  gradient?: PerceptualGradientStop[];
+  colorMap?: string;
+  analysis?: PerceptualColorAnalysis[];
+  compilerColorPass: PerceptualColorPassResult;
+}
+export interface PerceptualColorState {
+  revisions: number;
+  lastApplied: PerceptualColorTraitOutput | null;
+}
+export interface PerceptualColorCompilerMetadata {
+  mapName: string;
+  colors: string[];
+  stops: PerceptualGradientStop[];
+  minDeltaE: number;
+  maxDeltaE: number;
+  meanDeltaE: number;
+  warnings: string[];
+  pass: PerceptualColorPassResult;
+}
+export const SCIENTIFIC_COLOR_MAPS: Record<string, readonly string[]>;
+export const perceptualColorHandler: TraitHandler<PerceptualColorConfig>;
+export function normalizeHexColor(color: string): string;
+export function hexToSrgb(color: string): readonly [number, number, number];
+export function srgbToHex(rgb: readonly [number, number, number]): string;
+export function buildPerceptualGradient(
+  stops: readonly (string | PerceptualGradientStop)[],
+  options?: PerceptualColorPassOptions
+): PerceptualGradientResult;
+export function buildPerceptualPalette(
+  colors: readonly string[],
+  options?: PerceptualColorPassOptions
+): PerceptualPaletteResult;
+export function analyzePerceptualColor(color: string): {
+  color: string;
+  lightness: number;
+  chroma: number;
+  hue: number;
+  nearestNeutral: string;
+};
+export function applyPerceptualColorPass(input: PerceptualColorPassInput): PerceptualColorPassResult;
+
 export interface ParsedTrait {
   name: string;
   config: any;
@@ -248,6 +464,23 @@ export function parseHoloScriptPlus(source: string, options?: any): ParseResult;
 export const holoFactory: any;
 export function generateHoloSource(ast: any): string;
 
+// uAAL cognitive front-end bridge (G3): HoloComposition behavior -> UAAL bytecode.
+export class UaalBehaviorCompiler {
+  compile(composition: any): {
+    bytecode: { version: number; instructions: Array<{ opCode: number; operands?: any[] }> };
+    stats: {
+      actions: number;
+      handlers: number;
+      statements: number;
+      instructions: number;
+      executeCalls: number;
+      branches: number;
+      unhandled: Record<string, number>;
+      compilationMs: number;
+    };
+  };
+}
+
 // ============================================================================
 // COMPOSITION TYPES (from .holo files)
 // ============================================================================
@@ -771,14 +1004,23 @@ export class HoloScriptCompiler {
   compile(ast: any, target: string): any;
 }
 
-export class R3FCompiler {
+export interface SceneIRCompilerOptions {
+  qualityTier?: 'low' | 'med' | 'high' | 'ultra';
+  defaultLighting?: boolean;
+  holomapPointCloud?: any;
+  platformTarget?: any;
+}
+
+export class SceneIRCompiler {
+  constructor(options?: SceneIRCompilerOptions);
   compile(ast: any): any;
+  compileComposition(composition: any): R3FNode;
   [key: string]: any;
 }
 
 export interface CompilationResult {
   success: boolean;
-  r3fCode?: string;
+  sceneIR?: unknown;
   error?: string;
   metadata?: {
     zones: number;
@@ -796,16 +1038,6 @@ export class CompilerBridge {
 
 export function getCompilerBridge(): CompilerBridge;
 
-export interface Native2DCompilerOptions {
-  format?: 'html' | 'react';
-  minify?: boolean;
-}
-
-export class Native2DCompiler {
-  constructor(options?: Native2DCompilerOptions);
-  compile(ast: any, agentToken: string, outputPath?: string, options?: Native2DCompilerOptions): string | any;
-}
-
 export interface TraitCompositionDecl {
   name: string;
   components: string[];
@@ -1983,6 +2215,13 @@ export declare class AnimationEngine {
   update(delta: number): void;
   clear(): void;
 }
+export interface SampledKeyframe { time: number; value: number; easing?: string; }
+export declare function applyEasing(t: number, easing: string): number;
+export declare function sampleTrack(
+  keyframes: SampledKeyframe[],
+  t: number,
+  defaultEasing?: string
+): number;
 
 // ============================================================================
 // AUDIO ENGINE
@@ -3230,13 +3469,9 @@ export class OpenXRCompiler { constructor(options?: any); [key: string]: any; }
 export class AndroidCompiler { constructor(options?: any); [key: string]: any; }
 export class AndroidXRCompiler { constructor(options?: any); [key: string]: any; }
 export class IOSCompiler { constructor(options?: any); [key: string]: any; }
-export class ARCompiler { constructor(options?: any); [key: string]: any; }
-export class BabylonCompiler { constructor(options?: any); [key: string]: any; }
 export class WebGPUCompiler { constructor(options?: any); [key: string]: any; }
 export class WASMCompiler { constructor(options?: any); [key: string]: any; }
-export class PlayCanvasCompiler { constructor(options?: any); [key: string]: any; }
 export class DTDLCompiler { constructor(options?: any); [key: string]: any; }
-export class VRRCompiler { constructor(options?: any); [key: string]: any; }
 export class MultiLayerCompiler { constructor(options?: any); [key: string]: any; }
 
 export declare const VR_TRAITS: any;
@@ -3245,7 +3480,7 @@ export class CircuitBreakerRegistry { [key: string]: any; }
 export class CircuitState { [key: string]: any; }
 export class ExportManager { [key: string]: any; }
 export declare function getExportManager(options?: Partial<ExportOptions>): any;
-export type ExportTarget = 'urdf' | 'sdf' | 'unity' | 'unreal' | 'godot' | 'vrchat' | 'openxr' | 'android' | 'android-xr' | 'ios' | 'visionos' | 'ar' | 'babylon' | 'webgpu' | 'r3f' | 'wasm' | 'playcanvas' | 'usd' | 'usdz' | 'dtdl' | 'vrr' | 'multi-layer' | 'incremental' | 'state' | 'trait-composition' | 'tsl' | 'a2a-agent-card' | 'nir' | 'openxr-spatial-entities' | 'phone-sleeve-vr' | 'native-2d' | 'context' | '3dgs';
+export type ExportTarget = 'urdf' | 'sdf' | 'unity' | 'unreal' | 'godot' | 'vrchat' | 'openxr' | 'android' | 'android-xr' | 'ios' | 'visionos' | 'webgpu' | 'wasm' | 'usd' | 'usdz' | 'dtdl' | 'multi-layer' | 'incremental' | 'state' | 'trait-composition' | 'tsl' | 'a2a-agent-card' | 'nir' | 'openxr-spatial-entities' | 'context' | '3dgs';
 export class ExportOptions { [key: string]: any; }
 export declare function selectModality(platform: any, options?: any): any;
 export declare function selectModalityForAll(options?: any): Map<any, any>;
@@ -4351,7 +4586,6 @@ export function parseHoloPartial(source: string, options?: any): any;
 export function compileToWASM(ast: any, options?: any): any;
 
 // Compilers re-exported to main barrel for dynamic import callers
-export class FlatSemanticCompiler { constructor(options?: any); compile(ast: any, ...args: any[]): any; [key: string]: any; }
 export class SCMCompiler { constructor(options?: any); compile(ast: any, token?: any): any; [key: string]: any; }
 export class GaussianSplattingCompiler { constructor(options?: { format?: 'gltf' | 'glb'; [key: string]: any }); compile(ast: any, token?: any, ...args: any[]): any; [key: string]: any; }
 
@@ -4366,3 +4600,11 @@ export const ErrorRecovery: any;
 export const HOLOSCHEMA_KEYWORDS: string[];
 export const HOLOSCHEMA_GEOMETRIES: string[];
 export const HOLOSCHEMA_PROPERTIES: string[];
+
+// Known-trait union seam — SSOT for parser / LSP / linter trait vocabulary
+// (src/traits/knownTraitSet.ts, re-exported via barrel/trait-stdlib-interop).
+export declare function buildKnownTraitSet(
+  extras?: ReadonlyArray<string | readonly string[]>
+): Set<string>;
+export const NATIVE2D_TRAITS: readonly string[];
+export const CODE_GRAPH_TRAITS: readonly string[];