matrix-nodejs-homeserver 0.2.0 → 0.3.2

package/dist/homeserver.js

@@ -1,7 +1,9 @@
 import { loadSigningKey, randomString } from "./core/crypto.js";
+import "./core/m.js";
 import { SUPPORTED_ROOM_VERSIONS } from "./core/events.js";
 import { PartialStateService } from "./core/partialstate.js";
 import { RoomService } from "./core/rooms.js";
+import { addressPolicy, policyFetch } from "./core/outbound.js";
 import { FederationService } from "./federation/index.js";
 import { PolicyServers } from "./core/policy.js";
 import { ThreepidService } from "./core/threepid.js";
@@ -12,9 +14,9 @@ import { Notifier } from "./core/notifier.js";
 import { StreamManager, localCluster, newInstanceId } from "./core/cluster.js";
 import { TypingService } from "./core/typing.js";
 import { PushService } from "./core/push.js";
+import { SsoService } from "./core/sso.js";
 import { AdminService } from "./core/admin.js";
 import { OAuthDelegation } from "./core/oauth.js";
-import { SsoService } from "./core/sso.js";
 import { DelayedEventService } from "./core/delayed.js";
 import { AuditService } from "./core/audit.js";
 import { SettingsService } from "./core/settings.js";
@@ -77,8 +79,12 @@ var Homeserver = class extends EventEmitter {
 	policyServers;
 	threepids;
 	identityServers;
-	/** `fetch` used for outgoing requests (push gateways, URL previews, OAuth). Overridable for testing. */
+	/** `fetch` for requests to addresses the operator configured (OAuth, SSO, application services). */
 	fetch;
+	/** Which addresses requests to user- or remote-chosen destinations may reach (see `allowPrivateAddresses`). */
+	addressPolicy;
+	/** `fetch` for user- or remote-chosen URLs: refuses private addresses unless allowed, never follows redirects. */
+	publicFetch;
 	/** Resolves once storage is migrated and the server is ready to serve requests. */
 	ready;
 	_signingKey = null;
@@ -108,6 +114,7 @@ var Homeserver = class extends EventEmitter {
 			defaultRoomVersion,
 			accessTokenLifetimeMs: options.accessTokenLifetimeMs ?? null,
 			maxSyncTimeoutMs: options.maxSyncTimeoutMs ?? 3e4,
+			maxConcurrentSyncs: Math.max(1, options.maxConcurrentSyncs ?? 4),
 			urlPreviews: options.urlPreviews ? { allowPrivateAddresses: typeof options.urlPreviews === "object" && !!options.urlPreviews.allowPrivateAddresses } : null,
 			thumbnailer: options.thumbnailer ?? null,
 			rtc: options.rtc ?? {},
@@ -137,6 +144,9 @@ var Homeserver = class extends EventEmitter {
 		this.push = new PushService(this);
 		this.admin = new AdminService(this);
 		this.oauth = options.oauth ? new OAuthDelegation(this, options.oauth) : null;
+		this.fetch = options.fetch ?? globalThis.fetch;
+		this.addressPolicy = addressPolicy(options.allowPrivateAddresses);
+		this.publicFetch = policyFetch(this.addressPolicy, options.fetch);
 		this.federation = new FederationService(this, options.federation);
 		this.delayedEvents = new DelayedEventService(this, options.delayedEvents);
 		this.audit = new AuditService(this, options.audit);
@@ -156,7 +166,6 @@ var Homeserver = class extends EventEmitter {
 			this.cleanupTimer = setInterval(() => void this.cleanup().catch((err) => this.logger.warn("Cleanup failed", err)), cleanupEvery);
 			this.cleanupTimer.unref?.();
 		}
-		this.fetch = options.fetch ?? globalThis.fetch;
 		registerRoutes(this.router);
 		this.ready = this.init(options);
 		this.ready.catch((err) => this.logger.error("Homeserver failed to start", err));

package/dist/http/handler.js

@@ -1,6 +1,6 @@
 import { canonicalJson } from "../core/json.js";
+import { UNSTABLE } from "../core/m.js";
 import { MatrixError, errors } from "../core/errors.js";
-import { inputError } from "./input.js";
 //#region src/http/handler.ts
 const CORS_HEADERS = {
 	"access-control-allow-origin": "*",
@@ -95,7 +95,7 @@ async function dispatch(hs, request, url, options) {
 					const reg = hs.appservices.byToken(t);
 					if (reg) {
 						const userId = await hs.appservices.masquerade(reg, url.searchParams.get("user_id"));
-						const deviceId = url.searchParams.get("device_id") ?? url.searchParams.get("org.matrix.msc3202.device_id");
+						const deviceId = url.searchParams.get("device_id") ?? url.searchParams.get(UNSTABLE.ORG.MATRIX.MSC3202.DEVICE_ID);
 						if (deviceId && !await hs.db.findOne("devices", [{
 							field: "user_id",
 							value: userId
@@ -124,33 +124,12 @@ async function dispatch(hs, request, url, options) {
 			async optionalAuth() {
 				return token() ? ctx.auth() : null;
 			},
-			input: void 0,
 			async rateLimit(action) {
 				const s = token() ? await ctx.auth().catch(() => null) : null;
 				if (s?.isAdmin || s?.appservice && s.appservice.rate_limited === false) return;
 				await hs.rateLimits.check(action, s?.userId ?? ctx.ip ?? "unknown");
 			}
 		};
-		if (matched.input) {
-			const schema = matched.input;
-			let raw;
-			let readError;
-			try {
-				raw = await ctx.json();
-			} catch (err) {
-				readError = err;
-			}
-			let parsed = null;
-			Object.defineProperty(ctx, "input", { get() {
-				if (readError) throw readError;
-				if (!parsed) {
-					const result = schema.safeParse(raw);
-					if (!result.success) throw inputError(result.error);
-					parsed = { data: result.data };
-				}
-				return parsed.data;
-			} });
-		}
 		const result = await matched.handler(ctx);
 		if (result instanceof Response) return withCors(result);
 		return jsonResponse(result ?? {});

package/dist/http/input.js

@@ -1,8 +1,8 @@
 import { MatrixError } from "../core/errors.js";
-import { z } from "zod";
+import { looseObject } from "../vendor/zod/v4/classic/schemas.js";
 //#region src/http/input.ts
 /** A request body: a JSON object whose unknown keys are kept. */
-const body = (shape) => z.looseObject(shape);
+const body = (shape) => looseObject(shape);
 /**
 * Errors carry their Matrix errcode in the message, as `M_CODE: text`: `fail` builds the zod
 * error option for a field. Without one, a missing field is M_MISSING_PARAM and any other

package/dist/http/procedure.js

@@ -0,0 +1,25 @@
+import { inputError } from "./input.js";
+//#region src/http/procedure.ts
+function procedure(def) {
+	return async (ctx) => {
+		const session = def.auth === "user" ? await ctx.auth() : def.auth === "optional" ? await ctx.optionalAuth() : void 0;
+		const extra = def.guard ? await def.guard(ctx) : {};
+		if (def.rateLimit) await ctx.rateLimit(def.rateLimit);
+		let input;
+		if (def.input) {
+			const parsed = def.input.safeParse(await ctx.json());
+			if (!parsed.success) throw inputError(parsed.error);
+			input = parsed.data;
+		}
+		const result = await def.handler(Object.assign(ctx, extra, {
+			session,
+			input
+		}));
+		if (!def.output || result instanceof Response) return result;
+		const checked = def.output.safeParse(result);
+		if (!checked.success) throw new Error(`Response does not match the output schema: ${checked.error.message}`);
+		return checked.data;
+	};
+}
+//#endregion
+export { procedure };

package/dist/http/router.d.ts

@@ -1,10 +1,9 @@
 import { Session } from "../core/auth.js";
 import { RateLimitAction } from "../core/ratelimit.js";
 import { Homeserver } from "../homeserver.js";
-import { z } from "zod";
 //#region src/http/router.d.ts
 export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE";
-export interface RequestContext<I = unknown> {
+export interface RequestContext {
   hs: Homeserver;
   request: Request;
   url: URL;
@@ -23,38 +22,22 @@ export interface RequestContext<I = unknown> {
   accessToken(): string | null;
   /** Apply the rate limit for `action` to the requesting user (or IP when unauthenticated). */
   rateLimit(action: RateLimitAction): Promise<void>;
-  /**
-   * The request body parsed with the route's `input` schema (undefined for routes without one).
-   * Validated on first access, which throws the Matrix error for an invalid body: read it where
-   * the handler needs the body, after authenticating.
-   */
-  input: I;
 }
 export type HandlerResult = Response | object | void;
-export type Handler<I = any> = (ctx: RequestContext<I>) => Promise<HandlerResult> | HandlerResult;
-/** Per-route options. `input` validates and parses the JSON body before the handler runs. */
-export interface RouteOptions<S extends z.ZodType = z.ZodType> {
-  input?: S;
-}
-/** A route's handler, with the body type its `input` schema produces. */
-type Routed<S> = S extends z.ZodType ? Handler<z.output<S>> : Handler;
+/** What the router calls; endpoints build one with `procedure()` (see http/procedure.ts). */
+export type Handler = (ctx: RequestContext) => Promise<HandlerResult> | HandlerResult;
 export declare class Router {
   private routes;
-  add<S extends z.ZodType | undefined = undefined>(method: HttpMethod, path: string, handler: Routed<S>, options?: RouteOptions<NonNullable<S>>): void;
-  get(path: string, h: Handler): void;
-  post<S extends z.ZodType>(path: string, options: RouteOptions<S>, h: Routed<S>): void;
-  post(path: string, h: Handler): void;
-  put<S extends z.ZodType>(path: string, options: RouteOptions<S>, h: Routed<S>): void;
-  put(path: string, h: Handler): void;
-  delete(path: string, h: Handler): void;
+  add(method: HttpMethod, path: string, handler: Handler): void;
+  get: (path: string, h: Handler) => void;
+  post: (path: string, h: Handler) => void;
+  put: (path: string, h: Handler) => void;
+  delete: (path: string, h: Handler) => void;
   /** Register a client-server API route under both `r0` and `v3` (or the given versions). */
-  client<S extends z.ZodType>(method: HttpMethod, path: string, options: RouteOptions<S>, handler: Routed<S>, versions?: string[]): void;
   client(method: HttpMethod, path: string, handler: Handler, versions?: string[]): void;
   match(method: string, pathname: string): {
     handler: Handler;
     params: Record<string, string>;
-    input?: z.ZodType;
   } | "method" | null;
 }
-//#endregion
-export {};
+//#endregion

package/dist/http/router.js

@@ -1,39 +1,20 @@
 //#region src/http/router.ts
 var Router = class {
 	routes = [];
-	add(method, path, handler, options = {}) {
+	add(method, path, handler) {
 		this.routes.push({
 			method,
 			segments: path.split("/").filter(Boolean),
-			handler,
-			input: options.input
+			handler
 		});
 	}
-	get(path, h) {
-		this.add("GET", path, h);
-	}
-	post(path, a, b) {
-		if (typeof a === "function") this.add("POST", path, a);
-		else this.add("POST", path, b, a);
-	}
-	put(path, a, b) {
-		if (typeof a === "function") this.add("PUT", path, a);
-		else this.add("PUT", path, b, a);
-	}
-	delete(path, h) {
-		this.add("DELETE", path, h);
-	}
-	client(method, path, a, b, c) {
-		const [options, handler, versions] = typeof a === "function" ? [
-			{},
-			a,
-			b ?? ["r0", "v3"]
-		] : [
-			a,
-			b,
-			c ?? ["r0", "v3"]
-		];
-		for (const v of versions) this.add(method, `/_matrix/client/${v}${path}`, handler, options);
+	get = (path, h) => this.add("GET", path, h);
+	post = (path, h) => this.add("POST", path, h);
+	put = (path, h) => this.add("PUT", path, h);
+	delete = (path, h) => this.add("DELETE", path, h);
+	/** Register a client-server API route under both `r0` and `v3` (or the given versions). */
+	client(method, path, handler, versions = ["r0", "v3"]) {
+		for (const v of versions) this.add(method, `/_matrix/client/${v}${path}`, handler);
 	}
 	match(method, pathname) {
 		const parts = pathname.split("/").filter(Boolean);
@@ -47,8 +28,7 @@ var Router = class {
 			}
 			return {
 				handler: route.handler,
-				params,
-				input: route.input
+				params
 			};
 		}
 		return methodMismatch ? "method" : null;

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import { ThreepidEmail, ThreepidOptions, ThreepidPurpose, ThreepidSms } from "./core/threepid.js";
+import { M, UNSTABLE } from "./core/m.js";
 import { AppServiceRegistration, loadAppServiceRegistrations, parseAppServiceRegistration } from "./core/appservices.js";
-import { ClusterAdapter, localCluster } from "./core/cluster.js";
 import { DatabaseAdapter, FieldDef, FindManyOptions, ModelDef, Operator, Row, Schema, WhereClause } from "./storage/types.js";
+import { ClusterAdapter, localCluster } from "./core/cluster.js";
 import { AdminService, ServerNoticesOptions } from "./core/admin.js";
 import { OAuthDelegationOptions } from "./core/oauth.js";
 import { SsoOptions, SsoProvider } from "./core/sso.js";
@@ -21,5 +22,5 @@ import { memoryAdapter } from "./storage/memory.js";
 import { MysqlPoolLike, PgPoolLike, SqlAdapterOptions, SqlDialect, SqlExecutor, SqliteDatabaseLike, mysqlAdapter, postgresAdapter, sqlAdapter, sqliteAdapter } from "./storage/sql.js";
 import { schema } from "./storage/schema.js";
 import { S3MediaOptions, s3Media } from "./adapters/s3.js";
-import { PgClusterPoolLike, RedisLike, RedisSubscriberLike, postgresCluster, redisCluster } from "./adapters/cluster.js";
-export { type AdminRoomOptions, type AdminService, type AppServiceRegistration, type AuditAction, type AuditEntry, type AuditOptions, type ClusterAdapter, type DatabaseAdapter, type DelayedEventsOptions, type FederationOptions, type FieldDef, type FindManyOptions, Homeserver, type HomeserverOptions, type Logger, MatrixError, type MediaAdapter, type MediaMetadata, type ModelDef, type MysqlPoolLike, type NodeHandler, type OAuthDelegationOptions, type Operator, type PasswordCheckContext, type PgClusterPoolLike, type PgPoolLike, type RateLimitAction, type RateLimitRule, type RateLimiter, type RedisLike, type RedisSubscriberLike, type Row, type RtcOptions, type S3MediaOptions, type Schema, type ServerNoticesOptions, type SqlAdapterOptions, type SqlDialect, type SqlExecutor, type SqliteDatabaseLike, type SsoOptions, type SsoProvider, type ThreepidEmail, type ThreepidOptions, type ThreepidPurpose, type ThreepidSms, type ThumbnailRequest, type Thumbnailer, type TurnOptions, type UserAuthAdapter, type WhereClause, createHomeserver, filesystemMedia, getExpressHandler, getFastifyPlugin, getFetchHandler, getHonoHandler, getNodeHandler, handleRequest, isMatrixPath, loadAppServiceRegistrations, localCluster, memoryAdapter, memoryMedia, memoryRateLimiter, mysqlAdapter, parseAppServiceRegistration, postgresAdapter, postgresCluster, redisCluster, s3Media, schema, sharpThumbnailer, sqlAdapter, sqliteAdapter };
+import { PgClusterPoolLike, postgresCluster } from "./adapters/cluster.js";
+export { type AdminRoomOptions, type AdminService, type AppServiceRegistration, type AuditAction, type AuditEntry, type AuditOptions, type ClusterAdapter, type DatabaseAdapter, type DelayedEventsOptions, type FederationOptions, type FieldDef, type FindManyOptions, Homeserver, type HomeserverOptions, type Logger, M, MatrixError, type MediaAdapter, type MediaMetadata, type ModelDef, type MysqlPoolLike, type NodeHandler, type OAuthDelegationOptions, type Operator, type PasswordCheckContext, type PgClusterPoolLike, type PgPoolLike, type RateLimitAction, type RateLimitRule, type RateLimiter, type Row, type RtcOptions, type S3MediaOptions, type Schema, type ServerNoticesOptions, type SqlAdapterOptions, type SqlDialect, type SqlExecutor, type SqliteDatabaseLike, type SsoOptions, type SsoProvider, type ThreepidEmail, type ThreepidOptions, type ThreepidPurpose, type ThreepidSms, type ThumbnailRequest, type Thumbnailer, type TurnOptions, UNSTABLE, type UserAuthAdapter, type WhereClause, createHomeserver, filesystemMedia, getExpressHandler, getFastifyPlugin, getFetchHandler, getHonoHandler, getNodeHandler, handleRequest, isMatrixPath, loadAppServiceRegistrations, localCluster, memoryAdapter, memoryMedia, memoryRateLimiter, mysqlAdapter, parseAppServiceRegistration, postgresAdapter, postgresCluster, s3Media, schema, sharpThumbnailer, sqlAdapter, sqliteAdapter };

package/dist/index.js

@@ -1,3 +1,4 @@
+import { M, UNSTABLE } from "./core/m.js";
 import { MatrixError } from "./core/errors.js";
 import { localCluster } from "./core/cluster.js";
 import { loadAppServiceRegistrations, parseAppServiceRegistration } from "./core/appservices.js";
@@ -10,5 +11,5 @@ import { Homeserver, createHomeserver } from "./homeserver.js";
 import { getExpressHandler, getFastifyPlugin, getFetchHandler, getHonoHandler, getNodeHandler, isMatrixPath } from "./http/adapters.js";
 import { mysqlAdapter, postgresAdapter, sqlAdapter, sqliteAdapter } from "./storage/sql.js";
 import { s3Media } from "./adapters/s3.js";
-import { postgresCluster, redisCluster } from "./adapters/cluster.js";
-export { Homeserver, MatrixError, createHomeserver, filesystemMedia, getExpressHandler, getFastifyPlugin, getFetchHandler, getHonoHandler, getNodeHandler, handleRequest, isMatrixPath, loadAppServiceRegistrations, localCluster, memoryAdapter, memoryMedia, memoryRateLimiter, mysqlAdapter, parseAppServiceRegistration, postgresAdapter, postgresCluster, redisCluster, s3Media, schema, sharpThumbnailer, sqlAdapter, sqliteAdapter };
+import { postgresCluster } from "./adapters/cluster.js";
+export { Homeserver, M, MatrixError, UNSTABLE, createHomeserver, filesystemMedia, getExpressHandler, getFastifyPlugin, getFetchHandler, getHonoHandler, getNodeHandler, handleRequest, isMatrixPath, loadAppServiceRegistrations, localCluster, memoryAdapter, memoryMedia, memoryRateLimiter, mysqlAdapter, parseAppServiceRegistration, postgresAdapter, postgresCluster, s3Media, schema, sharpThumbnailer, sqlAdapter, sqliteAdapter };

package/dist/storage/batch.js

@@ -0,0 +1,11 @@
+//#region src/storage/batch.ts
+/**
+* Run independent reads together: in one round trip when the adapter can (`findManyBatch`),
+* otherwise concurrently. Results come in the order of the queries.
+*/
+function readBatch(db, queries) {
+	if (db.findManyBatch) return db.findManyBatch(queries);
+	return Promise.all(queries.map((query) => db.findMany(query.model, query.opts)));
+}
+//#endregion
+export { readBatch };

package/dist/storage/memory.js

@@ -72,6 +72,7 @@ function memoryAdapter() {
 					rows.sort((a, b) => a[field] < b[field] ? -dir : a[field] > b[field] ? dir : 0);
 				}
 				if (opts.limit !== void 0) rows = rows.slice(0, opts.limit);
+				if (opts.fields?.length) return rows.map((r) => Object.fromEntries(opts.fields.map((f) => [f, structuredClone(r[f] ?? null)])));
 				return rows.map((r) => structuredClone(r));
 			},
 			async update(model, where, data) {

package/dist/storage/schema.js

@@ -249,7 +249,7 @@ const schema = {
 			forgotten: b
 		},
 		primaryKey: ["room_id", "user_id"],
-		indexes: [["user_id"]]
+		indexes: [["user_id"], ["stream"]]
 	},
 	room_aliases: {
 		fields: {

package/dist/storage/sql.js

@@ -130,11 +130,30 @@ function sqlAdapter({ dialect, executor: rootExecutor, tablePrefix = "", transac
 			},
 			async findMany(model, opts = {}) {
 				const params = [];
-				let sql = `SELECT * FROM ${t(model)}${buildWhere(model, opts.where, params)}`;
+				let sql = `SELECT ${opts.fields?.length ? opts.fields.map(q).join(", ") : "*"} FROM ${t(model)}${buildWhere(model, opts.where, params)}`;
 				if (opts.sortBy) sql += ` ORDER BY ${q(opts.sortBy.field)} ${opts.sortBy.direction === "asc" ? "ASC" : "DESC"}`;
 				if (opts.limit !== void 0) sql += ` LIMIT ${Math.max(0, Math.floor(opts.limit))}`;
 				return (await executor.query(sql, params)).map((r) => fromDb(model, r));
 			},
+			...dialect === "postgres" ? { async findManyBatch(queries) {
+				if (queries.length === 0) return [];
+				const params = [];
+				const parts = queries.map(({ model, opts = {} }, i) => {
+					const fields = opts.fields?.length && opts.sortBy && !opts.fields.includes(opts.sortBy.field) ? [...opts.fields, opts.sortBy.field] : opts.fields;
+					let inner = `SELECT ${fields?.length ? fields.map(q).join(", ") : "*"} FROM ${t(model)}${buildWhere(model, opts.where, params)}`;
+					const order = opts.sortBy ? `${q(opts.sortBy.field)} ${opts.sortBy.direction === "asc" ? "ASC" : "DESC"}` : "";
+					if (order) inner += ` ORDER BY ${order}`;
+					if (opts.limit !== void 0) inner += ` LIMIT ${Math.max(0, Math.floor(opts.limit))}`;
+					return `SELECT ${i} AS i, row_number() OVER (${order ? `ORDER BY ${order.replace(/^"/, "b.\"")}` : ""}) AS n, to_jsonb(b) AS r FROM (${inner}) b`;
+				});
+				const rows = await executor.query(`${parts.join(" UNION ALL ")} ORDER BY i, n`, params);
+				const out = queries.map(() => []);
+				for (const row of rows) {
+					const r = typeof row.r === "string" ? JSON.parse(row.r) : row.r;
+					out[Number(row.i)].push(fromDb(queries[Number(row.i)].model, r));
+				}
+				return out;
+			} } : {},
 			async update(model, where, data) {
 				const fields = Object.keys(data).filter((k) => data[k] !== void 0);
 				if (fields.length === 0) return 0;

package/dist/storage/types.d.ts

@@ -21,8 +21,18 @@ export interface WhereClause {
   operator?: Operator;
 }
 export type Row = Record<string, any>;
+/** One read of a `findManyBatch`. */
+export interface BatchQuery {
+  model: string;
+  opts?: FindManyOptions;
+}
 export interface FindManyOptions {
   where?: WhereClause[];
+  /**
+   * Only these fields are needed. Adapters should read just these (a smaller query and less to
+   * parse); one that ignores the option and returns whole rows is still correct.
+   */
+  fields?: string[];
   sortBy?: {
     field: string;
     direction: "asc" | "desc";
@@ -35,6 +45,12 @@ export interface FindManyOptions {
  * All `where` clauses are combined with AND.
  */
 export interface DatabaseAdapter {
+  /**
+   * Several independent reads in one go: the results in the same order as the queries. Optional;
+   * an adapter that talks to a database server can send them in one round trip. Without it,
+   * callers run the reads separately (see `readBatch`).
+   */
+  findManyBatch?(queries: BatchQuery[]): Promise<Row[][]>;
   /** Create tables / collections for the given schema. Must be idempotent. */
   migrate?(schema: Schema): Promise<void>;
   create(model: string, data: Row): Promise<void>;

package/dist/vendor/zod/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Colin McDonnell
+
+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/vendor/zod/v4/classic/errors.js

@@ -0,0 +1,54 @@
+import { jsonStringifyReplacer } from "../core/util.js";
+import { $constructor } from "../core/core.js";
+import { $ZodError, flattenError, formatError } from "../core/errors.js";
+//#region node_modules/zod/v4/classic/errors.js
+const _installedErrorProtos = /* @__PURE__ */ new WeakSet([Object.prototype, Error.prototype]);
+function _lazyMethod(proto, key, make) {
+	Object.defineProperty(proto, key, {
+		configurable: true,
+		enumerable: false,
+		get() {
+			const value = make(this);
+			Object.defineProperty(this, key, {
+				value,
+				configurable: true,
+				writable: true
+			});
+			return value;
+		},
+		set(value) {
+			Object.defineProperty(this, key, {
+				value,
+				configurable: true,
+				writable: true
+			});
+		}
+	});
+}
+const initializer = (inst, issues) => {
+	$ZodError.init(inst, issues);
+	inst.name = "ZodError";
+	const proto = Object.getPrototypeOf(inst);
+	if (_installedErrorProtos.has(proto)) return;
+	_installedErrorProtos.add(proto);
+	_lazyMethod(proto, "format", (self) => (mapper) => formatError(self, mapper));
+	_lazyMethod(proto, "flatten", (self) => (mapper) => flattenError(self, mapper));
+	_lazyMethod(proto, "addIssue", (self) => (issue) => {
+		self.issues.push(issue);
+		self.message = JSON.stringify(self.issues, jsonStringifyReplacer, 2);
+	});
+	_lazyMethod(proto, "addIssues", (self) => (issues) => {
+		self.issues.push(...issues);
+		self.message = JSON.stringify(self.issues, jsonStringifyReplacer, 2);
+	});
+	Object.defineProperty(proto, "isEmpty", {
+		configurable: true,
+		enumerable: false,
+		get() {
+			return this.issues.length === 0;
+		}
+	});
+};
+const ZodRealError = /*@__PURE__*/ $constructor("ZodError", initializer, void 0, { Parent: Error });
+//#endregion
+export { ZodRealError };

package/dist/vendor/zod/v4/classic/parse.js

@@ -0,0 +1,17 @@
+import { _decode, _decodeAsync, _encode, _encodeAsync, _parse, _parseAsync, _safeDecode, _safeDecodeAsync, _safeEncode, _safeEncodeAsync, _safeParse, _safeParseAsync } from "../core/parse.js";
+import { ZodRealError } from "./errors.js";
+//#region node_modules/zod/v4/classic/parse.js
+const parse = /* @__PURE__ */ _parse(ZodRealError);
+const parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError);
+const safeParse = /* @__PURE__ */ _safeParse(ZodRealError);
+const safeParseAsync = /* @__PURE__ */ _safeParseAsync(ZodRealError);
+const encode = /* @__PURE__ */ _encode(ZodRealError);
+const decode = /* @__PURE__ */ _decode(ZodRealError);
+const encodeAsync = /* @__PURE__ */ _encodeAsync(ZodRealError);
+const decodeAsync = /* @__PURE__ */ _decodeAsync(ZodRealError);
+const safeEncode = /* @__PURE__ */ _safeEncode(ZodRealError);
+const safeDecode = /* @__PURE__ */ _safeDecode(ZodRealError);
+const safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
+const safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
+//#endregion
+export { decode, decodeAsync, encode, encodeAsync, parse, parseAsync, safeDecode, safeDecodeAsync, safeEncode, safeEncodeAsync, safeParse, safeParseAsync };