tjs-lang 0.6.19 → 0.6.26

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

@@ -1,233 +0,0 @@
-/**
- * Timestamp - Pure functions for ISO 8601 timestamp strings
- *
- * No Date warts:
- * - Months are 1-based (January = 1)
- * - All functions are pure (string in, string out)
- * - No mutable objects
- * - UTC by default, explicit timezone for display
- */
-/**
- * ISO 8601 timestamp string type
- * e.g., "2024-01-15T10:30:00.000Z"
- */
-export type TimestampString = string;
-/**
- * Validate that a string is a valid ISO 8601 timestamp
- */
-export declare function isValid(ts: string): ts is TimestampString;
-/**
- * Get the current timestamp as ISO string
- */
-export declare function now(): TimestampString;
-/**
- * Create a timestamp from components
- * IMPORTANT: month is 1-based (1 = January, 12 = December)
- */
-export declare function from(year: number, month: number, day: number, hour?: number, minute?: number, second?: number, ms?: number): TimestampString;
-/**
- * Parse a flexible date string into ISO timestamp
- * Handles various formats and normalizes to UTC
- */
-export declare function parse(input: string): TimestampString;
-/**
- * Try to parse a date string, returning null on failure
- */
-export declare function tryParse(input: string): TimestampString | null;
-/**
- * Add milliseconds to a timestamp
- */
-export declare function addMilliseconds(ts: TimestampString, ms: number): TimestampString;
-/**
- * Add seconds to a timestamp
- */
-export declare function addSeconds(ts: TimestampString, seconds: number): TimestampString;
-/**
- * Add minutes to a timestamp
- */
-export declare function addMinutes(ts: TimestampString, minutes: number): TimestampString;
-/**
- * Add hours to a timestamp
- */
-export declare function addHours(ts: TimestampString, hours: number): TimestampString;
-/**
- * Add days to a timestamp
- */
-export declare function addDays(ts: TimestampString, days: number): TimestampString;
-/**
- * Add weeks to a timestamp
- */
-export declare function addWeeks(ts: TimestampString, weeks: number): TimestampString;
-/**
- * Add months to a timestamp
- * Handles month overflow correctly (e.g., Jan 31 + 1 month = Feb 28/29)
- */
-export declare function addMonths(ts: TimestampString, months: number): TimestampString;
-/**
- * Add years to a timestamp
- * Handles leap years correctly (Feb 29 + 1 year = Feb 28)
- */
-export declare function addYears(ts: TimestampString, years: number): TimestampString;
-/**
- * Get the difference between two timestamps in milliseconds
- * Returns a - b (positive if a is after b)
- */
-export declare function diff(a: TimestampString, b: TimestampString): number;
-/**
- * Get the difference in seconds
- */
-export declare function diffSeconds(a: TimestampString, b: TimestampString): number;
-/**
- * Get the difference in minutes
- */
-export declare function diffMinutes(a: TimestampString, b: TimestampString): number;
-/**
- * Get the difference in hours
- */
-export declare function diffHours(a: TimestampString, b: TimestampString): number;
-/**
- * Get the difference in days
- */
-export declare function diffDays(a: TimestampString, b: TimestampString): number;
-/**
- * Get the year component
- */
-export declare function year(ts: TimestampString): number;
-/**
- * Get the month component (1-based: 1 = January, 12 = December)
- */
-export declare function month(ts: TimestampString): number;
-/**
- * Get the day of month component (1-31)
- */
-export declare function day(ts: TimestampString): number;
-/**
- * Get the hour component (0-23)
- */
-export declare function hour(ts: TimestampString): number;
-/**
- * Get the minute component (0-59)
- */
-export declare function minute(ts: TimestampString): number;
-/**
- * Get the second component (0-59)
- */
-export declare function second(ts: TimestampString): number;
-/**
- * Get the millisecond component (0-999)
- */
-export declare function millisecond(ts: TimestampString): number;
-/**
- * Get the day of week (1 = Monday, 7 = Sunday) - ISO 8601 convention
- */
-export declare function dayOfWeek(ts: TimestampString): number;
-/**
- * Format a timestamp for local display
- * Uses Intl.DateTimeFormat for timezone-aware formatting
- */
-export declare function toLocal(ts: TimestampString, timezone?: string, options?: Intl.DateTimeFormatOptions): string;
-/**
- * Format as a readable date/time string
- */
-export declare function format(ts: TimestampString, timezone?: string): string;
-/**
- * Format as date only (no time)
- */
-export declare function formatDate(ts: TimestampString, timezone?: string): string;
-/**
- * Format as time only (no date)
- */
-export declare function formatTime(ts: TimestampString, timezone?: string): string;
-/**
- * Extract just the date portion as YYYY-MM-DD (LegalDate format)
- */
-export declare function toDate(ts: TimestampString): string;
-/**
- * Check if a is before b
- */
-export declare function isBefore(a: TimestampString, b: TimestampString): boolean;
-/**
- * Check if a is after b
- */
-export declare function isAfter(a: TimestampString, b: TimestampString): boolean;
-/**
- * Check if two timestamps are equal
- */
-export declare function isEqual(a: TimestampString, b: TimestampString): boolean;
-/**
- * Get the earlier of two timestamps
- */
-export declare function min(a: TimestampString, b: TimestampString): TimestampString;
-/**
- * Get the later of two timestamps
- */
-export declare function max(a: TimestampString, b: TimestampString): TimestampString;
-/**
- * Get the start of the day (00:00:00.000 UTC)
- */
-export declare function startOfDay(ts: TimestampString): TimestampString;
-/**
- * Get the end of the day (23:59:59.999 UTC)
- */
-export declare function endOfDay(ts: TimestampString): TimestampString;
-/**
- * Get the start of the month
- */
-export declare function startOfMonth(ts: TimestampString): TimestampString;
-/**
- * Get the end of the month
- */
-export declare function endOfMonth(ts: TimestampString): TimestampString;
-/**
- * Get the start of the year
- */
-export declare function startOfYear(ts: TimestampString): TimestampString;
-/**
- * Get the end of the year
- */
-export declare function endOfYear(ts: TimestampString): TimestampString;
-export declare const Timestamp: {
-    isValid: typeof isValid;
-    now: typeof now;
-    from: typeof from;
-    parse: typeof parse;
-    tryParse: typeof tryParse;
-    addMilliseconds: typeof addMilliseconds;
-    addSeconds: typeof addSeconds;
-    addMinutes: typeof addMinutes;
-    addHours: typeof addHours;
-    addDays: typeof addDays;
-    addWeeks: typeof addWeeks;
-    addMonths: typeof addMonths;
-    addYears: typeof addYears;
-    diff: typeof diff;
-    diffSeconds: typeof diffSeconds;
-    diffMinutes: typeof diffMinutes;
-    diffHours: typeof diffHours;
-    diffDays: typeof diffDays;
-    year: typeof year;
-    month: typeof month;
-    day: typeof day;
-    hour: typeof hour;
-    minute: typeof minute;
-    second: typeof second;
-    millisecond: typeof millisecond;
-    dayOfWeek: typeof dayOfWeek;
-    toLocal: typeof toLocal;
-    format: typeof format;
-    formatDate: typeof formatDate;
-    formatTime: typeof formatTime;
-    toDate: typeof toDate;
-    isBefore: typeof isBefore;
-    isAfter: typeof isAfter;
-    isEqual: typeof isEqual;
-    min: typeof min;
-    max: typeof max;
-    startOfDay: typeof startOfDay;
-    endOfDay: typeof endOfDay;
-    startOfMonth: typeof startOfMonth;
-    endOfMonth: typeof endOfMonth;
-    startOfYear: typeof startOfYear;
-    endOfYear: typeof endOfYear;
-};
-export default Timestamp;

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

