@plumix/core 0.6.0 → 0.7.0

package/dist/rpc/meta/field-pipeline.js

@@ -0,0 +1,501 @@
+import { EMAIL_REGEX } from "valibot";
+import { HEX_COLOR } from "../../plugin/fields/color.js";
+import { parseLinkValue } from "../../plugin/fields/link.js";
+import { SAFE_HREF_RE, walkRichtextDoc, } from "../../plugin/fields/richtext-validate.js";
+import { formatTemporalValue, isTemporalInputType, isValidTemporalValue, } from "../../plugin/manifest.js";
+import { META_FIELD_MESSAGES } from "./field-messages.js";
+/**
+ * Run one value through the per-field write pipeline: coercion →
+ * `.sanitize()` → declarative constraints → `.validate()`. Never
+ * throws for value problems — they come back as `{ path, message }`
+ * errors the RPC layer aggregates across the whole patch.
+ */
+export async function runFieldPipeline(field, raw, path, mode = "strict") {
+    if (raw === null || raw === undefined) {
+        if (field.required && mode === "strict") {
+            return { errors: [{ path, message: META_FIELD_MESSAGES.required }] };
+        }
+        return { errors: [], isDeletion: true };
+    }
+    // `.returns("date")` hands the admin form a `Date`, and an untouched
+    // field comes back as one on save — encode it to the field's stored
+    // ISO shape (from UTC components) before the string coercion
+    // rejects it.
+    if (raw instanceof Date && isTemporalInputType(field.inputType)) {
+        if (Number.isNaN(raw.getTime())) {
+            return { errors: [{ path, message: META_FIELD_MESSAGES.invalid }] };
+        }
+        raw = formatTemporalValue(field.inputType, raw);
+    }
+    // Same round-trip reality for references: reads hydrate to
+    // `{ id, ... }` payloads and untouched fields come back as them —
+    // heal to the stored plain-id shape before coercion rejects the
+    // object. Repeater cells recurse through here, so nested refs heal
+    // too.
+    const target = referenceTargetOf(field);
+    if (target)
+        raw = healReferenceValue(target, raw);
+    const coerced = coerceValue(field.type, raw);
+    if (!coerced.ok) {
+        return { errors: [{ path, message: META_FIELD_MESSAGES.invalid }] };
+    }
+    if (isRepeaterField(field)) {
+        return runRepeaterPipeline(field, coerced.value, path, mode);
+    }
+    if (isGroupField(field)) {
+        return runGroupPipeline(field, coerced.value, path, mode);
+    }
+    // Structural normalization is part of coercion: it runs before the
+    // author's `.sanitize()` so the callback can trust its typed
+    // parameter (a `LinkValue`, a `string[]` of option values, …).
+    const normalized = normalizeValue(field, coerced.value, path);
+    if (!normalized.ok)
+        return { errors: [normalized.error] };
+    let value = normalized.value;
+    if (field.sanitize) {
+        try {
+            value = field.sanitize(value);
+        }
+        catch (error) {
+            // Buggy callbacks round to a generic `invalid` for the editor;
+            // keep the diagnostic trail in the server log.
+            console.error(`[plumix] sanitize callback for meta field ${JSON.stringify(path)} threw:`, error);
+            return { errors: [{ path, message: META_FIELD_MESSAGES.invalid }] };
+        }
+        // Re-normalize the callback's output — the shape gates (link URL
+        // safety, hex format, option-array shape) are declared constraints,
+        // and a transform must not be able to smuggle a value past them.
+        const renormalized = normalizeValue(field, value, path);
+        if (!renormalized.ok)
+            return { errors: [renormalized.error] };
+        value = renormalized.value;
+    }
+    if (field.required && mode === "strict" && isEmptyValue(value)) {
+        return { errors: [{ path, message: META_FIELD_MESSAGES.required }] };
+    }
+    const constraintErrors = checkConstraints(field, value, path, mode);
+    if (constraintErrors.length > 0)
+        return { errors: constraintErrors };
+    if (field.validate && mode === "strict") {
+        try {
+            const verdict = await field.validate(value);
+            if (verdict !== true) {
+                return { errors: [{ path, message: verdict }] };
+            }
+        }
+        catch (error) {
+            console.error(`[plumix] validate callback for meta field ${JSON.stringify(path)} threw:`, error);
+            return { errors: [{ path, message: META_FIELD_MESSAGES.invalid }] };
+        }
+    }
+    return { errors: [], value };
+}
+// --- repeater rows ------------------------------------------------------
+// Hard ceiling on row count regardless of field-level `max`. The 256 KiB
+// meta byte cap doesn't bound work pre-walk: a payload of N empty rows
+// allocates O(N) before the byte cap measures the post-strip output.
+const MAX_REPEATER_ROWS = 1000;
+export function isRepeaterField(field) {
+    return field?.inputType === "repeater" && "subFields" in field;
+}
+export function isGroupField(field) {
+    return field?.inputType === "group" && "fields" in field;
+}
+// --- group members ------------------------------------------------------
+/**
+ * Recurse the pipeline into each member of a group, addressing errors
+ * by `${path}.${memberKey}` (nested repeaters/groups extend the path
+ * further). A group all of whose members read empty is dropped (a
+ * deletion) unless the group is `.required()`. Members are stored back
+ * as a nested object keyed by member field key — no key-flattening.
+ */
+async function runGroupPipeline(field, value, path, mode) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return { errors: [{ path, message: META_FIELD_MESSAGES.invalid }] };
+    }
+    const source = value;
+    // Mirrors the repeater's blank-row strip, and must run BEFORE member
+    // validation: an all-empty group is an authoring affordance, not data,
+    // so it's dropped (optional) or rejected at the group path (required)
+    // without ever validating members. Otherwise a `.required()` member on
+    // an untouched optional group would error and make the group
+    // impossible to clear. "Empty" is strictly `null` / `undefined` / `""`
+    // per `isBlankRow`; `0` / `false` are real values.
+    if (isBlankRow(field.fields, source)) {
+        if (field.required === true && mode === "strict") {
+            return { errors: [{ path, message: META_FIELD_MESSAGES.required }] };
+        }
+        return { errors: [], isDeletion: true };
+    }
+    // A populated group keeps every member (blank cells included) and
+    // validates each — a required member left empty in a non-empty group
+    // is a real error, just as in a non-blank repeater row.
+    const errors = [];
+    const next = {};
+    for (const member of field.fields) {
+        const cell = await runFieldPipeline(member, source[member.key], `${path}.${member.key}`, mode);
+        errors.push(...cell.errors);
+        if (cell.errors.length === 0 && cell.isDeletion !== true) {
+            next[member.key] = cell.value;
+        }
+    }
+    if (errors.length > 0)
+        return { errors };
+    return { errors: [], value: next };
+}
+// --- reference healing --------------------------------------------------
+export function referenceTargetOf(field) {
+    if (!field)
+        return undefined;
+    return field
+        .referenceTarget;
+}
+/**
+ * Returns the `id` string of a `{ id: string, ... }` object, or null
+ * for any other shape (string, array, null, primitive, missing key).
+ */
+export function extractStringId(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return null;
+    }
+    const id = value.id;
+    return typeof id === "string" ? id : null;
+}
+/**
+ * Collapse a reference slot to the stored plain-id shape: hydrated
+ * payloads (and legacy write-time snapshots) read/write as their `id`;
+ * already-plain values pass through identity-preserving.
+ */
+export function healReferenceValue(target, value) {
+    if (target.multiple) {
+        if (!Array.isArray(value))
+            return value;
+        // Identity-preserving on the already-plain path — `healRepeaterRow`
+        // clones a row only when the healed slot differs.
+        if (!value.some((item) => extractStringId(item) !== null)) {
+            return value;
+        }
+        return value.map((item) => extractStringId(item) ?? item);
+    }
+    return extractStringId(value) ?? value;
+}
+// A row every cell of which reads empty is an authoring affordance, not
+// data the caller meant to persist — stripped before validation, so a
+// required subfield never blocks saving over a blank row. `0` and
+// `false` are real values; only `null` / `undefined` / `""` are blank.
+function isBlankRow(subFields, row) {
+    return subFields.every((sf) => {
+        const cell = row[sf.key];
+        return cell === null || cell === undefined || cell === "";
+    });
+}
+/**
+ * Recurse the pipeline into each kept row's cells. Error paths use the
+ * caller's ORIGINAL row indices — the admin form still shows the blank
+ * rows the strip removed, so a post-strip index would address the
+ * wrong input. Row-count bounds apply to the kept rows.
+ */
+async function runRepeaterPipeline(field, value, path, mode) {
+    if (!Array.isArray(value) || value.length > MAX_REPEATER_ROWS) {
+        return { errors: [{ path, message: META_FIELD_MESSAGES.invalid }] };
+    }
+    const errors = [];
+    const rows = [];
+    for (const [idx, rawRow] of value.entries()) {
+        if (rawRow === null ||
+            typeof rawRow !== "object" ||
+            Array.isArray(rawRow)) {
+            // Anchor on the repeater itself — the admin renders no message
+            // slot at the bare row path, and only non-form callers can send
+            // a non-object row anyway.
+            errors.push({ path, message: META_FIELD_MESSAGES.invalid });
+            continue;
+        }
+        const rowObj = rawRow;
+        if (isBlankRow(field.subFields, rowObj))
+            continue;
+        const next = {};
+        for (const sf of field.subFields) {
+            const cell = await runFieldPipeline(sf, rowObj[sf.key], `${path}.${String(idx)}.${sf.key}`, mode);
+            errors.push(...cell.errors);
+            if (cell.errors.length === 0 && cell.isDeletion !== true) {
+                next[sf.key] = cell.value;
+            }
+        }
+        rows.push(next);
+    }
+    // Row counts are business rules — a draft may be mid-authoring with too
+    // few (or a transient too many) rows. Cell-level structural errors above
+    // still surface in draft mode.
+    if (mode === "strict") {
+        if (field.required === true && rows.length === 0) {
+            errors.push({ path, message: META_FIELD_MESSAGES.required });
+        }
+        if (field.min !== undefined && rows.length < field.min) {
+            errors.push({
+                path,
+                message: { ...META_FIELD_MESSAGES.minRows, values: { min: field.min } },
+            });
+        }
+        if (field.max !== undefined && rows.length > field.max) {
+            errors.push({
+                path,
+                message: { ...META_FIELD_MESSAGES.maxRows, values: { max: field.max } },
+            });
+        }
+    }
+    if (errors.length > 0)
+        return { errors };
+    return { errors: [], value: rows };
+}
+function normalizeValue(field, value, path) {
+    if (field.inputType === "color") {
+        if (typeof value !== "string" || !HEX_COLOR.test(value)) {
+            return {
+                ok: false,
+                error: { path, message: META_FIELD_MESSAGES.invalid },
+            };
+        }
+        return { ok: true, value: value.toLowerCase() };
+    }
+    if (field.inputType === "richtext") {
+        const { marks, nodes, blocks } = field;
+        try {
+            return {
+                ok: true,
+                value: walkRichtextDoc({ marks, nodes, blocks })(value),
+            };
+        }
+        catch (error) {
+            // The walker's node-level path addresses ProseMirror positions,
+            // not form inputs — the editor is one input, so the error lands
+            // on the field; the detail stays in the server log.
+            console.error(`[plumix] richtext doc for meta field ${JSON.stringify(path)} rejected:`, error);
+            return {
+                ok: false,
+                error: { path, message: META_FIELD_MESSAGES.invalid },
+            };
+        }
+    }
+    if (field.inputType === "link") {
+        const parsed = parseLinkValue(value);
+        if (parsed === null) {
+            return {
+                ok: false,
+                error: { path, message: META_FIELD_MESSAGES.invalid },
+            };
+        }
+        return { ok: true, value: parsed };
+    }
+    if (field.inputType === "select" && isMultiSelect(field)) {
+        if (!Array.isArray(value)) {
+            return {
+                ok: false,
+                error: { path, message: META_FIELD_MESSAGES.invalid },
+            };
+        }
+        const seen = new Set();
+        for (const item of value) {
+            if (typeof item !== "string") {
+                return {
+                    ok: false,
+                    error: { path, message: META_FIELD_MESSAGES.invalid },
+                };
+            }
+            seen.add(item);
+        }
+        return { ok: true, value: [...seen] };
+    }
+    return { ok: true, value };
+}
+function isMultiSelect(field) {
+    return field.multiple === true;
+}
+// --- declarative constraints -------------------------------------------
+// One walker over the field-definition union: every constraint an
+// author can declare is enforced here, keyed off the `inputType`
+// discriminator. Replaces the per-factory hand-injected sanitizers.
+function checkConstraints(field, value, path, mode) {
+    if (isTemporalInputType(field.inputType)) {
+        return checkTemporal(field.inputType, field, value, path, mode);
+    }
+    if (field.inputType === "url" && typeof value === "string") {
+        // Security gate, not a business rule — the value is destined for a
+        // rendered href, so script-bearing schemes hard-fail even in draft mode.
+        if (value !== "" && !SAFE_HREF_RE.test(value)) {
+            return [{ path, message: META_FIELD_MESSAGES.invalidUrl }];
+        }
+    }
+    // Everything below is a business-rule constraint: option membership,
+    // format, and length/count bounds. A draft may hold not-yet-valid content,
+    // so skip them — publish re-runs the bag in strict mode.
+    if (mode === "draft")
+        return [];
+    if (field.inputType === "select") {
+        const select = field;
+        if (select.options) {
+            return checkSelect(select.options, select, value, path);
+        }
+    }
+    if (field.inputType === "email" && typeof value === "string") {
+        if (value !== "" && !EMAIL_REGEX.test(value)) {
+            return [{ path, message: META_FIELD_MESSAGES.invalidEmail }];
+        }
+    }
+    const errors = [];
+    const maxLength = field.maxLength;
+    if (maxLength !== undefined &&
+        typeof value === "string" &&
+        value.length > maxLength) {
+        errors.push({
+            path,
+            message: { ...META_FIELD_MESSAGES.maxLength, values: { max: maxLength } },
+        });
+    }
+    if (typeof value === "number") {
+        const { min, max } = field;
+        if (typeof min === "number" && value < min) {
+            errors.push({
+                path,
+                message: { ...META_FIELD_MESSAGES.min, values: { min } },
+            });
+        }
+        if (typeof max === "number" && value > max) {
+            errors.push({
+                path,
+                message: { ...META_FIELD_MESSAGES.max, values: { max } },
+            });
+        }
+    }
+    return errors;
+}
+function checkSelect(options, bounds, value, path) {
+    const allowed = new Set(options.map((opt) => opt.value));
+    if (bounds.multiple === true) {
+        // `normalizeValue` guaranteed a de-duped string array (re-run on
+        // the `.sanitize()` output, so the guarantee survives transforms).
+        const items = value;
+        if (items.some((item) => !allowed.has(item))) {
+            return [{ path, message: META_FIELD_MESSAGES.invalidOption }];
+        }
+        if (bounds.max !== undefined && items.length > bounds.max) {
+            return [
+                {
+                    path,
+                    message: {
+                        ...META_FIELD_MESSAGES.maxItems,
+                        values: { max: bounds.max },
+                    },
+                },
+            ];
+        }
+        return [];
+    }
+    if (typeof value !== "string" || !allowed.has(value)) {
+        return [{ path, message: META_FIELD_MESSAGES.invalidOption }];
+    }
+    return [];
+}
+function checkTemporal(inputType, field, value, path, mode) {
+    // Shape/validity is structural — a garbage date is always rejected.
+    if (typeof value !== "string" || !isValidTemporalValue(inputType, value)) {
+        return [{ path, message: META_FIELD_MESSAGES.invalid }];
+    }
+    // Bounds are a business rule — a draft may sit outside them.
+    if (mode === "draft")
+        return [];
+    // ISO shapes compare lexicographically in temporal order, so the
+    // bounds check is a plain string comparison against the authored
+    // `min` / `max` (declared in the same stored shape).
+    const { min, max } = field;
+    const errors = [];
+    if (min !== undefined && value < min) {
+        errors.push({
+            path,
+            message: { ...META_FIELD_MESSAGES.minTemporal, values: { min } },
+        });
+    }
+    if (max !== undefined && value > max) {
+        errors.push({
+            path,
+            message: { ...META_FIELD_MESSAGES.maxTemporal, values: { max } },
+        });
+    }
+    return errors;
+}
+// `.required()` rejects the values an editor produces by clearing an
+// input: the empty string (text-family) and the empty array (multi
+// selects, lists, repeaters). `0` and `false` are real values.
+function isEmptyValue(value) {
+    if (value === "")
+        return true;
+    return Array.isArray(value) && value.length === 0;
+}
+const COERCE_FAIL = { ok: false };
+function coerceValue(type, value) {
+    switch (type) {
+        case "string":
+            return coerceString(value);
+        case "number":
+            return coerceNumber(value);
+        case "boolean":
+            return coerceBoolean(value);
+        case "json":
+            return coerceJson(value);
+    }
+}
+function coerceString(value) {
+    if (typeof value === "string")
+        return { ok: true, value };
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return { ok: true, value: String(value) };
+    }
+    if (typeof value === "boolean")
+        return { ok: true, value: String(value) };
+    return COERCE_FAIL;
+}
+function coerceNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return { ok: true, value };
+    }
+    if (typeof value === "string") {
+        // Empty string comes from cleared form inputs; the admin dispatcher
+        // already sends `null` for those, but a direct RPC caller might send
+        // "" — reject so we don't silently coerce to 0 (`Number("") === 0`).
+        if (value.trim() === "")
+            return COERCE_FAIL;
+        const parsed = Number(value);
+        if (Number.isFinite(parsed))
+            return { ok: true, value: parsed };
+    }
+    if (typeof value === "boolean")
+        return { ok: true, value: value ? 1 : 0 };
+    return COERCE_FAIL;
+}
+function coerceBoolean(value) {
+    if (typeof value === "boolean")
+        return { ok: true, value };
+    if (value === 1 || value === "1" || value === "true") {
+        return { ok: true, value: true };
+    }
+    if (value === 0 || value === "0" || value === "false") {
+        return { ok: true, value: false };
+    }
+    return COERCE_FAIL;
+}
+function coerceJson(value) {
+    // json keys take anything round-trippable through JSON.stringify —
+    // reject values that throw (BigInt) or silently drop (functions,
+    // Symbols) so reads don't hand back `undefined` for something a
+    // plugin thought it stored.
+    try {
+        const encoded = JSON.stringify(value);
+        if (encoded === undefined)
+            return COERCE_FAIL;
+        return { ok: true, value: JSON.parse(encoded) };
+    }
+    catch {
+        return COERCE_FAIL;
+    }
+}
+//# sourceMappingURL=field-pipeline.js.map

