tjs-lang 0.8.3 → 0.8.4

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

@@ -0,0 +1,13 @@
+/**
+ * The CSS torture set — predicates for the exact cases where TS structural
+ * types and JSON Schema cave to `string`/`any`:
+ *   - open value grammars: var(), calc(), !important
+ *   - order-flexible shorthands: the `animation` family (tokenize + classify)
+ *   - open recursive structure: nested selectors / keyframes (recurse)
+ *
+ * Written in named-composition style — no inline arrows, no IO, no async —
+ * so it reads as "synchronous AJS" and verifies predicate-safe. `||` composition
+ * and `.every(namedPredicate)` are natural here because predicates run as native
+ * JS (the verified fast path), not through the sandboxed VM interpreter.
+ */
+export declare const CSS_PREDICATE_SOURCE: string;

package/dist/experiments/predicates/verify.d.ts

@@ -0,0 +1,39 @@
+export interface PredicateDiagnostic {
+    predicate: string;
+    message: string;
+    line: number;
+    column: number;
+}
+export interface VerifyResult {
+    safe: boolean;
+    predicates: string[];
+    diagnostics: PredicateDiagnostic[];
+}
+/**
+ * Build the effectful-name set from a VM atom registry: every atom tagged
+ * `effects: 'io'` (plus the non-atom globals). This is how the predicate
+ * verifier consumes the atom-effects classification.
+ */
+export declare function effectfulFrom(atoms: Record<string, {
+    op?: string;
+    effects?: 'pure' | 'io';
+}>): Set<string>;
+/**
+ * Verify every top-level function in `source` is predicate-safe. Because safety
+ * is a closure property, the whole cluster is safe iff each function is — so the
+ * transitive check is automatic: a call to another function in the set is fine,
+ * a call to anything effectful/unknown is not.
+ */
+export declare function verifyPredicates(source: string, opts?: {
+    effectful?: Set<string>;
+}): VerifyResult;
+/** Format diagnostics for a thrown error / log. */
+export declare function formatDiagnostics(d: PredicateDiagnostic[]): string;
+/**
+ * Verify, then compile the predicate cluster to native synchronous JS functions.
+ * Throws (with located diagnostics) at "definition time" if not predicate-safe —
+ * so an IO-using "predicate" never even compiles.
+ */
+export declare function compilePredicates(source: string, exports: string[], opts?: {
+    effectful?: Set<string>;
+}): Record<string, (...args: any[]) => any>;