@holoscript/core 8.0.8 → 8.0.9

package/dist/traits/kinematic-chain.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+var chunk3ILD7TKP_cjs = require('../chunk-3ILD7TKP.cjs');
+require('../chunk-ZHPMP447.cjs');
+
+
+
+Object.defineProperty(exports, "dhTransform", {
+  enumerable: true,
+  get: function () { return chunk3ILD7TKP_cjs.dhTransform; }
+});
+Object.defineProperty(exports, "kinematicChainHandler", {
+  enumerable: true,
+  get: function () { return chunk3ILD7TKP_cjs.kinematicChainHandler; }
+});
+Object.defineProperty(exports, "solveFk", {
+  enumerable: true,
+  get: function () { return chunk3ILD7TKP_cjs.solveFk; }
+});
+Object.defineProperty(exports, "solveIk", {
+  enumerable: true,
+  get: function () { return chunk3ILD7TKP_cjs.solveIk; }
+});
+//# sourceMappingURL=kinematic-chain.cjs.map
+//# sourceMappingURL=kinematic-chain.cjs.map

package/dist/traits/kinematic-chain.d.ts

@@ -0,0 +1 @@
+export * from './KinematicChainTrait.js';

package/dist/traits/kinematic-chain.js

@@ -0,0 +1,4 @@
+export { dhTransform, kinematicChainHandler, solveFk, solveIk } from '../chunk-EEMTCAK7.js';
+import '../chunk-W4GABFCR.js';
+//# sourceMappingURL=kinematic-chain.js.map
+//# sourceMappingURL=kinematic-chain.js.map

package/dist/traits/sensor-sampling.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var chunkUXBYA7DV_cjs = require('../chunk-UXBYA7DV.cjs');
+require('../chunk-ZHPMP447.cjs');
+
+
+
+Object.defineProperty(exports, "SensorRingBuffer", {
+  enumerable: true,
+  get: function () { return chunkUXBYA7DV_cjs.SensorRingBuffer; }
+});
+Object.defineProperty(exports, "applyNoise", {
+  enumerable: true,
+  get: function () { return chunkUXBYA7DV_cjs.applyNoise; }
+});
+Object.defineProperty(exports, "boxMuller", {
+  enumerable: true,
+  get: function () { return chunkUXBYA7DV_cjs.boxMuller; }
+});
+Object.defineProperty(exports, "computeWindowStats", {
+  enumerable: true,
+  get: function () { return chunkUXBYA7DV_cjs.computeWindowStats; }
+});
+Object.defineProperty(exports, "recordReading", {
+  enumerable: true,
+  get: function () { return chunkUXBYA7DV_cjs.recordReading; }
+});
+Object.defineProperty(exports, "sensorSamplingHandler", {
+  enumerable: true,
+  get: function () { return chunkUXBYA7DV_cjs.sensorSamplingHandler; }
+});
+//# sourceMappingURL=sensor-sampling.cjs.map
+//# sourceMappingURL=sensor-sampling.cjs.map

package/dist/traits/sensor-sampling.d.ts

@@ -0,0 +1 @@
+export * from './SensorSamplingTrait.js';

package/dist/traits/sensor-sampling.js

@@ -0,0 +1,4 @@
+export { SensorRingBuffer, applyNoise, boxMuller, computeWindowStats, recordReading, sensorSamplingHandler } from '../chunk-J2DAS2PL.js';
+import '../chunk-W4GABFCR.js';
+//# sourceMappingURL=sensor-sampling.js.map
+//# sourceMappingURL=sensor-sampling.js.map

package/dist/traits/simulation-solver-factory.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 var chunk4PDEPEQW_cjs = require('../chunk-4PDEPEQW.cjs');
-require('../chunk-HCCQLAA4.cjs');
+require('../chunk-ZHPMP447.cjs');
 
 
 

package/dist/traits/simulation-solver-factory.js

@@ -1,4 +1,4 @@
 export { SimulationSolverFactory } from '../chunk-YQELFNJV.js';
-import '../chunk-OL46QLBJ.js';
+import '../chunk-W4GABFCR.js';
 //# sourceMappingURL=simulation-solver-factory.js.map
 //# sourceMappingURL=simulation-solver-factory.js.map

