tjs-lang 0.6.26 → 0.6.27

package/dist/src/lang/runtime.d.ts

@@ -0,0 +1,488 @@
+/**
+ * TJS Runtime
+ *
+ * Monadic type checking at runtime:
+ * - Functions validate inputs against __tjs metadata
+ * - If any input is an error, pass it through (no work)
+ * - Type mismatches return error objects
+ * - Errors propagate through call chains
+ *
+ * This runtime is attached to globalThis.__tjs and shared across modules.
+ */
+import { validate } from 'tosijs-schema';
+import { Type, isRuntimeType, Union, Generic, Enum, FunctionPredicate, Nullable, Optional, TArray, TString, TNumber, TBoolean, TInteger, TPositiveInt, TNonEmptyString, TEmail, TUrl, TUuid, Timestamp, LegalDate, TPair, TRecord, isValidUrl, isValidTimestamp, isValidLegalDate } from '../types/Type';
+export { Type, isRuntimeType, Union, Generic, Enum, FunctionPredicate, Nullable, Optional, TArray, TString, TNumber, TBoolean, TInteger, TPositiveInt, TNonEmptyString, TEmail, TUrl, TUuid, Timestamp, LegalDate, TPair, TRecord, isValidUrl, isValidTimestamp, isValidLegalDate, };
+export declare const TJS_VERSION: string;
+/**
+ * Well-known symbol for custom equality.
+ *
+ * Any object can implement `[tjsEquals](other)` to control how `==` / `Is()`
+ * compares it. Useful for Proxies that should delegate equality to their target.
+ *
+ * Priority: tjsEquals symbol → .Equals method → structural comparison
+ */
+export declare const tjsEquals: unique symbol;
+/**
+ * Compare two version strings
+ * Returns: -1 if a < b, 0 if equal, 1 if a > b
+ */
+export declare function compareVersions(a: string, b: string): -1 | 0 | 1;
+/**
+ * Check if two versions are compatible (same major version)
+ */
+export declare function versionsCompatible(a: string, b: string): boolean;
+/**
+ * MonadicError - Internal error type for monadic error propagation
+ *
+ * This extends Error so:
+ * 1. It's a real Error with proper stack traces
+ * 2. User code can't accidentally process it as data (unlike { $error: true })
+ * 3. It flows through function calls via instanceof checks
+ *
+ * NOT exported to user code - they just see Error instances.
+ */
+export declare class MonadicError extends Error {
+    /** Path where the error occurred, e.g., "src/file.ts:42:greet.name" */
+    readonly path: string;
+    /** Expected type */
+    readonly expected?: string;
+    /** Actual type received */
+    readonly actual?: string;
+    /** TJS call stack (only in debug mode) - shows source locations */
+    readonly callStack?: string[];
+    constructor(message: string, path: string, expected?: string, actual?: string, callStack?: string[]);
+}
+/**
+ * Create a type error for inline validation
+ *
+ * Called ONLY when a type check fails - no overhead on happy path.
+ * Returns a MonadicError that propagates through the call chain.
+ * In debug mode, captures the TJS call stack with source locations.
+ *
+ * @param path - Location of the error, e.g., "src/file.ts:42:greet.name"
+ * @param expected - Expected type, e.g., "string"
+ * @param value - The actual value that failed the check
+ */
+export declare function typeError(path: string, expected: string, value: unknown): MonadicError;
+/**
+ * Check if a value is a MonadicError (for internal use)
+ */
+export declare function isMonadicError(value: unknown): value is MonadicError;
+/**
+ * Error marker - identifies TJS error objects
+ * @deprecated Use MonadicError instead. This interface is kept for backward compatibility.
+ */
+export interface TJSError {
+    $error: true;
+    message: string;
+    /** Failure location - e.g., "greet.name" */
+    path?: string;
+    /** Call stack in debug mode - e.g., ["main", "processUser", "greet.name"] */
+    stack?: string[];
+    expected?: string;
+    actual?: string;
+    cause?: Error | TJSError;
+    /** Source location for error reporting */
+    loc?: {
+        start: number;
+        end: number;
+    };
+    /** Multiple errors (when composing parameter errors) */
+    errors?: TJSError[];
+}
+/**
+ * Safety levels for runtime validation
+ * - 'none': No validation unless explicitly forced with (?) or -?
+ * - 'inputs': Validate inputs only (default) - outputs only with explicit -> or -?
+ * - 'all': Validate both inputs and outputs unless explicitly skipped with (!) or -!
+ */
+export type SafetyLevel = 'none' | 'inputs' | 'all';
+/**
+ * Runtime configuration
+ */
+export interface TJSConfig {
+    /** Enable debug mode - captures call stacks in errors */
+    debug?: boolean;
+    /** Safety level for validation (default: 'inputs') */
+    safety?: SafetyLevel;
+    /** Require explicit return types (error if -> not specified) */
+    requireReturnTypes?: boolean;
+    /** Maximum call stack size to prevent memory issues (default: 100) */
+    maxStackSize?: number;
+}
+/**
+ * Enter unsafe mode - disables validation for all wrapped function calls
+ * Can be nested (uses depth counter)
+ */
+export declare function enterUnsafe(): void;
+/**
+ * Exit unsafe mode - re-enables validation when depth returns to 0
+ */
+export declare function exitUnsafe(): void;
+/**
+ * Check if currently in unsafe mode
+ */
+export declare function isUnsafeMode(): boolean;
+/**
+ * Configure TJS runtime
+ */
+export declare function configure(options: TJSConfig): void;
+/**
+ * Get current configuration
+ */
+export declare function getConfig(): TJSConfig;
+/**
+ * Push a function onto the call stack (debug mode only)
+ * Respects maxStackSize to prevent unbounded memory growth
+ */
+export declare function pushStack(name: string): void;
+/**
+ * Pop a function from the call stack (debug mode only)
+ */
+export declare function popStack(): void;
+/**
+ * Get current call stack snapshot
+ */
+export declare function getStack(): string[];
+/**
+ * Reset runtime state to defaults
+ *
+ * Resets: config, callStack, unsafeDepth
+ * Use this in test teardown to prevent state leaking between tests.
+ */
+export declare function resetRuntime(): void;
+/**
+ * Structural equality - the == that works
+ *
+ * Rules:
+ * 1. If left has [tjsEquals], call left[tjsEquals](right)
+ * 2. If right has [tjsEquals], call right[tjsEquals](left)
+ * 3. If left has .Equals, call left.Equals(right)
+ * 4. If right has .Equals, call right.Equals(left)
+ * 5. Arrays/objects: recursive structural comparison
+ * 6. Primitives: strict equality (no coercion)
+ *
+ * Usage: `a Is b` transforms to `Is(a, b)`
+ */
+export declare function Is(a: unknown, b: unknown): boolean;
+/**
+ * Structural inequality - the != that works
+ *
+ * Usage: `a IsNot b` transforms to `IsNot(a, b)`
+ */
+export declare function IsNot(a: unknown, b: unknown): boolean;
+/**
+ * Honest equality — what == should have been.
+ *
+ * Like === but fixes the two remaining footguns:
+ * 1. Unwraps boxed primitives: new String('foo') Eq 'foo' → true
+ * 2. Nullish equality: null Eq undefined → true
+ *
+ * Does NOT do deep structural comparison on objects/arrays (that's O(n)).
+ * Use Is/IsNot for explicit structural comparison when you need it.
+ *
+ * Usage: `a == b` with TjsEquals transforms to `Eq(a, b)`
+ */
+/**
+ * Honest typeof — fixes `typeof null === 'object'`
+ *
+ * Returns `'null'` for null instead of `'object'`.
+ * All other values return the same as standard typeof.
+ *
+ * Usage: `typeof x` with TjsEquals transforms to `TypeOf(x)`
+ */
+export declare function TypeOf(value: unknown): string;
+export declare function Eq(a: unknown, b: unknown): boolean;
+/**
+ * Honest inequality — what != should have been.
+ *
+ * Usage: `a != b` with TjsEquals transforms to `NotEq(a, b)`
+ */
+export declare function NotEq(a: unknown, b: unknown): boolean;
+/**
+ * Check if a value is a TJS error
+ */
+export declare function isError(value: unknown): value is TJSError;
+/**
+ * Create a TJS error
+ * In debug mode, captures the current call stack
+ */
+export declare function error(message: string, details?: Partial<Omit<TJSError, '$error' | 'message'>>): TJSError;
+/**
+ * Compose multiple errors into a single error
+ * Used when multiple parameters have errors
+ */
+export declare function composeErrors(errors: TJSError[], funcName?: string): TJSError;
+/**
+ * Get the type of a value
+ *
+ * Enhanced typeof that handles:
+ * - null (returns 'null' not 'object')
+ * - undefined (returns 'undefined')
+ * - arrays (returns 'array' not 'object')
+ * - native/platform types (returns constructor name for objects)
+ *
+ * For objects, returns the constructor name which enables pragmatic
+ * native type checking (e.g., 'HTMLElement', 'Buffer', 'Event')
+ */
+export declare function typeOf(value: unknown): string;
+/**
+ * Check if a value is an instance of a native/platform type by constructor name
+ *
+ * This enables pragmatic native type checking without shipping type definitions:
+ * - isNativeType(el, 'HTMLElement') - DOM element check
+ * - isNativeType(buf, 'Buffer') - Node.js Buffer check
+ * - isNativeType(evt, 'Event') - DOM Event check
+ * - isNativeType(map, 'Map') - Map instance check
+ *
+ * @param value - The value to check
+ * @param typeName - The constructor name to match (e.g., 'HTMLElement', 'Buffer')
+ * @returns true if value's constructor.name matches or is in prototype chain
+ */
+export declare function isNativeType(value: unknown, typeName: string): boolean;
+/**
+ * Check if a value matches an expected type
+ *
+ * @param value - The value to check
+ * @param expected - Either a string type name ('string', 'number', etc.)
+ *                   or a RuntimeType instance with .check() method
+ * @param path - Optional path for error messages
+ */
+export declare function checkType(value: unknown, expected: string | {
+    check: (v: unknown) => boolean;
+    description: string;
+}, path?: string): TJSError | null;
+/** Type specifier - either a string name or a RuntimeType */
+type TypeSpec = string | {
+    check: (v: unknown) => boolean;
+    description: string;
+};
+/** Parameter metadata with optional location */
+interface ParamMeta {
+    type: TypeSpec;
+    required: boolean;
+    default?: unknown;
+    loc?: {
+        start: number;
+        end: number;
+    };
+}
+/**
+ * Validate function arguments against __tjs metadata
+ * Returns first error found, or null if all valid
+ */
+export declare function validateArgs(args: Record<string, unknown>, meta: {
+    params: Record<string, ParamMeta>;
+}, funcName?: string): TJSError | null;
+/**
+ * Function metadata with safety flags
+ */
+export interface FunctionMeta {
+    params: Record<string, any>;
+    returns?: {
+        type: any;
+        safe?: boolean;
+        defaults?: Record<string, unknown>;
+    };
+    /** Function marked with (!) - never validate inputs */
+    unsafe?: boolean;
+    /** Function marked with (?) - always validate inputs */
+    safe?: boolean;
+    /** Return type marked with -! - never validate output */
+    unsafeReturn?: boolean;
+    /** Return type marked with -? - always validate output */
+    safeReturn?: boolean;
+    /** Explicit function name for stack tracking (used when fn.name is empty) */
+    name?: string;
+    /** Polymorphic dispatcher — skip wrapping, dispatch handles validation */
+    polymorphic?: boolean;
+}
+/**
+ * Wrap a function with monadic type checking
+ *
+ * @param fn - The original function
+ * @param meta - The __tjs metadata
+ * @returns Wrapped function that validates inputs and propagates errors
+ */
+export declare function wrap<T extends (...args: any[]) => any>(fn: T, meta: FunctionMeta): T;
+/**
+ * Wrap a class to make it callable without `new`
+ *
+ * In TJS, classes can be instantiated without the `new` keyword:
+ *   const obj = MyClass(args)  // equivalent to new MyClass(args)
+ *
+ * This eliminates a common source of errors where developers forget `new`.
+ * Using explicit `new` still works but should be flagged by the linter.
+ */
+export declare function wrapClass<T extends new (...args: any[]) => any>(cls: T): T & ((...args: ConstructorParameters<T>) => InstanceType<T>);
+/**
+ * Create an isolated TJS runtime instance
+ *
+ * Each call returns a fresh runtime with its own:
+ * - config (debug, safety, etc.)
+ * - callStack
+ * - unsafeDepth
+ *
+ * The new instance inherits the current global config at creation time,
+ * but subsequent changes are isolated.
+ *
+ * Use this to prevent state leaking between transpiled modules.
+ */
+export declare function createRuntime(): {
+    version: string;
+    MonadicError: typeof MonadicError;
+    typeError: (path: string, expected: string, value: unknown) => MonadicError;
+    isMonadicError: typeof isMonadicError;
+    isError: typeof isError;
+    error: (message: string, details?: Partial<Omit<TJSError, "$error" | "message">>) => TJSError;
+    composeErrors: typeof composeErrors;
+    typeOf: typeof typeOf;
+    isNativeType: typeof isNativeType;
+    checkType: typeof checkType;
+    validateArgs: typeof validateArgs;
+    wrap: typeof wrap;
+    wrapClass: typeof wrapClass;
+    compareVersions: typeof compareVersions;
+    versionsCompatible: typeof versionsCompatible;
+    configure: (options: TJSConfig) => void;
+    getConfig: () => TJSConfig;
+    pushStack: (name: string) => void;
+    popStack: () => void;
+    getStack: () => string[];
+    resetRuntime: () => void;
+    enterUnsafe: () => void;
+    exitUnsafe: () => void;
+    isUnsafeMode: () => boolean;
+    validate: typeof validate;
+    infer: (value: any) => import("tosijs-schema").Base<any>;
+    Type: typeof Type;
+    isRuntimeType: typeof isRuntimeType;
+    Union: typeof Union;
+    Generic: typeof Generic;
+    Enum: typeof Enum;
+    FunctionPredicate: typeof FunctionPredicate;
+    Nullable: typeof Nullable;
+    Optional: typeof Optional;
+    TArray: typeof TArray;
+    TString: import("..").RuntimeType<string>;
+    TNumber: import("..").RuntimeType<number>;
+    TBoolean: import("..").RuntimeType<boolean>;
+    TInteger: import("..").RuntimeType<number>;
+    TPositiveInt: import("..").RuntimeType<number>;
+    TNonEmptyString: import("..").RuntimeType<string>;
+    TEmail: import("..").RuntimeType<string>;
+    TUrl: import("..").RuntimeType<string>;
+    TUuid: import("..").RuntimeType<string>;
+    TPair: import("..").GenericType<string[]>;
+    TRecord: import("..").GenericType<string[]>;
+    Is: typeof Is;
+    IsNot: typeof IsNot;
+    Eq: typeof Eq;
+    NotEq: typeof NotEq;
+    TypeOf: typeof TypeOf;
+    tjsEquals: symbol;
+    registerExtension: (typeName: string, methodName: string, fn: (...args: any[]) => any) => void;
+    resolveExtension: (value: unknown, methodName: string) => ((...args: any[]) => any) | undefined;
+};
+/** Type for runtime instances */
+export type TJSRuntime = ReturnType<typeof createRuntime>;
+/**
+ * TJS Runtime object - attached to globalThis.__tjs
+ *
+ * NOTE: This is a shared global instance. For isolated execution,
+ * use createRuntime() instead.
+ */
+export declare const runtime: {
+    version: string;
+    MonadicError: typeof MonadicError;
+    typeError: typeof typeError;
+    isMonadicError: typeof isMonadicError;
+    isError: typeof isError;
+    error: typeof error;
+    composeErrors: typeof composeErrors;
+    typeOf: typeof typeOf;
+    isNativeType: typeof isNativeType;
+    checkType: typeof checkType;
+    validateArgs: typeof validateArgs;
+    wrap: typeof wrap;
+    wrapClass: typeof wrapClass;
+    compareVersions: typeof compareVersions;
+    versionsCompatible: typeof versionsCompatible;
+    configure: typeof configure;
+    getConfig: typeof getConfig;
+    pushStack: typeof pushStack;
+    popStack: typeof popStack;
+    getStack: typeof getStack;
+    resetRuntime: typeof resetRuntime;
+    enterUnsafe: typeof enterUnsafe;
+    exitUnsafe: typeof exitUnsafe;
+    isUnsafeMode: typeof isUnsafeMode;
+    createRuntime: typeof createRuntime;
+    validate: typeof validate;
+    infer: (value: any) => import("tosijs-schema").Base<any>;
+    Type: typeof Type;
+    isRuntimeType: typeof isRuntimeType;
+    Union: typeof Union;
+    Generic: typeof Generic;
+    Enum: typeof Enum;
+    FunctionPredicate: typeof FunctionPredicate;
+    Nullable: typeof Nullable;
+    Optional: typeof Optional;
+    TArray: typeof TArray;
+    TString: import("..").RuntimeType<string>;
+    TNumber: import("..").RuntimeType<number>;
+    TBoolean: import("..").RuntimeType<boolean>;
+    TInteger: import("..").RuntimeType<number>;
+    TPositiveInt: import("..").RuntimeType<number>;
+    TNonEmptyString: import("..").RuntimeType<string>;
+    TEmail: import("..").RuntimeType<string>;
+    TUrl: import("..").RuntimeType<string>;
+    TUuid: import("..").RuntimeType<string>;
+    Timestamp: import("..").RuntimeType<string>;
+    LegalDate: import("..").RuntimeType<string>;
+    TPair: import("..").GenericType<string[]>;
+    TRecord: import("..").GenericType<string[]>;
+    Is: typeof Is;
+    IsNot: typeof IsNot;
+    Eq: typeof Eq;
+    NotEq: typeof NotEq;
+    TypeOf: typeof TypeOf;
+};
+/**
+ * Install runtime globally (idempotent, version-checked)
+ *
+ * Version handling:
+ * - Same version: reuse existing (no warning)
+ * - Compatible (same major): reuse existing, log info
+ * - Incompatible (different major): warn, use newer version
+ */
+export declare function installRuntime(): typeof runtime;
+/**
+ * Generate runtime wrapper code for emitted JS
+ * Skips wrapping for unsafe functions (marked with !)
+ */
+export declare function emitRuntimeWrapper(funcName: string): string;
+/**
+ * Generate class wrapper code for emitted JS
+ * Makes classes callable without `new` keyword
+ * Emits standalone JS - no runtime dependency
+ */
+export declare function emitClassWrapper(className: string): string;
+/**
+ * Questions/Notes:
+ *
+ * Q1: Should wrap() be automatic or opt-in?
+ *     Current: Must be explicitly wrapped
+ *     Could: Auto-wrap all functions with __tjs metadata
+ *
+ * Q2: Performance overhead of validation?
+ *     Need benchmarks comparing wrapped vs unwrapped
+ *     Could have 'production' mode that skips validation
+ *
+ * Q3: Async function handling?
+ *     wrap() should detect async and handle Promise returns
+ *
+ * Q4: Deep object validation?
+ *     Currently only checks top-level type
+ *     Could recursively validate object shapes
+ */

