@fuzdev/fuz_app 0.148.0 → 0.149.0

package/dist/testing/schema_generators.js

@@ -12,34 +12,78 @@ import { z } from 'zod';
 import { zod_unwrap_def, zod_get_base_type, zod_unwrap_to_object, zod_extract_fields } from '../zod.js';
 import { is_null_schema } from '../http/schema_helpers.js';
 /**
- * Detect format constraints on a field by converting to JSON Schema.
- * Returns format string (e.g. 'uuid', 'email') or null.
+ * The JSON Schema of a field's input side — where its format, pattern and
+ * bounds live — or `null` when JSON Schema can't render the field or any part
+ * of it (`z.date()`, `z.custom()`, a union with a `z.date()` branch).
+ *
+ * Rendered with `io: 'input'`, so a field carrying a `.transform()` or a pipe
+ * (`Username`) still yields the constraints its input is checked against;
+ * the default output side throws on a transform. A pipe yields its input
+ * side only, so constraints of the stage after it are not here. A
+ * `.nullable()` / `.nullish()` field renders as
+ * `anyOf: [{…}, {type: 'null'}]`; its one non-null branch is returned, so
+ * the bounds and pattern read the same as on the bare field. A union of two
+ * or more non-null branches returns the whole schema — its branches' bounds
+ * are no single field's bounds.
+ *
+ * A `.refine()` is never here: JSON Schema can't express one, so a bound a
+ * refinement enforces (a code-point length, a cross-field rule) generates no
+ * boundary case.
+ *
+ * @param field_schema - the field to read
+ * @returns the field's input-side JSON Schema, or `null` when it can't be rendered
  */
