@reifydb/core 0.10.1 → 0.10.2

package/dist/index.d.ts

@@ -769,6 +769,7 @@ declare class Option<T> {
     readonly [OPTION_BRAND] = true;
     private constructor();
     static some<T>(value: T): Option<T>;
+    static from<T>(value: T | null | undefined, inner: Type): Option<T>;
     static none<T = never>(inner: Type): Option<T>;
     isSome(): boolean;
     isNone(): boolean;
@@ -795,6 +796,18 @@ declare class Utf8Value implements Value {
     encode(): TypeValuePair;
 }
 
+declare class EnumVariant implements Value {
+    readonly type: Type;
+    readonly enum: string;
+    readonly variant: string;
+    constructor(enumName: string, variant: string);
+    valueOf(): string;
+    toString(): string;
+    equals(other: Value): boolean;
+    toJSON(): string;
+    encode(): TypeValuePair;
+}
+
 /**
  * A UUID version 4 (random) value type
  */
@@ -1009,6 +1022,7 @@ interface WireType {
     accuracy?: number;
     precision?: number;
     scale?: number;
+    enum?: string;
 }
 declare function typeToWire(type: Type): WireType;
 declare function typeFromWire(wire: WireType): Type;
@@ -1068,12 +1082,16 @@ interface ListType {
 interface RecordType {
     Record: RecordField[];
 }
-type Type = BaseType | OptionType | DigestType | FixedPointType | ListType | RecordType;
+interface EnumType {
+    Enum: string;
+}
+type Type = BaseType | OptionType | DigestType | FixedPointType | ListType | RecordType | EnumType;
+declare function isEnumType(t: Type): t is EnumType;
 declare function isOptionType(t: Type): t is OptionType;
 declare function isDigestType(t: Type): t is DigestType;
 declare function isListType(t: Type): t is ListType;
 declare function isRecordType(t: Type): t is RecordType;
-declare function unwrapOptionType(t: Type): BaseType | DigestType | FixedPointType | ListType | RecordType;
+declare function unwrapOptionType(t: Type): BaseType | DigestType | FixedPointType | ListType | RecordType | EnumType;
 declare function optionDepth(t: Type): number;
 declare function innerOfOption(t: OptionType): Type;
 /** A wire cell: a JSON bool for Boolean, a plain string for every other scalar type, or a real JSON array/object for List/Record. */
@@ -1284,6 +1302,7 @@ interface ErrorResponse {
     type: "Err";
     payload: {
         diagnostic: Diagnostic;
+        index?: number;
     };
 }
 declare class ReifyError extends Error {
@@ -1295,7 +1314,8 @@ declare class ReifyError extends Error {
     readonly help?: string;
     readonly notes: string[];
     readonly cause?: Diagnostic;
-    constructor(response: ErrorResponse);
+    readonly index?: number;
+    constructor(response: Pick<ErrorResponse, "payload">);
     toString(): string;
 }
 /**
@@ -1355,6 +1375,7 @@ declare const TYPE_CODE: {
     readonly Record: 28;
     readonly Tuple: 29;
     readonly Digest: 30;
+    readonly Enum: 31;
 };
 type TypeName = keyof typeof TYPE_CODE;
 declare function typeNameFromCode(code: number): TypeName;
@@ -1416,4 +1437,4 @@ interface RqlToken {
 }
 declare function tokenizeRql(source: string): RqlToken[];
 
-export { type ArrayShapeNode, type BaseType, BlobValue, BooleanValue, type Column, type ColumnAlign, DECIMAL_DEFAULT_SCALE, DateTimeValue, DateValue, type DecimalType, DecimalValue, type Diagnostic, type DiagnosticColumn, type DigestInnerType, type DigestType, DigestValue, DurationValue, type ErrorResponse, FIXED_POINT_MAX_PRECISION, FIXED_POINT_NARROW_PRECISION, type FixedPointKind, type FixedPointType, Float4Value, Float8Value, type Fragment, type Frame, type FrameResults, IdentityIdValue, type InferShape, type InferShapes, Int16Value, Int1Value, Int2Value, Int4Value, Int8Value, type ListType, ListValue, type MissingPresentation, NONE_PRESENTATION, NONE_VALUE, NoneValue, type ObjectShapeNode, Option, type OptionShapeNode, type OptionType, type Params, type PlannedColumn, type PrimitiveShapeNode, type PrimitiveToTS, type PrimitiveToValue, ROW_NUMBER_KEY, RQL_KEYWORDS, RQL_LITERALS, RQL_OPERATORS, RQL_SYSTEM_COLUMNS, RQL_TYPES, type RecordField, type RecordType, RecordValue, ReifyError, type ResultColumn, type RqlToken, type RqlTokenKind, Shape, ShapeBuilder, ShapeMismatch, type ShapeNode, type SingleFrameResult, TYPE_CODE, type TableLayoutOptions, type TablePlan, TimeValue, type Type, type TypeName, type TypeValuePair, Uint16Value, Uint1Value, Uint2Value, Uint4Value, Uint8Value, Utf8Value, Uuid4Value, Uuid7Value, Value, type ValueRole, type ValueShapeNode, type WireCellValue, type WireType, asFrameResults, cellText, checkFrame, checkFrames, columnsFromWire, columnsToRows, decimalType, decode, digestType, digestTypeName, displayWidth, encodeParams, encodeValue, envelopeToColumns, envelopesToFrames, fixedPointKind, fixedPointPrecision, fixedPointScale, fixedPointType, fixedPointTypeName, formatValue, framesFromWire, graphemeWidth, inferColumns, innerOfOption, isDigestType, isFixedPointType, isListType, isOption, isOptionType, isRecordType, noneDepth, noneMarker, noneMarkerDepth, optionDepth, padToWidth, parseValue, planTable, tokenizeRql, transformFrames, transformResult, truncateToWidth, typeFromWire, typeNameFromCode, typeToWire, unwrapOptionType, validateShape, valueRole, valueTypeName };
+export { type ArrayShapeNode, type BaseType, BlobValue, BooleanValue, type Column, type ColumnAlign, DECIMAL_DEFAULT_SCALE, DateTimeValue, DateValue, type DecimalType, DecimalValue, type Diagnostic, type DiagnosticColumn, type DigestInnerType, type DigestType, DigestValue, DurationValue, type EnumType, EnumVariant, type ErrorResponse, FIXED_POINT_MAX_PRECISION, FIXED_POINT_NARROW_PRECISION, type FixedPointKind, type FixedPointType, Float4Value, Float8Value, type Fragment, type Frame, type FrameResults, IdentityIdValue, type InferShape, type InferShapes, Int16Value, Int1Value, Int2Value, Int4Value, Int8Value, type ListType, ListValue, type MissingPresentation, NONE_PRESENTATION, NONE_VALUE, NoneValue, type ObjectShapeNode, Option, type OptionShapeNode, type OptionType, type Params, type PlannedColumn, type PrimitiveShapeNode, type PrimitiveToTS, type PrimitiveToValue, ROW_NUMBER_KEY, RQL_KEYWORDS, RQL_LITERALS, RQL_OPERATORS, RQL_SYSTEM_COLUMNS, RQL_TYPES, type RecordField, type RecordType, RecordValue, ReifyError, type ResultColumn, type RqlToken, type RqlTokenKind, Shape, ShapeBuilder, ShapeMismatch, type ShapeNode, type SingleFrameResult, TYPE_CODE, type TableLayoutOptions, type TablePlan, TimeValue, type Type, type TypeName, type TypeValuePair, Uint16Value, Uint1Value, Uint2Value, Uint4Value, Uint8Value, Utf8Value, Uuid4Value, Uuid7Value, Value, type ValueRole, type ValueShapeNode, type WireCellValue, type WireType, asFrameResults, cellText, checkFrame, checkFrames, columnsFromWire, columnsToRows, decimalType, decode, digestType, digestTypeName, displayWidth, encodeParams, encodeValue, envelopeToColumns, envelopesToFrames, fixedPointKind, fixedPointPrecision, fixedPointScale, fixedPointType, fixedPointTypeName, formatValue, framesFromWire, graphemeWidth, inferColumns, innerOfOption, isDigestType, isEnumType, isFixedPointType, isListType, isOption, isOptionType, isRecordType, noneDepth, noneMarker, noneMarkerDepth, optionDepth, padToWidth, parseValue, planTable, tokenizeRql, transformFrames, transformResult, truncateToWidth, typeFromWire, typeNameFromCode, typeToWire, unwrapOptionType, validateShape, valueRole, valueTypeName };

package/dist/index.js

@@ -1140,7 +1140,8 @@ var TYPE_CODE = {
   List: 27,
   Record: 28,
   Tuple: 29,
-  Digest: 30
+  Digest: 30,
+  Enum: 31
 };
 var CODE_TO_NAME = Object.fromEntries(
   Object.entries(TYPE_CODE).map(([k, v]) => [v, k])
@@ -2639,6 +2640,9 @@ function describeType(t) {
   if (isRecordType(t)) {
     return `Record(${t.Record.map((field) => `${field.name}: ${describeType(field.type)}`).join(", ")})`;
   }
+  if (isEnumType(t)) {
+    return `Enum(${t.Enum})`;
+  }
   return t;
 }
 function hasType(value) {
@@ -2659,8 +2663,14 @@ var _Option = class _Option {
     this[_a] = true;
   }
   static some(value) {
+    if (value === null || value === void 0) {
+      throw new Error("Option.some over null or undefined, use Option.none(inner) or Option.from(value, inner)");
+    }
     return new _Option({ some: true, value });
   }
+  static from(value, inner) {
+    return value === null || value === void 0 ? _Option.none(inner) : _Option.some(value);
+  }
   static none(inner) {
     return new _Option({ some: false, inner });
   }
@@ -2748,6 +2758,33 @@ var Utf8Value = class _Utf8Value {
   }
 };
 
+// src/value/enum-variant.ts
+var EnumVariant = class _EnumVariant {
+  constructor(enumName, variant) {
+    if (typeof enumName !== "string" || typeof variant !== "string") {
+      throw new Error(`EnumVariant needs a string enum and variant, got ${typeof enumName} and ${typeof variant}`);
+    }
+    this.type = { Enum: enumName };
+    this.enum = enumName;
+    this.variant = variant;
+  }
+  valueOf() {
+    return this.variant;
+  }
+  toString() {
+    return this.variant;
+  }
+  equals(other) {
+    return other instanceof _EnumVariant && other.enum === this.enum && other.variant === this.variant;
+  }
+  toJSON() {
+    return this.variant;
+  }
+  encode() {
+    return { type: this.type, value: this.variant };
+  }
+};
+
 // src/value/uuid4.ts
 import { v4 as uuidv4, NIL as NIL_UUID, validate, version } from "uuid";
 var Uuid4Value = class _Uuid4Value {
@@ -3256,6 +3293,9 @@ function typeToWire(type) {
   if (isRecordType(type)) {
     return { id: "Record", underlying: type.Record.map((field) => ({ name: field.name, type: typeToWire(field.type) })) };
   }
+  if (isEnumType(type)) {
+    return { id: "Enum", enum: type.Enum };
+  }
   return { id: type };
 }
 function typeFromWire(wire) {
@@ -3275,6 +3315,12 @@ function typeFromWire(wire) {
     }
     return digestType(inner, wire.accuracy);
   }
+  if (wire.id === "Enum") {
+    if (typeof wire.enum !== "string") {
+      throw new Error(`Enum type descriptor needs a string enum, got ${JSON.stringify(wire)}`);
+    }
+    return { Enum: wire.enum };
+  }
   if (wire.id === "Decimal") {
     const precision = wire.precision ?? FIXED_POINT_MAX_PRECISION;
     return decimalType(precision, wire.scale ?? DECIMAL_DEFAULT_SCALE);
@@ -3365,6 +3411,9 @@ function payloadOf(row, name, type) {
 }
 
 // src/value/index.ts
+function isEnumType(t) {
+  return typeof t === "object" && t !== null && "Enum" in t;
+}
 function isOptionType(t) {
   return typeof t === "object" && t !== null && "Option" in t;
 }
@@ -3406,6 +3455,12 @@ function decode(pair) {
     }
     return new NoneValue(stripOptionLayers(pair.type, noneAt + 1));
   }
+  if (isEnumType(pair.type)) {
+    if (typeof pair.value !== "string") {
+      throw new Error(`Enum cell must be a JSON string, got ${typeof pair.value}`);
+    }
+    return new EnumVariant(pair.type.Enum, pair.value);
+  }
   if (isDigestType(pair.type)) {
     return DigestValue.parse(pair.value, pair.type);
   }
@@ -3843,6 +3898,171 @@ var ShapeBuilder = class {
 };
 var Shape = ShapeBuilder;
 
+// 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 (typeof actual !== "string") {
+    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) {
+  if (isEnumType(type)) {
+    return matches(shape, "Utf8");
+  }
+  if (isFixedPointType(type)) {
+    const kind = fixedPointKind(type);
+    if (shape.kind === "primitive") return familyOf(shape.type).includes(kind);
+    if (shape.kind === "value") return shape.type === kind;
+    return false;
+  }
+  switch (shape.kind) {
+    case "primitive":
+      if (shape.type === "None") {
+        return type === "None" || isOptionType(type);
+      }
+      return typeof type === "string" && 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) : matches(shape.inner, type);
+    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) {
+  if (isDigestType(type)) {
+    return digestTypeName(type);
+  }
+  if (isFixedPointType(type)) {
+    return fixedPointTypeName(type);
+  }
+  if (isOptionType(type)) {
+    return `Option(${typeName2(type.Option)})`;
+  }
+  if (isListType(type)) {
+    return `List(${typeName2(type.List)})`;
+  }
+  if (isRecordType(type)) {
+    return `Record(${type.Record.map((field) => `${field.name}: ${typeName2(field.type)}`).join(", ")})`;
+  }
+  if (isEnumType(type)) {
+    return `Enum(${type.Enum})`;
+  }
+  return type;
+}
+
+// src/shape/type.ts
+function shapeType(shape) {
+  switch (shape.kind) {
+    case "primitive":
+    case "value":
+      return shape.type;
+    case "option":
+      return { Option: shapeType(shape.inner) };
+    case "object":
+    case "array":
+      throw new ShapeMismatch(`a ${shape.kind} shape has no wire type`);
+  }
+}
+
 // src/shape/parser.ts
 function createValueInstance(type, value) {
   switch (type) {
@@ -3923,7 +4143,7 @@ function parseValue(shape, value) {
   }
   if (shape.kind === "option") {
     if (value === null || value === void 0) {
-      return void 0;
+      return Option.none(shapeType(shape.inner));
     }
     if (isOption(value)) {
       return value.map((item) => parseValue(shape.inner, item));
@@ -4016,151 +4236,6 @@ 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 (typeof actual !== "string") {
-    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) {
-  if (isFixedPointType(type)) {
-    const kind = fixedPointKind(type);
-    if (shape.kind === "primitive") return familyOf(shape.type).includes(kind);
-    if (shape.kind === "value") return shape.type === kind;
-    return false;
-  }
-  switch (shape.kind) {
-    case "primitive":
-      if (shape.type === "None") {
-        return type === "None" || isOptionType(type);
-      }
-      return typeof type === "string" && 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) {
-  if (isDigestType(type)) {
-    return digestTypeName(type);
-  }
-  if (isFixedPointType(type)) {
-    return fixedPointTypeName(type);
-  }
-  if (isOptionType(type)) {
-    return `Option(${typeName2(type.Option)})`;
-  }
-  if (isListType(type)) {
-    return `List(${typeName2(type.List)})`;
-  }
-  if (isRecordType(type)) {
-    return `Record(${type.Record.map((field) => `${field.name}: ${typeName2(field.type)}`).join(", ")})`;
-  }
-  return type;
-}
-
 // src/shape/transform.ts
 function snakeToCamel(key) {
   return key.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
@@ -4182,12 +4257,7 @@ function transformResult(row, resultShape) {
       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);
-        }
+        transformedRow[outputKey] = toPrimitive(value, propertyShape.type);
       } else if (propertyShape && propertyShape.kind === "value") {
         transformedRow[outputKey] = widen(value, propertyShape.type);
       } else {
@@ -4197,10 +4267,7 @@ function transformResult(row, resultShape) {
     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);
+    return toPrimitive(row, resultShape.type);
   }
   if (resultShape && resultShape.kind === "value") {
     return widen(row, resultShape.type);
@@ -4212,6 +4279,9 @@ function transformResult(row, resultShape) {
     return row;
   }
   if (resultShape && resultShape.kind === "option") {
+    if (row === null || row === void 0) {
+      return Option.none(shapeType(resultShape.inner));
+    }
     if (row instanceof NoneValue) {
       const remaining = optionLayers(resultShape);
       const depth = noneDepth(row);
@@ -4229,6 +4299,15 @@ function transformResult(row, resultShape) {
 function optionLayers(shape) {
   return shape.kind === "option" ? optionLayers(shape.inner) + 1 : 0;
 }
+function toPrimitive(value, valueType) {
+  if (value instanceof DurationValue || value instanceof TimeValue) {
+    return value.toString();
+  }
+  if (value && typeof value === "object" && typeof value.valueOf === "function") {
+    return coerceToPrimitiveType(value.valueOf(), valueType);
+  }
+  return coerceToPrimitiveType(value, valueType);
+}
 function coerceToPrimitiveType(value, valueType) {
   if (value === void 0 || value === null) {
     return value;
@@ -4798,6 +4877,7 @@ var ReifyError = class extends Error {
     this.help = diagnostic.help;
     this.notes = diagnostic.notes ?? [];
     this.cause = diagnostic.cause;
+    this.index = response.payload.index;
     Object.setPrototypeOf(this, new.target.prototype);
   }
   toString() {
@@ -4823,6 +4903,7 @@ export {
   DecimalValue,
   DigestValue,
   DurationValue,
+  EnumVariant,
   FIXED_POINT_MAX_PRECISION,
   FIXED_POINT_NARROW_PRECISION,
   Float4Value,
@@ -4886,6 +4967,7 @@ export {
   inferColumns,
   innerOfOption,
   isDigestType,
+  isEnumType,
   isFixedPointType,
   isListType,
   isOption,