@reifydb/core 0.9.0 → 0.9.2

package/dist/index.js

@@ -1,5 +1,21 @@
 // src/constant.ts
 var NONE_VALUE = "\u27EAnone\u27EB";
+var NONE_MARKER_OPEN = NONE_VALUE.slice(0, -1);
+var NONE_MARKER_CLOSE = NONE_VALUE.slice(-1);
+function noneMarker(depth) {
+  return depth === 0 ? NONE_VALUE : `${NONE_MARKER_OPEN}:${depth}${NONE_MARKER_CLOSE}`;
+}
+function noneMarkerDepth(payload) {
+  if (payload === NONE_VALUE) {
+    return 0;
+  }
+  if (!payload.startsWith(`${NONE_MARKER_OPEN}:`) || !payload.endsWith(NONE_MARKER_CLOSE)) {
+    return void 0;
+  }
+  const digits = payload.slice(NONE_MARKER_OPEN.length + 1, -NONE_MARKER_CLOSE.length);
+  return /^[1-9][0-9]*$/.test(digits) ? Number(digits) : void 0;
+}
+var ROW_NUMBER_KEY = "#rownum";
 
 // src/value/blob.ts
 var BlobValue = class _BlobValue {
@@ -461,13 +477,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 +685,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 +893,7 @@ var DateTimeValue = class _DateTimeValue {
   /**
    * Get Unix timestamp in seconds
    */
-  to_epoch_secs() {
+  toEpochSecs() {
     const date = this.valueOf();
     if (date === void 0) return void 0;
     return Math.floor(date.getTime() / 1e3);
@@ -995,19 +1011,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 +1883,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 +1915,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) {
@@ -2285,11 +2301,151 @@ var NoneValue = class _NoneValue {
   }
   encode() {
     return {
-      type: "None",
+      type: { Option: this.innerType },
       value: NONE_VALUE
     };
   }
 };
+function noneDepth(v) {
+  return optionDepth(v.innerType) + 1;
+}
+
+// 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/value/option.ts
+function describeType(t) {
+  return isOptionType(t) ? `Option(${describeType(t.Option)})` : t;
+}
+function hasType(value) {
+  return typeof value === "object" && value !== null && "type" in value;
+}
+function hasToJSON(value) {
+  return typeof value === "object" && value !== null && "toJSON" in value && typeof value.toJSON === "function";
+}
+var OPTION_BRAND = /* @__PURE__ */ Symbol.for("reifydb.option");
+function isOption(value) {
+  return typeof value === "object" && value !== null && value[OPTION_BRAND] === true;
+}
+var _a;
+_a = OPTION_BRAND;
+var _Option = class _Option {
+  constructor(state) {
+    this.state = state;
+    this[_a] = true;
+  }
+  static some(value) {
+    return new _Option({ some: true, value });
+  }
+  static none(inner) {
+    return new _Option({ some: false, inner });
+  }
+  isSome() {
+    return this.state.some;
+  }
+  isNone() {
+    return !this.state.some;
+  }
+  unwrap() {
+    if (this.state.some) {
+      return this.state.value;
+    }
+    throw new Error(`unwrap on a None of type ${describeType(this.state.inner)}`);
+  }
+  unwrapOr(fallback) {
+    return this.state.some ? this.state.value : fallback;
+  }
+  map(fn) {
+    return this.state.some ? _Option.some(fn(this.state.value)) : _Option.none(this.state.inner);
+  }
+  get type() {
+    if (!this.state.some) {
+      return { Option: this.state.inner };
+    }
+    if (hasType(this.state.value)) {
+      return { Option: this.state.value.type };
+    }
+    throw new Error(`Option.some over a raw ${typeof this.state.value} has no wire type`);
+  }
+  toString() {
+    return this.state.some ? String(this.state.value) : NONE_PRESENTATION.text;
+  }
+  toJSON() {
+    if (!this.state.some) {
+      return null;
+    }
+    return hasToJSON(this.state.value) ? this.state.value.toJSON() : this.state.value;
+  }
+};
+var Option = _Option;
 
 // src/value/utf8.ts
 var Utf8Value = class _Utf8Value {
@@ -2745,6 +2901,49 @@ var IdentityIdValue = class _IdentityIdValue {
   }
 };
 
+// src/value/wire-type.ts
+function typeToWire(type) {
+  return isOptionType(type) ? { id: "Option", underlying: typeToWire(type.Option) } : { id: type };
+}
+function typeFromWire(wire) {
+  if (!wire || typeof wire !== "object" || typeof wire.id !== "string") {
+    throw new Error(`Expected a type descriptor object, got ${JSON.stringify(wire)}`);
+  }
+  if (wire.id === "Option") {
+    if (!wire.underlying) {
+      throw new Error("Option type descriptor is missing its underlying type");
+    }
+    return { Option: typeFromWire(wire.underlying) };
+  }
+  return wire.id;
+}
+function columnsFromWire(columns) {
+  return columns.map((column) => ({ ...column, type: typeFromWire(column.type) }));
+}
+function framesFromWire(frames) {
+  return frames.map(
+    (frame) => frame && frame.columns ? { ...frame, columns: columnsFromWire(frame.columns) } : frame
+  );
+}
+function envelopeToColumns(envelope) {
+  const types = envelope?.types ?? {};
+  const rows = envelope?.rows ?? [];
+  return Object.keys(types).map((name) => ({
+    name,
+    type: typeFromWire(types[name]),
+    payload: rows.map((row) => payloadOf(row?.[name]))
+  }));
+}
+function envelopesToFrames(envelopes) {
+  return Array.isArray(envelopes) ? envelopes.map((envelope) => ({ columns: envelopeToColumns(envelope) })) : [];
+}
+function payloadOf(value) {
+  if (value === null || value === void 0) {
+    return NONE_VALUE;
+  }
+  return typeof value === "string" ? value : String(value);
+}
+
 // src/value/index.ts
 function isOptionType(t) {
   return typeof t === "object" && t !== null && "Option" in t;
@@ -2753,17 +2952,30 @@ function unwrapOptionType(t) {
   if (isOptionType(t)) return unwrapOptionType(t.Option);
   return t;
 }
-var Value = class {
+function optionDepth(t) {
+  return isOptionType(t) ? optionDepth(t.Option) + 1 : 0;
+}
+function innerOfOption(t) {
+  return t.Option;
+}
+var Value2 = class {
 };
 
 // src/decoder.ts
+function stripOptionLayers(type, layers) {
+  return layers === 0 || !isOptionType(type) ? type : stripOptionLayers(innerOfOption(type), layers - 1);
+}
 function decode(pair) {
   if (isOptionType(pair.type)) {
-    const innerType = unwrapOptionType(pair.type);
-    if (pair.value === NONE_VALUE || pair.value === "") {
-      return new NoneValue(innerType);
+    const noneAt = noneMarkerDepth(pair.value);
+    if (noneAt === void 0) {
+      return decode({ type: unwrapOptionType(pair.type), value: pair.value });
+    }
+    const depth = optionDepth(pair.type);
+    if (noneAt >= depth) {
+      throw new Error(`none under ${noneAt} Some layers cannot fit an option of depth ${depth}`);
     }
-    return decode({ type: innerType, value: pair.value });
+    return new NoneValue(stripOptionLayers(pair.type, noneAt + 1));
   }
   switch (pair.type) {
     case "Blob":
@@ -2818,6 +3030,121 @@ 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, name = "$1") {
+  if (value === null || value === void 0) {
+    throw new Error(`parameter ${name} is null or undefined, use Option.none(inner)`);
+  }
+  if (value instanceof NoneValue && value.innerType === "None") {
+    throw new Error(`parameter ${name} is a NoneValue without an inner type, use Option.none(inner)`);
+  }
+  if (isOption(value)) {
+    if (value.isNone()) {
+      return { type: value.type, value: NONE_VALUE };
+    }
+    const inner = encodeValue(value.unwrap(), name);
+    const noneAt = noneMarkerDepth(inner.value);
+    return {
+      type: { Option: inner.type },
+      value: noneAt === void 0 ? inner.value : noneMarker(noneAt + 1)
+    };
+  }
+  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 toWire(pair) {
+  return { type: typeToWire(pair.type), value: pair.value };
+}
+function encodeParams(params) {
+  if (params === void 0 || params === null) {
+    return [];
+  }
+  if (Array.isArray(params)) {
+    return params.map((param, i) => toWire(encodeValue(param, `$${i + 1}`)));
+  } else if (typeof params === "object") {
+    const encoded = {};
+    for (const [key, value] of Object.entries(params)) {
+      encoded[key] = toWire(encodeValue(value, `$${key}`));
+    }
+    return encoded;
+  }
+  throw new Error(`Invalid parameters type: expected array or object, got ${typeof params}`);
+}
 
 // src/type-code.ts
 var TYPE_CODE = {
@@ -2857,7 +3184,7 @@ var TYPE_CODE = {
 var CODE_TO_NAME = Object.fromEntries(
   Object.entries(TYPE_CODE).map(([k, v]) => [v, k])
 );
-function type_name_from_code(code) {
+function typeNameFromCode(code) {
   const name = CODE_TO_NAME[code];
   if (!name) throw new Error(`Unknown type code: ${code}`);
   return name;
@@ -2964,8 +3291,8 @@ var ShapeBuilder = class {
   static array(items) {
     return { kind: "array", items };
   }
-  static optional(shape) {
-    return { kind: "optional", shape };
+  static option(inner) {
+    return { kind: "option", inner };
   }
   static number() {
     return { kind: "primitive", type: "Float8" };
@@ -3123,11 +3450,14 @@ function parseValue(shape, value) {
     }
     return value.map((item) => parseValue(shape.items, item));
   }
-  if (shape.kind === "optional") {
-    if (value === void 0) {
+  if (shape.kind === "option") {
+    if (value === null || value === void 0) {
       return void 0;
     }
-    return parseValue(shape.shape, value);
+    if (isOption(value)) {
+      return value.map((item) => parseValue(shape.inner, item));
+    }
+    return Option.some(parseValue(shape.inner, value));
   }
   if (shape.kind === "value") {
     if (value === null || value === void 0) {
@@ -3141,11 +3471,11 @@ function parseValue(shape, value) {
 // src/shape/validator.ts
 function validateShape(shape, value) {
   if (shape.kind === "primitive") {
-    const object_type = shape.type;
+    const objectType = shape.type;
     if (value === null || value === void 0) {
-      return object_type === "None";
+      return objectType === "None";
     }
-    switch (object_type) {
+    switch (objectType) {
       case "Boolean":
         return typeof value === "boolean";
       case "Float4":
@@ -3197,11 +3527,11 @@ function validateShape(shape, value) {
     }
     return value.every((item) => validateShape(shape.items, item));
   }
-  if (shape.kind === "optional") {
-    if (value === void 0) {
-      return true;
+  if (shape.kind === "option") {
+    if (!isOption(value)) {
+      return false;
     }
-    return validateShape(shape.shape, value);
+    return value.isNone() || validateShape(shape.inner, value.unwrap());
   }
   if (shape.kind === "value") {
     if (value === null || value === void 0) {
@@ -3215,6 +3545,752 @@ function validateShape(shape, value) {
   return false;
 }
 
+// src/shape/widen.ts
+var NUMERIC = {
+  Int1: { kind: "int", bits: 8 },
+  Int2: { kind: "int", bits: 16 },
+  Int4: { kind: "int", bits: 32 },
+  Int8: { kind: "int", bits: 64 },
+  Int16: { kind: "int", bits: 128 },
+  Uint1: { kind: "uint", bits: 8 },
+  Uint2: { kind: "uint", bits: 16 },
+  Uint4: { kind: "uint", bits: 32 },
+  Uint8: { kind: "uint", bits: 64 },
+  Uint16: { kind: "uint", bits: 128 },
+  Float4: { kind: "float", bits: 32 },
+  Float8: { kind: "float", bits: 64 }
+};
+function widens(target, actual) {
+  if (isOptionType(actual)) {
+    return false;
+  }
+  const t = NUMERIC[target];
+  const a = NUMERIC[actual];
+  if (!t || !a) {
+    return target === actual;
+  }
+  if (t.kind === "float" || a.kind === "float") {
+    return t.kind === "float" && a.kind === "float" && t.bits >= a.bits;
+  }
+  if (t.kind === "uint") {
+    return a.kind === "uint" && t.bits >= a.bits;
+  }
+  return a.kind === "int" ? t.bits >= a.bits : t.bits > a.bits;
+}
+function widen(value, target) {
+  if (!value || typeof value !== "object" || typeof value.type !== "string") {
+    return value;
+  }
+  const actual = value.type;
+  if (actual === target || !widens(target, actual)) {
+    return value;
+  }
+  const inner = value.value;
+  if (inner === void 0 || inner === null) {
+    return value;
+  }
+  return decode({ type: target, value: String(inner) });
+}
+
+// src/shape/check.ts
+var ShapeMismatch = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ShapeMismatch";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+function checkFrames(frames, shapes) {
+  if (shapes.length === 0) {
+    return;
+  }
+  if (frames.length !== shapes.length) {
+    throw new ShapeMismatch(`expected ${shapes.length} frames for ${shapes.length} shapes, got ${frames.length}`);
+  }
+  frames.forEach((frame, i) => checkFrame(frame.columns, shapes[i]));
+}
+function checkFrame(columns, shape) {
+  if (shape.kind !== "object") {
+    throw new ShapeMismatch(`a frame needs an object shape, got ${shape.kind}`);
+  }
+  for (const [name, propertyShape] of Object.entries(shape.properties)) {
+    const column = columns.find((c) => c.name === name);
+    if (!column) {
+      throw new ShapeMismatch(`column "${name}": expected ${describe(propertyShape)}, missing from frame`);
+    }
+    if (!matches(propertyShape, column.type)) {
+      throw new ShapeMismatch(`column "${name}": expected ${describe(propertyShape)}, got ${typeName2(column.type)}`);
+    }
+  }
+}
+var FAMILIES = [
+  ["Boolean"],
+  ["Int1", "Int2", "Int4", "Int8", "Int16", "Uint1", "Uint2", "Uint4", "Uint8", "Uint16", "Float4", "Float8"],
+  ["Utf8", "Decimal", "Duration", "Uuid4", "Uuid7", "IdentityId"],
+  ["Date", "DateTime", "Time"],
+  ["Blob"],
+  ["None"]
+];
+function familyOf(type) {
+  return FAMILIES.find((family) => family.includes(type)) ?? [type];
+}
+function matches(shape, type) {
+  switch (shape.kind) {
+    case "primitive":
+      if (shape.type === "None") {
+        return type === "None" || isOptionType(type);
+      }
+      return !isOptionType(type) && familyOf(shape.type).includes(type);
+    case "value":
+      if (shape.type === "None") {
+        return type === "None" || isOptionType(type);
+      }
+      return type === shape.type || widens(shape.type, type);
+    case "option":
+      return isOptionType(type) && matches(shape.inner, type.Option);
+    case "object":
+    case "array":
+      return false;
+  }
+}
+function describe(shape) {
+  switch (shape.kind) {
+    case "primitive":
+    case "value":
+      return shape.type;
+    case "option":
+      return `Option(${describe(shape.inner)})`;
+    case "object":
+    case "array":
+      return shape.kind;
+  }
+}
+function typeName2(type) {
+  return isOptionType(type) ? `Option(${typeName2(type.Option)})` : type;
+}
+
+// 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] = widen(value, propertyShape.type);
+      } 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 widen(row, resultShape.type);
+  }
+  if (resultShape && resultShape.kind === "array") {
+    if (Array.isArray(row)) {
+      return row.map((item) => transformResult(item, resultShape.items));
+    }
+    return row;
+  }
+  if (resultShape && resultShape.kind === "option") {
+    if (row instanceof NoneValue) {
+      const remaining = optionLayers(resultShape);
+      const depth = noneDepth(row);
+      if (depth > remaining) {
+        throw new ShapeMismatch(`a none ${depth} layers deep does not fit a shape with ${remaining} option layers`);
+      }
+      if (depth === remaining) {
+        return Option.none(row.innerType);
+      }
+    }
+    return Option.some(transformResult(row, resultShape.inner));
+  }
+  return row;
+}
+function optionLayers(shape) {
+  return shape.kind === "option" ? optionLayers(shape.inner) + 1 : 0;
+}
+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/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 NUMERIC2 = ["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,
+  ...NUMERIC2,
+  ...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) {
@@ -3261,11 +4337,20 @@ export {
   Int2Value,
   Int4Value,
   Int8Value,
+  NONE_PRESENTATION,
   NONE_VALUE,
   NoneValue,
+  Option,
+  ROW_NUMBER_KEY,
+  RQL_KEYWORDS,
+  RQL_LITERALS,
+  RQL_OPERATORS,
+  RQL_SYSTEM_COLUMNS,
+  RQL_TYPES,
   ReifyError,
   Shape,
   ShapeBuilder,
+  ShapeMismatch,
   TYPE_CODE,
   TimeValue,
   Uint16Value,
@@ -3276,13 +4361,43 @@ export {
   Utf8Value,
   Uuid4Value,
   Uuid7Value,
-  Value,
+  Value2 as Value,
   asFrameResults,
+  cellText,
+  checkFrame,
+  checkFrames,
+  columnsFromWire,
+  columnsToRows,
   decode,
+  displayWidth,
+  encodeParams,
+  encodeValue,
+  envelopeToColumns,
+  envelopesToFrames,
+  formatValue,
+  framesFromWire,
+  graphemeWidth,
+  inferColumns,
+  innerOfOption,
+  isOption,
   isOptionType,
+  noneDepth,
+  noneMarker,
+  noneMarkerDepth,
+  optionDepth,
+  padToWidth,
   parseValue,
-  type_name_from_code,
+  planTable,
+  tokenizeRql,
+  transformFrames,
+  transformResult,
+  truncateToWidth,
+  typeFromWire,
+  typeNameFromCode,
+  typeToWire,
   unwrapOptionType,
-  validateShape
+  validateShape,
+  valueRole,
+  valueTypeName
 };
 //# sourceMappingURL=index.js.map