@plumix/core 0.1.0

package/dist/rpc/procedures/settings/index.d.ts

@@ -0,0 +1,125 @@
+export declare const settingsRouter: {
+    readonly get: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<import("../../../index.js").AppContextBase<typeof import("../../../db/schema/index.js")> & import("../../../index.js").AppContextExtensions & Record<never, never>, import("../../../index.js").AppContextBase<typeof import("../../../db/schema/index.js")> & import("../../../index.js").AppContextExtensions & Record<never, never>, import("../../../index.js").AppContext>, import("@orpc/server").MergedCurrentContext<import("../../../index.js").AppContext, import("../../../index.js").AuthenticatedAppContext<typeof import("../../../db/schema/index.js")>>, import("valibot").ObjectSchema<{
+        readonly group: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 64, undefined>, import("valibot").RegexAction<string, "must be lowercase ASCII [a-z][a-z0-9_]*">]>;
+    }, undefined>, import("@orpc/server").Schema<Readonly<Record<string, unknown>>, Readonly<Record<string, unknown>>>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
+        readonly UNAUTHORIZED: {
+            readonly message: "Authentication required";
+        };
+        readonly BAD_REQUEST: {
+            readonly message: "Invalid input";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly reason: import("valibot").StringSchema<undefined>;
+            }, undefined>;
+        };
+        readonly FORBIDDEN: {
+            readonly message: "Permission denied";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly capability: import("valibot").StringSchema<undefined>;
+            }, undefined>;
+        };
+        readonly NOT_FOUND: {
+            readonly message: "Resource not found";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly kind: import("valibot").StringSchema<undefined>;
+                readonly id: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>;
+            }, undefined>;
+        };
+        readonly CONFLICT: {
+            readonly message: "Resource conflict";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly reason: import("valibot").StringSchema<undefined>;
+                readonly key: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+            }, undefined>;
+        };
+        readonly PAYLOAD_TOO_LARGE: {
+            readonly message: "Payload too large";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly limit: import("valibot").NumberSchema<undefined>;
+                readonly received: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+            }, undefined>;
+        };
+        readonly UNSUPPORTED_MEDIA_TYPE: {
+            readonly message: "Unsupported media type";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly mime: import("valibot").StringSchema<undefined>;
+            }, undefined>;
+        };
+        readonly INVALID_BLOCK_CONTENT: {
+            readonly message: "Block content failed registry validation";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly issues: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").StringSchema<undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                    readonly path: import("valibot").StringSchema<undefined>;
+                    readonly nodeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly attributeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly markName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+            }, undefined>;
+        };
+    }>, Record<never, never>>;
+    readonly upsert: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<import("../../../index.js").AppContextBase<typeof import("../../../db/schema/index.js")> & import("../../../index.js").AppContextExtensions & Record<never, never>, import("../../../index.js").AppContextBase<typeof import("../../../db/schema/index.js")> & import("../../../index.js").AppContextExtensions & Record<never, never>, import("../../../index.js").AppContext>, import("@orpc/server").MergedCurrentContext<import("../../../index.js").AppContext, import("../../../index.js").AuthenticatedAppContext<typeof import("../../../db/schema/index.js")>>, import("valibot").ObjectSchema<{
+        readonly group: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 64, undefined>, import("valibot").RegexAction<string, "must be lowercase ASCII [a-z][a-z0-9_]*">]>;
+        readonly values: import("valibot").SchemaWithPipe<readonly [import("valibot").RecordSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>, import("valibot").RegexAction<string, "settings value key must match [a-zA-Z0-9_:-]+">]>, import("valibot").UnknownSchema, undefined>, import("valibot").CheckAction<{
+            [x: string]: unknown;
+        }, "upsert accepts at most 200 keys per request">]>;
+    }, undefined>, import("@orpc/server").Schema<Readonly<Record<string, unknown>>, Readonly<Record<string, unknown>>>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
+        readonly UNAUTHORIZED: {
+            readonly message: "Authentication required";
+        };
+        readonly BAD_REQUEST: {
+            readonly message: "Invalid input";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly reason: import("valibot").StringSchema<undefined>;
+            }, undefined>;
+        };
+        readonly FORBIDDEN: {
+            readonly message: "Permission denied";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly capability: import("valibot").StringSchema<undefined>;
+            }, undefined>;
+        };
+        readonly NOT_FOUND: {
+            readonly message: "Resource not found";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly kind: import("valibot").StringSchema<undefined>;
+                readonly id: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>;
+            }, undefined>;
+        };
+        readonly CONFLICT: {
+            readonly message: "Resource conflict";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly reason: import("valibot").StringSchema<undefined>;
+                readonly key: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+            }, undefined>;
+        };
+        readonly PAYLOAD_TOO_LARGE: {
+            readonly message: "Payload too large";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly limit: import("valibot").NumberSchema<undefined>;
+                readonly received: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+            }, undefined>;
+        };
+        readonly UNSUPPORTED_MEDIA_TYPE: {
+            readonly message: "Unsupported media type";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly mime: import("valibot").StringSchema<undefined>;
+            }, undefined>;
+        };
+        readonly INVALID_BLOCK_CONTENT: {
+            readonly message: "Block content failed registry validation";
+            readonly data: import("valibot").ObjectSchema<{
+                readonly issues: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").StringSchema<undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                    readonly path: import("valibot").StringSchema<undefined>;
+                    readonly nodeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly attributeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly markName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+            }, undefined>;
+        };
+    }>, Record<never, never>>;
+};
+export type SettingsRouter = typeof settingsRouter;
+//# sourceMappingURL=index.d.ts.map

