tjs-lang 0.8.7 → 0.9.0

package/dist/scripts/build-editors.d.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env bun
+export declare const ROOT: string;
+export interface EditorTarget {
+    name: string;
+    entry: string;
+    outfile: string;
+    external: string[];
+    description: string;
+}
+/**
+ * Bundle one editor target. With `write: true` (default) it writes the `.js` in
+ * place and returns its bytes; with `write: false` it returns the bytes without
+ * touching disk (used by the anti-drift guard test to compare against the
+ * committed file).
+ */
+export declare function bundleEditor(target: EditorTarget, { write }?: {
+    write?: boolean;
+}): string;
+export declare const editorTargets: EditorTarget[];

package/dist/src/css/dimensions.d.ts

@@ -0,0 +1,23 @@
+/**
+ * CSS dimension / numeric value grammar (phase 2) — the other big family of leaf
+ * values: lengths, percentages, angles, times, resolutions, plain numbers, and
+ * the CSS-wide global keywords. Same rules as the color cluster: pure,
+ * synchronous, ReDoS-clean (flat character classes / bounded alternation only),
+ * with `var(--…)`/`calc(…)` as the open escapes.
+ *
+ * The numeric core `[+-]?(\d*\.\d+|\d+)` is a bounded alternation (each branch a
+ * single quantifier — no nesting), so it passes the verifier's ReDoS lint.
+ */
+/** Absolute + relative + container + viewport length units (CSS Values 4). */
+export declare const CSS_LENGTH_UNITS: string[];
+/** CSS-wide keywords valid on any property. */
+export declare const CSS_GLOBAL_KEYWORDS: string[];
+/**
+ * Dimension predicate cluster (source). Entry points cover each numeric family
+ * plus `isDimension` (any of them) and `isGlobalKeyword`. Units are ordered
+ * longest-first inside the alternation so e.g. `rem` isn't shadowed by `em`
+ * (belt-and-suspenders — the `$` anchor already forces a full match).
+ */
+export declare const CSS_DIMENSION_SOURCE: string;
+/** Entry predicates exported by the dimension cluster (for compile/suggest). */
+export declare const CSS_DIMENSION_ENTRIES: readonly ["isNumber", "isInteger", "isPercentage", "isLength", "isAngle", "isTime", "isResolution", "isGlobalKeyword", "isDimension"];

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