package/dist/traits/transaction.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var chunk2ZOTBO25_cjs = require('../chunk-2ZOTBO25.cjs');
+require('../chunk-ZHPMP447.cjs');
+
+
+
+Object.defineProperty(exports, "debitBalance", {
+  enumerable: true,
+  get: function () { return chunk2ZOTBO25_cjs.debitBalance; }
+});
+Object.defineProperty(exports, "depositBalance", {
+  enumerable: true,
+  get: function () { return chunk2ZOTBO25_cjs.depositBalance; }
+});
+Object.defineProperty(exports, "stakeBalance", {
+  enumerable: true,
+  get: function () { return chunk2ZOTBO25_cjs.stakeBalance; }
+});
+Object.defineProperty(exports, "transactionHandler", {
+  enumerable: true,
+  get: function () { return chunk2ZOTBO25_cjs.transactionHandler; }
+});
+Object.defineProperty(exports, "unstakeBalance", {
+  enumerable: true,
+  get: function () { return chunk2ZOTBO25_cjs.unstakeBalance; }
+});
+//# sourceMappingURL=transaction.cjs.map
+//# sourceMappingURL=transaction.cjs.map

package/dist/traits/transaction.d.ts

@@ -0,0 +1 @@
+export * from './TransactionTrait.js';

package/dist/traits/transaction.js

@@ -0,0 +1,4 @@
+export { debitBalance, depositBalance, stakeBalance, transactionHandler, unstakeBalance } from '../chunk-GTIPOEHN.js';
+import '../chunk-W4GABFCR.js';
+//# sourceMappingURL=transaction.js.map
+//# sourceMappingURL=transaction.js.map

package/dist/traits/webcam-gaze.cjs

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var chunk3FOKASKO_cjs = require('../chunk-3FOKASKO.cjs');
-require('../chunk-HCCQLAA4.cjs');
+require('../chunk-ZHPMP447.cjs');
 
 
 

package/dist/traits/webcam-gaze.js

@@ -1,4 +1,4 @@
 export { DEFAULT_WEBCAM_GAZE_CONFIG, WebcamGazeTracker, WebcamGazeTrait_default as default, estimateWebcamGazeFromLandmarks, webcamGazeHandler, webcamGazeToRay } from '../chunk-TDCNJHWO.js';
-import '../chunk-OL46QLBJ.js';
+import '../chunk-W4GABFCR.js';
 //# sourceMappingURL=webcam-gaze.js.map
 //# sourceMappingURL=webcam-gaze.js.map

package/dist/type-checker.cjs

@@ -1,19 +1,20 @@
 'use strict';
 
-var chunkW6RW64BB_cjs = require('./chunk-W6RW64BB.cjs');
-require('./chunk-C37BHB7N.cjs');
-require('./chunk-E7JP3BS3.cjs');
-require('./chunk-HCCQLAA4.cjs');
+var chunkHSWBIDZM_cjs = require('./chunk-HSWBIDZM.cjs');
+require('./chunk-ESBXUYOC.cjs');
+require('./chunk-P26YYPOO.cjs');
+require('./chunk-Q47JEE2C.cjs');
+require('./chunk-ZHPMP447.cjs');
 
 
 
 Object.defineProperty(exports, "HoloScriptTypeChecker", {
   enumerable: true,
-  get: function () { return chunkW6RW64BB_cjs.HoloScriptTypeChecker; }
+  get: function () { return chunkHSWBIDZM_cjs.HoloScriptTypeChecker; }
 });
 Object.defineProperty(exports, "createTypeChecker", {
   enumerable: true,
-  get: function () { return chunkW6RW64BB_cjs.createTypeChecker; }
+  get: function () { return chunkHSWBIDZM_cjs.createTypeChecker; }
 });
 //# sourceMappingURL=type-checker.cjs.map
 //# sourceMappingURL=type-checker.cjs.map

package/dist/type-checker.js

@@ -1,6 +1,7 @@
-export { HoloScriptTypeChecker, createTypeChecker } from './chunk-VMLKSV26.js';
-import './chunk-XSFNHP2E.js';
-import './chunk-VVKVQZI6.js';
-import './chunk-OL46QLBJ.js';
+export { HoloScriptTypeChecker, createTypeChecker } from './chunk-MDDWEBCX.js';
+import './chunk-ZVFHPMC5.js';
+import './chunk-KB26H447.js';
+import './chunk-RAN3ECAS.js';
+import './chunk-W4GABFCR.js';
 //# sourceMappingURL=type-checker.js.map
 //# sourceMappingURL=type-checker.js.map

package/dist/types/AdvancedTypeSystem.d.ts