package/dist/rpc/procedures/settings/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/rpc/procedures/settings/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGjB,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC"}

package/dist/rpc/procedures/settings/index.js

@@ -0,0 +1,7 @@
+import { get } from "./get.js";
+import { upsert } from "./upsert.js";
+export const settingsRouter = {
+    get,
+    upsert,
+};
+//# sourceMappingURL=index.js.map

package/dist/rpc/procedures/settings/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/rpc/procedures/settings/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,GAAG;IACH,MAAM;CACE,CAAC"}

package/dist/rpc/procedures/settings/schemas.d.ts

@@ -0,0 +1,15 @@
+import * as v from "valibot";
+export declare const settingsGetInputSchema: v.ObjectSchema<{
+    readonly group: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>, v.RegexAction<string, "must be lowercase ASCII [a-z][a-z0-9_]*">]>;
+}, undefined>;
+declare const MAX_SETTINGS_VALUE_BYTES: number;
+export declare const settingsUpsertInputSchema: v.ObjectSchema<{
+    readonly group: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>, v.RegexAction<string, "must be lowercase ASCII [a-z][a-z0-9_]*">]>;
+    readonly values: v.SchemaWithPipe<readonly [v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>, v.RegexAction<string, "settings value key must match [a-zA-Z0-9_:-]+">]>, v.UnknownSchema, undefined>, v.CheckAction<{
+        [x: string]: unknown;
+    }, "upsert accepts at most 200 keys per request">]>;
+}, undefined>;
+export type SettingsGetInput = v.InferOutput<typeof settingsGetInputSchema>;
+export type SettingsUpsertInput = v.InferOutput<typeof settingsUpsertInputSchema>;
+export { MAX_SETTINGS_VALUE_BYTES };
+//# sourceMappingURL=schemas.d.ts.map

package/dist/rpc/procedures/settings/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/rpc/procedures/settings/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AA8B7B,eAAO,MAAM,sBAAsB;;aAEjC,CAAC;AASH,QAAA,MAAM,wBAAwB,QAAY,CAAC;AAG3C,eAAO,MAAM,yBAAyB;;;;;aASpC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAC5E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,WAAW,CAC7C,OAAO,yBAAyB,CACjC,CAAC;AAEF,OAAO,EAAE,wBAAwB,EAAE,CAAC"}

package/dist/rpc/procedures/settings/schemas.js