@@ -0,0 +1,85 @@
+/**
+ * `tjs-lang/css` — CSS validation built from verified-safe predicates.
+ *
+ * The "computational half" of a CSS schema: precise, total validators for the
+ * open value grammars TS/JSON-Schema cave to `string` on (colors here in
+ * phase 1; lengths, shorthands and the recursive style-object structure land in
+ * later phases — see TODO.md #4). Every validator is compiled from a
+ * predicate-safe source cluster (`./predicates`), so it is pure, synchronous,
+ * fuel-bounded, and ReDoS-clean — safe to run on untrusted input.
+ *
+ * Autocomplete rides the same source: `suggestColor()` mines the named-color set
+ * and the open functional stubs (`var(--`, `color-mix(`, …), validating mined
+ * values through the compiled predicate so completions are guaranteed valid.
+ */
+import { type PredicateVerifyResult, type Suggestion } from '../lang/predicate';
+export { CSS_COLOR_SOURCE, CSS_COLOR_ENTRIES, CSS_NAMED_COLORS, } from './predicates';
+export { CSS_DIMENSION_SOURCE, CSS_DIMENSION_ENTRIES, CSS_LENGTH_UNITS, CSS_GLOBAL_KEYWORDS, } from './dimensions';
+export { CSS_STYLE_SOURCE, CSS_STYLE_ENTRIES, cssStyleSchema, cssColorSchema, cssDimensionSchema, } from './style';
+export { CSS_SHORTHAND_SOURCE, CSS_SHORTHAND_ENTRIES, cssAnimationSchema, cssTransitionSchema, } from './shorthands';
+/** Is `v` a valid CSS color (named, hex, rgb/hsl, modern fn, or `var(--…)`)? */
+export declare const isColor: (v: unknown) => boolean;
+/** Like {@link isColor}, but tolerates a trailing `!important`. */
+export declare const isColorValue: (v: unknown) => boolean;
+/** Is `v` a CSS named color (incl. `transparent`/`currentcolor`)? */
+export declare const isNamedColor: (v: unknown) => boolean;
+/** Is `v` a CSS hex color (`#rgb`, `#rgba`, `#rrggbb`, `#rrggbbaa`)? */
+export declare const isHexColor: (v: unknown) => boolean;
+/** Is `v` a CSS `<length>` (unit'd, unitless `0`, or `var()`/`calc()`)? */
+export declare const isLength: (v: unknown) => boolean;
+/** Is `v` a CSS `<percentage>` (`50%`)? */
+export declare const isPercentage: (v: unknown) => boolean;
+/** Is `v` a CSS `<number>` (numeric, or a numeric string)? */
+export declare const isNumber: (v: unknown) => boolean;
+/** Is `v` a CSS `<integer>`? */
+export declare const isInteger: (v: unknown) => boolean;
+/** Is `v` a CSS `<angle>` (`45deg`, `1turn`, `1.5rad`, `100grad`)? */
+export declare const isAngle: (v: unknown) => boolean;
+/** Is `v` a CSS `<time>` (`200ms`, `1s`)? */
+export declare const isTime: (v: unknown) => boolean;
+/** Is `v` any CSS dimension/number (length, %, angle, time, resolution, number)? */
+export declare const isDimension: (v: unknown) => boolean;
+/** Is `v` a CSS-wide keyword (`inherit`/`initial`/`unset`/`revert`/`revert-layer`)? */
+export declare const isGlobalKeyword: (v: unknown) => boolean;
+/**
+ * Is `v` a valid CSS **style object** — an open, recursive map of CSS properties
+ * to values and selectors/at-rules to nested style objects? Validates the whole
+ * structure (keys are properties or selectors; property values are style values,
+ * selector values are nested rules), recursively and fuel-bounded. This is the
+ * shape TS/JSON-Schema can't express.
+ */
+export declare const isStyleObject: (v: unknown) => boolean;
+/** Is `v` a valid leaf CSS value (a known color/dimension/keyword, else a non-empty string / finite number)? */
+export declare const isStyleValue: (v: unknown) => boolean;
+/**
+ * Property-AWARE leaf check: given the property name, tightens the closed value
+ * grammars (color/animation/transition) so `isStyleValueFor('color', 'notacolor')`
+ * is `false` while `isStyleValueFor('padding', 'anything')` stays permissive.
+ * This is what makes {@link isStyleObject} catch real value errors.
+ */
+export declare const isStyleValueFor: (prop: unknown, val: unknown) => boolean;
+/** Is `k` a CSS property name (`color`, `--custom`, `-webkit-foo`)? */
+export declare const isCssProperty: (k: unknown) => boolean;
+/** Is `k` a selector or at-rule key (nests a rule) rather than a property? */
+export declare const isSelectorOrAtRule: (k: unknown) => boolean;
+/** Is `v` a valid CSS `animation` shorthand (comma-separated, order-free tokens)? */
+export declare const isAnimation: (v: unknown) => boolean;
+/** Is `v` a valid CSS `transition` shorthand (comma-separated layers)? */
+export declare const isTransition: (v: unknown) => boolean;
+/** Is `v` a CSS `<easing-function>` (keyword, `cubic-bezier(…)`, `steps(…)`, `linear(…)`)? */
+export declare const isTimingFunction: (v: unknown) => boolean;
+/**
+ * Verify every CSS predicate-source cluster is predicate-safe (pure,
+ * synchronous, ReDoS-clean). Returns the combined result (safe iff all clusters
+ * are; diagnostics carry the cluster name). Always safe for the shipped source —
+ * exposed so downstream tools (and the drift test) can assert it, and so a
+ * consumer embedding a source in a `$predicate` schema can re-check before
+ * trusting it.
+ */
+export declare function verifyCss(): PredicateVerifyResult;
+/**
+ * Autocomplete candidates for a CSS color value. Returns concrete named colors
+ * (validated through the compiled predicate) plus open-ended stubs mined from
+ * the functional forms (`var(--`, `color-mix(`, `oklch(`, …). Prefix-filtered.
+ */
+export declare function suggestColor(prefix?: string, limit?: number): Suggestion[];