@@ -0,0 +1,489 @@
+/**
+ * @holoscript/core Advanced Type System
+ *
+ * Union types, generics, type inference, exhaustiveness checking
+ */
+export type HoloScriptType = PrimitiveType | ArrayType | UnionType | IntersectionType | GenericType | LiteralType | CustomType;
+/**
+ * Primitive types
+ */
+export type PrimitiveTypeName = 'number' | 'string' | 'boolean' | 'void';
+export interface PrimitiveType {
+    kind: 'primitive';
+    name: PrimitiveTypeName;
+}
+/**
+ * Array type: T[]
+ */
+export interface ArrayType {
+    kind: 'array';
+    elementType: HoloScriptType;
+}
+/**
+ * Union type: A | B | C
+ */
+export interface UnionType {
+    kind: 'union';
+    members: HoloScriptType[];
+}
+/**
+ * Intersection type: A & B
+ */
+export interface IntersectionType {
+    kind: 'intersection';
+    members: HoloScriptType[];
+}
+/**
+ * Generic type: Container<T>
+ */
+export interface GenericType {
+    kind: 'generic';
+    name: string;
+    typeArgs: HoloScriptType[];
+}
+/**
+ * Literal type: "idle" | "moving"
+ */
+export interface LiteralType {
+    kind: 'literal';
+    value: string | number | boolean;
+}
+/**
+ * Custom type: User-defined types
+ */
+export interface CustomType {
+    kind: 'custom';
+    name: string;
+    properties: Map<string, HoloScriptType>;
+    methods: Map<string, FunctionType>;
+}
+/**
+ * Function type
+ */
+export interface FunctionType {
+    kind: 'function';
+    parameters: {
+        name: string;
+        type: HoloScriptType;
+    }[];
+    returnType: HoloScriptType;
+}
+/**
+ * Type inference engine
+ */
+export declare class TypeInferenceEngine {
+    /**
+     * Infer type from value
+     */
+    inferType(value: unknown): HoloScriptType;
+    /**
+     * Check type compatibility
+     */
+    isAssignableTo(from: HoloScriptType, to: HoloScriptType): boolean;
+    /**
+     * Unify types (for generics)
+     */
+    unify(t1: HoloScriptType, t2: HoloScriptType): Map<string, HoloScriptType>;
+    private isTypeVariable;
+    /**
+     * Resolve generic type with type arguments
+     */
+    resolveGeneric(generic: GenericType, concreteTypes: HoloScriptType[]): HoloScriptType;
+    private substitute;
+}
+/**
+ * Exhaustiveness checker for match statements
+ */
+export declare class ExhaustivenessChecker {
+    /**
+     * Check if all union members are covered in match statement
+     */
+    checkMatch(unionType: UnionType, casePatterns: string[]): {
+        isExhaustive: boolean;
+        uncoveredCases: string[];
+    };
+    private getCaseName;
+}
+/**
+ * Type checker for HoloScript+
+ */
+export declare class AdvancedTypeChecker {
+    private inference;
+    private exhaustiveness;
+    private types;
+    constructor();
+    /**
+     * Infer type from value
+     */
+    inferType(value: unknown): HoloScriptType;
+    /**
+     * Check if from is assignable to to
+     */
+    isAssignableTo(from: HoloScriptType, to: HoloScriptType): boolean;
+    private registerBuiltins;
+    /**
+     * Register a new type
+     */
+    registerType(name: string, type: HoloScriptType): void;
+    /**
+     * Get registered type
+     */
+    getType(name: string): HoloScriptType | undefined;
+    /**
+     * Check union exhaustiveness
+     */
+    checkUnionExhaustiveness(unionType: UnionType, cases: string[]): {
+        isExhaustive: boolean;
+        uncoveredCases: string[];
+    };
+    /**
+     * Check type assignment
+     */
+    checkAssignment(from: HoloScriptType, to: HoloScriptType): {
+        valid: boolean;
+        error?: string;
+    };
+    /**
+     * Format type for display
+     */
+    formatType(type: HoloScriptType): string;
+}
+/**
+ * HoloScript+ AST Types
+ */
+export interface ASTProgram {
+    type: 'Program';
+    body: unknown[];
+    version: string | number;
+    root: unknown;
+    imports: Array<{
+        path: string;
+        alias: string;
+        namedImports?: string[];
+        isWildcard?: boolean;
+    }>;
+    hasState: boolean;
+    hasVRTraits: boolean;
+    hasControlFlow: boolean;
+    migrations?: unknown[];
+}
+export type HSPlusAST = ASTProgram;
+export type HSPlusDirective = HSPlusBaseDirective | HSPlusTraitDirective | HSPlusTraitSumDirective | HSPlusLifecycleDirective | HSPlusStateDirective | HSPlusForDirective | HSPlusForEachDirective | HSPlusWhileDirective | HSPlusIfDirective | HSPlusImportDirective | HSPlusVersionDirective | HSPlusMigrateDirective | HSPlusBindingsDirective | HSPlusExportDirective | HSPlusConfigDirective | HSPlusNamedConfigDirective | HSPlusAnnotateDirective | HSPlusSemanticRefDirective | HSPlusZonesDirective | HSPlusSpawnPointsDirective | HSPlusExternalApiDirective | HSPlusGenerateDirective | HSPlusNpcDirective | HSPlusDialogDirective | HSPlusHololandEventDirective | HSPlusAssetDirective;
+export interface HSPlusBaseDirective {
+    type: 'directive' | 'fragment';
+    name: string;
+    args: string[];
+}
+export interface HSPlusTraitDirective {
+    type: 'trait';
+    name: string;
+    args?: unknown[];
+    config?: Record<string, unknown>;
+}
+export interface HSPlusTraitAtom {
+    type: 'trait_atom';
+    name: string;
+    config: Record<string, unknown>;
+}
+export interface HSPlusTraitSumDirective {
+    type: 'trait_sum';
+    operation: 'additive';
+    alternatives: HSPlusTraitAtom[];
+}
+export interface HSPlusLifecycleDirective {
+    type: 'lifecycle';
+    name?: string;
+    hook: string;
+    params?: string[];
+    body: string;
+}
+export interface HSPlusStateDirective {
+    type: 'state';
+    name?: string;
+    body?: Record<string, unknown>;
+    initial?: unknown;
+}
+export interface HSPlusForDirective {
+    type: 'for';
+    variable: string;
+    range?: [number, number];
+    iterable?: string;
+    body: unknown[];
+}
+export interface HSPlusForEachDirective {
+    type: 'forEach';
+    variable: string;
+    collection: string;
+    body: unknown[];
+}
+export interface HSPlusWhileDirective {
+    type: 'while';
+    condition: string;
+    body: unknown[];
+}
+export interface HSPlusIfDirective {
+    type: 'if';
+    condition: string;
+    body: unknown[];
+    else?: unknown[];
+}
+export interface HSPlusImportDirective {
+    type: 'import';
+    path: string;
+    alias: string;
+    namedImports?: string[];
+    isWildcard?: boolean;
+}
+export interface HSPlusVersionDirective {
+    type: 'version';
+    version: number;
+}
+export interface HSPlusMigrateDirective {
+    type: 'migrate';
+    fromVersion: number;
+    body: string;
+}
+export interface HSPlusBindingsDirective {
+    type: 'bindings';
+    bindings: unknown[];
+}
+export interface HSPlusExportDirective {
+    type: 'export';
+    exportKind: string;
+    exportName: string;
+}
+/** Config-spread directives: { type: 'skybox', ...config } */
+export interface HSPlusConfigDirective {
+    type: 'world_metadata' | 'world_config' | 'skybox' | 'ambient_light' | 'fog' | 'artwork_metadata' | 'npc_behavior' | 'interactive' | 'lod' | 'gravity' | 'time_of_day' | 'audio_settings' | 'render_settings' | 'physics_config' | 'network_config' | 'accessibility';
+    [key: string]: unknown;
+}
+/** Named config-spread directives: { type: 'manifest', name, ...config } */
+export interface HSPlusNamedConfigDirective {
+    type: 'manifest' | 'semantic' | 'directional_light';
+    name: string;
+    [key: string]: unknown;
+}
+export interface HSPlusAnnotateDirective {
+    type: 'annotate';
+    annotationType: string;
+    config: Record<string, unknown>;
+}
+export interface HSPlusSemanticRefDirective {
+    type: 'semantic_ref';
+    ref: string;
+}
+export interface HSPlusZonesDirective {
+    type: 'zones';
+    zones: unknown[];
+}
+export interface HSPlusSpawnPointsDirective {
+    type: 'spawn_points';
+    spawns: unknown[];
+}
+export interface HSPlusExternalApiDirective {
+    type: 'external_api';
+    url: string;
+    method: string;
+    interval?: unknown;
+    body?: unknown[];
+}
+export interface HSPlusGenerateDirective {
+    type: 'generate';
+    prompt: string;
+    context: string;
+    target: string;
+}
+export interface HSPlusNpcDirective {
+    type: 'npc';
+    name: string;
+    props: Record<string, unknown>;
+}
+export interface HSPlusDialogDirective {
+    type: 'dialog';
+    name: string;
+    props: Record<string, unknown>;
+    options: unknown[];
+}
+export interface HSPlusHololandEventDirective {
+    type: 'hololand_event';
+    event: string;
+    params: unknown[];
+}
+export interface HSPlusAssetDirective {
+    type: 'asset';
+    id?: string;
+    [key: string]: unknown;
+}
+export interface HSPlusCompileResult {
+    success: boolean;
+    code?: string;
+    sourceMap?: unknown;
+    errors: Array<{
+        message: string;
+        line: number;
+        column: number;
+    }>;
+    ast?: unknown;
+    compiledExpressions?: unknown;
+    requiredCompanions?: string[];
+    features?: unknown;
+    warnings?: unknown[];
+    [key: string]: unknown;
+}
+export interface HSPlusParserOptions {
+    sourceMap?: boolean;
+    strict?: boolean;
+    enableTypeScriptImports?: boolean;
+    enableVRTraits?: boolean;
+}
+export interface StateDeclaration {
+    name: string;
+    type: HoloScriptType;
+    initialValue?: unknown;
+    [key: string]: unknown;
+}
+export interface LifecycleHook {
+    name: 'mounted' | 'updated' | 'destroyed';
+    handler: string;
+}
+export interface VRLifecycleHook {
+    name: 'grabbed' | 'released' | 'pointed' | 'unpointed' | 'thrown';
+    handler: string;
+}
+export interface ControllerHook {
+    name: 'trigger' | 'grip' | 'thumbstick' | 'button_a' | 'button_b';
+    handler: string;
+}
+/**
+ * Optional chaining expression: obj?.prop, arr?.[0], fn?.()
+ */
+export interface OptionalChainExpression {
+    kind: 'optional-chain';
+    base: Expression;
+    chain: OptionalChainSegment[];
+}
+export type OptionalChainSegment = {
+    type: 'property';
+    name: string;
+    optional: boolean;
+} | {
+    type: 'index';
+    index: Expression;
+    optional: boolean;
+} | {
+    type: 'call';
+    args: Expression[];
+    optional: boolean;
+};
+export type Expression = {
+    kind: 'identifier';
+    name: string;
+} | {
+    kind: 'literal';
+    value: string | number | boolean | null;
+} | {
+    kind: 'member';
+    object: Expression;
+    property: string;
+} | {
+    kind: 'index';
+    object: Expression;
+    index: Expression;
+} | {
+    kind: 'call';
+    callee: Expression;
+    arguments: Expression[];
+} | {
+    kind: 'binary';
+    operator: string;
+    left: Expression;
+    right: Expression;
+} | {
+    kind: 'unary';
+    operator: string;
+    operand: Expression;
+} | OptionalChainExpression | NullCoalescingExpression;
+/**
+ * Null coalescing expression: a ?? b
+ */
+export interface NullCoalescingExpression {
+    kind: 'null-coalescing';
+    left: Expression;
+    right: Expression;
+}
+/**
+ * Parse and evaluate optional chaining expressions
+ */
+export declare class OptionalChainingEvaluator {
+    /**
+     * Evaluate optional chain expression
+     */
+    evaluate(expr: OptionalChainExpression, context: Record<string, unknown>): unknown;
+    /**
+     * Evaluate null coalescing expression
+     */
+    evaluateNullCoalescing(expr: NullCoalescingExpression, context: Record<string, unknown>): unknown;
+    /**
+     * Evaluate any expression
+     */
+    evaluateExpression(expr: Expression, context: Record<string, unknown>): unknown;
+    private evaluateBinary;
+    private evaluateUnary;
+}
+/**
+ * Parse optional chaining syntax from string
+ */
+export declare class OptionalChainingParser {
+    private input;
+    private pos;
+    /**
+     * Parse expression string with optional chaining
+     */
+    parse(input: string): Expression;
+    private parseExpression;
+    private parseNullCoalescing;
+    private parseOr;
+    private parseAnd;
+    private parseEquality;
+    private parseComparison;
+    private parseTerm;
+    private parseFactor;
+    private parseUnary;
+    private parsePostfix;
+    private parsePrimary;
+    private parseArguments;
+    private parseIdentifier;
+    private parseNumber;
+    private parseString;
+    private peek;
+    private match;
+    private matchWord;
+    private expect;
+    private skipWhitespace;
+}
+/**
+ * Parse type annotations from strings
+ * Supports: string, number, Array<T>, Map<K, V>, T | U, T & U
+ */
+export declare class TypeAnnotationParser {
+    private input;
+    private pos;
+    /**
+     * Parse type annotation string
+     */
+    parse(input: string): HoloScriptType;
+    private parseType;
+    private parseUnionType;
+    private parseIntersectionType;
+    private parseArrayType;
+    private parsePrimaryType;
+    private parseTypeArguments;
+    private parseIdentifier;
+    private parseString;
+    private parseNumber;
+    private peek;
+    private match;
+    private matchWord;
+    private expect;
+    private skipWhitespace;
+}