package/dist/src/lang/schema.d.ts

@@ -0,0 +1,35 @@
+/**
+ * TJS Schema - Runtime type system for Typed JavaScript
+ *
+ * Builds on tosijs-schema to provide:
+ * - Schema(x) callable for inference by example
+ * - Schema.type(x) for "fixed typeof" (null returns 'null', not 'object')
+ * - All tosijs-schema methods (string, number, object, array, etc.)
+ *
+ * Usage:
+ *   Schema('hello')        // Schema matching string
+ *   Schema(42)             // Schema matching number (integer)
+ *   Schema(null)           // Schema matching null
+ *   Schema(undefined)      // Schema matching undefined
+ *   Schema([1, 2, 3])      // Schema matching array of integers
+ *   Schema({name: 'Anne'}) // Schema matching object with name: string
+ *
+ *   Schema.type(null)      // 'null' (not 'object' like typeof)
+ *   Schema.type(undefined) // 'undefined'
+ *   Schema.type([])        // 'array' (not 'object' like typeof)
+ *
+ *   Schema.null.validate(x)      // true if x is null
+ *   Schema.undefined.validate(x) // true if x is undefined
+ */
+import { s, type Base } from 'tosijs-schema';
+type SchemaCallable = {
+    (value: unknown): Base<unknown>;
+    type: (value: unknown) => string;
+    infer: (value: unknown) => Base<unknown>;
+} & typeof s;
+/**
+ * Schema - callable for inference, with all tosijs-schema methods attached
+ * Uses a Proxy to delegate property access to tosijs-schema's s object
+ */
+export declare const Schema: SchemaCallable;
+export type { Base, Infer } from 'tosijs-schema';