@@ -0,0 +1,33 @@
+import * as v from "valibot";
+// Group / page identifiers stay tight — lowercase snake_case ASCII so
+// they're safe in URLs (`/settings/<page>`), testids, and future
+// storage backends that may quote differently. Matches the
+// registration-time `SETTINGS_NAME_RE` in `plugin/validation/identifiers.ts`.
+const settingsNameSchema = v.pipe(v.string(), v.trim(), v.minLength(1), v.maxLength(64), v.regex(/^[a-z][a-z0-9_]*$/, "must be lowercase ASCII [a-z][a-z0-9_]*"));
+// Field-value keys share the permissive meta regex (`og:title`,
+// `my-field`, `2fa_enabled` all valid) so a plugin registering a
+// `MetaBoxField` via `registerSettingsGroup` isn't rejected at the
+// RPC boundary. Matches `META_FIELD_KEY_RE` in `plugin/validation/meta-box-fields.ts`.
+const settingsValueKeySchema = v.pipe(v.string(), v.trim(), v.minLength(1), v.maxLength(200), v.regex(/^[a-zA-Z0-9_:-]+$/, "settings value key must match [a-zA-Z0-9_:-]+"));
+// One round-trip per group is the primary read pattern (admin card
+// loads one group). Returning the bag lets the admin form seed its
+// state; fields absent from the bag fall back to their registered
+// `default`.
+export const settingsGetInputSchema = v.object({
+    group: settingsNameSchema,
+});
+// Null values in an upsert are deletions; everything else is an
+// upsert. Cap on keys per request blocks accidental fan-out from
+// callers that iterate on untrusted input; cap on encoded-value size
+// lives in the handler. Settings are typically short form fields —
+// 64 KiB per value comfortably fits any realistic string / JSON blob
+// a plugin would want to store as a setting and matches the WP
+// `wp_options` convention.
+const MAX_SETTINGS_VALUE_BYTES = 64 * 1024;
+const MAX_SETTINGS_KEYS_PER_UPSERT = 200;
+export const settingsUpsertInputSchema = v.object({
+    group: settingsNameSchema,
+    values: v.pipe(v.record(settingsValueKeySchema, v.unknown()), v.check((val) => Object.keys(val).length <= MAX_SETTINGS_KEYS_PER_UPSERT, `upsert accepts at most ${MAX_SETTINGS_KEYS_PER_UPSERT} keys per request`)),
+});
+export { MAX_SETTINGS_VALUE_BYTES };
+//# sourceMappingURL=schemas.js.map

package/dist/rpc/procedures/settings/schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../../../../src/rpc/procedures/settings/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAE7B,sEAAsE;AACtE,iEAAiE;AACjE,2DAA2D;AAC3D,8EAA8E;AAC9E,MAAM,kBAAkB,GAAG,CAAC,CAAC,IAAI,CAC/B,CAAC,CAAC,MAAM,EAAE,EACV,CAAC,CAAC,IAAI,EAAE,EACR,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EACd,CAAC,CAAC,SAAS,CAAC,EAAE,CAAC,EACf,CAAC,CAAC,KAAK,CAAC,mBAAmB,EAAE,yCAAyC,CAAC,CACxE,CAAC;AAEF,gEAAgE;AAChE,iEAAiE;AACjE,mEAAmE;AACnE,uFAAuF;AACvF,MAAM,sBAAsB,GAAG,CAAC,CAAC,IAAI,CACnC,CAAC,CAAC,MAAM,EAAE,EACV,CAAC,CAAC,IAAI,EAAE,EACR,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EACd,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,EAChB,CAAC,CAAC,KAAK,CAAC,mBAAmB,EAAE,+CAA+C,CAAC,CAC9E,CAAC;AAEF,mEAAmE;AACnE,mEAAmE;AACnE,kEAAkE;AAClE,aAAa;AACb,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC7C,KAAK,EAAE,kBAAkB;CAC1B,CAAC,CAAC;AAEH,gEAAgE;AAChE,iEAAiE;AACjE,qEAAqE;AACrE,mEAAmE;AACnE,qEAAqE;AACrE,+DAA+D;AAC/D,2BAA2B;AAC3B,MAAM,wBAAwB,GAAG,EAAE,GAAG,IAAI,CAAC;AAC3C,MAAM,4BAA4B,GAAG,GAAG,CAAC;AAEzC,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAAC;IAChD,KAAK,EAAE,kBAAkB;IACzB,MAAM,EAAE,CAAC,CAAC,IAAI,CACZ,CAAC,CAAC,MAAM,CAAC,sBAAsB,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,EAC7C,CAAC,CAAC,KAAK,CACL,CAAC,GAAG,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,IAAI,4BAA4B,EAChE,0BAA0B,4BAA4B,mBAAmB,CAC1E,CACF;CACF,CAAC,CAAC;AAOH,OAAO,EAAE,wBAAwB,EAAE,CAAC"}

