pipework 0.252.0 → 0.252.1

package/src/data/query/subquery.ts

@@ -0,0 +1,53 @@
+import { entityKind } from './entity.js';
+import type { SQL, SQLWrapper } from './sql/sql.js';
+
+export interface Subquery<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TAlias extends string = string,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TSelectedFields extends Record<string, unknown> = Record<string, unknown>,
+> extends SQLWrapper {
+	// SQLWrapper runtime implementation is defined in 'sql/sql.ts'
+}
+export class Subquery<
+	TAlias extends string = string,
+	TSelectedFields extends Record<string, unknown> = Record<string, unknown>,
+> implements SQLWrapper {
+	static readonly [entityKind]: string = 'Subquery';
+
+	declare _: {
+		brand: 'Subquery';
+		sql: SQL;
+		selectedFields: TSelectedFields;
+		alias: TAlias;
+		isWith: boolean;
+		usedTables?: string[];
+		/** CTE fence: `true` renders `as materialized`, `false` renders `as not materialized`, unset renders plain `as`. */
+		materialized?: boolean;
+	};
+
+	constructor(sql: SQL, fields: TSelectedFields, alias: string, isWith = false, usedTables: string[] = [], materialized?: boolean) {
+		this._ = {
+			brand: 'Subquery',
+			sql,
+			selectedFields: fields as TSelectedFields,
+			alias: alias as TAlias,
+			isWith,
+			usedTables,
+			...(materialized === undefined ? {} : { materialized }),
+		};
+	}
+
+	// getSQL(): SQL<unknown> {
+	// 	return new SQL([this]);
+	// }
+}
+
+export class WithSubquery<
+	TAlias extends string = string,
+	TSelection extends Record<string, unknown> = Record<string, unknown>,
+> extends Subquery<TAlias, TSelection> {
+	static override readonly [entityKind]: string = 'WithSubquery';
+}
+
+export type WithSubqueryWithoutSelection<TAlias extends string> = WithSubquery<TAlias, {}>;

package/src/data/query/table.ts