package/dist/src/lang/tests.d.ts

@@ -0,0 +1,94 @@
+/**
+ * TJS Inline Tests
+ *
+ * Extracts test blocks from TJS source and generates test runners.
+ *
+ * Syntax (TJS):
+ *   test 'description' {
+ *     assert(condition)
+ *     expect(a).toBe(b)
+ *   }
+ *
+ *   test {
+ *     // Anonymous test
+ *   }
+ *
+ *   mock {
+ *     // Setup code that runs before each test
+ *   }
+ *
+ * Syntax (TypeScript - embedded in comments):
+ *   /*test 'description' {
+ *     expect(add(2, 3)).toBe(5)
+ *   }* /
+ *
+ *   This syntax survives TypeScript compilation, enabling literate
+ *   programming for TypeScript: tests live alongside the code they
+ *   verify, extracted and executed at runtime by TJS.
+ *
+ *   For TS developers who don't care about TJS: you still get inline
+ *   tests that live with your code, literate development, and faster
+ *   debug loops. Set `safety none` and keep living in your world.
+ *
+ * Output:
+ *   - code: Clean source with tests stripped
+ *   - tests: Array of extracted test definitions
+ *   - testRunner: Generated code to execute tests
+ */
+export interface ExtractedTest {
+    description: string;
+    body: string;
+    line?: number;
+}
+export interface ExtractedMock {
+    body: string;
+    line?: number;
+}
+export interface TestExtractionResult {
+    /** Source code with tests and mocks removed */
+    code: string;
+    /** Extracted test definitions */
+    tests: ExtractedTest[];
+    /** Extracted mock/setup blocks */
+    mocks: ExtractedMock[];
+    /** Generated test runner code */
+    testRunner: string;
+}
+/**
+ * Extract inline tests from TJS source
+ *
+ * Note: Signature tests (from -> return types) are handled separately by the
+ * transpiler in js.ts. This function only extracts explicit test blocks.
+ */
+export declare function extractTests(source: string): TestExtractionResult;
+/**
+ * Test utilities - assert and expect
+ * Include this in the runtime or inject it
+ */
+export declare const assertFunction = "\nfunction assert(condition, message) {\n  if (!condition) {\n    throw new Error(message || 'Assertion failed')\n  }\n}\n";
+/**
+ * Expect API for richer test assertions
+ * Uses deep equality, handles null/undefined correctly
+ */
+export declare const expectFunction = "\nfunction expect(actual) {\n  const deepEqual = (a, b) => {\n    if (a === b) return true\n    if (a === null || b === null) return a === b\n    if (a === undefined || b === undefined) return a === undefined && b === undefined\n    if (typeof a !== typeof b) return false\n    if (typeof a !== 'object') return a === b\n    if (Array.isArray(a) !== Array.isArray(b)) return false\n    if (Array.isArray(a)) {\n      if (a.length !== b.length) return false\n      return a.every((v, i) => deepEqual(v, b[i]))\n    }\n    const keysA = Object.keys(a)\n    const keysB = Object.keys(b)\n    if (keysA.length !== keysB.length) return false\n    return keysA.every(k => deepEqual(a[k], b[k]))\n  }\n\n  const format = (v) => {\n    if (v === null) return 'null'\n    if (v === undefined) return 'undefined'\n    if (typeof v === 'string') return JSON.stringify(v)\n    if (typeof v === 'object') return JSON.stringify(v)\n    return String(v)\n  }\n\n  return {\n    toBe(expected) {\n      if (!deepEqual(actual, expected)) {\n        throw new Error(`Expected ${format(expected)} but got ${format(actual)}`)\n      }\n    },\n    toEqual(expected) {\n      if (!deepEqual(actual, expected)) {\n        throw new Error(`Expected ${format(expected)} but got ${format(actual)}`)\n      }\n    },\n    toContain(item) {\n      if (!Array.isArray(actual) || !actual.some(v => deepEqual(v, item))) {\n        throw new Error(`Expected ${format(actual)} to contain ${format(item)}`)\n      }\n    },\n    toThrow(message) {\n      let threw = false\n      let thrownMessage = ''\n      try {\n        if (typeof actual === 'function') actual()\n      } catch (e) {\n        threw = true\n        thrownMessage = e.message || String(e)\n      }\n      if (!threw) {\n        throw new Error('Expected function to throw but it did not')\n      }\n      if (message && !thrownMessage.includes(message)) {\n        throw new Error(`Expected error containing \"${message}\" but got \"${thrownMessage}\"`)\n      }\n    },\n    toBeTruthy() {\n      if (!actual) {\n        throw new Error(`Expected ${format(actual)} to be truthy`)\n      }\n    },\n    toBeFalsy() {\n      if (actual) {\n        throw new Error(`Expected ${format(actual)} to be falsy`)\n      }\n    },\n    toBeNull() {\n      if (actual !== null) {\n        throw new Error(`Expected null but got ${format(actual)}`)\n      }\n    },\n    toBeUndefined() {\n      if (actual !== undefined) {\n        throw new Error(`Expected undefined but got ${format(actual)}`)\n      }\n    },\n    toBeGreaterThan(n) {\n      if (!(actual > n)) {\n        throw new Error(`Expected ${format(actual)} to be greater than ${n}`)\n      }\n    },\n    toBeLessThan(n) {\n      if (!(actual < n)) {\n        throw new Error(`Expected ${format(actual)} to be less than ${n}`)\n      }\n    }\n  }\n}\n";
+/**
+ * Combined test utilities (assert + expect)
+ */
+export declare const testUtils: string;
+/**
+ * Questions/Notes:
+ *
+ * Q1: Should mocks be scoped per-test or shared?
+ *     Current: Each test runs all mocks before executing
+ *
+ * Q2: Should we support test.only / test.skip?
+ *     Easy to add with syntax: test.only('...') { } or test.skip('...') { }
+ *
+ * Q3: Integration with playground?
+ *     Playground could run extractTests() and show test results in a panel
+ *
+ * Q4: DOM tests - test.browser('desc') { }?
+ *     SHELVED: Plan is to run tests in actual browser (playground)
+ *     Happy-DOM is ~1MB packed, too heavy to bundle
+ *     If needed later: lazy-load happy-dom only for Node/Bun DOM tests
+ */