package/dist/src/css/predicates.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The CSS predicate library — canonical **source** form.
+ *
+ * Predicates are authored as source strings, not native functions, because the
+ * source is the serializable, portable artifact: it feeds the verifier
+ * (`verifyPredicate` — certifies pure/synchronous/ReDoS-clean), compiles to the
+ * native fast path (`compilePredicate`), mines autocomplete (`suggest`), and
+ * embeds into JSON Schema's `$predicate` keyword. This is the "computational
+ * half" JSON Schema and TS structural types can't express — CSS is the torture
+ * test (open value grammars, order-flexible shorthands, recursive structure).
+ *
+ * Style rules for anything added here (so it stays verifiable):
+ *   - pure & synchronous: no IO, no `await`, no `new`, no loops (use
+ *     `every`/`some`/`map`/recursion — fuel bounds them at function entry);
+ *   - regexes must be ReDoS-clean (no nested unbounded quantifiers — the
+ *     verifier rejects `(a+)+` and friends, so keep character classes flat);
+ *   - compose with `||` and named predicates as callbacks (`toks.every(isX)`).
+ *
+ * Phase 1 ships the color grammar. Later phases add lengths/dimensions,
+ * shorthands, and the recursive style-object structure — see TODO.md (#4).
+ */
+/**
+ * The CSS Color Module Level 4 named colors (+ the CSS-wide `transparent` and
+ * `currentcolor`), lower-cased. Data, kept in the source so the whole cluster
+ * stays serializable as one artifact.
+ */
+export declare const CSS_NAMED_COLORS: string[];
+/**
+ * Color predicate cluster (source). Entry points: `isColor` (any CSS color) and
+ * `isColorValue` (a color, tolerating a trailing `!important`). Regexes are
+ * flat-class (ReDoS-clean). The functional-color forms (`hwb`/`lab`/`lch`/
+ * `oklab`/`oklch`/`color`/`color-mix`) are matched by name + balanced parens
+ * rather than validating their args — precise enough for validation, open
+ * enough not to reject valid modern CSS.
+ */
+export declare const CSS_COLOR_SOURCE: string;
+/** Entry predicates exported by the color cluster (for compile/suggest). */
+export declare const CSS_COLOR_ENTRIES: readonly ["isColor", "isColorValue", "isNamedColor", "isHexColor", "isRgbColor", "isHslColor"];

package/dist/src/css/shorthands.d.ts

@@ -0,0 +1,31 @@
+/**
+ * CSS order-flexible shorthands (phase 3) — the second torture case from the
+ * PoC: a shorthand like `animation` or `transition` is a comma-separated list of
+ * layers, each a whitespace-separated bag of tokens whose *order is free*
+ * (`3s ease-in 1s infinite alternate slidein` ≡ any permutation). TS unions and
+ * JSON Schema can't express "a set of tokens, each classifiable, in any order";
+ * a predicate tokenizes and classifies (`toks.every(isAnimToken)`).
+ *
+ * Built on the dimension leaf cluster (for `isTime`/`isCssVar`/`isCssCalc`).
+ * Same rules as the other clusters: pure, synchronous, ReDoS-clean (the split
+ * regexes are single-quantifier `\s+` / `,`; classifier regexes are flat).
+ */
+import type { PredicateSchema } from '../lang/predicate-schema';
+/**
+ * The shorthand classifiers alone (no leaf cluster prepended). Exported so the
+ * combined style cluster (`style.ts`) can compose them for property-aware
+ * validation without re-including the dimension source.
+ */
+export declare const CSS_SHORTHAND_FRAGMENT = "\nvar ANIM_TIMING = ['linear','ease','ease-in','ease-out','ease-in-out','step-start','step-end']\nvar ANIM_DIRECTION = ['normal','reverse','alternate','alternate-reverse']\nvar ANIM_FILLMODE = ['none','forwards','backwards','both']\nvar ANIM_PLAYSTATE = ['running','paused']\n\nfunction isTimingFunction(t) {\n  if (typeof t !== 'string') { return false }\n  if (ANIM_TIMING.includes(t)) { return true }\n  return (t.startsWith('cubic-bezier(') || t.startsWith('steps(') || t.startsWith('linear(')) && t.endsWith(')')\n}\nfunction isIterationCount(t) {\n  return t === 'infinite' || (typeof t === 'string' && /^[0-9]*\\.?[0-9]+$/.test(t))\n}\nfunction isAnimName(t) {\n  // any custom-ident (also matches keywords, which classify earlier anyway)\n  return typeof t === 'string' && /^-?[a-z_][a-z0-9_-]*$/i.test(t)\n}\n// Tokenize a whole shorthand value. A function token like cubic-bezier(a, b) is\n// kept whole (arg spaces/commas must not split it); top-level commas (layer\n// separators) and whitespace are delimiters, so they're dropped. Loops are\n// banned in predicates, so this is one .match with a FLAT (ReDoS-clean) regex \u2014\n// note a paren-aware comma *splitter* would be a nested quantifier the verifier\n// rejects, so we tokenize instead and guard empty layers separately.\nfunction cssTokens(v) {\n  return typeof v === 'string' ? v.match(/[a-z-]+\\([^)]*\\)|[^\\s,]+/gi) : null\n}\n// Reject leading/trailing/double commas (empty layers). Flat, ReDoS-clean.\nfunction hasEmptyLayer(v) {\n  return typeof v === 'string' && /^\\s*,|,\\s*$|,\\s*,/.test(v)\n}\nfunction isAnimToken(t) {\n  return isTime(t) || isIterationCount(t) || isTimingFunction(t)\n      || ANIM_DIRECTION.includes(t) || ANIM_FILLMODE.includes(t) || ANIM_PLAYSTATE.includes(t)\n      || isCssVar(t) || isCssCalc(t) || isAnimName(t)\n}\nfunction isAnimation(v) {\n  if (typeof v !== 'string' || v.length === 0 || hasEmptyLayer(v)) { return false }\n  var toks = cssTokens(v)\n  return toks !== null && toks.length > 0 && toks.every(isAnimToken)\n}\n\nfunction isTransitionProperty(t) {\n  return t === 'all' || t === 'none' || isAnimName(t)\n}\nfunction isTransitionToken(t) {\n  return isTime(t) || isTimingFunction(t) || isCssVar(t) || isCssCalc(t) || isTransitionProperty(t)\n}\nfunction isTransition(v) {\n  if (typeof v !== 'string' || v.length === 0 || hasEmptyLayer(v)) { return false }\n  var toks = cssTokens(v)\n  return toks !== null && toks.length > 0 && toks.every(isTransitionToken)\n}\n";
+/**
+ * Shorthand predicate cluster (source) = dimension leaves + the shorthand
+ * classifiers. Entry predicates: `isAnimation`, `isTransition` (each accepts a
+ * comma-separated list of order-free token layers).
+ */
+export declare const CSS_SHORTHAND_SOURCE: string;
+/** Entry predicates exported by the shorthand cluster (for compile/verify). */
+export declare const CSS_SHORTHAND_ENTRIES: readonly ["isTimingFunction", "isAnimation", "isTransition"];
+/** `$predicate` schema for a CSS `animation` shorthand value. */
+export declare function cssAnimationSchema(): PredicateSchema;
+/** `$predicate` schema for a CSS `transition` shorthand value. */
+export declare function cssTransitionSchema(): PredicateSchema;

package/dist/src/css/style.d.ts

@@ -0,0 +1,48 @@
+/**
+ * CSS style-object structure (phase 4) — the recursive, open shape TS structural
+ * types and JSON Schema can't express, and the `$predicate` schemas that carry
+ * it. This is the thesis deliverable: a JSON-Schema node whose *structural* part
+ * (`type: 'object'`) a naive validator checks, and whose `$predicate` a
+ * predicate-aware validator runs to validate the whole recursive CSS structure —
+ * progressive enhancement, one serializable artifact.
+ *
+ * The combined source concatenates the color + dimension leaf clusters and adds
+ * the structure predicates, so `isStyleValue`/`isStyleObject` compose the leaves
+ * directly. `isStyleObject` is LAST — the entry the `$predicate` schema runs.
+ *
+ * Value precision is intentionally two-tier (as in the PoC): the *structure* is
+ * validated strictly (keys must be CSS properties or selectors/at-rules; a
+ * property maps to a value, a selector to a nested rule), while a generic leaf
+ * value falls back to "non-empty string or finite number" so a valid-but-
+ * unmodelled value (a shorthand, a not-yet-covered property) is never rejected.
+ * Per-property precision comes from the specific value schemas (`cssColorSchema`
+ * etc.) and, later, property-aware validation (phase 3 shorthands).
+ */
+import type { PredicateSchema } from '../lang/predicate-schema';
+/**
+ * The full CSS style predicate cluster: color + dimension + shorthand leaves +
+ * recursive, property-aware structure. Entry = `isStyleObject` (last function).
+ * Serializable — this is exactly what a `$predicate` schema carries.
+ */
+export declare const CSS_STYLE_SOURCE: string;
+/** Entry predicates exported by the style cluster (for compile/verify). */
+export declare const CSS_STYLE_ENTRIES: readonly ["isCssProperty", "isSelectorOrAtRule", "isStyleValue", "isStyleValueFor", "isStyleObject"];
+/**
+ * A `$predicate` JSON-Schema for a CSS style object (à la a tosijs styleSpec):
+ * naive validators check only `type: 'object'`; predicate-aware validators run
+ * `isStyleObject`, validating the whole recursive structure (nested selectors,
+ * property/value shapes). Progressive enhancement from one serializable schema.
+ */
+export declare function cssStyleSchema(): PredicateSchema;
+/**
+ * A `$predicate` schema for a single CSS **color** value (entry `isColorValue`,
+ * so a trailing `!important` is tolerated). Naive validators check `type:
+ * 'string'`; aware ones validate the color grammar.
+ */
+export declare function cssColorSchema(): PredicateSchema;
+/**
+ * A `$predicate` schema for a CSS **dimension** value (length/%/angle/time/
+ * number; entry `isDimension`). No structural `type` — a dimension may be a
+ * string (`10px`) or a number — so aware validators do all the work.
+ */
+export declare function cssDimensionSchema(): PredicateSchema;

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

@@ -45,7 +45,7 @@
  * See also: demo/src/tjs-playground.ts which has a manual __tjs stub that
  * must stay in sync with the runtime - a symptom of this leaky abstraction.
  */
-import type { TypeDescriptor, ParameterDescriptor } from '../types';
+import type { TypeDescriptor, ParameterDescriptor, PredicateVerification } from '../types';
 export { stripModuleSyntax, stripTjsPreamble } from './js-tests';
 export interface TJSTranspileOptions {
     /** Filename for error messages */
@@ -108,6 +108,14 @@ export interface TJSTranspileResult {
     metadata: Record<string, TJSTypeInfo>;
     /** Any warnings during transpilation */
     warnings?: string[];
+    /**
+     * Per-`Type`/`Generic` predicate verification status: `verified` → compiled to
+     * a fuel-bounded, DoS-safe native guard; `!verified` → fell back to a plain
+     * function (valid, but not fuel-bounded / not safe on untrusted data — its
+     * `reason` is the verifier diagnostic). Unverified entries are also mirrored
+     * into `warnings`. Lets tools flag unverifiable predicates.
+     */
+    predicates?: PredicateVerification[];
     /** Generated test runner code (if tests were present) - DEPRECATED, tests now run at transpile time */
     testRunner?: string;
     /** Number of tests extracted */

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

@@ -25,12 +25,12 @@ import type { TranspileOptions, TranspileResult, FunctionSignature } from './typ
 export * from './types';
 export { parse, preprocess, extractTDoc, validateSingleFunction, extractFunctions, } from './parser';
 export { dialectForFilename, sourceKindForFilename, type Dialect, type SourceKind, } from './dialect';
-export { verifyPredicate, compilePredicate, suggest, effectfulFromAtoms, formatPredicateDiagnostics, PredicateFuelExhausted, type PredicateDiagnostic, type PredicateVerifyResult, type VerifyPredicateOptions, type CompilePredicateOptions, type Suggestion, type SuggestOptions, } from './predicate';
+export { verifyPredicate, compilePredicate, emitVerifiedPredicate, createPredicateEvaluator, suggest, effectfulFromAtoms, formatPredicateDiagnostics, PredicateFuelExhausted, type PredicateDiagnostic, type PredicateVerifyResult, type VerifyPredicateOptions, type CompilePredicateOptions, type EmitPredicateResult, type PredicateEvaluatorOptions, type Suggestion, type SuggestOptions, } from './predicate';
 export { compilePredicateSchema, validatePredicateSchema, type PredicateSchema, type SchemaError, type SchemaValidationResult, type PredicateSchemaOptions, } from './predicate-schema';
 export { transformFunction } from './emitters/ast';
 export { transpileToJS, stripModuleSyntax, stripTjsPreamble, type TJSTranspileOptions, type TJSTranspileResult, type TJSTypeInfo, } from './emitters/js';
 export { generateDTS, typeDescriptorToTS, type GenerateDTSOptions, } from './emitters/dts';
-export { fromTS, type FromTSOptions, type FromTSResult, } from './emitters/from-ts';
+export type { FromTSOptions, FromTSResult } from './emitters/from-ts';
 export * from './inference';
 export { Schema } from './schema';
 export { typeDescriptorToJSONSchema, exampleToJSONSchema, functionMetaToJSONSchema, type JSONSchemaObject, } from './json-schema';

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

@@ -5,6 +5,7 @@
  * These operate on raw source strings before Acorn parsing.
  */
 import type { WasmBlock, TestBlock } from './parser-types';
+import type { PredicateVerification } from './types';
 export declare function transformTryWithoutCatch(source: string): string;
 /**
  * Extract WASM blocks from source and replace with runtime dispatch code
@@ -144,12 +145,15 @@ export declare function transformIsOperators(source: string): string;
  */
 export declare function insertAsiProtection(source: string): string;
 /**
- * Transform == and != to Is() and IsNot() calls
+ * Transform == and != to Eq() and NotEq() calls
  *
  * In TJS normal mode:
- *   a == b   -> Is(a, b)     (structural equality)
- *   a != b   -> IsNot(a, b)  (structural inequality)
+ *   a == b   -> Eq(a, b)     (footgun-free ===: unwraps boxed primitives,
+ *                             null == undefined, but does NOT coerce types and
+ *                             is NOT structural — see PRINCIPLES/guides)
+ *   a != b   -> NotEq(a, b)
  *   a === b  -> a === b      (identity, unchanged)
+ * (For deep structural equality use the explicit `Is`/`IsNot` operators.)
  *
  * Uses a two-pass algorithm:
  * 1. Find all == and != positions (outside strings/comments/regex)
@@ -169,7 +173,7 @@ export declare function transformEqualityToStructural(source: string): string;
  *
  * When predicate + example: auto-generate type guard from example
  */
-export declare function transformTypeDeclarations(source: string): string;
+export declare function transformTypeDeclarations(source: string, report?: PredicateVerification[]): string;
 /**
  * Transform FunctionPredicate declarations
  *
@@ -203,7 +207,7 @@ export declare function transformFunctionPredicateDeclarations(source: string):
  *   const Pair = Generic(['T', 'U'], (obj, checkT, checkU) => { ... }, '...')
  *   const Container = Generic(['T', ['U', '']], (obj, checkT, checkU) => { ... }, '...')
  */
-export declare function transformGenericDeclarations(source: string): string;
+export declare function transformGenericDeclarations(source: string, report?: PredicateVerification[]): string;
 /**
  * Transform Union declarations
  *

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

@@ -5,6 +5,7 @@
  * Transform functions are in parser-transforms.ts, param processing in parser-params.ts.
  */
 import type { Program, FunctionDeclaration } from 'acorn';
+import type { PredicateVerification } from './types';
 export type { ParseOptions, WasmBlock, TestBlock, PreprocessOptions, TjsModes, } from './parser-types';
 import type { ParseOptions, WasmBlock, TestBlock, PreprocessOptions, TjsModes } from './parser-types';
 export { transformExtensionCalls } from './parser-transforms';
@@ -30,6 +31,7 @@ export declare function preprocess(source: string, options?: PreprocessOptions):
     polymorphicNames: Set<string>;
     extensions: Map<string, Set<string>>;
     letAnnotations: Map<string, string>;
+    predicates: PredicateVerification[];
 };
 /**
  * Parse source code into an Acorn AST

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

@@ -101,3 +101,63 @@ export interface CompilePredicateOptions extends VerifyPredicateOptions {
  * opt-in). Emission is offset-spliced source, not a full AJS-AST→JS codegen.
  */
 export declare function compilePredicate(source: string, exportNames: string[], opts?: CompilePredicateOptions): Record<string, (...args: any[]) => any>;
+export interface EmitPredicateResult {
+    /** True iff the cluster passed predicate-safety verification. */
+    safe: boolean;
+    /**
+     * When `safe`, a self-contained JS **expression** that evaluates to the guard
+     * function `(...args) => boolean`. Inline it directly into transpiler output —
+     * it carries its own fuel counter (no global `__fuel`, no runtime dependency
+     * on the predicate engine or the `PredicateFuelExhausted` class). Undefined
+     * when `!safe`.
+     */
+    code?: string;
+    /** Verifier diagnostics (the reasons, when `!safe`). */
+    diagnostics: PredicateDiagnostic[];
+}
+/**
+ * Verify a predicate cluster and, if safe, emit a **self-contained source
+ * expression** for its guard — the transpile-time counterpart to
+ * `compilePredicate` (which evals to live closures). This is what lets a
+ * verified `Type`/`FunctionPredicate` predicate compile to a fuel-bounded native
+ * guard in standalone output: no import of this module, no shared runtime.
+ *
+ * Fuel model mirrors `compilePredicate` (function-entry `__fuel()` bounds all
+ * iteration since loops are rejected), but because a guard answers a boolean
+ * question, a runaway input **returns `false`** ("not a valid instance of this
+ * type") instead of throwing — DoS-safe validation that never crashes the caller.
+ * A deep-recursion stack overflow is the same runaway signal, normalized the
+ * same way.
+ *
+ * The runtime effectful-global shadow that `compilePredicate` applies is omitted
+ * here on purpose: a `safe` cluster provably references no effectful global (the
+ * static verifier guarantees it), so the shadow would only bloat emitted output.
+ *
+ * @param source      the predicate cluster (one or more `function` declarations)
+ * @param entryName   which declared function is the guard entry point
+ * @param opts        verify options + `fuel` budget (default 1,000,000)
+ */
+export declare function emitVerifiedPredicate(source: string, entryName: string, opts?: CompilePredicateOptions): EmitPredicateResult;
+export interface PredicateEvaluatorOptions extends CompilePredicateOptions {
+    /**
+     * Called once per source that fails to verify/compile. Default: `console.warn`.
+     * The evaluator fails **closed** on such a source (returns `false`), so an
+     * unverifiable `$predicate` can never validate a value as `true`.
+     */
+    onUnsafe?: (source: string, error: Error) => void;
+}
+/**
+ * Build a pluggable `$predicate` evaluator: `(source, value) => boolean`.
+ *
+ * This is the bridge for a predicate-aware JSON-Schema validator that lives in
+ * another package (e.g. `tosijs-schema`, which cannot depend on `tjs-lang` — the
+ * dependency runs the other way). Such a validator stays zero-dep and exposes a
+ * hook; a consumer that has this engine injects an evaluator built here.
+ *
+ * Each distinct source is verified + compiled **once** and cached, so repeated
+ * validation is just a native call. Semantics match `compilePredicateSchema`:
+ * the LAST top-level function is the entry; a source that isn't predicate-safe
+ * (or throws / exhausts fuel at runtime) yields `false` — never a thrown error
+ * mid-validation, never a silent pass.
+ */
+export declare function createPredicateEvaluator(opts?: PredicateEvaluatorOptions): (source: string, value: unknown) => boolean;

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

@@ -12,9 +12,10 @@
 export { transpile, ajs, tjs, createAgent, getToolDefinitions } from './core';
 export { parse, preprocess, extractTDoc } from './parser';
 export { dialectForFilename, sourceKindForFilename, type Dialect, type SourceKind, } from './dialect';
-export { verifyPredicate, compilePredicate, suggest, effectfulFromAtoms, formatPredicateDiagnostics, PredicateFuelExhausted, type PredicateDiagnostic, type PredicateVerifyResult, type VerifyPredicateOptions, type CompilePredicateOptions, type Suggestion, type SuggestOptions, } from './predicate';
+export { verifyPredicate, compilePredicate, emitVerifiedPredicate, createPredicateEvaluator, suggest, effectfulFromAtoms, formatPredicateDiagnostics, PredicateFuelExhausted, type PredicateDiagnostic, type PredicateVerifyResult, type VerifyPredicateOptions, type CompilePredicateOptions, type EmitPredicateResult, type PredicateEvaluatorOptions, type Suggestion, type SuggestOptions, } from './predicate';
 export { compilePredicateSchema, validatePredicateSchema, type PredicateSchema, type SchemaError, type SchemaValidationResult, type PredicateSchemaOptions, } from './predicate-schema';
 export { transformFunction } from './emitters/ast';
+export { generateDTS, typeDescriptorToTS, type GenerateDTSOptions, } from './emitters/dts';
 export { transpileToJS } from './emitters/js';
 export type { TJSTranspileOptions, TJSTranspileResult, TJSTypeInfo, } from './emitters/js';
 export * from './inference';
@@ -25,4 +26,4 @@ export { extractTests, assertFunction, expectFunction, testUtils, } from './test
 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';
+export type { TypeDescriptor, ParameterDescriptor, FunctionSignature, TranspileOptions, TranspileResult, TranspileWarning, PredicateVerification, } from './types';

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

@@ -77,6 +77,22 @@ export interface TranspileWarning {
     column: number;
     source?: string;
 }
+/**
+ * Per-declaration report of whether a `Type`/`Generic` predicate body verified
+ * as predicate-safe (→ compiled to a fuel-bounded, DoS-safe native guard) or
+ * fell back to a plain unverified function (still valid — TJS ⊇ JS — but not
+ * fuel-bounded or safe to run on untrusted data). Surfaced on the transpile
+ * result so tools can flag unverifiable predicates.
+ */
+export interface PredicateVerification {
+    /** The `Type` / `Generic` declaration name. */
+    name: string;
+    kind: 'Type' | 'Generic';
+    /** True → verified + compiled to a native guard; false → raw-function fallback. */
+    verified: boolean;
+    /** When `!verified`, the verifier's reason(s). */
+    reason?: string;
+}
 /** Source map for debugging */
 export interface SourceMap {
     version: 3;

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

@@ -0,0 +1,12 @@
+import { type PredicateEvaluatorOptions } from '../lang/predicate';
+export * from 'tosijs-schema';
+export { createPredicateEvaluator, type PredicateEvaluatorOptions, } from '../lang/predicate';
+/**
+ * Register tjs-lang's predicate engine as tosijs-schema's `$predicate` evaluator.
+ * Called automatically when this module is imported; exposed so callers can
+ * re-install with custom {@link PredicateEvaluatorOptions} (e.g. a smaller fuel
+ * budget, or an atom-aware effectful set) after opting out.
+ */
+export declare function installPredicateSupport(opts?: PredicateEvaluatorOptions): void;
+/** True once predicate support has been installed (and not since cleared). */
+export declare function predicateSupportInstalled(): boolean;