@@ -0,0 +1,208 @@
+import type { Column, GetColumnData } from './column.js';
+import { entityKind } from './entity.js';
+import type { OptionalKeyOnly, RequiredKeyOnly } from './operations.js';
+import type { SQLWrapper } from './sql/sql.js';
+import { TableName } from './table.utils.js';
+import type { Simplify, Update } from './utils.js';
+
+export interface TableConfig<TColumn extends Column = Column<any>> {
+	name: string;
+	schema: string | undefined;
+	columns: Record<string, TColumn>;
+	dialect: string;
+}
+
+export type UpdateTableConfig<T extends TableConfig, TUpdate extends Partial<TableConfig>> = Required<
+	Update<T, TUpdate>
+>;
+
+/** @internal */
+export const Schema = Symbol.for('drizzle:Schema');
+
+/** @internal */
+export const Columns = Symbol.for('drizzle:Columns');
+
+/** @internal */
+export const ExtraConfigColumns = Symbol.for('drizzle:ExtraConfigColumns');
+
+/** @internal */
+export const OriginalName = Symbol.for('drizzle:OriginalName');
+
+/** @internal */
+export const BaseName = Symbol.for('drizzle:BaseName');
+
+/** @internal */
+export const IsAlias = Symbol.for('drizzle:IsAlias');
+
+/** @internal */
+export const ExtraConfigBuilder = Symbol.for('drizzle:ExtraConfigBuilder');
+
+const IsDrizzleTable = Symbol.for('drizzle:IsDrizzleTable');
+
+export interface Table<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	T extends TableConfig = TableConfig,
+> extends SQLWrapper {
+	// SQLWrapper runtime implementation is defined in 'sql/sql.ts'
+}
+
+export class Table<T extends TableConfig = TableConfig> implements SQLWrapper {
+	static readonly [entityKind]: string = 'Table';
+
+	declare readonly _: {
+		readonly brand: 'Table';
+		readonly config: T;
+		readonly name: T['name'];
+		readonly schema: T['schema'];
+		readonly columns: T['columns'];
+		readonly inferSelect: InferSelectModel<Table<T>>;
+		readonly inferInsert: InferInsertModel<Table<T>>;
+	};
+
+	declare readonly $inferSelect: InferSelectModel<Table<T>>;
+	declare readonly $inferInsert: InferInsertModel<Table<T>>;
+
+	/** @internal */
+	static readonly Symbol = {
+		Name: TableName as typeof TableName,
+		Schema: Schema as typeof Schema,
+		OriginalName: OriginalName as typeof OriginalName,
+		Columns: Columns as typeof Columns,
+		ExtraConfigColumns: ExtraConfigColumns as typeof ExtraConfigColumns,
+		BaseName: BaseName as typeof BaseName,
+		IsAlias: IsAlias as typeof IsAlias,
+		ExtraConfigBuilder: ExtraConfigBuilder as typeof ExtraConfigBuilder,
+	};
+
+	/**
+	 * @internal
+	 * Can be changed if the table is aliased.
+	 */
+	[TableName]: string;
+
+	/**
+	 * @internal
+	 * Used to store the original name of the table, before any aliasing.
+	 */
+	[OriginalName]: string;
+
+	/** @internal */
+	[Schema]: string | undefined;
+
+	/** @internal */
+	[Columns]!: T['columns'];
+
+	/** @internal */
+	[ExtraConfigColumns]!: Record<string, unknown>;
+
+	/**
+	 *  @internal
+	 * Used to store the table name before the transformation via the `tableCreator` functions.
+	 */
+	[BaseName]: string;
+
+	/** @internal */
+	[IsAlias] = false;
+
+	/** @internal */
+	[IsDrizzleTable] = true;
+
+	/** @internal */
+	[ExtraConfigBuilder]: ((self: any) => Record<string, unknown> | unknown[]) | undefined = undefined;
+
+	constructor(name: string, schema: string | undefined, baseName: string) {
+		this[TableName] = this[OriginalName] = name;
+		this[Schema] = schema;
+		this[BaseName] = baseName;
+	}
+}
+
+export function isTable(table: unknown): table is Table {
+	return typeof table === 'object' && table !== null && IsDrizzleTable in table;
+}
+
+/**
+ * Any table with a specified boundary.
+ *
+ * @example
+	```ts
+	// Any table with a specific name
+	type AnyUsersTable = AnyTable<{ name: 'users' }>;
+	```
+ *
+ * To describe any table with any config, simply use `Table` without any type arguments, like this:
+ *
+	```ts
+	function needsTable(table: Table) {
+		...
+	}
+	```
+ */
+export type AnyTable<TPartial extends Partial<TableConfig>> = Table<UpdateTableConfig<TableConfig, TPartial>>;
+
+export function getTableName<T extends Table>(table: T): T['_']['name'] {
+	return table[TableName];
+}
+
+export function getTableUniqueName<T extends Table>(table: T): `${T['_']['schema']}.${T['_']['name']}` {
+	return `${table[Schema] ?? 'public'}.${table[TableName]}`;
+}
+
+export type MapColumnName<TName extends string, TColumn extends Column, TDBColumNames extends boolean> =
+	TDBColumNames extends true ? TColumn['_']['name']
+		: TName;
+
+export type InferModelFromColumns<
+	TColumns extends Record<string, Column>,
+	TInferMode extends 'select' | 'insert' = 'select',
+	TConfig extends { dbColumnNames: boolean; override?: boolean } = { dbColumnNames: false; override: false },
+> = Simplify<
+	TInferMode extends 'insert' ?
+			& {
+				[
+					Key in keyof TColumns & string as RequiredKeyOnly<
+						MapColumnName<Key, TColumns[Key], TConfig['dbColumnNames']>,
+						TColumns[Key]
+					>
+				]: GetColumnData<TColumns[Key], 'query'>;
+			}
+			& {
+				[
+					Key in keyof TColumns & string as OptionalKeyOnly<
+						MapColumnName<Key, TColumns[Key], TConfig['dbColumnNames']>,
+						TColumns[Key],
+						TConfig['override']
+					>
+				]?: GetColumnData<TColumns[Key], 'query'> | undefined;
+			}
+		: {
+			[
+				Key in keyof TColumns & string as MapColumnName<
+					Key,
+					TColumns[Key],
+					TConfig['dbColumnNames']
+				>
+			]: GetColumnData<TColumns[Key], 'query'>;
+		}
+>;
+
+/** @deprecated Use one of the alternatives: {@link InferSelectModel} / {@link InferInsertModel}, or `table.$inferSelect` / `table.$inferInsert`
+ */
+export type InferModel<
+	TTable extends Table,
+	TInferMode extends 'select' | 'insert' = 'select',
+	TConfig extends { dbColumnNames: boolean } = { dbColumnNames: false },
+> = InferModelFromColumns<TTable['_']['columns'], TInferMode, TConfig>;
+
+export type InferSelectModel<
+	TTable extends Table,
+	TConfig extends { dbColumnNames: boolean } = { dbColumnNames: false },
+> = InferModelFromColumns<TTable['_']['columns'], 'select', TConfig>;
+
+export type InferInsertModel<
+	TTable extends Table,
+	TConfig extends { dbColumnNames: boolean; override?: boolean } = { dbColumnNames: false; override: false },
+> = InferModelFromColumns<TTable['_']['columns'], 'insert', TConfig>;
+
+export type InferEnum<T> = T extends { enumValues: readonly (infer U)[] } ? U
+	: never;

