udbx4ts 0.3.0

package/dist/index.js

@@ -0,0 +1,3009 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/core/sql/SqlHelpers.ts
+async function queryAll(driver, sql, params) {
+  const statement = await driver.prepare(sql);
+  try {
+    if (params) {
+      await statement.bind(params);
+    }
+    const rows = [];
+    while (await statement.step()) {
+      rows.push(await statement.getRow());
+    }
+    return rows;
+  } finally {
+    await statement.finalize();
+  }
+}
+async function queryOne(driver, sql, params) {
+  const rows = await queryAll(driver, sql, params);
+  return rows[0] ?? null;
+}
+async function executeStatement(statement, params) {
+  try {
+    if (params) {
+      await statement.bind(params);
+    }
+    await statement.step();
+  } finally {
+    await statement.finalize();
+  }
+}
+async function executeSql(driver, sql, params) {
+  const statement = await driver.prepare(sql);
+  await executeStatement(statement, params);
+}
+
+// src/core/schema/UdbxTypeMappings.ts
+var datasetKindToValueMap = {
+  tabular: 0,
+  point: 1,
+  line: 3,
+  region: 5,
+  pointZ: 101,
+  lineZ: 103,
+  regionZ: 105,
+  text: 7,
+  cad: 149
+};
+var datasetValueToKindMap = new Map(
+  Object.entries(datasetKindToValueMap).map(([kind, value]) => [
+    value,
+    kind
+  ])
+);
+var fieldTypeToValueMap = {
+  boolean: 1,
+  byte: 2,
+  int16: 3,
+  int32: 4,
+  int64: 5,
+  single: 6,
+  double: 7,
+  date: 8,
+  binary: 9,
+  geometry: 10,
+  char: 11,
+  ntext: 127,
+  text: 128,
+  time: 16
+};
+var fieldValueToTypeMap = /* @__PURE__ */ new Map([
+  [1, "boolean"],
+  [2, "byte"],
+  [3, "int16"],
+  [4, "int32"],
+  [5, "int64"],
+  [6, "single"],
+  [7, "double"],
+  [8, "date"],
+  [9, "binary"],
+  [10, "geometry"],
+  [11, "char"],
+  [16, "time"],
+  [127, "ntext"],
+  [128, "text"]
+]);
+function datasetKindToValue(kind) {
+  return datasetKindToValueMap[kind];
+}
+function datasetValueToKind(value) {
+  const kind = datasetValueToKindMap.get(value);
+  if (!kind) {
+    throw new Error(`Unsupported SmDatasetType value: ${value}.`);
+  }
+  return kind;
+}
+function fieldTypeToValue(type) {
+  return fieldTypeToValueMap[type];
+}
+function fieldValueToType(value) {
+  const type = fieldValueToTypeMap.get(value);
+  if (!type) {
+    throw new Error(`Unsupported SmFieldType value: ${value}.`);
+  }
+  return type;
+}
+
+// src/core/schema/SmFieldInfoRepository.ts
+function mapRow(row) {
+  return {
+    name: row.SmFieldName,
+    fieldType: fieldValueToType(row.SmFieldType),
+    nullable: row.SmFieldbRequired !== 1,
+    defaultValue: row.SmFieldDefaultValue ?? void 0
+  };
+}
+var SmFieldInfoRepository = class {
+  constructor(driver) {
+    this.driver = driver;
+  }
+  async findByDatasetId(datasetId) {
+    const rows = await queryAll(
+      this.driver,
+      `SELECT
+         SmFieldName,
+         SmFieldType,
+         SmFieldbRequired,
+         SmFieldDefaultValue
+       FROM SmFieldInfo
+       WHERE SmDatasetID = ?
+       ORDER BY SmID`,
+      [datasetId]
+    );
+    return rows.map(mapRow);
+  }
+  async insertAll(datasetId, fields) {
+    for (const field of fields) {
+      const statement = await this.driver.prepare(
+        `INSERT INTO SmFieldInfo (
+           SmDatasetID,
+           SmFieldName,
+           SmFieldType,
+           SmFieldCaption,
+           SmFieldbRequired,
+           SmFieldDefaultValue
+         ) VALUES (?, ?, ?, ?, ?, ?)`
+      );
+      await executeStatement(statement, [
+        datasetId,
+        field.name,
+        fieldTypeToValue(field.fieldType),
+        field.name,
+        field.nullable ? 0 : 1,
+        field.defaultValue == null ? null : String(field.defaultValue)
+      ]);
+    }
+  }
+};
+
+// src/core/dataset/BaseDataset.ts
+var BaseDataset = class {
+  constructor(driver, info) {
+    this.driver = driver;
+    this.info = info;
+    __publicField(this, "fieldInfoRepository");
+    this.fieldInfoRepository = new SmFieldInfoRepository(driver);
+  }
+  getFields() {
+    return this.fieldInfoRepository.findByDatasetId(this.info.id);
+  }
+};
+
+// src/core/utils/errors.ts
+var NotImplementedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NotImplementedError";
+  }
+};
+function createNotImplementedError(scope) {
+  return new NotImplementedError(`${scope} is not implemented yet.`);
+}
+
+// src/core/dataset/CadDataset.ts
+var CadDataset = class extends BaseDataset {
+  async getById() {
+    throw createNotImplementedError("CadDataset.getById");
+  }
+  async list() {
+    throw createNotImplementedError("CadDataset.list");
+  }
+  async *iterate() {
+    throw createNotImplementedError("CadDataset.iterate");
+  }
+  async count() {
+    throw createNotImplementedError("CadDataset.count");
+  }
+  async insert() {
+    throw createNotImplementedError("CadDataset.insert");
+  }
+  async insertMany() {
+    throw createNotImplementedError("CadDataset.insertMany");
+  }
+  async update() {
+    throw createNotImplementedError("CadDataset.update");
+  }
+  async delete() {
+    throw createNotImplementedError("CadDataset.delete");
+  }
+};
+
+// src/core/utils/BinaryCursor.ts
+function toUint8Array(input) {
+  if (input instanceof Uint8Array) {
+    return input;
+  }
+  if (ArrayBuffer.isView(input)) {
+    return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+  }
+  return new Uint8Array(input);
+}
+var BinaryCursor = class {
+  constructor(input) {
+    __publicField(this, "bytes");
+    __publicField(this, "view");
+    __publicField(this, "offset", 0);
+    this.bytes = toUint8Array(input);
+    this.view = new DataView(
+      this.bytes.buffer,
+      this.bytes.byteOffset,
+      this.bytes.byteLength
+    );
+  }
+  get length() {
+    return this.bytes.byteLength;
+  }
+  get position() {
+    return this.offset;
+  }
+  get remaining() {
+    return this.length - this.offset;
+  }
+  seek(position) {
+    if (position < 0 || position > this.length) {
+      throw new RangeError(
+        `Cannot seek to ${position}; valid range is 0..${this.length}.`
+      );
+    }
+    this.offset = position;
+  }
+  skip(length) {
+    this.seek(this.offset + length);
+  }
+  readUint8() {
+    this.ensureAvailable(1);
+    const value = this.view.getUint8(this.offset);
+    this.offset += 1;
+    return value;
+  }
+  readInt32(littleEndian = true) {
+    this.ensureAvailable(4);
+    const value = this.view.getInt32(this.offset, littleEndian);
+    this.offset += 4;
+    return value;
+  }
+  readFloat64(littleEndian = true) {
+    this.ensureAvailable(8);
+    const value = this.view.getFloat64(this.offset, littleEndian);
+    this.offset += 8;
+    return value;
+  }
+  readBytes(length) {
+    this.ensureAvailable(length);
+    const value = this.bytes.slice(this.offset, this.offset + length);
+    this.offset += length;
+    return value;
+  }
+  peekUint8() {
+    this.ensureAvailable(1);
+    return this.view.getUint8(this.offset);
+  }
+  ensureAvailable(length) {
+    if (length < 0) {
+      throw new RangeError("Length must be non-negative.");
+    }
+    if (this.offset + length > this.length) {
+      throw new RangeError(
+        `Cannot read ${length} byte(s) from offset ${this.offset}; only ${this.remaining} byte(s) remain.`
+      );
+    }
+  }
+};
+
+// src/core/utils/BinaryWriter.ts
+var BinaryWriter = class {
+  constructor(initialCapacity = 64) {
+    __publicField(this, "buffer");
+    __publicField(this, "view");
+    __publicField(this, "bytes");
+    __publicField(this, "offset", 0);
+    if (initialCapacity <= 0) {
+      throw new RangeError("Initial capacity must be greater than 0.");
+    }
+    this.buffer = new ArrayBuffer(initialCapacity);
+    this.view = new DataView(this.buffer);
+    this.bytes = new Uint8Array(this.buffer);
+  }
+  get length() {
+    return this.offset;
+  }
+  writeUint8(value) {
+    this.ensureCapacity(1);
+    this.view.setUint8(this.offset, value);
+    this.offset += 1;
+  }
+  writeInt32(value, littleEndian = true) {
+    this.ensureCapacity(4);
+    this.view.setInt32(this.offset, value, littleEndian);
+    this.offset += 4;
+  }
+  writeFloat64(value, littleEndian = true) {
+    this.ensureCapacity(8);
+    this.view.setFloat64(this.offset, value, littleEndian);
+    this.offset += 8;
+  }
+  writeBytes(value) {
+    const bytes = value instanceof Uint8Array ? value : ArrayBuffer.isView(value) ? new Uint8Array(value.buffer, value.byteOffset, value.byteLength) : new Uint8Array(value);
+    this.ensureCapacity(bytes.byteLength);
+    this.bytes.set(bytes, this.offset);
+    this.offset += bytes.byteLength;
+  }
+  toUint8Array() {
+    return this.bytes.slice(0, this.offset);
+  }
+  ensureCapacity(required) {
+    if (this.offset + required <= this.buffer.byteLength) {
+      return;
+    }
+    let nextCapacity = this.buffer.byteLength;
+    while (this.offset + required > nextCapacity) {
+      nextCapacity *= 2;
+    }
+    const nextBuffer = new ArrayBuffer(nextCapacity);
+    const nextBytes = new Uint8Array(nextBuffer);
+    nextBytes.set(this.bytes.subarray(0, this.offset));
+    this.buffer = nextBuffer;
+    this.view = new DataView(this.buffer);
+    this.bytes = nextBytes;
+  }
+};
+
+// src/core/geometry/gaia/GaiaConstants.ts
+var GAIA_START = 0;
+var GAIA_BYTE_ORDER_LE = 1;
+var GAIA_MBR = 124;
+var GAIA_END = 254;
+var GAIA_GEOMETRY_DATA_OFFSET = 43;
+var GEO_TYPE_POINT = 1;
+var GEO_TYPE_POINTZ = 1001;
+var GEO_TYPE_MULTILINESTRING = 5;
+var GEO_TYPE_MULTILINESTRINGZ = 1005;
+var GEO_TYPE_MULTIPOLYGON = 6;
+var GEO_TYPE_MULTIPOLYGONZ = 1006;
+
+// src/core/geometry/gaia/GaiaErrors.ts
+var GaiaError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GaiaError";
+  }
+};
+var GaiaFormatError = class extends GaiaError {
+  constructor(message) {
+    super(message);
+    this.name = "GaiaFormatError";
+  }
+};
+var GaiaGeoTypeMismatchError = class extends GaiaError {
+  constructor(expected, actual) {
+    super(`Expected geoType=${expected}, got ${actual}.`);
+    this.name = "GaiaGeoTypeMismatchError";
+  }
+};
+var GaiaUnsupportedGeoTypeError = class extends GaiaError {
+  constructor(geoType) {
+    super(`Unsupported GAIA geoType: ${geoType}.`);
+    this.name = "GaiaUnsupportedGeoTypeError";
+  }
+};
+
+// src/core/geometry/gaia/GaiaHeader.ts
+function readGaiaHeader(cursor, expectedGeoType) {
+  cursor.seek(0);
+  const gaiaStart = cursor.readUint8();
+  if (gaiaStart !== GAIA_START) {
+    throw new GaiaFormatError(
+      `Invalid GAIA start marker: expected 0x${GAIA_START.toString(16)}, got 0x${gaiaStart.toString(16)}.`
+    );
+  }
+  const byteOrder = cursor.readUint8();
+  if (byteOrder !== GAIA_BYTE_ORDER_LE) {
+    throw new GaiaFormatError(
+      `Unsupported byte order: expected 0x${GAIA_BYTE_ORDER_LE.toString(16)}, got 0x${byteOrder.toString(16)}.`
+    );
+  }
+  const srid = cursor.readInt32(true);
+  const minX = cursor.readFloat64(true);
+  const minY = cursor.readFloat64(true);
+  const maxX = cursor.readFloat64(true);
+  const maxY = cursor.readFloat64(true);
+  const gaiaMbr = cursor.readUint8();
+  if (gaiaMbr !== GAIA_MBR) {
+    throw new GaiaFormatError(
+      `Invalid GAIA MBR marker: expected 0x${GAIA_MBR.toString(16)}, got 0x${gaiaMbr.toString(16)}.`
+    );
+  }
+  const geoType = cursor.readInt32(true);
+  if (expectedGeoType !== void 0 && geoType !== expectedGeoType) {
+    throw new GaiaGeoTypeMismatchError(expectedGeoType, geoType);
+  }
+  return {
+    byteOrder,
+    srid,
+    mbr: [minX, minY, maxX, maxY],
+    geoType,
+    geometryDataOffset: GAIA_GEOMETRY_DATA_OFFSET
+  };
+}
+function validateGaiaEnd(cursor) {
+  const gaiaEnd = cursor.readUint8();
+  if (gaiaEnd !== GAIA_END) {
+    throw new GaiaFormatError(
+      `Invalid GAIA end marker: expected 0x${GAIA_END.toString(16)}, got 0x${gaiaEnd.toString(16)}.`
+    );
+  }
+}
+
+// src/core/geometry/gaia/GaiaPointCodec.ts
+function isPoint3D(geometry) {
+  return geometry.coordinates.length === 3;
+}
+function createPointMbr(coordinates) {
+  return [coordinates[0], coordinates[1], coordinates[0], coordinates[1]];
+}
+function writeGaiaHeader(writer2, srid, mbr, geoType) {
+  writer2.writeUint8(GAIA_START);
+  writer2.writeUint8(GAIA_BYTE_ORDER_LE);
+  writer2.writeInt32(srid, true);
+  writer2.writeFloat64(mbr[0], true);
+  writer2.writeFloat64(mbr[1], true);
+  writer2.writeFloat64(mbr[2], true);
+  writer2.writeFloat64(mbr[3], true);
+  writer2.writeUint8(GAIA_MBR);
+  writer2.writeInt32(geoType, true);
+}
+var GaiaPointCodec = class {
+  static readPoint(input) {
+    const cursor = new BinaryCursor(input);
+    const header = readGaiaHeader(cursor, GEO_TYPE_POINT);
+    const x = cursor.readFloat64(true);
+    const y = cursor.readFloat64(true);
+    validateGaiaEnd(cursor);
+    return {
+      type: "Point",
+      coordinates: [x, y],
+      srid: header.srid,
+      bbox: header.mbr,
+      hasZ: false,
+      geoType: header.geoType
+    };
+  }
+  static readPointZ(input) {
+    const cursor = new BinaryCursor(input);
+    const header = readGaiaHeader(cursor, GEO_TYPE_POINTZ);
+    const x = cursor.readFloat64(true);
+    const y = cursor.readFloat64(true);
+    const z = cursor.readFloat64(true);
+    validateGaiaEnd(cursor);
+    return {
+      type: "Point",
+      coordinates: [x, y, z],
+      srid: header.srid,
+      bbox: header.mbr,
+      hasZ: true,
+      geoType: header.geoType
+    };
+  }
+  static writePoint(geometry, srid) {
+    if (isPoint3D(geometry)) {
+      throw new GaiaFormatError("writePoint expects a 2D Point geometry.");
+    }
+    const writer2 = new BinaryWriter(60);
+    const mbr = createPointMbr(geometry.coordinates);
+    writeGaiaHeader(writer2, srid, mbr, GEO_TYPE_POINT);
+    writer2.writeFloat64(geometry.coordinates[0], true);
+    writer2.writeFloat64(geometry.coordinates[1], true);
+    writer2.writeUint8(GAIA_END);
+    return writer2.toUint8Array();
+  }
+  static writePointZ(geometry, srid) {
+    if (!isPoint3D(geometry)) {
+      throw new GaiaFormatError("writePointZ expects a 3D Point geometry.");
+    }
+    const writer2 = new BinaryWriter(68);
+    const mbr = createPointMbr(geometry.coordinates);
+    writeGaiaHeader(writer2, srid, mbr, GEO_TYPE_POINTZ);
+    writer2.writeFloat64(geometry.coordinates[0], true);
+    writer2.writeFloat64(geometry.coordinates[1], true);
+    writer2.writeFloat64(geometry.coordinates[2], true);
+    writer2.writeUint8(GAIA_END);
+    return writer2.toUint8Array();
+  }
+};
+
+// src/core/geometry/gaia/GaiaLineCodec.ts
+var GAIA_ENTITY_MARK = 105;
+var GEO_TYPE_LINESTRING = 2;
+var GEO_TYPE_LINESTRINGZ = 1002;
+function is3DCoordinates(coordinates) {
+  return coordinates[0]?.[0]?.length === 3;
+}
+function createLineMbr(coordinates) {
+  const xs = [];
+  const ys = [];
+  for (const line of coordinates) {
+    for (const point of line) {
+      xs.push(point[0]);
+      ys.push(point[1]);
+    }
+  }
+  if (xs.length === 0) {
+    throw new GaiaFormatError("MultiLineString must contain at least one point.");
+  }
+  return [
+    Math.min(...xs),
+    Math.min(...ys),
+    Math.max(...xs),
+    Math.max(...ys)
+  ];
+}
+var GaiaLineCodec = class {
+  static readMultiLineString(input) {
+    const cursor = new BinaryCursor(input);
+    const header = readGaiaHeader(cursor, GEO_TYPE_MULTILINESTRING);
+    const lineCount = cursor.readInt32(true);
+    const coordinates = [];
+    for (let lineIndex = 0; lineIndex < lineCount; lineIndex += 1) {
+      const entityMark = cursor.readUint8();
+      if (entityMark !== GAIA_ENTITY_MARK) {
+        throw new GaiaFormatError(
+          `Invalid LineString entity mark: expected 0x${GAIA_ENTITY_MARK.toString(16)}, got 0x${entityMark.toString(16)}.`
+        );
+      }
+      const lineGeoType = cursor.readInt32(true);
+      if (lineGeoType !== GEO_TYPE_LINESTRING) {
+        throw new GaiaFormatError(
+          `Invalid LineString geoType: expected ${GEO_TYPE_LINESTRING}, got ${lineGeoType}.`
+        );
+      }
+      const pointCount = cursor.readInt32(true);
+      const line = [];
+      for (let pointIndex = 0; pointIndex < pointCount; pointIndex += 1) {
+        line.push([cursor.readFloat64(true), cursor.readFloat64(true)]);
+      }
+      coordinates.push(line);
+    }
+    validateGaiaEnd(cursor);
+    return {
+      type: "MultiLineString",
+      coordinates,
+      srid: header.srid,
+      bbox: header.mbr,
+      hasZ: false,
+      geoType: header.geoType
+    };
+  }
+  static readMultiLineStringZ(input) {
+    const cursor = new BinaryCursor(input);
+    const header = readGaiaHeader(cursor, GEO_TYPE_MULTILINESTRINGZ);
+    const lineCount = cursor.readInt32(true);
+    const coordinates = [];
+    for (let lineIndex = 0; lineIndex < lineCount; lineIndex += 1) {
+      const entityMark = cursor.readUint8();
+      if (entityMark !== GAIA_ENTITY_MARK) {
+        throw new GaiaFormatError(
+          `Invalid LineString entity mark: expected 0x${GAIA_ENTITY_MARK.toString(16)}, got 0x${entityMark.toString(16)}.`
+        );
+      }
+      const lineGeoType = cursor.readInt32(true);
+      if (lineGeoType !== GEO_TYPE_LINESTRINGZ) {
+        throw new GaiaFormatError(
+          `Invalid LineStringZ geoType: expected ${GEO_TYPE_LINESTRINGZ}, got ${lineGeoType}.`
+        );
+      }
+      const pointCount = cursor.readInt32(true);
+      const line = [];
+      for (let pointIndex = 0; pointIndex < pointCount; pointIndex += 1) {
+        line.push([
+          cursor.readFloat64(true),
+          cursor.readFloat64(true),
+          cursor.readFloat64(true)
+        ]);
+      }
+      coordinates.push(line);
+    }
+    validateGaiaEnd(cursor);
+    return {
+      type: "MultiLineString",
+      coordinates,
+      srid: header.srid,
+      bbox: header.mbr,
+      hasZ: true,
+      geoType: header.geoType
+    };
+  }
+  static writeMultiLineString(geometry, srid) {
+    if (is3DCoordinates(geometry.coordinates)) {
+      throw new GaiaFormatError(
+        "writeMultiLineString expects 2D coordinates."
+      );
+    }
+    const writer2 = new BinaryWriter();
+    writeGaiaHeader(
+      writer2,
+      srid,
+      createLineMbr(geometry.coordinates),
+      GEO_TYPE_MULTILINESTRING
+    );
+    writer2.writeInt32(geometry.coordinates.length, true);
+    for (const line of geometry.coordinates) {
+      writer2.writeUint8(GAIA_ENTITY_MARK);
+      writer2.writeInt32(GEO_TYPE_LINESTRING, true);
+      writer2.writeInt32(line.length, true);
+      for (const point of line) {
+        writer2.writeFloat64(point[0], true);
+        writer2.writeFloat64(point[1], true);
+      }
+    }
+    writer2.writeUint8(GAIA_END);
+    return writer2.toUint8Array();
+  }
+  static writeMultiLineStringZ(geometry, srid) {
+    if (!is3DCoordinates(geometry.coordinates)) {
+      throw new GaiaFormatError(
+        "writeMultiLineStringZ expects 3D coordinates."
+      );
+    }
+    const writer2 = new BinaryWriter();
+    writeGaiaHeader(
+      writer2,
+      srid,
+      createLineMbr(geometry.coordinates),
+      GEO_TYPE_MULTILINESTRINGZ
+    );
+    writer2.writeInt32(geometry.coordinates.length, true);
+    for (const line of geometry.coordinates) {
+      writer2.writeUint8(GAIA_ENTITY_MARK);
+      writer2.writeInt32(GEO_TYPE_LINESTRINGZ, true);
+      writer2.writeInt32(line.length, true);
+      for (const point of line) {
+        writer2.writeFloat64(point[0], true);
+        writer2.writeFloat64(point[1], true);
+        writer2.writeFloat64(point[2], true);
+      }
+    }
+    writer2.writeUint8(GAIA_END);
+    return writer2.toUint8Array();
+  }
+};
+
+// src/core/schema/SmRegisterRepository.ts
+function mapRow2(row) {
+  return {
+    id: row.SmDatasetID,
+    name: row.SmDatasetName,
+    kind: datasetValueToKind(row.SmDatasetType),
+    tableName: row.SmTableName,
+    srid: row.SmSRID ?? null,
+    objectCount: row.SmObjectCount,
+    geometryType: row.geometryType ?? null
+  };
+}
+var SmRegisterRepository = class {
+  constructor(driver) {
+    this.driver = driver;
+  }
+  async findAll() {
+    const rows = await queryAll(
+      this.driver,
+      `SELECT
+         SmDatasetID,
+         SmDatasetName,
+         SmTableName,
+         SmDatasetType,
+         SmObjectCount,
+         SmSRID
+       FROM SmRegister
+       ORDER BY SmDatasetID`
+    );
+    return rows.map(mapRow2);
+  }
+  async findByName(name) {
+    const row = await queryOne(
+      this.driver,
+      `SELECT
+         SmDatasetID,
+         SmDatasetName,
+         SmTableName,
+         SmDatasetType,
+         SmObjectCount,
+         SmSRID
+       FROM SmRegister
+       WHERE SmDatasetName = ?`,
+      [name]
+    );
+    return row ? mapRow2(row) : null;
+  }
+  async nextDatasetId() {
+    const row = await queryOne(
+      this.driver,
+      "SELECT COALESCE(MAX(SmDatasetID), 0) + 1 AS nextId FROM SmRegister"
+    );
+    return row?.nextId ?? 1;
+  }
+  async insert(params) {
+    const datasetId = await this.nextDatasetId();
+    const statement = await this.driver.prepare(
+      `INSERT INTO SmRegister (
+         SmDatasetID,
+         SmDatasetName,
+         SmTableName,
+         SmDatasetType,
+         SmObjectCount,
+         SmSRID,
+         SmIDColName,
+         SmGeoColName,
+         SmMaxGeometrySize,
+         SmCreateTime,
+         SmLastUpdateTime
+       ) VALUES (?, ?, ?, ?, 0, ?, ?, ?, 0, datetime('now'), datetime('now'))`
+    );
+    await executeStatement(statement, [
+      datasetId,
+      params.name,
+      params.name,
+      datasetKindToValue(params.kind),
+      params.srid,
+      params.idColumnName,
+      params.geometryColumnName
+    ]);
+    return datasetId;
+  }
+  async incrementObjectCount(datasetId, geometrySize) {
+    if (geometrySize === void 0) {
+      const statement2 = await this.driver.prepare(
+        "UPDATE SmRegister SET SmObjectCount = SmObjectCount + 1 WHERE SmDatasetID = ?"
+      );
+      await executeStatement(statement2, [datasetId]);
+      return;
+    }
+    const statement = await this.driver.prepare(
+      `UPDATE SmRegister
+       SET SmObjectCount = SmObjectCount + 1,
+           SmMaxGeometrySize = CASE
+             WHEN SmMaxGeometrySize < ? THEN ?
+             ELSE SmMaxGeometrySize
+           END
+       WHERE SmDatasetID = ?`
+    );
+    await executeStatement(statement, [geometrySize, geometrySize, datasetId]);
+  }
+  async incrementObjectCountBatch(datasetId, count, maxGeometrySize) {
+    const statement = await this.driver.prepare(
+      `UPDATE SmRegister
+       SET SmObjectCount = SmObjectCount + ?,
+           SmMaxGeometrySize = CASE
+             WHEN SmMaxGeometrySize < ? THEN ?
+             ELSE SmMaxGeometrySize
+           END
+       WHERE SmDatasetID = ?`
+    );
+    await executeStatement(statement, [
+      count,
+      maxGeometrySize,
+      maxGeometrySize,
+      datasetId
+    ]);
+  }
+  async decrementObjectCount(datasetId) {
+    const statement = await this.driver.prepare(
+      "UPDATE SmRegister SET SmObjectCount = SmObjectCount - 1 WHERE SmDatasetID = ? AND SmObjectCount > 0"
+    );
+    await executeStatement(statement, [datasetId]);
+  }
+};
+
+// src/core/dataset/vectorDatasetShared.ts
+function normalizeGeometryBlob(value) {
+  return value instanceof Uint8Array ? value : new Uint8Array(value);
+}
+function buildListSql(tableName, options) {
+  const params = [];
+  const clauses = [];
+  if (options?.ids?.length) {
+    const placeholders = options.ids.map(() => "?").join(", ");
+    clauses.push(`SmID IN (${placeholders})`);
+    params.push(...options.ids);
+  }
+  const whereClause = clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "";
+  let sql = `SELECT * FROM "${tableName}"${whereClause} ORDER BY SmID`;
+  if (options?.limit !== void 0) {
+    sql += " LIMIT ?";
+    params.push(options.limit);
+  }
+  if (options?.offset !== void 0) {
+    if (options.limit === void 0) {
+      sql += " LIMIT -1";
+    }
+    sql += " OFFSET ?";
+    params.push(options.offset);
+  }
+  return { sql, params };
+}
+function sqliteColumnType(field) {
+  switch (field.fieldType) {
+    case "boolean":
+    case "byte":
+    case "int16":
+    case "int32":
+    case "int64":
+      return "INTEGER";
+    case "single":
+    case "double":
+      return "REAL";
+    case "binary":
+    case "geometry":
+      return "BLOB";
+    case "date":
+    case "char":
+    case "ntext":
+    case "text":
+    case "time":
+    default:
+      return "TEXT";
+  }
+}
+
+// src/core/dataset/LineDataset.ts
+function mapLineRow(row) {
+  const { SmID, SmGeometry, ...attributes } = row;
+  return {
+    id: SmID,
+    geometry: GaiaLineCodec.readMultiLineString(normalizeGeometryBlob(SmGeometry)),
+    attributes
+  };
+}
+var LineDataset = class _LineDataset extends BaseDataset {
+  constructor(driver, info) {
+    super(driver, info);
+    __publicField(this, "registerRepository");
+    this.registerRepository = new SmRegisterRepository(driver);
+  }
+  async getById(id) {
+    const row = await queryOne(
+      this.driver,
+      `SELECT * FROM "${this.info.tableName}" WHERE SmID = ?`,
+      [id]
+    );
+    return row ? mapLineRow(row) : null;
+  }
+  async list(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const rows = await queryAll(this.driver, sql, params);
+    return rows.map((row) => mapLineRow(row));
+  }
+  async *iterate(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const statement = await this.driver.prepare(sql);
+    try {
+      if (params.length > 0) {
+        await statement.bind(params);
+      }
+      while (await statement.step()) {
+        yield mapLineRow(await statement.getRow());
+      }
+    } finally {
+      await statement.finalize();
+    }
+  }
+  async insert(feature) {
+    const userFields = await this.getFields();
+    const columnNames = ["SmID", "SmUserID", "SmGeometry", ...userFields.map((field) => field.name)];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const geometry = GaiaLineCodec.writeMultiLineString(
+      feature.geometry,
+      feature.geometry.srid ?? this.info.srid ?? 0
+    );
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    const params = [
+      feature.id,
+      0,
+      geometry,
+      ...userFields.map((field) => feature.attributes[field.name] ?? null)
+    ];
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+      await this.registerRepository.incrementObjectCount(this.info.id, geometry.byteLength);
+    });
+  }
+  async insertMany(features) {
+    const userFields = await this.getFields();
+    const columnNames = ["SmID", "SmUserID", "SmGeometry", ...userFields.map((field) => field.name)];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    await this.driver.transaction(async () => {
+      const statement = await this.driver.prepare(sql);
+      try {
+        let count = 0;
+        let maxGeometrySize = 0;
+        for await (const feature of features) {
+          const geometry = GaiaLineCodec.writeMultiLineString(
+            feature.geometry,
+            feature.geometry.srid ?? this.info.srid ?? 0
+          );
+          maxGeometrySize = Math.max(maxGeometrySize, geometry.byteLength);
+          const params = [
+            feature.id,
+            0,
+            geometry,
+            ...userFields.map(
+              (field) => feature.attributes[field.name] ?? null
+            )
+          ];
+          await statement.bind(params);
+          await statement.step();
+          await statement.reset();
+          count++;
+        }
+        if (count > 0) {
+          await this.registerRepository.incrementObjectCountBatch(
+            this.info.id,
+            count,
+            maxGeometrySize
+          );
+        }
+      } finally {
+        await statement.finalize();
+      }
+    });
+  }
+  async count() {
+    const row = await queryOne(
+      this.driver,
+      `SELECT COUNT(*) AS count FROM "${this.info.tableName}"`,
+      []
+    );
+    return row?.count ?? 0;
+  }
+  async update(id, changes) {
+    if (!changes.geometry && !changes.attributes) {
+      return;
+    }
+    const setClauses = [];
+    const params = [];
+    if (changes.geometry) {
+      const geometry = GaiaLineCodec.writeMultiLineString(
+        changes.geometry,
+        changes.geometry.srid ?? this.info.srid ?? 0
+      );
+      setClauses.push('"SmGeometry" = ?');
+      params.push(geometry);
+    }
+    if (changes.attributes) {
+      const userFields = await this.getFields();
+      const fieldNames = new Set(userFields.map((f) => f.name));
+      const validEntries = Object.entries(changes.attributes).filter(
+        ([key]) => fieldNames.has(key)
+      );
+      for (const [key, value] of validEntries) {
+        setClauses.push(`"${key}" = ?`);
+        params.push(value);
+      }
+    }
+    if (setClauses.length === 0) {
+      return;
+    }
+    const sql = `UPDATE "${this.info.tableName}" SET ${setClauses.join(", ")} WHERE SmID = ?`;
+    params.push(id);
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+    });
+  }
+  async delete(id) {
+    await this.driver.transaction(async () => {
+      await executeSql(
+        this.driver,
+        `DELETE FROM "${this.info.tableName}" WHERE SmID = ?`,
+        [id]
+      );
+      await this.registerRepository.decrementObjectCount(this.info.id);
+    });
+  }
+  static async create(driver, registerRepository, params) {
+    const fields = params.fields ?? [];
+    const datasetId = await registerRepository.insert({
+      name: params.name,
+      kind: "line",
+      srid: params.srid,
+      idColumnName: "SmID",
+      geometryColumnName: "SmGeometry"
+    });
+    const userColumnDefinitions = fields.map((field) => {
+      const nullability = field.nullable ? "" : " NOT NULL";
+      return `"${field.name}" ${sqliteColumnType(field)}${nullability}`;
+    });
+    const createTableParts = [
+      `"SmID" INTEGER NOT NULL PRIMARY KEY`,
+      `"SmUserID" INTEGER DEFAULT 0 NOT NULL`,
+      `"SmGeometry" BLOB NOT NULL`,
+      ...userColumnDefinitions
+    ];
+    await driver.exec(
+      `CREATE TABLE "${params.name}" (${createTableParts.join(", ")})`
+    );
+    await executeSql(
+      driver,
+      `INSERT INTO geometry_columns (
+         f_table_name,
+         f_geometry_column,
+         geometry_type,
+         coord_dimension,
+         srid,
+         spatial_index_enabled
+       ) VALUES (?, ?, ?, ?, ?, ?)`,
+      [params.name, "SmGeometry", 5, 2, params.srid, 0]
+    );
+    if (fields.length > 0) {
+      const fieldInfoRepository = new SmFieldInfoRepository(driver);
+      await fieldInfoRepository.insertAll(datasetId, fields);
+    }
+    return new _LineDataset(driver, {
+      id: datasetId,
+      name: params.name,
+      kind: "line",
+      tableName: params.name,
+      srid: params.srid,
+      objectCount: 0,
+      geometryType: 5
+    });
+  }
+};
+
+// src/core/dataset/LineZDataset.ts
+function mapLineZRow(row) {
+  const { SmID, SmGeometry, ...attributes } = row;
+  return {
+    id: SmID,
+    geometry: GaiaLineCodec.readMultiLineStringZ(normalizeGeometryBlob(SmGeometry)),
+    attributes
+  };
+}
+var LineZDataset = class _LineZDataset extends BaseDataset {
+  constructor(driver, info) {
+    super(driver, info);
+    __publicField(this, "registerRepository");
+    this.registerRepository = new SmRegisterRepository(driver);
+  }
+  async getById(id) {
+    const row = await queryOne(
+      this.driver,
+      `SELECT * FROM "${this.info.tableName}" WHERE SmID = ?`,
+      [id]
+    );
+    return row ? mapLineZRow(row) : null;
+  }
+  async list(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const rows = await queryAll(this.driver, sql, params);
+    return rows.map((row) => mapLineZRow(row));
+  }
+  async *iterate(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const statement = await this.driver.prepare(sql);
+    try {
+      if (params.length > 0) {
+        await statement.bind(params);
+      }
+      while (await statement.step()) {
+        yield mapLineZRow(await statement.getRow());
+      }
+    } finally {
+      await statement.finalize();
+    }
+  }
+  async count() {
+    const row = await queryOne(
+      this.driver,
+      `SELECT COUNT(*) AS count FROM "${this.info.tableName}"`,
+      []
+    );
+    return row?.count ?? 0;
+  }
+  async insert(feature) {
+    const userFields = await this.getFields();
+    const columnNames = ["SmID", "SmUserID", "SmGeometry", ...userFields.map((field) => field.name)];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const geometry = GaiaLineCodec.writeMultiLineStringZ(
+      feature.geometry,
+      feature.geometry.srid ?? this.info.srid ?? 0
+    );
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    const params = [
+      feature.id,
+      0,
+      geometry,
+      ...userFields.map((field) => feature.attributes[field.name] ?? null)
+    ];
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+      await this.registerRepository.incrementObjectCount(this.info.id, geometry.byteLength);
+    });
+  }
+  async insertMany(features) {
+    const userFields = await this.getFields();
+    const columnNames = ["SmID", "SmUserID", "SmGeometry", ...userFields.map((field) => field.name)];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    await this.driver.transaction(async () => {
+      const statement = await this.driver.prepare(sql);
+      try {
+        let count = 0;
+        let maxGeometrySize = 0;
+        for await (const feature of features) {
+          const geometry = GaiaLineCodec.writeMultiLineStringZ(
+            feature.geometry,
+            feature.geometry.srid ?? this.info.srid ?? 0
+          );
+          maxGeometrySize = Math.max(maxGeometrySize, geometry.byteLength);
+          const params = [
+            feature.id,
+            0,
+            geometry,
+            ...userFields.map(
+              (field) => feature.attributes[field.name] ?? null
+            )
+          ];
+          await statement.bind(params);
+          await statement.step();
+          await statement.reset();
+          count++;
+        }
+        if (count > 0) {
+          await this.registerRepository.incrementObjectCountBatch(
+            this.info.id,
+            count,
+            maxGeometrySize
+          );
+        }
+      } finally {
+        await statement.finalize();
+      }
+    });
+  }
+  async update(id, changes) {
+    if (!changes.geometry && !changes.attributes) {
+      return;
+    }
+    const setClauses = [];
+    const params = [];
+    if (changes.geometry) {
+      const geometry = GaiaLineCodec.writeMultiLineStringZ(
+        changes.geometry,
+        changes.geometry.srid ?? this.info.srid ?? 0
+      );
+      setClauses.push('"SmGeometry" = ?');
+      params.push(geometry);
+    }
+    if (changes.attributes) {
+      const userFields = await this.getFields();
+      const fieldNames = new Set(userFields.map((f) => f.name));
+      const validEntries = Object.entries(changes.attributes).filter(
+        ([key]) => fieldNames.has(key)
+      );
+      for (const [key, value] of validEntries) {
+        setClauses.push(`"${key}" = ?`);
+        params.push(value);
+      }
+    }
+    if (setClauses.length === 0) {
+      return;
+    }
+    const sql = `UPDATE "${this.info.tableName}" SET ${setClauses.join(", ")} WHERE SmID = ?`;
+    params.push(id);
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+    });
+  }
+  async delete(id) {
+    await this.driver.transaction(async () => {
+      await executeSql(
+        this.driver,
+        `DELETE FROM "${this.info.tableName}" WHERE SmID = ?`,
+        [id]
+      );
+      await this.registerRepository.decrementObjectCount(this.info.id);
+    });
+  }
+  static async create(driver, registerRepository, params) {
+    const fields = params.fields ?? [];
+    const datasetId = await registerRepository.insert({
+      name: params.name,
+      kind: "lineZ",
+      srid: params.srid,
+      idColumnName: "SmID",
+      geometryColumnName: "SmGeometry"
+    });
+    const userColumnDefinitions = fields.map((field) => {
+      const nullability = field.nullable ? "" : " NOT NULL";
+      return `"${field.name}" ${sqliteColumnType(field)}${nullability}`;
+    });
+    const createTableParts = [
+      `"SmID" INTEGER NOT NULL PRIMARY KEY`,
+      `"SmUserID" INTEGER DEFAULT 0 NOT NULL`,
+      `"SmGeometry" BLOB NOT NULL`,
+      ...userColumnDefinitions
+    ];
+    await driver.exec(
+      `CREATE TABLE "${params.name}" (${createTableParts.join(", ")})`
+    );
+    await executeSql(
+      driver,
+      `INSERT INTO geometry_columns (
+         f_table_name,
+         f_geometry_column,
+         geometry_type,
+         coord_dimension,
+         srid,
+         spatial_index_enabled
+       ) VALUES (?, ?, ?, ?, ?, ?)`,
+      [params.name, "SmGeometry", 1005, 3, params.srid, 0]
+    );
+    if (fields.length > 0) {
+      const fieldInfoRepository = new SmFieldInfoRepository(driver);
+      await fieldInfoRepository.insertAll(datasetId, fields);
+    }
+    return new _LineZDataset(driver, {
+      id: datasetId,
+      name: params.name,
+      kind: "lineZ",
+      tableName: params.name,
+      srid: params.srid,
+      objectCount: 0,
+      geometryType: 1005
+    });
+  }
+};
+
+// src/core/dataset/PointDataset.ts
+function mapPointRow(row) {
+  const { SmID, SmGeometry, ...attributes } = row;
+  return {
+    id: SmID,
+    geometry: GaiaPointCodec.readPoint(normalizeGeometryBlob(SmGeometry)),
+    attributes
+  };
+}
+var PointDataset = class _PointDataset extends BaseDataset {
+  constructor(driver, info) {
+    super(driver, info);
+    __publicField(this, "registerRepository");
+    this.registerRepository = new SmRegisterRepository(driver);
+  }
+  async getById(id) {
+    const row = await queryOne(
+      this.driver,
+      `SELECT * FROM "${this.info.tableName}" WHERE SmID = ?`,
+      [id]
+    );
+    return row ? mapPointRow(row) : null;
+  }
+  async list(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const rows = await queryAll(this.driver, sql, params);
+    return rows.map((row) => mapPointRow(row));
+  }
+  async *iterate(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const statement = await this.driver.prepare(sql);
+    try {
+      if (params.length > 0) {
+        await statement.bind(params);
+      }
+      while (await statement.step()) {
+        yield mapPointRow(await statement.getRow());
+      }
+    } finally {
+      await statement.finalize();
+    }
+  }
+  async insert(feature) {
+    const userFields = await this.getFields();
+    const columnNames = ["SmID", "SmUserID", "SmGeometry", ...userFields.map((field) => field.name)];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const geometry = GaiaPointCodec.writePoint(feature.geometry, feature.geometry.srid ?? this.info.srid ?? 0);
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    const params = [
+      feature.id,
+      0,
+      geometry,
+      ...userFields.map((field) => feature.attributes[field.name] ?? null)
+    ];
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+      await this.registerRepository.incrementObjectCount(this.info.id, geometry.byteLength);
+    });
+  }
+  async insertMany(features) {
+    const userFields = await this.getFields();
+    const columnNames = ["SmID", "SmUserID", "SmGeometry", ...userFields.map((field) => field.name)];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    await this.driver.transaction(async () => {
+      const statement = await this.driver.prepare(sql);
+      try {
+        let count = 0;
+        let maxGeometrySize = 0;
+        for await (const feature of features) {
+          const geometry = GaiaPointCodec.writePoint(
+            feature.geometry,
+            feature.geometry.srid ?? this.info.srid ?? 0
+          );
+          maxGeometrySize = Math.max(maxGeometrySize, geometry.byteLength);
+          const params = [
+            feature.id,
+            0,
+            geometry,
+            ...userFields.map(
+              (field) => feature.attributes[field.name] ?? null
+            )
+          ];
+          await statement.bind(params);
+          await statement.step();
+          await statement.reset();
+          count++;
+        }
+        if (count > 0) {
+          await this.registerRepository.incrementObjectCountBatch(
+            this.info.id,
+            count,
+            maxGeometrySize
+          );
+        }
+      } finally {
+        await statement.finalize();
+      }
+    });
+  }
+  async count() {
+    const row = await queryOne(
+      this.driver,
+      `SELECT COUNT(*) AS count FROM "${this.info.tableName}"`,
+      []
+    );
+    return row?.count ?? 0;
+  }
+  async update(id, changes) {
+    if (!changes.geometry && !changes.attributes) {
+      return;
+    }
+    const setClauses = [];
+    const params = [];
+    if (changes.geometry) {
+      const geometry = GaiaPointCodec.writePoint(
+        changes.geometry,
+        changes.geometry.srid ?? this.info.srid ?? 0
+      );
+      setClauses.push('"SmGeometry" = ?');
+      params.push(geometry);
+    }
+    if (changes.attributes) {
+      const userFields = await this.getFields();
+      const fieldNames = new Set(userFields.map((f) => f.name));
+      const validEntries = Object.entries(changes.attributes).filter(
+        ([key]) => fieldNames.has(key)
+      );
+      for (const [key, value] of validEntries) {
+        setClauses.push(`"${key}" = ?`);
+        params.push(value);
+      }
+    }
+    if (setClauses.length === 0) {
+      return;
+    }
+    const sql = `UPDATE "${this.info.tableName}" SET ${setClauses.join(", ")} WHERE SmID = ?`;
+    params.push(id);
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+    });
+  }
+  async delete(id) {
+    await this.driver.transaction(async () => {
+      await executeSql(
+        this.driver,
+        `DELETE FROM "${this.info.tableName}" WHERE SmID = ?`,
+        [id]
+      );
+      await this.registerRepository.decrementObjectCount(this.info.id);
+    });
+  }
+  static async create(driver, registerRepository, params) {
+    const fields = params.fields ?? [];
+    const datasetId = await registerRepository.insert({
+      name: params.name,
+      kind: "point",
+      srid: params.srid,
+      idColumnName: "SmID",
+      geometryColumnName: "SmGeometry"
+    });
+    const userColumnDefinitions = fields.map((field) => {
+      const nullability = field.nullable ? "" : " NOT NULL";
+      return `"${field.name}" ${sqliteColumnType(field)}${nullability}`;
+    });
+    const createTableParts = [
+      `"SmID" INTEGER NOT NULL PRIMARY KEY`,
+      `"SmUserID" INTEGER DEFAULT 0 NOT NULL`,
+      `"SmGeometry" BLOB NOT NULL`,
+      ...userColumnDefinitions
+    ];
+    await driver.exec(
+      `CREATE TABLE "${params.name}" (${createTableParts.join(", ")})`
+    );
+    await executeSql(
+      driver,
+      `INSERT INTO geometry_columns (
+         f_table_name,
+         f_geometry_column,
+         geometry_type,
+         coord_dimension,
+         srid,
+         spatial_index_enabled
+       ) VALUES (?, ?, ?, ?, ?, ?)`,
+      [params.name, "SmGeometry", 1, 2, params.srid, 0]
+    );
+    if (fields.length > 0) {
+      const fieldInfoRepository = new SmFieldInfoRepository(driver);
+      await fieldInfoRepository.insertAll(datasetId, fields);
+    }
+    return new _PointDataset(driver, {
+      id: datasetId,
+      name: params.name,
+      kind: "point",
+      tableName: params.name,
+      srid: params.srid,
+      objectCount: 0,
+      geometryType: 1
+    });
+  }
+};
+
+// src/core/dataset/PointZDataset.ts
+function mapPointZRow(row) {
+  const { SmID, SmGeometry, ...attributes } = row;
+  return {
+    id: SmID,
+    geometry: GaiaPointCodec.readPointZ(normalizeGeometryBlob(SmGeometry)),
+    attributes
+  };
+}
+var PointZDataset = class _PointZDataset extends BaseDataset {
+  constructor(driver, info) {
+    super(driver, info);
+    __publicField(this, "registerRepository");
+    this.registerRepository = new SmRegisterRepository(driver);
+  }
+  async getById(id) {
+    const row = await queryOne(
+      this.driver,
+      `SELECT * FROM "${this.info.tableName}" WHERE SmID = ?`,
+      [id]
+    );
+    return row ? mapPointZRow(row) : null;
+  }
+  async list(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const rows = await queryAll(this.driver, sql, params);
+    return rows.map((row) => mapPointZRow(row));
+  }
+  async *iterate(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const statement = await this.driver.prepare(sql);
+    try {
+      if (params.length > 0) {
+        await statement.bind(params);
+      }
+      while (await statement.step()) {
+        yield mapPointZRow(await statement.getRow());
+      }
+    } finally {
+      await statement.finalize();
+    }
+  }
+  async count() {
+    const row = await queryOne(
+      this.driver,
+      `SELECT COUNT(*) AS count FROM "${this.info.tableName}"`,
+      []
+    );
+    return row?.count ?? 0;
+  }
+  async insert(feature) {
+    const userFields = await this.getFields();
+    const columnNames = ["SmID", "SmUserID", "SmGeometry", ...userFields.map((field) => field.name)];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const geometry = GaiaPointCodec.writePointZ(
+      feature.geometry,
+      feature.geometry.srid ?? this.info.srid ?? 0
+    );
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    const params = [
+      feature.id,
+      0,
+      geometry,
+      ...userFields.map((field) => feature.attributes[field.name] ?? null)
+    ];
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+      await this.registerRepository.incrementObjectCount(this.info.id, geometry.byteLength);
+    });
+  }
+  async insertMany(features) {
+    const userFields = await this.getFields();
+    const columnNames = ["SmID", "SmUserID", "SmGeometry", ...userFields.map((field) => field.name)];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    await this.driver.transaction(async () => {
+      const statement = await this.driver.prepare(sql);
+      try {
+        let count = 0;
+        let maxGeometrySize = 0;
+        for await (const feature of features) {
+          const geometry = GaiaPointCodec.writePointZ(
+            feature.geometry,
+            feature.geometry.srid ?? this.info.srid ?? 0
+          );
+          maxGeometrySize = Math.max(maxGeometrySize, geometry.byteLength);
+          const params = [
+            feature.id,
+            0,
+            geometry,
+            ...userFields.map(
+              (field) => feature.attributes[field.name] ?? null
+            )
+          ];
+          await statement.bind(params);
+          await statement.step();
+          await statement.reset();
+          count++;
+        }
+        if (count > 0) {
+          await this.registerRepository.incrementObjectCountBatch(
+            this.info.id,
+            count,
+            maxGeometrySize
+          );
+        }
+      } finally {
+        await statement.finalize();
+      }
+    });
+  }
+  async update(id, changes) {
+    if (!changes.geometry && !changes.attributes) {
+      return;
+    }
+    const setClauses = [];
+    const params = [];
+    if (changes.geometry) {
+      const geometry = GaiaPointCodec.writePointZ(
+        changes.geometry,
+        changes.geometry.srid ?? this.info.srid ?? 0
+      );
+      setClauses.push('"SmGeometry" = ?');
+      params.push(geometry);
+    }
+    if (changes.attributes) {
+      const userFields = await this.getFields();
+      const fieldNames = new Set(userFields.map((f) => f.name));
+      const validEntries = Object.entries(changes.attributes).filter(
+        ([key]) => fieldNames.has(key)
+      );
+      for (const [key, value] of validEntries) {
+        setClauses.push(`"${key}" = ?`);
+        params.push(value);
+      }
+    }
+    if (setClauses.length === 0) {
+      return;
+    }
+    const sql = `UPDATE "${this.info.tableName}" SET ${setClauses.join(", ")} WHERE SmID = ?`;
+    params.push(id);
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+    });
+  }
+  async delete(id) {
+    await this.driver.transaction(async () => {
+      await executeSql(
+        this.driver,
+        `DELETE FROM "${this.info.tableName}" WHERE SmID = ?`,
+        [id]
+      );
+      await this.registerRepository.decrementObjectCount(this.info.id);
+    });
+  }
+  static async create(driver, registerRepository, params) {
+    const fields = params.fields ?? [];
+    const datasetId = await registerRepository.insert({
+      name: params.name,
+      kind: "pointZ",
+      srid: params.srid,
+      idColumnName: "SmID",
+      geometryColumnName: "SmGeometry"
+    });
+    const userColumnDefinitions = fields.map((field) => {
+      const nullability = field.nullable ? "" : " NOT NULL";
+      return `"${field.name}" ${sqliteColumnType(field)}${nullability}`;
+    });
+    const createTableParts = [
+      `"SmID" INTEGER NOT NULL PRIMARY KEY`,
+      `"SmUserID" INTEGER DEFAULT 0 NOT NULL`,
+      `"SmGeometry" BLOB NOT NULL`,
+      ...userColumnDefinitions
+    ];
+    await driver.exec(
+      `CREATE TABLE "${params.name}" (${createTableParts.join(", ")})`
+    );
+    await executeSql(
+      driver,
+      `INSERT INTO geometry_columns (
+         f_table_name,
+         f_geometry_column,
+         geometry_type,
+         coord_dimension,
+         srid,
+         spatial_index_enabled
+       ) VALUES (?, ?, ?, ?, ?, ?)`,
+      [params.name, "SmGeometry", 1001, 3, params.srid, 0]
+    );
+    if (fields.length > 0) {
+      const fieldInfoRepository = new SmFieldInfoRepository(driver);
+      await fieldInfoRepository.insertAll(datasetId, fields);
+    }
+    return new _PointZDataset(driver, {
+      id: datasetId,
+      name: params.name,
+      kind: "pointZ",
+      tableName: params.name,
+      srid: params.srid,
+      objectCount: 0,
+      geometryType: 1001
+    });
+  }
+};
+
+// src/core/geometry/gaia/GaiaPolygonCodec.ts
+var GAIA_ENTITY_MARK2 = 105;
+var GEO_TYPE_POLYGON = 3;
+var GEO_TYPE_POLYGONZ = 1003;
+function is3DCoordinates2(coordinates) {
+  return coordinates[0]?.[0]?.[0]?.length === 3;
+}
+function createPolygonMbr(coordinates) {
+  const xs = [];
+  const ys = [];
+  for (const polygon of coordinates) {
+    for (const ring of polygon) {
+      for (const point of ring) {
+        xs.push(point[0]);
+        ys.push(point[1]);
+      }
+    }
+  }
+  if (xs.length === 0) {
+    throw new GaiaFormatError("MultiPolygon must contain at least one point.");
+  }
+  return [
+    Math.min(...xs),
+    Math.min(...ys),
+    Math.max(...xs),
+    Math.max(...ys)
+  ];
+}
+function writeRing2D(writer2, ring) {
+  writer2.writeInt32(ring.length, true);
+  for (const point of ring) {
+    writer2.writeFloat64(point[0], true);
+    writer2.writeFloat64(point[1], true);
+  }
+}
+function writeRing3D(writer2, ring) {
+  writer2.writeInt32(ring.length, true);
+  for (const point of ring) {
+    writer2.writeFloat64(point[0], true);
+    writer2.writeFloat64(point[1], true);
+    writer2.writeFloat64(point[2], true);
+  }
+}
+function readRing2D(cursor) {
+  const pointCount = cursor.readInt32(true);
+  const ring = [];
+  for (let pointIndex = 0; pointIndex < pointCount; pointIndex += 1) {
+    ring.push([cursor.readFloat64(true), cursor.readFloat64(true)]);
+  }
+  return ring;
+}
+function readRing3D(cursor) {
+  const pointCount = cursor.readInt32(true);
+  const ring = [];
+  for (let pointIndex = 0; pointIndex < pointCount; pointIndex += 1) {
+    ring.push([
+      cursor.readFloat64(true),
+      cursor.readFloat64(true),
+      cursor.readFloat64(true)
+    ]);
+  }
+  return ring;
+}
+var GaiaPolygonCodec = class {
+  static readMultiPolygon(input) {
+    const cursor = new BinaryCursor(input);
+    const header = readGaiaHeader(cursor, GEO_TYPE_MULTIPOLYGON);
+    const polygonCount = cursor.readInt32(true);
+    const coordinates = [];
+    for (let polygonIndex = 0; polygonIndex < polygonCount; polygonIndex += 1) {
+      const entityMark = cursor.readUint8();
+      if (entityMark !== GAIA_ENTITY_MARK2) {
+        throw new GaiaFormatError(
+          `Invalid Polygon entity mark: expected 0x${GAIA_ENTITY_MARK2.toString(16)}, got 0x${entityMark.toString(16)}.`
+        );
+      }
+      const polygonGeoType = cursor.readInt32(true);
+      if (polygonGeoType !== GEO_TYPE_POLYGON) {
+        throw new GaiaFormatError(
+          `Invalid Polygon geoType: expected ${GEO_TYPE_POLYGON}, got ${polygonGeoType}.`
+        );
+      }
+      const ringCount = cursor.readInt32(true);
+      if (ringCount < 1) {
+        throw new GaiaFormatError(
+          `Polygon must contain at least one ring, got ${ringCount}.`
+        );
+      }
+      const polygon = [];
+      for (let ringIndex = 0; ringIndex < ringCount; ringIndex += 1) {
+        polygon.push(readRing2D(cursor));
+      }
+      coordinates.push(polygon);
+    }
+    validateGaiaEnd(cursor);
+    return {
+      type: "MultiPolygon",
+      coordinates,
+      srid: header.srid,
+      bbox: header.mbr,
+      hasZ: false,
+      geoType: header.geoType
+    };
+  }
+  static readMultiPolygonZ(input) {
+    const cursor = new BinaryCursor(input);
+    const header = readGaiaHeader(cursor, GEO_TYPE_MULTIPOLYGONZ);
+    const polygonCount = cursor.readInt32(true);
+    const coordinates = [];
+    for (let polygonIndex = 0; polygonIndex < polygonCount; polygonIndex += 1) {
+      const entityMark = cursor.readUint8();
+      if (entityMark !== GAIA_ENTITY_MARK2) {
+        throw new GaiaFormatError(
+          `Invalid Polygon entity mark: expected 0x${GAIA_ENTITY_MARK2.toString(16)}, got 0x${entityMark.toString(16)}.`
+        );
+      }
+      const polygonGeoType = cursor.readInt32(true);
+      if (polygonGeoType !== GEO_TYPE_POLYGONZ) {
+        throw new GaiaFormatError(
+          `Invalid PolygonZ geoType: expected ${GEO_TYPE_POLYGONZ}, got ${polygonGeoType}.`
+        );
+      }
+      const ringCount = cursor.readInt32(true);
+      if (ringCount < 1) {
+        throw new GaiaFormatError(
+          `Polygon must contain at least one ring, got ${ringCount}.`
+        );
+      }
+      const polygon = [];
+      for (let ringIndex = 0; ringIndex < ringCount; ringIndex += 1) {
+        polygon.push(readRing3D(cursor));
+      }
+      coordinates.push(polygon);
+    }
+    validateGaiaEnd(cursor);
+    return {
+      type: "MultiPolygon",
+      coordinates,
+      srid: header.srid,
+      bbox: header.mbr,
+      hasZ: true,
+      geoType: header.geoType
+    };
+  }
+  static writeMultiPolygon(geometry, srid) {
+    if (is3DCoordinates2(geometry.coordinates)) {
+      throw new GaiaFormatError("writeMultiPolygon expects 2D coordinates.");
+    }
+    const writer2 = new BinaryWriter();
+    writeGaiaHeader(
+      writer2,
+      srid,
+      createPolygonMbr(geometry.coordinates),
+      GEO_TYPE_MULTIPOLYGON
+    );
+    writer2.writeInt32(geometry.coordinates.length, true);
+    for (const polygon of geometry.coordinates) {
+      writer2.writeUint8(GAIA_ENTITY_MARK2);
+      writer2.writeInt32(GEO_TYPE_POLYGON, true);
+      writer2.writeInt32(polygon.length, true);
+      for (const ring of polygon) {
+        writeRing2D(writer2, ring);
+      }
+    }
+    writer2.writeUint8(GAIA_END);
+    return writer2.toUint8Array();
+  }
+  static writeMultiPolygonZ(geometry, srid) {
+    if (!is3DCoordinates2(geometry.coordinates)) {
+      throw new GaiaFormatError("writeMultiPolygonZ expects 3D coordinates.");
+    }
+    const writer2 = new BinaryWriter();
+    writeGaiaHeader(
+      writer2,
+      srid,
+      createPolygonMbr(geometry.coordinates),
+      GEO_TYPE_MULTIPOLYGONZ
+    );
+    writer2.writeInt32(geometry.coordinates.length, true);
+    for (const polygon of geometry.coordinates) {
+      writer2.writeUint8(GAIA_ENTITY_MARK2);
+      writer2.writeInt32(GEO_TYPE_POLYGONZ, true);
+      writer2.writeInt32(polygon.length, true);
+      for (const ring of polygon) {
+        writeRing3D(writer2, ring);
+      }
+    }
+    writer2.writeUint8(GAIA_END);
+    return writer2.toUint8Array();
+  }
+};
+
+// src/core/dataset/RegionDataset.ts
+function mapRegionRow(row) {
+  const { SmID, SmGeometry, ...attributes } = row;
+  return {
+    id: SmID,
+    geometry: GaiaPolygonCodec.readMultiPolygon(normalizeGeometryBlob(SmGeometry)),
+    attributes
+  };
+}
+var RegionDataset = class _RegionDataset extends BaseDataset {
+  constructor(driver, info) {
+    super(driver, info);
+    __publicField(this, "registerRepository");
+    this.registerRepository = new SmRegisterRepository(driver);
+  }
+  async getById(id) {
+    const row = await queryOne(
+      this.driver,
+      `SELECT * FROM "${this.info.tableName}" WHERE SmID = ?`,
+      [id]
+    );
+    return row ? mapRegionRow(row) : null;
+  }
+  async list(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const rows = await queryAll(this.driver, sql, params);
+    return rows.map((row) => mapRegionRow(row));
+  }
+  async *iterate(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const statement = await this.driver.prepare(sql);
+    try {
+      if (params.length > 0) {
+        await statement.bind(params);
+      }
+      while (await statement.step()) {
+        yield mapRegionRow(
+          await statement.getRow()
+        );
+      }
+    } finally {
+      await statement.finalize();
+    }
+  }
+  async insert(feature) {
+    const userFields = await this.getFields();
+    const columnNames = ["SmID", "SmUserID", "SmGeometry", ...userFields.map((field) => field.name)];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const geometry = GaiaPolygonCodec.writeMultiPolygon(
+      feature.geometry,
+      feature.geometry.srid ?? this.info.srid ?? 0
+    );
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    const params = [
+      feature.id,
+      0,
+      geometry,
+      ...userFields.map((field) => feature.attributes[field.name] ?? null)
+    ];
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+      await this.registerRepository.incrementObjectCount(this.info.id, geometry.byteLength);
+    });
+  }
+  async insertMany(features) {
+    const userFields = await this.getFields();
+    const columnNames = ["SmID", "SmUserID", "SmGeometry", ...userFields.map((field) => field.name)];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    await this.driver.transaction(async () => {
+      const statement = await this.driver.prepare(sql);
+      try {
+        let count = 0;
+        let maxGeometrySize = 0;
+        for await (const feature of features) {
+          const geometry = GaiaPolygonCodec.writeMultiPolygon(
+            feature.geometry,
+            feature.geometry.srid ?? this.info.srid ?? 0
+          );
+          maxGeometrySize = Math.max(maxGeometrySize, geometry.byteLength);
+          const params = [
+            feature.id,
+            0,
+            geometry,
+            ...userFields.map(
+              (field) => feature.attributes[field.name] ?? null
+            )
+          ];
+          await statement.bind(params);
+          await statement.step();
+          await statement.reset();
+          count++;
+        }
+        if (count > 0) {
+          await this.registerRepository.incrementObjectCountBatch(
+            this.info.id,
+            count,
+            maxGeometrySize
+          );
+        }
+      } finally {
+        await statement.finalize();
+      }
+    });
+  }
+  async count() {
+    const row = await queryOne(
+      this.driver,
+      `SELECT COUNT(*) AS count FROM "${this.info.tableName}"`,
+      []
+    );
+    return row?.count ?? 0;
+  }
+  async update(id, changes) {
+    if (!changes.geometry && !changes.attributes) {
+      return;
+    }
+    const setClauses = [];
+    const params = [];
+    if (changes.geometry) {
+      const geometry = GaiaPolygonCodec.writeMultiPolygon(
+        changes.geometry,
+        changes.geometry.srid ?? this.info.srid ?? 0
+      );
+      setClauses.push('"SmGeometry" = ?');
+      params.push(geometry);
+    }
+    if (changes.attributes) {
+      const userFields = await this.getFields();
+      const fieldNames = new Set(userFields.map((f) => f.name));
+      const validEntries = Object.entries(changes.attributes).filter(
+        ([key]) => fieldNames.has(key)
+      );
+      for (const [key, value] of validEntries) {
+        setClauses.push(`"${key}" = ?`);
+        params.push(value);
+      }
+    }
+    if (setClauses.length === 0) {
+      return;
+    }
+    const sql = `UPDATE "${this.info.tableName}" SET ${setClauses.join(", ")} WHERE SmID = ?`;
+    params.push(id);
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+    });
+  }
+  async delete(id) {
+    await this.driver.transaction(async () => {
+      await executeSql(
+        this.driver,
+        `DELETE FROM "${this.info.tableName}" WHERE SmID = ?`,
+        [id]
+      );
+      await this.registerRepository.decrementObjectCount(this.info.id);
+    });
+  }
+  static async create(driver, registerRepository, params) {
+    const fields = params.fields ?? [];
+    const datasetId = await registerRepository.insert({
+      name: params.name,
+      kind: "region",
+      srid: params.srid,
+      idColumnName: "SmID",
+      geometryColumnName: "SmGeometry"
+    });
+    const userColumnDefinitions = fields.map((field) => {
+      const nullability = field.nullable ? "" : " NOT NULL";
+      return `"${field.name}" ${sqliteColumnType(field)}${nullability}`;
+    });
+    const createTableParts = [
+      `"SmID" INTEGER NOT NULL PRIMARY KEY`,
+      `"SmUserID" INTEGER DEFAULT 0 NOT NULL`,
+      `"SmGeometry" BLOB NOT NULL`,
+      ...userColumnDefinitions
+    ];
+    await driver.exec(
+      `CREATE TABLE "${params.name}" (${createTableParts.join(", ")})`
+    );
+    await executeSql(
+      driver,
+      `INSERT INTO geometry_columns (
+         f_table_name,
+         f_geometry_column,
+         geometry_type,
+         coord_dimension,
+         srid,
+         spatial_index_enabled
+       ) VALUES (?, ?, ?, ?, ?, ?)`,
+      [params.name, "SmGeometry", 6, 2, params.srid, 0]
+    );
+    if (fields.length > 0) {
+      const fieldInfoRepository = new SmFieldInfoRepository(driver);
+      await fieldInfoRepository.insertAll(datasetId, fields);
+    }
+    return new _RegionDataset(driver, {
+      id: datasetId,
+      name: params.name,
+      kind: "region",
+      tableName: params.name,
+      srid: params.srid,
+      objectCount: 0,
+      geometryType: 6
+    });
+  }
+};
+
+// src/core/dataset/RegionZDataset.ts
+function mapRegionZRow(row) {
+  const { SmID, SmGeometry, ...attributes } = row;
+  return {
+    id: SmID,
+    geometry: GaiaPolygonCodec.readMultiPolygonZ(normalizeGeometryBlob(SmGeometry)),
+    attributes
+  };
+}
+var RegionZDataset = class _RegionZDataset extends BaseDataset {
+  constructor(driver, info) {
+    super(driver, info);
+    __publicField(this, "registerRepository");
+    this.registerRepository = new SmRegisterRepository(driver);
+  }
+  async getById(id) {
+    const row = await queryOne(
+      this.driver,
+      `SELECT * FROM "${this.info.tableName}" WHERE SmID = ?`,
+      [id]
+    );
+    return row ? mapRegionZRow(row) : null;
+  }
+  async list(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const rows = await queryAll(this.driver, sql, params);
+    return rows.map((row) => mapRegionZRow(row));
+  }
+  async *iterate(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const statement = await this.driver.prepare(sql);
+    try {
+      if (params.length > 0) {
+        await statement.bind(params);
+      }
+      while (await statement.step()) {
+        yield mapRegionZRow(
+          await statement.getRow()
+        );
+      }
+    } finally {
+      await statement.finalize();
+    }
+  }
+  async count() {
+    const row = await queryOne(
+      this.driver,
+      `SELECT COUNT(*) AS count FROM "${this.info.tableName}"`,
+      []
+    );
+    return row?.count ?? 0;
+  }
+  async insert(feature) {
+    const userFields = await this.getFields();
+    const columnNames = ["SmID", "SmUserID", "SmGeometry", ...userFields.map((field) => field.name)];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const geometry = GaiaPolygonCodec.writeMultiPolygonZ(
+      feature.geometry,
+      feature.geometry.srid ?? this.info.srid ?? 0
+    );
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    const params = [
+      feature.id,
+      0,
+      geometry,
+      ...userFields.map((field) => feature.attributes[field.name] ?? null)
+    ];
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+      await this.registerRepository.incrementObjectCount(this.info.id, geometry.byteLength);
+    });
+  }
+  async insertMany(features) {
+    const userFields = await this.getFields();
+    const columnNames = ["SmID", "SmUserID", "SmGeometry", ...userFields.map((field) => field.name)];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    await this.driver.transaction(async () => {
+      const statement = await this.driver.prepare(sql);
+      try {
+        let count = 0;
+        let maxGeometrySize = 0;
+        for await (const feature of features) {
+          const geometry = GaiaPolygonCodec.writeMultiPolygonZ(
+            feature.geometry,
+            feature.geometry.srid ?? this.info.srid ?? 0
+          );
+          maxGeometrySize = Math.max(maxGeometrySize, geometry.byteLength);
+          const params = [
+            feature.id,
+            0,
+            geometry,
+            ...userFields.map(
+              (field) => feature.attributes[field.name] ?? null
+            )
+          ];
+          await statement.bind(params);
+          await statement.step();
+          await statement.reset();
+          count++;
+        }
+        if (count > 0) {
+          await this.registerRepository.incrementObjectCountBatch(
+            this.info.id,
+            count,
+            maxGeometrySize
+          );
+        }
+      } finally {
+        await statement.finalize();
+      }
+    });
+  }
+  async update(id, changes) {
+    if (!changes.geometry && !changes.attributes) {
+      return;
+    }
+    const setClauses = [];
+    const params = [];
+    if (changes.geometry) {
+      const geometry = GaiaPolygonCodec.writeMultiPolygonZ(
+        changes.geometry,
+        changes.geometry.srid ?? this.info.srid ?? 0
+      );
+      setClauses.push('"SmGeometry" = ?');
+      params.push(geometry);
+    }
+    if (changes.attributes) {
+      const userFields = await this.getFields();
+      const fieldNames = new Set(userFields.map((f) => f.name));
+      const validEntries = Object.entries(changes.attributes).filter(
+        ([key]) => fieldNames.has(key)
+      );
+      for (const [key, value] of validEntries) {
+        setClauses.push(`"${key}" = ?`);
+        params.push(value);
+      }
+    }
+    if (setClauses.length === 0) {
+      return;
+    }
+    const sql = `UPDATE "${this.info.tableName}" SET ${setClauses.join(", ")} WHERE SmID = ?`;
+    params.push(id);
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+    });
+  }
+  async delete(id) {
+    await this.driver.transaction(async () => {
+      await executeSql(
+        this.driver,
+        `DELETE FROM "${this.info.tableName}" WHERE SmID = ?`,
+        [id]
+      );
+      await this.registerRepository.decrementObjectCount(this.info.id);
+    });
+  }
+  static async create(driver, registerRepository, params) {
+    const fields = params.fields ?? [];
+    const datasetId = await registerRepository.insert({
+      name: params.name,
+      kind: "regionZ",
+      srid: params.srid,
+      idColumnName: "SmID",
+      geometryColumnName: "SmGeometry"
+    });
+    const userColumnDefinitions = fields.map((field) => {
+      const nullability = field.nullable ? "" : " NOT NULL";
+      return `"${field.name}" ${sqliteColumnType(field)}${nullability}`;
+    });
+    const createTableParts = [
+      `"SmID" INTEGER NOT NULL PRIMARY KEY`,
+      `"SmUserID" INTEGER DEFAULT 0 NOT NULL`,
+      `"SmGeometry" BLOB NOT NULL`,
+      ...userColumnDefinitions
+    ];
+    await driver.exec(
+      `CREATE TABLE "${params.name}" (${createTableParts.join(", ")})`
+    );
+    await executeSql(
+      driver,
+      `INSERT INTO geometry_columns (
+         f_table_name,
+         f_geometry_column,
+         geometry_type,
+         coord_dimension,
+         srid,
+         spatial_index_enabled
+       ) VALUES (?, ?, ?, ?, ?, ?)`,
+      [params.name, "SmGeometry", 1006, 3, params.srid, 0]
+    );
+    if (fields.length > 0) {
+      const fieldInfoRepository = new SmFieldInfoRepository(driver);
+      await fieldInfoRepository.insertAll(datasetId, fields);
+    }
+    return new _RegionZDataset(driver, {
+      id: datasetId,
+      name: params.name,
+      kind: "regionZ",
+      tableName: params.name,
+      srid: params.srid,
+      objectCount: 0,
+      geometryType: 1006
+    });
+  }
+};
+
+// src/core/dataset/TabularDataset.ts
+var SYSTEM_COLUMN_PREFIX = "Sm";
+function mapTabularRow(row) {
+  const { SmID, ...rest } = row;
+  const attributes = {};
+  for (const [key, value] of Object.entries(rest)) {
+    if (!key.startsWith(SYSTEM_COLUMN_PREFIX)) {
+      attributes[key] = value;
+    }
+  }
+  return {
+    id: SmID,
+    attributes
+  };
+}
+var TabularDataset = class _TabularDataset extends BaseDataset {
+  constructor(driver, info) {
+    super(driver, info);
+    __publicField(this, "registerRepository");
+    this.registerRepository = new SmRegisterRepository(driver);
+  }
+  async getById(id) {
+    const row = await queryOne(
+      this.driver,
+      `SELECT * FROM "${this.info.tableName}" WHERE SmID = ?`,
+      [id]
+    );
+    return row ? mapTabularRow(row) : null;
+  }
+  async list(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const rows = await queryAll(this.driver, sql, params);
+    return rows.map((row) => mapTabularRow(row));
+  }
+  async *iterate(options) {
+    const { sql, params } = buildListSql(this.info.tableName, options);
+    const statement = await this.driver.prepare(sql);
+    try {
+      if (params.length > 0) {
+        await statement.bind(params);
+      }
+      while (await statement.step()) {
+        yield mapTabularRow(
+          await statement.getRow()
+        );
+      }
+    } finally {
+      await statement.finalize();
+    }
+  }
+  async count() {
+    const row = await queryOne(
+      this.driver,
+      `SELECT COUNT(*) AS count FROM "${this.info.tableName}"`,
+      []
+    );
+    return row?.count ?? 0;
+  }
+  async insert(record) {
+    const userFields = await this.getFields();
+    const columnNames = [
+      "SmID",
+      "SmUserID",
+      ...userFields.map((field) => field.name)
+    ];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    const params = [
+      record.id,
+      0,
+      ...userFields.map(
+        (field) => record.attributes[field.name] ?? null
+      )
+    ];
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+      await this.registerRepository.incrementObjectCount(this.info.id);
+    });
+  }
+  async insertMany(records) {
+    const userFields = await this.getFields();
+    const columnNames = [
+      "SmID",
+      "SmUserID",
+      ...userFields.map((field) => field.name)
+    ];
+    const placeholders = columnNames.map(() => "?").join(", ");
+    const sql = `INSERT INTO "${this.info.tableName}" (${columnNames.map((column) => `"${column}"`).join(", ")}) VALUES (${placeholders})`;
+    await this.driver.transaction(async () => {
+      const statement = await this.driver.prepare(sql);
+      try {
+        let count = 0;
+        for await (const record of records) {
+          const params = [
+            record.id,
+            0,
+            ...userFields.map(
+              (field) => record.attributes[field.name] ?? null
+            )
+          ];
+          await statement.bind(params);
+          await statement.step();
+          await statement.reset();
+          count++;
+        }
+        if (count > 0) {
+          await this.registerRepository.incrementObjectCountBatch(
+            this.info.id,
+            count,
+            0
+          );
+        }
+      } finally {
+        await statement.finalize();
+      }
+    });
+  }
+  async update(id, attributes) {
+    const userFields = await this.getFields();
+    const fieldNames = new Set(userFields.map((f) => f.name));
+    const validEntries = Object.entries(attributes).filter(
+      ([key]) => fieldNames.has(key)
+    );
+    if (validEntries.length === 0) return;
+    const keys = validEntries.map(([key]) => key);
+    const setClauses = keys.map((key) => `"${key}" = ?`).join(", ");
+    const sql = `UPDATE "${this.info.tableName}" SET ${setClauses} WHERE SmID = ?`;
+    const params = [
+      ...keys.map((key) => attributes[key]),
+      id
+    ];
+    await this.driver.transaction(async () => {
+      await executeSql(this.driver, sql, params);
+    });
+  }
+  async delete(id) {
+    await this.driver.transaction(async () => {
+      await executeSql(
+        this.driver,
+        `DELETE FROM "${this.info.tableName}" WHERE SmID = ?`,
+        [id]
+      );
+      await this.registerRepository.decrementObjectCount(this.info.id);
+    });
+  }
+  static async create(driver, registerRepository, params) {
+    const fields = params.fields ?? [];
+    const datasetId = await registerRepository.insert({
+      name: params.name,
+      kind: "tabular",
+      srid: 0,
+      idColumnName: "SmID",
+      geometryColumnName: null
+    });
+    const userColumnDefinitions = fields.map((field) => {
+      const nullability = field.nullable ? "" : " NOT NULL";
+      return `"${field.name}" ${sqliteColumnType(field)}${nullability}`;
+    });
+    const createTableParts = [
+      `"SmID" INTEGER NOT NULL PRIMARY KEY`,
+      `"SmUserID" INTEGER DEFAULT 0 NOT NULL`,
+      ...userColumnDefinitions
+    ];
+    await driver.exec(
+      `CREATE TABLE "${params.name}" (${createTableParts.join(", ")})`
+    );
+    if (fields.length > 0) {
+      const fieldInfoRepository = new SmFieldInfoRepository(driver);
+      await fieldInfoRepository.insertAll(datasetId, fields);
+    }
+    return new _TabularDataset(driver, {
+      id: datasetId,
+      name: params.name,
+      kind: "tabular",
+      tableName: params.name,
+      srid: 0,
+      objectCount: 0,
+      geometryType: null
+    });
+  }
+};
+
+// src/core/dataset/TextDataset.ts
+var TextDataset = class extends BaseDataset {
+  async getById() {
+    throw createNotImplementedError("TextDataset.getById");
+  }
+  async list(_options) {
+    throw createNotImplementedError("TextDataset.list");
+  }
+  async *iterate(_options) {
+    throw createNotImplementedError("TextDataset.iterate");
+  }
+  async count() {
+    throw createNotImplementedError("TextDataset.count");
+  }
+  async insert() {
+    throw createNotImplementedError("TextDataset.insert");
+  }
+  async insertMany() {
+    throw createNotImplementedError("TextDataset.insertMany");
+  }
+  async update() {
+    throw createNotImplementedError("TextDataset.update");
+  }
+  async delete() {
+    throw createNotImplementedError("TextDataset.delete");
+  }
+};
+
+// src/core/schema/UdbxSchemaInitializer.ts
+var UDBX_SYSTEM_TABLES = [
+  "spatial_ref_sys",
+  "geometry_columns",
+  "SmDataSourceInfo",
+  "SmRegister",
+  "SmFieldInfo"
+];
+var UDBX_SCHEMA_STATEMENTS = [
+  `CREATE TABLE spatial_ref_sys (
+    srid INTEGER NOT NULL PRIMARY KEY,
+    auth_name TEXT NOT NULL,
+    auth_srid INTEGER NOT NULL,
+    ref_sys_name TEXT NOT NULL DEFAULT 'Unknown',
+    proj4text TEXT NOT NULL,
+    srtext TEXT NOT NULL DEFAULT 'Undefined'
+  )`,
+  `CREATE TABLE geometry_columns (
+    f_table_name TEXT NOT NULL,
+    f_geometry_column TEXT NOT NULL,
+    geometry_type INTEGER NOT NULL,
+    coord_dimension INTEGER NOT NULL,
+    srid INTEGER NOT NULL,
+    spatial_index_enabled INTEGER NOT NULL,
+    CONSTRAINT pk_geom_cols PRIMARY KEY (f_table_name, f_geometry_column)
+  )`,
+  `CREATE TABLE SmDataSourceInfo (
+    SmFlag INTEGER DEFAULT 0 NOT NULL PRIMARY KEY AUTOINCREMENT,
+    SmVersion INTEGER,
+    SmDsDescription TEXT,
+    SmProjectInfo BLOB,
+    SmLastUpdateTime DATE DEFAULT CURRENT_TIMESTAMP NOT NULL,
+    SmDataFormat INTEGER DEFAULT 0 NOT NULL
+  )`,
+  `CREATE TABLE SmRegister (
+    SmDatasetID INTEGER DEFAULT 0 NOT NULL PRIMARY KEY,
+    SmDatasetName TEXT,
+    SmTableName TEXT,
+    SmOption INTEGER,
+    SmEncType INTEGER,
+    SmParentDTID INTEGER DEFAULT 0 NOT NULL,
+    SmDatasetType INTEGER,
+    SmObjectCount INTEGER DEFAULT 0 NOT NULL,
+    SmLeft REAL,
+    SmRight REAL,
+    SmTop REAL,
+    SmBottom REAL,
+    SmIDColName TEXT,
+    SmGeoColName TEXT,
+    SmMinZ REAL,
+    SmMaxZ REAL,
+    SmSRID INTEGER DEFAULT 0,
+    SmIndexType INTEGER DEFAULT 1,
+    SmToleRanceFuzzy REAL,
+    SmToleranceDAngle REAL,
+    SmToleranceNodeSnap REAL,
+    SmToleranceSmallPolygon REAL,
+    SmToleranceGrain REAL,
+    SmMaxGeometrySize INTEGER DEFAULT 0 NOT NULL,
+    SmOptimizeCount INTEGER DEFAULT 0 NOT NULL,
+    SmOptimizeRatio REAL,
+    SmDescription TEXT,
+    SmExtInfo TEXT,
+    SmCreateTime TEXT,
+    SmLastUpdateTime TEXT,
+    SmProjectInfo BLOB
+  )`,
+  `CREATE TABLE SmFieldInfo (
+    SmID INTEGER DEFAULT 0 NOT NULL PRIMARY KEY AUTOINCREMENT,
+    SmDatasetID INTEGER,
+    SmFieldName TEXT,
+    SmFieldCaption TEXT,
+    SmFieldType INTEGER,
+    SmFieldFormat TEXT,
+    SmFieldSign INTEGER,
+    SmFieldDomain TEXT,
+    SmFieldUpdatable INTEGER,
+    SmFieldbRequired INTEGER,
+    SmFieldDefaultValue TEXT,
+    SmFieldSize INTEGER
+  )`,
+  "INSERT INTO SmDataSourceInfo (SmVersion, SmDataFormat) VALUES (0, 1)",
+  "INSERT INTO spatial_ref_sys (srid, auth_name, auth_srid, ref_sys_name, proj4text, srtext) VALUES (0, 'none', 0, 'Undefined', '', 'Undefined')",
+  `INSERT INTO spatial_ref_sys (srid, auth_name, auth_srid, ref_sys_name, proj4text, srtext)
+   VALUES (
+    4326,
+    'epsg',
+    4326,
+    'WGS 84',
+    '+proj=longlat +datum=WGS84 +no_defs',
+    'GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84",6378137,298.257223563]],PRIMEM["Greenwich",0],UNIT["degree",0.0174532925199433],AUTHORITY["EPSG","4326"]]'
+   )`
+];
+var UdbxSchemaInitializer = class {
+  static async isInitialized(driver) {
+    const statement = await driver.prepare(
+      "SELECT name FROM sqlite_master WHERE type = 'table' AND name = ? LIMIT 1"
+    );
+    try {
+      await statement.bind(["SmDataSourceInfo"]);
+      return statement.step();
+    } finally {
+      await statement.finalize();
+    }
+  }
+  static async ensureInitialized(driver) {
+    const initialized = await this.isInitialized(driver);
+    if (initialized) {
+      return false;
+    }
+    await this.initialize(driver);
+    return true;
+  }
+  static async initialize(driver) {
+    await driver.exec("PRAGMA journal_mode = WAL");
+    await driver.transaction(async () => {
+      for (const statement of UDBX_SCHEMA_STATEMENTS) {
+        await driver.exec(statement);
+      }
+    });
+  }
+};
+
+// src/core/datasource/UdbxDataSource.ts
+var UdbxDataSource = class _UdbxDataSource {
+  constructor(driver, runtime = "unknown") {
+    this.driver = driver;
+    this.runtime = runtime;
+    __publicField(this, "registerRepository");
+    this.registerRepository = new SmRegisterRepository(driver);
+  }
+  static async open(params) {
+    await params.driver.open(params.target);
+    return new _UdbxDataSource(params.driver, params.runtime ?? "unknown");
+  }
+  static async create(params) {
+    await params.driver.open(params.target);
+    await UdbxSchemaInitializer.initialize(params.driver);
+    return new _UdbxDataSource(params.driver, params.runtime ?? "unknown");
+  }
+  async listDatasets() {
+    return this.registerRepository.findAll();
+  }
+  async getDataset(name) {
+    const info = await this.registerRepository.findByName(name);
+    if (!info) {
+      return null;
+    }
+    switch (info.kind) {
+      case "point":
+        return new PointDataset(this.driver, info);
+      case "pointZ":
+        return new PointZDataset(this.driver, info);
+      case "line":
+        return new LineDataset(this.driver, info);
+      case "lineZ":
+        return new LineZDataset(this.driver, info);
+      case "region":
+        return new RegionDataset(this.driver, info);
+      case "regionZ":
+        return new RegionZDataset(this.driver, info);
+      case "tabular":
+        return new TabularDataset(this.driver, info);
+      case "text":
+        return new TextDataset(this.driver, info);
+      case "cad":
+        return new CadDataset(this.driver, info);
+      default:
+        return null;
+    }
+  }
+  async createPointDataset(name, srid, fields) {
+    return this.driver.transaction(async () => {
+      const params = fields === void 0 ? { name, srid } : { name, srid, fields };
+      return PointDataset.create(this.driver, this.registerRepository, params);
+    });
+  }
+  async createLineDataset(name, srid, fields) {
+    return this.driver.transaction(async () => {
+      const params = fields === void 0 ? { name, srid } : { name, srid, fields };
+      return LineDataset.create(this.driver, this.registerRepository, params);
+    });
+  }
+  async createRegionDataset(name, srid, fields) {
+    return this.driver.transaction(async () => {
+      const params = fields === void 0 ? { name, srid } : { name, srid, fields };
+      return RegionDataset.create(this.driver, this.registerRepository, params);
+    });
+  }
+  async createPointZDataset(name, srid, fields) {
+    return this.driver.transaction(async () => {
+      const params = fields === void 0 ? { name, srid } : { name, srid, fields };
+      return PointZDataset.create(this.driver, this.registerRepository, params);
+    });
+  }
+  async createLineZDataset(name, srid, fields) {
+    return this.driver.transaction(async () => {
+      const params = fields === void 0 ? { name, srid } : { name, srid, fields };
+      return LineZDataset.create(this.driver, this.registerRepository, params);
+    });
+  }
+  async createRegionZDataset(name, srid, fields) {
+    return this.driver.transaction(async () => {
+      const params = fields === void 0 ? { name, srid } : { name, srid, fields };
+      return RegionZDataset.create(this.driver, this.registerRepository, params);
+    });
+  }
+  async createTabularDataset(name, fields) {
+    return this.driver.transaction(async () => {
+      const params = fields === void 0 ? { name } : { name, fields };
+      return TabularDataset.create(this.driver, this.registerRepository, params);
+    });
+  }
+  async createTextDataset(name, srid, fields) {
+    return this.driver.transaction(async () => {
+      const fieldList = fields ?? [];
+      const datasetId = await this.registerRepository.insert({
+        name,
+        kind: "text",
+        srid,
+        idColumnName: "SmID",
+        geometryColumnName: "SmGeometry"
+      });
+      const userColumnDefinitions = fieldList.map((field) => {
+        const nullability = field.nullable ? "" : " NOT NULL";
+        return `"${field.name}" TEXT${nullability}`;
+      });
+      const createTableParts = [
+        `"SmID" INTEGER NOT NULL PRIMARY KEY`,
+        `"SmUserID" INTEGER DEFAULT 0 NOT NULL`,
+        `"SmGeometry" BLOB`,
+        `"SmIndexKey" POLYGON`,
+        ...userColumnDefinitions
+      ];
+      await this.driver.exec(
+        `CREATE TABLE "${name}" (${createTableParts.join(", ")})`
+      );
+      if (fieldList.length > 0) {
+        const fieldInfoRepository = new SmFieldInfoRepository(this.driver);
+        await fieldInfoRepository.insertAll(datasetId, fieldList);
+      }
+      return new TextDataset(this.driver, {
+        id: datasetId,
+        name,
+        kind: "text",
+        tableName: name,
+        srid,
+        objectCount: 0,
+        geometryType: null
+      });
+    });
+  }
+  async createCadDataset(name, fields) {
+    return this.driver.transaction(async () => {
+      const fieldList = fields ?? [];
+      const datasetId = await this.registerRepository.insert({
+        name,
+        kind: "cad",
+        srid: 0,
+        idColumnName: "SmID",
+        geometryColumnName: "SmGeometry"
+      });
+      const userColumnDefinitions = fieldList.map((field) => {
+        const nullability = field.nullable ? "" : " NOT NULL";
+        return `"${field.name}" TEXT${nullability}`;
+      });
+      const createTableParts = [
+        `"SmID" INTEGER NOT NULL PRIMARY KEY`,
+        `"SmUserID" INTEGER DEFAULT 0 NOT NULL`,
+        `"SmGeometry" BLOB`,
+        ...userColumnDefinitions
+      ];
+      await this.driver.exec(
+        `CREATE TABLE "${name}" (${createTableParts.join(", ")})`
+      );
+      if (fieldList.length > 0) {
+        const fieldInfoRepository = new SmFieldInfoRepository(this.driver);
+        await fieldInfoRepository.insertAll(datasetId, fieldList);
+      }
+      return new CadDataset(this.driver, {
+        id: datasetId,
+        name,
+        kind: "cad",
+        tableName: name,
+        srid: 0,
+        objectCount: 0,
+        geometryType: null
+      });
+    });
+  }
+  async close() {
+    await this.driver.close();
+  }
+};
+
+// src/core/errors.ts
+var UdbxError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UdbxError";
+  }
+};
+var UdbxFormatError = class extends UdbxError {
+  constructor(message) {
+    super(message);
+    this.name = "UdbxFormatError";
+  }
+};
+var UdbxNotFoundError = class extends UdbxError {
+  constructor(what, id) {
+    super(id !== void 0 ? `${what} not found (id=${id})` : `${what} not found`);
+    this.name = "UdbxNotFoundError";
+  }
+};
+var UdbxUnsupportedError = class extends UdbxError {
+  constructor(what) {
+    super(`Unsupported: ${what}`);
+    this.name = "UdbxUnsupportedError";
+  }
+};
+var UdbxConstraintError = class extends UdbxError {
+  constructor(what) {
+    super(`Constraint violation: ${what}`);
+    this.name = "UdbxConstraintError";
+  }
+};
+var UdbxIOError = class extends UdbxError {
+  constructor(cause) {
+    super(cause ? `IO error: ${cause.message}` : "IO error");
+    this.name = "UdbxIOError";
+  }
+};
+
+// src/core/geometry/gaia/GaiaGeometryCodec.ts
+var decodeByGeoType = /* @__PURE__ */ new Map([
+  [GEO_TYPE_POINT, GaiaPointCodec.readPoint],
+  [GEO_TYPE_POINTZ, GaiaPointCodec.readPointZ],
+  [GEO_TYPE_MULTILINESTRING, GaiaLineCodec.readMultiLineString],
+  [GEO_TYPE_MULTILINESTRINGZ, GaiaLineCodec.readMultiLineStringZ],
+  [GEO_TYPE_MULTIPOLYGON, GaiaPolygonCodec.readMultiPolygon],
+  [GEO_TYPE_MULTIPOLYGONZ, GaiaPolygonCodec.readMultiPolygonZ]
+]);
+var pointCodecs = {
+  [GEO_TYPE_POINT]: {
+    geoType: GEO_TYPE_POINT,
+    decode: GaiaPointCodec.readPoint
+  },
+  [GEO_TYPE_POINTZ]: {
+    geoType: GEO_TYPE_POINTZ,
+    decode: GaiaPointCodec.readPointZ
+  }
+};
+var lineCodecs = {
+  [GEO_TYPE_MULTILINESTRING]: {
+    geoType: GEO_TYPE_MULTILINESTRING,
+    decode: GaiaLineCodec.readMultiLineString
+  },
+  [GEO_TYPE_MULTILINESTRINGZ]: {
+    geoType: GEO_TYPE_MULTILINESTRINGZ,
+    decode: GaiaLineCodec.readMultiLineStringZ
+  }
+};
+var polygonCodecs = {
+  [GEO_TYPE_MULTIPOLYGON]: {
+    geoType: GEO_TYPE_MULTIPOLYGON,
+    decode: GaiaPolygonCodec.readMultiPolygon
+  },
+  [GEO_TYPE_MULTIPOLYGONZ]: {
+    geoType: GEO_TYPE_MULTIPOLYGONZ,
+    decode: GaiaPolygonCodec.readMultiPolygonZ
+  }
+};
+function geometryHasZ(geometry) {
+  switch (geometry.type) {
+    case "Point":
+      return geometry.coordinates.length === 3;
+    case "MultiLineString":
+      return geometry.coordinates[0]?.[0]?.length === 3;
+    case "MultiPolygon":
+      return geometry.coordinates[0]?.[0]?.[0]?.length === 3;
+    case "Cad":
+    case "Text":
+      return false;
+    default:
+      return false;
+  }
+}
+function encodeGeometry(geometry, srid) {
+  switch (geometry.type) {
+    case "Point":
+      return geometryHasZ(geometry) ? GaiaPointCodec.writePointZ(geometry, srid) : GaiaPointCodec.writePoint(geometry, srid);
+    case "MultiLineString":
+      return geometryHasZ(geometry) ? GaiaLineCodec.writeMultiLineStringZ(geometry, srid) : GaiaLineCodec.writeMultiLineString(geometry, srid);
+    case "MultiPolygon":
+      return geometryHasZ(geometry) ? GaiaPolygonCodec.writeMultiPolygonZ(geometry, srid) : GaiaPolygonCodec.writeMultiPolygon(geometry, srid);
+    case "Cad":
+      throw new Error("CAD geometry is not supported by GaiaGeometryCodec.");
+    case "Text":
+      throw new Error("Text geometry is not supported by GaiaGeometryCodec.");
+    default:
+      throw new Error(`Unsupported geometry type: ${geometry.type}`);
+  }
+}
+var GaiaGeometryCodec = class {
+  static decode(input) {
+    const header = readGaiaHeader(new BinaryCursor(input));
+    const decoder = decodeByGeoType.get(header.geoType);
+    if (!decoder) {
+      throw new GaiaUnsupportedGeoTypeError(header.geoType);
+    }
+    return decoder(input);
+  }
+  static encode(geometry, srid) {
+    return encodeGeometry(geometry, srid);
+  }
+};
+
+// src/core/geometry/jsts/JstsGeometryAdapter.ts
+var reader = null;
+var writer = null;
+async function getReader() {
+  if (!reader) {
+    const { default: GeoJSONReader } = await import("jsts/org/locationtech/jts/io/GeoJSONReader");
+    const { default: GeometryFactory } = await import("jsts/org/locationtech/jts/geom/GeometryFactory");
+    reader = new GeoJSONReader(new GeometryFactory());
+  }
+  return reader;
+}
+async function getWriter() {
+  if (!writer) {
+    const { default: GeoJSONWriter } = await import("jsts/org/locationtech/jts/io/GeoJSONWriter");
+    writer = new GeoJSONWriter();
+  }
+  return writer;
+}
+async function toJsts(geometry) {
+  const r = await getReader();
+  return r.read(geometry);
+}
+async function fromJsts(jtsGeom) {
+  const w = await getWriter();
+  return w.write(jtsGeom);
+}
+async function toJstsPoint(geometry) {
+  const r = await getReader();
+  return r.read(geometry);
+}
+async function toJstsMultiLineString(geometry) {
+  const r = await getReader();
+  return r.read(geometry);
+}
+async function toJstsMultiPolygon(geometry) {
+  const r = await getReader();
+  return r.read(geometry);
+}
+var JstsGeometryCodec = class {
+  static async decode(input) {
+    const geojson = GaiaGeometryCodec.decode(input);
+    return toJsts(geojson);
+  }
+  static async encode(jtsGeom, srid) {
+    const geojson = await fromJsts(jtsGeom);
+    return GaiaGeometryCodec.encode(geojson, srid);
+  }
+};
+export {
+  BaseDataset,
+  BinaryCursor,
+  BinaryWriter,
+  CadDataset,
+  GAIA_BYTE_ORDER_LE,
+  GAIA_END,
+  GAIA_GEOMETRY_DATA_OFFSET,
+  GAIA_MBR,
+  GAIA_START,
+  GEO_TYPE_MULTILINESTRING,
+  GEO_TYPE_MULTILINESTRINGZ,
+  GEO_TYPE_MULTIPOLYGON,
+  GEO_TYPE_MULTIPOLYGONZ,
+  GEO_TYPE_POINT,
+  GEO_TYPE_POINTZ,
+  GaiaError,
+  GaiaFormatError,
+  GaiaGeoTypeMismatchError,
+  GaiaGeometryCodec,
+  GaiaLineCodec,
+  GaiaPointCodec,
+  GaiaPolygonCodec,
+  GaiaUnsupportedGeoTypeError,
+  JstsGeometryCodec,
+  LineDataset,
+  LineZDataset,
+  NotImplementedError,
+  PointDataset,
+  PointZDataset,
+  RegionDataset,
+  RegionZDataset,
+  SmFieldInfoRepository,
+  SmRegisterRepository,
+  TabularDataset,
+  TextDataset,
+  UDBX_SCHEMA_STATEMENTS,
+  UDBX_SYSTEM_TABLES,
+  UdbxConstraintError,
+  UdbxDataSource,
+  UdbxError,
+  UdbxFormatError,
+  UdbxIOError,
+  UdbxNotFoundError,
+  UdbxSchemaInitializer,
+  UdbxUnsupportedError,
+  createNotImplementedError,
+  datasetKindToValue,
+  datasetValueToKind,
+  fieldTypeToValue,
+  fieldValueToType,
+  fromJsts,
+  readGaiaHeader,
+  toJsts,
+  toJstsMultiLineString,
+  toJstsMultiPolygon,
+  toJstsPoint,
+  validateGaiaEnd,
+  writeGaiaHeader
+};
+//# sourceMappingURL=index.js.map