@@ -1,234 +0,0 @@
-/**
- * Type() - Runtime type definitions with descriptions and validation
- *
- * Forms:
- *   Type(description, predicate) - full form with custom validation
- *   Type(description, schema) - schema-based validation
- *   Type(schema) - schema only, self-documenting
- *
- * Usage:
- *   const ZipCode = Type('5-digit US zip code', (s) => /^\d{5}$/.test(s))
- *   const Email = Type('valid email', s.string.email)
- *   const Age = Type(s.number.min(0).max(150))
- *
- *   ZipCode.check('12345') // true
- *   ZipCode.check('abc') // false
- *   ZipCode.description // '5-digit US zip code'
- */
-import { type Base } from 'tosijs-schema';
-/** JSON Schema object type (simplified) */
-type JSONSchema = {
-    type?: string;
-    properties?: Record<string, JSONSchema>;
-    items?: JSONSchema;
-    required?: string[];
-    [key: string]: unknown;
-};
-/** Schema can be a tosijs-schema builder or a raw JSON Schema object */
-type Schema = Base<any> | JSONSchema;
-/** A runtime type with description and validation */
-export interface RuntimeType<T = unknown> {
-    /** Human-readable description of the type */
-    readonly description: string;
-    /** Check if a value matches this type */
-    check(value: unknown): value is T;
-    /** The underlying schema (if schema-based) */
-    readonly schema?: Schema;
-    /** The predicate function (if predicate-based) */
-    readonly predicate?: (value: unknown) => boolean;
-    /** Example value (for documentation and signature testing) */
-    readonly example?: T;
-    /** Multiple example values (from schema metadata, for autocomplete hints) */
-    readonly examples?: T[];
-    /** Default value (for instantiation) */
-    readonly default?: T;
-    /** Brand for type identification */
-    readonly __runtimeType: true;
-}
-/** Check if a value is a RuntimeType */
-export declare function isRuntimeType(value: unknown): value is RuntimeType;
-export declare function Type<T = unknown>(descriptionOrSchema: string | Schema, predicateOrSchemaOrExample?: ((value: unknown) => boolean) | Schema | T | undefined, exampleArg?: T, defaultArg?: T): RuntimeType<T>;
-/** String type */
-export declare const TString: RuntimeType<string>;
-/** Number type */
-export declare const TNumber: RuntimeType<number>;
-/** Boolean type */
-export declare const TBoolean: RuntimeType<boolean>;
-/** Integer type */
-export declare const TInteger: RuntimeType<number>;
-/** Positive integer type */
-export declare const TPositiveInt: RuntimeType<number>;
-/** Non-empty string type */
-export declare const TNonEmptyString: RuntimeType<string>;
-/** Email type (basic validation) */
-export declare const TEmail: RuntimeType<string>;
-/**
- * Check if a string is a valid URL (portable helper for predicates)
- * This will become an AJS builtin
- */
-export declare const isValidUrl: (v: string) => boolean;
-/** URL type */
-export declare const TUrl: RuntimeType<string>;
-/** UUID type */
-export declare const TUuid: RuntimeType<string>;
-/**
- * Check if a string is a valid ISO 8601 timestamp (portable helper for predicates)
- * This will become an AJS builtin
- */
-export declare const isValidTimestamp: (v: string) => boolean;
-/**
- * Check if a string is a valid YYYY-MM-DD date (portable helper for predicates)
- * This will become an AJS builtin
- */
-export declare const isValidLegalDate: (v: string) => boolean;
-/** ISO 8601 timestamp string (e.g., "2024-01-15T10:30:00Z") */
-export declare const Timestamp: RuntimeType<string>;
-/** Legal date string in YYYY-MM-DD format */
-export declare const LegalDate: RuntimeType<string>;
-/** Create a nullable version of a type */
-export declare function Nullable<T>(type: RuntimeType<T>): RuntimeType<T | null>;
-/** Create an optional version of a type (nullable + undefined) */
-export declare function Optional<T>(type: RuntimeType<T>): RuntimeType<T | null | undefined>;
-/**
- * Create a union type
- *
- * Two forms:
- *   Union(...types: RuntimeType[]) - combine existing types
- *   Union(description, values) - create literal union from values
- *
- * @example
- * // From RuntimeTypes
- * const StringOrNumber = Union(TString, TNumber)
- *
- * // From literal values (used by TJS syntax)
- * const Direction = Union('cardinal direction', ['up', 'down', 'left', 'right'])
- */
-export declare function Union<T extends unknown[]>(descriptionOrType: string | RuntimeType, valuesOrType?: T | RuntimeType, ...restTypes: RuntimeType[]): RuntimeType;
-/** Create an array type */
-export declare function TArray<T>(itemType: RuntimeType<T>): RuntimeType<T[]>;
-/** Type parameter - can be a RuntimeType, schema, or example value */
-export type TypeParam = RuntimeType | Base<any> | JSONSchema | unknown;
-/** Generic type factory */
-export interface GenericType<TParams extends string[] = string[]> {
-    /** Instantiate the generic with concrete type arguments */
-    (...typeArgs: TypeParam[]): RuntimeType;
-    /** The type parameter names */
-    readonly params: TParams;
-    /** Description template */
-    readonly description: string;
-}
-/**
- * Create a generic (parameterized) type factory
- *
- * @param params Array of type parameter names, with optional defaults: ['T', ['U', defaultSchema]]
- * @param predicate Function receiving (value, ...typeChecks) where typeChecks are validation functions
- * @param description Human-readable description template (type params will be substituted)
- *
- * @example
- * // Pair<T, U>
- * const Pair = Generic(
- *   ['T', 'U'],
- *   (x, checkT, checkU) =>
- *     Array.isArray(x) && x.length === 2 && checkT(x[0]) && checkU(x[1]),
- *   'Pair<T, U>'
- * )
- *
- * // Usage: Pair(TString, TNumber) creates a type for [string, number]
- * // Or with examples: Pair('', 0)
- */
-export declare function Generic<TParams extends string[]>(params: (string | [string, TypeParam])[], predicate: (value: unknown, ...typeChecks: Array<(v: unknown) => boolean>) => boolean, description: string): GenericType<TParams>;
-/** Pair<T, U> - 2-element tuple */
-export declare const TPair: GenericType<string[]>;
-/** Record<V> - object with string keys and values of type V */
-export declare const TRecord: GenericType<string[]>;
-/** Enum type with bidirectional lookup */
-export interface EnumType<T extends Record<string, string | number> = Record<string, string | number>> extends RuntimeType<T[keyof T]> {
-    /** The enum members as { Name: value } */
-    readonly members: T;
-    /** Reverse lookup: value -> name */
-    readonly names: Record<string | number, string>;
-    /** Get all valid values */
-    readonly values: Array<T[keyof T]>;
-    /** Get all member names */
-    readonly keys: Array<keyof T>;
-}
-/**
- * Create an enum type with bidirectional lookup
- *
- * @param description Human-readable description
- * @param members Object mapping names to values { Pending: 0, Active: 1 }
- *
- * @example
- * const Status = Enum('task status', { Pending: 0, Active: 1, Done: 2 })
- * Status.check(0)        // true
- * Status.check('done')   // false
- * Status.members.Pending // 0
- * Status.names[0]        // 'Pending'
- * Status.values          // [0, 1, 2]
- * Status.keys            // ['Pending', 'Active', 'Done']
- *
- * const Color = Enum('CSS color', { Red: 'red', Green: 'green', Blue: 'blue' })
- * Color.check('red')     // true
- * Color.members.Red      // 'red'
- */
-export declare function Enum<T extends Record<string, string | number>>(description: string, members: T): EnumType<T>;
-/** Return contract levels in order of strictness */
-export type ReturnContract = 'assertReturns' | 'returns' | 'checkedReturns';
-/** Specification for a FunctionPredicate */
-export interface FunctionPredicateSpec {
-    /** Parameter types as example values */
-    params?: Record<string, any>;
-    /** Return type as example value */
-    returns?: any;
-    /** Return contract level */
-    returnContract?: ReturnContract;
-}
-/** A runtime type that validates function signatures */
-export interface FunctionPredicateType extends RuntimeType<Function> {
-    /** Parameter specification */
-    readonly params: Record<string, any>;
-    /** Return type specification */
-    readonly returns?: any;
-    /** Return contract level */
-    readonly returnContract: ReturnContract;
-}
-/** A generic FunctionPredicate factory — call with type args to get a FunctionPredicateType */
-export interface GenericFunctionPredicateType {
-    (...typeArgs: TypeParam[]): FunctionPredicateType;
-    /** Type parameter names */
-    readonly typeParamNames: string[];
-    /** Description */
-    readonly description: string;
-    /** Marker for runtime type detection */
-    readonly __runtimeType: true;
-}
-/**
- * Create a runtime type for function signatures.
- *
- * Forms:
- *   FunctionPredicate(name, spec) - from a specification object
- *   FunctionPredicate(name, fn)   - from an existing typed function
- *
- * @example
- * const Callback = FunctionPredicate('Callback', {
- *   params: { x: 0, y: 0 },
- *   returns: 0,
- * })
- * Callback.check((a, b) => a + b) // true (typeof === 'function')
- * Callback.check(42)              // false
- *
- * @example
- * function add(a: 0, b: 0) -> 0 { return a + b }
- * const Adder = FunctionPredicate('Adder', add)
- * // Extracts params/returns from add.__tjs
- *
- * @example
- * // Generic form — returns a factory
- * const Creator = FunctionPredicate('Creator', [['T', {}]], (T) => ({
- *   params: { contents: [null] },
- *   returns: T,
- * }))
- * const HtmlCreator = Creator({})  // FunctionPredicateType with returns: {}
- */
-export declare function FunctionPredicate(name: string, specOrFn: FunctionPredicateSpec | Function | (string | [string, TypeParam])[], specBuilder?: (...typeArgs: any[]) => FunctionPredicateSpec): FunctionPredicateType | GenericFunctionPredicateType;
-export {};

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