package/dist/rpc/procedures/settings/upsert.d.ts

@@ -0,0 +1,63 @@
+export declare const upsert: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<import("../../../index.js").AppContextBase<typeof import("../../../db/schema/index.js")> & import("../../../index.js").AppContextExtensions & Record<never, never>, import("../../../index.js").AppContextBase<typeof import("../../../db/schema/index.js")> & import("../../../index.js").AppContextExtensions & Record<never, never>, import("../../../index.js").AppContext>, import("@orpc/server").MergedCurrentContext<import("../../../index.js").AppContext, import("../../../index.js").AuthenticatedAppContext<typeof import("../../../db/schema/index.js")>>, import("valibot").ObjectSchema<{
+    readonly group: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 64, undefined>, import("valibot").RegexAction<string, "must be lowercase ASCII [a-z][a-z0-9_]*">]>;
+    readonly values: import("valibot").SchemaWithPipe<readonly [import("valibot").RecordSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>, import("valibot").RegexAction<string, "settings value key must match [a-zA-Z0-9_:-]+">]>, import("valibot").UnknownSchema, undefined>, import("valibot").CheckAction<{
+        [x: string]: unknown;
+    }, "upsert accepts at most 200 keys per request">]>;
+}, undefined>, import("@orpc/server").Schema<Readonly<Record<string, unknown>>, Readonly<Record<string, unknown>>>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
+    readonly UNAUTHORIZED: {
+        readonly message: "Authentication required";
+    };
+    readonly BAD_REQUEST: {
+        readonly message: "Invalid input";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly reason: import("valibot").StringSchema<undefined>;
+        }, undefined>;
+    };
+    readonly FORBIDDEN: {
+        readonly message: "Permission denied";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly capability: import("valibot").StringSchema<undefined>;
+        }, undefined>;
+    };
+    readonly NOT_FOUND: {
+        readonly message: "Resource not found";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").StringSchema<undefined>;
+            readonly id: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>;
+        }, undefined>;
+    };
+    readonly CONFLICT: {
+        readonly message: "Resource conflict";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly reason: import("valibot").StringSchema<undefined>;
+            readonly key: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        }, undefined>;
+    };
+    readonly PAYLOAD_TOO_LARGE: {
+        readonly message: "Payload too large";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly limit: import("valibot").NumberSchema<undefined>;
+            readonly received: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        }, undefined>;
+    };
+    readonly UNSUPPORTED_MEDIA_TYPE: {
+        readonly message: "Unsupported media type";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly mime: import("valibot").StringSchema<undefined>;
+        }, undefined>;
+    };
+    readonly INVALID_BLOCK_CONTENT: {
+        readonly message: "Block content failed registry validation";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly issues: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly path: import("valibot").StringSchema<undefined>;
+                readonly nodeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly attributeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly markName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+            }, undefined>, undefined>;
+        }, undefined>;
+    };
+}>, Record<never, never>>;
+//# sourceMappingURL=upsert.d.ts.map

package/dist/rpc/procedures/settings/upsert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upsert.d.ts","sourceRoot":"","sources":["../../../../src/rpc/procedures/settings/upsert.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAmEf,CAAC"}

package/dist/rpc/procedures/settings/upsert.js