package/dist/src/lang/transpiler.d.ts

@@ -0,0 +1,25 @@
+/**
+ * TJS Transpiler - Core transpilation without TS compiler
+ *
+ * This is the lightweight entry point for TJS/AJS transpilation.
+ * Does NOT include fromTS (which requires the full TypeScript compiler).
+ *
+ * For TS -> TJS conversion, use the full bundle or import fromTS separately.
+ *
+ * NOTE: We import directly from source files, NOT from ./index, because
+ * ./index imports from-ts.ts which pulls in the TypeScript compiler (~4MB).
+ */
+export { transpile, ajs, tjs, createAgent, getToolDefinitions } from './core';
+export { parse, preprocess, extractTDoc } from './parser';
+export { transformFunction } from './emitters/ast';
+export { transpileToJS } from './emitters/js';
+export type { TJSTranspileOptions, TJSTranspileResult, TJSTypeInfo, } from './emitters/js';
+export * from './inference';
+export { Schema } from './schema';
+export { lint } from './linter';
+export type { LintResult, LintDiagnostic, LintOptions } from './linter';
+export { extractTests, assertFunction, expectFunction, testUtils, } from './tests';
+export type { ExtractedTest, ExtractedMock, TestExtractionResult, } from './tests';
+export { runtime, installRuntime, isError, error, typeOf, checkType, validateArgs, wrap, emitRuntimeWrapper, TJS_VERSION, } from './runtime';
+export type { TJSError } from './runtime';
+export type { TypeDescriptor, ParameterDescriptor, FunctionSignature, TranspileOptions, TranspileResult, TranspileWarning, } from './types';