@vibeorm/generator 2.3.0 → 3.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VibeORM contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/emit-dts.d.ts

@@ -23,10 +23,21 @@ import type { SchemaView } from "./schema-view.ts";
 export declare function emitEnumsDts(params: {
     view: SchemaView;
 }): string;
+/** Refuse compiler-proven logical input names without invalidating SchemaIR. */
+export declare function assertGeneratedInputNames(params: {
+    view: SchemaView;
+    computed?: readonly ComputedManifestEntry[];
+}): void;
 /** Emit the full index.d.ts for a resolved schema view. */
 export declare function emitDts(params: {
     view: SchemaView;
     baked?: BakedExtensions;
     computed?: readonly ComputedManifestEntry[];
 }): string;
+/** @internal Admit before other emitters, then render in the existing output order. */
+export declare function prepareDts(params: {
+    view: SchemaView;
+    baked?: BakedExtensions;
+    computed?: readonly ComputedManifestEntry[];
+}): () => string;
 //# sourceMappingURL=emit-dts.d.ts.map

package/dist/generate.d.ts

@@ -17,6 +17,7 @@ export type GenerateResult = {
  * Generate the client module for a schema into `outDir` (created if missing).
  *
  * @throws VibeError `VIBE_SCHEMA_INVALID` when the IR fails validation.
+ * @throws VibeError `VIBE_UNSUPPORTED_CAPABILITY` for logical members that cannot be represented by generated inputs.
  */
 export declare function generateClient(params: {
     schema: SchemaIR;

package/dist/index.js

@@ -32,10 +32,13 @@ function maybeParens(params) {
   return type.includes("|") ? `(${type})` : type;
 }
 function stableStringify(params) {
-  return renderValue({ value: params.value, indent: "" });
+  return renderValue({ value: params.value, indent: "", javascript: false });
+}
+function stableJs(params) {
+  return renderValue({ value: params.value, indent: "", javascript: true });
 }
 function renderValue(params) {
-  const { value, indent } = params;
+  const { value, indent, javascript } = params;
   if (value === null)
     return "null";
   const kind = typeof value;
@@ -45,7 +48,7 @@ function renderValue(params) {
     if (value.length === 0)
       return "[]";
     const inner = `${indent}  `;
-    const items = value.map((item) => inner + renderValue({ value: item, indent: inner }));
+    const items = value.map((item) => inner + renderValue({ value: item, indent: inner, javascript }));
     return `[
 ${items.join(`,
 `)}
@@ -57,7 +60,7 @@ ${indent}]`;
     if (keys.length === 0)
       return "{}";
     const inner = `${indent}  `;
-    const items = keys.map((key) => `${inner}${JSON.stringify(key)}: ${renderValue({ value: record[key], indent: inner })}`);
+    const items = keys.map((key) => `${inner}${javascript && key === "__proto__" ? `[${JSON.stringify(key)}]` : JSON.stringify(key)}: ${renderValue({ value: record[key], indent: inner, javascript })}`);
     return `{
 ${items.join(`,
 `)}
@@ -119,7 +122,7 @@ export { sql, decode, sqlModels, sqlProjection } from "./index.js";
 export const databaseModule = defineDatabaseModule({ ...${JSON.stringify(module)}, schema, manifest: ${JSON.stringify(manifest)} });
 ` },
     { name: "schema.js", content: `// Generated data-only schema and runtime manifest.
-export const schema = ${serialized};
+export const schema = ${stableJs({ value: view.schema })};
 export const moduleManifest = ${JSON.stringify(manifest)};
 ` },
     { name: "schema.d.ts", content: `import type { SchemaIR, DatabaseModuleManifest } from "@vibeorm/schema";
@@ -371,7 +374,7 @@ ${validatorLines}
 function serializeSchema(params) {
   const { schema } = params;
   if (schema.rls === undefined)
-    return stableStringify({ value: schema });
+    return stableJs({ value: schema });
   return renderIr({ value: schema, indent: "", ordered: false });
 }
 function renderIr(params) {
@@ -400,7 +403,7 @@ ${indent}]`;
   if (keys.length === 0)
     return "{}";
   const inner = `${indent}  `;
-  const items = keys.map((key) => `${inner}${JSON.stringify(key)}: ${renderIr({ value: record[key], indent: inner, ordered: ordered || key === "rls" })}`);
+  const items = keys.map((key) => `${inner}${key === "__proto__" ? `[${JSON.stringify(key)}]` : JSON.stringify(key)}: ${renderIr({ value: record[key], indent: inner, ordered: ordered || key === "rls" })}`);
   return `{
 ${items.join(`,
 `)}
@@ -441,7 +444,7 @@ ${view.models.map((model) => `  [${tsString({ value: model.clientName })}]: (opt
   }
   if (!baked.empty) {
     parts.push(`/** Extension manifest \u2014 verified against the live extension list (VIBE_STALE_CLIENT). */
-` + `const extensionManifest = ${stableStringify({ value: baked.manifest })};`);
+` + `const extensionManifest = ${stableJs({ value: baked.manifest })};`);
     parts.push(`/** Baked extension surfaces (extensions.md D9). */
 ` + `const extensionMounts = [
 ${baked.mounts.map((mount) => `  ${mount},`).join(`
@@ -450,7 +453,7 @@ ${baked.mounts.map((mount) => `  ${mount},`).join(`
   }
   if (hasComputed) {
     parts.push(`/** Computed-field manifest \u2014 verified against the live computed config (VIBE_STALE_CLIENT). */
-` + `const computedManifest = ${stableStringify({ value: computed })};`);
+` + `const computedManifest = ${stableJs({ value: computed })};`);
   }
   const destructured = [
     "adapter",
@@ -536,6 +539,15 @@ function inputBaseType(params) {
     return "Date | string";
   return field.enumName ?? INPUT_TYPES[field.scalar];
 }
+function aggregateOperandType(params) {
+  const { field, key } = params;
+  if (key === "_count")
+    return "number";
+  if (key === "_avg")
+    return "number";
+  const value = field.scalar === "DateTime" ? "Date | string" : inputBaseType({ field });
+  return value;
+}
 function filterName(params) {
   const { field } = params;
   const prefix = field.enumName ?? FILTER_PREFIX[field.scalar];
@@ -591,6 +603,12 @@ function orMany(params) {
   const { type } = params;
   return `${type} | readonly ${maybeParens({ type })}[]`;
 }
+function aggregatePredicateType(params) {
+  const { value } = params;
+  const skip = params.skippable === false ? "" : " | Skip";
+  const operators = ["equals", "not", "gt", "gte", "lt", "lte"];
+  return `${value} | { ${operators.map((operator) => `readonly ${operator}?: ${value}${skip}`).join("; ")} }`;
+}
 function payloadFieldType(params) {
   const { field } = params;
   const base = payloadBaseType({ field });
@@ -647,11 +665,18 @@ export type KeysetPage<T> = { readonly items: T[]; readonly nextCursor: KeysetTo
 export type KeysetOptions = {
   /**
    * Asserts that every DateTime ordering column in this query holds
-   * millisecond-exact values. Required on postgres and mysql, whose timestamps
-   * may be finer than a JavaScript Date; NOT safe for \`@default(now())\`
-   * columns on postgres, which are microsecond-precise.
+   * millisecond-exact values. Needed on postgres and mysql only for a column
+   * that may be finer than a JavaScript Date \u2014 one without a declared
+   * precision of 0-3; a column declared \`@db.Timestamptz(3)\` needs none. NOT
+   * safe for a microsecond \`@default(now())\` column.
    */
   readonly timestampPrecision?: "milliseconds";
+  /**
+   * The owner a page token belongs to (a user or tenant id). Mixed into the
+   * token's query binding beside the filters, so a token minted for one scope
+   * is refused for another. Encoded, not secret.
+   */
+  readonly scope?: string;
 };
 
 /** Result of createMany/updateMany/deleteMany. */
@@ -679,6 +704,21 @@ export type UpsertManyPayload = { readonly count: number; readonly affectedRows:
  */
 type Provided<T> = Exclude<T, Skip | undefined>;
 
+/** An absent projection member supplies the inactive fallback value. */
+type SelectionMember<S, K> = K extends keyof S ? S[K] : undefined;
+
+/** Object-bag keys only; primitive SKIP contributes no Symbol members. */
+type BagKeys<S> = S extends object ? keyof S : never;
+
+/** Read only object bags, preserving unions and optional bag omission. */
+type SelectionValue<S, K> = S extends object ? SelectionMember<S, K> : undefined;
+
+/** Only an active included relation replaces the selected relation. */
+type IncludedRelation<S, I> = I extends false | undefined | Skip ? S : I;
+
+/** Count include overrides even with false; omitted/nullish values fall back. */
+type IncludedCount<S, I> = I extends null | undefined | Skip ? S : I;
+
 /** Keys of an omit object whose value is exactly true \u2014 the scalars the result drops. */
 type OmittedKeys<O> = keyof { [K in keyof O as O[K] extends true ? K : never]: 0 };
 
@@ -1139,7 +1179,7 @@ function registerNestedContext(params) {
           `  readonly connectOrCreate?: ${connectOrCreateName};`,
           `  readonly update?: ${updateUnion};`,
           `  readonly upsert?: { readonly create: ${createUnion}; readonly update: ${updateUnion} };`,
-          ...allowDetach ? [`  readonly disconnect?: boolean;`, `  readonly delete?: boolean;`] : []
+          ...allowDetach ? [`  readonly disconnect?: boolean | ${t}WhereInput;`, `  readonly delete?: boolean | ${t}WhereInput;`] : []
         ]
       })
     });
@@ -1161,7 +1201,7 @@ ${[
   ].join(`
 `)}
 };`);
-  parts.push(`export type ${n}ScalarFieldEnum = ${model.fields.map((field) => tsString({ value: field.name })).join(" | ")};`);
+  parts.push(`export type ${n}ScalarFieldEnum = ${literalUnion({ members: model.fields.map((field) => field.name) }) || "never"};`);
   if (computedEntries.length > 0) {
     parts.push(`export type ${n}SelectableFieldEnum = ${n}ScalarFieldEnum | ${computedEntries.map((entry) => tsString({ value: entry.field })).join(" | ")};`);
   }
@@ -1286,7 +1326,7 @@ ${model.relations.map((relation) => `  ${propKey({ name: relation.name })}: ${re
   parts.push(inputAlias({ name: `${n}UncheckedUpdateInput`, lines: uncheckedUpdateLines({ model }) }));
   parts.push(inputAlias({ name: `${n}UpdateManyInput`, lines: uncheckedUpdateLines({ model, scalarOnly: true }) }));
   const numericFields = model.fields.filter((field) => !field.isList && field.scalar !== null && NUMERIC_SCALARS.has(field.scalar));
-  const minmaxFields = model.fields.filter((field) => !field.isList && field.scalar !== null && MINMAX_SCALARS.has(field.scalar));
+  const minmaxFields = model.fields.filter((field) => !field.isList && (field.enumName !== null || field.scalar !== null && MINMAX_SCALARS.has(field.scalar)));
   parts.push(inputAlias({
     name: `${n}CountAggregateInput`,
     lines: [
@@ -1313,6 +1353,44 @@ ${model.relations.map((relation) => `  ${propKey({ name: relation.name })}: ${re
     aggregateOpProps.push(`  readonly _min?: ${n}MinAggregateInput;`);
     aggregateOpProps.push(`  readonly _max?: ${n}MaxAggregateInput;`);
   }
+  const groupAggregates = [
+    { key: "_count", prefix: "Count", fields: model.fields },
+    ...numericFields.length > 0 ? [
+      { key: "_avg", prefix: "Avg", fields: numericFields },
+      { key: "_sum", prefix: "Sum", fields: numericFields }
+    ] : [],
+    ...minmaxFields.length > 0 ? [
+      { key: "_min", prefix: "Min", fields: minmaxFields },
+      { key: "_max", prefix: "Max", fields: minmaxFields }
+    ] : []
+  ];
+  const groupAggregateFields = new Map(groupAggregates.map((aggregate) => [aggregate, new Set(aggregate.fields)]));
+  const havingLines = [
+    `  readonly AND?: ${orMany({ type: `${n}HavingInput` })};`,
+    `  readonly OR?: ${orMany({ type: `${n}HavingInput` })};`,
+    `  readonly NOT?: ${orMany({ type: `${n}HavingInput` })};`
+  ];
+  const groupOrderLines = [...scalarOrderLines];
+  for (const aggregate of groupAggregates) {
+    const havingFields = aggregate.fields.map((field) => `  readonly ${propKey({ name: field.name })}?: ${aggregatePredicateType({ value: aggregateOperandType({ field, key: aggregate.key }) })};`);
+    const orderFields = aggregate.fields.map((field) => `  readonly ${propKey({ name: field.name })}?: SortOrder;`);
+    if (aggregate.key === "_count") {
+      havingFields.push(`  readonly _all?: ${aggregatePredicateType({ value: "number" })};`);
+      orderFields.push(`  readonly _all?: SortOrder;`);
+    }
+    parts.push(inputAlias({ name: `${n}${aggregate.prefix}AggregateHavingInput`, lines: havingFields }));
+    parts.push(inputAlias({ name: `${n}${aggregate.prefix}AggregateOrderByInput`, lines: orderFields }));
+    havingLines.push(`  readonly ${aggregate.key}?: ${n}${aggregate.prefix}AggregateHavingInput;`);
+    groupOrderLines.push(`  readonly ${aggregate.key}?: ${n}${aggregate.prefix}AggregateOrderByInput;`);
+  }
+  for (const field of model.fields) {
+    const aggregates = groupAggregates.filter((aggregate) => groupAggregateFields.get(aggregate).has(field)).map((aggregate) => `readonly ${aggregate.key}?: ${aggregatePredicateType({ value: aggregateOperandType({ field, key: aggregate.key }), skippable: field.scalar !== "Json" })} | Skip`);
+    const filter = `(${filterName({ field })} & { ${aggregates.join("; ")} })`;
+    const value = field.isList || field.scalar === "Json" ? filter : `${inputBaseType({ field })} | ${filter}${field.isOptional ? " | null" : ""}`;
+    havingLines.push(`  readonly ${propKey({ name: field.name })}?: ${value};`);
+  }
+  parts.push(inputAlias({ name: `${n}HavingInput`, lines: havingLines }));
+  parts.push(inputAlias({ name: `${n}GroupByOrderByInput`, lines: groupOrderLines }));
   for (const nested of [false, true]) {
     parts.push(inputAlias({
       name: `${n}${nested ? "RelationFindManyArgs" : "FindManyArgs"}`,
@@ -1438,13 +1516,19 @@ export type ${n}UpdateWhereInput = ${n}WhereUniqueInput & ${n}WhereInput;`);
       `  readonly skipUpdatedAt?: boolean;`
     ]
   }));
+  const returningSelect = [
+    ...model.fields.map((field) => `readonly ${propKey({ name: field.name })}?: boolean | Skip`),
+    ...computedEntries.map((entry) => `readonly ${propKey({ name: entry.field })}?: boolean | Skip`),
+    ...model.relations.map((relation) => `readonly ${propKey({ name: relation.name })}?: false | Skip`),
+    ...hasCounts ? ["readonly _count?: false | Skip"] : []
+  ].join("; ");
   parts.push(inputAlias({
     name: `${n}UpdateManyAndReturnArgs`,
     lines: [
       `  readonly include?: never;`,
       `  readonly where?: ${n}WhereInput;`,
       `  readonly data: ${n}UpdateManyInput;`,
-      `  readonly select?: ${n}Select;`,
+      `  readonly select?: { ${returningSelect} };`,
       `  readonly omit?: ${n}OmitInput;`,
       `  readonly skipUpdatedAt?: boolean;`
     ]
@@ -1496,8 +1580,8 @@ export type ${n}UpdateWhereInput = ${n}WhereUniqueInput & ${n}WhereInput;`);
     lines: [
       `  readonly by: readonly ${n}ScalarFieldEnum[];`,
       `  readonly where?: ${n}WhereInput;`,
-      `  readonly orderBy?: ${orMany({ type: `${n}ScalarOrderByInput` })};`,
-      `  readonly having?: ${n}WhereInput;`,
+      `  readonly orderBy?: ${orMany({ type: `${n}GroupByOrderByInput` })};`,
+      `  readonly having?: ${n}HavingInput;`,
       `  readonly take?: number;`,
       `  readonly skip?: number;`,
       ...aggregateOpProps
@@ -1516,9 +1600,9 @@ export type ${n}UpdateWhereInput = ${n}WhereUniqueInput & ${n}WhereInput;`);
 ` + `    { [K in keyof CS & (${listUnion}) as ${uncertainPart("CS")}]?: number }
 ` + `  : C extends { readonly select: Skip } ? { ${allCounts} }
 ` + `  : "select" extends keyof C ? Partial<{ ${allCounts} }> : { ${allCounts} };`);
-    parts.push(`type ${n}CountPayload<S> = S extends { readonly _count: infer C extends true | object } ? { _count: ${n}CountResult<C> }
-` + `  : S extends { readonly _count: false | undefined | Skip } ? unknown
-` + `  : S extends { readonly _count?: infer C extends boolean | object | Skip } ? { _count?: ${n}CountResult<Provided<C>> } : unknown;`);
+    parts.push(`type ${n}CountPayload<C> = [C] extends [true | object] ? { _count: ${n}CountResult<C> }
+` + `  : [C] extends [false | undefined | Skip] ? unknown
+` + `  : { _count?: ${n}CountResult<Exclude<C, false | undefined | Skip>> };`);
   }
   if (hasRelations) {
     const relationCases = model.relations.map((relation) => {
@@ -1538,20 +1622,23 @@ export type ${n}UpdateWhereInput = ${n}WhereUniqueInput & ${n}WhereInput;`);
     parts.push(`type ${n}RelationPayload<K extends keyof ${n}Relations, A> = {
 ${relationCases}
 }[K];`);
-    parts.push(`type ${n}IncludePayload<A> = A extends { readonly include: infer I extends object }
-` + `  ? { [K in keyof I & keyof ${n}Relations as ${exactPart("I")}]: ${n}RelationPayload<K, I[K]> } &
-` + `    { [K in keyof I & keyof ${n}Relations as ${uncertainPart("I")}]?: ${n}RelationPayload<K, I[K]> }${hasCounts ? ` &
-    ${n}CountPayload<I>` : ""}
-` + `  : "include" extends keyof A ? Partial<${n}IncludePayload<{ include: Provided<A["include"]> }>> : unknown;`);
+    parts.push(`type ${n}ResolvedSelection<A, S = SelectionValue<A, "select">, I = SelectionValue<A, "include">> = {
+` + `  [K in (BagKeys<S> | BagKeys<I>) & (${hasCounts ? `keyof ${n}Relations | "_count"` : `keyof ${n}Relations`})]: ${hasCounts ? `K extends "_count" ? IncludedCount<SelectionValue<S, K>, SelectionValue<I, K>> : ` : ""}IncludedRelation<SelectionValue<S, K>, SelectionValue<I, K>>;
+` + `};`);
+    parts.push(`type ${n}IncludePayload<A, I = "include" extends keyof A ? "select" extends keyof A ? ${n}ResolvedSelection<A> : SelectionValue<A, "include"> : SelectionValue<A, "select">> =
+` + `  [Exclude<SelectionValue<I, BagKeys<I> & (${hasCounts ? `keyof ${n}Relations | "_count"` : `keyof ${n}Relations`})>, false | undefined | Skip>] extends [never] ? unknown :
+` + `  { [K in BagKeys<I> & keyof ${n}Relations as ${exactPart("I").replaceAll("I[K]", "SelectionValue<I, K>")}]: ${n}RelationPayload<K, Exclude<SelectionValue<I, K>, false | undefined | Skip>> } &
+` + `  { [K in BagKeys<I> & keyof ${n}Relations as ${uncertainPart("I").replaceAll("I[K]", "SelectionValue<I, K>")}]?: ${n}RelationPayload<K, Exclude<SelectionValue<I, K>, false | undefined | Skip>> }${hasCounts ? ` &
+  ${n}CountPayload<SelectionValue<I, "_count">>` : ""};`);
     parts.push(`export type ${n}GetPayload<A> = A extends { readonly select: infer S extends object }
 ` + `  ? { [K in keyof S & ${selectableEnum} as ${exactPart("S")}]: ${n}[K & keyof ${n}] } &
 ` + `    { [K in keyof S & ${selectableEnum} as ${uncertainPart("S")}]?: ${n}[K & keyof ${n}] } &
-` + `    { [K in keyof S & keyof ${n}Relations as ${exactPart("S")}]: ${n}RelationPayload<K, S[K]> } &
-` + `    { [K in keyof S & keyof ${n}Relations as ${uncertainPart("S")}]?: ${n}RelationPayload<K, S[K]> }${hasCounts ? ` &
-    ${n}CountPayload<S>` : ""}
+` + `    ("include" extends keyof A ? ${n}IncludePayload<A> :
+` + `      [Exclude<SelectionValue<S, BagKeys<S> & (${hasCounts ? `keyof ${n}Relations | "_count"` : `keyof ${n}Relations`})>, false | undefined | Skip>] extends [never] ? unknown : ${n}IncludePayload<A>)
 ` + `  : A extends { readonly select: Skip } ? ${n}OmitBase<A> & ${n}IncludePayload<A>
-` + `  : "select" extends keyof A ? Partial<${n}>
-` + `  : ${n}OmitBase<A> & ${n}IncludePayload<A>;`);
+` + `  : "select" extends keyof A ? Partial<${n}> & ${n}IncludePayload<A>
+` + `  : "include" extends keyof A ? ${n}OmitBase<A> & ${n}IncludePayload<A>
+` + `  : ${n}OmitBase<A>;`);
   } else {
     parts.push(`export type ${n}GetPayload<A> = A extends { readonly select: infer S extends object }
 ` + `  ? { [K in keyof S & ${selectableEnum} as ${exactPart("S")}]: ${n}[K & keyof ${n}] } &
@@ -1560,7 +1647,7 @@ ${relationCases}
 ` + `  : "select" extends keyof A ? Partial<${n}> : ${n}OmitBase<A>;`);
   }
   const aggregateFields = (fields, value) => `{ ${fields.map((field) => `${propKey({ name: field.name })}: ${value(field)}`).join("; ")} }`;
-  const countValues = aggregateFields(model.fields, () => "number").replace(" }", "; _all: number }");
+  const countValues = `{ ${[...model.fields.map((field) => `${propKey({ name: field.name })}: number`), "_all: number"].join("; ")} }`;
   parts.push(`type ${n}AggregateValues = {
 ` + `  _count: ${countValues};
 ` + `  _avg: ${aggregateFields(numericFields, () => "number | null")};
@@ -1692,7 +1779,7 @@ function emitViewTypesForModel(params) {
       const target = relation.target;
       const targetClientKey = view.modelByName.get(target)?.clientName ?? target;
       const guard = `D extends { readonly ${propKey({ name: targetClientKey })}: infer RF extends object }`;
-      const masked = `ViewRow<${target}ViewSelectScalars<RF, A> & ${target}ViewReveal<A>>`;
+      const masked = `${target}ViewResult<RF, Exclude<A, false | undefined | Skip>, D>`;
       const unmasked = `(A extends object ? ${target}GetPayload<A> : ${target})`;
       let expression;
       if (relation.isList) {
@@ -2247,17 +2334,59 @@ ${scopeLines}} : {}) & `;
 ` + `};`
   ];
 }
-function emitDts(params) {
+var UNSUPPORTED_INPUT_MEMBER_NAMES = new Set([
+  "toString",
+  "valueOf",
+  "constructor",
+  "toLocaleString",
+  "hasOwnProperty",
+  "isPrototypeOf",
+  "propertyIsEnumerable"
+]);
+function groupComputed(params) {
+  const byModel = new Map;
+  for (const entry of params.computed) {
+    const model = entry.model;
+    const list = byModel.get(model);
+    if (list === undefined)
+      byModel.set(model, [entry]);
+    else
+      list.push(entry);
+  }
+  return byModel;
+}
+function assertGeneratedInputNames(params) {
+  const check = (member) => {
+    if (!UNSUPPORTED_INPUT_MEMBER_NAMES.has(member.name))
+      return;
+    const hint = member.kind === "field" ? "Rename the logical field and preserve its database column with @map or DSL .map()." : member.kind === "relation" ? "Rename the logical relation while keeping its FK fields, references, relation pairing name and constraint mapping. Relation fields do not have a column @map." : "Rename the computed alias in the computed configuration; it has no database column to map.";
+    throw new VibeError4({
+      code: "VIBE_UNSUPPORTED_CAPABILITY",
+      message: `Generated TypeScript inputs cannot represent logical ${member.kind} "${member.model}.${member.name}" safely because it conflicts with an inherited Object member. ${hint} SchemaIR and the dynamic client still accept this name.`,
+      meta: { reason: "generated_input_member", model: member.model, member: member.name, kind: member.kind }
+    });
+  };
+  const computedByModel = groupComputed({ computed: params.computed ?? [] });
+  for (const model of params.view.models) {
+    for (const field of model.fields)
+      check({ model: model.name, name: field.name, kind: "field" });
+    for (const relation of model.relations)
+      check({ model: model.name, name: relation.name, kind: "relation" });
+    for (const entry of computedByModel.get(model.name) ?? []) {
+      check({ model: model.name, name: entry.field, kind: "computed" });
+    }
+  }
+}
+function prepareDts(params) {
+  assertGeneratedInputNames({ view: params.view, computed: params.computed ?? [] });
+  return () => emitPreparedDts(params);
+}
+function emitPreparedDts(params) {
   const { view } = params;
   const baked = params.baked ?? EMPTY_BAKED_EXTENSIONS;
   const computed = params.computed ?? [];
   const hasComputed = computed.length > 0;
-  const computedByModel = new Map;
-  for (const entry of computed) {
-    const list = computedByModel.get(entry.model) ?? [];
-    list.push(entry);
-    computedByModel.set(entry.model, list);
-  }
+  const computedByModel = groupComputed({ computed });
   const parts = [];
   parts.push(GENERATED_HEADER);
   const schemaTypeImports = [
@@ -2501,11 +2630,12 @@ async function generateClient(params) {
     validateComputedConfig({ schema, computed: params.computed });
     computed = buildComputedManifest({ computed: params.computed });
   }
+  const declarations = prepareDts({ view, baked, computed });
   if (params.module !== undefined && (!baked.empty || computed.length > 0))
     throw new VibeError6({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Package modules do not support computed fields or extension mounts in this protocol", meta: { reason: "module_schema_feature", moduleId: params.module.id } });
   const outputs = [
     { name: "index.js", content: emitJs({ view, baked, computed }) },
-    { name: "index.d.ts", content: emitDts({ view, baked, computed }) },
+    { name: "index.d.ts", content: declarations() },
     { name: "enums.js", content: emitEnumsJs({ view }) },
     { name: "enums.d.ts", content: emitEnumsDts({ view }) },
     { name: "README.md", content: README },
@@ -2526,4 +2656,4 @@ export {
   prepareDatabaseModuleSchema
 };
 
-//# debugId=BD8C77FCC6EC9CEF64756E2164756E21
+//# debugId=0EF8A4E0C9CC959A64756E2164756E21