@holoscript/std 3.1.1 → 7.0.0

package/package.json

@@ -1,46 +1,53 @@
 {
   "name": "@holoscript/std",
-  "version": "3.1.1",
+  "version": "7.0.0",
   "description": "HoloScript Standard Library - Core types and utilities",
-  "main": "dist/index.js",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
     },
     "./math": {
       "types": "./dist/math.d.ts",
-      "import": "./dist/math.js"
+      "import": "./dist/math.js",
+      "require": "./dist/math.cjs"
     },
     "./collections": {
       "types": "./dist/collections.d.ts",
-      "import": "./dist/collections.js"
+      "import": "./dist/collections.js",
+      "require": "./dist/collections.cjs"
     },
     "./string": {
       "types": "./dist/string.d.ts",
-      "import": "./dist/string.js"
+      "import": "./dist/string.js",
+      "require": "./dist/string.cjs"
     },
     "./time": {
       "types": "./dist/time.d.ts",
-      "import": "./dist/time.js"
+      "import": "./dist/time.js",
+      "require": "./dist/time.cjs"
     },
     "./economic": {
       "types": "./dist/traits/EconomicPrimitives.d.ts",
-      "import": "./dist/traits/EconomicPrimitives.js"
+      "import": "./dist/traits/EconomicPrimitives.js",
+      "require": "./dist/traits/EconomicPrimitives.cjs"
     },
     "./economic-traits": {
       "types": "./dist/traits/EconomicTraits.d.ts",
-      "import": "./dist/traits/EconomicTraits.js"
+      "import": "./dist/traits/EconomicTraits.js",
+      "require": "./dist/traits/EconomicTraits.cjs"
+    },
+    "./fs": {
+      "types": "./dist/fs/index.d.ts",
+      "import": "./dist/fs/index.js",
+      "require": "./dist/fs/index.cjs"
     }
   },
-  "scripts": {
-    "build": "tsc",
-    "watch": "tsc -w",
-    "clean": "rm -rf dist",
-    "test": "vitest run --passWithNoTests"
-  },
   "keywords": [
     "holoscript",
     "std",
@@ -55,12 +62,22 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/brianonbased-dev/Holoscript.git",
+    "url": "https://github.com/brianonbased-dev/HoloScript.git",
     "directory": "packages/std"
   },
   "devDependencies": {
     "@types/node": "^24.10.1",
     "typescript": "~5.9.3",
-    "vitest": "^4.0.18"
+    "vitest": "^4.1.0"
+  },
+  "homepage": "https://github.com/brianonbased-dev/HoloScript#readme",
+  "bugs": {
+    "url": "https://github.com/brianonbased-dev/HoloScript/issues"
+  },
+  "scripts": {
+    "build": "tsup && tsc --emitDeclarationOnly --declarationDir dist --skipLibCheck",
+    "watch": "tsc -w",
+    "clean": "rm -rf dist",
+    "test": "vitest run --passWithNoTests"
   }
-}
+}

package/src/__tests__/index.test.ts

@@ -0,0 +1,14 @@
+import { describe, it, expect } from 'vitest';
+import * as std from '../index.js';
+
+describe('std/index', () => {
+  it('should export standard types and math', () => {
+    expect(std).toBeDefined();
+    expect(std.PI).toBeGreaterThan(3.14);
+  });
+
+  it('should export string utilities', () => {
+    expect(std.capitalize('holo')).toBe('Holo');
+    expect(typeof std.lerp).toBe('function');
+  });
+});

package/src/__tests__/{Sprint33.test.ts → standard-library-fundamentals.test.ts}

@@ -1,12 +1,12 @@
-/**
- * Sprint 33 — @holoscript/std acceptance tests
+/**
+ * @holoscript/std acceptance tests
  * Covers: types, collections, math, string, time
  */
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
-// ─────────────────────────────────────────────
+// ─────────────────────────────────────────────
 // types.ts
