tjs-lang 0.6.44 → 0.7.3

package/dist/scripts/compat-effect.d.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env bun
+/**
+ * Effect Compatibility Test
+ *
+ * Clones Effect (the "final boss" of TypeScript complexity), transpiles
+ * its source using fromTS, and attempts to run its Vitest suite.
+ *
+ * Effect uses higher-kinded types, massive intersections, and the most
+ * advanced TypeScript patterns in the wild.
+ *
+ * Usage:
+ *   bun scripts/compat-effect.ts
+ *   bun scripts/compat-effect.ts --clean
+ *   bun scripts/compat-effect.ts --test     # Also run tests (requires pnpm)
+ */
+export {};

package/dist/scripts/compat-kysely.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env bun
+/**
+ * Kysely Compatibility Test
+ *
+ * Clones Kysely, transpiles its TS source using TJS's fromTS.
+ * Kysely's tests require database connections so we only verify
+ * that all source files transpile without error.
+ *
+ * Usage:
+ *   bun scripts/compat-kysely.ts
+ *   bun scripts/compat-kysely.ts --clean
+ */
+export {};

package/dist/scripts/compat-radash.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env bun
+/**
+ * Radash Compatibility Test
+ *
+ * Clones Radash, transpiles its TypeScript source using TJS's fromTS,
+ * and runs Radash's own test suite to verify compatibility.
+ *
+ * Usage:
+ *   bun scripts/compat-radash.ts              # Direct mode (fromTS → JS)
+ *   bun scripts/compat-radash.ts --full       # Full pipeline (fromTS → TJS → JS)
+ *   bun scripts/compat-radash.ts --clean      # Remove clone and start fresh
+ */
+export {};

package/dist/scripts/compat-superstruct.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env bun
+/**
+ * Superstruct Compatibility Test
+ *
+ * Clones Superstruct, transpiles its TS source using TJS's fromTS,
+ * and runs Superstruct's own test suite to verify compatibility.
+ *
+ * Usage:
+ *   bun scripts/compat-superstruct.ts           # Direct mode (fromTS → JS)
+ *   bun scripts/compat-superstruct.ts --full     # Full pipeline (fromTS → TJS → JS)
+ *   bun scripts/compat-superstruct.ts --clean    # Remove clone and start fresh
+ */
+export {};

package/dist/scripts/compat-ts-pattern.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env bun
+/**
+ * ts-pattern Compatibility Test
+ *
+ * Clones ts-pattern, transpiles its TS source using TJS's fromTS,
+ * and runs ts-pattern's own test suite to verify compatibility.
+ *
+ * Usage:
+ *   bun scripts/compat-ts-pattern.ts            # Direct mode (fromTS → JS)
+ *   bun scripts/compat-ts-pattern.ts --full      # Full pipeline (fromTS → TJS → JS)
+ *   bun scripts/compat-ts-pattern.ts --clean     # Remove clone and start fresh
+ */
+export {};

package/dist/scripts/compat-zod.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env bun
+/**
+ * Zod Compatibility Test
+ *
+ * Clones Zod (monorepo), transpiles its TS source using TJS's fromTS,
+ * and runs Zod's own test suite to verify compatibility.
+ *
+ * Usage:
+ *   bun scripts/compat-zod.ts              # Direct mode (fromTS → JS)
+ *   bun scripts/compat-zod.ts --clean      # Remove clone and start fresh
+ */
+export {};

package/dist/src/lang/emitters/from-ts.d.ts

@@ -15,7 +15,7 @@
  * }
  *
  * // Output TJS:
- * function greet(name: '', age = 0) -> '' {
+ * function greet(name: '', age = 0): '' {
  *   return `Hello, ${name}!`
  * }
  *

package/dist/src/lang/emitters/js-tests.d.ts

@@ -49,6 +49,10 @@ interface SignatureTestInfo {
     defaults?: Record<string, unknown>;
     line: number;
     isAsync?: boolean;
+    /** For class method tests: the class name */
+    className?: string;
+    /** For class method tests: args to pass to the first constructor */
+    constructorArgs?: unknown[];
 }
 /**
  * Extract signature test info from source without executing

package/dist/src/lang/emitters/js.d.ts

@@ -5,7 +5,7 @@
  * Unlike the AST emitter (for AgentJS), this outputs executable JS code.
  *
  * Input:
- *   function greet(name: 'world') -> '' {
+ *   function greet(name: 'world'): '' {
  *     return `Hello, ${name}!`
  *   }
  *
@@ -135,7 +135,7 @@ interface SafetyOptions {
     unsafe?: boolean;
     /** Function marked with (?) - always validate inputs */
     safe?: boolean;
-    /** Return type safety: 'safe' (-?) or 'unsafe' (-!) */
+    /** Return type safety: 'safe' (:?) or 'unsafe' (:!) */
     returnSafety?: 'safe' | 'unsafe';
 }
 /**

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

@@ -30,6 +30,7 @@ export { generateDTS, typeDescriptorToTS, type GenerateDTSOptions, } from './emi
 export { fromTS, type FromTSOptions, type FromTSResult, } from './emitters/from-ts';
 export * from './inference';
 export { Schema } from './schema';
+export { typeDescriptorToJSONSchema, exampleToJSONSchema, functionMetaToJSONSchema, type JSONSchemaObject, } from './json-schema';
 export { MetadataCache, getGlobalCache, setGlobalCache } from './metadata-cache';
 export { lint, type LintResult, type LintDiagnostic, type LintOptions, } from './linter';
 export { generateDocs, generateDocsMarkdown, type DocResult, type DocItem, type FunctionTypeInfo, type ParamTypeInfo, } from './docs';

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

@@ -0,0 +1,40 @@
+/**
+ * JSON Schema generation from TJS TypeDescriptors and example values
+ *
+ * Converts TJS type information into standard JSON Schema (draft 2020-12).
+ */
+import type { TypeDescriptor } from './types';
+export interface JSONSchemaObject {
+    type?: string | string[];
+    properties?: Record<string, JSONSchemaObject>;
+    items?: JSONSchemaObject | JSONSchemaObject[];
+    required?: string[];
+    additionalProperties?: boolean;
+    anyOf?: JSONSchemaObject[];
+    minimum?: number;
+    examples?: unknown[];
+    description?: string;
+    [key: string]: unknown;
+}
+/**
+ * Convert a TypeDescriptor to JSON Schema
+ */
+export declare function typeDescriptorToJSONSchema(td: TypeDescriptor): JSONSchemaObject;
+/**
+ * Infer a JSON Schema from an example value (without going through TypeDescriptor)
+ */
+export declare function exampleToJSONSchema(value: unknown): JSONSchemaObject;
+/**
+ * Generate JSON Schema for function parameters (as an object schema)
+ * and return type from __tjs metadata
+ */
+export declare function functionMetaToJSONSchema(meta: {
+    params: Record<string, any>;
+    returns?: {
+        type: any;
+        example?: any;
+    };
+}): {
+    input: JSONSchemaObject;
+    output?: JSONSchemaObject;
+};

package/dist/src/lang/parser-transforms.d.ts

@@ -295,3 +295,17 @@ export declare function validateNoDate(source: string): string;
 export declare function transformConstBang(source: string): string;
 export declare function validateNoVar(source: string): string;
 export declare function validateNoEval(source: string): string;
+/**
+ * Transform bang access (!.) to __tjs.bang() calls.
+ *
+ * x!.foo       → __tjs.bang(x,'foo')
+ * x.y!.foo     → __tjs.bang(x.y,'foo')
+ * fn()!.foo    → __tjs.bang(fn(),'foo')
+ * arr[0]!.foo  → __tjs.bang(arr[0],'foo')
+ * x!.foo!.bar  → __tjs.bang(__tjs.bang(x,'foo'),'bar')
+ *
+ * If the source is null/undefined, returns MonadicError.
+ * If the source is a MonadicError, propagates it.
+ * Otherwise, performs a bare property access (throws as usual).
+ */
+export declare function transformBangAccess(source: string): string;

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

