@reifydb/core 0.8.1 → 0.9.1

package/dist/index.js

@@ -1,5 +1,6 @@
 // src/constant.ts
 var NONE_VALUE = "\u27EAnone\u27EB";
+var ROW_NUMBER_KEY = "#rownum";
 
 // src/value/blob.ts
 var BlobValue = class _BlobValue {
@@ -461,13 +462,13 @@ var DateValue = class _DateValue {
    * Helper to parse YYYY-MM-DD format
    */
   static parseDate(str) {
-    const match = str.match(/^(-?\d{1,4})-(\d{2})-(\d{2})$/);
-    if (!match) {
+    const match2 = str.match(/^(-?\d{1,4})-(\d{2})-(\d{2})$/);
+    if (!match2) {
       return null;
     }
-    const year = parseInt(match[1], 10);
-    const month = parseInt(match[2], 10);
-    const day = parseInt(match[3], 10);
+    const year = parseInt(match2[1], 10);
+    const month = parseInt(match2[2], 10);
+    const day = parseInt(match2[3], 10);
     if (month < 1 || month > 12) {
       return null;
     }
@@ -669,16 +670,16 @@ var _TimeValue = class _TimeValue {
    * Helper to parse HH:MM:SS[.nnnnnnnnn] format
    */
   static parseTime(str) {
-    const match = str.match(/^(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,9}))?$/);
-    if (!match) {
+    const match2 = str.match(/^(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,9}))?$/);
+    if (!match2) {
       return null;
     }
-    const hour = parseInt(match[1], 10);
-    const minute = parseInt(match[2], 10);
-    const second = parseInt(match[3], 10);
+    const hour = parseInt(match2[1], 10);
+    const minute = parseInt(match2[2], 10);
+    const second = parseInt(match2[3], 10);
     let nano = 0;
-    if (match[4]) {
-      const fracStr = match[4].padEnd(9, "0").substring(0, 9);
+    if (match2[4]) {
+      const fracStr = match2[4].padEnd(9, "0").substring(0, 9);
       nano = parseInt(fracStr, 10);
     }
     if (hour < 0 || hour > 23) {
@@ -877,7 +878,7 @@ var DateTimeValue = class _DateTimeValue {
   /**
    * Get Unix timestamp in seconds
    */
-  timestamp() {
+  toEpochSecs() {
     const date = this.valueOf();
     if (date === void 0) return void 0;
     return Math.floor(date.getTime() / 1e3);
@@ -995,19 +996,19 @@ var DateTimeValue = class _DateTimeValue {
    * Helper to parse ISO 8601 datetime format
    */
   static parseDateTime(str) {
-    const match = str.match(/^(-?\d{1,4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,9}))?Z$/);
-    if (!match) {
+    const match2 = str.match(/^(-?\d{1,4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,9}))?Z$/);
+    if (!match2) {
       return null;
     }
-    const year = parseInt(match[1], 10);
-    const month = parseInt(match[2], 10);
-    const day = parseInt(match[3], 10);
-    const hour = parseInt(match[4], 10);
-    const minute = parseInt(match[5], 10);
-    const second = parseInt(match[6], 10);
+    const year = parseInt(match2[1], 10);
+    const month = parseInt(match2[2], 10);
+    const day = parseInt(match2[3], 10);
+    const hour = parseInt(match2[4], 10);
+    const minute = parseInt(match2[5], 10);
+    const second = parseInt(match2[6], 10);
     let nanosFraction = 0n;
-    if (match[7]) {
-      const fracStr = match[7].padEnd(9, "0").substring(0, 9);
+    if (match2[7]) {
+      const fracStr = match2[7].padEnd(9, "0").substring(0, 9);
       nanosFraction = BigInt(fracStr);
     }
     if (month < 1 || month > 12) {
@@ -1867,19 +1868,19 @@ var DurationValue = class _DurationValue {
    * Parse ISO 8601 duration format: P[n]Y[n]M[n]DT[n]H[n]M[n.n]S
    */
   static parseIsoDuration(str, negative) {
-    const match = str.match(/^P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$/);
-    if (!match) {
+    const match2 = str.match(/^P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$/);
+    if (!match2) {
       return null;
     }
-    if (!match[1] && !match[2] && !match[3] && !match[4] && !match[5] && !match[6]) {
+    if (!match2[1] && !match2[2] && !match2[3] && !match2[4] && !match2[5] && !match2[6]) {
       return null;
     }
-    const years = parseInt(match[1] || "0", 10);
-    const months = parseInt(match[2] || "0", 10);
-    const days = parseInt(match[3] || "0", 10);
-    const hours = parseInt(match[4] || "0", 10);
-    const minutes = parseInt(match[5] || "0", 10);
-    const secondsStr = match[6] || "0";
+    const years = parseInt(match2[1] || "0", 10);
+    const months = parseInt(match2[2] || "0", 10);
+    const days = parseInt(match2[3] || "0", 10);
+    const hours = parseInt(match2[4] || "0", 10);
+    const minutes = parseInt(match2[5] || "0", 10);
+    const secondsStr = match2[6] || "0";
     const secondsParts = secondsStr.split(".");
     const wholeSeconds = parseInt(secondsParts[0] || "0", 10);
     let fracNanos = 0n;
@@ -1899,22 +1900,22 @@ var DurationValue = class _DurationValue {
    */
   static parseHumanDuration(str, negative) {
     const pattern = /^(?:(\d+)y)?(?:(\d+)mo)?(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m(?!s|o))?(?:(\d+)s(?!$)?)?(?:(\d+)ms)?(?:(\d+)us)?(?:(\d+)ns)?$/;
-    const match = str.match(pattern);
-    if (!match) {
+    const match2 = str.match(pattern);
+    if (!match2) {
       return null;
     }
-    if (!match[1] && !match[2] && !match[3] && !match[4] && !match[5] && !match[6] && !match[7] && !match[8] && !match[9]) {
+    if (!match2[1] && !match2[2] && !match2[3] && !match2[4] && !match2[5] && !match2[6] && !match2[7] && !match2[8] && !match2[9]) {
       return null;
     }
-    const years = parseInt(match[1] || "0", 10);
-    const months = parseInt(match[2] || "0", 10);
-    const days = parseInt(match[3] || "0", 10);
-    const hours = parseInt(match[4] || "0", 10);
-    const minutes = parseInt(match[5] || "0", 10);
-    const seconds = parseInt(match[6] || "0", 10);
-    const ms = parseInt(match[7] || "0", 10);
-    const us = parseInt(match[8] || "0", 10);
-    const ns = parseInt(match[9] || "0", 10);
+    const years = parseInt(match2[1] || "0", 10);
+    const months = parseInt(match2[2] || "0", 10);
+    const days = parseInt(match2[3] || "0", 10);
+    const hours = parseInt(match2[4] || "0", 10);
+    const minutes = parseInt(match2[5] || "0", 10);
+    const seconds = parseInt(match2[6] || "0", 10);
+    const ms = parseInt(match2[7] || "0", 10);
+    const us = parseInt(match2[8] || "0", 10);
+    const ns = parseInt(match2[9] || "0", 10);
     const totalNanos = BigInt(hours) * 3600n * 1000000000n + BigInt(minutes) * 60n * 1000000000n + BigInt(seconds) * 1000000000n + BigInt(ms) * 1000000n + BigInt(us) * 1000n + BigInt(ns);
     const totalMonths = years * 12 + months;
     if (negative) {
@@ -2818,6 +2819,148 @@ function decode(pair) {
       throw new Error(`Unsupported type: ${pair.type}`);
   }
 }
+function columnsToRows(columns) {
+  const rowCount = columns[0]?.payload.length ?? 0;
+  return Array.from({ length: rowCount }, (_, i) => {
+    const row = {};
+    for (const col of columns) {
+      row[col.name] = decode({ type: col.type, value: col.payload[i] });
+    }
+    return row;
+  });
+}
+
+// src/encoder.ts
+function encodeValue(value) {
+  if (value === null || value === void 0) {
+    return { type: "None", value: NONE_VALUE };
+  }
+  if (value && typeof value === "object" && "encode" in value && typeof value.encode === "function") {
+    return value.encode();
+  }
+  if (typeof value === "boolean") {
+    return { type: "Boolean", value: value.toString() };
+  }
+  if (typeof value === "number") {
+    if (Number.isInteger(value)) {
+      if (value >= -128 && value <= 127) {
+        return { type: "Int1", value: value.toString() };
+      } else if (value >= -32768 && value <= 32767) {
+        return { type: "Int2", value: value.toString() };
+      } else if (value >= -2147483648 && value <= 2147483647) {
+        return { type: "Int4", value: value.toString() };
+      } else {
+        return { type: "Int8", value: value.toString() };
+      }
+    } else {
+      return { type: "Float8", value: value.toString() };
+    }
+  }
+  if (typeof value === "string") {
+    if (/^[0-9a-f]{8}-[0-9a-f]{4}-[47][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value)) {
+      const version4 = value[14];
+      if (version4 === "4") {
+        return { type: "Uuid4", value };
+      } else if (version4 === "7") {
+        return { type: "Uuid7", value };
+      }
+    }
+    return { type: "Utf8", value };
+  }
+  if (typeof value === "bigint") {
+    if (value >= BigInt(0)) {
+      if (value <= BigInt(255)) {
+        return { type: "Uint1", value: value.toString() };
+      } else if (value <= BigInt(65535)) {
+        return { type: "Uint2", value: value.toString() };
+      } else if (value <= BigInt(4294967295)) {
+        return { type: "Uint4", value: value.toString() };
+      } else if (value <= BigInt("18446744073709551615")) {
+        return { type: "Uint8", value: value.toString() };
+      } else {
+        return { type: "Uint16", value: value.toString() };
+      }
+    } else {
+      if (value >= BigInt("-9223372036854775808")) {
+        return { type: "Int8", value: value.toString() };
+      } else {
+        return { type: "Int16", value: value.toString() };
+      }
+    }
+  }
+  if (value instanceof Date) {
+    return { type: "DateTime", value: value.toISOString() };
+  }
+  if (value instanceof Uint8Array) {
+    const hex = Array.from(value).map((b) => b.toString(16).padStart(2, "0")).join("");
+    return { type: "Blob", value: "0x" + hex };
+  }
+  if (value instanceof ArrayBuffer) {
+    const uint8Array = new Uint8Array(value);
+    const hex = Array.from(uint8Array).map((b) => b.toString(16).padStart(2, "0")).join("");
+    return { type: "Blob", value: "0x" + hex };
+  }
+  throw new Error(`Cannot encode value of type ${typeof value}: ${value}`);
+}
+function encodeParams(params) {
+  if (params === void 0 || params === null) {
+    return [];
+  }
+  if (Array.isArray(params)) {
+    return params.map((param) => encodeValue(param));
+  } else if (typeof params === "object") {
+    const encoded = {};
+    for (const [key, value] of Object.entries(params)) {
+      encoded[key] = encodeValue(value);
+    }
+    return encoded;
+  }
+  throw new Error(`Invalid parameters type: expected array or object, got ${typeof params}`);
+}
+
+// src/type-code.ts
+var TYPE_CODE = {
+  None: 0,
+  Boolean: 1,
+  Float4: 2,
+  Float8: 3,
+  Int1: 4,
+  Int2: 5,
+  Int4: 6,
+  Int8: 7,
+  Int16: 8,
+  Utf8: 9,
+  Uint1: 10,
+  Uint2: 11,
+  Uint4: 12,
+  Uint8: 13,
+  Uint16: 14,
+  Date: 15,
+  DateTime: 16,
+  Time: 17,
+  Duration: 18,
+  IdentityId: 19,
+  Uuid4: 20,
+  Uuid7: 21,
+  Blob: 22,
+  Int: 23,
+  Uint: 24,
+  Decimal: 25,
+  Any: 26,
+  DictionaryId: 27,
+  Type: 28,
+  List: 29,
+  Record: 30,
+  Tuple: 31
+};
+var CODE_TO_NAME = Object.fromEntries(
+  Object.entries(TYPE_CODE).map(([k, v]) => [v, k])
+);
+function typeNameFromCode(code) {
+  const name = CODE_TO_NAME[code];
+  if (!name) throw new Error(`Unknown type code: ${code}`);
+  return name;
+}
 
 // src/shape/builder.ts
 var ShapeBuilder = class {
@@ -3097,11 +3240,11 @@ function parseValue(shape, value) {
 // src/shape/validator.ts
 function validateShape(shape, value) {
   if (shape.kind === "primitive") {
-    const shape_type = shape.type;
+    const objectType = shape.type;
     if (value === null || value === void 0) {
-      return shape_type === "None";
+      return objectType === "None";
     }
-    switch (shape_type) {
+    switch (objectType) {
       case "Boolean":
         return typeof value === "boolean";
       case "Float4":
@@ -3171,6 +3314,692 @@ function validateShape(shape, value) {
   return false;
 }
 
+// src/shape/transform.ts
+function snakeToCamel(key) {
+  return key.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function transformFrames(frames, shapes) {
+  const transformed = frames.map((frame, frameIndex) => {
+    const frameShape = shapes[frameIndex];
+    if (!frameShape) {
+      return frame;
+    }
+    return frame.map((row) => transformResult(row, frameShape));
+  });
+  return transformed;
+}
+function transformResult(row, resultShape) {
+  if (resultShape && resultShape.kind === "object" && resultShape.properties) {
+    const transformedRow = {};
+    for (const [key, value] of Object.entries(row)) {
+      const propertyShape = resultShape.properties[key];
+      const outputKey = snakeToCamel(key);
+      if (propertyShape && propertyShape.kind === "primitive") {
+        if (value && typeof value === "object" && typeof value.valueOf === "function") {
+          const rawValue = value.valueOf();
+          transformedRow[outputKey] = coerceToPrimitiveType(rawValue, propertyShape.type);
+        } else {
+          transformedRow[outputKey] = coerceToPrimitiveType(value, propertyShape.type);
+        }
+      } else if (propertyShape && propertyShape.kind === "value") {
+        transformedRow[outputKey] = value;
+      } else {
+        transformedRow[outputKey] = propertyShape ? transformResult(value, propertyShape) : value;
+      }
+    }
+    return transformedRow;
+  }
+  if (resultShape && resultShape.kind === "primitive") {
+    if (row && typeof row === "object" && typeof row.valueOf === "function") {
+      return coerceToPrimitiveType(row.valueOf(), resultShape.type);
+    }
+    return coerceToPrimitiveType(row, resultShape.type);
+  }
+  if (resultShape && resultShape.kind === "value") {
+    return row;
+  }
+  if (resultShape && resultShape.kind === "array") {
+    if (Array.isArray(row)) {
+      return row.map((item) => transformResult(item, resultShape.items));
+    }
+    return row;
+  }
+  if (resultShape && resultShape.kind === "optional") {
+    if (row === void 0) {
+      return void 0;
+    }
+    if (row === null) {
+      return null;
+    }
+    return transformResult(row, resultShape.shape);
+  }
+  return row;
+}
+function coerceToPrimitiveType(value, valueType) {
+  if (value === void 0 || value === null) {
+    return value;
+  }
+  const bigintTypes = ["Int8", "Int16", "Uint8", "Uint16"];
+  if (bigintTypes.includes(valueType)) {
+    if (typeof value === "bigint") {
+      return value;
+    }
+    if (typeof value === "number") {
+      return BigInt(Math.trunc(value));
+    }
+    if (typeof value === "string") {
+      return BigInt(value);
+    }
+  }
+  return value;
+}
+
+// src/present/value.ts
+var NONE_PRESENTATION = {
+  text: "none",
+  italic: true,
+  muted: true
+};
+var ROLE_BY_TYPE = {
+  None: "none",
+  Boolean: "boolean",
+  Int1: "number",
+  Int2: "number",
+  Int4: "number",
+  Int8: "number",
+  Int16: "number",
+  Uint1: "number",
+  Uint2: "number",
+  Uint4: "number",
+  Uint8: "number",
+  Uint16: "number",
+  Float4: "number",
+  Float8: "number",
+  Decimal: "number",
+  Date: "temporal",
+  DateTime: "temporal",
+  Time: "temporal",
+  Duration: "temporal",
+  Uuid4: "uuid",
+  Uuid7: "uuid",
+  IdentityId: "uuid",
+  Utf8: "string",
+  Blob: "blob"
+};
+function typeName(value) {
+  if (value === null || typeof value !== "object") return void 0;
+  const candidate = value.type;
+  return typeof candidate === "string" ? candidate : void 0;
+}
+function valueTypeName(value) {
+  if (value === null || value === void 0) return "None";
+  return typeName(value);
+}
+function valueRole(value) {
+  if (value === null || value === void 0) return "none";
+  const name = typeName(value);
+  if (name !== void 0) {
+    return ROLE_BY_TYPE[name] ?? "unknown";
+  }
+  switch (typeof value) {
+    case "number":
+    case "bigint":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "string":
+      return "string";
+    default:
+      return "unknown";
+  }
+}
+function formatValue(value) {
+  if (value === null || value === void 0) return NONE_PRESENTATION.text;
+  if (typeof value === "bigint") return value.toString();
+  if (typeof value === "object") {
+    const name = typeName(value);
+    if (name === "None") return NONE_PRESENTATION.text;
+    if (name !== void 0) return String(value);
+    return JSON.stringify(value) ?? String(value);
+  }
+  return String(value);
+}
+
+// src/present/width.ts
+var ZERO_WIDTH = [
+  [768, 879],
+  [1155, 1161],
+  [1425, 1469],
+  [1552, 1562],
+  [1611, 1631],
+  [3633, 3633],
+  [3636, 3642],
+  [3761, 3761],
+  [3764, 3769],
+  [8203, 8207],
+  [8400, 8447],
+  [65024, 65039],
+  [65056, 65071],
+  [65279, 65279]
+];
+var WIDE = [
+  [4352, 4447],
+  [9001, 9002],
+  [11904, 12350],
+  [12353, 13311],
+  [13312, 19903],
+  [19968, 40959],
+  [40960, 42191],
+  [43360, 43391],
+  [44032, 55203],
+  [63744, 64255],
+  [65040, 65049],
+  [65072, 65135],
+  [65280, 65376],
+  [65504, 65510],
+  [127744, 129535],
+  [129648, 129791],
+  [131072, 262141]
+];
+function inRanges(code, ranges) {
+  let low = 0;
+  let high = ranges.length - 1;
+  while (low <= high) {
+    const middle = low + high >> 1;
+    const [start, end] = ranges[middle];
+    if (code < start) high = middle - 1;
+    else if (code > end) low = middle + 1;
+    else return true;
+  }
+  return false;
+}
+function codePointWidth(code) {
+  if (code === 0) return 0;
+  if (code < 32 || code >= 127 && code < 160) return 0;
+  if (inRanges(code, ZERO_WIDTH)) return 0;
+  if (inRanges(code, WIDE)) return 2;
+  return 1;
+}
+function createSegmenter() {
+  if (typeof Intl === "undefined") return null;
+  const factory = Intl.Segmenter;
+  if (typeof factory !== "function") return null;
+  return new factory(void 0, { granularity: "grapheme" });
+}
+var segmenter = createSegmenter();
+function graphemes(text) {
+  if (segmenter !== null) {
+    return Array.from(segmenter.segment(text), (entry) => entry.segment);
+  }
+  return Array.from(text);
+}
+function graphemeWidth(grapheme) {
+  let width = 0;
+  for (const character of grapheme) {
+    width += codePointWidth(character.codePointAt(0) ?? 0);
+  }
+  return Math.min(width, 2);
+}
+function displayWidth(text) {
+  let width = 0;
+  for (const grapheme of graphemes(text)) {
+    width += graphemeWidth(grapheme);
+  }
+  return width;
+}
+function truncateToWidth(text, width, ellipsis = "\u2026") {
+  if (width <= 0) return "";
+  if (displayWidth(text) <= width) return text;
+  const markerWidth = displayWidth(ellipsis);
+  if (width <= markerWidth) return ellipsis.slice(0, width);
+  const budget = width - markerWidth;
+  let used = 0;
+  let result = "";
+  for (const grapheme of graphemes(text)) {
+    const next = graphemeWidth(grapheme);
+    if (used + next > budget) break;
+    result += grapheme;
+    used += next;
+  }
+  return result + ellipsis;
+}
+function padToWidth(text, width, align) {
+  const padding = width - displayWidth(text);
+  if (padding <= 0) return text;
+  if (align === "right") return " ".repeat(padding) + text;
+  if (align === "left") return text + " ".repeat(padding);
+  const left = Math.floor(padding / 2);
+  return " ".repeat(left) + text + " ".repeat(padding - left);
+}
+
+// src/present/table.ts
+var DEFAULT_MAX_COLUMN_WIDTH = 40;
+var DEFAULT_COLUMN_OVERHEAD = 3;
+var DEFAULT_TABLE_OVERHEAD = 1;
+function inferColumns(rows) {
+  const names = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    for (const name of Object.keys(row)) {
+      if (seen.has(name)) continue;
+      seen.add(name);
+      names.push(name);
+    }
+  }
+  return names.map((name) => {
+    let role = "unknown";
+    let type;
+    for (const row of rows) {
+      const value = row[name];
+      const candidate = valueRole(value);
+      if (candidate === "none" || candidate === "unknown") continue;
+      role = candidate;
+      type = valueTypeName(value);
+      break;
+    }
+    return { name, type, role, align: role === "number" ? "right" : "left" };
+  });
+}
+function planTable(rows, columns, options = {}) {
+  const maxColumnWidth = options.maxColumnWidth ?? DEFAULT_MAX_COLUMN_WIDTH;
+  const columnOverhead = options.columnOverhead ?? DEFAULT_COLUMN_OVERHEAD;
+  const tableOverhead = options.tableOverhead ?? DEFAULT_TABLE_OVERHEAD;
+  const sample = options.sample ?? rows.length;
+  const measured = rows.slice(0, Math.max(sample, 0));
+  let truncated = false;
+  const natural = columns.map((column) => {
+    let width = displayWidth(column.name);
+    for (const row of measured) {
+      width = Math.max(width, displayWidth(formatValue(row[column.name])));
+    }
+    if (width > maxColumnWidth) truncated = true;
+    return { column, width: Math.min(width, maxColumnWidth) };
+  });
+  if (options.width === void 0) {
+    return { columns: natural, dropped: [], truncated };
+  }
+  const planned = [];
+  const dropped = [];
+  let used = tableOverhead;
+  for (const entry of natural) {
+    const required = entry.width + columnOverhead;
+    if (planned.length > 0 && used + required > options.width) {
+      dropped.push(entry.column);
+      continue;
+    }
+    if (planned.length === 0 && used + required > options.width) {
+      const available = options.width - used - columnOverhead;
+      const width = Math.max(available, 1);
+      if (width < entry.width) truncated = true;
+      planned.push({ column: entry.column, width });
+      used += width + columnOverhead;
+      continue;
+    }
+    planned.push(entry);
+    used += required;
+  }
+  return { columns: planned, dropped, truncated };
+}
+function cellText(value, width) {
+  return truncateToWidth(formatValue(value), width);
+}
+
+// src/syntax/keyword.ts
+var QUERY_TRANSFORMS = [
+  "map",
+  "extend",
+  "by",
+  "from",
+  "where",
+  "aggregate",
+  "having",
+  "sort",
+  "distinct",
+  "take",
+  "offset"
+];
+var JOINS_AND_SET_OPERATIONS = [
+  "left",
+  "inner",
+  "natural",
+  "join",
+  "on",
+  "using",
+  "intersect",
+  "except"
+];
+var DML = ["insert", "into", "update", "set", "delete"];
+var CONTROL_FLOW = [
+  "let",
+  "if",
+  "else",
+  "end",
+  "loop",
+  "while",
+  "break",
+  "continue",
+  "return"
+];
+var FUNCTIONS_AND_CASTING = ["fun", "call", "apply", "cast"];
+var DDL_AND_SHAPE = [
+  "describe",
+  "show",
+  "create",
+  "alter",
+  "drop",
+  "filter",
+  "gate",
+  "flow",
+  "window",
+  "returning"
+];
+var OPERATOR_KEYWORDS = ["in", "between", "like", "is", "with"];
+var OBJECT_TYPES = [
+  "namespace",
+  "sequence",
+  "series",
+  "subscription",
+  "table",
+  "ringbuffer",
+  "column",
+  "policy",
+  "property",
+  "view",
+  "deferred",
+  "transactional"
+];
+var INDEX_AND_CONSTRAINTS = [
+  "index",
+  "unique",
+  "primary",
+  "key",
+  "asc",
+  "desc",
+  "auto",
+  "increment",
+  "value"
+];
+var MISC_OPERATIONS = [
+  "exists",
+  "replace",
+  "cascade",
+  "restrict",
+  "to",
+  "pause",
+  "resume",
+  "query",
+  "rename",
+  "rownum",
+  "dictionary",
+  "for",
+  "output",
+  "append",
+  "assert",
+  "patch"
+];
+var ENUMS_AND_PATTERN_MATCHING = ["enum", "match"];
+var PROCEDURES_AND_EVENTS = ["procedure", "event", "handler", "dispatch", "tag"];
+var TESTING = ["test", "tests", "run"];
+var ACCESS_CONTROL = [
+  "user",
+  "role",
+  "grant",
+  "revoke",
+  "password",
+  "require",
+  "execute",
+  "access",
+  "subscribe",
+  "enable",
+  "disable"
+];
+var SYSTEM_OBJECTS = ["function", "session", "feature"];
+var MIGRATIONS = [
+  "add",
+  "migration",
+  "migrate",
+  "rollback",
+  "diff",
+  "version",
+  "current",
+  "pending"
+];
+var MISC = ["authentication", "contains", "remote", "error"];
+var ADDITIONAL_CONSTRUCTS = ["derive", "group", "union", "as"];
+var WORD_OPERATORS = ["and", "or", "not", "xor"];
+var RQL_KEYWORDS = [
+  ...QUERY_TRANSFORMS,
+  ...JOINS_AND_SET_OPERATIONS,
+  ...DML,
+  ...CONTROL_FLOW,
+  ...FUNCTIONS_AND_CASTING,
+  ...DDL_AND_SHAPE,
+  ...OPERATOR_KEYWORDS,
+  ...OBJECT_TYPES,
+  ...INDEX_AND_CONSTRAINTS,
+  ...MISC_OPERATIONS,
+  ...ENUMS_AND_PATTERN_MATCHING,
+  ...PROCEDURES_AND_EVENTS,
+  ...TESTING,
+  ...ACCESS_CONTROL,
+  ...SYSTEM_OBJECTS,
+  ...MIGRATIONS,
+  ...MISC,
+  ...ADDITIONAL_CONSTRUCTS,
+  ...WORD_OPERATORS
+];
+var RQL_LITERALS = ["none", "true", "false"];
+var SIGNED_INTEGERS = ["int1", "int2", "int4", "int8", "int16", "int"];
+var UNSIGNED_INTEGERS = ["uint1", "uint2", "uint4", "uint8", "uint16", "uint"];
+var FLOATING_POINT = ["float4", "float8"];
+var TEXT_AND_BINARY = ["utf8", "blob", "text"];
+var BOOLEAN = ["bool", "boolean"];
+var NUMERIC = ["decimal"];
+var TEMPORAL = ["date", "datetime", "time", "duration", "interval"];
+var IDENTIFIERS_AND_UUIDS = [
+  "uuid4",
+  "uuid7",
+  "identityid",
+  "identity_id",
+  "dictionaryid",
+  "dictionary_id"
+];
+var CONTAINERS = ["Option", "List", "Record", "Tuple"];
+var RQL_TYPES = [
+  ...SIGNED_INTEGERS,
+  ...UNSIGNED_INTEGERS,
+  ...FLOATING_POINT,
+  ...TEXT_AND_BINARY,
+  ...BOOLEAN,
+  ...NUMERIC,
+  ...TEMPORAL,
+  ...IDENTIFIERS_AND_UUIDS,
+  ...CONTAINERS,
+  "any"
+];
+var RQL_OPERATORS = [
+  "+",
+  "-",
+  "*",
+  "/",
+  "//",
+  "%",
+  "=",
+  "==",
+  "!=",
+  "->",
+  "=>",
+  ">",
+  "<",
+  ">=",
+  "<=",
+  "~=",
+  "&&",
+  "||",
+  "??"
+];
+var RQL_SYSTEM_COLUMNS = ["rownum", "created_at", "updated_at"];
+
+// src/syntax/tokenizer.ts
+var KEYWORD_SET = new Set(RQL_KEYWORDS.map((entry) => entry.toLowerCase()));
+var LITERAL_SET = new Set(RQL_LITERALS.map((entry) => entry.toLowerCase()));
+var TYPE_SET = new Set(RQL_TYPES.map((entry) => entry.toLowerCase()));
+var SYSTEM_COLUMN = /#(?:rownum|created_at|updated_at)\b/y;
+var COMMENT = /#.*/y;
+var NAMESPACE_HEAD = /[a-zA-Z_][\w$]*(?=\s*::)/y;
+var NAMESPACE_SEPARATOR = /::/y;
+var NAMED_ARGUMENT = /\w+\s*:(?!:)/y;
+var VARIABLE = /\$[\w$]+/y;
+var CALL_NAME = /[a-zA-Z_][\w$]*(?=\s*\()/y;
+var WORD = /[a-zA-Z_][\w$]*/y;
+var WHITESPACE = /[ \t\r\n]+/y;
+var BRACKET = /[{}()[\]]/y;
+var NUMBER = /[+-]?(?:[\d_]+(?:\.[\d_]+)?|\.[\d_]+)(?:[eE][+-]?\d+)?/y;
+var OPERATOR = /<<|>>|\.\.|==|!=|->|=>|>=|<=|~=|:=|&&|\|\||\?\?|\/\/|[+\-*/%|.=<>!&^?]/y;
+var DELIMITER = /[;,]/y;
+function match(pattern, source, position) {
+  pattern.lastIndex = position;
+  const result = pattern.exec(source);
+  return result === null ? null : result[0];
+}
+function classifyWord(word) {
+  const lowered = word.toLowerCase();
+  if (KEYWORD_SET.has(lowered)) return "keyword";
+  if (LITERAL_SET.has(lowered)) return "constant";
+  if (TYPE_SET.has(lowered)) return "type";
+  return "identifier";
+}
+function classifyCall(word) {
+  const lowered = word.toLowerCase();
+  if (KEYWORD_SET.has(lowered)) return "keyword";
+  if (TYPE_SET.has(lowered)) return "type";
+  return "function";
+}
+function scanString(source, position) {
+  const quote = source[position];
+  let index = position + 1;
+  while (index < source.length) {
+    const char = source[index];
+    if (char === "\\") {
+      index += 2;
+      continue;
+    }
+    index++;
+    if (char === quote) break;
+  }
+  return Math.min(index, source.length);
+}
+function tokenizeRql(source) {
+  const tokens = [];
+  let position = 0;
+  let afterSeparator = false;
+  const push = (kind, end) => {
+    tokens.push({ kind, start: position, end });
+    position = end;
+  };
+  while (position < source.length) {
+    if (afterSeparator) {
+      const white2 = match(WHITESPACE, source, position);
+      if (white2 !== null) {
+        push("white", position + white2.length);
+        continue;
+      }
+      const chained = match(NAMESPACE_HEAD, source, position);
+      if (chained !== null) {
+        afterSeparator = false;
+        push("namespace", position + chained.length);
+        continue;
+      }
+      const called = match(CALL_NAME, source, position);
+      if (called !== null) {
+        afterSeparator = false;
+        push("function", position + called.length);
+        continue;
+      }
+      const leaf = match(WORD, source, position);
+      if (leaf !== null) {
+        afterSeparator = false;
+        push("entity", position + leaf.length);
+        continue;
+      }
+      afterSeparator = false;
+    }
+    const systemColumn = match(SYSTEM_COLUMN, source, position);
+    if (systemColumn !== null) {
+      push("variable.predefined", position + systemColumn.length);
+      continue;
+    }
+    const comment = match(COMMENT, source, position);
+    if (comment !== null) {
+      push("comment", position + comment.length);
+      continue;
+    }
+    const namespace = match(NAMESPACE_HEAD, source, position);
+    if (namespace !== null) {
+      push("namespace", position + namespace.length);
+      continue;
+    }
+    const separator = match(NAMESPACE_SEPARATOR, source, position);
+    if (separator !== null) {
+      afterSeparator = true;
+      push("operator", position + separator.length);
+      continue;
+    }
+    const namedArgument = match(NAMED_ARGUMENT, source, position);
+    if (namedArgument !== null) {
+      push("key", position + namedArgument.length);
+      continue;
+    }
+    const variable = match(VARIABLE, source, position);
+    if (variable !== null) {
+      push("variable", position + variable.length);
+      continue;
+    }
+    const call = match(CALL_NAME, source, position);
+    if (call !== null) {
+      push(classifyCall(call), position + call.length);
+      continue;
+    }
+    const word = match(WORD, source, position);
+    if (word !== null) {
+      push(classifyWord(word), position + word.length);
+      continue;
+    }
+    const white = match(WHITESPACE, source, position);
+    if (white !== null) {
+      push("white", position + white.length);
+      continue;
+    }
+    const bracket = match(BRACKET, source, position);
+    if (bracket !== null) {
+      push("bracket", position + bracket.length);
+      continue;
+    }
+    const number = match(NUMBER, source, position);
+    if (number !== null) {
+      push("number", position + number.length);
+      continue;
+    }
+    const char = source[position];
+    if (char === '"' || char === "'") {
+      push("string", scanString(source, position));
+      continue;
+    }
+    const operator = match(OPERATOR, source, position);
+    if (operator !== null) {
+      push("operator", position + operator.length);
+      continue;
+    }
+    const delimiter = match(DELIMITER, source, position);
+    if (delimiter !== null) {
+      push("delimiter", position + delimiter.length);
+      continue;
+    }
+    push("identifier", position + 1);
+  }
+  return tokens;
+}
+
 // src/types.ts
 var ReifyError = class extends Error {
   constructor(response) {
@@ -3217,11 +4046,19 @@ export {
   Int2Value,
   Int4Value,
   Int8Value,
+  NONE_PRESENTATION,
   NONE_VALUE,
   NoneValue,
+  ROW_NUMBER_KEY,
+  RQL_KEYWORDS,
+  RQL_LITERALS,
+  RQL_OPERATORS,
+  RQL_SYSTEM_COLUMNS,
+  RQL_TYPES,
   ReifyError,
   Shape,
   ShapeBuilder,
+  TYPE_CODE,
   TimeValue,
   Uint16Value,
   Uint1Value,
@@ -3233,10 +4070,27 @@ export {
   Uuid7Value,
   Value,
   asFrameResults,
+  cellText,
+  columnsToRows,
   decode,
+  displayWidth,
+  encodeParams,
+  encodeValue,
+  formatValue,
+  graphemeWidth,
+  inferColumns,
   isOptionType,
+  padToWidth,
   parseValue,
+  planTable,
+  tokenizeRql,
+  transformFrames,
+  transformResult,
+  truncateToWidth,
+  typeNameFromCode,
   unwrapOptionType,
-  validateShape
+  validateShape,
+  valueRole,
+  valueTypeName
 };
 //# sourceMappingURL=index.js.map