@rio-cloud/cdk-v2-constructs 9.0.0-alpha.8 → 9.0.0

package/lib/fargate/trace-sampling.d.ts

@@ -0,0 +1,87 @@
+import type * as constructs from 'constructs';
+/**
+ * The trace sampling strategy used by the Fargate Datadog integration.
+ */
+export declare enum TraceSamplingMode {
+    /**
+     * Use RIO's per-Agent head-sampling target of 5 traces/sec and an additional
+     * error-sampling budget of 10 local error trace chunks/sec.
+     * Target-per-second sampling is a practical default for both low- and
+     * high-traffic services.
+     */
+    DEFAULT = 0,
+    /** Do not set sampling environment variables; retain Datadog's defaults. */
+    DATADOG_DEFAULT = 1,
+    /** Set a fixed sampling rule on the application tracer. */
+    FIXED_RATE = 2,
+    /** Set a per-Agent target number of traces per second. */
+    TARGET_PER_SECOND = 3
+}
+/**
+ * Use RIO's default Datadog Agent sampling targets.
+ *
+ * This is also the default when `traceSampling` is omitted.
+ */
+export interface RioDefaultTraceSamplingOptions {
+    /**
+     * The sampling strategy. May be omitted to use the default.
+     *
+     * @defaultValue - `TraceSamplingMode.DEFAULT`
+     */
+    readonly mode?: TraceSamplingMode.DEFAULT;
+}
+/** Do not set sampling environment variables; retain Datadog's defaults. */
+export interface DatadogDefaultTraceSamplingOptions {
+    /** The sampling strategy. */
+    readonly mode: TraceSamplingMode.DATADOG_DEFAULT;
+}
+/** Configure a fixed application-tracer sampling rate. */
+export interface FixedRateTraceSamplingOptions {
+    /** The sampling strategy. */
+    readonly mode: TraceSamplingMode.FIXED_RATE;
+    /**
+     * The global tracer sampling-rule rate, from 0.0 to 1.0 inclusive.
+     * Datadog tracers additionally apply their built-in 100-traces-per-second
+     * rate limit when sampling rules are configured. This construct does not
+     * expose or override that per-instance safeguard.
+     */
+    readonly fixedRate: number;
+}
+/** Configure Datadog Agent target sampling. */
+export interface TargetPerSecondTraceSamplingOptions {
+    /** The sampling strategy. */
+    readonly mode: TraceSamplingMode.TARGET_PER_SECOND;
+    /**
+     * The average head-sampling target in traces per second for each Agent
+     * sidecar (and therefore each Fargate service instance). Traffic spikes
+     * can exceed this target; it is not a hard cap on total ingestion.
+     */
+    readonly targetTracesPerSecond: number;
+    /**
+     * The budget for additional local error trace chunks per second missed by
+     * head sampling, for each Agent sidecar (and therefore each Fargate service
+     * instance). This does not cap error traces already kept by head sampling.
+     */
+    readonly errorTracesPerSecond?: number;
+}
+/**
+ * Options for configuring Datadog APM trace sampling.
+ *
+ * This discriminated union makes mode-specific settings invalid in TypeScript
+ * before synthesis. Numeric ranges are checked during synthesis.
+ */
+export type TraceSamplingOptions = RioDefaultTraceSamplingOptions | DatadogDefaultTraceSamplingOptions | FixedRateTraceSamplingOptions | TargetPerSecondTraceSamplingOptions;
+export declare class TraceSamplingValidator implements constructs.IValidation {
+    private readonly traceSampling?;
+    constructor(traceSampling?: TraceSamplingOptions | undefined);
+    validate(): string[];
+}
+export declare function addTraceSamplingEnvironmentWarning(scope: constructs.Construct, environment: {
+    [key: string]: string;
+} | undefined): void;
+export declare function getApplicationTraceSamplingEnvironment(traceSampling?: TraceSamplingOptions): {
+    [key: string]: string;
+};
+export declare function getAgentTraceSamplingEnvironment(traceSampling?: TraceSamplingOptions): {
+    [key: string]: string;
+};

package/lib/fargate/trace-sampling.js

