@lark-apaas/db-schema-sync 0.1.0-alpha.1

package/dist/chunk-QO7QQCAM.js

@@ -0,0 +1,2209 @@
+import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../server/http-client/dist/index.js
+var require_dist = __commonJS({
+  "../../server/http-client/dist/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export(index_exports, {
+      DEFAULT_CLOCK_TOLERANCE_SEC: () => DEFAULT_CLOCK_TOLERANCE_SEC,
+      DEFAULT_JWT_EXPIRE_TIME_MS: () => DEFAULT_JWT_EXPIRE_TIME_MS,
+      HttpClient: () => HttpClient2,
+      HttpError: () => HttpError,
+      generateJWTToken: () => generateJWTToken,
+      parseJWTTokenWithVerify: () => parseJWTTokenWithVerify,
+      registerPlatformPlugin: () => registerPlatformPlugin,
+      resolvePlatformBaseURL: () => resolvePlatformBaseURL
+    });
+    module.exports = __toCommonJS(index_exports);
+    var import_crypto = __require("crypto");
+    var DEFAULT_JWT_EXPIRE_TIME_MS = 30 * 60 * 1e3;
+    var DEFAULT_CLOCK_TOLERANCE_SEC = 60;
+    var JWT_HEADER = {
+      alg: "HS256",
+      typ: "JWT"
+    };
+    function generateJWTToken(customClaims, config) {
+      const nowSeconds = Math.floor(Date.now() / 1e3);
+      const payload = {
+        ...customClaims,
+        iss: customClaims.access_key,
+        iat: nowSeconds,
+        nbf: nowSeconds,
+        exp: nowSeconds + Math.floor(config.expireTimeMs / 1e3),
+        jti: (0, import_crypto.randomUUID)()
+      };
+      const encodedHeader = base64UrlEncode(JSON.stringify(JWT_HEADER));
+      const encodedPayload = base64UrlEncode(JSON.stringify(payload));
+      const signature = sign(`${encodedHeader}.${encodedPayload}`, config.secretKey);
+      return `${encodedHeader}.${encodedPayload}.${signature}`;
+    }
+    function parseJWTTokenWithVerify(tokenString, config, options) {
+      const segments = tokenString.split(".");
+      if (segments.length !== 3) {
+        throw new Error("invalid JWT token format");
+      }
+      const [encodedHeader, encodedPayload, signature] = segments;
+      const headerJson = JSON.parse(base64UrlDecode(encodedHeader));
+      if (headerJson.alg !== "HS256") {
+        throw new Error("unsupported JWT alg");
+      }
+      const expectedSignature = sign(`${encodedHeader}.${encodedPayload}`, config.secretKey);
+      const expectedBuffer = Buffer.from(expectedSignature);
+      const signatureBuffer = Buffer.from(signature);
+      if (expectedBuffer.length !== signatureBuffer.length || !(0, import_crypto.timingSafeEqual)(expectedBuffer, signatureBuffer)) {
+        throw new Error("JWT signature verification failed");
+      }
+      const payload = JSON.parse(base64UrlDecode(encodedPayload));
+      if (!options?.skipExpiration) {
+        const clockTolerance = options?.clockTolerance ?? DEFAULT_CLOCK_TOLERANCE_SEC;
+        const now = Math.floor(Date.now() / 1e3);
+        if (payload.exp !== void 0) {
+          if (payload.exp + clockTolerance < now) {
+            throw new Error(
+              `JWT token expired at ${new Date(payload.exp * 1e3).toISOString()}`
+            );
+          }
+        }
+        if (payload.nbf !== void 0) {
+          if (payload.nbf - clockTolerance > now) {
+            throw new Error(
+              `JWT token not yet valid, will be valid at ${new Date(payload.nbf * 1e3).toISOString()}`
+            );
+          }
+        }
+        if (payload.iat !== void 0) {
+          if (payload.iat - clockTolerance > now) {
+            throw new Error(
+              `JWT token issued in the future at ${new Date(payload.iat * 1e3).toISOString()}`
+            );
+          }
+        }
+      }
+      return payload;
+    }
+    function sign(input, secret) {
+      return (0, import_crypto.createHmac)("sha256", secret).update(input).digest("base64").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+    }
+    function base64UrlEncode(input) {
+      return Buffer.from(input).toString("base64").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+    }
+    function base64UrlDecode(input) {
+      const padLength = (4 - (input.length % 4 || 4)) % 4;
+      const padded = `${input}${"=".repeat(padLength)}`.replace(/-/g, "+").replace(/_/g, "/");
+      return Buffer.from(padded, "base64").toString("utf8");
+    }
+    var JWTTokenManager = class {
+      cache = /* @__PURE__ */ new Map();
+      config;
+      constructor(config) {
+        this.config = {
+          refreshBeforeMs: 5 * 60 * 1e3,
+          // 默认 5 分钟
+          ...config
+        };
+      }
+      /**
+       * 获取 JWT token，优先使用缓存
+       *
+       * 如果缓存的 token 即将过期（距离过期时间小于 refreshBeforeMs），
+       * 则会生成新的 token 并更新缓存
+       *
+       * @param claims - JWT claims
+       * @returns JWT token 字符串
+       */
+      getToken(claims) {
+        const cacheKey = this.getCacheKey(claims);
+        const cached = this.cache.get(cacheKey);
+        const now = Date.now();
+        if (cached && cached.expiresAtMs - now > this.config.refreshBeforeMs) {
+          return cached.token;
+        }
+        const token = generateJWTToken(claims, this.config);
+        const expiresAtMs = now + this.config.expireTimeMs;
+        this.cache.set(cacheKey, { token, expiresAtMs });
+        return token;
+      }
+      /**
+       * 清除所有缓存的 token
+       */
+      clearCache() {
+        this.cache.clear();
+      }
+      /**
+       * 清除特定 claims 的缓存
+       *
+       * @param claims - 要清除的 claims
+       */
+      clearCacheFor(claims) {
+        const cacheKey = this.getCacheKey(claims);
+        this.cache.delete(cacheKey);
+      }
+      /**
+       * 生成缓存 key（基于关键的 claims 字段）
+       *
+       * 使用稳定的字段顺序确保相同 claims 生成相同 key
+       *
+       * @private
+       */
+      getCacheKey(claims) {
+        const parts = [
+          claims.access_key,
+          claims.tenant_id?.toString() || "",
+          claims.user_id || "",
+          claims.app_id || "",
+          claims.app_env || "",
+          claims.sandbox_id || ""
+        ];
+        return parts.join(":");
+      }
+      /**
+       * 获取缓存统计信息（用于监控和调试）
+       *
+       * @returns 缓存统计信息
+       */
+      getCacheStats() {
+        const now = Date.now();
+        let validCount = 0;
+        let expiredCount = 0;
+        for (const cached of this.cache.values()) {
+          if (cached.expiresAtMs > now) {
+            validCount++;
+          } else {
+            expiredCount++;
+          }
+        }
+        return {
+          total: this.cache.size,
+          valid: validCount,
+          expired: expiredCount
+        };
+      }
+    };
+    var DEFAULT_DOMAIN_ENV = "FORCE_AUTHN_INNERAPI_DOMAIN";
+    var DEFAULT_ACCESS_KEY_ENV = "FORCE_AUTHN_ACCESS_KEY";
+    var DEFAULT_SECRET_KEY_ENV = "FORCE_AUTHN_ACCESS_SECRET";
+    function resolvePlatformBaseURL(options) {
+      if (!options?.enabled) {
+        return options?.baseURL;
+      }
+      if (options.baseURL) {
+        return options.baseURL;
+      }
+      const envName = options.domainEnv || DEFAULT_DOMAIN_ENV;
+      const domain = process.env[envName];
+      if (!domain) {
+        throw new Error(`\u5E73\u53F0\u6A21\u5F0F\u9700\u8981\u57FA\u7840\u57DF\u540D\uFF0C\u8BF7\u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF ${envName}`);
+      }
+      return domain;
+    }
+    function registerPlatformPlugin(interceptors, options) {
+      if (!options.enabled) {
+        return void 0;
+      }
+      ensureNoAccessKeyOverride("platform.defaultClaims", options.defaultClaims);
+      const accessKeyEnv = options.accessKeyEnv || DEFAULT_ACCESS_KEY_ENV;
+      const secretKeyEnv = options.secretKeyEnv || DEFAULT_SECRET_KEY_ENV;
+      const accessKey = options.accessKey ?? (process.env[accessKeyEnv] || "");
+      const secretKey = options.secretKey ?? (process.env[secretKeyEnv] || "");
+      const expireTimeMs = options.expireTimeMs ?? DEFAULT_JWT_EXPIRE_TIME_MS;
+      const tokenManager = new JWTTokenManager({
+        accessKey,
+        secretKey,
+        expireTimeMs,
+        refreshBeforeMs: options.refreshBeforeMs
+      });
+      interceptors.request.use((config) => {
+        ensureNoAccessKeyOverride("request.platformAuth.customClaims", config.platformAuth?.customClaims);
+        const claims = {
+          ...options.defaultClaims || {},
+          ...config.platformAuth?.customClaims || {},
+          access_key: accessKey
+        };
+        const token = tokenManager.getToken(claims);
+        const headers = {
+          ...config.headers,
+          "Authorization": `Bearer ${token}`,
+          "x-api-key": accessKey
+        };
+        return {
+          ...config,
+          headers
+        };
+      });
+      return tokenManager;
+    }
+    function ensureNoAccessKeyOverride(name, claims) {
+      if (claims && Object.prototype.hasOwnProperty.call(claims, "access_key")) {
+        throw new Error(`${name} \u4E0D\u5141\u8BB8\u8BBE\u7F6E access_key`);
+      }
+    }
+    var InterceptorManager = class {
+      interceptors = [];
+      /**
+       * 添加拦截器
+       * @returns 拦截器 ID，用于后续移除
+       */
+      use(onFulfilled, onRejected) {
+        this.interceptors.push({ onFulfilled, onRejected });
+        return this.interceptors.length - 1;
+      }
+      /**
+       * 移除拦截器
+       */
+      eject(id) {
+        if (this.interceptors[id]) {
+          this.interceptors[id] = null;
+        }
+      }
+      /**
+       * 清空所有拦截器
+       */
+      clear() {
+        this.interceptors = [];
+      }
+      /**
+       * 遍历所有拦截器
+       */
+      forEach(fn) {
+        this.interceptors.forEach((interceptor) => {
+          if (interceptor !== null) {
+            fn(interceptor);
+          }
+        });
+      }
+    };
+    function isPlainObject(value) {
+      if (typeof value !== "object" || value === null) {
+        return false;
+      }
+      const proto = Object.getPrototypeOf(value);
+      return proto === Object.prototype || proto === null;
+    }
+    function normalizeHeaders(headers) {
+      if (!headers) {
+        return {};
+      }
+      if (headers instanceof Headers) {
+        const normalized2 = {};
+        headers.forEach((value, key) => {
+          normalized2[key] = value;
+        });
+        return normalized2;
+      }
+      if (Array.isArray(headers)) {
+        return headers.reduce((acc, [key, value]) => {
+          acc[key] = value;
+          return acc;
+        }, {});
+      }
+      const normalized = {};
+      Object.entries(headers).forEach(
+        ([key, value]) => {
+          const normalizedValue = Array.isArray(value) ? value.join(",") : value;
+          normalized[key] = normalizedValue;
+        }
+      );
+      return normalized;
+    }
+    var HttpError = class _HttpError extends Error {
+      isHttpError = true;
+      response;
+      config;
+      constructor(response, config, message) {
+        super(message || `Request failed with status ${response?.status || "unknown"}`);
+        this.name = "HttpError";
+        this.response = response;
+        this.config = sanitizeConfig(config);
+        Object.setPrototypeOf(this, _HttpError.prototype);
+      }
+    };
+    function sanitizeConfig(config) {
+      const { headers, ...rest } = config;
+      return {
+        ...rest,
+        headers: sanitizeHeaders(headers)
+      };
+    }
+    function sanitizeHeaders(headers) {
+      if (!headers) {
+        return void 0;
+      }
+      const normalized = normalizeHeaders(headers);
+      const sanitized = {};
+      const sensitiveHeaders = ["authorization", "x-api-key", "cookie", "x-secret"];
+      for (const [key, value] of Object.entries(normalized)) {
+        const lowerKey = key.toLowerCase();
+        if (sensitiveHeaders.includes(lowerKey)) {
+          sanitized[key] = "[REDACTED]";
+        } else {
+          sanitized[key] = value;
+        }
+      }
+      return sanitized;
+    }
+    var HttpClient2 = class {
+      defaultConfig;
+      securityConfig;
+      /**
+       * 拦截器管理器（API 与 Axios 一致）
+       */
+      interceptors = {
+        request: new InterceptorManager(),
+        response: new InterceptorManager()
+      };
+      constructor(config) {
+        const { platform, security, ...restConfig } = config || {};
+        this.defaultConfig = {
+          timeout: 5e3,
+          ...restConfig
+        };
+        const strictMode = security?.strictMode ?? false;
+        this.securityConfig = {
+          allowedProtocols: strictMode ? ["http:", "https:"] : null,
+          maxResponseSize: strictMode ? 50 * 1024 * 1024 : 0,
+          // 50MB
+          strictMode,
+          ...security
+        };
+        if (platform?.enabled) {
+          if (!this.defaultConfig.baseURL) {
+            this.defaultConfig.baseURL = resolvePlatformBaseURL(platform);
+          }
+          registerPlatformPlugin(this.interceptors, platform);
+        }
+      }
+      /**
+       * GET 请求
+       */
+      async get(url, config) {
+        return this.request({ ...config, url, method: "GET" });
+      }
+      /**
+       * POST 请求
+       */
+      async post(url, data, config) {
+        const headers = { ...config?.headers };
+        let body = data;
+        if (isPlainObject(data)) {
+          body = JSON.stringify(data);
+          if (!Object.keys(headers).some((key) => key.toLowerCase() === "content-type")) {
+            headers["Content-Type"] = "application/json";
+          }
+        }
+        return this.request({
+          ...config,
+          url,
+          method: "POST",
+          body,
+          headers
+        });
+      }
+      /**
+       * PUT 请求
+       */
+      async put(url, data, config) {
+        const headers = { ...config?.headers };
+        let body = data;
+        if (isPlainObject(data)) {
+          body = JSON.stringify(data);
+          if (!Object.keys(headers).some((key) => key.toLowerCase() === "content-type")) {
+            headers["Content-Type"] = "application/json";
+          }
+        }
+        return this.request({
+          ...config,
+          url,
+          method: "PUT",
+          body,
+          headers
+        });
+      }
+      /**
+       * DELETE 请求
+       */
+      async delete(url, config) {
+        return this.request({ ...config, url, method: "DELETE" });
+      }
+      /**
+       * PATCH 请求
+       */
+      async patch(url, data, config) {
+        const headers = { ...config?.headers };
+        let body = data;
+        if (isPlainObject(data)) {
+          body = JSON.stringify(data);
+          if (!Object.keys(headers).some((key) => key.toLowerCase() === "content-type")) {
+            headers["Content-Type"] = "application/json";
+          }
+        }
+        return this.request({
+          ...config,
+          url,
+          method: "PATCH",
+          body,
+          headers
+        });
+      }
+      /**
+       * 核心请求方法（fetch 风格）
+       */
+      async request(config) {
+        const baseHeaders = normalizeHeaders(this.defaultConfig.headers);
+        const overrideHeaders = normalizeHeaders(config.headers);
+        const mergedKeyMap = {};
+        for (const key in baseHeaders) {
+          mergedKeyMap[key.toLowerCase()] = { key, value: baseHeaders[key] };
+        }
+        for (const key in overrideHeaders) {
+          mergedKeyMap[key.toLowerCase()] = { key, value: overrideHeaders[key] };
+        }
+        const finalHeaders = {};
+        for (const lowerKey in mergedKeyMap) {
+          const { key, value } = mergedKeyMap[lowerKey];
+          finalHeaders[key] = value;
+        }
+        let mergedConfig = {
+          ...this.defaultConfig,
+          ...config,
+          headers: finalHeaders
+        };
+        try {
+          mergedConfig = await this.runRequestInterceptors(mergedConfig);
+        } catch (error) {
+          return Promise.reject(error);
+        }
+        mergedConfig.headers = normalizeHeaders(mergedConfig.headers);
+        const fullUrl = this.buildUrl(mergedConfig.url, mergedConfig.params);
+        const timeout = mergedConfig.timeout || this.defaultConfig.timeout || 5e3;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        const externalSignal = mergedConfig.signal;
+        if (externalSignal) {
+          if (externalSignal.aborted) {
+            clearTimeout(timeoutId);
+            controller.abort();
+          } else {
+            externalSignal.addEventListener("abort", () => controller.abort(), { once: true });
+          }
+        }
+        const { platformAuth, params, timeout: _timeout, baseURL, url, ...fetchOptions } = mergedConfig;
+        try {
+          const response = await fetch(fullUrl, {
+            ...fetchOptions,
+            signal: controller.signal
+            // 传递我们自己的 controller signal
+          });
+          clearTimeout(timeoutId);
+          if (this.securityConfig.maxResponseSize > 0) {
+            const contentLength = response.headers.get("content-length");
+            if (contentLength) {
+              const size = parseInt(contentLength, 10);
+              if (size > this.securityConfig.maxResponseSize) {
+                throw new Error(
+                  `Response size ${size} bytes exceeds limit of ${this.securityConfig.maxResponseSize} bytes`
+                );
+              }
+            }
+          }
+          if (!response.ok) {
+            const error = new HttpError(response, mergedConfig);
+            return this.runResponseInterceptors(Promise.reject(error));
+          }
+          return this.runResponseInterceptors(Promise.resolve(response));
+        } catch (error) {
+          clearTimeout(timeoutId);
+          const httpError = error instanceof HttpError ? error : new HttpError(
+            void 0,
+            mergedConfig,
+            error.name === "AbortError" ? "Request aborted" : error.message
+          );
+          return this.runResponseInterceptors(Promise.reject(httpError));
+        }
+      }
+      /**
+       * 执行请求拦截器链
+       */
+      runRequestInterceptors(config) {
+        let promise = Promise.resolve(config);
+        const interceptors = [];
+        this.interceptors.request.forEach((interceptor) => {
+          interceptors.push(interceptor);
+        });
+        for (const interceptor of interceptors) {
+          promise = promise.then(
+            interceptor.onFulfilled,
+            interceptor.onRejected
+          );
+        }
+        return promise;
+      }
+      /**
+       * 执行响应拦截器链
+       */
+      async runResponseInterceptors(promise) {
+        let currentPromise = promise;
+        const interceptors = [];
+        this.interceptors.response.forEach((interceptor) => {
+          interceptors.push(interceptor);
+        });
+        for (const interceptor of interceptors) {
+          currentPromise = currentPromise.then(
+            interceptor.onFulfilled,
+            interceptor.onRejected
+          );
+        }
+        return currentPromise;
+      }
+      /**
+       * 构建完整 URL（包含 baseURL 和 query params）
+       */
+      buildUrl(url, params) {
+        const baseURL = this.defaultConfig.baseURL;
+        let combinedUrl;
+        if (!baseURL || /^https?:\/\//i.test(url)) {
+          combinedUrl = url;
+        } else {
+          combinedUrl = baseURL.replace(/\/+$/, "") + "/" + url.replace(/^\/+/, "");
+        }
+        const fullUrl = new URL(combinedUrl);
+        const { allowedProtocols } = this.securityConfig;
+        if (allowedProtocols && !allowedProtocols.includes(fullUrl.protocol)) {
+          throw new Error(
+            `Protocol ${fullUrl.protocol} is not allowed. Allowed: ${allowedProtocols.join(", ")}`
+          );
+        }
+        if (params) {
+          for (const [key, value] of Object.entries(params)) {
+            if (value === void 0 || value === null) continue;
+            fullUrl.searchParams.set(key, String(value));
+          }
+        }
+        return fullUrl.href;
+      }
+    };
+  }
+});
+
+// ../../../node_modules/tiny-pinyin/dist/dict.js
+var require_dict = __commonJS({
+  "../../../node_modules/tiny-pinyin/dist/dict.js"(exports, module) {
+    "use strict";
+    var UNIHANS = ["\u963F", "\u54CE", "\u5B89", "\u80AE", "\u51F9", "\u516B", "\u6300", "\u6273", "\u90A6", "\u52F9", "\u9642", "\u5954", "\u4F3B", "\u5C44", "\u8FB9", "\u706C", "\u618B", "\u6C43", "\u51AB", "\u7676", "\u5CEC", "\u5693", "\u5072", "\u53C2", "\u4ED3", "\u64A1", "\u518A", "\u5D7E", "\u66FD", "\u53C9", "\u8286", "\u8FBF", "\u4F25", "\u6284", "\u8F66", "\u62BB", "\u9637", "\u5403", "\u5145", "\u62BD", "\u51FA", "\u6B3B", "\u63E3", "\u5DDB", "\u5205", "\u5439", "\u65FE", "\u9034", "\u5472", "\u5306", "\u51D1", "\u7C97", "\u6C46", "\u5D14", "\u90A8", "\u6413", "\u5491", "\u5446", "\u4E39", "\u5F53", "\u5200", "\u561A", "\u6265", "\u706F", "\u6C10", "\u7538", "\u5201", "\u7239", "\u4E01", "\u4E1F", "\u4E1C", "\u543A", "\u53BE", "\u8011", "\u5796", "\u5428", "\u591A", "\u59B8", "\u8BF6", "\u5940", "\u97A5", "\u513F", "\u53D1", "\u5E06", "\u531A", "\u98DE", "\u5206", "\u4E30", "\u8985", "\u4ECF", "\u7D11", "\u592B", "\u65EE", "\u4F85", "\u7518", "\u5188", "\u768B", "\u6208", "\u7ED9", "\u6839", "\u522F", "\u5DE5", "\u52FE", "\u4F30", "\u74DC", "\u4E56", "\u5173", "\u5149", "\u5F52", "\u4E28", "\u5459", "\u54C8", "\u548D", "\u4F44", "\u592F", "\u8320", "\u8BC3", "\u9ED2", "\u62EB", "\u4EA8", "\u5677", "\u53FF", "\u9F41", "\u4E4E", "\u82B1", "\u6000", "\u6B22", "\u5DDF", "\u7070", "\u660F", "\u5419", "\u4E0C", "\u52A0", "\u620B", "\u6C5F", "\u827D", "\u9636", "\u5DFE", "\u5755", "\u5182", "\u4E29", "\u51E5", "\u59E2", "\u5658", "\u519B", "\u5494", "\u5F00", "\u520A", "\u5FFC", "\u5C3B", "\u533C", "\u808E", "\u52A5", "\u7A7A", "\u62A0", "\u625D", "\u5938", "\u84AF", "\u5BBD", "\u5321", "\u4E8F", "\u5764", "\u6269", "\u5783", "\u6765", "\u5170", "\u5577", "\u635E", "\u808B", "\u52D2", "\u5D1A", "\u54E9", "\u4FE9", "\u5941", "\u826F", "\u64A9", "\u6BDF", "\u62CE", "\u4F36", "\u6E9C", "\u56D6", "\u9F99", "\u779C", "\u565C", "\u9A74", "\u5A08", "\u63A0", "\u62A1", "\u7F57", "\u5463", "\u5988", "\u57CB", "\u5ADA", "\u7264", "\u732B", "\u4E48", "\u5445", "\u95E8", "\u753F", "\u54AA", "\u5B80", "\u55B5", "\u4E5C", "\u6C11", "\u540D", "\u8C2C", "\u6478", "\u54DE", "\u6BEA", "\u55EF", "\u62CF", "\u8149", "\u56E1", "\u56D4", "\u5B6C", "\u7592", "\u5A1E", "\u6041", "\u80FD", "\u59AE", "\u62C8", "\u5A18", "\u9E1F", "\u634F", "\u56DC", "\u5B81", "\u599E", "\u519C", "\u7FBA", "\u5974", "\u5973", "\u597B", "\u759F", "\u9EC1", "\u632A", "\u5594", "\u8BB4", "\u5991", "\u62CD", "\u7705", "\u4E53", "\u629B", "\u5478", "\u55B7", "\u5309", "\u4E15", "\u56E8", "\u527D", "\u6C15", "\u59D8", "\u4E52", "\u948B", "\u5256", "\u4EC6", "\u4E03", "\u6390", "\u5343", "\u545B", "\u6084", "\u767F", "\u4EB2", "\u9751", "\u536D", "\u4E18", "\u533A", "\u5CD1", "\u7F3A", "\u590B", "\u5465", "\u7A63", "\u5A06", "\u60F9", "\u4EBA", "\u6254", "\u65E5", "\u8338", "\u53B9", "\u909A", "\u633C", "\u5827", "\u5A51", "\u77A4", "\u637C", "\u4EE8", "\u6BE2", "\u4E09", "\u6852", "\u63BB", "\u95AA", "\u68EE", "\u50E7", "\u6740", "\u7B5B", "\u5C71", "\u4F24", "\u5F30", "\u5962", "\u7533", "\u5347", "\u5C38", "\u53CE", "\u4E66", "\u5237", "\u8870", "\u95E9", "\u53CC", "\u813D", "\u542E", "\u8BF4", "\u53B6", "\u5FEA", "\u635C", "\u82CF", "\u72FB", "\u590A", "\u5B59", "\u5506", "\u4ED6", "\u56FC", "\u574D", "\u6C64", "\u5932", "\u5FD1", "\u71A5", "\u5254", "\u5929", "\u65EB", "\u5E16", "\u5385", "\u56F2", "\u5077", "\u51F8", "\u6E4D", "\u63A8", "\u541E", "\u4E47", "\u7A75", "\u6B6A", "\u5F2F", "\u5C23", "\u5371", "\u6637", "\u7FC1", "\u631D", "\u4E4C", "\u5915", "\u8672", "\u4ED9", "\u4E61", "\u7071", "\u4E9B", "\u5FC3", "\u661F", "\u51F6", "\u4F11", "\u5401", "\u5405", "\u524A", "\u5743", "\u4E2B", "\u6079", "\u592E", "\u5E7A", "\u503B", "\u4E00", "\u56D9", "\u5E94", "\u54DF", "\u4F63", "\u4F18", "\u625C", "\u56E6", "\u66F0", "\u6655", "\u5E00", "\u707D", "\u5142", "\u5328", "\u50AE", "\u5219", "\u8D3C", "\u600E", "\u5897", "\u624E", "\u635A", "\u6CBE", "\u5F20", "\u4F4B", "\u8707", "\u8D1E", "\u4E89", "\u4E4B", "\u4E2D", "\u5DDE", "\u6731", "\u6293", "\u62FD", "\u4E13", "\u5986", "\u96B9", "\u5B92", "\u5353", "\u4E72", "\u5B97", "\u90B9", "\u79DF", "\u94BB", "\u539C", "\u5C0A", "\u6628", "\u5159"];
+    var PINYINS = ["A", "AI", "AN", "ANG", "AO", "BA", "BAI", "BAN", "BANG", "BAO", "BEI", "BEN", "BENG", "BI", "BIAN", "BIAO", "BIE", "BIN", "BING", "BO", "BU", "CA", "CAI", "CAN", "CANG", "CAO", "CE", "CEN", "CENG", "CHA", "CHAI", "CHAN", "CHANG", "CHAO", "CHE", "CHEN", "CHENG", "CHI", "CHONG", "CHOU", "CHU", "CHUA", "CHUAI", "CHUAN", "CHUANG", "CHUI", "CHUN", "CHUO", "CI", "CONG", "COU", "CU", "CUAN", "CUI", "CUN", "CUO", "DA", "DAI", "DAN", "DANG", "DAO", "DE", "DEN", "DENG", "DI", "DIAN", "DIAO", "DIE", "DING", "DIU", "DONG", "DOU", "DU", "DUAN", "DUI", "DUN", "DUO", "E", "EI", "EN", "ENG", "ER", "FA", "FAN", "FANG", "FEI", "FEN", "FENG", "FIAO", "FO", "FOU", "FU", "GA", "GAI", "GAN", "GANG", "GAO", "GE", "GEI", "GEN", "GENG", "GONG", "GOU", "GU", "GUA", "GUAI", "GUAN", "GUANG", "GUI", "GUN", "GUO", "HA", "HAI", "HAN", "HANG", "HAO", "HE", "HEI", "HEN", "HENG", "HM", "HONG", "HOU", "HU", "HUA", "HUAI", "HUAN", "HUANG", "HUI", "HUN", "HUO", "JI", "JIA", "JIAN", "JIANG", "JIAO", "JIE", "JIN", "JING", "JIONG", "JIU", "JU", "JUAN", "JUE", "JUN", "KA", "KAI", "KAN", "KANG", "KAO", "KE", "KEN", "KENG", "KONG", "KOU", "KU", "KUA", "KUAI", "KUAN", "KUANG", "KUI", "KUN", "KUO", "LA", "LAI", "LAN", "LANG", "LAO", "LE", "LEI", "LENG", "LI", "LIA", "LIAN", "LIANG", "LIAO", "LIE", "LIN", "LING", "LIU", "LO", "LONG", "LOU", "LU", "LV", "LUAN", "LVE", "LUN", "LUO", "M", "MA", "MAI", "MAN", "MANG", "MAO", "ME", "MEI", "MEN", "MENG", "MI", "MIAN", "MIAO", "MIE", "MIN", "MING", "MIU", "MO", "MOU", "MU", "N", "NA", "NAI", "NAN", "NANG", "NAO", "NE", "NEI", "NEN", "NENG", "NI", "NIAN", "NIANG", "NIAO", "NIE", "NIN", "NING", "NIU", "NONG", "NOU", "NU", "NV", "NUAN", "NVE", "NUN", "NUO", "O", "OU", "PA", "PAI", "PAN", "PANG", "PAO", "PEI", "PEN", "PENG", "PI", "PIAN", "PIAO", "PIE", "PIN", "PING", "PO", "POU", "PU", "QI", "QIA", "QIAN", "QIANG", "QIAO", "QIE", "QIN", "QING", "QIONG", "QIU", "QU", "QUAN", "QUE", "QUN", "RAN", "RANG", "RAO", "RE", "REN", "RENG", "RI", "RONG", "ROU", "RU", "RUA", "RUAN", "RUI", "RUN", "RUO", "SA", "SAI", "SAN", "SANG", "SAO", "SE", "SEN", "SENG", "SHA", "SHAI", "SHAN", "SHANG", "SHAO", "SHE", "SHEN", "SHENG", "SHI", "SHOU", "SHU", "SHUA", "SHUAI", "SHUAN", "SHUANG", "SHUI", "SHUN", "SHUO", "SI", "SONG", "SOU", "SU", "SUAN", "SUI", "SUN", "SUO", "TA", "TAI", "TAN", "TANG", "TAO", "TE", "TENG", "TI", "TIAN", "TIAO", "TIE", "TING", "TONG", "TOU", "TU", "TUAN", "TUI", "TUN", "TUO", "WA", "WAI", "WAN", "WANG", "WEI", "WEN", "WENG", "WO", "WU", "XI", "XIA", "XIAN", "XIANG", "XIAO", "XIE", "XIN", "XING", "XIONG", "XIU", "XU", "XUAN", "XUE", "XUN", "YA", "YAN", "YANG", "YAO", "YE", "YI", "YIN", "YING", "YO", "YONG", "YOU", "YU", "YUAN", "YUE", "YUN", "ZA", "ZAI", "ZAN", "ZANG", "ZAO", "ZE", "ZEI", "ZEN", "ZENG", "ZHA", "ZHAI", "ZHAN", "ZHANG", "ZHAO", "ZHE", "ZHEN", "ZHENG", "ZHI", "ZHONG", "ZHOU", "ZHU", "ZHUA", "ZHUAI", "ZHUAN", "ZHUANG", "ZHUI", "ZHUN", "ZHUO", "ZI", "ZONG", "ZOU", "ZU", "ZUAN", "ZUI", "ZUN", "ZUO", ""];
+    var EXCEPTIONS = {
+      "\u66FE": "ZENG",
+      // CENG 曾
+      "\u6C88": "SHEN",
+      // CHEN 沈
+      "\u55F2": "DIA",
+      // DIE 嗲
+      "\u78A1": "ZHOU",
+      // DU 碡
+      "\u8052": "GUO",
+      // GUA 聒
+      "\u7094": "QUE",
+      // GUI 炔
+      "\u86B5": "KE",
+      // HE 蚵
+      "\u7809": "HUA",
+      // HUO 砉
+      "\u5B24": "MO",
+      // MA 嬤
+      "\u5B37": "MO",
+      // MA 嬷
+      "\u8E52": "PAN",
+      // MAN 蹒
+      "\u8E4A": "XI",
+      // QI 蹊
+      "\u4E2C": "PAN",
+      // QIANG 丬
+      "\u9730": "XIAN",
+      // SAN 霰
+      "\u8398": "XIN",
+      // SHEN 莘
+      "\u8C49": "CHI",
+      // SHI 豉
+      "\u9967": "XING",
+      // TANG 饧
+      "\u7B60": "JUN",
+      // YUN 筠
+      "\u957F": "CHANG",
+      // ZHANG 长
+      "\u5E27": "ZHEN",
+      // ZHENG 帧
+      "\u5CD9": "SHI",
+      // ZHI 峙
+      "\u90CD": "NA",
+      "\u828E": "XIONG",
+      "\u8C01": "SHUI"
+    };
+    module.exports = {
+      PINYINS,
+      UNIHANS,
+      EXCEPTIONS
+    };
+  }
+});
+
+// ../../../node_modules/tiny-pinyin/dist/core.js
+var require_core = __commonJS({
+  "../../../node_modules/tiny-pinyin/dist/core.js"(exports, module) {
+    "use strict";
+    var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) {
+      return typeof obj;
+    } : function(obj) {
+      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    };
+    var DICT = require_dict();
+    var FIRST_PINYIN_UNIHAN = "\u963F";
+    var LAST_PINYIN_UNIHAN = "\u9FFF";
+    var LATIN = 1;
+    var PINYIN = 2;
+    var UNKNOWN = 3;
+    var supported = null;
+    var COLLATOR = void 0;
+    function patchDict(patchers) {
+      if (!patchers) return;
+      if (typeof patchers === "function") {
+        patchers = [patchers];
+      }
+      if (patchers.forEach) {
+        patchers.forEach(function(p) {
+          typeof p === "function" && p(DICT);
+        });
+      }
+    }
+    function isSupported(force) {
+      if (!force && supported !== null) {
+        return supported;
+      }
+      if ((typeof Intl === "undefined" ? "undefined" : _typeof(Intl)) === "object" && Intl.Collator) {
+        COLLATOR = new Intl.Collator(["zh-Hans-CN", "zh-CN"]);
+        supported = Intl.Collator.supportedLocalesOf(["zh-CN"]).length === 1;
+      } else {
+        supported = false;
+      }
+      return supported;
+    }
+    function genToken(ch) {
+      var UNIHANS = DICT.UNIHANS;
+      var PINYINS = DICT.PINYINS;
+      var EXCEPTIONS = DICT.EXCEPTIONS;
+      var token = {
+        source: ch
+        // First check EXCEPTIONS map, then search with UNIHANS table.
+      };
+      if (ch in EXCEPTIONS) {
+        token.type = PINYIN;
+        token.target = EXCEPTIONS[ch];
+        return token;
+      }
+      var offset = -1;
+      var cmp = void 0;
+      if (ch.charCodeAt(0) < 256) {
+        token.type = LATIN;
+        token.target = ch;
+        return token;
+      } else {
+        cmp = COLLATOR.compare(ch, FIRST_PINYIN_UNIHAN);
+        if (cmp < 0) {
+          token.type = UNKNOWN;
+          token.target = ch;
+          return token;
+        } else if (cmp === 0) {
+          token.type = PINYIN;
+          offset = 0;
+        } else {
+          cmp = COLLATOR.compare(ch, LAST_PINYIN_UNIHAN);
+          if (cmp > 0) {
+            token.type = UNKNOWN;
+            token.target = ch;
+            return token;
+          } else if (cmp === 0) {
+            token.type = PINYIN;
+            offset = UNIHANS.length - 1;
+          }
+        }
+      }
+      token.type = PINYIN;
+      if (offset < 0) {
+        var begin = 0;
+        var end = UNIHANS.length - 1;
+        while (begin <= end) {
+          offset = ~~((begin + end) / 2);
+          var unihan = UNIHANS[offset];
+          cmp = COLLATOR.compare(ch, unihan);
+          if (cmp === 0) {
+            break;
+          } else if (cmp > 0) {
+            begin = offset + 1;
+          } else {
+            end = offset - 1;
+          }
+        }
+      }
+      if (cmp < 0) {
+        offset--;
+      }
+      token.target = PINYINS[offset];
+      if (!token.target) {
+        token.type = UNKNOWN;
+        token.target = token.source;
+      }
+      return token;
+    }
+    function parse(str) {
+      if (typeof str !== "string") {
+        throw new Error("argument should be string.");
+      }
+      if (!isSupported()) {
+        throw new Error("not support Intl or zh-CN language.");
+      }
+      return str.split("").map(function(v) {
+        return genToken(v);
+      });
+    }
+    module.exports = {
+      isSupported,
+      parse,
+      patchDict,
+      genToken,
+      // inner usage
+      convertToPinyin: function convertToPinyin(str, separator, lowerCase) {
+        return parse(str).map(function(v) {
+          if (lowerCase && v.type === PINYIN) {
+            return v.target.toLowerCase();
+          }
+          return v.target;
+        }).join(separator || "");
+      }
+    };
+  }
+});
+
+// ../../../node_modules/tiny-pinyin/dist/patchers/56l.js
+var require_l = __commonJS({
+  "../../../node_modules/tiny-pinyin/dist/patchers/56l.js"(exports, module) {
+    "use strict";
+    exports = module.exports = function patcher(DICT) {
+      DICT.EXCEPTIONS = {
+        "\u55F2": "DIA",
+        // DIE 嗲
+        "\u78A1": "ZHOU",
+        // DU 碡
+        "\u8052": "GUO",
+        // GUA 聒
+        "\u7094": "QUE",
+        // GUI 炔
+        "\u86B5": "KE",
+        // HE 蚵
+        "\u7809": "HUA",
+        // HUO 砉
+        "\u5B37": "MO",
+        // MA 嬷 新增
+        "\u8E4A": "XI",
+        // QI 蹊
+        "\u4E2C": "PAN",
+        // QIANG 丬
+        "\u9730": "XIAN",
+        // SAN 霰
+        "\u8C49": "CHI",
+        // SHI 豉
+        "\u9967": "XING",
+        // TANG 饧
+        "\u5E27": "ZHEN",
+        // ZHENG 帧
+        "\u828E": "XIONG",
+        // 芎
+        "\u8C01": "SHUI",
+        // 谁
+        "\u94B6": "KE"
+        // 钶
+        // Update UNIHANS dict.
+      };
+      DICT.UNIHANS[91] = "\u4F15";
+      DICT.UNIHANS[347] = "\u4EDA";
+      DICT.UNIHANS[393] = "\u8BCC";
+      DICT.UNIHANS[39] = "\u5A64";
+      DICT.UNIHANS[50] = "\u8160";
+      DICT.UNIHANS[369] = "\u6538";
+      DICT.UNIHANS[123] = "\u4E6F";
+      DICT.UNIHANS[171] = "\u5215";
+      DICT.UNIHANS[102] = "\u4F5D";
+      DICT.UNIHANS[126] = "\u72BF";
+      DICT.UNIHANS[176] = "\u5217";
+      DICT.UNIHANS[178] = "\u5222";
+      DICT.UNIHANS[252] = "\u5A1D";
+      DICT.UNIHANS[330] = "\u5078";
+    };
+    exports.shouldPatch = function shouldPatch(toToken) {
+      if (typeof toToken !== "function") return false;
+      if (toToken("\u4F15").target === "FOU" && toToken("\u4EDA").target === "XIA" && toToken("\u8BCC").target === "ZHONG" && toToken("\u5A64").target === "CHONG" && toToken("\u8160").target === "CONG" && toToken("\u6538").target === "YONG" && toToken("\u4E6F").target === "HOU" && toToken("\u5215").target === "LENG" && toToken("\u4F5D").target === "GONG" && toToken("\u72BF").target === "HUAI" && toToken("\u5217").target === "LIAO" && toToken("\u5222").target === "LIN" && toToken("\u94B6").target === "E") {
+        return true;
+      }
+      return false;
+    };
+  }
+});
+
+// ../../../node_modules/tiny-pinyin/dist/index.js
+var require_dist2 = __commonJS({
+  "../../../node_modules/tiny-pinyin/dist/index.js"(exports, module) {
+    "use strict";
+    var pinyin = require_core();
+    var patcher56L = require_l();
+    if (pinyin.isSupported() && patcher56L.shouldPatch(pinyin.genToken)) {
+      pinyin.patchDict(patcher56L);
+    }
+    module.exports = pinyin;
+  }
+});
+
+// src/fetcher/api-client.ts
+var import_http_client = __toESM(require_dist(), 1);
+var clientInstance = null;
+function getHttpClient() {
+  if (!clientInstance) {
+    clientInstance = new import_http_client.HttpClient({
+      timeout: 3e4,
+      platform: { enabled: true }
+    });
+    const canaryEnv = process.env.FORCE_FRAMEWORK_CLI_CANARY_ENV;
+    if (canaryEnv) {
+      clientInstance.interceptors.request.use((req) => {
+        req.headers["x-tt-env"] = canaryEnv;
+        return req;
+      });
+    }
+  }
+  return clientInstance;
+}
+function resolveEnvOptions(env = process.env) {
+  const appId = env.app_id;
+  const workspace = env.suda_workspace_id;
+  if (!appId) {
+    throw new Error("[db-schema-sync] Error: app_id environment variable is required. Set it in your .env file or shell environment.");
+  }
+  if (!workspace) {
+    throw new Error("[db-schema-sync] Error: suda_workspace_id environment variable is required. Set it in your .env file or shell environment.");
+  }
+  return {
+    appId,
+    workspace,
+    dbBranch: env.FORCE_DB_BRANCH || "main",
+    timeoutMs: env.SCHEMA_API_TIMEOUT_MS ? Number(env.SCHEMA_API_TIMEOUT_MS) : 3e4
+  };
+}
+async function fetchListTableView(options) {
+  const { appId, workspace, dbBranch = "main", timeoutMs = 3e4 } = options;
+  const client = getHttpClient();
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const ttEnv = process.env.X_TT_ENV || process.env.FORCE_FRAMEWORK_CLI_CANARY_ENV || "";
+    const webUser = process.env.X_LARKGW_SUDA_WEBUSER || "";
+    const headers = {
+      "x-supaas-bizsource": "miaoda"
+    };
+    if (ttEnv) headers["x-tt-env"] = ttEnv;
+    if (webUser) headers["X-Larkgw-Suda-Webuser"] = webUser;
+    console.log(`[db-schema-sync] GET /v1/app/${appId}/dataloom/schema?dbBranch=${dbBranch}&workspace=${workspace}`);
+    if (ttEnv) console.log(`[db-schema-sync] x-tt-env: ${ttEnv}`);
+    const response = await client.get(
+      `/v1/app/${appId}/dataloom/schema`,
+      {
+        params: { dbBranch },
+        headers,
+        signal: controller.signal
+      }
+    );
+    if (!response.ok) {
+      let body = "";
+      try {
+        body = await response.text();
+      } catch {
+      }
+      throw new Error(`listTableView API failed: ${response.status} ${response.statusText}
+URL: ${response.url}
+Body: ${body.slice(0, 500)}`);
+    }
+    const json = await response.json();
+    const data = json.data;
+    return data?.data ?? data?.schema ?? data;
+  } catch (err) {
+    if (err?.response) {
+      const headers = err.response.headers;
+      const logId = headers?.get?.("x-tt-logid") ?? headers?.["x-tt-logid"] ?? "";
+      let body = "";
+      try {
+        body = typeof err.response.text === "function" ? await err.response.text() : JSON.stringify(err.response.data ?? err.response.body ?? "");
+      } catch {
+      }
+      throw new Error(`listTableView API failed: ${err.message}
+LogID: ${logId}
+Body: ${body.slice(0, 500)}`);
+    }
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/fetcher/identifier.ts
+var import_tiny_pinyin = __toESM(require_dist2(), 1);
+function toAsciiName(name) {
+  if (!/[^\x00-\x7F]/.test(name)) {
+    return name;
+  }
+  try {
+    const result = [];
+    for (const char of name) {
+      if (/[^\x00-\x7F]/.test(char) && import_tiny_pinyin.default.isSupported()) {
+        result.push(import_tiny_pinyin.default.convertToPinyin(char, "", true));
+      } else {
+        result.push(char);
+      }
+    }
+    return result.join("_") || name;
+  } catch {
+    return name;
+  }
+}
+function toCamelCase(str) {
+  const words = str.split(/[_\-\s]+/).filter(Boolean);
+  if (words.length === 0) return "";
+  return words.map((word, index) => {
+    if (index === 0) return word.toLowerCase();
+    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+  }).join("");
+}
+function sanitizeIdentifier(name) {
+  const asciiName = toAsciiName(name);
+  let sanitized = asciiName.replace(/[^A-Za-z0-9_]/g, "_");
+  sanitized = sanitized.replace(/_+/g, "_");
+  sanitized = sanitized.replace(/^_|_$/g, "");
+  sanitized = toCamelCase(sanitized);
+  if (!sanitized) sanitized = "table";
+  if (!/^[A-Za-z_]/.test(sanitized)) sanitized = `_${sanitized}`;
+  return sanitized;
+}
+function sanitizePropertyName(name) {
+  const leadingUnderscore = name.startsWith("_") ? "_" : "";
+  const stripped = leadingUnderscore ? name.slice(1) : name;
+  const base = sanitizeIdentifier(stripped);
+  return `${leadingUnderscore}${base}`;
+}
+function getUniqueIdentifier(name, usedIdentifiers) {
+  const base = sanitizeIdentifier(name);
+  if (!usedIdentifiers.has(base)) {
+    usedIdentifiers.add(base);
+    return base;
+  }
+  let suffix = 2;
+  while (usedIdentifiers.has(`${base}${suffix}`)) suffix++;
+  const unique = `${base}${suffix}`;
+  usedIdentifiers.add(unique);
+  return unique;
+}
+
+// src/fetcher/normalize.ts
+var SYSTEM_FIELD_NAMES = /* @__PURE__ */ new Set(["_created_at", "_created_by", "_updated_at", "_updated_by"]);
+function normalizeField(field, systemFieldNamesToRemove) {
+  if (systemFieldNamesToRemove.has(field.fieldName)) {
+    return null;
+  }
+  return {
+    fieldName: field.fieldName,
+    type: field.type,
+    isPrimary: field.isPrimary,
+    isNullable: field.isNullable,
+    isUnique: field.isUnique,
+    isArray: field.isArray,
+    isEnum: field.isEnum,
+    isSystem: SYSTEM_FIELD_NAMES.has(field.fieldName),
+    defaultValue: field.defaultValue ?? void 0,
+    comment: field.comment || void 0,
+    extraInfo: field.extraInfo
+  };
+}
+function normalizeRelationship(rel) {
+  return {
+    fieldNames: rel.fieldName,
+    targetTableName: rel.fkTableName,
+    targetFieldNames: rel.fkFieldName,
+    updatePolicy: rel.updateMethod,
+    removePolicy: rel.removeMethod
+  };
+}
+function normalizeIndex(index) {
+  return {
+    indexName: index.indexName,
+    indexColumns: index.indexColumns ?? [],
+    indexType: index.indexType,
+    indexCreationType: index.indexCreationType,
+    indexDef: index.indexDef
+  };
+}
+function resolveSystemFieldConflicts(fields) {
+  const businessJsNames = /* @__PURE__ */ new Set();
+  for (const field of fields) {
+    if (!SYSTEM_FIELD_NAMES.has(field.fieldName)) {
+      businessJsNames.add(sanitizeIdentifier(field.fieldName));
+    }
+  }
+  const toRemove = /* @__PURE__ */ new Set();
+  for (const field of fields) {
+    if (SYSTEM_FIELD_NAMES.has(field.fieldName)) {
+      const jsName = sanitizeIdentifier(field.fieldName);
+      if (businessJsNames.has(jsName)) {
+        toRemove.add(field.fieldName);
+      }
+    }
+  }
+  return toRemove;
+}
+function normalizeTable(table, usedIdentifiers) {
+  const identifier = getUniqueIdentifier(table.tableName, usedIdentifiers);
+  const systemFieldsToRemove = resolveSystemFieldConflicts(table.fields ?? []);
+  const fields = [];
+  for (const field of table.fields ?? []) {
+    const normalized = normalizeField(field, systemFieldsToRemove);
+    if (normalized !== null) {
+      fields.push(normalized);
+    }
+  }
+  const relationships = (table.relationships ?? []).map(normalizeRelationship);
+  const indexes = (table.indexes ?? []).map(normalizeIndex);
+  return {
+    tableName: table.tableName,
+    identifier,
+    comment: table.comment || void 0,
+    fields,
+    relationships,
+    indexes
+  };
+}
+function normalizeView(view, usedIdentifiers) {
+  const identifier = getUniqueIdentifier(view.tableName, usedIdentifiers);
+  const systemFieldsToRemove = resolveSystemFieldConflicts(view.fields ?? []);
+  const fields = [];
+  for (const field of view.fields ?? []) {
+    const normalized = normalizeField(field, systemFieldsToRemove);
+    if (normalized !== null) {
+      fields.push(normalized);
+    }
+  }
+  return {
+    viewName: view.tableName,
+    identifier,
+    comment: view.comment || void 0,
+    fields,
+    viewDef: view.tableDef || void 0
+  };
+}
+function extractSyncedTableMap(tables) {
+  const map = /* @__PURE__ */ new Map();
+  for (const table of tables) {
+    if (table.bitableSyncTask?.fieldApiNameList) {
+      map.set(table.tableName, new Set(table.bitableSyncTask.fieldApiNameList));
+    }
+  }
+  return map;
+}
+function normalizeApiResponse(response) {
+  const usedTableIdentifiers = /* @__PURE__ */ new Set();
+  const usedViewIdentifiers = /* @__PURE__ */ new Set();
+  const usedMViewIdentifiers = /* @__PURE__ */ new Set();
+  const usedEnumIdentifiers = /* @__PURE__ */ new Set();
+  const usedSeqIdentifiers = /* @__PURE__ */ new Set();
+  const tableItems = response.tables?.data ?? response.table?.data ?? [];
+  const viewItems = response.views?.data ?? response.view?.data ?? [];
+  const mViewItems = response.materializedViews?.data ?? response.materializedView?.data ?? [];
+  const tables = tableItems.map((t) => normalizeTable(t, usedTableIdentifiers));
+  const views = viewItems.map((v) => normalizeView(v, usedViewIdentifiers));
+  const materializedViews = mViewItems.map((v) => normalizeView(v, usedMViewIdentifiers));
+  const enums = (response.enums ?? []).map((e) => {
+    let values;
+    if (e.enumValues?.length) {
+      values = e.enumValues.map((v) => v.enumValueName);
+    } else if (e.values?.length) {
+      values = e.values;
+    } else {
+      values = [];
+    }
+    return {
+      enumName: e.enumName,
+      identifier: getUniqueIdentifier(e.enumName, usedEnumIdentifiers),
+      values
+    };
+  });
+  const sequences = (response.sequences ?? []).map((s) => ({
+    sequenceName: s.sequenceName,
+    identifier: getUniqueIdentifier(s.sequenceName, usedSeqIdentifiers)
+  }));
+  const allRawTables = [...tableItems, ...viewItems, ...mViewItems];
+  const syncedTableMap = extractSyncedTableMap(allRawTables);
+  return {
+    tables,
+    views,
+    materializedViews,
+    enums,
+    sequences,
+    syncedTableMap
+  };
+}
+
+// src/fetcher/index.ts
+async function fetchSchemaData(options) {
+  const raw = await fetchListTableView(options);
+  return normalizeApiResponse(raw);
+}
+
+// src/generator/type-mapper-registry.ts
+var TypeMapperRegistry = class {
+  mappers = [];
+  register(mapper) {
+    this.mappers.push(mapper);
+  }
+  resolve(field) {
+    for (const mapper of this.mappers) {
+      if (mapper.match(field)) return mapper;
+    }
+    throw new Error(`No mapper found for type: ${field.type}`);
+  }
+};
+
+// src/generator/utils.ts
+function escapeDoubleQuote(s) {
+  return s.replace(/"/g, '\\"');
+}
+
+// src/generator/mappers/primitives.ts
+var PG_CORE = "drizzle-orm/pg-core";
+var primitiveMappers = [
+  // uuid
+  {
+    name: "uuid",
+    match: (f) => f.type === "uuid",
+    generate: (f) => `uuid("${escapeDoubleQuote(f.fieldName)}")`,
+    imports: () => [{ name: "uuid", from: PG_CORE }]
+  },
+  // varchar
+  {
+    name: "varchar",
+    match: (f) => f.type === "varchar",
+    generate: (f) => `varchar("${escapeDoubleQuote(f.fieldName)}")`,
+    imports: () => [{ name: "varchar", from: PG_CORE }]
+  },
+  // text
+  {
+    name: "text",
+    match: (f) => f.type === "text",
+    generate: (f) => `text("${escapeDoubleQuote(f.fieldName)}")`,
+    imports: () => [{ name: "text", from: PG_CORE }]
+  },
+  // integer (int2, int4, integer)
+  {
+    name: "integer",
+    match: (f) => ["int2", "int4", "integer"].includes(f.type),
+    generate: (f) => `integer("${escapeDoubleQuote(f.fieldName)}")`,
+    imports: () => [{ name: "integer", from: PG_CORE }]
+  },
+  // bigint (int8, bigint)
+  {
+    name: "bigint",
+    match: (f) => ["int8", "bigint"].includes(f.type),
+    generate: (f) => `bigint("${escapeDoubleQuote(f.fieldName)}", { mode: 'number' })`,
+    imports: () => [{ name: "bigint", from: PG_CORE }]
+  },
+  // real (float4, real)
+  {
+    name: "real",
+    match: (f) => ["float4", "real"].includes(f.type),
+    generate: (f) => `real("${escapeDoubleQuote(f.fieldName)}")`,
+    imports: () => [{ name: "real", from: PG_CORE }]
+  },
+  // doublePrecision (float8, double precision)
+  {
+    name: "doublePrecision",
+    match: (f) => ["float8", "double precision"].includes(f.type),
+    generate: (f) => `doublePrecision("${escapeDoubleQuote(f.fieldName)}")`,
+    imports: () => [{ name: "doublePrecision", from: PG_CORE }]
+  },
+  // numeric (numeric, decimal)
+  {
+    name: "numeric",
+    match: (f) => ["numeric", "decimal"].includes(f.type),
+    generate: (f) => `numeric("${escapeDoubleQuote(f.fieldName)}")`,
+    imports: () => [{ name: "numeric", from: PG_CORE }]
+  },
+  // boolean (bool, boolean)
+  {
+    name: "boolean",
+    match: (f) => ["bool", "boolean"].includes(f.type),
+    generate: (f) => `boolean("${escapeDoubleQuote(f.fieldName)}")`,
+    imports: () => [{ name: "boolean", from: PG_CORE }]
+  },
+  // json
+  {
+    name: "json",
+    match: (f) => f.type === "json",
+    generate: (f) => `json("${escapeDoubleQuote(f.fieldName)}")`,
+    imports: () => [{ name: "json", from: PG_CORE }]
+  },
+  // jsonb
+  {
+    name: "jsonb",
+    match: (f) => f.type === "jsonb",
+    generate: (f) => `jsonb("${escapeDoubleQuote(f.fieldName)}")`,
+    imports: () => [{ name: "jsonb", from: PG_CORE }]
+  },
+  // date
+  {
+    name: "date",
+    match: (f) => f.type === "date",
+    generate: (f) => `date("${escapeDoubleQuote(f.fieldName)}")`,
+    imports: () => [{ name: "date", from: PG_CORE }]
+  },
+  // time
+  {
+    name: "time",
+    match: (f) => f.type === "time",
+    generate: (f) => `time("${escapeDoubleQuote(f.fieldName)}")`,
+    imports: () => [{ name: "time", from: PG_CORE }]
+  },
+  // serial
+  {
+    name: "serial",
+    match: (f) => f.type === "serial",
+    generate: (f) => `serial("${escapeDoubleQuote(f.fieldName)}")`,
+    imports: () => [{ name: "serial", from: PG_CORE }]
+  }
+];
+
+// src/generator/mappers/custom-types.ts
+var TIMESTAMP_TYPES = ["timestamptz", "timestamp"];
+var CUSTOM_TYPE_MAP = {
+  user_profile: "userProfile",
+  file_attachment: "fileAttachment"
+};
+var CUSTOM_ARRAY_TYPE_MAP = {
+  user_profile: "userProfileArray",
+  file_attachment: "fileAttachmentArray"
+};
+var customTypeMappers = [
+  // timestamptz/timestamp array — must come before non-array check
+  {
+    name: "customTimestamptz-array",
+    match: (f) => TIMESTAMP_TYPES.includes(f.type) && f.isArray,
+    generate: (f) => {
+      const precision = f.extraInfo?.timestamp_precision;
+      if (precision !== void 0) {
+        return `customTimestamptz("${escapeDoubleQuote(f.fieldName)}", { precision: ${precision} }).array()`;
+      }
+      return `customTimestamptz("${escapeDoubleQuote(f.fieldName)}").array()`;
+    },
+    imports: () => []
+  },
+  // timestamptz/timestamp (non-array)
+  {
+    name: "customTimestamptz",
+    match: (f) => TIMESTAMP_TYPES.includes(f.type) && !f.isArray,
+    generate: (f) => {
+      const precision = f.extraInfo?.timestamp_precision;
+      if (precision !== void 0) {
+        return `customTimestamptz("${escapeDoubleQuote(f.fieldName)}", { precision: ${precision} })`;
+      }
+      return `customTimestamptz("${escapeDoubleQuote(f.fieldName)}")`;
+    },
+    imports: () => []
+  },
+  // user_profile / file_attachment array — must come before non-array
+  {
+    name: "custom-type-array",
+    match: (f) => f.isArray && f.type in CUSTOM_ARRAY_TYPE_MAP,
+    generate: (f) => `${CUSTOM_ARRAY_TYPE_MAP[f.type]}("${escapeDoubleQuote(f.fieldName)}")`,
+    imports: () => []
+    // provided by inline-types enhancer
+  },
+  // user_profile / file_attachment (non-array)
+  {
+    name: "custom-type",
+    match: (f) => !f.isArray && f.type in CUSTOM_TYPE_MAP,
+    generate: (f) => `${CUSTOM_TYPE_MAP[f.type]}("${escapeDoubleQuote(f.fieldName)}")`,
+    imports: () => []
+    // provided by inline-types enhancer
+  }
+];
+
+// src/generator/mappers/fallback.ts
+var fallbackMapper = {
+  name: "fallback-text",
+  match: () => true,
+  generate: (field) => `text("${escapeDoubleQuote(field.fieldName)}")`,
+  imports: () => [{ name: "text", from: "drizzle-orm/pg-core" }]
+};
+
+// src/generator/mappers/index.ts
+function createDefaultRegistry() {
+  const registry = new TypeMapperRegistry();
+  for (const mapper of customTypeMappers) registry.register(mapper);
+  for (const mapper of primitiveMappers) registry.register(mapper);
+  registry.register(fallbackMapper);
+  return registry;
+}
+
+// src/generator/import-collector.ts
+var ImportCollector = class {
+  imports = /* @__PURE__ */ new Map();
+  add(spec) {
+    if (!this.imports.has(spec.from)) {
+      this.imports.set(spec.from, /* @__PURE__ */ new Set());
+    }
+    this.imports.get(spec.from).add(spec.name);
+  }
+  addAll(specs) {
+    for (const spec of specs) this.add(spec);
+  }
+  /** Generate import statements, sorted by source path */
+  generate() {
+    const lines = [];
+    const sortedPaths = [...this.imports.keys()].sort();
+    for (const from of sortedPaths) {
+      const names = [...this.imports.get(from)].sort();
+      lines.push(`import { ${names.join(", ")} } from '${from}';`);
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/generator/default-value.ts
+function formatDefaultValue(value) {
+  if (value == null || value === "") return "";
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.toUpperCase() === "NULL") return "";
+  if (/^gen_random_uuid\(\)$/i.test(trimmed)) return ".defaultRandom()";
+  if (/^CURRENT_TIMESTAMP$/i.test(trimmed)) return ".default(sql`CURRENT_TIMESTAMP`)";
+  if (trimmed === "true") return ".default(true)";
+  if (trimmed === "false") return ".default(false)";
+  if (/^-?\d+(\.\d+)?$/.test(trimmed)) return `.default(${trimmed})`;
+  if (/::|\(|CASE|current_setting/i.test(trimmed)) {
+    const escaped = trimmed.replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+    return `.default(sql\`${escaped}\`)`;
+  }
+  const escapedStr = trimmed.replace(/'/g, "\\'");
+  return `.default('${escapedStr}')`;
+}
+
+// src/generator/field-modifier.ts
+var defaultModifiers = [
+  {
+    name: "primaryKey",
+    match: (f) => f.isPrimary,
+    modify: () => ".primaryKey()"
+  },
+  {
+    name: "notNull",
+    match: (f) => !f.isNullable && !f.isPrimary,
+    modify: () => ".notNull()"
+  },
+  {
+    name: "unique",
+    match: (f) => f.isUnique,
+    modify: () => ".unique()"
+  },
+  {
+    name: "defaultValue",
+    match: (f) => f.defaultValue != null && f.defaultValue !== "",
+    modify: (f) => formatDefaultValue(f.defaultValue)
+  }
+];
+function applyModifiers(field, modifiers) {
+  let result = "";
+  for (const mod of modifiers) {
+    if (mod.match(field)) {
+      result += mod.modify(field);
+    }
+  }
+  return result;
+}
+
+// src/generator/structures/enum.ts
+function generateEnumCode(schema) {
+  const values = schema.values.map((v) => `'${v.replace(/'/g, "\\'")}'`).join(", ");
+  return `export const ${schema.identifier} = pgEnum("${escapeDoubleQuote(schema.enumName)}", [${values}]);`;
+}
+
+// src/generator/structures/index-gen.ts
+function generateIndexCode(idx, tableIdentifier) {
+  const fn = idx.indexType === "unique" ? "uniqueIndex" : "index";
+  const columns = idx.indexColumns.map((col) => `table.${sanitizePropertyName(col)}`).join(", ");
+  const escapedName = escapeDoubleQuote(idx.indexName);
+  const creationType = idx.indexCreationType || "btree";
+  if (creationType !== "btree" && columns) {
+    return `${fn}("${escapedName}").using("${creationType}", ${columns})`;
+  }
+  if (!columns) {
+    return `// Complex index: ${idx.indexDef || idx.indexName}`;
+  }
+  return `${fn}("${escapedName}").on(${columns})`;
+}
+
+// src/generator/structures/foreign-key.ts
+function generateForeignKeyCode(rel, tableIdentifier, tableIdentifierMap) {
+  const columns = rel.fieldNames.map((f) => `table.${sanitizePropertyName(f)}`).join(", ");
+  const targetIdentifier = tableIdentifierMap?.get(rel.targetTableName) ?? sanitizeIdentifier(rel.targetTableName);
+  const foreignColumns = rel.targetFieldNames.map((f) => `${targetIdentifier}.${sanitizePropertyName(f)}`).join(", ");
+  let code = `foreignKey({
+    columns: [${columns}],
+    foreignColumns: [${foreignColumns}],
+  })`;
+  if (rel.removePolicy && rel.removePolicy !== "NO_ACTION") {
+    code += `.onDelete("${escapeDoubleQuote(rel.removePolicy.toLowerCase())}")`;
+  }
+  if (rel.updatePolicy && rel.updatePolicy !== "NO_ACTION") {
+    code += `.onUpdate("${escapeDoubleQuote(rel.updatePolicy.toLowerCase())}")`;
+  }
+  return code;
+}
+
+// src/generator/structures/table.ts
+function generateTableCode(table, schemaData, registry, modifiers, tableIdentifierMap) {
+  const fieldLines = table.fields.map((field) => {
+    const mapper = registry.resolve(field);
+    const typeExpr = mapper.generate(field);
+    const mods = applyModifiers(field, modifiers);
+    const propName = sanitizePropertyName(field.fieldName);
+    return `  ${propName}: ${typeExpr}${mods},`;
+  });
+  const thirdArgParts = [];
+  for (const idx of table.indexes) {
+    thirdArgParts.push(generateIndexCode(idx, table.identifier));
+  }
+  for (const rel of table.relationships) {
+    thirdArgParts.push(generateForeignKeyCode(rel, table.identifier, tableIdentifierMap));
+  }
+  let code = `export const ${table.identifier} = pgTable("${escapeDoubleQuote(table.tableName)}", {
+${fieldLines.join("\n")}
+}`;
+  if (thirdArgParts.length > 0) {
+    const parts = thirdArgParts.map((p) => `  ${p},`).join("\n");
+    code += `, (table) => [
+${parts}
+]`;
+  }
+  code += ");";
+  return code;
+}
+
+// src/generator/structures/view.ts
+function generateViewCode(view, viewFn, registry, modifiers) {
+  if (view.viewDef) {
+    const escaped = view.viewDef.replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+    return `export const ${view.identifier} = ${viewFn}("${escapeDoubleQuote(view.viewName)}").as(sql\`${escaped}\`);`;
+  }
+  const fieldLines = view.fields.map((field) => {
+    const mapper = registry.resolve(field);
+    const typeExpr = mapper.generate(field);
+    const mods = applyModifiers(field, modifiers);
+    return `  ${sanitizePropertyName(field.fieldName)}: ${typeExpr}${mods},`;
+  });
+  return `export const ${view.identifier} = ${viewFn}("${escapeDoubleQuote(view.viewName)}", {
+${fieldLines.join("\n")}
+});`;
+}
+
+// src/generator/index.ts
+function generateSchemaCode(data) {
+  const registry = createDefaultRegistry();
+  const collector = new ImportCollector();
+  if (data.enums.length > 0) {
+    collector.add({ name: "pgEnum", from: "drizzle-orm/pg-core" });
+  }
+  if (data.sequences.length > 0) {
+    collector.add({ name: "pgSequence", from: "drizzle-orm/pg-core" });
+  }
+  if (data.tables.length > 0) {
+    collector.add({ name: "pgTable", from: "drizzle-orm/pg-core" });
+  }
+  if (data.views.length > 0) {
+    collector.add({ name: "pgView", from: "drizzle-orm/pg-core" });
+  }
+  if (data.materializedViews.length > 0) {
+    collector.add({ name: "pgMaterializedView", from: "drizzle-orm/pg-core" });
+  }
+  for (const table of data.tables) {
+    for (const field of table.fields) {
+      collector.addAll(registry.resolve(field).imports());
+    }
+    if (table.indexes.length > 0) {
+      const hasNonComplex = table.indexes.some(
+        (idx) => idx.indexColumns && idx.indexColumns.length > 0
+      );
+      if (hasNonComplex) {
+        collector.add({ name: "index", from: "drizzle-orm/pg-core" });
+        if (table.indexes.some((i) => i.indexType === "unique")) {
+          collector.add({ name: "uniqueIndex", from: "drizzle-orm/pg-core" });
+        }
+      }
+    }
+    if (table.relationships.length > 0) {
+      collector.add({ name: "foreignKey", from: "drizzle-orm/pg-core" });
+    }
+  }
+  for (const view of [...data.views, ...data.materializedViews]) {
+    for (const field of view.fields) {
+      collector.addAll(registry.resolve(field).imports());
+    }
+  }
+  const tableIdentifierMap = /* @__PURE__ */ new Map();
+  for (const table of data.tables) {
+    tableIdentifierMap.set(table.tableName, table.identifier);
+  }
+  const bodyParts = [];
+  for (const enumSchema of data.enums) {
+    bodyParts.push(generateEnumCode(enumSchema));
+  }
+  for (const seq of data.sequences) {
+    bodyParts.push(`export const ${seq.identifier} = pgSequence("${escapeDoubleQuote(seq.sequenceName)}");`);
+  }
+  for (const table of data.tables) {
+    bodyParts.push(generateTableCode(table, data, registry, defaultModifiers, tableIdentifierMap));
+  }
+  for (const view of data.views) {
+    bodyParts.push(generateViewCode(view, "pgView", registry, defaultModifiers));
+  }
+  for (const mview of data.materializedViews) {
+    bodyParts.push(generateViewCode(mview, "pgMaterializedView", registry, defaultModifiers));
+  }
+  const body = bodyParts.join("\n\n");
+  if (body.includes("sql`")) {
+    collector.add({ name: "sql", from: "drizzle-orm" });
+  }
+  const importSection = collector.generate();
+  if (!importSection) {
+    return body;
+  }
+  return `${importSection}
+
+${body}`;
+}
+
+// src/enhancer/index.ts
+function runEnhancers(source, enhancers, context) {
+  let current = source;
+  const allStats = {};
+  for (const enhancer of enhancers) {
+    const result = enhancer.enhance(current, context);
+    current = result.source;
+    if (result.stats) {
+      allStats[enhancer.name] = result.stats;
+    }
+  }
+  return { source: current, allStats };
+}
+
+// src/enhancer/enhancers/header.ts
+var ESLINT_DISABLE = "/* eslint-disable */";
+var HEADER_COMMENT = "/** auto generated, do not edit */";
+var FULL_HEADER = `${ESLINT_DISABLE}
+${HEADER_COMMENT}`;
+var headerEnhancer = {
+  name: "header",
+  enhance(source, _context) {
+    let trimmed = source;
+    const headerPatterns = [
+      /^\/\*\s*eslint-disable\s*\*\/\s*\n?/,
+      /^\/\*\*\s*auto generated[^*]*\*\/\s*\n?/
+    ];
+    for (const pattern of headerPatterns) {
+      while (pattern.test(trimmed)) {
+        trimmed = trimmed.replace(pattern, "");
+      }
+    }
+    trimmed = trimmed.trimStart();
+    return { source: `${FULL_HEADER}
+${trimmed}` };
+  }
+};
+
+// src/template/types.ts
+var CUSTOM_TIMESTAMPTZ_DEFINITION = `const customTimestamptz = customType<{
+  data: Date;
+  driverData: string;
+  config: { precision?: number };
+}>({
+  dataType(config) {
+    const precision = typeof config?.precision !== 'undefined'
+      ? \` (\${config.precision})\`
+      : '';
+    return \`timestamptz\${precision}\`;
+  },
+  toDriver(value: Date | string | number) {
+    if (value == null) return value as any;
+    if (typeof value === 'number') return new Date(value).toISOString();
+    if (typeof value === 'string') return value;
+    if (value instanceof Date) return value.toISOString();
+    throw new Error('Invalid timestamp value');
+  },
+  fromDriver(value: string | Date): Date {
+    if (value instanceof Date) return value;
+    return new Date(value);
+  },
+});`;
+var USER_PROFILE_DEFINITION = `const userProfile = customType<{
+  data: string;
+  driverData: string;
+}>({
+  dataType() {
+    return 'user_profile';
+  },
+  toDriver(value: string) {
+    return sql\`ROW(\${value})::user_profile\`;
+  },
+  fromDriver(value: string) {
+    const [userId] = value.slice(1, -1).split(',');
+    return userId.trim();
+  },
+});`;
+var FILE_ATTACHMENT_DEFINITION = `type FileAttachment = {
+  bucket_id: string;
+  file_path: string;
+};
+
+const fileAttachment = customType<{
+  data: FileAttachment;
+  driverData: string;
+}>({
+  dataType() {
+    return 'file_attachment';
+  },
+  toDriver(value: FileAttachment) {
+    return sql\`ROW(\${value.bucket_id},\${value.file_path})::file_attachment\`;
+  },
+  fromDriver(value: string): FileAttachment {
+    const [bucketId, filePath] = value.slice(1, -1).split(',');
+    return { bucket_id: bucketId.trim(), file_path: filePath.trim() };
+  },
+});`;
+var ESCAPE_LITERAL_DEFINITION = `function escapeLiteral(str: string): string {
+  return "'" + str.replace(/'/g, "''") + "'";
+}`;
+var USER_PROFILE_ARRAY_DEFINITION = `const userProfileArray = customType<{
+  data: string[];
+  driverData: string;
+}>({
+  dataType() {
+    return 'user_profile[]';
+  },
+  toDriver(value: string[]) {
+    if (!value || value.length === 0) {
+      return sql\`'{}'::user_profile[]\`;
+    }
+    const elements = value.map(id => \`ROW(\${escapeLiteral(id)})::user_profile\`).join(',');
+    return sql.raw(\`ARRAY[\${elements}]::user_profile[]\`);
+  },
+  fromDriver(value: string): string[] {
+    if (!value || value === '{}') return [];
+    const inner = value.slice(1, -1);
+    const matches = inner.match(/\\([^)]*\\)/g) || [];
+    return matches.map(m => m.slice(1, -1).split(',')[0].trim());
+  },
+});`;
+var FILE_ATTACHMENT_ARRAY_DEFINITION = `const fileAttachmentArray = customType<{
+  data: FileAttachment[];
+  driverData: string;
+}>({
+  dataType() {
+    return 'file_attachment[]';
+  },
+  toDriver(value: FileAttachment[]) {
+    if (!value || value.length === 0) {
+      return sql\`'{}'::file_attachment[]\`;
+    }
+    const elements = value.map(f =>
+      \`ROW(\${escapeLiteral(f.bucket_id)},\${escapeLiteral(f.file_path)})::file_attachment\`
+    ).join(',');
+    return sql.raw(\`ARRAY[\${elements}]::file_attachment[]\`);
+  },
+  fromDriver(value: string): FileAttachment[] {
+    if (!value || value === '{}') return [];
+    const inner = value.slice(1, -1);
+    const matches = inner.match(/\\([^)]*\\)/g) || [];
+    return matches.map(m => {
+      const [bucketId, filePath] = m.slice(1, -1).split(',');
+      return { bucket_id: bucketId.trim(), file_path: filePath.trim() };
+    });
+  },
+});`;
+
+// src/enhancer/enhancers/inline-types.ts
+var TYPE_RULES = [
+  {
+    usageName: "customTimestamptz",
+    definitionCheck: "const customTimestamptz = customType<",
+    definition: CUSTOM_TIMESTAMPTZ_DEFINITION
+  },
+  {
+    usageName: "userProfile",
+    definitionCheck: "const userProfile = customType<",
+    definition: USER_PROFILE_DEFINITION
+  },
+  {
+    usageName: "fileAttachment",
+    definitionCheck: "const fileAttachment = customType<",
+    definition: FILE_ATTACHMENT_DEFINITION
+  },
+  {
+    usageName: "escapeLiteral",
+    definitionCheck: "function escapeLiteral(",
+    definition: ESCAPE_LITERAL_DEFINITION
+  },
+  {
+    usageName: "userProfileArray",
+    definitionCheck: "const userProfileArray = customType<",
+    definition: USER_PROFILE_ARRAY_DEFINITION,
+    deps: ["userProfile", "escapeLiteral"]
+  },
+  {
+    usageName: "fileAttachmentArray",
+    definitionCheck: "const fileAttachmentArray = customType<",
+    definition: FILE_ATTACHMENT_ARRAY_DEFINITION,
+    deps: ["fileAttachment", "escapeLiteral"]
+  }
+];
+var inlineTypesEnhancer = {
+  name: "inline-types",
+  enhance(source, context) {
+    const exportCustomTypes = context.exportCustomTypes ?? false;
+    let text = source;
+    text = text.replace(/import \{[^}]*\} from ["']\.\/types["'];?\n*/g, "");
+    const usedTypes = /* @__PURE__ */ new Set();
+    for (const rule of TYPE_RULES) {
+      if (text.includes(rule.usageName + "(") && !text.includes(rule.definitionCheck)) {
+        usedTypes.add(rule.usageName);
+        if (rule.deps) {
+          for (const dep of rule.deps) usedTypes.add(dep);
+        }
+      }
+    }
+    if (usedTypes.size === 0) {
+      return { source: text };
+    }
+    text = ensureImportIdentifier(text, "drizzle-orm/pg-core", "customType");
+    if (!text.includes("from 'drizzle-orm'") && !text.includes('from "drizzle-orm"')) {
+      const pgCoreImportMatch = text.match(
+        /^import [\s\S]*?from ["']drizzle-orm\/pg-core["'];?\n/m
+      );
+      if (pgCoreImportMatch) {
+        const insertPoint = text.indexOf(pgCoreImportMatch[0]) + pgCoreImportMatch[0].length;
+        text = text.slice(0, insertPoint) + "import { sql } from 'drizzle-orm';\n" + text.slice(insertPoint);
+      }
+    }
+    const definitions = [];
+    for (const rule of TYPE_RULES) {
+      if (usedTypes.has(rule.usageName) && !text.includes(rule.definitionCheck)) {
+        let def = rule.definition;
+        if (exportCustomTypes) {
+          def = def.replace(/^(const |function |type )/gm, "export $1");
+        }
+        definitions.push(def);
+      }
+    }
+    if (definitions.length === 0) {
+      return { source: text };
+    }
+    const headerPrefix = `${FULL_HEADER}
+`;
+    let insertionPoint = 0;
+    if (text.startsWith(headerPrefix)) {
+      insertionPoint = headerPrefix.length;
+    }
+    const importSectionMatch = text.slice(insertionPoint).match(/^(?:import [^\n]+\n)+/);
+    if (importSectionMatch) {
+      insertionPoint += importSectionMatch[0].length;
+    }
+    const typeBlock = `
+${definitions.join("\n\n")}
+
+`;
+    text = text.slice(0, insertionPoint) + typeBlock + text.slice(insertionPoint);
+    return { source: text, stats: { typesInlined: definitions.length } };
+  }
+};
+function ensureImportIdentifier(source, packageName, identifier) {
+  const escapedPackage = packageName.replace(/\//g, "\\/");
+  const importRegex = new RegExp(
+    `import \\{([^}]*)\\} from ["']${escapedPackage}["'];?`
+  );
+  const match = source.match(importRegex);
+  if (!match) {
+    return source;
+  }
+  const identifiers = match[1].split(",").map((id) => id.trim()).filter(Boolean);
+  if (identifiers.includes(identifier)) {
+    return source;
+  }
+  identifiers.push(identifier);
+  const unique = Array.from(new Set(identifiers));
+  const replacement = `import { ${unique.join(", ")} } from "${packageName}"`;
+  return source.replace(importRegex, replacement);
+}
+
+// src/enhancer/enhancers/system-comments.ts
+var SYSTEM_FIELD_COMMENTS = {
+  _created_at: "Creation time",
+  _created_by: "Creator",
+  _updated_at: "Update time",
+  _updated_by: "Updater"
+};
+var systemCommentsEnhancer = {
+  name: "system-comments",
+  enhance(source, _context) {
+    const lines = source.split("\n");
+    let commentsAdded = 0;
+    for (let i = 0; i < lines.length; i += 1) {
+      const line = lines[i];
+      const entry = Object.entries(SYSTEM_FIELD_COMMENTS).find(
+        ([key]) => line.includes(`"${key}"`) || line.includes(`'${key}'`)
+      );
+      if (!entry) {
+        continue;
+      }
+      const [, description] = entry;
+      const previousLine = lines[i - 1]?.trim() ?? "";
+      if (previousLine.startsWith("//") && previousLine.includes("System field")) {
+        continue;
+      }
+      const indentMatch = line.match(/^\s*/);
+      const indent = indentMatch ? indentMatch[0] : "";
+      const comment = `${indent}// System field: ${description} (auto-filled, do not modify)`;
+      lines.splice(i, 0, comment);
+      i += 1;
+      commentsAdded += 1;
+    }
+    return {
+      source: lines.join("\n"),
+      stats: { commentsAdded }
+    };
+  }
+};
+
+// src/enhancer/enhancers/jsonb-comments.ts
+var TABLE_DEF_REGEX = /export const\s+\w+\s*=\s*pgTable\(\s*["'`]([^"'`]+)["'`]/;
+var JSON_FIELD_WITH_NAME_REGEX = /^\s*(\w+):\s*(?:json|jsonb)\(\s*["'`]([^"'`]+)["'`]\)/;
+var JSON_FIELD_NO_NAME_REGEX = /^\s*(\w+):\s*(?:json|jsonb)\(\s*\)/;
+var jsonbCommentsEnhancer = {
+  name: "jsonb-comments",
+  enhance(source, context) {
+    const columnComments = buildColumnCommentsMap(context);
+    if (columnComments.size === 0) {
+      return { source, stats: { commentsAdded: 0 } };
+    }
+    const lines = source.split("\n");
+    const result = [];
+    let commentsAdded = 0;
+    let currentTableName = null;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const tableMatch = line.match(TABLE_DEF_REGEX);
+      if (tableMatch) {
+        currentTableName = tableMatch[1];
+      }
+      let columnName = null;
+      const jsonMatchWithName = line.match(JSON_FIELD_WITH_NAME_REGEX);
+      const jsonMatchNoName = line.match(JSON_FIELD_NO_NAME_REGEX);
+      if (jsonMatchWithName) {
+        columnName = jsonMatchWithName[2];
+      } else if (jsonMatchNoName) {
+        columnName = jsonMatchNoName[1];
+      }
+      if (columnName && currentTableName) {
+        const commentKey = `${currentTableName}.${columnName}`;
+        const comment = columnComments.get(commentKey);
+        if (comment) {
+          const parsed = parseColumnComment(comment);
+          const indentMatch = line.match(/^\s*/);
+          const indent = indentMatch ? indentMatch[0] : "";
+          const prevLine = result[result.length - 1]?.trim() ?? "";
+          if (!prevLine.startsWith("/**") && !prevLine.startsWith("*") && !prevLine.startsWith("//")) {
+            const commentLines = [];
+            commentLines.push(`${indent}/**`);
+            if (parsed.description) {
+              const safeDesc = parsed.description.replace(/[\r\n]+/g, " ").trim();
+              commentLines.push(`${indent} * ${safeDesc}`);
+            }
+            if (parsed.type) {
+              if (parsed.description) {
+                commentLines.push(`${indent} *`);
+              }
+              const safeType = parsed.type.replace(/[\r\n]+/g, " ").trim();
+              commentLines.push(`${indent} * @type ${safeType}`);
+            }
+            commentLines.push(`${indent} */`);
+            result.push(...commentLines);
+            commentsAdded++;
+          }
+        }
+      }
+      if (line.match(/^\}\);?\s*$/) || line.match(/^}\s*,\s*\{/)) {
+        currentTableName = null;
+      }
+      result.push(line);
+    }
+    return {
+      source: result.join("\n"),
+      stats: { commentsAdded }
+    };
+  }
+};
+function buildColumnCommentsMap(context) {
+  const map = /* @__PURE__ */ new Map();
+  for (const table of context.schemaData.tables) {
+    for (const field of table.fields) {
+      if (field.comment) {
+        map.set(`${table.tableName}.${field.fieldName}`, field.comment);
+      }
+    }
+  }
+  return map;
+}
+function extractTypeAnnotation(comment) {
+  const typeStart = comment.indexOf("@type");
+  if (typeStart === -1) return null;
+  const afterType = comment.slice(typeStart + 5).trimStart();
+  if (!afterType.startsWith("{")) return null;
+  let depth = 0;
+  let endIndex = 0;
+  for (let i = 0; i < afterType.length; i++) {
+    if (afterType[i] === "{") depth++;
+    if (afterType[i] === "}") depth--;
+    if (depth === 0) {
+      endIndex = i + 1;
+      break;
+    }
+  }
+  if (endIndex === 0) return null;
+  return afterType.slice(0, endIndex);
+}
+function parseColumnComment(comment) {
+  const typeValue = extractTypeAnnotation(comment);
+  if (typeValue) {
+    const descMatch = comment.match(/@description\s+([^@]+)/);
+    return {
+      type: typeValue,
+      description: descMatch?.[1]?.trim()
+    };
+  }
+  return { description: comment.trim() };
+}
+
+// src/enhancer/enhancers/synced-comments.ts
+var TABLE_COMMENT = "Synced table: data is auto-synced from external source. Do not rename or delete this table.";
+var FIELD_COMMENT = "Synced field: auto-synced, do not modify or delete";
+var TABLE_DEF_REGEX2 = /^(export const\s+\w+\s*=\s*(?:pgTable|pgView|pgMaterializedView)\(\s*["'`])([^"'`]+)(["'`])/;
+var FIELD_WITH_NAME_REGEX = /^\s*[\w"']+\s*:\s*\w+\(\s*["'`]([^"'`]+)["'`]/;
+var FIELD_PROP_NAME_REGEX = /^\s*([\w]+)\s*:/;
+var syncedCommentsEnhancer = {
+  name: "synced-comments",
+  enhance(source, context) {
+    const syncedTableMap = context.schemaData.syncedTableMap;
+    if (!syncedTableMap || syncedTableMap.size === 0) {
+      return { source };
+    }
+    const lines = source.split("\n");
+    const result = [];
+    let commentsAdded = 0;
+    let currentSyncedFields = null;
+    let insideTableBody = false;
+    let braceDepth = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const tableMatch = line.match(TABLE_DEF_REGEX2);
+      if (tableMatch) {
+        const tableName = tableMatch[2];
+        const syncedFields = syncedTableMap.get(tableName);
+        if (syncedFields) {
+          currentSyncedFields = syncedFields;
+          insideTableBody = true;
+          braceDepth = 0;
+          const prevLine = result[result.length - 1]?.trim() ?? "";
+          if (!prevLine.includes("Synced table")) {
+            const indentMatch = line.match(/^\s*/);
+            const indent = indentMatch ? indentMatch[0] : "";
+            result.push(`${indent}// ${TABLE_COMMENT}`);
+            commentsAdded++;
+          }
+        }
+      }
+      if (insideTableBody) {
+        for (const ch of line) {
+          if (ch === "{") braceDepth++;
+          if (ch === "}") braceDepth--;
+        }
+        if (braceDepth <= 0) {
+          insideTableBody = false;
+          currentSyncedFields = null;
+        }
+        if (currentSyncedFields && braceDepth >= 1 && !tableMatch) {
+          const columnName = extractColumnName(line);
+          if (columnName && currentSyncedFields.has(columnName)) {
+            const prevLine = result[result.length - 1]?.trim() ?? "";
+            if (!prevLine.includes("Synced field")) {
+              const indentMatch = line.match(/^\s*/);
+              const indent = indentMatch ? indentMatch[0] : "";
+              result.push(`${indent}// ${FIELD_COMMENT}`);
+              commentsAdded++;
+            }
+          }
+        }
+      }
+      result.push(line);
+    }
+    return {
+      source: result.join("\n"),
+      stats: { commentsAdded }
+    };
+  }
+};
+function extractColumnName(line) {
+  const withNameMatch = line.match(FIELD_WITH_NAME_REGEX);
+  if (withNameMatch) {
+    return withNameMatch[1];
+  }
+  const propMatch = line.match(FIELD_PROP_NAME_REGEX);
+  if (propMatch) {
+    return propMatch[1];
+  }
+  return null;
+}
+
+// src/enhancer/enhancers/table-aliases.ts
+var TABLE_ALIAS_MARKER = "// table aliases";
+var tableAliasesEnhancer = {
+  name: "table-aliases",
+  enhance(source, _context) {
+    const markerIndex = source.indexOf(`
+${TABLE_ALIAS_MARKER}`);
+    const base = markerIndex === -1 ? source : source.slice(0, markerIndex);
+    const exportRegex = /export const\s+([A-Za-z_$][\w$]*)\s*=\s*(?:pgTable|pgView|pgMaterializedView)\s*\(/g;
+    const tableExports = /* @__PURE__ */ new Set();
+    for (const match of base.matchAll(exportRegex)) {
+      tableExports.add(match[1]);
+    }
+    if (tableExports.size === 0) {
+      return { source: base, stats: { aliasesGenerated: 0 } };
+    }
+    const aliasLines = Array.from(tableExports).sort().map((name) => `export const ${name}Table = ${name};`).join("\n");
+    const prefix = base.trimEnd();
+    return {
+      source: `${prefix}
+
+${TABLE_ALIAS_MARKER}
+${aliasLines}
+`,
+      stats: { aliasesGenerated: tableExports.size }
+    };
+  }
+};
+
+// src/enhancer/enhancers/format.ts
+var formatEnhancer = {
+  name: "format",
+  enhance(source, _context) {
+    let text = source;
+    text = text.replace(/\r\n/g, "\n");
+    text = text.replace(/\n{3,}/g, "\n\n");
+    if (!text.endsWith("\n")) {
+      text += "\n";
+    }
+    return { source: text };
+  }
+};
+
+// src/enhancer/enhancers/index.ts
+var defaultEnhancers = [
+  headerEnhancer,
+  inlineTypesEnhancer,
+  systemCommentsEnhancer,
+  jsonbCommentsEnhancer,
+  syncedCommentsEnhancer,
+  tableAliasesEnhancer,
+  formatEnhancer
+];
+
+// src/index.ts
+async function generateSchema(options) {
+  const schemaData = await fetchSchemaData(options);
+  return generateSchemaFromData(schemaData, options);
+}
+function generateSchemaFromData(schemaData, options) {
+  const rawCode = generateSchemaCode(schemaData);
+  const enhancers = options?.skipEnhancers ? defaultEnhancers.filter((e) => !options.skipEnhancers.includes(e.name)) : defaultEnhancers;
+  const context = {
+    schemaData,
+    exportCustomTypes: options?.exportCustomTypes ?? false
+  };
+  const { source } = runEnhancers(rawCode, enhancers, context);
+  return source;
+}
+
+export {
+  __require,
+  __commonJS,
+  __toESM,
+  resolveEnvOptions,
+  normalizeApiResponse,
+  generateSchemaCode,
+  generateSchema,
+  generateSchemaFromData
+};