package/src/data/query/table.utils.ts

@@ -0,0 +1,2 @@
+/** @internal */
+export const TableName = Symbol.for('drizzle:Name');

package/src/data/query/tracing-utils.ts

@@ -0,0 +1,3 @@
+export function iife<T extends unknown[], U>(fn: (...args: T) => U, ...args: T): U {
+	return fn(...args);
+}

package/src/data/query/tracing.ts

@@ -0,0 +1,11 @@
+/** @internal */
+interface Span {
+	setAttributes(attributes: Record<string, string>): void;
+}
+
+/** @internal */
+export const tracer = {
+	startActiveSpan<F extends (span?: Span) => unknown>(_name: string, fn: F): ReturnType<F> {
+		return fn() as ReturnType<F>;
+	},
+};

package/src/data/query/utils.ts

@@ -0,0 +1,357 @@
+import type { Cache } from './cache/core/cache.js';
+import type { AnyColumn } from './column.js';
+import { Column } from './column.js';
+import { is } from './entity.js';
+import type { Logger } from './logger.js';
+import type { SelectedFieldsOrdered } from './operations.js';
+import type { TableLike } from './query-builders/select.types.js';
+import { Param, SQL, View } from './sql/sql.js';
+import type { DriverValueDecoder } from './sql/sql.js';
+import { Subquery } from './subquery.js';
+import { getTableName, Table } from './table.js';
+import { ViewBaseConfig } from './view-common.js';
+
+/** @internal */
+export function mapResultRow<TResult>(
+	columns: SelectedFieldsOrdered<AnyColumn>,
+	row: unknown[],
+	joinsNotNullableMap: Record<string, boolean> | undefined,
+): TResult {
+	// Key -> nested object key, value -> table name if all fields in the nested object are from the same table, false otherwise
+	const nullifyMap: Record<string, string | false> = {};
+
+	const result = columns.reduce<Record<string, any>>(
+		(result, { path, field }, columnIndex) => {
+			let decoder: DriverValueDecoder<unknown, unknown>;
+			if (is(field, Column)) {
+				decoder = field;
+			} else if (is(field, SQL)) {
+				decoder = field.decoder;
+			} else if (is(field, Subquery)) {
+				decoder = field._.sql.decoder;
+			} else {
+				decoder = field.sql.decoder;
+			}
+			let node = result;
+			for (const [pathChunkIndex, pathChunk] of path.entries()) {
+				if (pathChunkIndex < path.length - 1) {
+					if (!(pathChunk in node)) {
+						node[pathChunk] = {};
+					}
+					node = node[pathChunk];
+				} else {
+					const rawValue = row[columnIndex]!;
+					const value = node[pathChunk] = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
+
+					if (joinsNotNullableMap && is(field, Column) && path.length === 2) {
+						const objectName = path[0]!;
+						if (!(objectName in nullifyMap)) {
+							nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
+						} else if (
+							typeof nullifyMap[objectName] === 'string' && nullifyMap[objectName] !== getTableName(field.table)
+						) {
+							nullifyMap[objectName] = false;
+						}
+					}
+				}
+			}
+			return result;
+		},
+		{},
+	);
+
+	// Nullify all nested objects from nullifyMap that are nullable
+	if (joinsNotNullableMap && Object.keys(nullifyMap).length > 0) {
+		for (const [objectName, tableName] of Object.entries(nullifyMap)) {
+			if (typeof tableName === 'string' && !joinsNotNullableMap[tableName]) {
+				result[objectName] = null;
+			}
+		}
+	}
+
+	return result as TResult;
+}
+
+/** @internal */
+export function orderSelectedFields<TColumn extends AnyColumn>(
+	fields: Record<string, unknown>,
+	pathPrefix?: string[],
+): SelectedFieldsOrdered<TColumn> {
+	return Object.entries(fields).reduce<SelectedFieldsOrdered<AnyColumn>>((result, [name, field]) => {
+		if (typeof name !== 'string') {
+			return result;
+		}
+
+		const newPath = pathPrefix ? [...pathPrefix, name] : [name];
+		if (is(field, Column) || is(field, SQL) || is(field, SQL.Aliased) || is(field, Subquery)) {
+			result.push({ path: newPath, field });
+		} else if (is(field, Table)) {
+			result.push(...orderSelectedFields(field[Table.Symbol.Columns], newPath));
+		} else {
+			result.push(...orderSelectedFields(field as Record<string, unknown>, newPath));
+		}
+		return result;
+	}, []) as SelectedFieldsOrdered<TColumn>;
+}
+
+export function haveSameKeys(left: Record<string, unknown>, right: Record<string, unknown>) {
+	const leftKeys = Object.keys(left);
+	const rightKeys = Object.keys(right);
+
+	if (leftKeys.length !== rightKeys.length) {
+		return false;
+	}
+
+	for (const [index, key] of leftKeys.entries()) {
+		if (key !== rightKeys[index]) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+/** @internal */
+export function mapUpdateSet(table: Table, values: Record<string, unknown>): UpdateSet {
+	const columns = table[Table.Symbol.Columns];
+
+	const entries: [string, UpdateSet[string]][] = Object.entries(values)
+		.filter(([, value]) => value !== undefined)
+		.map(([key, value]) => {
+			// A key with no column of that name would be dropped by buildUpdateSet, which
+			// walks the table's columns rather than this object: the write would vanish and
+			// the statement would still report rows updated. Refuse it here instead.
+			if (!(key in columns)) {
+				throw new Error(
+					`Cannot set "${key}" on "${getTableName(table)}": the table has no such column. `
+						+ `It has: ${Object.keys(columns).join(', ')}. `
+						+ `A column added by a migration must be added to the table definition before it can be written.`,
+				);
+			}
+
+			// eslint-disable-next-line unicorn/prefer-ternary
+			if (is(value, SQL) || is(value, Column)) {
+				return [key, value];
+			} else {
+				return [key, new Param(value, columns[key])];
+			}
+		});
+
+	if (entries.length === 0) {
+		throw new Error('No values to set');
+	}
+
+	return Object.fromEntries(entries);
+}
+
+export type UpdateSet = Record<string, SQL | Param | AnyColumn | null | undefined>;
+
+export type OneOrMany<T> = T | T[];
+
+export type Update<T, TUpdate> =
+	& {
+		[K in Exclude<keyof T, keyof TUpdate>]: T[K];
+	}
+	& TUpdate;
+
+export type Simplify<T> =
+	& {
+		// @ts-ignore - "Type parameter 'K' has a circular constraint", not sure why
+		[K in keyof T]: T[K];
+	}
+	& {};
+
+export type Not<T extends boolean> = T extends true ? false : true;
+
+export type IsNever<T> = [T] extends [never] ? true : false;
+
+export type IsUnion<T, U extends T = T> = (T extends any ? (U extends T ? false : true) : never) extends false ? false
+	: true;
+
+export type SingleKeyObject<T, TError extends string, K = keyof T> = IsNever<K> extends true ? never
+	: IsUnion<K> extends true ? DrizzleTypeError<TError>
+	: T;
+
+export type FromSingleKeyObject<T, Result, TError extends string, K = keyof T> = IsNever<K> extends true ? never
+	: IsUnion<K> extends true ? DrizzleTypeError<TError>
+	: Result;
+
+export type SimplifyMappedType<T> = [T] extends [unknown] ? T : never;
+
+export type ShallowRecord<K extends keyof any, T> = SimplifyMappedType<{ [P in K]: T }>;
+
+export type Assume<T, U> = T extends U ? T : U;
+
+export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
+
+export interface DrizzleTypeError<T extends string> {
+	$drizzleTypeError: T;
+}
+
+export type ValueOrArray<T> = T | T[];
+
+/** @internal */
+export function applyMixins(baseClass: any, extendedClasses: any[]) {
+	for (const extendedClass of extendedClasses) {
+		for (const name of Object.getOwnPropertyNames(extendedClass.prototype)) {
+			if (name === 'constructor') continue;
+
+			Object.defineProperty(
+				baseClass.prototype,
+				name,
+				Object.getOwnPropertyDescriptor(extendedClass.prototype, name) || Object.create(null),
+			);
+		}
+	}
+}
+
+export type Or<T1, T2> = T1 extends true ? true : T2 extends true ? true : false;
+
+export type IfThenElse<If, Then, Else> = If extends true ? Then : Else;
+
+export type PromiseOf<T> = T extends Promise<infer U> ? U : T;
+
+export type Writable<T> = {
+	-readonly [P in keyof T]: T[P];
+};
+
+export type NonArray<T> = T extends any[] ? never : T;
+
+export function getTableColumns<T extends Table>(table: T): T['_']['columns'] {
+	return table[Table.Symbol.Columns];
+}
+
+export function getViewSelectedFields<T extends View>(view: T): T['_']['selectedFields'] {
+	return view[ViewBaseConfig].selectedFields;
+}
+
+/** @internal */
+export function getTableLikeName(table: TableLike): string | undefined {
+	return is(table, Subquery)
+		? table._.alias
+		: is(table, View)
+		? table[ViewBaseConfig].name
+		: is(table, SQL)
+		? undefined
+		: table[Table.Symbol.IsAlias]
+		? table[Table.Symbol.Name]
+		: table[Table.Symbol.BaseName];
+}
+
+export type ColumnsWithTable<
+	TTableName extends string,
+	TForeignTableName extends string,
+	TColumns extends AnyColumn<{ tableName: TTableName }>[],
+> = { [Key in keyof TColumns]: AnyColumn<{ tableName: TForeignTableName }> };
+
+export type Casing = 'snake_case' | 'camelCase';
+
+export interface DrizzleConfig<TSchema extends Record<string, unknown> = Record<string, never>> {
+	logger?: boolean | Logger;
+	schema?: TSchema;
+	casing?: Casing;
+	cache?: Cache;
+	/** Wraps every statement the postgres-js session runs; see `StatementWatch`. */
+	statementWatch?: import('./postgres-js/session.js').StatementWatch;
+}
+export type ValidateShape<T, ValidShape, TResult = T> = T extends ValidShape
+	? Exclude<keyof T, keyof ValidShape> extends never ? TResult
+	: DrizzleTypeError<
+		`Invalid key(s): ${Exclude<(keyof T) & (string | number | bigint | boolean | null | undefined), keyof ValidShape>}`
+	>
+	: never;
+
+export type KnownKeysOnly<T, U> = {
+	[K in keyof T]: K extends keyof U ? T[K] : never;
+};
+
+export type IsAny<T> = 0 extends (1 & T) ? true : false;
+
+/** @internal */
+export function getColumnNameAndConfig<
+	TConfig extends Record<string, any> | undefined,
+>(a: string | TConfig | undefined, b: TConfig | undefined) {
+	return {
+		name: typeof a === 'string' && a.length > 0 ? a : '' as string,
+		config: typeof a === 'object' ? a : b as TConfig,
+	};
+}
+
+export type IfNotImported<T, Y, N> = unknown extends T ? Y : N;
+
+export type ImportTypeError<TPackageName extends string> =
+	`Please install \`${TPackageName}\` to allow Drizzle ORM to connect to the database`;
+
+export type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Keys extends any
+	? Required<Pick<T, Keys>> & Partial<Omit<T, Keys>>
+	: never;
+
+type ExpectedConfigShape = {
+	logger?: boolean | {
+		logQuery(query: string, params: unknown[]): void;
+	};
+	schema?: Record<string, never>;
+	casing?: 'snake_case' | 'camelCase';
+};
+
+// If this errors, you must update config shape checker function with new config specs
+const _: DrizzleConfig = {} as ExpectedConfigShape;
+const __: ExpectedConfigShape = {} as DrizzleConfig;
+
+export function isConfig(data: any): boolean {
+	if (typeof data !== 'object' || data === null) return false;
+
+	if (data.constructor.name !== 'Object') return false;
+
+	if ('logger' in data) {
+		const type = typeof data['logger'];
+		if (
+			type !== 'boolean' && (type !== 'object' || typeof data['logger']['logQuery'] !== 'function')
+			&& type !== 'undefined'
+		) return false;
+
+		return true;
+	}
+
+	if ('schema' in data) {
+		const type = typeof data['schema'];
+		if (type !== 'object' && type !== 'undefined') return false;
+
+		return true;
+	}
+
+	if ('casing' in data) {
+		const type = typeof data['casing'];
+		if (type !== 'string' && type !== 'undefined') return false;
+
+		return true;
+	}
+
+	if ('mode' in data) {
+		if (data['mode'] !== 'default' || data['mode'] !== 'planetscale' || data['mode'] !== undefined) return false;
+
+		return true;
+	}
+
+	if ('connection' in data) {
+		const type = typeof data['connection'];
+		if (type !== 'string' && type !== 'object' && type !== 'undefined') return false;
+
+		return true;
+	}
+
+	if ('client' in data) {
+		const type = typeof data['client'];
+		if (type !== 'object' && type !== 'function' && type !== 'undefined') return false;
+
+		return true;
+	}
+
+	if (Object.keys(data).length === 0) return true;
+
+	return false;
+}
+
+export type NeonAuthToken = string | (() => string | Promise<string>);
+
+export const textDecoder = typeof TextDecoder === 'undefined' ? null : new TextDecoder();

package/src/data/query/version.ts

@@ -0,0 +1,4 @@
+// @ts-ignore - imported using Rollup json plugin
+export { version as npmVersion } from '../package.json';
+// In version 7, we changed the PostgreSQL indexes API
+export const compatibilityVersion = 10;

package/src/data/query/view-common.ts

@@ -0,0 +1 @@
+export const ViewBaseConfig = Symbol.for('drizzle:ViewBaseConfig');

package/src/data/schema/branded.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod/v4'
+
+export function branded<T extends z.ZodType, B extends string>(
+  schema: T,
+  _brand: B,
+  refine?: (value: z.infer<T>) => boolean,
+  message?: string,
+) {
+  const refined = refine
+    ? schema.refine(refine, { message: message ?? `Invalid ${_brand}` })
+    : schema
+  return refined.brand<B>()
+}

package/src/data/schema/generated/coerce.ts

@@ -0,0 +1,5 @@
+// Auto-generated by scaffold-namespace — do not edit re-export lines
+// Run: node scripts/scaffold-namespace.js generate manifests/zod--v4.json
+// Manual symbols are not included — they live in separate files.
+
+export type { coerce } from 'zod/v4'

package/src/data/schema/generated/combinator.ts

@@ -0,0 +1,6 @@
+// Auto-generated by scaffold-namespace — do not edit re-export lines
+// Run: node scripts/scaffold-namespace.js generate manifests/zod--v4.json
+// Manual symbols are not included — they live in separate files.
+
+export type { catch } from 'zod/v4'
+export { _default, check, codec, describe, discriminatedUnion, exactOptional, intersection, invertCodec, keyof, looseObject, looseRecord, meta, nonoptional, nullable, nullish, optional, partialRecord, pipe, prefault, preprocess, readonly, refine, strictObject, superRefine, templateLiteral, transform, union, xor } from 'zod/v4'

package/src/data/schema/generated/encoding.ts

@@ -0,0 +1,5 @@
+// Auto-generated by scaffold-namespace — do not edit re-export lines
+// Run: node scripts/scaffold-namespace.js generate manifests/zod--v4.json
+// Manual symbols are not included — they live in separate files.
+
+export { decode, decodeAsync, encode, encodeAsync, safeDecode, safeDecodeAsync, safeEncode, safeEncodeAsync } from 'zod/v4'

package/src/data/schema/generated/error.ts

@@ -0,0 +1,6 @@
+// Auto-generated by scaffold-namespace — do not edit re-export lines
+// Run: node scripts/scaffold-namespace.js generate manifests/zod--v4.json
+// Manual symbols are not included — they live in separate files.
+
+export type { flattenError, formatError, prettifyError, treeifyError } from 'zod/v4'
+export { getErrorMap, setErrorMap } from 'zod/v4'