@@ -1,8 +0,0 @@
-/**
- * TJS Type System
- *
- * Runtime types with descriptions and validation.
- */
-export { Type, isRuntimeType, type RuntimeType, TString, TNumber, TBoolean, TInteger, TPositiveInt, TNonEmptyString, TEmail, TUrl, TUuid, Timestamp as TimestampType, LegalDate as LegalDateType, isValidUrl, isValidTimestamp, isValidLegalDate, Nullable, Optional, Union, TArray, Enum, type EnumType, Generic, TPair, TRecord, type GenericType, type TypeParam, FunctionPredicate, type FunctionPredicateType, type GenericFunctionPredicateType, type FunctionPredicateSpec, type ReturnContract, } from './Type';
-export { Timestamp, type TimestampString } from './Timestamp';
-export { LegalDate, type LegalDateString } from './LegalDate';

package/dist/src/vm/atoms/batteries.d.ts

@@ -1,6 +0,0 @@
-export declare const storeVectorize: import("..").Atom<Record<string, any>, number[]>;
-export declare const storeCreateCollection: import("..").Atom<Record<string, any>, void>;
-export declare const storeVectorAdd: import("..").Atom<Record<string, any>, void>;
-export declare const storeSearch: import("..").Atom<Record<string, any>, any[]>;
-export declare const llmPredictBattery: import("..").Atom<Record<string, any>, any>;
-export declare const llmVision: import("..").Atom<Record<string, any>, any>;

