agentnetes 0.1.1 → 0.1.4

package/web/node_modules/@vercel/sandbox/dist/utils/dev-credentials.js

@@ -0,0 +1,196 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cachedGenerateCredentials = void 0;
+exports.shouldPromptForCredentials = shouldPromptForCredentials;
+exports.generateCredentials = generateCredentials;
+exports.signInAndGetToken = signInAndGetToken;
+const picocolors_1 = __importDefault(require("picocolors"));
+const ms_1 = __importDefault(require("ms"));
+const Log = __importStar(require("./log"));
+async function importAuth() {
+    const auth = await Promise.resolve().then(() => __importStar(require("../auth/index")));
+    return auth;
+}
+function shouldPromptForCredentials() {
+    return (process.env.NODE_ENV !== "production" &&
+        !["1", "true"].includes(process.env.CI || "") &&
+        process.stdout.isTTY &&
+        process.stdin.isTTY);
+}
+/**
+ * Returns cached credentials for the given team/project combination.
+ *
+ * @remarks
+ * The cache is keyed by `teamId` and `projectId`. A new credential generation
+ * is triggered only when these values change or when a previous attempt failed.
+ *
+ * **Important:** Successfully resolved credentials are cached indefinitely and
+ * will not be refreshed even if the token expires. Cache invalidation only occurs
+ * on rejection (error). This is intentional for development use cases where
+ * short-lived sessions don't require proactive token refresh.
+ */
+exports.cachedGenerateCredentials = (() => {
+    let cache = null;
+    return async (opts) => {
+        if (!cache ||
+            cache[0].teamId !== opts.teamId ||
+            cache[0].projectId !== opts.projectId) {
+            const promise = generateCredentials(opts).catch((err) => {
+                cache = null;
+                throw err;
+            });
+            cache = [opts, promise];
+        }
+        const v = await cache[1];
+        Log.write("warn", `using inferred credentials team=${v.teamId} project=${v.projectId}`);
+        return v;
+    };
+})();
+/**
+ * Generates credentials by authenticating and inferring scope.
+ *
+ * @internal This is exported for testing purposes. Consider using
+ * {@link cachedGenerateCredentials} instead, which caches the result
+ * to avoid redundant authentication flows.
+ */
+async function generateCredentials(opts) {
+    const { OAuth, pollForToken, getAuth, updateAuthConfig, inferScope } = await importAuth();
+    let auth = getAuth();
+    if (!auth?.token) {
+        const timeout = process.env.VERCEL_URL
+            ? /* when deployed to vercel we don't want to have a long timeout */ "1 minute"
+            : "5 minutes";
+        auth = await signInAndGetToken({ OAuth, pollForToken, getAuth }, timeout);
+    }
+    if (auth?.refreshToken &&
+        auth.expiresAt &&
+        auth.expiresAt.getTime() <= Date.now()) {
+        const oauth = await OAuth();
+        const newToken = await oauth.refreshToken(auth.refreshToken);
+        auth = {
+            expiresAt: new Date(Date.now() + newToken.expires_in * 1000),
+            token: newToken.access_token,
+            refreshToken: newToken.refresh_token || auth.refreshToken,
+        };
+        updateAuthConfig(auth);
+    }
+    if (!auth?.token) {
+        throw new Error([
+            `Failed to retrieve authentication token.`,
+            `${picocolors_1.default.bold("hint:")} Set VERCEL_OIDC_TOKEN or provide a Vercel API token.`,
+            "├▶ Sandbox docs: https://vercel.com/docs/vercel-sandbox",
+            "╰▶ Access tokens: https://vercel.com/kb/guide/how-do-i-use-a-vercel-api-access-token",
+        ].join("\n"));
+    }
+    if (opts.teamId && opts.projectId) {
+        return {
+            token: auth.token,
+            teamId: opts.teamId,
+            projectId: opts.projectId,
+        };
+    }
+    const scope = await inferScope({ teamId: opts.teamId, token: auth.token });
+    if (scope.created) {
+        Log.write("info", `Created default project "${scope.projectId}" in team "${scope.teamId}".`);
+    }
+    return {
+        token: auth.token,
+        teamId: opts.teamId || scope.teamId,
+        projectId: opts.projectId || scope.projectId,
+    };
+}
+async function signInAndGetToken(auth, timeout) {
+    Log.write("warn", [
+        `No VERCEL_OIDC_TOKEN environment variable found, initiating device authorization flow...`,
+        `│  ${picocolors_1.default.bold("help:")} this flow only happens on development environment.`,
+        `│  In production, make sure to set up a proper token, or set up Vercel OIDC [https://vercel.com/docs/oidc].`,
+    ]);
+    const oauth = await auth.OAuth();
+    const request = await oauth.deviceAuthorizationRequest();
+    Log.write("info", [
+        `╰▶ To authenticate, visit: ${request.verification_uri_complete}`,
+        `   or visit ${picocolors_1.default.italic(request.verification_uri)} and type ${picocolors_1.default.bold(request.user_code)}`,
+        `   Press ${picocolors_1.default.bold("<return>")} to open in your browser`,
+    ]);
+    let error;
+    const generator = auth.pollForToken({ request, oauth });
+    let done = false;
+    let spawnedTimeout = setTimeout(() => {
+        if (done)
+            return;
+        const message = [
+            `Authentication flow timed out after ${timeout}.`,
+            `│  Make sure to provide a token to avoid prompting an interactive flow.`,
+            `╰▶ ${picocolors_1.default.bold("help:")} Link your project with ${Log.code("npx vercel link")} to refresh OIDC token automatically.`,
+        ].join("\n");
+        error = new Error(message);
+        // Note: generator.return() initiates cooperative cancellation. The generator's
+        // finally block will abort pending setTimeout calls, but any in-flight HTTP
+        // request will complete before the generator terminates. This is acceptable
+        // for this dev-only timeout scenario.
+        generator.return();
+    }, (0, ms_1.default)(timeout));
+    try {
+        for await (const event of generator) {
+            switch (event._tag) {
+                case "SlowDown":
+                case "Timeout":
+                case "Response":
+                    break;
+                case "Error":
+                    error = event.error;
+                    break;
+                default:
+                    throw new Error(`Unknown event type: ${JSON.stringify(event)}`);
+            }
+        }
+    }
+    finally {
+        done = true;
+        clearTimeout(spawnedTimeout);
+    }
+    if (error) {
+        Log.write("error", `${picocolors_1.default.bold("error:")} Authentication failed: ${error.message}`);
+        throw error;
+    }
+    Log.write("success", `${picocolors_1.default.bold("done!")} Authenticated successfully!`);
+    const stored = auth.getAuth();
+    return stored;
+}
+//# sourceMappingURL=dev-credentials.js.map