@@ -107,8 +107,18 @@ export interface TJSConfig {
     safety?: SafetyLevel;
     /** Require explicit return types (error if -> not specified) */
     requireReturnTypes?: boolean;
-    /** Maximum call stack size to prevent memory issues (default: 100) */
+    /** Track call stacks for error diagnostics (default: false).
+     *  Useful for server-side logging and agent debugging without devtools.
+     *  Uses a fixed ring buffer — no allocation pressure. */
+    callStacks?: boolean;
+    /** Ring buffer size for call stack tracking (default: 64) */
     maxStackSize?: number;
+    /** Track recent type errors in a ring buffer (default: true).
+     *  Zero cost on happy path — only writes when an error occurs.
+     *  Lets you catch monadic errors that were silently ignored. */
+    trackErrors?: boolean;
+    /** Ring buffer size for error tracking (default: 64) */
+    maxErrors?: number;
     /** Log type errors to console.error when they occur (default: false) */
     logTypeErrors?: boolean;
     /** Throw type errors instead of returning them (default: false).
@@ -137,22 +147,37 @@ export declare function configure(options: TJSConfig): void;
  */
 export declare function getConfig(): TJSConfig;
 /**
- * Push a function onto the call stack (debug mode only)
- * Respects maxStackSize to prevent unbounded memory growth
+ * Push a function onto the call stack ring buffer.
+ * Only tracks when callStacks or debug is enabled.
+ * O(1), no allocation.
  */
 export declare function pushStack(name: string): void;
 /**
- * Pop a function from the call stack (debug mode only)
+ * Pop a function from the call stack ring buffer.
+ * O(1), no allocation.
  */
 export declare function popStack(): void;
 /**
- * Get current call stack snapshot
+ * Get current call stack snapshot (most recent entries, newest last)
  */
 export declare function getStack(): string[];
+/**
+ * Get recent type errors (newest last).
+ * Only tracks when trackErrors is enabled (default: true).
+ */
+export declare function errors(): MonadicError[];
+/**
+ * Clear error history. Returns the cleared errors.
+ */
+export declare function clearErrors(): MonadicError[];
+/**
+ * Total error count since last clear (may exceed buffer size).
+ */
+export declare function getErrorCount(): number;
 /**
  * Reset runtime state to defaults
  *
- * Resets: config, callStack, unsafeDepth
+ * Resets: config, callStack, errors, unsafeDepth
  * Use this in test teardown to prevent state leaking between tests.
  */
 export declare function resetRuntime(): void;
@@ -338,6 +363,7 @@ export declare function createRuntime(): {
     MonadicError: typeof MonadicError;
     typeError: (path: string, expected: string, value: unknown) => MonadicError;
     isMonadicError: typeof isMonadicError;
+    bang: (obj: unknown, prop: string) => unknown;
     isError: typeof isError;
     error: (message: string, details?: Partial<Omit<TJSError, "$error" | "message">>) => TJSError;
     composeErrors: typeof composeErrors;
@@ -349,11 +375,15 @@ export declare function createRuntime(): {
     wrapClass: typeof wrapClass;
     compareVersions: typeof compareVersions;
     versionsCompatible: typeof versionsCompatible;
+    createRuntime: typeof createRuntime;
     configure: (options: TJSConfig) => void;
     getConfig: () => TJSConfig;
     pushStack: (name: string) => void;
     popStack: () => void;
     getStack: () => string[];
+    errors: () => MonadicError[];
+    clearErrors: () => MonadicError[];
+    getErrorCount: () => number;
     resetRuntime: () => void;
     enterUnsafe: () => void;
     exitUnsafe: () => void;
@@ -418,6 +448,9 @@ export declare const runtime: {
     pushStack: typeof pushStack;
     popStack: typeof popStack;
     getStack: typeof getStack;
+    errors: typeof errors;
+    clearErrors: typeof clearErrors;
+    getErrorCount: typeof getErrorCount;
     resetRuntime: typeof resetRuntime;
     enterUnsafe: typeof enterUnsafe;
     exitUnsafe: typeof exitUnsafe;

package/dist/src/types/Type.d.ts

@@ -16,6 +16,7 @@
  *   ZipCode.description // '5-digit US zip code'
  */
 import { type Base } from 'tosijs-schema';
+import { type JSONSchemaObject } from '../lang/json-schema';
 /** JSON Schema object type (simplified) */
 type JSONSchema = {
     type?: string;
@@ -42,6 +43,10 @@ export interface RuntimeType<T = unknown> {
     readonly examples?: T[];
     /** Default value (for instantiation) */
     readonly default?: T;
+    /** Generate JSON Schema for this type */
+    toJSONSchema(): JSONSchemaObject;
+    /** Strip a value down to only the fields matching this type's schema */
+    strip(value: unknown): unknown;
     /** Brand for type identification */
     readonly __runtimeType: true;
 }