package/dist/src/vm/atoms/browser.d.ts

@@ -1,18 +0,0 @@
-export interface DomCapabilities {
-    querySelector(selector: string): Element | null;
-    querySelectorAll(selector: string): NodeListOf<Element>;
-}
-export interface StorageCapabilities {
-    getItem(key: string): string | null;
-    setItem(key: string, value: string): void;
-}
-export declare const createBrowserCapabilities: () => {
-    dom: {
-        querySelector: (s: string) => Element | null;
-        querySelectorAll: (s: string) => NodeListOf<Element>;
-    };
-    storage: {
-        getItem: (k: string) => string | null;
-        setItem: (k: string, v: string) => void;
-    };
-};

package/dist/src/vm/atoms/index.d.ts

@@ -1,10 +0,0 @@
-import { coreAtoms } from '../runtime';
-export declare const batteryAtoms: {
-    storeCreateCollection: import("..").Atom<Record<string, any>, void>;
-    storeSearch: import("..").Atom<Record<string, any>, any[]>;
-    storeVectorAdd: import("..").Atom<Record<string, any>, void>;
-    storeVectorize: import("..").Atom<Record<string, any>, number[]>;
-    llmPredictBattery: import("..").Atom<Record<string, any>, any>;
-    llmVision: import("..").Atom<Record<string, any>, any>;
-};
-export { coreAtoms };

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

@@ -1,12 +0,0 @@
-/**
- * TJS VM - Sandboxed execution runtime
- *
- * Lightweight (~33KB) VM for executing AJS AST with:
- * - Fuel metering (gas limits)
- * - Capability-based security
- * - Monadic error handling
- * - Timeout enforcement
- */
-export * from './runtime';
-export * from './vm';
-export * from './atoms';