-export const detect_format = (field_schema) => {
+export const to_field_json_schema = (field_schema) => {
+    let json;
     try {
-        const json = z.toJSONSchema(field_schema);
-        if (typeof json.format === 'string')
-            return json.format;
-        if (typeof json.pattern === 'string')
-            return 'pattern';
-        // `.nullish()` / `.nullable()` produce `anyOf: [{format, …}, {type: 'null'}]`
-        // — descend into the first non-null branch so format/pattern surface.
-        if (Array.isArray(json.anyOf)) {
-            for (const branch of json.anyOf) {
-                if (branch.type === 'null')
-                    continue;
-                if (typeof branch.format === 'string')
-                    return branch.format;
-                if (typeof branch.pattern === 'string')
-                    return 'pattern';
-            }
-        }
+        json = z.toJSONSchema(field_schema, { io: 'input' });
     }
     catch {
-        // schema can't be converted, no format
+        return null; // a type JSON Schema can't represent
+    }
+    if (Array.isArray(json.anyOf)) {
+        const branches = json.anyOf.filter((branch) => branch.type !== 'null');
+        if (branches.length === 1)
+            return branches[0];
+    }
+    return json;
+};
+/**
+ * The format constraint a field's input-side JSON Schema carries: its
+ * `format` (e.g. `'uuid'`, `'email'`), `'pattern'` for a regex, or `null`.
+ * A union (`anyOf` of several non-null branches) answers its first branch
+ * carrying one — a value violating every branch is what the caller needs,
+ * and the generators check the field refuses the candidate.
+ *
+ * @param json - a field's JSON Schema, as `to_field_json_schema` returns it
+ * @returns the format, `'pattern'`, or `null`
+ */
+export const detect_json_schema_format = (json) => {
+    if (typeof json.format === 'string')
+        return json.format;
+    if (typeof json.pattern === 'string')
+        return 'pattern';
+    if (Array.isArray(json.anyOf)) {
+        for (const branch of json.anyOf) {
+            if (branch.type === 'null')
+                continue;
+            if (typeof branch.format === 'string')
+                return branch.format;
+            if (typeof branch.pattern === 'string')
+                return 'pattern';
+        }
     }
     return null;
 };
+/**
+ * Detect format constraints on a field from its input-side JSON Schema
+ * (`to_field_json_schema`). Returns the format string (e.g. `'uuid'`,
+ * `'email'`), `'pattern'` for a regex, or `null`.
+ */
+export const detect_format = (field_schema) => {
+    const json = to_field_json_schema(field_schema);
+    return json && detect_json_schema_format(json);
+};
 /**
  * Extract a candidate value from a JSON Schema `pattern` when the shape is a
  * fixed-length hex character class, optionally behind a literal prefix —
@@ -110,8 +154,8 @@ const generate_valid_string = (field_schema) => {
     let min_length = 0;
     let max_length = Infinity;
     let pattern = null;
-    try {
-        const json = z.toJSONSchema(field_schema);
+    const json = to_field_json_schema(field_schema);
+    if (json) {
         if (typeof json.minLength === 'number')
             min_length = json.minLength;
         if (typeof json.maxLength === 'number')
@@ -119,9 +163,6 @@ const generate_valid_string = (field_schema) => {
         if (typeof json.pattern === 'string')
             pattern = json.pattern;
     }
-    catch {
-        // no constraints
-    }
     const target = Math.max(min_length, Math.min(10, max_length));
     const base = 'x'.repeat(target) || 'test_value';
     // Validate against the full schema (including refinements/brands).
@@ -155,6 +196,10 @@ const generate_valid_string = (field_schema) => {
     const as_url = 'https://example.com/' + base;
     if (field_schema.safeParse(as_url).success)
         return as_url;
+    // Two-segment path refinement (an `owner/name` repo slug)
+    const segments = `${base}/${base}`;
+    if (field_schema.safeParse(segments).success)
+        return segments;
     return base; // fall through — generate_valid_body will report the failure
 };
 /** Generate a valid-ish value for a field based on its base type. */
@@ -180,8 +225,8 @@ export const generate_valid_value = (field, field_schema) => {
                 if (field_schema.safeParse(candidate).success)
                     return candidate;
             }
-            try {
-                const json = z.toJSONSchema(field_schema);
+            const json = to_field_json_schema(field_schema);
+            if (json) {
                 if (typeof json.minimum === 'number')
                     return Math.ceil(json.minimum);
                 if (typeof json.exclusiveMinimum === 'number')
@@ -191,23 +236,13 @@ export const generate_valid_value = (field, field_schema) => {
                 if (typeof json.exclusiveMaximum === 'number')
                     return Math.ceil(json.exclusiveMaximum) - 1;
             }
-            catch {
-                // no bounds to read
-            }
             return 1; // fall through — generate_valid_body will report the failure
         }
         case 'boolean':
             return true;
         case 'array': {
-            let min_items = 0;
-            try {
-                const json = z.toJSONSchema(field_schema);
-                if (typeof json.minItems === 'number')
-                    min_items = json.minItems;
-            }
-            catch {
-                // no constraint
-            }
+            const json = to_field_json_schema(field_schema);
+            const min_items = typeof json?.minItems === 'number' ? json.minItems : 0;
             if (min_items === 0)
                 return [];
             const def = zod_unwrap_def(field_schema);
@@ -222,18 +257,13 @@ export const generate_valid_value = (field, field_schema) => {
             return Array.from({ length: min_items }, () => item);
         }
         case 'object': {
-            // Recursively generate valid nested objects
+            // recurse with the same optional-field fallback as the top level, so a
+            // nested `.refine()` over optional fields (exactly-one-of) is satisfied;
+            // a nested object that still fails is returned as built, and the
+            // top-level parse reports it
             const nested_schema = zod_unwrap_to_object(field_schema);
-            if (nested_schema) {
-                const nested_fields = zod_extract_fields(nested_schema);
-                const nested = {};
-                for (const nf of nested_fields) {
-                    if (!nf.required && !nf.has_default)
-                        continue;
-                    nested[nf.name] = generate_valid_value(nf, nested_schema.shape[nf.name]);
-                }
-                return nested;
-            }
+            if (nested_schema)
+                return generate_valid_object(nested_schema, field_schema).value;
             return {};
         }
         case 'null':
@@ -284,6 +314,166 @@ export const generate_valid_value = (field, field_schema) => {
             return 'test_value';
     }
 };
+/**
+ * Generate a valid object for an object schema: its required and defaulted
+ * fields first; when `schema` still refuses it, each optional field alone on
+ * top of those, in declaration order, taking the first that parses; and
+ * failing that, the optional fields added one at a time, in declaration
+ * order, until it parses. The fill covers a `.refine()` over optional fields
+ * (at least one of, exactly one of, both of), which the required-only object
+ * can't satisfy, and the single-field pass keeps an unrelated optional field
+ * declared ahead of the refined ones (an `acting`, a note) out of the object.
+ *
+ * Shared by the top-level body generators and `generate_valid_value`'s
+ * nested-object case, so a refined object validates the same way at any depth.
+ *
+ * @param object_schema - the unwrapped object whose fields are generated
+ * @param schema - the schema the object must satisfy, refinements included
+ *   (`object_schema` or a schema wrapping it)
+ * @returns the generated object and its last `safeParse` result — the caller
+ *   decides whether a failure throws
+ */
+export const generate_valid_object = (object_schema, schema) => {
+    const base = {};
+    const optional = [];
+    for (const field of zod_extract_fields(object_schema)) {
+        const value = generate_valid_value(field, object_schema.shape[field.name]);
+        if (is_optional_field(field))
+            optional.push([field.name, value]);
+        else
+            base[field.name] = value;
+    }
+    return fill_optional_fields(schema, base, optional);
+};
+/** A field the object may omit — optional and without a default Zod fills. */
+const is_optional_field = (field) => !field.required && !field.has_default;
+/**
+ * `start` as is when `schema` accepts it; else `start` plus each candidate
+ * alone, in order, taking the first that parses; else the candidates added
+ * one at a time, in order, until it parses.
+ *
+ * @param schema - the schema the object must satisfy
+ * @param start - the fields every result keeps
+ * @param candidates - optional fields and their values, in declaration order
+ * @returns the object and its last `safeParse` result
+ */
+const fill_optional_fields = (schema, start, candidates) => {
+    let result = schema.safeParse(start);
+    if (result.success)
+        return { value: start, result };
+    // each optional field alone, so one the refinement doesn't need stays out
+    for (const [name, field_value] of candidates) {
+        const value = { ...start, [name]: field_value };
+        const single_result = schema.safeParse(value);
+        if (single_result.success)
+            return { value, result: single_result };
+    }
+    // then cumulatively, for a refinement needing several
+    const value = { ...start };
+    for (const [name, field_value] of candidates) {
+        value[name] = field_value;
+        result = schema.safeParse(value);
+        if (result.success)
+            break;
+    }
+    return { value, result };
+};
+/**
+ * A valid object that carries `field`, built from `base`, a valid object of
+ * `object_schema` — the body a case breaking `field` changes, so the case
+ * breaks that field and nothing else. `base` itself when it carries the
+ * field. Otherwise the field takes a generated value and joins `base`, with
+ * the optional fields `base` omits filled as `generate_valid_object` fills
+ * them (a pair rule: adding `scope_kind` needs `scope_id`); failing that, it
+ * replaces `base`'s optional fields, refilled the same way around it (an
+ * exactly-one-of rule: adding `slug` means dropping `id`).
+ *
+ * @param object_schema - the unwrapped object `base` is an instance of
+ * @param schema - the schema the object must satisfy, refinements included
+ * @param base - a valid object, the generated or seeded base
+ * @param field - the field the object must carry
+ * @returns the object, or `null` when no object the generator can build
+ *   carries the field and passes `schema`
+ */
+export const generate_valid_object_with_field = (object_schema, schema, base, field) => {
+    if (Object.hasOwn(base, field.name))
+        return base;
+    const fields = zod_extract_fields(object_schema);
+    const value_of = (f) => Object.hasOwn(base, f.name)
+        ? base[f.name]
+        : generate_valid_value(f, object_schema.shape[f.name]);
+    const field_value = value_of(field);
+    // the field joins the base, which keeps its optional fields
+    const absent = fields
+        .filter((f) => f.name !== field.name && is_optional_field(f) && !Object.hasOwn(base, f.name))
+        .map((f) => [f.name, value_of(f)]);
+    const joined = fill_optional_fields(schema, { ...base, [field.name]: field_value }, absent);
+    if (joined.result.success)
+        return joined.value;
+    // the field in place of the base's optional fields, which are refilled around it
+    const optional_names = new Set(fields.filter(is_optional_field).map((f) => f.name));
+    const core = {};
+    for (const [k, v] of Object.entries(base)) {
+        if (!optional_names.has(k))
+            core[k] = v;
+    }
+    core[field.name] = field_value;
+    const others = fields
+        .filter((f) => f.name !== field.name && is_optional_field(f))
+        .map((f) => [f.name, value_of(f)]);
+    const replaced = fill_optional_fields(schema, core, others);
+    return replaced.result.success ? replaced.value : null;
+};
+const NIL_UUID = '00000000-0000-0000-0000-000000000000';
+/**
+ * A string a URL-sourced field accepts — a route param or a query value, which
+ * arrive as strings whatever the schema parses them into. The nil UUID for a
+ * UUID field; else the first the field accepts of `test_value`, the generated
+ * valid value written as a string, `1`, `0`, `true` and `false`, the field's
+ * JSON Schema `default` or lower bound written as a string (a preprocessed
+ * integer whose minimum is above one), and a string synthesized from the
+ * field's constraints.
+ *
+ * @param field - the field's info, from `zod_extract_fields`
+ * @param field_schema - the field's schema
+ * @returns the string, or `null` when no candidate passes
+ */
+export const generate_valid_string_param = (field, field_schema) => {
+    const candidates = [];
+    if (field.base_type === 'uuid' || detect_format(field_schema) === 'uuid') {
+        candidates.push(NIL_UUID);
+    }
+    candidates.push('test_value');
+    const generated = generate_valid_value(field, field_schema);
+    if (typeof generated === 'string' ||
+        typeof generated === 'number' ||
+        typeof generated === 'boolean') {
+        candidates.push(String(generated));
+    }
+    candidates.push('1', '0', 'true', 'false');
+    // a number the URL string is preprocessed into: its default or its lower bound
+    const json = to_field_json_schema(field_schema);
+    if (json) {
+        const fallback = json.default;
+        if (typeof fallback === 'number' || typeof fallback === 'string') {
+            candidates.push(String(fallback));
+        }
+        if (typeof json.minimum === 'number')
+            candidates.push(String(Math.ceil(json.minimum)));
+        if (typeof json.exclusiveMinimum === 'number') {
+            candidates.push(String(Math.floor(json.exclusiveMinimum) + 1));
+        }
+    }
+    candidates.push(generate_valid_string(field_schema));
+    return candidates.find((c) => field_schema.safeParse(c).success) ?? null;
+};
+/**
+ * Format Zod issues as `path: message` pairs for a generator's error message.
+ *
+ * @param error - the failed parse's error
+ * @returns the issues, comma-separated
+ */
+export const format_zod_issues = (error) => error.issues.map((i) => `${i.path.join('.')}: ${i.message}`).join(', ');
 /**
  * The `Content-Type` a well-formed request to a route sends: `application/json`,
  * or `application/octet-stream` for a `raw_body` route. Every `POST` route
@@ -351,32 +541,10 @@ export const generate_valid_body = (input_schema) => {
     const object_schema = zod_unwrap_to_object(input_schema);
     if (!object_schema)
         return undefined;
-    const fields = zod_extract_fields(object_schema);
-    const body = {};
-    for (const field of fields) {
-        if (!field.required && !field.has_default)
-            continue;
-        body[field.name] = generate_valid_value(field, object_schema.shape[field.name]);
-    }
-    let result = input_schema.safeParse(body);
-    if (!result.success) {
-        // Fallback for schemas with a top-level `.refine()` that requires at
-        // least one of N optional fields. Fill optional fields until the body
-        // satisfies validation.
-        for (const field of fields) {
-            if (field.required || field.has_default || field.name in body)
-                continue;
-            body[field.name] = generate_valid_value(field, object_schema.shape[field.name]);
-            result = input_schema.safeParse(body);
-            if (result.success)
-                break;
-        }
-    }
+    const { value, result } = generate_valid_object(object_schema, input_schema);
     if (!result.success) {
         throw new Error(`generate_valid_body: generated body fails validation — ` +
-            `fix generate_valid_value for: ${result.error.issues
-                .map((i) => `${i.path.join('.')}: ${i.message}`)
-                .join(', ')}`);
+            `fix generate_valid_value for: ${format_zod_issues(result.error)}`);
     }
-    return body;
+    return value;
 };

package/dist/testing/stubs.d.ts

@@ -64,9 +64,10 @@ export declare const stub_mw: (_c: any, next: any) => Promise<void>;
  * wires a listener fails loudly instead of silently never firing
  * (`create_recording_audit_emitter` accepts listeners); `listener_count`
  * returns 0; `drain_inflight` resolves immediately, since nothing is ever
- * written. Tests asserting on real audit-row persistence (or on listener
- * fan-out) build a real emitter via `create_audit_emitter` against a stub or
- * real DB — `create_test_app` already does this on the test backend.
+ * written, and `is_tracking_inflight` answers `false`. Tests asserting on
+ * real audit-row persistence (or on listener fan-out) build a real emitter
+ * via `create_audit_emitter` against a stub or real DB — `create_test_app`
+ * already does this on the test backend.
  */
 export declare const create_test_audit_emitter: () => AuditEmitter;
 /**

package/dist/testing/stubs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stubs.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/stubs.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"stubs.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/stubs.ts"],"names":[],"mappings":"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"}

package/dist/testing/stubs.js

@@ -102,9 +102,10 @@ const stub_db = create_noop_stub('stub_db');
  * wires a listener fails loudly instead of silently never firing
  * (`create_recording_audit_emitter` accepts listeners); `listener_count`
  * returns 0; `drain_inflight` resolves immediately, since nothing is ever
- * written. Tests asserting on real audit-row persistence (or on listener
- * fan-out) build a real emitter via `create_audit_emitter` against a stub or
- * real DB — `create_test_app` already does this on the test backend.
+ * written, and `is_tracking_inflight` answers `false`. Tests asserting on
+ * real audit-row persistence (or on listener fan-out) build a real emitter
+ * via `create_audit_emitter` against a stub or real DB — `create_test_app`
+ * already does this on the test backend.
  */
 export const create_test_audit_emitter = () => ({
     emit: () => { },
@@ -115,7 +116,8 @@ export const create_test_audit_emitter = () => ({
         throw new Error('create_test_audit_emitter accepts no listeners — use create_recording_audit_emitter');
     },
     listener_count: () => 0,
-    drain_inflight: async () => { }
+    drain_inflight: async () => { },
+    is_tracking_inflight: () => false
 });
 /**
  * Build a no-op `AuditLogSse` for tests that wire `audit_sse` into the

package/dist/zod.d.ts

@@ -30,6 +30,15 @@ export declare const zod_get_base_type: (schema: z.ZodType) => string;
  * @returns the innermost non-wrapper schema
  */
 export declare const zod_get_innermost_type: (schema: z.ZodType) => z.ZodType;
+/**
+ * Every layer of a schema, from the schema itself through each wrapper
+ * (optional, nullable, default, transform, pipe, prefault) to the innermost
+ * non-wrapper — for reading `.meta()` a wrapper does not carry over from the
+ * schema it wraps.
+ *
+ * @returns the layers, outermost first, ending at `zod_get_innermost_type(schema)`
+ */
+export declare const zod_get_schema_layers: (schema: z.ZodType) => Array<z.ZodType>;
 /**
  * Get all property keys from an object schema, unwrapping wrappers.
  * Returns an empty array if the innermost type is not an object.

package/dist/zod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zod.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/zod.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgC7B;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,CAAC,CAAC,IAAI,CAAC,WAOzD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,MAAqC,CAAC;AAgC5F;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,CAAC,CAAC,OAM5D,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,CAAC,CAAC,OAAO,EACtD,QAAQ,CAAC,KACP,KAAK,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,MAAM,CAGjC,CAAC;AAaF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAAI,QAAQ,CAAC,CAAC,OAAO,EAAE,KAAK,MAAM,KAAG,CAAC,CAAC,OAIvE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,CAAC,CAAC,SAAS,GAAG,IAUtE,CAAC;AAIF,qEAAqE;AACrE,MAAM,WAAW,YAAY;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;IACrB,QAAQ,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAAI,QAAQ,CAAC,CAAC,SAAS,KAAG,KAAK,CAAC,YAAY,CAa1E,CAAC"}
+{"version":3,"file":"zod.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/zod.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgC7B;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,CAAC,CAAC,IAAI,CAAC,WAOzD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,MAAqC,CAAC;AAgC5F;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,CAAC,CAAC,OAM5D,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,KAAK,CAAC,CAAC,CAAC,OAAO,CAUxE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,CAAC,CAAC,OAAO,EACtD,QAAQ,CAAC,KACP,KAAK,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,MAAM,CAGjC,CAAC;AAaF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAAI,QAAQ,CAAC,CAAC,OAAO,EAAE,KAAK,MAAM,KAAG,CAAC,CAAC,OAIvE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAAI,QAAQ,CAAC,CAAC,OAAO,KAAG,CAAC,CAAC,SAAS,GAAG,IAUtE,CAAC;AAIF,qEAAqE;AACrE,MAAM,WAAW,YAAY;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;IACrB,QAAQ,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAAI,QAAQ,CAAC,CAAC,SAAS,KAAG,KAAK,CAAC,YAAY,CAa1E,CAAC"}

package/dist/zod.js

@@ -104,6 +104,26 @@ export const zod_get_innermost_type = (schema) => {
     }
     return schema;
 };
+/**
+ * Every layer of a schema, from the schema itself through each wrapper
+ * (optional, nullable, default, transform, pipe, prefault) to the innermost
+ * non-wrapper — for reading `.meta()` a wrapper does not carry over from the
+ * schema it wraps.
+ *
+ * @returns the layers, outermost first, ending at `zod_get_innermost_type(schema)`
+ */
+export const zod_get_schema_layers = (schema) => {
+    const layers = [schema];
+    let s = schema;
+    while (ZOD_WRAPPER_TYPES.has(s.def.type)) {
+        const sub = zod_to_subschema(s.def);
+        if (!sub)
+            break;
+        layers.push(sub);
+        s = sub;
+    }
+    return layers;
+};
 /**
  * Get all property keys from an object schema, unwrapping wrappers.
  * Returns an empty array if the innermost type is not an object.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fuzdev/fuz_app",
-  "version": "0.148.0",
+  "version": "0.149.0",
   "description": "fullstack app library",
   "glyph": "🗝",
   "logo": "logo.svg",