package/dist/rpc/meta/field-pipeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-pipeline.js","sourceRoot":"","sources":["../../../src/rpc/meta/field-pipeline.ts"],"names":[],"mappings":"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"}

package/dist/rpc/procedures/auth/allowed-domains/create.d.ts

@@ -40,6 +40,13 @@ export declare const create: import("@orpc/server").DecoratedProcedure<import("@
         readonly data: import("valibot").ObjectSchema<{
             readonly reason: import("valibot").StringSchema<undefined>;
             readonly key: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly errors: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly path: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").LooseObjectSchema<{
+                    readonly id: import("valibot").StringSchema<undefined>;
+                    readonly message: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                }, undefined>], undefined>;
+            }, undefined>, undefined>, undefined>;
         }, undefined>;
     };
     readonly PAYLOAD_TOO_LARGE: {

package/dist/rpc/procedures/auth/allowed-domains/create.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../../../src/rpc/procedures/auth/allowed-domains/create.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA0Bf,CAAC"}
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../../../src/rpc/procedures/auth/allowed-domains/create.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA0Bf,CAAC"}

package/dist/rpc/procedures/auth/allowed-domains/delete.d.ts

@@ -38,6 +38,13 @@ export declare const del: import("@orpc/server").DecoratedProcedure<import("@orp
         readonly data: import("valibot").ObjectSchema<{
             readonly reason: import("valibot").StringSchema<undefined>;
             readonly key: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly errors: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly path: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").LooseObjectSchema<{
+                    readonly id: import("valibot").StringSchema<undefined>;
+                    readonly message: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                }, undefined>], undefined>;
+            }, undefined>, undefined>, undefined>;
         }, undefined>;
     };
     readonly PAYLOAD_TOO_LARGE: {

package/dist/rpc/procedures/auth/allowed-domains/delete.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../../../src/rpc/procedures/auth/allowed-domains/delete.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAiBZ,CAAC"}
+{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../../../src/rpc/procedures/auth/allowed-domains/delete.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAiBZ,CAAC"}

package/dist/rpc/procedures/auth/allowed-domains/index.d.ts

@@ -37,6 +37,13 @@ export declare const allowedDomainsRouter: {
             readonly data: import("valibot").ObjectSchema<{
                 readonly reason: import("valibot").StringSchema<undefined>;
                 readonly key: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly errors: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").StringSchema<undefined>;
+                    readonly message: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").LooseObjectSchema<{
+                        readonly id: import("valibot").StringSchema<undefined>;
+                        readonly message: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    }, undefined>], undefined>;
+                }, undefined>, undefined>, undefined>;
             }, undefined>;
         };
         readonly PAYLOAD_TOO_LARGE: {
@@ -108,6 +115,13 @@ export declare const allowedDomainsRouter: {
             readonly data: import("valibot").ObjectSchema<{
                 readonly reason: import("valibot").StringSchema<undefined>;
                 readonly key: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly errors: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").StringSchema<undefined>;
+                    readonly message: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").LooseObjectSchema<{
+                        readonly id: import("valibot").StringSchema<undefined>;
+                        readonly message: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    }, undefined>], undefined>;
+                }, undefined>, undefined>, undefined>;
             }, undefined>;
         };
         readonly PAYLOAD_TOO_LARGE: {
@@ -179,6 +193,13 @@ export declare const allowedDomainsRouter: {
             readonly data: import("valibot").ObjectSchema<{
                 readonly reason: import("valibot").StringSchema<undefined>;
                 readonly key: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly errors: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").StringSchema<undefined>;
+                    readonly message: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").LooseObjectSchema<{
+                        readonly id: import("valibot").StringSchema<undefined>;
+                        readonly message: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    }, undefined>], undefined>;
+                }, undefined>, undefined>, undefined>;
             }, undefined>;
         };
         readonly PAYLOAD_TOO_LARGE: {
@@ -248,6 +269,13 @@ export declare const allowedDomainsRouter: {
             readonly data: import("valibot").ObjectSchema<{
                 readonly reason: import("valibot").StringSchema<undefined>;
                 readonly key: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly errors: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").StringSchema<undefined>;
+                    readonly message: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").LooseObjectSchema<{
+                        readonly id: import("valibot").StringSchema<undefined>;
+                        readonly message: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    }, undefined>], undefined>;
+                }, undefined>, undefined>, undefined>;
             }, undefined>;
         };
         readonly PAYLOAD_TOO_LARGE: {

package/dist/rpc/procedures/auth/allowed-domains/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/rpc/procedures/auth/allowed-domains/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKvB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/rpc/procedures/auth/allowed-domains/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKvB,CAAC"}

package/dist/rpc/procedures/auth/allowed-domains/list.d.ts

@@ -36,6 +36,13 @@ export declare const list: import("@orpc/server").DecoratedProcedure<import("@or
         readonly data: import("valibot").ObjectSchema<{
             readonly reason: import("valibot").StringSchema<undefined>;
             readonly key: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly errors: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly path: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").LooseObjectSchema<{
+                    readonly id: import("valibot").StringSchema<undefined>;
+                    readonly message: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                }, undefined>], undefined>;
+            }, undefined>, undefined>, undefined>;
         }, undefined>;
     };
     readonly PAYLOAD_TOO_LARGE: {

package/dist/rpc/procedures/auth/allowed-domains/list.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../../../src/rpc/procedures/auth/allowed-domains/list.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAWb,CAAC"}
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../../../src/rpc/procedures/auth/allowed-domains/list.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAWb,CAAC"}