@@ -0,0 +1,84 @@
+import { sql } from "drizzle-orm";
+import { and, eq, inArray } from "../../../db/index.js";
+import { settings } from "../../../db/schema/settings.js";
+import { authenticated } from "../../authenticated.js";
+import { base } from "../../base.js";
+import { MAX_SETTINGS_VALUE_BYTES, settingsUpsertInputSchema, } from "./schemas.js";
+const CAPABILITY = "settings:manage";
+// Single endpoint for all group writes. Keys mapped to `null` or
+// `undefined` are deletions; anything else is an upsert. Unmentioned
+// keys are left alone — same partial-patch semantic as `entry.meta`.
+export const upsert = base
+    .use(authenticated)
+    .input(settingsUpsertInputSchema)
+    .handler(async ({ input, context, errors }) => {
+    if (!context.auth.can(CAPABILITY)) {
+        throw errors.FORBIDDEN({ data: { capability: CAPABILITY } });
+    }
+    const filtered = await context.hooks.applyFilter("rpc:settings.upsert:input", input);
+    const deletes = [];
+    const upsertRows = [];
+    for (const [key, value] of Object.entries(filtered.values)) {
+        if (value === null || value === undefined) {
+            deletes.push(key);
+            continue;
+        }
+        assertEncodedSize(filtered.group, key, value, errors);
+        upsertRows.push({ group: filtered.group, key, value });
+    }
+    if (deletes.length > 0) {
+        await context.db
+            .delete(settings)
+            .where(and(eq(settings.group, filtered.group), inArray(settings.key, deletes)));
+    }
+    if (upsertRows.length > 0) {
+        await context.db
+            .insert(settings)
+            .values(upsertRows)
+            .onConflictDoUpdate({
+            target: [settings.group, settings.key],
+            set: { value: sql `excluded.value` },
+        });
+    }
+    // Re-read the authoritative bag and ship it back + to the output
+    // filter so plugins can observe the final shape in one place.
+    const fresh = await context.db
+        .select({ key: settings.key, value: settings.value })
+        .from(settings)
+        .where(eq(settings.group, filtered.group));
+    const bag = {};
+    for (const row of fresh)
+        bag[row.key] = row.value;
+    // Fire only when the call actually changed state — an empty
+    // `values: {}` payload is a no-op and shouldn't wake up
+    // cache-invalidators / audit-log subscribers.
+    if (upsertRows.length > 0 || deletes.length > 0) {
+        await context.hooks.doAction("settings:group_changed", {
+            group: filtered.group,
+            set: Object.fromEntries(upsertRows.map((r) => [r.key, r.value])),
+            removed: deletes,
+        });
+    }
+    return context.hooks.applyFilter("rpc:settings.upsert:output", bag, {
+        group: filtered.group,
+    });
+});
+// Guard against values that can't be persisted (un-serializable) or
+// that blow past the per-value cap in `schemas.ts`. Both translate to a
+// CONFLICT with a keyed `reason` so admin UIs surface which field hit
+// the limit.
+function assertEncodedSize(group, key, value, errors) {
+    const encoded = JSON.stringify(value);
+    if (encoded === undefined) {
+        throw errors.CONFLICT({
+            data: { reason: "settings_invalid_value", key: `${group}.${key}` },
+        });
+    }
+    const byteLength = new TextEncoder().encode(encoded).length;
+    if (byteLength > MAX_SETTINGS_VALUE_BYTES) {
+        throw errors.CONFLICT({
+            data: { reason: "settings_value_too_large", key: `${group}.${key}` },
+        });
+    }
+}
+//# sourceMappingURL=upsert.js.map

package/dist/rpc/procedures/settings/upsert.js.map

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

package/dist/rpc/procedures/term/create.d.ts