package/web/node_modules/@vercel/sandbox/dist/utils/get-credentials.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schema = exports.VercelOidcContextError = exports.LocalOidcContextError = void 0;
+exports.getCredentials = getCredentials;
+const oidc_1 = require("@vercel/oidc");
+const decode_base64_url_1 = require("./decode-base64-url");
+const zod_1 = require("zod");
+const dev_credentials_1 = require("./dev-credentials");
+/**
+ * Error thrown when OIDC context is not available in local development,
+ * therefore we should guide how to ensure it is set up by linking a project
+ */
+class LocalOidcContextError extends Error {
+    constructor(cause) {
+        const message = [
+            "Could not get credentials from OIDC context.",
+            "Please link your Vercel project using `npx vercel link`.",
+            "Then, pull an initial OIDC token with `npx vercel env pull`",
+            "and retry.",
+            "╰▶ Make sure you are loading `.env.local` correctly, or passing $VERCEL_OIDC_TOKEN directly.",
+        ].join("\n");
+        super(message, { cause });
+        this.name = "LocalOidcContextError";
+    }
+}
+exports.LocalOidcContextError = LocalOidcContextError;
+/**
+ * Error thrown when OIDC context is not available in Vercel environment,
+ * therefore we should guide how to set it up.
+ */
+class VercelOidcContextError extends Error {
+    constructor(cause) {
+        const message = [
+            "Could not get credentials from OIDC context.",
+            "Please make sure OIDC is set up for your project",
+            "╰▶ Docs: https://vercel.com/docs/oidc",
+        ].join("\n");
+        super(message, { cause });
+        this.name = "VercelOidcContextError";
+    }
+}
+exports.VercelOidcContextError = VercelOidcContextError;
+async function getVercelToken(opts) {
+    try {
+        const token = await (0, oidc_1.getVercelOidcToken)({
+            team: opts.teamId,
+            project: opts.projectId,
+        });
+        return getCredentialsFromOIDCToken(token);
+    }
+    catch (error) {
+        if (!(0, dev_credentials_1.shouldPromptForCredentials)()) {
+            if (process.env.VERCEL_URL) {
+                throw new VercelOidcContextError(error);
+            }
+            else {
+                throw new LocalOidcContextError(error);
+            }
+        }
+        return await (0, dev_credentials_1.cachedGenerateCredentials)(opts);
+    }
+}
+/**
+ * Allow to get credentials to access the Vercel API. Credentials can be
+ * provided in two different ways:
+ *
+ * 1. By passing an object with the `teamId`, `token`, and `projectId` properties.
+ * 2. By using an environment variable VERCEL_OIDC_TOKEN.
+ *
+ * If both methods are used, the object properties take precedence over the
+ * environment variable. If neither method is used, an error is thrown.
+ */
+async function getCredentials(params) {
+    const credentials = getCredentialsFromParams(params ?? {});
+    if (credentials) {
+        return credentials;
+    }
+    const oidcToken = await getVercelToken({
+        teamId: params &&
+            typeof params === "object" &&
+            "teamId" in params &&
+            typeof params.teamId === "string"
+            ? params.teamId
+            : undefined,
+        projectId: params &&
+            typeof params === "object" &&
+            "projectId" in params &&
+            typeof params.projectId === "string"
+            ? params.projectId
+            : undefined,
+    });
+    return oidcToken;
+}
+/**
+ * Attempt to extract credentials from the provided parameters. Either all
+ * required fields (`token`, `teamId`, and `projectId`) must be present
+ * or none of them, otherwise an error is thrown.
+ */
+function getCredentialsFromParams(params) {
+    // Type guard: params must be an object
+    if (!params || typeof params !== "object") {
+        return null;
+    }
+    const missing = [
+        "token" in params && typeof params.token === "string" ? null : "token",
+        "teamId" in params && typeof params.teamId === "string" ? null : "teamId",
+        "projectId" in params && typeof params.projectId === "string"
+            ? null
+            : "projectId",
+    ].filter((value) => value !== null);
+    if (missing.length === 0) {
+        return {
+            token: params.token,
+            projectId: params.projectId,
+            teamId: params.teamId,
+        };
+    }
+    if (missing.length < 3) {
+        throw new Error(`Missing credentials parameters to access the Vercel API: ${missing
+            .filter((value) => value !== null)
+            .join(", ")}`);
+    }
+    return null;
+}
+/**
+ * Schema to validate the payload of the Vercel OIDC token where we expect
+ * to find the `teamId` and `projectId`.
+ */
+exports.schema = zod_1.z.object({
+    exp: zod_1.z.number().optional().describe("Expiry timestamp (seconds since epoch)"),
+    iat: zod_1.z.number().optional().describe("Issued at timestamp"),
+    owner_id: zod_1.z.string(),
+    project_id: zod_1.z.string(),
+});
+/**
+ * Extracts credentials from a Vercel OIDC token. The token is expected to be
+ * a JWT with a payload that contains `project_id` and `owner_id`.
+ *
+ * @param token - The Vercel OIDC token.
+ * @returns An object containing the token, projectId, and teamId.
+ * @throws If the token is invalid or does not contain the required fields.
+ */
+function getCredentialsFromOIDCToken(token) {
+    try {
+        const payload = exports.schema.parse((0, decode_base64_url_1.decodeBase64Url)(token.split(".")[1]));
+        return {
+            token,
+            projectId: payload.project_id,
+            teamId: payload.owner_id,
+        };
+    }
+    catch (error) {
+        throw new Error(`Invalid Vercel OIDC token: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+//# sourceMappingURL=get-credentials.js.map

package/web/node_modules/@vercel/sandbox/dist/utils/log.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.write = write;
+exports.code = code;
+const picocolors_1 = __importDefault(require("picocolors"));
+const colors = {
+    warn: picocolors_1.default.yellow,
+    error: picocolors_1.default.red,
+    success: picocolors_1.default.green,
+    info: picocolors_1.default.blue,
+};
+const logPrefix = picocolors_1.default.dim("[vercel/sandbox]");
+function write(level, text) {
+    text = Array.isArray(text) ? text.join("\n") : text;
+    const prefixed = text.replace(/^/gm, `${logPrefix} `);
+    console.error(colors[level](prefixed));
+}
+function code(text) {
+    return picocolors_1.default.italic(picocolors_1.default.dim("`") + text + picocolors_1.default.dim("`"));
+}
+//# sourceMappingURL=log.js.map

package/web/node_modules/@vercel/sandbox/dist/utils/network-policy.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toAPINetworkPolicy = toAPINetworkPolicy;
+exports.fromAPINetworkPolicy = fromAPINetworkPolicy;
+function toAPINetworkPolicy(policy) {
+    if (policy === "allow-all")
+        return { mode: "allow-all" };
+    if (policy === "deny-all")
+        return { mode: "deny-all" };
+    if (policy.allow && !Array.isArray(policy.allow)) {
+        const allowedDomains = Object.keys(policy.allow);
+        const injectionRules = [];
+        for (const [domain, rules] of Object.entries(policy.allow)) {
+            const merged = {};
+            for (const rule of rules) {
+                for (const t of rule.transform ?? []) {
+                    Object.assign(merged, t.headers);
+                }
+            }
+            if (Object.keys(merged).length > 0) {
+                injectionRules.push({ domain, headers: merged });
+            }
+        }
+        return {
+            mode: "custom",
+            ...(allowedDomains.length > 0 && { allowedDomains }),
+            ...(injectionRules.length > 0 && { injectionRules }),
+            ...(policy.subnets?.allow && { allowedCIDRs: policy.subnets.allow }),
+            ...(policy.subnets?.deny && { deniedCIDRs: policy.subnets.deny }),
+        };
+    }
+    return {
+        mode: "custom",
+        ...(policy.allow && { allowedDomains: policy.allow }),
+        ...(policy.subnets?.allow && { allowedCIDRs: policy.subnets.allow }),
+        ...(policy.subnets?.deny && { deniedCIDRs: policy.subnets.deny }),
+    };
+}
+function fromAPINetworkPolicy(api) {
+    if (api.mode === "allow-all")
+        return "allow-all";
+    if (api.mode === "deny-all")
+        return "deny-all";
+    const subnets = (api.allowedCIDRs || api.deniedCIDRs)
+        ? {
+            subnets: {
+                ...(api.allowedCIDRs && { allow: api.allowedCIDRs }),
+                ...(api.deniedCIDRs && { deny: api.deniedCIDRs }),
+            },
+        }
+        : undefined;
+    // If injectionRules are present, reconstruct the record form.
+    // The API returns headerNames (secret values are stripped), so we
+    // populate each header value with "<redacted>".
+    if (api.injectionRules && api.injectionRules.length > 0) {
+        const rulesByDomain = new Map(api.injectionRules.map((r) => [r.domain, r.headerNames ?? []]));
+        const allow = {};
+        for (const domain of api.allowedDomains ?? []) {
+            const headerNames = rulesByDomain.get(domain);
+            if (headerNames && headerNames.length > 0) {
+                const headers = Object.fromEntries(headerNames.map((n) => [n, "<redacted>"]));
+                allow[domain] = [{ transform: [{ headers }] }];
+            }
+            else {
+                allow[domain] = [];
+            }
+        }
+        // Include injection rules for domains not in allowedDomains
+        for (const rule of api.injectionRules) {
+            if (!(rule.domain in allow)) {
+                const headers = Object.fromEntries((rule.headerNames ?? []).map((n) => [n, "<redacted>"]));
+                allow[rule.domain] = [{ transform: [{ headers }] }];
+            }
+        }
+        return { allow, ...subnets };
+    }
+    return {
+        ...(api.allowedDomains && { allow: api.allowedDomains }),
+        ...subnets,
+    };
+}
+//# sourceMappingURL=network-policy.js.map

package/web/node_modules/@vercel/sandbox/dist/utils/normalizePath.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePath = normalizePath;
+const path_1 = __importDefault(require("path"));
+/**
+ * Normalize a path and make it relative to `params.extractDir` for inclusion
+ * in our tar archives.
+ *
+ * Relative paths are first resolved to `params.cwd`.
+ * Absolute paths are normalized and resolved relative to `params.extractDir`.
+ *
+ * In addition, paths are normalized so consecutive slashes are removed and
+ * stuff like `../..` is resolved appropriately.
+ *
+ * This function always returns a path relative to `params.extractDir`.
+ */
+function normalizePath(params) {
+    if (!path_1.default.posix.isAbsolute(params.cwd)) {
+        throw new Error("cwd dir must be absolute");
+    }
+    if (!path_1.default.posix.isAbsolute(params.extractDir)) {
+        throw new Error("extractDir must be absolute");
+    }
+    const basePath = path_1.default.posix.isAbsolute(params.filePath)
+        ? path_1.default.posix.normalize(params.filePath)
+        : path_1.default.posix.join(params.cwd, params.filePath);
+    return path_1.default.posix.relative(params.extractDir, basePath);
+}
+//# sourceMappingURL=normalizePath.js.map

package/web/node_modules/@vercel/sandbox/dist/utils/resolveSignal.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSignal = resolveSignal;
+const linuxSignalMapping = {
+    SIGHUP: 1,
+    SIGINT: 2,
+    SIGQUIT: 3,
+    SIGKILL: 9,
+    SIGTERM: 15,
+    SIGCONT: 18,
+    SIGSTOP: 19,
+};
+function resolveSignal(signal) {
+    if (typeof signal === "number") {
+        return signal;
+    }
+    if (signal in linuxSignalMapping) {
+        return linuxSignalMapping[signal];
+    }
+    throw new Error(`Unknown signal name: ${String(signal)}`);
+}
+//# sourceMappingURL=resolveSignal.js.map

package/web/node_modules/@vercel/sandbox/dist/utils/types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrivateParams = void 0;
+/**
+ * Extract private parameters out of an object.
+ */
+const getPrivateParams = (params) => {
+    const privateEntries = Object.entries(params ?? {}).filter(([k]) => k.startsWith("__"));
+    return Object.fromEntries(privateEntries);
+};
+exports.getPrivateParams = getPrivateParams;
+//# sourceMappingURL=types.js.map

package/web/node_modules/@vercel/sandbox/dist/version.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+// Autogenerated by inject-version.ts
+exports.VERSION = "1.9.0";
+//# sourceMappingURL=version.js.map

package/web/node_modules/@vercel/sandbox/node_modules/zod/lib/ZodError.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZodError = exports.quotelessJson = exports.ZodIssueCode = void 0;
+const util_1 = require("./helpers/util");
+exports.ZodIssueCode = util_1.util.arrayToEnum([
+    "invalid_type",
+    "invalid_literal",
+    "custom",
+    "invalid_union",
+    "invalid_union_discriminator",
+    "invalid_enum_value",
+    "unrecognized_keys",
+    "invalid_arguments",
+    "invalid_return_type",
+    "invalid_date",
+    "invalid_string",
+    "too_small",
+    "too_big",
+    "invalid_intersection_types",
+    "not_multiple_of",
+    "not_finite",
+]);
+const quotelessJson = (obj) => {
+    const json = JSON.stringify(obj, null, 2);
+    return json.replace(/"([^"]+)":/g, "$1:");
+};
+exports.quotelessJson = quotelessJson;
+class ZodError extends Error {
+    get errors() {
+        return this.issues;
+    }
+    constructor(issues) {
+        super();
+        this.issues = [];
+        this.addIssue = (sub) => {
+            this.issues = [...this.issues, sub];
+        };
+        this.addIssues = (subs = []) => {
+            this.issues = [...this.issues, ...subs];
+        };
+        const actualProto = new.target.prototype;
+        if (Object.setPrototypeOf) {
+            // eslint-disable-next-line ban/ban
+            Object.setPrototypeOf(this, actualProto);
+        }
+        else {
+            this.__proto__ = actualProto;
+        }
+        this.name = "ZodError";
+        this.issues = issues;
+    }
+    format(_mapper) {
+        const mapper = _mapper ||
+            function (issue) {
+                return issue.message;
+            };
+        const fieldErrors = { _errors: [] };
+        const processError = (error) => {
+            for (const issue of error.issues) {
+                if (issue.code === "invalid_union") {
+                    issue.unionErrors.map(processError);
+                }
+                else if (issue.code === "invalid_return_type") {
+                    processError(issue.returnTypeError);
+                }
+                else if (issue.code === "invalid_arguments") {
+                    processError(issue.argumentsError);
+                }
+                else if (issue.path.length === 0) {
+                    fieldErrors._errors.push(mapper(issue));
+                }
+                else {
+                    let curr = fieldErrors;
+                    let i = 0;
+                    while (i < issue.path.length) {
+                        const el = issue.path[i];
+                        const terminal = i === issue.path.length - 1;
+                        if (!terminal) {
+                            curr[el] = curr[el] || { _errors: [] };
+                            // if (typeof el === "string") {
+                            //   curr[el] = curr[el] || { _errors: [] };
+                            // } else if (typeof el === "number") {
+                            //   const errorArray: any = [];
+                            //   errorArray._errors = [];
+                            //   curr[el] = curr[el] || errorArray;
+                            // }
+                        }
+                        else {
+                            curr[el] = curr[el] || { _errors: [] };
+                            curr[el]._errors.push(mapper(issue));
+                        }
+                        curr = curr[el];
+                        i++;
+                    }
+                }
+            }
+        };
+        processError(this);
+        return fieldErrors;
+    }
+    static assert(value) {
+        if (!(value instanceof ZodError)) {
+            throw new Error(`Not a ZodError: ${value}`);
+        }
+    }
+    toString() {
+        return this.message;
+    }
+    get message() {
+        return JSON.stringify(this.issues, util_1.util.jsonStringifyReplacer, 2);
+    }
+    get isEmpty() {
+        return this.issues.length === 0;
+    }
+    flatten(mapper = (issue) => issue.message) {
+        const fieldErrors = {};
+        const formErrors = [];
+        for (const sub of this.issues) {
+            if (sub.path.length > 0) {
+                fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
+                fieldErrors[sub.path[0]].push(mapper(sub));
+            }
+            else {
+                formErrors.push(mapper(sub));
+            }
+        }
+        return { formErrors, fieldErrors };
+    }
+    get formErrors() {
+        return this.flatten();
+    }
+}
+exports.ZodError = ZodError;
+ZodError.create = (issues) => {
+    const error = new ZodError(issues);
+    return error;
+};