@omgbase/core 0.1.0

package/dist/src/search/cel/ast.d.ts

@@ -0,0 +1,74 @@
+export type Node = Or | And | Not | Comparison | Membership | OuterMembership | Call | MethodCall | Quantifier | FieldRef | OuterRef | Literal;
+export interface Or {
+    kind: "or";
+    left: Node;
+    right: Node;
+}
+export interface And {
+    kind: "and";
+    left: Node;
+    right: Node;
+}
+export interface Not {
+    kind: "not";
+    operand: Node;
+}
+export type RelOp = "==" | "!=" | "<" | "<=" | ">" | ">=";
+export interface Comparison {
+    kind: "comparison";
+    op: RelOp;
+    left: Node;
+    right: Node;
+}
+/** literal in list(field) */
+export interface Membership {
+    kind: "membership";
+    value: Literal;
+    field: FieldRef;
+}
+/** value in ^name — membership over a one-scope-outward collection binding (a
+ * lift). `value` is the current scope's operand (a field/value/literal); the
+ * collection is resolved from the enclosing scope. */
+export interface OuterMembership {
+    kind: "outerMembership";
+    value: Node;
+    collection: OuterRef;
+}
+/** ^name — a reference to a binding one query scope outward (OQX correlation).
+ * Resolved by the compiler against the AliasCtx's outer-binding resolver. */
+export interface OuterRef {
+    kind: "outerref";
+    name: string;
+}
+/** free-standing call: ident(args) — e.g. under("x"), has(field), size(x) */
+export interface Call {
+    kind: "call";
+    name: string;
+    args: Node[];
+}
+/** method call: receiver.name(args) — e.g. x.contains("s") */
+export interface MethodCall {
+    kind: "method";
+    receiver: Node;
+    name: string;
+    args: Node[];
+}
+/** collection.exists(v, pred) / .all(v, pred) over list() or graph predicates */
+export interface Quantifier {
+    kind: "quantifier";
+    collection: Node;
+    op: "exists" | "all";
+    varName: string;
+    predicate: Node;
+}
+/** dotted field path; `$` set when intrinsic ($id, $path, doc.$path handled by segments) */
+export interface FieldRef {
+    kind: "field";
+    segments: string[];
+    intrinsic: boolean;
+}
+export interface Literal {
+    kind: "literal";
+    value: string | number | boolean | null;
+    type: "string" | "int" | "double" | "bool" | "null";
+}

package/dist/src/search/cel/ast.js

@@ -0,0 +1,3 @@
+// AST for the CEL subset (query-language §3.1).
+export {};
+//# sourceMappingURL=ast.js.map

package/dist/src/search/cel/compile.d.ts

@@ -0,0 +1,60 @@
+import type { Node } from "./ast.js";
+export type Target = "docs" | "blocks" | "nodes" | "edges";
+export interface AliasCtx {
+    self: string;
+    doc: string;
+    /** Resolver for `^name` one-scope-outward references (OQX correlation). OQX
+     * supplies it per nested scope; the base `query` surface leaves it undefined,
+     * so a `^name` reaching an absent resolver is a loud error. */
+    outer?: OuterResolver;
+    /** Resolver for `semantic("phrase")` — maps the phrase to a pre-computed query
+     * vector (BLOB) + its model. OQX's async runner embeds the literals and
+     * supplies this; when absent (or the phrase is unresolved) `semantic(...)` is a
+     * loud `semantic_unavailable`. The language stays provider-free: the function
+     * takes a string, the runtime supplies the embedding. */
+    semantic?: SemanticResolver;
+    /** Recursion-intrinsic columns for a `follow` query's post-walk scope. When
+     * set, `$depth`/`$stop`/`$leaf`/`$frontier` resolve to these PARAM-FREE column
+     * expressions (references into the `walked` CTE) instead of the per-target
+     * meaning — so recursion metadata is queryable in select/order by. On the
+     * blocks target this shadows `$depth` (which otherwise means block nesting
+     * depth). OQX only sets it for the post-walk scope of a follow query. */
+    recur?: RecurCtx;
+}
+/** SQL-expression strings for the recursion intrinsics (all param-free column
+ * references into the `walked` CTE). See AliasCtx.recur. */
+export interface RecurCtx {
+    depth: string;
+    stop: string;
+    leaf: string;
+    frontier: string;
+    /** deterministic rank over admitted occurrences, ordered by (depth, path). */
+    ordinal: string;
+}
+export interface OuterBinding {
+    scalar?: () => {
+        expr: string;
+        params: unknown[];
+    };
+    collection?: () => {
+        expr: string;
+        params: unknown[];
+    };
+}
+export type OuterResolver = (name: string) => OuterBinding | undefined;
+export interface SemanticVec {
+    vec: Buffer;
+    model: string;
+}
+export type SemanticResolver = (phrase: string) => SemanticVec | undefined;
+export declare function defaultCtx(target: Target): AliasCtx;
+export declare function scalarValue(node: Node, target: Target, ctx?: AliasCtx): {
+    expr: string;
+    params: unknown[];
+};
+export declare function compile(node: Node, target: Target, ctx?: AliasCtx): Compiled;
+export declare function topOrdinal(self: string): string;
+export interface Compiled {
+    sql: string;
+    params: unknown[];
+}