-// ─────────────────────────────────────────────
+// ─────────────────────────────────────────────
 import {
   vec2,
   vec3,
@@ -26,14 +26,14 @@ import {
   colorToHex,
 } from '../types.js';
 
-// ─────────────────────────────────────────────
+// ─────────────────────────────────────────────
 // collections.ts
-// ─────────────────────────────────────────────
+// ─────────────────────────────────────────────
 import { List, HoloMap, HoloSet, SpatialGrid, PriorityQueue } from '../collections.js';
 
-// ─────────────────────────────────────────────
+// ─────────────────────────────────────────────
 // math.ts
-// ─────────────────────────────────────────────
+// ─────────────────────────────────────────────
 import {
   PI,
   TAU,
@@ -60,9 +60,9 @@ import {
   random,
 } from '../math.js';
 
-// ─────────────────────────────────────────────
+// ─────────────────────────────────────────────
 // string.ts
-// ─────────────────────────────────────────────
+// ─────────────────────────────────────────────
 import {
   capitalize,
   titleCase,
@@ -113,9 +113,9 @@ import {
   uuid,
 } from '../string.js';
 
-// ─────────────────────────────────────────────
+// ─────────────────────────────────────────────
 // time.ts
-// ─────────────────────────────────────────────
+// ─────────────────────────────────────────────
 import {
   now,
   sleep,
@@ -127,10 +127,10 @@ import {
   DateTime,
 } from '../time.js';
 
-// ═══════════════════════════════════════════════
+// ═══════════════════════════════════════════════
 // types.ts
-// ═══════════════════════════════════════════════
-describe('types — factory functions', () => {
+// ═══════════════════════════════════════════════
+describe('types — factory functions', () => {
   it('vec2 defaults to (0,0)', () => {
     const v = vec2();
     expect(v.x).toBe(0);
@@ -203,13 +203,18 @@ describe('types — factory functions', () => {
   });
 });
 
-describe('types — conversion utilities', () => {
+describe('types — conversion utilities', () => {
   it('vec3ToArray / arrayToVec3 round-trip', () => {
     const v = vec3(1, 2, 3);
     const arr = vec3ToArray(v);
     expect(arr).toEqual([1, 2, 3]);
     const v2 = arrayToVec3(arr);
-    expect(v2).toEqual({ x: 1, y: 2, z: 3 });
+    // vec3() returns an Array-backed Vec3 with non-enumerable x/y/z accessors
+    // (types.ts:195). toEqual on {x,y,z} therefore fails on structure
+    // mismatch — assert each accessor instead to test the behavioral contract.
+    expect(v2.x).toBe(1);
+    expect(v2.y).toBe(2);
+    expect(v2.z).toBe(3);
   });
 
   it('quatToArray / arrayToQuat round-trip', () => {
@@ -236,9 +241,9 @@ describe('types — conversion utilities', () => {
   });
 });
 
-// ═══════════════════════════════════════════════
-// collections — List
-// ═══════════════════════════════════════════════
+// ═══════════════════════════════════════════════
+// collections — List
+// ═══════════════════════════════════════════════
 describe('List', () => {
   it('creates empty list', () => {
     const l = new List<number>();
@@ -363,9 +368,9 @@ describe('List', () => {
   });
 });
 
-// ═══════════════════════════════════════════════
-// collections — HoloMap
-// ═══════════════════════════════════════════════
+// ═══════════════════════════════════════════════
+// collections — HoloMap
+// ═══════════════════════════════════════════════
 describe('HoloMap', () => {
   it('creates empty map', () => {
     const m = new HoloMap<string, number>();
@@ -435,9 +440,9 @@ describe('HoloMap', () => {
   });
 });
 
-// ═══════════════════════════════════════════════
-// collections — HoloSet
-// ═══════════════════════════════════════════════
+// ═══════════════════════════════════════════════
+// collections — HoloSet
+// ═══════════════════════════════════════════════
 describe('HoloSet', () => {
   it('creates empty set', () => {
     const s = new HoloSet<number>();
@@ -516,9 +521,9 @@ describe('HoloSet', () => {
   });
 });
 
-// ═══════════════════════════════════════════════
-// collections — PriorityQueue
-// ═══════════════════════════════════════════════
+// ═══════════════════════════════════════════════
+// collections — PriorityQueue
+// ═══════════════════════════════════════════════
 describe('PriorityQueue', () => {
   it('minHeap dequeues lowest priority first', () => {
     const pq = PriorityQueue.minHeap<string>();
@@ -561,9 +566,9 @@ describe('PriorityQueue', () => {
   });
 });
 
-// ═══════════════════════════════════════════════
-// collections — SpatialGrid
-// ═══════════════════════════════════════════════
+// ═══════════════════════════════════════════════
+// collections — SpatialGrid
+// ═══════════════════════════════════════════════
 describe('SpatialGrid', () => {
   it('insert and query by radius', () => {
     const grid = new SpatialGrid<string>(1.0);
@@ -592,9 +597,9 @@ describe('SpatialGrid', () => {
   });
 });
 
-// ═══════════════════════════════════════════════
-// math — constants
-// ═══════════════════════════════════════════════
+// ═══════════════════════════════════════════════
+// math — constants
+// ═══════════════════════════════════════════════
 describe('math constants', () => {
   it('PI is ~3.14159', () => expect(PI).toBeCloseTo(3.14159, 4));
   it('TAU is 2*PI', () => expect(TAU).toBeCloseTo(PI * 2, 10));
@@ -604,10 +609,10 @@ describe('math constants', () => {
   it('EPSILON is small', () => expect(EPSILON).toBeGreaterThan(0));
 });
 
-// ═══════════════════════════════════════════════
-// math — basic functions
-// ═══════════════════════════════════════════════
-describe('math — basic functions', () => {
+// ═══════════════════════════════════════════════
+// math — basic functions
+// ═══════════════════════════════════════════════
+describe('math — basic functions', () => {
   it('clamp', () => {
     expect(clamp(5, 0, 10)).toBe(5);
     expect(clamp(-5, 0, 10)).toBe(0);
@@ -664,9 +669,9 @@ describe('math — basic functions', () => {
   });
 });
 
-// ═══════════════════════════════════════════════
-// math — vec2Math
-// ═══════════════════════════════════════════════
+// ═══════════════════════════════════════════════
+// math — vec2Math
+// ═══════════════════════════════════════════════
 describe('vec2Math', () => {
   it('add', () => {
     const r = vec2Math.add({ x: 1, y: 2 }, { x: 3, y: 4 });
@@ -712,13 +717,21 @@ describe('vec2Math', () => {
   });
 });
 
-// ═══════════════════════════════════════════════
-// math — vec3Math
-// ═══════════════════════════════════════════════
+// ═══════════════════════════════════════════════
+// math — vec3Math
+// ═══════════════════════════════════════════════
 describe('vec3Math', () => {
   it('zero / one factory functions', () => {
-    expect(vec3Math.zero()).toEqual({ x: 0, y: 0, z: 0 });
-    expect(vec3Math.one()).toEqual({ x: 1, y: 1, z: 1 });
+    // vec3() is Array-backed with non-enumerable x/y/z (types.ts:195); test
+    // accessor contract rather than object structure.
+    const z = vec3Math.zero();
+    expect(z.x).toBe(0);
+    expect(z.y).toBe(0);
+    expect(z.z).toBe(0);
+    const o = vec3Math.one();
+    expect(o.x).toBe(1);
+    expect(o.y).toBe(1);
+    expect(o.z).toBe(1);
   });
 
   it('up / down / forward / back factory functions', () => {
@@ -729,8 +742,12 @@ describe('vec3Math', () => {
   });
 
   it('add', () => {
+    // vec3Math.add returns a vec3() (Array-backed with non-enumerable x/y/z).
+    // Assert accessor contract instead of object structure.
     const r = vec3Math.add({ x: 1, y: 2, z: 3 }, { x: 4, y: 5, z: 6 });
-    expect(r).toEqual({ x: 5, y: 7, z: 9 });
+    expect(r.x).toBe(5);
+    expect(r.y).toBe(7);
+    expect(r.z).toBe(9);
   });
 
   it('sub', () => {
@@ -776,9 +793,9 @@ describe('vec3Math', () => {
   });
 });
 
-// ═══════════════════════════════════════════════
-// math — quatMath
-// ═══════════════════════════════════════════════
+// ═══════════════════════════════════════════════
+// math — quatMath
+// ═══════════════════════════════════════════════
 describe('quatMath', () => {
   it('identity quaternion', () => {
     const q = quatMath.identity();
@@ -827,9 +844,9 @@ describe('quatMath', () => {
   });
 });
 
-// ═══════════════════════════════════════════════
-// math — aabbMath
-// ═══════════════════════════════════════════════
+// ═══════════════════════════════════════════════
+// math — aabbMath
+// ═══════════════════════════════════════════════
 describe('aabbMath', () => {
   const box = { min: { x: 0, y: 0, z: 0 }, max: { x: 2, y: 2, z: 2 } };
 
@@ -875,9 +892,9 @@ describe('aabbMath', () => {
   });
 });
 
-// ═══════════════════════════════════════════════
-// math — noise
-// ═══════════════════════════════════════════════
+// ═══════════════════════════════════════════════
+// math — noise
+// ═══════════════════════════════════════════════
 describe('noise', () => {
   it('perlin2d returns value in range', () => {
     const v = noise.perlin2d(0.5, 0.5);
@@ -912,9 +929,9 @@ describe('noise', () => {
   });
 });
 
-// ═══════════════════════════════════════════════
-// math — random
-// ═══════════════════════════════════════════════
+// ═══════════════════════════════════════════════
+// math — random
+// ═══════════════════════════════════════════════
 describe('random', () => {
   it('float returns [0,1)', () => {
     for (let i = 0; i < 20; i++) {
@@ -976,10 +993,10 @@ describe('random', () => {
   });
 });
 
-// ═══════════════════════════════════════════════
+// ═══════════════════════════════════════════════
 // string utilities
-// ═══════════════════════════════════════════════
-describe('string — case conversion', () => {
+// ═══════════════════════════════════════════════
+describe('string — case conversion', () => {
   it('capitalize', () => expect(capitalize('hello world')).toBe('Hello world'));
   it('titleCase', () => expect(titleCase('hello world')).toBe('Hello World'));
   it('camelCase', () => expect(camelCase('hello world')).toBe('helloWorld'));
@@ -989,7 +1006,7 @@ describe('string — case conversion', () => {
   it('constantCase', () => expect(constantCase('helloWorld')).toBe('HELLO_WORLD'));
 });
 
-describe('string — padding and truncation', () => {
+describe('string — padding and truncation', () => {
   it('padLeft', () => expect(padLeft('hi', 5)).toBe('   hi'));
   it('padRight', () => expect(padRight('hi', 5)).toBe('hi   '));
   it('center', () => {
@@ -1007,7 +1024,7 @@ describe('string — padding and truncation', () => {
   });
 });
 
-describe('string — checks', () => {
+describe('string — checks', () => {
   it('isBlank / isNotBlank', () => {
     expect(isBlank('')).toBe(true);
     expect(isBlank('  ')).toBe(true);
@@ -1049,7 +1066,7 @@ describe('string — checks', () => {
   });
 });
 
-describe('string — manipulation', () => {
+describe('string — manipulation', () => {
   it('repeat', () => expect(repeat('ab', 3)).toBe('ababab'));
   it('reverse', () => expect(reverse('hello')).toBe('olleh'));
   it('count occurrences', () => expect(count('hello world hello', 'hello')).toBe(2));
@@ -1061,7 +1078,7 @@ describe('string — manipulation', () => {
   it('unwrap', () => expect(unwrap('"hello"', '"')).toBe('hello'));
 });
 
-describe('string — splitting', () => {
+describe('string — splitting', () => {
   it('lines splits by newline', () => {
     const l = lines('a\nb\nc');
     expect(l).toEqual(['a', 'b', 'c']);
@@ -1075,7 +1092,7 @@ describe('string — splitting', () => {
   });
 });
 
-describe('string — formatting', () => {
+describe('string — formatting', () => {
   it('format substitutes named placeholders', () => {
     const result = format('Hello {name}, you are {age}!', { name: 'World', age: 42 });
     expect(result).toContain('World');
@@ -1093,7 +1110,7 @@ describe('string — formatting', () => {
   });
 });
 
-describe('string — escaping', () => {
+describe('string — escaping', () => {
   it('escapeHtml / unescapeHtml', () => {
     const escaped = escapeHtml('<b>hello</b>');
     expect(escaped).toContain('&lt;');
@@ -1111,7 +1128,7 @@ describe('string — escaping', () => {
   });
 });
 
-describe('string — similarity', () => {
+describe('string — similarity', () => {
   it('levenshtein', () => {
     expect(levenshtein('kitten', 'sitting')).toBeGreaterThan(0);
     expect(levenshtein('abc', 'abc')).toBe(0);
@@ -1128,7 +1145,7 @@ describe('string — similarity', () => {
   });
 });
 
-describe('string — indentation', () => {
+describe('string — indentation', () => {
   it('indent adds prefix', () => {
     const s = indent('a\nb', 2);
     expect(s).toContain('  a');
@@ -1149,7 +1166,7 @@ describe('string — indentation', () => {
   });
 });
 
-describe('string — generation', () => {
+describe('string — generation', () => {
   it('randomString generates string of given length', () => {
     const s = randomString(10);
     expect(s.length).toBe(10);
@@ -1162,9 +1179,9 @@ describe('string — generation', () => {
   });
 });
 
-// ═══════════════════════════════════════════════
+// ═══════════════════════════════════════════════
 // time utilities
-// ═══════════════════════════════════════════════
+// ═══════════════════════════════════════════════
 describe('now', () => {
   it('returns number', () => {
     expect(typeof now()).toBe('number');