@@ -0,0 +1,85 @@
+export declare const create: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<import("../../../index.js").AppContextBase<typeof import("../../../db/schema/index.js")> & import("../../../index.js").AppContextExtensions & Record<never, never>, import("../../../index.js").AppContextBase<typeof import("../../../db/schema/index.js")> & import("../../../index.js").AppContextExtensions & Record<never, never>, import("../../../index.js").AppContext>, import("@orpc/server").MergedCurrentContext<import("../../../index.js").AppContext, import("../../../index.js").AuthenticatedAppContext<typeof import("../../../db/schema/index.js")>>, import("valibot").ObjectSchema<{
+    readonly taxonomy: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 100, undefined>]>;
+    readonly name: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>;
+    readonly slug: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>, import("valibot").RegexAction<string, "slug must be kebab-case ASCII">]>;
+    readonly description: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 10000, undefined>]>, undefined>, undefined>;
+    readonly parentId: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 1, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>, undefined>;
+    readonly meta: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").RecordSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>, import("valibot").RegexAction<string, "meta key must be alphanumeric/_/:/-">]>, import("valibot").UnknownSchema, undefined>, import("valibot").CheckAction<{
+        [x: string]: unknown;
+    }, "meta accepts at most 200 keys per request">]>, undefined>;
+}, undefined>, import("@orpc/server").Schema<{
+    id: number;
+    name: string;
+    meta: Record<string, unknown>;
+    taxonomy: string;
+    parentId: number | null;
+    slug: string;
+    description: string | null;
+    version: number;
+}, {
+    id: number;
+    name: string;
+    meta: Record<string, unknown>;
+    taxonomy: string;
+    parentId: number | null;
+    slug: string;
+    description: string | null;
+    version: number;
+}>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
+    readonly UNAUTHORIZED: {
+        readonly message: "Authentication required";
+    };
+    readonly BAD_REQUEST: {
+        readonly message: "Invalid input";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly reason: import("valibot").StringSchema<undefined>;
+        }, undefined>;
+    };
+    readonly FORBIDDEN: {
+        readonly message: "Permission denied";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly capability: import("valibot").StringSchema<undefined>;
+        }, undefined>;
+    };
+    readonly NOT_FOUND: {
+        readonly message: "Resource not found";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").StringSchema<undefined>;
+            readonly id: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>;
+        }, undefined>;
+    };
+    readonly CONFLICT: {
+        readonly message: "Resource conflict";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly reason: import("valibot").StringSchema<undefined>;
+            readonly key: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        }, undefined>;
+    };
+    readonly PAYLOAD_TOO_LARGE: {
+        readonly message: "Payload too large";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly limit: import("valibot").NumberSchema<undefined>;
+            readonly received: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        }, undefined>;
+    };
+    readonly UNSUPPORTED_MEDIA_TYPE: {
+        readonly message: "Unsupported media type";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly mime: import("valibot").StringSchema<undefined>;
+        }, undefined>;
+    };
+    readonly INVALID_BLOCK_CONTENT: {
+        readonly message: "Block content failed registry validation";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly issues: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly path: import("valibot").StringSchema<undefined>;
+                readonly nodeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly attributeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly markName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+            }, undefined>, undefined>;
+        }, undefined>;
+    };
+}>, Record<never, never>>;
+//# sourceMappingURL=create.d.ts.map

package/dist/rpc/procedures/term/create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../../src/rpc/procedures/term/create.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA2Ff,CAAC"}

package/dist/rpc/procedures/term/create.js

@@ -0,0 +1,73 @@
+import { and, eq, isUniqueConstraintError } from "../../../db/index.js";
+import { terms } from "../../../db/schema/terms.js";
+import { authenticated } from "../../authenticated.js";
+import { base } from "../../base.js";
+import { taxonomyCapability } from "./helpers.js";
+import { assertTermMetaCapabilities, decodeMetaBag, loadTermMeta, sanitizeMetaForRpc, validateTermMetaReferences, writeTermMeta, } from "./meta.js";
+import { termCreateInputSchema } from "./schemas.js";
+export const create = base
+    .use(authenticated)
+    .input(termCreateInputSchema)
+    .handler(async ({ input, context, errors }) => {
+    const filtered = await context.hooks.applyFilter("rpc:term.create:input", input);
+    if (!context.plugins.termTaxonomies.has(filtered.taxonomy)) {
+        throw errors.NOT_FOUND({
+            data: { kind: "taxonomy", id: filtered.taxonomy },
+        });
+    }
+    const editCap = taxonomyCapability(filtered.taxonomy, "edit");
+    if (!context.auth.can(editCap)) {
+        throw errors.FORBIDDEN({ data: { capability: editCap } });
+    }
+    if (filtered.parentId !== undefined && filtered.parentId !== null) {
+        const parent = await context.db.query.terms.findFirst({
+            where: and(eq(terms.id, filtered.parentId), eq(terms.taxonomy, filtered.taxonomy)),
+        });
+        if (!parent) {
+            throw errors.CONFLICT({ data: { reason: "parent_mismatch" } });
+        }
+    }
+    // Validate meta up-front so a bad key fails before the term insert —
+    // keeps the DB clean when the client sends a typo in a meta key.
+    const metaPatch = sanitizeMetaForRpc(context.plugins, filtered.taxonomy, filtered.meta, errors);
+    if (metaPatch) {
+        assertTermMetaCapabilities(context.plugins, filtered.taxonomy, metaPatch, context.auth, errors);
+        await validateTermMetaReferences(context, filtered.taxonomy, metaPatch, errors);
+    }
+    let created;
+    try {
+        [created] = await context.db
+            .insert(terms)
+            .values({
+            taxonomy: filtered.taxonomy,
+            name: filtered.name,
+            slug: filtered.slug,
+            description: filtered.description ?? null,
+            parentId: filtered.parentId ?? null,
+        })
+            .returning();
+    }
+    catch (error) {
+        if (isUniqueConstraintError(error)) {
+            throw errors.CONFLICT({ data: { reason: "slug_taken" } });
+        }
+        throw error;
+    }
+    if (!created) {
+        throw errors.CONFLICT({ data: { reason: "insert_failed" } });
+    }
+    let meta;
+    if (metaPatch) {
+        await writeTermMeta(context, created, metaPatch);
+        meta = await loadTermMeta(context, created);
+    }
+    else {
+        meta = decodeMetaBag(context.plugins, created.taxonomy, created.meta);
+    }
+    await context.hooks.doAction("term:created", created);
+    return context.hooks.applyFilter("rpc:term.create:output", {
+        ...created,
+        meta,
+    });
+});
+//# sourceMappingURL=create.js.map

