@objectstack/spec 3.0.0 → 3.0.1

package/dist/index.js

@@ -12,21 +12,35 @@ var __export = (target, all) => {
 var shared_exports = {};
 __export(shared_exports, {
   AggregationFunctionEnum: () => AggregationFunctionEnum,
+  AppNameSchema: () => AppNameSchema,
   BaseMetadataRecordSchema: () => BaseMetadataRecordSchema,
   CacheStrategyEnum: () => CacheStrategyEnum,
   CorsConfigSchema: () => CorsConfigSchema,
   EventNameSchema: () => EventNameSchema,
   FieldMappingSchema: () => FieldMappingSchema,
+  FieldNameSchema: () => FieldNameSchema,
+  FlowNameSchema: () => FlowNameSchema,
   HttpMethod: () => HttpMethod,
   IsolationLevelEnum: () => IsolationLevelEnum,
   MetadataFormatSchema: () => MetadataFormatSchema,
   MutationEventEnum: () => MutationEventEnum,
+  ObjectNameSchema: () => ObjectNameSchema,
   RateLimitConfigSchema: () => RateLimitConfigSchema,
+  RoleNameSchema: () => RoleNameSchema,
   SnakeCaseIdentifierSchema: () => SnakeCaseIdentifierSchema,
   SortDirectionEnum: () => SortDirectionEnum,
   StaticMountSchema: () => StaticMountSchema,
   SystemIdentifierSchema: () => SystemIdentifierSchema,
-  TransformTypeSchema: () => TransformTypeSchema
+  TransformTypeSchema: () => TransformTypeSchema,
+  ViewNameSchema: () => ViewNameSchema,
+  findClosestMatches: () => findClosestMatches,
+  formatSuggestion: () => formatSuggestion,
+  formatZodError: () => formatZodError,
+  formatZodIssue: () => formatZodIssue,
+  levenshteinDistance: () => levenshteinDistance,
+  objectStackErrorMap: () => objectStackErrorMap,
+  safeParsePretty: () => safeParsePretty,
+  suggestFieldType: () => suggestFieldType
 });
 var SystemIdentifierSchema = zod.z.string().min(2, { message: "System identifier must be at least 2 characters" }).regex(/^[a-z][a-z0-9_.]*$/, {
   message: 'System identifier must be lowercase, starting with a letter, and may contain letters, numbers, underscores, or dots (e.g., "user_profile" or "order.created")'
@@ -176,388 +190,13 @@ var BaseMetadataRecordSchema = zod.z.object({
   format: MetadataFormatSchema.optional().describe("Source file format")
 }).describe("Base metadata record fields shared across kernel and system");
 
-// src/data/index.ts
-var data_exports = {};
-__export(data_exports, {
-  ALL_OPERATORS: () => ALL_OPERATORS,
-  AddressSchema: () => AddressSchema,
-  AggregationFunction: () => AggregationFunction,
-  AggregationMetricType: () => AggregationMetricType,
-  AggregationNodeSchema: () => AggregationNodeSchema,
-  AggregationPipelineSchema: () => AggregationPipelineSchema,
-  AggregationStageSchema: () => AggregationStageSchema,
-  AnalyticsQuerySchema: () => AnalyticsQuerySchema,
-  ApiMethod: () => ApiMethod,
-  AsyncValidationSchema: () => AsyncValidationSchema,
-  BaseEngineOptionsSchema: () => BaseEngineOptionsSchema,
-  CDCConfigSchema: () => CDCConfigSchema,
-  ComparisonOperatorSchema: () => ComparisonOperatorSchema,
-  ComputedFieldCacheSchema: () => ComputedFieldCacheSchema,
-  ConditionalValidationSchema: () => ConditionalValidationSchema,
-  ConsistencyLevelSchema: () => ConsistencyLevelSchema,
-  CrossFieldValidationSchema: () => CrossFieldValidationSchema,
-  CubeJoinSchema: () => CubeJoinSchema,
-  CubeSchema: () => CubeSchema,
-  CurrencyConfigSchema: () => CurrencyConfigSchema,
-  CurrencyValueSchema: () => CurrencyValueSchema,
-  CustomValidatorSchema: () => CustomValidatorSchema,
-  DataEngineAggregateOptionsSchema: () => DataEngineAggregateOptionsSchema,
-  DataEngineAggregateRequestSchema: () => DataEngineAggregateRequestSchema,
-  DataEngineBatchRequestSchema: () => DataEngineBatchRequestSchema,
-  DataEngineContractSchema: () => DataEngineContractSchema,
-  DataEngineCountOptionsSchema: () => DataEngineCountOptionsSchema,
-  DataEngineCountRequestSchema: () => DataEngineCountRequestSchema,
-  DataEngineDeleteOptionsSchema: () => DataEngineDeleteOptionsSchema,
-  DataEngineDeleteRequestSchema: () => DataEngineDeleteRequestSchema,
-  DataEngineExecuteRequestSchema: () => DataEngineExecuteRequestSchema,
-  DataEngineFilterSchema: () => DataEngineFilterSchema,
-  DataEngineFindOneRequestSchema: () => DataEngineFindOneRequestSchema,
-  DataEngineFindRequestSchema: () => DataEngineFindRequestSchema,
-  DataEngineInsertOptionsSchema: () => DataEngineInsertOptionsSchema,
-  DataEngineInsertRequestSchema: () => DataEngineInsertRequestSchema,
-  DataEngineQueryOptionsSchema: () => DataEngineQueryOptionsSchema,
-  DataEngineRequestSchema: () => DataEngineRequestSchema,
-  DataEngineSortSchema: () => DataEngineSortSchema,
-  DataEngineUpdateOptionsSchema: () => DataEngineUpdateOptionsSchema,
-  DataEngineUpdateRequestSchema: () => DataEngineUpdateRequestSchema,
-  DataEngineVectorFindRequestSchema: () => DataEngineVectorFindRequestSchema,
-  DataQualityRulesSchema: () => DataQualityRulesSchema,
-  DataTypeMappingSchema: () => DataTypeMappingSchema,
-  DatasetMode: () => DatasetMode,
-  DatasetSchema: () => DatasetSchema,
-  DatasourceCapabilities: () => DatasourceCapabilities,
-  DatasourceSchema: () => DatasourceSchema,
-  DimensionSchema: () => DimensionSchema,
-  DimensionType: () => DimensionType,
-  DocumentSchema: () => DocumentSchema,
-  DocumentSchemaValidationSchema: () => DocumentSchemaValidationSchema,
-  DocumentTemplateSchema: () => DocumentTemplateSchema,
-  DocumentVersionSchema: () => DocumentVersionSchema,
-  DriverCapabilitiesSchema: () => DriverCapabilitiesSchema,
-  DriverConfigSchema: () => DriverConfigSchema,
-  DriverDefinitionSchema: () => DriverDefinitionSchema,
-  DriverInterfaceSchema: () => DriverInterfaceSchema,
-  DriverOptionsSchema: () => DriverOptionsSchema,
-  DriverType: () => DriverType,
-  ESignatureConfigSchema: () => ESignatureConfigSchema,
-  EqualityOperatorSchema: () => EqualityOperatorSchema,
-  ExternalDataSourceSchema: () => ExternalDataSourceSchema,
-  ExternalFieldMappingSchema: () => ExternalFieldMappingSchema,
-  ExternalLookupSchema: () => ExternalLookupSchema,
-  FILTER_OPERATORS: () => FILTER_OPERATORS,
-  Field: () => Field,
-  FieldMappingSchema: () => FieldMappingSchema2,
-  FieldNodeSchema: () => FieldNodeSchema,
-  FieldOperatorsSchema: () => FieldOperatorsSchema,
-  FieldReferenceSchema: () => FieldReferenceSchema,
-  FieldSchema: () => FieldSchema,
-  FieldType: () => FieldType,
-  FileAttachmentConfigSchema: () => FileAttachmentConfigSchema,
-  FilterConditionSchema: () => FilterConditionSchema,
-  FormatValidationSchema: () => FormatValidationSchema,
-  FullTextSearchSchema: () => FullTextSearchSchema,
-  HookContextSchema: () => HookContextSchema,
-  HookEvent: () => HookEvent,
-  HookSchema: () => HookSchema,
-  IndexSchema: () => IndexSchema,
-  JSONValidationSchema: () => JSONValidationSchema,
-  JoinNodeSchema: () => JoinNodeSchema,
-  JoinStrategy: () => JoinStrategy,
-  JoinType: () => JoinType,
-  LOGICAL_OPERATORS: () => LOGICAL_OPERATORS,
-  LocationCoordinatesSchema: () => LocationCoordinatesSchema,
-  MappingSchema: () => MappingSchema,
-  MetricSchema: () => MetricSchema,
-  NoSQLDataTypeMappingSchema: () => NoSQLDataTypeMappingSchema,
-  NoSQLDatabaseTypeSchema: () => NoSQLDatabaseTypeSchema,
-  NoSQLDriverConfigSchema: () => NoSQLDriverConfigSchema,
-  NoSQLIndexSchema: () => NoSQLIndexSchema,
-  NoSQLIndexTypeSchema: () => NoSQLIndexTypeSchema,
-  NoSQLOperationTypeSchema: () => NoSQLOperationTypeSchema,
-  NoSQLQueryOptionsSchema: () => NoSQLQueryOptionsSchema,
-  NoSQLTransactionOptionsSchema: () => NoSQLTransactionOptionsSchema,
-  NormalizedFilterSchema: () => NormalizedFilterSchema,
-  ObjectCapabilities: () => ObjectCapabilities,
-  ObjectExtensionSchema: () => ObjectExtensionSchema,
-  ObjectOwnershipEnum: () => ObjectOwnershipEnum,
-  ObjectSchema: () => ObjectSchema,
-  PartitioningConfigSchema: () => PartitioningConfigSchema,
-  PoolConfigSchema: () => PoolConfigSchema,
-  QueryFilterSchema: () => QueryFilterSchema,
-  QuerySchema: () => QuerySchema,
-  RangeOperatorSchema: () => RangeOperatorSchema,
-  ReplicationConfigSchema: () => ReplicationConfigSchema,
-  SQLDialectSchema: () => SQLDialectSchema,
-  SQLDriverConfigSchema: () => SQLDriverConfigSchema,
-  SSLConfigSchema: () => SSLConfigSchema,
-  ScriptValidationSchema: () => ScriptValidationSchema,
-  SearchConfigSchema: () => SearchConfigSchema,
-  SelectOptionSchema: () => SelectOptionSchema,
-  SetOperatorSchema: () => SetOperatorSchema,
-  ShardingConfigSchema: () => ShardingConfigSchema,
-  SoftDeleteConfigSchema: () => SoftDeleteConfigSchema,
-  SortNodeSchema: () => SortNodeSchema,
-  SpecialOperatorSchema: () => SpecialOperatorSchema,
-  StateMachineValidationSchema: () => StateMachineValidationSchema,
-  StringOperatorSchema: () => StringOperatorSchema,
-  TenancyConfigSchema: () => TenancyConfigSchema,
-  TimeUpdateInterval: () => TimeUpdateInterval,
-  TransformType: () => TransformType,
-  UniquenessValidationSchema: () => UniquenessValidationSchema,
-  ValidationRuleSchema: () => ValidationRuleSchema,
-  VectorConfigSchema: () => VectorConfigSchema,
-  VersioningConfigSchema: () => VersioningConfigSchema,
-  WindowFunction: () => WindowFunction,
-  WindowFunctionNodeSchema: () => WindowFunctionNodeSchema,
-  WindowSpecSchema: () => WindowSpecSchema
-});
-var FieldReferenceSchema = zod.z.object({
-  $field: zod.z.string().describe("Field Reference/Column Name")
-});
-var EqualityOperatorSchema = zod.z.object({
-  /** Equal to (default) - SQL: = | MongoDB: $eq */
-  $eq: zod.z.any().optional(),
-  /** Not equal to - SQL: <> or != | MongoDB: $ne */
-  $ne: zod.z.any().optional()
-});
-var ComparisonOperatorSchema = zod.z.object({
-  /** Greater than - SQL: > | MongoDB: $gt */
-  $gt: zod.z.union([zod.z.number(), zod.z.date(), FieldReferenceSchema]).optional(),
-  /** Greater than or equal to - SQL: >= | MongoDB: $gte */
-  $gte: zod.z.union([zod.z.number(), zod.z.date(), FieldReferenceSchema]).optional(),
-  /** Less than - SQL: < | MongoDB: $lt */
-  $lt: zod.z.union([zod.z.number(), zod.z.date(), FieldReferenceSchema]).optional(),
-  /** Less than or equal to - SQL: <= | MongoDB: $lte */
-  $lte: zod.z.union([zod.z.number(), zod.z.date(), FieldReferenceSchema]).optional()
-});
-var SetOperatorSchema = zod.z.object({
-  /** In list - SQL: IN (?, ?, ?) | MongoDB: $in */
-  $in: zod.z.array(zod.z.any()).optional(),
-  /** Not in list - SQL: NOT IN (...) | MongoDB: $nin */
-  $nin: zod.z.array(zod.z.any()).optional()
-});
-var RangeOperatorSchema = zod.z.object({
-  /** Between (inclusive) - takes [min, max] array */
-  $between: zod.z.tuple([
-    zod.z.union([zod.z.number(), zod.z.date(), FieldReferenceSchema]),
-    zod.z.union([zod.z.number(), zod.z.date(), FieldReferenceSchema])
-  ]).optional()
-});
-var StringOperatorSchema = zod.z.object({
-  /** Contains substring - SQL: LIKE %?% | MongoDB: $regex */
-  $contains: zod.z.string().optional(),
-  /** Starts with prefix - SQL: LIKE ?% | MongoDB: $regex */
-  $startsWith: zod.z.string().optional(),
-  /** Ends with suffix - SQL: LIKE %? | MongoDB: $regex */
-  $endsWith: zod.z.string().optional()
-});
-var SpecialOperatorSchema = zod.z.object({
-  /** Is null check - SQL: IS NULL (true) / IS NOT NULL (false) | MongoDB: field: null */
-  $null: zod.z.boolean().optional(),
-  /** Field exists check (primarily for NoSQL) - MongoDB: $exists */
-  $exists: zod.z.boolean().optional()
-});
-var FieldOperatorsSchema = zod.z.object({
-  // Equality
-  $eq: zod.z.any().optional(),
-  $ne: zod.z.any().optional(),
-  // Comparison (numeric/date)
-  $gt: zod.z.union([zod.z.number(), zod.z.date(), FieldReferenceSchema]).optional(),
-  $gte: zod.z.union([zod.z.number(), zod.z.date(), FieldReferenceSchema]).optional(),
-  $lt: zod.z.union([zod.z.number(), zod.z.date(), FieldReferenceSchema]).optional(),
-  $lte: zod.z.union([zod.z.number(), zod.z.date(), FieldReferenceSchema]).optional(),
-  // Set & Range
-  $in: zod.z.array(zod.z.any()).optional(),
-  $nin: zod.z.array(zod.z.any()).optional(),
-  $between: zod.z.tuple([
-    zod.z.union([zod.z.number(), zod.z.date(), FieldReferenceSchema]),
-    zod.z.union([zod.z.number(), zod.z.date(), FieldReferenceSchema])
-  ]).optional(),
-  // String-specific
-  $contains: zod.z.string().optional(),
-  $startsWith: zod.z.string().optional(),
-  $endsWith: zod.z.string().optional(),
-  // Special
-  $null: zod.z.boolean().optional(),
-  $exists: zod.z.boolean().optional()
-});
-var FilterConditionSchema = zod.z.lazy(
-  () => zod.z.record(zod.z.string(), zod.z.unknown()).and(
-    zod.z.object({
-      $and: zod.z.array(FilterConditionSchema).optional(),
-      $or: zod.z.array(FilterConditionSchema).optional(),
-      $not: FilterConditionSchema.optional()
-    })
-  )
-);
-var QueryFilterSchema = zod.z.object({
-  where: FilterConditionSchema.optional()
-});
-var NormalizedFilterSchema = zod.z.lazy(
-  () => zod.z.object({
-    $and: zod.z.array(
-      zod.z.union([
-        // Field condition: { field: { $op: value } }
-        zod.z.record(zod.z.string(), FieldOperatorsSchema),
-        // Nested logical group
-        NormalizedFilterSchema
-      ])
-    ).optional(),
-    $or: zod.z.array(
-      zod.z.union([
-        zod.z.record(zod.z.string(), FieldOperatorsSchema),
-        NormalizedFilterSchema
-      ])
-    ).optional(),
-    $not: zod.z.union([
-      zod.z.record(zod.z.string(), FieldOperatorsSchema),
-      NormalizedFilterSchema
-    ]).optional()
-  })
-);
-var FILTER_OPERATORS = [
-  // Equality
-  "$eq",
-  "$ne",
-  // Comparison
-  "$gt",
-  "$gte",
-  "$lt",
-  "$lte",
-  // Set & Range
-  "$in",
-  "$nin",
-  "$between",
-  // String
-  "$contains",
-  "$startsWith",
-  "$endsWith",
-  // Special
-  "$null",
-  "$exists"
-];
-var LOGICAL_OPERATORS = ["$and", "$or", "$not"];
-var ALL_OPERATORS = [...FILTER_OPERATORS, ...LOGICAL_OPERATORS];
-
-// src/data/query.zod.ts
-var SortNodeSchema = zod.z.object({
-  field: zod.z.string(),
-  order: zod.z.enum(["asc", "desc"]).default("asc")
-});
-var AggregationFunction = zod.z.enum([
-  "count",
-  "sum",
-  "avg",
-  "min",
-  "max",
-  "count_distinct",
-  "array_agg",
-  "string_agg"
-]);
-var AggregationNodeSchema = zod.z.object({
-  function: AggregationFunction.describe("Aggregation function"),
-  field: zod.z.string().optional().describe("Field to aggregate (optional for COUNT(*))"),
-  alias: zod.z.string().describe("Result column alias"),
-  distinct: zod.z.boolean().optional().describe("Apply DISTINCT before aggregation"),
-  filter: FilterConditionSchema.optional().describe("Filter/Condition to apply to the aggregation (FILTER WHERE clause)")
-});
-var JoinType = zod.z.enum(["inner", "left", "right", "full"]);
-var JoinStrategy = zod.z.enum(["auto", "database", "hash", "loop"]);
-var JoinNodeSchema = zod.z.lazy(
-  () => zod.z.object({
-    type: JoinType.describe("Join type"),
-    strategy: JoinStrategy.optional().describe("Execution strategy hint"),
-    object: zod.z.string().describe("Object/table to join"),
-    alias: zod.z.string().optional().describe("Table alias"),
-    on: FilterConditionSchema.describe("Join condition"),
-    subquery: zod.z.lazy(() => QuerySchema).optional().describe("Subquery instead of object")
-  })
-);
-var WindowFunction = zod.z.enum([
-  "row_number",
-  "rank",
-  "dense_rank",
-  "percent_rank",
-  "lag",
-  "lead",
-  "first_value",
-  "last_value",
-  "sum",
-  "avg",
-  "count",
-  "min",
-  "max"
-]);
-var WindowSpecSchema = zod.z.object({
-  partitionBy: zod.z.array(zod.z.string()).optional().describe("PARTITION BY fields"),
-  orderBy: zod.z.array(SortNodeSchema).optional().describe("ORDER BY specification"),
-  frame: zod.z.object({
-    type: zod.z.enum(["rows", "range"]).optional(),
-    start: zod.z.string().optional().describe('Frame start (e.g., "UNBOUNDED PRECEDING", "1 PRECEDING")'),
-    end: zod.z.string().optional().describe('Frame end (e.g., "CURRENT ROW", "1 FOLLOWING")')
-  }).optional().describe("Window frame specification")
-});
-var WindowFunctionNodeSchema = zod.z.object({
-  function: WindowFunction.describe("Window function name"),
-  field: zod.z.string().optional().describe("Field to operate on (for aggregate window functions)"),
-  alias: zod.z.string().describe("Result column alias"),
-  over: WindowSpecSchema.describe("Window specification (OVER clause)")
-});
-var FieldNodeSchema = zod.z.lazy(
-  () => zod.z.union([
-    zod.z.string(),
-    // Primitive field: "name"
-    zod.z.object({
-      field: zod.z.string(),
-      // Relationship field: "owner"
-      fields: zod.z.array(FieldNodeSchema).optional(),
-      // Nested select: ["name", "email"]
-      alias: zod.z.string().optional()
-    })
-  ])
-);
-var FullTextSearchSchema = zod.z.object({
-  query: zod.z.string().describe("Search query text"),
-  fields: zod.z.array(zod.z.string()).optional().describe("Fields to search in (if not specified, searches all text fields)"),
-  fuzzy: zod.z.boolean().optional().default(false).describe("Enable fuzzy matching (tolerates typos)"),
-  operator: zod.z.enum(["and", "or"]).optional().default("or").describe("Logical operator between terms"),
-  boost: zod.z.record(zod.z.string(), zod.z.number()).optional().describe("Field-specific relevance boosting (field name -> boost factor)"),
-  minScore: zod.z.number().optional().describe("Minimum relevance score threshold"),
-  language: zod.z.string().optional().describe('Language for text analysis (e.g., "en", "zh", "es")'),
-  highlight: zod.z.boolean().optional().default(false).describe("Enable search result highlighting")
-});
-var BaseQuerySchema = zod.z.object({
-  /** Target Entity */
-  object: zod.z.string().describe("Object name (e.g. account)"),
-  /** Select Clause */
-  fields: zod.z.array(FieldNodeSchema).optional().describe("Fields to retrieve"),
-  /** Where Clause (Filtering) */
-  where: FilterConditionSchema.optional().describe("Filtering criteria (WHERE)"),
-  /** Full-Text Search */
-  search: FullTextSearchSchema.optional().describe("Full-text search configuration ($search parameter)"),
-  /** Order By Clause (Sorting) */
-  orderBy: zod.z.array(SortNodeSchema).optional().describe("Sorting instructions (ORDER BY)"),
-  /** Pagination */
-  limit: zod.z.number().optional().describe("Max records to return (LIMIT)"),
-  offset: zod.z.number().optional().describe("Records to skip (OFFSET)"),
-  top: zod.z.number().optional().describe("Alias for limit (OData compatibility)"),
-  cursor: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Cursor for keyset pagination"),
-  /** Joins */
-  joins: zod.z.array(JoinNodeSchema).optional().describe("Explicit Table Joins"),
-  /** Aggregations */
-  aggregations: zod.z.array(AggregationNodeSchema).optional().describe("Aggregation functions"),
-  /** Group By Clause */
-  groupBy: zod.z.array(zod.z.string()).optional().describe("GROUP BY fields"),
-  /** Having Clause */
-  having: FilterConditionSchema.optional().describe("HAVING clause for aggregation filtering"),
-  /** Window Functions */
-  windowFunctions: zod.z.array(WindowFunctionNodeSchema).optional().describe("Window functions with OVER clause"),
-  /** Subquery flag */
-  distinct: zod.z.boolean().optional().describe("SELECT DISTINCT flag")
-});
-var QuerySchema = BaseQuerySchema.extend({
-  expand: zod.z.lazy(() => zod.z.record(zod.z.string(), QuerySchema)).optional().describe("Recursive relation loading (nested queries)")
-});
+// src/shared/branded-types.zod.ts
+var ObjectNameSchema = SnakeCaseIdentifierSchema.brand().describe("Branded object name (snake_case, no dots)");
+var FieldNameSchema = SnakeCaseIdentifierSchema.brand().describe("Branded field name (snake_case, no dots)");
+var ViewNameSchema = SystemIdentifierSchema.brand().describe("Branded view name (system identifier)");
+var AppNameSchema = SystemIdentifierSchema.brand().describe("Branded app name (system identifier)");
+var FlowNameSchema = SystemIdentifierSchema.brand().describe("Branded flow name (system identifier)");
+var RoleNameSchema = SystemIdentifierSchema.brand().describe("Branded role name (system identifier)");
 var EncryptionAlgorithmSchema = zod.z.enum([
   "aes-256-gcm",
   "aes-256-cbc",
@@ -1042,6 +681,601 @@ var Field = {
     ...config
   })
 };
+
+// src/shared/suggestions.zod.ts
+function levenshteinDistance(a, b) {
+  const la = a.length;
+  const lb = b.length;
+  if (la === 0) return lb;
+  if (lb === 0) return la;
+  let prev = new Array(lb + 1);
+  let curr = new Array(lb + 1);
+  for (let j = 0; j <= lb; j++) {
+    prev[j] = j;
+  }
+  for (let i = 1; i <= la; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= lb; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(
+        prev[j] + 1,
+        // deletion
+        curr[j - 1] + 1,
+        // insertion
+        prev[j - 1] + cost
+        // substitution
+      );
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[lb];
+}
+function findClosestMatches(input, candidates, maxDistance = 3, maxResults = 3) {
+  const normalized = input.toLowerCase().replace(/[-\s]/g, "_");
+  const scored = candidates.map((candidate) => ({
+    value: candidate,
+    distance: levenshteinDistance(normalized, candidate)
+  })).filter((s) => s.distance <= maxDistance && s.distance > 0).sort((a, b) => a.distance - b.distance);
+  return scored.slice(0, maxResults).map((s) => s.value);
+}
+var FIELD_TYPE_ALIASES = {
+  // Common alternative names
+  string: "text",
+  str: "text",
+  varchar: "text",
+  char: "text",
+  int: "number",
+  integer: "number",
+  float: "number",
+  double: "number",
+  decimal: "number",
+  numeric: "number",
+  bool: "boolean",
+  checkbox: "boolean",
+  check: "boolean",
+  date_time: "datetime",
+  timestamp: "datetime",
+  // Common typos
+  text_area: "textarea",
+  textarea_: "textarea",
+  textfield: "text",
+  dropdown: "select",
+  picklist: "select",
+  enum: "select",
+  multi_select: "multiselect",
+  multiselect_: "multiselect",
+  reference: "lookup",
+  ref: "lookup",
+  foreign_key: "lookup",
+  fk: "lookup",
+  relation: "lookup",
+  master: "master_detail",
+  richtext_: "richtext",
+  rich_text: "richtext",
+  upload: "file",
+  attachment: "file",
+  photo: "image",
+  picture: "image",
+  img: "image",
+  percent_: "percent",
+  percentage: "percent",
+  money: "currency",
+  price: "currency",
+  auto_number: "autonumber",
+  auto_increment: "autonumber",
+  sequence: "autonumber",
+  markdown_: "markdown",
+  md: "markdown",
+  barcode: "qrcode",
+  tag: "tags",
+  star: "rating",
+  stars: "rating",
+  geo: "location",
+  gps: "location",
+  coordinates: "location",
+  embed: "vector",
+  embedding: "vector",
+  embeddings: "vector"
+};
+function suggestFieldType(input) {
+  const normalized = input.toLowerCase().replace(/[-\s]/g, "_");
+  const alias = FIELD_TYPE_ALIASES[normalized];
+  if (alias) {
+    return [alias];
+  }
+  return findClosestMatches(normalized, FieldType.options);
+}
+function formatSuggestion(suggestions) {
+  if (suggestions.length === 0) return "";
+  if (suggestions.length === 1) return `Did you mean '${suggestions[0]}'?`;
+  return `Did you mean one of: ${suggestions.map((s) => `'${s}'`).join(", ")}?`;
+}
+
+// src/shared/error-map.zod.ts
+var objectStackErrorMap = (issue) => {
+  if (issue.code === "invalid_value") {
+    const values = issue.values;
+    const input = issue.input;
+    const received = String(input ?? "");
+    const options = values.map(String);
+    const fieldTypeOptions = FieldType.options;
+    const isFieldTypeEnum = options.length > 10 && fieldTypeOptions.every((ft) => options.includes(ft));
+    if (isFieldTypeEnum) {
+      const suggestions2 = suggestFieldType(received);
+      const suggestion2 = formatSuggestion(suggestions2);
+      const base2 = `Invalid field type '${received}'.`;
+      return {
+        message: suggestion2 ? `${base2} ${suggestion2}` : `${base2} Valid types: ${options.slice(0, 10).join(", ")}...`
+      };
+    }
+    const suggestions = findClosestMatches(received, options);
+    const suggestion = formatSuggestion(suggestions);
+    const base = `Invalid value '${received}'.`;
+    return {
+      message: suggestion ? `${base} ${suggestion}` : `${base} Expected one of: ${options.join(", ")}.`
+    };
+  }
+  if (issue.code === "too_small") {
+    const origin = issue.origin;
+    const minimum = issue.minimum;
+    if (origin === "string") {
+      return {
+        message: `Must be at least ${minimum} character${minimum === 1 ? "" : "s"} long.`
+      };
+    }
+  }
+  if (issue.code === "too_big") {
+    const origin = issue.origin;
+    const maximum = issue.maximum;
+    if (origin === "string") {
+      return {
+        message: `Must be at most ${maximum} character${maximum === 1 ? "" : "s"} long.`
+      };
+    }
+  }
+  if (issue.code === "invalid_format") {
+    const format = issue.format;
+    const input = issue.input;
+    if (format === "regex" && input) {
+      const pathArr = issue.path;
+      const pathStr = pathArr?.join(".") ?? "";
+      if (pathStr.endsWith("name") || pathStr === "name") {
+        return {
+          message: `Invalid identifier '${input}'. Must be lowercase snake_case (e.g., 'my_object', 'task_name'). No uppercase, spaces, or hyphens allowed.`
+        };
+      }
+    }
+  }
+  if (issue.code === "invalid_type") {
+    const expected = issue.expected;
+    const input = issue.input;
+    if (input === void 0) {
+      const pathArr = issue.path;
+      const field = pathArr?.[pathArr.length - 1] ?? "";
+      return {
+        message: `Required property '${field}' is missing.`
+      };
+    }
+    const receivedType = input === null ? "null" : typeof input;
+    return {
+      message: `Expected ${expected} but received ${receivedType}.`
+    };
+  }
+  if (issue.code === "unrecognized_keys") {
+    const keys = issue.keys;
+    const keyStr = keys.join(", ");
+    return {
+      message: `Unrecognized key${keys.length > 1 ? "s" : ""}: ${keyStr}. Check for typos in property names.`
+    };
+  }
+  return null;
+};
+function formatZodIssue(issue) {
+  const path = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+  return `  \u2717 ${path}: ${issue.message}`;
+}
+function formatZodError(error, label) {
+  const count = error.issues.length;
+  const header = label ? `${label} (${count} issue${count === 1 ? "" : "s"}):` : `Validation failed (${count} issue${count === 1 ? "" : "s"}):`;
+  const lines = error.issues.map(formatZodIssue);
+  return `${header}
+
+${lines.join("\n")}`;
+}
+function safeParsePretty(schema, data, label) {
+  const result = schema.safeParse(data, { error: objectStackErrorMap });
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return {
+    success: false,
+    error: result.error,
+    formatted: formatZodError(result.error, label)
+  };
+}
+
+// src/data/index.ts
+var data_exports = {};
+__export(data_exports, {
+  ALL_OPERATORS: () => ALL_OPERATORS,
+  AddressSchema: () => AddressSchema,
+  AggregationFunction: () => AggregationFunction,
+  AggregationMetricType: () => AggregationMetricType,
+  AggregationNodeSchema: () => AggregationNodeSchema,
+  AggregationPipelineSchema: () => AggregationPipelineSchema,
+  AggregationStageSchema: () => AggregationStageSchema,
+  AnalyticsQuerySchema: () => AnalyticsQuerySchema,
+  ApiMethod: () => ApiMethod,
+  AsyncValidationSchema: () => AsyncValidationSchema,
+  BaseEngineOptionsSchema: () => BaseEngineOptionsSchema,
+  CDCConfigSchema: () => CDCConfigSchema,
+  ComparisonOperatorSchema: () => ComparisonOperatorSchema,
+  ComputedFieldCacheSchema: () => ComputedFieldCacheSchema,
+  ConditionalValidationSchema: () => ConditionalValidationSchema,
+  ConsistencyLevelSchema: () => ConsistencyLevelSchema,
+  CrossFieldValidationSchema: () => CrossFieldValidationSchema,
+  CubeJoinSchema: () => CubeJoinSchema,
+  CubeSchema: () => CubeSchema,
+  CurrencyConfigSchema: () => CurrencyConfigSchema,
+  CurrencyValueSchema: () => CurrencyValueSchema,
+  CustomValidatorSchema: () => CustomValidatorSchema,
+  DataEngineAggregateOptionsSchema: () => DataEngineAggregateOptionsSchema,
+  DataEngineAggregateRequestSchema: () => DataEngineAggregateRequestSchema,
+  DataEngineBatchRequestSchema: () => DataEngineBatchRequestSchema,
+  DataEngineContractSchema: () => DataEngineContractSchema,
+  DataEngineCountOptionsSchema: () => DataEngineCountOptionsSchema,
+  DataEngineCountRequestSchema: () => DataEngineCountRequestSchema,
+  DataEngineDeleteOptionsSchema: () => DataEngineDeleteOptionsSchema,
+  DataEngineDeleteRequestSchema: () => DataEngineDeleteRequestSchema,
+  DataEngineExecuteRequestSchema: () => DataEngineExecuteRequestSchema,
+  DataEngineFilterSchema: () => DataEngineFilterSchema,
+  DataEngineFindOneRequestSchema: () => DataEngineFindOneRequestSchema,
+  DataEngineFindRequestSchema: () => DataEngineFindRequestSchema,
+  DataEngineInsertOptionsSchema: () => DataEngineInsertOptionsSchema,
+  DataEngineInsertRequestSchema: () => DataEngineInsertRequestSchema,
+  DataEngineQueryOptionsSchema: () => DataEngineQueryOptionsSchema,
+  DataEngineRequestSchema: () => DataEngineRequestSchema,
+  DataEngineSortSchema: () => DataEngineSortSchema,
+  DataEngineUpdateOptionsSchema: () => DataEngineUpdateOptionsSchema,
+  DataEngineUpdateRequestSchema: () => DataEngineUpdateRequestSchema,
+  DataEngineVectorFindRequestSchema: () => DataEngineVectorFindRequestSchema,
+  DataQualityRulesSchema: () => DataQualityRulesSchema,
+  DataTypeMappingSchema: () => DataTypeMappingSchema,
+  DatasetMode: () => DatasetMode,
+  DatasetSchema: () => DatasetSchema,
+  DatasourceCapabilities: () => DatasourceCapabilities,
+  DatasourceSchema: () => DatasourceSchema,
+  DimensionSchema: () => DimensionSchema,
+  DimensionType: () => DimensionType,
+  DocumentSchema: () => DocumentSchema,
+  DocumentSchemaValidationSchema: () => DocumentSchemaValidationSchema,
+  DocumentTemplateSchema: () => DocumentTemplateSchema,
+  DocumentVersionSchema: () => DocumentVersionSchema,
+  DriverCapabilitiesSchema: () => DriverCapabilitiesSchema,
+  DriverConfigSchema: () => DriverConfigSchema,
+  DriverDefinitionSchema: () => DriverDefinitionSchema,
+  DriverInterfaceSchema: () => DriverInterfaceSchema,
+  DriverOptionsSchema: () => DriverOptionsSchema,
+  DriverType: () => DriverType,
+  ESignatureConfigSchema: () => ESignatureConfigSchema,
+  EqualityOperatorSchema: () => EqualityOperatorSchema,
+  ExternalDataSourceSchema: () => ExternalDataSourceSchema,
+  ExternalFieldMappingSchema: () => ExternalFieldMappingSchema,
+  ExternalLookupSchema: () => ExternalLookupSchema,
+  FILTER_OPERATORS: () => FILTER_OPERATORS,
+  Field: () => Field,
+  FieldMappingSchema: () => FieldMappingSchema2,
+  FieldNodeSchema: () => FieldNodeSchema,
+  FieldOperatorsSchema: () => FieldOperatorsSchema,
+  FieldReferenceSchema: () => FieldReferenceSchema,
+  FieldSchema: () => FieldSchema,
+  FieldType: () => FieldType,
+  FileAttachmentConfigSchema: () => FileAttachmentConfigSchema,
+  FilterConditionSchema: () => FilterConditionSchema,
+  FormatValidationSchema: () => FormatValidationSchema,
+  FullTextSearchSchema: () => FullTextSearchSchema,
+  HookContextSchema: () => HookContextSchema,
+  HookEvent: () => HookEvent,
+  HookSchema: () => HookSchema,
+  IndexSchema: () => IndexSchema,
+  JSONValidationSchema: () => JSONValidationSchema,
+  JoinNodeSchema: () => JoinNodeSchema,
+  JoinStrategy: () => JoinStrategy,
+  JoinType: () => JoinType,
+  LOGICAL_OPERATORS: () => LOGICAL_OPERATORS,
+  LocationCoordinatesSchema: () => LocationCoordinatesSchema,
+  MappingSchema: () => MappingSchema,
+  MetricSchema: () => MetricSchema,
+  NoSQLDataTypeMappingSchema: () => NoSQLDataTypeMappingSchema,
+  NoSQLDatabaseTypeSchema: () => NoSQLDatabaseTypeSchema,
+  NoSQLDriverConfigSchema: () => NoSQLDriverConfigSchema,
+  NoSQLIndexSchema: () => NoSQLIndexSchema,
+  NoSQLIndexTypeSchema: () => NoSQLIndexTypeSchema,
+  NoSQLOperationTypeSchema: () => NoSQLOperationTypeSchema,
+  NoSQLQueryOptionsSchema: () => NoSQLQueryOptionsSchema,
+  NoSQLTransactionOptionsSchema: () => NoSQLTransactionOptionsSchema,
+  NormalizedFilterSchema: () => NormalizedFilterSchema,
+  ObjectCapabilities: () => ObjectCapabilities,
+  ObjectExtensionSchema: () => ObjectExtensionSchema,
+  ObjectOwnershipEnum: () => ObjectOwnershipEnum,
+  ObjectSchema: () => ObjectSchema,
+  PartitioningConfigSchema: () => PartitioningConfigSchema,
+  PoolConfigSchema: () => PoolConfigSchema,
+  QueryFilterSchema: () => QueryFilterSchema,
+  QuerySchema: () => QuerySchema,
+  RangeOperatorSchema: () => RangeOperatorSchema,
+  ReplicationConfigSchema: () => ReplicationConfigSchema,
+  SQLDialectSchema: () => SQLDialectSchema,
+  SQLDriverConfigSchema: () => SQLDriverConfigSchema,
+  SSLConfigSchema: () => SSLConfigSchema,
+  ScriptValidationSchema: () => ScriptValidationSchema,
+  SearchConfigSchema: () => SearchConfigSchema,
+  SelectOptionSchema: () => SelectOptionSchema,
+  SetOperatorSchema: () => SetOperatorSchema,
+  ShardingConfigSchema: () => ShardingConfigSchema,
+  SoftDeleteConfigSchema: () => SoftDeleteConfigSchema,
+  SortNodeSchema: () => SortNodeSchema,
+  SpecialOperatorSchema: () => SpecialOperatorSchema,
+  StateMachineValidationSchema: () => StateMachineValidationSchema,
+  StringOperatorSchema: () => StringOperatorSchema,
+  TenancyConfigSchema: () => TenancyConfigSchema,
+  TimeUpdateInterval: () => TimeUpdateInterval,
+  TransformType: () => TransformType,
+  UniquenessValidationSchema: () => UniquenessValidationSchema,
+  ValidationRuleSchema: () => ValidationRuleSchema,
+  VectorConfigSchema: () => VectorConfigSchema,
+  VersioningConfigSchema: () => VersioningConfigSchema,
+  WindowFunction: () => WindowFunction,
+  WindowFunctionNodeSchema: () => WindowFunctionNodeSchema,
+  WindowSpecSchema: () => WindowSpecSchema
+});
+var FieldReferenceSchema = zod.z.object({
+  $field: zod.z.string().describe("Field Reference/Column Name")
+});
+var EqualityOperatorSchema = zod.z.object({
+  /** Equal to (default) - SQL: = | MongoDB: $eq */
+  $eq: zod.z.any().optional(),
+  /** Not equal to - SQL: <> or != | MongoDB: $ne */
+  $ne: zod.z.any().optional()
+});
+var ComparisonOperatorSchema = zod.z.object({
+  /** Greater than - SQL: > | MongoDB: $gt */
+  $gt: zod.z.union([zod.z.number(), zod.z.date(), FieldReferenceSchema]).optional(),
+  /** Greater than or equal to - SQL: >= | MongoDB: $gte */
+  $gte: zod.z.union([zod.z.number(), zod.z.date(), FieldReferenceSchema]).optional(),
+  /** Less than - SQL: < | MongoDB: $lt */
+  $lt: zod.z.union([zod.z.number(), zod.z.date(), FieldReferenceSchema]).optional(),
+  /** Less than or equal to - SQL: <= | MongoDB: $lte */
+  $lte: zod.z.union([zod.z.number(), zod.z.date(), FieldReferenceSchema]).optional()
+});
+var SetOperatorSchema = zod.z.object({
+  /** In list - SQL: IN (?, ?, ?) | MongoDB: $in */
+  $in: zod.z.array(zod.z.any()).optional(),
+  /** Not in list - SQL: NOT IN (...) | MongoDB: $nin */
+  $nin: zod.z.array(zod.z.any()).optional()
+});
+var RangeOperatorSchema = zod.z.object({
+  /** Between (inclusive) - takes [min, max] array */
+  $between: zod.z.tuple([
+    zod.z.union([zod.z.number(), zod.z.date(), FieldReferenceSchema]),
+    zod.z.union([zod.z.number(), zod.z.date(), FieldReferenceSchema])
+  ]).optional()
+});
+var StringOperatorSchema = zod.z.object({
+  /** Contains substring - SQL: LIKE %?% | MongoDB: $regex */
+  $contains: zod.z.string().optional(),
+  /** Starts with prefix - SQL: LIKE ?% | MongoDB: $regex */
+  $startsWith: zod.z.string().optional(),
+  /** Ends with suffix - SQL: LIKE %? | MongoDB: $regex */
+  $endsWith: zod.z.string().optional()
+});
+var SpecialOperatorSchema = zod.z.object({
+  /** Is null check - SQL: IS NULL (true) / IS NOT NULL (false) | MongoDB: field: null */
+  $null: zod.z.boolean().optional(),
+  /** Field exists check (primarily for NoSQL) - MongoDB: $exists */
+  $exists: zod.z.boolean().optional()
+});
+var FieldOperatorsSchema = zod.z.object({
+  // Equality
+  $eq: zod.z.any().optional(),
+  $ne: zod.z.any().optional(),
+  // Comparison (numeric/date)
+  $gt: zod.z.union([zod.z.number(), zod.z.date(), FieldReferenceSchema]).optional(),
+  $gte: zod.z.union([zod.z.number(), zod.z.date(), FieldReferenceSchema]).optional(),
+  $lt: zod.z.union([zod.z.number(), zod.z.date(), FieldReferenceSchema]).optional(),
+  $lte: zod.z.union([zod.z.number(), zod.z.date(), FieldReferenceSchema]).optional(),
+  // Set & Range
+  $in: zod.z.array(zod.z.any()).optional(),
+  $nin: zod.z.array(zod.z.any()).optional(),
+  $between: zod.z.tuple([
+    zod.z.union([zod.z.number(), zod.z.date(), FieldReferenceSchema]),
+    zod.z.union([zod.z.number(), zod.z.date(), FieldReferenceSchema])
+  ]).optional(),
+  // String-specific
+  $contains: zod.z.string().optional(),
+  $startsWith: zod.z.string().optional(),
+  $endsWith: zod.z.string().optional(),
+  // Special
+  $null: zod.z.boolean().optional(),
+  $exists: zod.z.boolean().optional()
+});
+var FilterConditionSchema = zod.z.lazy(
+  () => zod.z.record(zod.z.string(), zod.z.unknown()).and(
+    zod.z.object({
+      $and: zod.z.array(FilterConditionSchema).optional(),
+      $or: zod.z.array(FilterConditionSchema).optional(),
+      $not: FilterConditionSchema.optional()
+    })
+  )
+);
+var QueryFilterSchema = zod.z.object({
+  where: FilterConditionSchema.optional()
+});
+var NormalizedFilterSchema = zod.z.lazy(
+  () => zod.z.object({
+    $and: zod.z.array(
+      zod.z.union([
+        // Field condition: { field: { $op: value } }
+        zod.z.record(zod.z.string(), FieldOperatorsSchema),
+        // Nested logical group
+        NormalizedFilterSchema
+      ])
+    ).optional(),
+    $or: zod.z.array(
+      zod.z.union([
+        zod.z.record(zod.z.string(), FieldOperatorsSchema),
+        NormalizedFilterSchema
+      ])
+    ).optional(),
+    $not: zod.z.union([
+      zod.z.record(zod.z.string(), FieldOperatorsSchema),
+      NormalizedFilterSchema
+    ]).optional()
+  })
+);
+var FILTER_OPERATORS = [
+  // Equality
+  "$eq",
+  "$ne",
+  // Comparison
+  "$gt",
+  "$gte",
+  "$lt",
+  "$lte",
+  // Set & Range
+  "$in",
+  "$nin",
+  "$between",
+  // String
+  "$contains",
+  "$startsWith",
+  "$endsWith",
+  // Special
+  "$null",
+  "$exists"
+];
+var LOGICAL_OPERATORS = ["$and", "$or", "$not"];
+var ALL_OPERATORS = [...FILTER_OPERATORS, ...LOGICAL_OPERATORS];
+
+// src/data/query.zod.ts
+var SortNodeSchema = zod.z.object({
+  field: zod.z.string(),
+  order: zod.z.enum(["asc", "desc"]).default("asc")
+});
+var AggregationFunction = zod.z.enum([
+  "count",
+  "sum",
+  "avg",
+  "min",
+  "max",
+  "count_distinct",
+  "array_agg",
+  "string_agg"
+]);
+var AggregationNodeSchema = zod.z.object({
+  function: AggregationFunction.describe("Aggregation function"),
+  field: zod.z.string().optional().describe("Field to aggregate (optional for COUNT(*))"),
+  alias: zod.z.string().describe("Result column alias"),
+  distinct: zod.z.boolean().optional().describe("Apply DISTINCT before aggregation"),
+  filter: FilterConditionSchema.optional().describe("Filter/Condition to apply to the aggregation (FILTER WHERE clause)")
+});
+var JoinType = zod.z.enum(["inner", "left", "right", "full"]);
+var JoinStrategy = zod.z.enum(["auto", "database", "hash", "loop"]);
+var JoinNodeSchema = zod.z.lazy(
+  () => zod.z.object({
+    type: JoinType.describe("Join type"),
+    strategy: JoinStrategy.optional().describe("Execution strategy hint"),
+    object: zod.z.string().describe("Object/table to join"),
+    alias: zod.z.string().optional().describe("Table alias"),
+    on: FilterConditionSchema.describe("Join condition"),
+    subquery: zod.z.lazy(() => QuerySchema).optional().describe("Subquery instead of object")
+  })
+);
+var WindowFunction = zod.z.enum([
+  "row_number",
+  "rank",
+  "dense_rank",
+  "percent_rank",
+  "lag",
+  "lead",
+  "first_value",
+  "last_value",
+  "sum",
+  "avg",
+  "count",
+  "min",
+  "max"
+]);
+var WindowSpecSchema = zod.z.object({
+  partitionBy: zod.z.array(zod.z.string()).optional().describe("PARTITION BY fields"),
+  orderBy: zod.z.array(SortNodeSchema).optional().describe("ORDER BY specification"),
+  frame: zod.z.object({
+    type: zod.z.enum(["rows", "range"]).optional(),
+    start: zod.z.string().optional().describe('Frame start (e.g., "UNBOUNDED PRECEDING", "1 PRECEDING")'),
+    end: zod.z.string().optional().describe('Frame end (e.g., "CURRENT ROW", "1 FOLLOWING")')
+  }).optional().describe("Window frame specification")
+});
+var WindowFunctionNodeSchema = zod.z.object({
+  function: WindowFunction.describe("Window function name"),
+  field: zod.z.string().optional().describe("Field to operate on (for aggregate window functions)"),
+  alias: zod.z.string().describe("Result column alias"),
+  over: WindowSpecSchema.describe("Window specification (OVER clause)")
+});
+var FieldNodeSchema = zod.z.lazy(
+  () => zod.z.union([
+    zod.z.string(),
+    // Primitive field: "name"
+    zod.z.object({
+      field: zod.z.string(),
+      // Relationship field: "owner"
+      fields: zod.z.array(FieldNodeSchema).optional(),
+      // Nested select: ["name", "email"]
+      alias: zod.z.string().optional()
+    })
+  ])
+);
+var FullTextSearchSchema = zod.z.object({
+  query: zod.z.string().describe("Search query text"),
+  fields: zod.z.array(zod.z.string()).optional().describe("Fields to search in (if not specified, searches all text fields)"),
+  fuzzy: zod.z.boolean().optional().default(false).describe("Enable fuzzy matching (tolerates typos)"),
+  operator: zod.z.enum(["and", "or"]).optional().default("or").describe("Logical operator between terms"),
+  boost: zod.z.record(zod.z.string(), zod.z.number()).optional().describe("Field-specific relevance boosting (field name -> boost factor)"),
+  minScore: zod.z.number().optional().describe("Minimum relevance score threshold"),
+  language: zod.z.string().optional().describe('Language for text analysis (e.g., "en", "zh", "es")'),
+  highlight: zod.z.boolean().optional().default(false).describe("Enable search result highlighting")
+});
+var BaseQuerySchema = zod.z.object({
+  /** Target Entity */
+  object: zod.z.string().describe("Object name (e.g. account)"),
+  /** Select Clause */
+  fields: zod.z.array(FieldNodeSchema).optional().describe("Fields to retrieve"),
+  /** Where Clause (Filtering) */
+  where: FilterConditionSchema.optional().describe("Filtering criteria (WHERE)"),
+  /** Full-Text Search */
+  search: FullTextSearchSchema.optional().describe("Full-text search configuration ($search parameter)"),
+  /** Order By Clause (Sorting) */
+  orderBy: zod.z.array(SortNodeSchema).optional().describe("Sorting instructions (ORDER BY)"),
+  /** Pagination */
+  limit: zod.z.number().optional().describe("Max records to return (LIMIT)"),
+  offset: zod.z.number().optional().describe("Records to skip (OFFSET)"),
+  top: zod.z.number().optional().describe("Alias for limit (OData compatibility)"),
+  cursor: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Cursor for keyset pagination"),
+  /** Joins */
+  joins: zod.z.array(JoinNodeSchema).optional().describe("Explicit Table Joins"),
+  /** Aggregations */
+  aggregations: zod.z.array(AggregationNodeSchema).optional().describe("Aggregation functions"),
+  /** Group By Clause */
+  groupBy: zod.z.array(zod.z.string()).optional().describe("GROUP BY fields"),
+  /** Having Clause */
+  having: FilterConditionSchema.optional().describe("HAVING clause for aggregation filtering"),
+  /** Window Functions */
+  windowFunctions: zod.z.array(WindowFunctionNodeSchema).optional().describe("Window functions with OVER clause"),
+  /** Subquery flag */
+  distinct: zod.z.boolean().optional().describe("SELECT DISTINCT flag")
+});
+var QuerySchema = BaseQuerySchema.extend({
+  expand: zod.z.lazy(() => zod.z.record(zod.z.string(), QuerySchema)).optional().describe("Recursive relation loading (nested queries)")
+});
 var BaseValidationSchema = zod.z.object({
   // Identification
   name: zod.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Unique rule name (snake_case)"),
@@ -1368,8 +1602,35 @@ var ObjectSchemaBase = zod.z.object({
   /** Key Prefix */
   keyPrefix: zod.z.string().max(5).optional().describe('Short prefix for record IDs (e.g., "001" for Account)')
 });
+function snakeCaseToLabel(name) {
+  return name.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
 var ObjectSchema = Object.assign(ObjectSchemaBase, {
-  create: (config) => config
+  /**
+   * Type-safe factory for creating business object definitions.
+   * 
+   * Enhancements over raw schema:
+   * - **Auto-label**: Generates `label` from `name` if not provided (snake_case → Title Case).
+   * - **Validation**: Runs Zod `.parse()` to validate the config at creation time.
+   * 
+   * @example
+   * ```ts
+   * const Task = ObjectSchema.create({
+   *   name: 'project_task',
+   *   // label auto-generated as 'Project Task'
+   *   fields: {
+   *     subject: { type: 'text', label: 'Subject', required: true },
+   *   },
+   * });
+   * ```
+   */
+  create: (config) => {
+    const withDefaults = {
+      ...config,
+      label: config.label ?? snakeCaseToLabel(config.name)
+    };
+    return ObjectSchemaBase.parse(withDefaults);
+  }
 });
 var ObjectOwnershipEnum = zod.z.enum(["own", "extend"]);
 var ObjectExtensionSchema = zod.z.object({
@@ -4001,7 +4262,9 @@ __export(ui_exports, {
   WidgetManifestSchema: () => WidgetManifestSchema,
   WidgetPropertySchema: () => WidgetPropertySchema,
   WidgetSourceSchema: () => WidgetSourceSchema,
-  ZIndexSchema: () => ZIndexSchema
+  ZIndexSchema: () => ZIndexSchema,
+  defineApp: () => defineApp,
+  defineView: () => defineView
 });
 var I18nObjectSchema = zod.z.object({
   /** Translation key (e.g., "views.task_list.label", "apps.crm.description") */
@@ -4346,6 +4609,9 @@ var AppSchema = zod.z.object({
 var App = {
   create: (config) => AppSchema.parse(config)
 };
+function defineApp(config) {
+  return AppSchema.parse(config);
+}
 var HttpMethodSchema = zod.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]);
 var HttpRequestSchema = zod.z.object({
   url: zod.z.string().describe("API endpoint URL"),
@@ -4655,6 +4921,9 @@ var ViewSchema = zod.z.object({
   listViews: zod.z.record(zod.z.string(), ListViewSchema).optional().describe("Additional named list views"),
   formViews: zod.z.record(zod.z.string(), FormViewSchema).optional().describe("Additional named form views")
 });
+function defineView(config) {
+  return ViewSchema.parse(config);
+}
 var DashboardWidgetSchema = zod.z.object({
   /** Widget Title */
   title: I18nLabelSchema.optional().describe("Widget title"),
@@ -19522,6 +19791,7 @@ __export(ai_exports, {
   WorkflowAgentActionSchema: () => WorkflowAgentActionSchema,
   WorkflowFieldConditionSchema: () => WorkflowFieldConditionSchema,
   WorkflowScheduleSchema: () => WorkflowScheduleSchema,
+  defineAgent: () => defineAgent,
   fullStackDevOpsAgentExample: () => fullStackDevOpsAgentExample
 });
 var AIModelConfigSchema = zod.z.object({
@@ -19630,6 +19900,9 @@ var AgentSchema = zod.z.object({
   /** Structured Output */
   structuredOutput: StructuredOutputConfigSchema.optional().describe("Structured output format and validation configuration")
 });
+function defineAgent(config) {
+  return AgentSchema.parse(config);
+}
 var NavigationActionTypeSchema = zod.z.enum([
   "navigate_to_object_list",
   // Navigate to object list view
@@ -29610,7 +29883,8 @@ __export(automation_exports, {
   WebhookTriggerType: () => WebhookTriggerType,
   WorkflowActionSchema: () => WorkflowActionSchema,
   WorkflowRuleSchema: () => WorkflowRuleSchema,
-  WorkflowTriggerType: () => WorkflowTriggerType
+  WorkflowTriggerType: () => WorkflowTriggerType,
+  defineFlow: () => defineFlow
 });
 var FlowNodeAction = zod.z.enum([
   "start",
@@ -29704,6 +29978,9 @@ var FlowSchema = zod.z.object({
     fallbackNodeId: zod.z.string().optional().describe("Node ID to jump to on unrecoverable error")
   }).optional().describe("Flow-level error handling configuration")
 });
+function defineFlow(config) {
+  return FlowSchema.parse(config);
+}
 var WebhookTriggerType = zod.z.enum([
   "create",
   "update",
@@ -33626,7 +33903,93 @@ var ObjectStackDefinitionSchema = zod.z.object({
   devPlugins: zod.z.array(zod.z.union([ManifestSchema, zod.z.string()])).optional().describe("Plugins to load only in development (CLI dev command)")
 });
 var ObjectStackSchema = ObjectStackDefinitionSchema;
-var defineStack = (config) => config;
+function collectObjectNames(config) {
+  const names = /* @__PURE__ */ new Set();
+  if (config.objects) {
+    for (const obj of config.objects) {
+      names.add(obj.name);
+    }
+  }
+  return names;
+}
+function validateCrossReferences(config) {
+  const errors = [];
+  const objectNames = collectObjectNames(config);
+  if (objectNames.size === 0) return errors;
+  if (config.workflows) {
+    for (const workflow of config.workflows) {
+      if (workflow.objectName && !objectNames.has(workflow.objectName)) {
+        errors.push(
+          `Workflow '${workflow.name}' references object '${workflow.objectName}' which is not defined in objects.`
+        );
+      }
+    }
+  }
+  if (config.approvals) {
+    for (const approval of config.approvals) {
+      if (approval.object && !objectNames.has(approval.object)) {
+        errors.push(
+          `Approval '${approval.name}' references object '${approval.object}' which is not defined in objects.`
+        );
+      }
+    }
+  }
+  if (config.hooks) {
+    for (const hook of config.hooks) {
+      if (hook.object) {
+        const hookObjects = Array.isArray(hook.object) ? hook.object : [hook.object];
+        for (const obj of hookObjects) {
+          if (!objectNames.has(obj)) {
+            errors.push(
+              `Hook '${hook.name}' references object '${obj}' which is not defined in objects.`
+            );
+          }
+        }
+      }
+    }
+  }
+  if (config.views) {
+    for (const [i, view] of config.views.entries()) {
+      const checkViewData = (data, viewLabel) => {
+        if (data && typeof data === "object" && "provider" in data && "object" in data) {
+          const d = data;
+          if (d.provider === "object" && d.object && !objectNames.has(d.object)) {
+            errors.push(
+              `${viewLabel} references object '${d.object}' which is not defined in objects.`
+            );
+          }
+        }
+      };
+      if (view.list?.data) {
+        checkViewData(view.list.data, `View[${i}].list`);
+      }
+      if (view.form?.data) {
+        checkViewData(view.form.data, `View[${i}].form`);
+      }
+    }
+  }
+  return errors;
+}
+function defineStack(config, options) {
+  if (!options?.strict) {
+    return config;
+  }
+  const result = ObjectStackDefinitionSchema.safeParse(config, {
+    error: objectStackErrorMap
+  });
+  if (!result.success) {
+    throw new Error(formatZodError(result.error, "defineStack validation failed"));
+  }
+  const crossRefErrors = validateCrossReferences(result.data);
+  if (crossRefErrors.length > 0) {
+    const header = `defineStack cross-reference validation failed (${crossRefErrors.length} issue${crossRefErrors.length === 1 ? "" : "s"}):`;
+    const lines = crossRefErrors.map((e) => `  \u2717 ${e}`);
+    throw new Error(`${header}
+
+${lines.join("\n")}`);
+  }
+  return result.data;
+}
 var ObjectQLCapabilitiesSchema = zod.z.object({
   /** Query Capabilities */
   queryFilters: zod.z.boolean().default(true).describe("Supports WHERE clause filtering"),
@@ -33764,6 +34127,17 @@ exports.Shared = shared_exports;
 exports.Studio = studio_exports;
 exports.System = system_exports;
 exports.UI = ui_exports;
+exports.defineAgent = defineAgent;
+exports.defineApp = defineApp;
+exports.defineFlow = defineFlow;
 exports.defineStack = defineStack;
+exports.defineView = defineView;
+exports.findClosestMatches = findClosestMatches;
+exports.formatSuggestion = formatSuggestion;
+exports.formatZodError = formatZodError;
+exports.formatZodIssue = formatZodIssue;
+exports.objectStackErrorMap = objectStackErrorMap;
+exports.safeParsePretty = safeParsePretty;
+exports.suggestFieldType = suggestFieldType;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map