@@ -0,0 +1,123 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraceSamplingValidator = exports.TraceSamplingMode = void 0;
+exports.addTraceSamplingEnvironmentWarning = addTraceSamplingEnvironmentWarning;
+exports.getApplicationTraceSamplingEnvironment = getApplicationTraceSamplingEnvironment;
+exports.getAgentTraceSamplingEnvironment = getAgentTraceSamplingEnvironment;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdk = require("aws-cdk-lib");
+/**
+ * The trace sampling strategy used by the Fargate Datadog integration.
+ */
+var TraceSamplingMode;
+(function (TraceSamplingMode) {
+    /**
+     * Use RIO's per-Agent head-sampling target of 5 traces/sec and an additional
+     * error-sampling budget of 10 local error trace chunks/sec.
+     * Target-per-second sampling is a practical default for both low- and
+     * high-traffic services.
+     */
+    TraceSamplingMode[TraceSamplingMode["DEFAULT"] = 0] = "DEFAULT";
+    /** Do not set sampling environment variables; retain Datadog's defaults. */
+    TraceSamplingMode[TraceSamplingMode["DATADOG_DEFAULT"] = 1] = "DATADOG_DEFAULT";
+    /** Set a fixed sampling rule on the application tracer. */
+    TraceSamplingMode[TraceSamplingMode["FIXED_RATE"] = 2] = "FIXED_RATE";
+    /** Set a per-Agent target number of traces per second. */
+    TraceSamplingMode[TraceSamplingMode["TARGET_PER_SECOND"] = 3] = "TARGET_PER_SECOND";
+})(TraceSamplingMode || (exports.TraceSamplingMode = TraceSamplingMode = {}));
+class TraceSamplingValidator {
+    constructor(traceSampling) {
+        this.traceSampling = traceSampling;
+    }
+    validate() {
+        const options = this.traceSampling;
+        if (!options) {
+            return [];
+        }
+        // Keep validating the runtime shape: JavaScript consumers and TypeScript
+        // callers using a cast can bypass the discriminated union.
+        const values = options;
+        const mode = values.mode ?? TraceSamplingMode.DEFAULT;
+        const hasFixedRate = values.fixedRate !== undefined;
+        const hasTargetTps = values.targetTracesPerSecond !== undefined;
+        const hasErrorTps = values.errorTracesPerSecond !== undefined;
+        const errors = [];
+        const isNonNegativeInteger = (value) => value !== undefined && Number.isInteger(value) && value >= 0;
+        if (mode === TraceSamplingMode.DEFAULT || mode === TraceSamplingMode.DATADOG_DEFAULT) {
+            if (hasFixedRate || hasTargetTps || hasErrorTps) {
+                errors.push(`${TraceSamplingMode[mode]} does not accept fixedRate, targetTracesPerSecond, or errorTracesPerSecond.`);
+            }
+        }
+        else if (mode === TraceSamplingMode.FIXED_RATE) {
+            const fixedRate = values.fixedRate;
+            if (!hasFixedRate ||
+                fixedRate === undefined ||
+                !Number.isFinite(fixedRate) ||
+                fixedRate < 0.0 ||
+                fixedRate > 1.0) {
+                errors.push('FIXED_RATE requires fixedRate to be a number between 0 and 1 inclusive.');
+            }
+            if (hasTargetTps) {
+                errors.push('FIXED_RATE does not accept targetTracesPerSecond.');
+            }
+            if (hasErrorTps) {
+                errors.push('FIXED_RATE does not accept errorTracesPerSecond.');
+            }
+        }
+        else if (mode === TraceSamplingMode.TARGET_PER_SECOND) {
+            if (!isNonNegativeInteger(values.targetTracesPerSecond)) {
+                errors.push('TARGET_PER_SECOND requires targetTracesPerSecond to be a non-negative integer.');
+            }
+            if (hasFixedRate) {
+                errors.push('TARGET_PER_SECOND does not accept fixedRate.');
+            }
+            if (hasErrorTps && !isNonNegativeInteger(values.errorTracesPerSecond)) {
+                errors.push('TARGET_PER_SECOND errorTracesPerSecond must be a non-negative integer.');
+            }
+        }
+        else {
+            errors.push('traceSampling.mode must be a TraceSamplingMode value.');
+        }
+        return errors;
+    }
+}
+exports.TraceSamplingValidator = TraceSamplingValidator;
+_a = JSII_RTTI_SYMBOL_1;
+TraceSamplingValidator[_a] = { fqn: "@rio-cloud-internal/cdk-v2-constructs.TraceSamplingValidator", version: "0.0.0" };
+function addTraceSamplingEnvironmentWarning(scope, environment) {
+    const samplingKeys = ['DD_TRACE_SAMPLING_RULES', 'DD_TRACE_SAMPLE_RATE', 'DD_APM_TARGET_TPS', 'DD_APM_ERROR_TPS'];
+    const configuredKeys = samplingKeys.filter(key => environment && key in environment);
+    if (configuredKeys.length > 0) {
+        cdk.Validations.of(scope).addWarning('@rio-cloud/cdk-v2-constructs:directTraceSamplingEnvironment', [
+            `Direct trace-sampling environment variable(s) detected: ${configuredKeys.join(', ')}.`,
+            'Recommended action: remove these variables to use the DEFAULT sampling policy.',
+            'To select a different policy, configure datadogOptions.traceSampling explicitly.',
+            'Direct sampling environment variables remain supported only for backwards compatibility. Users who choose them are responsible for their compatibility and maintenance.',
+        ].join('\n'));
+    }
+}
+function getApplicationTraceSamplingEnvironment(traceSampling) {
+    if (traceSampling?.mode === TraceSamplingMode.FIXED_RATE) {
+        const rules = [{ sample_rate: traceSampling.fixedRate }];
+        return { DD_TRACE_SAMPLING_RULES: JSON.stringify(rules) };
+    }
+    return {};
+}
+function getAgentTraceSamplingEnvironment(traceSampling) {
+    if (traceSampling?.mode === undefined || traceSampling.mode === TraceSamplingMode.DEFAULT) {
+        return { DD_APM_TARGET_TPS: '5', DD_APM_ERROR_TPS: '10' };
+    }
+    if (traceSampling?.mode === TraceSamplingMode.TARGET_PER_SECOND) {
+        const environment = {};
+        if (traceSampling.targetTracesPerSecond !== undefined) {
+            environment.DD_APM_TARGET_TPS = String(traceSampling.targetTracesPerSecond);
+        }
+        if (traceSampling.errorTracesPerSecond !== undefined) {
+            environment.DD_APM_ERROR_TPS = String(traceSampling.errorTracesPerSecond);
+        }
+        return environment;
+    }
+    return {};
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trace-sampling.js","sourceRoot":"","sources":["../../src/fargate/trace-sampling.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport type * as constructs from 'constructs';\n\n/**\n * The trace sampling strategy used by the Fargate Datadog integration.\n */\nexport enum TraceSamplingMode {\n  /**\n   * Use RIO's per-Agent head-sampling target of 5 traces/sec and an additional\n   * error-sampling budget of 10 local error trace chunks/sec.\n   * Target-per-second sampling is a practical default for both low- and\n   * high-traffic services.\n   */\n  DEFAULT,\n\n  /** Do not set sampling environment variables; retain Datadog's defaults. */\n  DATADOG_DEFAULT,\n\n  /** Set a fixed sampling rule on the application tracer. */\n  FIXED_RATE,\n\n  /** Set a per-Agent target number of traces per second. */\n  TARGET_PER_SECOND,\n}\n\n/**\n * Use RIO's default Datadog Agent sampling targets.\n *\n * This is also the default when `traceSampling` is omitted.\n */\nexport interface RioDefaultTraceSamplingOptions {\n  /**\n   * The sampling strategy. May be omitted to use the default.\n   *\n   * @defaultValue - `TraceSamplingMode.DEFAULT`\n   */\n  readonly mode?: TraceSamplingMode.DEFAULT;\n}\n\n/** Do not set sampling environment variables; retain Datadog's defaults. */\nexport interface DatadogDefaultTraceSamplingOptions {\n  /** The sampling strategy. */\n  readonly mode: TraceSamplingMode.DATADOG_DEFAULT;\n}\n\n/** Configure a fixed application-tracer sampling rate. */\nexport interface FixedRateTraceSamplingOptions {\n  /** The sampling strategy. */\n  readonly mode: TraceSamplingMode.FIXED_RATE;\n\n  /**\n   * The global tracer sampling-rule rate, from 0.0 to 1.0 inclusive.\n   * Datadog tracers additionally apply their built-in 100-traces-per-second\n   * rate limit when sampling rules are configured. This construct does not\n   * expose or override that per-instance safeguard.\n   */\n  readonly fixedRate: number;\n}\n\n/** Configure Datadog Agent target sampling. */\nexport interface TargetPerSecondTraceSamplingOptions {\n  /** The sampling strategy. */\n  readonly mode: TraceSamplingMode.TARGET_PER_SECOND;\n\n  /**\n   * The average head-sampling target in traces per second for each Agent\n   * sidecar (and therefore each Fargate service instance). Traffic spikes\n   * can exceed this target; it is not a hard cap on total ingestion.\n   */\n  readonly targetTracesPerSecond: number;\n\n  /**\n   * The budget for additional local error trace chunks per second missed by\n   * head sampling, for each Agent sidecar (and therefore each Fargate service\n   * instance). This does not cap error traces already kept by head sampling.\n   */\n  readonly errorTracesPerSecond?: number;\n}\n\n/**\n * Options for configuring Datadog APM trace sampling.\n *\n * This discriminated union makes mode-specific settings invalid in TypeScript\n * before synthesis. Numeric ranges are checked during synthesis.\n */\nexport type TraceSamplingOptions =\n  | RioDefaultTraceSamplingOptions\n  | DatadogDefaultTraceSamplingOptions\n  | FixedRateTraceSamplingOptions\n  | TargetPerSecondTraceSamplingOptions;\n\n/** The untrusted runtime shape used by synthesis-time validation. */\ntype TraceSamplingValues = {\n  readonly mode?: TraceSamplingMode;\n  readonly fixedRate?: number;\n  readonly targetTracesPerSecond?: number;\n  readonly errorTracesPerSecond?: number;\n};\n\nexport class TraceSamplingValidator implements constructs.IValidation {\n  constructor(private readonly traceSampling?: TraceSamplingOptions) {}\n\n  validate(): string[] {\n    const options = this.traceSampling;\n    if (!options) {\n      return [];\n    }\n\n    // Keep validating the runtime shape: JavaScript consumers and TypeScript\n    // callers using a cast can bypass the discriminated union.\n    const values = options as TraceSamplingValues;\n    const mode = values.mode ?? TraceSamplingMode.DEFAULT;\n    const hasFixedRate = values.fixedRate !== undefined;\n    const hasTargetTps = values.targetTracesPerSecond !== undefined;\n    const hasErrorTps = values.errorTracesPerSecond !== undefined;\n    const errors: string[] = [];\n    const isNonNegativeInteger = (value: number | undefined) =>\n      value !== undefined && Number.isInteger(value) && value >= 0;\n\n    if (mode === TraceSamplingMode.DEFAULT || mode === TraceSamplingMode.DATADOG_DEFAULT) {\n      if (hasFixedRate || hasTargetTps || hasErrorTps) {\n        errors.push(\n          `${TraceSamplingMode[mode]} does not accept fixedRate, targetTracesPerSecond, or errorTracesPerSecond.`\n        );\n      }\n    } else if (mode === TraceSamplingMode.FIXED_RATE) {\n      const fixedRate = values.fixedRate;\n      if (\n        !hasFixedRate ||\n        fixedRate === undefined ||\n        !Number.isFinite(fixedRate) ||\n        fixedRate < 0.0 ||\n        fixedRate > 1.0\n      ) {\n        errors.push('FIXED_RATE requires fixedRate to be a number between 0 and 1 inclusive.');\n      }\n      if (hasTargetTps) {\n        errors.push('FIXED_RATE does not accept targetTracesPerSecond.');\n      }\n      if (hasErrorTps) {\n        errors.push('FIXED_RATE does not accept errorTracesPerSecond.');\n      }\n    } else if (mode === TraceSamplingMode.TARGET_PER_SECOND) {\n      if (!isNonNegativeInteger(values.targetTracesPerSecond)) {\n        errors.push('TARGET_PER_SECOND requires targetTracesPerSecond to be a non-negative integer.');\n      }\n      if (hasFixedRate) {\n        errors.push('TARGET_PER_SECOND does not accept fixedRate.');\n      }\n      if (hasErrorTps && !isNonNegativeInteger(values.errorTracesPerSecond)) {\n        errors.push('TARGET_PER_SECOND errorTracesPerSecond must be a non-negative integer.');\n      }\n    } else {\n      errors.push('traceSampling.mode must be a TraceSamplingMode value.');\n    }\n\n    return errors;\n  }\n}\n\nexport function addTraceSamplingEnvironmentWarning(\n  scope: constructs.Construct,\n  environment: { [key: string]: string } | undefined\n): void {\n  const samplingKeys = ['DD_TRACE_SAMPLING_RULES', 'DD_TRACE_SAMPLE_RATE', 'DD_APM_TARGET_TPS', 'DD_APM_ERROR_TPS'];\n  const configuredKeys = samplingKeys.filter(key => environment && key in environment);\n  if (configuredKeys.length > 0) {\n    cdk.Validations.of(scope).addWarning(\n      '@rio-cloud/cdk-v2-constructs:directTraceSamplingEnvironment',\n      [\n        `Direct trace-sampling environment variable(s) detected: ${configuredKeys.join(', ')}.`,\n        'Recommended action: remove these variables to use the DEFAULT sampling policy.',\n        'To select a different policy, configure datadogOptions.traceSampling explicitly.',\n        'Direct sampling environment variables remain supported only for backwards compatibility. Users who choose them are responsible for their compatibility and maintenance.',\n      ].join('\\n')\n    );\n  }\n}\n\nexport function getApplicationTraceSamplingEnvironment(traceSampling?: TraceSamplingOptions): {\n  [key: string]: string;\n} {\n  if (traceSampling?.mode === TraceSamplingMode.FIXED_RATE) {\n    const rules = [{ sample_rate: traceSampling.fixedRate }];\n    return { DD_TRACE_SAMPLING_RULES: JSON.stringify(rules) };\n  }\n  return {};\n}\n\nexport function getAgentTraceSamplingEnvironment(traceSampling?: TraceSamplingOptions): { [key: string]: string } {\n  if (traceSampling?.mode === undefined || traceSampling.mode === TraceSamplingMode.DEFAULT) {\n    return { DD_APM_TARGET_TPS: '5', DD_APM_ERROR_TPS: '10' };\n  }\n  if (traceSampling?.mode === TraceSamplingMode.TARGET_PER_SECOND) {\n    const environment: { [key: string]: string } = {};\n    if (traceSampling.targetTracesPerSecond !== undefined) {\n      environment.DD_APM_TARGET_TPS = String(traceSampling.targetTracesPerSecond);\n    }\n    if (traceSampling.errorTracesPerSecond !== undefined) {\n      environment.DD_APM_ERROR_TPS = String(traceSampling.errorTracesPerSecond);\n    }\n    return environment;\n  }\n  return {};\n}\n"]}

package/lib/sbom-catalog/lambda/handler.cjs

@@ -38779,6 +38779,7 @@ __export(util_exports, {
   required: () => required,
   safeExtend: () => safeExtend,
   shallowClone: () => shallowClone,
+  sizeCaps: () => sizeCaps,
   slugify: () => slugify,
   stringifyPrimitive: () => stringifyPrimitive,
   toZod: () => toZod,
@@ -39298,6 +39299,18 @@ function prefixIssues(path, issues) {
 function unwrapMessage(message) {
   return typeof message === "string" ? message : message?.message;
 }
+function sizeCaps(defChecks) {
+  const caps = [];
+  for (const ch of defChecks ?? []) {
+    const d5 = ch._zod.def;
+    if (!/_(length|size)$|_equals$/.test(d5.check))
+      break;
+    const max = d5.maximum ?? d5.length ?? d5.size;
+    if (max >= 0)
+      caps.push([max, ch]);
+  }
+  return caps;
+}
 function attachSchema(issues, start, inst) {
   var _a4;
   for (let i5 = start; i5 < issues.length; i5++) {
@@ -40219,7 +40232,7 @@ ${content.join("\n")}
 var version = {
   major: 4,
   minor: 6,
-  patch: 5
+  patch: 7
 };
 
 // node_modules/zod/v4/core/schemas.js
@@ -40727,6 +40740,29 @@ var $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => {
     return payload;
   };
 });
+function capSize(inst, size) {
+  const caps = sizeCaps(inst._zod.def.checks);
+  if (!caps.length)
+    return;
+  const cap = Math.min(...caps.map((c5) => c5[0]));
+  const parse3 = inst._zod.parse;
+  inst._zod.parse = (payload, ctx) => {
+    const n3 = size(payload.value);
+    if (n3 > cap && !ctx?.skipChecks && ctx?.direction !== "backward") {
+      for (const [max, ch] of sizeCaps(inst._zod.def.checks)) {
+        if (n3 > max && ch._zod.def.when(payload)) {
+          const start = payload.issues.length;
+          ch._zod.check(payload);
+          payload.issues[start].continue = false;
+          attachSchema(payload.issues, start, inst);
+          return payload;
+        }
+      }
+    }
+    return parse3(payload, ctx);
+  };
+}
+var arraySize = (input) => Array.isArray(input) ? input.length : -1;
 function handleArrayResult(result, final, index) {
   if (result.issues.length) {
     final.issues.push(...prefixIssues(index, result.issues));
@@ -40770,6 +40806,7 @@ var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
     }
     return payload;
   };
+  capSize(inst, arraySize);
 });
 function handlePropertyResult(result, final, key, input, optin, optout) {
   const isPresent = key in input;

package/node_modules/zod/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.6.5",
+  "version": "4.6.7",
   "type": "module",
   "license": "MIT",
   "author": "Colin McDonnell <zod@colinhacks.com>",

package/node_modules/zod/src/v4/classic/tests/array.test.ts

@@ -140,6 +140,33 @@ test("continue parsing despite array size error", () => {
   `);
 });
 
+test("an upper size bound fails before any element is parsed", () => {
+  let parsed = 0;
+  const el = z.string().refine(() => ++parsed);
+  let refined = 0;
+  const schema = z
+    .array(el)
+    .max(2, "too many")
+    .refine(() => ++refined);
+  expect(schema.safeParse([1, 2, 3]).error!.issues).toMatchObject([{ code: "too_big", path: [], message: "too many" }]);
+  expect(z.array(el).length(2).safeParse(["a", "b", "c"]).error!.issues).toMatchObject([
+    { code: "too_big", exact: true },
+  ]);
+  expect(z.object({ a: z.array(el).max(1) }).safeParse({ a: [1, 2] }).error!.issues).toMatchObject([
+    { code: "too_big", path: ["a"] },
+  ]);
+  expect([parsed, refined]).toEqual([0, 0]);
+
+  // a check that may rewrite the value ends the gate
+  expect(
+    z
+      .array(z.number())
+      .overwrite((a) => a.slice(0, 2))
+      .max(2)
+      .parse([1, 2, 3])
+  ).toEqual([1, 2]);
+});
+
 test("parse should fail given sparse array", () => {
   const schema = z.array(z.string()).nonempty().min(1).max(3);
   const result = schema.safeParse(new Array(3));

package/node_modules/zod/src/v4/classic/tests/map.test.ts

@@ -97,6 +97,13 @@ test("failing when map is bigger than max() ", () => {
   expect(result.success).toEqual(false);
   expect(result.error!.issues.length).toEqual(1);
   expect(result.error!.issues[0].code).toEqual("too_big");
+  const bad = new Map([
+    [1, 1],
+    [2, 2],
+  ]);
+  const capped = z.map(z.string(), z.string()).max(1);
+  expect(capped.safeParse(bad).error!.issues).toMatchObject([{ code: "too_big" }]);
+  expect(capped.safeParse(new Set([1, 2])).error!.issues[0]).toMatchObject({ code: "invalid_type", expected: "map" });
 });
 
 test("failing when map does not match size() ", () => {

package/node_modules/zod/src/v4/classic/tests/set.test.ts

@@ -83,6 +83,12 @@ test("failing when set is bigger than max() ", () => {
   expect(result.success).toEqual(false);
   expect(result.error!.issues.length).toEqual(1);
   expect(result.error!.issues[0].code).toEqual("too_big");
+  expect(
+    z
+      .set(z.string())
+      .max(1)
+      .safeParse(new Set([1, 2])).error!.issues
+  ).toMatchObject([{ code: "too_big" }]);
 });
 
 test("failing when set does not match size() ", () => {

package/node_modules/zod/src/v4/core/compile.ts

@@ -1551,6 +1551,12 @@ function generateNullableCheck(
   return outputVar;
 }
 
+function generateSizeGate(doc: Doc, schema: SomeType, size: string): void {
+  for (const [max, check] of util.sizeCaps(schema._zod.def.checks)) {
+    doc.write(`if (${size} > ${numericOperand(max, check._zod.def.check)}) return INVALID;`);
+  }
+}
+
 function generateArrayCheck(
   doc: Doc,
   ctx: CompileContext,
@@ -1560,6 +1566,7 @@ function generateArrayCheck(
 ): string | null {
   const def = schema._zod.def as unknown as { element: SomeType };
   doc.write(`if (!Array.isArray(${accessor})) return INVALID;`);
+  generateSizeGate(doc, schema, `${accessor}.length`);
 
   // Build a new array with validated/transformed elements.
   const outputVar = buildsValue ? newVar(ctx) : null;
@@ -2094,6 +2101,7 @@ function generateMapCheck(doc: Doc, ctx: CompileContext, schema: SomeType, acces
   const def = schema._zod.def as unknown as { keyType: SomeType; valueType: SomeType };
 
   doc.write(`if (!(${accessor} instanceof Map)) return INVALID;`);
+  generateSizeGate(doc, schema, `${accessor}.size`);
 
   const outputVar = newVar(ctx);
   const kVar = newVar(ctx);
@@ -2115,6 +2123,7 @@ function generateSetCheck(doc: Doc, ctx: CompileContext, schema: SomeType, acces
   const def = schema._zod.def as unknown as { valueType: SomeType };
 
   doc.write(`if (!(${accessor} instanceof Set)) return INVALID;`);
+  generateSizeGate(doc, schema, `${accessor}.size`);
 
   const outputVar = newVar(ctx);
   const valVar = newVar(ctx);

package/node_modules/zod/src/v4/core/schemas.ts

@@ -1844,6 +1844,34 @@ export interface $ZodArrayInternals<T extends SomeType = $ZodType> extends _$Zod
 
 export interface $ZodArray<T extends SomeType = $ZodType> extends $ZodType<any, any, $ZodArrayInternals<T>> {}
 
+// an oversized container fails its leading size checks before any element is parsed
+function capSize(inst: $ZodType, size: (input: any) => number): void {
+  const caps = util.sizeCaps(inst._zod.def.checks);
+  if (!caps.length) return;
+  const cap = Math.min(...caps.map((c) => c[0]));
+  const parse = inst._zod.parse;
+  inst._zod.parse = (payload, ctx) => {
+    const n = size(payload.value);
+    if (n > cap && !ctx?.skipChecks && ctx?.direction !== "backward") {
+      for (const [max, ch] of util.sizeCaps(inst._zod.def.checks)) {
+        if (n > max && ch._zod.def.when!(payload)) {
+          const start = payload.issues.length;
+          ch._zod.check(payload as ParsePayload<never>);
+          // the value is still the raw input, so no later check may read it
+          (payload.issues[start] as { continue?: boolean }).continue = false;
+          util.attachSchema(payload.issues, start, inst);
+          return payload;
+        }
+      }
+    }
+    return parse(payload, ctx);
+  };
+}
+
+const arraySize = (input: unknown): number => (Array.isArray(input) ? input.length : -1);
+const mapSize = (input: unknown): number => (input instanceof Map ? input.size : -1);
+const setSize = (input: unknown): number => (input instanceof Set ? input.size : -1);
+
 function handleArrayResult(result: ParsePayload<any>, final: ParsePayload<any[]>, index: number) {
   if (result.issues.length) {
     final.issues.push(...util.prefixIssues(index, result.issues));
@@ -1899,6 +1927,7 @@ export const $ZodArray: core.$constructor<$ZodArray> = /*@__PURE__*/ core.$const
 
     return payload; //handleArrayResultsAsync(parseResults, final);
   };
+  capSize(inst, arraySize);
 });
 
 //////////////////////////////////////////
@@ -3218,8 +3247,11 @@ export type $InferZodRecordInput<
     : Record<core.input<Key> & PropertyKey, core.input<Value>>;
 
 export interface $ZodRecordInternals<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType>
-  extends $ZodTypeInternals<$InferZodRecordOutput<Key, Value>, $InferZodRecordInput<Key, Value>> {
+  extends $ZodTypeInternals {
   def: $ZodRecordDef<Key, Value>;
+  // members rather than base type arguments, which TypeScript 7.1 reports as circular for `z.json()`
+  output: $InferZodRecordOutput<Key, Value>;
+  input: $InferZodRecordInput<Key, Value>;
   isst: errors.$ZodIssueInvalidType | errors.$ZodIssueInvalidKey<Record<PropertyKey, unknown>>;
   optin?: "optional" | undefined;
   optout?: "optional" | undefined;
@@ -3480,6 +3512,7 @@ export const $ZodMap: core.$constructor<$ZodMap> = /*@__PURE__*/ core.$construct
     if (proms.length) return Promise.all(proms).then(() => payload);
     return payload;
   };
+  capSize(inst, mapSize);
 });
 
 function handleMapResult(
@@ -3582,6 +3615,7 @@ export const $ZodSet: core.$constructor<$ZodSet> = /*@__PURE__*/ core.$construct
     if (proms.length) return Promise.all(proms).then(() => payload);
     return payload;
   };
+  capSize(inst, setSize);
 });
 
 function handleSetResult(result: ParsePayload, final: ParsePayload<Set<any>>) {

package/node_modules/zod/src/v4/core/util.ts

@@ -935,6 +935,19 @@ export function unwrapMessage(message: string | { message: string } | undefined
 }
 
 /* A check holds no link back to the schema it is attached to — the same check instance is shared by every clone of that schema — so the owner is stamped onto the issues a check just raised, at the only point where both are in scope. Runs on the failure path only; `start` is the issue count from before the check ran. */
+/** The leading size checks of `defChecks` that set an upper bound, each paired with it. */
+export function sizeCaps(defChecks: checks.$ZodCheck<never>[] | undefined): [number, checks.$ZodCheck<never>][] {
+  const caps: [number, checks.$ZodCheck<never>][] = [];
+  for (const ch of defChecks ?? []) {
+    const d = ch._zod.def as any;
+    // a later check may rewrite the value
+    if (!/_(length|size)$|_equals$/.test(d.check)) break;
+    const max = d.maximum ?? d.length ?? d.size;
+    if (max >= 0) caps.push([max, ch]);
+  }
+  return caps;
+}
+
 export function attachSchema(issues: errors.$ZodRawIssue[], start: number, inst: schemas.$ZodType): void {
   for (let i = start; i < issues.length; i++) {
     (issues[i] as any).schema ??= inst;

package/node_modules/zod/src/v4/core/versions.ts

@@ -1,5 +1,5 @@
 export const version = {
   major: 4,
   minor: 6,
-  patch: 5 as number,
+  patch: 7 as number,
 } as const;

package/node_modules/zod/v4/core/compile.cjs

@@ -1241,9 +1241,15 @@ function generateNullableCheck(doc, ctx, schema, accessor, buildsValue = true) {
     doc.write(`}`);
     return outputVar;
 }
+function generateSizeGate(doc, schema, size) {
+    for (const [max, check] of util.sizeCaps(schema._zod.def.checks)) {
+        doc.write(`if (${size} > ${numericOperand(max, check._zod.def.check)}) return INVALID;`);
+    }
+}
 function generateArrayCheck(doc, ctx, schema, accessor, buildsValue = true) {
     const def = schema._zod.def;
     doc.write(`if (!Array.isArray(${accessor})) return INVALID;`);
+    generateSizeGate(doc, schema, `${accessor}.length`);
     // Build a new array with validated/transformed elements.
     const outputVar = buildsValue ? newVar(ctx) : null;
     const iVar = newVar(ctx);
@@ -1707,6 +1713,7 @@ function literalPropertyKey(ctx, key) {
 function generateMapCheck(doc, ctx, schema, accessor) {
     const def = schema._zod.def;
     doc.write(`if (!(${accessor} instanceof Map)) return INVALID;`);
+    generateSizeGate(doc, schema, `${accessor}.size`);
     const outputVar = newVar(ctx);
     const kVar = newVar(ctx);
     const valVar = newVar(ctx);
@@ -1723,6 +1730,7 @@ function generateMapCheck(doc, ctx, schema, accessor) {
 function generateSetCheck(doc, ctx, schema, accessor) {
     const def = schema._zod.def;
     doc.write(`if (!(${accessor} instanceof Set)) return INVALID;`);
+    generateSizeGate(doc, schema, `${accessor}.size`);
     const outputVar = newVar(ctx);
     const valVar = newVar(ctx);
     doc.write(`const ${outputVar} = new Set();`);

package/node_modules/zod/v4/core/compile.js

@@ -1210,9 +1210,15 @@ function generateNullableCheck(doc, ctx, schema, accessor, buildsValue = true) {
     doc.write(`}`);
     return outputVar;
 }
+function generateSizeGate(doc, schema, size) {
+    for (const [max, check] of util.sizeCaps(schema._zod.def.checks)) {
+        doc.write(`if (${size} > ${numericOperand(max, check._zod.def.check)}) return INVALID;`);
+    }
+}
 function generateArrayCheck(doc, ctx, schema, accessor, buildsValue = true) {
     const def = schema._zod.def;
     doc.write(`if (!Array.isArray(${accessor})) return INVALID;`);
+    generateSizeGate(doc, schema, `${accessor}.length`);
     // Build a new array with validated/transformed elements.
     const outputVar = buildsValue ? newVar(ctx) : null;
     const iVar = newVar(ctx);
@@ -1676,6 +1682,7 @@ function literalPropertyKey(ctx, key) {
 function generateMapCheck(doc, ctx, schema, accessor) {
     const def = schema._zod.def;
     doc.write(`if (!(${accessor} instanceof Map)) return INVALID;`);
+    generateSizeGate(doc, schema, `${accessor}.size`);
     const outputVar = newVar(ctx);
     const kVar = newVar(ctx);
     const valVar = newVar(ctx);
@@ -1692,6 +1699,7 @@ function generateMapCheck(doc, ctx, schema, accessor) {
 function generateSetCheck(doc, ctx, schema, accessor) {
     const def = schema._zod.def;
     doc.write(`if (!(${accessor} instanceof Set)) return INVALID;`);
+    generateSizeGate(doc, schema, `${accessor}.size`);
     const outputVar = newVar(ctx);
     const valVar = newVar(ctx);
     doc.write(`const ${outputVar} = new Set();`);

package/node_modules/zod/v4/core/schemas.cjs

@@ -860,6 +860,33 @@ exports.$ZodDate = core.$constructor("$ZodDate", (inst, def) => {
         return payload;
     };
 });
+// an oversized container fails its leading size checks before any element is parsed
+function capSize(inst, size) {
+    const caps = util.sizeCaps(inst._zod.def.checks);
+    if (!caps.length)
+        return;
+    const cap = Math.min(...caps.map((c) => c[0]));
+    const parse = inst._zod.parse;
+    inst._zod.parse = (payload, ctx) => {
+        const n = size(payload.value);
+        if (n > cap && !ctx?.skipChecks && ctx?.direction !== "backward") {
+            for (const [max, ch] of util.sizeCaps(inst._zod.def.checks)) {
+                if (n > max && ch._zod.def.when(payload)) {
+                    const start = payload.issues.length;
+                    ch._zod.check(payload);
+                    // the value is still the raw input, so no later check may read it
+                    payload.issues[start].continue = false;
+                    util.attachSchema(payload.issues, start, inst);
+                    return payload;
+                }
+            }
+        }
+        return parse(payload, ctx);
+    };
+}
+const arraySize = (input) => (Array.isArray(input) ? input.length : -1);
+const mapSize = (input) => (input instanceof Map ? input.size : -1);
+const setSize = (input) => (input instanceof Set ? input.size : -1);
 function handleArrayResult(result, final, index) {
     if (result.issues.length) {
         final.issues.push(...util.prefixIssues(index, result.issues));
@@ -905,6 +932,7 @@ exports.$ZodArray = core.$constructor("$ZodArray", (inst, def) => {
         }
         return payload; //handleArrayResultsAsync(parseResults, final);
     };
+    capSize(inst, arraySize);
 });
 function handlePropertyResult(result, final, key, input, optin, optout) {
     const isPresent = key in input;
@@ -1942,6 +1970,7 @@ exports.$ZodMap = core.$constructor("$ZodMap", (inst, def) => {
             return Promise.all(proms).then(() => payload);
         return payload;
     };
+    capSize(inst, mapSize);
 });
 function handleMapResult(keyResult, valueResult, final, key, input, inst, ctx) {
     if (keyResult.issues.length) {
@@ -2011,6 +2040,7 @@ exports.$ZodSet = core.$constructor("$ZodSet", (inst, def) => {
             return Promise.all(proms).then(() => payload);
         return payload;
     };
+    capSize(inst, setSize);
 });
 function handleSetResult(result, final) {
     if (result.issues.length) {

package/node_modules/zod/v4/core/schemas.d.cts

@@ -834,8 +834,10 @@ export type $InferZodRecordOutput<Key extends $ZodRecordKey = $ZodRecordKey, Val
 export type $InferZodRecordInput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<core.input<Key> & PropertyKey, core.input<Value>>> : [
     Value
 ] extends [OptionalInSchema] ? Partial<Record<core.input<Key> & PropertyKey, core.input<Value>>> : Record<core.input<Key> & PropertyKey, core.input<Value>>;
-export interface $ZodRecordInternals<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeInternals<$InferZodRecordOutput<Key, Value>, $InferZodRecordInput<Key, Value>> {
+export interface $ZodRecordInternals<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeInternals {
     def: $ZodRecordDef<Key, Value>;
+    output: $InferZodRecordOutput<Key, Value>;
+    input: $InferZodRecordInput<Key, Value>;
     isst: errors.$ZodIssueInvalidType | errors.$ZodIssueInvalidKey<Record<PropertyKey, unknown>>;
     optin?: "optional" | undefined;
     optout?: "optional" | undefined;