package/dist/rpc/procedures/term/create.js.map

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

package/dist/rpc/procedures/term/delete.d.ts

@@ -0,0 +1,78 @@
+export declare const del: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<import("../../../index.js").AppContextBase<typeof import("../../../db/schema/index.js")> & import("../../../index.js").AppContextExtensions & Record<never, never>, import("../../../index.js").AppContextBase<typeof import("../../../db/schema/index.js")> & import("../../../index.js").AppContextExtensions & Record<never, never>, import("../../../index.js").AppContext>, import("@orpc/server").MergedCurrentContext<import("../../../index.js").AppContext, import("../../../index.js").AuthenticatedAppContext<typeof import("../../../db/schema/index.js")>>, import("valibot").ObjectSchema<{
+    readonly id: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 1, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>;
+}, undefined>, import("@orpc/server").Schema<{
+    id: number;
+    name: string;
+    meta: Record<string, unknown>;
+    taxonomy: string;
+    parentId: number | null;
+    slug: string;
+    description: string | null;
+    version: number;
+}, {
+    id: number;
+    name: string;
+    meta: Record<string, unknown>;
+    taxonomy: string;
+    parentId: number | null;
+    slug: string;
+    description: string | null;
+    version: number;
+}>, import("@orpc/server").MergedErrorMap<Record<never, never>, {
+    readonly UNAUTHORIZED: {
+        readonly message: "Authentication required";
+    };
+    readonly BAD_REQUEST: {
+        readonly message: "Invalid input";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly reason: import("valibot").StringSchema<undefined>;
+        }, undefined>;
+    };
+    readonly FORBIDDEN: {
+        readonly message: "Permission denied";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly capability: import("valibot").StringSchema<undefined>;
+        }, undefined>;
+    };
+    readonly NOT_FOUND: {
+        readonly message: "Resource not found";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").StringSchema<undefined>;
+            readonly id: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>;
+        }, undefined>;
+    };
+    readonly CONFLICT: {
+        readonly message: "Resource conflict";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly reason: import("valibot").StringSchema<undefined>;
+            readonly key: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        }, undefined>;
+    };
+    readonly PAYLOAD_TOO_LARGE: {
+        readonly message: "Payload too large";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly limit: import("valibot").NumberSchema<undefined>;
+            readonly received: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        }, undefined>;
+    };
+    readonly UNSUPPORTED_MEDIA_TYPE: {
+        readonly message: "Unsupported media type";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly mime: import("valibot").StringSchema<undefined>;
+        }, undefined>;
+    };
+    readonly INVALID_BLOCK_CONTENT: {
+        readonly message: "Block content failed registry validation";
+        readonly data: import("valibot").ObjectSchema<{
+            readonly issues: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly path: import("valibot").StringSchema<undefined>;
+                readonly nodeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly attributeName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly markName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+            }, undefined>, undefined>;
+        }, undefined>;
+    };
+}>, Record<never, never>>;
+//# sourceMappingURL=delete.d.ts.map

package/dist/rpc/procedures/term/delete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../../src/rpc/procedures/term/delete.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA4BZ,CAAC"}